C# MemoryBlock.GetMemoryBlockAt方法代码示例

        internal DocumentTableReader(
            int numberOfRows,
            int guidHeapRefSize,
            int blobHeapRefSize,
            MemoryBlock containingBlock,
            int containingBlockOffset)
        {
            NumberOfRows = numberOfRows;
            _isGuidHeapRefSizeSmall = guidHeapRefSize == 2;
            _isBlobHeapRefSizeSmall = blobHeapRefSize == 2;

            _hashAlgorithmOffset = NameOffset + blobHeapRefSize;
            _hashOffset = _hashAlgorithmOffset + guidHeapRefSize;
            _languageOffset = _hashOffset + blobHeapRefSize;
            RowSize = _languageOffset + guidHeapRefSize;

            Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, RowSize * numberOfRows);
        }

 internal ModuleTableReader(
     int numberOfRows,
     int stringHeapRefSize,
     int guidHeapRefSize,
     MemoryBlock containingBlock,
     int containingBlockOffset
 )
 {
     this.NumberOfRows = numberOfRows;
     _IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
     _IsGUIDHeapRefSizeSmall = guidHeapRefSize == 2;
     _GenerationOffset = 0;
     _NameOffset = _GenerationOffset + sizeof(UInt16);
     _MVIdOffset = _NameOffset + stringHeapRefSize;
     _EnCIdOffset = _MVIdOffset + guidHeapRefSize;
     _EnCBaseIdOffset = _EnCIdOffset + guidHeapRefSize;
     this.RowSize = _EnCBaseIdOffset + guidHeapRefSize;
     this.Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, this.RowSize * (int)numberOfRows);
 }

        internal EnCLogTableReader(
            int numberOfRows,
            MemoryBlock containingBlock,
            int containingBlockOffset,
            MetadataStreamKind metadataStreamKind)
        {
            // EnC tables are not allowed in a compressed stream.
            // However when asked for a snapshot of the current metadata after an EnC change has been applied 
            // the CLR includes the EnCLog table into the snapshot (but not EnCMap). We pretend EnCLog is empty.
            this.NumberOfRows = (metadataStreamKind == MetadataStreamKind.Compressed) ? 0 : numberOfRows;

            _TokenOffset = 0;
            _FuncCodeOffset = _TokenOffset + sizeof(uint);
            this.RowSize = _FuncCodeOffset + sizeof(uint);
            this.Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, (int)(this.RowSize * numberOfRows));
        }

        public unsafe void ReadFromMemoryBlock()
        {
            byte[] buffer = new byte[4] { 0, 1, 0, 2 };
            fixed (byte* bufferPtr = buffer)
            {
                var block = new MemoryBlock(bufferPtr, buffer.Length);

                Assert.Throws<BadImageFormatException>(() => block.PeekUInt32(Int32.MaxValue));
                Assert.Throws<BadImageFormatException>(() => block.PeekUInt32(-1));
                Assert.Throws<BadImageFormatException>(() => block.PeekUInt32(Int32.MinValue));
                Assert.Throws<BadImageFormatException>(() => block.PeekUInt32(4));
                Assert.Throws<BadImageFormatException>(() => block.PeekUInt32(1));
                Assert.Equal(0x02000100U, block.PeekUInt32(0));

                Assert.Throws<BadImageFormatException>(() => block.PeekUInt16(Int32.MaxValue));
                Assert.Throws<BadImageFormatException>(() => block.PeekUInt16(-1));
                Assert.Throws<BadImageFormatException>(() => block.PeekUInt16(Int32.MinValue));
                Assert.Throws<BadImageFormatException>(() => block.PeekUInt16(4));
                Assert.Equal(0x0200, block.PeekUInt16(2));

                int bytesRead;

                MetadataStringDecoder stringDecoder = MetadataStringDecoder.DefaultUTF8;
                Assert.Throws<BadImageFormatException>(() => block.PeekUtf8NullTerminated(Int32.MaxValue, null, stringDecoder, out bytesRead));
                Assert.Throws<BadImageFormatException>(() => block.PeekUtf8NullTerminated(-1, null, stringDecoder, out bytesRead));
                Assert.Throws<BadImageFormatException>(() => block.PeekUtf8NullTerminated(Int32.MinValue, null, stringDecoder, out bytesRead));
                Assert.Throws<BadImageFormatException>(() => block.PeekUtf8NullTerminated(5, null, stringDecoder, out bytesRead));

                Assert.Throws<BadImageFormatException>(() => block.GetMemoryBlockAt(-1, 1));
                Assert.Throws<BadImageFormatException>(() => block.GetMemoryBlockAt(1, -1));
                Assert.Throws<BadImageFormatException>(() => block.GetMemoryBlockAt(0, -1));
                Assert.Throws<BadImageFormatException>(() => block.GetMemoryBlockAt(-1, 0));
                Assert.Throws<BadImageFormatException>(() => block.GetMemoryBlockAt(-Int32.MaxValue, Int32.MaxValue));
                Assert.Throws<BadImageFormatException>(() => block.GetMemoryBlockAt(Int32.MaxValue, -Int32.MaxValue));
                Assert.Throws<BadImageFormatException>(() => block.GetMemoryBlockAt(Int32.MaxValue, Int32.MaxValue));
                Assert.Throws<BadImageFormatException>(() => block.GetMemoryBlockAt(block.Length, -1));
                Assert.Throws<BadImageFormatException>(() => block.GetMemoryBlockAt(-1, block.Length));


                Assert.Equal("\u0001", block.PeekUtf8NullTerminated(1, null, stringDecoder, out bytesRead));
                Assert.Equal(bytesRead, 2);

                Assert.Equal("\u0002", block.PeekUtf8NullTerminated(3, null, stringDecoder, out bytesRead));
                Assert.Equal(bytesRead, 1);

                Assert.Equal("", block.PeekUtf8NullTerminated(4, null, stringDecoder, out bytesRead));
                Assert.Equal(bytesRead, 0);

                byte[] helloPrefix = Encoding.UTF8.GetBytes("Hello");

                Assert.Equal("Hello\u0001", block.PeekUtf8NullTerminated(1, helloPrefix, stringDecoder, out bytesRead));
                Assert.Equal(bytesRead, 2);

                Assert.Equal("Hello\u0002", block.PeekUtf8NullTerminated(3, helloPrefix, stringDecoder, out bytesRead));
                Assert.Equal(bytesRead, 1);

                Assert.Equal("Hello", block.PeekUtf8NullTerminated(4, helloPrefix, stringDecoder, out bytesRead));
                Assert.Equal(bytesRead, 0);
            }
        }

        internal FieldMarshalTableReader(
            int numberOfRows,
            bool declaredSorted,
            int hasFieldMarshalRefSize,
            int blobHeapRefSize,
            MemoryBlock containingBlock,
            int containingBlockOffset
        )
        {
            this.NumberOfRows = numberOfRows;
            _IsHasFieldMarshalRefSizeSmall = hasFieldMarshalRefSize == 2;
            _IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
            _ParentOffset = 0;
            _NativeTypeOffset = _ParentOffset + hasFieldMarshalRefSize;
            this.RowSize = _NativeTypeOffset + blobHeapRefSize;
            this.Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, this.RowSize * numberOfRows);

            if (!declaredSorted && !CheckSorted())
            {
                Throw.TableNotSorted(TableIndex.FieldMarshal);
            }
        }

        internal CustomAttributeTableReader(
            int numberOfRows,
            bool declaredSorted,
            int hasCustomAttributeRefSize,
            int customAttributeTypeRefSize,
            int blobHeapRefSize,
            MemoryBlock containingBlock,
            int containingBlockOffset
        )
        {
            this.NumberOfRows = numberOfRows;
            _IsHasCustomAttributeRefSizeSmall = hasCustomAttributeRefSize == 2;
            _IsCustomAttributeTypeRefSizeSmall = customAttributeTypeRefSize == 2;
            _IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
            _ParentOffset = 0;
            _TypeOffset = _ParentOffset + hasCustomAttributeRefSize;
            _ValueOffset = _TypeOffset + customAttributeTypeRefSize;
            this.RowSize = _ValueOffset + blobHeapRefSize;
            this.Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, (int)(this.RowSize * numberOfRows));
            this.PtrTable = null;

            if (!declaredSorted && !CheckSorted())
            {
                this.PtrTable = this.Block.BuildPtrTable(
                    numberOfRows,
                    this.RowSize,
                    _ParentOffset,
                    _IsHasCustomAttributeRefSizeSmall);
            }
        }

 internal MemberRefTableReader(
     int numberOfRows,
     int memberRefParentRefSize,
     int stringHeapRefSize,
     int blobHeapRefSize,
     MemoryBlock containingBlock,
     int containingBlockOffset
 )
 {
     this.NumberOfRows = numberOfRows;
     _IsMemberRefParentRefSizeSmall = memberRefParentRefSize == 2;
     _IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
     _IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
     _ClassOffset = 0;
     _NameOffset = _ClassOffset + memberRefParentRefSize;
     _SignatureOffset = _NameOffset + stringHeapRefSize;
     this.RowSize = _SignatureOffset + blobHeapRefSize;
     this.Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, (int)(this.RowSize * numberOfRows));
 }

 internal ParamTableReader(
     int numberOfRows,
     int stringHeapRefSize,
     MemoryBlock containingBlock,
     int containingBlockOffset
 )
 {
     this.NumberOfRows = numberOfRows;
     _IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
     _FlagsOffset = 0;
     _SequenceOffset = _FlagsOffset + sizeof(UInt16);
     _NameOffset = _SequenceOffset + sizeof(UInt16);
     this.RowSize = _NameOffset + stringHeapRefSize;
     this.Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, (int)(this.RowSize * numberOfRows));
 }

 internal MethodTableReader(
     int numberOfRows,
     int paramRefSize,
     int stringHeapRefSize,
     int blobHeapRefSize,
     MemoryBlock containingBlock,
     int containingBlockOffset
 )
 {
     this.NumberOfRows = numberOfRows;
     _IsParamRefSizeSmall = paramRefSize == 2;
     _IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
     _IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
     _RVAOffset = 0;
     _ImplFlagsOffset = _RVAOffset + sizeof(UInt32);
     _FlagsOffset = _ImplFlagsOffset + sizeof(UInt16);
     _NameOffset = _FlagsOffset + sizeof(UInt16);
     _SignatureOffset = _NameOffset + stringHeapRefSize;
     _ParamListOffset = _SignatureOffset + blobHeapRefSize;
     this.RowSize = _ParamListOffset + paramRefSize;
     this.Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, (int)(this.RowSize * numberOfRows));
 }

 internal AssemblyRefOSTableReader(
     int numberOfRows,
     int assemblyRefTableRowRefSize,
     MemoryBlock containingBlock,
     int containingBlockOffset)
 {
     this.NumberOfRows = numberOfRows;
     _IsAssemblyRefTableRowRefSizeSmall = assemblyRefTableRowRefSize == 2;
     _OSPlatformIdOffset = 0;
     _OSMajorVersionIdOffset = _OSPlatformIdOffset + sizeof(UInt32);
     _OSMinorVersionIdOffset = _OSMajorVersionIdOffset + sizeof(UInt32);
     _AssemblyRefOffset = _OSMinorVersionIdOffset + sizeof(UInt32);
     this.RowSize = _AssemblyRefOffset + assemblyRefTableRowRefSize;
     this.Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, (int)(this.RowSize * numberOfRows));
 }

 internal AssemblyRefProcessorTableReader(
     int numberOfRows,
     int assemblyRefTableRowRefSize,
     MemoryBlock containingBlock,
     int containingBlockOffset
 )
 {
     this.NumberOfRows = numberOfRows;
     _IsAssemblyRefTableRowSizeSmall = assemblyRefTableRowRefSize == 2;
     _ProcessorOffset = 0;
     _AssemblyRefOffset = _ProcessorOffset + sizeof(UInt32);
     this.RowSize = _AssemblyRefOffset + assemblyRefTableRowRefSize;
     this.Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, (int)(this.RowSize * numberOfRows));
 }

        internal AssemblyRefTableReader(
            int numberOfRows,
            int stringHeapRefSize,
            int blobHeapRefSize,
            MemoryBlock containingBlock,
            int containingBlockOffset,
            MetadataKind metadataKind)
        {
            this.NumberOfNonVirtualRows = numberOfRows;
            this.NumberOfVirtualRows = (metadataKind == MetadataKind.Ecma335) ? 0 : (int)AssemblyReferenceHandle.VirtualIndex.Count;

            _IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
            _IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
            _MajorVersionOffset = 0;
            _MinorVersionOffset = _MajorVersionOffset + sizeof(UInt16);
            _BuildNumberOffset = _MinorVersionOffset + sizeof(UInt16);
            _RevisionNumberOffset = _BuildNumberOffset + sizeof(UInt16);
            _FlagsOffset = _RevisionNumberOffset + sizeof(UInt16);
            _PublicKeyOrTokenOffset = _FlagsOffset + sizeof(UInt32);
            _NameOffset = _PublicKeyOrTokenOffset + blobHeapRefSize;
            _CultureOffset = _NameOffset + stringHeapRefSize;
            _HashValueOffset = _CultureOffset + stringHeapRefSize;
            this.RowSize = _HashValueOffset + blobHeapRefSize;
            this.Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, this.RowSize * numberOfRows);
        }

 internal AssemblyProcessorTableReader(
     int numberOfRows,
     MemoryBlock containingBlock,
     int containingBlockOffset
 )
 {
     this.NumberOfRows = numberOfRows;
     _ProcessorOffset = 0;
     this.RowSize = _ProcessorOffset + sizeof(UInt32);
     this.Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, (int)(this.RowSize * numberOfRows));
 }

        internal AssemblyTableReader(
            int numberOfRows,
            int stringHeapRefSize,
            int blobHeapRefSize,
            MemoryBlock containingBlock,
            int containingBlockOffset
        )
        {
            // NOTE: obfuscated assemblies may have more than one row in Assembly table,
            //       we ignore all rows but the first one
            this.NumberOfRows = numberOfRows > 1 ? 1 : numberOfRows;

            _IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
            _IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
            _HashAlgIdOffset = 0;
            _MajorVersionOffset = _HashAlgIdOffset + sizeof(UInt32);
            _MinorVersionOffset = _MajorVersionOffset + sizeof(UInt16);
            _BuildNumberOffset = _MinorVersionOffset + sizeof(UInt16);
            _RevisionNumberOffset = _BuildNumberOffset + sizeof(UInt16);
            _FlagsOffset = _RevisionNumberOffset + sizeof(UInt16);
            _PublicKeyOffset = _FlagsOffset + sizeof(UInt32);
            _NameOffset = _PublicKeyOffset + blobHeapRefSize;
            _CultureOffset = _NameOffset + stringHeapRefSize;
            this.RowSize = _CultureOffset + stringHeapRefSize;
            this.Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, this.RowSize * numberOfRows);
        }

 internal EnCMapTableReader(
     int numberOfRows,
     MemoryBlock containingBlock,
     int containingBlockOffset)
 {
     this.NumberOfRows = numberOfRows;
     _TokenOffset = 0;
     this.RowSize = _TokenOffset + sizeof(uint);
     this.Block = containingBlock.GetMemoryBlockAt(containingBlockOffset, this.RowSize * numberOfRows);
 }