Я использую отражение, чтобы перебрать свойства Type
и установить определенные типы по умолчанию. Теперь я могу сделать переключатель типа и установить default(Type)
явно, но я предпочел бы сделать это в одной строке. Есть ли программный эквивалент по умолчанию?
Программный эквивалент по умолчанию (Тип)
Ответ 1
- В случае типа значения используйте Activator.CreateInstance, и он должен работать нормально.
- При использовании ссылочного типа просто возвращайте ноль
public static object GetDefault(Type type)
{
if(type.IsValueType)
{
return Activator.CreateInstance(type);
}
return null;
}
В более новой версии .net, такой как стандарт .net, type.IsValueType
должен быть записан как type.GetTypeInfo().IsValueType
Ответ 2
Почему бы не вызвать метод, который возвращает значение по умолчанию (T) с отражением? Вы можете использовать GetDefault любого типа с помощью:
public object GetDefault(Type t)
{
return this.GetType().GetMethod("GetDefaultGeneric").MakeGenericMethod(t).Invoke(this, null);
}
public T GetDefaultGeneric<T>()
{
return default(T);
}
Ответ 3
Вы можете использовать PropertyInfo.SetValue(obj, null)
. Если вы вызовете тип значения, он даст вам значение по умолчанию. Это поведение документировано в .NET 4.0 и в .NET 4.5.
Ответ 4
Если вы используете .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
и не используете его постоянно, память, потребляемая кешем может перевесить преимущества.
Ответ 5
Почему вы говорите, что дженерики не видны?
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);
}
Ответ 6
Это оптимизированное решение 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;
}
}
}
Ответ 7
Выбранный ответ является хорошим ответом, но будьте осторожны с возвращенным объектом.
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.");
Ответ 8
Выражения могут помочь здесь:
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();
}
Я не тестировал этот фрагмент, но я думаю, что он должен производить "типизированные" нули для ссылочных типов.
Ответ 9
Пока что нет ничего простого и элегантного, но у меня есть одна идея: если вы знаете тип свойства, который хотите установить, вы можете написать свой собственный default(T)
. Существует два случая: T
- тип значения, а T
- ссылочный тип. Вы можете увидеть это, установив T.IsValueType
. Если T
является ссылочным типом, вы можете просто установить его на null
. Если T
- тип значения, тогда у него будет конструктор без параметров, который вы можете вызвать, чтобы получить "пустое" значение.
Ответ 10
Я выполняю ту же задачу, как это.
//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;
}
Ответ 11
Эквивалент 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;
}
}
}
Ответ 12
/// <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;
}
Ответ 13
Небольшие изменения в решении @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));
}