C# IEnumerable.AsReadOnly方法代码示例

 public DbDeclaration(IEnumerable<DbVariableDeclaration> variables, 
     DbSelectExpression source)
     : base(DbExpressionType.Declaration, typeof(void))
 {
     _variables = variables.AsReadOnly();
     _source = source;
 }

 public QueryCommand(string commandText, IEnumerable<QueryParameter> parameters, 
     IEnumerable<DbColumnExpression> columns)
 {
     this.commandText = commandText;
     this.parameters = parameters.AsReadOnly();
     this.columns = columns.AsReadOnly();
 }

 public JsMethod(IMember csharpMember, string name, IEnumerable<string> typeParameterNames, JsFunctionDefinitionExpression definition)
 {
     CSharpMember       = csharpMember;
     Name               = name;
     TypeParameterNames = typeParameterNames.AsReadOnly();
     Definition         = definition;
 }

 public DbFunctionExpression(Type type, string name, 
     IEnumerable<Expression> arguments)
     : base(DbExpressionType.Function, type)
 {
     _name = name;
     _arguments = arguments.AsReadOnly();
 }

		public JsSwitchSection(IEnumerable<JsExpression> values, JsStatement body) {
			if (values == null) throw new ArgumentNullException("values");
			if (body == null) throw new ArgumentNullException("body");
			Values = values.AsReadOnly();
			if (Values.Count == 0) throw new ArgumentException("Values cannot be empty", "values");
			Body = JsStatement.EnsureBlock(body);
		}

 public DbInsertExpression(DbTableExpression table, 
     IEnumerable<DbColumnAssignment> assignments)
     : base(DbExpressionType.Insert, typeof(int))
 {
     _table = table;
     _assignments = assignments.AsReadOnly();
 }

 public DbUpdateExpression(DbTableExpression table, 
     Expression where, IEnumerable<DbColumnAssignment> assignments)
     : base(DbExpressionType.Update, typeof(int))
 {
     _table = table;
     _where = where;
     _assignments = assignments.AsReadOnly();
 }

 public DbClientJoinExpression(DbProjectionExpression projection, 
     IEnumerable<Expression> outerKey, IEnumerable<Expression> innerKey)
     : base(DbExpressionType.ClientJoin, projection.Type)
 {
     _outerKey = outerKey.AsReadOnly();
     _innerKey = innerKey.AsReadOnly();
     _projection = projection;
 }

 public JsMethod(IMember csharpMember, string name, IEnumerable<string> typeParameterNames, JsFunctionDefinitionExpression definition)
 {
     Require.ValidJavaScriptIdentifier(name, "name");
     CSharpMember       = csharpMember;
     Name               = name;
     TypeParameterNames = typeParameterNames.AsReadOnly();
     Definition         = definition;
 }

        public SelectClauseExpression(IEnumerable<SelectorExpression> selectors, bool distinct)
        {
            _nodeType = CqlExpressionType.SelectColumns;
            _distinct = distinct;

            _selectors = selectors.AsReadOnly();
            for (int i = 0; i < _selectors.Count; i++)
                _selectors[i].Ordinal = i;
        }

        public SelectorExpression(MethodInfo function, IEnumerable<SelectorExpression> arguments)
        {
            if (function.DeclaringType != typeof (CqlFunctions))
                throw new ArgumentException("function must be a valid Cql Function");

            _function = function;
            _arguments = arguments.AsReadOnly();
            _type = function.ReturnType;
            _selectorType = CqlExpressionType.FunctionSelector;
        }

 public DbSelectExpression(DbTableAlias alias,
     IEnumerable<DbColumnDeclaration> columns,
     Expression from, Expression where,
     IEnumerable<DbOrderExpression> orderBy,
     IEnumerable<Expression> groupBy,
     bool isDistinct, Expression skip, Expression take)
     : base(DbExpressionType.Select, typeof(void), alias)
 {
     _isDistinct = isDistinct;
     _columns = columns.AsReadOnly();
     _from = from;
     _where = where;
     _orderBy = orderBy.AsReadOnly();
     _groupBy = groupBy.AsReadOnly();
     _take = take;
     _skip = skip;
 }

 private TermExpression(TermExpression original, IEnumerable<TermExpression> terms,
                        IDictionary<TermExpression, TermExpression> dictTerms)
 {
     _function = original.Function;
     _termType = original._termType;
     _type = original.Type;
     _value = original.Value;
     _terms = terms.AsReadOnly();
     _dictionaryTerms = dictTerms.AsReadOnly();
 }

 public IRMultiUnit(IEnumerable<IIRUnit> inner)
 {
     Inner = inner.AsReadOnly();
 }

 public static ConstructorScriptSemantics Json(IEnumerable<IMember> parameterToMemberMap)
 {
     return new ConstructorScriptSemantics { Type = ImplType.Json, _parameterToMemberMap = parameterToMemberMap.AsReadOnly(), GenerateCode = false };
 }