Curso Programando com C# e o Visual Studio.NET 2005

Prévia do material em texto

Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 1 
 
 
 
 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 2 
 
Nota sobre direitos autorais: 
 
Este e-book é de autoria de Herbert Moroni Cavallari da Costa Gois, sendo 
comercializado diretamente através do site www.juliobattisti.com.br e 
www.linhadecodigo.com.br ou através do site de leilões Mercado Livre: 
www.mercadolivre.com.br, mediante contato através do email: 
batisti@hotmail.com ou webmaster@juliobattisti.com.br, diretamente pelo autor ou 
por Júlio Battisti. No Mercado Livre, somente o usuário GROZA é que tem 
autorização para comercializar este e-book. Nenhum outro usuário/email e/ou 
empresa está autorizada a comercializar este ebook. 
 
Ao adquirir este ebook você tem o direito de lê-lo na tela do seu computador e de 
imprimir quantas cópias desejar. É vetada a distribuição deste arquivo, mediante 
cópia ou qualquer outro meio de reprodução, para outras pessoas. Se você recebeu 
este ebook através do e-mail ou via ftp de algum site da Internet, ou através de 
um CD de Revista, saiba que você está com uma cópia pirata, ilegal, não 
autorizada, a qual constitui crime de Violação de Direito Autoral, de acordo com a 
Lei 5988. Se for este o caso entre em contato com o autor, através do e-mail 
webmaster@juliobattisti.com.br, para regularizar esta cópia. Ao regularizar a sua 
cópia você irá remunerar, mediante uma pequena quantia, o trabalho do autor e 
incentivar que novos trabalhos sejam disponibilizados. Se você tiver sugestões 
sobre novos cursos que gostaria de ver disponibilizados, entre em contato pelo e-
mail: webmaster@juliobattisti.com.br. 
 
Visite periodicamente o site www.juliobattisti.com.br para ficar por dentro das 
novidades: 
• Cursos de informática. 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 3 
 
• Guias de Estudo para os Exames de Certificação da Microsoft. 
• Artigos e dicas sobre Certificações da Microsoft. 
• Artigos sobre Carreira e Trabalho. 
• Dicas de livros e sites sobre diversos assuntos. 
• Simulados gratuitos, em português, para os exames da Microsoft. 
 
 
• ESTE E-BOOK NÃO PODE SER FORNECIDO EM UM CD 
OU DVD DE NENHUMA REVISTA 
• SE VOCÊ OBTEVE UMA CÓPIA DESTE E-BOOK 
ATRAVÉS DO E-MULE, KAZAA, MORPHEUS OU 
OUTRO PROGRAMA DE COMPARTILHAMENTO, 
SAIBA QUE VOCÊ ESTÁ COM UMA CÓPIA ILEGAL, 
NÃO AUTORIZADA 
• USAR UMA CÓPIA NÃO AUTORIZADA É CRIME DE 
VIOLAÇÃO DE DIREITOS AUTORAIS, COM PENA 
PREVISTA DE CADEIA
 
 
 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 5 
 
PRÉ-REQUISITOS PARA O CURSO: 
 
Para que você possa acompanhar as lições deste curso é necessário que você já 
tenha preenchido os seguintes pré-requisitos: 
 
• Conhecimento básico do Windows 98, 2000 ou XP, tais como: 
 
	 Criação de pastas e subpastas. 
	 Utilização do mouse e do teclado. 
	 Operações básicas com arquivos e pastas, usando o Windows 
Explorer. 
	 Conhecer conceitos tais como ícones, área de trabalho, janelas do 
Windows, uso de menus e outras configurações básicas do Windows. 
 
 
 
 
 
 
 
 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 6 
 
Palavras do autor: 
 
A proposta desde curso é ajudá-lo a entrar no mundo da programação usando a 
linguagem C# e a ferramenta Visual Studio .NET 2005. Para tanto, não exite em 
fazer os exemplos propostos. Aprender a programar é como dirigir, você aprende 
fazendo, para isso apresentamos uma série de exemplos passo-a-passo e conforme 
vamos nos aprofundando nos exemplos e as duvidas vão surgindo discutimos a 
teoria, assim fica mais fácil assimilar e memorizar o assunto proposto. 
 
Também estou a disposição para responder eventuais dúvidas sobre o conteúdo do 
curso, envie-me também suas sugestões para que possamos sempre melhorar o 
material proposto. Meu e-mail para contato é herbertmoroni@hotmail.com ou 
moroni@weblitenet.com.br. 
 
Ao final deste curso você vai dominar a linguagem de programação C# e vai saber 
como tirar proveito dos principais recursos do Visual Studio .NET 2005, 
proporcionando melhor produtividade no desenvolvimento de sistemas. 
 
 
 
 
 
 
 
 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 7 
 
Índice do Curso 
Índice do Curso............................................................................................ 7 
Introdução ................................................................................................ 10 
Módulo 1 .............................................................................................................................................13 
Bem vindo ao C# e ao Visual Studio.NET 2005 ..................................................................13 
Lição 1 – Bem vindo ao C# e ao Visual Studio .NET 2005 ........................................13 
Lição 2 – Usando o CSC para compilar seu programa.................................................28 
Lição 3 – Criando sua primeira aplicação Windows com C# e o Visual Studio 
.NET .................................................................................................................................................34 
Lição 4 – Criando documentação usando XML e cometários.....................................47 
Módulo 2 .............................................................................................................................................56 
Variáveis .............................................................................................................................................56 
Lição 5 – Entendo variáveis e tipos de dados .................................................................56 
Lição 6 – Nomeando uma variável ......................................................................................59 
Lição 7 – Palavras Reservadas do C# ................................................................................61 
Lição 8 – Declarando variáveis .............................................................................................62Lição 9 – Atribuindo valor a variáveis ................................................................................63 
Lição 10 – Tipos de dados ......................................................................................................64 
Lição 11 – Adicionando valor a uma variável ..................................................................67 
Lição 12 – Operadores .............................................................................................................69 
Módulo 3 .............................................................................................................................................81 
Métodos e Escopo ...........................................................................................................................81 
Lição 13 – Entendento métodos ...........................................................................................81 
Lição 14 – Entendento Escopo ..............................................................................................86 
Lição 15 – Criando e Chamando Métodos.........................................................................89 
Módulo 4 ...........................................................................................................................................107 
Estruturas de Decisão .................................................................................................................107 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 8 
 
