| private Error ( TraceSwitch traceSwitch, string message ) : void | ||
| traceSwitch | TraceSwitch | |
| message | string | |
| return | void | |
internal static TypeWrapper LoadClassNoThrow(ClassLoaderWrapper classLoader, string name)
{
try
{
TypeWrapper wrapper = classLoader.LoadClassByDottedNameFast(name);
if (wrapper == null)
{
Tracer.Error(Tracer.ClassLoading, "Class not found: {0}", name);
wrapper = new UnloadableTypeWrapper(name);
}
return(wrapper);
}
catch (RetargetableJavaException x)
{
// HACK keep the compiler from warning about unused local
GC.KeepAlive(x);
#if !STATIC_COMPILER && !FIRST_PASS && !STUB_GENERATOR
if (Tracer.ClassLoading.TraceError)
{
java.lang.ClassLoader cl = (java.lang.ClassLoader)classLoader.GetJavaClassLoader();
if (cl != null)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
string sep = "";
while (cl != null)
{
sb.Append(sep).Append(cl);
sep = " -> ";
cl = cl.getParent();
}
Tracer.Error(Tracer.ClassLoading, "ClassLoader chain: {0}", sb);
}
Exception m = ikvm.runtime.Util.mapException(x.ToJava());
Tracer.Error(Tracer.ClassLoading, m.ToString() + Environment.NewLine + m.StackTrace);
}
#endif // !STATIC_COMPILER && !FIRST_PASS && !STUB_GENERATOR
return(new UnloadableTypeWrapper(name));
}
}
private void InitializeJavaClassLoader()
{
Assembly assembly = assemblyLoader.Assembly;
{
Type customClassLoaderClass = null;
LoadCustomClassLoaderRedirects();
string assemblyName = assembly.FullName;
foreach (KeyValuePair <string, string> kv in customClassLoaderRedirects)
{
string asm = kv.Key;
// FXBUG
// We only support matching on the assembly's simple name,
// because there appears to be no viable alternative.
// There is AssemblyName.ReferenceMatchesDefinition()
// but it is completely broken.
if (assemblyName.StartsWith(asm + ","))
{
try
{
customClassLoaderClass = Type.GetType(kv.Value, true);
}
catch (Exception x)
{
Tracer.Error(Tracer.Runtime, "Unable to load custom class loader {0} specified in app.config for assembly {1}: {2}", kv.Value, assembly, x);
}
break;
}
}
if (customClassLoaderClass == null)
{
object[] attribs = assembly.GetCustomAttributes(typeof(CustomAssemblyClassLoaderAttribute), false);
if (attribs.Length == 1)
{
customClassLoaderClass = ((CustomAssemblyClassLoaderAttribute)attribs[0]).Type;
}
}
if (customClassLoaderClass != null)
{
try
{
if (!customClassLoaderClass.IsPublic && !customClassLoaderClass.Assembly.Equals(assembly))
{
throw new Exception("Type not accessible");
}
ConstructorInfo customClassLoaderCtor = customClassLoaderClass.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { typeof(Assembly) }, null);
if (customClassLoaderCtor == null)
{
throw new Exception("No constructor");
}
if (!customClassLoaderCtor.IsPublic && !customClassLoaderClass.Assembly.Equals(assembly))
{
customClassLoaderCtor = null;
throw new Exception("Constructor not accessible");
}
hasCustomClassLoader = true;
// NOTE we're creating an uninitialized instance of the custom class loader here, so that getClassLoader will return the proper object
// when it is called during the construction of the custom class loader later on. This still doesn't make it safe to use the custom
// class loader before it is constructed, but at least the object instance is available and should anyone cache it, they will get the
// right object to use later on.
// Note that creating the unitialized instance will (unfortunately) trigger the static initializer. The static initializer can
// trigger a call to getClassLoader(), which means we can end up here recursively.
java.lang.ClassLoader newJavaClassLoader = (java.lang.ClassLoader)GetUninitializedObject(customClassLoaderClass);
if (javaClassLoader == null) // check if we weren't invoked recursively and the nested invocation already did the work
{
javaClassLoader = newJavaClassLoader;
SetWrapperForClassLoader(javaClassLoader, this);
DoPrivileged(new CustomClassLoaderCtorCaller(customClassLoaderCtor, javaClassLoader, assembly));
Tracer.Info(Tracer.Runtime, "Created custom assembly class loader {0} for assembly {1}", customClassLoaderClass.FullName, assembly);
}
else
{
// we didn't initialize the object, so there is no need to finalize it
GC.SuppressFinalize(newJavaClassLoader);
}
}
catch (Exception x)
{
Tracer.Error(Tracer.Runtime, "Unable to create custom assembly class loader {0} for {1}: {2}", customClassLoaderClass.FullName, assembly, x);
}
}
}
if (javaClassLoader == null)
{
javaClassLoader = (java.lang.ClassLoader)DoPrivileged(new CreateAssemblyClassLoader(assembly));
SetWrapperForClassLoader(javaClassLoader, this);
}
}