Bagaimana cara memeriksa apakah suatu objek dapat dibatalkan?

Bagaimana cara memeriksa apakah objek yang diberikan dapat dibatalkan dengan kata lain cara menerapkan metode berikut ...

bool IsNullableValueType(object o)
{
    ...
}

EDIT: Saya mencari jenis nilai yang dapat dibatalkan. Saya tidak memiliki tipe ref dalam pikiran.

//Note: This is just a sample. The code has been simplified 
//to fit in a post.

public class BoolContainer
{
    bool? myBool = true;
}

var bc = new BoolContainer();

const BindingFlags bindingFlags = BindingFlags.Public
                        | BindingFlags.NonPublic
                        | BindingFlags.Instance
                        ;


object obj;
object o = (object)bc;

foreach (var fieldInfo in o.GetType().GetFields(bindingFlags))
{
    obj = (object)fieldInfo.GetValue(o);
}

obj sekarang merujuk ke objek bertipe bool( System.Boolean) dengan nilai sama dengan true. Yang benar-benar saya inginkan adalah objek bertipeNullable<bool>

Jadi sekarang sebagai pekerjaan di sekitar saya memutuskan untuk memeriksa apakah o dapat dibatalkan dan membuat pembungkus nullable di sekitar obj.

Ada dua jenis nullable - Nullable<T>dan tipe referensi.

Jon telah mengoreksi saya bahwa sulit untuk mendapatkan ketik jika kotak, tetapi Anda bisa dengan obat generik: - jadi bagaimana kalau di bawah ini. Ini sebenarnya tipe pengujian T, tetapi menggunakan objparameter murni untuk inferensi tipe generik (untuk membuatnya mudah dipanggil) - itu akan bekerja hampir identik tanpa objparam, meskipun.

static bool IsNullable<T>(T obj)
{
    if (obj == null) return true; // obvious
    Type type = typeof(T);
    if (!type.IsValueType) return true; // ref-type
    if (Nullable.GetUnderlyingType(type) != null) return true; // Nullable<T>
    return false; // value-type
}

Tapi ini tidak akan bekerja dengan baik jika Anda telah mengotakkan nilai ke variabel objek.

Dokumentasi Microsoft: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/nullable-types/how-to-identify-a-nullable-type

Ada solusi yang sangat sederhana menggunakan kelebihan metode

http://deanchalk.com/is-it-nullable/

kutipan:

public static class ValueTypeHelper
{
    public static bool IsNullable<T>(T t) { return false; }
    public static bool IsNullable<T>(T? t) where T : struct { return true; }
}

kemudian

