 1

DESENVOLVIMENTO PARA
WEB
PROF. MARCELO IURY
Programação para Web IV
 marceloiury@gmail.com
http://sites.google.com/site/marceloiury/

 2
Quem Sou
 Marcelo Iury de Sousa Oliveira
 Graduado em Ciências da Computação pela
Universidade Estadual do Ceará.
 Mestre em Computação pela Universidade Federal
Campina Grande
 Bolsista MIC, 2 anos
 MCP- Developing and Implementing Windows-
Based Applications with Microsoft Visual C#
 MCP - Web Services and Distributed Components
with Microsoft Visual C#
 Trabalho há 8 anos com informática e há pelo menos
7 anos em desenvolvimento de Sistemas.
 3
 Casado, dono de dois gatos
Objetivos do Curso
 Especializar profissionais para o atuarem no
projeto e desenvolvimento de sistemas Web
utilizando a tecnologia.Net;
  Desenvolver habilidades técnicas e práticas para o
desenvolvimento de sistemas Web utilizando .Net.
 Oferecer ao profissional de informática uma visão
ampla e aprofundada da plataforma .Net e suas
tecnologias relacionadas.

 4
Conteúdo Programático
 Introdução ao Framework.NET
 Visão geral sobre o Visual Studio.NET e
linguagens.NET
 Web Forms
 Recurso de Code-Behind e procedimentos de
eventos a um Web Server Control
 Visão geral sobre validação dos dados do usuário

 5
Conteúdo Programático
 Introdução ao Framework.NET
 Visão geral sobre o Visual Studio.NET e

ASP.NET
linguagens.NET
 Web Forms
 Recurso de Code-Behind e procedimentos de
eventos a um Web Server Control
 Visão geral sobre validação dos dados do usuário

 6
O que é o ASP.Net?
 Inicialmente, o ASP.NET surgiu com a intenção de
corrigir os muitos bugs do famoso ASP.
 Mas, o programa evoluiu
 ASP .NET é a próxima geração da ASP e tem o
objetivo de poder ser usada para criar sites de grande
escala comercial como pequenas aplicações para
intranet de uma maneira simples e fácil.

 7
Benefícios do ASP.Net
 Páginas ASP.NET são compiladas
 São assim carregadas mais rápidas;
 Páginas ASP.NET são construidas com controles de
interface do lado do servidor
 ASP.NET é parte do .NET Framework
 O .NET Framework torna disponível mais de 3000
classes que podem ser usadas para as aplicações
ASP.NET .
 ASP.NET é totalmente orientado a objeto;
 A ASP.NET traz então o desenvolvimento das
 8
ferramentas RAD
ASP.NET é igual a ASP ?
 Pode parecer igual , mas não é.
 É mais estruturado e … complexo ( a primeira vista).
 Embora o código ASP seja muito simples podemos
identificar nele alguns problemas:
 O código é executado linha por linha ;
 Temos misturado o código da página (HTML) e o da
lógica da página;
 E dífícil reaproveitar o código;
 Ele depende da plataforma;
 O VBScript , a principal linguagem de script ASP, não
diferencia os tipos de variáveis;  9
Framework .Net

 10
Plataforma Microsoft .NET

 Plataforma de desenvolvimento multi-linguagem e

multi-paradigma
 Ambiente de execução gerenciado:
 Máquina virtual
 Compilação just-in-time
 Gerenciamento automático de memória

 11
Desenvolvimento de software

Aplicações

.NET Framework

SO
Monitor

Impressora
Computador

Teclado 12
 Modelo de programação unificado

Web Mobile Desktop

.NET Framework

 1
3
.NET – Arquitetura

.NET Framework 3.5

Ajax LINQ WF & WCF
Enhancements
Visual Basic 9.0 C# 3.0

.NET Framework 3.0 + SP1

Windows Windows Windows

Windows
Presentation Communication Workflow
CardSpace
Foundation Foundation Foundation

.NET Framework 2.0 + SP1

14
 Linguagens Suportadas

APL
COBOL
Boo Clarion
C++
Component Pascal C#
Fortran
Eiffel Forth
Jscript
Haskell Java
Mercury
J# Lua
Delphi
Mondrian Oberon
Perl
Oz Pascal
Python
PowerBuilder PowerShell
Scheme
Ruby
ML
RPG Standard ML
Visual Basic  15
SmallTalk
Dynamic Language Runtime

IronPython IronRuby
VB C#

Dynamic Language Runtime

Common Language Runtime

16
 Portabilidade

 Compact Framework
 SSCLI – Rotor
 http://msdn.microsoft.com/net/sscli
 Mono
 http://www.go-mono.com

Acordo Microsoft Novell garantiu a

continuidade do Mono

 17
 .NET X J2EE

.NET:
“Várias linguagens em um único ambiente”
J2EE
 “Uma única linguagem em vários ambientes”

