オブジェクトがnull可能かどうかを確認する方法は？

特定のオブジェクトがnull可能かどうかを確認する方法、つまり次のメソッドを実装する方法...

bool IsNullableValueType(object o)
{
    ...
}

編集：私はnullable値タイプを探しています。ref型は考えていませんでした。

//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は、値がに等しいタイプbool（System.Boolean）のオブジェクトを参照するようになりましたtrue。私が本当に欲しかったのはタイプのオブジェクトでしたNullable<bool>

そこで、回避策として、私はoがnull可能かどうかを確認し、objの周りにnull可能ラッパーを作成することにしました。

nullableには2つのタイプがあります- Nullable<T>とreference-typeです。

ジョンは、ボックス化されているとタイプを取得するのが難しいことを修正しましたが、ジェネリックスを使用してこれを行うことができます。これは実際にはtypeをテストTしていobjますが、純粋にジェネリック型の推論のためにパラメーターを使用しています（呼び出しを簡単にするため）obj。ただし、パラメーターがなくてもほとんど同じように機能します。

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
}

しかし、値をオブジェクト変数に既にボックス化している場合、これはあまりうまく機能しません。

Microsoftのドキュメント：https : //docs.microsoft.com/en-us/dotnet/csharp/programming-guide/nullable-types/how-to-identify-a-nullable-type

メソッドのオーバーロードを使用する非常に簡単な解決策があります

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

抜粋：

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

その後

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

「型がnull可能かどうかを確認する方法」の質問 これは実際には「型がNullable<>？かどうかを確認する方法」であり、これは「型が何らかのジェネリック型の構築型かどうかを確認する方法？」に一般化できるため、「Is Nullable<int>a Nullable<>？」という質問に答えるだけではありません。だけでなく、「です？」。List<int>List<>

提供されているソリューションのほとんどはこのNullable.GetUnderlyingType()メソッドを使用しています。これは明らかにの場合にのみ機能しNullable<>ます。ジェネリック型で機能する一般的なリフレクションソリューションは見当たらないので、この質問はすでにかなり前に回答されていますが、後世のためにここに追加することにしました。

型がNullable<>リフレクションを使用する何らかの形であるかどうかを確認するには、まず、作成したジェネリック型を、たとえばNullable<int>、ジェネリック型定義に変換する必要がありますNullable<>。クラスのGetGenericTypeDefinition()メソッドを使用してそれを行うことができますType。次に、結果の型を次と比較できますNullable<>。

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

同じことがすべてのジェネリック型に適用できます。

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

いくつかの型は同じように見えるかもしれませんが、型引数の数が異なるということは、完全に異なる型であることを意味します。

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

以来Type、オブジェクトがタイプごとに一度インスタンス化されている、あなたはそれらの間の基準の等価性をチェックすることができます。したがって、2つのオブジェクトが同じジェネリック型定義であるかどうかを確認する場合は、次のように記述できます。

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

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

オブジェクトがnullではなく、null可能かどうかを確認する場合はType、上記の手法をMarc Gravellのソリューションと組み合わせて、かなり単純なメソッドを作成できます。

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

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

これは私にとってはうまくいき、簡単に見えます：

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

値タイプの場合：

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

まあ、あなたは使うことができます：

return !(o is ValueType);

...しかし、オブジェクト自体はnull可能ではないか、そうでなければ- 型はnull です。これをどのように使用する予定でしたか？

私が理解できる最も簡単な方法は：

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

ここには2つの問題があります。1）Typeがnull可能かどうかを確認するテスト。2）オブジェクトがnull許容型を表すかどうかを確認するためのテスト。

問題1（タイプのテスト）について、私が自分のシステムで使用したソリューションは次のとおりです：TypeIsNullable-checkソリューション

問題2（オブジェクトのテスト）の場合、上記のDean Chalkのソリューションは値型に対しては機能しますが、<T>オーバーロードを使用すると常にfalseが返されるため、参照型に対しては機能しません。参照型は本質的にnull可能であるため、参照型をテストすると常にtrueが返されます。これらのセマンティクスの説明については、下記の「null可能性について」の注記を参照してください。したがって、ここにディーンのアプローチへの私の変更があります：

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

上記のソリューションのクライアントテストコードに対する私の変更は次のとおりです。

    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

IsObjectNullable <T>（T t）でDeanのアプローチを変更した理由は、彼の元のアプローチが参照型に対して常にfalseを返したためです。IsObjectNullableのようなメソッドは参照型の値を処理できる必要があり、すべての参照型は本質的にnull可能であるため、参照型またはnullが渡された場合、メソッドは常にtrueを返す必要があります。

上記の2つの方法は、次の単一の方法で置き換えることができ、同じ出力が得られます。

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

ただし、この最後の単一メソッドアプローチの問題は、Nullable <T>パラメーターを使用するとパフォーマンスが低下することです。IsObjectNullable呼び出しでNullable <T>タイプのパラメーターが使用されている場合、コンパイラーが前に示した2番目のメソッドオーバーロードを選択できるようにするよりも、この単一メソッドの最後の行を実行するのにはるかに多くのプロセッサ時間がかかります。したがって、最適なソリューションは、ここに示す2つの方法のアプローチを使用することです。

