LINQ to Entity Změna Subjektu za Běhu

To by mělo fungovat pro EF6, ale byl jsem testování na EFCore.

Udělal jsem něco poněkud podobné s tím, když jsem potřeboval upravit všechny DbSets, které implementují určité rozhraní.

Máte dvě možnosti pro vaši situaci. Od všech vašich model typy nemají společný základní typ (jiné než object), můžete refaktorovat ty generované třídy extrahovat společné vlastnosti základní třídy ( Id, Namea Type vlastnosti).

Tady předpokládám, že vaše Coffee1 a Coffee2 tabulky jen typ entity Coffee1 a Coffee2 resp.

Možnost 1:

Refaktorovat tříd a extrakt tyto společné vlastnosti

public partial class Coffee1 : BaseCoffee {}
public partial class Coffee2 : BaseCoffee {}
public abstract class BaseCoffee
{
  public int Id { get; set; }
  public string Name { get; set; }
  public string Type { get; set; }
}

pak se váš dotaz bude vypadat takto

var dbSets = ctxCoin.GetType().GetProperties()
    .Where(p => p.PropertyType.IsAssignableTo(typeof(IQueryable<BaseCoffee>)))
    .Select(set => set.GetValue(ctxCoin))
    .Cast<IQueryable<BaseCoffee>>();

var coffeeList = new ObservableCollection<GenericCoffeeList>();

foreach (var coffee in dbSets)
{
    var query = coffee.Select(c => new GenericCoffeeList { CoffeeCatalogId = c.Id, Name = c.Name, Type = c.Type });

    foreach (var c in query)
    {
        coffeeList.Add(c);
    }
}

Tato možnost je mnohem více typů-bezpečné a méně náchylné k chybám.

Možnost 2:

Použití reflexe IQueryable<object>

Udržujte své modely stejné a použít toto:

var dbSets = ctxCoin.GetType().GetProperties()
    .Where(p => p.PropertyType.IsAssignableTo(typeof(IQueryable<object>)))
    .Select(set => set.GetValue(ctxCoin))
    .Cast<IQueryable<object>>();

var coffeeList = new ObservableCollection<GenericCoffeeList>();

foreach (var queryableObject in dbSets)
{
    var query = queryableObject.Select(GenerateGenericCoffee);

    foreach (var c in query)
    {
        coffeeList.Add(c);
    }
}

Na GenerateGenericCoffee pomocník metoda

GenericCoffeeList GenerateGenericCoffee(object coffeeObject)
{
    var objType = coffeeObject.GetType();

    return new GenericCoffeeList
    {
        CoffeeCatalogId = GetProperty<int>("Id"),
        Name = GetProperty<string>("Name"),
        Type = GetProperty<string>("Type"),
    };

    T GetProperty<T>(string name)
    {
        return (T)objType.GetProperty(name).GetValue(coffeeObject);
    }
}

Pokud všechny své modely obsahují Id, Namea Typebudeš v pohodě , jinak budete muset zkontrolovat tyto vlastnosti existují první před provedením GenericCoffeeList položka.

Myslím, že vytvoření genetické třídy na dotaz. Při změně Objektu(TEntity), dotaz proveden pro Objekt(TEntity).

public class QueryRepo<TEntity> where TEntity : class
{
    private readonly ctxCoin;
    public QueryRepo(){
        ctxCoin = new CtxCoin();
    }

    public IEnumerable<GenericCoffeeList> GetCoffeeList()
    {
        var entity = ctxCoin.Set<TEntity>();
        return (from c in entity
            select new GenericCoffeeList
            {
                CoffeeCatalogId = c.Id,
                Name = c.Name,
                Type = c.Type
            }).ToList();
    }
}

Já osobně bych se pokusit pomocí obecné metody s labda, který se používá k převedení různých druhů Kávy do GenericCoffeeList.

public IEnumerable<GenericCoffeeList> GetCoffeeList<TCoffee>(Func<TCoffee, GenericCoffeeList> toGenericCoffeeList)
{
    return ctxCoin.Set<TCoffee>()
        .Select(coffee => toGenericCoffeeList(coffee)
        .ToList();
}

To dělají tímto způsobem, snižuje množství kódu potřebné a jediná věc, která musí být duplciated je funkce, které je předán jako toGenericCoffeeList ale také nevyžaduje refactoring 200+ třídy, implementovat rozhraní.

Tento přístup může být upraven v závislosti na tom, co je třeba udělat (nejsem si přesně jistý, co vaše metoda má dělat, protože coffeeList je nikdy použity, a coinList nikdy prohlásil,)

Můžete map jednoho Typu na jiný pomocí mapování oblastech, jako je tato:

public static Expression<Func<T, R>> MapFields<T, R>(IDictionary<string, string> fieldNamesMapping) 
            where R: new()
{
    var parameter = Expression.Parameter(typeof(T), "o");  
             
    return Expression.Lambda<Func<T, R>>(
        Expression.MemberInit(
            Expression.New(typeof(R)), 
            GetMemberBindings<T,R>(fieldNamesMapping, parameter)), 
        parameter);
}
      

private static IEnumerable<MemberBinding> GetMemberBindings<T,R>(IDictionary<string, string> fieldNamesMapping,
    ParameterExpression parameter) 
        => fieldNamesMapping
            .Select(o => (MemberBinding)Expression.Bind(
                typeof(R).GetProperty(o.Value) ?? throw new InvalidOperationException(), 
                Expression.Property(parameter, typeof(T).GetProperty(o.Key) ?? throw new InvalidOperationException())));

Tento kód předpokládá, že druhy mají vlastnosti s podobnými typy, ale různá jména. Tedy Slovník s odpovídající filednames.

Pokud pole náhodou mají stejné názvy můžete samozřejmě odvodit vlastnosti pomocí reflexe.

Použití je tak jako:

var toBeMapped = new List<FooA> {
                new FooA {A = 1, B = 2, C = 3},
                new FooA {A = 4, B = 5, C = 6},
                new FooA {A = 7, B = 8, C = 9},
                new FooA {A = 10, B = 11, C = 12}
            };

            var result = toBeMapped.AsQueryable().Select(
                MemberBindingExpressions.MapFields<FooA, FooB>(
                    new Dictionary<string, string> {["A"] = "A", ["B"] = "E"})).ToList();

            result[0].Should().Be(new FooB {A = 1, E = 2});
            result[3].Should().Be(new FooB { A = 10, E = 11 });