Treinamento C# ASP - Net PI

Treinamento C#.
NET
Introdução
A Microsoft e a iniciativa .NET
A plataforma .NET
Em resumo, o .NET Framework é ambiente gerenciado com tipificação forte para o

desenvolvimento de aplicações e sua execução.
A plataforma .NET é a nova iciativa da Microsoft para prover um novo framework de
desenvolvimento com um nova API para serviços e API´s para os sistemas operacionais
Windows, especialmente o Windows 2000, trazendo a tona tecnologias que foram
emergentes nos anos 90 (COM+, ASP, XML, etc).
A Microsoft diz que 80% de seus recursos de desenvolvimento estão sendo aplicados no
.NET e suas tecnologias associadas. A plataforma consiste em 2 grupos de produtos
separados:
Um conjunto de linguagens (incluindo o C# e o Visual Basic.NET); Ferramentas de
desenvolvimento (Visual Studio.NET); Conjunto de classes comuns para serem usadas no
desenvolvimento de aplicações (Web ou Windows) e WebServices; E o CLR (Commom
Language Runtime) para a execução dos objetos construídos com o Framework.
Um conjunto de servidores corporativos (SQL Server, Exchange, etc) que vão
prover a funcionalidade específica para armazenamento em banco de dados, email,
etc.
Uma oferta de WebServices comerciais.
Novos dispositivos (Não apenas computadores) como celulares e video-games
com .NET
.NET FrameWork
O .NET Framework é um conjunto de componentes que permitem, além da

indepêndencia de linguagem, a integração. Desta forma o código implementado e
compilado usando o VB.NET pode ser reutilizado com todos os recursos (inclusive a
herança) por um código desenvolvido usando a nova linguagem C#. O .NET
FrameWork torna isso possível com o CTS (Commom Type System ou Sistema de Tipos
Comuns). Por exemplo, todos os objetos criado no usando o .NET Framework herdam de
um objeto comum (System.Object). O CTS suporta todo o conceito da classes,
interfaces e delegates (com suporte para CallBacks), tipos por referência e por valor.
Adicionalmente o .NET Framework incluí a CLS (Commom Language Specification ou
Especificação de Liguagem Comum) que determina um série de regras para a
integração das liguagens. O FCL (Framework Class Library) pode ser usado por qualquer
linguegem que atenda as estas regras.
O C#
O C# é a linguagem nativa do .NET Framework. Ela foi concebida preenchendo todos

os aspectos do .NET Commom Language Runtime.Você pode escrever o seu código
em C++ ou Visual Basic, mas o C# foi desenvolvido para o .NET Framework.
Além disso, o C# tem alguns recursos que são únicos dela. Como os comentários XML,
que permitem que uma documentação seja gerada partindo do código comentado
pelo desenvolvedor.
Quanto ao desempenho, todas as linguegns que rodam sobre o .NET Framework teriam
desempenho similar. A cada execução, os binários gerados são otimizados para
melhor desempenho. As variáveis (máquina processdor, quantidade de memória, etc)
são muitas para que se possa dizer que esta ou aquela linguagem é mais “otimizada”
ao rodar sobre o .NET Framework.
Componentes de Software
O .NET Commom Language Runtime é um ambiente baseado em componentes. Estes

componentes possuem todos os recursos necessários para que você utilize-os em seu
código.
No Visual Basic 6.0 era necessário que você utilizasse recursos da API Win32. Agora os
desenvolvedores que utilizam a plataforma .NET tem em suas mãos o conjunto de
classes da biblioteca System que encapsula boa parte desta API.
O código gerado (MSIL)
Ao compilar um fonte desenvolvido sobre a plataforma .NET não será gerado um

executável. Ao invés disso é gerado o código IL (Intermediate Language).
Esta etapa gera o que chamamos mais comumente de assemblies. Eles contem tudo
o que é necessário para que o Framework .NET consiga executar o código do
assemblie.
O código IL é ator o principal, mas dentro de um assemblie também existem os
metadados. Estes funcionam como os TypeLibrarys no mundo COM, porém mais
completos (contendo o nome dos objetos, todas as propriedades e seus tipos,
parâmetros e nomes de parâmetros).
Ao executar a aplicação, entra em ação o JIT (Just In Time) Compilation que compila o
código em liguagem nativa. A cada execução este compilador otimiza a execução
da aplicação.
Por isto, NÃO EXISTE diferença de performance entre as linguagens usadas com o .NET
Framework. A performance depende desta otimização.
Prática
O Hellow Universe
Inicialmente vamos construir o famoso Hello Universe. Este será contruído usando
apenas o .NET Framework.
A Microsoft adotou a mesma estratégia da Sun quando fez com que o .NET Framework
fosse gratuito como o Java. Você pode desenvolver com .NET usando apenas o bloco
de notas.
O Visual Studio é uma ferramenta que deve ser adquirida a parte. E engana-se quem
pensa que existe apenas ele para ser usado.
Para desenvolver com .NET você também pode usar:
* C# Builder (www.borland.com) - A vantagem deste é que se for apenas para estudo

a versão mais simples é grátis.
* SharpDevelop - Totalmente grátis, porém sua maior desvantagem é ainda ser um
beta. E por isso ter muitos problemas na iDE.
* Eclipse - O Eclipse é originalmente feito para desenvolvedores Java, porém usando
um plugin, é possível utiliza-o também para desenvolver com C#. A principal
desvantagem é não termos intellisense/autocomplete ( recurso onde a ferramenta
"sugere" parte de seu código) o que faz com que utilizemos o Eclipse apenas como
editor de código.
No bloco de notas do windows digite:
using System;
class Hello
{
public static void Main(string[] args)
{
Console.WriteLine("Hello, Universe");
// interagindo com argumento passados por parâmetro,
// (imprimindo-os)
for (int arg = 0; arg < args.Length; arg++)
Console.WriteLine("Arg {0}: {1}", arg, args[arg]);
}
}
b) Salve este arquivo na pasta c:\curso\aula1\primeiro\Hello.cs