J2EE .NET
Web Struts, JSF, Laszlo ASP .NET
Banco de Dados JDBC ADO .NET
Web Services Suporte por meio de Suporte embutido e
APIs simplificado
Distribuição RMI, EJB .NET Remoting

 18
 Common Language Infrastructure

 Infra-estrutura de execução padronizada pela

ECMA
 Especificação define:
 Common Type System
 Metadados
 Common Language Specification
 Virtual Execution System

 19
Common Language Runtime - CLR
 Ambiente que permite a execução em tempo real
de aplicações.
 Fornece um conjunto de serviços, ao nível das
fases de desenvolvimento, de distribuição e de
execução, que melhoram o desempenho da
aplicação.

 20
CLR - Características
 Sistema Comum de Tipos
 Conversão directa dos tipos de informação da Linguagem de
programação para os da Framework
 Compilador Just-in-time (JIT)
 O JIT converte o código intermédio (MSIL) em código nativo
optimizado
 Gestão de memória – Garbage Collection
 Evita problemas de “falta de memória disponível”
 Tratamento de Excepções
 Permite um tratamento de erros mais elegante
 Gestão de Threads

 21
CLR - Arquitetura
Faz a integração com a .NET Framework class library.

SequenciaBase Class Library

a distribuição dos(.NET Framework) Support
componentes
Tratamento de erros
Procedimentos de segurança baseados na
Threadidentificação
Support do utilizador eCOM Marshaler do
na localização
código
Fornece classes e interfaces para
Type Checker
utilização de threads Exception Manager
Converte código MSIL para código nativo
optimizado
Security
Impede Engine inadequadas e gere
conversões Debug
o Engine
acesso às variáveis

MSIL to Native Code fazer debug da aplicação

Permite Garbage
Gestão de memória
Compilers (JIT) Manager Collector (GC)

Class Loader
Controla a execução do código

Gera o metadata e o carregamento das classes necessárias.

22
Visão Geral da Compilação e Execução

Código
VB C# C++
Fonte

Componente
Compilador Compilador Compilador
Não Gerenciável

Código
Gerenciável Assembly - Código IL

Common Language Runtime (CLR)

Compilador JIT

Código Nativo

Serviços do Sistema Operacional

Assembly
 Contêm código e metadata para o CLR
 Constitui-se como unidade básica de distribuição
 Podem ser do tipo EXE e DLL

 24
Visual Studio 2008
Visual Studio 2008
 Ambiente de desenvolvimento integrado (IDE
- Integrated Development Environment) da
Microsoft para geração rápida de aplicações
(RAD - Rapid Application Development);
 Suporte a múltiplas linguagens (C#, VB.Net,
F#, etc) e plataformas (Web, Mobile,
Windows).
Visual Studio Professional

 Ambiente Integrado de Desenvolvimento

 Sistema de Projetos
 Editores e Design
 Ferramentas de Compilação e Depuração
 Ferramentas de Implantação
 Documentação do Produto
 Vários projetos em uma única solução.
 Ótimo Code Complemetation
 Separação do “negócio” e da “interface”.
 Edições

 Download e mais informações em:

 http://www.microsoft.com/express

 http://www.microsoft.com/visualstudio/

 28
Requisitos de Instalação
Arquitetura de Arquivos do Projeto
 Arquivos (.cs, .vb, .resx,
.settings, etc) estão contidos
dentro de uma estrutura de pastas
denominado Projeto;

 Uma solução (solution) é um

conjunto de projetos e é
representado por um arquivo
com a extensão .sln;
Características do Editor de Código

 Syntax Highlighting: cores diferenciadas

para elementos do código;
 Code Completion (IntelliSense): menu
preditivo de comandos, CTRL + ESPAÇO.
 Facilidade para refatoração de código;
 Background compiling: compilação
incremental, permite a correção imediata de
erros.
 Características do Editor de Código
 Documentação integrada à IDE:
o MSDN: Microsoft Developer Network;
o Própria via comentários XML:
 http://www.msdnbrasil.com.br/docs/vstudionet/visualstudio_comen
tsxml.doc
 Bookmarks de código;
 Delimitação de regiões (outlining) no código a partir da diretiva #region /
#endregion;
 Características do Editor de Código

 Suporte a atalhos de teclado:

o Ver poster em:
http://tinyurl.com/25sez4
o Ver, principalmente, os
atalhos de refatoração (CTRL
+ R);
 Code Snippets:
o Fragmentos de código;
o Exemplos: cw, if, foreach,
switch, while, ;
o Digitar o nome do code
snippet e clicar TAB 2x ou
pelo menu contextual;
Janela ToolBox

 Caixa de ferramentas

 Menu View/ToolBox

 Comporta os componentes a serem inseridos nos

projetos
Janela ToolBox

 Clique no componente desejado e

logo após no Form Designer.
 O componente será inserido no seu
Form, como desejado.
Janela Properties

 Menu View/Properties Window.

 Quando se insere um componente em um Form, é

