Verificação nula profunda, existe uma maneira melhor?

Nota: Esta pergunta foi feita antes da introdução do .?operador em C # 6 / Visual Studio 2015 .

Todos nós já estivemos lá, temos algumas propriedades profundas, como cake.frosting.berries.loader, que precisamos verificar se é nulo, para que não haja exceção. A maneira de fazer é usar uma instrução if de curto-circuito

if (cake != null && cake.frosting != null && cake.frosting.berries != null) ...

Isso não é exatamente elegante e talvez deva haver uma maneira mais fácil de verificar toda a cadeia e verificar se ela se depara com uma variável / propriedade nula.

É possível usar algum método de extensão ou seria um recurso de linguagem ou é apenas uma má idéia?

Consideramos adicionar uma nova operação "?." para o idioma que possui a semântica desejada. (E foi adicionado agora; veja abaixo.) Ou seja, você diria

cake?.frosting?.berries?.loader

e o compilador geraria todas as verificações de curto-circuito para você.

Não chegou ao C # 4. Talvez para uma versão futura hipotética da linguagem.

Atualização (2014): O ?.operador agora está planejado para a próxima versão do compilador Roslyn. Observe que ainda há algum debate sobre a análise sintática e semântica exata do operador.

Atualização (julho de 2015): o Visual Studio 2015 foi lançado e é fornecido com um compilador C # que suporta os operadores ?.e condicionais nulos?[] .

Eu me inspirei nessa pergunta para tentar descobrir como esse tipo de verificação nula profunda pode ser feita com uma sintaxe mais fácil / mais bonita usando árvores de expressão. Embora eu concorde com as respostas afirmando que pode ser um design ruim se você precisar acessar instâncias profundas na hierarquia, também acho que, em alguns casos, como a apresentação de dados, pode ser muito útil.

Então, eu criei um método de extensão, que permitirá que você escreva:

var berries = cake.IfNotNull(c => c.Frosting.Berries);

Isso retornará os Berries se nenhuma parte da expressão for nula. Se nulo for encontrado, nulo será retornado. No entanto, existem algumas ressalvas: na versão atual, ele funciona apenas com acesso simples a membros e funciona no .NET Framework 4, porque usa o método MemberExpression.Update, que é novo na v4. Este é o código para o método de extensão IfNotNull:

using System;
using System.Collections.Generic;
using System.Linq.Expressions;

namespace dr.IfNotNullOperator.PoC
{
    public static class ObjectExtensions
    {
        public static TResult IfNotNull<TArg,TResult>(this TArg arg, Expression<Func<TArg,TResult>> expression)
        {
            if (expression == null)
                throw new ArgumentNullException("expression");

            if (ReferenceEquals(arg, null))
                return default(TResult);

            var stack = new Stack<MemberExpression>();
            var expr = expression.Body as MemberExpression;
            while(expr != null)
            {
                stack.Push(expr);
                expr = expr.Expression as MemberExpression;
            } 

            if (stack.Count == 0 || !(stack.Peek().Expression is ParameterExpression))
                throw new ApplicationException(String.Format("The expression '{0}' contains unsupported constructs.",
                                                             expression));

            object a = arg;
            while(stack.Count > 0)
            {
                expr = stack.Pop();
                var p = expr.Expression as ParameterExpression;
                if (p == null)
                {
                    p = Expression.Parameter(a.GetType(), "x");
                    expr = expr.Update(p);
                }
                var lambda = Expression.Lambda(expr, p);
                Delegate t = lambda.Compile();                
                a = t.DynamicInvoke(a);
                if (ReferenceEquals(a, null))
                    return default(TResult);
            }

            return (TResult)a;            
        }
    }
}

Ele funciona examinando a árvore de expressões que representa sua expressão e avaliando as partes uma após a outra; sempre que verificar se o resultado não é nulo.

Estou certo de que isso pode ser estendido para que outras expressões que não sejam MemberExpression sejam suportadas. Considere isso como um código de prova de conceito e lembre-se de que haverá uma penalidade de desempenho ao usá-lo (o que provavelmente não será importante em muitos casos, mas não o use em um circuito fechado :-))

Eu achei essa extensão bastante útil para cenários de aninhamento profundo.

