Konstanter Wert vom Typ kann nicht erstellt werden In diesem Kontext werden nur primitive Typen oder Aufzählungstypen unterstützt

Ich erhalte diesen Fehler für die folgende Abfrage

Es kann kein konstanter Wert vom Typ erstellt werden API.Models.PersonProtocol. In diesem Zusammenhang werden nur primitive Typen oder Aufzählungstypen unterstützt

ppCombinedunten ist ein IEnumerableObjekt von PersonProtocolType, das durch Concat von 2 PersonProtocolListen aufgebaut ist.

Warum scheitert das? Können wir die LINQ- JOINKlausel nicht innerhalb SELECTvon a verwenden JOIN?

var persons = db.Favorites
    .Where(x => x.userId == userId)
    .Join(db.Person, x => x.personId, y => y.personId, (x, y) =>
        new PersonDTO
        {
            personId = y.personId,
            addressId = y.addressId,                   
            favoriteId = x.favoriteId,
            personProtocol = (ICollection<PersonProtocol>) ppCombined
                .Where(a => a.personId == x.personId)
                .Select( b => new PersonProtocol()
                 {
                     personProtocolId = b.personProtocolId,
                     activateDt = b.activateDt,
                     personId = b.personId
                 })
        });

Dies kann nicht funktionieren, da ppCombinedes sich um eine Sammlung von Objekten im Speicher handelt und Sie einen Datensatz in der Datenbank nicht mit einem anderen Datensatz im Speicher verknüpfen können. Sie können stattdessen versuchen, die gefilterten Elemente personProtocolder ppCombinedSammlung im Speicher zu extrahieren, nachdem Sie die anderen Eigenschaften aus der Datenbank abgerufen haben:

var persons = db.Favorites
    .Where(f => f.userId == userId)
    .Join(db.Person, f => f.personId, p => p.personId, (f, p) =>
        new // anonymous object
        {
            personId = p.personId,
            addressId = p.addressId,   
            favoriteId = f.favoriteId,
        })
    .AsEnumerable() // database query ends here, the rest is a query in memory
    .Select(x =>
        new PersonDTO
        {
            personId = x.personId,
            addressId = x.addressId,   
            favoriteId = x.favoriteId,
            personProtocol = ppCombined
                .Where(p => p.personId == x.personId)
                .Select(p => new PersonProtocol
                {
                    personProtocolId = p.personProtocolId,
                    activateDt = p.activateDt,
                    personId = p.personId
                })
                .ToList()
        });

Ich weiß nicht, ob jemand danach sucht. Ich hatte das gleiche Problem. Eine Auswahl in der Abfrage und dann das Wo (oder Verbinden) und die Verwendung der Auswahlvariablen lösten das Problem für mich. (Problem war in der Sammlung "Reintegraties" für mich)

query.Select(zv => new
            {
                zv,
                rId = zv.this.Reintegraties.FirstOrDefault().Id
            })
            .Where(x => !db.Taken.Any(t => t.HoortBijEntiteitId == x.rId
                                             && t.HoortBijEntiteitType == EntiteitType.Reintegratie
                                             && t.Type == TaakType))
            .Select(x => x.zv);

hoffe das hilft jedem.

In meinem Fall konnte ich das Problem folgendermaßen beheben:

Ich habe meinen Code geändert:

var r2 = db.Instances.Where(x => x.Player1 == inputViewModel.InstanceList.FirstOrDefault().Player2 && x.Player2 == inputViewModel.InstanceList.FirstOrDefault().Player1).ToList();

Dazu:

var p1 = inputViewModel.InstanceList.FirstOrDefault().Player1;
var p2 = inputViewModel.InstanceList.FirstOrDefault().Player2;
var r1 = db.Instances.Where(x => x.Player1 == p1 && x.Player2 == p2).ToList();

Es lohnt sich hinzuzufügen, da das Codebeispiel des OP nicht genügend Kontext bietet, um das Gegenteil zu beweisen, aber ich habe diesen Fehler auch für den folgenden Code erhalten:

public RetailSale GetByRefersToRetailSaleId(Int32 refersToRetailSaleId)
{
    return GetQueryable()
        .FirstOrDefault(x => x.RefersToRetailSaleId.Equals(refersToRetailSaleId));
}

Anscheinend kann ich Int32.Equalsin diesem Zusammenhang kein Int32 mit einem primitiven Int vergleichen. Ich musste (sicher) dazu wechseln:

public RetailSale GetByRefersToRetailSaleId(Int32 refersToRetailSaleId)
{
    return GetQueryable()
      .FirstOrDefault(x => x.RefersToRetailSaleId == refersToRetailSaleId);
}

Fügen Sie einfach AsEnumerable () und ToList () hinzu, damit es so aussieht

db.Favorites
    .Where(x => x.userId == userId)
    .Join(db.Person, x => x.personId, y => y.personId, (x, y).ToList().AsEnumerable()

ToList().AsEnumerable()