警告：このメソッドは、例に示すように、元のオブジェクト参照または正確なコピーを使用して呼び出された場合にのみ確実に機能します。ただし、null許容オブジェクトが元のNullable <>フォームのままではなく、別のType（オブジェクトなど）にボックス化されている場合、このメソッドは確実に機能しません。このメソッドを呼び出すコードが元のボックス化されていないオブジェクト参照または正確なコピーを使用していない場合、このメソッドを使用してオブジェクトのnull可能性を確実に判断することはできません。

ほとんどのコーディングシナリオでは、null可能かどうかを判断するには、参照ではなく元のオブジェクトのタイプのテストに依存する必要があります（たとえば、null可能かどうかを判断するには、コードがオブジェクトの元のタイプにアクセスできる必要があります）。これらのより一般的なケースでは、IsTypeNullable（リンクを参照）は、ヌル可能性を判断する信頼できる方法です。

PS-「nullability」について

私は別の投稿で私が作ったヌル可能性についての声明を繰り返す必要があります。これは、このトピックに適切に対処するために直接適用されます。つまり、ここでの議論の焦点は、オブジェクトが汎用のNullable型であるかどうかを確認する方法ではなく、その型のオブジェクトにnullの値を割り当てることができるかどうかにあると考えています。つまり、オブジェクト型がnull可能かどうかではなく、null可能かどうかを判断する必要があると思います。違いはセマンティクス、つまりnull可能かどうかを決定する実際的な理由にあります。これは通常重要なことです。

実行時まで不明である可能性のあるタイプのオブジェクト（Webサービス、リモート呼び出し、データベース、フィードなど）を使用するシステムでは、一般的な要件は、オブジェクトにnullを割り当てることができるかどうか、またはオブジェクトにnull。nullを許容しない型でこのような操作を実行すると、エラー（通常は例外）が発生する可能性が高く、パフォーマンスとコーディング要件の両方の面で非常にコストがかかります。このような問題を積極的に回避するという非常に好ましいアプローチをとるには、任意のTypeのオブジェクトがnullを含むことができるかどうかを判断する必要があります。つまり、一般に「null可能」かどうか。

非常に実用的で一般的な意味で、.NET用語のnull可能性は、オブジェクトのTypeがNullableの形式であることを必ずしも意味しません。実際、多くの場合、オブジェクトには参照型があり、null値を含めることができるため、すべてnull可能です。これらのどれもNullableタイプを持ちません。したがって、ほとんどのシナリオでの実用的な目的のために、実装に依存するNullableの概念ではなく、Null可能性の一般的な概念に対してテストを行う必要があります。したがって、.NET Nullable型のみに焦点を当てることでハングアップするのではなく、NULL可能性の一般的で実用的な概念に焦点を合わせるプロセスに、その要件と動作の理解を組み込む必要があります。

私が思いついた最も簡単なソリューションは、Microsoftのソリューション（方法：null可能な型を特定する（C＃プログラミングガイド））を拡張メソッドとして実装することです。

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

これは次のように呼び出すことができます：

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

これは、クラスのIsNullable()他のすべてのIsXxxx()メソッドに適合するため、アクセスするのにも論理的な方法のようTypeです。

null許容型（Nullable<int>またはint？など）をボックス化するときは注意してください。

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

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

これは真の参照型になるため、null可能であったという事実を失います。

トピックから少し外れたかもしれませんが、それでも興味深い情報がいくつかあります。Nullable.GetUnderlyingType() != null型がnull可能である場合、ID を使用する人がたくさんいます。これは明らかに機能しますが、Microsoftは次のようにアドバイスしていますtype.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)（http://msdn.microsoft.com/en-us/library/ms366789.aspxを参照）。

これをパフォーマンスの面から見ました。以下のテスト（100万回の試行）の結論は、型がnull許容の場合、Microsoftオプションが最高のパフォーマンスを提供するということです。

Nullable.GetUnderlyingType（）： 1335ms（3倍遅い）

GetGenericTypeDefinition（）== typeof（Nullable <>）： 500 ミリ秒

私たちは少しの時間について話していることを知っていますが、誰もがミリ秒を微調整するのが大好きです:-)！ですから、上司が数ミリ秒の短縮を望んでいるなら、これがあなたの救世主です...

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

このバージョン：

• 結果のキャッシュがより速く、
• Method（T obj）のような不要な変数を必要としません
• 複雑ではない:)、
• 一度だけ計算されたフィールドを持つ静的な汎用クラス

：

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;

他のすべてが失敗したように見えたので、ここに私が思いついたものがあります-少なくともPLC-Portable Class Library / .NET Core >> C＃6

解決策：すべてのタイプのための静的メソッドを拡張TしてNullable<T>、基礎となるタイプに一致する静的な拡張メソッドは、呼び出される予定とジェネリックよりも優先されるという事実を使用T拡張メソッドを。

の場合T：

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

そしてのために Nullable<T>

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

Reflectionおよびtype.IsGenericType...の使用は、現在の.NETランタイムのセットでは機能しませんでした。また、MSDNドキュメントは役に立ちませんでした。

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

一部には、.NET CoreでReflection APIが大幅に変更されたためです。

Microsoftが推奨するテストを使用するものIsGenericTypeは良いと思いますが、のコードではGetUnderlyingType、Microsoftが追加のテストを使用して、ジェネリック型定義を渡していないことを確認していますNullable<>。

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

これを行う簡単な方法：

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

        return true;
    }

これらは私のユニットテストであり、すべて合格

    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

実際の単体テスト

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