Si l'instruction à l'intérieur d'une fonction Lambda?

Ce peut être assez simple, mais je suis plutôt nouvelle pour Lambda si patient avec moi.

J'ai une fonction qui utilise une fonction Lambda répéter.
La fonction principale reçoit un booléen indiquant la nécessité d'inclure certaines informations ou de ne pas l'intérieur de la lambda.

La fonction est conçue pour écrire une classe personnalisée à XML - je pense que le code est assez explanitory.

Pour le moment, j'ai surmonté le problème à l'aide d'une simple instruction if, mais il se sent moche donc demandé si quelqu'un connaissait une meilleure façon?

        private XElement ErrorListToXml(ErrorList el, bool outputTagsOnly)
    {
        //Need to declare in advance to call within the lambda.
        Func<ErrorType, XElement> recursiveGenerator = null;

        if (outputTagsOnly)
            recursiveGenerator = error => new XElement
                (error.Name,
                 error.ChildErrors.Select(recursiveGenerator));
        else
            recursiveGenerator = error => new XElement
          (error.Name,
          new XAttribute("Ignore", error.Filter),
           error.ChildErrors.Select(recursiveGenerator));


        var element = new XElement
                   ("ErrorList",
                    ChildErrors.Select(recursiveGenerator));

        Console.WriteLine(element);

        return element;
    }

OriginalL'auteur Chris | 2009-06-03

.net c#c#-3.0 lambda

6

mquander la solution peut être légèrement améliorée afin de réduire les dédoublements. Vous pouvez utiliser le fait que vous pouvez passer dans null un élément dans la XElement constructeur de contenu, et c'est ignorée. On peut donc déplacer la condition supplémentaire:
```
Func<ErrorType, XElement> recursiveGenerator = null;    
recursiveGenerator = (error => new XElement(error.Name,
            outputTagsOnly ? null : new XAttribute("Ignore", error.Filter),
            error.ChildErrors.Select(recursiveGenerator));

var element = new XElement("ErrorList", ChildErrors.Select(recursiveGenerator));
```
+1, ne pas connaître le constructeur avait que de la propriété.
Ahhh, c'est comment j'ai d'abord essayé de le faire mais ne savais pas que vous pourriez passer la valeur null. Merci

OriginalL'auteur Jon Skeet
6

Vous pouvez déplacer l'instruction "if" à l'intérieur de la fonction lambda en toute sécurité, si vous avez préféré:
```
Func<ErrorType, XElement> recursiveGenerator = null;

recursiveGenerator = (error =>
    outputTagsOnly
        ? new XElement(error.Name,
                       error.ChildErrors.Select(recursiveGenerator));
        : new XElement(error.Name, new XAttribute("Ignore", error.Filter),
                       error.ChildErrors.Select(recursiveGenerator)));

var element = new XElement("ErrorList", ChildErrors.Select(recursiveGenerator));
```
Autre que cela, il n'a pas l'air d'être trivial manière à simplifier ce que vous avez.

(P. S. Quand il semble laid, mettre du rouge à lèvres sur ce cochon par impression 😉

Merci c'est ce que je cherchais
Ici, le rendement est un peu moins bonne que dans le code d'origine: vous vérifiez l'indicateur outputTagsOnly sur la génération de tous nœud, alors que c'est totalement pas nécessaire, vous pouvez vérifier une fois. (Bien sûr, pour les petits les données d'entrée de son insignifiant)
Oui, j'ai réalisé que, mais le drapeau vérifier est donc extrêmement insignifiante par rapport à la surcharge de la construction d'éléments XML que je pense que c'est d'absolument aucune importance par rapport à la lisibilité.

OriginalL'auteur mquander
6

Vous pouvez prendre une décision entre les valeurs de même type dans une lambda assez facilement:
```
customer => flag ? customer.Name : customer.Address
```
Vous pouvez utiliser une instruction if dans un lambda avec un peu plus d'effort:
```
customer =>
{
  if (flag)
    return customer.Name
  else
    return customer.Address
}
```
Ni l'un ni l'aide de votre méthode grandement.

OriginalL'auteur Amy B

Je suppose que vous pouvez le faire, mais à la fin de la journée, c'est toujours un si:

                recursiveGenerator = error => outputTagsOnly ? 
                   new XElement(error.Name,error.ChildErrors.Select(recursiveGenerator)
              : 
              new XElement(error.Name,new XAttribute("Ignore", error.Filter), 
             error.ChildErrors.Select(recursiveGenerator);

Cheers mate, mquander battue vous à la poste. Je sais que c'est encore si j'essayais juste de trouver une façon plus élégante. Merci!

OriginalL'auteur BFree

Vous pouvez essayer de décomposer votre problème en deux types différents:

Comment construire un arbre à partir des erreurs de structure.
Quoi mettre dans les nœuds de l'arborescence.

Ensuite, le code ressemblera à:

        private XElement ErrorListToXml(ErrorList el, bool outputTagsOnly)
        {
            //Need to declare in advance to call within the lambda.
            Func<ErrorType, XElement> treeGenerator = null;
            Func<ErrorType, object[]> elementParametersGenerator = null;

            treeGenerator = error => new XElement
                (error.Name,
                elementParametersGenerator(error));

            if(outputTagsOnly)
                elementParametersGenerator = error => 
                    new object[] {error.ChildErrors.Select(treeGenerator)};
            else
                elementParametersGenerator = error => 
                    new object[] { new XAttribute("Ignore", error.Filter), error.ChildErrors.Select(treeGenerator) };

            var element = new XElement
                       ("ErrorList",
                        ChildErrors.Select(treeGenerator));

            Console.WriteLine(element);

            return element;
        }

Pas tout nettement mieux dans ce cas particulier, mais c'est une approche plus générale.

OriginalL'auteur Max Galkin

Vous devez vous connecter pour publier un commentaire.