private static bool AssemblySatisfiesReference(AssemblyName assemblyName, AssemblyName reference)
{
if (reference.Name != assemblyName.Name)
{
return(false);
}
if ((reference.Version != null) && !reference.Version.Equals(assemblyName.Version))
{
return(false);
}
if ((reference.CultureInfo != null) && !reference.CultureInfo.Equals(assemblyName.CultureInfo))
{
return(false);
}
byte[] publicKeyToken = reference.GetPublicKeyToken();
if (publicKeyToken != null)
{
byte[] curKeyToken = assemblyName.GetPublicKeyToken();
if (!SafeSecurityHelper.IsSameKeyToken(publicKeyToken, curKeyToken))
{
return(false);
}
}
return(true);
}
internal bool AreInternalsVisibleTo(Assembly fromAssembly, Assembly toAssembly)
{
if (fromAssembly.Equals(toAssembly))
{
return(true);
}
ICollection <AssemblyName> internalsVisibleTo = this.GetXmlNsInfo(fromAssembly).InternalsVisibleTo;
if (internalsVisibleTo.Count != 0)
{
AssemblyName name = new AssemblyName(toAssembly.FullName);
foreach (AssemblyName name2 in internalsVisibleTo)
{
if (name2.Name == name.Name)
{
byte[] publicKeyToken = name2.GetPublicKeyToken();
if (publicKeyToken == null)
{
return(true);
}
byte[] curKeyToken = name.GetPublicKeyToken();
return(SafeSecurityHelper.IsSameKeyToken(publicKeyToken, curKeyToken));
}
}
}
return(false);
}
// Note: this is a version-tolerant comparison, i.e. the types are considered equal if their
// names, namespaces, assembly short names, culture infos, and public keys match.
internal static bool AssemblyQualifiedNameEquals(Type t1, Type t2)
{
if (t1 is null)
{
return(t2 is null);
}
if (t2 is null)
{
return(false);
}
if (t1.FullName != t2.FullName)
{
return(false);
}
if (t1.Assembly.FullName == t2.Assembly.FullName)
{
return(true);
}
AssemblyName t1name = new AssemblyName(t1.Assembly.FullName);
AssemblyName t2name = new AssemblyName(t2.Assembly.FullName);
if (t1name.Name == t2name.Name)
{
return(t1name.CultureInfo.Equals(t2name.CultureInfo) &&
SafeSecurityHelper.IsSameKeyToken(t1name.GetPublicKeyToken(), t2name.GetPublicKeyToken()));
}
return(IsWindowsBaseToSystemXamlComparison(t1.Assembly, t2.Assembly, t1name, t2name));
}
internal static bool AssemblyQualifiedNameEquals(Type t1, Type t2)
{
if (object.ReferenceEquals(t1, null))
{
return(object.ReferenceEquals(t2, null));
}
if (object.ReferenceEquals(t2, null))
{
return(false);
}
if (t1.FullName != t2.FullName)
{
return(false);
}
if (t1.Assembly.FullName == t2.Assembly.FullName)
{
return(true);
}
AssemblyName name = new AssemblyName(t1.Assembly.FullName);
AssemblyName name2 = new AssemblyName(t2.Assembly.FullName);
if (!(name.Name == name2.Name))
{
return(IsWindowsBaseToSystemXamlComparison(t1.Assembly, t2.Assembly, name, name2));
}
return(name.CultureInfo.Equals(name2.CultureInfo) && SafeSecurityHelper.IsSameKeyToken(name.GetPublicKeyToken(), name2.GetPublicKeyToken()));
}
private static bool IsWindowsBaseToSystemXamlComparison(Assembly a1, Assembly a2, AssemblyName name1, AssemblyName name2)
{
AssemblyName name = null;
if ((name1.Name == "WindowsBase") && (a2 == typeof(MarkupExtension).Assembly))
{
name = name1;
}
else if ((name2.Name == "WindowsBase") && (a1 == typeof(MarkupExtension).Assembly))
{
name = name2;
}
return((name != null) && SafeSecurityHelper.IsSameKeyToken(name.GetPublicKeyToken(), WindowsBaseToken));
}
// When doing a version-tolerant comparison against System.Xaml types, we also need to
// support references to types that were type-forwarded from WindowsBase.
static bool IsWindowsBaseToSystemXamlComparison(Assembly a1, Assembly a2,
AssemblyName name1, AssemblyName name2)
{
AssemblyName windowsBaseName = null;
if (name1.Name == WindowsBase && a2 == typeof(IMarkupExtension).Assembly)
{
windowsBaseName = name1;
}
else if (name2.Name == WindowsBase && a1 == typeof(IMarkupExtension).Assembly)
{
windowsBaseName = name2;
}
return(windowsBaseName != null && SafeSecurityHelper.IsSameKeyToken(windowsBaseName.GetPublicKeyToken(), WindowsBaseToken));
}
private static Assembly LoadAssemblyHelper(string assemblyGivenName, string assemblyPath)
{
AssemblyName reference = new AssemblyName(assemblyGivenName);
string str = reference.Name.ToUpper(CultureInfo.InvariantCulture);
Assembly loadedAssembly = (Assembly)_loadedAssembliesHash[str];
if (loadedAssembly != null)
{
if (reference.Version != null)
{
AssemblyName definition = new AssemblyName(loadedAssembly.FullName);
if (!AssemblyName.ReferenceMatchesDefinition(reference, definition))
{
string str2 = reference.ToString();
string str3 = definition.ToString();
throw new InvalidOperationException(System.Xaml.SR.Get("ParserAssemblyLoadVersionMismatch", new object[] { str2, str3 }));
}
}
return(loadedAssembly);
}
if (string.IsNullOrEmpty(assemblyPath))
{
loadedAssembly = SafeSecurityHelper.GetLoadedAssembly(reference);
}
if (loadedAssembly == null)
{
if (!string.IsNullOrEmpty(assemblyPath))
{
loadedAssembly = Assembly.LoadFile(assemblyPath);
}
else
{
try
{
loadedAssembly = Assembly.Load(assemblyGivenName);
}
catch (FileNotFoundException)
{
loadedAssembly = null;
}
}
}
if (loadedAssembly != null)
{
_loadedAssembliesHash[str] = loadedAssembly;
}
return(loadedAssembly);
}
private Assembly ResolveAssembly(string assemblyName)
{
AssemblyName name = new AssemblyName(assemblyName);
Assembly loadedAssembly = SafeSecurityHelper.GetLoadedAssembly(name);
if (loadedAssembly != null)
{
return(loadedAssembly);
}
try
{
byte[] publicKeyToken = name.GetPublicKeyToken();
if (((name.Version != null) || (name.CultureInfo != null)) || (publicKeyToken != null))
{
try
{
return(Assembly.Load(assemblyName));
}
catch (Exception exception)
{
if (CriticalExceptions.IsCriticalException(exception))
{
throw;
}
AssemblyName assemblyRef = new AssemblyName(name.Name);
if (publicKeyToken != null)
{
assemblyRef.SetPublicKeyToken(publicKeyToken);
}
return(Assembly.Load(assemblyRef));
}
}
return(Assembly.LoadWithPartialName(assemblyName));
}
catch (Exception exception2)
{
if (CriticalExceptions.IsCriticalException(exception2))
{
throw;
}
return(null);
}
}
