apostila c#

1

Projetos de Sistemas Web – C#

1) Linguagem C# ................................................................................................................ 2

1.1 Classes .................................................................................................................... 4

1.2 Objetos .................................................................................................................... 4

1.3 Atributos e Métodos ............................................................................................... 6

1.4 Método Main .......................................................................................................... 8

1.5 Comentários ............................................................................................................ 9

1.6 Tipos de Dados ..................................................................................................... 10

1.7 Variáveis ............................................................................................................... 11

1.8 Constantes ............................................................................................................. 14

1.9 Conversões de Tipos de dados.............................................................................. 14

1.10 Operadores ............................................................................................................ 16

1.11 Ordem dos Operadores ......................................................................................... 18

1.12 Strings ................................................................................................................... 19

1.13 Controle de Fluxo – If-Else .................................................................................. 22

1.14 Comandos de Repetição ....................................................................................... 23

1.15 Vetores .................................................................................................................. 24

1.16 Exceções ............................................................................................................... 25

1.17 Herança ................................................................................................................. 26

1.18 Métodos Estáticos (Métodos de classe) ................................................................ 29

2

1) Linguagem C#

C# é uma linguagem de programação orientada a objetos. A estruturação do

programa é semelhante à linguagem Java, com a diferença que muitas das palavras-chave

são provenientes da linguagem C++, além disso, C# herda vários conceitos da linguagem

C++, como struts, tipos sem sinal e sobrecarga de operadores.

Como qualquer linguagem orientada a objetos, C# oferece suporte a

encapsulamento, herança e polimorfismo, e no geral, sua sintaxe é muito semelhante à

linguagem Java, além de compartilharem muitas outras características.

Tanto Java como C# compartilham das seguintes características:

Ambas compilam em formado intermediário (há um arquivo intermediário

que é interpretado para executar o programa).

Usam coleta automática de lixo (as variáveis que não são mais utilizadas são

apagadas da memória automaticamente).

Todas as classes descendem de Object (há uma superclasse para todas as

classes e qualquer programa deve ser uma classe).

Não há funções globais nem constantes globais (a linguagem é puramente

orientada a objetos).

Não há herança múltipla:

o Em C++ tem-se tal recurso.

o Com isso , simplifica os programas.

o Interfaces visam suprir essa falta.

Utilizam exceções para manipular erros (os erros na execução do programa

são classificados e tratados de acordo com seu tipo).

Arrays são saltos verificados (um array é um bloco de memória dividido em

posições, porém a verificação automática dos limites ao acessar uma posição

no vetor, previne o acesso de uma área de memória fora do vetor).

A documentação da própria API pode ser obtida pela documentação do

código. (código e documentação da API estão juntas no mesmo arquivo).

Ambas utilizam pacotes/namespaces para evitar colisões de tipos (O sistema

de fontes distribuídos em diretórios evita conflitos de nomes).

Pode-se citar algumas características próprias da linguagem C#, que são as

seguintes:

Usa atributos de propriedades (atributos que já têm automaticamente setter e

getter).

Enumerações como em C++.

Struts (estruturas de dados sem métodos).

Os métodos são não-virtuais por padrão (ao sobrescrever um método, vale

por padrão a versão mais próxima de Object). Usar override para

sobreescrever.

Sobrecarga de operador (permite criar operadores que manipulam objetos).

Operadores de Conversão (permite criar operadores que convertem objetos

em outros).

3

Documentação em linha XML (a documentação da API é colocada no

código fonte no formato XML, depois a documentação pode ser recuperada

concatenando todas as partes XML).

Como visto anteriormente, a linguagem C# contém várias características, porém

somente algumas serão estudadas nesse curso, uma vez que o foco dessa disciplina é a

integração de C# com Asp.Net.

Para se começar a trabalhar com C#, pode-se utilizar o SDK do software Microsoft

.NET Framework que está disponível gratuitamente no site da Microsoft. Além disso,

pode-se trabalhar com C# diretamente no Microsoft Visual Studio, que será a forma

adotada nessa disciplina.

Para trabalhar com o SDK, deve-se baixar o SDK do Microsoft .NET Framework,

instalá-lo, e executá-lo pelo comando/aplicativo csc.exe que pode ser chamado pela linha

de comando. O comando csc /help exibirá as opções e modo de uso do SDK, por exemplo,

o comando csc /out:Hello.exe Hello.cs compila um programa C#, onde out é o nome do

executável gerado e Hello.cs é o nome do arquivo de código fonte.

Para se trabalhar com C# no Visual Studio pode-se compilar e desenvolver os

programas no ambiente do próprio Visual Studio. Para criar um aplicativo do tipo console

no C# deve-se ir no menu New Project e escolher Console Application e em seguida

escrever um nome para o projeto. Selecionar C# como linguagem de programação. Para

compilar deve-se apertar F6 e para executar deve-se apertar F5. Esse tipo de projeto é um

projeto C# de uma aplicação de console.

Ao criar um novo projeto de Console, é criado automaticamente uma classe básica

de teste. Ao ser executada, ela exibe uma mensagem e fecha, pois o programa termina. Para

manter o programa aberto e ver a mensagem após o término de sua execução, deve-se

inserir o comando Console.read() no final do método Main para paralisar a execução

enquanto o programa aguarda por uma entrada proveniente do teclado.

Existem vários ambientes de desenvolvimento para a linguagem C# na Internet,

