C# ObservableCollection.OrderBy方法代码示例

        private void HandleGamesResponse(ObservableCollection<GameData> gamesCollection, Exception exception)
        {
            if (exception != null)
            {

            }
            else
            {
                ObservableCollection<GameData> temp = new ObservableCollection<GameData>(gamesCollection.OrderBy(g => g.UK_Name.Trim()));

                //var games = from game in temp
                //               group game by game.UK_Name.Trim().ToLower().Substring(0, 1) into c
                //               orderby c.Key
                //               select new Group<GameData>(c.Key, c);



                this.GamesList = temp;
                this.HaveGames = temp.Count() > 0;
            }
        }

        private void LoadDeviceManagers()
        {
            ObservableCollection<DeviceManagerSettings> deviceManagerList = new ObservableCollection<DeviceManagerSettings>();

            XmlElement managers = GetElement("devicemanagerlist");
            if (managers == null)
            {
                managers = GetElement("modbusmanagerlist");  // locate node to be replaced
                if (managers != null)
                {
                    XmlElement managersNew = AddElement(settings, "devicemanagerlist"); // create replacement
                    while(managers.HasChildNodes)  // locate old device manager nodes
                    {
                        XmlElement managerNew = AddElement(managersNew, "devicemanager"); // create new device manager node
                        XmlElement manager = (XmlElement)managers.FirstChild; // select old device manager
                        while (manager.HasChildNodes)
                            managerNew.AppendChild(manager.FirstChild);  // reparent old manager children to new manager
                        managers.RemoveChild(manager); // remove old device manager from old managers list
                    }
                    settings.RemoveChild(managers); // remove old device managers list
                    managers = managersNew; // install new device managers list
                }
            }
            if (managers == null)
                managers = AddElement(settings, "devicemanagerlist");
            else
                foreach(XmlElement manager in managers.ChildNodes)
                    RemoveExtraElements(manager, "serialport", 1);

            foreach (XmlNode e in managers.ChildNodes)
            {
                if (e.NodeType == XmlNodeType.Element && e.Name == "devicemanager")
                {
                    DeviceManagerSettings manager = new DeviceManagerSettings(this, (XmlElement)e);
                    deviceManagerList.Add(manager);
                }
            }

            IEnumerable<DeviceManagerSettings> sorted = deviceManagerList.OrderBy(mms => ((mms.Enabled ? "0" : "1") + mms.Description));

            _DeviceManagerList = new ObservableCollection<DeviceManagerSettings>();
            foreach (DeviceManagerSettings im in sorted)
                _DeviceManagerList.Add(im);

            _AllDevicesList = new ObservableCollection<DeviceManagerDeviceSettings>();
            _AllConsolidationDevicesList = new ObservableCollection<DeviceManagerDeviceSettings>();
            RefreshAllDevices();
            // consolidations must be registered after all devices from all managers are in the list
            foreach (DeviceManagerDeviceSettings dev in _AllDevicesList)
                dev.RegisterConsolidations();
        }

        /// <summary>
        /// Order a collection of items by the right sort
        /// </summary>
        /// <param name="items">Collection of items</param>
        /// <returns>Ordered collection</returns>
        private ObservableCollection<Item> OrderItems()
        {
            // create a new collection without any system itemtypes (which are used for section headings)
            var sorted = new ObservableCollection<Item>();
            foreach (var i in list.Items)
                if (i.ItemTypeID != SystemItemTypes.System)
                    sorted.Add(i);

            // order the folder by the correct fields
            switch (OrderBy)
            {
                case FieldNames.DueDate:
                    sorted = sorted.OrderBy(t => t.Complete).ThenBy(t => !t.IsList).ThenBy(t => t.DueSort).ThenBy(t => t.Name).ToObservableCollection();
                    break;
                case FieldNames.Priority:
                    sorted = sorted.OrderBy(t => t.Complete).ThenBy(t => !t.IsList).ThenByDescending(t => t.PrioritySort).ThenBy(t => t.Name).ToObservableCollection();
                    break;
                case FieldNames.Name:
                    sorted = sorted.OrderBy(t => t.Complete).ThenBy(t => !t.IsList).ThenBy(t => t.Name).ToObservableCollection();
                    break;
                case FieldNames.Address:
                    sorted = sorted.OrderBy(t => t.Address).ThenBy(t => !t.IsList).ThenBy(t => t.Name).ToObservableCollection();
                    break;
                case FieldNames.Phone:
                    sorted = sorted.OrderBy(t => t.Phone).ThenBy(t => !t.IsList).ThenBy(t => t.Name).ToObservableCollection();
                    break;
                case FieldNames.Email:
                    sorted = sorted.OrderBy(t => t.Email).ThenBy(t => !t.IsList).ThenBy(t => t.Name).ToObservableCollection();
                    break;
                case FieldNames.Complete:
                    sorted = sorted.OrderBy(t => t.Complete).ThenBy(t => !t.IsList).ThenBy(t => t.Name).ToObservableCollection();
                    break;
                case FieldNames.Category:
                    sorted = sorted.OrderBy(t => t.Complete).ThenBy(t => !t.IsList).ThenBy(t => t.Category).ThenBy(t => t.Name).ToObservableCollection();
                    break;
                case null:
                    sorted = sorted.OrderBy(t => t.Complete).ThenBy(t => !t.IsList).ThenBy(t => t.SortOrder).ToObservableCollection();
                    break;
                default:
                    sorted = sorted.OrderBy(t => t.Complete).ThenBy(t => !t.IsList).ThenBy(t => t.Name).ToObservableCollection();
                    break;
            }

            // if we aren't categorizing then there is no need to create section headings
            if (!Categorize())
                return sorted;

            // insert separators for section headings
            string separator = null;
            var finalList = new ObservableCollection<Item>();
            foreach (var item in sorted)
            {
                ItemType itemType = App.ViewModel.ItemTypes.Single(it => it.ID == item.ItemTypeID);
                string displayType = DisplayTypes.Text;
                string value = null;
                if (itemType.Fields.Any(f => f.Name == OrderBy))
                {
                    Field field = itemType.Fields.Single(f => f.Name == OrderBy);
                    FieldValue fv = item.GetFieldValue(field, false);
                    displayType = field.DisplayType;
                    value = fv != null ? fv.Value : null;
                }
                string currentSectionHeading = item.Complete == true ? "completed" : FormatSectionHeading(displayType, value);
                currentSectionHeading = item.IsList == true ? "lists" : currentSectionHeading;
                if (currentSectionHeading != separator)
                {
                    finalList.Add(new Item() { Name = currentSectionHeading, ItemTypeID = SystemItemTypes.System }); // System itemtype designates separator
                    separator = currentSectionHeading;
                }
                finalList.Add(item);
            }

            return finalList;
        }

 /// <summary>
 /// Order a collection of tasks by the right sort
 /// </summary>
 /// <param name="tasks">Collection of tasks</param>
 /// <returns>Ordered collection</returns>
 private ObservableCollection<Task> OrderTasks(ObservableCollection<Task> tasks)
 {
     // order the list by the correct fields
     switch (OrderBy)
     {
         case "due":
             return tasks.OrderBy(t => t.Complete).ThenBy(t => t.DueSort).ThenBy(t => t.Name).ToObservableCollection();
         case "priority": // by pri
             return tasks.OrderBy(t => t.Complete).ThenByDescending(t => t.PriorityIDSort).ThenBy(t => t.Name).ToObservableCollection();
         case "name": // by name
             return tasks.OrderBy(t => t.Complete).ThenBy(t => t.Name).ToObservableCollection();
     }
     return null;
 }

        private ObservableCollection<string> SortData(ObservableCollection<string> columnDataList, bool IsNumericData)
        {
            ObservableCollection<string> returnedData = new ObservableCollection<string>();
            if (IsNumericData)
            {
                List<double> numberList = new List<double>();
                foreach (string numText in columnDataList)
                {
                    double num = 0;
                    if (double.TryParse(numText, out num))
                    {
                        numberList.Add(num);
                    }
                }

                foreach (double number in numberList.OrderBy(x => x).ToList())
                {
                    returnedData.Add(number.ToString());
                }
            }
            else
            {
                foreach (string text in columnDataList.OrderBy(x=>x).ToList())
                {
                    returnedData.Add(text);
                }
            }
            return returnedData;
        }

 public override ObservableCollection<ClaimDetailDto> GetSortedClaimDetailDtos(ObservableCollection<ClaimDetailDto> claimDetailDtos)
 {
     return claimDetailDtos.OrderBy(a => (a.Data as IClaimDetailData).ClaimDetailSortOrder)
         .ThenBy(a => int.Parse((a.Data as IClaimDetailData).ClaimDetailReference)).ToObservableCollection();
 }

        private void LoadAsync(string txiFile)
        {
            var doc = XDocument.Load(txiFile);

            var shiftCount = doc.Element("Schichten").Descendants().Count();
            int verarb = 0;

            Schichten = new ObservableCollection<Schicht>();

            // Parallel.ForEach(doc.Element("Schichten").Elements("Schicht"), ig =>
            foreach (var ig in doc.Element("Schichten").Elements("Schicht"))
            {
                var i = ig;
                var schicht = new Schicht()
                                  {
                                      Index = i.AttValue<int>("Index"),
                                      AbrechnungFertig = i.AttValue<bool>("AbrechnungFertig"),
                                      Abgerechnet = i.AttValue<bool>("IstAbgerechnet"),
                                      Anfang = i.AttValue<DateTime>("Anfang"),
                                      Ende = i.AttValue<DateTime>("Ende"),
                                      GeldVorher = i.AttValue<float>("GeldVorher"),
                                      GeldNachher = i.AttValue<float>("GeldNachher"),
                                      GeliehenesWechselgeld = i.AttValue<float>("GeliehenesWechselgeld")
                                  };

                foreach (var j in i.Elements("Sonderausgabe"))
                {
                    schicht.Sonderausgaben.Add(j.AttValue<float>("Wert"));
                }

                foreach (var j in i.Elements("Privatausgabe"))
                {
                    var priv = new Privatausgabe { Index = j.AttValue<int>("Index"), Bemerkung = j.AttValue<string>("Bemerkung") ?? "n/a", Wert = j.AttValue<double>("Wert") };
                    schicht.Privatausgaben.Add(priv);
                }

                foreach (var n in i.Elements("Fahrzeug"))
                {
                    var fzg = new Fahrzeug
                                  {
                                      Index = n.AttValue<int>("Index"),
                                      Nummer = n.AttValue<int>("Nummer"),
                                      TotalAnfang = n.AttValue<Single>("TotalAnfang"),
                                      TotalEnde = n.AttValue<Single>("TotalEnde"),
                                      BesetztAnfang = n.AttValue<Single>("BesetztAnfang"),
                                      BesetztEnde = n.AttValue<Single>("BesetztEnde"),
                                      TourenAnfang = n.AttValue<int>("TourenAnfang"),
                                      TourenEnde = n.AttValue<int>("TourenEnde"),
                                      PreisAnfang = n.AttValue<Single>("EinnahmenAnfang"),
                                      PreisEnde = n.AttValue<Single>("EinnahmenEnde"),
                                  };

                    schicht.Fahrzeuge.Add(fzg);

                    foreach (var p in n.Elements("Fahrt"))
                    {
                        var _kmV = p.Attribute("km").Value;
                        var _km = (int?)p.AttValue<int>("km");
                        var _apesV = p.Attribute("APES").Value;
                        var _apes = (float?)p.AttValue<Single>("APES");
                        var _priceV = p.Attribute("Preis").Value;
                        var _price = (float?)p.AttValue<Single>("Preis");
                        var ft = new Fahrt
                                     {
                                         Index = p.AttValue<int>("Index"),
                                         Description = p.AttValue<string>("Bemerkung"),
                                         KM = (_kmV == "NULL") ? null : _km,
                                         APES = (_apesV == "NULL") ? null : _apes,
                                         Preis = (_priceV == "NULL") ? null : _price,
                                         Rechnungsfahrt = p.AttValue<bool>("IstRechnungsfahrt")
                                     };
                        this.OnProgress(ref verarb, shiftCount);
                        fzg.Fahrten.Add(ft);
                    }
                    this.OnProgress(ref verarb, shiftCount);
                }

                UIDispatcher.Invoke(new Action(() => this.Schichten.Add(schicht)));

                this.OnProgress(ref verarb, shiftCount);
            }
            int uoSIdx = 1;
            foreach (var item in Schichten.OrderBy(p => p.Anfang))
            {
                if (item.Index == 0)
                {
                    while (Schichten.Any(p => p.Index != 0 && p.Index == uoSIdx)) uoSIdx++;
                    item.Index = uoSIdx;
                    item.Parent = this;
                }
                item.ReindexVehicles();
            }
        }