Apostila desenvolvimento aplicações comerciais com C#

Sumário
Conteúdo Página
Capítulo 1- .NET 1
Framework
O que é? 1
História 1
Versões do .NET Framework 2
Principais Recursos por versões 2
Arquitetura básica 3
O que é IL? 3
Garbage Collection 6
GAC 6
LINKS 7

Capítulo 2-Microsoft 8
Visual Studio 2010
O que é? 8
História 8
Funcionalidades por versões 8
Como iniciar? 8
Estrutura de um projeto e tipos de 10
arquivos básicos
Templates 11
Code Snippet 12
Ferramentas de analise de código 13
Principais janelas do VS 2010 13
Debugando com VS 2010 13
IntelliTrace 14
Gerando um release 16
LINKS 16

Capítulo 3-Microsoft C# 17
O que é? 17
História 17
Visão conceitual classes 17
Namespaces 18
Using 18
Tipos de dados básicos 19
Tipos de valor e de referência 20
Varáveis 21
Operadores 21
Desvios condicionais 24
Switch 25
Estruturas de repetição 26
Tratamento de erro 30
Arrays e Lists 30
Windows Forms 32
Eventos 32
Guia rápido: Hello World 33
Principais componentes Windows 34

Forms
Trabalhando com arquivo texto 51
Modificadores de acesso 53
Classes 53
Propriedades e variáveis 53
Construtores 54
Métodos 56
Sobrecarga 57
Enums 59
Herança 59
Classes e métodos estáticos 60
Conversões 61
Interfaces 61
ADO.net – Trabalhando com 62
bancos de dados
Criação de controles 65
customizados
Generics 66
Lambda Expressions 67
Reflection 68
LINKS 71

Capítulo 4 – Orientação a 72
objetos
Pilares 72
Princípios 73

1 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#

Capítulo 1 - Microsoft .NET Framework.

O que é?

Microsoft .NET é componente construído pela Microsoft, que visa uma plataforma única para desenvolvimento e
execução de sistemas e aplicações. Todo e qualquer código gerado para .NET, pode ser executado em qualquer dispositivo que
possua o framework de tal plataforma instalado. Dessa forma o programador deixa de escrever código para um sistema ou
dispositivo específico, e passa a escrever para a plataforma.NET.

O .net Framework é projetado para atender os seguintes objetivos:

 Fornecer um ambiente de programação orientada a objetos consistente, se o código é armazenado e executado
localmente, executado localmente, mas distribuído pela Internet ou executado remotamente.
 Fornecer um ambiente de execução que minimiza conflitos de implantação de software e controle de versões.
 Fornecer um ambiente de execução que promove a execução segura do código, incluindo código criado por um
desconhecido ou por um terceiro que não seja totalmente confiável.
 Fornecer um ambiente de execução que elimina os problemas de desempenho de ambientes interpretados ou com scripts.
 Tornar a experiência do desenvolvedor consistente, através dos diversos tipos de aplicações, tais como aplicativos
baseados no Windows e aplicativos baseados na Web.
 Construir toda a comunicação em padrões da indústria para garantir que o código com base no .net framework possa
interagir com qualquer outro código.

História

A Microsoft lançou o .net Framework em 2001 com a intenção de redefinir a maneira que escrevemos programas para Windows e
também pra web, a iniciativa .net travou uma árdua briga com a Sun Microsystems em relação a versão da Microsoft da
linguagem java que era a mais usada para desenvolvimento de aplicativos .net quando o framework surgiu. Esta implementação
específica do java concebida pela Microsoft foi nomeada J++ e sua biblioteca de classe WFC(Windows foundation Classes) foi
em grande parte desenhada por Ander Hejlsber um ex-funcionário da Borland que ficou conhecido pela sua participação
nas linguagens Pascal, Turbo Pascal,Borland Pascal e Delphi. Posteriormente o Visual J + +( Visual Studio 6.0 foi o último a
conter suporte a essa linguagem) foi descontinuado, Hejlsberg foi nomeado arquiteto-chefe da linguagem C # e um dos principais
desenvolvedores do .NET Framework.


Versões do .net framework

Principais recursos por versão do framework

Cada versão do .net framework tem suas particularidades, porém toda versão é completamente compatíveis com as anteriores
minimizando assim o impacto da migração de uma versão para outra, inclusive módulos compilados em uma versão mais antiga
pode ser carregado em um aplicativo construído com uma versão mais atual. Na tabela abaixo temos os principais alterações
ocorridas em cada versão do .net framework, notem que nem sempre o CLR é atualizado a cada versão do .net quer dizer que
apenas novos módulos foram adicionados mas a forma de gerenciamento do código permanece a mesma.

Versão do .NET Versão Versão do Visual Studio Descrição
Framework do CLR
1.0 1.0 Visual Studio .NET Contém a primeira versão do CLR e a primeira versão da
biblioteca de classes.
1.1 1.1 Visual Studio .NET 2003 Inclui atualizações para o ASP.NET e pra o ADO.NET. Essa
versão foi posteriormente atualizada 2 vezes com o Service
Pack 1(SP1) e Service Pack 2(SP2) Essa versão também
introduziu a execução sibe-by-side a qual habilita aplicações
em um único computador executar em várias versões do CLR .
2.0 2.0 Visual Studio 2005
Introduziu uma nova versão do CLR com adições para as
bibliotecas de classes incluindo os tipos genéricos, coleções
genéricas e acréscimos significativos para o ASP.NET. Esta
versão foi posteriormente atualizada com o SP1 e o SP2.

3.0 2.0 Visual Studio 2005 Esta versão é essencialmente o .NET Framework 2.0 com a
adição do Windows Presentation Foundation (WPF), o
Windows Communications Foundation (WCF), o Windows
Workflow Foundation (WF) e o CardSpace. Posteriormente foi
atualizado com o SP1 e o SP2.

3.5 2.0 Visual Studio 2008 Acrescentou novas funcionalidades, tais como suporte a AJAX
e LINQ. A atualização do SP1, acrescentou ao. NET
Framework, dados dinâmicos, e um pequeno conjunto de
melhorias adicionais.
4 4 Visual Studio 2010 Inclui uma nova versão do CLR, bibliotecas de classes básicas
e novas funcionalidades, tais como o Managed Extensibility
Framework (MEF) , dynamic language runtime (DLR) e code
contracts.


Arquitetura básica

O Microsoft .NET Framework é composto por 2 componentes principais: o CLR(Common Language Runtime) e a biblioteca de
classes. O Common Language Runtime é a base do Framework .NET. Você pode pensar no Runtime como um agente que gere
código em tempo de execução, fornecendo principalmente serviços como gerenciamento de memória, gerenciamento de segmento
e processamento remoto, ao mesmo tempo a segurança de tipos estritos e outras formas de precisão de código que promovem
segurança e robustez. Na verdade, o conceito de gerenciamento de código é um princípio fundamental do runtime. Código
rodando sobre o CLR é conhecido como código gerenciado, enquanto o código que não roda sobre ele é conhecido como código
não gerenciado. A biblioteca de classes, é o outro componente principal do .NET Framework, se trata de uma vasta coleção
orientada a objetos de tipos reutilizáveis que você pode usar para desenvolver aplicações que vão desde a tradicional linha de
comando até aplicativos com interface gráfica do usuário (GUI), para aplicativos com base em inovações mais recentes fornecidas
pelo ASP.NET, como Web Forms e Serviços Web XML.

Abaixo temos uma ilustração com uma visão holística da relação entre a biblioteca de classes, o.net framework, sua aplicação e o
sistema operacional ou o hardware.

O que é IL?

Uma grande quantidade de linguagens podem ser utilizadas para construção de aplicativos baseados no .net framework , na
verdade qualquer linguagem que possua um compilador IL pode ser utilizada, como exemplo podemos citar C#, VB.NET,
DELPHI.NET e J#, apesar de o C# ter sido adotado como linguagem oficial para o .net framework. O que acontece na verdade
acontece é que todo código é traduzido na compilação para IL que é a abreviação Itermediate language, ou seja, linguagem
intermediária e essa é a única linguagem que o CLR entende sendo interpretada e gerenciada por ele em tempo de execução e
transformando-a posteriormente em código de máquina(binário), os principais tipos de arquivos gerados por um compilador IL
variam dependendo do tipo de projeto são estes: EXE, DLL e ASPX.

Abaixo um pequeno exemplo “hello world” em c# e abaixo o mesmo programa em IL.

Versão C#;

using System;
namespace HelloWorldIL
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello, World !");
}
}
}


Versão IL;

.assembly extern mscorlib {}
.assembly HelloWorldIL {}
.namespace HelloWorldIL
{
.class Program
{
.method static public void Main() cil managed
{
.entrypoint
.maxstack 8
ldstr "Hello, World !"
call void [mscorlib] System.Console::WriteLine(string)
call valuetype [mscorlib]System.ConsoleKeyInfo
[mscorlib]System.Console::ReadKey()
ret
}
}
}