static void Main(string[] args)
{
    int a = 123;
    int? b = null;
    object c = new object();
    object d = null;
    int? e = 456;
    var f = (int?)789;
    bool result1 = ValueTypeHelper.IsNullable(a); // false
    bool result2 = ValueTypeHelper.IsNullable(b); // true
    bool result3 = ValueTypeHelper.IsNullable(c); // false
    bool result4 = ValueTypeHelper.IsNullable(d); // false
    bool result5 = ValueTypeHelper.IsNullable(e); // true
    bool result6 = ValueTypeHelper.IsNullable(f); // true

Pertanyaan "Bagaimana cara memeriksa apakah suatu jenis dapat dibatalkan?" sebenarnya "Bagaimana memeriksa apakah suatu tipe adalah Nullable<>?", yang dapat digeneralisasi menjadi "Bagaimana memeriksa apakah suatu tipe adalah tipe yang dikonstruksi dari beberapa tipe generik?", sehingga tidak hanya menjawab pertanyaan "Apakah Nullable<int>a Nullable<>?", tetapi juga "Apakah List<int>a List<>?".

Sebagian besar solusi yang disediakan menggunakan Nullable.GetUnderlyingType()metode ini, yang jelas hanya akan bekerja dengan case Nullable<>. Saya tidak melihat solusi reflektif umum yang akan bekerja dengan semua jenis generik, jadi saya memutuskan untuk menambahkannya di sini untuk anak cucu, meskipun pertanyaan ini sudah dijawab sejak lama.

Untuk memeriksa apakah suatu jenis Nullable<>menggunakan bentuk refleksi, Anda harus terlebih dahulu mengubah tipe generik yang Anda buat, misalnya Nullable<int>, ke definisi tipe generik Nullable<>,. Anda dapat melakukannya dengan menggunakan GetGenericTypeDefinition()metode Typekelas. Anda kemudian dapat membandingkan jenis yang dihasilkan dengan Nullable<>:

Type typeToTest = typeof(Nullable<int>);
bool isNullable = typeToTest.GetGenericTypeDefinition() == typeof(Nullable<>);
// isNullable == true

Hal yang sama dapat diterapkan untuk semua jenis generik:

Type typeToTest = typeof(List<int>);
bool isList = typeToTest.GetGenericTypeDefinition() == typeof(List<>);
// isList == true

Beberapa tipe mungkin terlihat sama, tetapi jumlah argumen tipe yang berbeda berarti tipe yang sama sekali berbeda.

Type typeToTest = typeof(Action<DateTime, float>);
bool isAction1 = typeToTest.GetGenericTypeDefinition() == typeof(Action<>);
bool isAction2 = typeToTest.GetGenericTypeDefinition() == typeof(Action<,>);
bool isAction3 = typeToTest.GetGenericTypeDefinition() == typeof(Action<,,>);
// isAction1 == false
// isAction2 == true
// isAction3 == false

Karena Typeobjek dipakai sekali per jenis, Anda dapat memeriksa kesetaraan referensi di antara mereka. Jadi, jika Anda ingin memeriksa apakah dua objek memiliki definisi tipe generik yang sama, Anda dapat menulis:

var listOfInts = new List<int>();
var listOfStrings = new List<string>();

bool areSameGenericType =
    listOfInts.GetType().GetGenericTypeDefinition() ==
    listOfStrings.GetType().GetGenericTypeDefinition();
// areSameGenericType == true

Jika Anda ingin memeriksa apakah suatu objek nullable, bukan a Type, maka Anda dapat menggunakan teknik di atas bersama dengan solusi Marc Gravell untuk membuat metode yang agak sederhana:

static bool IsNullable<T>(T obj)
{
    if (!typeof(T).IsGenericType)
        return false;

    return typeof(T).GetGenericTypeDefinition() == typeof(Nullable<>);
}

Ini bekerja untuk saya dan tampaknya sederhana:

static bool IsNullable<T>(T obj)
{
    return default(T) == null;
}

Untuk jenis nilai:

static bool IsNullableValueType<T>(T obj)
{
    return default(T) == null && typeof(T).BaseType != null && "ValueType".Equals(typeof(T).BaseType.Name);
}

Nah, Anda bisa menggunakan:

return !(o is ValueType);

... tetapi sebuah objek itu sendiri tidak dapat dibatalkan atau sebaliknya - suatu tipe adalah. Bagaimana Anda berencana menggunakan ini?

Cara paling sederhana yang bisa saya pikirkan adalah:

public bool IsNullable(object obj)
{
    Type t = obj.GetType();
    return t.IsGenericType 
        && t.GetGenericTypeDefinition() == typeof(Nullable<>);
}

Ada dua masalah di sini: 1) pengujian untuk melihat apakah suatu Jenis dapat dibatalkan; dan 2) pengujian untuk melihat apakah suatu objek mewakili Tipe yang dapat dibatalkan.

Untuk edisi 1 (menguji Tipe), inilah solusi yang saya gunakan dalam sistem saya sendiri: Solusi TypeIsNullable-check

Untuk edisi 2 (menguji suatu objek), solusi Dean Chalk di atas berfungsi untuk tipe nilai, tetapi itu tidak berfungsi untuk tipe referensi, karena menggunakan <T> yang berlebihan selalu menghasilkan false. Karena tipe referensi secara inheren nullable, pengujian tipe referensi harus selalu mengembalikan true. Silakan lihat catatan [Tentang "nullability"] di bawah untuk penjelasan tentang semantik ini. Jadi, inilah modifikasi saya untuk pendekatan Dean:

    public static bool IsObjectNullable<T>(T obj)
    {
        // If the parameter-Type is a reference type, or if the parameter is null, then the object is always nullable
        if (!typeof(T).IsValueType || obj == null)
            return true;

        // Since the object passed is a ValueType, and it is not null, it cannot be a nullable object
        return false; 
    }

    public static bool IsObjectNullable<T>(T? obj) where T : struct
    {
        // Always return true, since the object-type passed is guaranteed by the compiler to always be nullable
        return true;
    }

