Excel e C#: Adicionar célula ou linha + Modificar fonte, cores e bordas

A ideia é que o post de hoje seja rápido e o mais curto possível.
Vou agrupar todas as explicações em um único código.

Como foi no post anterior, vou partir do princípio de que o componente para trabalhar com Excel já foi adicionado às referências do projeto.

Se não estiver entendendo absolutamente nada do que está lendo sugiro ver o post Criar planilha do Excel em C#. Lá tem um tutorial para adicionar o componente Microsoft Excel 12.0 Object Library às referências, não que não sirva pra outras versões, mas a que está lá é a 12.0.

No meu primeiro post sobre Excel e C#, o qual eu citei acima, eu coloquei um método para remover linhas do Excel. Recentemente me dei conta de que precisava de um método para adicionar linhas também. Essa vai ser a primeira parte do post. É bem simples: usando um Excel.Range eu defino qualquer célula que pertença à linha onde eu quero inserir uma nova linha e então eu uso o método Insert para inserir uma linha. É possível inserir uma única célula também, mas os detalhes ficam no código.

A segunda parte do código é para mostrar um pouco de formatação de células: como mudar a fonte, o tamanho da fonte, a cor, opções de negrito, sublinhado e itálico, alinhamento do texto, tamanho da célula, cor de fundo da célula e opções de borda.

Basicamente é isso.
Então vamos começar.
Vou fazer do mesmo jeito que fiz no post anterior, vou só abrir um documento que tenho num Form vazio e fazer as alterações no construtor, apenas pra exemplificar, mostrando os métodos responsáveis por cada uma das coisas que citei acima.

Excel e C#: Abrir uma planilha e ler células

Vou começar este post de um ponto um pouco avançado.
Vou fazer isso na verdade porque há outro post no blog que fala sobre criaçao de planilhas do Excel.
Então, caso não entendas alguma parte, sugiro ver o post Criar planilha do Excel em C#, antes de perguntar quaisquer coisas. Se ainda assim houverem dúvidas, é só comentar.


A ideia hoje é fazer duas coisas basicamente. A primeira está descrita no título: abrir um planilha (e possivelmente ler alguma informação). A segunda é fazer algumas observações importantes sobre a leitura de células no Excel.

Vamos começar pelo código para abrir uma planilha.
Quero deixar claro que para que o código abaixo funcione é preciso primeiro adicionar a biblioteca do Microsoft Office Excel às referências. Não é o foco deste post descrever esta parte passo a passo, então, caso não saibas como fazer, sugiro olhar o outro post que comentei ali em cima.
Vamos ao que interessa.

Para abrir uma planilha é preciso primeiramente iniciar o Excel, criando uma nova instância. Depois basta usar o método Open da classe Workbooks de dentro da classe Application.
O quê? Oo
=]
Melhor mostrar no código.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Excel = Microsoft.Office.Interop.Excel;

namespace TesteExcel

{
    public partial class Form1 : Form
    {
        private Excel.Application excelApp = null;
        private Excel.Workbook arquivoDeTrabalho = null;
        private Excel.Worksheet planilha = null;

        public Form1()
        {
            InitializeComponent();

            string celula = "";
            List lista = new List();

            /*Iniciando o Excel e desligando os alertas.*/

            excelApp = new Excel.Application();
            excelApp.DisplayAlerts = false;

            /*Abrindo arquivo.*/
            arquivoDeTrabalho = (Excel.Workbook)excelApp.Workbooks.Open(

            "C:\\ExemploTeste.xlsx", 0, true, 5, "", "", 

            true, Excel.XlPlatform.xlWindows, "\t", false, 

            false, 0, true, null, null);

            /*Selecionando a primeira planilha como planilha de trabalho.*/
            planilha = (Excel.Worksheet)arquivoDeTrabalho.Sheets[1];
            /*Lendo os valores das 25 primeiras células e exibindo em uma MessageBox.*/
            for (int i = 1; i < 6; i++)
            {
                for (int j = 1; j < 6; j++)
                {
                    try
                    {
                        celula = ((Excel.Range)planilha.Cells[i, j]).Value2.ToString();
                    }
                    catch (Exception e)

                    {

                        celula = "Erro: " + e.Message;

                    }
                    lista.Add(celula);
                }
            }
            foreach (string s in lista)
                MessageBox.Show(s);
            

            arquivoDeTrabalho.Close(false, "", false);
            excelApp.Quit();
        }
    }
}

iTextSharp (parte 3) - PDF: Exemplo de código em C# com texto, imagem e tabela

Caso você não tenha lido:
Parte 1
Parte 2

Explicações dadas, problemas resolvidos, vamos ao código.
Vou usar como texto a primeira parte do post.

Para usar o iTextSharp você precisa adicioná-lo às referências do seu projeto.
Abaixo um passo a passo:

