Equivalente programático de defecto (Tipo)

Estoy usando la reflexión para recorrer Typelas propiedades de una y establecer ciertos tipos a sus valores predeterminados. Ahora, podría cambiar el tipo y configurarlo default(Type)explícitamente, pero prefiero hacerlo en una línea. ¿Existe un equivalente programático del incumplimiento?

• En el caso de un tipo de valor, use Activator.CreateInstance y debería funcionar bien.
• Cuando use el tipo de referencia, simplemente devuelva nulo

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

En la versión más reciente de .net, como .net standard, type.IsValueTypedebe escribirse comotype.GetTypeInfo().IsValueType

¿Por qué no llamar al método que devuelve default (T) con reflexión? Puede usar GetDefault de cualquier tipo con:

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

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

Puedes usar PropertyInfo.SetValue(obj, null). Si se llama a un tipo de valor, le dará el valor predeterminado. Este comportamiento está documentado en .NET 4.0 y en .NET 4.5 .

Si está utilizando .NET 4.0 o superior y desea una versión programática que no sea una codificación de reglas definidas fuera del código , puede crear Expression, compilar y ejecutar sobre la marcha.

El siguiente método de extensión tomará ay Typeobtendrá el valor devuelto a default(T)través del Defaultmétodo en la Expressionclase:

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

También debe almacenar en caché el valor anterior en función del Type, pero tenga en cuenta que si llama a esto para una gran cantidad de Typeinstancias, y no lo usa constantemente, la memoria consumida por la memoria caché podría superar los beneficios.

¿Por qué dice que los genéricos están fuera de la imagen?

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

Esta es la solución optimizada 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;
        }
    }
}

La respuesta elegida es una buena respuesta, pero tenga cuidado con el objeto devuelto.

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

Extrapolando ...

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

Las expresiones pueden ayudar aquí:

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

No probé este fragmento, pero creo que debería producir nulos "tipados" para los tipos de referencia.

Todavía no puedo encontrar nada simple y elegante, pero tengo una idea: si conoce el tipo de propiedad que desea establecer, puede escribir la suya default(T). Hay dos casos: Tes un tipo de valor y Tes un tipo de referencia. Puedes ver esto marcando T.IsValueType. Si Tes un tipo de referencia, simplemente puede establecerlo en null. Si Tes un tipo de valor, tendrá un constructor sin parámetros predeterminado al que puede llamar para obtener un valor "en blanco".

Hago la misma tarea así.

//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 a la respuesta de Dror pero como método de extensión:

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

Pequeños ajustes a la solución de @Rob Fonseca-Ensor : El siguiente método de extensión también funciona en .Net Standard ya que uso GetRuntimeMethod en lugar de 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);
    }
}

... y la prueba de unidad correspondiente para aquellos que se preocupan por la calidad:

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

Esto debería funcionar: Nullable<T> a = new Nullable<T>().GetValueOrDefault();