/// <summary> /// Closes this URLClassLoader, so that it can no longer be used to load /// new classes or resources that are defined by this loader. /// Classes and resources defined by any of this loader's parents in the /// delegation hierarchy are still accessible. Also, any classes or resources /// that are already loaded, are still accessible. /// <para> /// In the case of jar: and file: URLs, it also closes any files /// that were opened by it. If another thread is loading a /// class when the {@code close} method is invoked, then the result of /// that load is undefined. /// </para> /// <para> /// The method makes a best effort attempt to close all opened files, /// by catching <seealso cref="IOException"/>s internally. Unchecked exceptions /// and errors are not caught. Calling close on an already closed /// loader has no effect. /// </para> /// <para> /// </para> /// </summary> /// <exception cref="IOException"> if closing any file opened by this class loader /// resulted in an IOException. Any such exceptions are caught internally. /// If only one is caught, then it is re-thrown. If more than one exception /// is caught, then the second and following exceptions are added /// as suppressed exceptions of the first one caught, which is then re-thrown. /// </exception> /// <exception cref="SecurityException"> if a security manager is set, and it denies /// <seealso cref="RuntimePermission"/>{@code ("closeClassLoader")} /// /// @since 1.7 </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void close() throws java.io.IOException public virtual void Close() { SecurityManager security = System.SecurityManager; if (security != null) { security.CheckPermission(new RuntimePermission("closeClassLoader")); } IList <IOException> errors = Ucp.closeLoaders(); // now close any remaining streams. lock (Closeables) { WeakHashMap <Closeable, Void> .KeyCollection keys = Closeables.KeySet(); foreach (Closeable c in keys) { try { c.Close(); } catch (IOException ioex) { errors.Add(ioex); } } Closeables.Clear(); } if (errors.Count == 0) { return; } IOException firstex = errors.Remove(0); // Suppress any remaining exceptions foreach (IOException error in errors) { firstex.AddSuppressed(error); } throw firstex; }
/// <summary> /// Returns the next Event or {@code null} if there are no more events or /// the walker is closed. /// </summary> internal virtual Event Next() { DirectoryNode top = Stack.Peek(); if (top == null) { return(null); // stack is empty, we are done } // continue iteration of the directory at the top of the stack Event ev; do { Path entry = null; IOException ioe = null; // get next entry in the directory if (!top.Skipped()) { IEnumerator <Path> iterator = top.Iterator(); try { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: if (iterator.hasNext()) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: entry = iterator.next(); } } catch (DirectoryIteratorException x) { ioe = x.InnerException; } } // no next entry so close and pop directory, creating corresponding event if (entry == null) { try { top.Stream().Close(); } catch (IOException e) { if (ioe != null) { ioe = e; } else { ioe.AddSuppressed(e); } } Stack.Pop(); return(new Event(EventType.END_DIRECTORY, top.Directory(), ioe)); } // visit the entry ev = Visit(entry, true, true); // canUseCached - ignoreSecurityException } while (ev == null); return(ev); }