默认值的编程等价(类型)

我像这样做同样的任务。

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

• 对于值类型，使用激活。CreateInstance除外，应该可以正常工作。
• 当使用引用类型时，只返回null

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

在。net的新版本中，如。net标准，type.IsValueType需要被写成type.GetTypeInfo().IsValueType

所选的答案是一个很好的答案，但要注意返回的对象。

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

推断……

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

为什么你说泛型被淘汰了?

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

为什么不调用带有反射返回default(T)的方法呢?你可以使用任何类型的GetDefault:

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


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

下面的表达可以帮助你:

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

我没有测试这个片段，但我认为它应该为引用类型产生“类型化”空值。

您可以使用PropertyInfo.SetValue(obj, null)。如果在一个值类型上调用，它将为您提供默认值。此行为记录在在。net 4.0和在。net 4.5中。

相当于Dror的答案，但作为一种扩展方法:

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

如果你使用的是。net 4.0或更高版本，你想要一个编程版本，而不是定义为代码外的规则的编码，你可以创建一个Expression，编译并运行它。

下面的扩展方法将接受Type，并获得从default(T)到# EYZ2方法在Expression类上返回的值:

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

您还应该基于Type缓存上面的值，但是要注意，如果您对大量的Type实例调用这个值，并且不要经常使用它，那么缓存所消耗的内存可能会超过它的好处。

这是优化后的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;
}
}
}

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

以下扩展方法也适用于. net Standard，因为我使用GetRuntimeMethod而不是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);
}
}

.．.对于那些关心质量的人，相应的单元测试:

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


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


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

这应该工作: # EYZ0 < / p >

如果你已经创建了一个对象，你可以尝试…

var yourObj = new yourObj();
var properties = yourObj.GetType().GetProperties();


foreach (var p in properties)
{
// you can get default value for each property
var defaultValue = p.GetValue(yourObj, null);
}