C# ReadOnlyArray类代码示例

        public Z80(ReadOnlyArray<byte> rom, IMemoryManagementUnit mmu)
        {
            InitOpcodes();

            this.mmu = mmu;
            this.rom = rom;
        }

        /// <summary>
        /// Returns a constructed type given its instance type and type arguments.
        /// </summary>
        /// <param name="instanceType">the instance type to construct the result from</param>
        /// <param name="typeArguments">the immediate type arguments to be replaced for type parameters in the instance type</param>
        /// <returns></returns>
        internal static NamedTypeSymbol Construct1(this NamedTypeSymbol instanceType, ReadOnlyArray<TypeSymbol> typeArguments)
        {
            Debug.Assert(instanceType.ConstructedFrom == instanceType);
            
            var sequenceEqual = true;
            var args = instanceType.TypeArguments;

            if (args.Count != typeArguments.Count)
            {
                sequenceEqual = false;
            }
            else
            {
                for (int i = 0; i < args.Count; i++)
                {
                    if (args[i] != typeArguments[i])
                    {
                        sequenceEqual = false;
                        break;
                    }
                }
            }

            return sequenceEqual
                ? instanceType
                : ConstructedNamedTypeSymbol.Make(instanceType, typeArguments);
        }

        public ReadOnlyArray<JsonProperty> GetProperties()
        {
            var builder = new ReadOnlyArray<JsonProperty>.Builder();

            foreach (var assignment in _assignments)
            {
                if (assignment.Value.Mode == PropertyExpressionType.Data)
                {
                    builder.Add(new JsonDataProperty(
                        assignment.Key,
                        assignment.Value.Expression
                    ));
                }
                else
                {
                    builder.Add(new JsonAccessorProperty(
                        assignment.Key,
                        assignment.Value.GetExpression,
                        assignment.Value.SetExpression
                    ));
                }
            }

            return builder.ToReadOnly();
        }

        /// <summary>
        /// Spill an expression list with a receiver (e.g. array access, method call), where at least one of the
        /// receiver or the arguments contains an await expression.
        /// </summary>
        private Tuple<BoundExpression, ReadOnlyArray<BoundExpression>> SpillExpressionsWithReceiver(
            BoundExpression receiverOpt,
            ReadOnlyArray<BoundExpression> expressions,
            SpillBuilder spillBuilder,
            ReadOnlyArray<RefKind> refKindsOpt)
        {
            if (receiverOpt == null)
            {
                return Tuple.Create(default(BoundExpression), SpillExpressionList(spillBuilder, expressions));
            }

            // We have a non-null receiver, and an expression of the form:
            //     receiver[index1, index2, ..., indexN]
            //     or:
            //     receiver(arg1, arg2, ... argN)

            // Build a list containing the receiver and all expressions (in that order)
            var allExpressions = ReadOnlyArray<BoundExpression>.CreateFrom(receiverOpt).Concat(expressions);
            var allRefKinds = (refKindsOpt != null)
                ? ReadOnlyArray<RefKind>.CreateFrom(RefKind.None).Concat(refKindsOpt)
                : ReadOnlyArray<RefKind>.Empty;

            // Spill the expressions (and possibly the receiver):
            var allSpilledExpressions = SpillExpressionList(spillBuilder, allExpressions, allRefKinds);

            var spilledReceiver = allSpilledExpressions.First();
            var spilledArguments = allSpilledExpressions.RemoveFirst();
            return Tuple.Create(spilledReceiver, spilledArguments);
        }

        public RomInfo(byte[] rom)
        {
            Rom = new ReadOnlyArray<byte>(rom);

            NintendoGraphic = new byte[48];
            Array.Copy(rom, 0x0104, NintendoGraphic, 0, 48);

            var name = new byte[14];
            Array.Copy(rom, 0x0134, name, 0, 14);
            RomName = new string(name.Where(b => b != 0).Select(b => (char) b).ToArray());

            IsColor = rom[0x0143] == 0x80;
            LicenseeCode = (ushort)((rom[0x0144] << 8) | rom[0x0145]);
            IsSuperGb = rom[0x0146] == 3;

            CartridgeInfo = new CartridgeInfo(rom[0x0147]);
            RomSize = new RomSize(rom[0x0148]);
            RamSize = new RamSize(rom[0x0149]);

            Japanese = rom[0x014A] == 1;
            OldLincenseeCode = rom[0x01B];
            MaskRomVersionNumber = rom[0x014C];

            ComplementCheck = rom[0x014D];
            Checksum = (ushort)((rom[0x014E] << 8) | rom[0x014F]);
        }

        public Closure(ReadOnlyArray<string> fields)
        {
            if (fields == null)
                throw new ArgumentNullException("fields");

            Fields = fields;
        }

 public CustomAttribute(
     IMethodReference constructor,
     ITypeReference type,
     ReadOnlyArray<MetadataConstant> positionalArguments) :
     this(constructor, type, positionalArguments, ReadOnlyArray<IMetadataNamedArgument>.Empty)
 {
 }

 public Scope(BodyType bodyType, Scope parent, ReadOnlyArray<string> parameters)
 {
     _bodyType = bodyType;
     Parent = parent;
     _parameters = parameters;
     _rootScope = parent != null ? parent._rootScope : this;
 }

 internal void AllocateFields(ReadOnlyArray<BoundSpillTemp> spills)
 {
     foreach (var spill in spills)
     {
         AllocateField(spill);
     }
 }

 public GuitarData(Wiimote Owner)
     : base(Owner)
 {
     _stick = new byte[2];
     _stick_readonly = new ReadOnlyArray<byte>(_stick);
     _frets = new bool[5];
     _frets_readonly = new ReadOnlyArray<bool> (_frets);
 }

 public UnconfirmedCOVNotificationRequest(uint subscriberProcessIdentifier, ObjectId initiatingDeviceIdentifier, ObjectId monitoredObjectIdentifier, uint timeRemaining, ReadOnlyArray<PropertyValue> listOfValues)
 {
     this.SubscriberProcessIdentifier = subscriberProcessIdentifier;
     this.InitiatingDeviceIdentifier = initiatingDeviceIdentifier;
     this.MonitoredObjectIdentifier = monitoredObjectIdentifier;
     this.TimeRemaining = timeRemaining;
     this.ListOfValues = listOfValues;
 }

        public BodySyntax ExecuteBlockStatements(ReadOnlyArray<string> parameters)
        {
            _builder.EnterFunctionBody(parameters);

            blockStatements();

            return _builder.ExitBody();
        }

            public AsyncStruct(MethodSymbol method, TypeCompilationState compilationState)
                : base(method, GeneratedNames.MakeIteratorOrAsyncDisplayClassName(method.Name, compilationState.GenerateTempNumber()), TypeKind.Struct)
            {
                this.interfaces = ReadOnlyArray<NamedTypeSymbol>.CreateFrom(
                    compilationState.EmitModule.Compilation.GetWellKnownType(WellKnownType.System_Runtime_CompilerServices_IAsyncStateMachine));

                this.constructor = new SynthesizedInstanceConstructor(this);
            }

        public static NamedTypeSymbol Construct(this NamedTypeSymbol type, ReadOnlyArray<TypeSymbol> arguments)
        {
            Debug.Assert(type != null);
            Debug.Assert(arguments.IsNotNull);
            TypeMap map = new TypeMap(ReadOnlyArray<TypeSymbol>.CreateFrom(type.ConstructedFrom.TypeParameters),
                                            arguments);

            return map.SubstituteNamedType(type.ConstructedFrom);
        }

        public AssemblyResolver WithPaths(ReadOnlyArray<string> paths)
        {
            if (paths == this.searchPaths)
            {
                return this;
            }

            return new AssemblyResolver(paths, getFullPath, architectureFilter, preferredCulture);
        }