Équivalent programmatique du défaut (Type)

Question

J'utilise la réflexion pour boucler un Type et de définir certains types à leur valeur par défaut. Maintenant, je pourrais faire un switch sur le type et mettre la propriété default(Type) explicitement, mais je préfère le faire en une seule ligne. Existe-t-il un équivalent programmatique de default ?

Answer 1

• Dans le cas d'un type de valeur, utilisez Activator.CreateInstance et ça devrait fonctionner correctement.

• Lorsque vous utilisez un type de référence, il suffit de renvoyer null

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

Dans les nouvelles versions de .net telles que .net standard, type.IsValueType doit être écrit comme suit type.GetTypeInfo().IsValueType

Answer 2

Pourquoi ne pas appeler la méthode qui renvoie default(T) avec la réflexion ? Vous pouvez utiliser GetDefault de n'importe quel type avec :

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

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

Answer 3

Vous pouvez utiliser PropertyInfo.SetValue(obj, null) . S'il est appelé sur un type de valeur, il vous donnera la valeur par défaut. Ce comportement est documenté dans .NET 4.0 y dans .NET 4.5 .

Answer 4

Si vous utilisez .NET 4.0 ou plus et que vous souhaitez une version programmatique qui ne soit pas une codification de règles définies en dehors du code vous pouvez créer un Expression de le compiler et de l'exécuter à la volée.

La méthode d'extension suivante prend un Type et obtenir la valeur retournée par default(T) à travers le Default méthode sur le Expression classe :

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

Vous devez également mettre en cache la valeur ci-dessus sur la base de l'adresse de l'utilisateur. Type mais attention, si vous l'appelez pour un grand nombre d'utilisateurs, vous ne pouvez pas l'utiliser. Type et ne l'utilisez pas en permanence, la mémoire consommée par le cache pourrait l'emporter sur les avantages.

Answer 5

C'est la solution optimisée de Flem :

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