public static R Coal<T, R>(this T obj, Func<T, R> f)
    where T : class
{
    return obj != null ? f(obj) : default(R);
}

É uma ideia que tirei do operador coalescente nulo em C # e T-SQL. O bom é que o tipo de retorno é sempre o tipo de retorno da propriedade interna.

Dessa forma, você pode fazer isso:

var berries = cake.Coal(x => x.frosting).Coal(x => x.berries);

... ou uma ligeira variação do anterior:

var berries = cake.Coal(x => x.frosting, x => x.berries);

Não é a melhor sintaxe que conheço, mas funciona.

Além de violar a Lei de Demeter, como Mehrdad Afshari já apontou, parece-me que você precisa de "verificação nula profunda" para a lógica de decisão.

Geralmente, esse é o caso em que você deseja substituir objetos vazios por valores padrão. Nesse caso, você deve considerar a implementação do Padrão de Objeto Nulo . Ele atua como substituto de um objeto real, fornecendo valores padrão e métodos de "não ação".

Atualização: a partir do Visual Studio 2015, o compilador C # (versão 6 do idioma) agora reconhece o ?.operador, o que facilita a "verificação nula profunda". Veja esta resposta para detalhes.

Além de redesenhar seu código, como sugeriu esta resposta excluída , outra opção (ainda que terrível) seria usar um try…catchbloco para verificar se isso NullReferenceExceptionocorre em algum momento durante essa pesquisa profunda de propriedade.

try
{
    var x = cake.frosting.berries.loader;
    ...
}
catch (NullReferenceException ex)
{
    // either one of cake, frosting, or berries was null
    ...
}

Eu pessoalmente não faria isso pelos seguintes motivos:

• Não parece legal.
• Ele usa tratamento de exceção, que deve visar situações excepcionais e não algo que você espera que ocorra frequentemente durante o curso normal da operação.
• NullReferenceExceptionProvavelmente, nunca deve ser capturado explicitamente. (Veja esta pergunta .)

Então, é possível usar algum método de extensão ou seria um recurso de linguagem, [...]

