C# IEnumerable.ToReadOnly方法代码示例

		public CSharpSetMemberBinder (CSharpBinderFlags flags, string name, Type callingContext, IEnumerable<CSharpArgumentInfo> argumentInfo)
			: base (name, false)
		{
			this.flags = flags;
			this.callingContext = callingContext;
			this.argumentInfo = argumentInfo.ToReadOnly ();
		}

		public CSharpInvokeBinder (CSharpBinderFlags flags, Type callingContext, IEnumerable<CSharpArgumentInfo> argumentInfo)
			: base (CSharpArgumentInfo.CreateCallInfo (argumentInfo, 1))
		{
			this.flags = flags;
			this.callingContext = callingContext;
			this.argumentInfo = argumentInfo.ToReadOnly ();
		}

 public ClientJoinExpression(ProjectionExpression projection, IEnumerable<Expression> outerKey, IEnumerable<Expression> innerKey)
     : base(DbExpressionType.ClientJoin, projection.Type)
 {
     this.outerKey = outerKey.ToReadOnly();
     this.innerKey = innerKey.ToReadOnly();
     this.projection = projection;
 }

 public UpdateCommandExpression(IdentifiableExpression identifiable, Expression where, IEnumerable<FieldAssignment> assignments)
     : base(DbExpressionType.Update, typeof(int))
 {
     this.identifiable = identifiable;
     this.where = where;
     this.assignments = assignments.ToReadOnly();
 }

 public void LoadProvinces(IEnumerable<Province> provinces)
 {
     Provinces = provinces.ToReadOnly();
     SeaProvinces = Provinces.OfType<SeaProvince>().ToReadOnly();
     LandProvinces = Provinces.OfType<LandProvince>().ToReadOnly();
     ProvincePicker.Initialize(Provinces.First().Zones.First());
 }

        public static SwitchExpression Switch(Expression value, LabelTarget label, IEnumerable<SwitchCase> cases) {
            RequiresCanRead(value, "value");
            ContractUtils.Requires(value.Type == typeof(int), "value", Strings.ValueMustBeInt);
            ContractUtils.RequiresNotNull(cases, "cases");
            var caseList = cases.ToReadOnly();
            ContractUtils.RequiresNotEmpty(caseList, "cases");
            ContractUtils.RequiresNotNullItems(caseList, "cases");
            // TODO: does it make sense for switch to have non-void type?
            ContractUtils.Requires(label == null || label.Type == typeof(void), "label", Strings.LabelTypeMustBeVoid);

            bool @default = false;
            int max = Int32.MinValue;
            int min = Int32.MaxValue;
            foreach (SwitchCase sc in caseList) {
                if (sc.IsDefault) {
                    ContractUtils.Requires(@default == false, "cases", Strings.OnlyDefaultIsAllowed);
                    @default = true;
                } else {
                    int val = sc.Value;
                    if (val > max) max = val;
                    if (val < min) min = val;
                }
            }

            ContractUtils.Requires(UniqueCaseValues(caseList, min, max), "cases", Strings.CaseValuesMustBeUnique);

            return new SwitchExpression(value, label, caseList);
        }

 public static Expression VariableDictionary(IEnumerable<ParameterExpression> variables) {
     var vars = variables.ToReadOnly();
     return Expression.New(
         typeof(LocalsDictionary).GetConstructor(new[] { typeof(IRuntimeVariables), typeof(SymbolId[]) }),
         Expression.RuntimeVariables(vars),
         AstUtils.Constant(vars.Map(v => SymbolTable.StringToIdOrEmpty(v.Name)))
     );
 }

		public CSharpInvokeMemberBinder (CSharpBinderFlags flags, string name, Type callingContext, IEnumerable<Type> typeArguments, IEnumerable<CSharpArgumentInfo> argumentInfo)
			: base (name, false, CSharpArgumentInfo.CreateCallInfo (argumentInfo, 1))
		{
			this.flags = flags;
			this.callingContext = callingContext;
			this.argumentInfo = argumentInfo.ToReadOnly ();
			this.typeArguments = typeArguments.ToReadOnly ();
		}

 //CONFORMING
 ///<summary>Creates a <see cref="T:System.Linq.Expressions.MemberListBinding" /> where the member is a field or property.</summary>
 ///<returns>A <see cref="T:System.Linq.Expressions.MemberListBinding" /> that has the <see cref="P:System.Linq.Expressions.MemberBinding.BindingType" /> property equal to <see cref="F:System.Linq.Expressions.MemberBindingType.ListBinding" /> and the <see cref="P:System.Linq.Expressions.MemberBinding.Member" /> and <see cref="P:System.Linq.Expressions.MemberListBinding.Initializers" /> properties set to the specified values.</returns>
 ///<param name="member">A <see cref="T:System.Reflection.MemberInfo" /> that represents a field or property to set the <see cref="P:System.Linq.Expressions.MemberBinding.Member" /> property equal to.</param>
 ///<param name="initializers">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains <see cref="T:System.Linq.Expressions.ElementInit" /> objects to use to populate the <see cref="P:System.Linq.Expressions.MemberListBinding.Initializers" /> collection.</param>
 ///<exception cref="T:System.ArgumentNullException">
 ///<paramref name="member" /> is null. -or-One or more elements of <paramref name="initializers" /> is null.</exception>
 ///<exception cref="T:System.ArgumentException">
 ///<paramref name="member" /> does not represent a field or property.-or-The <see cref="P:System.Reflection.FieldInfo.FieldType" /> or <see cref="P:System.Reflection.PropertyInfo.PropertyType" /> of the field or property that <paramref name="member" /> represents does not implement <see cref="T:System.Collections.IEnumerable" />.</exception>
 public static MemberListBinding ListBind(MemberInfo member, IEnumerable<ElementInit> initializers) {
     ContractUtils.RequiresNotNull(member, "member");
     ContractUtils.RequiresNotNull(initializers, "initializers");
     Type memberType;
     ValidateGettableFieldOrPropertyMember(member, out memberType);
     ReadOnlyCollection<ElementInit> initList = initializers.ToReadOnly();
     ValidateListInitArgs(memberType, initList);
     return new MemberListBinding(member, initList);
 }

 //CONFORMING
 public static ElementInit ElementInit(MethodInfo addMethod, IEnumerable<Expression> arguments) {
     ContractUtils.RequiresNotNull(addMethod, "addMethod");
     ContractUtils.RequiresNotNull(arguments, "arguments");
     RequiresCanRead(arguments, "arguments");
     ValidateElementInitAddMethodInfo(addMethod);
     ReadOnlyCollection<Expression> argumentsRO = arguments.ToReadOnly();
     ValidateArgumentTypes(addMethod, ExpressionType.Call, ref argumentsRO);
     return new ElementInit(addMethod, argumentsRO);
 }

        /// <summary>
        /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" />.
        /// </summary>
        /// <param name="binder">The runtime binder for the dynamic operation.</param>
        /// <param name="returnType">The result type of the dynamic expression.</param>
        /// <param name="arguments">The arguments to the dynamic operation.</param>
        /// <returns>
        /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to
        /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the
        /// <see cref="DynamicExpression.Binder">Binder</see> and
        /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values.
        /// </returns>
        /// <remarks>
        /// The <see cref="DynamicExpression.DelegateType">DelegateType</see> property of the
        /// result will be inferred from the types of the arguments and the specified return type.
        /// </remarks>
        public static DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, IEnumerable<Expression> arguments)
        {
            ContractUtils.RequiresNotNull(arguments, nameof(arguments));
            ContractUtils.RequiresNotNull(returnType, nameof(returnType));

            var args = arguments.ToReadOnly();
            ContractUtils.RequiresNotEmpty(args, nameof(args));
            return MakeDynamic(binder, returnType, args);
        }

        /// <summary>
        /// Creates a <see cref="System.Linq.Expressions.SwitchCase">SwitchCase</see> for use in a <see cref="SwitchExpression"/>.
        /// </summary>
        /// <param name="body">The body of the case.</param>
        /// <param name="testValues">The test values of the case.</param>
        /// <returns>The created <see cref="System.Linq.Expressions.SwitchCase">SwitchCase</see>.</returns>
        public static SwitchCase SwitchCase(Expression body, IEnumerable<Expression> testValues) {
            RequiresCanRead(body, "body");
            
            var values = testValues.ToReadOnly();
            RequiresCanRead(values, "testValues");
            ContractUtils.RequiresNotEmpty(values, "testValues");

            return new SwitchCase(body, values);
        }

 /// <summary>
 /// Creates a <see cref="MemberMemberBinding"/> that represents the recursive initialization of members of a field or property. 
 /// </summary>
 /// <param name="member">The <see cref="MemberInfo"/> to set the <see cref="P:MemberBinding.Member"/> property equal to.</param>
 /// <param name="bindings">An <see cref="IEnumerable{T}"/> that contains <see cref="MemberBinding"/> objects to use to populate the <see cref="P:MemberMemberBindings.Bindings"/> collection.</param>
 /// <returns>A <see cref="MemberMemberBinding"/> that has the <see cref="P:MemberBinding.BindingType"/> property equal to <see cref="MemberBinding"/> and the <see cref="P:MemberBinding.Member"/> and <see cref="P:MemberMemberBindings.Bindings"/> properties set to the specified values.</returns>
 public static MemberMemberBinding MemberBind(MemberInfo member, IEnumerable<MemberBinding> bindings) {
     ContractUtils.RequiresNotNull(member, "member");
     ContractUtils.RequiresNotNull(bindings, "bindings");
     ReadOnlyCollection<MemberBinding> roBindings = bindings.ToReadOnly();
     Type memberType;
     ValidateGettableFieldOrPropertyMember(member, out memberType);
     ValidateMemberInitArgs(memberType, roBindings);
     return new MemberMemberBinding(member, roBindings);
 }

        /// <summary>
        /// Creates a <see cref="Expressions.SwitchCase"/> for use in a <see cref="SwitchExpression"/>.
        /// </summary>
        /// <param name="body">The body of the case.</param>
        /// <param name="testValues">The test values of the case.</param>
        /// <returns>The created <see cref="Expressions.SwitchCase"/>.</returns>
        public static SwitchCase SwitchCase(Expression body, IEnumerable<Expression> testValues)
        {
            RequiresCanRead(body, nameof(body));

            ReadOnlyCollection<Expression> values = testValues.ToReadOnly();
            ContractUtils.RequiresNotEmpty(values, nameof(testValues));
            RequiresCanRead(values, nameof(testValues));

            return new SwitchCase(body, values);
        }

 //CONFORMING
 public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable<Expression> initializers) {
     ContractUtils.RequiresNotNull(newExpression, "newExpression");
     ContractUtils.RequiresNotNull(initializers, "initializers");
     ReadOnlyCollection<Expression> initializerlist = initializers.ToReadOnly();
     if (initializerlist.Count == 0) {
         throw Error.ListInitializerWithZeroMembers();
     }
     MethodInfo addMethod = FindMethod(newExpression.Type, "Add", null, new Expression[] { initializerlist[0] }, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
     return ListInit(newExpression, addMethod, initializers);
 }