csharp formacao.net

Programa de Formao .NET

Apostila Treinamento C#

2

ndice

Captulo 1 Introduo 9

Captulo 2 Viso Geral do .NET 9

Estratgia .NET ......................................................................................................................9

Tecnologias ............................................................................................................................11 Vantagens do .NET ................................................................................................................12 Desvantagens do .NET ..........................................................................................................13 Verses do Framework ..........................................................................................................13

Framework .NET Verso 1.0 (1.0.3705) 14

Framework .NET Verso 1.1 (1.1.4322) 14

Framework .NET Verso 2.0 (2.0.50727.42) 14

Funcionamento do Framework ......................................................................................15

A Mquina Virtual ...................................................................................................................15

Esquema de funcionamento do .NET. 16

Coleta de lixo (Garbage Collector) .........................................................................................17 Captulo 3 Visual Studio 2005 19

Objetivos..............................................................................................................................19

Conceitos de Soluo e Projeto ....................................................................................19

Breve Introduo aos Diferentes Tipos de Projeto .....................................................20

Explorando as Janelas......................................................................................................22

Solution Explorer ....................................................................................................................22 Toolbox...................................................................................................................................23 Properties ...............................................................................................................................23 Server Explorer.......................................................................................................................24 Task List .................................................................................................................................24 Output .....................................................................................................................................25 Error List .................................................................................................................................25

Lab: Navegando na IDE ..................................................................................................25

Reviso.................................................................................................................................28

Captulo 4 Linguagem C# 29

Declarao de Variveis.................................................................................................29


3

Case Sensitive.....................................................................................................................29

Tipos de variveis...............................................................................................................29

Marcadores de bloco e finalizadores...........................................................................32

Smbolos e operadores lgico-aritmticos ..................................................................32

If...else...................................................................................................................................33

Laos While .........................................................................................................................33

Laos for ..............................................................................................................................33

Laos do...while .................................................................................................................34

Switch..Case .......................................................................................................................34

Loop foreach......................................................................................................................34

Vetores (arrays) ..................................................................................................................35

Funes................................................................................................................................35

Estrutura de um programa C# .......................................................................................36

Converso de tipos (cast) ...............................................................................................36

Strings....................................................................................................................................37

Reviso.................................................................................................................................37

Captulo 5 Orientao a Objetos com C# 38

Objetivos..............................................................................................................................38

Viso Geral..........................................................................................................................38

Classes e Objetos...............................................................................................................39

Agora que criamos a classe porta, como fazemos para criar um objeto do tipo

Porta? 40

Atributos e Propriedades .................................................................................................40

Mtodos...............................................................................................................................41

New Keyword .....................................................................................................................42

Construtores e Destrutores...............................................................................................43

Lab: Trabalhando com Classes ......................................................................................44

Nveis de Acesso e Visibilidade.......................................................................................47

Public ......................................................................................................................................48 Private.....................................................................................................................................48 Protected ................................................................................................................................48 Internal....................................................................................................................................49 Protected Internal ...................................................................................................................49


4

Resumo dos Nveis ................................................................................................................49

Encapsulamento................................................................................................................50

Notao UML .....................................................................................................................50

Herana...............................................................................................................................51

Classe Abstrata e Classe Selada...........................................................................................53

Sobrescrita de Mtodos ...................................................................................................54

Sobrecarga de Mtodos .................................................................................................55

Acessando a classe pai base e this ....................................................................................55

Polimorfismo........................................................................................................................55

Lab: Trabalhando com Herana ...................................................................................57

Interface ..............................................................................................................................57

Mtodos, Atributos e Propriedades Estticas..............................................................58

Classes Parciais ..................................................................................................................59

Reviso.................................................................................................................................60

Captulo 6 Tpicos Avanados 61

Objetivos..............................................................................................................................61

Namespaces ......................................................................................................................61

Outro uso para Using .............................................................................................................63

So idnticas! 63

Referncias .........................................................................................................................64

Lab: Trabalhando com Namespace e Referncias..................................................65

Bibliotecas do Framework .NET 2.0 ................................................................................67

O namespace System ............................................................................................................67

Nota 68

O namespace System.Text ....................................................................................................68 O namespace System.Collections .........................................................................................68

Trabalhando com HashTables 69

O namespace System.IO .......................................................................................................70

Escrevendo um arquivo 70

Lendo um arquivo 70

Tarefas recorrentes............................................................................................................70

Acessando o diretrio da aplicao .......................................................................................70 Verificando o nome do computador .......................................................................................70


5

string NomeComp = System.Environment.MachineName; 70

string nDNS = System.Net.Dns.GetHostByName("LocalHost").HostName; 71 Verificando a verso do sistema operacional ........................................................................71 Verificando o usurio que est rodando o programa.............................................................71

string usr = System.Environment.UserName; 71

Tratamento de Erros Uso de Try/Catch/Finally .........................................................71

Tratamento estruturado de erros try/catch..........................................................................71 Excees personalizadas.......................................................................................................74 Disparando exceptions...........................................................................................................74 Finally .....................................................................................................................................74

Reviso.................................................................................................................................75

Captulo 7 XML 76

Objetivos..............................................................................................................................76

O que XML?.....................................................................................................................76

Elementos de um Documento XML...............................................................................77

Declarao .............................................................................................................................77 Tags........................................................................................................................................77 Atributos .................................................................................................................................79 Comentrios ...........................................................................................................................79 XML Bem Formado ................................................................................................................79

Definindo a Estrutura do Documento ...........................................................................79

Reviso.................................................................................................................................81

Captulo 8 ADO.NET 82

Objetivos..............................................................................................................................82

O que o ADO.NET...........................................................................................................82

Providers do .NET................................................................................................................82

Modelo ADO.NET ...............................................................................................................83

Connection .............................................................................................................................83 Command ...............................................................................................................................83 DataReader ............................................................................................................................84 DataAdapter ...........................................................................................................................85 Criando comandos automaticamente: o CommandBuilder....................................................86

DataSet................................................................................................................................87

Nota 87


6

Populando e iterando por um DataSet ...................................................................................88 Filtrando dados em um DataSet.............................................................................................88 Procurando por uma informao em um DataSet..................................................................89 DataViews ..............................................................................................................................89

Nota 89

Atualizando o banco com informaes do DataSet ...............................................................90

Acessando arquivos XML.................................................................................................91

Gravando arquivos XML a partir de um DataSet ...................................................................91 Lendo arquivos XML em um Dataset .....................................................................................92

Trabalhando com nulos ...................................................................................................93

Reviso.................................................................................................................................93

Captulo 9 Trabalhando com Windows Forms 94

Objetivos..............................................................................................................................94

Formulrios MDI ..................................................................................................................94

Herana de formulrios ..........................................................................................................95

Nota 95

User Controls .......................................................................................................................96

Adicionando um controle programaticamente........................................................................96 Disparando eventos de um controle.......................................................................................96

Lab: Criando um User Control.........................................................................................97

Respondendo a eventos de teclado .........................................................................100

Data Binding.....................................................................................................................100

DataSource...........................................................................................................................100 DataBinding ..........................................................................................................................102 BindingNavigator ..................................................................................................................102

Lab: Data Binding............................................................................................................103

DataGridView...................................................................................................................107

Populando um DataGridView ...............................................................................................108 Ativando a ordenao automtica........................................................................................108 Ativando o auto-ajuste de linhas e colunas..........................................................................108 Renomeando as colunas......................................................................................................109 Formatando colunas.............................................................................................................109 Mudando o estilo de acordo com uma condio..................................................................109 Fazendo um DataGridView zebrado..................................................................................110 Lendo eventos de seleo ...................................................................................................110


7

Oferecendo uma lista de opes em um ListBox.................................................................111

Formulrios Master/Detail ..............................................................................................112

DataRelation.........................................................................................................................112 Estratgia do Master/Detail ..................................................................................................113

Lab: Relacionamentos e Master-Detail ......................................................................113

Reviso...............................................................................................................................117

Captulo 10 Web Services 118

Objetivos............................................................................................................................118

Conceito: O que um Web Service?.........................................................................118

Criando um Web Service...............................................................................................120

Consumindo um Web Service ......................................................................................125

Distribuindo um Web Service ........................................................................................127

Reviso...............................................................................................................................129

Captulo 11 Depurao, Debug e Trace 130

Objetivos............................................................................................................................130

Depurando uma aplicao..........................................................................................130

Breakpoints e condies ......................................................................................................132 Watch Window......................................................................................................................133 O QuickWatch ......................................................................................................................133 A janela Output.....................................................................................................................134 A janela Immediate...............................................................................................................134 As janelas Locals e Auto ......................................................................................................135

