Програмний еквівалент за замовчуванням (Тип)

Я використовую відображення для перегляду Typeвластивостей 's та встановлення певних типів за замовчуванням. Тепер я міг би зробити перемикач на тип і встановити default(Type)явно, але краще зробити це в один рядок. Чи є програмний еквівалент за замовчуванням?

• У разі типу значення використовуйте Activator.CreateInstance, і воно повинно працювати нормально.
• При використанні довідкового типу просто поверніть null

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

У новій версії .net, такої як .net standard, type.IsValueTypeпотрібно писати якtype.GetTypeInfo().IsValueType

Чому б не зателефонувати методу, який повертає типовий (T) з відображенням? Ви можете використовувати GetDefault будь-якого типу з:

    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 , компілювати та запустити його на ходу.

Наступний метод розширення прийме a 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примірників, і не використовуєте його постійно, пам'ять, що споживається кешем, може перевершити переваги.

Чому ви кажете, що генерики не в курсі?

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

Обрана відповідь є хорошою відповіддю, але будьте обережні з поверненим об'єктом.

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

Я не перевіряв цей фрагмент, але я думаю, що він повинен створити "набрані" нулі для еталонних типів ..

Наразі ще не знайти нічого простого і елегантного, але у мене є одна ідея: якщо ви знаєте тип об'єкта, який хочете встановити, ви можете написати своє default(T). Є два випадки - Tце тип значення і Tє еталонним типом. Ви можете побачити це, поставивши галочку T.IsValueType. Якщо Tце еталонний тип, ви можете просто встановити його null. Якщо Tце тип значення, то він буде мати конструктор без параметрів за замовчуванням, який ви можете зателефонувати, щоб отримати "порожнє" значення.

Я виконую таке ж завдання, як це.

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

Еквівалент відповіді Дрора, але як метод розширення:

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

 /// <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> a = new Nullable<T>().GetValueOrDefault();