A imagem abaixo demonstra o fluxo ocorrido entre a compilação e a execução de um aplicativo .net.

Você pode acessar o código em IL de um arquivo .net compilado através da ferramenta IL Disassembler que normalmente pode
ser encontrado na pasta do Visual Studio 2010 no menu iniciar-> Microsoft Windows SDK Tools IL Disassemble ou no caminho:
C:Program FilesMicrosoft SDKsWindowsv7.0ABinNETFX 4.0 Toolsx64ildasm.exe

Você pode também escrever um aplicativo utilizando IL diretamente, mas infelizmente o Visual Studio 2010 não oferece suporte
a essa linguagem então um editor de texto qualquer pode ser utilizado, para compilar utilize a ferramenta ILAsm que vem junto
com o SDK do .net framework e é acessível através do prompt do Visual Studio e pode ser encontrado normalmente na pasta do
menu iniciar do Visual Studio->Visual Studio Tools->Visual Studio Command Prompt. Apesar desta prática não ser muito


comum nos ajuda a entender como funcionam as coisa “por baixo do capô” no .net framework e também pode ser utilizado para
criar programas em tempo de execução(Reflection.Emitting).

Garbage Collection

O Garbage Collection é um recurso do Common Language Runtime que faz o gerenciamento automático da memória e oferece os
seguintes benefícios:

 Permite que você desenvolva sua aplicação sem a necessidade de liberar memória.
 Aloca objetos no heap gerenciado de forma eficiente.
 Identifica objetos que não estão mais sendo usados, apaga-os da memória e a mantém disponível para futuras atribuições.
 Objetos gerenciados automaticamente têm o espaço para seus atributos previamente alocados, assim o construtor não
precisa inicializar cada um deles.
 Fornece segurança de memória, certificando-se que um objeto não pode usar o conteúdo de outro objeto.

Em que situações o Garbage Collection é acionado:

 O sistema tem memória física baixa.
 A memória que é usada por objetos alocados no heap gerenciado ultrapassa um limite aceitável. Este limiar é
continuamente ajustado conforme o processo é executado.
 O método GC.Collect é chamado. Em quase todos os casos, você não precisa chamar esse método, porque o coletor de
lixo é executado de forma contínua. Este método é usado principalmente para situações únicas e testes.

Nota: Heap Gerenciado é o segmento de memória para armazenar e gerenciar os objetos.

GAC

GAC é a abreviações para Global Assembly Cache que consiste em um sistema robusto e unificado serviço de
gerenciamento de DLL’S compartilhadas, com ele aplicações podem usar diferentes versões da mesma DLL instalada no disco.


LINKS
Visão conceitural do .net framework - http://msdn.microsoft.com/pt-br/library/zw4w595w.aspx

Página oficial do .net framework - http://msdn.microsoft.com/en-us/netframework/default.aspx

Versões e dependências do .net framework - http://msdn.microsoft.com/pt-br/library/bb822049.aspx

Instalação do .net framework 4.0 runtime - http://www.microsoft.com/download/en/details.aspx?id=17718

Como o framework .net reconhece tantas linguagens - http://www.devmedia.com.br/post-14830-Como-o-framework--NET-
reconhece-varias-linguagens-de-programacao.html

.NET Framework Class library overview - http://msdn.microsoft.com/en-us/library/hfa3fa08.aspx

Common language runtime overview- http://msdn.microsoft.com/en-us/library/ddk909ch.aspx

Entrevistas de Anders Hejlsberg sobre o .net framework -
http://www.bitwisemag.com/copy/programming/milestones/pm_dotnet.html

Artigo Wikipédia j++ - http://en.wikipedia.org/wiki/Visual_J%2B%2B

Fundamentos garbage collection - http://msdn.microsoft.com/en-us/library/ee787088.aspx

Visão geral biblioteca .net - http://msdn.microsoft.com/en-us/library/hfa3fa08.aspx

Mapa das principais classes .net framework 4.0 - http://brad_abrams.members.winisp.net/Projects/PDC2008/PDC2008-
NETFX4.pdf

Mapa de classes comuns do .net framework 3.5 - http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=19341


Capítulo 2 – Microsoft Visual Studio

O que é?

O Microsoft Visual Studio é uma IDE(integrated development enviroment) , se trata uma plataforma multi linguagem concebida
pela Microsoft que apresenta facilidades significativas para o desenvolvimento de software englobando um série de
funcionalidades que auxiliam nas rotinas de desenvolvimento, pode ser usada para desenvolver aplicações console ou gráficas
através das bibliotecas Windows Forms, web sites, aplicações web e web services.

Algumas das suas principais funcionalidades são

 Um editor de código com esquema de cores que visa facilitar o entendimento.
 Um sistema de auto completar para nome de funções, tipos de dados, namespaces e palavras reservadas
(Intelissense).
 Um compilador/interpretador de código.
 Em versões mais avançadas até mesmo controle de versões.
 Editor gráfico para criação da interface de usuário.
 Refatoração de código.

Dentre as linguagens suportadas de forma nativa estão: C#,VB.net,F#,XML,HTML,JavaScript e CSS.

Apesar de ser um software proprietário, existem as versões gratuitas chamadas de express que possuem menos recursos e são
voltadas para um linguagem específica como Visual C# Express,Visual C++ dentro outras.

História

A primeira versão do Visual Studio foi o Visual Studio 97 que agregou grande parte das ferramentas necessárias para o
desenvolvimento de software pela primeira vez. O Visual Studio 97 teve duas versões, Visual Studio Professional e o Visual
Studio Enterprise. As linguagem suportadas eram Visual Basic 5.0 e Visual C++ 5.0 voltados ao desenvolvimento para Windows,
J++ 1.1 para programação para JVM, Visual Fox Pro 5.0 para programação de bancos de dados e também foi introduzido suporte
à construção de sites de conteúdo dinâmico através do Active Server Page(ASP), em 2002 foi lançado o primeiro Visual Studio
voltado a programação com .net. A versão atual da IDE é o Microsoft Visual Studio 2010 e esta será a que utilizaremos como
ferramenta padrão de desenvolvimento em nosso curso, as principais alterações ocorridas nessa versão foram a reorganização da
interface para torna-la mais simples utilizando as novas tecnologias para desenvolvimento de interface criadas pela própria
Microsoft (WPF). Inclusão do DLR - Dynamic Language Runtime no pacote de instalação que dá suporte aos tipos dinâmico e à
metaprogramação, Suporte ao .net framework 4.0 e Suporte ao desenvolvimento de aplicativos para o Windows phone 7.

Funcionalidades por versão do Microsoft Visual Studio 2010

Como Iniciar?

Agora faremos um rápido guia de como construir uma aplicação simples no VS2010. Para começar o desenvolvimento de um
aplicativo com Visual Studio é relativamente simples basta abrir o programa ir até o menu superior na opção File->new->Project.
Uma janela como a da imagem abaixo aparecerá:


Do lado direto temos uma lista hierárquica com o título “Instaled templates” o que seria modelos de projetos para cada tipo de
aplicativo, os templates serão detalhados posteriormente nesse capítulo. No caso está selecionada a categoria “Windows” e dentro
dela há subtipos como “Windows Forms Applications” e “Class Library Application”. Na parte superior temos versão do .net que
será utilizado no projeto no caso selecionado .net framework 4. Na parte inferior temos o nome que queremos dar ao nosso
projeto, e logo abaixo o caminho no computador que os projetos e os arquivos relacionados serão salvos e abaixo o nome da
solução que funciona como uma agregadora de conteúdo para podermos organizar um sistema formado de vários projetos será
melhor explicada posteriormente nesse capítulo.

Temos ainda duas caixas de seleção a primeira indica se gostaríamos de criar um diretório para organizar fisicamente os arquivos
da solução e o segundo indica se gostaríamos de já adicionar o projeto á um controle de versão.

Feitas essas configurações iniciais podemos dar ok e será criado um projeto de acordo com o template escolhido e este
normalmente é apresentado do lado direito na janela “Solution Explorer”. A partir de agora tomaremos como exemplo o template
“Console Application” que é um dos mais simples para prosseguir esse guia rápido.


A imagem abaixo mostra o que veremos após dar ok na janela anterior:

Já será aberto o arquivo com a classe principal do projeto e o método de entrada basta editar a definição do mesmo
implementando as ações que desejar e depois clicar no botão parecido com um play na parte superior da tela ao lado da palavra
debug o seu aplicativo será executado para que o comportamento do mesmo seja analisado. Vamos supor que
tudo correu bem, o próximo será alterar o a caixa de seleção onde está escrita a palavra Debug para Release, feito isso basta clicar
com o botão direto sobre a solução na janela “Solution Explorer”, será aberto um menu contextual escolha a opção “rebuild” e isto
iniciará a montagem do seu aplicativo para um arquivo executável. Agora basta ir até o diretório da solução, procurar a pasta do
projeto, “ConsoleApplication1”->bin->release, o arquivo executável estará lá dentro, clique duas vezes no mesmo e sua aplicação
será iniciada.