Debug e Trace .................................................................................................................135

Mtodos do Debug e do Trace.............................................................................................135 Listeners ...............................................................................................................................136

Reviso...............................................................................................................................137

Captulo 12 Distribuio 138

Objetivos............................................................................................................................138

Tipos de setup suportados .............................................................................................138

Criando um projeto de setup .......................................................................................138

Personalizando o setup ..................................................................................................141

Seo File System................................................................................................................143 Seo Registry .....................................................................................................................144 Seo File Types..................................................................................................................144


8

Seo User Interface............................................................................................................145 Sees Custom Actions e Launch Conditions .....................................................................145

Criando um projeto de atualizao ...........................................................................146

Click-once deploy...........................................................................................................147

Reviso...............................................................................................................................149

Apndice A Referncias 150

Livros e Revistas ................................................................................................................150

Sites .....................................................................................................................................150

.NET e Visual C# ..................................................................................................................150

Microsoft ASP.NET Site oficial da Microsoft sobre ASP.NET 150

MSDN Brasil Outro site official da Microsoft, trata das plataformas de

desenvolvimento Microsoft 150

Visual C# Walkthroughs 150

Code Project 150

C# Reference 150

Windows Forms....................................................................................................................151

Introducing a New Data Grid 151

Windows Forms Demos 151

XML ......................................................................................................................................151

XML Tutorial 151

XML Introduo 151

DTD Tutorial 151

XML Schema Tutorial 151

System.Xml Namespace 151

Acessando XML remoto e buscando informaes com o Namespace

System.Xml.XPath 151

Migrando arquivos Textos delimitados para XML 151

Distribuio...........................................................................................................................152


9

Captulo 1 Introduo

Com este intuito, esto sendo desenvolvidos treinamentos, para preparar os profissionais para este o novo conceito de desenvolvimento, que surge junto com o .NET.

Para que os profissionais tenham condio de compreender esse novo universo introduzido pelo .NET, esse Adoption Lab ir discutir os principais conceitos que esto por trs deste. Faremos um tour pelo Visual Studio, e criaremos algumas aplicaes usando o C# como base. Terminaremos mostrando como distribuir as aplicaes desenvolvidas, e como planejar estratgias de migrao.

Como a plataforma .NET extremamente rica, e o tempo do curso limitado, no ser possvel cobrir tudo o que o .NET tm a oferecer. Como essa migrao uma mudana de paradigmas, necessrio cobrir alguns dos aspectos mais importantes da linguagem e do framework como orientao a objetos, acesso a dados atravs do ADO.NET, XML, Web Services. Procuramos, no material terico, dar um embasamento maior do que o que ser visto em sala, para que o aluno possa por iniciativa prpria complementar o conhecimento adquirido em sala.

Por fim, esperamos com esse treinamento plantar uma semente, que instigue os profissionais a buscar conhecer mais sobre esse assunto. Para auxili-los, indicamos algumas referncias aonde possvel iniciar a sua pesquisa.

Captulo 2 Viso Geral do .NET

Estratgia .NET A Microsoft vem constantemente evoluindo as tecnologias de desenvolvimento, buscando integrar aplicaes e tornar o desenvolvedor mais produtivo.

Com o aparecimento do DDE e OLE, a Microsoft permitiu a integrao fcil entre aplicaes Office e programas desenvolvidos dentro do ambiente Windows.


10

O ActiveX veio no bojo da Internet, oferecendo para os programadores os conceitos de componentizao. A tecnologia COM trouxe maior liberdade de desenvolvimento, e a COM+ introduziu um framework que permite escalabilidade, transaes e segurana.

Apesar dessas mudanas, ainda existia um grade vazio a ser preenchido. Era custoso para um programador Visual Basic desenvolver componentes que usassem todos os recursos da tecnologia COM, bem como fazer uso da API: a documentao disponvel era voltada a programadores C++, e a principal fonte de informao eram livros que traduziam as interfaces da API para que os programadores VB pudessem utilizar. Alm disso, ainda havia o problema de tipos de dados que as interfaces usavam e que no estavam disponveis no VB.

Mesmo com os avanos trazidos pelas tecnologias citadas, os programadores Windows ainda enfrentavam outro problema: o famigerado DLL Hell - sobreposio de verses de DLLs em cujas novas verses haviam chamadas de funes diferentes das anteriores, o que fazia com que programas que usavam a verso mais antiga da DLL deixassem de funcionar.

Outra caracterstica que foi perdida foi a capacidade de instalar uma aplicao apenas com a cpia dos arquivos: tornou-se necessrio o uso de instaladores que, alm de copiar os arquivos, ainda precisavam registrar os componentes no Registro do Windows.

O .NET no s resolve tais problemas, mas tambm unifica a plataforma de desenvolvimento e adiciona novas funcionalidades que so ou sero essenciais para o desenvolvimento corporativo, como XML, Web Services, threading, SmartClients e outros. Ele permite que diversas linguagens trabalhem juntas, de forma transparente, para criar aplicaes que so mais fceis de fazer, gerenciar, distribuir e integrar com outros sistemas.

Entre suas caractersticas, temos:

Interoperabilidade Como diversas bibliotecas COM j haviam sido criadas, o .NET Framework prov meios de permitir interoperabilidade entre o novo cdigo e bibliotecas existentes.


11

Common Runtime Engine As linguagens de programao no .NET Framework compilam o cdigo em uma linguagem intermediria conhecida com Common Intermediate Language (CIL). Durante a execuo, essa o arquivo no formato CIL compilada pelo Just In Time Compiler (JIT) em cdigo nativo. A combinao desses conceitos chamada Common Language Runtime (CLR).

Independncia de Linguagem O .NET Framework suporta o desenvolvimento em mltiplas linguagens de programao. Isso possvel porque todas as linguagens devem converter seu cdigo em um cdigo que atenda aos requisitos da MSIL.

Base Class Library (BCL) A BCL (tambm conhecida como Framework Class Library - FCL), uma biblioteca de classes disponvel a todas as linguagens que utilizam o .NET Framework. Ele prove um conjunto de classes que encapsulam funes comuns, como: acesso a arquivo, interao com banco de dados, manipulap XML, etc.

Distribuio Simplificada Instalao e distribuio de aplicaes Windows foi simplificada. Manipulao de Registry, distribuio de arquivos, registro de DLLs foram quase completamente eliminadas pelos novos mecanismos de distribuio do .NET.

Segurana O Framework .NET permite ao cdigo rodar com diferentes nveis de confiabilidade.

Tecnologias O .NET engloba diversas tecnologias:

Windows Forms Permite o desenvolvimento de aplicaes para Windows, incluindo elementos comuns de interface com o usurio;

Windows Services Permite o desenvolvimento de servios para Windows.


12

ASP.NET Foi a tecnologia escolhida pela Microsoft para substituir as antigas pginas ASP. Permite ao desenvolvedor desenvolver aplicaes web, usando todas facilidades do BCL, alm de diversos controles que reduzem drsticamente o tempo de desenvolvimento de qualquer aplicao Web.

ADO.NET O ADO.NET a nova verso o ActiveX Data Objects (ADO) para .NET. Ele simplifica o acesso a dados, e permite o acesso desconectado.

.NET Remoting Corresponde a uma nova abordagem de comunicao entre processos. Prov um rico e extensvel framework para comunicao entre diversas aplicaes, rodando em diferentes domnios de aplicao.

Web Services Utilizando SOAP, XML, e os conceitos de Service Oriented Architecture (SOA), um web services permite conexo entre aplicaes atravs da internet.

Mobille Applications Utilizando-se do Compact Framework, possvel desenvolver de forma transparente aplicaes para Pocket, SmartPhone, e outros dispositivos compactos.

Visual Studio Tools for Office (VSTO) Com o VSTO, possvel desenvolver aplicaes que utilizem a riqueza da interface com o usurio do Office, e o poder e a robustez das aplicaes .NET.

Vantagens do .NET A plataforma .NET traz vantagens interessantes, tais como:

Conjunto rico de bibliotecas com os mais variados usos;

Controle de verso: fim do DLL Hell;

Facilidade de desenvolvimento de aplicaes desde as simples at as mais complexas;

Facilidade na instalao e na distribuio de aplicaes;


13

Orientada a objetos;

ADO.NET trabalha com dados desconectados;

Alta escalabilidade para ambientes de misso crtica;

Interoperabilidade entre plataformas e componentes desenvolvidos em outras linguagens .NET;

Sintonizado com as ltimas tecnologias;

Soluo sendo mundialmente adotada;

Tecnologia baseada em mquina virtual;

