/// <summary>
/// Read a string token from the signature stream and convert it to the actual string.
/// </summary>
/// <returns></returns>
private void ParseStringHandle(StringBuilder builder)
{
uint rid = ReadUInt();
UserStringHandle stringHandle = MetadataTokens.UserStringHandle((int)rid);
builder.Append(_metadataReader.GetUserString(stringHandle));
}
internal unsafe BlobReader GetStringAsBlobReader(UserStringHandle handle)
{
int offset, size;
var result = Block.PeekHeapValueOffsetAndSize(handle.GetHeapOffset(), out offset, out size);
Debug.Assert(result);
return(new BlobReader(Block.Pointer + offset, size - 1));
}
/// <summary>
/// Returns the a handle to the UserString that follows the given one in the UserString heap or a nil handle if it is the last one.
/// </summary>
/// <exception cref="ArgumentNullException"><paramref name="reader"/> is null.</exception>
public static UserStringHandle GetNextHandle(this MetadataReader reader, UserStringHandle handle)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
return(reader.UserStringStream.GetNextHandle(handle));
}
/// <summary>
/// Returns the a handle to the UserString that follows the given one in the UserString heap or a nil handle if it is the last one.
/// </summary>
/// <exception cref="ArgumentNullException"><paramref name="reader"/> is null.</exception>
public static UserStringHandle GetNextHandle(this MetadataReader reader, UserStringHandle handle)
{
if (reader == null)
{
Throw.ArgumentNull(nameof(reader));
}
return(reader.UserStringStream.GetNextHandle(handle));
}
private static string GetArgumentString(MetadataReader metadataReader, int intOperand, out bool isPrintable)
{
if (IsUserString(intOperand))
{
UserStringHandle usrStr = MetadataTokens.UserStringHandle(intOperand);
var str = metadataReader.GetUserString(usrStr);
str = ProcessAndNormalizeString(str, out isPrintable);
return(str);
}
throw new ArgumentException("Invalid argument, must be a user string metadata token.");
}
public string GetUserString(UserStringHandle handle)
{
lock (_cache)
{
if (_cache.Entities.TryGetValue(MetadataTokens.GetToken(handle), out var result))
{
return((string)result);
}
}
throw new ArgumentException("Invalid UserStringHandle passed to MutableModule.GetObject");
}
internal string GetString(UserStringHandle handle)
{
int offset, size;
if (!Block.PeekHeapValueOffsetAndSize(handle.GetHeapOffset(), out offset, out size))
{
return string.Empty;
}
// Spec: Furthermore, there is an additional terminal byte (so all byte counts are odd, not even).
// The size in the blob header is the length of the string in bytes + 1.
return Block.PeekUtf16(offset, size & ~1);
}
private UserStringHandle GetNewUserStringHandle()
{
int offset = _userStringHeapStartOffset + _userStringBuilder.Count;
// Native metadata emitter allows strings to exceed the heap size limit as long
// as the index is within the limits (see https://github.com/dotnet/roslyn/issues/9852)
if (offset >= UserStringHeapSizeLimit)
{
Throw.HeapSizeLimitExceeded(HeapIndex.UserString);
}
return(UserStringHandle.FromOffset(offset));
}
public UserStringHeapTreeNode(PEFile module, MetadataReader metadata)
: base(HandleKind.UserString, module, metadata)
{
list = new List <UserStringHeapEntry>();
UserStringHandle handle = MetadataTokens.UserStringHandle(0);
do
{
UserStringHeapEntry entry = new UserStringHeapEntry(metadata, handle);
list.Add(entry);
handle = metadata.GetNextHandle(handle);
} while (!handle.IsNil);
}
internal UserStringHandle GetNextHandle(UserStringHandle handle)
{
int offset, size;
if (!Block.PeekHeapValueOffsetAndSize(handle.GetHeapOffset(), out offset, out size))
{
return default(UserStringHandle);
}
int nextIndex = offset + size;
if (nextIndex >= Block.Length)
{
return default(UserStringHandle);
}
return UserStringHandle.FromOffset(nextIndex);
}
internal UserStringHandle GetNextHandle(UserStringHandle handle)
{
int offset, size;
if (!Block.PeekHeapValueOffsetAndSize(handle.Index, out offset, out size))
{
return(default(UserStringHandle));
}
int nextIndex = offset + size;
if (nextIndex >= Block.Length)
{
return(default(UserStringHandle));
}
return(UserStringHandle.FromIndex((uint)nextIndex));
}
internal int SerializeHandle(UserStringHandle handle) => handle.GetHeapOffset();
/// <summary> /// Returns the offset of metadata heap data that corresponds /// to the specified <paramref name="handle"/>. /// </summary> /// <returns> /// Zero based offset, or -1 if <paramref name="handle"/> can only be interpreted in a context of a specific <see cref="MetadataReader"/> or <see cref="MetadataBuilder"/>. /// See <see cref="GetHeapOffset(MetadataReader, Handle)"/>. /// </returns> public static int GetHeapOffset(UserStringHandle handle) => handle.GetHeapOffset();
public void LoadString(UserStringHandle handle)
{
OpCode(ILOpCode.Ldstr);
Token(MetadataTokens.GetToken(handle));
}
/// <summary> /// Returns the offset of metadata heap data that corresponds /// to the specified <paramref name="handle"/>. /// </summary> /// <returns> /// Zero based offset, or -1 if <paramref name="handle"/> can only be interpreted in a context of a specific <see cref="MetadataReader"/> or <see cref="MetadataBuilder"/>. /// See <see cref="GetHeapOffset(MetadataReader, Handle)"/>. /// </returns> internal static int GetHeapOffset(UserStringHandle handle) => handle.GetHeapOffset();
/// <summary> /// Returns the offset of metadata heap data that corresponds /// to the specified <paramref name="handle"/>. /// </summary> /// <returns> /// Zero based offset, or -1 if <paramref name="handle"/> can only be interpreted in a context of a specific <see cref="MetadataReader"/> or <see cref="MetadataBuilder"/>. /// See <see cref="GetHeapOffset(MetadataReader, Handle)"/>. /// </returns> public static int GetHeapOffset(UserStringHandle handle) => handle.GetHeapOffset();
public UserStringHeapEntry(MetadataReader metadata, UserStringHandle handle)
{
this.metadata = metadata;
this.handle = handle;
}
private int InspectILBlock(
ImmutableArray <byte> ilBytes,
int length,
IReadOnlyList <HandlerSpan> spans,
int blockOffset,
int curIndex,
int spanIndex,
IReadOnlyDictionary <int, string> markers,
out int nextSpanIndex)
{
int lastSpanIndex = spanIndex - 1;
List <string> loadedValues = new List <string>();
while (curIndex < length)
{
if (lastSpanIndex > 0 && StartsFilterHandler(spans, lastSpanIndex, curIndex + blockOffset))
{
}
if (StartsSpan(spans, spanIndex, curIndex + blockOffset))
{
curIndex = InspectILBlock(ilBytes, length, spans, blockOffset, curIndex, spanIndex + 1, markers, out spanIndex);
}
else
{
int ilOffset = curIndex + blockOffset;
string marker;
if (markers != null && markers.TryGetValue(ilOffset, out marker))
{
}
else
{
}
OpCode opCode;
int expectedSize;
byte op1 = ilBytes[curIndex++];
if (op1 == 0xfe && curIndex < length)
{
byte op2 = ilBytes[curIndex++];
opCode = s_twoByteOpCodes[op2];
expectedSize = 2;
}
else
{
opCode = s_oneByteOpCodes[op1];
expectedSize = 1;
}
if (opCode.Size != expectedSize)
{
//sb.AppendLine(string.Format(" <unknown 0x{0}{1:X2}>", expectedSize == 2 ? "fe" : "", op1));
continue;
}
//sb.Append(" ");
// Console.WriteLine (opCode.OperandType == OperandType.InlineNone ? "{0} {1}" : "{0,-10} {1}", opCode, opCode.OperandType);
switch (opCode.OperandType)
{
case OperandType.InlineField:
// read token
uint fieldToken = ReadUInt32(ilBytes, ref curIndex);
// get the kind
uint tokenKind = fieldToken & TokenTypeIds.TokenTypeMask;
// and the rowId
uint rowId = fieldToken & TokenTypeIds.RIDMask;
var fieldHandle = MetadataTokens.FieldDefinitionHandle((int)rowId);
var fieldDef = metaReader.GetFieldDefinition(fieldHandle);
// No way to predetermine if fieldDef.Name is valid
try
{
var fieldName = metaReader.GetString(fieldDef.Name);
if (opCode.ToString() == "stfld")
{
InspectorField inspectorField;
if (_inspectorComponent.Fields.TryGetValue(fieldName, out inspectorField))
{
inspectorField.DefaultValue = String.Join(" ", loadedValues.ToArray());
}
}
}
catch (Exception) { break; }
finally
{
loadedValues.Clear();
}
break;
case OperandType.InlineMethod:
// new Vector3, etc
if (opCode.ToString() == "newobj")
{
}
else
{
loadedValues.Clear();
}
break;
case OperandType.InlineTok:
case OperandType.InlineType:
ReadUInt32(ilBytes, ref curIndex);
loadedValues.Clear();
break;
case OperandType.InlineSig: // signature (calli), not emitted by C#/VB
ReadUInt32(ilBytes, ref curIndex);
loadedValues.Clear();
break;
case OperandType.InlineString:
//sb.Append(" 391 ");
//sb.Append(VisualizeUserString());
uint stringToken = ReadUInt32(ilBytes, ref curIndex);
// get the kind
//uint tokenKind = stringToken & TokenTypeIds.TokenTypeMask;
// and the rowId
//uint rowId = stringToken & TokenTypeIds.RIDMask;
UserStringHandle handle = MetadataTokens.UserStringHandle((int)stringToken);
loadedValues.Add(metaReader.GetUserString(handle));
break;
case OperandType.InlineNone:
if (opCode == OpCodes.Ldc_I4_0)
{
loadedValues.Add("0");
}
else if (opCode == OpCodes.Ldc_I4_1)
{
loadedValues.Add("1");
}
else if (opCode == OpCodes.Ldc_I4_2)
{
loadedValues.Add("2");
}
else if (opCode == OpCodes.Ldc_I4_3)
{
loadedValues.Add("3");
}
else if (opCode == OpCodes.Ldc_I4_4)
{
loadedValues.Add("4");
}
else if (opCode == OpCodes.Ldc_I4_5)
{
loadedValues.Add("5");
}
else if (opCode == OpCodes.Ldc_I4_6)
{
loadedValues.Add("6");
}
else if (opCode == OpCodes.Ldc_I4_7)
{
loadedValues.Add("7");
}
else if (opCode == OpCodes.Ldc_I4_8)
{
loadedValues.Add("8");
}
else if (opCode == OpCodes.Ldc_I4_M1)
{
loadedValues.Add("-1");
}
break;
case OperandType.ShortInlineI:
loadedValues.Add(ReadSByte(ilBytes, ref curIndex).ToString());
break;
case OperandType.ShortInlineVar:
loadedValues.Add(ReadByte(ilBytes, ref curIndex).ToString());
break;
case OperandType.InlineVar:
loadedValues.Add(ReadUInt16(ilBytes, ref curIndex).ToString());
break;
case OperandType.InlineI:
loadedValues.Add(ReadUInt32(ilBytes, ref curIndex).ToString());
break;
case OperandType.InlineI8:
loadedValues.Add(ReadUInt64(ilBytes, ref curIndex).ToString());
break;
case OperandType.ShortInlineR:
{
loadedValues.Add(ReadSingle(ilBytes, ref curIndex).ToString());
}
break;
case OperandType.InlineR:
{
loadedValues.Add(ReadDouble(ilBytes, ref curIndex).ToString());
}
break;
case OperandType.ShortInlineBrTarget:
loadedValues.Clear();
var sbyteValue = ReadSByte(ilBytes, ref curIndex) + curIndex + blockOffset;
break;
case OperandType.InlineBrTarget:
loadedValues.Clear();
var int32value = ReadInt32(ilBytes, ref curIndex) + curIndex + blockOffset;
break;
case OperandType.InlineSwitch:
loadedValues.Clear();
int labelCount = ReadInt32(ilBytes, ref curIndex);
int instrEnd = curIndex + labelCount * 4;
for (int i = 0; i < labelCount; i++)
{
var int32LabelValue = ReadInt32(ilBytes, ref curIndex) + instrEnd + blockOffset;
//sb.AppendLine((i == labelCount - 1) ? ")" : ",");
}
break;
default:
throw new InvalidOperationException();
//throw ExceptionUtilities.UnexpectedValue(opCode.OperandType);
}
//sb.AppendLine();
}
if (EndsSpan(spans, lastSpanIndex, curIndex + blockOffset))
{
break;
}
}
nextSpanIndex = spanIndex;
return(curIndex);
}
public string GetUserString(UserStringHandle userStringHandle)
{
// String literals are not cached
return(_metadataReader.GetUserString(userStringHandle));
}
public string GetUserString(UserStringHandle handle)
{
return UserStringStream.GetString(handle);
}
/// <summary>
/// Returns the a handle to the UserString that follows the given one in the UserString heap or a nil handle if it is the last one.
/// </summary>
/// <exception cref="ArgumentNullException"><paramref name="reader"/> is null.</exception>
public static UserStringHandle GetNextHandle(this MetadataReader reader, UserStringHandle handle)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
return reader.UserStringStream.GetNextHandle(handle);
}
public static string GetUserString(this UserStringHandle handle, MetadataReader reader) => reader.GetUserString(handle);
public int GetHeapOffset(UserStringHandle handle)
{
return(MetadataTokens.GetHeapOffset(handle));
}
public void LoadString(UserStringHandle handle)
{
OpCode(ILOpCode.Ldstr);
Token(MetadataTokens.GetToken(handle));
}
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);
}
/// <summary>
/// Returns the a handle to the UserString that follows the given one in the UserString heap or a nil handle if it is the last one.
/// </summary>
/// <exception cref="ArgumentNullException"><paramref name="reader"/> is null.</exception>
public static UserStringHandle GetNextHandle(this MetadataReader reader, UserStringHandle handle)
{
if (reader == null)
{
Throw.ArgumentNull(nameof(reader));
}
return reader.UserStringHeap.GetNextHandle(handle);
}
