How to make exe file with parameters

See more:

C#

C#4.0

Hi everybody,

I'm using vs2010, and i want to make an exe file, that asks for parameters, can i declare inside my file variable myproces.startinfo.arguments?

here my code:

<pre lang="msil">
class Program
   {
         [STAThread]
       static void Main(string[] args)
       {
             new Program();

       }
         public Program()
         {
             Process myProces = new Process();
             myProces.StartInfo.CreateNoWindow = true;
             //string strFolderPathFromUser = "C:\\";
             myProces.StartInfo.Arguments = ".";
             myProces.StartInfo.UseShellExecute = false;
             myProces.StartInfo.RedirectStandardInput = true;
             myProces.StartInfo.RedirectStandardOutput = true;
             myProces.StartInfo.WorkingDirectory = ".";
             myProces.StartInfo.RedirectStandardError = true;
             PrintDialog pd = new PrintDialog();
             pd.PrinterSettings = new PrinterSettings();
             if (DialogResult.OK == pd.ShowDialog())
             {
                 // Print the file to the printer.
                 RawPrinterHelper.SendFileToPrinter(pd.PrinterSettings.PrinterName, myProces.StartInfo.Arguments);

             }

 #region RawPrinterHelper
          public class RawPrinterHelper
          {
              // Structure and API declarions:
              [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
              public class DOCINFOA
              {
                  [MarshalAs(UnmanagedType.LPStr)]
                  public string pDocName;
                  [MarshalAs(UnmanagedType.LPStr)]
                  public string pOutputFile;
                  [MarshalAs(UnmanagedType.LPStr)]
                  public string pDataType;
              }
              [DllImport("winspool.Drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
              public static extern bool OpenPrinter([MarshalAs(UnmanagedType.LPStr)] string szPrinter, out IntPtr hPrinter, IntPtr pd);

              [DllImport("winspool.Drv", EntryPoint = "ClosePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
              public static extern bool ClosePrinter(IntPtr hPrinter);

              [DllImport("winspool.Drv", EntryPoint = "StartDocPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
              public static extern bool StartDocPrinter(IntPtr hPrinter, Int32 level, [In, MarshalAs(UnmanagedType.LPStruct)] DOCINFOA di);

              [DllImport("winspool.Drv", EntryPoint = "EndDocPrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
              public static extern bool EndDocPrinter(IntPtr hPrinter);

              [DllImport("winspool.Drv", EntryPoint = "StartPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
              public static extern bool StartPagePrinter(IntPtr hPrinter);

              [DllImport("winspool.Drv", EntryPoint = "EndPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
              public static extern bool EndPagePrinter(IntPtr hPrinter);

              [DllImport("winspool.Drv", EntryPoint = "WritePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
              public static extern bool WritePrinter(IntPtr hPrinter, IntPtr pBytes, Int32 dwCount, out Int32 dwWritten);

               //SendBytesToPrinter()
               //When the function is given a printer name and an unmanaged array
               //of bytes, the function sends those bytes to the print queue.
               //Returns true on success, false on failure.

              #region SendBytesToPrinter
              public static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, Int32 dwCount)
              {
                  Int32 dwError = 0, dwWritten = 0;
                  IntPtr hPrinter = new IntPtr(0);
                  DOCINFOA di = new DOCINFOA();
                  bool bSuccess = false; // Assume failure unless you specifically succeed.

                  di.pDocName = "My C#.NET RAW Document";
                  di.pDataType = "RAW";

                  // Open the printer.
                  if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
                  {
                      // Start a document.
                      if (StartDocPrinter(hPrinter, 1, di))
                      {
                          // Start a page.
                          if (StartPagePrinter(hPrinter))
                          {
                              // Write your bytes.
                              bSuccess = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                              EndPagePrinter(hPrinter);
                          }
                          EndDocPrinter(hPrinter);
                      }
                      ClosePrinter(hPrinter);
                  }
                  // If you did not succeed, GetLastError may give more information
                  // about why not.
                  if (bSuccess == false)
                  {
                      dwError = Marshal.GetLastWin32Error();
                  }
                  return bSuccess;
              }
              #endregion

              #region SendFileToPrinter
              public static bool SendFileToPrinter(string szPrinterName, string szFileName)
              {

                  // Open the file.
                  FileStream fs = new FileStream(szFileName, FileMode.Open);
                  // Create a BinaryReader on the file.
                  BinaryReader br = new BinaryReader(fs);

                  // Dim an array of bytes big enough to hold the file's contents.
                  Byte[] bytes = new Byte[fs.Length];
                  bool bSuccess = false;
                  // Your unmanaged pointer.
                  IntPtr pUnmanagedBytes = new IntPtr(0);
                  int nLength;

                  nLength = Convert.ToInt32(fs.Length);
                  // Read the contents of the file into the array.
                  bytes = br.ReadBytes(nLength);
                  // Allocate some unmanaged memory for those bytes.
                  pUnmanagedBytes = Marshal.AllocCoTaskMem(nLength);
                  // Copy the managed byte array into the unmanaged array.
                  Marshal.Copy(bytes, 0, pUnmanagedBytes, nLength);
                  // Send the unmanaged bytes to the printer.
                  bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, nLength);
                  // Free the unmanaged memory that you allocated earlier.
                  Marshal.FreeCoTaskMem(pUnmanagedBytes);
                  return bSuccess;


              }
              #endregion</pre>

</pre> 

I want to start a cmd command and go to path of .exe and run it with an argument, thus .exe space filetosendtoprinter.

Thanks for any help.