Isso seria quase certamente tem que ser um recurso de linguagem (que está disponível em C # 6 na forma do .?e ?[]operadores), a menos que C # já teve avaliação preguiçosa mais sofisticado, ou menos que você queira usar a reflexão (que provavelmente também não é uma boa ideia por razões de desempenho e segurança do tipo).

Como não há como simplesmente passar cake.frosting.berries.loaderpara uma função (ela seria avaliada e lançaria uma exceção de referência nula), você teria que implementar um método de pesquisa geral da seguinte maneira: Ele pega objetos e nomes de propriedades para olho para cima:

static object LookupProperty( object startingPoint, params string[] lookupChain )
{
    // 1. if 'startingPoint' is null, return null, or throw an exception.
    // 2. recursively look up one property/field after the other from 'lookupChain',
    //    using reflection.
    // 3. if one lookup is not possible, return null, or throw an exception.
    // 3. return the last property/field's value.
}

...

var x = LookupProperty( cake, "frosting", "berries", "loader" );

(Nota: código editado.)

Você vê rapidamente vários problemas com essa abordagem. Primeiro, você não obtém nenhum tipo de segurança e possível boxe de valores de propriedades de um tipo simples. Segundo, você pode retornar nullse algo der errado e terá que verificar isso em sua função de chamada ou lançar uma exceção e voltar ao ponto em que começou. Terceiro, pode ser lento. Quarto, parece mais feio do que você começou.

[...] ou é apenas uma má ideia?

Eu ficaria com:

if (cake != null && cake.frosting != null && ...) ...

ou vá com a resposta acima de Mehrdad Afshari.

PS: Quando escrevi esta resposta, obviamente não considerava árvores de expressão para funções lambda; veja, por exemplo, a resposta do @driis 'para uma solução nessa direção. Também é baseado em um tipo de reflexão e, portanto, pode não ter um desempenho tão bom quanto em uma solução mais simples ( if (… != null & … != null) …), mas pode ser considerado melhor do ponto de vista da sintaxe.

Embora a resposta dos driis seja interessante, acho que é um desempenho um pouco caro demais. Em vez de compilar muitos delegados, prefiro compilar um lambda por caminho de propriedade, armazená-lo em cache e reinvocá-lo de vários tipos.

NullCoalesce abaixo faz exatamente isso, ele retorna uma nova expressão lambda com verificações nulas e um retorno de padrão (TResult) no caso de qualquer caminho ser nulo.

Exemplo:

NullCoalesce((Process p) => p.StartInfo.FileName)

Retornará uma expressão

(Process p) => (p != null && p.StartInfo != null ? p.StartInfo.FileName : default(string));

Código:

    static void Main(string[] args)
    {
        var converted = NullCoalesce((MethodInfo p) => p.DeclaringType.Assembly.Evidence.Locked);
        var converted2 = NullCoalesce((string[] s) => s.Length);
    }

    private static Expression<Func<TSource, TResult>> NullCoalesce<TSource, TResult>(Expression<Func<TSource, TResult>> lambdaExpression)
    {
        var test = GetTest(lambdaExpression.Body);
        if (test != null)
        {
            return Expression.Lambda<Func<TSource, TResult>>(
                Expression.Condition(
                    test,
                    lambdaExpression.Body,
                    Expression.Default(
                        typeof(TResult)
                    )
                ),
                lambdaExpression.Parameters
            );
        }
        return lambdaExpression;
    }

    private static Expression GetTest(Expression expression)
    {
        Expression container;
        switch (expression.NodeType)
        {
            case ExpressionType.ArrayLength:
                container = ((UnaryExpression)expression).Operand;
                break;
            case ExpressionType.MemberAccess:
                if ((container = ((MemberExpression)expression).Expression) == null)
                {
                    return null;
                }
                break;
            default:
                return null;
        }
        var baseTest = GetTest(container);
        if (!container.Type.IsValueType)
        {
            var containerNotNull = Expression.NotEqual(
                container,
                Expression.Default(
                    container.Type
                )
            );
            return (baseTest == null ?
                containerNotNull :
                Expression.AndAlso(
                    baseTest,
                    containerNotNull
                )
            );
        }
        return baseTest;
    }

Uma opção é usar o Null Object Patten; portanto, em vez de ter nulo quando você não tem um bolo, você tem um NullCake que retorna um NullFosting etc. Desculpe. Não sou muito bom em explicar isso, mas outras pessoas são.

• Um exemplo do uso Null Object Patten
• Os wikipedai escrevem sobre o Null Object Patten

Eu também frequentemente desejei uma sintaxe mais simples! Fica especialmente feio quando você tem valores de retorno de método que podem ser nulos, porque você precisa de variáveis ​​extras (por exemplo cake.frosting.flavors.FirstOrDefault().loader:)

No entanto, aqui está uma alternativa bastante decente que eu uso: crie um método auxiliar Null-Safe-Chain. Percebo que isso é bastante semelhante à resposta de @ John acima (com o Coalmétodo de extensão), mas acho que é mais direto e menos digitado. Aqui está o que parece:

var loader = NullSafe.Chain(cake, c=>c.frosting, f=>f.berries, b=>b.loader);

Aqui está a implementação:

public static TResult Chain<TA,TB,TC,TResult>(TA a, Func<TA,TB> b, Func<TB,TC> c, Func<TC,TResult> r) 
where TA:class where TB:class where TC:class {
    if (a == null) return default(TResult);
    var B = b(a);
    if (B == null) return default(TResult);
    var C = c(B);
    if (C == null) return default(TResult);
    return r(C);
}

Também criei várias sobrecargas (com 2 a 6 parâmetros), bem como sobrecargas que permitem que a cadeia termine com um tipo de valor ou padrão. Isso funciona muito bem para mim!

Existe o projeto Talvez codeplex que Implementa Talvez ou IfNotNull usando lambdas para expressões profundas em C #

Exemplo de uso:

int? CityId= employee.Maybe(e=>e.Person.Address.City);

O link foi sugerido em uma pergunta semelhante. Como verificar nulos em uma expressão lambda profunda?

Como sugerido na John Leidegren 's resposta , uma abordagem para trabalho em torno isso é usar métodos de extensão e delegados. Usá-los pode ser algo como isto:

int? numberOfBerries = cake
    .NullOr(c => c.Frosting)
    .NullOr(f => f.Berries)
    .NullOr(b => b.Count());

A implementação é confusa porque é necessário fazê-la funcionar para tipos de valor, tipos de referência e tipos de valor anuláveis. Você pode encontrar uma implementação completa em Timwi 's resposta para o que é a maneira correta para verificar se há valores nulos? .

Ou você pode usar a reflexão :)

