We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Diagnostics \ ProcessStartInfo

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright file="ProcessStartInfo.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  16. namespace System.Diagnostics
  17. {
  18.     using System.Threading;
  19.     using System.Runtime.InteropServices;
  20.     using System.ComponentModel;
  21.     using System.Diagnostics;
  22.     using System;
  23.     using System.Security;
  24.     using System.Security.Permissions;
  25.     using Microsoft.Win32;
  26.     using System.IO;
  27.     using System.ComponentModel.Design;
  28.     using System.Collections.Specialized;
  29.     using System.Collections;
  30.     using System.Globalization;
  31.     using System.Text;
  32.    
  33.     /// <devdoc>
  34.     /// A set of values used to specify a process to start. This is
  35.     /// used in conjunction with the <see cref='System.Diagnostics.Process'/>
  36.     /// component.
  37.     /// </devdoc>
  38.    
  39.         // Disabling partial trust scenarios
  40.     [TypeConverter(typeof(ExpandableObjectConverter)), PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust"), HostProtection(SharedState = true, SelfAffectingProcessMgmt = true)]
  41.     public sealed class ProcessStartInfo
  42.     {
  43.         string fileName;
  44.         string arguments;
  45.         string directory;
  46.         string verb;
  47.         ProcessWindowStyle windowStyle;
  48.         bool errorDialog;
  49.         IntPtr errorDialogParentHandle;
  50.         bool useShellExecute = false;
  51.         bool redirectStandardInput = false;
  52.         bool redirectStandardOutput = false;
  53.         bool redirectStandardError = false;
  54.         Encoding standardOutputEncoding;
  55.         Encoding standardErrorEncoding;
  56.        
  57.         bool createNoWindow = false;
  58.         WeakReference weakParentProcess;
  59.         internal StringDictionary environmentVariables;
  60.        
  61.         /// <devdoc>
  62.         /// Default constructor. At least the <see cref='System.Diagnostics.ProcessStartInfo.FileName'/>
  63.         /// property must be set before starting the process.
  64.         /// </devdoc>
  65.         public ProcessStartInfo()
  66.         {
  67.         }
  68.        
  69.         internal ProcessStartInfo(Process parent)
  70.         {
  71.             this.weakParentProcess = new WeakReference(parent);
  72.         }
  73.        
  74.         /// <devdoc>
  75.         /// Specifies the name of the application or document that is to be started.
  76.         /// </devdoc>
  77.         public ProcessStartInfo(string fileName)
  78.         {
  79.             this.fileName = fileName;
  80.         }
  81.        
  82.         /// <devdoc>
  83.         /// Specifies the name of the application that is to be started, as well as a set
  84.         /// of command line arguments to pass to the application.
  85.         /// </devdoc>
  86.         public ProcessStartInfo(string fileName, string arguments)
  87.         {
  88.             this.fileName = fileName;
  89.             this.arguments = arguments;
  90.         }
  91.        
  92.         /// <devdoc>
  93.         /// <para>
  94.         /// Specifies the verb to use when opening the filename. For example, the "print"
  95.         /// verb will print a document specified using <see cref='System.Diagnostics.ProcessStartInfo.FileName'/>.
  96.         /// Each file extension has it's own set of verbs, which can be obtained using the
  97.         /// <see cref='System.Diagnostics.ProcessStartInfo.Verbs'/> property.
  98.         /// The default verb can be specified using "".
  99.         /// </para>
  100.         /// <note type="rnotes">
  101.         /// Discuss 'opening' vs. 'starting.' I think the part about the
  102.         /// default verb was a dev comment.
  103.         /// Find out what
  104.         /// that means.
  105.         /// </note>
  106.         /// </devdoc>
  107.         [DefaultValueAttribute(""), TypeConverter("System.Diagnostics.Design.VerbConverter, " + AssemblyRef.SystemDesign), MonitoringDescription(SR.ProcessVerb), NotifyParentProperty(true)]
  108.         public string Verb {
  109.             get {
  110.                 if (verb == null)
  111.                     return string.Empty;
  112.                 return verb;
  113.             }
  114.             set { verb = value; }
  115.         }
  116.        
  117.         /// <devdoc>
  118.         /// Specifies the set of command line arguments to use when starting the application.
  119.         /// </devdoc>
  120.         [DefaultValueAttribute(""), MonitoringDescription(SR.ProcessArguments), RecommendedAsConfigurable(true), TypeConverter("System.Diagnostics.Design.StringValueConverter, " + AssemblyRef.SystemDesign), NotifyParentProperty(true)]
  121.         public string Arguments {
  122.             get {
  123.                 if (arguments == null)
  124.                     return string.Empty;
  125.                 return arguments;
  126.             }
  127.             set { arguments = value; }
  128.         }
  129.        
  130.         /// <devdoc>
  131.         /// <para>[To be supplied.]</para>
  132.         /// </devdoc>
  133.         [DefaultValue(false), MonitoringDescription(SR.ProcessCreateNoWindow), NotifyParentProperty(true)]
  134.         public bool CreateNoWindow {
  135.             get { return createNoWindow; }
  136.             set { createNoWindow = value; }
  137.         }
  138.        
  139.         /// <devdoc>
  140.         /// <para>[To be supplied.]</para>
  141.         /// </devdoc>
  142.         [Editor("System.Diagnostics.Design.StringDictionaryEditor, " + AssemblyRef.SystemDesign, "System.Drawing.Design.UITypeEditor, " + AssemblyRef.SystemDrawing), DesignerSerializationVisibility(DesignerSerializationVisibility.Content), DefaultValue(null), MonitoringDescription(SR.ProcessEnvironmentVariables), NotifyParentProperty(true)]
  143.         public StringDictionary EnvironmentVariables {
  144.             get {
  145.                 if (environmentVariables == null) {
  146.                     #if PLATFORM_UNIX
  147.                     environmentVariables = new CaseSensitiveStringDictionary();
  148.                     #else
  149.                     environmentVariables = new StringDictionary();
  150.                     #endif // PLATFORM_UNIX
  151.                    
  152.                     // if not in design mode, initialize the child environment block with all the parent variables
  153.                     if (!(this.weakParentProcess != null && this.weakParentProcess.IsAlive && ((Component)this.weakParentProcess.Target).Site != null && ((Component)this.weakParentProcess.Target).Site.DesignMode)) {
  154.                        
  155.                         foreach (DictionaryEntry entry in Environment.GetEnvironmentVariables())
  156.                             environmentVariables.Add((string)entry.Key, (string)entry.Value);
  157.                     }
  158.                    
  159.                 }
  160.                 return environmentVariables;
  161.             }
  162.         }
  163.        
  164.         /// <devdoc>
  165.         /// <para>[To be supplied.]</para>
  166.         /// </devdoc>
  167.         [DefaultValue(false), MonitoringDescription(SR.ProcessRedirectStandardInput), NotifyParentProperty(true)]
  168.         public bool RedirectStandardInput {
  169.             get { return redirectStandardInput; }
  170.             set { redirectStandardInput = value; }
  171.         }
  172.        
  173.         /// <devdoc>
  174.         /// <para>[To be supplied.]</para>
  175.         /// </devdoc>
  176.         [DefaultValue(false), MonitoringDescription(SR.ProcessRedirectStandardOutput), NotifyParentProperty(true)]
  177.         public bool RedirectStandardOutput {
  178.             get { return redirectStandardOutput; }
  179.             set { redirectStandardOutput = value; }
  180.         }
  181.        
  182.         /// <devdoc>
  183.         /// <para>[To be supplied.]</para>
  184.         /// </devdoc>
  185.         [DefaultValue(false), MonitoringDescription(SR.ProcessRedirectStandardError), NotifyParentProperty(true)]
  186.         public bool RedirectStandardError {
  187.             get { return redirectStandardError; }
  188.             set { redirectStandardError = value; }
  189.         }
  190.        
  191.        
  192.         public Encoding StandardErrorEncoding {
  193.             get { return standardErrorEncoding; }
  194.             set { standardErrorEncoding = value; }
  195.         }
  196.        
  197.         public Encoding StandardOutputEncoding {
  198.             get { return standardOutputEncoding; }
  199.             set { standardOutputEncoding = value; }
  200.         }
  201.        
  202.        
  203.         /// <devdoc>
  204.         /// <para>[To be supplied.]</para>
  205.         /// </devdoc>
  206.         [DefaultValue(true), MonitoringDescription(SR.ProcessUseShellExecute), NotifyParentProperty(true)]
  207.         public bool UseShellExecute {
  208.             get { return useShellExecute; }
  209.             set { useShellExecute = value; }
  210.         }
  211.        
  212.        
  213.         /// <devdoc>
  214.         /// <para>
  215.         /// Returns or sets the application, document, or URL that is to be launched.
  216.         /// </para>
  217.         /// </devdoc>
  218.         [DefaultValue(""), Editor("System.Diagnostics.Design.StartFileNameEditor, " + AssemblyRef.SystemDesign, "System.Drawing.Design.UITypeEditor, " + AssemblyRef.SystemDrawing), MonitoringDescription(SR.ProcessFileName), RecommendedAsConfigurable(true), TypeConverter("System.Diagnostics.Design.StringValueConverter, " + AssemblyRef.SystemDesign), NotifyParentProperty(true)]
  219.         public string FileName {
  220.             get {
  221.                 if (fileName == null)
  222.                     return string.Empty;
  223.                 return fileName;
  224.             }
  225.             set { fileName = value; }
  226.         }
  227.        
  228.         /// <devdoc>
  229.         /// Returns or sets the initial directory for the process that is started.
  230.         /// Specify "" to if the default is desired.
  231.         /// </devdoc>
  232.         [DefaultValue(""), MonitoringDescription(SR.ProcessWorkingDirectory), Editor("System.Diagnostics.Design.WorkingDirectoryEditor, " + AssemblyRef.SystemDesign, "System.Drawing.Design.UITypeEditor, " + AssemblyRef.SystemDrawing), RecommendedAsConfigurable(true), TypeConverter("System.Diagnostics.Design.StringValueConverter, " + AssemblyRef.SystemDesign), NotifyParentProperty(true)]
  233.         public string WorkingDirectory {
  234.             get {
  235.                 if (directory == null)
  236.                     return string.Empty;
  237.                 return directory;
  238.             }
  239.             set { directory = value; }
  240.         }
  241.        
  242.         /// <devdoc>
  243.         /// Sets or returns whether or not an error dialog should be displayed to the user
  244.         /// if the process can not be started.
  245.         /// </devdoc>
  246.         [DefaultValueAttribute(false), MonitoringDescription(SR.ProcessErrorDialog), NotifyParentProperty(true)]
  247.         public bool ErrorDialog {
  248.             get { return errorDialog; }
  249.             set { errorDialog = value; }
  250.         }
  251.        
  252.         /// <devdoc>
  253.         /// Sets or returns the window handle to use for the error dialog that is shown
  254.         /// when a process can not be started. If <see cref='System.Diagnostics.ProcessStartInfo.ErrorDialog'/>
  255.         /// is true, this specifies the parent window for the dialog that is shown. It is
  256.         /// useful to specify a parent in order to keep the dialog in front of the application.
  257.         /// </devdoc>
  258.         [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
  259.         public IntPtr ErrorDialogParentHandle {
  260.             get { return errorDialogParentHandle; }
  261.             set { errorDialogParentHandle = value; }
  262.         }
  263.        
  264.         /// <devdoc>
  265.         /// Sets or returns the style of window that should be used for the newly created process.
  266.         /// </devdoc>
  267.         [DefaultValueAttribute(System.Diagnostics.ProcessWindowStyle.Normal), MonitoringDescription(SR.ProcessWindowStyle), NotifyParentProperty(true)]
  268.         public ProcessWindowStyle WindowStyle {
  269.             get { return windowStyle; }
  270.             set {
  271.                 if (!Enum.IsDefined(typeof(ProcessWindowStyle), value))
  272.                     throw new InvalidEnumArgumentException("value", (int)value, typeof(ProcessWindowStyle));
  273.                
  274.                 windowStyle = value;
  275.             }
  276.         }
  277.     }
  278. }

Developer Fusion