C# IEnumerable.Single方法代码示例

        protected override IEnumerable<ICommandFilter> BuildFilters(IEnumerable<CaptionFilter> filters)
        {
            yield return new CommandFilter("[property_type]=1");

            yield return new CommandFilter(string.Format("[cube_name]='{0}'"
                                                           , filters.Single(f => f.Target == Target.Perspectives).Caption
                                                           ));

            yield return new CommandFilter(string.Format("[dimension_unique_name]='[{0}]'"
                                                            , filters.Single(f => f.Target == Target.Dimensions).Caption
                                                            ));

            yield return new CommandFilter(string.Format("[hierarchy_unique_name]='[{0}].[{1}]'"
                                                , filters.Single(f => f.Target == Target.Dimensions).Caption
                                                , filters.Single(f => f.Target == Target.Hierarchies).Caption
                                                ));

            yield return new CommandFilter(string.Format("[level_unique_name]='[{0}].[{1}].[{2}]'"
                                                , filters.Single(f => f.Target == Target.Dimensions).Caption
                                                , filters.Single(f => f.Target == Target.Hierarchies).Caption
                                                , filters.Single(f => f.Target == Target.Levels).Caption
                                                ));

            var filter = filters.SingleOrDefault(f => f.Target == Target.Properties);
            if (filter!=null)
                yield return new CommandFilter(string.Format("[property_caption]='{0}'"
                                                           , filter.Caption
                                                           ));
        }

        public MessageBrokerConnection(IEnumerable<KeyValuePair<string, string>> rabbitEnvironment)
        {
            this.Server = rabbitEnvironment.Single(kvp => kvp.Key == "RabbitMQServer").Value;
            this.Port = Convert.ToInt32(rabbitEnvironment.Single(kvp => kvp.Key == "RabbitMQPort").Value, CultureInfo.InvariantCulture);
            this.VHost = rabbitEnvironment.Single(kvp => kvp.Key == "RabbitMQVHost").Value;

            this.Connection = this.CreateConnection();
            this.Connection.ConnectionShutdown += Connection_ConnectionShutdown;
        }

 public static GameStatus CreateFromEntity(Entity.Game entity, IEnumerable<Player> players)
 {
     return new Model.GameStatus(
                 players.Single(x => x.ID == entity.CurrentPlayerID),
                 players.Single(x => x.ID != entity.CurrentPlayerID),
                 players.FirstOrDefault(x => x.ID == entity.WinnerID),
                 entity.Active,
                 Model.GameMove.Empty,
                 Model.GameMoveResultType.Nothing,
                 null,
                 null);
 }

 public static ResourceSet GetResourceSet(IEnumerable<PlanetResource> resources)
 {
     var metal = resources.Single(r => r.ResourceId == (int)ResourceItem.Metal);
     var crystal = resources.Single(r => r.ResourceId == (int)ResourceItem.Crystal);
     var deiterium = resources.Single(r => r.ResourceId == (int)ResourceItem.Deiterium);
     return new ResourceSet
     {
         Metal = metal,
         Crystal = crystal,
         Deiterium = deiterium
     };
 }

        protected override IEnumerable<ICommandFilter> BuildFilters(IEnumerable<CaptionFilter> filters)
        {
            yield return new CommandFilter(string.Format("[routine_schema]='{0}'"
                                                            , filters.Single(f => f.Target == Target.Perspectives).Caption
                                                            ));

            var filter = filters.SingleOrDefault(f => f.Target == Target.Routines);
            if (filter != null)
                yield return new CommandFilter(string.Format("[routine_name]='{0}'"
                                                           , filters.Single(f => f.Target == Target.Routines).Caption
                                                           ));
        }

        public static KpisViewModel FromQueryModel(IEnumerable<Kpi> data)
        {
            if (data == null || data.Count() == 0)
                return new KpisViewModel();

            return new KpisViewModel()
            {
                Employees = data.Single(i => i.Id == "Employees").Value,
                GrossPay = data.Single(i => i.Id == "GrossPay").Value,
                Benefits = data.Single(i => i.Id == "Benefits").Value,
                NetPay = data.Single(i => i.Id == "NetPay").Value
            };
        }

        protected override IEnumerable<ICommandFilter> BuildFilters(IEnumerable<CaptionFilter> filters)
        {
            yield return new CommandFilter("len(measuregroup_name)>0");

            yield return new CommandFilter(string.Format("[cube_name]='{0}'"
                                    , filters.Single(f => f.Target == Target.Perspectives).Caption
                                    ));

            var mgFilter = filters.SingleOrDefault(f => f.Target == Target.MeasureGroups);
            if (mgFilter != null)
                yield return new CommandFilter(string.Format("[measuregroup_name]='{0}'"
                                                , filters.Single(f => f.Target == Target.MeasureGroups).Caption
                                                ));
        }

        protected override IEnumerable<ICommandFilter> BuildFilters(IEnumerable<CaptionFilter> filters)
        {
            yield return new CommandFilter(string.Format("[table_schema]='{0}'"
                                                            , filters.Single(f => f.Target == Target.Perspectives).Caption
                                                            ));

            yield return new CommandFilter(string.Format("[table_name]='{0}'"
                                                           , filters.Single(f => f.Target == Target.Tables).Caption
                                                           ));

            yield return new CommandFilter(string.Format("[column_name]='{0}'"
                                                           , filters.Single(f => f.Target == Target.Columns).Caption
                                                           ));
        }

        public ParameterSetResolver(Object target, IEnumerable<ParameterSet> parameterSets)
        {
            if (target == null)
            {
                throw Logger.Fatal.ArgumentNull(nameof(target));
            }

            if (parameterSets == null)
            {
                throw Logger.Fatal.ArgumentNull(nameof(parameterSets));
            }

            if (!parameterSets.Any())
            {
                throw Logger.Fatal.ArgumentEmptySequence(nameof(parameterSets));
            }

            DefaultParameterSet = parameterSets.Single(
                set => set.IsDefault
            );

            ParameterSets = parameterSets.ToImmutableDictionary(
                set => set.Name,
                ParameterSet.NameComparer
            );

            Target = target;
        }

        private void EnsureNonDuplicationOfParty(IEnumerable<DataCollectionParty> dataCollectionParties)
        {
            var newUrdmsParties = (from o in dataCollectionParties
                                    where o.Party.Id < 1 && !string.IsNullOrWhiteSpace(o.Party.UserId)
                                    select o.Party).ToList();
            if (newUrdmsParties.Count != 0)
            {
                var parties = _session.QueryOver<Party>().List();

                foreach (var newUrdmsParty in newUrdmsParties)
                {
                    var key = newUrdmsParty.UserId;
                    var existingParty = parties.Where(o => o.UserId == key).Take(1).FirstOrDefault();
                    if (existingParty != null)
                    {
                        existingParty.FirstName = newUrdmsParty.FirstName;
                        existingParty.LastName = newUrdmsParty.LastName;
                        existingParty.FullName = newUrdmsParty.FullName;
                        existingParty.Email = newUrdmsParty.Email;
                        var dataCollectionParty = dataCollectionParties.Single(o => o.Party.UserId == key);
                        dataCollectionParty.Party = existingParty;
                    }
                }
            }
        }

 public Expr Convolute(IContext context, IEnumerable<Expr> args)
 {
     var arg = args.Single();
     return EvalConvolution(arg) ??
         ConstantConvolution(arg) ??
         SpecificConvolution(context, arg);
 }

        IEnumerable<Price> IMarketPriceRepository.FetchPrices(IEnumerable<Item> items, SolarSystem system)
        {
            string urlData = "";
            foreach (Item item in items)
            {
                urlData += "typeid=" + item.ApiId + "&";
            }
            urlData += "usesystem=" + system.ApiId;

            XDocument doc = XDocument.Load(String.Format(String.Format(_priceURL, urlData)));
            IEnumerable<XElement> itemElements = doc.Element("evec_api").Element("marketstat").Elements("type");
            IList<Price> prices = new List<Price>();
            foreach (XElement itemElement in itemElements)
            {
                string itemApi = itemElement.Attribute("id").Value;
                Item currentItem = items.Single(i => i.ApiId.Equals(itemApi));
                Price price = new Price
                {
                    Item = currentItem,
                    SolarSystem = system,
                    Buy = Double.Parse(itemElement.Element("buy").Element("max").Value, CultureInfo.InvariantCulture),
                    Sell = Double.Parse(itemElement.Element("sell").Element("min").Value, CultureInfo.InvariantCulture),
                    Date = DateTime.Today
                };
                prices.Add(price);
            }
            return prices.AsEnumerable();
        }

        public static Position GetCentralPosition(IEnumerable<Position> geoCoordinates)
        {
            if (geoCoordinates.Count() == 1) {
                return geoCoordinates.Single ();
            }

            double x = 0;
            double y = 0;
            double z = 0;

            foreach (var geoCoordinate in geoCoordinates) {
                var latitude = geoCoordinate.Latitude * Math.PI / 180;
                var longitude = geoCoordinate.Longitude * Math.PI / 180;

                x += Math.Cos (latitude) * Math.Cos (longitude);
                y += Math.Cos (latitude) * Math.Sin (longitude);
                z += Math.Sin (latitude);
            }

            var total = geoCoordinates.Count();

            x = x / total;
            y = y / total;
            z = z / total;

            var centralLongitude = Math.Atan2 (y, x);
            var centralSquareRoot = Math.Sqrt (x * x + y * y);
            var centralLatitude = Math.Atan2 (z, centralSquareRoot);

            return new Position (
                centralLatitude * 180 / Math.PI,
                centralLongitude * 180 / Math.PI
            );
        }

 public override object SetIndex(Func<object> proceed, dynamic self, IEnumerable<object> keys, object value) {
     if (keys.Count() == 1) {
         var name = keys.Single().ToString();
         if (name.Equals("Id")) {
             // need to mutate the actual type
             var s = self as Shape;
             if (s != null) {
                 s.Id = System.Convert.ToString(value);
             }
             return value;
         }
         if (name.Equals("Classes")) {
             var args = Arguments.From(new[] { value }, Enumerable.Empty<string>());
             MergeClasses(args, self.Classes);
             return value;
         }
         if (name.Equals("Attributes")) {
             var args = Arguments.From(new[] { value }, Enumerable.Empty<string>());
             MergeAttributes(args, self.Attributes);
             return value;
         }
         if (name.Equals("Items")) {
             var args = Arguments.From(new[] { value }, Enumerable.Empty<string>());
             MergeItems(args, self);
             return value;
         }
     }
     return proceed();
 }

        public void UpdateSession(IEnumerable<EventSourceSettings> updatedEventSources)
        {
            Guard.ArgumentNotNull(updatedEventSources, "updatedEventSources");

            var eventSourceComparer = new EventSourceSettingsEqualityComparer(nameOnly: true);

            // updated sources
            foreach (var currentSource in this.eventSources.Intersect(updatedEventSources, eventSourceComparer).ToArray())
            {
                var updatedSource = updatedEventSources.Single(s => s.Name == currentSource.Name);
                if (updatedSource.Level != currentSource.Level ||
                    updatedSource.MatchAnyKeyword != currentSource.MatchAnyKeyword)
                {
                    TraceEventUtil.EnableProvider(this.session, updatedSource.EventSourceId, updatedSource.Level, updatedSource.MatchAnyKeyword, sendManifest: false);
                    currentSource.Level = updatedSource.Level;
                    currentSource.MatchAnyKeyword = updatedSource.MatchAnyKeyword;
                }
            }

            // new sources
            foreach (var newSource in updatedEventSources.Except(this.eventSources, eventSourceComparer).ToArray())
            {
                TraceEventUtil.EnableProvider(this.session, newSource.EventSourceId, newSource.Level, newSource.MatchAnyKeyword, sendManifest: true);
                this.eventSources.Add(newSource);
            }

            // removed sources
            foreach (var removedSource in this.eventSources.Except(updatedEventSources, eventSourceComparer).ToArray())
            {
                this.session.DisableProvider(removedSource.EventSourceId);
                this.eventSources.Remove(removedSource);
            }
        }