/// <summary> /// This method is used to acquire the class of the specified name. /// Loading is performed by the thread context class loader as this /// will ensure that the class loading strategy can be changed as /// requirements dictate. Typically the thread context class loader /// can handle all serialization requirements. /// </summary> /// <param name="type"> /// this is the name of the class that is to be loaded /// </param> /// <returns> /// this returns the class that has been loaded by this /// </returns> public Class Load(String type) { ClassLoader loader = ClassLoader; if(loader == null) { loader = CallerClassLoader; } return loader.loadClass(type); }
private static Class LoadClass(string name, JNIEnv env, ClassLoader classLoader) { Class res; string rn = name.Replace('.', '/'); res = env.FindClassNoThrow(rn); if (res == null) { if (classLoader == null) { classLoader = systemClassLoader; } if (classLoader != null) { try { res = classLoader.loadClass(name); } catch (Throwable th) { throw new JNIException("Can't load java class for " + name + ((classLoader == null) ? "" : " from classLoader " + classLoader), th); } } } return(res); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") protected Class loadJobExecutorClass(ClassLoader processApplicationClassloader, String jobExecutorClassname) protected internal virtual Type loadJobExecutorClass(ClassLoader processApplicationClassloader, string jobExecutorClassname) { try { return((Type)processApplicationClassloader.loadClass(jobExecutorClassname)); } catch (ClassNotFoundException e) { throw LOG.couldNotLoadJobExecutorClass(e); } }
/// /// <param name="classLoader"> /// the classloader to scan </param> /// <param name="paResourceRootPath"> /// see <seealso cref="ProcessArchiveXml.PROP_RESOURCE_ROOT_PATH"/> </param> /// <param name="metaFileUrl"> /// the URL to the META-INF/processes.xml file </param> /// <param name="additionalResourceSuffixes"> /// a list of additional suffixes for resources </param> /// <returns> a Map of process definitions </returns> public static IDictionary<string, sbyte[]> findResources(ClassLoader classLoader, string paResourceRootPath, URL metaFileUrl, string[] additionalResourceSuffixes) { ProcessApplicationScanner scanner = null; try { // check if we must use JBoss VFS classLoader.loadClass("org.jboss.vfs.VFS"); scanner = new VfsProcessApplicationScanner(); } catch (Exception) { scanner = new ClassPathProcessApplicationScanner(); } return scanner.findResources(classLoader, paResourceRootPath, metaFileUrl, additionalResourceSuffixes); }
/// <summary> /// Create an ExpressionFactory instance. /// </summary> /// <param name="properties"> /// Properties passed to the constructor of the implementation. </param> /// <returns> an instance of ExpressionFactory </returns> /// <param name="className"> /// The name of the ExpressionFactory class. </param> /// <param name="classLoader"> /// The class loader to be used to load the class. </param> /// <returns> An instance of ExpressionFactory. </returns> /// <exception cref="ELException"> /// if the class could not be found or if it is not a subclass of ExpressionFactory /// or if the class could not be instantiated. </exception> private static ExpressionFactory newInstance(Properties properties, string className, ClassLoader classLoader) { Type clazz = null; try { clazz = classLoader.loadClass(className.Trim()); if (!clazz.IsAssignableFrom(typeof(ExpressionFactory))) { //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: throw new ELException("Invalid expression factory class: " + clazz.FullName); } } catch (ClassNotFoundException e) { throw new ELException("Could not find expression factory class", e); } try { if (properties != null) { //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: Constructor<?> constructor = null; System.Reflection.ConstructorInfo <object> constructor = null; try { constructor = clazz.GetConstructor(typeof(Properties)); } catch (Exception) { // do nothing } if (constructor != null) { return((ExpressionFactory)constructor.newInstance(properties)); } } return((ExpressionFactory)System.Activator.CreateInstance(clazz)); } catch (Exception e) { throw new ELException("Could not create expression factory instance", e); } }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected: //ORIGINAL LINE: private org.neo4j.helpers.collection.Visitable<DbStructureVisitor> compileVisitable(final String className, String inputSource) private Visitable <DbStructureVisitor> CompileVisitable(string className, string inputSource) { return(Compile(className, inputSource, (success, manager, diagnostics) => { AssertSuccessfullyCompiled(success, diagnostics, className); object instance; try { ClassLoader classLoader = manager.getClassLoader(null); Type clazz = classLoader.loadClass(className); instance = clazz.getDeclaredField("INSTANCE").get(null); } catch (Exception e) when(e is IllegalAccessException || e is ClassNotFoundException || e is NoSuchFieldException) { throw new AssertionError("Failed to instantiate compiled class", e); } return (Visitable <DbStructureVisitor>)instance; })); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: protected Class fetchNextOrNull() throws java.io.IOException protected internal override Type fetchNextOrNull() { try { while (true) { ZipEntry nextEntry = _zip.NextEntry; if (nextEntry == null) { _zip.close(); return(null); } string name = nextEntry.Name; if (name.EndsWith(".class", StringComparison.Ordinal)) { string className = name.Substring(0, name.Length - ".class".Length).Replace('/', '.'); try { Type aClass = _loader.loadClass(className); // We do getDeclaredMethods to trigger NoClassDefErrors, which loadClass above does // not do. // This way, even if some of the classes in a jar cannot be loaded, we still check // the others. aClass.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance); return(aClass); } catch (Exception e) when(e is UnsatisfiedLinkError || e is NoClassDefFoundError || e is Exception) { _outerInstance.log.warn("Failed to load `%s` from plugin jar `%s`: %s", className, _jar.File, e.Message); } } } } catch (Exception e) when(e is IOException || e is Exception) { _zip.close(); throw e; } }
//UPGRADE_ISSUE: Class 'java.lang.ClassLoader' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javalangClassLoader"' /// <summary> Creates an instance of an AudioDevice implementation. /// </summary> /// <param name="loader The"><code>ClassLoader</code> to use to /// load the named class, or null to use the /// system class loader. /// </param> /// <param name="name The">name of the class to load. /// </param> /// <returns> A newly-created instance of the audio device class. /// /// </returns> protected internal virtual AudioDevice instantiate(ClassLoader loader, System.String name) { AudioDevice dev = null; System.Type cls = null; if (loader == null) { //UPGRADE_TODO: Format of parameters of method 'java.lang.Class.forName' are different in the equivalent in .NET. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1092"' cls = System.Type.GetType(name); } else { //UPGRADE_ISSUE: Method 'java.lang.ClassLoader.loadClass' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javalangClassLoader"' cls = loader.loadClass(name); } System.Object o = SupportClass.CreateNewInstance(cls); dev = (AudioDevice)o; return(dev); }
public static List <Class> loadClasses(this ClassLoader classLoader, List <string> classesToLoad) { var classes = new List <Class>(); foreach (var classToLoad in classesToLoad) { try { var loadedClass = classLoader.loadClass(classToLoad); if (loadedClass.notNull()) { classes.add(loadedClass); } "Loaded class: {0}".info(classToLoad); } catch (System.Exception ex) { "[ClassLoader] loading class {0} threw: {1}".error(classToLoad, ex.Message); } } return(classes); }
private static Class LoadClass(string name, JNIEnv env, bool throwNoFound) { Class res; string rn = name.Replace('.', '/'); res = env.FindClassNoThrow(rn); if (res == null && systemClassLoader != null) { try { res = systemClassLoader.loadClass(name); } catch (Throwable th) { } } if (res == null && throwNoFound) { throw new JNIException("Can't find java class for " + name); } return(res); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") protected <T> Class loadClass(String className, ClassLoader customClassloader, Class<T> clazz) protected internal virtual Type loadClass <T>(string className, ClassLoader customClassloader, Type clazz) { clazz = typeof(T); try { if (customClassloader != null) { return((Type)customClassloader.loadClass(className)); } else { return((Type)ReflectUtil.loadClass(className)); } } catch (ClassNotFoundException e) { throw LOG.camnnotLoadConfigurationClass(className, e); } catch (System.InvalidCastException e) { throw LOG.configurationClassHasWrongType(className, clazz, e); } }
private static Class loadClass(string clazzName, bool logDetails) { Class clazz = JNIEnv.ThreadEnv.FindClassNoThrow(clazzName); if (clazz == null && systemClassLoader != null) { try { string replace = clazzName.Replace('/', '.'); clazz = systemClassLoader.loadClass(replace); } catch (Throwable ex) { Console.Error.WriteLine("Can't load class " + clazzName); if (config.Verbose) { Console.Error.WriteLine(ex.ToString()); } clazz = null; } } return(clazz); }
//UPGRADE_ISSUE: Class 'java.lang.ClassLoader' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javalangClassLoader"' /// <summary> Creates an instance of an AudioDevice implementation. /// </summary> /// <param name="loader The"><code>ClassLoader</code> to use to /// load the named class, or null to use the /// system class loader. /// </param> /// <param name="name The">name of the class to load. /// </param> /// <returns> A newly-created instance of the audio device class. /// /// </returns> protected internal virtual AudioDevice instantiate(ClassLoader loader, System.String name) { AudioDevice dev = null; System.Type cls = null; if (loader == null) { //UPGRADE_TODO: Format of parameters of method 'java.lang.Class.forName' are different in the equivalent in .NET. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1092"' cls = System.Type.GetType(name); } else { //UPGRADE_ISSUE: Method 'java.lang.ClassLoader.loadClass' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javalangClassLoader"' cls = loader.loadClass(name); } System.Object o = SupportClass.CreateNewInstance(cls); dev = (AudioDevice) o; return dev; }
/// <summary> /// Perform instantiation of the process's /// <see cref="Application">Application</see> /// object. The /// default implementation provides the normal system behavior. /// </summary> /// <param name="cl">The ClassLoader with which to instantiate the object.</param> /// <param name="className"> /// The name of the class implementing the Application /// object. /// </param> /// <param name="context">The context to initialize the application with</param> /// <returns>The newly instantiated Application object.</returns> /// <exception cref="java.lang.InstantiationException"></exception> /// <exception cref="System.MemberAccessException"></exception> /// <exception cref="System.TypeLoadException"></exception> public virtual Application newApplication(ClassLoader cl, string klass, Context context) { return(newApplication(cl.loadClass(klass), context)); }