private void InitializeScopeReference(Cts.ModuleDesc module, ScopeReference scopeReference)
{
var assemblyDesc = module as Cts.IAssemblyDesc;
if (assemblyDesc != null)
{
var assemblyName = assemblyDesc.GetName();
scopeReference.Name = HandleString(assemblyName.Name);
scopeReference.Culture = HandleString(assemblyName.CultureName);
scopeReference.MajorVersion = checked ((ushort)assemblyName.Version.Major);
scopeReference.MinorVersion = checked ((ushort)assemblyName.Version.Minor);
scopeReference.BuildNumber = checked ((ushort)assemblyName.Version.Build);
scopeReference.RevisionNumber = checked ((ushort)assemblyName.Version.Revision);
Debug.Assert((int)AssemblyFlags.PublicKey == (int)AssemblyNameFlags.PublicKey);
Debug.Assert((int)AssemblyFlags.Retargetable == (int)AssemblyNameFlags.Retargetable);
// References use a public key token instead of full public key.
scopeReference.Flags = (AssemblyFlags)(assemblyName.Flags & ~AssemblyNameFlags.PublicKey);
if (assemblyName.ContentType == AssemblyContentType.WindowsRuntime)
{
scopeReference.Flags |= (AssemblyFlags)((int)AssemblyContentType.WindowsRuntime << 9);
}
scopeReference.PublicKeyOrToken = assemblyName.GetPublicKeyToken();
}
else
{
throw new NotSupportedException("Multi-module assemblies");
}
}
private Object ResolveAssemblyReference(ScopeReferenceHandle handle)
{
ScopeReference assemblyReference = _metadataReader.GetScopeReference(handle);
AssemblyName an = new AssemblyName();
an.Name = _metadataReader.GetString(assemblyReference.Name);
an.Version = new Version(assemblyReference.MajorVersion, assemblyReference.MinorVersion, assemblyReference.BuildNumber, assemblyReference.RevisionNumber);
an.CultureName = _metadataReader.GetString(assemblyReference.Culture) ?? "";
var publicKeyOrToken = assemblyReference.PublicKeyOrToken.ConvertByteCollectionToArray();
if ((assemblyReference.Flags & AssemblyFlags.PublicKey) != 0)
{
an.SetPublicKey(publicKeyOrToken);
}
else
{
an.SetPublicKeyToken(publicKeyOrToken);
}
// TODO: ContentType - depends on newer version of the System.Reflection contract
return(Context.ResolveAssembly(an));
}
private void CheckTypeReferenceForProperWinRTHome(TypeReference typeReference, string module)
{
ScopeReference scope = GetScopeReferenceOfType(typeReference);
Assert.Equal(module, scope.Name.Value);
int windowsRuntimeFlag = ((int)System.Reflection.AssemblyContentType.WindowsRuntime << 9);
Assert.True((((int)scope.Flags) & windowsRuntimeFlag) == windowsRuntimeFlag);
}
private NamespaceReference HandleNamespaceReference(Cts.ModuleDesc parentScope, string namespaceString)
{
NamespaceReference result;
NamespaceKey key = new NamespaceKey(parentScope, namespaceString);
if (_namespaceRefs.TryGetValue(key, out result))
{
return(result);
}
ScopeReference scope = HandleScopeReference(parentScope);
NamespaceReference rootNamespace;
key = new NamespaceKey(parentScope, null);
if (!_namespaceRefs.TryGetValue(key, out rootNamespace))
{
rootNamespace = new NamespaceReference
{
Name = null,
ParentScopeOrNamespace = scope,
};
_namespaceRefs.Add(key, rootNamespace);
}
NamespaceReference currentNamespace = rootNamespace;
string currentNamespaceName = String.Empty;
foreach (var segment in namespaceString.Split('.'))
{
string nextNamespaceName = currentNamespaceName;
if (nextNamespaceName.Length > 0)
{
nextNamespaceName = nextNamespaceName + '.';
}
nextNamespaceName += segment;
NamespaceReference nextNamespace;
key = new NamespaceKey(parentScope, nextNamespaceName);
if (!_namespaceRefs.TryGetValue(key, out nextNamespace))
{
nextNamespace = new NamespaceReference
{
Name = HandleString(segment.Length == 0 ? null : segment),
ParentScopeOrNamespace = currentNamespace
};
_namespaceRefs.Add(key, nextNamespace);
}
currentNamespace = nextNamespace;
currentNamespaceName = nextNamespaceName;
}
return(currentNamespace);
}
public ScopeReference GetScopeReferenceOfType(TypeReference typeReference)
{
Assert.NotNull(typeReference);
ScopeReference scope = null;
NamespaceReference currentNamespaceReference = typeReference.ParentNamespaceOrType as NamespaceReference;
while (scope == null)
{
Assert.NotNull(currentNamespaceReference);
scope = currentNamespaceReference.ParentScopeOrNamespace as ScopeReference;
currentNamespaceReference = currentNamespaceReference.ParentScopeOrNamespace as NamespaceReference;
}
return(scope);
}
public static RuntimeAssemblyName ToRuntimeAssemblyName(this ScopeReferenceHandle scopeReferenceHandle, MetadataReader reader)
{
ScopeReference scopeReference = scopeReferenceHandle.GetScopeReference(reader);
return(CreateRuntimeAssemblyNameFromMetadata(
reader,
scopeReference.Name,
scopeReference.MajorVersion,
scopeReference.MinorVersion,
scopeReference.BuildNumber,
scopeReference.RevisionNumber,
scopeReference.Culture,
scopeReference.PublicKeyOrToken,
scopeReference.Flags
));
}
public void ScopeReference()
{
var scopeProvider = ScopeProvider;
var scope = scopeProvider.CreateScope();
var nested = scopeProvider.CreateScope();
Assert.IsNotNull(scopeProvider.AmbientScope);
var scopeRef = new ScopeReference(scopeProvider);
scopeRef.Dispose();
Assert.IsNull(scopeProvider.AmbientScope);
Assert.Throws <ObjectDisposedException>(() =>
{
var db = scope.Database;
});
Assert.Throws <ObjectDisposedException>(() =>
{
var db = nested.Database;
});
}
private void InitializeScopeReference(AssemblyName assemblyName, ScopeReference scopeReference)
{
scopeReference.Name = HandleString(assemblyName.Name);
scopeReference.Culture = HandleString(assemblyName.CultureName);
scopeReference.MajorVersion = checked ((ushort)assemblyName.Version.Major);
scopeReference.MinorVersion = checked ((ushort)assemblyName.Version.Minor);
scopeReference.BuildNumber = checked ((ushort)assemblyName.Version.Build);
scopeReference.RevisionNumber = checked ((ushort)assemblyName.Version.Revision);
Debug.Assert((int)AssemblyFlags.PublicKey == (int)AssemblyNameFlags.PublicKey);
Debug.Assert((int)AssemblyFlags.Retargetable == (int)AssemblyNameFlags.Retargetable);
// References use a public key token instead of full public key.
scopeReference.Flags = (AssemblyFlags)(assemblyName.Flags & ~AssemblyNameFlags.PublicKey);
if (assemblyName.ContentType == AssemblyContentType.WindowsRuntime)
{
scopeReference.Flags |= (AssemblyFlags)((int)AssemblyContentType.WindowsRuntime << 9);
}
scopeReference.PublicKeyOrToken = assemblyName.GetPublicKeyToken();
}
public static bool CompareScopeReferenceAcrossModules(ScopeReferenceHandle sr1, MetadataReader mr1, ScopeReferenceHandle sr2, MetadataReader mr2)
{
ScopeReference srData1 = mr1.GetScopeReference(sr1);
ScopeReference srData2 = mr2.GetScopeReference(sr2);
if (!srData1.Name.StringEquals(srData2.Name.GetConstantStringValue(mr2).Value, mr1))
{
return(false);
}
if (!srData1.Culture.StringEquals(srData2.Culture.GetConstantStringValue(mr2).Value, mr1))
{
return(false);
}
if (srData1.MajorVersion != srData2.MajorVersion)
{
return(false);
}
if (srData1.MinorVersion != srData2.MinorVersion)
{
return(false);
}
if (srData1.RevisionNumber != srData2.RevisionNumber)
{
return(false);
}
if (srData1.BuildNumber != srData2.BuildNumber)
{
return(false);
}
return(ComparePublicKeyOrTokens(srData1.PublicKeyOrToken, srData1.Flags.HasFlag(AssemblyFlags.PublicKey), srData2.PublicKeyOrToken, srData2.Flags.HasFlag(AssemblyFlags.PublicKey)));
}
public static bool CompareScopeReferenceToDefinition(ScopeReferenceHandle sr1, MetadataReader mr1, ScopeDefinitionHandle sd2, MetadataReader mr2)
{
ScopeReference srData1 = mr1.GetScopeReference(sr1);
ScopeDefinition sdData2 = mr2.GetScopeDefinition(sd2);
if (!srData1.Name.StringEquals(sdData2.Name.GetConstantStringValue(mr2).Value, mr1))
{
return(false);
}
if (!srData1.Culture.StringEquals(sdData2.Culture.GetConstantStringValue(mr2).Value, mr1))
{
return(false);
}
if (srData1.MajorVersion != sdData2.MajorVersion)
{
return(false);
}
if (srData1.MinorVersion != sdData2.MinorVersion)
{
return(false);
}
if (srData1.RevisionNumber != sdData2.RevisionNumber)
{
return(false);
}
if (srData1.BuildNumber != sdData2.BuildNumber)
{
return(false);
}
return(true);
}
