Wie Lambda-Ausdruck x => x ist TypeTier dynamisch (Vergleich von Objekttyp)

Question

Hier ist meine linq Abfrage

switch (classname) { 
    case "Tier": 
     classname= getType("Tier") 
     var newquery = from tier in query.AsEnumerable() 
        where tier is className 
        select tier; 
    case "TierNatural": 
     classname= getType("TierNatural") 
     var newquery = from tier in query.AsEnumerable() 
        where tier is className 
        select tier; 
    case "Tierlegal": 
     classname= getType("Tierlegal") 
     var newquery = from tier in query.AsEnumerable() 
        where tier is className 
        select tier; 
} 

Aber es gibt Fehler Klassennamen unterstreichen auf rot (Fehlertyp oder Namensraum erwartet)

bauen

Answer 1

This article hat alles, was Sie brauchen.

Ihr Problem kann so gelöst werden:

internal class Program 
{ 
    private static void Main(string[] args) 
    { 
     string[] companies = 
     { 
      "Consolidated Messenger", "Alpine Ski House", "Southridge Video", "City Power & Light", 
      "Coho Winery", "Wide World Importers", "Graphic Design Institute", "Adventure Works", 
      "Humongous Insurance", "Woodgrove Bank", "Margie's Travel", "Northwind Traders", 
      "Blue Yonder Airlines", "Trey Research", "The Phone Company", 
      "Wingtip Toys", "Lucerne Publishing", "Fourth Coffee" 
     }; 

     var intResults = companies.WhereIsOfType<string, int>(); 
     Console.WriteLine(intResults.Count()); //0 

     var stringResults = companies.WhereIsOfType<string, string>(); 
     Console.WriteLine(stringResults.Count()); //18 
    } 
} 

public static class Extensions 
{ 
    public static IEnumerable<TInput> WhereIsOfType<TInput, TResult>(this IEnumerable<TInput> source) 
    { 
     var queryableSource = source.AsQueryable(); 

     var pe = Expression.Parameter(typeof (TInput), "x"); 

     var left = Expression.Constant(pe.Name); 
     var expr = Expression.TypeIs(left, typeof (TResult)); 

     var whereCallexp = Expression.Call(
      typeof (Queryable), 
      "Where", 
      new[] {typeof (TInput)}, 
      queryableSource.Expression, 
      Expression.Lambda<Func<TInput, bool>>(expr, pe)); 

     var results = queryableSource.Provider.CreateQuery<TInput>(whereCallexp); 
     return results; 
    } 
} 

Answer 2

Sie brauchen nicht einen Ausdruck Baum zu bauen, was Sie zu acheive versuchen.

Sie LINQ verwenden können Enumerable.Where<T> Erweiterungsmethode

Sie query ist vom Typ IEnumerable<T>

var className = "<A class name>" 

query.where(q => q.GetType().Name == className); 

Unter der Annahme, Objekt, wenn Sie Sie möchten, können eine Erweiterungsmethode erstellen:

public static IEnumerable<T> OfType<T>(this IEnumerable<T> source, string className) => 
    source.where(s => s.GetType().Name == className);