public static int ComputeHashCode(this TypeReferenceHandle typeRefHandle, MetadataReader reader)
{
HashCodeBuilder builder = new HashCodeBuilder("");
TypeReference typeRef = reader.GetTypeReference(typeRefHandle);
HandleType parentHandleType = typeRef.ParentNamespaceOrType.HandleType;
bool isNested = parentHandleType == HandleType.TypeReference;
if (!isNested)
{
Debug.Assert(parentHandleType == HandleType.NamespaceReference);
AppendNamespaceHashCode(ref builder, typeRef.ParentNamespaceOrType.ToNamespaceReferenceHandle(reader), reader);
}
string typeName = reader.GetString(typeRef.TypeName);
builder.Append(typeName);
if (isNested)
{
int enclosingTypeHashCode = typeRef.ParentNamespaceOrType.ToTypeReferenceHandle(reader).ComputeHashCode(reader);
return(TypeHashingAlgorithms.ComputeNestedTypeHashCode(enclosingTypeHashCode, builder.ToHashCode()));
}
return(builder.ToHashCode());
}
public unsafe void TestDefinitionHashCodes()
{
var wr = new Writer.MetadataWriter();
wr.ScopeDefinitions.Add(BuildSimpleTestDefinitionData());
var ms = new MemoryStream();
wr.Write(ms);
fixed(byte *pBuffer = ms.ToArray())
{
var rd = new Reader.MetadataReader((IntPtr)pBuffer, (int)ms.Length);
Reader.ScopeDefinitionHandle scopeHandle = rd.ScopeDefinitions.Single();
Reader.ScopeDefinition systemRuntimeScope = scopeHandle.GetScopeDefinition(rd);
// Validate root type hash code
Reader.NamespaceDefinition rootNamespace = systemRuntimeScope.RootNamespaceDefinition.GetNamespaceDefinition(rd);
Reader.TypeDefinitionHandle moduleTypeHandle = rootNamespace.TypeDefinitions.Single();
Assert.Equal(TypeHashingAlgorithms.ComputeNameHashCode("<Module>"), MetadataTypeHashingAlgorithms.ComputeHashCode(moduleTypeHandle, rd));
// Validate namespace type hashcode
Reader.NamespaceDefinition systemNamespace = rootNamespace.NamespaceDefinitions.Single().GetNamespaceDefinition(rd);
Reader.TypeDefinitionHandle objectTypeHandle = systemNamespace.TypeDefinitions.Single();
int objectHashCode = TypeHashingAlgorithms.ComputeNameHashCode("System.Object");
Assert.Equal(objectHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(objectTypeHandle, rd));
// Validate nested type hashcode
Reader.TypeDefinitionHandle nestedTypeHandle = objectTypeHandle.GetTypeDefinition(rd).NestedTypes.Single();
int nestedHashCode = TypeHashingAlgorithms.ComputeNestedTypeHashCode(objectHashCode, TypeHashingAlgorithms.ComputeNameHashCode("Nested"));
Assert.Equal(nestedHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(nestedTypeHandle, rd));
// Validate really nested type hashcode
Reader.TypeDefinitionHandle reallyNestedTypeHandle = nestedTypeHandle.GetTypeDefinition(rd).NestedTypes.Single();
int reallyNestedHashCode = TypeHashingAlgorithms.ComputeNestedTypeHashCode(nestedHashCode, TypeHashingAlgorithms.ComputeNameHashCode("ReallyNested"));
Assert.Equal(reallyNestedHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(reallyNestedTypeHandle, rd));
}
}
public static int ComputeHashCode(this TypeDefinitionHandle typeDefHandle, MetadataReader reader)
{
HashCodeBuilder builder = new HashCodeBuilder("");
TypeDefinition typeDef = reader.GetTypeDefinition(typeDefHandle);
bool isNested = typeDef.Flags.IsNested();
if (!isNested)
{
AppendNamespaceHashCode(ref builder, typeDef.NamespaceDefinition, reader);
}
string typeName = reader.GetString(typeDef.Name);
builder.Append(typeName);
if (isNested)
{
int enclosingTypeHashCode = typeDef.EnclosingType.ComputeHashCode(reader);
return(TypeHashingAlgorithms.ComputeNestedTypeHashCode(enclosingTypeHashCode, builder.ToHashCode()));
}
return(builder.ToHashCode());
}
public unsafe void TestReferenceHashCodes()
{
var wr = new Writer.MetadataWriter();
var systemRuntimeScopeRecord = new Writer.ScopeReference
{
Name = (Writer.ConstantStringValue) "System.Runtime",
MajorVersion = 4,
};
var rootNamespaceRecord = new Writer.NamespaceReference
{
Name = null,
ParentScopeOrNamespace = systemRuntimeScopeRecord,
};
var fooTypeRecord = new Writer.TypeReference
{
ParentNamespaceOrType = rootNamespaceRecord,
TypeName = (Writer.ConstantStringValue) "Foo",
};
var nestedTypeRecord = new Writer.TypeReference
{
ParentNamespaceOrType = fooTypeRecord,
TypeName = (Writer.ConstantStringValue) "Nested",
};
var reallyNestedTypeRecord = new Writer.TypeReference
{
ParentNamespaceOrType = nestedTypeRecord,
TypeName = (Writer.ConstantStringValue) "ReallyNested",
};
var systemNamespaceRecord = new Writer.NamespaceReference
{
Name = (Writer.ConstantStringValue) "System",
ParentScopeOrNamespace = rootNamespaceRecord,
};
var objectTypeRecord = new Writer.TypeReference
{
ParentNamespaceOrType = systemNamespaceRecord,
TypeName = (Writer.ConstantStringValue) "Object",
};
wr.AdditionalRootRecords.Add(objectTypeRecord);
wr.AdditionalRootRecords.Add(fooTypeRecord);
wr.AdditionalRootRecords.Add(nestedTypeRecord);
wr.AdditionalRootRecords.Add(reallyNestedTypeRecord);
var ms = new MemoryStream();
wr.Write(ms);
fixed(byte *pBuffer = ms.ToArray())
{
var rd = new Reader.MetadataReader((IntPtr)pBuffer, (int)ms.Length);
var fooTypeHandle = new Reader.TypeReferenceHandle(wr.GetRecordHandle(fooTypeRecord));
var fooTypeHashCode = TypeHashingAlgorithms.ComputeNameHashCode("Foo");
Assert.Equal(fooTypeHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(fooTypeHandle, rd));
var objectTypeHandle = new Reader.TypeReferenceHandle(wr.GetRecordHandle(objectTypeRecord));
Assert.Equal(TypeHashingAlgorithms.ComputeNameHashCode("System.Object"), MetadataTypeHashingAlgorithms.ComputeHashCode(objectTypeHandle, rd));
var nestedTypeHandle = new Reader.TypeReferenceHandle(wr.GetRecordHandle(nestedTypeRecord));
var nestedTypeHashCode = TypeHashingAlgorithms.ComputeNestedTypeHashCode(fooTypeHashCode, TypeHashingAlgorithms.ComputeNameHashCode("Nested"));
Assert.Equal(nestedTypeHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(nestedTypeHandle, rd));
var reallyNestedTypeHandle = new Reader.TypeReferenceHandle(wr.GetRecordHandle(reallyNestedTypeRecord));
var reallyNestedTypeHashCode = TypeHashingAlgorithms.ComputeNestedTypeHashCode(nestedTypeHashCode, TypeHashingAlgorithms.ComputeNameHashCode("ReallyNested"));
Assert.Equal(reallyNestedTypeHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(reallyNestedTypeHandle, rd));
}
}
