C# IEnumerable.ToImmutableList方法代码示例

        public Exercise(ILoggerService loggerService, ISpeechService speechService, string name, int setCount, int repetitionCount, IEnumerable<MatcherWithAction> matchersWithActions)
        {
            loggerService.AssertNotNull(nameof(loggerService));
            speechService.AssertNotNull(nameof(speechService));
            name.AssertNotNull(nameof(name));
            matchersWithActions.AssertNotNull(nameof(matchersWithActions));

            if (setCount < 0)
            {
                throw new ArgumentException("setCount cannot be less than zero.", "setCount");
            }

            if (repetitionCount < 0)
            {
                throw new ArgumentException("repetitionCount cannot be less than zero.", "repetitionCount");
            }

            this.logger = loggerService.GetLogger(this.GetType());
            this.speechService = speechService;
            this.name = name;
            this.setCount = setCount;
            this.repetitionCount = repetitionCount;
            this.matchersWithActions = matchersWithActions.ToImmutableList();

            using (var dummyExecutionContext = new ExecutionContext())
            {
                this.duration = this
                    .GetEventsWithActions(dummyExecutionContext)
                    .SelectMany(x => x.Actions)
                    .Select(x => x.Duration)
                    .DefaultIfEmpty()
                    .Aggregate((running, next) => running + next);
            }
        }

 public PhotoSet(string id, PhotoSetType type, string displayName, IEnumerable<Photo> photos)
 {
     this.Id = id;
     this.Type = type;
     this.DisplayName = displayName;
     this.Photos = photos.ToImmutableList();
 }

 public XRefCollection(IEnumerable<Uri> uris)
 {
     if (uris == null)
     {
         throw new ArgumentNullException(nameof(uris));
     }
     Uris = uris.ToImmutableList();
 }

 public FSharpCompilationFailure(
   string filePath,
   IEnumerable<FSharpCompilationMessage> messages)
 {
   _filePath = filePath;
   _fileContent = File.Exists(filePath) ? File.ReadAllText(filePath) : null;
   _messages = messages.ToImmutableList();
 }

 public ValuesEntity(string id, DateTimeOffset createdOn, DateTimeOffset lastModifiedOn, DateTimeOffset lastAccessedOn, IEnumerable<string> values = null)
 {
     this.Id = id;
     this.CreatedOn = createdOn;
     this.LastModifiedOn = lastModifiedOn;
     this.LastAccessedOn = lastAccessedOn;
     this.Values = values == null ? ImmutableList<string>.Empty : values.ToImmutableList();
 }

 public Configuration(
     IEnumerable<Transformation> namespaceTransformations,
     IEnumerable<Transformation> nameTransformations,
     IEnumerable<Filter> interfaceFilters)
 {
     this.namespaceTransformations = namespaceTransformations.ToImmutableList();
     this.nameTransformations = nameTransformations.ToImmutableList();
     this.interfaceFilters = interfaceFilters.ToImmutableList();
 }

 public SearchMethodInfo(SearchTypeInfo type, string methodName, IEnumerable<string> parameters = null,
     IEnumerable<string> typeParameters = null, bool? isStatic = null, bool? isAbstract = null)
 {
     Type = type;
     MethodName = methodName;
     Parameters = parameters?.ToImmutableList();
     TypeParameters = typeParameters == null ? ImmutableList<string>.Empty : (typeParameters.ToImmutableList());
     IsStatic = isStatic;
     IsAbstract = isAbstract;
 }

        public MetronomeAction(IAudioService audioService, IDelayService delayService, ILoggerService loggerService, IEnumerable<MetronomeTick> ticks)
        {
            audioService.AssertNotNull(nameof(audioService));
            delayService.AssertNotNull(nameof(delayService));
            loggerService.AssertNotNull(nameof(loggerService));
            ticks.AssertNotNull(nameof(ticks));

            this.ticks = ticks.ToImmutableList();
            this.innerAction = new SequenceAction(GetInnerActions(audioService, delayService, loggerService, this.ticks));
        }

        public ParallelAction(IEnumerable<IAction> children)
        {
            Ensure.ArgumentNotNull(children, nameof(children), assertContentsNotNull: true);

            this.children = children.ToImmutableList();
            this.duration = this
                .children
                .Select(x => x.Duration)
                .DefaultIfEmpty()
                .Max();
        }

        public SequenceAction(IEnumerable<IAction> children)
        {
            children.AssertNotNull(nameof(children), assertContentsNotNull: true);

            this.children = children.ToImmutableList();
            this.duration = this
                .children
                .Select(x => x.Duration)
                .DefaultIfEmpty()
                .Aggregate((running, next) => running + next);
        }

        /// <summary>
        /// Initializes an instance of <see cref="TextChangeEventArgs"/>.
        /// </summary>
        /// <param name="oldText">The text before the change.</param>
        /// <param name="newText">The text after the change.</param>
        /// <param name="changes">A non-empty set of ranges for the change.</param>
        public TextChangeEventArgs(SourceText oldText, SourceText newText, IEnumerable<TextChangeRange> changes)
        {
            if (changes == null || changes.IsEmpty())
            {
                throw new ArgumentException("changes");
            }

            this.OldText = oldText;
            this.NewText = newText;
            this.Changes = changes.ToImmutableList();
        }

		public ClassificationResult(
				IEnumerable<SuspiciousNode> suspiciousNodes, IEnumerable<BigInteger> wronglyAcceptedFeatures,
				IEnumerable<BigInteger> wronglyRejectedFeatures, int wrongVectorCount, int wrongElementCount,
				EncodingResult encodingResult) {
			SuspiciousNodes = suspiciousNodes != null ? suspiciousNodes.ToImmutableList() : null;
			WronglyAcceptedVectors = wronglyAcceptedFeatures.ToImmutableList();
			WronglyRejectedVectors = wronglyRejectedFeatures.ToImmutableList();
			WrongVectorCount = wrongVectorCount;
			WrongElementCount = wrongElementCount;
			_vector2Node = encodingResult.Vector2Node;
		}

        public ExerciseProgram(ILoggerService loggerService, string name, IEnumerable<Exercise> exercises)
        {
            Ensure.ArgumentNotNull(loggerService, nameof(loggerService));
            Ensure.ArgumentNotNull(name, nameof(name));
            Ensure.ArgumentNotNull(exercises, nameof(exercises), assertContentsNotNull: true);

            this.logger = loggerService.GetLogger(this.GetType());
            this.name = name;
            this.exercises = exercises.ToImmutableList();
            this.duration = this
                .exercises
                .Select(x => x.Duration)
                .DefaultIfEmpty()
                .Aggregate((running, next) => running + next);
        }

        public RuleReference(Implication originalRule, IEnumerable<PropNetFlattener.Condition> conditions, IList<Term> productionTemplate = null)
        {
            OriginalRule = originalRule;
            ProductionTemplate = productionTemplate==null ? ImmutableList<Term>.Empty :  productionTemplate.ToImmutableList();

            Conditions = conditions.ToImmutableList();

            int producttionTemplateHashCode = 1;

            if (productionTemplate != null)
                foreach (Term term in productionTemplate)
                    producttionTemplateHashCode = 31 * producttionTemplateHashCode + (term == null ? 0 : term.GetHashCode());

            int conditionsHashcode = Conditions.Aggregate(1, (current, cond) => 31 * current + (cond == null ? 0 : cond.GetHashCode()));
            _hashCode = producttionTemplateHashCode + conditionsHashcode;
        }

        private Step(Step step, IEnumerable<Cell> cells, IEnumerable<Cell> rotateCells, Cell newCenter)
        {
            height = step.height;
            width = step.width;
            pieceIndex = step.pieceIndex;
            commandIndex = step.commandIndex + 1;
            points = step.points;

            Center = newCenter;
            Pieces = step.Pieces;
            CurrentPieceCells = rotateCells.ToImmutableList();
            UsedCells = step.UsedCells;
            RunningCells = cells.ToImmutableHashSet();
        }