LINQ: "enthält" und eine Lambda-Abfrage

Ich habe einen List<BuildingStatus>angerufen buildingStatus. Ich möchte prüfen, ob es einen Status enthält, dessen Zeichencode (zurückgegeben von GetCharCode()) einer Variablen entspricht v.Status.

Gibt es eine Möglichkeit, dies im Sinne des folgenden (nicht kompilierten) Codes zu tun?

buildingStatus.Contains(item => item.GetCharValue() == v.Status)

Verwenden Sie Any()anstelle von Contains():

buildingStatus.Any(item => item.GetCharValue() == v.Status)

Die Linq-Erweiterungsmethode Jeder könnte für Sie arbeiten ...

buildingStatus.Any(item => item.GetCharValue() == v.Status)

So können Sie Containserreichen, was Sie wollen:

buildingStatus.Select(item => item.GetCharValue()).Contains(v.Status) Dies gibt einen Booleschen Wert zurück.

Ich bin mir nicht sicher, wonach Sie suchen, aber dieses Programm:

    public class Building
    {
        public enum StatusType
        {
            open,
            closed,
            weird,
        };

        public string Name { get; set; }
        public StatusType Status { get; set; }
    }

    public static List <Building> buildingList = new List<Building> ()
    {
        new Building () { Name = "one", Status = Building.StatusType.open },
        new Building () { Name = "two", Status = Building.StatusType.closed },
        new Building () { Name = "three", Status = Building.StatusType.weird },

        new Building () { Name = "four", Status = Building.StatusType.open },
        new Building () { Name = "five", Status = Building.StatusType.closed },
        new Building () { Name = "six", Status = Building.StatusType.weird },
    };

    static void Main (string [] args)
    {
        var statusList = new List<Building.StatusType> () { Building.StatusType.open, Building.StatusType.closed };

        var q = from building in buildingList
                where statusList.Contains (building.Status)
                select building;

        foreach ( var b in q )
            Console.WriteLine ("{0}: {1}", b.Name, b.Status);
    }

erzeugt die erwartete Ausgabe:

one: open
two: closed
four: open
five: closed

Dieses Programm vergleicht eine Zeichenfolgendarstellung der Aufzählung und erzeugt dieselbe Ausgabe:

    public class Building
    {
        public enum StatusType
        {
            open,
            closed,
            weird,
        };

        public string Name { get; set; }
        public string Status { get; set; }
    }

    public static List <Building> buildingList = new List<Building> ()
    {
        new Building () { Name = "one", Status = "open" },
        new Building () { Name = "two", Status = "closed" },
        new Building () { Name = "three", Status = "weird" },

        new Building () { Name = "four", Status = "open" },
        new Building () { Name = "five", Status = "closed" },
        new Building () { Name = "six", Status = "weird" },
    };

    static void Main (string [] args)
    {
        var statusList = new List<Building.StatusType> () { Building.StatusType.open, Building.StatusType.closed };
        var statusStringList = statusList.ConvertAll <string> (st => st.ToString ());

        var q = from building in buildingList
                where statusStringList.Contains (building.Status)
                select building;

        foreach ( var b in q )
            Console.WriteLine ("{0}: {1}", b.Name, b.Status);

        Console.ReadKey ();
    }

Ich habe diese Erweiterungsmethode erstellt, um eine IEnumerable in eine andere zu konvertieren, bin mir aber nicht sicher, wie effizient sie ist. Möglicherweise wird nur eine Liste hinter den Kulissen erstellt.

public static IEnumerable <TResult> ConvertEach (IEnumerable <TSource> sources, Func <TSource,TResult> convert)
{
    foreach ( TSource source in sources )
        yield return convert (source);
}

Dann können Sie die where-Klausel in Folgendes ändern:

where statusList.ConvertEach <string> (status => status.GetCharValue()).
    Contains (v.Status)

und überspringen Sie das Erstellen des List<string>mit ConvertAll ()am Anfang.

Wenn ich das richtig verstehe, müssen Sie den Typ (Zeichenwert), den Sie in der Gebäudeliste speichern, in den Typ (Aufzählung) konvertieren, den Sie in der Gebäudestatusliste speichern.

(Existiert der Status für jeden Status in der Gebäudeliste // Zeichenwert // in der Gebäudestatusliste // Aufzählungswert //)

public static IQueryable<Building> WithStatus(this IQueryable<Building> qry,  
IList<BuildingStatuses> buildingStatus) 
{ 
    return from v in qry
           where ContainsStatus(v.Status)
           select v;
} 


private bool ContainsStatus(v.Status)
{
    foreach(Enum value in Enum.GetValues(typeof(buildingStatus)))
    {
        If v.Status == value.GetCharValue();
            return true;
    }

    return false;
}