Varsayılan programatik eşdeğeri (Tür)

Yansıma Type'özellikleri arasında döngü ve varsayılan belirli türleri ayarlamak için kullanıyorum. Şimdi, tip üzerinde bir anahtar yapabilir ve default(Type)açıkça ayarlayabilirim , ancak tek bir satırda yapmayı tercih ederim. Varsayılan programatik eşdeğeri var mı?

• Bir değer türü durumunda Activator.CreateInstance kullanın ve düzgün çalışması gerekir.
• Referans türünü kullanırken null değerini döndürün

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

.Net'in .net standardı gibi yeni sürümlerinde type.IsValueTypeşu şekilde yazılmalıdır:type.GetTypeInfo().IsValueType

Neden yansımayla (T) varsayılan döndüren yöntemi çağırmıyorsunuz? Herhangi bir türde GetDefault'u aşağıdakilerle kullanabilirsiniz:

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

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

Kullanabilirsiniz PropertyInfo.SetValue(obj, null). Bir değer türünde çağrılırsa, size varsayılan değer verilir. Bu davranış belgelenmiştir .NET 4.0 ve .NET 4.5 .

.NET 4.0 veya üstünü kullanıyorsanız ve kod dışında tanımlanan kuralların kodlaması olmayan programlı bir sürüm istiyorsanız, bir Expressionderleme oluşturabilir ve anında çalıştırabilirsiniz.

Aşağıdaki uzantı yöntemi , sınıftaki yöntem aracılığıyla Typedöndürülen değeri alır ve alır :default(T)DefaultExpression

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

Yukarıdaki değeri de temel alarak önbelleğe almalısınız Type, ancak bunu çok sayıda Typeörnek için çağırıyorsanız ve sürekli kullanmıyorsanız, önbellek tarafından tüketilen bellek avantajlardan daha ağır basabilir.

Neden jenerik ilaçların resim dışında olduğunu söylüyorsun?

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

Bu, Flem'in çözümü için optimize edilmiştir:

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

Seçilen cevap iyi bir cevaptır, ancak döndürülen nesneye dikkat edin.

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

Götürdüğümüzde ...

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

İfadeler burada yardımcı olabilir:

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

Ben bu pasajı test etmedi, ama ben referans türleri için "yazılan" nulls üretmek gerektiğini düşünüyorum ..

Henüz basit ve zarif bir şey bulamıyorum, ama bir fikrim var: Ayarlamak istediğiniz mülkün türünü biliyorsanız, kendiniz yazabilirsiniz default(T). İki durum vardır - Tbir değer türüdür ve Tbir referans türüdür. Bunu kontrol ederek görebilirsiniz T.IsValueType. Eğer Tbir referans türüdür, o zaman sadece şekilde ayarlayabilirsiniz null. Eğer Tbir değer türüdür, o zaman bir "boş" değeri elde etmek çağırabilir o varsayılan bir parametresiz yapıcı olacaktır.

Ben de aynı işi böyle yapıyorum.

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

Dror'un cevabına eşdeğer, ancak bir uzatma yöntemi olarak:

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'un çözümü için küçük ayarlamalar : GetMethod yerine GetRuntimeMethod kullandığımdan dolayı aşağıdaki uzantı yöntemi .Net Standard üzerinde de çalışır.

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

... ve kaliteyi önemseyenler için uygun birim testi:

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

Bu çalışmalı: Nullable<T> a = new Nullable<T>().GetValueOrDefault();