Gruppe Liste der Objekte, die auf der Grundlage von Eigentum mit Linq?

Ich habe ein Objekt:

public class SiteInfo
        {
            public string Title { get; set; }
            public string URL { get; set; }
            public string Type { get; set; }      

        }

Dass ich mit um eine Liste zu erstellen:
var sites = new Liste();

        foreach (SPWeb site in web.GetSubwebsForCurrentUser())
        {
            string sitetype = getConfigurationKey(site, "siteType");
            //If sites have a site type then add to list
            if (sitetype != "*ERROR*" && sitetype != "*KEYNOTFOUND*")
            {
                SiteInfo s = new SiteInfo();
                s.Title = site.Title;
                s.URL = site.Url;
                s.Type = sitetype;

                sites.Add(s);
            }
        }
        //sort list by type
        sites.Sort((x, y) => string.Compare(x.Type, y.Type));

        //serialize and send..    
        JavaScriptSerializer serializer = new JavaScriptSerializer();
        StringBuilder sbJsonResults = new StringBuilder();
        serializer.Serialize(sites, sbJsonResults);
etc.....

Jedoch, was ich gerne tun würde, ist die Gruppe der Websites Geben vor der Serialisierung von Ihnen. Ist das möglich mit LINQ oder eine andere Methode.

  • OrderBy, vielleicht
  • Ich würde anfangen, durch das betrachten einer Liste aller LINQ-Methoden und sehen, wenn irgendwelche von Ihnen schauen, wie Sie beziehen sich möglicherweise auf die Gruppierung der Funktionen. Wenn Sie das tun, GroupBy sollte hoffentlich stechen Sie. -1 für eindeutig setzen, keine Forschung.
InformationsquelleAutor BlueBird | 2013-02-01
  1. 24

    Klingt es wie Sie wollen, so etwas wie:

    //No need to sort sites first
var grouped = sites.OrderBy(x => x.Type)
                   .GroupBy(x => x.Type);

    Dann einfach serialisieren grouped. Allerdings, ich weiß nicht Recht, was für ein IGrouping Aussehen wird, JSON... und der Typ in jedem Fall. Sie kann möchte etwas wie:

    var grouped = sites.OrderBy(x => x.Type)
                   .GroupBy(x => x.Type)
                   .Select(g => new { Type = g.Key,
                                      Sites = g.Select(site => new {
                                                           site.Title,
                                                           site.URL
                                                       } });

    Ich denke, die Ihnen würde ein schöner JSON-Struktur.

    InformationsquelleAutor Jon Skeet
  2. 2

    Diese

    var sites = new List<SiteInfo>()
{
    new SiteInfo(){Title="1",Type="a",URL="http://aaaa"},
    new SiteInfo(){Title="2",Type="b",URL="http://bbbb"},
    new SiteInfo(){Title="3",Type="a",URL="http://aaaa"},
    new SiteInfo(){Title="4",Type="b",URL="http://bbb"},
};

var json = new JavaScriptSerializer().Serialize(sites.GroupBy(s => s.Type));

    produzieren würde

    [
    [{"Title":"1","URL":"http://aaaa","Type":"a"},{"Title":"3","URL":"http://aaaa","Type":"a"}],
    [{"Title":"2","URL":"http://bbbb","Type":"b"},{"Title":"4","URL":"http://bbb","Type":"b"}]
]

    oder

    var json = new JavaScriptSerializer().Serialize(sites.GroupBy(s => s.Type)
                                                      .ToDictionary(x=>x.Key,x=>x));

    produzieren würde

    {
    "a":[{"Title":"1","URL":"http://aaaa","Type":"a"},{"Title":"3","URL":"http://aaaa","Type":"a"}],
    "b":[{"Title":"2","URL":"http://bbbb","Type":"b"},{"Title":"4","URL":"http://bbb","Type":"b"}]
}
    InformationsquelleAutor I4V
  3. 1

    Hier ist eine einfache Konsolenanwendung, die tut, was Sie wollen:

    static void Main(string[] args)
{
    List<SiteInfo> sites = new List<SiteInfo>()
    {
        new SiteInfo() { Title = "Site A", Type = "Whatever 2" },
        new SiteInfo() { Title = "Site B", Type = "Whatever 1" },
        new SiteInfo() { Title = "Site C", Type = "Whatever 1" },
        new SiteInfo() { Title = "Site D", Type = "Whatever 3" },
        new SiteInfo() { Title = "Site E", Type = "Whatever 3" }
    };

    var sitesGroupedByType =
        sites.GroupBy(s => s.Type).Select(g => new { Type = g.Key,
                                    Sites = g.Select(site => new
                                    {
                                          site.Title,
                                          site.URL
                                    })});

    foreach (var siteTypeGroup in sitesGroupedByType.OrderBy(g => g.Type))
    {
        foreach(var site in siteTypeGroup.Sites)
        {
            Console.WriteLine(string.Format("Type => {0}, Title => {1}",
                              siteTypeGroup.Type, site.Title));
        }
    }

    Console.ReadKey();
}

    Ausgabe:

    Type => Whatever 1, Title => Site B
Type => Whatever 1, Title => Site C
Type => Whatever 2, Title => Site A
Type => Whatever 3, Title => Site D
Type => Whatever 3, Title => Site E
    InformationsquelleAutor Leniel Maccaferri
Schreibe einen Kommentar