Lição 16 – Entendendo as Estruturas de Decisão........................................................107 
Lição 17 – Usando o if ............................................................................................................108 
Lição 18 – Usando o switch..................................................................................................118 
Módulo 5 ...........................................................................................................................................129 
Estruturas de Repetição .............................................................................................................129 
Lição 19 – Usando o while ....................................................................................................129 
Lição 20 – Usando o do .........................................................................................................134 
Lição 21 – Usando o for .........................................................................................................138 
Lição 22 – Conhecendo o foreach ......................................................................................143 
Módulo 6 ...........................................................................................................................................144 
Gerenciando Erros e Exceções .................................................................................................144 
Lição 23 – Conhecendo os três tipos de erros ..............................................................144 
Lição 24 – Encontrando erros com o Visual Studio.NET 2005 ................................145 
Lição 25 – Usando a janela Watch ....................................................................................158 
Lição 26 – Usando a janela Command.............................................................................163 
Lição 27 – try..catch ...............................................................................................................166 
Lição 28 – Usando try...catch aninhados ........................................................................176 
Lição 29 – Programação defensiva....................................................................................180 
Lição 30 – Exit try....................................................................................................................181 
Módulo 7 ...........................................................................................................................................183 
Arrays e Coleções .........................................................................................................................183 
Lição 31 – Usando Arrays .....................................................................................................183 
Lição 32 – Coleções.................................................................................................................197 
Módulo 8 ...........................................................................................................................................205 
Aprofundando em Windows Forms.........................................................................................205 
Lição 33 – Trabalhando com múltiplos formulários ....................................................205 
Lição 34 – Passando valores entre Forms ......................................................................212 
Lição 35 – Posicionando os formulários na tela............................................................217 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 9 
 
Lição 36 – Controlando os eventos dos formulários ...................................................218 
Módulo 9 ...........................................................................................................................................221 
Usando controles do Windows Forms....................................................................................221 
Lição 37 – Usando o controle dateTimePicket...............................................................221 
Lição 38 – Usando os controles radioButton, checkBox, listBox e comboBox..226 
Módulo 10 ........................................................................................................................................238 
Bancos de dados com ADO.NET ..............................................................................................238 
Lição 39 – Conceitos básicos de banco de dados ........................................................238 
Lição 40– Usando o Visual Studio 2005 para manipular dados de um banco de 
dados. ...........................................................................................................................................245 
Módulo 11 ........................................................................................................................................260 
Imprimindo ......................................................................................................................................260 
Lição 41 – Imprimindo a partir de uma textBox ..........................................................260 
Módulo 12 ........................................................................................................................................274 
Distribuindo sua aplicação .........................................................................................................274 
Lição 42 – Criando um projeto de instalação ................................................................275 
Lição 43 – Executando o programa de instalação .......................................................295Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 10 
 
Introdução 
 
Neste curso você vai aprender a usar a linguagem de programação C# e utilizar 
seus recursos para desenvolver aplicações para Windows através da ferramenta 
Visual Studio .NET 2005. 
 
O C#, junto com o Visual Studio .NET 2005 compõe uma ferramenta extremamente 
robusta e fácil de utilizar, com perfeito suporte a todas as novas ondas que rondam 
o mundo da informática e tecnologia. 
 
O Visual Studio .NET 2005 é a melhor ferramenta de desenvolvimento de aplicações 
para a plataforma .NET. Com uma interface amigável e integrada com os ambientes 
e de fácil entendimento, proporciona aos desenvolvedores a criação de aplicações 
sofisticadas com todos os recursos existentes, sem ter que ficar criando parte de 
código em um aplicativo e o restante no outro. É possivel com o Visual Studio 
gerenciar recursos da máquina e local e de um possível servidor, criar aplicações 
para Windows, web e dispositivos móveis. 
 
Capítulo 1: Neste capítulo você vai iniciar no desenvolvimento usando o Visual 
Studio .NET 2005, vai aprender a criar aplicações Windows e a utilizar o CSC para 
compilar seu programa pelo prompt de comando. Vai aprender também como gerar 
documentação XML a partir de comentários que podem ser inseridos em seus 
programas. 
 
Capítulo 2: Neste capítulo você vai aprender sobre variáveis, tipos de dados, 
conversão de tipos de dados, operadores, o que é Common language Runtime e 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 11 
 
Common Type System, além disso vai receber dicas sobre como nomear suas 
variáveis. 
 
Capitulo 3: Neste capitulo você vai entender o que são métodos e escopo. Vai 
aprender a criar e usar métodos. 
 
Capítulo 4: Neste capítulo você vai aprender sobre estruturas de DECISÃO, vai 
saber como usar o IF e o SWITCH. 
 
Capítulo 5: Neste capítulo você vai aprender sobre estruturas de REPETIÇÃO, vai 
saber como usar o WHILE, o DO, o FOR e vai conhecer o FOREACH. 
 
Capítulo 6: Neste capítulo você vai aprender como encontrar erros utilizando o 
Visual Studio .NET, vai também aprender a usar o Try..Catch..Finally para tratar 
seus erros em tempo de execução. Não bastando vai aprender a programar 
defensivamente, evitando erros. 
 
Capítulo 7: Neste capítulo você vai aprender a criar e manipular dados de Arrays e 
Coleções. 
 
Capítulo 8: Neste capítulo você vai aprender a usar múltiplos formulários no seu 
programa, passar valor entre eles, posicioná-los na tela e controlar seus eventos. 
 
Capítulo 9: Neste capítulo você vai aprender a usar os controles disponíveis para 
suas aplicações Windows, para isso estudaremos o uso dos controles: 
DateTimePicket, RadioButton, CheckBox, ListBox, ComboBox. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 12 
 
Capítulo 10: Neste capítulo você vai aprender os conceitos principais de banco de 
dados e como inserir, apagar e alterar registros. 
 
Capítulo 11: Neste capítulo você vai aprender a imprimir informações de seus 
programas, vai aprende também a implementar os recurso de configurar impressão 
e visualizar impressão. 
 
Capítulo 12: Neste capítulo você vai aprender como distribuir suas aplicações 
criando um instalador. 
 
 
Para enviar suas dúvidas referentes aos assuntos e exemplos abordados neste 
curso, para enviar sugestões de alterações/correções, para sugerir novos cursos, 
para criticar e para elogiar (porque não?), é só entrar em contato pelo e-mail: 
moroni@weblitenet.com.br. 
 
 
 
 
 
 
 
 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 13 
 
Módulo 1 
Bem vindo ao C# e ao Visual Studio.NET 2005 
 
Neste capitulo você vai se familiarizar com a linguagem C# e o ambiente de 
desenvolvimento do Visual Studio .NET 2005. Para isso vai criar uma sua primeira 
aplicação. 
 
 
Lição 1 – Bem vindo ao C# e ao Visual Studio .NET 
2005 
 