Rotina automtica de coleta de lixo que permite remoo de variveis e objetos que no so mais utilizados;

Novo ambiente de desenvolvimento acelerado (RAD).

As vantagens no acabam por aqui, seriam necessrias pginas e pginas para conseguir chegar a uma lista mais completa. Mas a lista acima j um tanto agradvel.

Desvantagens do .NET As maiores desvantagens do .NET, que devem ser vistas para se ter uma idia do esforo de migrao:

um novo paradigma, e requer aprendizado de novas tcnicas para fazer o melhor uso da ferramenta;

Requer a distribuio do framework;

Em alguns casos requer reengenharia ou reescrita completa do cdigo.

Verses do Framework Existem diferentes verses do Framework:


14

Framework .NET Verso 1.0 (1.0.3705)

Esta foi a primeira verso do Framework, liberado em 2002. Ele est disponvel como um pacote de distribuio, como um kit de desenvolvimento de software (SDK), ou junto com o Visual Studio 2002.

Framework .NET Verso 1.1 (1.1.4322)

Este foi o primeiro grande upgrade, liberado em 2003. Ele est disponvel como um pacote de distribuio, como um SDK ou junto com o Visual Studio 2003. Alm disso, ele acompanha o Windows Server 2003.

Mudanas da verso 1.0

Suporte nativo a aplicaes mobile (na verso 1.0, era disponvel como um Add-On).

Mudanas em Segurana permite a assemblies Windows Form executarem em um modo semi-confivel

Suporte nativo a bancos ODBC e Oracle (na verso 1.0, era disponvel como um Add-On).

.NET Compact Framework Uma verso de Framework para aparelhos como Pocket e SmartPhone.

Suporte ao Internet Protocol v6 (IPv6).

Numerosas mudanas em APIs.

Framework .NET Verso 2.0 (2.0.50727.42)

Nesta verso, liberada em Outubro de 2005, houveram alteraes no s de tecnologia, como de estratgia. Ele est disponvel como um pacote de distribuio, como um SDK ou junto com o Visual Studio 2005 ou o SQL Server 2005.

Mudanas da Verso 1.1

Numerosas mudanas em APIs.


15

Novos controles ASP.NET.

Verso interna de IIS, permitindo desenvolver aplicaes ASP.NET ou Webservices sem a necessidade de ter o IIS instalado na mquina de desenvolvimento.

Suporte completo a 64-bits para as plataformas x64 e IA64.

Suporte de linguagem para Generics diretamente na CLR.

Funcionamento do Framework

A Mquina Virtual O .NET baseia-se no conceito de mquina virtual, que serve como uma camada que fica entre o cdigo e o sistema operacional.

No conceito de mquina virtual, um programa pode ser portado entre vrias plataformas, desde que exista para elas uma mquina virtual capaz de compilar o cdigo. Alm do pacote de instalao comum para Windows, a Microsoft prov o Shared Source Common Language Infraestructure, que roda em Windows, FreeBSD e Mac OS X; e como o CLI um padro aberto, existem diversos projetos open source que surgiram para prover suporte para plataformas adicionais, sendo o mais conhecido o Mono.

