Setara programatik dari standar (Tipe)

Saya menggunakan refleksi untuk mengulangi Typeproperti a dan mengatur tipe tertentu ke default. Sekarang, saya bisa melakukan saklar pada jenis dan mengatur default(Type)secara eksplisit, tetapi saya lebih suka melakukannya dalam satu baris. Apakah ada program yang setara dengan standar?

• Dalam hal tipe nilai gunakan Activator.CreateInstance dan itu akan berfungsi dengan baik.
• Saat menggunakan tipe referensi, kembalikan null saja

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

Dalam versi .net yang lebih baru seperti standar .net, type.IsValueTypeperlu ditulis sebagai .nettype.GetTypeInfo().IsValueType

Mengapa tidak memanggil metode yang mengembalikan default (T) dengan refleksi? Anda dapat menggunakan GetDefault jenis apa pun dengan:

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

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

Anda bisa menggunakannya PropertyInfo.SetValue(obj, null). Jika dipanggil pada tipe nilai itu akan memberi Anda default. Perilaku ini didokumentasikan dalam. NET 4.0 dan .NET 4.5 .

Jika Anda menggunakan .NET 4.0 atau di atas dan Anda menginginkan versi program yang bukan kodifikasi aturan yang didefinisikan di luar kode , Anda dapat membuat Expression, mengkompilasi, dan menjalankannya sambil jalan.

Metode ekstensi berikut akan mengambil Typedan mendapatkan nilai yang dikembalikan dari default(T)melalui Defaultmetode di Expressionkelas:

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

Anda juga harus men-cache nilai di atas berdasarkan pada Type, tetapi perlu diketahui jika Anda memanggil ini untuk sejumlah besar Typecontoh, dan jangan menggunakannya terus-menerus, memori yang dikonsumsi oleh cache mungkin lebih besar daripada manfaatnya.

Mengapa Anda mengatakan obat generik tidak tersedia?

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

Ini adalah solusi Flem yang dioptimalkan:

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

Jawaban yang dipilih adalah jawaban yang baik, tetapi hati-hati dengan objek yang dikembalikan.

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

Mengekstrapolasi ...

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

Ekspresi dapat membantu di sini:

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

Saya tidak menguji cuplikan ini, tetapi saya pikir itu harus menghasilkan null "diketik" untuk jenis referensi ..

Tidak dapat menemukan sesuatu yang sederhana dan elegan dulu, tetapi saya punya satu ide: Jika Anda tahu jenis properti yang ingin Anda atur, Anda dapat menulis sendiri default(T). Ada dua kasus - Tadalah tipe nilai, dan Tmerupakan tipe referensi. Anda dapat melihat ini dengan memeriksa T.IsValueType. Jika Tmerupakan tipe referensi, maka Anda cukup mengaturnya null. Jika Tadalah tipe nilai, maka itu akan memiliki konstruktor tanpa parameter default yang dapat Anda panggil untuk mendapatkan nilai "kosong".

Saya melakukan tugas yang sama seperti ini.

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

Setara dengan jawaban Dror tetapi sebagai metode ekstensi:

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

Penyesuaian sedikit ke solusi @Rob Fonseca-Ensor : Metode ekstensi berikut ini juga berfungsi pada .Net Standard karena saya menggunakan GetRuntimeMethod alih-alih 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);
    }
}

... dan unit test yang sesuai untuk mereka yang peduli tentang kualitas:

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

Ini seharusnya bekerja: Nullable<T> a = new Nullable<T>().GetValueOrDefault();