como a SharpDevelop, que é um editor novo voltado a iniciantes que contem suporte a

outras linguagens, como Java.

No Visual Studio, aplicativos podem ser desenvolvidos visualmente arrastando

componentes. Para se criar um aplicativo Windows dessa forma com C#, deve-se ir no

menu File/New Project e selecionar Windows Application. Com isso um formulário será

exibido, onde podem ser inseridos componentes da toolbox.

Outra utilização de C# é através de scripts que são executados quando ocorrem

eventos no browser. O primeiro passo é criar um website que use a linguagem C#. Depois

disso, quando o usuário clicar nos botões de submissão dos formulários ou outros eventos,

deve-se escrever o código C# que será executado no servidor. Cada tela do site contém um

arquivo C# code-behind próprio, que contém uma classe C#, de forma que cada evento da

tela está relacionado a um método diferente nessa classe. Tais classes não precisam ter um

método Main.

4

1.1 Classes

Uma classe é uma entidade/conceito em um programa que contém atributos (seu

estado interno) e contém métodos (as operações que ela pode realizar). Um mesmo arquivo

de código fonte pode conter a definição de várias classes. A seguir, tem-se um exemplo de

declaração de classe:

using System;

namespace ConsoleApplication1

{

class Pessoa

{

public String nome;

public long cpf;

public long rg;

public int idade;

// Construtor da classe Pessoa

public Pessoa(String nome1, int idade1, long cpf1, long rg1)

{

nome = nome1;

idade = idade1;

cpf = cpf1;

rg = rg1;

}

}

}

Nesse exemplo, tem-se:

using: indica a importação de outras classes ou pacote contendo várias classes.

System é a biblioteca padrão.

namespace: indica o pacote (ou diretório) da classe.

class: indica que começou a declaração de uma classe. Além disso, indica o nome

da classe.

Atributos public podem ser acessados fora da classe.

Construtor: método que permite criar uma instância. Será visto adiante.

1.2 Objetos

Como visto anteriormente, uma classe define uma entidade no programa. Porém a

declaração de uma classe num arquivo de código fonte é apenas uma definição estática, ou

seja, a classe pessoa apenas indica tudo o que é relevante sobre uma pessoa, sem especificar

as diversas pessoas do sistema.

Um objeto é uma instância de uma classe, portanto, cada objeto é uma pessoa diferente

no sistema, ou seja, ao criar uma nova pessoa, os seus dados são preenchidos de acordo

com os atributos que estão especificados na classe. A figura a seguir é um exemplo de

classe e objeto.

5

Abaixo tem-se a classe Pessoa. A classe Pessoa contém quatro atributos, que são

nome, cpf, rg e idade. Logo a seguir, têm-se duas instâncias da classe Pessoa, que são

Instancia1 e Instancia2, que são objetos. Cada uma dessas instâncias é um objeto distinto,

porém compartilham a mesma classe, ou seja, compartilham as mesmas definições.

Pode-se ter infinitas instâncias de uma mesma classe e cada instância vai ser um

objeto diferente, ou seja, ele ocupa um espaço de memória próprio para si. Considere o

exemplo do cadastro de cliente de uma grande organização que tem centenas de clientes. A

classe será a definição estrutural de cada cliente no programa e os objetos corresponderão a

cada cliente cadastrado na organização.

Exercício 1 (com base na revisão em aula):

Crie um novo projeto de console C# e crie uma classe chamada Pessoa no arquivo

cs que foi criado.

Além de nome, CPF, RG e idade, insira o atributo endereço como String.

Na classe pessoa, crie um construtor que permita informar todos os dados de uma

pessoa.

Crie um método main na classe Pessoa. Esse método deve criar dois objetos pessoa

e, em seguida, deve escrever na tela o CPF dos dois objetos. Use o método

Console.WriteLine para escrever dados no console.

A seguir, o gabarito do exemplo: // Biblioteca Padrão

using System;

// Pacote da aplicação (nome do projeto)


{

// Definição da classe Pessoa

class Pessoa

{

// Atributos de instância

public String nome;

public int idade;

public long cpf;

public long rg;

6

public String endereco;


public Pessoa(String nome1, int idade1, long cpf1, long rg1,

String endereco1)

{

nome = nome1;

idade = idade1;

cpf = cpf1;

rg = rg1;

endereco = endereco1;

}

// Método programa

public static void Main(String[] args)

{

// cria dois objetos da classe Pessoa

Pessoa joao = new Pessoa("João", 20, 9999999999, 888888888,

"Avenida Independência, 123, Caxias do Sul - RS");

Pessoa paulo = new Pessoa("Paulo", 23, 123456789, 987654321,

"Avenida República, 999, Caxias do Sul - RS");

// escreve o cpf de ambos

Console.WriteLine(joao.cpf);

Console.WriteLine(paulo.cpf);

// espera antes de fechar o programa

Console.Read();

}

}

}

1.3 Atributos e Métodos

Em uma classe podem ser definidos atributos e métodos. Como visto, os atributos

determinam as características ou estado de um objeto. São declarados no corpo da classe,

por exemplo, nome, rg, cpf e idade do exemplo anterior. Os métodos são as operações que

aquele objeto pode realizar.

Os métodos podem ser compreendidos como funções, porém podem alterar apenas

os atributos do próprio objeto (ou atributos públicos de qualquer objeto). Um método tem

