¿La mejor manera de probar si un tipo genérico es una cadena? (C#)

Tengo una clase genérica que debería permitir cualquier tipo, primitivo o no. El único problema con esto es usar default(T). Cuando llama a default en un tipo de valor o una cadena, lo inicializa a un valor razonable (como una cadena vacía). Cuando llama default(T)a un objeto, devuelve nulo. Por varias razones, necesitamos asegurarnos de que si no es un tipo primitivo, entonces tendremos una instancia predeterminada del tipo, no nula. Aquí está el intento 1:

T createDefault()
{
    if(typeof(T).IsValueType)
    {
        return default(T);
    }
    else
    {
        return Activator.CreateInstance<T>();
    }
}

Problema: la cadena no es un tipo de valor, pero no tiene un constructor sin parámetros. Entonces, la solución actual es:

T createDefault()
{
    if(typeof(T).IsValueType || typeof(T).FullName == "System.String")
    {
        return default(T);
    }
    else
    {
        return Activator.CreateInstance<T>();
    }
}

Pero esto se siente como una torpeza. ¿Existe una forma mejor de manejar el caso de cuerdas?

Tenga en cuenta que el valor predeterminado (cadena) es nulo, no cadena. Es posible que desee un caso especial en su código:

if (typeof(T) == typeof(String)) return (T)(object)String.Empty;

if (typeof(T).IsValueType || typeof(T) == typeof(String))
{
     return default(T);
}
else
{
     return Activator.CreateInstance<T>();
}

Sin probar, pero lo primero que me vino a la mente.

Puede utilizar la enumeración TypeCode . Llame al método GetTypeCode en las clases que implementan la interfaz IConvertible para obtener el código de tipo para una instancia de esa clase. IConvertible está implementado por Boolean, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double, Decimal, DateTime, Char y String, por lo que puede verificar los tipos primitivos usando esto. Más información sobre " Verificación de tipo genérico ".

Personalmente, me gusta la sobrecarga de métodos:

public static class Extensions { 
  public static String Blank(this String me) {      
    return String.Empty;
  }
  public static T Blank<T>(this T me) {      
    var tot = typeof(T);
    return tot.IsValueType
      ? default(T)
      : (T)Activator.CreateInstance(tot)
      ;
  }
}
class Program {
  static void Main(string[] args) {
    Object o = null;
    String s = null;
    int i = 6;
    Console.WriteLine(o.Blank()); //"System.Object"
    Console.WriteLine(s.Blank()); //""
    Console.WriteLine(i.Blank()); //"0"
    Console.ReadKey();
  }
}

Sé que esta pregunta es antigua, pero ha habido una actualización.

Desde C # 7.0 puede utilizar el isoperador para comparar tipos. Ya no necesita el uso de typeofcomo en la respuesta aceptada.

        public bool IsObjectString(object obj)
        {
            return obj is string;
        }

https://docs.microsoft.com/en-US/dotnet/csharp/language-reference/keywords/is

La discusión sobre String no funciona aquí.

Tenía que tener el siguiente código para genéricos para que funcionara:

   private T createDefault()
    { 

        {     
            if(typeof(T).IsValueType)     
            {         
                return default(T);     
            }
            else if (typeof(T).Name == "String")
            {
                return (T)Convert.ChangeType(String.Empty,typeof(T));
            }
            else
            {
                return Activator.CreateInstance<T>();
            } 
        } 

    }