关于c＃：默认的程序化等价物（Type）


Programmatic equivalent of default(Type)

我使用反射来循环遍历Type的属性，并将某些类型设置为它们的默认值。现在，我可以在类型上做一个开关，并显式地设置default(Type)，但我更愿意在一行中这样做。是否存在与默认值等效的程序？

  • 对于值类型，使用Activator.CreateInstance，它应该可以正常工作。
  • 使用引用类型时，只返回空值
1
2
3
4
5
6
7
8
public static object GetDefault(Type type)
{
   if(type.IsValueType)
   {
      return Activator.CreateInstance(type);
   }
   return null;
}

在.NET标准等较新版本中，type.IsValueType需要写成type.GetTypeInfo().IsValueType。

相关讨论

为什么不调用返回带有反射的默认值(T)的方法？任何类型的getdefault都可以用于：

1
2
3
4
5
6
7
8
9
    public object GetDefault(Type t)
    {
        return this.GetType().GetMethod("GetDefaultGeneric").MakeGenericMethod(t).Invoke(this, null);
    }

    public T GetDefaultGeneric<T>()
    {
        return default(T);
    }
相关讨论

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

相关讨论

如果您使用的是.NET 4.0或更高版本，并且您想要的编程版本不是代码外定义的规则的编码，那么您可以创建一个Expression，编译并运行它。

下面的扩展方法是取一个Type，通过Expression类的Default方法得到default(T)返回的值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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实例调用此值，并且不经常使用它，则缓存所消耗的内存可能会超过好处。

相关讨论

你为什么说仿制药已经过时了？

1
2
3
4
5
6
7
8
9
10
    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解决方案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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;
        }
    }
}
相关讨论

选择的答案是一个很好的答案，但是要小心返回的对象。

1
2
3
4
5
6
string test = null;
string test2 ="";
if (test is string)
     Console.WriteLine("This will never be hit.");
if (test2 is string)
     Console.WriteLine("Always hit.");

外推…

1
2
3
string test = GetDefault(typeof(string));
if (test is string)
     Console.WriteLine("This will never be hit.");
相关讨论

表达式可以帮助您：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    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();
    }

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

相关讨论

我做同样的工作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//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;
    }

现在还找不到任何简单而优雅的东西，但我有一个想法：如果你知道你想要设置的属性的类型，你可以写自己的default(T)。有两种情况-T是值类型，T是引用类型。您可以通过检查T.IsValueType来查看。如果T是引用类型，那么只需将其设置为null即可。如果T是一个值类型，那么它将有一个默认的无参数构造函数，您可以调用它来获得一个"空白"值。

相当于德罗的答案，但作为扩展方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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;
        }
    }
}

稍微调整一下@rob fonseca ensor的解决方案：以下扩展方法也适用于.NET标准，因为我使用getruntimemethod而不是getmethod。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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);
    }
}

…对那些关心质量的人进行相应的单元测试：

1
2
3
4
5
6
7
8
9
10
11
12
[Fact]
public void GetDefaultTest()
{
    // Arrange
    var type = typeof(DateTime);

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

    // Assert
    defaultValue.Should().Be(default(DateTime));
}
1
2
3
4
5
6
7
8
 /// <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;
    }
相关讨论