LINQ to entities Cambio de Entidad en tiempo de ejecución

Esto debería funcionar para EF6 pero estaba probando en EFCore.

Yo he hecho algo similar a esto cuando he necesitado modificar todos los DbSets que implementar una interfaz específica.

Usted tiene dos opciones para su situación. Dado que todos los de su modelo de tipos no tienen una base común de tipo (aparte de object), podría refactorizar esas clases generadas para extraer las propiedades comunes a una clase base (la Id, Namey Type propiedades).

Aquí estoy asumiendo que tu Coffee1 y Coffee2 las tablas sólo tiene el tipo de entidad Coffee1 y Coffee2 respectivamente.

Opción 1:

Refactorizar clases y extraer las propiedades comunes

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; }
}

haga su consulta tendría este aspecto

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);
    }
}

Esta opción es mucho más seguro y menos propenso a errores.

Opción 2:

Utilizar la reflexión sobre IQueryable<object>

Mantener los modelos de la misma y el uso de este:

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);
    }
}

El GenerateGenericCoffee método auxiliar

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);
    }
}

Si todos los modelos contienen Id, Namey Typeusted estará bien en lo contrario, tendrá que comprobar las propiedades que existen antes de hacer el GenericCoffeeList elemento.

Creo que, de crear genética de la clase para la consulta. Al cambiar de Objeto(TEntity), consulta ejecutada por el Objeto(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();
    }
}

Personalmente me gustaría probar el uso de un método genérico con un labda que se utiliza para convertir los diferentes tipos de Café en GenericCoffeeList.

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

Haciendo de esta manera se reduce la cantidad de código necesario y la única cosa que necesita ser duplciated es la función que se pasa como toGenericCoffeeList pero también no requiere de refactorización 200+ clases para implementar una interfaz.

Este enfoque puede ser adaptado dependiendo de lo que usted necesita hacer (no estoy exactamente seguro de lo que su método se supone que debe hacer, porque coffeeList nunca se utiliza y coinList nunca es declarado)

Puede asignar un Tipo a otro de mapeo de los campos, como este:

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())));

Este código supone que los tipos tienen propiedades con tipos similares pero con diferentes nombres. Así, el Diccionario con el correspondiente filednames.

Si los campos tienen el mismo nombre que usted podría, por supuesto, inferir las propiedades mediante la reflexión.

El uso es así:

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 });