Why is there a Nullable struct and Nullable class?

Question

There is a Nullable<T> struct and there is also another static Nullable class with three static methods.

My question is, why can't these static methods in static Nullable class go into Nullable<T> struct? What is the reason for defining them in two different types?

And there is a INullable interface as well.What does it do?

Good explaination http://stackoverflow.com/questions/4272101/why-nullablet-is-a-struct — Hakunamatata, Jan 20 '17 at 04:26
Possible duplicate of [Why Nullable is a struct?](http://stackoverflow.com/questions/4272101/why-nullablet-is-a-struct) — Abion47, Jan 20 '17 at 04:35

AL - Lil Hunk · Accepted Answer · 2017-01-20T05:48:23.033

Is a standard practice with Generics to have class with the same name of your generic class with utility methods related to the generic class. Because when you use a generic class you cant't infer the generics in the type declaration you'll end up with many more characters. Look how it would be if the static methods were placed in the generic class:
```
Nullable<int?>.Compare(x, Y);
var n = new Tuple<int,string>(10, "Text");
```
vs
```
Nullable.Compare(x, Y);
var n = Tuple.Create(10, "Text");
```
I included Tuple as another example.

Interfaces and base classes are very useful in Generics, and since Nullable<> is struct and structs cannot have a base class, we are left with interfaces. Now here is a possible usage of it.

{
    int? a = 10;
    long? b = 10L;

    Process(a);
    Process(b);
}

private static void Process(INullable value)
{
    if (value.IsNull)
    {
        // Process for null .. 
    }
    else
    {
        // Process for value .. 
    }
}

I never seen an article about the non generic class of some of the generic class, but by looking at multiple generic classes in the .NET framework I got to this conclusion. You can see the documentation of the non generic class Tuple and Nullable and you'll notice they are mentioned like if they are same class [Tuple](https://msdn.microsoft.com/en-us/library/system.tuple(v=vs.110).aspx) [Nullable](https://msdn.microsoft.com/en-us/library/system.nullable(v=vs.110).aspx) — AL - Lil Hunk, Jan 21 '17 at 03:03

Thanesh Davuluri · Answer 2 · 2017-01-20T06:34:52.267

they are written is a separate class because those methods are utility methods and are intended to be used anywhere without actually having to create a nullable structure instance every time you want to use these methods for example,

public static bool Is<T>(this T variable,Type type) {
    if (var != null) {
        Type currentType = variable.GetType();
        type = Nullable.GetUnderlyingType(type) ?? type;
        while (currentType != typeof(object)) {
            if (currentType == type) {
                return true;
            }
            currentType = currentType.BaseType;
        }
    }                  
    return false;
}

In the above example the variable can be of any type(not necessarily nullable), but it can actually be nullable, and hence has to be checked if nullable.

For that very case I used the Nullable.GetUnderlyingType(type), because it is a utility method.This is intended behaviour for utility methods i.e. making them reusable anywhere required without having to create an instance, every time you need them.

Why is there a Nullable struct and Nullable class?

2 Answers2