Função de reflexão:

public Object GetPropValue(String name, Object obj)
    {
        foreach (String part in name.Split('.'))
        {
            if (obj == null) { return null; }

            Type type = obj.GetType();
            PropertyInfo info = type.GetProperty(part);
            if (info == null) { return null; }

            obj = info.GetValue(obj, null);
        }
        return obj;
    }

Uso:

object test1 = GetPropValue("PropertyA.PropertyB.PropertyC",obj);

My Case (retorne DBNull.Value em vez de nulo na função de reflexão):

cmd.Parameters.AddWithValue("CustomerContactEmail", GetPropValue("AccountingCustomerParty.Party.Contact.ElectronicMail.Value", eInvoiceType));

Tente este código:

    /// <summary>
    /// check deep property
    /// </summary>
    /// <param name="obj">instance</param>
    /// <param name="property">deep property not include instance name example "A.B.C.D.E"</param>
    /// <returns>if null return true else return false</returns>
    public static bool IsNull(this object obj, string property)
    {
        if (string.IsNullOrEmpty(property) || string.IsNullOrEmpty(property.Trim())) throw new Exception("Parameter : property is empty");
        if (obj != null)
        {
            string[] deep = property.Split('.');
            object instance = obj;
            Type objType = instance.GetType();
            PropertyInfo propertyInfo;
            foreach (string p in deep)
            {
                propertyInfo = objType.GetProperty(p);
                if (propertyInfo == null) throw new Exception("No property : " + p);
                instance = propertyInfo.GetValue(instance, null);
                if (instance != null)
                    objType = instance.GetType();
                else
                    return true;
            }
            return false;
        }
        else
            return true;
    }

Postei isso ontem à noite e um amigo me indicou essa pergunta. Espero que ajude. Você pode fazer algo assim:

var color = Dis.OrDat<string>(() => cake.frosting.berries.color, "blue");


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace DeepNullCoalescence
{
  public static class Dis
  {
    public static T OrDat<T>(Expression<Func><T>> expr, T dat)
    {
      try
      {
        var func = expr.Compile();
        var result = func.Invoke();
        return result ?? dat; //now we can coalesce
      }
      catch (NullReferenceException)
      {
        return dat;
      }
    }
  }
}

Leia o post completo do blog aqui .

O mesmo amigo também sugeriu que você assista a isso .

Modifiquei levemente o código daqui para fazê-lo funcionar na pergunta:

public static class GetValueOrDefaultExtension
{
    public static TResult GetValueOrDefault<TSource, TResult>(this TSource source, Func<TSource, TResult> selector)
    {
        try { return selector(source); }
        catch { return default(TResult); }
    }
}

E sim, essa provavelmente não é a solução ideal devido a implicações de desempenho de tentativa / captura, mas funciona:>

Uso:

var val = cake.GetValueOrDefault(x => x.frosting.berries.loader);

Onde você precisa conseguir isso, faça o seguinte:

Uso

Color color = someOrder.ComplexGet(x => x.Customer.LastOrder.Product.Color);

ou

Color color = Complex.Get(() => someOrder.Customer.LastOrder.Product.Color);

Implementação da classe auxiliar

public static class Complex
{
    public static T1 ComplexGet<T1, T2>(this T2 root, Func<T2, T1> func)
    {
        return Get(() => func(root));
    }

    public static T Get<T>(Func<T> func)
    {
        try
        {
            return func();
        }
        catch (Exception)
        {
            return default(T);
        }
    }
}

Eu gosto da abordagem adotada pelo Objective-C:

"A linguagem Objective-C adota outra abordagem para esse problema e não invoca métodos em zero, mas retorna nulo para todas essas invocações".

if (cake.frosting.berries != null) 
{
    var str = cake.frosting.berries...;
}