Melhor maneira de testar se um tipo genérico é uma string? (C #)

Tenho uma classe genérica que deve permitir qualquer tipo, primitivo ou não. O único problema com isso é usar default(T). Quando você chama default em um tipo de valor ou string, ele o inicializa com um valor razoável (como string vazia). Quando você chama default(T)um objeto, ele retorna nulo. Por vários motivos, precisamos garantir que, se não for um tipo primitivo, teremos uma instância padrão do tipo, não nula. Aqui está a tentativa 1:

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

Problema - string não é um tipo de valor, mas não tem um construtor sem parâmetros. Portanto, a solução atual é:

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

Mas isso parece um desastre. Existe uma maneira mais agradável de lidar com o caso da string?

Lembre-se de que o padrão (string) é nulo, não string.Empty. Você pode querer um caso especial em seu 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>();
}

Não testado, mas a primeira coisa que me veio à mente.

Você pode usar a enumeração TypeCode . Chame o método GetTypeCode em classes que implementam a interface IConvertible para obter o código de tipo para uma instância dessa classe. IConvertible é implementado por Boolean, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double, Decimal, DateTime, Char e String, então você pode verificar por tipos primitivos usando isso. Mais informações sobre " Verificação de tipo genérico ".

Pessoalmente, gosto de sobrecarga de método:

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();
  }
}

Eu sei que esta pergunta é antiga, mas houve uma atualização.

Desde C # 7.0, você pode usar o isoperador para comparar tipos. Você não precisa mais de typeofcomo na resposta aceita.

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

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

A discussão sobre String não está funcionando aqui.

Eu precisava seguir o código de genéricos para fazê-lo funcionar -

   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>();
            } 
        } 

    }