¿Hay un equivalente de C# de m_nCmdShow?

Question

En un programa MFC, puede determinar si el atajo de la aplicación tenía el valor de Ejecución establecido en "Minimizado" al verificar el valor de m_nCmdShow. ¿Hay una manera equivalente de hacer esto en C#?

Para aclarar, no quiero establecer el estado de un formulario en particular. Si observa las propiedades de un acceso directo, hay una opción "Ejecutar". Puede establecer este valor en la Ventana Normal, Minimizado o Maximizado.

En C++ puede leer el valor de inicio establecido en m_nCmdShow. Necesito hacer lo mismo en C#.

actualización

Este intento:

[STAThread] 
static void Main(string[] args) 
{ 
    ProcessStartInfo processInfo = Process.GetCurrentProcess().StartInfo; 
    MessageBox.Show(processInfo.WindowStyle.ToString()); 
    ... 
} 

siempre informa Normal, no importa lo que el acceso directo se establece en.

Answer 1

En WindowsForms es la propiedad WindowState de la clase Form. verifíquelo en las propiedades en el momento del diseño o configúrelo desde el código.

Editar: Al ejecutar el programa desde un acceso directo, es probable que Windows use CreateProcess API pasando una estructura STARTUPINFO.

de su aplicación de Windows Forms que conseguir dicha estructura de esta manera:

System.Diagnostics.Process.GetCurrentProcess().StartInfo 

que contiene la propiedad: WindowStyle y los valores disponibles para el mismo, los de la enumeración:

System.Diagnostics.ProcessWindowStyle 

por lo :

Hidden; 
Minimized; 
Maximized; 
Normal; 

y ese es el mapeo de m_nCmdShow que el OP está buscando.

Answer 2

Esto le permite recuperar el estado de la ventana inicial accediendo a NativeMethods.StartupInfo.GetInitialWindowStyle() en su código. Puede usar más información accediendo al NativeMethods.StartupInfo.FromCurrentProcess. Si inicia su programa desde cmd.exe con START "My Program Title" /MIN MyProgram.exe, encontrará "Mi título de programa" en NativeMethods.StartupInfo.FromCurrentProcess.lpTitle y NativeMethods.StartupInfo.GetInitialWindowStyle() y devuelve ProcessWindowStyle.Minimized.

static partial class NativeMethods 
{ 
    public static class StartupInfo 
    { 
     [StructLayout(LayoutKind.Sequential)] 
     public class STARTUPINFO 
     { 
      public readonly UInt32 cb; 
      private IntPtr lpReserved; 
      [MarshalAs(UnmanagedType.LPWStr)] public readonly string lpDesktop; 
      [MarshalAs(UnmanagedType.LPWStr)] public readonly string lpTitle; 
      public readonly UInt32 dwX; 
      public readonly UInt32 dwY; 
      public readonly UInt32 dwXSize; 
      public readonly UInt32 dwYSize; 
      public readonly UInt32 dwXCountChars; 
      public readonly UInt32 dwYCountChars; 
      public readonly UInt32 dwFillAttribute; 
      public readonly UInt32 dwFlags; 
      [MarshalAs(UnmanagedType.U2)] public readonly UInt16 wShowWindow; 
      [MarshalAs(UnmanagedType.U2)] private UInt16 cbReserved2; 
      private IntPtr lpReserved2; 
      public readonly IntPtr hStdInput; 
      public readonly IntPtr hStdOutput; 
      public readonly IntPtr hStdError; 
     } 

     public readonly static STARTUPINFO FromCurrentProcess = null; 

     const uint STARTF_USESHOWWINDOW = 0x00000001; 
     const ushort SW_HIDE = 0; 
     const ushort SW_SHOWNORMAL = 1; 
     const ushort SW_SHOWMINIMIZED = 2; 
     const ushort SW_SHOWMAXIMIZED = 3; 
     const ushort SW_MINIMIZE = 6; 
     const ushort SW_SHOWMINNOACTIVE = 7; 
     const ushort SW_FORCEMINIMIZE = 11; 

     [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)] 
     static extern void GetStartupInfoW(IntPtr startupInfoPtr); 

     static StartupInfo() //Static constructor 
     { 
      FromCurrentProcess = new STARTUPINFO(); 
      int length = Marshal.SizeOf(typeof(STARTUPINFO)); 
      IntPtr ptr = Marshal.AllocHGlobal(length); 

      Marshal.StructureToPtr(FromCurrentProcess, ptr, false); 

      GetStartupInfoW(ptr); 

      Marshal.PtrToStructure(ptr, FromCurrentProcess); 
      Marshal.FreeHGlobal(ptr); 
     } 

     public static ProcessWindowStyle GetInitialWindowStyle() 
     { 
      if ((FromCurrentProcess.dwFlags & STARTF_USESHOWWINDOW) == 0) return ProcessWindowStyle.Normal; 

      switch (FromCurrentProcess.wShowWindow) 
      { 
       case SW_HIDE: return ProcessWindowStyle.Hidden; 
       case SW_SHOWNORMAL: return ProcessWindowStyle.Normal; 
       case SW_MINIMIZE: 
       case SW_FORCEMINIMIZE: 
       case SW_SHOWMINNOACTIVE: 
       case SW_SHOWMINIMIZED: return ProcessWindowStyle.Minimized; 
       case SW_SHOWMAXIMIZED: return ProcessWindowStyle.Maximized; 
       default: return ProcessWindowStyle.Normal; 
      } 
     } 
    } 
}