Todo cdigo escrito em .NET (usando Visual Basic, C#, J# ou qualquer outra linguagem disponvel) compilado para uma linguagem intermediria, chamada CIL (ou MSIL). O cdigo CIL ento distribudo e executado pelos clientes e usurios da aplicao.

Os leitores mais atentos podem estar pensando: - Mas idntico ao que o VB 6 j fazia: o cdigo traduzido em tokens que so interpretados. A que reside a grande diferena: o cdigo .NET compilado just-in-time pela mquina virtual, ou seja, gerado de fato cdigo de mquina que executado com extrema rapidez. No VB 6, o cdigo era interpretado pelo VBRun: a cada instruo o interpretador comandava instrues para o processador mas se, por exemplo, uma funo for chamada repetidas vezes, ela sero reinterpretada a cada chamada que for feita.


16

As grandes vantagens de se fazer a compilao just-in-time so a compilao especfica para o hardware em que a Mquina Virtual roda, e a portabilidade, j mencionada.

Como todo o cdigo traduzido para a linguagem intermediria, tornou-se fcil padronizar tipos de dados, bibliotecas, classes, componentes, que passam agora a ser especificamente .NET e facilmente utilizveis em qualquer linguagem .NET, seja ela C++, Visual Basic ou C#.

esse conjunto de bibliotecas, deu-se o nome de Base Class Library (BCL) - tambm conhecida como Framework Class Library (FCL). A BCL prove um conjunto de classes que encapsulam funes comuns, como acesso a arquivo, interao com banco de dados, manipulap XML, etc.

O esquema abaixo detalha as camadas da Mquina Virtual:

Esquema de funcionamento do .NET.

As caixas superiores (C# e VB.NET) representam o cdigo que escrito por programadores, como por exemplo MeuPrograma.cs (em C#) ou MeuPrograma.vb (em Visual Basic . NET).


17

Para cada linguagem h um compilador especfico, que traduz o cdigo escrito para a linguagem intermediria (CIL). O compilador especfico do Visual Basic o vbc.exe (de Visual Basic Compiler). O cdigo CIL gerado ento armazenado, junto com outras informaes, em um arquivo .exe ou .dll, dependendo do que for parametrizado na chamada do vbc.exe. O Visual Studio j faz essa tarefa de chamar o vbc.exe com os parmetros corretos ao se usar qualquer uma das opes de Build e Run.

A caixa CLR representa a Mquina Virtual (CLR de Common Language Runtime), que responsvel pelo gerenciamento dos objetos .NET e pela chamada do compilator just-in-time (JIT), que compilar o cdigo em linguagem de mquina.

O cdigo compilado ficar ento em cache at que o Windows seja desligado ou reiniciado, ou ainda quando a Mquina Virtual necessitar de recursos.

Coleta de lixo (Garbage Collector) O .NET possui um mecanismo interno de coleta de lixo, capaz de desalocar a memria ocupada por objetos que j no esto mais sendo usados.

Alm de retirar do programador a preocupao de limpeza de recursos, a coleta de lixo tambm resolve os problemas de desalocao de referncias circulares e de dependncia de objetos que esporadicamente aconteciam no COM. A limpeza era feita atribuindo-se Nothing uma varivel de referncia mas, se essa varivel apontasse para um objeto que, internamente, tambm tivesse referncia a outros objetos, estes ltimos no seriam liberados se o programador no tomasse os cuidados necessrios.

A coleta de lixo feita sem que o usurio tenha que intervir, e o framework decide qual o melhor momento em que ela ocorrer, usando parmetros como escasseamento de recursos (caso o sistema passe por situaes de falta de memria) ou ociosidade de CPU (quando o .NET usa ciclos ociosos para alocar suas threads de limpeza).

A coleta de lixo baseada em um contador de referncias que uma caracterstica de cada objeto. Quando o .NET detecta um objeto cujo marcador de referncias


18

contm zero, isto , no existe nenhum outro objeto que o referencia, ele colocado em uma fila e ser posteriormente eliminado.

H meios de se lidar com o mecanismo de coleta de lixo, como o mtodo GC.Collect(), mas usada em casos especficos aonde se termina de usar objetos muito grandes que, no entender do programador, devem ser liberados rapidamente. No geral, deve se deixar o mecanismo de coleta de lixo realizar a sua tarefa automaticamente.


19

Captulo 3 Visual Studio 2005

Objetivos O objetivo deste captulo familiarizar o leitor com o ambiente de desenvolvimento integrado (IDE) do Visual Studio 2005.

Conceitos de Soluo e Projeto O projeto o ponto de partida para o desenvolvimento de aplicaes, componentes e servios no Visual Studio .NET. Ele age como um container, que gerencia seu cdigo fonte, conexes de dados, arquivos e referncias. Um projeto organizado como parte de uma soluo, a qual pode conter mltiplos projetos, que so interdependentes entre si.

O Visual Studio usa um modelo baseado em pastas todos os itens do projeto so colocados na hierarquia da pasta do projeto. Quando voc adiciona um arquivo


20

texto, uma cpia do arquivo adicionada pasta do projeto. Alm disso, quando voc remove um arquivo, voc exclui o arquivo fisicamente.

Os projetos so agrupados em solues, que podem conter at projetos de linguagens diferentes. No Visual Studio .NET, os arquivos de projeto (.vbproj, .csproj, etc) e os arquivos de soluo (.sln) esto no formato XML.

Breve Introduo aos Diferentes Tipos de Projeto Na tela inicial do Visual Studio, quando voc seleciona File > New, voc j possui alguns tipos diferentes de opes a seguir:

Project

Web Site

Ambos referem-se a projetos. Entretanto, o primeiro grupo corresponde aos projetos aplicados a solues desktop, e o segundo grupo aos projetos desenvolvidos para Internet. Essa separao foi introduzida apenas na verso 2005.

Ao selecionarmos uma das opes (Project ou Web Site), ser exibida uma tela na qual poderemos visualizar os outros tipos de projetos disponveis.


21

Ao selecionarmos File > New > Project, visualizamos a tela acima. Em Project types, podemos ver os tipos de projeto disponveis agrupados por categoria (por exemplo, Linguagem, ou se aplicao Windows ou para Smart Devices).

Se quisermos criar uma soluo em branco, devemos selecionar Other Project Types > Visual Studio Solutions > Blank Solution. Isso ir criar uma soluo em branco. A partir desta, poderemos adicionar novos projetos no futuro.

Entretanto, quando criamos um novo projeto, uma soluo automaticamente criada, com o mesmo nome da soluo que voc criou.

Alguns tipos de projeto disponveis:

Blank Solution Como o nome diz, cria uma soluo em branco.

Windows Application Cria uma aplicao executvel, que usa como interface formulrios Windows (Windows Forms).

Console Application Cria uma aplicao executvel, que usa como interface a linha de comando.

Class Library Cria um projeto que ser compilado em uma biblioteca (DLL) de classes.


22

Windows Control Library Cria um projeto que abriga uma biblioteca (DLL) de controles que podem ser adicionados aos formulrios Windows.

Windows Service Cria uma aplicao executvel que roda como um servio no Windows.

Device Application Cria uma aplicao executvel, desenvolvida para dispositivos compactos.

Setup Project Cria um instalador para outras aplicaes.

Setup Wizard Cria um instalador para outras aplicaes, utilizando um Wizard de aplicaes.

Visual Studio Add-In Permite desenvolver aplicativos que iro customizar o ambiente do Visual Studio.

Test Project Cria um projeto que executa testes na sua aplicao.

Alm disso, em File > New > Web Site, temos os seguintes projetos:

ASP.NET Web Site Cria um projeto de um web site, utilizando ASP.NET.

ASP.NET Web Service Cria um projeto de um web service, utilizando ASP.NET.

Estes so apenas alguns exemplos de projetos disponveis. Alm disso, alguns plug-ins para o Visual Studio instalam outros templates de projeto.

Explorando as Janelas

Solution Explorer A janela Solution Explorer permite visualizar a estrutura de arquivos de nossa soluo, os projetos contidos nesta, e os arquivos contidos em cada projeto.

Para facilitar a programao, ela agrupa arquivos similares (como, por exemplo, o arquivo que representa a planilha e os arquivos de cdigo por trs desta) e oculta os que no fazem parte da soluo.


23

Toolbox Esta janela utilizada em modo de design, e agrupa todos os controles que podem ser adicionados ao seu projeto. Basta arrastar um controle para o design, para que o cdigo produzido pela insero desse controle seja automaticamente gerado.

Properties Nesta janela, voc pode alterar as propriedades de controles, formulrios, pginas etc, em modo de Design. Alm disso, voc pode verificar os eventos acionados por cada controle.


24

Server Explorer Esta janela permite gerenciar diversos recursos, como conexes de dados, o event log do Windows, filas de mensagem, lista de servios, etc.

Como a ToolBox possui uma abordagem Drag-and-Drop, permite voc inserir objetos em modo de design, inserindo em seu projeto objetos que permitem se comunicar com os recursos do sistema.

Task List Permite ao desenvolvedor visualizar comentrios e tarefas, deixados por ele mesmo ou por outro desenvolvedor.

Para criar um comentrio, basta usar a seguinte sintaxe:

// TODO: Implementar acesso de usurio.

Todos os desenvolvedores que abrirem a Task List, vero que na linha x do arquivo y, existe este comentrio.


25

Output Na janela Output mostrada a sada do console. Ali possvel ver no s o progresso da compilao, mas tambm todas as mensagens que so enviadas ao console como, por exemplo, System.Console.Write().

Error List Nesta janela, possvel verificar erros, warnings e mensagens geradas pelo compilador durante a compilao de nosso cdigo.

Lab: Navegando na IDE Vamos comear a explorar a IDE do Visual Studio, criando um novo projeto e uma soluo.

Abra o Visual Studio 2005. Em File > New, selecione a opo Project. Em Project Types, selecione Visual C# > Office. Em Project Templates, selecione Windows Application.


26

Devemos dar um nome para a nossa aplicao.

Na caixa Name, escreva WindowsApplicationCS, em Location, digite C:\LabVS, e em Solution Name deixe o nome proposto.

Como no estaremos trabalhando com controle de verso, deixe a caixa Add to Source Control desativada. Entretanto, deixe a caixa Create directory for Solution ativada (ele ir criar uma pasta para a Soluo, separada da pasta do projeto). Clique em OK.

A estrutura criada pelo projeto no disco ficou da seguinte forma:

Voltando agora ao Visual Studio, abra a janela ToolBox, expanda All Windows Forms, e arraste um controle do tipo Button da ToolBox para a planilha.


27

Clique com o boto direito no boto, e selecione Propriedades. Na janela de propriedades, busque e altere os seguintes campos:

Campo Valor

(Name) btnHelloWorld Text Hello World!

Feito isso, clique 2 vezes no boto. No evento que trata o click do boto, escreva o seguinte trecho de cdigo:

MessageBox.Show("Hello World!");

Agora, voc deve ter o seguinte trecho de cdigo:

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

private void btnHelloWorld_Click(object sender, EventArgs e) { MessageBox.Show("Hello World"); } } }

Rode sua aplicao, clicando no cone . A sua aplicao ser executada, e voc ver o formulrio. Clique no boto.

Grave as alteraes efetuadas, e feche o Visual Studio.


28

Reviso Esperamos, neste ponto, que o leitor tenha se familiarizado com a interface do Visual Studio 2005, e seja capaz de criar um novo projeto. O projeto criado nessa sesso ser utilizado como base nas sesses seguintes.


29

Captulo 4 Linguagem C#

Declarao de Variveis No C# as variveis so declaradas ao longo do cdigo e o tipo vem antes do nome da varivel.

Dessa forma, temos:

C#: int a; string b;

Case Sensitive O C# case sensitive. O que isso significa? Vejamos um exemplo:

int teste = 0; int Teste = 0;

...neste caso, as variveis teste e Teste so duas variveis diferentes!

Alm disso, supondo que temos uma varivel carro...

string carro;

...no podemos acess-la como Carro, CARRO, etc. O nico modo de acess-la atravs de:

carro = 2;

Tipos de variveis O Common Type System (CTS) define como os tipos so declarados, utilizados e gerenciados em tempo de execuo, e tambm uma parte importante do suporte do runtime de intregrao entre linguagens.

O CTS realiza as seguintes funes:

Estabelece um framework que auxilia a integrao entre linguagens, segurana de tipos, e alta performance de execuo de dados;


30

Prov um modelo de orientao de objetos que suporta a implementao completa de muitas linguagens de programao.

Define as regras que as linguagens devem seguir, o que ajuda a garantir que objetos escritos em diferentes linguagens possam interagir entre si.

Os principais tipos existentes no C# esto contidos na tabela abaixo. Na tabela, os valores entre parnteses representam as classes bases do tipo. Quando no houver um valor entre parnteses, indica que o nome da classe o mesmo do nome do tipo do C#.

Categoria Tipo do C# Alocao Memria

Range valores

Booleano Bool Depende plataforma

True ou False.

byte 1 byte 0 a 255 (sem sinal). sbyte 1 byte -128 a 127 (com sinal). No

compatvel com a CLS.

short (Int16) 2 bytes -32.768 a 32.767 (com sinal).

int (Int32) 4 bytes -2.147.483.648 a 2.147.483.647 (com sinal).

long (Int64) 8 bytes -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807 (com sinal).

ushort (UInt16) 2 bytes 0 a 65.535 (sem sinal). uint (UInt32) 4 bytes 0 a 4.294.967.295 (sem

sinal).

Inteiro

ulong (UInt64) 8 bytes 0 a 18.446.744.073.709.551.615 (sem sinal).

Ponto Flutuante float 4 bytes -3.4028235x1038 a -1.401298x10-45 para valores negativos;

1.401298x10-45 a


31

3.4028235x1038 para valores positivos.

decimal 16 bytes Um decimal de 128-bits, representando valores variando de 1.0x10-28 a 7.9x1028, com 28-29 dgitos significantes.

double 8 bytes -1.79769313486231570x10308 a -4.94065645841246544x10-324

para valores negativos;

