C# IEnumerable.All方法代码示例

        public bool ValidAttributesFor(string table, string featureType, IEnumerable<FeatureActions> actions)
        {
            if (string.IsNullOrEmpty(featureType))
            {
                return false;
            }

            featureType = featureType.ToLower();

            if (featureType == "affected area" && actions == null)
            {
                return true;
            }

            if (string.IsNullOrEmpty(table))
            {
                return false;
            }

            table = table.ToLower();

            if (actions == null)
            {
                return false;
            }

            switch (table)
            {
                case "poly":
                    return
                        actions.All(
                            x =>
                                !string.IsNullOrEmpty(x.Action) &&
                                x.Treatments.All(t => !string.IsNullOrEmpty(t.Treatment)));
                case "point":
                    if (actions.Count() != 1)
                    {
                        return false;
                    }

                    if (new[] {"guzzler", "fish passage structure"}.Contains(featureType))
                    {
                        return actions.All(x => !string.IsNullOrEmpty(x.Action) &&
                                                 !string.IsNullOrEmpty(x.Type));
                    }

                    return actions.All(x => !string.IsNullOrEmpty(x.Description));
                case "line":
                    if (actions.Count() != 1)
                    {
                        return false;
                    }

                    return actions.All(x => !string.IsNullOrEmpty(x.Action) &&
                                                 !string.IsNullOrEmpty(x.Type));

            }

            return false;
        }

        /// <summary>
        /// Exports specified stops to serializable stop information.
        /// </summary>
        /// <param name="stops">The reference to the collection of stops to be exported.</param>
        /// <param name="capacitiesInfo">The reference to capacities info object to be used
        /// for retrieving custom order properties for stops.</param>
        /// <param name="orderCustomPropertiesInfo">The reference custom order properties info
        /// object.</param>
        /// <param name="addressFields">The reference to address fields object to be used
        /// for retrieving custom order properties for stops.</param>
        /// <param name="solver">The reference to VRPSolver to be used for retrieving
        /// curb approach policies for stops.</param>
        /// <param name="orderPropertiesFilter">Function returning true for custom order
        /// property names which should not be exported.</param>
        /// <returns>A reference to the collection of serializable stop information objects.
        /// </returns>
        public static IEnumerable<StopInfo> ExportStops(
            IEnumerable<Stop> stops,
            CapacitiesInfo capacitiesInfo,
            OrderCustomPropertiesInfo orderCustomPropertiesInfo,
            AddressField[] addressFields,
            IVrpSolver solver,
            Func<string, bool> orderPropertiesFilter = null)
        {
            Debug.Assert(stops != null);
            Debug.Assert(stops.All(stop => stop != null));
            Debug.Assert(stops.All(stop => stop.Route != null));
            Debug.Assert(capacitiesInfo != null);
            Debug.Assert(orderCustomPropertiesInfo != null);
            Debug.Assert(addressFields != null);

            if (!stops.Any())
            {
                return Enumerable.Empty<StopInfo>();
            }

            var capacityProperties = Order.GetPropertiesInfo(capacitiesInfo);
            var addressProperties = Order.GetPropertiesInfo(addressFields);
            var customProperties = Order.GetPropertiesInfo(orderCustomPropertiesInfo);

            var exportOrderProperties = _CreateExportOrderProperties(
                capacitiesInfo,
                orderCustomPropertiesInfo,
                addressFields,
                orderPropertiesFilter);

            // Make a dictionary for mapping routes to collection of sorted route stops.
            var routesSortedStops = stops
                .Select(stop => stop.Route)
                .Distinct()
                .ToDictionary(route => route, route => CommonHelpers.GetSortedStops(route));

            // Prepare result by exporting each stop individually.
            var settings = CommonHelpers.GetSolverSettings(solver);
            var result = stops
                .Select(stop => _ExportStop(
                    stop,
                    routesSortedStops[stop.Route],
                    exportOrderProperties,
                    addressProperties,
                    capacityProperties,
                    customProperties,
                    settings))
                .ToList();

            return result;
        }

        public static ValidationResult Create(RuleValidator validator, RuleValidatorContext context, IList<Object> parameterValues, object messageKey, IEnumerable<ValidationResult> nestedValidationResults = null)
        {
            string message = string.Empty;
            var messageService = new MessageService();

            if (String.IsNullOrEmpty(validator.Message))
            {
                var messageContext = new MessageContext(context, validator.GetType(), validator.Negate, validator.MessageStoreName, messageKey, validator.MessageFormatter);
                message = messageService.GetDefaultMessageAndFormat(messageContext, parameterValues);
            }
            else
            {
                //Since the message was supplied, don't get the default message from the store, just format it
                message = messageService.FormatMessage(validator.Message, context, parameterValues, validator.MessageFormatter);
            }

            //Override level if all the nested validation errors are Warnings

            if (nestedValidationResults != null && nestedValidationResults.All(vr => vr.Level == ValidationLevelType.Warn))
            {
                return new ValidationResult(context.PropertyInfo, message, ValidationLevelType.Warn, context.PropertyValue, nestedValidationResults);
            }
            else
            {
                return new ValidationResult(context.PropertyInfo, message, context.Level, context.PropertyValue, nestedValidationResults);
            }

            //return new ValidationResult(context.PropertyInfo, message, context.Level, context.PropertyValue, nestedValidationResults);
        }

        /// <summary>
        /// Create a span_near query.
        /// </summary>
        /// <param name="clauses">The span queries used to find documents.</param>
        public SpanNearQuery(IEnumerable<SpanQueryBase> clauses)
        {
            if (clauses == null || clauses.All(x => x == null))
                throw new ArgumentNullException("clauses", "SpanNearQuery requires at least one span query for clauses.");

            Clauses = clauses;
        }

		public IReadOnlyCollection<string> GetBlockWrapper(IEnumerable<string> code)
		{
			// If the code doesn't have any braces, surround it in a ruleset so that properties are valid.
			if (code.All(t => t.IndexOfAny(new[] { '{', '}' }) == -1))
				return new[] { ".GeneratedClass-" + Guid.NewGuid() + " {", "}" };
			return null;
		}

        /// <summary>
        /// Create a script_field value.
        /// </summary>
        /// <param name="fields">The fields to create, and the scripts to create them with.</param>
        public ScriptFieldRequest(IEnumerable<ScriptField> fields)
        {
            if (fields == null || fields.All(x => x == null))
                throw new ArgumentNullException("fields", "ScriptFields requires at least one field.");

            Fields = fields.Where(x => x != null);
        }

        static XDocument MergeXml(IEnumerable<XDocument> inputs)
        {
            // What assembly is this?
            var assemblyName = GetAssemblyName(inputs.First());

            if (!inputs.All(input => GetAssemblyName(input) == assemblyName))
            {
                throw new Exception("All input files must be for the same assembly.");
            }

            // Merge all the member documentation into a single list.
            var mergedMembers = from input in inputs
                                from member in input.Element("doc").Element("members").Elements()
                                where !IsNamespace(member)
                                select member;

            // Remove documentation tags that Intellisense does not use, to minimize the size of the shipping XML files.
            RemoveUnwantedElements(mergedMembers);

            // Generate new Intellisense XML.
            return new XDocument(
                new XElement("doc",
                    new XElement("assembly",
                        new XElement("name", assemblyName)
                    ),
                    new XElement("members",
                        mergedMembers
                    )
                )
            );
        }

        private void ValidateUniqueCurrency(IEnumerable<Currency> otherCurrencies, ref ModelStateDictionary modelStateDictionary)
        {
            if (otherCurrencies.All(oc => oc.CurrencyType != CurrencyType))
                return;

            modelStateDictionary.AddModelError(BaseCache.CurrencyTypeField, String.Format(ValidationResource.Global_OwnUnique_ErrorMessage, FieldResource.Global_Currency_Name));
        }

        public async void SavePackageSources(IEnumerable<IPackageSource> packageSources)
        {
            if (_busy)
                return;

            _busy = true;

            await Task.Run(() =>
            {
                foreach (var packageSource in _packageSources.ToArray())
                {
                    if (packageSources.All(n => n != packageSource))
                    {
                        Remove(packageSource);
                    }
                }

                foreach (var packageSource in packageSources.ToArray())
                {
                    if (!_packageSources.Any(n => n.Name == packageSource.Name && n.Location == packageSource.Location && n.Provider == packageSource.Provider))
                    {
                        Add(packageSource);
                    }
                }
            });

            Reload();

            _busy = false;
        }

        /// <summary>
        /// Create a suggest request body document.
        /// </summary>
        /// <param name="suggestors">Sets the fields to get suggests from.</param>
        public Suggest(IEnumerable<ISuggester> suggestors)
        {
            if (suggestors == null || suggestors.All(x => x == null))
                throw new ArgumentNullException("suggestors", "Suggest requires at least one field suggest.");

            Suggestors = suggestors.Where(x => x != null);
        }

 private static IEnumerable<Variant> GenerateVariants(Variant variant, Potter aBook, IEnumerable<Variant> alreadyGenerated)
 {
     return variant.Piles
         .Where(pile => !pile.Contains(aBook))
         .Select(pile => CreateNewVariant(variant, pile, aBook))
         .Where(newVariant => alreadyGenerated.All(v => !v.Equals(newVariant)));
 }

        /// <summary>
        /// Create the highlighter.
        /// </summary>
        /// <param name="fieldHighlighters">Sets the fields to highlight.</param>
        public Highlighter(IEnumerable<FieldHighlighter> fieldHighlighters)
        {
            if (fieldHighlighters == null || fieldHighlighters.All(x => x == null))
                throw new ArgumentNullException("fieldHighlighters", "Highlighter requires at least one field highlighter.");

            FieldHighlighters = fieldHighlighters.Where(x => x != null);
        }

		public void Prepend( IEnumerable<object> sut, object[] items )
		{
			var prepended = sut.Prepend( items );
			Assert.Equal( sut.Count() + items.Length, prepended.Count() );
			Assert.True( sut.All( x => prepended.Contains( x ) ) );
			Assert.True( items.All( x => prepended.Contains( x ) ) );
		}

        public Facets(IEnumerable<IFacet> facetGenerators)
        {
            if (facetGenerators == null || facetGenerators.All(x => x == null))
                throw new ArgumentNullException("facetGenerators", "Facets requires at least one facet generator.");

            FacetGenerators = facetGenerators.Where(x => x != null);
        }

        /// <summary>
        /// Create an aggregations object.
        /// </summary>
        /// <param name="aggregators">Sets the aggregations.</param>
        public Aggregations(IEnumerable<IAggregation> aggregators)
        {
            if (aggregators == null || aggregators.All(x => x == null))
                throw new ArgumentNullException("aggregators", "Aggregations requires at least one aggregator.");

            Aggregators = aggregators.Where(x => x != null);
        }