sábado, 8 de novembro de 2014

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

segunda-feira, 8 de setembro de 2014

C++ - Ola Mundo - Aula 1

 Muitas pessoas que estão começando a estudar C++ simplesmente desistem pois acham muito difícil, na realidade ele não é muito difícil e acho muito melhor programar em C++ do que em outras linguagens, a maioria das bibliotecas são feitas para o C++ e existem muitos tutorias pela internet que ajudam muito quem esta começando a programar em C++.
 No geral se você ler uma apostila inteira de C++ você aprende somente a criar programas em Console, mas aprende todas as regras, funções de bibliotecas padrões, trabalhar com arquivos, comandos de controle de fluxo e outros, depois de conhecer tudo isso você deve começar estudar bibliotecas relacionadas ao tipo de programa você vai desenvolver, por exemplo, DirectX ou OpenGL para trabalhar com gráficos 3D e desenvolvimento de jogos, ffmpeg para a edição de videos, mas isso varia muito com o que você vai desenvolver.
 Existem muitas bibliotecas para facilitar o trabalho manual, por exemplo, para criar uma simples janela você deve conhecer o Win32 API, mas existem bibliotecas como QT, GTK+, WxWidgets e outros que facilitam este serviço para você.
 Como na maioria das apostilas, eu vou começar falando do C++ com o exemplo Ola Mundo que é simplesmente um programa que imprime Ola Mundo no Console, para isso vou estar utilizando o Visual Studio 2012 (deixei o link de download na postagem anterior).
 Apos instalar e abrir o Visual Studio você deve ver a seguinte tela:
 Primeiramente, na maioria das apostilas existem duas formas de imprimir o Ola Mundo na tela, uma das maneiras é usando o arquivo de cabeçalho "stdio.h"que significa Standard Input/Output ou Entradas e Saídas Padronizadas, e outra usando o "iostream.h" que significa Input/Output Stream que ficaria mais ou menos Fluxo de Entrada e Saída em português.
 No geral, a maioria das pessoa preferem o "iostream.h" do que o "stdio.h" pois dizem que é mais seguro, mais rápido e mais fácil mas nos antigos compiladores de linguagem C o "iostream.h" não existia.
 Se você ficou confuso nessa primeira parte não se preocupe, vou falar disso em outros posts, mas hoje vou começar mostrando o método usando o "stdio.h" que não é complicado.
 Primeiro abra sua IDE que no meu caso é o Visual Studio, clique em File->New->Project, neste momento vai abrir uma janela para você escolher o tipo de projeto que você quer, do lado esquerdo da janela em Templates escolha a opção Visual C++ e na lista ao lado escolha a opção Win32 Console Application como na imagem abaixo:


























 Preencha o campo Name e clique em OK, a seguir vai aparecer outra janela, apenas clique em Finish, sera gerado um codigo como esse:
 // Aula1_blog.cpp : Defines the entry point for the console application.  
 //  
 #include "stdafx.h"  
 int _tmain(int argc, _TCHAR* argv[])  
 {
      
      return 0;  
 }  

Se você já leu apostilas de C++ você deve ter percebido que no geral a primeira função a ser iniciada é a função main, mas no Visual Studio para ter compatibilidade com algumas bibliotecas o ponto de entrada acaba sendo diferente, no caso o _tmain, e para utilizarmos a função de escrita precisaríamos incluir a biblioteca "stdio.h", mas o próprio "stdafx.h" já inclui o "stdio.h".
 A primeira e a segunda linha do código acima começam com \\ (Duas Barras), isso significa que são comentários e serão desconsiderados pelo compilador, ou seja, você pode utiliza-las para manter seu código mais organizado.
 A terceira linha tem a diretiva de compilação #include que diz ao compilador para incluir um arquivo de código fonte, quando ele esta entre aspas duplas significa que o arquivo esta no seu projeto, quando esta entre os símbolos de < "Menor que" e o > "Maior que" significa que o documento a ser incluso esta nas includes do compilador.
 A quarta linha é uma função, vamos falar futuramente o que são funções, no caso acima o "int
