C# - Argumento por linha de comando (listando arquivos aberto com o programa)

 Neste post vou explicar sobre um recurso existente na maioria dos programas que executamos diariamente no nosso computador que funciona quase como um "atalho" que é o Argumento por linha de comando. No geral quando vamos abrir um arquivo .doc (Documento do Word) ou .txt (Documento de texto) o Windows já tem no Gerenciador de Registros a informação de qual será o programa que vai abrir este arquivo, então ao dar dois cliques sobre o arquivo o Windows abre o programa enviando o diretório do arquivo a ser aberto, assim não é necessário primeiro abrir o software para ir até a opção abrir arquivo.
 Só para informar, o argumento por linha de comando não serve apenas para receber arquivos, mas também para receber qualquer informação que você quiser passar para o programa, ele era principalmente usado nos programas do MS-DOS que recebiam aquelas informações junto com a chamada do programa.

 No C# e na maioria das linguagens isso é bem simples e de forma parecida, isso porque o diretório do arquivo vai ser recebido através dos argumentos da função main. Geralmente ao criar um projeto em C# um dos arquivos presente no Solution Explorer é o Program.cs, nele tem a função main do seu programa, a primeira a ser executada, ele vem dessa forma:

 ...  
   static class Program  
   {  
     /// <summary>  
     /// The main entry point for the application.  
     /// </summary>  
     [STAThread]  
     static void Main()  
     {  
       Application.EnableVisualStyles();  
       Application.SetCompatibleTextRenderingDefault(false);  
       Application.Run(new Form1());  
     }  
   }  
 ....  

 Nesse caso a função main não recebera nada pois ele não tem o parâmetro necessário para receber os argumentos de linha de comando, esse parâmetro é o args que é uma array de strings que precisa ser colocado, então na linha "static void Main()" substitua por "static void Main(string[] args)" de uma maneira que seu código fique assim:

 ...  
   static class Program  
   {  
     /// <summary>  
     /// The main entry point for the application.  
     /// </summary>  
     [STAThread]  
     static void Main(string[] args)  
     {  
       Application.EnableVisualStyles();  
       Application.SetCompatibleTextRenderingDefault(false);  
       Application.Run(new Form1());  
     }  
   }  
 ....  

  Se você esta no modo WindowsForms e quer chamar uma função que esta no Form1 é necessario criar um objeto da classe do seu formulário para depois chamar a função Run enviando o objeto do seu Form. Você pode fazer da seguinte maneira:

 ...  
   static class Program  
   {  
     /// <summary>  
     /// The main entry point for the application.  
     /// </summary>  
     [STAThread]  
     static void Main(string[] args)  
     {  
       Application.EnableVisualStyles();  
       Application.SetCompatibleTextRenderingDefault(false);  
       // Cria o objeto da classe Form1  
       Form1 f1 = new Form1();  
       f1.LoadFile(args[0]);  
       // Inicia o f1  
       Application.Run(f1);  
     }  
   }  
 ....  

 O problema de se fazer isso é que nem sempre que seu programa for iniciado será enviado um arquivo, então nesses casos aconteceria um erro em tempo de execução, para que isso não ocorra é necessario verificar se há algum argumento na array args, para isso basta usar um if para verificar o tamanho da array e para ficar ainda melhor você pode testar se o arquivo existe, mas nesse caso será necessario adicionar a "using System.IO;", veja o exemplo abaixo:

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Windows.Forms;  
 using System.IO;  
 namespace txtedit  
 {  
   static class Program  
   {  
     /// <summary>  
     /// The main entry point for the application.  
     /// </summary>  
     [STAThread]  
     static void Main(string[] args)  
     {  
       Application.EnableVisualStyles();  
       Application.SetCompatibleTextRenderingDefault(false);  
       // Cria o objecto da class Form1  
       Form1 f1 = new Form1();  
       // Verifica se há algum arquivo sendo aberto com o programa  
       if (args.Length > 0)  
       {  
         // Verifica se o arquivo existe  
         if (File.Exists(args[0]))  
         {  
           f1.LoadFile(args[0]);  
         }  
       }  
       // Inicia o f1  
       Application.Run(f1);  
     }  
   }  
 }  

 Se algum controle da Form1 estiver como public você pode chamar a função do controle diretamente dessa parte e até mesmo verificar se a extensão é .rtf (também precisa de System.IO), veja esse exemplo:

 ...  
   static class Program  
   {  
     /// <summary>  
     /// The main entry point for the application.  
     /// </summary>  
     [STAThread]  
     static void Main(string[] args)  
     {  
       Application.EnableVisualStyles();  
       Application.SetCompatibleTextRenderingDefault(false);  
       // Cria o objecto da class Form1  
       Form1 f1 = new Form1();  
       // Verifica se há algum arquivo sendo aberto com o programa  
       if (args.Length > 0)  
       {  
         // Verifica se o arquivo existe  
         if (File.Exists(args[0]))  
         {  
           // Verifica se a extensão do arquivo é .rtf  
           if (Path.GetExtension(args[0]) == ".rtf")  
           {  
             // Carrega o arquivo diretamente para o richTextBox1  
             f1.richTextBox1.LoadFile(args[0]);  
           }  
         }  
       }  
       // Inicia o f1  
       Application.Run(f1);  
     }  
   }  
 ....  

 Se você estiver no modo console application isso é mais fácil ainda, isso também porque ele já vem com o parâmetro args na função main, veja este exemplo de como listar multiplos arquivos que estão sendo abertos por linha de comando usando o foreach:

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 namespace argstest  
 {  
   class Program  
   {  
     static void Main(string[] args)  
     {  
       // Verifica se tem argumentos na linha  
       if (args.Length > 0)  
       {  
         // Lista os arquivos na linha de comando  
         foreach (string arg in args)  
         {  
           // Mostra o nome do arquivo  
           Console.WriteLine("- " + arg);  
         }  
       }  
       else  
       {  
         // Caso não tenha  
         Console.WriteLine("Nenhum arquivo na linha de comando!");  
       }  
       // Espera o usuario pressionar enter  
       Console.ReadLine();  
     }  
   }  
 }  

