DragDrop de arquivos em C#

Não pretendia fazer outro post tão cedo, mas lembrei disso e achei que poderia ser interessante.

Estive trabalhando em um software que envia um arquivo pela porta serial.
A princípio o arquivo deveria ser procurado entre as pastas do computador através de uma janela do Explorer e ao clicar em "Abrir" na janela de navegação o caminho do arquivo era copiado para uma TextBox na minha janela principal.
Eu decidi adicionar uma opção em que se possa arrastar e soltar o arquivo na janela e então recuperar o caminho para manipular o arquivo como desejado. Fiz isso utilizando os eventos de DragDrop já disponíveis em C#.

No caso estou trabalhando dentro da classe da minha janela principal, chamada Form1.cs e tenho uma TextBox chamada nomeArquivo.

A primeira coisa a fazer é modificar a propriedade AllowDrop da Form1 para true. Isso pode ser feito no modo Design.

A parte do código é bem simples.
É possivel recuperar o caminho do arquivo desejado na forma de um vetor de strings de forma muito simples. Se você soltar um grupo de arquivos você ficará com o caminho de cada arquivo em uma posição do vetor.

Exemplo: Eu usei o evento DragEnter para definir o efeito e DragDrop para recuperar o caminho do arquivo.

{
.
.
.
    private void Form1_DragEnter(object sender, DragEventArgs e)
    {
        if(e.Data.GetDataPresent(DataFormats.FileDrop))
            e.Effect = DragDropEffects.Copy;
    }

    private void Form1_DragDrop(object sender, DragEventArgs e)
    {
        string[] arquivos = (string[])e.Data.GetData(DataFormats.FileDrop);
        nomeArquivo.Text = arquivos.Last();
    }
.
.
.
}


No caso eu não tenho como carregar mais de um arquivo ao mesmo tempo, então eu decidi optar por pegar sempre o último arquivo do vetor (se colocar apenas um arquivo, ele é carregado; se forem vários, pega só o último do vetor). Mas só fiz isso porque realmente não me interessa, nessse caso, trabalhar com mais de um arquivo.

Até mais.

Problema com threads e porta serial em C#

Faz um tempão que não posto aqui, mas hoje também não poderei me deter muito aqui. O fato de eu não ter postado nada aqui ultimamente não quer dizer que eu esteja parado. O problema é que algumas vezes começo a trabalhar em mais de um software ao mesmo e começa a ficar difícil filtrar e decidir o que pode ser interessante postar aqui e o que só é relevante lá dentro do software mesmo.
Mas essa semana me deparei com algo muito incômodo. Eu já fiz um outro post falando um pouco sobre comunicação serial com C#, então não vou entrar em detalhes agora, embora eu não tenha explorado todos os recursos da classe SerialPort naquele post. Mas o fato aqui é outro: usar uma thread para receber os dados de uma porta serial.
Mas o que é uma thread?
Thread é um trecho de código-fonte que deve ser executado determinado número de vezes (ou o tempo inteiro) em paralelo ao código do programa. Na prática esses processos não são paralelos, o que acontece na verdade é uma alternância entre o código principal e o código da thread.
Eu, particularmente, prefiro não usar threads se houver uma forma de não usá-las, mas às vezes não há escapatória.

Meu caso:
Estive refazendo um código de programa desenvolvido em VB 6.0 que o Visual Studio converteu parcialmente para VB.NET. O software usava um componente de comunicação serial obsoleto (conhecido como MSComm) o qual substitui por um objeto da classe SerialPort do namespace System.IO.Ports, com as devidas alterações no código-fonte, claro. Mas não foi sobre isso que vim escrever.
Feito isso decidi reescrever o código em C# (para fins de conhecimento geral, pois isso me ajudou a conhecer um pouco do VB.NET, que até então não tinha tido contato) e depois implementar um terminal de comunicação serial no software. Basicamente um terminal para enviar comandos via porta serial e escrever as linhas recebidas como resposta na tela.
O problema de fazer isso é que é necessário ficar "monitorando" a porta serial, ficar constantemente lendo a entrada de dados. Para fazer isso pode-se criar uma thread que fique executando um código que leia a porta serial e escreva o que foi lido num TextBox, por exemplo. Mas não vou entrar no detalhe da criação de uma thread.
A outra forma de fazer isso é usar o evento DataReceived existente na classe SerialPort e é a forma que demonstrarei. Esse evento já funciona como uma thread então os mesmos problemas que eu tive com thread eu encontrei ao lidar com esse evento.

Executar um programa externo em C#

Uma tarefa simples e um post curto dessa vez.

Para executar um programa externo em C# há o namespace 'System.Diagnostics.Process'.
Você pode inserí-lo no início do programa, ou simplesmente utilizá-lo por extenso junto com o método quando precisar.
Por exemplo:

{
.
.
.
    //linhas
    //de
    //código

    System.Diagnostics.Process.Start("C:\Pasta\programa.exe");

    //linhas
    //de
    //código
.
.
.
}