Vamos primeiramente conhecer um pouco do Visual Studio.NET, a ferramenta que 
utilizaremos para desenvolver nossos aplicativos e criar nosso primeiro exemplo. 
 
1 – Entre no Visual Studio.NET, eu estou usando a versão 2005, mas os exercícios 
funcionam em qualquer versão. 
 
Você pode entrar no Visual Studio.NET através do menu Iniciar / Programas / 
Microsoft Visual Studio .NET / Microsoft Visual Studio .NET , sinta-se a 
vontade para criar qualquer atalho para ele. 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 14 
 
 
A imagem anterior mostra o Visual Studio .NET assim que o iniciamos, é exibida a 
pagina Start Page onde podemos abrir rapidamente os ultimos projetos criados 
através da caixa Recent Projects. 
 
2 – No menu File, aponte em New, e clique em Project. (Ou clique Ctrl+Shift+N). 
 
 A caixa de dialogo New Project aparece. Ela permite que criemos um novo 
projeto usando vários templates, como um Windows Application, Class Library, 
Console Application e vários outros. 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 15 
 
 
 
3 – No painel Project Type, clique em Visual C# Projects, aqui estão todos os 
templates disponíveis para a linguagem C#. 
 
4 – No painel Templates clique em Console Application. 
 
5 – No campo nome digite, ClassicoHelloWorld. 
 
Perceba que você pode ainda alterar o caminho onde sua aplicação será 
salva e o nome da sua Solução. 
 
6 – Clique em OK. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 16 
 
 
 
A barra de menus (menu bar) possibilita o acesso aos comandos que você usa 
no ambiente de programação. Você pode usar o teclado ou o mouse para acessar o 
menu ou atalhos exatamente como usa em outros programas baseados em 
Windows.A barra de ferramentas (toolbar) é localizada embaixo da barra de menus e 
disponibiliza botões que executam os comandos usados com mais freqüência. Não 
confunda toolbar com toolbox. 
 
A janela Solution Explorer mostra os nomes dos arquivos associados com o seu 
projeto. Você pode dar um clique duplo sobre o nome do arquivo para exibi-lo no 
painel de código (Code pane). Vamos examinar os arquivos que o Visual Studio 
criou como parte do seu projeto: 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 17 
 
• ClassicoHelloWorld.sln organiza os projetos de cada solução, uma solução 
pode ter vários projetos, seu nome é representado no primeiro item na 
janela Solution Explorer só que sem a extensão do arquivo. 
 
• ClassicoHelloWorld.csproj este é o arquivo do projeto C#. Pode ser 
associado a vários arquivos de código. É reconhecido no Solution Explorer 
pelo nome do projeto apenas, no entanto é gravado no disco com a 
extensão .csproj. 
 
• Program.cs é um arquivo de código do C#. Você vai escrever seu código 
neste arquivo. O Visual Studio já adicionou algum código nele 
automaticamente, examinaremos esse código mais adiante. 
 
• AssemblyInfo.cs este é um outro arquivo de código do C#. Você pode usar 
esse arquivo para adicionar atributos ao seu programa, como por exemplo, 
nome do autor, data que o programa foi escrito e outros. Vamos examina-lo 
também mais adiante no curso. 
 
Aos poucos nós vamos explorando mais o Visual Studio, vamos ao nosso primeiro 
exemplo. 
 
O arquivo Program.cs define uma classe chamada Program que contém um 
método chamado Main. Todos os métodos precisam ser definidos dentro de uma 
classe. O método Main é especial porque ele é o primeiro a ser executado quando 
o programa é iniciado, por isso ele precisa ser designado como static (estático), 
métodos e classes vão ser discutidos em detalhes mais adiante no curso. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 18 
 
Importante: O C# é case-sensitive, ele diferencia letras minúsculas de 
maiúsculas, um M é interpretado diferente de um m. Consequentemente Main é 
diferente de main. 
 
Nosso primeiro exemplo é bem simples, e um clássico para quem esta aprendendo 
qualquer linguagem, ele escreve Hello World no console. 
 
7 – Dentro do método Main, entre os colchetes digite: Console 
 
 
 
A classe Console contém os métodos para exibir mensagens na tela e pegar as 
entradas do teclado. Tudo que o usuário digita no teclado pode ser lido através da 
classe Console. A classe Console só é significante para aplicações que rodam no 
prompt de comando como neste nosso primeiro exemplo. 
 
8 – Agora digite um ponto depois de Console. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 19 
 
Uma lista aparece, ela é chamada de IntelliSense, esse não é um recurso 
exclusivo do Visual Studio mas ajuda muito na programação principalmente em 
linguagens case-sensitive, como é o C#. O IntelliSense exibe todos os métodos, 
propriedades e campos da classe. 
 
 
 
9 – Selecione WriteLine, você pode usar o Mouse ou o Teclado, tecle Enter ou dê 
um clique duplo sobre o WriteLine. 
 
O IntelliSense é fechado e o método WriteLine é adicionado ao código. Como a 
seguinte imagem: 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 20 
 
 
 
Quando o IntelliSense aparece você também pode pressionar W para ir direto para 
o primeiro membro do método Console que começar com w. 
 
10 – Abra parênteses ( 
 
É mostrado uma outra forma do IntelliSense, esse mostra os parâmetros do 
método WriteLine. O método WriteLine tem o que chamamos de Sobrecarga 
(Overload). Para cada sobrecarga do método WriteLine usamos parâmetros 
diferentes. Cada sobrecarga e seus respectivos parâmetros podem ser visualizados 
clicando com o mouse na seta do IntelliSense ou navegando pelas setas do 
teclado. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 21 
 
 
 
11 – Feche os parênteses ) e digite ponto-e-virgula, vai ficar assim: 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 22 
 
 
 
12 – Digite entre os parênteses a string “Hello World”, string deve ficar entre 
aspas. Vamos aprender sobre os tipos de dados em detalhes também, o importante 
agora é saber que string é um tipo de dado. Vai ficar assim: 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 23 
 
 
 
Pegue o habito de digitar os pares de caracteres juntos, como ( e ) e { e }, antes 
de entrar com seus respectivos conteúdos. Assim você evitará alguns erros por 
esquecer de fechar. 
 
13 – Vamos agora compilar nossa aplicação. No menu Build, clique em Build 
Solution. Se tudo estiver certinho vai aparecer a seguinte linha na janela Output: 
 
========== Build: 1 succeeded or up-to-date, 0 failed, 0 skipped ========== 
 
Para exibir a janela Output na barra de menus clique em View, Output ou pressione 
Ctrl+W+O. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 24 
 
 
 