Dan inilah modifikasi saya pada kode uji klien untuk solusi di atas:

    int a = 123;
    int? b = null;
    object c = new object();
    object d = null;
    int? e = 456;
    var f = (int?)789;
    string g = "something";

    bool isnullable = IsObjectNullable(a); // false 
    isnullable = IsObjectNullable(b); // true 
    isnullable = IsObjectNullable(c); // true 
    isnullable = IsObjectNullable(d); // true 
    isnullable = IsObjectNullable(e); // true 
    isnullable = IsObjectNullable(f); // true 
    isnullable = IsObjectNullable(g); // true

Alasan saya memodifikasi pendekatan Dean di IsObjectNullable <T> (Tt) adalah bahwa pendekatan aslinya selalu kembali false untuk tipe referensi. Karena metode seperti IsObjectNullable harus dapat menangani nilai tipe referensi dan karena semua tipe referensi secara inheren nullable, maka jika salah satu tipe referensi atau nol dilewatkan, metode tersebut harus selalu mengembalikan true.

Dua metode di atas dapat diganti dengan metode tunggal berikut dan mencapai hasil yang sama:

    public static bool IsObjectNullable<T>(T obj)
    {
        Type argType = typeof(T);
        if (!argType.IsValueType || obj == null)
            return true;
        return argType.IsGenericType && argType.GetGenericTypeDefinition() == typeof(Nullable<>);
    }

Namun, masalah dengan pendekatan metode tunggal terakhir ini adalah bahwa kinerja menderita ketika parameter <T> Nullable digunakan. Dibutuhkan lebih banyak waktu prosesor untuk mengeksekusi baris terakhir metode tunggal ini daripada yang memungkinkan kompiler untuk memilih kelebihan metode kedua yang ditunjukkan sebelumnya ketika parameter tipe-Nullable <T> digunakan dalam panggilan IsObjectNullable. Oleh karena itu, solusi optimal adalah dengan menggunakan pendekatan dua metode yang diilustrasikan di sini.

CAVEAT: Metode ini hanya berfungsi jika dipanggil menggunakan referensi objek asli atau salinan yang tepat, seperti yang ditunjukkan dalam contoh. Namun, jika objek nullable dikotakkan ke Tipe lain (seperti objek, dll.) Alih-alih tetap dalam bentuk Nullable <> aslinya, metode ini tidak akan bekerja dengan andal. Jika kode yang memanggil metode ini tidak menggunakan referensi objek asli, tanpa kotak, atau salinan yang tepat, kode tersebut tidak dapat diandalkan untuk menentukan nullability objek menggunakan metode ini.

Dalam sebagian besar skenario pengkodean, untuk menentukan nullability, seseorang harus bergantung pada pengujian Jenis objek asli, bukan referensi (misalnya, kode harus memiliki akses ke Tipe asli objek untuk menentukan nullability). Dalam kasus yang lebih umum ini, IsTypeNullable (lihat tautan) adalah metode yang dapat diandalkan untuk menentukan nullability.

PS - Tentang "nullability"

Saya harus mengulangi pernyataan tentang pembatalan yang saya buat di pos terpisah, yang berlaku langsung untuk menangani topik ini dengan benar. Yaitu, saya percaya fokus pembahasan di sini seharusnya bukan bagaimana memeriksa untuk melihat apakah suatu objek adalah tipe Nullable generik, melainkan apakah seseorang dapat menetapkan nilai nol ke objek jenisnya. Dengan kata lain, saya pikir kita harus menentukan apakah tipe objek nullable, bukan apakah itu Nullable. Perbedaannya adalah dalam semantik, yaitu alasan praktis untuk menentukan nullability, yang biasanya adalah yang terpenting.