c) Clique <Iniciar> <Executar> e digite cmd <ENTER>
d) Vá até a pasta onde o arquivo foi salvo e digite csc Hello.cs
e) Agora Digite Hello <ENTER>
Dica
Configurando o compilador do C#
- Pressione <Windows> + <E>

- Clique com o botão direito do mouse no driver C e clique pesquisar
- Digite csc.exe
- Clique com o botão direito no arquivo encontrado
- Selecione <Abrir pasta recipiente>
- Selecione o caminho onde está o arquivo e tecle <CTRL> + <C>.
- Clique <Iniciar> <Configurações> <Painel de Controle>
- Clique no ícone sistema
- Clicque na aba avançado
- Clique no botão <Variáveis de ambiente>
- Procure uma variável chamada PATH. Caso não exista crie uma.
- Em seu valor tecle ; e <CTRL> + <V>.
- Clique OK e OK.
Entendendo namespaces e using
Abra uma nova janela do bloco de notas e digite o programa abaixo
using System;
namespace TestesIniciais
{
class TesteInicial
{
static void Main(string[] args)
{
string strValor="";
int intValor1=0;
int intValor2=0;
int intResultado=0;
Console.WriteLine("Será efetuada uma soma");

Console.Write("Digite o primeiro número:");
strValor = Console.ReadLine();
intValor1 = Convert.ToInt32(strValor);

intResultado = intValor1 + intValor2;

Console.WriteLine("O resultado da soma eh:" + intResultado);
Console.Write("Pressione qualquer tecla para continuar");

Console.Read();
}
}
}
Salve este arquivo na pasta aula1\TesteInicial no arquivo TesteInicial.cs
Namespaces e Using
O comando Using serve para organizarmos as classes usadas em uma estrutura
hierarquica. O uso correto de namespaces soluciona o problema de usarmos 2 classes
com o mesmo nome, mas de diferentes autores.
O Namespace System (usado acima) é o principal namespace do .NET. Nele
encontram-se classes para controle de segurança, criptografia, threads, etc.
Resumindo, ao criar classes estas serão colocadas em namespaces que serão
chamados utilizando a palavra using ou a assinatura completa da classe.
Uma referencia no C# consiste apenas em dizer onde está um executável. Não existe
dependência entre referências (um objeto não deixará de ser instanciado por estar
nesta ou naquela DLL. Basta ter namespaces bem definidos).
O Console
O objeto Console possuí os métodos Write e WriteLine para escrever em tela. A
diferença entre os dois é uma quebra de linha colocada pelo método WriteLine.
Já com os métodos ReadLine e Read a diferença está na quantidade de caracteres
que poderão ser digitadas. O método ReadLine recebe tudo que for digitado até que
seja pressionado ENTER e retorna esta string para ser armazenada. Enquanto o método
Read recebe apenas uma tecla retornando seu código ASCII.
O objeto Convert
Este tem por objetivo fazer a conversão de tipos no .NET.
A linguagem C#
Tipos no C#
Existem dois grandes conjuntos de tipos no C#: tipos de valor e tipos de referência.
A diferença entre eles consiste na forma como os dados são armazenados na
memória. Os tipos de valor são armazenados em uma área chamada de pilha (stack).
Enquanto os tipos por referência são armazenados em uma área chamada monte
(heap).
A pilha(stack) mantém a execução do programa, como o fluxo de trabalho em um
restaurante. O último pedido que entra deve ser o primeiro a sair. Desta forma, cada
bloco de código com suas variáveis vai para a pilha de execução. Ao término do
mesmo, a área de memória usada é limpa.
Já o monte(heap) armazena seus dados aleatóriamente. O acesso é feito conforme
solicitação, não em uma ordem determinada. Este é o espaço usado para
armazenamento dos objetos criados em memória.
Abaixo está a tabela com os tipos de valor padrão do C#.
Tipo Tamanh Tipo . Descrição