Um asterisco depois do nome do arquivo no painel de código indica que foram 
feitas modificações no código do respectivo arquivo e que essas alterações não 
foram salvas. Você pode salvar manualmente antes de compilar a aplicação, mas 
ao compilar o Visual Studio salva automaticamente todos os arquivos da aplicação. 
 
14 – No menu Debug, clique em Start Without Debugging para executar o 
programa no prompt de commando. 
 
CursoProgramando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 25 
 
 
 
O programa vai escrever Hello World como a ilustração acima. 
 
Nós escolhemos Start Without Debugging para forçar uma pausa no final da 
execução. Se clicássemos em Start ele iria executar o programa e fechar o prompt 
de comando logo após a execução, seria tão rápido que não conseguiríamos ver o 
que foi escrito, experimente. 
 
15 – Com o foco no prompt de comando pressione qualquer tecla. 
 
A janela irá fechar e retornaremos para o Visual Studio. 
 
16 - Na janela Solution Explorer, clique no botão Show All Files. 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 26 
 
 
 
Aparecem os nomes bin e obj depois do nome do projeto. Esses dois 
correspondem a pastas com seus respectivos nomes. Essas pastas são criadas 
quando você executa a aplicação e contem uma versão executável do programa e 
outros arquivos necessários para depurar o programa. 
 
 
 
 
17 – Ainda na janela Solution Explorer, clique no sinal de + à esquerda do nome 
bin. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 27 
 
 
 
Um outro nome aparece representando uma outra pasta chamada debug. 
 
18 – Clique no sinal de + de debug. 
 
 
 
Repare nos arquivos: ClassicoHelloWorld.exe e ClassicoHelloWorld.pdb. 
 
O arquivo .exe é o executável da aplicação. 
 
O arquivo .pdb armazena informações de depuração da aplicação. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 28 
 
O arquivo ClassicoHelloWorld.vshost.exe só aparece no Visual Studio 2005, ele 
é usado para melhorar a performance da depuração de erros. 
 
Como vimos até agora, o Visual Studio compilou automaticamente nosso programa 
e criou os arquivos necessários automaticamente, durante o processo de 
compilação. Em resumo a compilação é o processo que transforma seus arquivos 
fonte em um arquivo executável pelo sistema operacional, um .exe por exemplo. 
 
 
Lição 2 – Usando o CSC para compilar seu programa 
 
1 - Com o Visual Studio fechado, na barra de ferramentas do windows clique em 
Iniciar, Executar, digite notepad em Abrir e clique em OK. 
 
 
 
2 - Digite o seguinte código no notepad. 
 
using System; 
 
namespace txtHello 
{ 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 29 
 
 class Class1 
 { 
 static void Main(string[] args) 
 { 
 Console.WriteLine("Hello World"); 
 } 
 } 
} 
 
 
3 – Salve o arquivo com o nome teste.cs 
Para isso será necessário escolher Todos os arquivos na opção Salvar como tipo no 
notepad quando você clicar em Arquivo \ Salvar. 
 
4 – Feche o notepad. 
 
5 – No menu Iniciar, vá em Programas / Visual Studio .NET / Visual Studio 
.NET Tools e clique em Visual Studio .NET Command Prompt. 
 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 30 
 
 
Para compilarmos manualmente nosso programa são necessárias algumas 
mudanças no ambiente do sistema operacional como alterações em algumas 
variáveis de ambiente, PATH, LIB e INCLUDE. Essas mudanças incluem adicionar 
pastas contendo bibliotecas e utilitários .NET. 
 
6 – No prompt, vá até a pasta que você salvou o arquivo teste.cs. 
 
7 – Digite dir e tecle enter. 
 
Ele vai listar os arquivos da pasta, no caso vai mostrar o arquivo teste.cs. 
 
8 – Digite: csc /out:hello.exe teste.cs 
 
Isso vai criar um executável chamado hello.exe. 
 
9 – Digite dir e tecle enter. 
 
Agora você não vê apenas o arquivo teste.cs, foi adicionado um arquivo chamado 
hello.exe, ele é o resultado da compilação do seu arquivo fonte teste.cs. 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 31 
 
 
10 – Digite hello e tecle enter. 
 
 
 
O programa será executado, no caso, será escrito a palavra “Hello World”, no 
prompt semelhante ao que ocorreu com o exemplo da lição 1. 
 
11 – Digite del hello.exe e tecle enter. 
 
Isso apagara o arquivo executável. 
 
12 – Digite csc teste.cs 
 
Ao omitir o parâmetro /out o compilador cria um arquivo executável com o mesmo 
nome do arquivo fonte. Será criado então o arquivo teste.exe, execute este 
arquivo para testá-lo. 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 32 
 
 
13 – Abra novamente o arquivo teste.cs, pode ser no próprio notepad ou no Visual 
Studio .NET. 
 
14 – Apague a primeira linha de código. Vai ficar assim: 
 
namespace txtHello 
{ 
 class Class1 
 { 
 static void Main(string[] args) 
 { 
 Console.WriteLine("Hello World"); 
 } 
 } 
} 
 
15 – Compile e teste a aplicação, novamente fica a sua escolha, use o prompt de 
comando ou o Visual Studio .NET. Uma recomendação, compile manualmente pelo 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 33 
 
prompt para se familiarizar melhor com ele, já que não falaremos muito mais 
sobre ele no curso. 
 
16 – Ao compilar ele vai emitir um erro. Como este: 
 
teste.cs(7,4): error CS0246: The type or namespace name 'Console' could not be 
 found (are you missing a using directive or an assembly reference?) 
 
17 – Mude a linha com Console.WriteLine("HelloWorld"); para 
System.Console.WriteLine("Hello World"); 
 
18 - Compile e teste novamente. 
 
A compilação é concluída com sucesso e o programa funciona normalmente só que 
desta vez sem a diretiva using System; 
 
Como parte do Microsoft .NET Framework o C# pode fazer uso de uma série de 
classes de utilidades que executam uma gama de operações úteis. Essas classes 
são organizadas no que chamamos de namespaces, eles contem um conjunto de 
classes relacionadas e também podem conter outros namespaces. 
 
System é um namespace. O namespace System é o mais importante porque 
contém as classes que a maior parte das aplicações utiliza para interagir com o 
sistema operacional. 
 
A classe Console é uma classe do namespace System. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 34 
 
O método Writeline é um método da classe console que escreve uma mensagem 
no prompt de comando. 
 
Os namespaces ajudam a reduzir a complexidade de um programa e a facilitar sua 
manutenção. 
 
Podemos criar nossos próprios namespaces. 
 
Programas pequenos e crianças pequenas têm uma coisa obvia em comum, eles 
crescem. Com o crescimento de um programa surgem dois problemas: 
 
1º - Quanto mais código maior a complexidade do programa e mais difícil 
sua manutenção. 
 