Só vou fazer uma observação. Se na string do caminho para executar o programa houver algum caracter especial ('\t', '\n' ou outros do gênero) coloque um @ antes da aspa inicial para que ele não interprete esses caracteres como caracteres especiais.
Exemplo:

{
.
.
.
    //linhas
    //de
    //código

    System.Diagnostics.Process.Start(@"C:\Pasta\trabalho\arquivo.exe");

    //linhas
    //de
    //código
.
.
.
}

Eu não vou entrar em detalhes de como o 'System.Diagnostics.Process.Start' pode ser usado.
No site abaixo há vários exemplos de como utilizá-lo, eu apenas estaria copiando de lá.

Site útil:
http://social.msdn.microsoft.com/Forums/pt-BR/vscsharppt/thread/762f056e-85e9-4adf-8af6-d12abd3d78b0

Conectando a um banco de dados MySQL com C#

Bom. Primeiro você precisará baixar e instalar o MySql Connector Net, para usar MySQL no Visual Studio.
    Link:
    http://dev.mysql.com/downloads/connector/net/6.1.html

Segundo. Será necessário um servidor MySQL.
    XAMPP
    http://www.baixaki.com.br/download/xampp.htm

Sempre que precisar conectar ao banco de dados você deverá estar com o xampp em execução e o MySQL do xampp iniciado (conforme a imagem). Para iniciar ele é só clicar no "Start" ao lado do MySQL.

Agora ao que interessa.
Na Solution Explorer do programa em que pretende utilizar o banco de dados, clique com o botão direito do mouse em 'References' e então clique em 'Add Reference'.

Abrirá uma nova janela. Na aba '.NET' ache o componente 'MySql.Data' selecione-o e então clique OK.

Feito isso adicione o namespace no início do programa utilizando a instrução 'using'.
Exemplo:
using System;
using System.Text;
using System.Collections.Generic;
using MySql.Data.MySqlClient;\\ <====

Feito isso vamos aos atributos.

Criar planilha do Excel em C#

Para criar uma planilha do Excel em C# podemos proceder de duas maneiras.

A primeira seria utilizar um StreamWriter comum para criar um arquivo com extensão ".xls" e utilizar tabulação (\t) e nova linha (\n) para separar colunas e linhas.
Eu fiz isso a princípio, e até consegui abrir o arquivo no Excel, mas há uma forma mais apropriada para fazê-lo. E foi a forma que eu preferi adotar.

No Visual Studio 2008:

Primeiro será preciso adicionar uma referência ao projeto. No "Solution Explorer" clicar em "References" com o botão direito do mouse e clicar em "Add Reference".

Nas abas superiores da janela que abriu vá para a aba "COM".
Na lista de componentes da aba COM procure em "Component Name" por:

     Microsoft Excel 12.0 Object Library

OBS.: O '12.0' é referente à versão, então pode não ser esse o número.

Selecione o componente e clique OK.

Próximo passo...

No início da classe em que pretende fazer os métodos do Excel adicionar o namespace Microsoft.Office.Interop.Excel, utilizando a instrução 'using', da seguinte maneira. Exemplo:

using System;
using System.Collection.Generics;
using System.Text;
using Excel = Microsoft.Office.Interop.Excel;

Acessando porta serial com C#

Enviar uma string via porta serial.
Esse é o objetivo.

Em C# há um namespace próprio para trabalhar com portas seriais do computador:
System.IO.Ports

Ele fornece uma série de métodos e propriedades que podemos usar para trabalhar com porta serial.
O primeiro passo é incluir o namespace no início do arquivo de código fonte da classe onde você pretende acessar a porta serial, junto com os demais namespaces que estiver usando. Exemplo:

using System;
using System.Collection.Generics;
using System.Text;
using System.IO.Ports;

Dentro desse namespace há uma classe chamada SerialPort. O próximo passo é criar um atributo, que é um objeto da classe SerialPort, dentro da classe que estiver usando.

class Nome_da_classe
{
    static SerialPort _portaCOM;

.
.
.
}

"_portaCOM" é um nome para o atributo. Você pode escolher outro nome.

OBS.: Se estiver criando um programa diretamente no método Main(), a classe deve ser declarada antes do Main().

public class Nome_da_classe
{
    static SerialPort _portaCOM;

    public static void Main()
    {
        //linhas
        //de
        //código
    }
}

Feito isso vamos ao que interessa.

Início

Bom, esse é o primeiro post do blog e não será muito extenso.
Na verdade ele é só para explicar sobre o que o blog será.

O blog será, basicamente, sobre programação e a intenção é registrar o que precisei fazer durante meu período de estágio, as dificuldades que encontrei e como contornei elas.
A princípio trabalharei principalmente com C# (mas isso pode mudar no decorrer do caminho) em Windows e, ocasionalmente, em Linux.

Ao final do meu período de estágio talvez eu mude um pouco o blog.
Mas isso não importa agora.

Acho que por enquanto era isso.