Kann nicht implizit konvertiert Typ 'System.Sammlungen.Generisches.Liste<AnonymousType#1>' zu 'System.Linq -.IQueryable<AnonymousType#2>'

Diese Abfrage kompiliert wird ohne Fehler:

            var _entityList = context.customer

                .Join(context.applications,
                cust => cust.cust_id,
                app => app.cust_id,
                (cust, app) => new { customer = cust, application = app })

                .Join(context.advices,
                cust => cust.application.app_id,
                sa => sa.app_id,
                (cust, sa) => new { customer = cust, advice = sa })

                .GroupBy(g => new { g.customer.customer.cust_id, g.customer.customer.cust_code, g.customer.customer.cust_name })
                .Select(g => new { cust_id = g.Key.cust_id, cust_code = g.Key.cust_code, cust_name = g.Key.cust_name })
                .ToList();

Wird, während Sie eine bedingte where-Klausel für die obige Abfrage gibt compile-Zeit-Typ-Konvertierungsfehler:

            var _entityList = context.customer

                .Join(context.applications,
                cust => cust.cust_id,
                app => app.cust_id,
                (cust, app) => new { customer = cust, application = app })

                .Join(context.advices,
                cust => cust.application.app_id,
                sa => sa.app_id,
                (cust, sa) => new { customer = cust, advice = sa });

            if (custcode != null && custcode != "")
                _entityList = _entityList.Where(e => e.customer.customer.cust_code == custcode);

            _entityList = _entityList
                .GroupBy(g => new { g.customer.customer.cust_id, g.customer.customer.cust_code, g.customer.customer.cust_name })
                .Select(g => new { cust_id = g.Key.cust_id, cust_code = g.Key.cust_code, cust_name = g.Key.cust_name })
                .ToList(); //error on this line

Kann nicht implizit konvertiert Art System.Collections.Generic.List<AnonymousType#1> zu System.Linq.IQueryable<AnonymousType#2>

Was bin ich?

Sind Sie sicher, dass e.Kunden.Kunden.cust_code und custcode sind die normalen strings?
_entityListis vom Typ IQueryable und Sie versuchen, zuweisen in der Liste?
Ich schlage vor, Sie erstellen eine Typ-Klasse und verwendet ihn, Ihr wählt
bis letzten _entityList = _entityList, _entityList ist IQueryable<Type1>. Mit Ihrem letzten linq erstellen Sie eine neue Art , erstellen Sie eine Liste aus und versuchen Sie es zu assing das Ergebnis IQueryable<Type1>. (Wie IQueryable<Type1> = List<Type2>)
ja, beide sind normale Zeichenketten. auch wenn ich die bedingte auskommentieren, wo, noch gibt Kompilierungsfehler.
sorry, habe ich nicht bekommen, Sie @ " ... erstellen Sie eine Liste aus und versuchen Sie zu ordnen ...."
siehe meine Antwort...

InformationsquelleAutor Khadim Ali | 2013-08-15

.net c#entity-framework entity-framework-4 linq-method-syntax

Betrachten Sie das folgende vereinfachte Beispiel:

var _entityList = Enumerable.Range(0, 1)
    .Select(i=>new {i1 =i, i2 = i+1});
_entityList = _entityList
    //.Select(i => new { i1 = i.i1, i2 = i.i2 })    //works
    //.Select(i => i)                               //works
    .Select(i => new { i })                         //fails
    .ToList();

In Ihrem ersten Szenario, es ist nur ein anonymer Typ beteiligt, daher _entityList ist ein List<AnonymousType#1>. In Ihrem 2. Szenario ändern Sie den zurückgegebenen Typ von einem anonymen Typ:

new { 
    customer = cust, 
    advice = sa 
}

anderen:

new { 
    cust_id = g.Key.cust_id, 
    cust_code = g.Key.cust_code, 
    cust_name = g.Key.cust_name 
}

so ein Konvertierungsfehler Auftritt.

Versuchen Sie dies:

var _entityList = context.customer
    .Join(context.applications,
            cust => cust.cust_id,
            app => app.cust_id,
            (cust, app) => new { customer = cust, application = app })
    .Join(context.advices,
            cust => cust.application.app_id,
            sa => sa.app_id,
            (cust, sa) => new { customer = cust, advice = sa })
    .Where(e => (custcode != null && custcode != "") 
        ? e.customer.customer.cust_code == custcode : true)
    .GroupBy(g => new { 
        g.customer.customer.cust_id, 
        g.customer.customer.cust_code, 
        g.customer.customer.cust_name })
    .Select(g => new { 
        cust_id = g.Key.cust_id, 
        cust_code = g.Key.cust_code, 
        cust_name = g.Key.cust_name })
    .ToList();

So, wie Sie dieses Problem umgehen? Ihre vereinfachte Beispiel scheint nur eine Verdeutlichung des Problems. Ist es nicht?
siehe meine aktualisierte Antwort.
Danke. Es funktionierte, und auch einen besseren Ansatz.
Sie sind willkommen, keep it up!

InformationsquelleAutor Alex Filipovici

Ändern

_entityList = _entityList
            .GroupBy(g => new { g.customer.customer.cust_id, g.customer.customer.cust_code, g.customer.customer.cust_name })
            .Select(g => new { cust_id = g.Key.cust_id, cust_code = g.Key.cust_code, cust_name = g.Key.cust_name })
            .ToList(); //error on this line

var result = _entityList
            .GroupBy(g => new { g.customer.customer.cust_id, g.customer.customer.cust_code, g.customer.customer.cust_name })
            .Select(g => new { cust_id = g.Key.cust_id, cust_code = g.Key.cust_code, cust_name = g.Key.cust_name })
            .ToList();

oh, ich habe es. es arbeitete. danke.

InformationsquelleAutor I4V

0

Wenn die When-Klausel verwenden Sie den Typ
```
(cust, sa) => new { customer = cust, advice = sa }.
```
Aber nach der änderung zu
```
new { cust_id = g.Key.cust_id, cust_code = g.Key.cust_code, cust_name = g.Key.cust_name }
```
Sind Sie verschiedene Arten zu compiler.
- Also, wie könnte es gelöst werden?
- Es hängt davon ab, was Sie wollen. Vielleicht gelten die wo kurz vor ToList(). So etwas .Where(e => e.cust_code == custcode) ich denke, dass könnte funktionieren.
- Es hat nicht funktioniert. In der Tat, es immer noch gibt Fehler nach dem entfernen des bedingten, wo insgesamt. Ich habe jedoch zu versuchen, andere Vorschläge nun.
InformationsquelleAutor Alessandro D'Andria

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.