2º - Mais código usualmente representa mais nomes de dados, funções, 
classes, etc. Facilitando os erros por conter nomes iguais. 
 
Os namespaces tem a função de ajudar a solucionar esses dois problemas. Para 
usar um namespace lembre-se que é necessário fazer uma referencia ao mesmo 
através de uma diretiva using seguido do nome do namespace no começo do 
bloco de código. Você pode fazer referencia a vários namespaces no seu arquivo 
de código. Um em cada linha. Um após o outro. 
 
 
Lição 3 – Criando sua primeira aplicação Windows 
com C# e o Visual Studio .NET 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 35 
 
Até agora por motivo didático usamos somente o prompt de comando para criar os 
nossos exemplos. Como sabemos esse tipo de aplicação não é muito útil nos dias 
de hoje. O Visual Studio .NET conta com diversos recursos importantes para o 
desenvolvimento de aplicações Windows. 
 
1 – Entre no Visual Studio .NET. 
 
2 – Crie um novo projeto, só que desta vez do tipo Windows Application, 
chamado WinHello. 
 
 
 
O Visual Studio .NET cria e mostra um formulário baseado em Windows no modo 
Design. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 36 
 
 
 
Vamos agora criar a nossa interface com o usuário. 
 
3 – Na barra de ferramentas do Visual Studio .NET clique em ToolBox. O ícone da 
ToolBox aparece a esquerda do formulário. Você também pode localizar a ToolBox 
através do menu View > ToolBox. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 37 
 
 
 
4 – Arraste da barra de ferramentas o controle Label e posicione-o no canto 
superior esquerdo do formulário. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 38 
 
 
 
Para colocar um controle no formulário você pode também dar um clique duplo 
sobre ele na barra de ferramentas ou clicar uma vez sobre ele na barra de 
ferramentas e depois clicar no formulário. O clique duplo posiciona o controle no 
canto superior esquerdo. A segunda opção coloca o controle no local onde você 
clicar. 
 
5 – Coloque também no formulário um controle TextBox e um controle Button. 
Como na próxima ilustração: 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 39 
 
 
 
6 – Na janela Solution Explorer, clique no botão View Code. 
 
O código do arquivo Form1.cs aparece. 
 
Para voltar ao modo design, também na janela Solution Explorer clique em View 
Design. 
 
Form1.cs tem todo o código gerado automaticamente pelo Visual Studio .NET. 
Note os seguintes elementos no código. 
 
• As diretivas usadas no inicio do código referenciando aos namespaces. 
 
using System; 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 40 
 
using System.Collections.Generic; 
using System.ComponentModel; 
using System.Data; 
using System.Drawing; 
using System.Text; 
using System.Windows.Forms; 
 
 
• O Visual Studio .NET usa o mesmo nome do projeto para criar o namespace 
principal. 
 
namespace WinHello 
{ 
… 
} 
 
 
• Uma classe chamada Form1 dentro do namespace WinHello. 
 
namespace WinHello 
{ 
 public class Form1 ... 
 { 
 ... 
 } 
} 
 
 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 41 
 
• O constructor (construtor), é um método especial que tem o mesmo nome 
da classe. Ele é o primeiro método a ser executado quando o programa é 
iniciado. 
 
public class Form1 ... 
{ 
... 
 public Form1() 
 { 
 ... 
 } 
} 
 
 
 
• Um método chamado InitializeComponent. O código dentro deste método 
configura as propriedades dos controles que adicionamos no modo Design. 
Atenção, não modifique o conteúdo do InitializeComponent diretamente no 
código, use a janela Properties no modo Design. Vamos aprender mais sobre 
os métodos nos próximos tutoriais. Este método esta no arquivo 
Form1.designer.cs no Visual Studio .NET 2005. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.bre www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 42 
 
 
 
private void InitializeComponent() 
 { 
 this.label1 = new System.Windows.Forms.Label(); 
 this.button1 = new System.Windows.Forms.Button(); 
 this.textBox1 = new System.Windows.Forms.TextBox(); 
 this.SuspendLayout(); 
 // 
 // label1 
 // 
 this.label1.AutoSize = true; 
 this.label1.Location = new System.Drawing.Point(13, 13); 
 this.label1.Name = "label1"; 
 this.label1.Size = new System.Drawing.Size(35, 13); 
 this.label1.TabIndex = 0; 
 this.label1.Text = "label1"; 
 // 
 // button1 
 // 
 this.button1.Location = new System.Drawing.Point(150, 50); 
 this.button1.Name = "button1"; 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 43 
 
 this.button1.Size = new System.Drawing.Size(75, 23); 
 this.button1.TabIndex = 1; 
 this.button1.Text = "button1"; 
 this.button1.UseVisualStyleBackColor = true; 
 // 
 // textBox1 
 // 
 this.textBox1.Location = new System.Drawing.Point(16, 50); 
 this.textBox1.Name = "textBox1"; 
 this.textBox1.Size = new System.Drawing.Size(100, 20); 
 this.textBox1.TabIndex = 2; 
 // 
 // Form1 
 // 
 this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 
13F); 
 this.AutoScaleMode = 
System.Windows.Forms.AutoScaleMode.Font; 
 this.ClientSize = new System.Drawing.Size(292, 273); 
 this.Controls.Add(this.textBox1); 
 this.Controls.Add(this.button1); 
 this.Controls.Add(this.label1); 
 this.Name = "Form1"; 
 this.Text = "Form1"; 
 this.ResumeLayout(false); 
 this.PerformLayout(); 
 
 }... 
 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 44 
 
 
Vamos agora definir as propriedades dos controles que colocamos no Form. 
 
7 – Volte para o modo Design. 
 
Para voltar ao modo design, também na janela Solution Explorer clique em View 
Design. 
 
8 – De um clique sobre o Button1 para selecioná-lo. 
 
9 – Na janela Properties, altere a propriedade Text do button1 para OK. 
 
Se não localizar a janela Properties, clique em F4, ou no menu View, clique em 
Properties Window. 
 
10 – Altere também a propriedate Text do Label1 para Digite o seu nome 
 
11 – Altere agora a propriedade Text do controle textBox1 para aqui. 
 
Note que as propriedades modificadas na janela Properties ficam em negrito. 
Assim você pode saber se elas estão com seu valor padrão ou não. 
 
12 – Selecione o formulário clicando sobre ele. 
 
Note que aparecem alguns marcadores envolta do formulário. Eles ajudam a 
redimensionar o formulário. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 45 
 
13 - Clique sobre o marcador central na parte de baixo do Form1 e mantendo o 
botão pressionado arraste para cima. 
 
 
 