acesso total aos atributos declarados dentro da classe, assim como acesso total a todos os

outros métodos da mesma classe.

Quando um objeto tenta acessar um atributo de um segundo objeto, o operador

ponto é usado para realizar o acesso ao atributo. Sua forma de utilização é objeto ponto

atributo (ou método). O operador ponto não é necessário quando um objeto tenta acessar

seus próprios atributos.

Um método pode alterar o estado interno de um objeto ou retornar dados do objeto.

Na criação dos métodos de um projeto de software, para descobrir a classe certa que deve

conter um determinado método, deve-se observar a qual entidade no programa que está

centrado o significado daquele método. Por exemplo, a classe Pessoa deve conter todas as

operações do conceito de pessoa.

7

Os métodos podem receber parâmetros e retornar dados. Por default, um método

pode acessar todos os atributos do objeto ao qual está inserido.

Os construtores são métodos especiais sem retorno que criam uma instância da

própria classe. Um construtor não deve ter retorno e o nome dele deve ser o mesmo nome

da classe. Essas características identificam um construtor. Em C# é permitido sobrecarga de

construtores, nesse caso, variam os parâmetros entre os diversos construtores, porém eles

têm o mesmo nome.

Em C#, pode haver sobrecarga de métodos, nesse caso, ocorrem múltiplas

ocorrências de um método com o mesmo nome, porém, a sua assinatura (parâmetros) deve

ser diferente, ou seja, os parâmetros devem ser diferentes. Quanto ao retorno não conta para

definir uma assinatura. Cada método sobrecarregado pode retornar um tipo de dado

diferente se desejado.

O método Main é o método responsável por executar um programa. Ele será visto

adiante.

Exercício 2 (com base na revisão em aula):

Crie um novo projeto de console C# e crie uma classe chamada Cachorro no

arquivo cs que foi criado. Ela deve ter atributos que identifiquem um cachorro.

Na classe cachorro, crie um construtor que permita informar todos os dados de um

cachorro.

Depois crie um método latir, que deve escrever na tela qual cachorro está latindo.

Crie um método comer, que receba como parâmetro uma descrição da comida e

escreva na tela o que está comendo.

Crie um método main na classe Cachorro.

No método main, crie dois cachorros.

Ao rodar o programa, ambos os cachorros devem latir e comer alguma coisa.

Deve ser verificado no console os métodos que os cachorros executaram.

A seguir, o gabarito do exercício: // biblioteca padrão

using System;

// pacote (nome do projeto)


{

// declaração da classe cachorro

class Cachorro

{

// atributos de cachorro

public String nome;

public String raca;

// construtor da classe cachorro

public Cachorro(String nome1, String raca1)

{

// guarda os parametros dentro do objeto

nome = nome1;

raca = raca1;

}

8

// método latir

public void latir()

{

Console.WriteLine("Cachorro " + nome + " latindo: Au-au");

}

// método comer

public void comer(String nomeAlimento)

{

Console.WriteLine("Cachorro " + nome + " comendo: " +

nomeAlimento);

}

// método programa


{

// cria dois objetos distintos

Cachorro dipsy = new Cachorro("Dipsy", "Pastor Alemão");

Cachorro boby = new Cachorro("Boby", "Pitbull");

// chamando as operações

dipsy.latir();

boby.latir();

dipsy.comer("Ração para Filhote");

boby.comer("Ração para Adulto");

// aguarda o usuário digitar algo.

Console.Read();

}

}

}

1.4 Método Main

Quando se deseja executar um programa em C#, deve-se executar o arquivo cs que

contém alguma classe executável, ou seja, que contém um método Main. A assinatura do

método Main é mais comumente usada como public static void Main(){}. Podem ser

passados parâmetros ao método Main, porém recomenda-se utilizar a seguinte forma de

parâmetros: string[] args, por permitir receber uma lista de parâmetros. Além disso, o

método Main pode retornar void ou int. O exemplo a seguir escreve na tela todos os

parâmetros passados ao programa:

// biblioteca padrão

using System;

// pacote (nome do projeto)


{

// classe

class SayHello

{

// método programa que recebe um vetor de string

static void Main(string[] args)

9

{

// para cada parâmetro no vetor

foreach (string arg in args)

// escreve o parâmetro na tela

Console.WriteLine("Hello " + "{0}", arg);

// aguarda entrada do usuário

Console.Read();

}

}

}

Para se passar parâmetros para o programa no Visual Studio, deve-se ir no menu

Project e escolher propriedades do projeto (última opção). Escolher a opção debug e

preencher command line arguments.

Ao invés de retornar void, o método Main pode retornar um valor inteiro (int). Ao

retornar um inteiro, pode-se fazer com que o retorno do programa esteja relacionado com o

tipo de finalização do programa, indicando se ocorreu sucesso na execução ou erro, e ainda

um código que determina o tipo de erro.

1.5 Comentários

Em C#, os comentários de linha simples são escritos com duas barras e os

comentários de linhas múltiplas são escritos com barra asterisco, como no exemplo abaixo:

Using System;


{

class SayHello

{

// método main


{

/* para cada parametro arg

escreve o parametro na tela

*/



// espera o usuario digitar uma tecla

Console.Read();

}

}

}

Deve-se comentar sempre os programas desenvolvidos de forma que explique

realmente a funcionalidade dos mesmos. A inclusão de comentários ajuda na legibilidade

