So verwenden Objekte anstelle von anonymen Typen

Question

Ich habe diese Abfragen LINQ:

 var type1 = (from ftr in db.TB_FTR 
           join mst in db.TB_MST on ftr.MST_ID equals mst.MST_ID 
           join trf in db.TYPE_ID on mst.TYPE_ID equals trf.ID 
           where ftr.CITY == city && ftr.COUNTY == county 
           select new MyType { City = ftr.CITY, County = ftr.COUNTY Type = trf.TYPE } 
      ).OrderBy(i => i.City); 

     var type2 = type1.GroupBy(i => new { i.City, i.County, i.Type }) 
      .Select(group => new { Name = group.Key, MyCount = group.Count() }) 
      .OrderBy(x => x.Name).ThenByDescending(x => x.MyCount) 
      .GroupBy(g => new { g.Name.City, g.Name.County }) 
      .Select(g => g.Select(g2 => 
      new { Name = new { g.Key.City, g.Key.County, g2.Name.Type }, g2.MyCount })).Take(1000).ToList(); 

Wie Sie die zweite Abfrage sehen einen anonymen Typ zurückgibt. Aber ich möchte diese Abfragen in einer Methode verwenden. Daher kann ich den anonymen Typ nicht zurückgeben. Wie kann ich Typ2 als nicht anonymen Typ festlegen?

Ich habe zwei Objekte darauf vorbereitet:

public class MyType 
{ 
     public string City { get; set; } 
     public string County { get; set; } 
     public string Type { get; set; } 
} 

public class ProcessedType 
{ 
public MyType Name {get; set;} 
public int MyCount {get; set;} 
} 

Aber ich konnte sie nicht richtig benutzen, weil ich sie wahrscheinlich in der Abfrage fehl am Platze. Können Sie mir helfen, damit ich die zweite Abfrage ein definiertes Objekt zurückgeben kann? Vielen Dank.

Answer 1

Sie haben dies in Ihrem Code:

new { Name = new { g.Key.City, g.Key.County, g2.Name.Type }, g2.MyCount } 

die noch anonyme Typen sind. Sie haben die tatsächlichen Typnamen in dort setzen sie in der Lage zurückzukehren:

new ProcessedType { Name = new MyType { g.Key.City, g.Key.County, g2.Name.Type }, g2.MyCount } 

an Ihrem Code sucht, sind Sie auch in der Lage sein sollten, die bestehenden Name zuweisen:

new ProcessedType { Name = g2.Name, g2.MyCount } 

Answer 2

Jedes Mal, wenn Sie Schreiben Sie newnicht gefolgt von einem Typ-Namen erstellen Sie eine Instanz eines anoymous Typ. Wie Sie richtig herausgefunden haben, können Sie diese Instanzen nicht an andere Methoden übergeben (effektiv können Sie können als sogar anonyme Typen erben von System.Object, aber auf diese Weise verlieren Sie alle Typ-Informationen Ihres tatsächlichen Typs).

In Ihrem Fall haben Sie bereits haben einen benannten Typ - ProcessedType. Anstatt also diese:

new { Name = new { g.Key.City, g.Key.County, g2.Name.Type }, g2.MyCount } 

Verwendung dieses:

new ProcessedType 
{ 
    Name = new MyType { g.Key.City, g.Key.County, g2.Name.Type }, 
    MyCount = g2.MyCount 
} 

Warum ist dieser Fehler? Nun, wie sollte der Compiler wissen, dass Sie tatsächlich auf ProcessedType statt auf jeden anderen Typ verweisen, der die gleichen Eigenschaften MyTypüe und MyCount haben kann? Es ist unmöglich für den Compiler, den Typ zu erraten, der hier abgeleitet werden soll, insbesondere gibt es keine implizite Konvertierung von einem anonymen Typ zu ProcessedType.

BEARBEITEN: die einzige Annahme, die mir in den Sinn kommt meine erste Abschnitt bezieht sich auf eine implizit typisierte Array, wo Sie auch new[] { 1 } schreiben können, die implizit als int[] deklariert werden.

Answer 3

Versuchen Sie, diese

var type2 = type1.GroupBy(i => new { i.City, i.County, i.Type }) 
     .Select(group => new { Name = group.Key, MyCount = group.Count() }) 
     .OrderBy(x => x.Name).ThenByDescending(x => x.MyCount) 
     .GroupBy(g => new { g.Name.City, g.Name.County }) 
     .Select(g => g.Select(g2 => 
     new ProcessedType{ Name = new MyType { City = g.Key.City, County = g.Key.County, Type = g2.Name.Type }, MyCount = g2.MyCount })).Take(1000).ToList();