Equivalente programmatico di default (Tipo)

Sto usando il riflesso per scorrere Typele proprietà di un e impostare alcuni tipi sul loro valore predefinito. Ora, potrei fare un interruttore sul tipo e impostare default(Type)esplicitamente, ma preferirei farlo in una riga. Esiste un equivalente programmatico di default?

• Nel caso di un tipo di valore, utilizzare Activator.CreateInstance e dovrebbe funzionare correttamente.
• Quando si utilizza il tipo di riferimento, restituire null

public static object GetDefault(Type type)
{
   if(type.IsValueType)
   {
      return Activator.CreateInstance(type);
   }
   return null;
}

Nella versione più recente di .net come .net standard, type.IsValueTypedeve essere scritto cometype.GetTypeInfo().IsValueType

Perché non chiamare il metodo che restituisce default (T) con reflection? Puoi utilizzare GetDefault di qualsiasi tipo con:

    public object GetDefault(Type t)
    {
        return this.GetType().GetMethod("GetDefaultGeneric").MakeGenericMethod(t).Invoke(this, null);
    }

    public T GetDefaultGeneric<T>()
    {
        return default(T);
    }

È possibile utilizzare PropertyInfo.SetValue(obj, null). Se chiamato su un tipo di valore, questo ti darà il valore predefinito. Questo comportamento è documentato in .NET 4.0 e .NET 4.5 .

Se si utilizza .NET 4.0 o versione successiva e si desidera una versione programmatica che non sia una codifica di regole definite al di fuori del codice , è possibile creare unExpression , compilare ed eseguirlo al volo.

Il seguente metodo di estensione prenderà a Typee otterrà il valore restituito default(T)tramite il Defaultmetodo sulla Expressionclasse:

public static T GetDefaultValue<T>()
{
    // We want an Func<T> which returns the default.
    // Create that expression here.
    Expression<Func<T>> e = Expression.Lambda<Func<T>>(
        // The default value, always get what the *code* tells us.
        Expression.Default(typeof(T))
    );

    // Compile and return the value.
    return e.Compile()();
}

public static object GetDefaultValue(this Type type)
{
    // Validate parameters.
    if (type == null) throw new ArgumentNullException("type");

    // We want an Func<object> which returns the default.
    // Create that expression here.
    Expression<Func<object>> e = Expression.Lambda<Func<object>>(
        // Have to convert to object.
        Expression.Convert(
            // The default value, always get what the *code* tells us.
            Expression.Default(type), typeof(object)
        )
    );

    // Compile and return the value.
    return e.Compile()();
}

Dovresti anche memorizzare nella cache il valore sopra basato su Type, ma fai attenzione se lo stai chiamando per un gran numero di Typeistanze e non utilizzarlo costantemente, la memoria consumata dalla cache potrebbe superare i vantaggi.

Perché dici che i generici sono fuori dai giochi?

    public static object GetDefault(Type t)
    {
        Func<object> f = GetDefault<object>;
        return f.Method.GetGenericMethodDefinition().MakeGenericMethod(t).Invoke(null, null);
    }

    private static T GetDefault<T>()
    {
        return default(T);
    }

Questa è la soluzione Flem ottimizzata:

using System.Collections.Concurrent;

namespace System
{
    public static class TypeExtension
    {
        //a thread-safe way to hold default instances created at run-time
        private static ConcurrentDictionary<Type, object> typeDefaults =
           new ConcurrentDictionary<Type, object>();

        public static object GetDefaultValue(this Type type)
        {
            return type.IsValueType
               ? typeDefaults.GetOrAdd(type, Activator.CreateInstance)
               : null;
        }
    }
}

La risposta scelta è una buona risposta, ma fai attenzione con l'oggetto restituito.

string test = null;
string test2 = "";
if (test is string)
     Console.WriteLine("This will never be hit.");
if (test2 is string)
     Console.WriteLine("Always hit.");

Estrapolando ...

string test = GetDefault(typeof(string));
if (test is string)
     Console.WriteLine("This will never be hit.");

Le espressioni possono aiutare qui:

    private static Dictionary<Type, Delegate> lambdasMap = new Dictionary<Type, Delegate>();

    private object GetTypedNull(Type type)
    {
        Delegate func;
        if (!lambdasMap.TryGetValue(type, out func))
        {
            var body = Expression.Default(type);
            var lambda = Expression.Lambda(body);
            func = lambda.Compile();
            lambdasMap[type] = func;
        }
        return func.DynamicInvoke();
    }

Non ho testato questo frammento, ma penso che dovrebbe produrre valori null "tipizzati" per i tipi di riferimento.

Non riesco ancora a trovare nulla di semplice ed elegante, ma ho un'idea: se conosci il tipo di proprietà che desideri impostare, puoi scriverne uno tuo default(T). Esistono due casi: Tè un tipo di valore ed Tè un tipo di riferimento. Puoi vederlo controllando T.IsValueType. Se Tè un tipo di riferimento, puoi semplicemente impostarlo su null. Se Tè un tipo di valore, avrà un costruttore senza parametri predefinito che puoi chiamare per ottenere un valore "vuoto".

Faccio lo stesso compito in questo modo.

//in MessageHeader 
   private void SetValuesDefault()
   {
        MessageHeader header = this;             
        Framework.ObjectPropertyHelper.SetPropertiesToDefault<MessageHeader>(this);
   }

//in ObjectPropertyHelper
   public static void SetPropertiesToDefault<T>(T obj) 
   {
            Type objectType = typeof(T);

            System.Reflection.PropertyInfo [] props = objectType.GetProperties();

            foreach (System.Reflection.PropertyInfo property in props)
            {
                if (property.CanWrite)
                {
                    string propertyName = property.Name;
                    Type propertyType = property.PropertyType;

                    object value = TypeHelper.DefaultForType(propertyType);
                    property.SetValue(obj, value, null);
                }
            }
    }

//in TypeHelper
    public static object DefaultForType(Type targetType)
    {
        return targetType.IsValueType ? Activator.CreateInstance(targetType) : null;
    }

Equivalente alla risposta di Dror ma come metodo di estensione:

namespace System
{
    public static class TypeExtensions
    {
        public static object Default(this Type type)
        {
            object output = null;

            if (type.IsValueType)
            {
                output = Activator.CreateInstance(type);
            }

            return output;
        }
    }
}

Lievi aggiustamenti alla soluzione di @Rob Fonseca-Ensor : Il seguente metodo di estensione funziona anche su .Net Standard poiché utilizzo GetRuntimeMethod anziché GetMethod.

public static class TypeExtensions
{
    public static object GetDefault(this Type t)
    {
        var defaultValue = typeof(TypeExtensions)
            .GetRuntimeMethod(nameof(GetDefaultGeneric), new Type[] { })
            .MakeGenericMethod(t).Invoke(null, null);
        return defaultValue;
    }

    public static T GetDefaultGeneric<T>()
    {
        return default(T);
    }
}

... e il test unitario corrispondente per coloro che hanno a cuore la qualità:

[Fact]
public void GetDefaultTest()
{
    // Arrange
    var type = typeof(DateTime);

    // Act
    var defaultValue = type.GetDefault();

    // Assert
    defaultValue.Should().Be(default(DateTime));
}

 /// <summary>
    /// returns the default value of a specified type
    /// </summary>
    /// <param name="type"></param>
    public static object GetDefault(this Type type)
    {
        return type.IsValueType ? (!type.IsGenericType ? Activator.CreateInstance(type) : type.GenericTypeArguments[0].GetDefault() ) : null;
    }

Questo dovrebbe funzionare: Nullable<T> a = new Nullable<T>().GetValueOrDefault();