Isso serve para os outros controles também, clique sobre os outros controles e note 
os marcadores. 
 
Vamos agora escrever o código para o nosso programa. 
 
14 – No painel de código de um clique duplo sobre o Button1. 
 
Note que ele vai diretamente para o painel de código e é criado automaticamente o 
seguinte código. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 46 
 
private void button1_Click(object sender, System.EventArgs e) 
{ 
 
} 
 
Tudo que for digitado dentro deste código será executado assim que o Button1 for 
clicado quando o programa estiver executando. 
 
15 - Digite o seguinte código: 
 
Tenha atenção com esse código, ele deve ser digitado exatamente como se segue, 
lembre-se que o C# é case-sensitive. É necessário também o ponto-e-virgula no 
final da linha. 
 
MessageBox.Show("Hello " + textBox1.Text); 
 
Vai ficar assim: 
 
private void button1_Click(object sender, System.EventArgs e) 
{ 
 MessageBox.Show("Hello " + textBox1.Text); 
 
} 
 
16 – Execute o programa. 
 
Para executar o programa você pode clicar e F5, ou no menu Debug clicar em 
Start Debugging. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 47 
 
Automaticamente o Visual Studio .NET salva o programa, compila e o executa. A 
seguinte janela aparece: 
 
 
 
17 – Digite seu nome e clique em OK. 
 
Uma janela aparece exibindo a mensagem “Hello seu-nome”. 
 
 
 
18 - Clique em Ok para fechar a janela com a mensagem. 
 
19 – Na janela executando o Form1 clique em fechar. 
 
 
Lição 4 – Criando documentação usando XML e 
cometários 
 
Podemos facilitar o processo de documentação de nossos programas usando XML. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 48 
 
Vamos fazer um exemplo pratico pra ver como isso é possível. 
 
1 – Entre no Visual Studio .NET e crie uma Console Application chamada 
Documentacao. 
 
 
 
2 – No painel de código modifique o nome da classe de Program para 
BemVindos, não pode haver espaços entre as palavras quando se nomeia uma 
classe. 
 
3 – Adicione o seguinte código dentro do namespace Documentacao: 
 /// <summary> 
 /// <remarks> 
 /// Este programa escreve "Hello World" 
 /// usando o método WriteLine da 
 /// Classe Syste.Console 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET”Página 49 
 
 /// The main entry point for the application. 
 /// </remarks> 
 /// </summary> 
 
 
Vai ficar como a imagem abaixo: 
 
 
 
 
4 – Dentro do método Main digite o código que escreve “Hello World” no prompt 
de comando. Se tiver duvida consulte a lição 1. 
 
5 – Na janela Solution Explorer clique sobre o arquivo Program.cs. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 50 
 
6 – Na janela Properties, modifique o nome do arquivo Program.cs para 
BemVindos.cs 
 
 
 
Se você for verificar o nome do arquivo pelo Explorer do Windows verá que o nome 
do arquivo foi realmente modificado. 
 
 
 
Mudao o nome da classe não muda o nome do arquivo, é uma boa pratica sempre 
mudar o nome do arquivo após a mudança do nome da classe. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 51 
 
7 – Entre no prompt de comando. Qualquer duvida sobre isso visite a lição 2. 
 
8 – Navegue até a pasta dos arquivos do projeto. 
 
9 – Digite csc /doc:Hello.xml BemVindos.cs 
 
 
 
Esse comando extrai os comentários XML inseridos junto com o código. 
 
10 – Através do Explorer do Windows, vá até a pasta do programa e de um clique 
duplo sobre o arquivo Hello.xml 
 
Você vai visualizar o código XML com os comentários que inserimos no código no 
Internet Explorer. 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 52 
 
 
 
Existe uma variedade enorme de tags XML que podem ser usadas na documentação 
do código, iremos listar as mais usadas logo abaixo. 
 
O comentário XML é sempre adicionado após barras triplas, ou seja, uma barra a 
mais que usamos para comentar o código, como o exemplo abaixo: 
 
 /// <remarks> 
 /// Este programa escreve "Hello World" 
 /// usando o método WriteLine da 
 /// Classe Syste.Console 
 /// The main entry point for the application. 
 /// </remarks> 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 53 
 
Abaixo segue uma lista das tags XML mais usadas. Lembre-se que com XML você 
pode criar suas próprias tags. 
 
TAG PROPÓSITO 
<summary> … </summary> Para uma breve descrição de uma 
classe, método ou propriedade. 
<remarks> … </remarks> Para uma descrição mais detalhada. 
<para> ... </para> Permite delinear parágrafos dentro da 
tag <remarks> 
<list type="…"> … </list> Permite usar marcadores para formatar 
uma descrição. Os tipos de marcadores 
podem ser “bullet”, “number” e “table”. 
<example> … </example> Para disponibilizar um exemplo de como 
usar um método, propriedade ou outro 
membro da biblioteca. 
<code> … </code> Para indicar que o texto incluído é 
código da aplicação. 
<c> … </c> Para indicar que o texto incluído é 
código da aplicação. É usada para linhas 
de código que precisam ser separadas 
da descrição. 
<see cref="member"/> Indica uma referencia a outro membro 
ou campo. O compilador verifica se o 
membro realmente existe. 
<exception> … </exception> Para fazer a descrição de uma exceção. 
<permission> … </permission> Para documentar a acessibilidade. 
<param name="name"> … </param> Para documentar um parâmetro de um 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 54 
 
método. 
<returns> … </returns> Para documentar um valor e seu tipo 
retornado de um método. 
<value> … </value> Para descrever uma propriedade. 
 
Existe uma maneira mais fácil de gerar sua documentação XML, usando o Visual 
Studio sem precisar do prompt de comando. 
 
11 – Na janela Solution Explorer, clique com o botão direito do mouse e selecione 
Properties, como a imagem seguinte. 
 
 
 
12 – Na janela que se abre, clique na guia Build e marque a opção XML 
Documentation file, como na próxima imagem. 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 55 
 
 
 
13 – No menu Build, clique em Build Solution ou pressione F6. 
 
Seu arquivo de documentação é gerado. Você pode alterar o nome do arquivo que 
será gerado na caixa de texto que segue a opção XML documentation file, pode 
alterar também o caminho do local onde o arquivo será gerado. Por padrão ele tem 
o mesmo nome do projeto e é criado na pasta bin\debug dentro do projeto. 
 
Você pode agora ir clicar em Show All Files na janela Solution Explorer e 
navegar até o local onde o arquivo XML foi criado para visualizá-lo. 
 
 
 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 56 
 
Módulo 2 
Variáveis 
 
 
Lição 5 – Entendo variáveis e tipos de dados 
 
