Sélectionnez analysé int, si la chaîne a été parseable à int

Il est difficile de le faire que dans la syntaxe de la requête, mais c'est pas trop mal à lambda syntaxe:

var ints = strings.Select(str => {
                             int value;
                             bool success = int.TryParse(str, out value);
                             return new { value, success };
                         })
                  .Where(pair => pair.success)
                  .Select(pair => pair.value);

Alternativement, vous pouvez le trouver en valeur l'écriture d'une méthode qui retourne un int?:

public static int? NullableTryParseInt32(string text)
{
    int value;
    return int.TryParse(text, out value) ? (int?) value : null;
}

Vous pouvez simplement utiliser:

var ints = from str in strings
           let nullable = NullableTryParseInt32(str)
           where nullable != null
           select nullable.Value;

Si vous n'avez pas l'esprit de vos collègues de travail le saut, vous dans le stationnement, il y a un moyen de le faire à une véritable ligne de linq (pas de points-virgules) ....

strings.Select<string, Func<int,int?>>(s => (n) => int.TryParse(s, out n) ? (int?)n : (int?)null ).Where(λ => λ(0) != null).Select(λ => λ(0).Value);

Il n'est pas pratique, mais, ce faisant, dans une déclaration était bien trop intéressant, un défi pour la laisser passer.

Je ferais c'est de LINQ-to-objets:

static int? ParseInt32(string s) {
    int i;
    if(int.TryParse(s,out i)) return i;
    return null;
}

Puis dans la requête:

let i = ParseInt32(str)
where i != null
select i.Value;

Inspiré par Carl Walsh réponse, j'ai pris un peu plus loin pour permettre l'analyse de propriétés:

public static IEnumerable<TResult> SelectTry<TSource, TValue, TResult>(
     this IEnumerable<TSource> source, 
     Func<TSource, TValue> selector, 
     TryFunc<TValue, TResult> executor)
{
    foreach (TSource s in source)
    {
        TResult r;
        if (executor(selector(s), out r))
            yield return r;
    }
}

Voici un exemple qui peut également être trouvé dans ce violon:

public class Program
{
    public static void Main()
    {       
        IEnumerable<MyClass> myClassItems = new List<MyClass>() {new MyClass("1"), new MyClass("2"), new MyClass("InvalidValue"), new MyClass("3")};

        foreach (int integer in myClassItems.SelectTry<MyClass, string, int>(x => x.MyIntegerAsString, int.TryParse))
        {
            Console.WriteLine(integer);
        }
    }
}

public static class LinqUtilities
{
    public delegate bool TryFunc<in TSource, TResult>(TSource arg, out TResult result);

    public static IEnumerable<TResult> SelectTry<TSource, TValue, TResult>(
        this IEnumerable<TSource> source, 
        Func<TSource, TValue> selector, 
        TryFunc<TValue, TResult> executor)
    {
        foreach (TSource s in source)
        {
            TResult r;
            if (executor(selector(s), out r))
                yield return r;
        }
    }
}

public class MyClass
{
    public MyClass(string integerAsString)
    {
        this.MyIntegerAsString = integerAsString;
    }

     public string MyIntegerAsString{get;set;}
}

De sortie de ce programme:

1

2

3

Je suis d'accord que l'utilisation de la variable supplémentaire se sent laid.

Basé sur Jon répondre et la mise à jour vers C# 7.0 solutions on peut utiliser la nouvelle var out fonctionnalité: (pas beaucoup plus courte, mais pas besoin pour un intérieur de la portée ou de la requête variables temp)

var result = strings.Select(s => new { Success = int.TryParse(s, out var value), value })
                    .Where(pair => pair.Success)
                    .Select(pair => pair.value);

et avec uplets nommé:

var result = strings.Select(s => (int.TryParse(s, out var value), value))
                    .Where(pair => pair.Item1)
                    .Select(pair => pair.value);

Ou si ce qui suggère une méthode pour l'utilisation de la syntaxe de la requête:

public static int? NullableTryParseInt32(string text)
{
    return int.TryParse(text, out var value) ? (int?)value : null;
}

---

J'aimerais également proposer une syntaxe de requête sans une méthode supplémentaire pour elle, mais comme expliqué dans le lien suivant out var n'est pas pris en charge par le c# 7.0 et les résultats dans l'erreur de compilation:

Variables et le modèle des déclarations de variables ne sont pas autorisés à l'intérieur d'une requête de la clause

Le lien: L'Expression des variables dans les expressions de requête

---

Par le biais de ce C# 7.0 fonctionnalité, on peut le faire fonctionner sur plus tôt .NET versions:

• C# 7 .NET /CLR /version de Visual Studio exigences
• Est-ce que C# 7.0 travail pour .NET 4.5?