Equivalente programático del valor predeterminado (Tipo)

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

  • En el caso de un tipo de valor use Activator.CreateInstance y debería funcionar bien.
  • Al usar el tipo de referencia solo devuelve nulo
 public static object GetDefault(Type type) { if(type.IsValueType) { return Activator.CreateInstance(type); } return null; } 

En la versión más nueva de .net, como .net estándar, type.IsValueType debe escribirse como type.GetTypeInfo().IsValueType

¿Por qué no llamar al método que devuelve el valor predeterminado (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() { return default(T); } 

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

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

El siguiente método de extensión tomará un Type y obtendrá el valor devuelto por default(T) través del método Default en la clase de Expression :

 public static T GetDefaultValue() { // We want an Func which returns the default. // Create that expression here. Expression> e = Expression.Lambda>( // 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 which returns the default. // Create that expression here. Expression> e = Expression.Lambda>( // 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 un gran número de instancias de Type y no lo usa constantemente, la memoria consumida por el caché puede superar los beneficios.

¿Por qué dices que los generics están fuera de escena?

  public static object GetDefault(Type t) { Func f = GetDefault; return f.Method.GetGenericMethodDefinition().MakeGenericMethod(t).Invoke(null, null); } private static T GetDefault() { 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 typeDefaults = new ConcurrentDictionary(); 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 lambdasMap = new Dictionary(); 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 valores 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 su propio default(T) . Hay dos casos: T es un tipo de valor y T es un tipo de referencia. Puedes ver esto marcando T.IsValueType . Si T es un tipo de referencia, simplemente puede establecerlo en null . Si T es 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(this); } //in ObjectPropertyHelper public static void SetPropertiesToDefault(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; } } } 
  ///  /// returns the default value of a specified type ///  ///  public static object GetDefault(this Type type) { return type.IsValueType ? (!type.IsGenericType ? Activator.CreateInstance(type) : type.GenericTypeArguments[0].GetDefault() ) : null; }