public override void VisitAssemblyNameReference(AssemblyNameReference name)
{
byte [] pkortoken;
if (name.PublicKey != null && name.PublicKey.Length > 0)
{
pkortoken = name.PublicKey;
}
else if (name.PublicKeyToken != null && name.PublicKeyToken.Length > 0)
{
pkortoken = name.PublicKeyToken;
}
else
{
pkortoken = new byte [0];
}
AssemblyRefTable arTable = m_tableWriter.GetAssemblyRefTable();
AssemblyRefRow arRow = m_rowWriter.CreateAssemblyRefRow(
(ushort)name.Version.Major,
(ushort)name.Version.Minor,
(ushort)name.Version.Build,
(ushort)name.Version.Revision,
name.Flags,
m_mdWriter.AddBlob(pkortoken),
m_mdWriter.AddString(name.Name),
m_mdWriter.AddString(name.Culture),
m_mdWriter.AddBlob(name.Hash));
arTable.Rows.Add(arRow);
}
public override void FromRawData(byte [] buff, int offs, int numRows)
{
for (int i = numRows; --i >= 0;)
{
Row row = new AssemblyRefRow(this);
row.FromRawData(buff, offs);
Add(row);
offs += AssemblyRefRow.LogicalSize;
}
}
/// <summary>
/// Reads the specified token.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="result">The result.</param>
public void Read(TokenTypes token, out AssemblyRefRow result)
{
if ((token & TokenTypes.TableMask) != TokenTypes.AssemblyRef)
{
throw new ArgumentException("Invalid token type for AssemblyRefRow.", "token");
}
using (BinaryReader reader = CreateReaderForToken(token))
{
result = new AssemblyRefRow(reader.ReadUInt16(), reader.ReadUInt16(), reader.ReadUInt16(), reader.ReadUInt16(), (AssemblyFlags)reader.ReadUInt32(), ReadIndexValue(reader, IndexType.BlobHeap), ReadIndexValue(reader, IndexType.StringHeap), ReadIndexValue(reader, IndexType.StringHeap), ReadIndexValue(reader, IndexType.BlobHeap));
}
}
/// <summary>
/// Resolves the given assembly reference and loads the associated IMetadataModule.
/// </summary>
/// <param name="provider">The metadata provider, which contained the assembly reference.</param>
/// <param name="assemblyRef">The assembly reference to resolve.</param>
/// <returns>
/// An instance of IMetadataModule representing the resolved assembly.
/// </returns>
public IMetadataModule Resolve(IMetadataProvider provider, AssemblyRefRow assemblyRef)
{
string name;
provider.Read(assemblyRef.NameIdx, out name);
IMetadataModule result = GetLoadedAssembly(name) ?? DoLoadAssembly(name + ".dll");
if (result == null)
{
throw new TypeLoadException();
}
return(result);
}
public override void VisitAssemblyNameReferenceCollection(AssemblyNameReferenceCollection names)
{
if (!m_tHeap.HasTable(AssemblyRefTable.RId))
{
return;
}
AssemblyRefTable arTable = m_tableReader.GetAssemblyRefTable();
for (int i = 0; i < arTable.Rows.Count; i++)
{
AssemblyRefRow arRow = arTable [i];
AssemblyNameReference aname = new AssemblyNameReference(
ReadString(arRow.Name),
ReadString(arRow.Culture),
new Version(arRow.MajorVersion, arRow.MinorVersion,
arRow.BuildNumber, arRow.RevisionNumber));
aname.PublicKeyToken = ReadBlob(arRow.PublicKeyOrToken);
aname.Hash = ReadBlob(arRow.HashValue);
aname.MetadataToken = new MetadataToken(TokenType.AssemblyRef, (uint)i + 1);
names.Add(aname);
}
}
private IMetadataModule LoadDependencies(string file)
{
IMetadataModule metadataModule = LoadAssembly(file);
if (!isLoaded(metadataModule.Name))
{
Token maxToken = metadataModule.Metadata.GetMaxTokenValue(TableType.AssemblyRef);
//for (TokenTypes token = TokenTypes.AssemblyRef + 1; token <= maxToken; token++)
foreach (Token token in new Token(TableType.AssemblyRef, 1).Upto(maxToken))
{
AssemblyRefRow row = metadataModule.Metadata.ReadAssemblyRefRow(token);
string assembly = metadataModule.Metadata.ReadString(row.Name);
LoadDependencies(assembly);
}
if (!isLoaded(metadataModule.Name))
{
modules.Add(metadataModule);
}
}
return(metadataModule);
}
public virtual void VisitAssemblyRefRow(AssemblyRefRow row)
{
}
public AssemblyRefRowExt(IMetadataProvider metadata, AssemblyRefRow row)
: base(metadata)
{
this.row = row;
}
void IMetadataProvider.Read(TokenTypes token, out AssemblyRefRow result)
{
TableHeap theap = (TableHeap)_streams[(int)HeapType.Tables];
theap.Read(token, out result);
}
public virtual void VisitAssemblyRefRow(AssemblyRefRow row)
{
}
public static AssemblyReference Resolve(uint rid, AssemblyRefRow row, MetadataSystem metadata)
{
var resolver = new AssemblyReferenceResolver(rid, row, metadata);
return(new AssemblyReference(resolver));
}
private AssemblyReferenceResolver(uint rid, AssemblyRefRow row, MetadataSystem metadata)
{
_token = new MetadataToken(MetadataTokenType.AssemblyRef, rid);
_row = row;
_metadata = metadata;
}
/// <summary>
/// Loads the interfaces.
/// </summary>
protected void LoadTypeReferences()
{
Token maxToken = GetMaxTokenValue(TableType.TypeRef);
foreach (Token token in new Token(TableType.TypeRef, 1).Upto(maxToken))
{
RuntimeType runtimeType = null;
TypeRefRow row = metadataProvider.ReadTypeRefRow(token);
string typeName = GetString(row.TypeNameIdx);
switch (row.ResolutionScope.Table)
{
case TableType.Module:
goto case TableType.TypeRef;
case TableType.TypeDef:
throw new NotImplementedException();
case TableType.TypeRef:
{
TypeRefRow row2 = metadataProvider.ReadTypeRefRow(row.ResolutionScope);
string typeName2 = GetString(row2.TypeNameIdx);
string typeNamespace2 = GetString(row2.TypeNamespaceIdx) + "." + typeName2;
AssemblyRefRow asmRefRow = metadataProvider.ReadAssemblyRefRow(row2.ResolutionScope);
string assemblyName = GetString(asmRefRow.Name);
ITypeModule module = typeSystem.ResolveModuleReference(assemblyName);
runtimeType = module.GetType(typeNamespace2, typeName);
if (runtimeType == null)
{
throw new TypeLoadException("Could not find type: " + typeNamespace2 + Type.Delimiter + typeName);
}
break;
}
case TableType.TypeSpec:
throw new NotImplementedException();
case TableType.ModuleRef:
throw new NotImplementedException();
case TableType.AssemblyRef:
{
string typeNamespace = GetString(row.TypeNamespaceIdx);
AssemblyRefRow asmRefRow = metadataProvider.ReadAssemblyRefRow(row.ResolutionScope);
string assemblyName = GetString(asmRefRow.Name);
ITypeModule module = typeSystem.ResolveModuleReference(assemblyName);
runtimeType = module.GetType(typeNamespace, typeName);
if (runtimeType == null)
{
throw new TypeLoadException("Could not find type: " + typeNamespace + Type.Delimiter + typeName);
}
break;
}
default:
throw new NotImplementedException();
}
typeRef[token.RID - 1] = runtimeType;
}
}
