public void Construct()
{
string typeName = "MyType";
string assemblyName = "MyAssembly";
AssemblyQualifiedTypeName tn = new AssemblyQualifiedTypeName(typeName, assemblyName);
Assert.AreEqual(typeName, tn.Type);
Assert.AreEqual(assemblyName, tn.Assembly);
}
/// <summary>
/// Returns a <see cref="System.Type"/> from an already loaded Assembly or an
/// Assembly that is loaded with a partial name.
/// </summary>
/// <param name="name">An <see cref="AssemblyQualifiedTypeName" />.</param>
/// <param name="throwOnError"><see langword="true" /> if an exception should be thrown
/// in case of an error, <see langword="false" /> otherwise.</param>
/// <returns>
/// A <see cref="System.Type"/> object that represents the specified type,
/// or <see langword="null" /> if the type cannot be loaded.
/// </returns>
/// <remarks>
/// Attempts to get a reference to the type from an already loaded assembly. If the
/// type cannot be found then the assembly is loaded using
/// <see cref="Assembly.Load(string)" />.
/// </remarks>
public static System.Type TypeFromAssembly(AssemblyQualifiedTypeName name, bool throwOnError)
{
try
{
// Try to get the type from an already loaded assembly
System.Type type = System.Type.GetType(name.ToString());
if (type != null)
{
return(type);
}
if (name.Assembly == null)
{
// No assembly was specified for the type, so just fail
const string noAssembly = "Could not load type {0}. Possible cause: no assembly name specified.";
log.Warn(noAssembly, name);
if (throwOnError)
{
throw new TypeLoadException(string.Format(noAssembly, name));
}
return(null);
}
Assembly assembly = Assembly.Load(name.Assembly);
if (assembly == null)
{
log.Warn("Could not load type {0}. Possible cause: incorrect assembly name specified.", name);
return(null);
}
type = assembly.GetType(name.Type, throwOnError);
if (type == null)
{
log.Warn("Could not load type {0}.", name);
return(null);
}
return(type);
}
catch (Exception e)
{
if (log.IsErrorEnabled())
{
log.Error(e, "Could not load type {0}.", name);
}
if (throwOnError)
{
throw;
}
return(null);
}
}
public bool Equals(AssemblyQualifiedTypeName obj)
{
if (obj == null)
{
return false;
}
if (ReferenceEquals(this, obj))
{
return true;
}
return Equals(obj.type, type) && Equals(obj.assembly, assembly);
}
public bool Equals(AssemblyQualifiedTypeName obj)
{
if (obj == null)
{
return(false);
}
if (ReferenceEquals(this, obj))
{
return(true);
}
return(Equals(obj.type, type) && Equals(obj.assembly, assembly));
}
public override bool Equals(object obj)
{
AssemblyQualifiedTypeName other = obj as AssemblyQualifiedTypeName;
if (other == null)
{
return(false);
}
return(string.Equals(type, other.type) &&
string.Equals(assembly, other.assembly));
}
/// <summary>
/// Returns a reference to the Type.
/// </summary>
/// <param name="name">The name of the class or a fully qualified name.</param>
/// <returns>The Type for the Class.</returns>
/// <remarks>
/// See <see cref="System.Type.GetType(System.String, System.Boolean)"/> for a full
/// description of how this works. This method trims the <c>name</c> before passing
/// it to GetType.
/// </remarks>
public static System.Type ClassForName(string name)
{
AssemblyQualifiedTypeName parsedName = AssemblyQualifiedTypeName.Parse(name,
Assembly.GetExecutingAssembly().FullName);
System.Type result = TypeFromAssembly(parsedName);
if (result == null)
{
throw new TypeLoadException("Could not load type '" + parsedName + "', check that type and assembly names are correct");
}
return(result);
}
public ClassEntry(string extends, string className, string entityName, string assembly, string @namespace)
{
fullExtends = string.IsNullOrEmpty(extends) ? null : TypeNameParser.Parse(extends, @namespace, assembly);
fullClassName = string.IsNullOrEmpty(className) ? null : TypeNameParser.Parse(className, @namespace, assembly);
this.entityName = entityName;
extendsEntityName = string.IsNullOrEmpty(extends) ? null : extends;
unchecked
{
hashCode = (entityName != null ? entityName.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (fullExtends != null ? fullExtends.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (fullClassName != null ? fullClassName.GetHashCode() : 0);
}
}
/// <summary>
/// Returns a <see cref="System.Type"/> from an already loaded Assembly or an
/// Assembly that is loaded with a partial name.
/// </summary>
/// <param name="name">An <see cref="AssemblyQualifiedTypeName" />.</param>
/// <returns>
/// A <see cref="System.Type"/> object that represents the specified type,
/// or <c>null</c> if the type cannot be loaded.
/// </returns>
/// <remarks>
/// Attempts to get a reference to the type from an already loaded assembly. If the
/// type cannot be found then the assembly is loaded using
/// <see cref="Assembly.LoadWithPartialName(string)" />.
/// </remarks>
public static System.Type TypeFromAssembly(AssemblyQualifiedTypeName name)
{
if (name.Assembly == null)
{
name = new AssemblyQualifiedTypeName(name.Type, Assembly.GetExecutingAssembly().FullName);
}
try
{
// Try to get the types from an already loaded assembly
System.Type type = System.Type.GetType(name.ToString());
// If the type is null then the assembly is not loaded.
if (type == null)
{
// Use the partial name because we don't know the public key, version,
// culture-info of the assembly on the local machine.
Assembly assembly = Assembly.LoadWithPartialName(name.Assembly);
if (assembly != null)
{
type = assembly.GetType(name.Type);
}
}
return(type);
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
log.Error(name + " could not be loaded.", e);
}
return(null);
}
}
public ClassEntry(string extends, string className, string assembly, string @namespace)
{
_fullExtends = extends == null ? null : TypeNameParser.Parse(extends, @namespace, assembly);
_fullClassName = TypeNameParser.Parse(className, @namespace, assembly);
}
public AssemblyQualifiedTypeName MakeGenericType(AssemblyQualifiedTypeName qualifiedName, bool isArrayType,
AssemblyQualifiedTypeName[] typeArguments)
{
Debug.Assert(typeArguments.Length > 0);
var baseType = qualifiedName.Type;
var sb = new StringBuilder(typeArguments.Length * 200);
sb.Append(baseType);
sb.Append('[');
for (int i = 0; i < typeArguments.Length; i++)
{
if(i>0)
{
sb.Append(",");
}
sb.Append('[').Append(typeArguments[i].ToString()).Append(']');
}
sb.Append(']');
if(isArrayType)
{
sb.Append("[]");
}
return new AssemblyQualifiedTypeName(sb.ToString(), qualifiedName.Assembly);
}
/// <summary>
/// Returns a <see cref="System.Type"/> from an already loaded Assembly or an
/// Assembly that is loaded with a partial name.
/// </summary>
/// <param name="name">An <see cref="AssemblyQualifiedTypeName" />.</param>
/// <returns>
/// A <see cref="System.Type"/> object that represents the specified type,
/// or <c>null</c> if the type cannot be loaded.
/// </returns>
/// <remarks>
/// Attempts to get a reference to the type from an already loaded assembly. If the
/// type cannot be found then the assembly is loaded using
/// <see cref="Assembly.LoadWithPartialName(string)" />.
/// </remarks>
public static System.Type TypeFromAssembly( AssemblyQualifiedTypeName name )
{
if( name.Assembly == null )
{
name = new AssemblyQualifiedTypeName( name.Type, Assembly.GetExecutingAssembly().FullName );
}
try
{
// Try to get the types from an already loaded assembly
System.Type type = System.Type.GetType( name.ToString() );
// If the type is null then the assembly is not loaded.
if( type == null )
{
// Use the partial name because we don't know the public key, version,
// culture-info of the assembly on the local machine.
Assembly assembly = Assembly.LoadWithPartialName( name.Assembly );
if( assembly != null )
{
type = assembly.GetType( name.Type );
}
}
return type;
}
catch( Exception e )
{
if( log.IsErrorEnabled )
{
log.Error( name + " could not be loaded.", e );
}
return null;
}
}
public void ToStringEscaped()
{
AssemblyQualifiedTypeName tn = new AssemblyQualifiedTypeName("Escaped\\,Type", "Escaped\\,Assembly");
Assert.AreEqual(tn.Type + ", " + tn.Assembly, tn.ToString());
}
public void ToStringComplex()
{
AssemblyQualifiedTypeName tn = new AssemblyQualifiedTypeName("MyType", "MyAssembly");
Assert.AreEqual("MyType, MyAssembly", tn.ToString());
}
public void ToStringSimple()
{
AssemblyQualifiedTypeName tn = new AssemblyQualifiedTypeName("MyType", null);
Assert.AreEqual("MyType", tn.ToString());
}
public ClassEntry(string extends, string className, string assemblyName, string @namespace, string fileName, Assembly assembly)
{
_fullExtends = extends == null ? null : TypeNameParser.Parse(extends, @namespace, assemblyName);
_fullClassName = TypeNameParser.Parse(className, @namespace, assemblyName);
_fileName = fileName;
_assembly = assembly;
}
/// <summary>
/// Returns a <see cref="System.Type"/> from an already loaded Assembly or an
/// Assembly that is loaded with a partial name.
/// </summary>
/// <param name="name">An <see cref="AssemblyQualifiedTypeName" />.</param>
/// <param name="throwOnError"><see langword="true" /> if an exception should be thrown
/// in case of an error, <see langword="false" /> otherwise.</param>
/// <returns>
/// A <see cref="System.Type"/> object that represents the specified type,
/// or <see langword="null" /> if the type cannot be loaded.
/// </returns>
/// <remarks>
/// Attempts to get a reference to the type from an already loaded assembly. If the
/// type cannot be found then the assembly is loaded using
/// <see cref="Assembly.Load(string)" />.
/// </remarks>
public static System.Type TypeFromAssembly(AssemblyQualifiedTypeName name, bool throwOnError)
{
try
{
// Try to get the type from an already loaded assembly
System.Type type = System.Type.GetType(name.ToString());
if (type != null)
{
return type;
}
if (name.Assembly == null)
{
// No assembly was specified for the type, so just fail
string message = "Could not load type " + name + ". Possible cause: no assembly name specified.";
log.Warn(message);
if (throwOnError) throw new TypeLoadException(message);
return null;
}
Assembly assembly = Assembly.Load(name.Assembly);
if (assembly == null)
{
log.Warn("Could not load type " + name + ". Possible cause: incorrect assembly name specified.");
return null;
}
type = assembly.GetType(name.Type, throwOnError);
if (type == null)
{
log.Warn("Could not load type " + name + ".");
return null;
}
return type;
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
log.Error("Could not load type " + name + ".", e);
}
if (throwOnError) throw;
return null;
}
}
public override bool Equals(object obj)
{
AssemblyQualifiedTypeName other = obj as AssemblyQualifiedTypeName;
return(Equals(other));
}