4.94065645841246544x10-324

a 1.79769313486231570 x10308 para valores positivos.

char 2 bytes Um caracter unicode de 16-bits.

DateTime 8 bytes Um tipo que representa um valor de data e hora. Ele armazena os valores em incrementos de 100 nanosegundos de tempo passado desde 12:00 AM de 1/1/1 do calendrio Gregoriano.

IntPtr Um inteiro com sinal cujo tamanho varia de acordo com o sistema (32-bits em um plataforma 32-bits, e 64-bits, em uma plataforma de 64-bits).

Outros

UIntPtr Um inteiro sem sinal cujo tamanho varia de acordo com o sistema (32-bits em um plataforma 32-bits, e 64-bits, em uma plataforma de 64-bits). No compatvel com CLS.

Objetos Object 4-bytes em plataforma 32-

bits;

8-bytes em

A raiz da hierarquia de objetos, qualquer tipo pode ser adicionado em um tipo objeto.


32

plataforma 64-bits.

string Varia Uma string de tamanho fixo de caracteres unicode.

Os tipos bsicos esto contidos na biblioteca System (veremos bibliotecas nos captulos seguintes).

Marcadores de bloco e finalizadores No C#, o marcador de bloco so as chaves ( { e } ) e as sentenas so terminadas com ponto-e-vrgula.

C#: { a = 10; b = 11; c = a + b; }

Smbolos e operadores lgico-aritmticos Como pode ser observado no exemplo acima, o operador de atribuio do C# o sinal de igual. A tabela abaixo lista smbolos e operadores:

Smbolo/operador C#

Atribuio =

Igual (Comparao) ==

Diferente (Comparao) !=

And lgico &&

Or lgico ||

Not lgico !

Incremento x++


33

Decremento x--

If...else No C#, a condio comparada sempre deve vir dentro de parnteses e, por isso, existe um delimitador que informa aonde comea uma condio e aonde ela termina.

Assim sendo:

C#: if (x > 7) y = x 6; else { y = x; }

Laos While O while, seguindo a mesma idia de colocar a condio dentro de parnteses:

C#: while (x > 7) x++;

Laos for Os laos for nada mais so um lao while aonde possvel:

declarar/inicializar uma varivel contadora;

verificar uma condio de sada;

incrementar/decrementar a varivel contadora.

Como exemplo de cada uma dessas funcionalidades, temos:

