Chamada de método se não for nula em C #

É possível encurtar de alguma forma esta afirmação?

if (obj != null)
    obj.SomeMethod();

porque escrevo muito isso e fica muito chato. A única coisa que posso pensar é implementar o padrão Null Object , mas isso não é o que posso fazer todas as vezes e certamente não é uma solução para encurtar a sintaxe.

E problema semelhante com eventos, onde

public event Func<string> MyEvent;

e então invocar

if (MyEvent != null)
    MyEvent.Invoke();

Do C # 6 em diante, você pode apenas usar:

MyEvent?.Invoke();

ou:

obj?.SomeMethod();

O ?.é o operador de propagação nula e causará um .Invoke()curto-circuito quando o operando for null. O operando é acessado apenas uma vez, não havendo risco do problema de "mudança de valor entre checar e invocar".

===

Antes do C # 6, não: não há mágica de segurança nula, com uma exceção; métodos de extensão - por exemplo:

public static void SafeInvoke(this Action action) {
    if(action != null) action();
}

agora isso é válido:

Action act = null;
act.SafeInvoke(); // does nothing
act = delegate {Console.WriteLine("hi");}
act.SafeInvoke(); // writes "hi"

No caso de eventos, tem a vantagem de remover também a condição de corrida, ou seja, você não precisa de uma variável temporária. Normalmente, você precisa de:

var handler = SomeEvent;
if(handler != null) handler(this, EventArgs.Empty);

mas com:

public static void SafeInvoke(this EventHandler handler, object sender) {
    if(handler != null) handler(sender, EventArgs.Empty);
}

podemos usar simplesmente:

SomeEvent.SafeInvoke(this); // no race condition, no null risk

O que você está procurando é o Null condicional (e não "coalescência") operador: ?.. Ele está disponível a partir de C # 6.

Seu exemplo seria obj?.SomeMethod();. Se obj for nulo, nada acontece. Quando o método tem argumentos, por exemplo, obj?.SomeMethod(new Foo(), GetBar());os argumentos não são avaliados se objfor nulo, o que importa se a avaliação dos argumentos tiver efeitos colaterais.

E o encadeamento é possível: myObject?.Items?[0]?.DoSomething()

Um método de extensão rápido:

    public static void IfNotNull<T>(this T obj, Action<T> action, Action actionIfNull = null) where T : class {
        if(obj != null) {
            action(obj);
        } else if ( actionIfNull != null ) {
            actionIfNull();
        }
    }

exemplo:

  string str = null;
  str.IfNotNull(s => Console.Write(s.Length));
  str.IfNotNull(s => Console.Write(s.Length), () => Console.Write("null"));

ou alternativamente:

    public static TR IfNotNull<T, TR>(this T obj, Func<T, TR> func, Func<TR> ifNull = null) where T : class {
        return obj != null ? func(obj) : (ifNull != null ? ifNull() : default(TR));
    }

exemplo:

    string str = null;
    Console.Write(str.IfNotNull(s => s.Length.ToString());
    Console.Write(str.IfNotNull(s => s.Length.ToString(), () =>  "null"));

Os eventos podem ser inicializados com um delegado padrão vazio que nunca é removido:

public event EventHandler MyEvent = delegate { };

Nenhuma verificação nula necessária.

[ Atualização , obrigado a Bevan por apontar isso]

Porém, esteja ciente do possível impacto no desempenho. Um rápido micro benchmark que fiz indica que lidar com um evento sem assinantes é 2 a 3 vezes mais lento ao usar o padrão de "delegado padrão". (No meu laptop dual core de 2,5 GHz, isso significa 279 ms: 785 ms para gerar 50 milhões de eventos não inscritos.). Para pontos de acesso de aplicativos, isso pode ser um problema a ser considerado.

Sim, em C # 6.0 - https://msdn.microsoft.com/en-us/magazine/dn802602.aspx .

object?.SomeMethod()

Este artigo de Ian Griffiths apresenta duas soluções diferentes para o problema, que ele conclui serem truques bacanas que você não deve usar.

O método de extensão cerating como o sugerido não resolve realmente problemas com condições de corrida, mas sim os esconde.

public static void SafeInvoke(this EventHandler handler, object sender)
{
    if (handler != null) handler(sender, EventArgs.Empty);
}

Conforme declarado, este código é o elegante equivalente à solução com variável temporária, mas ...

O problema com ambos é que é possível que o assinante do evento seja chamado DEPOIS de ter cancelado a inscrição do evento . Isso é possível porque o cancelamento da assinatura pode acontecer depois que a instância do delegado é copiada para a variável temporária (ou passada como parâmetro no método acima), mas antes que o delegado seja invocado.

Em geral, o comportamento do código do cliente é imprevisível nesse caso: o estado do componente já não podia permitir o tratamento da notificação de eventos. É possível escrever o código do cliente da maneira de lidar com isso, mas colocaria uma responsabilidade desnecessária para o cliente.

A única maneira conhecida de garantir a segurança do encadeamento é usar a instrução de bloqueio para o remetente do evento. Isso garante que todas as assinaturas \ unsubscriptions \ invocation sejam serializadas.

Para ser mais preciso, o bloqueio deve ser aplicado ao mesmo objeto de sincronização usado nos métodos de acesso adicionar / remover eventos, que é o padrão 'this'.

Concordo com a resposta de Kenny Eliasson. Vá com métodos de extensão. Aqui está uma breve visão geral dos métodos de extensão e seu método IfNotNull obrigatório.

Métodos de extensão (método IfNotNull)

Talvez não seja melhor, mas na minha opinião mais legível é criar um método de extensão

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

Existe um operador nulo pouco conhecido em C # para isso, ??. Pode ser útil:

http://weblogs.asp.net/scottgu/archive/2007/09/20/the-new-c-null-coalescing-operator-and-using-it-with-linq.aspx