/// <summary>
/// Returns true if the two signatures match according to the criteria of the CLR loader.
/// </summary>
public static bool SignaturesAreEqual(ISignature signature1, ISignature signature2)
{
if (signature1.CallingConvention != signature2.CallingConvention)
{
return(false);
}
if (signature1.ReturnValueIsByRef != signature2.ReturnValueIsByRef)
{
return(false);
}
if (signature1.ReturnValueIsModified != signature2.ReturnValueIsModified)
{
return(false);
}
if (!TypeHelper.TypesAreEquivalent(signature1.Type, signature2.Type))
{
return(false);
}
return(IteratorHelper.EnumerablesAreEqual(signature1.Parameters, signature2.Parameters, ParameterInformationComparer));
}
/// <summary>
/// Returns true if the given object is an identifier that identifies the same object as this identifier.
/// </summary>
//^ [Confined]
public sealed override bool Equals(object /*?*/ obj)
{
if (obj == (object)this)
{
return(true);
}
AssemblyIdentity /*?*/ otherAssembly = obj as AssemblyIdentity;
if (otherAssembly == null)
{
return(false);
}
if (this.Name.UniqueKeyIgnoringCase != otherAssembly.Name.UniqueKeyIgnoringCase)
{
return(false);
}
if (this.Version != otherAssembly.Version)
{
return(false);
}
if (string.Compare(this.Culture, otherAssembly.Culture, StringComparison.OrdinalIgnoreCase) != 0)
{
return(false);
}
if (IteratorHelper.EnumerableIsNotEmpty(this.PublicKeyToken))
{
return(IteratorHelper.EnumerablesAreEqual(this.PublicKeyToken, otherAssembly.PublicKeyToken));
}
else
{
if (this.Location.Length == 0 || otherAssembly.Location.Length == 0)
{
return(true);
}
return(string.Compare(this.Location, otherAssembly.Location, StringComparison.OrdinalIgnoreCase) == 0);
}
}
/// <summary>
/// Returns true if the given two assembly references are to be considered equivalent.
/// </summary>
public static bool AssembliesAreEquivalent(IAssemblyReference /*?*/ assembly1, IAssemblyReference /*?*/ assembly2)
{
if (assembly1 == null || assembly2 == null)
{
return(false);
}
if (assembly1 == assembly2)
{
return(true);
}
if (assembly1.Name.UniqueKeyIgnoringCase != assembly2.Name.UniqueKeyIgnoringCase)
{
return(false);
}
if (!assembly1.Version.Equals(assembly2.Version))
{
return(false);
}
if (!assembly1.Culture.Equals(assembly2.Culture))
{
return(false);
}
return(IteratorHelper.EnumerablesAreEqual <byte>(assembly1.PublicKeyToken, assembly2.PublicKeyToken));
}
/// <summary>
/// Returns true if the given object is an identifier that identifies the same object as this identifier.
/// </summary>
//^ [Confined]
public sealed override bool Equals(object /*?*/ obj)
{
if (obj == (object)this)
{
return(true);
}
AssemblyIdentity /*?*/ otherAssembly = obj as AssemblyIdentity;
if (otherAssembly == null)
{
return(false);
}
if (this.Name.UniqueKeyIgnoringCase != otherAssembly.Name.UniqueKeyIgnoringCase)
{
return(false);
}
if (this.Version != otherAssembly.Version)
{
return(false);
}
if (string.Compare(this.Culture, otherAssembly.Culture, StringComparison.OrdinalIgnoreCase) != 0)
{
return(false);
}
if (IteratorHelper.EnumerableIsNotEmpty(this.PublicKeyToken))
{
return(IteratorHelper.EnumerablesAreEqual(this.PublicKeyToken, otherAssembly.PublicKeyToken));
}
else
{
// This can be dangerous! Returning true here means that weakly named assemblies are assumed to be the
// same just because their name is the same. So two assemblies from different locations but the same name
// should *NOT* be allowed.
return(true);
}
}
