Verificar se um objecto é nulo em C#

C# 6 tem verificação monádica nula :)

Antes de:

if (points != null) {
    var next = points.FirstOrDefault();
    if (next != null && next.X != null) return next.X;
}   
return -1;

Depois de:

var bestValue = points?.FirstOrDefault()?.X ?? -1;

O seu dataList é nulo porque não foi instanciado, a julgar pelo código que publicou.

Tenta:

public List<Object> dataList = new List<Object>();
public  bool AddData(ref Object data)
bool success = false;
try
{
    if (!data.Equals(null))   // I've also used if(data != null) which hasn't worked either
    {
       dataList.Add(data);                      //NullReferenceException occurs here
       success = doOtherStuff(data);
    }
}
catch (Exception e)
{
    throw new Exception(e.ToString());
}
return success;

}

[editado para reflectir a sugestão de @kelton52]

A maneira mais simples é fazer object.ReferenceEquals(null, data)

Uma vez que {[2] } não é garantido que funcione:

class Nully
{
    public static bool operator ==(Nully n, object o)
    {
        Console.WriteLine("Comparing '" + n + "' with '" + o + "'");
        return true;
    }
    public static bool operator !=(Nully n, object o) { return !(n==o); }
}
void Main()
{
    var data = new Nully();
    Console.WriteLine(null == data);
    Console.WriteLine(object.ReferenceEquals(null, data));
}

Produz:

Comparando " com 'Nully'

Verdadeiro

Falso

Não, devias estar a usar {[[0]}. Se data for realmente nulo, então o seu programa irá simplesmente estoirar com um NullReferenceException como resultado de tentar chamar o método Equals em null. Perceba também que, se você quiser verificar especificamente a igualdade de referência, você deve usar o método Object.ReferenceEquals Como você nunca sabe como Equals foi implementado.

O teu programa está a falhar porque dataList é nulo porque nunca o inicializas.

O problema neste caso não é que data seja nulo. É que dataList em si é nulo.

No local onde declara dataList deve criar um novo objecto List e atribuí - lo à variável.

List<object> dataList = new List<object>();

Em C # 7 o melhor é

if (obj is null) ...

Isto vai ignorar qualquer == or != definido pelo objeto (a menos, claro, que você queira usá-los ...)

Pois não podes if (!(obj is null)) (feio)

Além de @Jose Ortega resposta, seu melhor uso método de extensão

 public static bool IsNull(this object T)
     {
        return T == null;
     } 

E usar IsNull método para todos os objectos como:

object foo = new object(); //or any object from any class
if (foo.IsNull())
   {
     // blah blah //
   }

Existe também outro problema com o seu código: está a usar a palavra-chave ref, o que significa que os dados do argumento não podem ser nulos! O MSDN diz:

Um argumento passado para um parâmetro ref deve ser inicializado primeiro. Isto difere de fora, cujos argumentos não precisam ser iniciados explicitamente antes de serem passados

Também não é uma boa ideia usar genéricos com o tipo `Objecto´. Os genéricos devem evitar o boxe / desligamento e também garantir a segurança do tipo. Se você quer um tipo comum faça seu método genérico. Finalmente o seu código deve ser assim:

public class Foo<T> where T : MyTypeOrInterface {

      public List<T> dataList = new List<T>();

      public bool AddData(ref T data) {
        bool success = false;
        try {
          dataList.Add(data);                   
          success = doOtherStuff(data);
        } catch (Exception e) {
          throw new Exception(e.ToString());
        }
        return success;
      }

      private bool doOtherStuff(T data) {
        //...
      }
    }

Como outros já salientaram, não é {[[0]} mas muito provável dataList que seja null. Além disso...

catch-throw é um antipattern que quase sempre me dá vontade de vomitar sempre que o vejo. Imagine que algo corre mal profundamente em algo que doOtherStuff() chama. Tudo o que tens de volta é um objecto, atirado ao throw em AddData(). Nenhum traço de pilha, nenhuma informação de chamada, nenhum Estado, nada para indicar a verdadeira fonte do problema, a menos que você vá entre e mude o seu depurador para quebrar a excepção lançada em vez de a abrir. Se você está pegando uma exceção e apenas re-jogando-a de qualquer forma, particularmente se o código no bloco de tentativa é de alguma forma não trivial, faça a si mesmo (e seus colegas, presente e futuro) um favor e jogue fora todo o bloco de teste try-catch block. Concedido, throw; é melhor do que as alternativas, mas você ainda está dando a si mesmo (ou quem quer que esteja tentando corrigir um bug no código) completamente dores de cabeça desnecessárias. Isto não quer dizer que tentar atirar seja necessariamente mau por si só, desde que você faça algo relevante com o objeto de exceção que foi jogado dentro do bloco de captura.

  public static bool isnull(object T)
  {
      return T == null ? true : false;
  }

Utilizar:

isnull(object.check.it)

Uso condicional:

isnull(object.check.it) ? DoWhenItsTrue : DoWhenItsFalse;

Actualização (de outra forma) actualizada 08/31/2017. Obrigado pelo comentário.

public static bool isnull(object T)
{
    return T ? true : false;
}

Sempre que estiver a criar objectos de classe, terá de verificar se o objecto é nulo ou não usando o código abaixo.

void myFunction(object1)
{
  if(object1!=null)
  {
     object1.value1 //If we miss the null check then here we get the Null Reference exception
  }
}