Antes de falarmos sobre os tipos de dados vamos conhecer um pouco mais da 
plataforma .NET. 
 
Uma aplicações desenvolvida utilizando uma linguagem de programação como 
Delphi ou Visual Basic é executada encima do sistema operacional, ou seja, ela 
acessa DLLs, APIs e outros recursos diretamente do sistema operacional. 
 
Isso não acontece com o .NET, esse acessa seus recursos do .NET Framework. O 
.NET Framework é um conjunto de DLLs que disponibiliza os recursos que podem 
ser usados na plataforma .NET. 
 
O objetivo do .NET Framework é simplificar o desenvolvimento de software. Alguns 
dos seus benefícios são: 
 
• Baseado em padrões WEB: suporta a maioria das tecnologias disponíveis 
para a Internet incluindo HTML, XML, SOAP, XSLT, XPath, e outros. 
 
• Modelo de aplicação unificado: as classes do .NET Framework estão 
disponíveis para qualquer linguagem com suporte à plataforma. 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET”Página 57 
 
 
• Fácil de se usar: o código é organizado hierarquicamente em namespaces e 
classes. Os tipos de dados são unificados entre as linguagens compatíveis 
com a plataforma. Vamos estudar melhor sobre os tipos de dados. 
Namespaces e classes vão ser tratados no futuro. 
 
• Classes extensíveis: A hierarquia do .NET Framework não é oculta ao 
desenvolvedor, você pode acessar e extender classes do .NET Framework 
(menos as classes seladas) usando herança. 
 
 
Você vai entender melhor os benefícios do .NET Framework durante o curso. Como 
você pode ver ele é muito importante para a plataforma .NET. 
 
Por sua vez, um dos principais componentes do .NET Framework é a CLR ou 
Common Language Runtime. A CLR fornece vários benefícios para o 
desenvolvedor, tais como: 
 
• Tratamento de erros 
• Segurança 
• Depuração 
• Controle de versão 
 
Estes benefícios estão disponíveis em qualquer linguagem criada para a CLR. Isto 
quer dizer que a CLR pode servir a uma variedade de linguagens e pode oferecer 
um conjunto comum de ferramentas para estas linguagens. A Microsoft criou o C# 
e o VB .NET, como as principais linguagens para a CLR. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 58 
 
Quando um compilador compila para a CLR, o código é chamado de código 
gerenciado. Código gerenciado é simplesmente código que tira vantagem dos 
serviços oferecidos pela CLR. 
 
Quando você declara uma variável no C# você precisa determinar qual tipo de dado 
será armazenado nela. O tipo de dado vai dizer quais valores são possíveis de se 
armazenar nessa variável. 
 
Quem define as regras para os tipos de dados como declaração, uso e 
gerenciamento dos tipos é o CTS ou common type system que faz parte do CLR. 
 
Através do CTS é possível o desenvolvimento em linguagens diferentes na mesma 
plataforma e ter total integração entre elas, além disso, ele é responsável por 
garantir o tipo de dado e aumentar o desempenho da execução. 
 
Variáveis são espaços na memória do computador reservador para armazenar 
dados. 
 
A referencia aos dados de uma variável pode ser feita de duas maneiras: 
 
1. Por valor, chamado de Value-Type. 
2. Por referência, chamada de Reference-Type 
 
A principal diferença entre os dois tipos é que quando você faz referencia a uma 
variável Value-Type ela contém diretamente um dado, enquanto uma variável 
Reference-Type contém uma referencia ao dado. Vamos analisar um pouco melhor 
esses dois tipos de variaveis: 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 59 
 
Value-Type 
• Contém diretamente o dado. 
• Cada copia da variável contém uma copia do dado. 
• Operações em uma variável não afetam a sua cópia. 
• Exemplos de variáveis Value-Type são: integers, doubles, floats, e 
structures. 
 
Reference-Type 
• Armazenam uma referencia ao dado(conhecido como objetos) 
• Duas variáveis Reference-Type podem conter referencia a um mesmo 
objeto. 
• Operações em uma afetam a outra. 
• Exemplos de Reference-Type são: strings, arrays, e classes. 
 
 
Vamos aprender agora como declarar variáveis, seus principais tipos e como 
atribuir e recuperar valores delas. 
 
 
Lição 6 – Nomeando uma variável 
 
A documentação do Microsoft .Net Framework da as seguintes recomendações para 
a nomeação das variáveis: 
 
• Evite usar underline; 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 60 
 
• Não crie variáveis que apenas se diferenciem apenas pela sua forma. 
Exemplo: minhaVariavel e outra chamada MinhaVariavel; 
 
• Procure iniciar o nome com uma letra minúscula; 
 
• Evite usar todas as letras maiúsculas; 
 
• Quando o nome tiver mais que uma palavra, a primeira letra de cada 
palavra após a primeira deve ser maiúscula (conhecido como notação 
camelCase); 
 
• Não use notação Húngara. 
 
Convenção PascalCasing 
 
Para usar a convenção PascalCasing para nomear suas variáveis, capitalize o 
primeiro caractere de cada palavra. Exemplo: 
 
void InitializeData(); 
 
A microsoft recomenda usar o PascalCasing quando estiver nomeando classes, 
métodos, propriedades, enumeradores, interfaces, constantes, campos somente 
leitura e namespaces. 
 
Convenção camelCasing 
 
Para usar esse tipo de convenção, capitalize a primeira letra de cada palavra menos 
da primeira. Como o exemplo: 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 61 
 
 
int loopCountMax; 
 
A Microsoft recomenda usar essa convenção na nomeação de variáveis que definem 
campos e parâmetros. 
 
Para maiores informações sobre convenção de nomes pesquise “Naming 
Guidelines”, na documentação do Visual Studio. 
 
 
Lição 7 – Palavras Reservadas do C# 
 
A linguagem C# reserva setenta e cinco palavras para seu próprio uso. Estas 
palavras são chamadas de palavras reservadas e cada uma tem um uso particular. 
 
Palavras reservadas também não são permitidas como nome de variáveis. 
 
Segue uma lista que identifica todas estas palavras: 
 
abstract as base Bool 
break byte case Catch 
char checked class Const 
continue decimal default Delegate 
do double else Enum 
event explicit extern false 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 62 
 
finally fixed float for 
foreach goto if implicit 
in int interface internal 
is lock long namespace 
new null object operator 
out override params private 
protected public readonly ref 
return sbyte sealed short 
sizeof stackalloc static string 
struct switch this throw 
 
No painel de código do Visual Studio .NET as palavras reservadas são identificadas 
pela cor de letra azul. 
 
 
Lição 8 – Declarando variáveis 
 