Estrutura de um projeto e tipos de arquivos básicos

O Visual Studio tem uma organização hierárquica que consiste basicamente em Soluções, Projetos, Configurações, itens do
projeto e itens das soluções.

-Soluções

Funciona como uma forma de organizar os insumos necessários para execução e/ou construção de um
sistema, uma solução pode ter diretório, projetos e qualquer outro tipo de arquivo que seja importante para o sistema, como uma
imagem ou um documento de texto, cada projeto pode gerar um executável ou uma dll e pode ter dependências de outros projetos,
a solução se encarrega de organizar a ordem de “build” para que todas dependências de um projeto que estejam também estejam
na forma de projeto sejam compiladas antes do mesmo. A solução só existe em tempo de desenvolvimento depois de compilado
não gera uma saída significativa e vai depender de como você organizar os arquivos gerados para realização com sucesso do
deploy, no computador as soluções ficam armazenadas em arquivos com a extensão “.sln” e você pode abri-la clicando duas vezes
no arquivo, porém para copiar com sucesso uma solução o computador deve estar configurado para mostrar arquivos oculto, pois
existe um arquivo com o mesmo nome da solução com a extensão “.suo” que precisa ser copiado junto para a pasta destino.

-Projetos

O Projeto é a versão em tempo de desenvolvimento de uma aplicação, nele contém todos os arquivos de códigos
não compilados os “.cs” no caso do c#, todas as configurações por exemplo, as plataformas suportada(X86,X64) e todas as
referências externas necessárias para o seu funcionamento, na compilação é ele que de fato se transforma no produto final. No
computador o projeto em c# ficam armazenados em arquivos com a extensão “.csproj” e você pode abri-lo no Visual Studio


clicando sobre esse arquivo, porém na verdade ele se trata de um arquivo XML em um padrão estabelecido pelo VS, você pode
acessar e editar diretamente esse arquivo XML clicando com o botão direito sobre o arquivo e seleciona abri com... notepad.

-Propriedades

Praticamente todos os templates de projetos criam um item chamado properties onde podem ser configurados os
principais aspectos do projeto, apesar de poder ser considerado como um item do projeto merece uma atenção especial, abaixo as
principais configurações que podem ser feitas no properties de um projeto para Windows.

 Plataforma(s) em que a aplicação funcionará depois de compilada.
 Versão do framework utilizada no projeto.
 Versão do arquivo compilado.
 Temos um espaço para colocarmos recursos que ficarão embarcados no arquivo compilado.

As propriedades não são salvas em um arquivo único com uma extensão específica, mas estão distribuídas nos arquivos “.csproj”,
no arquivo AssembyInfo.cs e quando adicionados recursos no arquivo também nos arquivos ” .resx” e no Resource.Design.cs,
como os aplicativos .net foram projetados para serem xcopy ou seja basta colocar todas dependências em uma pasta sem precisar
de criar valores no registro, a maioria dos arquivo que gravam dados sobre aplicativos são xmls em um padrão do Visual Studio e
tiveram sua extensão relacionadas com o mesmo.

-Itens do projeto

O projeto como a solução pode ter praticamente quaisquer tipos de arquivos adicionados entre os seus itens, como
imagens e documentos de textos, mas o principal em aplicações Windows podemos dizer que são os arquivos “.cs” que contêm o
código fonte de nossos programas, esses arquivos servem apenas para organizar o código, que pode ser separado em arquivos da
forma que for mais conveniente, facilitando o controle de versão e melhorando a semântica.