o (bytes) NET
byte 1 Byte Valores sem sinal (entre 0 e 255).
char 1 Char Caracteres UNICODE
bool 1 Boolean true ou false
sbyte 1 SByte Bytes com sinal (-128 até 127)
short 2 Int16 Inteiros com sinal (entre -32.768 até 32.767)
ushort 2 UInt16 Inteiros sem sinal (entre 0 e 65.535)
int 4 Int32 Inteiros com sinal (entre -2,147,483,647 e 2,147,483,647).
uint 4 UInt32 Inteiros sem sinal (entre 0 e 4,294,967,295).
float 4 Single Valores com ponto flutuante (entre apoximadamente +/-1.5 * 10-45 e +/-
3.4 * 1038
double 4 Double Valores de ponto flutuante com dupla precisão (entre +/-5.0 * 10-324 e
+/-1.7 * 10308).
decimal 8 Decimal Precisão fixa de 28 dígitos do ponto decimal. Normalmente usada para
cálculos financeiros.
long 8 Int63 Inteiros longos (entre -9,223,372,036,854,775,808
e9,223,372,036,854,775,807).
ulong 8 UInt64 Inteiros long sem sinal (entre 0 e 0xffffffffffffffff).
Ao utilizar um dos tipos numéricos descritos acima, tenha em mente seu uso para
otimizar a memória usada por sua aplicação e também para garantir a integridade de
seus dados.
Por exemplo, ao criar uma classe chamada Cliente que vai manter a idade do cliente
a maioria dos programadores utilizaria um tipo int para isto. Quando poderia ser usado
um byte ou um short (pelo menos) e preferencialmente sem sinal (ushort ou ubyte) desta
forma, caso o usuário tentasse atribuir um valor negativo para a idade, o próprio
compilador retornaria erro.
Operadores lógicos e de atribuição mais usados
Abaixo estão os operadores mis usados no C#. Os operadores para operações bit-a-bit
não são citados neste manual.
Operadores de atribuição
Operador Finalidade
= Atribuir um valor para uma variável ou
objeto.
+= Identico a variável = variável + Valor
-= Identico a variável = variável + Valor
++ Idêntico a variável = variável + 1
-- Idêntico a variável = variável - 1
Operadores lógicos
Operador Finalidade
&& E
|| Ou
! Não
Comandos mais utilizados

Segue a relação com os comandos mais utilizados:
if
É o SE lógico.
Exemplos de uso:
sozinho
if ( [condição] )
comando / bloco (executado caso a condição seja verdadeira)
com else
if ( [condição] )
else
comando / bloco (executado caso a condição seja falsa)
outros
if ( [condição] )
else if ( [condição] )
comando / bloco (executados caso a condição seja verdadeira)
else
comando / bloco (executados caso as condições sejam falsas)
Prática
Crie o arquivo abaixo no bloco de notas e salve-o na pasta aula1\TesteIf com o nome
TesteIf.cs.
using System;
namespace TesteIf
{
/// <summary>
/// Teste do comando If.
/// </summary>
class TesteIf
{
/// <summary>
/// O método principal Main é o primeiro que será executado.
/// </summary>
[STAThread]
{
string strValor="";
string strOperador="";
int intValor1=0;
int intValor2=0;
int intResultado=0;
Console.WriteLine("Será efetuada uma operação");


Console.Write("Digite o operador desejado ( + , - , * , / ) :");

strOperador = Console.ReadLine();
if (strOperador == "+")
else if (strOperador == "-")
intResultado = intValor1 - intValor2;
else if (strOperador == "*")
intResultado = intValor1 * intValor2;
else if (strOperador == "/")
intResultado = intValor1 / intValor2;
else
Console.WriteLine("Informe uma operação válida. O resultado
será" + "zerado.");

Console.Read();
}
}
}
while
Usado para fazermos laços (repetição de código) condicionais.
Exemplos de uso:
bool blnValor = true;

int intValor = 0;
while (blnValor)
{
Console.WriteLine("Valor: " + n);
if (n>5)
blnValor = false;
n++;
}
for
Usado para fazermos laços (repetição de código) com um contador.
Exemplos de uso:
for (int intValor = 20; n--; n>0)

{
Console.WriteLine("Valor: " + n);
}
Prática
Usando o comando while e for.
using System;
namespace Comandos
{
/// <summary>
/// Teste dos comandos while e for.
/// </summary>
class Comandos
{
/// <summary>
/// </summary>
[STAThread]
{
int intValor1 = 0;
int intResultado = 0;
string strValor = "";

bool blnSair = false;
Console.WriteLine("Será exibida a tabuada dos números

selecionados");
while (!blnSair)
{
Console.Write("Digite um número:");
for (int x=0; x<=10; x++)

{
intResultado = intValor1 * x;
Console.WriteLine( x.ToString() + " X " +
intValor1.ToString() +
" = " + intResultado);
}
Console.Write("Deseja Sair (S/N)");

if (strValor == "s")
blnSair = true;
else
{
blnSair = false;
}
}
}
}
}
switch
Usado para testar múltiplos valores em uma variável.
Prática
using System;
namespace TesteSwitch
{
/// <summary>
/// Teste do comando switch.
/// </summary>
class TesteSwitch
{
/// <summary>
/// </summary>
[STAThread]
{
string strValor="";
int intValor1=0;
int intValor2=0;
int intResultado=0;



switch (strOperador == "+")

{
case "+":
break;
case "-":
case "*":
case "/":
default:
Console.WriteLine("Informe uma operação válida. O resultado será
zerado.");
break;
}

Console.Read();
}
}
}
foreach
Usado para fazermos laços (repetição de código) com em uma coleção/array de
objetos.
Prática
using System;
using System.Collections;
namespace TesteArrayList
{
/// <summary>
/// Teste do comando foreach e arrays.
/// </summary>
class TesteArray
{
/// <summary>
/// </summary>
[STAThread]
{
ArrayList arrNomes = new ArrayList();
//string[] astrNomes = {"João","Mário","Cremildo"};
string[] astrNomes = new string[3];
arrNomes.Add("Mário");
arrNomes.Add("João");
arrNomes.Add("Cremildo");
astrNomes[0] = "João";
astrNomes[1] = "Mário";
astrNomes[2] = "Cremildo";
foreach (string strNome in arrNomes)

{
Console.WriteLine(strNome);
}
foreach (string strNome in astrNomes)

{
Console.WriteLine(strNome);
}
Console.WriteLine("Pressione qquer tecla para continuar");

Console.Read();
}
}
}
2. Iniciando em ASP.NET
A WEB
A Internet de hoje foi desenvolvida por universidades para troca de conteúdo

(ARPANET - Advanced Research Projects Agency).
A Internet e a Web não são a mesma coisa. A Internet é um rede pública
baseada no protocolo chamado TCP/IP (Transmission Control Protocol/Internet Control)
para comunicação da dados. O que fazemos é utilizar a base deste protocolo para
criarmos outros protocolos para transmissão, como o HTTP (Hypertext Transmission
Protocol) para comunicação de dados.
A linguagem padrão na Internet é o HTML uma liguagem de marcações (TAGS)
que utiliza o protocolo HTTP.
O HTML permite uma fácil navegação entre as páginas que podem conter
texto ou imagens. Após algum tempo de uso foi agregado a ele o Javascript pela
Netscape.
O Java e o Javascript são linguagem diferentes para atender "mundos"

diferentes.
O Javascript permitiu a interação do browser com os dados da página sendo

exibida.
Foi criado tembém o CSS (Cascade Style Sheet) para definir o posicionamento
dos itens nas páginas (até então tudo era feito com porcentagens para atender a
todo tipo de browser). Ao Javascript foi adicionado o "objeto" style como um
agregado da maioria dos controles. A este conjunto chamamos DHTML ou HTML
dinamico.
Na mesma época em que estes itens foram consolidados, eram utilizados
executáveis feitos em diferentes linguagens (C, Pascal, Delphi e até VB) para termos
"processamento no servidor" em ambiente Windows. Já existiam linguagens com PHP
e PERL usadas no Unix, de onde o ASP da Microsoft foi baseado.
ASP.NET
O que é o ASP.NET então? Apenas uma evolução do ASP tradicional? A resposta é um

grande e sonoro NÃO. Veja abaixo algumas diferenças:
ASP ASP.NET
Interpretado Compilado/Interpretado
Tipificação Fraca Tipificação Forte
Dificuldade para usar componentes Componentes são utilizados facilmente
Prática
1. No Visual Studio, selecione <New Project>
2. Na lista à esquerda da janela que aparece, selecione <Visual C# Projects>
3. Na lista do lado direito, selecione <ASP.NET Web Application>
4. Indique o nome http://localhost/TesteASPNET
5. Será criado um novo projeto com o WebForm1.aspx selecionado.
6. Clique com o botão direto sobre o nome dete formulário no Solution Explorer e clique
em renomear.
7. Digite o nome TesteASPNET.aspx
8. Arraste para página o Controle Label da barra de ferramentas WebControls. Pressione
<F4> e digite o lblServer na propriedade ID.
9. Arraste para página o Controle Label da barra de ferramentas HTML. Pressione <F4> e
digite o lblClient1 na propriedade ID.
Sua tela deve estar assim:
10. Arraste para página o Controle Label da barra de ferramentas HTML. Pressione <F4>
e digite o lblClient2 na propriedade ID e limpe a propriedade Text.
11. Reposicione o controle lblServer para que fique abaixo dos outros 2.
12. Arraste para página o Controle Text da barra de ferramentas WebControls. Pressione
<F4> e digite o txtValor1 na propriedade ID e limpe a propriedade Text.
13. Arraste para página o Controle Text da barra de ferramentas WebControls. Pressione
<F4> e digite o txtValor2 na propriedade ID e limpe a propriedade Text.
14. Arraste para página o Controle Button da barra de ferramentas WebControls.
Pressione <F4> e digite o btnResultado na propriedade ID e Resultado na propriedade
Text.
14. Clique na parte interna do controle lblClient1 e digite:
1o. Número:
15. Clique na parte interna do controle lblClient2 e digite:
2o. Número:
Sua tela deverá ficar assim:
16. Com um duplo-clique no botão btnResultado, digite o código:
lblResultado.Text = txtValor1.Text + txtValor2.Text;
17. Execute a aplicação teclando <F5>.
3.Recaptulando OO
Classe
Uma classe é o abstrato de um objeto. Uma classe é um conjunto de informações e

funcionalidades específicas sobre um assunto. E deve ter sua responsábilidade bem
definida.
Objeto
Um objeto é a instancia de uma classe criada para prover a funcionalidade
especificada em uma classe.
Normalmente se refere a algo existente no mundo real.
Encapsulamento
Ao criar uma classe você decidirá o que deve ou não ficar visível para quem vai utilizar
o objeto. Este recurso é chamado de encapsulamento. Ao "esconder" de quem vai
utilizar sua classe o "como fazer" você está encapsulando código e tornando mais fácil
a utilização de um determinado recurso computacional.
Organização
Uma classe divide-se em propriedades, métodos e eventos.

Propriedades são as caracteristicas da classe.
Métodos são as ações executadas.
Eventos são respostas disparadas ao ocorrer uma determinada ação ou
funcionalidade.
§
Veja a figura acima:
O Carro acima é um Ford 32. Ford 32 é uma Classe ou uma objeto?

Um objeto. Carro é uma classe.
Quais as propriedades do carro Ford 32?

Cor, quantidade pneus, tipo de motor, etc.
Quais as possíveis ações que podemos executar em um carro?

Acelerar, freiar, Virar a direita, engrenar marcha, etc
Por questões de segurança, foi adicionado ao Ford duplo airbag. AoBater seria um
método ou um evento? EncherAirBags seria um método ou um evento?
AoBater - Evento. Representa algo que será executado somente quando uma
determinada condição acontecer para o objeto.
EncherAirBags - Método. Ação executada.
Pratica
1. Crie uma nova aplicação tipo console com C#. Dê o nome de Calculadora.
2. Clique com o botão direito sobre a solução (1o. arquivo no solution explorer).
3. Clique na opção <Add> depois em <New project...>
4. Selecione Class Library e nomeie como Calcula.
5. Renomeie o arquivo Class1.cs para Calcula.cs e digite:
using System;
namespace Classes.Calcula
{
/// <summary>
/// Responsável pelos cálculos efetuados
/// </summary>
public class Calcula
{
/// <summary>
/// Construtor da Classe Calcula
/// </summary>
public Calcula()
{
}
/// <summary>
/// Executa a soma de dois valores</summary>
/// <param name="pdecValor1">
/// Primeiro Valor para ser calculado.
/// </param>
/// Segundo Valor para ser calculado.
/// </param>
/// <value>Resultado da soma</value>
public decimal Soma(decimal pdecValor1, decimal pdecValor2)
{
return pdecValor1 + pdecValor2 //ocorrerá um erro aqui (não
conserte // ainda!!!).
}
/// <summary>
/// Executa a subtração de dois valores</summary>
/// </param>
/// </param>
/// <value>Resultado da subtração</value>
public decimal Subtrai(decimal pdecValor1, decimal pdecValor2)
{
return pdecValor1 + pdecValor2;
}
/// <summary>
/// Executa a multiplicação de dois valores</summary>
/// </param>
/// </param>
/// <value>Resultado da multiplicação</value>
public decimal Multiplica(decimal pdecValor1, decimal pdecValor2)
{
return pdecValor1 * pdecValor2;
}
/// <summary>
/// Executa a divisão de dois valores</summary>
/// </param>
/// </param>
/// <value>Resultado da divisão</value>
public decimal Divide(decimal pdecValor1, decimal pdecValor2)
{
return pdecValor1 / pdecValor2;
}
}
}
OBS.: Repare nos comentários XML (iniciados por /// barras). Tente supor o que fazem.
6. No projeto Calculadora, clique com o botão direito no projeto e depois em <Add> <Add
Class...>
7. Nomeie a classe como ConsoleApoio digite:
using System;
namespace ClasseInicio
{
/// <summary>
/// Summary description for Console.
/// </summary>
public class ConsoleApoio
{
public ConsoleApoio()
{
}
/// <summary>
/// Exibe uma mensagem na tela e aguarda digitação de um
valor</summary>
/// <param name="pstrMensagem">
/// Mensagem informativa do valor que será digitado
/// </param>
public decimal EntraValor(string pstrMensagem)
{
string strValor="";
Console.Write(pstrMensagem);
return Convert.ToDecimal(strValor);
}
/// <summary>
/// Exibe uma mensagem na tela e aguarda digitação de um
operador</summary>
/// Mensagem informativa do valor que será digitado
/// </param>
public string EntraOperador(string pstrMensagem)
{
string strValor="";
Console.Write(pstrMensagem);
return strValor;
}
/// <summary>
/// Exibe uma mensagem na tela</summary>
/// Mensagem que será exibida
/// </param>
public void Mensagem(string pstrMensagem)
{
Console.WriteLine(pstrMensagem);
}
/// <summary>
/// Aguarda que seja pressionada uma tecla</summary>
public void PressioneTecla()
{
Console.Read();
}
}
}
8. Renomeie o arquivo Class1.cs para UI.cs

9. Digite o código abaixo.
// XMLsample.cs
// compile with: /doc:XMLDoc.xml
using System;
using Classes.Calculos;
{
/// <summary>
/// Interface da calculadora
/// </summary>
class UI
{
/// <summary>
/// Método inicial executado automáticamente para uma aplicação console
/// </summary>
[STAThread]
{
decimal decValor1=0;
decimal decResultado=0;
ConsoleApoio objApoio = new ConsoleApoio();

Calcula objCalcula = new Calcula();
objApoio.Mensagem("Serão efetuadas várias operações");

objApoio.Mensagem("********************************");
decValor1 = objApoio.EntraValor("Digite um número:");

strOperador = objApoio.EntraOperador("Digite o operador desejado" +

" ( + , - , * , / ) :");
if (strOperador== "+")
decResultado = objCalcula.Soma(decValor1, decValor2);
else if (strOperador == "-")
decResultado = objCalcula.Subtrai(decValor1, decValor2);
else if (strOperador == "*")
decResultado = objCalcula.Multiplica(decValor1, decValor2);
else if (strOperador == "/")
decResultado = objCalcula.Divide(decValor1, decValor2);
else
objApoio.Mensagem("Informe uma operação válida.");
objApoio.Mensagem("O resultado eh:" + decResultado);
objApoio.PressioneTecla();
}
}
}
10. Ao tentar executar você verá que serão apresentados erros de execução. Verifique a
que a ordem correta para corrigi-los é de baixo para cima. Verifique também o uso da
janela Output.
11. Verifique o uso dos namespaces novamente.
12. Vamos utilizar Eventos. Após a linha de declaração do namespace, dentro das
chaves, digite a linha:
public delegate void MessageHandler(string pstrMessage);
13. Agora, adicione o método abaixo na classe Calcula:
/// <summary>
/// Verifica qual operação poderá ser executada dependendo do parâmetro
/// informado.</summary>
/// <param name="pstrOperacao">
/// String que representa a operação qeu será executada ( +,-,* ou /).
/// </param>
/// </param>
/// </param>
public decimal ExecutaOperacao(string pstrOperacao, decimal pdecValor1,
decimal pdecValor2)
{
bool blnValido=true;
if (pstrOperacao== "+")
decResultado = this.Soma(pdecValor1, pdecValor2);
else if (pstrOperacao == "-")
decResultado = this.Subtrai(pdecValor1, pdecValor2);
else if (pstrOperacao == "*")
decResultado = this.Multiplica(pdecValor1, pdecValor2);
else if (pstrOperacao == "/")
decResultado = this.Divide(pdecValor1, pdecValor2);
else
blnValido=false;
if (blnValido)
this.OnMessage("O resultado eh:" + decResultado);
else
this.OnMessage("Informe uma operação válida.");
return decResultado;
}
13. Agora modiique UI.cs para que fique da forma abaixo:
//XMLsample.cs
// compile with: /doc:XMLDoc.xml
using System;
using Classes.Calculos;
{
/// <summary>
/// Interface da calculadora
/// </summary>
class UI
{
/// <summary>
/// Método inicial executado automáticamente para uma aplicação console
/// </summary>
[STAThread]
{

Calcula objCalcula = new Calcula();
objCalcula.OnMessage += new MessageHandler(UI.Message);
objApoio.Mensagem("Serão efetuadas várias operações");

objApoio.Mensagem("********************************");

strOperador = objApoio.EntraOperador("Digite o operador desejado "

+
" ( + , - , * , / ) :");
objCalcula.ExecutaOperacao(strOperador,decValor1,decValor2);
// if (strOperador== "+")
// decResultado = objCalcula.Soma(decValor1, decValor2);
// else if (strOperador == "-")
// decResultado = objCalcula.Subtrai(decValor1, decValor2);
// else if (strOperador == "*")
// decResultado = objCalcula.Multiplica(decValor1, decValor2);
// else if (strOperador == "/")
// decResultado = objCalcula.Divide(decValor1, decValor2);
// else
// objApoio.Mensagem("Informe uma operação válida.");
//
// objApoio.Mensagem("O resultado eh:" + decResultado);
objApoio.PressioneTecla();
static void Message(string pstrMensagem)

{
objApoio.Mensagem(pstrMensagem);
}
}
}
No exemplo acima, OnMessage é um evento que ao ser acionado, foi "ligado" a rotina
Message para que exiba a mensagem correspondente.
Vamos utilizar o ASP.NET reaproveitando o código gerado.
1. Crie um novo projeto "ASP.NET Web Application" nomeie como Calculadora.

2. Agora adicione (clicando <Add> <Existing Project...>) o projeto chamado Calcula.
3. Crie a página Calculadora.aspx cmo abaixo:
4. Tente faze-la funcionar utilizando o código já criado (lembre-se que devemos adicionar
a referência e depois o namespace).
Herança
A herança é o recurso fundamental de toda linguagem orientada para objetos. Trata-se

do recurso de herdar em uma classe todas as caracteristicas e funcionalidades de outra.
Existem duas ressalvas:
1) a herança só deve ser usada quando você tem o relacionamento “é um” entre as
classes. Por exemplo, gato “é um” animal. Porém, cachorro não é um gato!
Parece piada, mas algumas vezes “erros” deste tipo são cometidos por descuido ou
porque o desenvolvedor queria obter apenas uma determinada funcionalidade que a
classe gato continha.
2) para usar herança, a classe deve ter sido desenhada tendo em mente a herança. Isto
é muito importante pois se o objeto não foi construído desta forma a herença pode não
funcionar conforme o esperado.
OBS.: Muitas vezes usa-se herança onde poderia-se ter usado simplesmente uma
agregação (uma classe dentro de outra).
Pratica
1. Abra o solution usado no último exercício.
2. Modifique o projeto Calcula. Abrindo a classe Calcula e modificando:
/// <summary>
/// Verifica qual operação poderá ser executada dependendo do
/// parâmetro informado.</summary>
/// </param>
/// </param>
/// </param>
/// <value>Resultado da operação</value>
public virtual decimal ExecutaOperacao(string pstrOperacao, decimal
pdecValor1
,decimal pdecValor2)
{
else
blnValido=false;
if (blnValido)
this.DisparaEvento("O resultado eh:" + decResultado);
else
this.DisparaEvento("Informe uma operação válida.");
}
/// <summary>
/// Dispara o evento que retorna a mensagem para o objeto que o está
usando.
/// </summary>
/// String que representa a Mensagem que será retornada.
/// </param>
public void DisparaEvento(string pstrMessage)
{
this.OnMessage(pstrMessage);
}
13. Agora, adicione um novo projeto de um classlibrary em C#
14. Renomeie o arquivo Class1.cs para CalculaEX.cs
15. Digite o código abaixo:
using System;
namespace Classes.Calculos
{
/// <summary>
/// Responsável por novos calculos
/// </summary>
public class CalculaEX: Calcula
{
public CalculaEX()
{
}
/// <summary>
/// </param>
/// </param>
/// </param>
public decimal Raiz(decimal pdecValor1)
{
return (decimal) Math.Sqrt(Convert.ToDouble(pdecValor1));
}
/// <summary>
/// </param>
/// </param>
/// </param>
public decimal Potencia(decimal pdecValor1, decimal pdecValor2)
{
return (decimal)
Math.Pow(Convert.ToDouble(pdecValor1),
Convert.ToDouble(pdecValor2));
}
/// <summary>
/// String que representa a operação qeu será executada ( +,-,* ou /). Permite
também /// Raiz e Potencia.
/// </param>
/// </param>
/// </param>
public override decimal ExecutaOperacao(string pstrOperacao, decimal
pdecValor1
, decimal pdecValor2)
{
bool blnPai =false;
if (pstrOperacao == "P")
decResultado = this.Raiz(pdecValor1);
else if (pstrOperacao == "P")
decResultado = this.Potencia(pdecValor1, pdecValor2);
else if (pstrOperacao == "+" || pstrOperacao == "-" || pstrOperacao ==
"*"
|| pstrOperacao == "/")
{
base.ExecutaOperacao(pstrOperacao, pdecValor1,
pdecValor2);
blnPai=true;
}
else
blnValido=false;
if (!blnPai)
{
if (blnValido)
base.DisparaEvento("O resultado eh:" + decResultado);
else
base.DisparaEvento("Informe uma operação válida.");
}
}
}
}
Muito bem, suponde que tudo correu bem. Vamos fazer com que o projeto da calculadora
funcione como esperado no ASP.NET também.
Abra a solution da calculadora e adicione os dois novos botões na página
Calculadora.aspx.
Polimorfismo e funções virtuais
O polimorfismo permite que você tenha uma classe vão assumir diferentes ações
dependendo do objeto que a implementa. Além dos muito conhecidos métodos
polimórficos.
Prática
A prática será vista apenas nas próximas aulas.
Parte 3
Tratamento de Exceções
No C#
O tratamento de exceções normalmente é abordado ao fim da maioria dos
livros especializados. Porém (talvés por este motivo) muitos se esquecem da
importância de tratar exceções no mundo orientado para objetos. Alguns nem sabem
como faze-lo.
Para tratar exceções no C# são usados blocos estruturados de código. Usando
as palavras try..... catch e finally.
Try..Catch
Suponha que você queira que seu código continue funcionando normalmente
ao acontecer determinado erro. Para isto, basta trata-lo da maneira correta. Após a
palavra try colocamos o código onde pode ocorrer um determinado tipo de erro. O
comando catch obtém o erro caso este ocorra.
Prática
No Console
1. Vamos acertar o código que você utilizou para teste do comando switch:
using System;
namespace TesteSwitch
{
/// <summary>
/// Teste do comando switch.
/// </summary>
class TesteSwitch
{
/// <summary>
/// </summary>
[STAThread]
{
string strValor="";
int intValor1=0;
int intValor2=0;
int intResultado=0;



try
{
switch (strOperador == "+")
{
case "+":
break;
case "-":
break;
case "*":
break;
case "/":
break;
default:
Console.WriteLine("Informe uma operação válida." +
"O resultado será zerado.");
break;
}
}
catch(DivideByZeroException dex)
{
Console.WriteLine("Não é possível dividir por zero!");
}
catch(Exception ex)
{
throw ex;
}

Console.Read();
}
}
}
Podemos verificar que todos os cálculos foram colocados dentro de um bloco try. O primeiro bloco catch
trata apenas de erros do tipo DivideByZeroException fazendo com que seja exibida uma mensagem mais
amigável para este caso.
Já quanto a erros de outros tipos. Estes simplesmente são redirecionado para que caiam no tratamento de
erros padrão do sistema (sair do executável no caso de uma aplicação console).
No ASP.NET
Vamos colocar o mesmo tratamento de erros em nossa última alicação ASP.NET.
1. Abra a Solution da Calculadora

2. Abra a classe Calcula do projeto Calcula.
3. Modifique o método abaixo:
/// <summary>
/// Executa a divisão de dois valores</summary>
/// </param>
/// </param>
/// <value>Resultado da divisão</value>
public decimal Divide(decimal pdecValor1, decimal pdecValor2)
{
try
{
return pdecValor1 / pdecValor2;
}
{
throw new DivideByZeroException("Divisão por zero. " +
"Informe o valor correto!",
dex);
}
catch(Exception ex)
{
throw ex;
}
}
3. No método que executa operações:
/// <summary>
/// </param>
/// </param>
/// </param>
public virtual decimal ExecutaOperacao(string pstrOperacao, decimal
pdecValor1
, decimal pdecValor2)
{
try
{
else
blnValido=false;
if (blnValido)
this.DisparaEvento("O resultado eh:" + decResultado);
else
this.DisparaEvento("Informe uma operação válida.");
}
{
this.DisparaEvento(dex.Message);
}
catch(Exception ex)
{
throw ex;
}
}
4. Faça testes.

Treinamento C# ASP - Net PI

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Treinamento C# ASP - Net PI

Enviado por

Direitos autorais:

Formatos disponíveis

Treinamento C#.

A Microsoft e a iniciativa .NET

Em resumo, o .NET Framework é ambiente gerenciado com tipificação forte para o

O .NET Framework é um conjunto de componentes que permitem, além da

O C# é a linguagem nativa do .NET Framework. Ela foi concebida preenchendo todos

O .NET Commom Language Runtime é um ambiente baseado em componentes. Estes

O código gerado (MSIL)

Ao compilar um fonte desenvolvido sobre a plataforma .NET não será gerado um

* C# Builder (www.borland.com) - A vantagem deste é que se for apenas para estudo

No bloco de notas do windows digite:

b) Salve este arquivo na pasta c:\curso\aula1\primeiro\Hello.cs

- Pressione <Windows> + <E>

Entendendo namespaces e using

Abra uma nova janela do bloco de notas e digite o programa abaixo

Console.WriteLine("Será efetuada uma soma");

Console.Write("Digite o primeiro número:");

intResultado = intValor1 + intValor2;

Console.Write("Pressione qualquer tecla para continuar");

Salve este arquivo na pasta aula1\TesteInicial no arquivo TesteInicial.cs

Abaixo está a tabela com os tipos de valor padrão do C#.

Tipo Tamanh Tipo . Descrição

Comandos mais utilizados

Console.WriteLine("Será efetuada uma operação");

Console.Write("Digite o primeiro número:");

Console.Write("Digite o operador desejado ( + , - , * , / ) :");

Console.WriteLine("O resultado da soma eh:" + intResultado);

Console.Write("Pressione qualquer tecla para continuar");

bool blnValor = true;

for (int intValor = 20; n--; n>0)

string strValor = "";

Console.WriteLine("Será exibida a tabuada dos números

for (int x=0; x<=10; x++)

Console.Write("Deseja Sair (S/N)");

Console.WriteLine("Será efetuada uma operação");

Console.Write("Digite o primeiro número:");

Console.Write("Digite o operador desejado ( + , - , * , / ) :");

switch (strOperador == "+")

Console.WriteLine("O resultado da soma eh:" + intResultado);

Console.Write("Pressione qualquer tecla para continuar");

foreach (string strNome in arrNomes)

foreach (string strNome in astrNomes)

Console.WriteLine("Pressione qquer tecla para continuar");

A Internet de hoje foi desenvolvida por universidades para troca de conteúdo

O Java e o Javascript são linguagem diferentes para atender "mundos"

O Javascript permitiu a interação do browser com os dados da página sendo

O que é o ASP.NET então? Apenas uma evolução do ASP tradicional? A resposta é um

Sua tela deve estar assim:

Sua tela deverá ficar assim:

16. Com um duplo-clique no botão btnResultado, digite o código:

lblResultado.Text = txtValor1.Text + txtValor2.Text;

17. Execute a aplicação teclando <F5>.

Uma classe é o abstrato de um objeto. Uma classe é um conjunto de informações e

Uma classe divide-se em propriedades, métodos e eventos.

O Carro acima é um Ford 32. Ford 32 é uma Classe ou uma objeto?

Quais as propriedades do carro Ford 32?

Quais as possíveis ações que podemos executar em um carro?

8. Renomeie o arquivo Class1.cs para UI.cs

ConsoleApoio objApoio = new ConsoleApoio();

objApoio.Mensagem("Serão efetuadas várias operações");

decValor1 = objApoio.EntraValor("Digite um número:");

strOperador = objApoio.EntraOperador("Digite o operador desejado" +

objApoio.Mensagem("O resultado eh:" + decResultado);

11. Verifique o uso dos namespaces novamente.