Clique com o botão direito do mouse no seu namespace dentro do Solution Explorer.

No menu aberto, clique em Add Reference...

Uma nova janela será aberta. Nessa janela selecione, entre as abas na parte superior da janela, a aba Browse.

iTextSharp (parte 2) - PDF: Imagens e tabelas em C#

[update]
Gostaria de salientar que este post e o anterior contêm apenas explicações. Nada de código. Se, por algum motivo, houver preferência por ver apenas um código de exemplo do uso do iTextSharp, sugiro ir direto para o terceiro post, mas acho que a leitura das explicações pode ajudar bastante.
[/update]

Retomando o assunto de criação de pdf em C# com o iTextSharp.
Se você não está entendendo o que está acontecendo você provavelmente deveria começar a leitura pelo primeiro post.

Imagens
Para trabalhar com imagens eu usei combinações entre a classe System.Drawing.Image e a classe Image do iTextSharp.
Antes de mais nada é preciso entender que eu fiz uso de imagens que eu havia adicionado aos Recursos do meu projeto. Pra quem não souber como fazer é bom ver o post do blog que fala sobre isso. Pode acessar aqui.

Eis o que eu fiz a partir disso.
Defini um objeto System.Drawing.Image chamado imagemTemporaria.
Ele receberá cada imagem antes de passá-la para a classe Image do iTextSharp.
Serão duas imagens.

Primeiro eu instancio o objeto imagemTemporaria usando um new System.Drawing.Bitmap e passando a imagem que está nos Recursos como parâmetro.
Depois crio uma nova instância da classe Image do iTextSharp usando Image.GetInstance e passando por parâmetros o objeto imagemTemporaria e um objeto indicando o formato. Como no meu caso é um arquivo PNG, o segundo parâmetro será System.Drawing.Imaging.ImageFormat.Png.
Feito isso eu ajusto a propriedade Alignment da minha imagem.
Existem várias combinações possíveis, então não vou entrar em detalhes. Cada um pode fazer os testes necessários.
Eu farei uso da combinação Image.LEFT_ALIGN e Image.TEXTWRAP, usando o operador | de forma semelhante ao que é feito nos estilos para a classe Font, que eu mostrei nos post anterior.
Por fim ajusto a escala da imagem se necessário, utilizando o metódo ScalePercent, passando o valor percentual como parâmetro.

Repito isso para minhas duas imagens.

iTextSharp (parte 1) - PDF: Criação de documento e adição de texto em C#

[update]
Gostaria de salientar que este post e o seguinte contêm apenas explicações. Nada de código. Se, por algum motivo, houver preferência por ver apenas um código de exemplo do uso do iTextSharp, sugiro ir direto para o terceiro post, mas acho que a leitura das explicações pode ajudar bastante.
[/update]

Nos próximos dias, a ideia é falar sobre criação de documentos em pdf.

Pra quem ainda não viu, um tempo atrás eu fiz um post sobre geração de arquivos do Excel.

A ideia aqui segue a mesma linha:
Eu precisava gerar um documento. A reação inicial foi: "Vou gerar um documento do Word, a biblioteca deve ser bem parecida com a do Excel". Mas então recebi a sugestão de trabalhar com '.pdf', já que pode ser aberto em um visualizador que é distribuído gratuitamente, ao contrário do '.doc' que usa o Word. Gostei da sugestão e fui pesquisar sobre bibliotecas para geração de pdf que eu pudesse integrar ao meu projeto em C#. Acabei encontrando o iTextSharp.

iTextSharp é uma biblioteca (ou um componente, se preferirem ver dessa forma) que permite fazer diversas operações com documentos pdf. Das várias possibilidades que encontrei na internet ele é com certeza um dos mais completos na área, embora ainda faltem alguns recursos que, em determinados momentos, poderiam ter sido extremamente úteis para mim. Mas nenhum grande transtorno.

Bom, a intenção, então, é falar sobre esse "cara", ou ao menos começar a falar.

Vejamos o que pretendo abordar nos próximos dias:

- Criação do documento em si, principais parâmetros.
- Principais observações sobre como adicionar, ao documento:
  - Parágrafos, utilizando a classe Paragraph.
  - Frases, utilizando a classe Phrase.
  - Imagens (superficialmente).
- Abordagem rápida sobre como adicionar tabelas, mas com foco em demostrar os problemas que tive, e como os resolvi.


Eu mudei um pouco a ideia de como produzir os posts. Tenho preferido fazer uma explicação e depois deixar o código todo agrupado, ao invés de ter um parágrafo de explicação e um trecho de código, como nos primeiros posts. Embora isso deixe a explicação com uma aparência um pouco densa, acredito que o código agrupado é melhor. Em todo caso vou tentar separar a explicação em pequenos títulos dessa vez.
No último post eu colocarei apenas um código de exemplo. Embora me pareça ruim a ideia de o código estar separado do post acho que fica melhor organizado dessa forma.

