428 lines
16 KiB
C#
428 lines
16 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="ProcessStartInfo.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Diagnostics {
|
|
using System.Threading;
|
|
using System.Runtime.InteropServices;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics;
|
|
using System;
|
|
using System.Security;
|
|
using System.Security.Permissions;
|
|
using Microsoft.Win32;
|
|
using System.IO;
|
|
using System.ComponentModel.Design;
|
|
using System.Collections.Specialized;
|
|
using System.Collections;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
using System.Runtime.Versioning;
|
|
|
|
/// <devdoc>
|
|
/// A set of values used to specify a process to start. This is
|
|
/// used in conjunction with the <see cref='System.Diagnostics.Process'/>
|
|
/// component.
|
|
/// </devdoc>
|
|
|
|
[
|
|
TypeConverter(typeof(ExpandableObjectConverter)),
|
|
// Disabling partial trust scenarios
|
|
PermissionSet(SecurityAction.LinkDemand, Name="FullTrust"),
|
|
HostProtection(SharedState=true, SelfAffectingProcessMgmt=true)
|
|
]
|
|
public sealed class ProcessStartInfo {
|
|
string fileName;
|
|
string arguments;
|
|
string directory;
|
|
string verb;
|
|
ProcessWindowStyle windowStyle;
|
|
bool errorDialog;
|
|
IntPtr errorDialogParentHandle;
|
|
#if FEATURE_PAL
|
|
bool useShellExecute = false;
|
|
#else //FEATURE_PAL
|
|
bool useShellExecute = true;
|
|
string userName;
|
|
string domain;
|
|
SecureString password;
|
|
bool loadUserProfile;
|
|
#endif //FEATURE_PAL
|
|
bool redirectStandardInput = false;
|
|
bool redirectStandardOutput = false;
|
|
bool redirectStandardError = false;
|
|
Encoding standardOutputEncoding;
|
|
Encoding standardErrorEncoding;
|
|
|
|
bool createNoWindow = false;
|
|
WeakReference weakParentProcess;
|
|
internal StringDictionary environmentVariables;
|
|
|
|
/// <devdoc>
|
|
/// Default constructor. At least the <see cref='System.Diagnostics.ProcessStartInfo.FileName'/>
|
|
/// property must be set before starting the process.
|
|
/// </devdoc>
|
|
public ProcessStartInfo() {
|
|
}
|
|
|
|
internal ProcessStartInfo(Process parent) {
|
|
this.weakParentProcess = new WeakReference(parent);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Specifies the name of the application or document that is to be started.
|
|
/// </devdoc>
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
public ProcessStartInfo(string fileName) {
|
|
this.fileName = fileName;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Specifies the name of the application that is to be started, as well as a set
|
|
/// of command line arguments to pass to the application.
|
|
/// </devdoc>
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
public ProcessStartInfo(string fileName, string arguments) {
|
|
this.fileName = fileName;
|
|
this.arguments = arguments;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Specifies the verb to use when opening the filename. For example, the "print"
|
|
/// verb will print a document specified using <see cref='System.Diagnostics.ProcessStartInfo.FileName'/>.
|
|
/// Each file extension has it's own set of verbs, which can be obtained using the
|
|
/// <see cref='System.Diagnostics.ProcessStartInfo.Verbs'/> property.
|
|
/// The default verb can be specified using "".
|
|
/// </para>
|
|
/// <note type="rnotes">
|
|
/// Discuss 'opening' vs. 'starting.' I think the part about the
|
|
/// default verb was a dev comment.
|
|
/// Find out what
|
|
/// that means.
|
|
/// </note>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValueAttribute(""),
|
|
TypeConverter("System.Diagnostics.Design.VerbConverter, " + AssemblyRef.SystemDesign),
|
|
MonitoringDescription(SR.ProcessVerb),
|
|
NotifyParentProperty(true)
|
|
]
|
|
public string Verb {
|
|
get {
|
|
if (verb == null) return string.Empty;
|
|
return verb;
|
|
}
|
|
set {
|
|
verb = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Specifies the set of command line arguments to use when starting the application.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValueAttribute(""),
|
|
MonitoringDescription(SR.ProcessArguments),
|
|
SettingsBindable(true),
|
|
TypeConverter("System.Diagnostics.Design.StringValueConverter, " + AssemblyRef.SystemDesign),
|
|
NotifyParentProperty(true)
|
|
]
|
|
public string Arguments {
|
|
get {
|
|
if (arguments == null) return string.Empty;
|
|
return arguments;
|
|
}
|
|
set {
|
|
arguments = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(false),
|
|
MonitoringDescription(SR.ProcessCreateNoWindow),
|
|
NotifyParentProperty(true)
|
|
]
|
|
public bool CreateNoWindow {
|
|
get { return createNoWindow; }
|
|
set { createNoWindow = value; }
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[
|
|
Editor("System.Diagnostics.Design.StringDictionaryEditor, " + AssemblyRef.SystemDesign, "System.Drawing.Design.UITypeEditor, " + AssemblyRef.SystemDrawing),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
DefaultValue( null ),
|
|
MonitoringDescription(SR.ProcessEnvironmentVariables),
|
|
NotifyParentProperty(true)
|
|
]
|
|
public StringDictionary EnvironmentVariables {
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
[ResourceConsumption(ResourceScope.Machine)]
|
|
get {
|
|
if (environmentVariables == null) {
|
|
#if PLATFORM_UNIX
|
|
environmentVariables = new CaseSensitiveStringDictionary();
|
|
#else
|
|
environmentVariables = new StringDictionaryWithComparer ();
|
|
#endif // PLATFORM_UNIX
|
|
|
|
// if not in design mode, initialize the child environment block with all the parent variables
|
|
if (!(this.weakParentProcess != null &&
|
|
this.weakParentProcess.IsAlive &&
|
|
((Component)this.weakParentProcess.Target).Site != null &&
|
|
((Component)this.weakParentProcess.Target).Site.DesignMode)) {
|
|
|
|
foreach (DictionaryEntry entry in Environment.GetEnvironmentVariables())
|
|
environmentVariables.Add((string)entry.Key, (string)entry.Value);
|
|
}
|
|
|
|
}
|
|
return environmentVariables;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(false),
|
|
MonitoringDescription(SR.ProcessRedirectStandardInput),
|
|
NotifyParentProperty(true)
|
|
]
|
|
public bool RedirectStandardInput {
|
|
get { return redirectStandardInput; }
|
|
set { redirectStandardInput = value; }
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(false),
|
|
MonitoringDescription(SR.ProcessRedirectStandardOutput),
|
|
NotifyParentProperty(true)
|
|
]
|
|
public bool RedirectStandardOutput {
|
|
get { return redirectStandardOutput; }
|
|
set { redirectStandardOutput = value; }
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(false),
|
|
MonitoringDescription(SR.ProcessRedirectStandardError),
|
|
NotifyParentProperty(true)
|
|
]
|
|
public bool RedirectStandardError {
|
|
get { return redirectStandardError; }
|
|
set { redirectStandardError = value; }
|
|
}
|
|
|
|
|
|
public Encoding StandardErrorEncoding {
|
|
get { return standardErrorEncoding; }
|
|
set { standardErrorEncoding = value; }
|
|
}
|
|
|
|
public Encoding StandardOutputEncoding {
|
|
get { return standardOutputEncoding; }
|
|
set { standardOutputEncoding = value; }
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(true),
|
|
MonitoringDescription(SR.ProcessUseShellExecute),
|
|
NotifyParentProperty(true)
|
|
]
|
|
public bool UseShellExecute {
|
|
get { return useShellExecute; }
|
|
set { useShellExecute = value; }
|
|
}
|
|
|
|
#if !FEATURE_PAL
|
|
|
|
/// <devdoc>
|
|
/// Returns the set of verbs associated with the file specified by the
|
|
/// <see cref='System.Diagnostics.ProcessStartInfo.FileName'/> property.
|
|
/// </devdoc>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public string[] Verbs {
|
|
[ResourceExposure(ResourceScope.None)]
|
|
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
|
|
get {
|
|
ArrayList verbs = new ArrayList();
|
|
RegistryKey key = null;
|
|
string extension = Path.GetExtension(FileName);
|
|
try {
|
|
if (extension != null && extension.Length > 0) {
|
|
key = Registry.ClassesRoot.OpenSubKey(extension);
|
|
if (key != null) {
|
|
string value = (string)key.GetValue(String.Empty);
|
|
key.Close();
|
|
key = Registry.ClassesRoot.OpenSubKey(value + "\\shell");
|
|
if (key != null) {
|
|
string[] names = key.GetSubKeyNames();
|
|
for (int i = 0; i < names.Length; i++)
|
|
if (string.Compare(names[i], "new", StringComparison.OrdinalIgnoreCase) != 0)
|
|
verbs.Add(names[i]);
|
|
key.Close();
|
|
key = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally {
|
|
if (key != null) key.Close();
|
|
}
|
|
string[] temp = new string[verbs.Count];
|
|
verbs.CopyTo(temp, 0);
|
|
return temp;
|
|
}
|
|
}
|
|
|
|
[NotifyParentProperty(true)]
|
|
public string UserName {
|
|
get {
|
|
if( userName == null) {
|
|
return string.Empty;
|
|
}
|
|
else {
|
|
return userName;
|
|
}
|
|
}
|
|
set { userName = value; }
|
|
}
|
|
|
|
public SecureString Password {
|
|
get { return password; }
|
|
set { password = value; }
|
|
}
|
|
|
|
[NotifyParentProperty(true)]
|
|
public string Domain {
|
|
get {
|
|
if( domain == null) {
|
|
return string.Empty;
|
|
}
|
|
else {
|
|
return domain;
|
|
}
|
|
}
|
|
set { domain = value;}
|
|
}
|
|
|
|
[NotifyParentProperty(true)]
|
|
public bool LoadUserProfile {
|
|
get { return loadUserProfile;}
|
|
set { loadUserProfile = value; }
|
|
}
|
|
|
|
#endif // !FEATURE_PAL
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Returns or sets the application, document, or URL that is to be launched.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
Editor("System.Diagnostics.Design.StartFileNameEditor, " + AssemblyRef.SystemDesign, "System.Drawing.Design.UITypeEditor, " + AssemblyRef.SystemDrawing),
|
|
MonitoringDescription(SR.ProcessFileName),
|
|
SettingsBindable(true),
|
|
TypeConverter("System.Diagnostics.Design.StringValueConverter, " + AssemblyRef.SystemDesign),
|
|
NotifyParentProperty(true)
|
|
]
|
|
public string FileName {
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
get {
|
|
if (fileName == null) return string.Empty;
|
|
return fileName;
|
|
}
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
set { fileName = value;}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns or sets the initial directory for the process that is started.
|
|
/// Specify "" to if the default is desired.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
MonitoringDescription(SR.ProcessWorkingDirectory),
|
|
Editor("System.Diagnostics.Design.WorkingDirectoryEditor, " + AssemblyRef.SystemDesign, "System.Drawing.Design.UITypeEditor, " + AssemblyRef.SystemDrawing),
|
|
SettingsBindable(true),
|
|
TypeConverter("System.Diagnostics.Design.StringValueConverter, " + AssemblyRef.SystemDesign),
|
|
NotifyParentProperty(true)
|
|
]
|
|
public string WorkingDirectory {
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
get {
|
|
if (directory == null) return string.Empty;
|
|
return directory;
|
|
}
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
set {
|
|
directory = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Sets or returns whether or not an error dialog should be displayed to the user
|
|
/// if the process can not be started.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValueAttribute(false),
|
|
MonitoringDescription(SR.ProcessErrorDialog),
|
|
NotifyParentProperty(true)
|
|
]
|
|
public bool ErrorDialog {
|
|
get { return errorDialog;}
|
|
set { errorDialog = value;}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Sets or returns the window handle to use for the error dialog that is shown
|
|
/// when a process can not be started. If <see cref='System.Diagnostics.ProcessStartInfo.ErrorDialog'/>
|
|
/// is true, this specifies the parent window for the dialog that is shown. It is
|
|
/// useful to specify a parent in order to keep the dialog in front of the application.
|
|
/// </devdoc>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public IntPtr ErrorDialogParentHandle {
|
|
get { return errorDialogParentHandle;}
|
|
set { errorDialogParentHandle = value;}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Sets or returns the style of window that should be used for the newly created process.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValueAttribute(System.Diagnostics.ProcessWindowStyle.Normal),
|
|
MonitoringDescription(SR.ProcessWindowStyle),
|
|
NotifyParentProperty(true)
|
|
]
|
|
public ProcessWindowStyle WindowStyle {
|
|
get { return windowStyle;}
|
|
set {
|
|
if (!Enum.IsDefined(typeof(ProcessWindowStyle), value))
|
|
throw new InvalidEnumArgumentException("value", (int)value, typeof(ProcessWindowStyle));
|
|
|
|
windowStyle = value;
|
|
}
|
|
}
|
|
}
|
|
}
|