Se não tiver nenhum:

Se tiver varios:

 Este exemplo mostra somente o nome do arquivo (também precisa do Sistem.IO):

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 using System.IO;  
 namespace argstest  
 {  
   class Program  
   {  
     static void Main(string[] args)  
     {  
       // Verifica se tem argumentos na linha  
       if (args.Length > 0)  
       {  
         // Lista os arquivos na linha de comando  
         foreach (string arg in args)  
         {  
           // Mostra o nome do arquivo  
           string fn = Path.GetFileName(arg);  
           Console.WriteLine("- " + fn);  
         }  
       }  
       else  
       {  
         // Caso não tenha  
         Console.WriteLine("Nenhum arquivo na linha de comando!");  
       }  
       // Espera o usuario pressionar enter  
       Console.ReadLine();  
     }  
   }  
 }  

 Ou se você não usa o "foreach" e só usa o "for":

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 using System.IO;  
 namespace argstest  
 {  
   class Program  
   {  
     static void Main(string[] args)  
     {  
       // Verifica se tem argumentos na linha  
       if (args.Length > 0)  
       {  
         // Lista os arquivos na linha de comando (usando for)  
         for (int index = 0; index < args.Length; index++)  
         {  
           // Mostra o nome do arquivo  
           string fn = Path.GetFileName(args[index]);  
           Console.WriteLine("- " + fn);  
         }  
       }  
       else  
       {  
         // Caso não tenha  
         Console.WriteLine("Nenhum arquivo na linha de comando!");  
       }  
       // Espera o usuario pressionar enter  
       Console.ReadLine();  
     }  
   }  
 }  

 Para mais informações sobre argumento por linha de comando você pode verificar este link para o site da microsotf: http://msdn.microsoft.com/pt-br/library/cb20e19t.aspx
 Espero ter ajudado