Sobre o iTextSharp.
Ele é gratuito e você pode baixá-lo aqui, ou pela página abaixo:
http://sourceforge.net/projects/itextsharp/


Sobre o documento.

Criação do documento
Para a criação do documento em pdf será necessário fazer uso da classe Document em conjunto com o método GetInstance, da classe PdfWriter.
A classe Document pode ser instanciada sem parâmetros, com um Rectangle que representa o tamanho da página, ou com um Rectangle e as medidas das bordas (quatro objetos float).
No código irei mostrar o instanciamento com o tamanho da página e as bordas.

Feito isso será necessário iniciar uma sequência try/catch.
Dentro do try é feita a chamada ao PdfWriter.GetInstance, com 2 parâmetros: uma classe Document e uma FileStream. A classe Document é, obviamente, a que instanciamos antes do try e a FileStream pode ser instanciada ali mesmo, passando um nome para o arquivo e um FileMode.Create, como parâmetros.

Pode parecer meio sem sentido ficar escrevendo assim, mas com o código ficará claro. Ao menos é o que eu espero.

Carregando biblioteca no código com C#

Post curto porém útil hoje.
Ao menos do meu ponto de vista.

Eventualmente você quer rodar um software sem fazer uma instalação, certo?
Mas se você estiver usando uma biblioteca como você carrega essa biblioteca junto com o código do seu programa?
Bom. A solução que eu encontrei foi a seguinte, carregar a biblioteca com os recursos do meu projeto e escrevê-la no local onde o software é exetucado.
É bem simples.
Vejamos com um exemplo. Supondo que o nome da biblioteca seja minhaBiblioteca.dll.

Primeiro eu adiciono ela aos recursos do meu projeto, como um array de bytes
(opção Files, dentro de Resources.resx).
Não vou entrar em detalhes nesse post de como isso é feito, mas quem não souber como fazer pode dar uma olhada nesse outro post aqui.

Depois posso fazer o seguinte no construtor da minha Form1.cs.


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace MeuProjeto
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();

            if (!System.IO.File.Exists(Application.StartupPath + "\\minhaBiblioteca.dll"))
            {
                System.IO.File.WriteAllBytes(
                    Application.StartupPath + "\\minhaBiblioteca.dll", 
        global::MeuProjeto.Properties.Resources.minhaBiblioteca);
            }
        }
    }
}


É preciso ter cuidado ao fazer esse tipo de operação.
Se você não tiver permissão pra escrever arquivos no local onde o sofware estiver sendo executado, uma exceção será gerada.
Nesse caso, seria interessante colocar o if em uma estrutura try-catch. Não fiz isso porque, no meu caso, sei que ele não passará por esse problema, então seria código desnecessário.
Outro ponto importante de se ressaltar é que o arquivo, no caso do código acima, não foi apagado do sistema, então permanecerá lá mesmo após o software ter sido fechado.
É possível criar código para remover o arquivo do sistema, ou simplesmente deixar que o usuário remova-o manualmente se desejar.

[update]
Um dia desses estava fazendo algo semelhante a ideia desse post e pensei em postar aqui.
No caso acima eu usei o método System.IO.File.WriteAllBytes, pois se tratava de uma biblioteca. Há outros métodos de escrita dentro de System.IO.File que podem ser mais ou menos apropriados dependendo de com o que estás trabalhando.
Quando se carrega um arquivo xml, por exemplo, ele fica armazenado, nos Recursos, como texto. Era esse o meu caso: eu tinha um arquivo serializado xml que continha dados necessários para preencher uma lista do software, e então eu usei o método System.IO.File.WriteAllText para escrever o arquivo no local onde o programa é executado.
Nem vou colocar código porque é basicamente a mesma coisa do exemplo acima, apenas quis chamar atenção para a existência de diferentes métodos.
[/update]

Por enquanto era isso.
Qualquer dúvida é só comentar.

Adicionando arquivos aos recursos do projeto C#

O post de hoje será focado em como adicionar arquivos aos recursos do seu projeto, os quais ficam armazenados na Resources.resx e também em mostrar como usar estes arquivos adicionados.

Basicamente é possível adicionar arquivos de imagens, ícones, áudio, texto e outros (para arquivos em geral). Também há a opção de adicionar strings dentro do Resources.resx, mas aí já não se trata de arquivos em si. Vou falar apenas sobre arquivos e exemplificarei com um exemplo que adiciona e usa uma imagem e um exemplo que adiciona uma biblioteca (.dll).

Primeiro é necessário abrir a interface do Resources.resx.
Na árvore de arquivos do seu projeto, à direita na imagem abaixo, expanda a pasta Properties.
Fazendo isso o Resources.resx ficará visível, como na imagem.