" que tem antes do _tmain quer dizer o tipo que a função vai retornar, no caso um numero inteiro, o _tmain é o nome da função que é o ponto de entrada e o que tem entre os parenteses são os parâmetros da função que também vou falar futuramente sobre isso.
 O que tem na quinta e na ultima linha são chaves "{ }" que delimitam até onde vai a função, sempre quando a função termina ela deve retornar o tipo especificado na criação da função, no caso da _tmain é um valor inteiro, por isso na sexta linha esta escrito return 0;.
 Sempre que você termina uma linha do código que sejam operações de alteração, chamadas de função e outros você precisam terminar com ponto e virgula no final, como você pode ver na linha 6.
 Agora vamos chamar a função para escrever o texto "Ola Mundo" na tela.
 A função da "stdio.h" usada para escrever algo na tela é a printf, mas como estamos usando o Visual Studio vamos usar o printf_s, adicione a seguinte linha antes do codigo "return 0":
      printf_s("Ola Mundo");  
      getchar();  
 printf_s é uma função usada para mostrar textos, numeros e outros na tela, quando chamamos uma função mandamos informações para ela chamadas de argumentos, estas informações devem estar entre parenteses como você pode ver acima, mas no nosso caso esta informação é um texto (o que chamamos de string e vamos explicar depois) e devemos coloca-los entre aspas duplas para que os compilador não confunda o texto com um codigo, e no final não devemos de esquecer de colocar o ponto e virgula.
 getchar é uma função usada para receber um caractere, mas no nosso caso usamos somente para manter nosso texto na tela, caso contrario ele apareceria durante menos de 1 segundo, do mesmo jeito que o printf_s devemos colocar os parenteses pois getchar também é uma função, porem ela não recebe parâmetros então deixamos os parenteses vazios, e novamente terminamos com ponto e virgula no final.
 O código inteiro deve ter ficado dessa maneira:
 // Aula1_blog.cpp : Defines the entry point for the console application.  
 //  
 #include "stdafx.h"  
 int _tmain(int argc, _TCHAR* argv[])  
 {  
      printf_s("Ola Mundo");  
      getchar();  
      return 0;  
 }  
 Apos ter escrito este código você já pode executa-lo, para isso você clica em Debug e em Start Debugging, este modo de execução avisa quando tem um erro no tempo de execução, mas seu executável também foi gerado e deve estar no diretório de Documentos\Visual Studio 2012\Projects\Nome_do_seu_projeto\Debug\Nome_do_projeto.exe
 O resultado final da execução deve ter ficado dessa maneira:
Neste post é só, se vocês tiverem alguma duvida coloquem nos comentários, até o próximo post.

Postagens sobre programação

 Hoje depois de 9 meses sem postar nada voltei para falar que vou começar fazer aulas sobre programação aqui no blog, se você for ver as próximas aulas é necessário que você tenha instalado uma IDE, eu vou estar utilizando o Visual Studio que vocês podem baixar no site da microsoft no seguinte link:
 http://www.visualstudio.com/downloads/download-visual-studio-vs
 Se vocês quiserem usar outra IDE para C++ eu recomendo o Code::Blocks, mas este usa o compilador MinGW.
 Provavelmente vou começar falando de C++ ou C# mas depois vou falar de outras linguagens e bibliotecas.

sexta-feira, 31 de janeiro de 2014

O que fazer quando cai algum liquido sobre o notebook

 Você estava tomando café e ao colocar a xícara em cima da mesa ela acabou desequilibrando de sua mão e caiu sobre o teclado de seu notebook? Isso é muito comum principalmente com o café e é muito provável que a garantia não cubra estes tipos de danos, mas mantenha a calma e veja os passos abaixo.
 Tudo vai depender da velocidade na hora que o liquido acabou de cair, você deverá logo no momento desligar seu notebook ou até mesmo já retirar a bateria de seu notebook, retire também o cabo do carregador e outros equipamentos conectados em seu notebook como Pen Drive e outros.
 Se tiver caído água sobre seu notebook seu problema será menor mas em muitos casos é mais comum cair café sobre o notebook o que é um grande problema principalmente porque ele tem açúcar.
 Jamais ligue seu notebook enquanto ele estiver molhado, pode dar curto e queimar a placa mãe e você poderá ter um prejuízo muito maior.
 Agora você pode levar a um técnico e pagar para fazer uma limpeza ou você mesmo poderá fazer a limpeza, caso você mesmo quiser fazer a limpeza siga os passos abaixo.
 Se você tiver deixado cair líquidos doce como café é bem provável que o teclado vai ser uma das partes mais afetadas, ele poderá ficar pegajoso e após um tempo pode parar de dar contato e algumas teclas vão parar de funcionar.
 Você pode passar um pano úmido com água somente nas partes de plastico(Não use aguá para limpar a placa mãe).
 O teclado é uma parte complicada de limpar, se você quiser limpar o teclado coloque as teclas na ordem certa para não causar confusão na hora da montagem, cuidado para não quebrar as presilhas que ficam no formato de X, algumas teclas como o espaço podem ter dois pares de presilhas.
 Tome cuidado com a energia estática, utilize pulseira anti-estática para evitar queimar CIs ou outros componentes.
 Se tiver caído somente água uma simples secagem com ar morno pode resolver o problema, mas o café(Ou outros líquidos doce) pode deixar a placa grudenta e após um certo tempo começa a oxidar o que é um grande problema.
 Lave a placa com álcool Isopropílico(1% de água ou menos) e esfregue com um pincel Anti-Estático, o álcool isopropílico vai evaporar rapidamente, você pode usar um jato de ar morno para secar a parte interna da placa e evitar que fique umidade, utilizando uma lupa verifique se a placa tem algum ponto de oxidação, caso tenha utiliza um limpa contato para remove-la, coloque limpa contato também nos conectores da placa mãe como por exemplo o do teclado.
 Espere algumas horas antes de ligar seu notebook para ter certeza que esteja tudo seco.
 Caso o notebook não ligue ou apresente outros problemas verifique se você montou corretamente, caso você não encontre o problema leve-o a uma assistência técnica.
------------------------------------------------------------------------------------------------------------
 Isso aconteceu comigo semana passada, eu derrubei meio copo de café fervendo e doce sobre o teclado do notebook, mas com rapidez eu o desliguei, removi a bateria e outros componentes e fiz a limpeza acima e voltou a funcionar normalmente, agora só estou com problemas com algumas teclas do meu teclado.