private getProperty ( global par0 ) : global::java.lang.String | ||
par0 | global | |
return | global::java.lang.String |
public virtual Void Run() { bool loaded = false; String jit = System.getProperty("java.compiler"); if ((jit != null) && (!jit.Equals("NONE")) && (!jit.Equals(""))) { try { //JAVA TO C# CONVERTER TODO TASK: The library is specified in the 'DllImport' attribute for .NET: // System.loadLibrary(jit); initialize(); loaded = true; } catch (UnsatisfiedLinkError) { System.Console.Error.WriteLine("Warning: JIT compiler \"" + jit + "\" not found. Will use interpreter."); } } String info = System.getProperty("java.vm.info"); if (loaded) { System.setProperty("java.vm.info", info + ", " + jit); } else { System.setProperty("java.vm.info", info + ", nojit"); } return(null); }
/// <summary> /// Returns {@code true} if and only if the system property /// named by the argument exists and is equal to the string /// {@code "true"}. (Beginning with version 1.0.2 of the /// Java<small><sup>TM</sup></small> platform, the test of /// this string is case insensitive.) A system property is accessible /// through {@code getProperty}, a method defined by the /// {@code System} class. /// <para> /// If there is no property with the specified name, or if the specified /// name is empty or null, then {@code false} is returned. /// /// </para> /// </summary> /// <param name="name"> the system property name. </param> /// <returns> the {@code boolean} value of the system property. </returns> /// <exception cref="SecurityException"> for the same reasons as /// <seealso cref="System#getProperty(String) System.getProperty"/> </exception> /// <seealso cref= java.lang.System#getProperty(java.lang.String) </seealso> /// <seealso cref= java.lang.System#getProperty(java.lang.String, java.lang.String) </seealso> public static bool GetBoolean(String name) { bool result = false; try { result = ParseBoolean(System.getProperty(name)); } //JAVA TO C# CONVERTER TODO TASK: There is no equivalent in C# to Java 'multi-catch' syntax: catch (IllegalArgumentException | NullPointerException e) { } return(result); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private ProcessImpl(String cmd[] , final String envblock, final String path, final long[] stdHandles, final boolean redirectErrorStream) throws java.io.IOException //JAVA TO C# CONVERTER WARNING: 'final' parameters are not allowed in .NET: private ProcessImpl(String[] cmd, String envblock, String path, long[] stdHandles, bool redirectErrorStream) { String cmdstr; SecurityManager security = System.SecurityManager; bool allowAmbiguousCommands = false; if (security == null) { allowAmbiguousCommands = true; String value = System.getProperty("jdk.lang.Process.allowAmbiguousCommands"); if (value != null) { allowAmbiguousCommands = !"false".Equals(value, StringComparison.CurrentCultureIgnoreCase); } } if (allowAmbiguousCommands) { // Legacy mode. // Normalize path if possible. String executablePath = (new File(cmd[0])).Path; // No worry about internal, unpaired ["], and redirection/piping. if (NeedsEscaping(VERIFICATION_LEGACY, executablePath)) { executablePath = QuoteString(executablePath); } cmdstr = CreateCommandLine(VERIFICATION_LEGACY, executablePath, cmd); //legacy mode doesn't worry about extended verification } else { String executablePath; try { executablePath = GetExecutablePath(cmd[0]); } catch (IllegalArgumentException) { // Workaround for the calls like // Runtime.getRuntime().exec("\"C:\\Program Files\\foo\" bar") // No chance to avoid CMD/BAT injection, except to do the work // right from the beginning. Otherwise we have too many corner // cases from // Runtime.getRuntime().exec(String[] cmd [, ...]) // calls with internal ["] and escape sequences. // Restore original command line. StringBuilder join = new StringBuilder(); // terminal space in command line is ok foreach (String s in cmd) { join.Append(s).Append(' '); } // Parse the command line again. cmd = GetTokensFromCommand(join.ToString()); executablePath = GetExecutablePath(cmd[0]); // Check new executable name once more if (security != null) { security.CheckExec(executablePath); } } // Quotation protects from interpretation of the [path] argument as // start of longer path with spaces. Quotation has no influence to // [.exe] extension heuristic. cmdstr = CreateCommandLine(IsShellFile(executablePath) ? VERIFICATION_CMD_BAT : VERIFICATION_WIN32, QuoteString(executablePath), cmd); // We need the extended verification procedure for CMD files. } Handle = create(cmdstr, envblock, path, stdHandles, redirectErrorStream); AccessController.doPrivileged(new PrivilegedActionAnonymousInnerClassHelper(this, stdHandles)); }