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)); } }