Dalam sistem yang menggunakan objek dengan tipe yang mungkin tidak diketahui hingga run-time (layanan web, panggilan jarak jauh, database, feed, dll.), Persyaratan umum adalah untuk menentukan apakah null dapat ditetapkan ke objek, atau apakah objek tersebut mungkin berisi sebuah nol. Melakukan operasi seperti itu pada tipe yang tidak dapat dibatalkan kemungkinan akan menghasilkan kesalahan, biasanya pengecualian, yang sangat mahal baik dalam hal kinerja dan persyaratan pengkodean. Untuk mengambil pendekatan yang sangat disukai untuk secara proaktif menghindari masalah seperti itu, perlu untuk menentukan apakah suatu objek dari Tipe arbitrer mampu mengandung null; yaitu, apakah secara umum 'nullable'.

Dalam arti yang sangat praktis dan khas, nullability dalam istilah .NET sama sekali tidak selalu menyiratkan bahwa Jenis objek adalah bentuk Nullable. Dalam banyak kasus pada kenyataannya, objek memiliki tipe referensi, dapat berisi nilai nol, dan dengan demikian semuanya dapat dibatalkan; tidak ada yang memiliki tipe Nullable. Oleh karena itu, untuk tujuan praktis dalam sebagian besar skenario, pengujian harus dilakukan untuk konsep umum nullability, vs konsep implementasi-tergantung Nullable. Jadi kita tidak boleh menutup telepon hanya dengan memfokuskan pada tipe .NET Nullable tetapi menggabungkan pemahaman kita tentang persyaratan dan perilakunya dalam proses pemfokusan pada konsep umum praktis tentang nullability.

Solusi paling sederhana yang saya buat adalah dengan mengimplementasikan solusi Microsoft ( Cara: Mengidentifikasi Jenis Nullable (C # Programming Guide) ) sebagai metode ekstensi:

public static bool IsNullable(this Type type)
{
    return Nullable.GetUnderlyingType(type) != null;
}

Ini kemudian dapat disebut seperti ini:

bool isNullable = typeof(int).IsNullable();

Ini juga tampaknya cara yang logis untuk mengakses IsNullable()karena cocok dengan semua IsXxxx()metode lain di Typekelas.

Hati-hati, saat meninju tipe nullable ( Nullable<int>atau int? Misalnya):

int? nullValue = null;
object boxedNullValue = (object)nullValue;
Debug.Assert(boxedNullValue == null);

int? value = 10;
object boxedValue = (object)value;
Debug.Assert( boxedValue.GetType() == typeof(int))

Itu menjadi tipe referensi yang benar, jadi Anda kehilangan fakta bahwa itu nullable.

Mungkin sedikit di luar topik, tetapi masih beberapa informasi menarik. Saya menemukan banyak orang yang menggunakan Nullable.GetUnderlyingType() != nullidentitas jika suatu tipe dapat dibatalkan. Ini jelas bekerja, tetapi Microsoft menyarankan berikut ini type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)(lihat http://msdn.microsoft.com/en-us/library/ms366789.aspx ).

Saya melihat ini dari sisi kinerja. Kesimpulan dari pengujian (satu juta upaya) di bawah ini adalah bahwa ketika suatu jenis nullable, opsi Microsoft memberikan kinerja terbaik.

Nullable.GetUnderlyingType (): 1335ms (3 kali lebih lambat)

GetGenericTypeDefinition () == typeof (Nullable <>): 500ms

Saya tahu bahwa kita berbicara tentang sejumlah kecil waktu, tetapi semua orang suka men-tweak milidetik :-)! Jadi jika Anda bos ingin Anda mengurangi beberapa milidetik maka ini adalah penyelamat Anda ...

/// <summary>Method for testing the performance of several options to determine if a type is     nullable</summary>
[TestMethod]
public void IdentityNullablePerformanceTest()
{
    int attempts = 1000000;

    Type nullableType = typeof(Nullable<int>);

    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();
    for (int attemptIndex = 0; attemptIndex < attempts; attemptIndex++)
    {
        Assert.IsTrue(Nullable.GetUnderlyingType(nullableType) != null, "Expected to be a nullable"); 
    }

    Console.WriteLine("Nullable.GetUnderlyingType(): {0} ms", stopwatch.ElapsedMilliseconds);

    stopwatch.Restart();

    for (int attemptIndex = 0; attemptIndex < attempts; attemptIndex++)
   {
       Assert.IsTrue(nullableType.IsGenericType && nullableType.GetGenericTypeDefinition() == typeof(Nullable<>), "Expected to be a nullable");
   }

   Console.WriteLine("GetGenericTypeDefinition() == typeof(Nullable<>): {0} ms", stopwatch.ElapsedMilliseconds);
   stopwatch.Stop();
}

Versi ini:

• hasil caching lebih cepat,
• tidak memerlukan variabel yang tidak perlu, seperti Metode (T obj)
• TIDAK RUMIT :),
• hanya kelas generik statis, yang memiliki bidang perhitungan satu kali

