Programmatisches Äquivalent zum Standard (Typ)

Ich verwende Reflection, um die TypeEigenschaften von a zu durchlaufen und bestimmte Typen auf ihre Standardeinstellungen zu setzen. Jetzt könnte ich den Typ umschalten und default(Type)explizit festlegen , aber ich würde es lieber in einer Zeile tun. Gibt es ein programmatisches Äquivalent zum Standard?

• Verwenden Sie im Falle eines Werttyps Activator.CreateInstance und es sollte gut funktionieren.
• Wenn Sie den Referenztyp verwenden, geben Sie einfach null zurück

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

In der neueren Version von .net wie .net Standard type.IsValueTypemuss geschrieben werden alstype.GetTypeInfo().IsValueType

Warum nicht die Methode aufrufen, die Standard (T) mit Reflektion zurückgibt? Sie können GetDefault eines beliebigen Typs verwenden mit:

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

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

Sie können verwenden PropertyInfo.SetValue(obj, null). Wenn ein Werttyp aufgerufen wird, erhalten Sie die Standardeinstellung. Dieses Verhalten ist in .NET 4.0 und in .NET 4.5 dokumentiert .

Wenn Sie .NET 4.0 oder höher verwenden und eine programmatische Version wünschen, bei der es sich nicht um eine Kodifizierung von Regeln handelt, die außerhalb des Codes definiert sind , können Sie eine erstellen Expression, kompilieren und im laufenden Betrieb ausführen.

Die folgende Erweiterungsmethode verwendet a Typeund ruft den Wert ab, der default(T)über die DefaultMethode für die ExpressionKlasse zurückgegeben wird:

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

Sie sollten den oben genannten Wert auch basierend auf dem Typezwischenspeichern. Beachten Sie jedoch Type, dass der vom Cache verbrauchte Speicher möglicherweise die Vorteile überwiegt, wenn Sie ihn für eine große Anzahl von Instanzen aufrufen und ihn nicht ständig verwenden.

Warum sagen Sie, dass Generika nicht im Bilde sind?

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

Dies ist die optimierte Flem-Lösung:

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

Die gewählte Antwort ist eine gute Antwort, aber seien Sie vorsichtig mit dem zurückgegebenen Objekt.

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

Extrapolieren ...

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

Die Ausdrücke können hier helfen:

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

Ich habe dieses Snippet nicht getestet, aber ich denke, es sollte "typisierte" Nullen für Referenztypen erzeugen.

Ich kann noch nichts Einfaches und Elegantes finden, aber ich habe eine Idee: Wenn Sie den Typ der Immobilie kennen, die Sie festlegen möchten, können Sie Ihre eigene schreiben default(T). Es gibt zwei Fälle - Tist ein Werttyp und Tein Referenztyp. Sie können dies sehen, indem Sie überprüfen T.IsValueType. Wenn Tes sich um einen Referenztyp handelt, können Sie ihn einfach auf einstellen null. Wenn Tes sich um einen Werttyp handelt, verfügt er über einen standardmäßigen parameterlosen Konstruktor, den Sie aufrufen können, um einen "leeren" Wert zu erhalten.

Ich mache die gleiche Aufgabe wie diese.

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

Entspricht Drors Antwort, jedoch als Erweiterungsmethode:

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

Leichte Anpassungen an der Lösung von @Rob Fonseca-Ensor : Die folgende Erweiterungsmethode funktioniert auch mit .Net Standard, da ich GetRuntimeMethod anstelle von GetMethod verwende.

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

... und der entsprechende Unit-Test für diejenigen, denen Qualität am Herzen liegt:

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

Das sollte funktionieren: Nullable<T> a = new Nullable<T>().GetValueOrDefault();