Question: I am always confused with the different ways of expressing nulls. There is the null reference type (aka "null"). Then I've seen that throughout my application, developers have used MinValue to represent nulls. Ex: Double.MinValue or DateTime.MinValue except for a String for which they use "null"

Then there is System.DBNull (and System.DBNull.Value - not sure what to use when). To add to the confusion, there are also `System.Nullable` and `System.Nullable<T>` namespaces.

Can someone help me clear this null confusion?

Thanks

Answer: 
* `null` is only valid for *reference* types: types that are a `class` rather than a `structure`.
* .Net also has value types: int, double, DateTime, etc. Value types cannot be null, you so you normally compare those to their default value, which is very often `type.MinValue`, but might be something (consider Boolean, for example).
* `Nullable<T>` is for when you have a value type that might genuinely be null. The default value (maybe MinValue) is also valid and you need to distinguish it from when the variable has not been assigned yet. In C#, you can use a ? with a value type as a short hand notation (for example: `int?`), but you're still creating the same `Nullable<T>`.
* `DBNull` specifically refers to NULL values from a database. It's not the same thing as using null elsewhere in the language: it's only for talking to a database so you can know when a query returned a null value.
* When using generics, you'll also see the `default(T)` construct used, where T is a type parameter. This allows you to set a type's default value without knowing whether that type is a reference type or a value type, much less what a specific value type's default value might be.
the best way for tou to understand this different null values is to try them and see what the use of each one but to make things simple here is some guideline

* null can be used only on reference types like collections and custom classes (string is special)
* DBNull is for null values that came out of the db query.
* because we cant assign null to a decimal or double we assign them with the MinValue property (they are value objects)
* Nullable is a way for the developer to assign null values to value objects like decimal,
`Nullable<int> is same as int?`

---

i hope i helped you understanding the differences.