Answers:
public static object GetDefault(Type type)
{
if(type.IsValueType)
{
return Activator.CreateInstance(type);
}
return null;
}
在.net标准等新版.net中,type.IsValueType
需要写成type.GetTypeInfo().IsValueType
default(T) != (T)(object)default(T) && !(default(T) != default(T))
参数的类型,否则将其装箱与否无关紧要,因为它们是等效的。
default(T) != default(T)
return为false,这就是作弊!=)
Array.CreateInstance(type, length)
。
为什么不通过反射调用返回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);
}
nameof(GetDefaultGeneric)
如果可以的话,请更好地使用它,而不是"GetDefaultGeneric"
如果您使用的是.NET 4.0或更高版本,并且希望使用的程序版本不是在代码外部定义的规则的编纂,则可以实时创建Expression
,编译和运行它。
以下扩展方法将采用Type
并获取default(T)
通过类上的Default
方法返回的值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
实例调用此值,并且不经常使用它,则缓存消耗的内存可能会超过收益。
e.Compile()
。这就是表达的重点。
e.Compile()
应该缓存的结果,但是假设该方法的速度大约是例如的14倍long
。有关基准和结果,请参见gist.github.com/pvginkel/fed5c8512b9dfefc2870c6853bbfbf8b。
e.Compile()
而不是e.Compile()()
?即,类型的默认类型可以在运行时更改吗?如果不是这样(我相信是这样),则可以仅存储结果缓存,而不是存储编译后的表达式,这将进一步提高性能。
为什么您说泛型不适合?
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);
}
这是优化的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;
}
}
}
return type.IsValueType ? typeDefaults.GetOrAdd(type, Activator.CreateInstance) : null;
选择的答案是一个很好的答案,但是要小心返回的对象。
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.");
表达式可以在这里提供帮助:
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();
}
我没有测试此代码段,但我认为它应该为引用类型生成“类型化”的null。
"typed" nulls
-解释一下。您要返回什么对象?如果返回类型为object的对象type
,但其值为null
,则该对象不会-不能-拥有除其以外的任何其他信息null
。您无法查询null
值,也不知道它应该是什么类型。如果您不返回null,而是返回..我不知道什么..,那么它将不会像null
。
我做同样的任务。
//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;
}
对@Rob Fonseca-Ensor解决方案的调整:由于我使用GetRuntimeMethod而不是GetMethod,因此以下扩展方法也适用于.Net Standard。
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));
}
/// <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;
}
Nullable<T>
类型不起作用:它不返回default(Nullable<T>)
应该等于的值null
。Dror接受的答案效果更好。