nesta janela que deve-se configurar os valores
iniciais das propriedades deste componente.
Janela Properties
Janela Output

 Saída de informações.
 Menu View/Output.
 Exibe as saídas de informações do ambiente de
desenvolvimento.
 O programador pode forçar uma saída
informações usando o comando:
Console.WriteLine();
Janela Object Browser

 Navegador de objetos
 Menu View/Other Windows/Object Browser
 Apresenta a estrutura hierárquica de cada objeto
disponível, bem como a lista de membros
pertencentes a cada objeto selecionado.
Janela Object Browser
 Atalhos
 Execução e Depuração:  Refatoração:
o F5: Iniciar depuração; o CTRL+R, R: renomear
o F6: Build (sem execução); campo;
o SHIFT + F5: Parar depuração; o CTRL+R, M: extrair
o CTRL + F5: Executar sem depurar; método;
o F10: Step over; o CTRL+R, E: encapsular
o F11: Step into; campo.
o CTRL + D, I: Immediate Window;  Bookmarks:
 Editor: o CTRL + B, T: Colocar
o CTRL + ESPAÇO: IntelliSense; Bookmark;
o CTRL + E, C: Comentar linhas; o CTRL + B, N: Próximo
o CTRL + E, U: Descomentar linhas; Bookmark;
o CTRL + E, D: Identação do documento; o CTRL + B, P: Bookmark
o CTRL + E, F: Identação da seleção; Anterior;
o F7: Modo de Código;
o SHIFT + F7: Modo de Design;
 Características do Depurador
 Depuração Tradicional: Disassembly (obtenção a partir do
Breakpoints,Watches, Step Into, código de máquina)do código, caso
Step Over; não esteja disponível;
 Call Stack: pilha de chamadas; Edit and Continue: Edição do
 Depura programas externos código enquanto se depura;
(.exe e .dll) caso um programa
dê erro grave; Data Tooltips: mostra o valor das
 Código gerenciado e código variáveis quando o usuário passa
nativo; com o mouse por cima;
Editores Visuais Disponíveis
 WinForms Designer:
 Editor visual da GUI (Graphic
User Interface) para
aplicações Windows;
 Web Designer:
 Editor visual para aplicações
web;
 Editor de ASP.NET, CSS,
Javascript, HTML, CSS;
 Interface compartilhada
com o Expression Studio;
 Class Designer:
 Editor de classes;
 Não disponível na versão
Express;
 Data Designer:
 Editor de bases de dados;
 Mapping Designer:
 Editor de mapeamentos
objeto-relacionais;
 WPF Designer: voltado
para interfaces WPF
(Silverlight).
Exercício 0
 Abra o VisualStudio.Net
 Construa a aplicação calculadora
 Não será necessário adicionar código

 45
Conceitos de C#
Introdução ao C#
 Linguagem baseada no C/C++
 com inspiração no Java
 preserva investimentos e conhecimentos adquiridos
 permite um código mais “limpo”
 possui construções sintácticas especiais para retirar
