protected sealed override KeyValuePair <String, ulong>[] ReadNamesAndValues()
{
LowLevelList <KeyValuePair <String, ulong> > namesAndUnboxedValues = new LowLevelList <KeyValuePair <String, ulong> >();
MetadataReader reader = _reader;
foreach (FieldDefinitionHandle fieldHandle in _typeDefinition.GetFields())
{
FieldDefinition field = reader.GetFieldDefinition(fieldHandle);
if (0 != (field.Attributes & FieldAttributes.Static))
{
String name = reader.GetString(field.Name);
if ((field.Attributes & FieldAttributes.HasDefault) != FieldAttributes.HasDefault)
{
throw new BadImageFormatException();
}
ConstantHandle valueHandle = field.GetDefaultValue();
ulong ulValue = ReadUnboxedEnumValue(reader, valueHandle);
namesAndUnboxedValues.Add(new KeyValuePair <String, ulong>(name, ulValue));
}
}
return(namesAndUnboxedValues.ToArray());
}
private ulong HandleConstant(EcmaModule module, ConstantHandle constantHandle)
{
MetadataReader reader = module.MetadataReader;
Constant constant = reader.GetConstant(constantHandle);
BlobReader blob = reader.GetBlobReader(constant.Value);
switch (constant.TypeCode)
{
case ConstantTypeCode.Byte:
return((ulong)blob.ReadByte());
case ConstantTypeCode.Int16:
return((ulong)blob.ReadInt16());
case ConstantTypeCode.Int32:
return((ulong)blob.ReadInt32());
case ConstantTypeCode.Int64:
return((ulong)blob.ReadInt64());
case ConstantTypeCode.SByte:
return((ulong)blob.ReadSByte());
case ConstantTypeCode.UInt16:
return((ulong)blob.ReadUInt16());
case ConstantTypeCode.UInt32:
return((ulong)blob.ReadUInt32());
case ConstantTypeCode.UInt64:
return((ulong)blob.ReadUInt64());
}
System.Diagnostics.Debug.Assert(false);
return(0);
}
private Mapping <ConstantHandle> MapConstantImpl(ConstantHandle handle)
{
Constant constant = _sourceMetadata.GetConstant(handle);
Mapping <Handle> parent = MapHandle(constant.Parent);
if (parent.Target.IsNil)
{
return(new Mapping <ConstantHandle>());
}
ConstantHandle targetHandle;
switch (parent.Target.Kind)
{
case HandleKind.Parameter:
Parameter targetParameter = _targetMetadata.GetParameter((ParameterHandle)parent.Target);
targetHandle = targetParameter.GetDefaultValue();
break;
case HandleKind.FieldDefinition:
FieldDefinition targetFieldDefinition = _targetMetadata.GetFieldDefinition((FieldDefinitionHandle)parent.Target);
targetHandle = targetFieldDefinition.GetDefaultValue();
break;
case HandleKind.PropertyDefinition:
PropertyDefinition targetPropertyDefinition = _targetMetadata.GetPropertyDefinition((PropertyDefinitionHandle)parent.Target);
targetHandle = targetPropertyDefinition.GetDefaultValue();
break;
default:
throw new InvalidOperationException();
}
if (targetHandle.IsNil)
{
return(new Mapping <ConstantHandle>());
}
Constant targetConstant = _targetMetadata.GetConstant(targetHandle);
if (constant.TypeCode != targetConstant.TypeCode)
{
var candidateTargets = ImmutableArray.Create(targetHandle);
var candidateReasons = ImmutableArray.Create("Mapped constant has a different type.");
return(new Mapping <ConstantHandle>(candidateTargets, candidateReasons));
}
ImmutableArray <byte> sourceContent = _sourceMetadata.GetBlobContent(constant.Value);
ImmutableArray <byte> targetContent = _targetMetadata.GetBlobContent(targetConstant.Value);
if (!sourceContent.SequenceEqual(targetContent))
{
var candidateTargets = ImmutableArray.Create(targetHandle);
var candidateReasons = ImmutableArray.Create("Mapped constant has a different value.");
return(new Mapping <ConstantHandle>(candidateTargets, candidateReasons));
}
return(new Mapping <ConstantHandle>(targetHandle));
}
public ConstantEntry(PEFile module, ConstantHandle handle)
{
this.metadataOffset = module.Reader.PEHeaders.MetadataStartOffset;
this.module = module;
this.metadata = module.Metadata;
this.handle = handle;
this.constant = metadata.GetConstant(handle);
}
private static object ConstantValueAsObject(ConstantHandle constantHandle, MetadataReader metadataReader, Type declaredType, bool raw)
{
object defaultValue = constantHandle.ParseConstantValue(metadataReader);
if ((!raw) && declaredType.IsEnum && defaultValue != null)
{
defaultValue = Enum.ToObject(declaredType, defaultValue);
}
return(defaultValue);
}
private void ImportDefaultValue(ConstantHandle defaultValue, EntityHandle dstHandle)
{
if (!defaultValue.IsNil)
{
var srcConst = _reader.GetConstant(defaultValue);
var value = _reader.GetBlobReader(srcConst.Value).ReadConstant(srcConst.TypeCode);
var dstConst = _builder.AddConstant(dstHandle, value);
Trace?.Invoke($"Imported default value {_reader.ToString(srcConst)} -> {RowId(dstConst):X} = {value}");
}
}
//
// This returns the underlying enum values as "ulong" regardless of the actual underlying type. Signed integral types
// get sign-extended into the 64-bit value, unsigned types get zero-extended.
//
public static ulong ReadUnboxedEnumValue(MetadataReader metadataReader, ConstantHandle constantHandle)
{
if (constantHandle.IsNil)
{
throw new BadImageFormatException();
}
Constant constantValue = metadataReader.GetConstant(constantHandle);
if (constantValue.Value.IsNil)
{
throw new BadImageFormatException();
}
BlobReader reader = metadataReader.GetBlobReader(constantValue.Value);
switch (constantValue.TypeCode)
{
case ConstantTypeCode.Boolean:
return(reader.ReadBoolean() ? 1UL : 0UL);;
case ConstantTypeCode.Char:
return((ulong)(long)reader.ReadChar());
case ConstantTypeCode.SByte:
return((ulong)(long)reader.ReadSByte());
case ConstantTypeCode.Int16:
return((ulong)(long)reader.ReadInt16());
case ConstantTypeCode.Int32:
return((ulong)(long)reader.ReadInt32());
case ConstantTypeCode.Int64:
return((ulong)(long)reader.ReadInt64());
case ConstantTypeCode.Byte:
return((ulong)(long)reader.ReadByte());
case ConstantTypeCode.UInt16:
return((ulong)(long)reader.ReadUInt16());
case ConstantTypeCode.UInt32:
return((ulong)(long)reader.ReadUInt32());
case ConstantTypeCode.UInt64:
return((ulong)(long)reader.ReadUInt64());
}
throw new BadImageFormatException();
}
private ulong GetEnumRecordValue(FieldDesc field)
{
var ecmaField = field as EcmaField;
if (ecmaField != null)
{
MetadataReader reader = ecmaField.MetadataReader;
FieldDefinition fieldDef = reader.GetFieldDefinition(ecmaField.Handle);
ConstantHandle defaultValueHandle = fieldDef.GetDefaultValue();
if (!defaultValueHandle.IsNil)
{
return(HandleConstant(ecmaField.Module, defaultValueHandle));
}
}
return(0);
}
public Program.Constant ParseConstant(ConstantHandle handle)
{
var temp = Reader.GetConstant(handle);
var type = ConstantTypeMap[temp.TypeCode];
var val = Reader.GetBlobBytes(temp.Value);
return new Program.Constant(new ElementType(type), null);
}
public static string ToString(this MetadataReader reader, ConstantHandle x) => reader.ToString(reader.GetConstant(x));
public Mapping<ConstantHandle> MapConstant(ConstantHandle handle)
{
return _constants.GetOrAdd(handle, MapConstantImpl);
}
internal Handle GetParent(ConstantHandle handle)
{
int rowOffset = (int)(handle.RowId - 1) * this.RowSize;
return HasConstantTag.ConvertToToken(this.Block.PeekTaggedReference(rowOffset + this.ParentOffset, this.IsHasConstantRefSizeSmall));
}
public Constant GetConstant(ConstantHandle handle)
{
return new Constant(this, handle.RowId);
}
internal EntityHandle GetParent(ConstantHandle handle)
{
int rowOffset = (handle.RowId - 1) * this.RowSize;
return HasConstantTag.ConvertToHandle(this.Block.PeekTaggedReference(rowOffset + _ParentOffset, _IsHasConstantRefSizeSmall));
}
internal ConstantTypeCode GetType(ConstantHandle handle)
{
int rowOffset = (handle.RowId - 1) * this.RowSize;
return (ConstantTypeCode)this.Block.PeekByte(rowOffset + _TypeOffset);
}
public static object?ToRawObject(this ConstantHandle constantHandle, MetadataReader metadataReader)
{
if (constantHandle.IsNil)
{
throw new BadImageFormatException();
}
Constant constantValue = metadataReader.GetConstant(constantHandle);
// Partition II section 24.2.4:
// The first entry in both these heaps is the empty 'blob' that consists of the single byte 0x00.
//
// This means zero value is valid for string and is used to represent the empty string.
if (constantValue.Value.IsNil && constantValue.TypeCode != ConstantTypeCode.String)
{
throw new BadImageFormatException();
}
BlobReader reader = metadataReader.GetBlobReader(constantValue.Value);
switch (constantValue.TypeCode)
{
case ConstantTypeCode.Boolean:
return(reader.ReadBoolean());
case ConstantTypeCode.Char:
return(reader.ReadChar());
case ConstantTypeCode.SByte:
return(reader.ReadSByte());
case ConstantTypeCode.Int16:
return(reader.ReadInt16());
case ConstantTypeCode.Int32:
return(reader.ReadInt32());
case ConstantTypeCode.Int64:
return(reader.ReadInt64());
case ConstantTypeCode.Byte:
return(reader.ReadByte());
case ConstantTypeCode.UInt16:
return(reader.ReadUInt16());
case ConstantTypeCode.UInt32:
return(reader.ReadUInt32());
case ConstantTypeCode.UInt64:
return(reader.ReadUInt64());
case ConstantTypeCode.Single:
return(reader.ReadSingle());
case ConstantTypeCode.Double:
return(reader.ReadDouble());
case ConstantTypeCode.String:
return(reader.ReadUTF16(reader.Length));
case ConstantTypeCode.NullReference:
// Partition II section 22.9:
// The encoding of Type for the nullref value is ELEMENT_TYPE_CLASS with a Value of a 4-byte zero.
// Unlike uses of ELEMENT_TYPE_CLASS in signatures, this one is not followed by a type token.
if (reader.ReadUInt32() == 0)
{
return(null);
}
break;
}
throw new BadImageFormatException();
}
public static Constant GetConstant(this ConstantHandle handle, MetadataReader reader) => reader.GetConstant(handle);
public ReaderConstantValue(MetadataReader reader, ConstantHandle handle)
{
this.reader = reader;
this.handle = handle;
}
private Mapping<ConstantHandle> MapConstantImpl(ConstantHandle handle)
{
Constant constant = _sourceMetadata.GetConstant(handle);
Mapping<Handle> parent = MapHandle(constant.Parent);
if (parent.Target.IsNil)
return new Mapping<ConstantHandle>();
ConstantHandle targetHandle;
switch (parent.Target.Kind)
{
case HandleKind.Parameter:
Parameter targetParameter = _targetMetadata.GetParameter((ParameterHandle)parent.Target);
targetHandle = targetParameter.GetDefaultValue();
break;
case HandleKind.FieldDefinition:
FieldDefinition targetFieldDefinition = _targetMetadata.GetFieldDefinition((FieldDefinitionHandle)parent.Target);
targetHandle = targetFieldDefinition.GetDefaultValue();
break;
case HandleKind.PropertyDefinition:
PropertyDefinition targetPropertyDefinition = _targetMetadata.GetPropertyDefinition((PropertyDefinitionHandle)parent.Target);
targetHandle = targetPropertyDefinition.GetDefaultValue();
break;
default:
throw new InvalidOperationException();
}
if (targetHandle.IsNil)
return new Mapping<ConstantHandle>();
Constant targetConstant = _targetMetadata.GetConstant(targetHandle);
if (constant.TypeCode != targetConstant.TypeCode)
{
var candidateTargets = ImmutableArray.Create(targetHandle);
var candidateReasons = ImmutableArray.Create("Mapped constant has a different type.");
return new Mapping<ConstantHandle>(candidateTargets, candidateReasons);
}
ImmutableArray<byte> sourceContent = _sourceMetadata.GetBlobContent(constant.Value);
ImmutableArray<byte> targetContent = _targetMetadata.GetBlobContent(targetConstant.Value);
if (!sourceContent.SequenceEqual(targetContent))
{
var candidateTargets = ImmutableArray.Create(targetHandle);
var candidateReasons = ImmutableArray.Create("Mapped constant has a different value.");
return new Mapping<ConstantHandle>(candidateTargets, candidateReasons);
}
return new Mapping<ConstantHandle>(targetHandle);
}
internal BlobHandle GetValue(ConstantHandle handle)
{
int rowOffset = (handle.RowId - 1) * this.RowSize;
return BlobHandle.FromOffset(this.Block.PeekHeapReference(rowOffset + _ValueOffset, _IsBlobHeapRefSizeSmall));
}
private static bool IsNil(ConstantHandle x) => x.IsNil;
public static object ToRawObject(this ConstantHandle constantHandle, MetadataReader metadataReader)
{
if (constantHandle.IsNil)
{
throw new BadImageFormatException();
}
Constant constantValue = metadataReader.GetConstant(constantHandle);
if (constantValue.Value.IsNil)
{
throw new BadImageFormatException();
}
BlobReader reader = metadataReader.GetBlobReader(constantValue.Value);
switch (constantValue.TypeCode)
{
case ConstantTypeCode.Boolean:
return(reader.ReadBoolean());
case ConstantTypeCode.Char:
return(reader.ReadChar());
case ConstantTypeCode.SByte:
return(reader.ReadSByte());
case ConstantTypeCode.Int16:
return(reader.ReadInt16());
case ConstantTypeCode.Int32:
return(reader.ReadInt32());
case ConstantTypeCode.Int64:
return(reader.ReadInt64());
case ConstantTypeCode.Byte:
return(reader.ReadByte());
case ConstantTypeCode.UInt16:
return(reader.ReadUInt16());
case ConstantTypeCode.UInt32:
return(reader.ReadUInt32());
case ConstantTypeCode.UInt64:
return(reader.ReadUInt64());
case ConstantTypeCode.Single:
return(reader.ReadSingle());
case ConstantTypeCode.Double:
return(reader.ReadDouble());
case ConstantTypeCode.String:
return(reader.ReadUTF16(reader.Length));
case ConstantTypeCode.NullReference:
// Partition II section 22.9:
// The encoding of Type for the nullref value is ELEMENT_TYPE_CLASS with a Value of a 4-byte zero.
// Unlike uses of ELEMENT_TYPE_CLASS in signatures, this one is not followed by a type token.
if (reader.ReadUInt32() == 0)
{
return(null);
}
break;
}
throw new BadImageFormatException();
}
public Mapping <ConstantHandle> MapConstant(ConstantHandle handle)
{
return(_constants.GetOrAdd(handle, MapConstantImpl));
}
public void IsNil()
{
Assert.False(ModuleDefinitionHandle.FromRowId(1).IsNil);
Assert.False(AssemblyDefinitionHandle.FromRowId(1).IsNil);
Assert.False(InterfaceImplementationHandle.FromRowId(1).IsNil);
Assert.False(MethodDefinitionHandle.FromRowId(1).IsNil);
Assert.False(MethodSpecificationHandle.FromRowId(1).IsNil);
Assert.False(TypeDefinitionHandle.FromRowId(1).IsNil);
Assert.False(ExportedTypeHandle.FromRowId(1).IsNil);
Assert.False(TypeReferenceHandle.FromRowId(1).IsNil);
Assert.False(TypeSpecificationHandle.FromRowId(1).IsNil);
Assert.False(MemberReferenceHandle.FromRowId(1).IsNil);
Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil);
Assert.False(EventDefinitionHandle.FromRowId(1).IsNil);
Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil);
Assert.False(StandaloneSignatureHandle.FromRowId(1).IsNil);
Assert.False(MemberReferenceHandle.FromRowId(1).IsNil);
Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil);
Assert.False(EventDefinitionHandle.FromRowId(1).IsNil);
Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil);
Assert.False(ParameterHandle.FromRowId(1).IsNil);
Assert.False(GenericParameterHandle.FromRowId(1).IsNil);
Assert.False(GenericParameterConstraintHandle.FromRowId(1).IsNil);
Assert.False(ModuleReferenceHandle.FromRowId(1).IsNil);
Assert.False(CustomAttributeHandle.FromRowId(1).IsNil);
Assert.False(DeclarativeSecurityAttributeHandle.FromRowId(1).IsNil);
Assert.False(ManifestResourceHandle.FromRowId(1).IsNil);
Assert.False(ConstantHandle.FromRowId(1).IsNil);
Assert.False(ManifestResourceHandle.FromRowId(1).IsNil);
Assert.False(AssemblyFileHandle.FromRowId(1).IsNil);
Assert.False(MethodImplementationHandle.FromRowId(1).IsNil);
Assert.False(AssemblyReferenceHandle.FromRowId(1).IsNil);
Assert.False(((EntityHandle)ModuleDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)AssemblyDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)InterfaceImplementationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MethodDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MethodSpecificationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)TypeDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ExportedTypeHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)TypeReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)TypeSpecificationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)StandaloneSignatureHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ParameterHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)GenericParameterHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)GenericParameterConstraintHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ModuleReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)CustomAttributeHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ConstantHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)AssemblyFileHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MethodImplementationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)AssemblyReferenceHandle.FromRowId(1)).IsNil);
Assert.False(StringHandle.FromOffset(1).IsNil);
Assert.False(BlobHandle.FromOffset(1).IsNil);
Assert.False(UserStringHandle.FromOffset(1).IsNil);
Assert.False(GuidHandle.FromIndex(1).IsNil);
Assert.False(((Handle)StringHandle.FromOffset(1)).IsNil);
Assert.False(((Handle)BlobHandle.FromOffset(1)).IsNil);
Assert.False(((Handle)UserStringHandle.FromOffset(1)).IsNil);
Assert.False(((Handle)GuidHandle.FromIndex(1)).IsNil);
Assert.True(ModuleDefinitionHandle.FromRowId(0).IsNil);
Assert.True(AssemblyDefinitionHandle.FromRowId(0).IsNil);
Assert.True(InterfaceImplementationHandle.FromRowId(0).IsNil);
Assert.True(MethodDefinitionHandle.FromRowId(0).IsNil);
Assert.True(MethodSpecificationHandle.FromRowId(0).IsNil);
Assert.True(TypeDefinitionHandle.FromRowId(0).IsNil);
Assert.True(ExportedTypeHandle.FromRowId(0).IsNil);
Assert.True(TypeReferenceHandle.FromRowId(0).IsNil);
Assert.True(TypeSpecificationHandle.FromRowId(0).IsNil);
Assert.True(MemberReferenceHandle.FromRowId(0).IsNil);
Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil);
Assert.True(EventDefinitionHandle.FromRowId(0).IsNil);
Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil);
Assert.True(StandaloneSignatureHandle.FromRowId(0).IsNil);
Assert.True(MemberReferenceHandle.FromRowId(0).IsNil);
Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil);
Assert.True(EventDefinitionHandle.FromRowId(0).IsNil);
Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil);
Assert.True(ParameterHandle.FromRowId(0).IsNil);
Assert.True(GenericParameterHandle.FromRowId(0).IsNil);
Assert.True(GenericParameterConstraintHandle.FromRowId(0).IsNil);
Assert.True(ModuleReferenceHandle.FromRowId(0).IsNil);
Assert.True(CustomAttributeHandle.FromRowId(0).IsNil);
Assert.True(DeclarativeSecurityAttributeHandle.FromRowId(0).IsNil);
Assert.True(ManifestResourceHandle.FromRowId(0).IsNil);
Assert.True(ConstantHandle.FromRowId(0).IsNil);
Assert.True(ManifestResourceHandle.FromRowId(0).IsNil);
Assert.True(AssemblyFileHandle.FromRowId(0).IsNil);
Assert.True(MethodImplementationHandle.FromRowId(0).IsNil);
Assert.True(AssemblyReferenceHandle.FromRowId(0).IsNil);
Assert.True(((EntityHandle)ModuleDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)AssemblyDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)InterfaceImplementationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MethodDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MethodSpecificationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)TypeDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ExportedTypeHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)TypeReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)TypeSpecificationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)StandaloneSignatureHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ParameterHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)GenericParameterHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)GenericParameterConstraintHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ModuleReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)CustomAttributeHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ConstantHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)AssemblyFileHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MethodImplementationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)AssemblyReferenceHandle.FromRowId(0)).IsNil);
// heaps:
Assert.True(StringHandle.FromOffset(0).IsNil);
Assert.True(BlobHandle.FromOffset(0).IsNil);
Assert.True(UserStringHandle.FromOffset(0).IsNil);
Assert.True(GuidHandle.FromIndex(0).IsNil);
Assert.True(((Handle)StringHandle.FromOffset(0)).IsNil);
Assert.True(((Handle)BlobHandle.FromOffset(0)).IsNil);
Assert.True(((Handle)UserStringHandle.FromOffset(0)).IsNil);
Assert.True(((Handle)GuidHandle.FromIndex(0)).IsNil);
// virtual:
Assert.False(AssemblyReferenceHandle.FromVirtualIndex(0).IsNil);
Assert.False(StringHandle.FromVirtualIndex(0).IsNil);
Assert.False(BlobHandle.FromVirtualIndex(0, 0).IsNil);
Assert.False(((Handle)AssemblyReferenceHandle.FromVirtualIndex(0)).IsNil);
Assert.False(((Handle)StringHandle.FromVirtualIndex(0)).IsNil);
Assert.False(((Handle)BlobHandle.FromVirtualIndex(0, 0)).IsNil);
}
internal BlobHandle GetValue(ConstantHandle handle)
{
int rowOffset = (int)(handle.RowId - 1) * this.RowSize;
return BlobHandle.FromIndex(this.Block.PeekReference(rowOffset + this.ValueOffset, this.IsBlobHeapRefSizeSmall));
}