Exemplo de TextBox com máscara de horário em C#

Olha eu aqui de novo.


Hoje vou escrever um pouco sobre máscaras em TextBox. Mais especificamente sobre uma TextBox com máscara de horário no formato xx:xx que eu precisei fazer, mas a lógica básica para criar uma máscara serve como ideia, fora isso, só é necessário aplicar as regras específicas dependendo das regras da sua máscara.
O post de hoje é um pouco diferente, pois eu não vou, digamos assim, "dar o assunto por encerrado", a ideia é deixar a minha máscara incompleta, ou seja, não aplicar todas as regras necessárias.
Por quê?
Primeiro: porque dependendo de como você trabalha com a TextBox algumas regras podem ser desnecessárias, pois podem nunca acontecer.
Segundo: porque é para ser uma ideia geral apenas e não necessariamente completa.
Terceiro e mais improvável: se alguém ler e perguntar algo ou sugerir um problema relacionado especificamente com a máscara que eu vou abordar no post, eu posso fazer um edit e adicionar o caso sugerido.


Bom, primeiro explicando a ideia básica.
O objetivo é uma TextBox com uma máscara de horário xx:xx que, quando o usuário digitar, vá substituindo do primeiro ao último dígito do horário automaticamente. Ela começará com o valor 00:00 e as regras básicas que eu vou aplicar são:
1 - O primeiro dígito das horas não pode ser maior do que 2.
2 - Se o primeiro dígito das horas for 2 o segundo não pode ser maior do que 3.
3 - O primeiro dígito dos minutos não pode ser maior do que 5.
4 - O usuário não pode substituir o ':' em ocasião alguma.

Controles com transparência em C#

Blog meio largado às traças.
Ao menos é isso que deve parecer pra quem olha, mas não é isso não. Só não andava sabendo o que postar, ou como postar. E também andei meio empenhado por aqui aí acabei deixando o blog de lado um pouco, mas resolvi postar aqui uma coisa que considero interessante.


Quem já lidou na plataforma .Net e precisou fazer alguma coisa de interface um pouco complexa, já deve ter se deparado com o mesmo problema. A plataforma não suporta transparência, pelo menos não uma transparência de fato.
Se tu, por exemplo, selecionares um controle qualquer e mudares a propriedade BackColor para Color.Transparent o que ele faz na verdade é pintar o background do controle da mesma cor do background do container em que o controle se encontra, ou (o que efetivamente acontece) da mesma cor do que estiver selecionado como Parent.
Explicação rápida: Parent é uma propriedade do tipo Control, que armazena um controle que é "superior" em relação ao controle com o qual se está trabalhando. Ao menos é esse meu entendimento, a partir do que eu vi até hoje em relação a essa propriedade. Ela é bem comum em controles dentro de containers (Nota: container também é um controle), onde o container, geralmente, é o Parent dos controles dentro dele. Os controles dentro do container são chamados de Childs.
Voltando ao assunto, se tu pegares um controle que tem um canto arredondado, por exemplo, e colocá-lo por cima de outro controle, perceberás que o canto está pintado da cor do background do container, o que não é efetivamente transparente.
Isso não será um problema, se teus controles forem estáticos e não forem se sobrepor.
Mas e se eles forem?
Bom, a boa notícia é que há uma solução, a ruim é que, dependendo do que tu fores desenvolver tu podes não gostar muito do resultado, ou achar apenas razoável. É o meu caso, achei razoável.

Agora por partes.
Pesquisando na internet por transparência é possível encontrar coisas que não funcionam, como é o caso da Color.Transparent, ou coisas que não estão relacionadas com esse assunto, mas sim com uma transparência em relação às outras coisas na tela do computador, como a propriedade TransparencyKey. Usando essa propriedade, você pode escolher uma cor que fique completamente transparente no software, mostrando o que estiver atrás dele na tela do seu computador. Mas isso também não é o que eu quero.

Aí vem a questão. Dependendo do tipo de aplicação que tu estiveres desenvolvendo tu precisas de mais ou menos recursos. Por exemplo, tu simplesmente tens um controle com cantos arredondados, que está por cima de uma imagem e tu precisas que os cantos dele fiquem transparentes pra imagem aparecer corretamente. Ou tu estás criando controles que precisam se movimentar e são mais dinâmicos.
No meu caso, por exemplo, meus controles são espécies de quebra-cabeças, eles precisam se encaixar, e para isso há partes deles que precisarão ficar transparentes.
Basicamente, a implementação da transparência é uma só, mas se eles serão dinâmicos (o usuário poderá movimentá-los) há mais algumas coisas para prestar atenção além da implementação da transparência.

Primeiro uma explicação escrita, depois o código de fato.