partido da framework
 arquivos têm extensão .cs

 47
 Tipos Valor e Tipos Referência
 Tipos valor (value types)
 Variáveis contêm diretamente dados/instâncias
 Não podem ser null (Nothing em VB)
 Comparação e atribuição operam com os próprios valores (em C#)
 Manipulação eficiente porque dados podem ser alocados na stack

 Tipos referência (reference types)

 Variáveis contêm referências para objetos/instâncias (no heap)
 Podem ser null (Nothing em VB)
 Comparação e atribuição operam com as referências (em C#)
 Gestão automática de memória (garbage collector do CLR)

i 123
int i = 123;

string s = "Hello, world"; s "Hello, world"

 48
Tipos Valor e Tipos Referência
 Tipos Valor
 Primitivos int i; (de facto também são
estruturas!)
 Enumerações enum State { Off, On }
 Estruturas struct Point { int x, y; }

 Tipos Referência
 Arrays string[] a = new string[10];
 Classes class Foo: Bar, IFoo {...}
 Interfaces interface IFoo: IBar {...}
 Delegates delegate double
MathFunc(double x);  49
 Sistema de Tipos
String string Nome;

Array int[] tabela;

Object Class class Pessoa { ... }

Enum
enum Estado
{ Ligado, Desligado}

Struct struct Ponto

ValueType
{ int x; int y; }

bool byte sbyte decimal

char short ushort

float int uint decimal conta;

 50
double long ulong
Compatibilidade de Tipos

 51
Passagem de parâmetros
 params – passagem de nº variável de parâmetros
public static void Main()
{
UseParams(1, 'a', "test");
int[] myarray = new int[3] {10,11,12};
UseParams(myarray);
}
public static void UseParams(params object[] list)
{
for ( int i = 0 ; i < list.Length ; i++ )
Console.WriteLine(list[i]);
Console.WriteLine();
}
 52
 Tipos Pré-definidos em C#

CTS Type Name C# Alias Description

System.Object object Base class for all CTS types
Classes System.String string String
System.SByte sbyte Signed 8-bit byte
System.Byte byte Unsigned 8-bit byte
System.Int16 short Signed 16-bit value
System.UInt16 ushort Unsigned 16-bit value
System.Int32 int Signed 32-bit value
System.UInt32 uint Unsigned 32-bit value
Estruturas System.Int64 long Signed 64-bit value
System.UInt64 ulong Unsigned 64-bit value
System.Char char 16-bit Unicode character
System.Single float IEEE 32-bit float
System.Double double IEEE 64-bit float
System.Boolean bool Boolean value (true/false)
System.Decimal decimal 128-bit data type exact to 28
or 29 digits mainly used for
financial applications
 53
Tudo é um Objeto
 Todos os tipos (mesmo tipos valor) derivam de object e
podem ser tratados como objetos
 Concilia eficiência com simplicidade
 instâncias de tipos valor são guardadas na stack
 não há wrapper classes com em Java (graças a mecanismo de boxing
e unboxing – ver a seguir)
 coleções funcionam com todos os tipos

object

string Stream Hashtable int double

MemoryStream FileStream ...

 54
Tudo é um objeto
 Todos os tipos (mesmo tipos valor) derivam de object e
podem ser tratados como objetos
 Concilia eficiência com simplicidade
 instâncias de tipos valor são guardadas na stack
 não há wrapper classes com em Java (graças a mecanismo de boxing
e unboxing – ver a seguir)
 colecções funcionam com todos os tipos

object

int
string
i = 1;
Stream Hashtable int double
string s = i.ToString() + 123.ToString();
MemoryStream FileStream ...
 55
 Tudo é um objeto (2)
C# JAVA
Hashtable ht
Hashtable ht
= new Hashtable();
= new Hashtable();

ht.Add(1, “Xpto”);
ht.Add(2, “Xpti”); ht.put(new Integer(1), “Xpto”);
ht.put(new Integer(2), “Xpti”);

O fim das classes de wrapping!

 56
 Boxing e Unboxing
 Boxing – conversão de tipo valor para tipo referência
 Unboxing – conversão de tipo referência para tipo valor

int i = 123;
stack
boxing
i 123 heap
// upcast
object o = i;
o System.Int32
// downcast explícito 123
int j = (int)o; j 123

// outra forma
unboxing
int j = o as int;

 57
Espaços de Nomes (namespaces)
 Programa constituído por declarações de tipos (classes, interfaces,
estruturas, etc.) dentro de espaços de nomes
 código escrito inline; ordem de declaração irrelevante
 Um espaço de nomes pode conter tipos (classes, estruturas, etc.) e outros
espaços de nomes
 Tipos declarados fora de qualquer espaço de nomes ficam num espaço
de nomes global
 Vários arquivos de código fonte podem contribuir para o mesmo espaço
de nomes, mas cada tipo tem de ser definido num único arquivo
 Para minimizar conflitos, é aconselhável usar o nome da empresa seguido
do produto ou projecto (exemplo: Novabase.CSI.LockMngr)
 Instruções:
 using nome-de-espaço-de-nomes;
 using alias = nome-de-classe;
 namespace nome-de-espaço-de-nomes
{ declarações-de-tipos-e-espaços-de-nomes }
 58
Espaços de Nomes
Exemplo *
namespace N1 // nome completo: N1
{
class C1 // nome completo: N1.C1
{
class C2 // nome completo: N1.C1.C2
{ }
}
namespace N2 // nome completo: N1.N2
{
class C2 // nome completo: N1.N2.C2
{ }
} using
using MyC2
MyC2 ==
} N1.N2.C2;
N1.N2.C2;
namespace N1.N2 using
using N1;
N1;
{ class myClass
class myClass
class C3 // N1.N2.C3
{{
C1
C1 c1;
c1; //
// N1.C1
N1.C1
{ }
MyC2
MyC2 c2;
c2; //
//
} N1.N2.C2  59
N1.N2.C2
Exercício 1
 Abra o VisualStudio.Net
 Construa a aplicação “Hello World” como Console
Application
 Utilize o método WriteLine da classe Console
 Construa uma aplicação semelhante, agora como
Windows Application
 Utilize o método Show da classe MessageBox

 60
Exercício 2
 Abra o VisualStudio.Net
 Construa a aplicação “Hello World” como Console
Application
 Utilize o método WriteLine da classe Console
 Realize testes de conversão de tipos numéricos
 Procure um determinado texto em uma string ,
apresentando a primeira ocorrência e a última ocorrência
 Preencha uma string com uma série de caracteres
 Utilize TimeSpan e DateTime para criar um intervalo de
tempo e informar o usuário sobre dados como ano, mês,
dia e etc.
 61
Classes
Classes
 { Membros }
 Campos, métodos, constantes, propriedades, indexadores,
operadores, construtores, destrutores, eventos, tipos
nested
 Âmbito: estáticos (partilhados) ou de instância
 Acessibilidade: private (por omissão), protected,
public ou internal (mesma unidade de compilação;
combinação ou c/ protected)
 : Bases
 herança de 0 ou 1 uma classe base
 por omissão é System.Object
 são herdados todos os membros exceto construtores e
destrutores
 implementação de 0 ou mais interfaces base  63
Campos (fields)
Conceitos
 Guardam dados
 Âmbito:
 campos de instância – alocados em cada instância da classe, para
guardar dados da instância
 campos estáticos (static) ou partilhados (VB) – alocados uma vez
para toda a classe, para guardar dados partilhados por todas as
instâncias
 Campo imutável (readonly) – guarda valor imutável
definido pelo construtor (ou inicializador) no momento da
execução
 podem ser estáticos
 Podem ter inicializador
 senão são inicializados com valor por omissão do respectivo tipo

 64
Campos (fields)
Exemplo
using Date = System.DateTime;
public class Factura {
// campos (private por omissão)
static int ultimoNumero = 0;
readonly int numero = ++ultimoNumero;
Date data = Date.Today;
decimal valor;
public Factura(decimal valor) // constructor
{ this.valor = valor; }
public override string ToString() // método
{ return "Factura número=" + numero.ToString()
+ " data=" + data.ToShortDateString()
+ " valor=" + valor.ToString("C"); }
}

 65
 Campos (fields)
Exemplo (cont.)

class FacturaApp
{
public static void Main()
{
System.Console.WriteLine(new Factura(10000));
System.Console.WriteLine(new Factura(20000));
}
}

Factura
Factura número=1
número=1 data=23-07-2001
data=23-07-2001 valor=10.000$00
valor=10.000$00 Esc.
Esc.
Factura
Factura número=2
número=2 data=23-07-2001
data=23-07-2001 valor=20.000$00
valor=20.000$00 Esc.
Esc.

 66
Métodos
Conceitos
 Âmbito:
 Estáticos (partilhados) (static)
 invocados com classe.método
 De instância
 invocados com objeto.método
 objeto é parâmetro implícito (this)

 Overloading
 vários métodos com o mesmo nome e diferentes
tipos de parâmetros

 67
Métodos
Tipos de Parâmetros
 Parâmetros valor, só de entrada (default)
 Parâmetros referência de entrada e saída (ref)
 obrigatório passar variáveis já inicializadas
 Parâmetros referência só de saída (out)
 permite passar variáveis não inicializadas

class Calculator
{
private double mem;
public void Store(double x) { mem = x; }
public void Load(out double x) { x = mem; }
public void Exchange(ref double x)
{ double old_mem = mem; mem = x; x = old_mem;}
}  68
Métodos
Argumentos Variáveis *
 Métodos podem aceitar um nº variável de argumentos do
mesmo tipo (no limite object, i.e., qualquer tipo)
 Declara-se parâmetro do tipo array com params
 Podem existir parâmetros anteriores normais (sem param)
 Podem-se passar vários argumentos ou um array

class VarArgsApp
{ public static double Sum(params double[] nums)
{ double sum = 0;
foreach (double x in nums) sum += x;
return sum;
}
public static void Main()
{ System.Console.WriteLine(Sum(1.0, 2.0, 3.0)); }
}
 69
 Herança e "Substitutabilidade"
using System; class InheritanceApp {
Herda implicitamente
de System.Object public static
void Main(){
class C1 { C1 c1 = new C1();
public void F1() C2 c2 = new C2();
{Console.WriteLine("F1");} C3 c3 = new C3();
} // herança
Herda membros de c2.F1();
C1 e acrescenta F2
c3.F1();
class C2: C1 { c3.F2();
public void F2() // substitutabilidade
{Console.WriteLine("F2");} c2 = c3;
} c1 = c2;
c1 = c3;
class C3: C2 { }
public void F3()
{Console.WriteLine("F3");} Onde se espera um objeto da classe
} base (C1) pode-se passar um objeto
de uma classe derivada (C3)  70
Upcast e Downcast *
 Upcast – conversão de classe derivada para classe base (ao
nível de referências)
 Sempre possível de acordo com princípio da "substitutabilidade"
 Não precisa de cast explícito
 Downcast – conversão de classe base para classe derivada
(ao nível de referências)
 Tem de se fazer um cast explícito com (type) ou as type
 Só é possível se objeto referenciado for da classe derivada (ou de uma
terceira classe derivada desta)
 Se assim não for,
 "(type)objref " dá exceção System.InvalidCastException
 "objref as type" dá null

 71
 Métodos Virtuais e Polimorfismo
using System;
pode ser overriden
class A {
public virtual void F() {Console.WriteLine("A.F");}
}
substitui implementação de método virtual
herdado, para objetos da classe derivada
class B: A {
public override void F() {Console.WriteLine("B.F");}
}
Utilização explícita de override reduz
class PolymorphismApp { o problema da classe base frágil
public static void Main(){
B b = new B();
A a = b; método chamado depende do tipo do objeto
a.F(); // B.F referenciado (determinado em tempo de
execução – late binding) e não do tipo da
b.F(); // B.F variável que guarda a referência (determinado
} em tempo de compilação – early binding)
}
 72
Classes e Métodos Abstratos
 Classe abstrata: não pode ser instanciada (só classes
derivadas podem ser instanciadas)
 Método abstrato: não tem implementação na classe em que
é declarado (só em classes derivadas)
 Classe tem de ser abstrata
 É implicitamente virtual (mas não leva virtual)
public abstract class Shape {
public abstract void Resize(double factor);
public void DoubleSize() { Resize(2.0); }
}

public class Box: Shape {

public override void Resize(double factor)
{ ... }
}  73
Classes e Métodos Selados
 Classe selada: não pode ser usada como base doutra classe

sealed class X {}

class Y : X {} // Erro!

 Método selado: não pode ser overriden

class A { public virtual void F() {} }

class B : A { public sealed override void F()

{} }

class C: B { public override void F() {} } //

Erro!
 74
Construtores
 Seguem as regras do C/C++
 Mesmo nome da classe
 Sem tipo de retorno
 Podem ter ou não argumentos

public class MyClass {

...
public MyClass() { ... }
public MyClass(String Title) { ... }
}
 75
Criação de objetos

// definição da classe
public class MyClass { ... }

// definição da variável
MyClass obj;

// criação do objeto
obj = new MyClass();

 76
Interfaces
 Um interface define um contrato ao qual tem de aderir
qualquer classe ou estrutura que o implemente
 Membros: métodos, propriedades, eventos e indexadores
 sem implementação
 a fornecer por classes ou estruturas que implementam o interface
 implicitamente públicos e de instância (não estáticos)
 pode-se usar new para esconder membro herdado
 Herança múltipla:
 um interface pode herdar de múltiplos interfaces
 uma classe ou estrutura pode implementar múltiplos interfaces
 Nome: habitual começar com letra "I”

 77
 Interfaces
Exemplo
public delegate void StringListEvent(IStringList sender);

public interface IStringList {

void Add(string s);
int Count { get; }
event StringListEvent Changed;
string this[int index] { get; set; }
}

public class StringList : IStringList {

private string[] strings;
public void Add(string s) { ... }
public int Count { get {return strings.Length} }
public event StringListEvent Changed;
public string this[int index] { get{...} set{...} }
}
 78
 Interfaces
Herança entre Interfaces
interface IControl {
void Paint();
}
interface ITextBox: IControl {
void SetText(string text);
}
interface IListBox: IControl {
void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {}

class MyComboBox : IComboBox {

public void Paint() { ... }
public void SetText(string text) { ... }
public void SetItems(string[] items) { ... }
}
 79
 Interfaces
Implementação explícita *
interface IDataBound
{
void Bind(IDataBinder binder);
}

class EditBox: Control, IDataBound

{
void IDataBound.Bind(IDataBinder binder) {...}
}

Nome completamente qualificado (com prefixo que

indica interface em que foi especificado) – só pode
ser acedido através de instância do interface

 80
Constantes
 Valor constante definido no momento da compilação
 Difere de campo imutável, cujo valor pode ser definido no momento
da execução
 Sintaxe: campo com prefixo const e inicialização
 São membros estáticos (partilhados), mas não levam
static
namespace System
{
public sealed class Math
{
public const double PI = 3.14159265358979323846;
public const double E = 2.7182818284590452354;
...
}
} 81 
Propriedades
 São “smart fields”
 Usados como campos
 Implementados por métodos set e/ou get
 Podem ser virtuais, abstractos, estáticos, etc. (como
métodos)
public class Button: Control
{
private string caption;

public string Caption {

get { return caption; }
set { caption = value; Repaint(); }
}
} Button b = new Button();
b.Caption = "OK";  82
string s = b.Caption;
Indexadores (indexers)
 São “smart arrays”
 Permitem usar objetos como arrays
 Implementados por métodos set e/ou get
 Podem ser overloaded
 Podem ser virtuais, abstractos, etc. (como métodos)
 Mapeados para propriedades com argumentos no CTS
public class ListBox: Control {
private string[] items;
public string this[int index] {
get { return items[index]; }
set { items[index] = value; Repaint(); }
}
} ListBox listBox = new ListBox();
listBox[0] = "hello";
Console.WriteLine(listBox[0]);  83
Exercício 2
 Crie um novo projeto C# de Console Application
 Adicione um novo arquivo de classes (.cs)
 Defina a interface IListaNomes, que deverá incluir:
 Adicionar novo nome à lista de nomes
 Retornar a listagem de todos os nomes presentes na lista
de nomes, sob a forma de uma cadeia de caracteres
 Limpar o conteúdo da lista de nomes

 84
Exercício 2 (continuação)
 Crie uma classe que implemente IListaNomes e crie
uma instância dessa classe na sua Console
Application. (Utilize a classe ArrayList para guardar os
nomes)
 Construa a Console Application de tal forma a utilizar
todas as funcionalidades fornecidas pela interface
IListaNomes
 Coloque breakpoints em cada método da classe e
verifique que cada método da mesma é chamado e
executado corretamente.

 85
Operadores e Instruções
Operadores e Instruções
 São basicamente os mesmos do C/C++, com alguns
melhoramentos para evitar erros comuns
 Instruções sem qualquer efeito são proibidas
i == 0; // Instrução não válida!

 Condições em if, while, for têm de ser do tipo

bool ou de um tipo convertível explicitamente para
bool (não há conversão implícita de int para
bool) int i = 1;
if (i) ... // Errado!
if (i != 0) .... // Certo!
 87
Instrução switch *

 Não faz fall-through, requer "goto case" ou

"goto default"
switch(opcao)
{
case 'a':
case 'A': // Certo
adicionar();
goto case 'R'; // Dá erro se não tiver isto!
case 'R':
refrescar();
break; // Opcional no último case ou default
}

 88
Instrução foreach

 foreach (type identifier in expression)

embedded-statement
 Iteração sobre arrays
public static void Main(string[] args)
{
foreach (string s in args)
Console.WriteLine(s);
}

 Iteração sobre colecções

void Display(System.Collections.ArrayList words)

{
foreach (string s in words)
Console.WriteLine(s);  89
}
Enumerações e Arrays
Enumerações
 Definem conjuntos de constantes simbólicas
 Conversão de/para inteiro, mas só explícita
 Operadores aplicáveis:
 comparação: == > < >= <= !=
 bit-a-bit: & | ^ ~
 outros: + - ++ -- sizeof
 Pode especificar-se o tipo subjacente (por omissão int)
 byte, sbyte, short, ushort, int, uint, long ou ulong
 Herdam implicitamente de System.Enum
enum Color: byte {
Red = 1,
Color c =
Green = 2,
Color.Red;
Blue = 4,
Black = 0,
White = Red | Green | Blue
}  91
Arrays uni-dimensionais
 Declaração com tipo de array e nome:
 int[] a; // array uni-dimensional de elementos do tipo int
 Criação (alocação):
 a = new int[4]; // cria array de 4 inteiros
 Tamanho é determinado ao criar (em tempo de execução)
 Índices são inteiros e começam em 0
 Inicializados com valores por omissão do respectivo tipo, ou
com valores (constantes) dados explicitamente:
 new int[] {1, 2, 3}; ou: new int[3] {1, 2, 3};
 Conversão entre arrays do tipo A[] e B[] realiza-se nas
mesmas condições que conversão entre tipos A e B
 object[] aceita qualquer array uni-dimensional
 92
Arrays de Arrays *
 Declaração
 int[][] a; //array uni-dimensional de elem's do tipo int[]
 Utilização
 int[] ai = a[i]; int aij = a[i][j];
 Sub-arrays têm de ser criados um a um
 int[][] a = new int[100][5]; // Erro
 int[][] a = new int[100][]; // Ok
for (int i = 0; i < 100; i++)
a[i] = new int[5];
 Sub-arrays podem ter tamanhos diferentes
 int[][] matrizTriang = new int[10];
for (int i = 0; i < 10; i++)
matrizTriang[i] = new int[i+1];
 93
Arrays multi-dimensionais *
 Declaração
 int[,] m; //array bi-dimensional de int's
 Criação
 m = new int[4,3]; // array 4x3
 Inicialização
 new int[,] {{0, 1}, {2, 3}, {4, 5}};
 new int[3, 2] {{0, 1}, {2, 3}, {4, 5}};//equiv.
 Conversão
 Só entre arrays com o mesmo nº de dimensões
 Tipo object[,] aceita qualquer array bi-dimensional

 94
Arrays
Métodos e propriedades
 Herdam implicitamente de System.Array
 Métodos estáticos: BinarySearch, Clear,
Copy, IndexOf, LastIndexOf, Reverse,
Sort, CreateInstance, ...
 Propriedades de instância: Length (dá o nº total de
elementos em todas as dimensões do array), Rank
(nº de dimensões do array)
 Métodos de instância: Clone, Equals,
GetLength (nº de elementos numa dada
dimensão),...

 95
Exercício 3
 Implemente um enumaration Clube
 Implemente um método que recebe um múltiplos
objetos do Tipo Clube e retorna o total de titulos
nacionais.

 96
Delegates e Eventos
Delegates
 São apontadores para funções orientados por objetos
 Tipo de delegate
 Sintaxe: assinatura de método com a palavra chave delegate
 Implicitamente derivado de System.Delegate
 Instância de delegate
 Encapsula zero ou mais entidades invocáveis - métodos estáticos ou
de instância, com assinatura idêntica à definida no tipo de delegate
 Usado como objeto (em atribuições, passagem de parâmetros,
etc.) ou como método (para invocar indirectamente as entidades
nele encapsuladas)

 98
Delegates
Exemplo
using System;
class DelegateApp {
// Declaração do tipo de delegate (assinatura)
public delegate void IntFunc(int n);
// Método a chamar indirectamente
static void F(int n)
{ Console.WriteLine("F called with n={0}", n); }
public static void Main() {
// Instanciação do delegate
IntFunc func = new IntFunc(F);

// Invocação indirecta de método

func(1);
}
}
 99
Eventos
Detalhes
 A assinatura do evento (ou melhor, dos métodos que tratam o evento) é
definida por um delegate com dois parâmetros:
 o objeto que disparou o evento
 um objeto da classe System.EventArgs ou classe derivada, com
informação sobre o evento
 O evento é definido num membro com a palavra-chave event,
seguida do nome do tipo de delegate que define a assinatura do evento,
seguido do nome do evento
 esse campo guarda a lista de métodos que tratam o evento (handlers)
 Registar um método que trata o evento:
 evento += new delegate-type(método)
 Disparar evento: evento(obj,args)
 métodos registados são invocados sequencialmente
 previamente testa-se se não é null (i.e., se há subscritores)  10
0
 Eventos
Definir e disparar
// tipo de delegate que define a assinatura do evento
public delegate void EventHandler(object sender,
EventArgs e);

public class Button { ou classe derivada

// campo que define o evento e memoriza handlers
public event EventHandler Click;

// método que dispara o evento

// (normalmente escondido de clientes)
protected void OnClick(EventArgs e) {
if (Click != null)
Click(this, e); // dispara aqui
}
}

 10
1
 Eventos
Registar handler e tratar
using System.Windows.Forms;
public class MyForm: Form {
Button okButton;
public MyForm() {
okButton = new Button();
okButton.Text = "OK"; regista handler
okButton.Click += new EventHandler(OkButtonClick);
Controls.Add(okButton);
Show();
} trata evento
void OkButtonClick(object sender, EventArgs e)
{ MessageBox.Show("You pressed the OK button"); }
public static void Main(string[] args)
{Application.Run(new MyForm());}
}

 10
2
 Exercício 4
public static void Main()
// compose.cs {
using System; MyDelegate a, b, c, d;

// Create the delegate object a that references

delegate void MyDelegate(string s); // the method Hello:
a = new MyDelegate(Hello);
// Create the delegate object b that references
class MyClass // the method Goodbye:
b = new MyDelegate(Goodbye);
{ // The two delegates, a and b, are composed
public static void Hello(string s) to form c:
c = a + b;
{ // Remove a from the composed delegate,
Console.WriteLine(" Hello, {0}!", s); leaving d,
// which calls only the method Goodbye:
} d = c - a;

Console.WriteLine("Invoking delegate a:");

public static void Goodbye(string s) a("A");
{ Console.WriteLine("Invoking delegate b:");
b("B");
Console.WriteLine(" Goodbye, {0}!", s); Console.WriteLine("Invoking delegate c:");
} c("C");
Console.WriteLine("Invoking delegate d:");
d("D");
}
}
Fim!!!
Dúvidas???

 10
4
Por que usar .net?
 Desempenho e escalabilidade melhores

 Maior Confiabilidade

 Implantação Fácil

 Novos Modelos de Aplicativos

 Produtividade do Desenvolvedor
Mercado de Trabalho
 Mercado escasso.

 Alto nível de salários.

 Mercado amplo, aberto e extremamente vazio.

 Alta aplicabilidade
 Comercial
 Coorporativa
 WEB
Empresas que Usam C#
 Misys
 http://www.misyshealthcare.com/

 All Scripts
 http://www.allscripts.com/

 Apply Solutions
 http://www.applysolutions.com.br/
Treinamentos
 Material GRATUITO on-line
 Programador 5 estrelas.
 Forum MSDN
 http://msdn.microsoft.com/pt-br/default.aspx
 Programa S2B
 Programa Dream Spark
 Programa Imagine Cup
 Microsoft IT Academy
 Microsoft Student Partner
 Material Pago
 Cursos .net e c# pagos
 Livros sobre a tecnologia.
Certificações
 http://www.microsoft.com/learning/en/us/certification/mcpd.aspx#tab2
 Realizadas pela Prometric
 http://www.prometric.com/Microsoft/default.htm
 Presente no Recife
 Provas em Inglês(em sua maioria)
 Entre 80 e 320 dollares por prova.
 Windows Developer 3.5 for developers who build rich client applications
for the Windows Forms platform by using the Microsoft .NET Framework
3.5.
 ASP.NET Developer 3.5 for developers who build interactive, data-driven
ASP.NET applications by using ASP.NET 3.5 for both intranet and Internet
uses.
 Enterprise Application Developer 3.5 for developers who build
distributed solutions that focus on ASP.NET and Windows Forms rich-client
experiences.