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

Пока не могу найти ничего простого и элегантного, но у меня есть одна идея: если вы знаете тип свойства, которое хотите установить, вы можете написать свой собственный 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;
    }

• В случае типа значения используйте Activator.CreateInstance, и он должен работать нормально.
• При использовании ссылочного типа просто верните null

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

В более новой версии .net, такой как стандарт .net, type.IsValueType должен быть записан как type.GetTypeInfo().IsValueType.

Выбранный ответ - хороший ответ, но будьте осторожны с возвращаемым объектом.

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.");

Почему вы говорите, что дженерики не используются?

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

Почему бы не вызвать метод, который возвращает значение по умолчанию (T) с отражением? Вы можете использовать GetDefault любого типа с:

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

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

Здесь могут помочь выражения:

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

Я не тестировал этот фрагмент, но думаю, что он должен создавать "типизированные" нули для ссылочных типов.

Вы можете использовать PropertyInfo.SetValue(obj, null). Если вызывается для типа значения, он даст вам значение по умолчанию. Это поведение задокументировано в .NET 4.0 и в .NET 4.5.

Эквивалентно ответу Dror, но как метод расширения:

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

Если вы используете .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 и не используете его постоянно, память, потребляемая кешем, может перевесить преимущества.

Это оптимизированное решение Флема:

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

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

Небольшие изменения в Решение @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));
}

Это должно работать: Nullable<T> a = new Nullable<T>().GetValueOrDefault();