for (int i =0 ; i


34

Laos do...while O lao do..while, vale para a mesma regra para a condio de loop do while: a condio deve estar entre parnteses.

C#: exit = false; do { a = a + 1; if (a > 99) exit = true; } while (! exit);

Switch..Case A instruo Switch..Case do C#, agrega vrias comparaes simples, poupando o desenvolvedor de usar vrios if encadeados:

C#: switch (i) { case 1: Opcao = "1 prestao"; break; case 2: Opcao = "2 prestaes";break; case 3: Opcao = "3 prestaes";break; default Opcao = "Pagamento no ato";break; }

Algumas observaes importantes sobre o switch:

todas as opes devem terminar com break ou goto;

no possvel trabalhar com intervalos;

o switch aceita usar strings no case.

Loop foreach uma alternativa interessante e muito usada para iterar por listas, colees ou vetores: com o foreach no necessrio buscar dados de tamanho e ndice inicial para que possa ser feito um lao for trivial. O foreach se encarrega de controlar


35

esses dados, deixando o desenvolvedor livre para implementar outras funcionalidade sem se preocupar com o controle desse loop.

O exemplo abaixo ilustra o seu uso:

static void Main(string[] args) { foreach (string str in args) Console.WriteLine(str); }

A declarao static void Main usada em C# para indicar que aquela a funo a ser chamada quando o programa for iniciado. string[] args o vetor dos argumentos de linha de comando.

A funo acima itera por cada argumento de string[] args. A cada iterao, o valor correspondente do vetor armazenado na varivel str e impressa na sada do console.

Vetores (arrays) Os vetores no C# so declarados junto com a varivel e tm sempre ndice inicial zero. As diferentes formas de declarar so:

C#: int[] pontos; int[10] outrosPontos; int[,] plano;

Funes No C# tanto procedures como functions so funes, e so diferenciadas pelo tipo do retorno: se forem void, as funes so tratadas como procedures, se tiverem qualquer outro tipo, so tratadas como functions. Por exemplo:

C#: void Executa(int codigo); double Calcula(int Codigo, double passo);


36

Estrutura de um programa C# No C# o desenvolvedor no fica restrito s reas de declarao: variveis e mtodos podem ser declarados ao longo do cdigo, e no em uma seo especfica. O desenvolvedor pode declarar no incio as variveis e se disciplinar para isso, mas a linguagem no o obriga a tal.

A seo using do C#, deve vir sempre no incio do cdigo.

using System;

public class MinhaClasse {

public int MinhaFuncao(int Entrada); // s a assinatura, implementada abaixo

public void MinhaProcedure() { // implementao }

public int MinhaFuncao(int Entrada) { // implementao }

}

Converso de tipos (cast) No C# deve ser usada a notao abaixo para a conveso:

() varivel

Sendo assim:

public int SomaInteiros(Double par1, par2) { return (int)par1 + (int)par2; }

Para converter para strings, pode ser usado o mtodo ToString:

public string SomaInteiros(Double par1, par2) { int soma soma; soma = (int)par1 + (int)par2 return soma.ToString(); }


37

Strings As Strings do .NET merecem ateno especial. As novas strings so Unicode, e ocupam 2 bytes a cada caractere.

Ao concatenar uma string com outra, obtemos uma nova string. Por conta disso, o .NET foi aparelhado com a classe StringBuilder, contida na biblioteca System.Text. (falaremos mais sobre classes e bibliotecas nos prximos captulos).

A classe StringBuilder deve sempre ser usada em casos na qual existam mltiplas concatenaes. Por exemplo:

StringBuilder sb = new StringBuilder(); string strFrase; sb.Append("A "); sb.Append("ligeira "); sb.Append("raposa "); sb.Append("marrom "); sb.Append("ataca "); sb.Append("o co preguioso."); strFrase = sb.ToString();

Nota No C#, como j foi falado na seo de converses, todos os tipos implementam um mtodo chamado ToString. Este mtodo, quando executado, retorna o dado no formato de string, de acordo com o tratamento dado pelo tipo.

int var1 = 2; string str = var1.ToString(); // O mesmo que str = 2

Reviso Vimos nesse captulo, as principais caractersticas na sintaxe da programao do C#. Iremos, nos captulos seguintes, nos aprofundar nos conceitos de Orientao a objetos.


38

Captulo 5 Orientao a Objetos com C#

Objetivos A linguagem C# foi criada a partir do zero no surgimento do .NET. A Microsoft optou por basear a sua nova linguagem nos conceitos de programao orientada a objetos (OOP), disponveis nas mais modernas linguagens de programao. O objetivo deste captulo apresentar alguns desses conceitos para o leitor (aplicados ao C#), para que seja possvel aproveitar ao mximo o potencial dessa linguagem.

Conhecer a Orientao a Objetos uma das tarefas que qualquer desenvolver que ainda no conhece deve fazer. Apesar do C# no obrigar o desenvolvedor a programar usando OOP, ele estar limitando o seu potencial.

O assunto de Orientao a Objetos, por si s, j valeria um livro exclusivo e dedicado. No est no escopo desta Apostila explicar em mincias as tcnicas de orientao a objetos, mas sim mostrar em linhas gerais o que e como empregada.

A seguir veremos como so implementados os conceitos de OOP no Visual C#.

Viso Geral A Orientao a Objetos foi criada em meados da dcada de 70, mas s se popularizou ao final da dcada de 90.

A Orientao a Objetos um paradigma que aproxima o modo como enxergamos o mundo real com o modo de programarmos. A programao procedural, realizada at ento, tinha como foco a codificao de problemas em uma forma de script, com comeo, meio e fim determinados, contendo em seu interior desvios, loops e verificaes condicionais.

J a Orientao a Objetos foca na estrutura dos objetos envolvidos no problema e sua relao entre eles. O cdigo procedural fica confinado internamente e altamente fragmentado em relao outra tecnologia.


39

As maiores vantagens da Orientao a Objetos so:

Um sistema OO bem projetado reduz significativamente o custo de manuteno e permite distribuir melhor os trabalhos por uma equipe.

Permite melhor compreenso do problema por parte do programador e do analista de negcios.

Torna mais fcil a reutilizao e a componentizao do cdigo.

H tambm desvantagens que devem ser levadas em conta:

um novo paradigma a ser descoberto.

Requer prtica para arquitetar solues.

Classes e Objetos Classes so esqueletos ou plantas que especificam objetos. Objetos so entidades que representam entidades do mundo real.

Um exemplo rotineiramente estudado em livros a classe Carro. Um carro pode ter caractersticas (como cor, nmero de portas, tipo de pneus, potncia do motor, etc) que chamaremos de atributos - e aes (acelerar, frear, abrir porta, acionar o limpador de pra-brisas, etc) que chamaremos de mtodos.

Note que, apesar de terem valores diferentes (como, por exemplo, cor diferente), o conjunto de atributos e mtodos citados comum maioria dos automveis. Ou seja, existe um conjunto de caractersticas que define o que um carro, uma planta. A esse conjunto de caractersticas, damos o nome de classe.

Quando os mecnicos da fbrica de automveis montam um carro (ou seja, fazem uma implementao fsica do que est contido no papel), ele deixa de ser apenas um modelo, apesar de ainda compartilhar caractersticas com outros carros. Ele passa a ser um objeto, algo fsico, no qual podemos entrar e andar por a.

Em programao, quando criamos uma instncia de uma classe em memria, como se estivssemos utilizando a classe como planta para criar um objeto fsico.


40

Voltando ao exemplo da classe carro, quando instanciamos em memria a classe, dando-lhe atributos como cor = verde, numeroDePortas = 4, tipoDePneus = asfaltoComum, etc, ela se tornou um objeto, que a instncia de uma classe.

Vamos comear o nosso exemplo criando uma classe que representa uma porta:

class Porta { ...

}

Agora que criamos a classe porta, como fazemos para criar um objeto do tipo Porta?

Porta porta = new Porta();

Com isso, temos que a varivel porta contm uma referncia para um novo objeto do tipo Porta. Nas sees seguintes, veremos como criar atributos, propriedades e mtodos em uma classe.

Atributos e Propriedades Atributos so definidos em uma classe, e guardam valores ou referncias. Normalmente, so expressas por substantivos que representam os atributos. No C#, os atributos correspondem s variveis. Vamos mostrar o seu funcionamento atravs de mais um exemplo.

class Casa { Porta porta = new Porta(); ...

}

O que temos aqui? Criamos uma nova classe Casa, e dentro dela adicionamos um atributo uma porta! Ou seja, toda casa que gerarmos a partir de nossa classe Casa ter uma porta mesmo que sejam portas diferentes.

No C#, uma propriedade nada mais do que um tipo especial de varivel que deve ser lida/escrita atravs de acessores. Isso feito da seguinte forma:

Porta PortaEsquerda { get { return portaEsquerda; } set { portaEsquerda = value; } }


41

Mtodos Mtodos so as aes que so definidas na classe. Normalmente so expressas por verbos que representam operaes que a classe permite executar.

Como exemplo, vamos implementar alguns mtodos em nossa classe Porta:

class Porta { string cor; bool fechada; bool trancada;

void Abrir() { if (! trancada) { fechada = false; } }

void Fechar() { if (! fechada) { fechada = true; } }

void Trancar() { if (fechada) { trancada = true; } }

void Destrancar() { trancada = false; }

bool VerifTrancada() { return trancada; }

void MudarCor(string novaCor) { cor = novaCor; } }


42

Como pode ser visto no exemplo, existe uma nica forma para se declarar um mtodo:

[] [] ([]) { ...

}

Falaremos sobre nveis de acesso ainda neste captulo. A lista de parmetros deve obeceder seguinte estrutura:

[ref|out] [, ]

A palavra chave ref, indica que o parmetro ser passado por referncia. Um argumento passado por referncia precisa antes de tudo ser inicializado.

J a palavra chave out, indica que esse parmetro um parmetro de sada o seu valor no ser utilizado no cdigo.

Para facilitar a compreenso das diferenas entre passar um valor por parmetro ou por referncias, veremos o exemplo de um mtodo que recebe o comprimento e a largura, e retorna a rea do quadrado:

double CalculaArea( double comprimento, double largura ) { // Declarando variveis locais. double area;

if( comprimento == 0 || largura == 0 ) { // Se um argumento = 0, no d para calcular a rea. area = 0; } else { // Calcula a rea do retangulo. area = comprimento * largura; } return area; }

New Keyword No C# quando queremos declarar uma varivel que aponta para uma classe fazemos da seguinte forma:

Util util;


43

...e quando queremos inicializar a nossa varivel com uma nova instncia, utilizamos palavra chave New:

util = new Util();

Por fim, todas as classes herdam de Object.

Construtores e Destrutores E se voc precisar criar uma classe que, durante a inicializao de um novo objeto, precise executar algum cdigo? Ou precisar rodar comandos de limpeza, antes de o objeto ser destrudo?

No C#, como no Delphi, existe o conceito de contrutores e destrutores.

Um construtor acionado, caso exista, quando utilizamos palavra chave New:

util = new Util();

Vamos ver um exemplo. Imagine novamente o caso da porta:

class Porta { string cor; bool fechada; bool trancada; ...

}

Vamos agora imaginar que gostaramos de ter uma classe Porta que permitisse que, em sua inicializao, fossem atribudos valores s propriedades fechada e trancada.

Para isso, vamos utilizar um construtor. O formato da declarao do construtor semelhante declarao de um mtodo, com a diferena que no aceita tipo de retorno e que deve possuir o mesmo nome da classe. Assim sendo, em nosso caso teramos:

Porta( bool fechada, bool trancada ) { if( fechada ) { Fechar(); } else { Abrir(); }


44

if (trancada) { Trancar(); } else { Destrancar(); } }

Quando um objeto no mais necessrio, o Garbage Collector chama o mtodo Finalize para aquele objeto antes de liberar a memria. O mtodo Finalize chamado destrutor, porque ele realiza tarefas de limpeza, tais como gravar informao de estado, fechar arquivos e conexes com bancos de dados, alm de outras tarefas que precisam ser feitas antes de liberar o objeto.

No C#, os destrutores no podem ser chamados eles so disparados automaticamente pelo GC. Entretanto, devido caracterstica no-determinstica do GC, no possvel saber exatamente quando o destrutor ser acionado.

Vamos agora utilizar um destrutor para mudar o valor das variveis fechada e trancada para false, antes de podermos destruir esse objeto da memria.

~Porta() { trancada = false; fechada = false; }

Lab: Trabalhando com Classes Vamos trabalhar com classes.

Abra o Visual Studio 2005. Abra o projeto WindowsApplicationCS que criamos anteriormente.

Remova o boto Hello World, e adicione 6 botes:

(Name) Text btnAbrePortaEsquerda Abre Esq.

btnFechaPortaEsquerda Fecha Esq.

btnAbrePortaDireita Abre Dir.

btnFechaPortaDireita Fecha Dir.


45

btnAcelera Acelera

btnFreia Freia

Agora, adicione 3 controles Label, com os seguintes textos:

Porta Esquerda:

Porta Direita:

Velocidade:

Por fim, adicione mais 3 controles do tipo Label, com os seguintes IDs:

lblPortaEsquerda

lblPortaDireita

lblVelocidade

Voc deve ter algo do gnero:

Agora que a parte grfica de nossa aplicao est pronta, vamos implementar o cdigo. Adicione ao seu projeto uma classe Porta (clique com o boto direito no seu projeto, e selecione Add>New Item, selecione Class, e d o nome Porta.cs).

Em sua classe, implemente:

Atributo fechada indica se a porta est fechada;

Atributo trancada indica se a porta est trancada;


46

Mtodo Abrir permite a abertura da porta;

Mtodo Fechar permite o fechamento da porta;

Mtodo Trancar permite trancar a porta, caso esta esteja fechada;

Mtodo Destrancar destranca a porta, caso esteja trancada;

Mtodo VerifFechada retorna indicador se a porta est ou no fechada;

Mtodo VerifTrancada retorna indicador se a porta est ou no trancada;

Construtor recebe como parmetro se a porta est fechada e trancada.

At este momento, o cdigo utilizado idntico ao dos nossos exemplos. Vamos agora mudar um pouco. Crie uma nova classe, chamada Carro.

Como todo carro tem pelo menos 2 portas, iremos adicionar ao nosso carro 2 atributos do tipo Porta (j criado no comeo desse lab), e cham-los de portaEsquerda e portaDireita. Adicione tambm um atributo chamado velocidade, que deve ser capaz de receber um valor inteiro.

No construtor da classe, inicialize ambas as portas como abertas e destrancadas, e a velocidade em 0.

Agora, crie 2 propriedades, PortaEsquerda e PortaDireita, que iro prover acesso aos atributos respectivos.

Por fim, iremos adicionar os seguintes mtodos:

Acelera(valor) Aumenta velocidade do carro, em incrementos de 10, at 180 Km/hora. Se passar de 180, atribui 180 e retorna um indicador, indicando que a velocidade mxima foi atingida.

Freia(valor) Diminui a velocidade do carro em valor, em decrementos de 10, chegando ao mnimo de 0. Se for menor que 0, retorna um indicador que o carro j est parado.


47

VelocidadeAtual() Retorna um inteiro, indicando a velocidade atual do carro.

Grave as alteraes. Nesse ponto, o nosso cdigo est pronto. Vamos agora ligar o formulrio com o cdigo.

Clique 2 vezes sobre o formulrio, em uma regio aonde no haja nenhum boto ou label. O Visual Studio ir abrir o modo de cdigo, e criar automaticamente um evento Form1_Load. Esse evento ser executado antes do Form ser mostrado para o usurio.

Entretanto, como queremos definir o carro como global, precisamos declar-lo fora do mtodo. Ento, logo acima da declarao do Form1_Load, declare e inicialize uma varivel do tipo Carro.

Agora, crie um mtodo chamado ShowResults, que ir atualizar as labels lblPortaEsquerda, lblPortaDireita e lblVelocidade com os valores corretos. No evento Form1_Load, execute o mtodo ShowResults.

Volte agora para o modo de exibio. Clique em cada um dos botes, e implemente a lgica correspondente. No se esquea de chamar o mtodo ShowResults, para atualizar os dados na tela para o usurio. Por fim, caso a velocidade caia abaixo de 0, ou passe do limite, mostre uma mensagem na tela para o usurio.

A soluo para este laboratrio est contida no CD.

Nveis de Acesso e Visibilidade Existem propriedades e mtodos que, de alguma forma, devem ficar restritos classe. Por exemplo, flags que mostram se a porta est trancada ou destrancada podem ficar ocultos ao exterior, e um usurio usaria uma funo VerifTrancada() para saber se a porta est trancada (se a funo retornar True) ou se ela est destrancada (se a funo retornar False).

Para isso, encapsula-se partes do contedo de forma a permitir que outras classes enxerguem propriedades e mtodos. Fazemos isso atravs do controle dos nveis de acesso.


48

O nvel de acesso de um elemento determina que cdigo possui permisso para ler e executar o elemento. Cdigo que no pode acessar um elemento, no pode acessar qualquer elemento contido dentro dele, mesmo que os elementos internos tenham um nvel de permisso maior do que o elemento externo.

Public O nvel de acesso Public especifica que o elemento acessvel a partir de qualquer lugar dentro do mesmo projeto, de outros projetos que referenciam o projeto que o contm, ou de qualquer assembly construdo a partir do projeto. Exemplo:

public class Porta

Private O nvel de acesso Private especifica que os elementos somente so acessveis dentro do mesmo contexto (mdulo, classe ou estrutura) no qual foram declarados. Exemplo:

private string cor;

Protected Voc s pode utilizar Protected em nvel de Classe (dentro de uma). Protected especifica que o elemento acessvel apenas dentro da prpria classe, ou por classes derivadas desta.

public class Ambiente { protected class Animal { ...

}

protected class Leo : Animal { ...

} }

A classe derivada de uma outra classe deve possuir um nvel de acesso menor ou igual classe pai.


49

Internal O nvel de acesso Internal especifica que os elementos sero acessveis de dentro do mesmo Assembly, mas no fora dele. Um exemplo de declarao:

internal string mensagem;

Protected Internal possvel utilizar ambos os nveis de acesso Protected e Internal juntos em uma declarao para especificar que um elemento acessvel ou de classes derivadas, ou de dentro do mesmo assembly.

protected internal string mensagem;

Resumo dos Nveis Acesso Nvel de acesso Elementos a que se aplica Contexto

Public Qualquer cdigo que pode visualizar um elemento pblico pode acess-lo.

Interfaces; Mdulos; Classes; Estruturas; Propriedades; Atributos (internos); Constantes; Enums; Eventos; Declaraes Externas; Delegates.

Arquivo; Namespace; Interface; Mdulo; Classe; Estrutura.

Private Cdigo dentro do mesmo contexto pode acessar.


Mdulo; Classe; Estrutura.

Protected Cdigo dentro da classe, ou de uma classe que herda desta podem acessar.

Interfaces; Classes; Estruturas; Propriedades; Atributos (internos); Constantes; Enums; Eventos; Declaraes Externas; Delegates.

Classe.

Internal Cdigo dentro do mesmo assembly.


Arquivo; Namespace; Interface; Mdulo; Classe; Estrutura.

Protected Internal

Cdigo dentro da mesma classe ou mesmo assembly, ou qualquer classe derivada da classe aonde o elemento est contido.

Interfaces; Classes; Estruturas; Propriedades; Atributos (internos); Constantes; Enums; Eventos; Declaraes Externas; Delegates.

Classe.


50

+Abrir()

+Fechar()

+Trancar()+Destrancar()

+VerifTrancada() : Boolean

+cor : Integer

-tipoTrinco : String

#fechada : Boolean

#trancada : Boolean

PortaPortaPortaPorta

Encapsulamento Existem atributos e mtodos que, de alguma forma, devem ficar restritos classe. Por exemplo, flags que mostram se a porta est trancada ou destrancada podem ficar ocultos ao exterior, e um usurio usaria uma funo VerifTrancada() para saber se a porta est trancada (se a funo retornar True) ou se ela est destrancada (se a funo retornar False).

Para isso, encapsula-se partes do contedo de forma a permitir que outras classes enxerguem propriedades e mtodos. Fazemos isso, controlando os nveis de acesso.

Notao UML A notao UML (de Unified Modeling Language) um conjunto de diagramas que permitem que um analista especifique um sistema usando modelos-padro adotados pelo mercado. No escopo deste curso explicar cada um dos diagramas e seus componentes (isso tarefa para um curso de pelo menos 40 horas !), mas convm aqui mostrar como uma classe mostrada em um diagrama de classes, que comumente visto na literatura:

Esse desenho corresponde representao UML da classe abaixo:

public class Porta { public int cor; private string tipoTrinco; protected bool fechada; protected bool trancada;

public void Abrir() { if (! trancada) { fechada = false; }


51

}

public void Fechar() { if (! fechada) { fechada = true; } }

public void Trancar() { if (fechada) { trancada = true; } }

public void Destrancar() { trancada = false; }

public bool VerifTrancada() { return trancada; } }

Na notao UML, uma classe representada por um retngulo dividido em trs partes. Na parte superior, ficam o nome da classe. Na parte central, as propriedades, na parte inferior, as aes.

Propriedades e mtodos pblicos so indicados com um sinal de (+) na frente do nome. Propriedades e mtodos privados so representados com um sinal de (-) na frente do nome. Por fim, propriedades e mtodos protected so representados com um sinal de (#).

Herana O conceito de herana largamente utilizado na orientao a objetos. Atravs desse conceito, uma classe pode herdar o que j especificado em outra classe. Diz-se ento que uma classe-filha est herdando de uma classe-pai ou uma super-classe.

Vamos supor que estamos desenvolvendo um sistema para uma empresa que comercializa portas de todos os tipos e formas. Existem atributos e aes que so especficas de qualquer porta:

- atributos: material, cor, tipo de fechadura, tipo de trinco, altura, largura, profundidade, peso, etc;


52

- aes: abrir, fechar, trancar, destrancar, etc.

Essa classe atende boa parte das portar que a empresa comercializa. Mas existem tipos de portas especiais que, alm de terem as mesmas caractersticas da classe Porta, adicionam outras caractersticas novas. Mais ainda, existem portas que precisam de procedimentos modificados.

Um exemplo a porta de cofre. A porta de cofre, alm de ter as caractersticas de uma porta tradicional, ainda precisa de um segredo para ser aberta junto com a chave e o trinco.

Ao invs de reescrever uma classe PortaDeCofre inteira, o mais fcil fazer com que essa classe herde todas as caractersticas de Porta, mas adicione algumas propriedades e que sobrescreva a implementao de Destrancar(), uma vez que essa porta em especial precisa tratar tambm do segredo do cofre.

O diagrama UML ficaria assim:

Dessa forma, ao criarmos uma instncia de PortaDeCofre, se chamssemos PortaDeCofre.Abrir() ou PortaDeCofre.cor, no seria gerado erro: uma vez que PordaDeCofre herda de Porta, ao ser instanciado criada uma rea na memria com todo o contedo de porta e mais o contedo de PortaDeCrofre.

+ D e s t r a n c a r ( )- S e g r e d oP o r t a D e C o f r e

+ A b r i r ( )+ F e c h a r ( )+ T r a n c a r ( )+ D e s t r a n c a r ( )+ V e r i fT r a n c a d a ( ) : B o o le a n

+ c o r : In t e g e r- t ip o T r in c o : S t r in g# fe c h a d a : B o o le a n# t r a n c a d a : B o o le a n

P o r t a


53

A implementao de herana no VB.NET feita atravs da palavra-chave Inherits. O cdigo que representaria uma porta de cofre ficaria ento:

public class PortaDeCofre : Porta

importante notar que, no .NET, uma classe s pode herdar de 1 nica classe (existem algumas linguagens de programao que permitem o que chamado herana mltipla). Entretanto quando uma classe herda de outra, como se ela herdasse tambm de todas as classes pai da classe pai dela.

Ou seja, quando temos algo como:

public class Animal {}

public class Mamifero : Animal { }

public class Leao : Mamfero { }

A classe Leao acaba herdando da classe Animal indiretamente, na medida em que todo Leo um Mamfero, e todo Mamfero um Animal.

Todas as classes, em algum nvel, herdam do tipo Object, o tipo mais bsico do CTS. Quando no declaramos uma classe pai para a nossa classe, o compilador automaticamente faz com que a nossa classe herde de Object.

Classe Abstrata e Classe Selada Uma classe abstrata uma classe que no pode ser instanciada ela criada com o nico propsito de servir de pai para outras classes. Ou seja, voc no pode criar uma declarao usando New com uma classe do tipo abstrata.

No C#, o modificador abstract implementa uma classe abstrata:

public abstract class MinhaClasse { }

Uma classe abstrata pode conter mtodos abstratos ou no. Entretanto, uma classe no abstrata no pode conter mtodos abstratos.

Alm do conceito de classe abstrata, existe tambm o conceito de classe selada. Uma classe selada uma classe que no pode ser herdada ou seja, nenhuma classe pode derivar dela.

O C# implementa classes seladas atravs do modificador NotInheritable:


54

public sealed class MinhaClasse { }

Sobrescrita de Mtodos Sobrescrevermos um mtodo quando queremos substituir o mtodo original por uma outra implementao, especfica de uma classe filha.

No C#, temos duas opes para sobrescrever um mtodo: usando a palavra chave new, ou usando a palavra chave override.

A diferena entre os dois mtodos que no primeiro caso, estamos criando um novo mtodo com o mesmo nome e escondendo o membro original. Esse o comportamento padro, ou seja, no necessrio usar a palavra chave new, mas o compilador ir disparar um aviso, indicando a necessidade do new.

J no segundo caso, estamos estendendo a implementao para um membro herdado. Para que isso seja possvel, na declarao original do mtodo precisamos definir o mtodo com um dos seguintes modificadores: abstract, virtual ou override (o modificador virtual define apenas que uma classe pode ser sobrescrita).

No nosso exemplo da classe Porta, podemos sobrescrever o mtodo Destrancar(), uma vez que PortaDeCofre s pode ser aberta se o segredo que o usurio inseriu for o correto. Nosso mtodo, na classe PortaDeCofre, ficaria ento:

public override void Destrancar() { if (segredo == "cges") { base.Destrancar(); } }

Enquanto na classe Porta temos:

public virtual void Destrancar() { trancada = false; }

Note que usamos a instruo override para declarar que Destrancar() sobrescreve a implementao desse mtodo.


55

Sobrecarga de Mtodos Fazemos uma sobrecarga quando precisamos implementar um mtodo que deve receber um conjunto diferente de parmetros.

No nosso exemplo, podemos escrever um mtodo para abrir a porta, mas passando como parmetro o segredo da porta. O usurio ento teria outra opo para poder abrir a porta: ou ele atribui um valor propriedade Segredo e chama Destrancar(), ou ento ele chama Destrancar passando o segredo:

public void Destrancar(string segredo) { this.segredo = segredo; Destrancar(); }

Como possvel visualizar abaixo, quando voc acessa um mtodo que possui sobrecarga, mostrado ao desenvolvedor uma lista, com todos as possveis chamadas deste mtodo.

Acessando a classe pai base e this H situaes em que sobrescrevemos ou ocultamos membros da classe-pai. Como podemos indicar em nosso cdigo se mtodo que queremos usar o membro original (da classe-pai) ou a especializao (da classe filha)?

Quando estamos dentro de uma classe, o comando this permite indicar que usaremos o membro da classe em que estamos, e o comando base permite usar o membro a partir da classe-pai da qual estamos herdando.

Polimorfismo Vamos agora voltar a falar um pouco mais sobre classes.


56

Quando falamos sobre sobrecarga de mtodos, definimos uma classe filha da classe Porta a classe PortaDeCofre. Alm disso, mostramos como era possvel classe filha sobrescrever um mtodo da classe pai:

Classe PortaDeCofre:

public override void Destrancar() { if (segredo == "cges") { base.Destrancar(); } }

Classe Porta:

public virtual void Destrancar() { trancada = false; }

O que tudo isso de herana implica? Implica que a classe PortaDeCofre corresponde a um subgrupo do tipo Porta, e como tal possui caractersticas em comum com outras classes de porta (como PortaDeVidro). Quando estamos falando genericamente sobre Portas, uma PortaDeCofre pode ser usada como Porta.

A esse conceito, d-se o nome de Polimorfismo a capacidade de uma classe filha se passar por uma classe pai mesmo que, internamente, tenha mecanismos diferentes de funcionamento.

Por exemplo, podemos declarar uma varivel da seguinte forma:

No exemplo acima, vemos como uma varivel do tipo Porta pode receber uma varivel do tipo PortaDeCofre. Entretanto, nesse momento todas as caractersticas


57

externas que diferenciam um PortaDeCofre de uma Porta ficam ocultas afinal, no estamos trabalhando com uma PortaDeCofre, mas com uma Porta!

Entretanto, quando sobrescrevemos um mtodo, a classe filha passa a ter um funcionamento diferente da classe pai. O que ir ocorrer nesse caso?

Se pensarmos novamente na Porta e na PortaDeCofre, vemos que ambas funcionam de forma diferente. Como o funcionamento de uma Porta diferente do funcionamento de uma PortaDeCofre, quando chamarmos o mtodo Destrancar() estaremos chamando o mtodo da classe especializada (PortaDeCofre), ao invs do mtodo da classe pai. Apenas se a classe filha no tiver alterado a implementao, que ser chamado o mtodo da classe pai.

Lab: Trabalhando com Herana Vamos agora criar uma classe que represente um carro esportivo. Um carro esportivo corre muito mais rpido que um carro normal, mas ainda tem 2 portas.

Abra a soluo WindowsApplicationCS, desenvolvida anteriormente. Adicione uma nova classe CarroEsportivo. Essa nova classe deve herdar da classe Carro.

Na classe Carro, transforme a propriedade velocidade de private para protected, de forma que seja possvel alterar o seu valor a partir da classe filha.

Sobrescreva o mtodo Acelera, para permitir ao condutor acelerar at 250 Km/hora, e substitua a chamada para a classe Carro, por uma chamada classe CarroEsportivo. Rode a sua aplicao e verifique o que acontece quando voc acelera seu carro acima de 180 km/hora.

Para ver a resposta do exerccio, abra o Lab Trabalhando com Herana, do CD.

Interface Interfaces, como classes, definem um pacote de propriedades e mtodos. Entretanto, diferentemente de classes, interfaces no provm implementao.

Uma interface funciona como um contrato, no qual a classe que a implementa precisa implementar todos os aspectos definidos pela interface exatamente como definida.


58

A grande vantagem de interfaces, que apesar de uma classe s poder herdar de uma nica classe, ela pode implementar inmeras interfaces diferentes.

public interface IPessoa { public string GetNome(); }

public class PessoaFisica : IPessoa { private string nome;

public string GetNome() { return nome; }

...

}

Mtodos, Atributos e Propriedades Estticas Uma propriedade, um atributo ou um mtodo esttico podem ser vistos como uma caracterstica da classe e no do objeto. O que isso significa?

Lembra-se de quando falamos que, quando declaramos um objeto usando a palavra-chave New, estamos alocando um espao na memria onde os dados do objeto ficaro alocados? Um atributo esttico no fica armazenado nesse espao, mas sim fica armazenado junto com a definio da classe.

Isso significa que, todos os objetos criados a partir da classe iro acessar o mesmo dado.

Vamos considerar, como exemplo, a classe ContadorAcessos abaixo:

public class ContadorAcessos { public int conta = 0; public void SomaUm() { conta++; } public i

csharp formacao.net

Documents