Tabela de extensões básica do Visual Studio(C#)

Extensão Do que se trata
*.sln Arquivo onde ficam armazenadas as informações sobre as
soluções do Visual Studio.
*.suo Arquivo oculto complementar da solução precisa ser copiado
com a solução para a pasta destino.
*.csproj Arquivo onde ficam armazenados os dados sobre os projetos
do Visual Studio.
*.cs Arquivo onde fica armazenado o código não compilado do c#.
*.resx Arquivo onde ficam contidas informações sobre os recursos de
um projeto.

TEMPLATES

Os templates são modelos pré-definidos para facilitar a inclusão de um projeto, o template define quais as referências necessárias
para um determinado tipo de projeto, por exemplo, a dll System.Windows.Forms do .net framework é adicionada no template
“Windows application” mas não é adicionada no template “Console application”, porém nada impede que essa dll seja adicionada
posteriormente, no template também estão definidos os item que serão adicionados ao projeto incialmente tomando novamente
como exemplo “Windows Forms” e o “Console Applications” no primeiro um formulário já vem adicionado no projeto e no
segundo não. No Visual Studio 2010 os templates instalados vão depender das suas escolhas na hora da instalação, mas de
qualquer maneira você terá uma vasta gama de templates a sua disposição, ainda há templates disponibilizado na internet por
terceiros como “Applications for twitter” e quando se tratar de algo muito específico você mesmo pode fazer os seus templates.

Intellissense

O Intellissense é um recurso do Visual Studio 2010 que auxilia na construção do código fonte ele tem o papel de sugerir o
complemento da palavras que estamos digitando e também auxiliar na resolução de problemas, como identificar o namespace que
precisa ser “importado”. Ao começar escrever uma palavra aparece uma lista do que possivelmente você pretende escrever, você


pode navegar pela lista com as setas do teclado e encontrando a correspondência que deseja basta dar tab para que a palavra seja
inserida no fonte.

Imagem da janela de auto complemento do intellissense

No caso de você escrever um tipo não reconhecido aparecerá um pequeno quadrado sobre ele, basta clicar com o mouse no
mesmo e selecionar a ação desejada, ao renomear algum objeto também aparecerá o mesmo quadrado clicando nele terão as
opções para ajudar a refatorar o código. Veja na imagem abaixo.

Aqui a sugestão foi apenas de adicionar o namespace que já está disponível ao contexto atual.

Code Snippet

Os code snnipet’s além de auto completar a palavra inserem o restante de código que compõe um comando, um exemplo é o “for “
o auto completar ajudaria sugerindo “for” quando for digitado “f”, mas não incluiria uma espécie de esqueleto no editor com a
sintaxe básica do comando. Toda vez que iniciar a digitação de um comando e houve uma espécie de um papel partido na frente
da sugestão de complemento conforme a imagem abaixo:

Basta apertar duas vezes o “Tab” que o complemento do comando será incluído, abaixo imagem com o código gerado ao apertar
duas vezes o “Tab”.

Se você continuar utilizar o “Tab” o cursor será direcionado as partes variáveis da função que são as que estão com o fundo
amarelo na imagem acima.


Ferramentas de análise de código

O Visual Studio tem algumas ferramentas que auxiliam a melhorar e manter a qualidade dos projetos uma é especialmente
interessante.

-Code metrics analysis

Essa ferramenta fornece uma série de índices sobre a qualidade do código, ajuda avaliar o trabalho feito e também é interessante
para analisar se as mudanças feitas melhoraram ou pioram os aspectos avaliados. Ela é muito simples de usar basta clicar com o
botão direito sobre a solução ou sobre um projeto específico e selecionar a opção “Calculate Code Metrics”, será aberta uma
janela e um índice geral é atribuído para cada item, inclusive ele ajuda você interpreta-los, é possível ir abrindo níveis até chegar
nas funções que estão piorando os indíces.

Principais janelas do Visual Studio 2010

ToolBox

Concentra os itens que podemos utilizar dependendo do contexto, no desenvolvimento de aplicativos Windows estarão disponível
na ToolBox os controles nativos para esse tipo aplicação como textbox,lable,combobox,datagrid e datetimepiker . Eventualmente
poderá conter também controles definido pelo usuário. Pode ser acessada pelo menu:View->Toolbox ou pelo atalho Ctrl+W,X.

Solution Explorer

Essa janela apresenta uma lista hierárquica representando a solução com todos seus itens. Pode ser acessada através do
menu:View->Solution Explorer ou pelo atalho Ctrl+W,S.

Server Explorer

Essa janela serve para gerenciar conexões com bancos de dados. Pode ser usada para localizar Windows Services ativos e servir
como DataSources. Pode ser acessada através do menu:View->Server Explorer ou pelo atalho Ctrl+W,L.

Properties

Essa janela apresenta as propriedade da maioria dos itens selecionáveis no Visual Studio 2010 como controles e projetos. Pode ser
acessada clicando com o botão direito sobre o item deseja e selecionando a opção “properties” no menu contextual, pelo menu
principal: View->Propertie Window ou ainda pelo atalho Ctrl+W,P.

Document Outline

Essa janela apresenta uma lista hierárquica com todos os componentes contidos em um formulário, é uma ótima opção para
navegar entre eles. Pode ser acessada pelo menu:View->Other Windows->Document Outline ou pelo atalho Ctrl+W,U.

Immediate

Essa só é acessível em tempo de depuração e serve para execução de comandos, utilizando os objetos carregados no escopo em
que a aplicação foi pausada, é interessante usa-la para avaliar os comportamentos individuais dos objetos. Pode ser acessada pelo
menu: Debug->Windows->Immediate ou pelo atalho Ctrl+D,I.

Debugando com Visual Studio

Para debugar o código no Visual Studio, basta selecionar a opção Debug na caixa de seleção da barra de ferramentas padrão e
clicar no botão Start Debugging se trata do botão do lado da caixa onde foi escolhida a opção Debug com um ícone parecido com
um “play” ou ainda apertar o atalho F5. O programa será executado no modo debbug. Pontos de parada podem ser adicionados ao
código selecionando a linha em que deseja que ocorra a interrupção e apertando o atalho f9, uma bola vermelha será adicionada do
lado esquerdo da linha e a mesma terá a cor do plano de fundo alterada para vermelho conforme imagem abaixo:


Assim a execução do programa será interrompida quando chegar a este ponto uma seta amarela apontará para a linha indicando
que a execução está parada naquele ponto conforme a imagem abaixo.

O desenvolvedor poderá fazer basicamente 3 coisas a partir desse ponto, executar o próximo passo sem passar na definição do
método(F10), executar o próximo passo passando por dentro da definição do método(F11) ou voltar a execução normal do
programa(F5). No Visual Studio você pode voltar à execução do programa arrastando a seta amarela para a linha desejada.
Enquanto o programa estiver parado o desenvolvedor pode analisar os valores das variáveis colocando o mouse sobre elas, em
quais condições a linha de execução entrou ao ver por onde a seta amarela está se movendo e fazer simulações com a Immediate
Window, dentre outras coisas ou seja analisar passo a passo o que está acontecendo com o sistema afim de solucionar problemas.
Para analisar valores de um objeto podemos utilizar a função QuickWatch, para acessa-la é só selecionar o objeto em questão e
clicar com o botão direto sobre, como na imagem abaixo:

Selecionar a opção QuickWatch, uma popup como a da imagem abaixo será exibida mostrando as informações do objeto:

Nela temos o nome do objeto, o valor e o tipo, no caso de objetos que têm propriedades poderíamos navegar entre elas verificando
cada um de seus valores.

A execução do programa pode ser Interrompida também pelo botão “Break All” presente na barra de ferramentas “Debug”, o
ícone do botão tem o aspecto de um símbolo de Pause ou pelo atalho Ctrl+Alt+Break. Para encerrar o Debug e consequentemente
a execução da aplicação basta fecha-la ou selecionar o botão “Stop Debugging” na barra de ferramentas “Debug” ou ainda acionar
o atalho Shift+F5.

IntelliTrace

Intellitrace é uma nova tecnologia de rastreamento disponível apenas para usuários do Visual Studio 2010 Ultimate.
Com o Intellitrace mensagens sobre os eventos ocorrido na aplicação são automaticamente emitidas pelo Visual


Studio em segundo plano para um arquivo .iTrace, onde podem ser recuperadas e examinados para
fins de depuração. O Intellitrace é altamente configurável no que diz respeito ao tipo e quantidade
de informação que você deseja gravar e com as configurações padrão tem muito pouco impacto sobre a performance da execução
durante a depuração.

Habilitando o IntelliTrace

O IntelliTrace já vem habilitado por padrão e os eventos do Intellitrace são registrados automaticamente. Esse evento representam
os eventos da aplicação e as gravações dessas informações causam um impacto tão pequeno que se torna praticamente
imperceptível na execução do aplicativo. Você pode também configurar o IntelliTrace para registrar as chamadas de função,
informação sobre os parâmetros passados e eventos disparados por componentes.

Porém registrando essas informação pode haver uma degradação da performance que por outro lado proporciona mais dados para
depuração.

Para habilitar o IntelliTrace:

1-Selecionar Tools->Options - Na lista da direita da popup que aparecer seleciona IntelliTrace e por fim marque a opção Enable
IntelliTrace.

2-Para habilitar o registro sobre chamada de função e eventos selecione a opção IntelliTrace Events and Call Informations.

Selecionando o local para salvar os arquivos do IntelliTrace

Os arquivos do IntelliTrace podem ser salvos em disco para posterior analise. Para selecionar o local onde ficará esse arquivo
pode ser escolhido seguindo os seguintes passos:

1- Selecionar Tools->Options->Na lista da direita da popup que aparecer expanda a opção IntelliTrace.

2-Selecione Advanced.

3-Se a opção “Store IntelliTrace recordings in this directory” estiver desmarcada, marque-a.

4-Clique no botão “Browse” e selecione o caminho em seu computador.

Selecionando os eventos que o Intellitrace irá registrar.

Os tipo de eventos a serem registrados pelo IntelliTrace são altamente configuráveis. Você pode registrar todos os eventos
disponíveis ou limitar o registro apenas aos tipos de eventos que lhe interessar seguindo estes passos:

1- Selecionar Tools->Options->Na lista da direita da popup que aparecer expanda a opção IntelliTrace.

2-Selecione a opção IntelliTrace Events.

3-Aparecerá uma série de tipos de eventos, basta marca-los e desmarca-los para incluir ou excluir dos tipos de eventos a serem
registrados pelo intellitrace.

Visualizando eventos do IntelliTrace durante a depuração.

Você pode ver os eventos do IntelliTrace em tempo de depuração através da janela do IntelliTrace.

Os eventos só poderão ser visualizados quando a aplicação estiver pausada.

Para o caminho para acessar a janela é:

Debug->IntelliTrace->IntelliTrace events só disponível durante a depuração.


Gerando um release

Para gerar um release no Visual Studio 2010 basta mudar o valor da caixa de seleção “Solutions Configurations” na barra de
tarefas padrão para release clicar com um botão direto sobre um projeto ou sobre a solução no caso de querer compilar todos
os projetos que estiverem contidos na mesma e no menu contextual selecionar “rebuild”.

LINKS

Página oficial do Visual Studio 2010 - http://msdn.microsoft.com/en-us/vstudio/default

História Visual Studio - http://blogs.msdn.com/b/ricom/archive/2009/10/05/my-history-of-visual-studio-part-1.aspx

Artigo Wikipedia - http://en.wikipedia.org/wiki/Microsoft_Visual_Studio


Capítulo 3-Microsoft C#

O que é?

C # é uma linguagem de programação multi-paradigma fortemente tipada, imperativa, declarativa, funcional, genérica, orientada
a objetos (class-based) e orientada a componentes. Ele foi desenvolvido pela Microsoft como parte da iniciativa
.net e posteriormente aprovada como padrão pelo Ecma (ECMA-334) e ISO (ISO / IEC 23270). C # é uma das linguagens de
programação projetadas para o Common Language Infrastructure.
C # é destinado a ser uma linguagem orientada a objetos, simples, moderna e de propósito geral. A sua equipe de
desenvolvimento é liderada por Anders Hejlsberg.

História

Durante o desenvolvimento do .net Framework as biblioteca de classes foram originalmente escrita utilizando um sistema
compilador de código gerenciado chamado Simple Managed C(SMC). Em janeiro de 1999 Anders Hejlsberg formou um time para
construir uma nova linguagem por hora chamada de Cool um Acrônimo para “Clique Object Oriented Language”. A Microsoft
chegou a considerar deixar Cool como o nome final da linguagem, mas mudou de ideia por razões comerciais. O C# foi anunciado
oficialmente em julho de 2000 e neste momento a biblioteca de classes do ASP.net já havia sido reescrita em c#.

Visão Conceitual Classes
Iniciaremos com uma visão conceitual sobre classes, pois o C# é totalmente orientado a objetos e tudo é baseado em classes, o
conceito de classe é basicamente a união entre os dados e as funções em uma mesma unidade lógica. Diferente de linguagens
como o C++ você não consegue escrever uma função sem que a mesma esteja dentro de uma classe. As classes são utilizadas
para criar instancias, ou seja armazenar dados na memória sobre operações e valores para que fiquem disponíveis em tempo
execução. Abaixo um exemplo de classe:

public. class MyClass
{
//No caso MyPropertie e MypropertieInt int seriam os dados da classe MyClass
private string MyPropertie;
private int MyPropertieInt;

//SetMyPropertie seria um método que manipula os dados dados da própria classe
public void SetMyPropertie(string MyPropertie) {
this.MyPropertie = MyPropertie;
}
}

A sintaxe básica de uma classe em C#

public class [Nome da classe]{
//Variaveis
private string var1;
private string varN...;

//Contrutores
public [Nome da classe]();

//Funções
public void Method1();
public void MethodN...();
}


Sintaxe para criação de Instancia em C#;

MyClass obj = new MyClass();

Posteriormente nesse capítulo abordaremos as classes com mais profundidade.

Namespaces

Os Namespaces servem como uma forma de dividir os objetos em categorias, normalmente de acordo com sua natureza,
independente do projeto ou arquivo que estão.

Sintaxe básica

namespace [NomeNameEspace]{
...//Objetos definidos no namespace
}
Namespaces podem conter outros namespace formando uma estrutura hierárquica, veja o exemplo abaixo:

namespace Animal
{
namespace Caninos
{
namespace Cachorro
{
public class Poodle
{

}
}
}
}
Isso permite ter o mesmo nome de classe em namespaces diferentes, pois o nome completo da classe consiste em cada um de seus
namespaces separados por um ponto com o nome da classe no final, também separado por um ponto. Sendo assim o nome
completo da classe Poodle seria “Animal.Caninos.Cachorro.Poodle”, esse nome não precisa ser escrito completo a toda hora
graças ao comando using que será detalhado a seguir.

Using
Esse é outro elemento básico da sintaxe do C# ele serve para que todos os tipos definidos em um namespace fiquem disponíveis
sem escrever o seu nome completo. Abaixo um exemplo:

Temos 3 classes Poodle,PastorAlemao e Canil, as duas primeiras estão no namespace “Animais” e a última está no namespace
“Lugares”, precisamos declarar um objeto Poodle e um PastorAlemão na classe Canil, abaixo o código sem a utilização de using:

namespace Lugares
{
public class Canil
{
Animais.Poodle Cachorro1;
Animais.PastorAlemao Cachorro2;

public Canil(Animais.Poodle Cachorro1,Animais.PastorAlemao Cachorro2) {
this.Cachorro1 = Cachorro1;
}

}
}

Agora com a utilização do using:

using System;
using System.Collections.Generic;
using System.Linq;


using System.Text;
using Animais;
namespace Lugares
{
public class Canil
{
Poodle Cachorro1;
PastorAlemao Cachorro2;

public Canil(Poodle Cachorro1, PastorAlemao Cachorro2)
{
}

}
}

Observe os outros namespaces antes de Animais, são onde estão os tipos fundamentais do framework e por padrão são
adicionados ao criar uma classe.

Tipos de dados básicos

C# é uma linguagem fortemente tipada. Cada variável e constante tem um tipo explícito. Cada assinatura do método Especifica
um tipo para cada parâmetro de entrada e o valor de retorno. A.NET Framework class library define um conjunto de tipos
numéricos internos, como também os tipos mais complexos que representam uma ampla variedade de construções lógicas, como,
por exemplo, sistema de arquivos, conexões de rede, coleções e matrizes de objetos e as datas. Um programa C# típico usa tipos
da biblioteca de classes bem como tipos definidos pelo usuário que modelam os conceitos que são específicos para o domínio do
problema do programa.

As informações armazenadas em um tipo podem incluir o seguinte:

 O espaço de armazenamento que necessita de uma variável do tipo.
 Os valores máximo e mínimo que ele pode representar.
 Os membros (métodos, campos, eventos e assim por diante) que ele contém.
 O tipo base que ela herda.
 O local de memória onde as variáveis serão alocadas em tempo de execução.
 Os tipos de operações que são permitidos.

O compilador usa informações do tipo para verificar se todas as operações que são executadas em seu código são seguras. Por
exemplo, se você declarar uma variável do tipo int, o compilador permite usar a variável em operações de soma e subtração. Se
você tentar executar essas mesmas operações em uma variável do tipo bool, o compilador gera um erro.

Abaixo exemplo de código que geraria um erro no compilador

{
int a = 5;
int b = a + 2; //OK

bool test = true;

// Error. Operator '+' cannot be applied to operands of type 'int'
and 'bool'.
int c = a + test;
}

O operador + não pode ser aplicado entre um int e um bool;


Especificações dos principais tipos em C#.

Tipos inteiros
Tipo Abrangência Tamanho em bits
sbyte -128 to 127 8
byte 0 to 255 8
char U+0000 to U+ffff 16
short -32,768 to 32,767 16
ushort 0 to 65,535 16

int -2,147,483,648 to 2,147,483,647 32

uint 0 to 4,294,967,295 32

-9,223,372,036,854,775,808 to
long 64
9,223,372,036,854,775,807

ulong 0 to 18,446,744,073,709,551,615 64

Tipos de ponto flutuante e decimal
Tamanho
Abrangência
Tipo Precisão em bits
float ±1.5e−45 to ±3.4e38 7 dígitos 32
double ±5.0e−324 to ±1.7e308 15-16dígitos 64
28 28 0 to 28
decimal (-7.9 x 10 to 7.9 x 10 ) / (10 ) 28-29 dígitos significantes 128

Outros tipos de dados importantes
Tipo Descrição
string Representa uma cadeia de caracteres
DateTime Representa um espaço de tempo e contém uma série de funções para lidar com datas

Tipos de valor e de referência

Os tipos de valor são aqueles tipos que a variável fica diretamente ligada ao valor atribuído a mesma, e quando passado como
parâmetro para alguma função na verdade é copiado para o escopo da função, o que faz que alterações feitas nos valores dentro
dela não reflitam no valor original da variável, a menos que ela seja atribuída novamente no escopo em que foi declarada. Já com
tipo de referência o que ocorre é que a variável esta relacionada a um ponteiro para o espaço de memória onde o valor da mesma
está armazenado, então quando ela é passada como parâmetro para uma função a referência é passada e as alterações de valores
são feitas diretamente no espaço de memória que guarda o valor da variável alterando assim o valor da mesma no escopo original,
porém isso só ocorre quando a palavra reservada “ref” é colocada na assinatura da função. Abaixo um exemplo para ficar mais
fácil entender o que isso representa.

class Program
{
{
string a = "5";


string b = "2";

String a2="5";
String b2 = "2";

Console.WriteLine("TIPOS DE VALOR...rnrn");
Console.WriteLine(string.Format("Valores de a e b no escopo que foram definidos a:{0}
b:{1}rn",a,b));
Swap(ref a,ref b);
Console.WriteLine(string.Format("Valores de a e b no escopo que foram definidos
continuam os mesmos a:{0} b:{1}rn",a2,b2));

Console.WriteLine("TIPOS DE REFERÊNCIA...rnrn");
Console.WriteLine(string.Format("Valores de a e b no escopo que foram definidos a:{0}
b:{1}rn",a2,b2));
Swap(ref a2,ref b2);
Console.WriteLine(string.Format("Valores de a e b no escopo que foram definidos mudam
a:{0} b:{1}rn",a2,b2));
Console.ReadKey();
}
public static void Swap(ref String a,ref String b)
{
string c;
c = a;
a = b;
b = c;
Console.WriteLine(string.Format("Valores de a e b no escopo da função a:{0}
b:{1}rn",a,b));
}

}

Escrevam esse código em um projeto do tipo Console Application do Visual Studio e percebam que os valores de a e b foram
alterados dentro da função, mas na classe main permaneceram os mesmos, já de a2 e b2 tiveram os seus valores alterados também
no escopo principal. Dos tipos apresentados nas tabelas acima apenas DateTime é de referência os demais são de valor, porém
todos os tipos citados tem um correspondente de referência que fazem parte do .net Framework.

Variáveis

Variáveis são simplesmente locais de armazenamento de dados. Você pode armazenar e recuperar os dados através de um nome
atribuído à variável. Quando criamos uma variável precisamos dizer o tipo de dado a ser armazenado na mesma e atribuir-lhe um
nome, a sintaxe para isso em C# é a seguinte:

[Tipos] [Nome Da Variável];

Exemplo:

int Numero;
As variáveis assim como as funções só podem ser definidas dentro de uma classe.

Operadores

Em C #, um operador é um elemento do programa que é aplicada a um ou mais operações em uma expressão ou
declaração. Operadores que levam um operando, como o operador de incremento (+ +), são referidos como operadores
unários. Operadores que usam dois operandos, como operadores aritméticos (+,-,*,/), são referidos como operadores binários. O
operador condicional (?:), leva três operandos e é o único operador ternário em C #.

Um operando pode ser uma expressão válida de qualquer tamanho, e pode ser composto por qualquer numero de outras
expressões. Em uma expressão que contenha múltiplos operadores, a ordem na qual os operadores serão aplicados é determinada
pela ordem de precedência do operador, associatividade e posicionamento de parênteses.


Cada operador tem uma precedência definida. Em uma expressão que contenham múltiplos operadores com ordem de precedência
diferentes, a precedência dos operadores determina a ordem que os operadores serão executados. Por exemplo, a expressão
seguinte atribui o valor 3 para n1.

n1 = 11 - 2 * 4;

A multiplicação é executada primeiro, pois tem precedência sobre a subtração.

As tabelas a seguir separam os operadores em categorias baseadas no tipo de operações que realizam. As
categorias estão listadas em ordem de precedência.

Operações primárias

Expressão Descrição
x.y Acesso de associado
f(x) Invocação de métodos e delegates
a[x] Array and indexer access
x++ Pós-incremento
x-- Pós-decremento
new T(...) Criação de objetos e delegates
new T(...){...} Criação de objeto com inicializador.
new {...} Inicializador de objeto anônimo.
new T[...] Criação de array
typeof(T) Obtém o Sytem.Type para T
checked(x) Executa a expressão em um contexto checado
unchecked(x) Executa a expressão em um contexto não checado
default (T) Obtém o valor default para T
delegate {} Função anônima(Método anônimo)

Operadores unários

+x Identidade
-x Negação
!x Negação lógica
~x Negação bit à bit
++x Pré-Incremento
--x Pré-decremento
(T)x Conversão explicita para o tipo T

Operadores multiplicativos

* Multiplicação
/ Divisão
% Resto

Operadores Aditivos

x+y Adição, concatenação de string, combinação de delegate.
x-y Subtração remoção de delegate.

Operadores de troca


x << y Troca à direita
x >> y Troca à esquerda

Operadores relacionais e de tipo

x<y Menor
x>y Maior
x <= y Menor ou igual
x >= y Maior ou igual
x is T Retorna se x é do tipo T.
x as T Retorna x “tipado” como T ou nulo se não for possível.

Operadores de igualdade

x == y Igual
x != y Diferente

Operadores lógicos,condicionais e para tratamento de valores nulos

Categoria Expressão Descrição
Logical AND x&y AND bit à bit inteiro, AND lógico booleano
Logical XOR x^y XOR bit à bit inteiro, XOR lógico booleano
Logical OR x|y OR bit à bit inteiro, OR lógico booleano
Conditional AND x && y Retorna verdadeiro para x e y verdadeiros.
Conditional OR x || y Verdadeiro se x ou y verdadeiros.
Null coalescing x ?? y Retorna y se x for nulo, caso contrário x
Conditional x ?: y : z Retorna y para x verdadeiro, caso contrário z

Operadores de atribuição e anônimos

= Atribuição
x op= y Compound assignment. Supports these operators: +=, -=, *=, /=, %=, &=, |=, !=, <<=, >>=
(T x) => y Função anônima (lambda expression.)

Alguns exemplos com operadores

//Operador de negacao(-) inverte o sinal do número
int Identidade = 1;
Console.WriteLine(-Identidade);
//Saída "-1"
Identidade = -1;
Console.WriteLine(-Identidade);
//Saída "1"
int Negacao = 1;

//Operador de pré-incremento(++)
int PreIncremento = 1;
PreIncremento = ++PreIncremento;
Console.WriteLine(PreIncremento);


//Saída "2"

//Operador pós-incremento
int PosIncremento = 1;
PosIncremento = PosIncremento++;
Console.WriteLine(PosIncremento);
//Saída "1", pois primeiro ele atribui o valor a variável e depois incrementa o valor.

bool NegacaoLogica = true;
Console.WriteLine(!NegacaoLogica);
//Saída "false"
NegacaoLogica = false;
Console.WriteLine(!NegacaoLogica);
//Saída "true", pois negar uma negação a torna em uma afirmação.

//Algumas operações aritmética
int n1=4, n2 = 2;

Console.WriteLine(n1 + n2);
//Saída "6", 4+2

Console.WriteLine(n1 * n2);
//Saída "8", 4*2

Console.WriteLine(n1 / n2);
//Saída "2", 4/2

Console.WriteLine(n1 - n2);
//Saída "2", 4-2

Console.ReadKey();

Desvios condicionais

A instrução ”if” é usada para realizar desvios condicionais no C#. Com ele o fluxo de execução pode ser alterado de acordo com o
retorno de expressões booleanas, a sintaxe do comando é a seguinte:

if( [Expressão booleana]){

Trecho de código...

}

Você pode definir o segmento “else” para um “if” que serve como fluxo alternativo caso a condição testada seja falsa.



}else{


}

Você pode ainda testar várias condições em uma mesma instrução “if” adicionando segmentos “else if”, a execução
passará na primeira e somente na primeira condição verdadeira do “if” se houver.



}else if([Expressão booleana]){



}

Exemplos utilizando “if”:

bool Validado = true;
//Quando se tratar de um booleano não precisa fazer comparação porque ele mesmo já é um
valor booleano
if (Validado)
{
Console.WriteLine("Ok!");
}

string strRetorno = "Sucesso";
//Outros tipos de dados precisam de uma expressão booleano escrita.
//Obs: O == é um operador de comparação, que retorna true caso os valores sejam iguais
caso contrário false
if (strRetorno == "Sucesso")
{
Console.WriteLine("Missão comprida");
}
else {
Console.WriteLine("Tente novamente");
}
//Aqui temos um if sem delimitadores "{}", essa sintaxe pode ser utilizada quando formos
executar apenas uma instrução.
//Obs: o != é o inverso do == e retorna true para valores diferente caso contrário
false.
if (strRetorno != "Sucesso")
Console.WriteLine("Tente novamente");
else
Console.WriteLine("Sucesso");

DateTime Dt = DateTime.Now;

if (Dt.Hour < 8)
Console.WriteLine("Está muito cedo....");
else if (Dt.Hour == 8)
Console.WriteLine("Em cima da hora....");
else
Console.WriteLine("Atrasado!");
Switch

O comando switch serve para definirmos ações a serem executadas dependendo do valor de uma variável ou de uma expressão, é
muito utilizado com enumerações e quando temos um rol de valores conhecidos que a variável ou a expressão pode assumir.

A sintaxe básica para o switch é a seguinte

switch([Nome da variável]){

case [possível valor 1]

[Ações a serem executadas];

break;//Termina a execução da instrução switch

....

case[Possível valor n]

[Ações a serem executadas];

break;//Termina a execução da instrução switch


default://Opcional

[Ação padrão para caso o valor não esteja definido em nenhum dos Cases];

break;

}

int caseSwitch = 1;
switch (caseSwitch)
{
case 1:
Console.WriteLine("Case 1");
break;
case 2:
break;
default:
Console.WriteLine("Default case");
break;
}

int switchExpression = 3;
switch (switchExpression)
{
// Uma seção de instruções podem ser iniciadas por mais de um valor no caso 0 e 1
case 0:
case 1:
Console.WriteLine("Case 0 or 1");
// para cada case é necessário um break, um return ou um goto.
break;
case 2:
break;
// O código da linha abaixo causa um alerta na compilação, pois nunca será
executada pelo fato de estar depois do break;
Console.WriteLine("Código irrelevante");
// 7 - 4 abaixo o case está em função de um expressão matemática “7-4” então quando
o valor da variável for 3 essa condição será satisfeita.
case 7 - 4:
break;
// Se o valor da váriavel não estiver entre 0, 1, 2, or 3, o código definido no
rótulo default será executado.
default:
Console.WriteLine("Default case (Opcional)");
break;
}
Estruturas de repetição

Estruturas de repetição são instruções que de acordo com uma condição, executam uma sequência de ações repetidas um
determinado número de vezes. Estruturas de repetição também são conhecidas como loops.

As principais instruções para execução de Loop são: “while”,”do”,”for” e “foreach”, vamos analisar cada uma separadamente.

WHILE

Um loop while verifica uma condição e em seguida executa um bloco de código enquanto a condição avaliada for verdadeira. A
sua sintaxe é a seguinte:

while ([Expressão booleana]) {

[Conjunto de instruções]


}

Ao terminar a execução das instruções dentro do bloco definido para o while a expressão booleana é verificada novamente e caso
seja verdadeira o conjunto de instruções é executado novamente esse ciclo se repete até que o valor da expressão avaliada no
segmento while seja falsa. No while se na primeira verificação o valor avaliado for falso o bloco de código não é executado nem
uma vez.

Exemplo:

//Declaração de uma variável
int i = 0;

//Segmento while, nesse caso verifica se o valor da váriavel i é menor que 10.
//O bloco de código será executado enquanto essa expressão for verdadeira
while (i<10)
{
//Conjunto de instruções a serem executadas

//Escreve o valor de i no console
Console.WriteLine(1);

//Soma 1 ao valor de i a cada execução do bloco de código.
i++;
}
//Espera que uma tecla seja digitada para encerrar a execução do programa.
Console.ReadKey();

DO

O loop “do” se comporta como o loop “while”, porém é garantido que o bloco de código seja executado ao menos uma vez, pois a
expressão booleana é avaliada depois da execução do bloco de código.

A sintaxe é a seguinte:

do{


}while([Expressão booleana]);

Exemplo:

//Declaração de uma variável
int i = 0;

do
{
//Conjunto de instruções a serem executadas.
//A diferença é que mesmo que neste ponto o valor de i seja maior que 10
//Esse bloco de código será executado ao menos 1 vez.

//Escreve o valor de i no console
Console.WriteLine(1);

//Soma 1 ao valor de i a cada execução do bloco de código.
i++;
}
while (i < 10);//Segmento while, nesse caso verifica se o valor da váriavel i é menor
que 10.
//O bloco de código será executado enquanto essa expressão for verdadeira

Console.ReadKey();


FOR

O Loop for também executa um bloco de código em função de uma expressão booleana, com a diferença de possuir em sua
sintaxe a possibilidade de incluir um inicializador e um modificador para uma variável que existirá somente em seu escopo. Essa
instrução é largamente utilizada para varrer listas, pois sua sintaxe garante uma semântica melhor em relação ao while quando é
necessário ter um contador das iterações ocorridas no loop.

Sintaxe:

for([Inicializador de variável];[Expressão booleana];[Modificador da variável]){


}

Exemplos:

//Declarando um array de inteiros, e já inicializando com valores.
int[] valores = new int[]{1,2,3,4,5,6,7,8,9,10};

/*No segmento for esta sendo feita inicialização de uma váriavel i que será incrementada
com mais 1
a cada iteração ocorrida, enquanto o valor da váriavel seja menor que o tamanho da
colação de inteiros obtida através da propriedade length do valor.
é importante lembrar que o ultimo índice da lista é sempre o tamanho da mesma menos 1,
pois a primeira posição é 0 e não 1.*/
for (int i = 0; i < valores.Length; i++)
{
//Escreve o valor que está na posição "i" da lista a cada iteração sendo que o "i"
vai sendo incrementado a cada iteração.
//Todos os valores da lista serão escritos na tela em ordem crescente.
Console.WriteLine(valores[i]);
}

Console.WriteLine("Ordem decrescente");
/*Podemos também escreve-los de forma decrescente.
Fazendo algumas alterações no nosso segmento for.
- Iniciando a váriavel i com a ultima posição do array em vez da primeira "0", a
melhor formam de fazer isso é
atribuindo o valor da propriedade length -1 ao seu valor.
- Invertendo o sinal da expressão booleana de < para >= e substituindo a propriedade
length pela constante 0.
- Por fim substituindo o operador unário de incremento(++) para o de decremento(--).
*/

for (int i = valores.Length-1; i >=0; i--)
{
//Escreve o valor que está na posição "i" da lista a cada iteração sendo que o "i"
vai sendo decrementado a cada iteração.
//Todos os valores da lista serão escritos na tela em ordem decrescente.
Console.WriteLine(valores[i]);
}

Console.ReadKey();

FOREACH

Este é um tipo de loop específico da linguagem C# que veio como uma forma de varrer coleções mais eficientemente. Com
foreach não é necessário verificar se o número de iterações é menor que o número de item em uma coleção e nem acessar o item
da coleção através do índice em função da variável do for, pois no foreach ocorre uma iteração para cada item da lista e uma


variável assume o valor deste item, qualquer objeto que herde da interface IEnumerable pode ser utilizado como fonte de dados
em um foreach. Listas serão exploradas com mais profundidade neste capítulo.

foreach ([Declaração da variável] in [Coleção a ser varrida]){


}

Exemplo:

int[] valores = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

/*Agora faremos a mesma coisa que nos dois exemplos utilizando for, ou seja mostraremos
os valores do array
* em ordem crescente e decrescente só que utilizando o foreach.*/

/*No segmento foreach temos a declaração de uma váriavel que assumira o valor de um item
da lista de cada vez
* Reparem que o tipo da váriavel devem representar o tipo que a lista reúne no caso
int. Depois a palavra reservada in
* que deve ser sucedida pela lista a ser varrida.
*/
foreach (int item in valores)
{
Console.WriteLine(item);
}

/*Agora em ordem decrescente
Basta utilizar o método reverse disponível para qualquer tipo de array, que a ordem dos
valores na lista será invertida completamente.
Como os valores estão organizados em forma crescente nesse exemplo, ao inverter serão
apresentados de forma decrescente.
*/
foreach (int item in valores.Reverse())
{
}

Console.ReadKey();

BREAK

O comando break pode ser utilizado dentro do bloco de código de qualquer Loop apresentado anteriormente e causa uma
interrupção imediata das iterações. Pode ser utilizado para quando estamos procurando a primeira ocorrência de um valor
específico, abaixo um exemplo.

int[] valores = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

foreach (int item in valores)
{
if (item == 3)
{
//Ao encontrar a primeira ocorrência do valor 3 o mesmo será escrito na tela e a
execução do Loop será interrompida.
break;


}
}

Tratamento de erro

O C# implementa uma funcionalidade do framework para tratamento de erros, que consiste na possibilidade de executar uma ação
que trata um exceção gerada pelo programa, de modo que não ocorra uma interrupção na execução, esse tratamento é feito através
da instrução “try”, cuja sintaxe básica é a seguinte:

try{

[Conjunto de instruções que podem lançar uma exceção]

}catch([Tipo de exceção] [Nome da variável](Opcional declaração da variável)){

[Conjunto de instrução que gerencia a exceção ocorrida]

}

Exemplo:

int[] vals=new int[]{0,1,2,3,4,5,6,7,8,9};

try
{
/*Nesse caso ocorrerá um erro, pois iniciei o contador do for em 1 o que vai causar
uma tentativa de acesso à uma posição que não existe na lista a posição 10 e
apesar da lista
ter 10 valores os índices vão de 0 a 9, isso provocará o lançamento de uma
exceção no sistema.

*/
for (int i = 1; i < vals.Length+1; i++)
{
Console.WriteLine(vals[i]);
}
}
//O Bloco catch escreverá a mensagem de erro retornada no console e evitará que a
execução do programa seja interrompida.
catch (Exception ex) {
Console.WriteLine(ex.Message);
}
Console.ReadKey();

Arrays e Lists

Muitas vezes no desenvolvimento de aplicações necessitamos de agrupar determinados tipos de dados em coleções, para efeitos de
comparação, ordenação, dentre outros. Em C# é possível fazer esse agrupamento de duas formas.

Através de Arrays e Lists, a diferença fundamental entre ambo é que o Array precisa ter o seu tamanho definido na sua
inicialização, já as Lists podem crescer indefinidamente. As Lists também oferecem mais recursos para tratamento das coleções
como consequência consumem mais processamento. As List foram implementadas sobre o conceito de tipos genéricos que serão
detalhados posteriormente nesse capítulo, por hora vamos analisar a sintaxe, a utilização em um contexto e a interoperabilidade
entre ambos.

Arrays

Um Array pode ser composto por várias dimensões, porém o mais comum é o unidimensional cuja sintaxe é a seguinte:

“[tipo de dado]”[] “[Nome da variável]”;


Exemplo Array de inteiros:

int[] Inteiros;

Ou seja basta adicionar um par de colchetes ao lado do tipo da variável e este passa a representar uma lista unidimensional
daquele mesmo tipo.

Para declaração de um Array multidimensional basta colocar uma vírgula separando as dimensões, por exemplo, a declaração de
um array bidimensional de inteiros ficaria assim:

int[,] MatrizInteiros;

O acesso aos itens dos vetores se dá através de índices, sendo cada índice a posição de uma unidade na matriz, a coleção de
índices começa em 0 e termina no tamanho do vetor -1, o índice do último elemento de um vetor de tamanho n é igual a n-1.

Existem algumas maneiras de se inicializar um vetor abaixo exemplos comentados.

// Declaração e inicialização de um Array unidimensional de 5 posições.
int[] array1 = new int[5];

// Declaração e inicialização de um Array unidimensional de 5 posições,
// mas nesse caso o número de posições é definido pelo número de valores definido entre as
chaves na sintaxe de inicialização.
int[] array2 = new int[] { 1, 3, 5, 7, 9 };

// Sintaxe alternativa
int[] array3 = { 1, 2, 3, 4, 5, 6 };

// Declaração e inicialização de um Array bidimensional, sem atribuição de valores.
int[,] multiDimensionalArray1 = new int[2, 3];

// Declaração e inicialização de um Array bidimensional, com atribuição de valores.
int[,] multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } };

Para acessar o elemento de valor 3 do array “array2” a sintaxe seria a seguinte:

int Elemento = array2[1];

Para atribuir um novo valor a esta mesma posição a sintaxe seria a seguinte:
int Elemento=20;
array2[1]=Elemento;

Para acessar o elemento de valor 5 do array multidimensional “multiDimensionalArray2” a sintaxe seria a seguinte:
int elemento= multiDimensionalArray2[1,1];

Para atribuir um novo valor a esta mesma posição a sintaxe seria a seguinte:
int Elemento=20;
array2[1,1]=Elemento;

Lists

Os Lists são listas genéricas unidimensionais que assumem um determinado tipo. Não precisam ter seu tamanho especificado na
inicialização. A List provê algumas funcionalidades a mais que o Array como o método Find, que serve para encontrar
ocorrências de um determinado valor na lista. Para utilização do List o namespace System.Collections.Generic do assembly
“mscorlib.dll” deve estar acessível.

A sintaxe básica é a seguinte:

List<[Tipo de dado]> [Nome da variável];

Exemplo List de inteiros:


List<int> lst = new List<int>();

A inclusão de um elemento na lista pode ser feito através do método Add. Cuja sintaxe é a seguinte:

int Elemento=10;
lst.Add(Elemento);

A sintaxe de acesso e atribuição de elementos é idêntica à de Arrays unidimensionais.

Interoperabilidade
Uma lista pode ser transformada em um Array através do método “ToArray()”, exemplo abaixo:
int[] Myarray;
List<int> MyList = new List<int>();
Myarray = MyList.ToArray();

Um Array pode ser transformado em List através do método “ToList()”,exemplo abaixo:
List<int> MyList;
int[] Myarray=new int[10];

MyList = Myarray.ToList();

Todos os itens de um Array podem ser inserido em uma lista através do método AddRange([Fonte de dados enumerável]) da
classe List, Exemplo abaixo:
List<int> MyList=new List<int>();
int[] Myarray=new int[10];

MyList.AddRange(Myarray);

Tabela com os principais métodos comuns à Arrays e Lists.

Nome do método Descrição
Reverse() Inverte a ordem dos elementos na lista.
First() Retorna o primeiro elemento da lista.
OrderBy(Predicate) Ordena os valores da lista de acordo com o valor passado com
parâmetro.
Max() Retorna o elemento de valor máximo pela ordem de
precedência.
Min() Retorna o elemento de valor mínimo pela ordem de
precedência.

Windows Forms

Windows Forms é um conjunto de bibliotecas que fornecem funcionalidades para desenvolvimento de aplicações desktop que
utilizem interações através de janelas no padrão Windows. As principais funcionalidades estão na biblioteca
System.WindowsForms.dll. Nesse tópico iremos abordar os principais componentes do Windows forms.

Eventos

A orientação a eventos é um dos paradigmas da linguagem C#, isso quer dizer que os componentes executam as suas ações através
de eventos. Por exemplo, um componente do tipo botão tem o evento Click, esse evento será relacionado com um ou mais
métodos e quando o mesmo ocorrer as instruções contidas nesses métodos serão executadas.


Guia rápido hello World em Windows forms

Vamos fazer passo a passo a criação de um aplicativo Windows forms simples. O famoso Hello World.

Abra o Microsoft Visual Studio 2010.

Vá até o menu:File->New->Project.

A janela abaixo aparecerá:

Escolha a categoria Windows e dentro dela escolha Windows Forms Application.

Seleciona o nome do projeto na caixa de texto rotulada “Name”.

Clique em Ok.

O form principal do projeto aparecerá.

Abra a toolbox e arraste um controle do tipo Button para o form.

Clique no controle que acabou de adicionar com o botão direito e escolha a opção “Properties”.

Na janela que aparecerá selecione o item “text” e mude o valor de “button1” para “Saudar”, conforme imagem abaixo:

Agora clique na imagem de um raio no topo da janela properties.


Uma lista dos eventos existente para o botão será exibida, dê um duplo clique no evento “Click”.

Você será redirecionado ao arquivo de código onde já terá um método criado e relacionado ao evento “Click”, coloque o trecho de
código a seguir entre as chaves do método.

//Aqui temos uma chamado ao método show da classe MessageBox , este método exibe uma caixa de dialogo com o texto passado
como parâmetro à ele.

MessageBox.Show("Hello World");

Agora basta apertar F5 para rodar o aplicativo.

Clique no botão do formulário para visualizar a caixa de dialogo.

Principais componentes

Form

O form é o elemento fundamental das aplicações Windows forms e pode hospedar uma série de outros controles.

O form pode receber as interações do usuário através do mouse ou através do teclado, e também apresentar dados através dos
controles hospedados. Aplicações mais complexas podem necessitar de uma série de forms para cumprir seu objetivo. Sempre que
você criar um projeto do tipo Windows forms um form com o nome form1.cs é adicionado, você pode mudar o nome clicando
sobre ele e apertando a tecla F2, se tudo correr bem todas as referências para o mesmo também serão alteradas. Você pode
adicionar outros forms ao seu projeto clicando sobre ele com o botão direito, escolhendo a opção new->item no menu contextual.
A janela abaixo aparecerá:


Selecione o item Windows Form, mude o nome na caixa de texto abaixo da lista conforme desejado. E clique no botão “Add”.


O formulário pode ser customizado através de suas propriedades para altera-las acesse a janela “properties”, abaixo uma tabela
com as mais importantes e suas respectivas descrições:

Propriedade Descrição
(Name) O nome do objeto form.
Backcolor Cor de fundo do formulário.
BackgroundImage Indica uma imagem para o plano de fundo do formulário.
Determina como a imagem defina na propriedade BackGroundImage será apresentada.
BackgroundImage1Layout
ControlBox Determina quando o form tem um ControBox.
Cursor Aparência do cursor do mouse quando estiver sobre o form.
Enabled Determina se o form está habilitado, se estiver falso todos os controle hospedados também ficarão
desabilitados
Font Atribui a font padrão para textos do form.

ForeColor Determina uma cor de primeiro plano padrão, será utilizada para todos controle caso não seja
atribuída separadamente.

FormBorderStyle Indica a aparência e o comportamento das bordas do form.

HelpButton Indica quando o Form tem um botão de ajuda.
Icon Indica o ícone a ser apresentado no topo do form.
Location Determina o posicionamento do form na tela quando a propriedade StarPosition está com o valor
“Manual”.

MaximizeBox Indica se o form tem a opção de maximizar.
MaximumSize Determina o tamanho máximo que o form pode assumir.

MinimizeBox Indica se o form tem a opção de minimizar.
MinimumSize Determina o tamanho mínimo que o form pode assumir.

Opacity Representa o nível de transparência do formulário, quando maior mais transparente.

Size Atribui e recupera o tamanho inicial do form
StartPosition Posição do Form na sua primeira aparição.

Text Determina o texto que aparece no topo do forn.
TopMost Determina se o formulário aparece na frente de todas as outras aplicações.

Visible Determina se o formulário esta visível.
Windowstate Determina o estado inicial do formulário: Maximizado, Minimizado, etc.

Alterando o formulário inicial de um projeto

Esse é o primeiro form aberto ao executarmos um projeto, para alterar qual será esse formulário é necessário abrir o arquivo
program.cs e mudar a instância de form passada para o método Run([Instância form]) da classe application . Se o form criado
junto com o projeto não tiver sido renomeado estará assim:


Application.Run(new Form1());

Caso contrário no lugar de Form1 estará o nome atual do Form que foi criado junto com o projeto. Altere para o nome do
formulário que deseja que seja inicializado.

Prática;

Crie 2 formulários.

Os requisitos do primeiro são:

1. O título deve ser “formulário 1”.
2. O formulário deve abrir maximizado.
3. O formulário não pode ser minimizado.
4. O formulário deve ser parcialmente transparente.
5. O formulário deve aparecer acima de todas as outras telas abertas.
6. O formulário deve abrir junto canto superior direito da tela.

Os requisitos do segundo são:

1. O título deve ser “formulário 2”
2. O formulário deve abrir no centro da tela.
3. A cor de fundo do formulário deve ser vermelha.
4. O Formulário deve apesentar um ícone ao lado do texto.
5. O formulário não pode ser redimensionado.
6. O Formulário não pode ser minimizado.

Controles containers

Os controles do tipo contêineres foram concebidos para reunir uma série de outros controles. Com eles é possível criar subdivisões
lógicas e físicas no form que agrupam outros controles. Por exemplo, você pode colocar uma série de opções correlatas dentro de
um groupbox onde somente uma pode ser escolhida. Quando um controle do tipo container hospeda outros controles, algumas
propriedades do mesmo podem impactar em todos os seus filhos, por exemplo, se a propriedade Enable for atribuída como false
todos os controles dentro do contêiner também ficarão desabilitados, assim como se a propriedade Visible for falsa, todos os itens
também ficarão invisíveis.

Para adicionar controles a um container basta arrasta-los da ToolBox para o mesmo.

Existem propriedades de layout dos itens que tem relação com seu container. Por exemplo, a propriedade “Anchor” presente em
todos os controles Windows Forms. Essa propriedade determina quais distâncias entre as extremidades do controle item e seu
container serão mantidas quando o container for redimensionado. Observe as imagens abaixo para que esse conceito fique mais
claro.

Temos um botão dentro de um groupbox na imagem abaixo.

Apostila desenvolvimento aplicações comerciais com C#

Apostila desenvolvimento aplicações comerciais com C#

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a Apostila desenvolvimento aplicações comerciais com C#

Semelhante a Apostila desenvolvimento aplicações comerciais com C# (20)

Apostila desenvolvimento aplicações comerciais com C#