C# IEnumerable.ToReadOnlyCollection方法代码示例

 public DataStatementAst(IScriptExtent extent, string variableName, IEnumerable<ExpressionAst> commandsAllowed, StatementBlockAst body)
     : base(extent)
 {
     this.Variable = variableName;
     this.CommandsAllowed = commandsAllowed.ToReadOnlyCollection();
     this.Body = body;
 }

 public PropertyDefinitionExpression(string propertyName, Type propertyType, bool isPredeclaration, IEnumerable<string> modifiers)
 {
     this.PropertyType = propertyType;
     this.PropertyName = propertyName;
     this.IsPredeclaration = isPredeclaration;
     this.Modifiers = modifiers.ToReadOnlyCollection();
 }

        public Root(TaskData taskData, IEnumerable<Color> folderColorOptions)
        {
            Contract.Requires(null != taskData, "taskData");
            m_taskData = taskData;

            Contract.Requires(null != folderColorOptions, "folderColorOptions");
            m_folderColorOptions = folderColorOptions.ToReadOnlyCollection();

            Tasks = new TaskListViewModel(taskData, filter);
            Timeline = new TimelineViewModel(Tasks.AllTasks);

            Filters = new Filters(taskData);
            Folders = new Folders(taskData);

            taskData.PropertyChanged += (sender, args) =>
            {
                if (args.PropertyName == "CurrentFolder" || args.PropertyName == "Filter")
                {
                    Tasks.RefreshFilter();
                }
            };

            DispatcherTimer dateChanger = new DispatcherTimer();
            dateChanger.Interval = TimeSpan.FromMinutes(1);
            dateChanger.Tick += new EventHandler(dateChanger_Tick);
            Tasks.RefreshFilter();
        }

 internal ExecutionPlan( IEnumerable<IPluginInfo> pluginsToStart, IEnumerable<IPluginInfo> pluginsToStop, IReadOnlyCollection<IPluginInfo> pluginsToDisable )
 {
     Debug.Assert( pluginsToStart != null && pluginsToStop != null && pluginsToDisable != null );
     PluginsToStart = pluginsToStart.ToReadOnlyCollection();
     PluginsToStop = pluginsToStop.ToReadOnlyCollection();
     PluginsToDisable = pluginsToDisable;
 }

 public SimpleLambdaExpression(Type returnType, Expression body, IEnumerable<Expression> variables, params Expression[] parameters)
 {
     this.ReturnType = returnType;
     this.Body = body;
     this.Variables = variables.ToReadOnlyCollection();
     this.Parameters = parameters.ToReadOnlyCollection();
 }

 public ContentTypeDefinition(string name, string displayName, IEnumerable<ContentTypePartDefinition> parts, SettingsDictionary settings)
 {
     Name = name;
     DisplayName = displayName;
     Parts = parts.ToReadOnlyCollection();
     Settings = settings;
 }

 public TryStatementAst(IScriptExtent extent, StatementBlockAst body, IEnumerable<CatchClauseAst> catchClauses, StatementBlockAst @finally)
     : base(extent)
 {
     this.Body = body;
     this.CatchClauses = catchClauses.ToReadOnlyCollection();
     this.Finally = @finally;
 }

 public ServiceModel(ServiceModelInfo serviceModelInfo, IEnumerable<ServiceEnum> enums, IEnumerable<ServiceClass> classes, IEnumerable<ServiceGateway> gateways)
 {
     this.ServiceModelInfo = serviceModelInfo ?? new ServiceModelInfo();
     this.Enums = enums.ToReadOnlyCollection();
     this.Classes = classes.ToReadOnlyCollection();
     this.Gateways = gateways.ToReadOnlyCollection();
 }

 public ParameterAst(IScriptExtent extent, VariableExpressionAst name, IEnumerable<AttributeBaseAst> attributes, ExpressionAst defaultValue)
     : base(extent)
 {
     this.Name = name;
     this.Attributes = attributes.ToReadOnlyCollection();
     this.DefaultValue = defaultValue;
 }

 public SwitchStatementAst(IScriptExtent extent, string label, PipelineBaseAst condition, SwitchFlags flags, IEnumerable<Tuple<ExpressionAst, StatementBlockAst>> clauses, StatementBlockAst @default)
     : base(extent, label, condition)
 {
     this.Flags = flags;
     this.Clauses = clauses.ToReadOnlyCollection();
     this.Default = @default;
 }

 public FunctionDefinitionAst(IScriptExtent extent, bool isFilter, bool isWorkflow, string name, IEnumerable<ParameterAst> parameters, ScriptBlockAst body)
     : base(extent)
 {
     this.IsFilter = isFilter;
     this.IsWorkflow = isWorkflow;
     this.Name = name;
     this.Parameters = parameters.ToReadOnlyCollection();
     this.Body = body;
 }

 internal FunctionInfo(string name, ScriptBlock function, IEnumerable<ParameterAst> explicitParams,
                       ScopedItemOptions options)
     : base(name, CommandTypes.Function)
 {
     ScriptBlock = function;
     Options = options;
     ScopeUsage = ScopeUsages.NewScope;
     _explicitParameters = explicitParams == null ? new ReadOnlyCollection<ParameterAst>(new ParameterAst[0])
                                                  : explicitParams.ToReadOnlyCollection();
 }

 public CommandKeyBindingSnapshot(
     CommandListSnapshot snapshot,
     IEnumerable<KeyInput> vimFirstKeyInputs,
     IEnumerable<CommandKeyBinding> removed,
     IEnumerable<CommandKeyBinding> conflicting)
 {
     _commandListSnapshot = snapshot;
     _vimFirstKeyInputs = vimFirstKeyInputs.ToReadOnlyCollection();
     _removedBindings = removed.ToReadOnlyCollection();
     _conflictingBindings = conflicting.ToReadOnlyCollection();
 }

 public MethodDefinitionExpression(string name, ReadOnlyCollection<Expression> parameters, AccessModifiers accessModifiers, Type returnType, Expression body, bool isPredeclaration, string rawAttributes = "", ReadOnlyDictionary<string, string> attributes = null, IEnumerable<Exception> exceptions = null)
 {
     this.RawAttributes = rawAttributes;
     this.Attributes = attributes ?? new ReadOnlyDictionary<string, string>(new Dictionary<string, string>());
     this.Name = name;
     this.AccessModifiers = accessModifiers;
     this.ReturnType = returnType;
     this.Parameters = parameters;
     this.Body = body;
     this.IsPredeclaration = isPredeclaration;
     this.Exceptions = exceptions == null ? null : exceptions.ToReadOnlyCollection();
 }

		public SqlForeignKeyConstraintExpression(string constraintName, IEnumerable<string> columnNames, SqlReferencesColumnExpression referencesColumnExpression)
			: this(constraintName, columnNames.ToReadOnlyCollection(), referencesColumnExpression)
		{	
		}