Chương trình tương đương với mặc định (Loại)

Tôi đang sử dụng sự phản chiếu để lặp qua Typecác thuộc tính của một và đặt các loại nhất định thành mặc định của chúng. Bây giờ, tôi có thể thực hiện chuyển đổi loại và đặt default(Type)rõ ràng, nhưng tôi muốn thực hiện nó trong một dòng. Có một chương trình tương đương mặc định?

• Trong trường hợp loại giá trị, hãy sử dụng Activator.CreateInstance và nó sẽ hoạt động tốt.
• Khi sử dụng kiểu tham chiếu chỉ cần trả về null

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

Trong phiên bản mới hơn của .net, chẳng hạn như .net, type.IsValueTypecần phải được viết làtype.GetTypeInfo().IsValueType

Tại sao không gọi phương thức trả về mặc định (T) bằng phản xạ? Bạn có thể sử dụng GetDefault của bất kỳ loại nào với:

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

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

Bạn có thể sử dụng PropertyInfo.SetValue(obj, null). Nếu được gọi trên một loại giá trị, nó sẽ cung cấp cho bạn mặc định. Hành vi này được ghi lại trong .NET 4.0 và .NET 4.5 .

Nếu bạn đang sử dụng .NET 4.0 trở lên và bạn muốn có một phiên bản lập trình không phải là mã hóa các quy tắc được xác định bên ngoài mã , bạn có thể tạo Expression, biên dịch và chạy nó một cách nhanh chóng.

Phương thức mở rộng sau đây sẽ lấy a Typevà nhận giá trị được trả về default(T)thông qua Defaultphương thức trên Expressionlớp:

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

Bạn cũng nên lưu trữ giá trị trên dựa trên Type, nhưng lưu ý nếu bạn gọi số này cho một số lượng lớn các Typetrường hợp và không sử dụng nó liên tục, bộ nhớ được sử dụng bởi bộ đệm có thể vượt quá lợi ích.

Tại sao bạn nói thuốc generic là ra khỏi hình ảnh?

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

Đây là giải pháp tối ưu của 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;
        }
    }
}

Câu trả lời được chọn là một câu trả lời tốt, nhưng hãy cẩn thận với đối tượng trả về.

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

Ngoại suy ...

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

Các biểu thức có thể giúp đỡ ở đây:

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

Tôi đã không kiểm tra đoạn mã này, nhưng tôi nghĩ nó sẽ tạo ra các "null" null cho các loại tham chiếu ..

Chưa thể tìm thấy bất cứ điều gì đơn giản và thanh lịch, nhưng tôi có một ý tưởng: Nếu bạn biết loại tài sản bạn muốn đặt, bạn có thể tự viết default(T). Có hai trường hợp - Tlà loại giá trị và Tlà loại tham chiếu. Bạn có thể thấy điều này bằng cách kiểm tra T.IsValueType. Nếu Tlà một kiểu tham chiếu, thì bạn có thể chỉ cần đặt nó thành null. Nếu Tlà một loại giá trị, thì nó sẽ có một hàm tạo không tham số mặc định mà bạn có thể gọi để lấy giá trị "trống".

Tôi làm nhiệm vụ tương tự như thế này.

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

Tương đương với câu trả lời của Dror nhưng là một phương pháp mở rộng:

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

Điều chỉnh nhẹ cho giải pháp của @Rob Fonseca-Ensor : Phương pháp tiện ích mở rộng sau đây cũng hoạt động trên .Net Standard kể từ khi tôi sử dụng GetR nbMethod thay vì 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);
    }
}

... Và bài kiểm tra theo đơn vị cho những người quan tâm đến chất lượng:

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

Điều này sẽ làm việc: Nullable<T> a = new Nullable<T>().GetValueOrDefault();