Antes de usar uma variável é necessário declará-la. 
 
Quando declaramos uma variável, alocamos espaço para a mesma na memória do 
computador. Sempre que declaramos uma variável precisamos dizer que tipo de 
dado pode ser armazenado nela. O tipo de dado indica qual o tamanho do espaço 
vai ser reservado para a variável. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br ewww.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 63 
 
O C# pode armazenar diferentes tipos de dados: como inteiros, números de ponto 
flutuante, textos e caracteres. 
 
Declaramos especificando o tipo de dado seguido do nome da variável como no 
exemplo: 
 
int contador; 
 
Esse exemplo declara uma variável chamada contador do tipo integer. Ou seja, ela 
deverá armazenar números inteiros, mais a frente estudaremos melhor o que 
armazenar em cada tipo de dado. 
 
Podemos também declarar múltiplas variáveis de uma vez, fazemos isso da 
seguinte maneira: 
 
int contador, numeroCarro; 
 
Estamos declarando nesse exemplo duas variáveis do tipo integer, uma chamada 
contador e a outra numeroCarro. 
 
 
Lição 9 – Atribuindo valor a variáveis 
 
Depois de declarar sua variável você precisa atribuir um valor a ela. No C# você 
não pode usar uma variável antes de colocar um valor nela, isso gera um erro de 
compilação. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 64 
 
Exemplo de como atribuir um valor a uma variável: 
 
int numeroFuncionario; 
 
numeroFuncionario = 23; 
 
Primeiro nós declaramos nossa variável do tipo integer. Depois atribuímos o valor 
23 a ela. Entendemos pelo sinal de igual como recebe. Assim numeroFuncionario 
recebe 23. 
 
Podemos também atribuir um valor a variável quando a declaramos, dessa forma: 
 
int numeroFuncionario = 23; 
 
Isso faz à mesma coisa que o exemplo anterior, só que tudo em uma linha. 
 
Mais um exemplo: 
 
char letraInicial = ‘M’; 
 
 
Lição 10 – Tipos de dados 
 
A seguinte tabela mostra os tipos do C# com sua referencia no Framework. 
 
Os tipos da tabela abaixo são conhecidos como tipos internos ou Built-in. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 65 
 
C# Type .NET Framework type 
bool System.Boolean 
byte System.Byte 
sbyte System.SByte 
char System.Char 
decimal System.Decimal 
double System.Double 
float System.Single 
int System.Int32 
uint System.UInt32 
long System.Int64 
ulong System.UInt64 
object System.Object 
short System.Int16 
ushort System.UInt16 
string System.String 
 
Cada tipo no C# é um atalho para o tipo do Framework. Isso quer dizer que se 
declararmos a variável desta forma: 
 
string nome; 
 
ou dessa forma 
 
System.String nome; 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 66 
 
teremos o mesmo resultado. O atalho serve apenas para facilitar na hora de 
desenvolver a aplicação. 
 
A seguinte tabela mostra os tipos de variáveis e os valores possíveis de se 
armazenar em cada uma delas. 
 
 
C# Type Valores possíveis de se armazenar 
bool Verdadeiro ou Falso (Valores booleandos) 
byte 0 a 255 (8 bits) 
sbyte -128 a 127 (8 bits) 
char Um caractere (16 bits) 
decimal ±1.0 × 10−28 a ±7.9 × 1028 (128 bits) 
double ±5.0 × 10−324 a ±1.7 × 10308 (64 bits) 
float ±1.5 × 10−45 a ±3.4 × 1038 (32 bits) 
int -2,147,483,648 a 2,147,483,647 (32 bits) 
uint 0 a 4,294,967,295 (32 bits) 
long –9,223,372,036,854,775,808 a 
9,223,372,036,854,775,807 (64 bits) 
ulong 0 a 18,446,744,073,709,551,615 (64 bits) 
object Qualquer tipo. 
short -32,768 a 32,767 (16 bits) 
ushort 0 a 65,535 (16 bits) 
string Seqüência de caracteres (16 bits por caractere) 
 
Todos os tipos na tabela com exceção dos tipos object e string são conhecidos 
como tipos simples. 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 67 
 
 
Para retornar o tipo de qualquer variável do C# você pode usar o método 
GetType(); Como no exemplo: 
 
Console.WriteLine(minhaVariavel.GetType()); 
 
Isso retornaria o tipo da variável minhaVariavel. 
 
 
Lição 11 – Adicionando valor a uma variável 
 
É muito comum precisarmos adicionar ou subtrair valores de uma variável usando 
no calculo o valor que já esta armazenado na mesma. 
 
O código seguinte declara uma variável do tipo integer chamada contador e 
armazena o valor 2 nesta variável, depois incrementa o valor 40: 
 
int contador; 
contador = 2; 
contador = contador + 40; 
 
No final do código acima a variável contador tem qual valor? 
 
A resposta é 42, claro, criamos a variável, adicionamos o valor 2 nela e após, 
pegamos o valor dela (que era 2) e adicionamos 40, e armazenamos o valor na 
mesma. 
 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 68 
 
Preste atenção na seguinte linha de código: 
 
contador = contador + 40; 
 
Perceba que para somar o valor a variável precisamos repetir o nome da variável. 
 
Podemos fazer da seguinte forma também em C#: 
 
contador += 40; 
 
Isso teria o mesmo resultado e é uma maneira mais elegante. 
 
Você pode subtrair também valores, como o exemplo: 
 
contador -= 23; 
 
Isso subtrairia 23 do valor da variável. 
 
Na verdade você pode fazer isso com todos os operadores aritméticos, como 
multiplicação e divisão também. Você vai aprender sobre operadores no próximo 
capitulo. 
 
Para saber mais você pode consultar a documentação do Visual Studio e procurar 
por “assignment”. 
 
Embora não tenhamos feito nenhum exercício até aqui neste capitulo você 
aprendeu como declarar uma variável, de que forma nomear as variáveis, quais as 
palavras que não podem ser usadas na nomeação de variáveis e quais os tipos de 
Curso Programando com C# e o Visual Studio .NET 2005 
 
 
Autor: Herbert Moroni Cavallari da Costa Gois 
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br 
Confira também o curso: “Programando com VB.NET” Página 69 
 
dados e valores que eles suportam. Os exercícios sobre esse conteúdo serão feitos 
sempre, já que sempre faremos uso de variáveis em nossos programas, assim fique 
tranqüilo aos pouco isso será bem familiar a você. 
 
 
Lição 12 – Operadores 
 
Operadores Aritméticos: 
 
O C# suporta os símbolos aritméticos que todos nós conhecemos para as operações 
aritméticas básicas como adição (+) e subtração (-), ele utiliza o asterisco