C# IReadOnlyCollection.Any方法代码示例

        public void AllMatchingUsersAreRetrieved()
        {
            const string customPropertyName = "name";
            const string customPropertyValue = "value";
            var customProperties = new List<KeyValuePair<string, string>> { new KeyValuePair<string, string>(customPropertyName, customPropertyValue) };
            AddActiveDirectoryUser(Guid.NewGuid(), "Tim", "timber", false, customProperties);
            AddActiveDirectoryUser(Guid.NewGuid(), "Tom", "tomcat", false, customProperties);
            AddActiveDirectoryUser(Guid.NewGuid(), "John", "johnsnow");

            result = sut.GetUsers(customPropertyName, customPropertyValue, AccountType.ActiveDirectory);

            Assert.AreEqual(2, result.Count);
            Assert.IsTrue(result.Any(u => u.Name.Equals("Tom")));
            Assert.IsTrue(result.Any(u => u.Name.Equals("Tim")));
        }

        public void GenerateNewTypes(string providerName, IReadOnlyCollection<DataTypeDescriptor> dataTypeDescriptors, bool makeAFlush)
        {
            Verify.ArgumentNotNullOrEmpty(providerName, "providerName");
            Verify.ArgumentNotNull(dataTypeDescriptors, "dataTypeDescriptors");

            foreach (var dataTypeDescriptor in dataTypeDescriptors)
            {
                UpdateWithNewMetaDataForeignKeySystem(dataTypeDescriptor);
                UpdateWithNewPageFolderForeignKeySystem(dataTypeDescriptor, false);
            }

            var types = DataTypeTypesManager.GetDataTypes(dataTypeDescriptors);
            
            foreach (var dataTypeDescriptor in dataTypeDescriptors)
            {
                dataTypeDescriptor.TypeManagerTypeName = TypeManager.SerializeType(types[dataTypeDescriptor.DataTypeId]);
            }

            DynamicTypeManager.CreateStores(providerName, dataTypeDescriptors, makeAFlush);

            if (makeAFlush && dataTypeDescriptors.Any(d => d.IsCodeGenerated))
            {
                CodeGenerationManager.GenerateCompositeGeneratedAssembly(true);
            }
        }

		private static Func<IMessage, Task<object>> GenerateNext(
			BusSettings busSettings,
			IDependencyScope dependencyScope,
			IReadOnlyCollection<Type> pipelineHandlerTypes,
			IEnumerable<Type> leftHandlerTypes
			)
		{
			return (async message => {

				if (message == null) {
					throw new NullMessageTypeException();
				}

				if (!pipelineHandlerTypes.Any()) {
					return await RunLeafHandlers(busSettings, dependencyScope, leftHandlerTypes, message);
				}

				var head = pipelineHandlerTypes.First();
				var nextHandler = (IPipelineHandler)dependencyScope.GetService(head);

				var tail = pipelineHandlerTypes.Skip(1).ToList();
				var nextFunction = GenerateNext(busSettings, dependencyScope, tail, leftHandlerTypes);

				return await nextHandler.Handle(nextFunction, message);
			});
		}

        public static Generator ToHTML5(this Element self, IReadOnlyCollection<ITag> inners, Generator generator)
        {
            var tags = new Generator(generator.Indention + 1);
            inners.ForEach(x => x.ToHTML5(tags));
            var annotations = String.Concat(self.Annotations.Select(x => x.ToHTML5()));

            var isText = inners.Count == 1 && inners.Single() is Text;
            if (!inners.Any())
            {
                if (self.Name.ToLower() == "script")
                    generator.Write("<{0}{1}></{0}>", self.Name, annotations);
                else
                    generator.Write("<{0}{1} />", self.Name, annotations);
            }
            else if (isText)
            {
                generator.Write("<{0}{1}>{2}</{0}>", self.Name, annotations, tags.Generate().Trim());
            }
            else
            {
                generator.Write("<{0}{1}>{2}", self.Name, annotations, tags.Generate());
                generator.Write("</{0}>", self.Name);
            }
            return generator;
        }

 public void EnsurePolicyIsUpdated(IReadOnlyCollection<string> config)
 {
     if (config.Any())
     {
         var policy = new SnsPolicy(config);
         policy.Save(Arn, Client);
     }
 }

 private void Process(IReadOnlyCollection<IScriptable> items, string type)
 {
     if (!items.Any())
         return;
     Console.WriteLine($"{items.Count} {type}");
     foreach (var item in items)
         scripter.ScriptToDisk(item, type);
 }

 public CombinedNodeCommandWrapper(IViewModelServiceProvider serviceProvider, string name, IReadOnlyCollection<ModelNodeCommandWrapper> commands)
     : base(serviceProvider)
 {
     if (commands == null) throw new ArgumentNullException(nameof(commands));
     if (commands.Count == 0) throw new ArgumentException(@"The collection of commands to combine is empty", nameof(commands));
     if (commands.Any(x => !ReferenceEquals(x.NodeCommand, commands.First().NodeCommand))) throw new ArgumentException(@"The collection of commands to combine cannot contain different node commands", nameof(commands));
     this.commands = commands;
     Name = name;
 }

        public EventAggregator(IList<IEvent> aggregatedEvents)
        {
            _supportedEvents = GetType().GenericTypeArguments;

            if (!_supportedEvents.Any())
            {
                throw new NotSupportedException();
            }

            AggregatedEvents = aggregatedEvents;
        }

        public void AccountTypeDoesNotMatch()
        {
            const string customPropertyName = "name";
            const string customPropertyValue = "value";
            var customProperties = new List<KeyValuePair<string, string>> { new KeyValuePair<string, string>(customPropertyName, customPropertyValue) };
            AddActiveDirectoryUser(Guid.NewGuid(), "Tim", "timber", false, customProperties);

            result = sut.GetUsers(customPropertyName, customPropertyValue, AccountType.Federated);

            Assert.IsFalse(result.Any());
        }

        private void Handle(IReadOnlyCollection<RecordDelayCommand> commands)
        {
            if (!commands.Any())
            {
                return;
            }

            var eldestEventTime = commands.Min(x => x.EventTime);
            var delta = DateTime.UtcNow - eldestEventTime;
            _telemetryPublisher.Publish<StatisticsProcessingDelayIdentity>((long)delta.TotalMilliseconds);
        }

        internal virtual async Task SendMessagesAsync(IReadOnlyCollection<Message> kafkaMessages)
        {
            Contract.Requires<ArgumentException>(kafkaMessages != null && kafkaMessages.Any());

            var producer = await this.GetOrCreateKafkaProducerAsync().ConfigureAwait(false);

            foreach (var kafkaMessage in kafkaMessages)
            {
                producer.Send(kafkaMessage);
            }
        }

        private void Handle(IReadOnlyCollection<RecordDelayCommand> commands)
        {
            if (!commands.Any())
            {
                return;
            }

            var eldestEventTime = commands.Min(x => x.EventTime);
            var delta = DateTime.UtcNow - eldestEventTime;
            _eventLogger.Log(new IEvent[] { new BatchProcessedEvent(DateTime.UtcNow) });
            _telemetryPublisher.Publish<PrimaryProcessingDelayIdentity>((long)delta.TotalMilliseconds);
        }

        public async Task<bool> WriteAsync(IReadOnlyCollection<EventData> events, CancellationToken cancellationToken)
        {
            Guard.ArgumentNotNull(events, "events");

            if(!events.Any())
            {
                return false;
            }

            try
            {
                string logMessages;
                using (var serializer = new ElasticSearchEventDataSerializer(_index, _type))
                {
                    logMessages = serializer.Serialize(events);
                }

                using (var client = new HttpClient())
                {
                    var resp = await _retryPolicy.ExecuteAsync(async () =>
                    {
                        var content = new StringContent(logMessages);
                        content.Headers.ContentType = new MediaTypeHeaderValue("application/json");

                        var response = await client.PostAsync(_elasticsearchUrl, content, cancellationToken).ConfigureAwait(false);

                        if(response.StatusCode != HttpStatusCode.OK)
                        {
                            WarmStorageEventSource.Log.WriteToElasticSearchFailedPerf(events.Count);

                            await HandleErrorResponse(response);
                        }

                        //This is for retry strategy. If response is not successful it will raise an exception catched by the retry strategy.
                        response.EnsureSuccessStatusCodeEx();

                        WarmStorageEventSource.Log.WriteToElasticSearchSuccessPerf(events.Count);

                        return response;
                    });
                }

                return true;
            }
            catch (Exception ex)
            {
                //If a non-transient error has ocurred or if we ran out of attempts.

                WarmStorageEventSource.Log.WriteToElasticSearchError(ex);

                return false;
            }
        }

 public CombinedNodeCommandWrapper(IViewModelServiceProvider serviceProvider, string name, string observableNodePath, ObservableViewModelIdentifier identifier, IReadOnlyCollection<ModelNodeCommandWrapper> commands)
     : base(serviceProvider, null)
 {
     if (commands == null) throw new ArgumentNullException("commands");
     if (commands.Count == 0) throw new ArgumentException(@"The collection of commands to combine is empty", "commands");
     if (commands.Any(x => !ReferenceEquals(x.NodeCommand, commands.First().NodeCommand))) throw new ArgumentException(@"The collection of commands to combine cannot contain different node commands", "commands");
     service = serviceProvider.Get<ObservableViewModelService>();
     this.commands = commands;
     this.name = name;
     this.identifier = identifier;
     this.serviceProvider = serviceProvider;
     ObservableNodePath = observableNodePath;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="Addition"/> class.
        /// </summary>
        /// <param name="start">The start.</param>
        /// <param name="newContent">The new content.</param>
        /// <exception cref="System.ArgumentOutOfRangeException"></exception>
        /// <exception cref="System.ArgumentNullException"></exception>
        /// <exception cref="System.ArgumentException"></exception>
        internal Addition(int start, IReadOnlyCollection<string> newContent)
        {
            if (newContent == null)
            {
                throw new ArgumentNullException();
            }

            if (!newContent.Any())
            {
                throw new ArgumentException();
            }

            Initialize(start, 0, newContent);
        }