C# ImmutableList.Select方法代码示例

            public static EventFilter CreateFilter(EventKind internalEventKind, JvmtiEnvironment environment, JniEnvironment nativeEnvironment, RequestId requestId, SuspendPolicy suspendPolicy, ImmutableList<EventRequestModifier> modifiers)
            {
                if (modifiers.Count == 0)
                    return new PassThroughEventFilter(internalEventKind, requestId, suspendPolicy, modifiers);

                EventFilter[] elements = modifiers.Select(modifier => CreateFilter(internalEventKind, environment, nativeEnvironment, requestId, suspendPolicy, modifiers, modifier)).ToArray();
                if (elements.Length == 1)
                    return elements[0];

                return new AggregateEventFilter(internalEventKind, requestId, suspendPolicy, modifiers, elements);
            }

        public ImmutableList<TagCloudWord> CreateCloudWords(ImmutableList<FrequencyWord> frequencyWords)
        {
            var freqs = frequencyWords
                .Select(x => x.Frequency)
                .Distinct()
                .OrderByDescending(x => x)
                .ToImmutableList();

            using (fontSelector.Configure(freqs))
                using (brushSelector.Configure(freqs))
                    using (rectSelector.Configure(freqs))
                        return CreateCloudWordUsingSelectors(frequencyWords).ToImmutableList();
        }

        private static IReadOnlyList<TypeScriptClass> GetModels(ImmutableList<SourceFileProcessor> processors)
        {
            var models = new List<TypeScriptClass>();

            var classNames = processors.Select(p => p.ClassName).ToImmutableList();
            var classNamesToProperties = processors.ToDictionary(processor => processor.ClassName, processor => processor.GetProperties(classNames));

            foreach (var classToProperty in classNamesToProperties)
            {
                var references = classToProperty.Value.Where(p => classNames.Contains(p.Type) && p.Type != classToProperty.Key).Select(p => p.Type).Distinct().ToImmutableList();
                models.Add(new TypeScriptClass(classToProperty.Key, classToProperty.Value, references));
            }

            return models.ToImmutableList();
        }

        private Workspace(DirectoryInfo dir, Entry tree,
            ImmutableList<string> projects)
        {
            _dir = dir;
            _tree = tree;
            _projects = projects;
            _projectCache = new Lazy<ImmutableList<ProjectEntry>>(() => _projects.Select(p => FindProject(_tree, p)).ToImmutableList());
            _errorList = new Lazy<ImmutableList<DiagnosticMessage>>(() =>
            {
                var diagnostics = ImmutableList.CreateBuilder<DiagnosticMessage>();

                foreach (var project in _projectCache.Value)
                    diagnostics.AddRange(project.Diagnostics);

                return diagnostics.ToImmutable();
            });
        }

        private Step(Step step, Tuple<IEnumerable<Cell>, int> pointsNCells)
        {
            height = step.height;
            width = step.width;
            commandIndex = step.commandIndex + 1;
            points = step.points + pointsNCells.Item2;

            Pieces = step.Pieces;
            CurrentPieceCells = Pieces[step.pieceIndex].Cells;
            UsedCells = pointsNCells.Item1.ToImmutableHashSet();
            Center = GetShift(CurrentPieceCells);
            RunningCells = CurrentPieceCells.Select(c => new Cell(c + Center)).ToImmutableHashSet();
            pieceIndex = (step.pieceIndex + 1) % step.Pieces.Count;
        }

 private static Message CreateAggregateMessage(
     Guid searchTermId,
     ImmutableList<Message> searchResultMessages)
 {
     var aggregateMessage = Message.CreateMessage(
         searchTermId.ToCanonicalString(),
         "Aggregate",
         Predecessors.Set
             .In("SearchResult", searchResultMessages.Select(r => r.Hash)),
         searchTermId,
         new { });
     return aggregateMessage;
 }

 static ImmutableList<Order> DeQueue(ImmutableList<Order> orders, DateTime currentTime)
 {
   return orders.Select(order => order.Status == OrderStatus.InQueue && order.ToTime <= currentTime ? order.With(status: OrderStatus.New, products: order.Products.Select(product => product.With(status: ProductStatus.New)).ToImmutableArray()) : order).ToImmutableList();
 }

 // TODO: param name should be optional
 public static FunctionType Create(ExprType returnType, ImmutableList<Tuple<Option<String>, ExprType>> args, Boolean hasVarArgs) =>
     Create(returnType, args.Select(_ => Tuple.Create(_.Item1.IsSome ? _.Item1.Value : "", _.Item2)).ToList(), hasVarArgs);