:

public static class IsNullable<T>
{
    private static readonly Type type = typeof(T);
    private static readonly bool is_nullable = type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
    public static bool Result { get { return is_nullable; } }
}

bool is_nullable = IsNullable<int?>.Result;

Inilah yang saya pikirkan, karena segala sesuatu yang lain tampaknya gagal - setidaknya pada PLC - Portable Class Library / .NET Core dengan> = C # 6

Solusi: Perluas metode statis untuk Jenis apa pun Tdan Nullable<T>dan gunakan fakta bahwa metode ekstensi statis, yang cocok dengan jenis yang mendasarinya akan dipanggil dan diutamakan daripada generikT ekstensi .

Untuk T:

public static partial class ObjectExtension
{
    public static bool IsNullable<T>(this T self)
    {
        return false;
    }
}

dan untuk Nullable<T>

public static partial class NullableExtension
{
    public static bool IsNullable<T>(this Nullable<T> self) where T : struct
    {
        return true;
    }
}

Menggunakan Refleksi dan type.IsGenericType... tidak berfungsi pada rangkaian .NET Runtimes saya saat ini. Dokumentasi MSDN juga tidak membantu.

if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)) {…}

Sebagian karena API Refleksi telah diubah cukup signifikan dalam .NET Core.

Saya pikir yang menggunakan pengujian yang disarankan Microsoft IsGenericTypebagus, tetapi dalam kode untuk GetUnderlyingType, Microsoft menggunakan tes tambahan untuk memastikan Anda tidak lulus dalam definisi tipe umum Nullable<>:

 public static bool IsNullableType(this Type nullableType) =>
    // instantiated generic type only                
    nullableType.IsGenericType &&
    !nullableType.IsGenericTypeDefinition &&
    Object.ReferenceEquals(nullableType.GetGenericTypeDefinition(), typeof(Nullable<>));

cara sederhana untuk melakukan ini:

    public static bool IsNullable(this Type type)
    {
        if (type.IsValueType) return Activator.CreateInstance(type) == null;

        return true;
    }

ini adalah unit test saya dan semuanya lulus

    IsNullable_String_ShouldReturn_True
    IsNullable_Boolean_ShouldReturn_False
    IsNullable_Enum_ShouldReturn_Fasle
    IsNullable_Nullable_ShouldReturn_True
    IsNullable_Class_ShouldReturn_True
    IsNullable_Decimal_ShouldReturn_False
    IsNullable_Byte_ShouldReturn_False
    IsNullable_KeyValuePair_ShouldReturn_False

tes unit aktual

    [TestMethod]
    public void IsNullable_String_ShouldReturn_True()
    {
        var typ = typeof(string);
        var result = typ.IsNullable();
        Assert.IsTrue(result);
    }

    [TestMethod]
    public void IsNullable_Boolean_ShouldReturn_False()
    {
        var typ = typeof(bool);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_Enum_ShouldReturn_Fasle()
    {
        var typ = typeof(System.GenericUriParserOptions);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_Nullable_ShouldReturn_True()
    {
        var typ = typeof(Nullable<bool>);
        var result = typ.IsNullable();
        Assert.IsTrue(result);
    }

    [TestMethod]
    public void IsNullable_Class_ShouldReturn_True()
    {
        var typ = typeof(TestPerson);
        var result = typ.IsNullable();
        Assert.IsTrue(result);
    }

    [TestMethod]
    public void IsNullable_Decimal_ShouldReturn_False()
    {
        var typ = typeof(decimal);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_Byte_ShouldReturn_False()
    {
        var typ = typeof(byte);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_KeyValuePair_ShouldReturn_False()
    {
        var typ = typeof(KeyValuePair<string, string>);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }