C# IEnumerable.ToReadOnlyList方法代码示例

        public BlogSettingsHelper(IEnumerable<BlogSetting> blogSettings)
        {
            if (blogSettings == null)
            {
                throw new ArgumentNullException(nameof(blogSettings));
            }

            this.blogSettings = blogSettings.ToReadOnlyList();

            this.BlogKeys =
                this.blogSettings.Select(x => new BlogKey(x.BlogKey)).Where(x => x.HasValue).ToReadOnlyList();
        }

 public SqlSelectExpression(Type type, string alias, IEnumerable<SqlColumnDeclaration> columns, Expression from, Expression where, IEnumerable<Expression> orderBy, bool forUpdate)
     : this(type, alias, columns.ToReadOnlyList(), from, where, orderBy.ToReadOnlyList(), null, false, null, null, forUpdate)
 {
 }

 public SqlSelectExpression ChangeColumns(IEnumerable<SqlColumnDeclaration> columns, bool columnsAlreadyOrdered)
 {
     return new SqlSelectExpression(this.Type, this.Alias, columnsAlreadyOrdered ? columns.ToReadOnlyList() : columns.OrderBy(c => c.Name).ToReadOnlyList(), this.From, this.Where, this.OrderBy, this.GroupBy, this.Distinct, this.Take, this.Skip, this.ForUpdate);
 }

 public SqlCreateIndexExpression(string indexName, SqlTableExpression table, bool unique, bool lowercaseIndex, IndexType indexType, bool ifNotExist, IEnumerable<SqlIndexedColumnExpression> columns)
     : this(indexName, table, unique, lowercaseIndex, indexType, ifNotExist, columns.ToReadOnlyList())
 {
 }

 public SqlReferencesColumnExpression(SqlTableExpression referencedTable, SqlColumnReferenceDeferrability deferrability, IEnumerable<string> referencedColumnNames, SqlColumnReferenceAction onDelete, SqlColumnReferenceAction onUpdate)
     : this(referencedTable, deferrability, referencedColumnNames.ToReadOnlyList(), onDelete, onUpdate)
 {
 }

		public SqlCreateTableExpression(SqlTableExpression table, bool ifNotExist, IEnumerable<SqlColumnDefinitionExpression> columnExpressions, IEnumerable<Expression> tableConstraintExpressions)
			: this(table, ifNotExist, columnExpressions.ToReadOnlyList(), tableConstraintExpressions.ToReadOnlyList())
		{
		}

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

 public SqlQueryFormatResult(string commandText, IEnumerable<Tuple<Type, object>> parameterValues)
     : this(commandText, parameterValues.ToReadOnlyList())
 {
 }

        private async Task<object> ResolveField( ExecutionContext context, ObjectGraphType parentType, object source, IEnumerable<Field> fields, List<ExecutionError> executionErrors )
        {
            context.CancellationToken.ThrowIfCancellationRequested();

            IReadOnlyList<Field> fieldsAsReadOnlyList = fields.ToReadOnlyList();

            Field field = fieldsAsReadOnlyList.First();

            FieldType fieldDefinition = GetFieldDefinition(context.Schema, parentType, field);
            if (fieldDefinition == null)
            {
                return null;
            }

            IReadOnlyDictionary<string, object> arguments = GetArgumentValues(context.Schema, fieldDefinition.Arguments, field.Arguments, context.Variables);

            Func<ResolveFieldContext, object> defaultResolve =
                ctx =>
                {
                    return ctx.Source != null ? GetProperyValue(ctx.Source, ctx.FieldAst.Name) : null;
                };

            try
            {
                ResolveFieldContext resolveContext = new ResolveFieldContext(
                    field.Name,
                    field,
                    fieldDefinition,
                    context.Schema.FindType( fieldDefinition.Type ),
                    parentType,
                    arguments,
                    context.RootValue,
                    source,
                    context.Schema,
                    context.Operation,
                    context.Fragments,
                    context.Variables,
                    context.CancellationToken,
                    context.UserContext );

                Func<ResolveFieldContext, object> resolve = fieldDefinition.Resolve ?? defaultResolve;
                object result = resolve( resolveContext );

                Task resultAsTask = result as Task;
                if( resultAsTask != null )
                {
                    await resultAsTask;
                    result = GetProperyValue( resultAsTask, "Result" );
                }

                if ( fieldDefinition.IsPluralIdentifyingRootField )
                {
                    ThrowIfPluralIdentifyingRootFieldRequirementsNotMet(
                        result,
                        resolveContext );
                }
                
                __Field parentTypeAsField = parentType as __Field;
                Type resultAsType = result as Type;
                if ( parentTypeAsField != null &&
                     resultAsType != null )
                {
                    result = context.Schema.FindType( resultAsType );
                }

                return await CompleteValue(
                    context,
                    context.Schema.FindType( fieldDefinition.Type ),
                    fieldsAsReadOnlyList,
                    result,
                    executionErrors );
            }
            catch( Exception exception )
            {
                executionErrors.Add(
                    new ExecutionError( string.Format( "Error trying to resolve {0}.", field.Name ), exception ) );

                return null;
            }
        }

 public SqlStatementListExpression(IEnumerable<Expression> statements)
     : this(statements.ToReadOnlyList())
 {
 }

 public SqlEnumDefinitionExpression(IEnumerable<string> labels)
     : this(labels.ToReadOnlyList())
 {
 }

 public SqlFunctionCallExpression(Type type, string userDefinedFunctionName, IEnumerable<Expression> arguments)
     : this(type, SqlFunction.UserDefined, arguments.ToReadOnlyList())
 {
     this.UserDefinedFunctionName = userDefinedFunctionName;
 }

 public SqlColumnDefinitionExpression(string columnName, Expression columnTypeName, IEnumerable<Expression> constraintExpressions)
     : this(columnName, columnTypeName, constraintExpressions.ToReadOnlyList())
 {
 }

 public SqlInsertIntoExpression(SqlTableExpression table, IEnumerable<string> columnNames, IEnumerable<string> returningAutoIncrementColumnNames, IEnumerable<Expression> valueExpressions)
     : this(table, columnNames.ToReadOnlyList(), returningAutoIncrementColumnNames.ToReadOnlyList(), valueExpressions.ToReadOnlyList())
 {
 }

 public BindResult(IEnumerable<SqlColumnDeclaration> columns, IEnumerable<SqlOrderByExpression> orderings)
 {
     this.Columns = columns.ToReadOnlyList();
     this.Orderings = orderings.ToReadOnlyList();
 }