do programa, além de oferecer uma visão de como o programa funciona. Programas

complexos com comentários que não explicam a semântica do programa podem se tornar

ilegíveis. Outro fator a favor do uso de comentários é que comentários não aumentam o

tamanho do executável.

10

Para criar comentários de documentação, deve-se usar os comentários de

documentação XML. Através de tais comentários, pode-se criar uma documentação da API

voltada ao código fonte, semelhante a Java com Javadoc. Essa documentação é gerada no

formato XML e pode explicar o funcionamento de cada classe, método e membros.

Existem várias tags XML suportadas na documentação do código, cada uma tendo uma

função específica. A seguir tem-se um exemplo simples de comentário XML:

Using System;

/// <summary>

/// ConsoleApplication é um pacote

/// que contém um objeto simples

/// de teste.

/// </summary>


{

class SayHello

1.6 Tipos de Dados

Em toda a plataforma .NET é usado o sistema CTS (commom type system) que

permite a conversão automática de tipos de dados entre linguagens quando ocorre troca de

dados entre programas de diferentes linguagens do visual studio (aspx, c#, j#, vb e outros).

Essas conversões são realizadas automaticamente pela plataforma, por exemplo, quando

uma tela aspx chama um método de uma classe C# que tem parâmetros, os parâmetros são

automaticamente convertidos de aspx para C#, sem perda de informações, sem o usuário

precisar se preocupar com como a conversão é feita.

Existem diversos tipos de dados primitivos disponíveis na linguagem C#. Em C#,

todos os tipos de dados primitivos provém do namespace system, portanto, deve-se

importar System (colocar using System) em todos os programas, dentro do System, por

exemplo, bool corresponde à System.Boolean. Os tipos de dados básicos da linguagem C#

são os seguintes:

11

1.7 Variáveis

Na linguagem C#, todas as variáveis devem ser declaradas antes de serem

utilizadas, pois do contrário será informado um erro de compilação ao tentar executar o

programa. Além disso, o tipo de cada variável deve ser informado na declaração.

Pode-se definir o valor de uma variável na sua declaração. Múltiplas variáveis

podem ser declaradas no mesmo comando de declaração.

O tipo de uma variável pode ser um tipo básico visto anteriormente, um tipo de

classe, sendo no caso uma declaração de objeto e ainda outros tipos, como struts e outros.

Para criar um novo objeto, usa-se o comando new.

Exercício 3:

Crie um novo projeto de console C# e crie uma classe chamada Coordenada no

arquivo cs que foi criado. Ela deve ter atributos de instância x e y inteiros.

Crie um construtor para Coordenada.

Crie um método Main numa nova classe. No método Main, crie duas coordenadas e

escreva o seu conteúdo. Use variáveis locais para criar o conteúdo das duas

coordenadas.

A seguir o gabarito do exemplo:

Using System;

using System.Collections.Generic;

using System.Text;


{

12

// Classe coordenada

public class Coordenada

{

// variavel de instancia x e y

public int x, y;

// construtor que inicializa a instancia

public Coordenada(int x1, int y1)

{

x = x1;

y = y1;

}

}

// classe programa

public class Programa

{

// método programa


{

// criando variaveis locais a b e c

int a = 1, b = 2, c = 3;

// criando objetos c1 e c2

Coordenada c1 = new Coordenada(a, b);

Coordenada c2 = new Coordenada(3, 4*c);

// escrevendo as variaveis de instancia da classe Coordenada

Console.WriteLine("c1(x,y)=(" + c1.x + "," + c1.y + "):

variáveis de instância de c1");

Console.WriteLine("c2(x,y)=(" + c2.x + "," + c2.y + "):

variáveis de instância de c2");

Console.Read();

}

}

}

Nesse exemplo, há dois grupos de variáveis, no primeiro grupo, situado logo após a

declaração da classe, são declaradas as variáveis de instância x e y ao simultaneamente. No

segundo grupo, logo após a primeira linha do método Main, são declaradas três variáveis a,

b, e c com valores inicializados. Existe uma diferença entre esses grupos de variáveis que é

comentada a seguir:

Há três tipos de variáveis (quanto ao escopo):

Variáveis de Instância: É uma variável que pertence à instância, ou seja, toda a

instância tem uma cópia daquela variável. Ela é declarada no corpo da classe e cada

vez que uma instância é criada, ela é inicializada. Corresponde a x e y no exemplo

anterior.

Variáveis Locais: Uma variável local é uma variável que é declarada dentro de um

método. Ela só existe durante a execução do método (a não ser que seja guardada),

portanto quando o método for chamado, aquela variável é instanciada e inicializada,

e quando o método acabar, aquela variável é destruída. Corresponde à a, b e c no

exemplo anterior.

13

Variáveis de Classe: São variáveis que pertencem à classe e não à instância, ou seja,

a variável é única para todas as instâncias e não precisa haver uma instância para a

variável existir, apenas a classe. Tais variáveis são inicializadas apenas quando a

classe é carregada pela primeira vez. Elas são declaradas da mesma forma que as

variáveis de instância, com a diferença que elas contém o prefixo static.

A visibilidade de variáveis pode ser alterada através dos modificadores de acesso.

Em C#, tem-se as seguintes combinações de modificadores de acesso.

internal: O acesso à variável é limitado para o projeto local.

private: O acesso à variável é limitado para apenas dentro da classe que a contém.

protected: O acesso à variável é limitado à classe.

protected internal: O acesso à variável é limitado á classe ou projeto local.

public: O acesso à variável é irrestrito.

Quando uma variável é declarada, ela é inicializada com o valor default daquele

tipo. Uma exceção a essa regra é que as variáveis locais nunca são inicializadas

automaticamente, elas devem ser inicializadas manualmente no código. Isso ocorre por que

espera-se que as variáveis locais sejam usadas em seu escopo, que é limitado.

As variáveis do tipo objeto são inicializadas com null.

A seguir, há um exemplo com uma melhoria sobre o código anterior. Com o uso de

uma variável de classe qtde, é contado o número de instâncias da mesma classe. Sempre

antes de criar um novo objeto, o programa escreve a quantidade de instâncias da classe

Coordenada.

using System;

using System.Collections.Generic;

using System.Text;


{

// Classe coordenada

public class Coordenada

{

// variavel de instancia x e y

public int x, y;

// variavel de classe que indica a quantidade de instancias

public static int qtde = 0;

// construtor que inicializa a instancia

public Coordenada(int x1, int y1)

{

x = x1;

y = y1;

qtde = qtde + 1;

}

}

// classe programa

public class Programa

14

{

// método programa


{

// criando variaveis locais a b e c

int a = 1, b = 2, c = 3;

// escreve 0 por que não há instâncias ainda

Console.WriteLine(Coordenada.qtde);

// escreve 1 por que foi criada uma instância

Coordenada c1 = new Coordenada(a, b);


// escreve 2 por que foi criado duas instâncias

Coordenada c2 = new Coordenada(3, 4*c);


// aguarda o usuario apertar enter

Console.Read();

}

}

}

1.8 Constantes

Constantes são variáveis cujo valor não pode ser modificado. Elas atuam como

qualquer outra variável e são declaradas com o prefixo const. Uma constante deve ser

inicializada no momento de sua declaração. Por exemplo:

const int d = 5;

1.9 Conversões de Tipos de dados

Quando uma variável deve ser atribuída a outra deve-se observar se a atribuição é

possível, ou seja, se ambos os tipos são compatíveis, e a variável que recebe deve ter

precisão igual ou maior a outra. Em C# tem-se dois tipos de conversões de variáveis:

Conversão Implícita: É o caso onde uma variável recebe um valor de precisão

menor que a sua, como atribuir um inteiro para um numero real ou, no caso de

um byte para um inteiro.

Conversão Explícita: É o caso onde um valor é convertido para outro tipo antes

de ser atribuído a uma variável. Por exemplo, deve-se converter um inteiro

para byte antes de atribuir o valor. Nesse caso, se o valor do inteiro for maior

que um byte haverá perda de informação e não será gerado um erro

informando essa perda de informação. O programa deve garantir que as

operações não sofram perda de dados. As varáveis são convertidas quando é

15

colocado o tipo-destino entre parênteses na frente da variável. Expressões mais

complexas para serem convertidas devem estar entre parênteses também.

O exemplo abaixo mostra várias conversões:

using System;


{

class SayHello

{


{

Teste teste = new Teste();

teste.teste();

Console.Read();

}

}

class Teste

{

public void teste()

{

byte a = 1; // variavel local Byte

int b = 1234; // variavel local Inteira

int c = a; // Conversao Implícita

double d = b; // Conversao Implícita

Console.WriteLine("c={0}", c);

Console.WriteLine("d={0}", d);

double e = 5.2344; // Variável Real

int f = (int)e; // Conversão Explícita

Console.WriteLine("f={0}", f);

}

}

}

Observe, que na declaração da variável c, ocorre uma conversão implícita, pois a

variável byte a é atribuída a variável inteira c. Essa é uma conversão de um tipo menor para

um tipo maior e é automática, pois a variável inteira pode conter um byte.

O mesmo ocorre na linha seguinte, onde um número inteiro é atribuído a um

número real. O número real pode conter um inteiro, e a conversão ocorre sem perda de

informação.

Na declaração da variável f, ocorre uma conversão explícita de double para int. Com

essa conversão vai ocorrer perda de informação, ou seja, a parte fracionária da variável e

será ignorada. Para ver a perda de informação, veja o resultado do programa:

16

Exercício 4:

Faça um programa que crie uma variável do tipo byte, uma int, uma long,

uma float e uma double, e inicialize elas. Nas operações a seguir, utilize

casting, caso necessário:

Atribua o valor da variável double para uma long.

Atribua o valor da variável long para a variável byte.

Some todas as variáveis e atribua para uma variável double.

Some todas as variáveis e atribua para uma variável long.

Imprima na tela o resultado das conversões.

1.10 Operadores

Existem diversos tipos de operadores que são oferecidos na linguagem C#. Os

principais operadores são:

Operadores Matemáticos:

Operador Descrição

+ Adição

- Subtração

* Multiplicação

/ Divisão

% Resto (Módulo)

Principais Operadores de Atribuição:

Operador Descrição

= Atribuição simples

+= Atribuição com adição

-= Atribuição com subtração

*= Atribuição com multiplicação

/= Atribuição com divisão

%= Atribuição com resto

&= Atribuição com AND

|= Atribuição com OR

Incremento e Decremento:

17

Os operadores de incremento e decremento são respectivamente ++ e --. O operador

de decremento aumenta o valor de uma variável em uma unidade, enquanto que o

decremento diminui em uma unidade.

Os operadores de incremento e decremento são operadores unários, ou seja,

precisam de apenas uma variável. Se o operador for colocado antes da variável (prefixado),

a primeira coisa que ocorrerá naquela expressão será o incremento, se for colocado após a

variável, o incremento ocorrerá após a execução da expressão total. Como exemplo, tem-se:

using System;


{

class Operators

{

static void Main()

{

int a = 10, b, c;

b = a++; // operação posfixa

c = ++a; // operação préfixa

Console.WriteLine("{0}", b);

Console.WriteLine("{0}", c);

b = b--; // operação posfixa

c = --c; // operação préfixa

Console.WriteLine("{0}", b);

Console.WriteLine("{0}", c);

Console.Read();

}

}

}

Que gera a seguinte saída:

Operadores Relacionais:

== Igual a

!= Diferente de

< Menor que

<= Menor ou igual a

> Maior que

>= Maior ou igual a

18

Operadores Lógicos

&& AND lógico

|| OR lógico

! Negação Lógica

Operador Ternário:

O operador ternário representa uma estrutura condicional, sendo o

equivalente a if-then-else. A forma de utilização do operador ternário exige 3

parâmetros, e tem a seguinte forma:

Expressão1 ? Expressão2 : Expressão3

Expressão1 é uma expressão lógica, que resulta em valor true ou false.

Expressão2 é uma expressãode qualquer tipo, assim como Expressão3.

Quando ao modo de execução do operador ternário, se Expressão1 for

verdadeiro, então, o resultado será Expressão2, caso contrário, será Expressao3.

Operadores ternários podem ser aninhados também. Um exemplo com

uso de operador ternário está a seguir:

using System;


{

class Operators

{

static void Main()

{

int a = 10, b = 5;

int c = a==b ? a : b;

Console.WriteLine("{0}", c); // resultado 5

Console.Read();

}

}

}

1.11 Ordem dos Operadores

A ordem dos operadores deve ser observada, pois pode alterar o resultado da

expressão. Para se alterar a ordem dos operadores, deve-se usar parênteses. Expressões

entre parênteses são executadas primeiro que as outras. A seguir, tem-se a tabela da ordem

de execução dos operadores em C#:

19

1.12 Strings

Strings são dados alfanuméricos. As literais String são rodeadas por aspas duplas.

Uma string é um objeto. Um objeto String é imutável, ou seja, não pode ser alterado.

Quando deseja-se alterar uma string, deve-se realizar a operação criando uma nova string e

atribuir o resultado a variável desejada. A seguir, um exemplo de uso de String:

Using System;


{

class ManipulacaoDeStrings

{

static void Main()

{

20

String s = "Hello World";

Console.WriteLine("Programa Teste");

Console.WriteLine(s);

Console.Read();

}

}

}

Como String são objetos, cada String contém todos os métodos da classe String.

Tais métodos permitem converter a string, concatenar, comparar e outras operações. Como

as strings são imutáveis, a string resultante da operação é retornada ao invés de alterar a

string original. Os principais métodos da classe String são:

Length: retorna o tamanho da string.

[int index]: recupera o caracter da posição index.

Concat(String str): concatena esse string a outro e retorna a string total.

Compare: permite comparar uma string com outra.

ToLower(): converte para lower case.

ToUpper(): converte para upper case.

Trim(): remove espaços em branco no início e fim do string.

Além disso, as strings podem ser concatenadas com o operador +. As strings

possuem alguns caracteres especiais que precisam ser escritos conforme a tabela a seguir:

Nova linha \r

Fim de linha \n

Tabulação \t

Barra \\

Exercício 5:

Faça um programa que tenha a classe Pessoa do Exercício 1.

No método Main, crie três pessoas com endereços distintos (sem país).

Verifique se a string endereço de cada pessoa contém o nome: “Julio de

Castilhos”.

Depois disso, concatene ao endereço de cada pessoa o país do endereço.

Escreva o endereço de cada objeto na tela.

A seguir, o gabarito do exercício: using System;

using System.Text;


{

// Definição da classe Pessoa

class Pessoa

{

21

// Atributos de instância

public String nome;

public int idade;

public long cpf;

public long rg;



public Pessoa(String nome1, int idade1, long cpf1, long rg1,

String endereco1)

{

nome = nome1;

idade = idade1;

cpf = cpf1;

rg = rg1;


}


{

// criando três objetos pessoa

Pessoa joao = new Pessoa("João", 20, 111, 123, "Avenida

Paulista, 2332, Edifício Excalibur, São Paulo, SP");

Pessoa pedro = new Pessoa("Pedro", 21, 121, 134, "Julio de

Castilhos, 5233, Edifício Pérola, Caxias do Sul, RS");

Pessoa ademar = new Pessoa("Ademar", 23, 345, 345, "Avenida

Independência, 1111, Porto Alegre, RS");

// verifica se a rua é julio de castilhos

Console.WriteLine(joao.endereco.Contains("Julio de

Castilhos"));

Console.WriteLine(pedro.endereco.Contains("Julio de

Castilhos"));

Console.WriteLine(ademar.endereco.Contains("Julio de

Castilhos"));

// concatena o país no endereço.

// como strings são imutáveis, devem ser criados novos

objetos

joao.endereco = joao.endereco + ", Brasil";

pedro.endereco = pedro.endereco + ", Brasil";

ademar.endereco = ademar.endereco + ", Brasil";

// escrevendo os novos enderecos

Console.WriteLine(joao.endereco);

Console.WriteLine(pedro.endereco);

Console.WriteLine(ademar.endereco);

// espera dgitar enter

Console.Read();

}

}

}

Gerando o seguinte resultado:

22

1.13 Controle de Fluxo – If-Else

Para desviar o fluxo de execução do programa, pode-se usar a instrução if-else. A

instrução if testa uma afirmação lógica (valor booleano). Se o resultado for verdadeiro, será

executado o bloco de comando do if. Se o resultado for falso, será executado o bloco de

comando do else.

Um exemplo de uso do comando if é o seguinte:

using System;

using System.Text;


{

public class Pessoa

{

public String nome;


public Pessoa(String nome1, String endereco1)

{

nome = nome1;


}

public void testeStrings()

{

int x = 3;

double y = Math.Sqrt(3);

if (x >= y)

Console.WriteLine("x é maior");

else

Console.WriteLine("x é menor");

if (endereco.Contains("Avenida Paulista"))

{

Console.WriteLine("Endereço na Avenida Paulista");

}

else

Console.WriteLine("Endereço é em outra rua");

}


{

23

Pessoa joao = new Pessoa("João", "Avenida Paulista, 2332,

Edifício Excalibur, Próximo Livraria Cultura");

joao.testeStrings();

Console.Read();

}

}

}

Gera o seguinte resultado:

Exercício 6:

Faça um programa em C# que verifica se dois números passados pela linha de

comando são múltiplos.

O programa deve escrever “são múltiplos” quando forem múltiplos, e caso

contrário, “não são múltiplos”.

1.14 Comandos de Repetição

Para se executar um determinado bloco de comando várias vezes, deve-se usar os

comandos de repetição. O comando mais básico é o while. O comando while executa um

determinado bloco de comandos enquanto uma determinada condição for verdadeira.

Por exemplo, tem-se o seguinte programa que escreve todos os números menores que

10:

using System;

using System.Text;


{

public class Teste

{


{

int x = 0;

Console.Write("Números menores que 10:");

while (x < 10)

{

Console.WriteLine(x);

x = x + 1;

}

Console.Read();

}

}

}

24

Outro comando é o for. Ele permite iterar entre um determinado intervalo de valores.

O exemplo a seguir ilustra o uso do for:

using System;

using System.Text;


{

public class Teste

{


{

for (int x = 234; x < 545; x++)

{

Console.WriteLine(x);

}

Console.Read();

}

}

}

A instrução break pode parar um laço de repetição.

A instrução continue termina a iteração corrente e inicia a próxima.

O comando foreach permite iterar entre todos os elementos de um vetor. O seu uso

ocorre da seguinte forma:

Using System;


{

class SayHello

{


{



Console.Read();

}

}

}

Exercício 7:

Faça um programa que receba dois números inteiros pela linha de comando e

escreva todos os números inteiros que estão entre aqueles dois números.

1.15 Vetores

Um vetor armazena uma coleção de valores ou objetos. Todo o vetor tem um tipo (que

é o tipo de elementos que ele pode guardar) e um tamanho. As posições no vetor iniciam

25

em zero. O atributo Length retorna o tamanho do vetor. O exemplo a seguir lê 20 strings do

teclado e coloca em um vetor com 20 posições. Observe o uso do for:

using System;

using System.Text;


{

public class Teste

{


{

String[] nomes = new String[20];

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

{

nomes[x] = Console.ReadLine(d);

}

Console.Read();

}

}

}

Quando um vetor é inicializado, é informado o tamanho do vetor. Seus elementos são

criados com o valor default, sendo null para objetos. O próprio vetor é um objeto. Se o

vetor não for inicializado na sua declaração, ele terá o valor default null.

Matrizes podem ser criadas da mesma forma que vetores, com a diferença que um

novo abre-fecha colchetes é adicionado. As dimensões da matriz devem ser informadas na

sua inicialização.

Exercício 8:

Faça um programa em C# que lê 5 valores inteiros da entrada padrão

(Console.read) e insira os valores em um vetor de 5 posições.

Em seguida, o vetor deve ser percorrido para calcular a soma de todos os

elementos no vetor.

Escrever na tela a soma dos elementos.

1.16 Exceções

Quando ocorre um erro no programa, o programa é abortado. Porém, é possível definir

tratamento de erros em C# e continuar a execução do programa. O ideal nesses casos, é

capturar o erro, tratar da forma adequada mostrando uma mensagem de erro ao usuário e

retornar ao fluxo normal do programa, com as devidas correções.

Para definir um bloco de código que seja capaz de prever exceções, deve-se usar o

comando try-catch. Como a própria exceção é um objeto, existem vários tipos de exceção,

pois toda a exceção deriva da classe Exception, sendo assim cada exceção uma classe

diferente. O comando finally define um bloco de código de limpeza, que é executado

independentemente de uma exceção ter sido lançada ou não. Execute esse programa no

Visual Studio para ver o lançamento e a captura da exceção. Nesse programa, é criado um

26

vetor com duas posições, porém ele tenta acessar uma posição além do limite do vetor. Ao

fazer isso, é lançada uma exceção do tipo IndexOutOfRangeException. O comando catch

define o tratamento da exceção.

Using System;


{

public class Teste

{


{

try

{

String[] nomes = new String[2];

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

{

nomes[x] = Console.ReadLine();

}

}

catch (IndexOutOfRangeException e)

{

Console.WriteLine("fora do limite do vetor");

}

finally

{

Console.WriteLine("Limpeza");

}

Console.Read();

}

}

}

Em C# é possível criar novas exceções estendendo a classe ApplicationException

(por herança). O comando throw permite lançar (ou relançar) exceções.

É recomendável criar exceções públicas, para que possam ser manipuladas por

outros códigos, dessa forma.

1.17 Herança

É a relação entre duas classes na qual uma herda tudo o que a outra contém, ou seja,

todos os atributos e métodos que a superclasse tem, a subclasse também tem. Em C#, todos

os métodos são virtuais por default, ou seja vale a versão da superclasse. O modificador

override permite fazer com que valha a versão da subclasse. Para definir uma relação de

herança, deve-se informar a superclasse na definição da classe (com dois pontos).

Exemplo de classe com relação de herança:

Using System;

using System.Text;

27


{

public class Animal

{

public String nome;

public String especie;

public Animal(String nome1, String especie1)

{

nome = nome1;

especie = especie1;

}

public void caminhar()

{

Console.WriteLine("Animal Caminhando: " + nome);

}

}

public class Gato : Animal

{

String dono;

public Gato(String nome1, String especie1, String dono1) :

base(nome1, especie1)

{

dono = dono1;

}

public void miar()

{

Console.WriteLine("Gato Miando: " + nome + ":" + dono);

}

}

public class Teste

{

public static void Main(string[] args)

{

Animal a = new Animal("Golfinho", "mamífero");

a.caminhar();

Gato g = new Gato("felix", "felino", "Paulo");

g.caminhar();

g.miar();

Console.Read();

}

}

}

No construtor de uma subclasse, deve-se colocar o código que inicializa a instância

que está sendo criada da subclasse, ou seja, suas personalizações.

Ao declarar um construtor de uma subclasse, deve-se chamar o construtor da

superclasse antes de qualquer coisa. Usa-se o comando base para definir qual o construtor

da superclasse que é chamado na inicialização da subclasse.

28

Public Gato(String nome1, String especie1, String dono1) : base(nome1,

especie1)

A relação de herança entre gato e animal estabelece que cada objeto gato também é

um objeto animal, mas o contrário não é verdadeiro.

public class Gato : Animal //animal: superclasse

Animal é a superclasse a gato é a subclasse. Gato herda todos os métodos e atributos

públicos de Animal:

Public class Gato : Animal

Veja o resultado da execução do programa anterior:

A palavra this se referente sempre a própria instância, ou seja, ela é a própria

instância. Ao retornar this, será retornada a própria instância. Dentro de uma classe, os

atributos da instância podem ser acessados também por this.nomeAtributo, que é o mesmo

que apenas acessar pelo nome do atributo.

Quando é declarada uma variável local cujo nome é igual a uma variável de instância,

a variável de instância somente poderá ser acessada através de this, pois a última declaração

é a que vale, e a última declaração é a variável local.

Recriando a classe Pessoa do primeiro exemplo usando this no construtor, temos o

seguinte código:

using System;


{

class Pessoa

{

public String nome;

public int idade;

public long cpf;

public long rg;


public Pessoa(String nome, int idade, long cpf, long rg, String

endereco)

{

this.nome = nome;

this.idade = idade;

this.cpf = cpf;

this.rg = rg;

29

this.endereco = endereco;

}

}

}

1.18 Métodos Estáticos (Métodos de classe)

São métodos que contém o prefixo static. Como eles são métodos de classe, eles não

podem acessar as variáveis de instância da própria classe na qual estão inseridos. Além

disso, os métodos estáticos não podem acessar os métodos de instância.

Portanto, métodos estáticos apenas podem acessar outros métodos estáticos e variáveis

estáticas.

Isso ocorre por que dentro de um método estático, não existe instância, logo não

existem variáveis e métodos de instância.

Uma forma de se acessar tais métodos dentro do método estático, é criar um objeto do

mesmo tipo da classe. Agora aqueles métodos poderão ser acessados, mas somente através

da instância que foi criada, com operador ponto.

O método Main é um exemplo de método estático que não pode acessar variáveis

e métodos de instância.

Exercícios:

1. Faça um programa em C# que leia dois números e escreva na tela todos os números

inteiros entre os dois números.

2. Faça um programa em C# que leia um número e escreva na tela se o número é

primo ou não.

3. Faça um programa que crie uma classe pessoa e uma classe animal. A classe pessoa

deve ter o atributo nome e a classe animal deve ter o atributo nome e o atributo

especie. Crie uma classe PessoaXAnimal que guarda um objeto pessoa e um

animal de estimação, possibilitando assim, uma mesma pessoa ter vários animais

de estimação. Crie três objetos pessoa e quatro objetos animal. Defina os donos de

todos os animais de estimação criando instâncias da classe PessoaXAnimal.

Escreva na tela todos os objetos criados.

4. Faça um programa que leia um vetor de números inteiros do teclado e escreva o

maior elemento do vetor.

5. Crie uma classe Animal e uma classe gato e uma classe cachorro que são filhas de

Animal. A classe animal deve ter o método comer. Redefina esses métodos nas

classes filhas. Escreva na tela os resultados.

Documents

apostila c#