C# IReadOnlyCollection.Select方法代码示例

		public static void RegisterHandlersWithAutofac(ContainerBuilder containerBuilder, IReadOnlyCollection<MessageRegistration> registrations)
		{
			var handlers = registrations.Select(x => x.Handler).Distinct();
			var piplelineHandlers = registrations.Select(x => x.Pipeline).Distinct().SelectMany(x => x).Distinct();

			RegisterLeafHandlers(containerBuilder, handlers);
			RegisterPipelineHandlers(containerBuilder, piplelineHandlers);

			foreach (var registration in registrations)
			{
				if (registration.Dependancies.Any())
				{
					foreach (var dependancy in registration.Dependancies)
					{
						containerBuilder.RegisterType(dependancy).AsSelf();
					}
				}

				if (registration.ScopedDependancies.Any())
				{
					foreach (var dependancy in registration.ScopedDependancies)
					{
						containerBuilder.RegisterType(dependancy).AsSelf().AsImplementedInterfaces().InstancePerLifetimeScope();
					}
				}
			}
		}

        // Internal for testing
        internal string Parse(string code, IReadOnlyCollection<Type> moduleTypes, IEnumerable<string> namespaces)
        {
            // Rewrite the lambda shorthand expressions
            SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(code, new CSharpParseOptions(kind: SourceCodeKind.Script));
            LambdaRewriter lambdaRewriter = new LambdaRewriter(moduleTypes.Select(x => x.Name));
            SyntaxNode syntaxNode = lambdaRewriter.Visit(syntaxTree.GetRoot());

            // "Lift" class and method declarations
            LiftingWalker liftingWalker = new LiftingWalker();
            liftingWalker.Visit(syntaxNode);

            // Get the using statements
            string usingStatements = string.Join(Environment.NewLine, namespaces.Select(x => "using " + x + ";"));

            // Get the methods to instantiate each module
            Dictionary<string, string> moduleNames = new Dictionary<string, string>();
            string moduleMethods = string.Join(Environment.NewLine,
                moduleTypes.Select(x => GenerateModuleConstructorMethods(x, moduleNames)));

            // Return the fully parsed script
            return 
                [email protected]"// Generated: bring all module namespaces in scope
                {usingStatements}

                // Input: using directives
                {liftingWalker.UsingDirectives}

                public class {ScriptClassName} : ScriptBase
                {{
                    public {ScriptClassName}(Engine engine) : base(engine) {{ }}

                    public override void Run()
                    {{
                        // Input: script code
{liftingWalker.ScriptCode}
                    }}

                    // Input: lifted methods
{liftingWalker.MethodDeclarations}

                    // Generated: methods for module instantiation
                    {moduleMethods} 
                }}

                // Input: lifted object declarations
{liftingWalker.TypeDeclarations}

                public static class ScriptExtensionMethods
                {{
                    // Input: lifted extension methods
{liftingWalker.ExtensionMethodDeclarations}
                }}";
        }

        public IndexCollection(IReadOnlyCollection<Index> latest,
                                    IndexCollection previous,
                                    FileInfo info,
                                    Encoding encoding)
        {
            Info = info;
            Encoding = encoding;
            Count = latest.Select(idx => idx.LineCount).Sum();
            Indicies = latest.ToArray();
            Diff = Count - (previous?.Count ?? 0);
            
            //need to check whether
            if (previous == null)
            {
                ChangedReason = LinesChangedReason.Loaded;
                TailInfo = new TailInfo(latest.Max(idx => idx.End));
            }
            else
            {
                var mostRecent = latest.OrderByDescending(l => l.TimeStamp).First();
                ChangedReason = mostRecent.Type == IndexType.Tail
                                ? LinesChangedReason.Tailed
                                : LinesChangedReason.Paged;

             TailInfo = new TailInfo(previous.Indicies.Max(idx => idx.End));
            }
        }

        private void Handle(IReadOnlyCollection<IAggregateCommand> commands)
        {
            var aggregateRootTypes = commands.Select(x => x.AggregateRootType).ToArray();
            var actors = _aggregateActorFactory.Create(aggregateRootTypes);

            // TODO: Can agreggate actors be executed in parallel? See https://github.com/2gis/nuclear-river/issues/76
            foreach (var actor in actors)
            {
                var actorName = actor.GetType().GetFriendlyName();

                using (var transaction = new TransactionScope(
                    TransactionScopeOption.Required,
                    new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted, Timeout = TimeSpan.Zero }))
                {
                    using (Probe.Create($"ETL2 {actorName}"))
                    {
                        actor.ExecuteCommands(commands);
                    }

                    transaction.Complete();
                }
            }

            _telemetryPublisher.Publish<StatisticsProcessedOperationCountIdentity>(commands.Count);
        }

        public Task WriteAsync(IReadOnlyCollection<IUnpersistedRawStreamEvent> events)
        {
            lock (_events)
            {
                var globalSequence = _events.Count + 1;

                var existingEvents = _events.Select(e => e.EventID);

                if (existingEvents.Intersect(events.Select(e => e.EventID)).Any())
                    throw new DuplicatedEntryException();

                foreach (var e in events)
                {
                    e.GlobalSequence = globalSequence++;

                    var p = new PersistedRawEvent
                    {
                        GlobalSequence = e.GlobalSequence,
                        EventID = e.EventID,
                        Stream = e.Stream,
                        EventType = e.EventType,
                        UtcTimestamp = e.UtcTimestamp,
                        Metadata = e.Metadata,
                        Payload = e.Payload
                    };

                    _events.Add(p);
                }
            }

            return Unit.GetCompletedTask();
        }

        public async Task<bool> TryAddSourceItemsToOwnedProjectFileAsync(IReadOnlyCollection<ItemData> items, string projectFilePath) {
            if (!CheckProjectFileOwnership(projectFilePath)) {
                return false;
            }

            var unhandledItems = await _temporaryItems.AddTemporaryFiles(_configuredProject, items.Select(i => i.Item2));
            return unhandledItems.Count < items.Count;
        }

        private static void ProcessDonations(IReadOnlyCollection<Tuple<string, int>> donations)
        {
            // Change the Fs to EF or Dapper for different ORM implementation
            var persons = Fs.PersonLoader.LoadPersons(donations.Select(x => x.Item1)).ToList();

            AddDonations(donations, persons);

            LogOrgAmounts(persons);
        }

 private static IEnumerable<string> GenerateCtor(EntityModel entity, IReadOnlyCollection<IPropertyModel> classProps)
 {
     var ctorArgs = string.Join(", ", classProps.Select(p => p.TypeFullName + " " + p.Name));
     yield return $"public {entity.Name}({ctorArgs}) {{";
     foreach (var prop in classProps)
     {
         yield return $"\tthis.{prop.Name} = {prop.Name};";
     }
     yield return "}";
 }

 public GraphNode SetStartNodes(IReadOnlyCollection<SkillNode> startNodes)
 {
     var supernode = new GraphNode(startNodes.Select(n => n.Id));
     foreach (var node in startNodes)
     {
         NodeDict.Add(node, supernode);
         CheckLinks(node);
     }
     return supernode;
 }

 private static string DetermineErrorMessage(int returnCode, IReadOnlyCollection<int> errorCodes)
 {
     string errorMessage = (OstcMessages.ReturnCodeMessages.ContainsKey(returnCode) ? OstcMessages.ReturnCodeMessages[returnCode] : "Unbekannter Rückgabe-Wert");
     var exceptionMessage = $"Rückgabe-Wert {returnCode}: {errorMessage}";
     if (errorCodes.Count != 0)
     {
         var errorCodesList = string.Join(", ", errorCodes.Select(x => x.ToString()).ToArray());
         exceptionMessage = $"{exceptionMessage}\nFolgende Fehlercodes wurden zurückgeliefert: {errorCodesList}";
     }
     return exceptionMessage;
 }

        private static void PrintFailures(IReadOnlyCollection<KeyValuePair<string, Exception>> errors)
        {
            if (errors == null || errors.Count <= 0)
                return;

            Console.WriteLine();
            Console.WriteLine(Resources.StatisticsFailuresHeader);
            Console.WriteLine(String.Join(Environment.NewLine, 
                errors.Select(e => String.Format(CultureInfo.InvariantCulture, 
                    Resources.StatisticsFailureItemFormat, e.Key, e.Value.Message))));
        }

        public Constructor(ConstructorInfo constructor)
        {
            Parameters = Array.AsReadOnly(constructor.GetParameters().Select(p => p.ParameterType).ToArray());

            var inputs = Expression.Parameter(typeof(object[]));
            var create = Expression.New(constructor,
                    Parameters.Select((p, i) => Expression.Convert(Expression.ArrayIndex(inputs, Expression.Constant(i)), p)));

            // compile the ConstructorInfo into a function
            _Constructor = Expression.Lambda<Func<object[], object>>(constructor.DeclaringType.IsValueType ?
                Expression.Convert(create, typeof(object)) as Expression : create, inputs).Compile();
        }

 public static string GetTranslatedSort(string modelColumn, string defaultSort, IReadOnlyCollection<string> allowedColumns)
 {
     if (string.IsNullOrEmpty(modelColumn))
         return defaultSort.ToUpperInvariant();
     var arguments = modelColumn.Split(' ');
     if (arguments.Length != 2)
         return defaultSort.ToUpperInvariant();
     var ascending = arguments[1].ToUpperInvariant() == "ASC";
     var column = arguments[0].ToUpperInvariant();
     if (!allowedColumns.Select(c => c.ToUpperInvariant()).Contains(column))
         return defaultSort.ToUpperInvariant();
     return $"{column} {(@ascending ? "ASC" : "DESC")}";
 }

        /// <summary>
        /// Gets the selected messages from the store
        /// </summary>
        /// <param name="messageStore">The store to retrieve from</param>
        /// <param name="messageIds">The messages to retrieve</param>
        /// <returns></returns>
        private static IEnumerable<Message> GetMessagesFromStore(IAmAMessageStore<Message> messageStore, IReadOnlyCollection<string> messageIds)
        {
            IEnumerable<Message> foundMessages = messageIds 
                .Select(messageId => messageStore.Get(Guid.Parse(messageId)))
                .Where(fm => fm != null)
                .ToList();

            if (foundMessages.Count() < messageIds.Count)
            {
                throw new SystemException("Cannot find messages " +
                                          string.Join(",", messageIds.Where(id => foundMessages.All(fm => fm.Id.ToString() != id.ToString())).ToArray()));
            }
            return foundMessages;
        }

 static void LogFoundMessages(IReadOnlyCollection<MessageMetadata> messageDefinitions)
 {
     if (!Logger.IsInfoEnabled)
     {
         return;
     }
     Logger.DebugFormat("Number of messages found: {0}", messageDefinitions.Count);
     if (!Logger.IsDebugEnabled)
     {
         return;
     }
     Logger.DebugFormat("Message definitions: \n {0}",
         string.Concat(messageDefinitions.Select(md => md + "\n")));
 }