ApostilaC Muito Boa

Bacharelado em Informática
Programação Visual (C#)
Profa. Msc. Liliane Jacon
2. Semestre / 2009
INDICE
1. HISTÓRICO E PRIMEIROS EXEMPLOS....................................................................................................................... 3
1.1 Ambiente do Visual Studio .................................................................................................................................. 3
2. MÉTODOS DE PROGRAMA EM C#.............................................................................................................................. 6
2.1 Métodos da classe Math ....................................................................................................................................... 6
2.2 Utilizando Arrays (vetores).................................................................................................................................. 6
2.3 Passagem de Parâmetros (VETORES) por Valor e por Referência ..................................................................... 7
2.4 Método da Bolha (Ordenação/Classificação)....................................................................................................... 8
3. CONCEITOS DE POO...................................................................................................................................................... 9
3.1 Encapsulamento, Atributos e métodos, Ocultação da informação ....................................................................... 9
3.2 Modificadores de Acesso (public e private)....................................................................................................... 11
3.3 Construtores ....................................................................................................................................................... 11
3.4 Utilização de SET´s e GET´s / Propriedades ..................................................................................................... 13
3.5 Composição: referências a objetos como variáveis de instância de outras classes ............................................ 15
3.6 Usando a referência THIS .................................................................................................................................. 16
4. HERANÇA ...................................................................................................................................................................... 17
5. TRABALHO DE HERANÇA ......................................................................................................................................... 23
6. POLIMORFISMO ........................................................................................................................................................... 28
6.1 conversâo de objetos da classe derivada para objetos da classe base................................................................. 28
6.2 Classes Abstratas................................................................................................................................................ 29
6.3 Interface ............................................................................................................................................................. 32
7. EXCEÇÃO....................................................................................................................................................................... 34
7.1 DivideByZeroException .................................................................................................................................... 34
7.2 Criando uma classe separada para tratamento da Exceção................................................................................. 35
7.3 Testando estouros com os operadores CHECKED e UNCHECKED ................................................................ 36
8. CONTROLES/COMPONENTES VISUAIS SIMPLES.................................................................................................. 37
8.1 Label, Textbox e Button..................................................................................................................................... 37
8.2 Groupbox e Panel............................................................................................................................................... 37
8.3 Exercicio: Calculadora ...................................................................................................................................... 38
8.4. Controle Com Guias (TabControl).................................................................................................................... 40
8.5 Trabalhando Com STRINGS ............................................................................................................................. 41
8.6 Indice, tamanho e metodo CopyTo .................................................................................................................... 42
8.7 Comparando Strings........................................................................................................................................... 42
8.8 Localizando caracteres e substrings em strings................................................................................................. 43
8.9 Exercicio ........................................................................................................................................................... 44
8.10 Trabalhando Com Messagebox ....................................................................................................................... 45
9. JANELA MDI (Janela Interna) & MENU ...................................................................................................................... 48
9.1 Exercício com Menu e Janela MDI................................................................................................................... 50
10. LISTA ENCADEADA .................................................................................................................................................. 53
10.1 Implementando Lista Encadeada com Interface Gráfica.................................................................................. 53
10.2 Utilizando ArrayList (Coleção de Strings)....................................................................................................... 59
10.3 Exercício utilizando Coleção do C# (LIST)..................................................................................................... 61
11. LISTBOX, COMBOBOX, CHECKEDLISTBOX E LINKLABEL ............................................................................. 63
11.1 Exercicio ListBox & ComboBox ..................................................................................................................... 65
11.2 LinkLabel ......................................................................................................................................................... 65
12. CRIANDO DLL´s (Dynamic Link Library) .................................................................................................................. 66
12.1 Herança Visual ................................................................................................................................................. 66
12.2 Utilizando UserControl .................................................................................................................................... 67
13. BANCO DE DADOS MySQL....................................................................................................................................... 69
13.1 Instalação do BD LIVROS e do MySQL......................................................................................................... 69
13.2 Diagrama de Relacionamento de Entidades do banco de dados LIVROS ....................................................... 70
13.3 Exercícios DML: Fazendo consultas e operações no BD Livros .................................................................... 70
14. ADO .NET ..................................................................................................................................................................... 71
14.1 Primeira Aplicação ADO. NET (Controle Alunos) ......................................................................................... 73
14.2 Utilizando um ComboBox para visualizar a descrição da Chave Estrangeira ................................................. 75
14.3 Relatórios: Utilizando Crystal Report .............................................................................................................. 79
Programação Visual – C#
Profa. Liliane Jacon
1. HISTÓRICO E PRIMEIROS EXEMPLOS
O C# tem raízes em C, C++ e Java.

Trata-se de uma linguagem visual dirigida por eventos e total/ee orientada a objetos.
A Microsoft sabedora das necessidades do mercado para :
• Aplicativos baseados na Web
• Ferramentas de programação para dispositivos eletrônicos móveis (por ex telefones
celulares)
Para atender essas necessidades a Microsoft anunciou sua iniciativa .NET (dot.net ou
ponto.net) em junho de 2000.
A plataforma .NET possibilita que os aplicativos baseados na Web possam ser distribuídos
para uma grande variedade de dispositivos (até telefones celulares) e p/computadores de mesa.
Ela é independente de uma linguagem, permitindo que os programadores criar aplicativos em uma
linguagem compatível com essa tecnologia (código nas linguagens .NET compreendem C#,
Visual C++.NET, Visual Basic.NET Java, JScript, Pascal, Perl entre outras)
1.1 Ambiente do Visual Studio

Solution Explorer: lista todos os arquivos da solução. Quando o Visual Studio é carregado, o
solution explorer está vazio. Quando um novo projeto é criado, o solution explorer exibe o
conteúdo desse projeto.
ToolBox (caixa de ferramentas): os programadores podem arrastar e soltar controles em um
formulário. Existem grupos de componentes relacionados (Common Controls, Containers, Data,
Components, Windows Forms).
Janela Properties: Permite a manipulação das propriedades do controle. Na ilustração abaixo,
mostra as propriedades do FORM. A coluna da direita mostra seus valores atuais. O ícone
EVENTS permite que o controle ou formulário responda a certas ações do usuário.
3
1o. exemplo) Imprimindo uma linha de texto
using System; // acrescentando biblioteca
class Primeiro
{
static void Main (string[] args)
{
Console.WriteLine(“Inicio da programação com C#”);
string pausa = Console.ReadLine();
} /* comentario
} */
2o. exemplo) Exibindo uma caixa de texto

using System.Windows.Forms;
class Segundo
{
{
MessageBox.Show(“Inicio da programação com C# \n parte 2”);
} /* comentario
} */
3º. Exemplo) Somando dois números

class SomaNumeros
{
{
string primeiroNumero, segundoNumero;
int num1, num2, soma;
Console. Write( “favor entre com primeiro numero inteiro: “);

primeiroNumero = Console.ReadLine();
Console. Write( “favor entre com segundo numero inteiro: “);

segundoNumero = Console.ReadLine();
num1 = Int32.Parse(primeiroNumero);
num2 = Int32.Parse(segundoNumero);
soma = num1 + num2;
Console.WriteLine(“\n A soma eh {0 } ”, soma);

Console.WriteLine (“\nOs números foram {0} e {1} “,num1, num2);
} /* comentario
} */
Operador Precedência == Igualdade

( ) parênteses 1ª. != Diferente
* / ou % 2ª. > Maior
+ ou - 3ª < Menor
>= Maior igual
<= Menor igual
Faça um algoritmo para ler as notas de 10 alunos. Calcular a média da classe.
4
class MediaClasse
{
{
int media, somaTotal, contador, nota;
somaTotal = 0;
contador = 1;
while (contador <= 10)

{
Console. Write( “entre com a nota do aluno: “);
nota = Int32.Parse(Console.ReadLine());
somaTotal = somaTotal + nota;
contador = contador + 1;
}
media = somaTotal / 10;
Console. WriteLine( “\n\nMedia da classe = {0} “, media);
} /* comentario
} */
Refaça o exercício, mas agora o número de alunos é indeterminado. (entra lido, sai lido)
Faça um algoritmo para calcular quantos alunos foram aprovados e qtos foram reprovados. O
número de alunos é indeterminado.
using System;
class AnaliseClasse
{
{
int media, somaTotal, contAprovado, contReprovado, nota;
somaTotal = 0;
contAprovado = 0; contReprovado = 0;
Console.Write( “entre com a nota do aluno (-1 finaliza): “);
while (nota != -1)

{
somaTotal = somaTotal + nota;
if (nota >= 60)

contAprovado = contAprovado + 1;
else
contReprovado = contReprovado + 1;
Console.Write( “entre com a nota do aluno (-1 finaliza): “);

}
media = somaTotal / 10;
5
Console. WriteLine( “\n\nMedia da classe = {0} “, media);
Console. WriteLine( “\nAprovados = {0} e Reprovados = {1} “, contAprovado, contReprovado);
} /* comentario
} */
2. MÉTODOS DE PROGRAMA EM C# double

2.1 Métodos da classe Math
Console.WriteLine( Math.Sqrt(900.0)); // resultado = 30.0 (doublé)
Console.WriteLine ( Math.PI ); // exibe 3,14159265358979323846
Cos (x ) Cos (0.0) é 1.0

Pow (x, y) X elevado a y
Pow (2,3) = 23 = 8
Sin (x )
Sqrt ( x )
Tan ( x )
Floor ( x ) Arredonda x para o maior inteiro não maior que x
Floor (9.2) = 9.0
Ceiling (x ) Arredonda x para o menor inteiro não menor do que x
Ceiling (9.2) = 10.0
2.2 Utilizando Arrays (vetores)

Os métodos permitem que o programador modularize o programa.
using System;
public class TrabalhandoComVetores
{
{
TrabalhandoComVetores r = new TrabalhandoComVetores();
r.geracao();
}
public void geracao()

{
int [] vetor = {1,2,3,4,5};
Console.WriteLine(“\nAntes de modificar o vetor\n”);
for (int i = 0; i < vetor.Length; i++)
Console. WriteLine( “\nVetor [ {0}] = {1} “, i,vetor[i]);
ModificaVetor (vetor);
Console.WriteLine(“\nDepois de modificar o vetor\n”);
Console. WriteLine( “\nVetor [ {0}] = {1} “, i,vetor[i]);
Console.WriteLine(“\nAntes de modificar o Elemento do Vetor[3]= {0}”, vetor[3]);
ModificaElemento (vetor[3]);
Console.WriteLine(“\nDepois de modificar o Elemento do Vetor[3]= {0}”, vetor[3]);
}
6
// o metodo modifica o vetor que recebe. O original será modificado
public void ModificaVetor( int [] v )
{
for (int i = 0; i < v.Length; i++)
v[i] = v[i] * 2;
}
// o metodo modifica o valor passado para ele. Mas o original não será modificado
public void ModificaElemento ( int elem)
{
Console. WriteLine( “\nElemento antes de modificar {0}“, elem);
elem = elem * 2;
Console. WriteLine( “\nElemento após modificar {0} dentro do metodo“, elem);
}
} // fecha a classe TrabalhandoComVetores
2.3 Passagem de Parâmetros (VETORES) por Valor e por Referência
using System;
public class PassagemParametros
{
{
PassagemParametros r = new PassagemParametros ();
r.inicializa();
}
public void inicializa()

{
int [] primVetor = {1,2,3};
int [] primVetorCopia = primVetor;
Console.writeLine(“\nTestando passagem primVetor por Valor\n”);

Console.writeLine(“\nExibe primVetor antes do Método ModificaPorValor\n”);
for (int i = 0; i < primVetor.Length; i++)
Console. writeLine( “\nVetor [ {0}] = {1} “, i,primVetor[i]);
ModificaPorValor (primVetor);
Console.writeLine(“\nExibe primVetor depois do Método ModificaPorValor \n”);
for (int i = 0; i < primVetor.Length; i++)
Console. writeLine( “\nVetor [ {0}] = {1} “, i,primVetor[i]);
if (primVetor == primVetorCopia)
Console.writeLine(“\nA referência do vetor refere-se ao mesmo array\n”);
else
Console.writeLine(“\A referência aponta que refere-se a arrays diferentes\n”);
int [] segVetor = {1,2,3};

int [] segVetorCopia = segVetor;
Console.writeLine(“\nTestando passagem segVetor por Referência\n”);

Console.writeLine(“\nExibe segVetor antes do Método ModificaPorReferencia\n”);
for (int i = 0; i < segVetor.Length; i++)
7
Console. writeLine( “\nVetor [ {0}] = {1} “, i,segVetor[i]);
ModificaPorReferencia ( ref segVetor);
Console.writeLine(“\nExibe segVetor depois do Método ModificaPorReferencia \n”);

for (int i = 0; i < segVetor.Length; i++)
Console. writeLine( “\nVetor [ {0}] = {1} “, i, segVetor[i]);
if (segVetor == segVetorCopia)
Console.writeLine(“\nA referência do vetor refere-se ao mesmo array\n”);
else
Console.writeLine(“\A referência aponta que refere-se a arrays diferentes\n”);
} // main
// o metodo modifica o vetor que recebe. O original será modificado

public void ModificaPorValor( int [] v )
{
v[i] = v[i] * 2;
// cria uma nova referência e a atribui ao array
v = new int [] { 11, 12, 13 };
} // ModificaPorValor
// o metodo modifica o valor passado para ele. Mas o original não será modificado
public void ModificaPorReferencia ( ref int[] v)
{
v[i] = v[i] * 2;
// cria uma nova referência e a atribui ao array
v = new int [] { 11, 12, 13 };
} // ModificaPorReferencia
} // fecha a classe PassagemParametros
2.4 Método da Bolha (Ordenação/Classificação)
using System;
public class Ordenacao
{
{
Ordenacao r = new Ordenacao ();
r.inicializa();
}
public void inicializa()

{
int [] vetor = new int[10];
Console.writeLine(“\n Entrada dos elementos do Vetor\n”);

{
Console. writeLine( “\nVetor [ {0}] = “, i);
vetor[i] = Int32.Parse(Console.ReadLine());
}
8
Bolha(vetor);
Console.writeLine(“\n Vetor Ordenado\n”);

Console. writeLine( “\nVetor [ {0}] = {1} “, I, vetor[i]);
} // inicializa
public void Bolha ( int [] b )

{
for ( int i = 1; i < b.Length; i++)
for ( int j = 0; j < b.Length - 1; j++)
if ( b[j] > b[j+1] )
{
int aux = b[j]; b[j] = b[j+1]; b[j+1] = aux;
}
} // bolha
} // Ordenacao
3. CONCEITOS DE POO
3.1 Encapsulamento, Atributos e métodos, Ocultação da informação

A orientação a objetos usa classes para encapsular (isto é reunir) dados (atributos) e métodos
(comportamentos). Os objetos tem capacidade de ocultar sua implementação de outros objetos
(esse princípio é chamado de ocultamento de informações).
Embora alguns objetos possam se comunicar uns com os outros, por meio de interfaces bem
definidas (assim como a interface do motorista com um carro inclui um volante, pedal acelerador,
pedal de freio e cambio), os objetos não sabem como os outros são implementados (assim como o
motorista não sabe como o volante, o motor, o freio, e os mecanismos de transmissão são
implementados). Em geral dos detalhes da implementação ficam ocultos dentro dos próprios
objetos. Certamente é possível dirigir um carro sem conhecer os detalhes do funcionamento dos
motores, das transmissões e dos sistemas de escape.
Em linguagens de programação procedimentais (como C) a programação tende a ser
orientada a ações. A programação C#, entretanto é orientada a objetos. Em C, a unidade de
programação é a função (as funções são chamadas de métodos em C#). Em C#, a unidade de
programação é a classe. Os objetos são eventualmente instanciados (isto é, criados) dessas
classes, e as funções são encapsuladas dentro dos limites das classes como métodos.
Os programadores de C se concentram na escrita de funções. Eles agrupam em uma função
ações que executam alguma tarefa e, então agrupam as funções para formar um programa.
Certamente, os dados são importantes em C, mas eles existem principalmente para suportar as
ações que as funções executam. Os verbos (calcule, verifique, busque) em um documento de
requisitos de um sistema descrevendo os requisitos de um novo aplicativo, ajudam o programador
de C a determinar o conjunto de funções que trabalharão juntas para implementar o sistema.
Em contraste, os programadores C# se concentram na criação de seus próprios tipos
definidos pelo usuário, chamados classes. Também nos referimos as classes como tipos definidos
pelo programador. Cada classe contem dados e um conjunto de métodos que manipulam dados.
Os componentes de dados ou membros de dados de uma classe são chamados de variáveis de
instancia. Em C#, a atenção é focalizada nas classes, em vez de métodos. Os substantivos em um
documento de requisitos (pessoa, funcionário, aluno, livro) ajudam o programador de C# a
determinar um conjunto inicial de classes com as quais vai começar o processo de projeto.
9
class VerificaTriangulo
{
int a, b, c;
public VerificaTriangulo(int va,int vb,int vc)
{
a = va; b = vb; c = vc;
}
public bool verificaFormacao()
{
if ((a < b + c)&&(b < a+c)&&(c < a + b))
return true;
else
return false;
}
public int verificaTipo()
{
if (verificaFormacao())
{
if ((a == b) && (b == c))
return 1; //equuilatero
else if ((a != b) && (b != c) && (c != a))
return 2; //escaleno
else return 3; //isosceles
}
else return -1; //não eh triangulo
}
public override string ToString()
{
string temp;
switch (verificaTipo())
{
case 1: temp = "Equilatero"; break;
case 2: temp = "Escaleno"; break;
case 3: temp = "Isosceles"; break;
case -1: temp = "Nao forma triangulo"; break;
}
return temp;
}
}
Interface (FORM) ligação com a classe VerificaTriangulo
namespace Triangulo
{
public partial class Form1 : Form
{
public Form1()
{ InitializeComponent(); }
private void bVerifica_Click(object sender, EventArgs e)

{
try
{ int a = Int32.Parse(tbA.Text);
int b = Int32.Parse(tbB.Text);
int c = Int32.Parse(tbC.Text);
VerificaTriangulo TR = new VerificaTriangulo(a, b, c);
lSaida.Text = TR.ToString();
}
catch (Exception erro)
{ MessageBox.Show("entre com os valores primeiramente..."); }
}
}
}
10
3.2 Modificadores de Acesso (public e private)

As 3 variáveis de instância Hora, Minuto e Segundo foram declaradas com o modificador de acesso
PRIVATE, indicando que essas variaveis de instancia são acessíveis apenas para membros da classe
– isso é conhecido como ocultamento de dados.
Isto indica que apenas os métodos dentro da classe conseguem enxergar as variáveis de instancia
Hora,Minuto e Segundo.
Normalmente, as variáveis de instancia são declaradas como PRIVATE e os métodos como PUBLIC.
É possível declarar de outra forma também (variáveis de instancia PUBLIC e/ou métodos PRIVATE,
conhecidos por serem métodos utilitários, usados só dentro da própria classe).
3.3 Construtores
Os constructores de uma classe podem ser sobrecarregados.
O C# chama o constructor apropriado fazendo corresponder o número, tipos e ordem dos
argumentos especificados na chamada do constructor com o número, tipos e ordem dos
parâmetros especificados em cada definição do constructor.
namespace Tempo
{
class ClasseTempo
{
private int hora; // de 0 a 23
private int minuto; // de 0 a 59
private int segundo; // de 0 a 59
public ClasseTempo() // constructor

{ SetTempo(0, 0, 0);//meia-noite
}
public ClasseTempo(int hora) // constructor so com hora
{
SetTempo(hora, 0, 0);
}
public ClasseTempo(int hora, int minuto) // constructor so com minuto
{
SetTempo(hora, minuto, 0);
}
public ClasseTempo(int hora, int minuto, int segundo)// constructor so c/segundo
{ SetTempo(hora, minuto, segundo);
}
11
public ClasseTempo(ClasseTempo tempo)// constructor c/um tempo anterior
{
SetTempo(tempo.hora, tempo.minuto, tempo.segundo);
}
public void SetTempo(int valorHora, int valorMinuto,int valorSegundo)
{
hora = (valorHora >= 0 && valorHora < 24) ? valorHora : 0;
minuto = (valorMinuto >= 0 && valorMinuto < 60) ? valorMinuto : 0;
segundo = (valorSegundo >= 0 && valorSegundo < 60) ? valorSegundo : 0;
}
// converte a hora para uma string no formato de hora universal (24 horas)
public string ToUniversalString()
{
// formato D2 =formato de numero digital base 10 - de dois digitos
return String.Format("{0:D2}:{1:D2}:{2:D2}", hora, minuto, segundo);
}
public string ToAmericanoString()
{
return String.Format("{0}:{1:D2}:{2:D2} {3}",
((hora == 12 || hora == 0) ? 12 : hora % 12),
minuto, segundo, (hora < 12 ? "AM" : "PM"));
}
}
}
Ligando a interface (Form) com a classe ClasseTempo

namespace Tempo
{
{
ClasseTempo T = new ClasseTempo();
public Form1()
private void bVerifica_Click(object sender, EventArgs e)

{
int h, m, s;
if ((tbHora.Text == "")&&(tbMinuto.Text=="")&&(tbSegundo.Text==""))
T = new ClasseTempo();//meia noite
else if ((tbHora.Text!= null)&&(tbMinuto.Text=="")&&(tbSegundo.Text==""))
{
h = Int32.Parse(tbHora.Text);
T = new ClasseTempo(h, 0, 0);//so hora
}
else if ((tbHora.Text !="")&&(tbMinuto.Text != "")&&(tbSegundo.Text==""))
{
m = Int32.Parse(tbMinuto.Text);
T = new ClasseTempo(h, m, 0); //hora+minuto
}
else// todos diferentes de null
{
m = Int32.Parse(tbMinuto.Text);
s = Int32.Parse(tbSegundo.Text);
T = new ClasseTempo(h, m, s);
}
string temp = "Americano=" + T.ToAmericanoString() + "\n" +
"Universal=" + T.ToUniversalString();
lSaida.Text = temp;
}
12
private void Form1_Load(object sender, EventArgs e)
{
tbHora.Clear();
tbMinuto.Clear();
tbSegundo.Clear();
}
private void bValida_Click(object sender, EventArgs e)

{
ClasseTempo tempo1 = new ClasseTempo();//00:00:00
ClasseTempo tempo2 = new ClasseTempo(2);//02:00:00
ClasseTempo tempo3 = new ClasseTempo(21, 34);//21:34:00
ClasseTempo tempo4 = new ClasseTempo(12, 25, 42);//12:25:42
ClasseTempo tempo5 = new ClasseTempo(27, 74, 99);//00:00:00 invalido
ClasseTempo tempo6 = new ClasseTempo(tempo4);//12:25:42
string saida;
saida = "Constructores utilizados: " +
"\nTempo1: todos argumentos são default" +
"\n " + tempo1.ToUniversalString() +
"\n " + tempo1.ToAmericanoString();
saida += "\nTempo2: hora especifica, minutos e segundos são default" +
saida += "\nTempo3: especificos Hora e minutos, segundos são default" +
saida += "\nTempo4: especificos Hora, minutos e segundos" +
saida += "\nTempo5: tempo com Hora, minutos e segundos invalidos" +
saida += "\nTempo6: tempo setado com o Tempo4" +
lTeste.Text = saida;
}
}
}
3.4 Utilização de SET´s e GET´s / Propriedades

Os métodos de uma classe odem manipular variáveis de instancia private desta classe. Suponha uma
classe ContaBancaria que tenha uma variável de instancia private SALDO. Um método para alterar o
saldo seria CalcularTaxadeJuros, por exemplo.
Frequentemente, as classes fornecem PROPRIEDADES public para permitir aos clientes configurarem
(isto é, atribuírem valores as) ou obterem (isto é, obterem os valores de) variáveis de instância Private.
Por exemplo, no exemplo abaixo temos três propriedades Hora, Minuto e Segundo que acessam as
variáveis de instancia hora, minuto e segundo respectivamente. Cada propriedade tem um acessor GET
(para recuperar o valor do campo) e um acessor SET (para modificar o valor do campo).
Se uma variável de instancia é private, um acessor get public parece permitir que outros métodos
leiam os dados a vontade. Entretanto, o acessor get pode controlar a formatação e exibir os dados. Um
acessor set public pode investigar tentativas de modificar o valor da variável de instancia, garantindo
assim que o novo valor seja apropriado para a variável de instancia. Por exemplo, uma tentativa de
configurar (set) o dia do mês como 37 seria rejeitada, e uma tentativa de configurar o peso de uma
pessoa com um valor negativo também seria rejeitada. Assim, os acessores set e get podem fornecer
acesso a dados private, mas a implementação desses acessores controla o que o código cliente pode
fazer com os dados.
13
class VerificaTriangulo
{
int a, b, c;
public int A
{
get { return a; }
set { a = (value >=0)? value : 1; }
}
public int B
{
get { return b; }
set { b = (value >=0)? value : 1; }
}
public int C
{
get { return c; }
set { c = (value >=0)? value : 1; }
}
public VerificaTriangulo(int va,int vb,int vc)
{
A = va; B = vb; C = vc;
}
public bool verificaFormacao()
{
if ((A < B + C) && (B < A + C) && (C < A + B))
return true;
else
return false;
}
public int verificaTipo()
{
if (verificaFormacao())
{
if ((A == B) && (B == C))
return 1; //equuilatero
else if ((A != B) && (B != C) && (C != A))
return 2; //escaleno
else return 3; //isosceles
}
else return -1; //não eh triangulo
}
{
string temp = "";
switch (verificaTipo())
{
case 1: temp = "Equilatero"; break;
case 2: temp = "Escaleno"; break;
case 3: temp = "Isosceles"; break;
case -1: temp = "Nao forma triangulo"; break;
}
return temp;
}
}
14
3.5 Composição: referências a objetos como variáveis de instância de outras
classes
Hierarquia de Agregação/decomposição
Agregação - Um objeto pode ser visto como um agregado de outros objetos (suas partes). Por
exemplo, numa casa típica, pode-se visualizar várias objetos que a compõem, a exemplo do
diagrama que se segue:
Este diagrama mostra que um objeto casa é composto por vários outros objetos. A relação
entre uma casa e suas partes componentes pode ser lida como:
- uma casa <é composta por> ..

- ma casa <é um agregado de>
- uma casa <é decomposta em>
...
e apresenta uma visão todo -> parte, ou seja, do objeto mais complexo para as partes que o
compõe. Uma mudança rápida de perspectiva possibilita um outro tipo de afirmações:
- o endereço <é parte da> casa
- os móveis <são parte da> casa
Exemplo: Classe Datas – Classe Empregado – Classe TestaEmpregado(main)

A classe DATE encapsula informações relacionadas a uma data específica. A classe
EMPREGADO encapsula o nome do funcionário e dois objetos DATE representando a data de
nascimento e de contratação do funcionário. A classe TestaComposição cria um objeto da classe
Empregado para demonstrar a composição
O uso de referências a objetos de classes já existentes, como membros de novos objetos, é
chamado de composição (ou agregação).
Classe DATE
using System;
public class Date {

private int mes; // de 1 a 12
private int dia; // 1 a 31
private int ano; // qq ano
public Date(int d, int m, int a)

{
if (m > 0 && m <= 12)
mes = m;
else
{
mes = 1;
Console.WriteLine("mes {0} invalido. setado como mes 1", m);
}
ano = a;
dia = verificaDia(d);
15
}// constructor Date
Classe Empregado
using System;
public class Empregado

{
private string nome;
private Date niver;
private Date contratacao;
public Empregado(string n, int dn,int mn, int an,

int dc,int mc, int ac)
{
nome = n;
niver = new Date(dn, mn, an);
contratacao = new Date(dc, mc, ac);
}// constructor Empregado
public string ToEmpregadoString()

{
return nome + " nasceu em " + niver.ToDateString() +
"\n foi contratado em " + contratacao.ToDateString();
}
}// class Empregado

Classe TestaComposição
using System;
public class TestaComposicao

{
static void Main(string[] args)
{
Empregado e = new Empregado("Joao da Silva", 10, 10, 1980, 05, 06, 2005);
MessageBox.Show(e.ToEmpregadoString(), "Testtando classe empregado");
}
}// class testaComposicao
3.6 Usando a referência THIS

Todo objeto pode acessar uma referência a si mesmo, chamada de referência THIS. A referência THIS
pode se referir implicitamente as variáveis de instancia, propriedades e métodos de um objeto. A palavra-
chave THIS é normalmente usada dentro de métodos, onde THIS é uma referência ao objeto em que o
método esta executando operações.
using System;
public class Tempo4

{
private int hora;
private int minuto;
private int segundo;
public Tempo4(int hora, int minuto, int segundo)

{
this.hora = hora;
this.minuto = minuto;
this.segundo = segundo;
}
16
public string ConstroiString()
{
return "this.ToIniciaString(): " + this.ToIniciaString() +
"\n sem ToIniciaString(): " + ToIniciaString();
}
public string ToIniciaString()

{
return String.Format("{0}:{1:D2}:{2:D2} {3}",
((this.hora==12 || this.hora==0)?12:
this.hora%12),this.minuto, this.segundo,
(this.hora <12? "AM":"PM"));
}
}
using System;
class TestaTHIS
{
{
Tempo4 tempo = new Tempo4(12,30,19);
MessageBox.Show(tempo.ConstroiString(),
"Demosntrando o \"this\" referencia");
}
}
4. HERANÇA
A herança é uma forma de reutilização de software em que as classes são criadas pela
absorção dos dados e comportamentos de uma classe já existente e aprimorando-as com novos
recursos.
Ao criar uma classe, em vez de escrever variáveis de instancia e métodos completamente
novos, o programador pode indicar que a nova classe deve herdar as variáveis de classe,
propriedades e métodos de outra classe. A classe anteriormente definida é chamada classe base ou
super classe, e a nova classe é referida como classe derivada.
Uma classe derivada, na qual variaveis de instancia, propriedades, e métodos exclusivos são
normalmente adicionados, é frequentemente maior do que a sua classe base.
Fazemos uma distinção entre o relacionamento “é-um” e o relacionamento “tem-um”. É-UM
representa herança . Em um relacionamento É UM , um objeto de uma classe derivada também
pode ser tratado como um objeto de sua classe base. Por exemplo, um carro é um veículo. Em
contraste, “tem-um” significa composição. No relacionamento tem-um, um objeto da classe
contém uma ou mais referências de objeto como membros. Por exemplo, um carro tem um
volante.
Um problema de herança é que uma classe derivada pode herdar propriedades e métodos
que não precisa ou que não deve ter. É responsabilidade do projetista da classe garantir que os
recursos fornecidos por uma classe sejam apropriados para as futuras classes derivadas. Mesmo
quando a propriedade ou método de uma classe base é apropriada para uma classe derivada, essa
classe derivada frequentemente exige que a propriedade ou método realize sua tarefa de maneira
especifica para a classe derivada. Em tais casos, a propriedade ou o método da classe base pode
ser sobreposto (overriden, redefinida) na classe derivada, com uma implementação apropriada.
17
Ponto
Circulo
Cilindro
Circulo área= Π r 2
Cilindro área = (Π r 2) + ( 2 Π r h ) onde h é a altura
using System;
// a definição da classe Ponto herda impliciatamente de Object
public class Ponto
{
private int x, y;
public Ponto()
{ // a chamada implicita ao constructor de Object ocorre aqui
}
public Ponto(int xvalor,int yvalor)

{
X = xvalor;
Y = yvalor;
}
public int X
{
get { return x; }
set { x = value;}
}
public int Y
{
get { return y; }
set { y = value; }
}
// toda classe em C# herda da classe System.Object

// isto significa que ela herda 8 métodos padrão da classe Object
// o método ToString da classe Ponto sobrepõe o metodo ToString original da
classe Object
{
return "["+x+", "+y+"]";
}
}
using System;
class circulo : Ponto
18
{
private double raio;
public circulo()
{ // chamada implicita ao contrsuctor de Ponto ocorre aqui
}
public circulo(int xvalor, int yvalor,double r): base(xvalor,yvalor)

Raio = r;
}
public double Raio

{
get { return raio; }
set { if (raio>=0) raio = value; }
}
public double Diametro()

{
return raio * 2;
}
public double Circunferencia()

{
return Math.PI * Diametro();
}
public virtual double Area()

//essa palavra chave permite que as classes derivadas
//sobreponham um metodo da classe base
{
return Math.PI * Math.Pow(raio, 2);
}

{
return "Centro= ["+base.ToString()+"\nRaio= "+raio;
}
}
using System;
class Cilindro: circulo

{
private double altura;
public Cilindro()
{
}
public Cilindro(int xvalor, int yvalor, double r, double alt)

: base(xvalor, yvalor, r)
{
Altura = alt;
}
public double Altura

{
get { return altura; }
set { if (value >= 0) altura = value; }
19
}
public override double Area()

{
return 2 * base.Area() + base.Circunferencia() * Altura;
}
public double Volume()

{
return base.Area() * Altura;
}

{
return base.ToString() + "\n Altura "+Altura;
}
}// fim da classe cilindro
using System;
public class TestaPonto

{
public static void Main(string[] args)
{
/*Ponto p = new Ponto(72,118);
string saida = "Coordenada X = " + p.X + "\n" + "Coordenada Y = " + p.Y;
p.X = 10;
p.Y = 10;
saida += "\n\nA nova localização do ponto = " + p;
// note aqui a chamada ao ToString
MessageBox.Show(saida, "demonstração da classe ponto");
*/
//====================================================================
/*circulo c = new circulo(37,43,2.5);
string saida = "Coordenada X = " + c.X + "\n" + "Coordenada Y = " + c.Y+
"\n Raio = "+c.Raio;
c.X = 2;
c.Y = 2;
c.Raio = 4.25;
saida += "\n\n" + "Nova localização e raio do circulo = " +

"\n" + c + "\n";
saida += "Diametro = " + String.Format("{0:F}", c.Diametro()) + "\n";

saida += "Circunferencia = " + String.Format("{0:F}",
c.Circunferencia()) + "\n";
saida += "Area = " + String.Format("{0:F}",c.Area()) + "\n";
MessageBox.Show(saida, "demonstração da classe circulo");

*/
//===================================================================
Cilindro cil = new Cilindro(12,23,2.5,5.7);
string saida = "Coordenada X = " + cil.X + "\n" +
"Coordenada Y = " + cil.Y +
"\n Raio = " + cil.Raio + "\n"+ "Altura = "+cil.Altura;
cil.X = 2;
cil.Y = 2;
cil.Raio = 4.25;
20
cil.Altura = 10;
saida += "\n\n" + "Nova localização: raio e altura do cilindro = " +

"\n" + cil + "\n";
saida += "Diametro = " + String.Format("{0:F}", cil.Diametro()) + "\n";

saida += "Circunferencia = " + String.Format("{0:F}",
cil.Circunferencia()) + "\n";
saida += "Area = " + String.Format("{0:F}", cil.Area()) + "\n";
saida += "Volume = " + String.Format("{0:F}", cil.Volume()) + "\n";
MessageBox.Show(saida, "demonstração da classe cilindro");
}
}
Destrutores
Não podemos determinar exatamente quando a chamada de um destrutor ocorrerá , pois não
podemos determinar com precisão quando a coleta de lixo ocorrerá. Entretanto,definindo um
destructor , podemos especificar um código para ser executado antes que o coletor de lixo remova
um objeto da memória.
using System;
// a definição da classe Ponto herda impliciatamente de Object
public class Ponto
{
private int x, y;
public Ponto()
{ // a chamada implicita ao constructor de Object ocorre aqui
}
public Ponto(int xvalor, int yvalor)

{
X = xvalor;
Y = yvalor;
}
~Ponto() // destrutor
{
Console.WriteLine("\n Ponto destruidfo {0}", this);
}
public int X
{
get { return x; }
set { x = value; }
}
public int Y
{
get { return y; }
set { y = value; }
}
// toda classe em C# herda da classe System.Object

// isto significa que ela herda 8 métodos padrão da classe Object
// o método ToString da classe Ponto sobrepõe o metodo ToString original da classe
Object
{
return "[" + x + ", " + y + "]";
21
}
}
class Circulo : Ponto

{
public Circulo()
}
public Circulo(int xvalor, int yvalor, double r)

: base(xvalor, yvalor)
Raio = r;
}
~Circulo()
{
Console.WriteLine("\n Destruindo objeto circulo {0}", this);
}
public double Raio

{
set { if (raio >= 0) raio = value; }
}

{
return raio * 2;
}

{
}
public virtual double Area()//essa palavra chave permite que as classes derivadas
//sobreponham um metodo da classe base
{
}

{
return "Centro= [" + base.ToString() + "Raio= " + raio+"\n";
}
}
public class TestaDestrutor

{
{
Circulo c1 = new Circulo(37,43,2.5);
Circulo c2 = new Circulo(5, 5, 10);
string saida = "Coordenada X = " + c1.X + "\n" + "Coordenada Y = " + c1.Y+

"Raio = "+c1.Raio+"\n\n";
saida += "Coordenada X = " + c2.X + "\n" + "Coordenada Y = " + c2.Y +

"Raio = " + c2.Raio+"\n\n";
Console.WriteLine(saida);
22
c1= null;
c2 = null;
System.GC.Collect();

}
}
5. TRABALHO DE HERANÇA
Observações:
- o método CalculaSalário tem que ser refeito a
cada especialização
Empregado - o método toString tem que ser refeito a cada
especialização, mas deve-ser aproveitado a
implementação da classe Base imediata
Matrícula (acima)
Nome - novos métodos podem ser acrescentados ao
SalarioBruto projeto, conforme a necessidade
SalarioLiquido - Utilizar variáveis de instância com
modificadores PRIVATE somente.
DataAdmissão - Cada classe tem suas propriedades
Constructor sem args

Constructor com args
Propriedades DATAS
ToString
Dia, mês, ano

Operador Britadeira
ToString
Insalubridade
Propriedades
verifica()
getData()
bissexto()
CalculaSalario
ToString
propriedades
Técnico de Explosivos
Adicional Periculosidade

CalculaSalario
ToString
propriedades
23
CLASSE DATAS
using System;
public class datas
{
private int dia, mes, ano;
public datas()
{
dia = 0; mes = 0; ano = 0;
}
public datas(int d, int m, int a)

{
Dia = d; Mes = m; Ano = a;
verifica();
}
public int bissexto() // se = 0 e bissexto, caso contrario nao eh

{
if (((ano % 4 == 0) && (ano % 100 > 0)) || (ano % 400 == 0))
return 0;
else return 1;
}
public int Dia

{
set { dia = value; }
get { return dia; }
}
public int Mes

{
set { mes = value; }
get { return mes; }
}
public int Ano

{
set { ano = value; }
get { return ano; }
}
public void verifica()

{
int[] dmes={0,31,28,31,30,31,30,31,31,30,31,30,31};
ano = ano > 0 ? ano:1;
dmes[2] = dmes[2]+bissexto();
mes = mes > 0 && mes < 13 ? mes:1;
dia = dia > 0 && dia <= dmes[mes] ? dia:1;
} // fecha verifica
public String getData()

{
verifica();
string[] nomes=
{"zero", "Janeiro","Fevereiro","Marco", "Abril", "Maio",
"Junho", "Julho", "Agosto", "Setembro", "Outubro",
"Novembro","Dezembro"};
string temp = dia+"/"+nomes[mes]+"/"+ano;
return (temp);
}
}// classe datas
24
CLASSE EMPREGADO
using System;
public class empregado

{
// variaveis de instancia
private string matricula;
private string nome;
private double salarioLiquido;
private double salarioBruto;
private datas dataAdm;
// metodos
public empregado()
{
nome = "";
matricula = ""; salarioLiquido = 0.0; salarioBruto = 0.0;
dataAdm = new datas();
}
public empregado(string n, string matr,

double sal, int da, int ma, int aa)
{
Nome = n;
Matricula = matr;
SalarioBruto = sal;
salarioLiquido = 0.0;
dataAdm = new datas(da, ma, aa);
}
public string Matricula

{
get { return matricula;}
set { matricula = value;}
}
public string Nome

{
get { return nome;}
set { nome = value;}
}
public double SalarioBruto

{
get { return salarioBruto;}
set { salarioBruto = (value >= 0)? value: 0;}
}
public double SalarioLiquido

{
get { return salarioLiquido;}
set { salarioLiquido = (value >= 0)? value: 0;}
}
public void setAdmissao(int d, int m, int a)

{
dataAdm.Dia = d;
dataAdm.Mes = (m);
dataAdm.Ano = (a);
}
25
{
string temp = "\n\nMatricula= " + Matricula + " Nome= " + Nome + "
Salario Bruto= " + SalarioBruto;
return (temp);
}
public virtual void calculaSalario()

{
salarioLiquido = salarioBruto;
}
} // fecha classe empregado

CLASSE OPERADOR DE BRITADEIRA
using System;
public class operadorBritadeira : empregado

{
private double insalubridade;
// metodos
public operadorBritadeira(): base()
{
Insalubridade=0;
}
public double Insalubridade

{
get { return insalubridade;}
set { insalubridade = (value >= 0)? value: 0;}
}
public operadorBritadeira(String n, String matr,

double sal, int da,int ma, int aa,double insalub)
: base(n,matr,sal,da,ma,aa)
{
Insalubridade = insalub;
}
public override void calculaSalario()

{
SalarioLiquido = SalarioBruto+Insalubridade;
}
public override String ToString()

{
String temp = "\n"+base.ToString()+
String.Format("\n Insalubridade= "+Insalubridade);
return (temp);
}
}// fecha classe operadorBritadeira
CLASSE TECNICO DE EXPLOSIVO
using System;
public class tecnicoExplosivo : operadorBritadeira

{
private double periculosidade;
// metodos
26
public tecnicoExplosivo(): base ()
{
Periculosidade=0;
}
public tecnicoExplosivo(string n, string matr,

double sal, int da,int ma, int aa,double insalub,
double pericul) : base (n,matr,sal,da,ma,aa,insalub)
{
Periculosidade = pericul;
}
public double Periculosidade

{
get { return periculosidade;}
set { periculosidade = (value >= 0)? value: 0;}
}
public override void calculaSalario()

{ SalarioLiquido = SalarioBruto+Insalubridade+Periculosidade; }
public override string ToString() {

string temp = "\n"+base.ToString()+
String.Format(" Periculosidade="+Periculosidade);
return (temp);
}
}// fecha classe tecnicoExplosivo
PRINCIPAL – Testa HERANÇA

public class TestaHeranca
{
{
Console.WriteLine("\nTestando Heranca Empregado Tecnico Operador");
empregado e = new empregado("joao", "1234",4000, 10, 12, 2002);
e.calculaSalario();
string temp= "\n\nEmpregado Comum "+e.ToString()+"
Liquido="+e.SalarioLiquido;
Console.WriteLine(temp);
operadorBritadeira op = new operadorBritadeira("operadTil", "2345",

1300, 13, 08, 2002, 500);
op.calculaSalario();
temp = "\n\nOperador Britadeira " + op.ToString()+"
Liquido="+op.SalarioLiquido;
pausa = Console.ReadLine();
tecnicoExplosivo te = new tecnicoExplosivo("explosão ", "2345", 1300,

13, 08, 2002, 500,450);
te.calculaSalario();
temp = "\n\nTecnico Explosivo " + te.ToString()+
" Liquido="+te.SalarioLiquido;
pausa = Console.ReadLine();
}
}
===============================================================
27
6. POLIMORFISMO
O polimorfismo nos permite escrever programas que tratam uma ampla variedade de classes
relacionadas de uma maneira genérica e facilita a adição de novas classes e recursos em um
sistema.
Os programas podem processar objetos de todas as classes genericamente em uma hierarquia de
classes, como objetos de uma classe base comum. Alem disso, novas classes podem ser
adicionadas com pouca ou nenhuma modificação nas partes genéricas do programa.
Polimorfismo ocorre quando uma subclasse tem um método com a mesma
assinatura da superclasse (classe base), ou seja, contêm a mesma assinatura.
Assinatura significa número, tipo e ordem dos parâmetros. Polimorfismo também é
definido da seguinte forma: Trata-se da criação de uma família de funções (métodos)
que compartilham do mesmo nome, mas cada uma tem código independente.
6.1 conversâo de objetos da classe derivada para objetos da classe base

using System;
class Ponto
{
private int x, y;
public Ponto()
{
}
public Ponto(int xValor, int yValor)
{
X = xValor;
Y = yValor;
}
public int X
{
get { return x; }
set { x = value; }
}
public int Y
{
get { return y; }
set { y = value; }
}
{
return "["+X+", "+Y+"]";
}
}
using System;
class Circulo: Ponto
{
public Circulo()
{
}
public Circulo(int xValor, int yValor, double r)
: base(xValor, yValor)
{
raio = r;
}
public double Raio
{
set { raio = ((value > 0) ? value : 1); }
}
28
{
return raio * 2;
}
public double circunferencia()
{
}
{
}
{
return "Centro= "+base.ToString()+"; Raio= "+Raio;
}
}
using System;
class testaConversao
{
{
Ponto p = new Ponto(30, 50);
Circulo c = new Circulo(120, 89, 2.7);
string saida = "Ponto p " + p.ToString() +
"\nCirculo c " + c.ToString();
//relacionamento é-um para atribuir circulo c ao um objeto Ponto

Ponto p2 = c;
saida += "\nCirculo foi atribuido ao Ponto p2 " + p2.ToString();
//converte ponto p2 novamente para circulo c2

Circulo c2 = (Circulo)p2;
saida += "\nPonto p2 (que era circulo) volta a origem circulo c2 " + c2.ToString();
saida += "\nArea de circulo c2 " + c2.Area().ToString("F");
if (p is Circulo)
{
c2 = (Circulo)p;
saida += "\n\nCast realizado com sucesso";
}
else saida += "\n\nPonto p não é um circulo";
MessageBox.Show(saida, "Demonstrativo do Relacionamento é-um");

}
}
6.2 Classes Abstratas
Existem casos em que é interessante definir classes para as quais o programador nunca pretende
instanciar quaisquer objetos. Tais classes são chamadas classes abstratas. Essas classes não podem
ser usadas para instanciar objetos, pois as classes abastratas são incompletas. As classes derivadas
devem definir as partes faltantes. As classes abstratas contem um ou mais métodos abstratos ou
29
propriedades abstratas, que são métodos e propriedades que não fornecem implementação. As
classes a partir das quais objetos podem ser instanciados são chamados de classes concretas.
using System;
public abstract class Figura

{
//retorna a area da figura
{
return 0;
}
//retorna o volume da figura
public virtual double Volume()
{
return 0;
}
public abstract string Nome
{
get;//as classes derivadas devem implementar essa propriedade
//para se tornar classes concretas
}
}
public class Ponto: Figura
{
private int x, y;
public Ponto()
{
}
public Ponto(int xValor, int yValor)

{
X = xValor;
Y = yValor;
}
public int X
{
get { return x; }
set { x = value; }
}
public int Y
{
get { return y; }
set { y = value; }
}

{
return "[" + X + ", " + Y + "]";
}
public override string Nome

{
get { return " Ponto "; }
}
30
}
public class Circulo: Ponto
{
public Circulo()
{
}
public Circulo(int xValor, int yValor, double r)

: base(xValor, yValor)
{
raio = r;
}
public double Raio

{
set { raio = ((value > 0) ? value : 1); }
}

{
return raio * 2;
}

{
}

{
}

{
return "Centro= "+base.ToString()+"; Raio= "+Raio;
}

{
get { return " Circulo "; }
}
}
public class Cilindro: Circulo
{
private double altura;
public Cilindro()
{
}
public Cilindro(int xValor, int yValor, double r,double h):

base (xValor, yValor, r)
{
altura = h;
}
31
public double Altura
{
get { return altura; }
set { altura = ((value >= 0) ? value : 0); }
}

{
return 2 * base.Area() + base.Circunferencia() * Altura;
}
public override double Volume()

{
return base.Area()* Altura;
}

{
return base.ToString()+"; Altura = "+Altura;
}

{
get { return " Cilindro "; }
}
}
using System;
public class testaAbstrata
{
{
Ponto p = new Ponto(7, 11);
Circulo cir = new Circulo(22, 8, 3.5);
Cilindro cil = new Cilindro(10, 10, 3.3, 10);
// cria um vetor vazio de Figuras

Figura[] vetor = new Figura[3];
vetor[0] = p;
vetor[1] = cir;
vetor[2] = cil;
string saida="";
foreach (Figura atual in vetor)

{
saida += "\n\n"+atual.Nome+": "+atual+
"\nArea= "+atual.Area().ToString("F")+
"\nVolume= "+atual.Volume().ToString("F");
}
MessageBox.Show(saida,"Testando array de objetos abstratos");
}
}
6.3 Interface
32
Interfaces especificam conjuntos de serviços PUBLIC (isto é, métodos e propriedades) que as
classes DEVEM implementar. Uma interface é usada quando não existe nenhuma implementação
padrão para herdar (nenhuma variável de instancia e nenhuma implementação de método).
Uma classe abstrata é usada para fornecer DADOS e serviços (MÉTODOS e PROPRIEDADES).
Uma interface é usada para fornecer serviços SEM IMPLEMENTAÇÃO (Métodos e
Propriedades) que “reúnem” objetos díspares, que se relacionam entre si apenas por meio desta
interface.
public interface InterfaceIdade

{
int Idade { get; }
string Nome { get; }
}
using System;
public class Arvore: InterfaceIdade
{
private int aneis;// numero de
//aneis no tronco da arvore
public Arvore(int anoPlantado)
{
aneis = DateTime.Now.Year - anoPlantado;
}
public void AddAneis()
{
aneis++;
}
public int Idade
{
get { return aneis; }
}
public string Nome
{
get { return "Arvore"; }
}
}
public class Pessoa : InterfaceIdade
{
private string primNome;
private string ultNome;
private int anoNasc;
public Pessoa(string pN, string uN, int ano)

{
primNome = pN;
ultNome = uN;
if (ano > 0 & ano <= DateTime.Now.Year)
anoNasc = ano;
else
anoNasc = DateTime.Now.Year;
}
public int Idade

{
get { return DateTime.Now.Year - anoNasc; }
}
33
public string Nome
{
get { return primNome + " " + ultNome; }
}
}
using System;
public class TestaInterface

{
{
Arvore tree = new Arvore(1978);
Pessoa p = new Pessoa("Joao", "Pereira", 1990);
InterfaceIdade[] vetor = new InterfaceIdade[2];
vetor[0] = tree;
vetor[1] = p;
string saida = tree + ": " + tree.Nome + "\nIdade = " + tree.Idade + "\n\n";
saida += p + ": " + p.Nome + "\nIdade = " + p.Idade + "\n\n";
foreach (InterfaceIdade atual in vetor)

{
saida += atual.Nome + ": Idade= " + atual.Idade + "\n";
}
MessageBox.Show(saida, "Demonstrando Polimorfismo com Interface");

}
}
7. EXCEÇÃO
Uma exceção é uma indicação de um problema que ocorre durante a execução de um programa. O
nome “exceção” vem do fato de que, embora um problema possa ocorrer, ele ocorre raramente. A
idéia é que programadores escrevam programas mais robustos, claros e mais tolerantes a falhas.
7.1 DivideByZeroException
using System;
public class Divisao

{
{
try
{
Console.WriteLine("\n Entre com o numerador ");
int numerador = Int32.Parse(Console.ReadLine());
Console.WriteLine("\n Entre com o denominador ");

int denominador = Int32.Parse(Console.ReadLine());
double result = numerador / denominador;
string saida = String.Format("{0:F}", result);

MessageBox.Show(saida, "testando exceção de divisão por zero");
}
34
catch (FormatException) // entrada (formato) invalido
{
MessageBox.Show("vc deve entrar com 2 numeros inteiros",
"formato invalido de entrada",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
catch (DivideByZeroException erroDivisao)// tentou dividir por zero
{
MessageBox.Show(erroDivisao.Message,
"tentou dividir por zero",
}
}// fim do main

}// fim da classe
7.2 Criando uma classe separada para tratamento da Exceção

Exemplo: Extrair a raiz quadrada de um número negativo
using System;
class NumeroNegativoExcecao : ApplicationException
{
public NumeroNegativoExcecao()
: base("Operacao Ilegal devido a numero negativo")
{
}
public NumeroNegativoExcecao( string mensagem)

: base(mensagem)
{
}
public NumeroNegativoExcecao(string mensagem, Exception erro)

: base(mensagem, erro)
{
}
}
using System;
public class raizQuadrada
{
{
try
{
Console.WriteLine("\n Entre com um numero real: ");
double numero = Double.Parse(Console.ReadLine());
if (numero < 0) throw new NumeroNegativoExcecao("Não é

permitido raiz quadrada de nro negativo");
double result = Math.Sqrt(numero);
string saida = String.Format("{0:F}", result);

MessageBox.Show(saida, "testando exceção raiz quadrada");
}
catch (FormatException) // entrada (formato) invalido
{
MessageBox.Show("vc deve entrar com numero inteiro positivo",
"formato invalido de entrada",
}
catch (NumeroNegativoExcecao erroNegativo)
// tentou dividir por zero
{
MessageBox.Show(erroNegativo.Message,
"raiz quadrada de Nro Negativo não existe",
35
}
}// fim do main
}// fim da classe
7.3 Testando estouros com os operadores CHECKED e UNCHECKED

using System;
class Overflow
{
{
int numero1 = Int32.MaxValue; ;// 2.147.483.647
int numero2 = Int32.MaxValue;
int soma = 0;
Console.WriteLine("numero 1 {0:D} \n Numero 2: {0:D}", numero1, numero2);
try
{
Console.WriteLine("\nSoma de inteiros ");
soma = checked(numero1 + numero2);
}
catch (OverflowException overExcecao)
{
Console.WriteLine(overExcecao.ToString());
}
Console.WriteLine("\nSoma depois de checar a operação {0}",soma);
Console.WriteLine("\nSoma de inteiros não checados ");
soma = unchecked(numero1+numero2);
Console.WriteLine("soma depois de operação não checada {0}",soma);
}// main
}// Overflow
Resumo sobre Exceção:
• Uma exceção é uma indicação de um problema que ocorre durante a execução de um

programa;
• O tratamento de exceções permite que os programadores criem aplicações que podem
resolver exceções, frequentemente permitindo que o programa continue sua execução
como se nenhum problema tivesse sido encontrado.
• O tratamento de exceções permite que os programadores escrevam programas claros,
robustos e mais tolerantes a falhas.
36
• O tratamento de exceções permite que o programador remova o código de tratamento
de erros da “linha principal” da execução do programa. Isso melhora a clareza do
programa e também sua capacidade de modificação.
8. CONTROLES/COMPONENTES VISUAIS SIMPLES
8.1 Label, Textbox e Button
TextBox – propriedades:
Name: tB1
PasswordChar: *
Label – propriedades:
Name: l1
BorderStyle: Fixed3D
Autosize: false
Text: vazio
Button – propriedades:
Name: b1
Text: Mostrar Texto
Evento Click do botão

private void b1_Click(object sender, EventArgs e)
{
l1.Text = tB1.Text;
}
8.2 Groupbox e Panel
GroupBox (caixas de grupo) pode exibir uma legenda

Panel (painéis) pode ter barra de rolagem
GroupBox – propriedades:
Name gB1
Text: sexo
Panel – propriedades:
AutoScroll: padrão é false
(se true aparece as barras de rolagem)
BorderStyle: borda (padrão é none) outras opções Fixed3D e FixedSingle
RadioButton – propriedades: Label – propriedades:
Name (masculino/femino) Name: l1 e l2
Text (masculino/feminino) Text: (vazio)
Checked: true para masculino
private void feminino_CheckedChanged(object sender, EventArgs e)

{ l1.Text = "Feminino selecionado"; }
private void masculino_CheckedChanged(object sender, EventArgs e)

{ l1.Text = "Masculino selecionado"; }
37
private void bsoma_Click(object sender, EventArgs e)
{ l2.Text = "botão soma"; }
private void bsubtrai_Click(object sender, EventArgs e)

{ l2.Text = "botão subtrai"; }
private void bdivide_Click(object sender, EventArgs e)

{ l2.Text = "botão divide"; }
private void bmultiplica_Click(object sender, EventArgs e)

{ l2.Text = "botão multiplica"; }
8.3 Exercicio: Calculadora
Criar um novo projeto WindowApplication calculadora

Adicione:
• Um textBox para o visor. Mude a propriedade NAME
para visor. Mude textAlign para Right
• 10 botões (Button) para as teclas numéricas da
calculadora. Mude as propriedades dos botões NAME e
TEXT. Exemplo botão 1: Name b1 e Text 1
• Coloque os botões dentro de um container groupBox.
Retire a propriedade TEXT do controle.
• Acrescente mais 5 botões na lateral direita, e mude a
propriedade Text para + - * / e clear. Mude também as
propriedades Name para bsoma bsubtrai bmultiplica
bdivide e bclear.
• Dentro de Form1.cs, acrescente:
{
String NumAtual="";
String NumAnterior="";
String operador;
int atual;
int anterior;
• Dê um duplo clique em qq um dos botões da interface (calculadora) no Form

Ele automaticamente entrará no Form1.cs (view code)
{
}
Mude para o seguinte:
private void botao_Click(object sender, EventArgs e)
{
if (sender==b1)
NumAtual = NumAtual+'1';
else if (sender==b2)
38
NumAtual = NumAtual+'9'; faça para os demais
else NumAtual = NumAtual+'0'; botões b1 até b9
visor.Text = NumAtual;
}

{
botao_Click(sender, e);
}
• Dê um duplo clique em qq um dos botões da interface (calculadora) no Form

Ele automaticamente entrará no Form1.cs (view code)
{
}
Mude para o seguinte:

private void operacao_Click(object sender, EventArgs e)
{
if (sender == bigual)
{
atual = Int32.Parse(NumAtual);
anterior = Int32.Parse(NumAnterior);
NumAtual = "";
if (operador == "+")
atual = atual + anterior;
else if (operador == "-")
atual = anterior - atual;
else if (operador == "*")
atual = atual * anterior;
else if (operador == "/")
atual = Convert.ToInt32(anterior / atual);
visor.Text = atual.ToString();
}
else
{
NumAnterior = visor.Text;
NumAtual = "";
if (sender == bsoma)
operador = "+";
else if (sender == bsubtrai)
operador = "-";
else if (sender == bmultiplica)
operador = "*";
else if (sender == bdivide) Faça para os botões:
operador = "/"; bmultiplica
else if (sender == bclear) bsubrai
{
bdivide
NumAnterior = "";
visor.Text = NumAtual; bclear
} bigual
}
}
39
{
operacao_Click(sender, e);
}
Pronto! Teste a calculadora....
Exercicio
8.4. Controle Com Guias (TabControl)

Form1.cs [Design]
1 Label : posicione-o abaixo do TabControl. Mude o Name para msg

1 TabControl. Para adicionar PagPages, clique botão direito no TabControl e dê ADD TAB
Verifique na caixa de Propriedades se está selecionado o TabControl ou o TabPage
Modifique a propriedade Text dos TabPage´s: Cor, Tamanho, Msg e Sobre
40
Dentro de cada TabPage, coloque RadioButton´s (mude Name e Text)
Form1.cs
{
public Form1()
private void Azul_CheckedChanged(object sender, EventArgs e)

{ msg.ForeColor = Color.Blue; }
private void Preto_CheckedChanged(object sender, EventArgs e)

{ msg.ForeColor = Color.Black; }
private void vermelho_CheckedChanged(object sender, EventArgs e)

{ msg.ForeColor = Color.Red; }
private void doze_CheckedChanged(object sender, EventArgs e)

{ msg.Font = new Font(msg.Font.Name, 12); }
private void catorze_CheckedChanged(object sender, EventArgs e)

private void dezesseis_CheckedChanged(object sender, EventArgs e)

private void oi_CheckedChanged(object sender, EventArgs e)

{ msg.Text = "Oiiiiii"; }
private void tchau_CheckedChanged(object sender, EventArgs e)

{ msg.Text = "Tchauuuuuu"; }
}// fecha class
8.5 Trabalhando Com STRINGS

{
string saida;
string original, str1, str2, str3, str4;
char[] vetorChar = { 'f', 'e', 'l', 'i', 'z', ' ', 'd', 'i', 'a' };
//inicializacao
original = "Bem vindo a programação em C#";
str1 = original;
str2 = new string(vetorChar);
str3 = new string(vetorChar, 6, 3);
str4 = new string('A', 5);
41
saida = "str1 = " + "\"" + str1 + "\"\n" +

"str2 = " + "\"" + str2 + "\"\n" +
"str3 = " + "\"" + str3 + "\"\n" +
"str4 = " + "\"" + str4 + "\"\n";
MessageBox.Show(saida, "Constructores da Classe String",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
8.6 Indice, tamanho e metodo CopyTo

{
string str1, saida;
char[] vetorChar;
str1 = "Liliane Jacon";
vetorChar = new char[5];
saida = "str1 = \"" + str1 + "\"";

saida += "\nTamanho da string "+str1.Length;
saida += "\nString em ordem inversa : ";

for (int i=str1.Length-1 ; i>=0; i--)
saida += str1[i];
saida += "\nO vetor de caracteres : ";

str1.CopyTo(8,vetorChar,0,5);//vou copiar Jacon para o vetor
for (int i = 0; i < vetorChar.Length; i++)

saida += vetorChar[i];
MessageBox.Show(saida,"Demosntracao de String "+

" indice, tamanho e metodo CopyTo",
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
8.7 Comparando Strings

{
string str1 = "alo";
string str2 = "adeus";
string str3 = "Feliz Aniversario";
string str4 = "feliz aniversario";
string saida;
saida = "str1 = \"" + str1 + "\"" +

"\nstr2 = \"" + str2 + "\"" +
"\nstr3 = \"" + str3 + "\"" +
42
"\nstr4 = \"" + str4 + "\"\n\n";
// testa igualdade usando o metodo EQUALS

if (str1.Equals("alo"))
saida += "str1 igual \"alo\" usando metodo EQUALS\n";
else
saida += "str1 diferente \"alo\"\n";
// testa igualdade com ==

if (str1 == "alo")
saida += "str1 igual \"alo\" usando == \n";
else
saida += "str1 diferente \"alo\"\n";
//testa string considerando diferenças entre Maiuscula e Minuscula

if (String.Equals(str3, str4))
saida += "str3 igual str4 - maiusc.e minusc.(Equals)\n";
else
saida += "str3 diferente str4 - maiusc.e minusc.(Equals)\n";
//testa CompareTo
saida += "\n CompareTo se (=0 são iguais) \n " +
"(=-1 str que chama < que a do argumento) \n" +
"(= 1 str que chama > que a do argumento) \n";
saida += "\nstr1.CompareTo( str2) " +
str1.CompareTo(str2) + "\n" +
"str2.CompareTo(str1) " +
str4.CompareTo(str3) + "\n\n";
MessageBox.Show(saida, "Demosntracao de comparacao de strings",

}
8.8 Localizando caracteres e substrings

em strings

{
string letras = "abcdefghijklmnopqrstuvxyzabcdefghi";
string saida = "";
char[] buscaLetra = { 'c', 'a', '$' };
//testa indexOf p/localizar um char numa string

saida += "'c' esta localizado nas letras na posicao " +
letras.IndexOf('c');
//indexof com 2 argumentos

saida += "\n'a' esta localizado nas letras na posicao " +
letras.IndexOf('a',1);
//indexof com 3 argumentos

saida += "\n'$' esta localizado nas letras na posicao " +
letras.IndexOf('$',3,5);//3 = indice onde vai começar
43
//5= numero de caracteres a serem procurados
//LastIndexOf localiza a ultima ocorrencia de um caractere em uma string

saida += "\n\nUltimo 'c' esta localizado na posicao " +
letras.LastIndexOf('c');
saida += "\nUltimo 'a' esta localizado na posicao " +

letras.LastIndexOf('a',25);//indice +alto apartir deonde vai comecar a busca para tras
saida += "\n'$' esta localizado nas letras na posicao " +

letras.LastIndexOf('$', 15, 5);
//usando IndexOf para localizar uma substring em uma string

saida += "\n\n\"def\" esta localizado na posicao " +
letras.IndexOf("def");
saida += "\n\n\"def\" com 2 argumentos esta localizado na posicao " +

letras.IndexOf("def",7);
saida += "\n\n\"alo\" esta localizado na posicao " +

letras.IndexOf("alo",5,15);
// testa LastIndexOf p/ substring dentro da string

saida += "\n\nUltimo \"def\" esta localizado na posicao " +
letras.LastIndexOf("def");
saida += "\n\nUltimo \"def\" começando da posicao 25 (de tras p/frente)" +

letras.LastIndexOf("def",25);
//testa IndexOfAny p/localizar 1a.ocorrencia do caractere

saida += "\n\nPrimeira ocorrencia de 'c', 'a','$' eh" +
letras.IndexOfAny(buscaLetra);
MessageBox.Show(saida, "Testando IndexOf LastIndexOf IndexOfAny",

}
8.9 Exercicio
44
8.10 Trabalhando Com Messagebox
Form1.cs {Design]
2 GroupBox (mudar Text)

Dentro dos GroupBox coloque RadioButtons
Para cada radioButton, mude Name, Text
Isso ele faz automaticamente:

private void rbOK_CheckedChanged(object sender, EventArgs e)
{ // CheckedChanged disparado qdo o RadioButton é marcado ou desmarcado
tipoBotao_CheckedChanged(sender, e); // esse vc vai fazer
}
Form1.Designer.cs
………#endregion
private System.Windows.Forms.Label label1;

private System.Windows.Forms.GroupBox groupBox1;
…..
private System.Windows.Forms.MessageBoxIcon icone =
System.Windows.Forms.MessageBoxIcon.Error;
private System.Windows.Forms.MessageBoxButtons botao =
System.Windows.Forms.MessageBoxButtons.OK;
Form1.cs (código)
using System;
using System.Collections.Generic; using System.ComponentModel;
using System.Data; using System.Drawing; using System.Text;
namespace teste_MessageBox_com_RadioButto
{
{
public Form1()
{
InitializeComponent();
}
45
Private void tipoBotao_CheckedChanged(object sender, EventArgs e) // voce vai digitar esse

{
if (sender == rbOK)
botao = MessageBoxButtons.OK;
else if (sender == rbOKCancela)
botao = MessageBoxButtons.OKCancel;
else if (sender == rbARI)
botao = MessageBoxButtons.AbortRetryIgnore;
else if (sender == rbYNC)
botao = MessageBoxButtons.YesNoCancel;
else if (sender == rbYN)
botao = MessageBoxButtons.YesNo;
else botao = MessageBoxButtons.RetryCancel;
}
private void rbOK_CheckedChanged(object sender, EventArgs e) // esses vc vai clicar e ele entra automatica/e
{
tipoBotao_CheckedChanged(sender, e);
}
private void rbOKCancela_CheckedChanged(object sender, EventArgs e)

{
}
private void rbARI_CheckedChanged(object sender, EventArgs e)

{
}
private void rbYNC_CheckedChanged(object sender, EventArgs e)

{
}
private void rbYN_CheckedChanged(object sender, EventArgs e)

{
}
private void rbRC_CheckedChanged(object sender, EventArgs e)

{
}
private void tipoIcone_CheckedChanged(object sender, EventArgs e) // esse vc vai ter que digitar
{
if (sender == rbErro)
icone = MessageBoxIcon.Error;
else if (sender == rbInfo)
icone = MessageBoxIcon.Information;
else if (sender == rbExclama)
icone = MessageBoxIcon.Exclamation;
else
icone = MessageBoxIcon.Question;
}
private void rbErro_CheckedChanged(object sender, EventArgs e)

{
46
tipoIcone_CheckedChanged(sender, e);
}
private void rbExclama_CheckedChanged(object sender, EventArgs e)

{
}
private void rbInfo_CheckedChanged(object sender, EventArgs e)

{
}
private void rbQuestao_CheckedChanged(object sender, EventArgs e)

{
}
private void bMostra_Click(object sender, EventArgs e) // evento do botão

{
DialogResult resul = MessageBox.Show("este é o MessageBox escolhido",
"MessageBox Escolhido", botao, icone, 0, 0);
switch (resul)
{
case DialogResult.OK:
texto.Text = "OK foi pressionado";
break;
case DialogResult.Cancel:
texto.Text = "Cancela foi pressionado";
break;
case DialogResult.Abort:
texto.Text = "Aborta foi pressionado";
break;
case DialogResult.Retry:
texto.Text = "Repete foi pressionado";
break;
case DialogResult.Ignore:
texto.Text = "Ignore foi pressionado";
break;
case DialogResult.Yes:
texto.Text = "Yes foi pressionado";
break;
case DialogResult.No:
texto.Text = "Não foi pressionado";
break;
}
}
}
}
47
9. JANELA MDI (Janela Interna) & MENU
opção ARQUIVO:
Nova e Exit
Janela 1,
Janela 2
Janela 3
Opção FORMATO:
Cascata,
TileHorizontal
TileVertical
Mudar no Form1 propriedade
IsMDIContainer = true
Copiar 3 arquivos GIF dentro da pasta PROJECTS – (nomeDoProjeto) – Bin\Debug

{
public Form1()
{
}
private void janela1ToolStripMenuItem_Click(object sender, EventArgs e)

{
Filho janFilho = new Filho("Janela 1", "\\dado1.gif");
janFilho.MdiParent = this;
janFilho.Show();
}

{
janFilho.Show();
}

{
janFilho.Show();
}
private void exitToolStripMenuItem_Click(object sender, EventArgs e)

{
Application.Exit();
}
private void cascataToolStripMenuItem_Click(object sender, EventArgs e)

{
this.LayoutMdi(MdiLayout.Cascade);
}
private void tileHorizontalToolStripMenuItem_Click(object sender, EventArgs e)

{ this.LayoutMdi(MdiLayout.TileHorizontal); }
private void tileVerticalToolStripMenuItem_Click(object sender, EventArgs e)
48
{
this.LayoutMdi(MdiLayout.TileVertical);
}
}
Menu PROJECT, clique na opção ADD WINDOWS FORM – Windows Forms

Dê o nome de Filho e em seguida ADD
Adicione um PictureBox na nova janela (formulário Filho)

Diminua o formulário e deixe o PictureBox com tamanho 100 x 100 (propriedade Size)
Mude a propriedade Name do PictureBox para pBox.
Modifique o constructor do formulário Filho, conforme abaixo.
Repare que o constructor do formulário Filho exige 2 argumentos.
No FILHO.cs
using System.IO; //não esqueça de acrescentar esta linha no form Filho
public partial class Filho : Form
{
public Filho(string titulo, string filename)
{
Text = titulo;
pBox.Image = Image.FromFile(Directory.GetCurrentDirectory() + filename);
}
}
Cascata TileHorizontal TileVertical
49
9.1 Exercício com Menu e Janela MDI
Opção Opção VETORES

ARQUIVO Busca Binária
Sobre Ordena (Bolha)
Exit Insere um
Remove um
50
Observação:
No form PAI , ao clicar numa opção do Menu, acrescentei mais um parâmetro:
private void buscaBinariaToolStripMenuItem_Click(object sender, EventArgs e)

{
Filho janFilho = new Filho("Busca Binaria", 1);
janFilho.Show();
}
( 1= Busca Binaria, 2= Ordena (Bolha) , 3=Insere um e 4=Remove um)
No Form FILHO, coloquei 4 paineis: pOrdena, pBusca, pInsere e pRemove
Portanto, ao inicializar o form Filho, alternar a propriedade Visible dos

paineis:
public Filho(string titulo, int num)

{
Text = titulo;
switch (num)
{
case 1: pOrdena.Visible=false; pBusca.Visible = true;
pInsere.Visible = false; pRemove.Visible = false;
bB0.Text = vetor[0].ToString(); bB1.Text = vetor[1].ToString();
bB2.Text = vetor[2].ToString(); bB3.Text = vetor[3].ToString(); bB4.Text = vetor[4].ToString();
break;
case 2: pBusca.Visible=false; pOrdena.Visible = true;
pInsere.Visible = false; pRemove.Visible = false;
bO0.Text = vetor[0].ToString(); bO1.Text = vetor[1].ToString();
bO2.Text = vetor[2].ToString(); bO3.Text = vetor[3].ToString();
bO4.Text = vetor[4].ToString();
break;
case 3: ....
case 4: ....
}//fecha todos
51
Fiz um método separado para a busca binária (que é chamado ao clicar nos botões)
private int BuscaBin(int num)
{
int inicio, meio, fim, posicao;
inicio = 0;
fim = vetor.Length - 1;
meio = (inicio + fim) / 2;
while ((inicio < fim) && (vetor[meio] != num))
{
if (num > vetor[meio])
inicio = meio + 1;
else
fim = meio;
meio = (inicio + fim) / 2;
}
if (num > vetor[meio])
posicao = (meio + 1);
else posicao = (meio);
return posicao;
}
Já a rotina para Ordenar (Bolha) é chamada dentro dos eventos dos botões:
private void bOrdena_Click(object sender, EventArgs e)
{
int i,aux, tam;
tam = vetor.Length - 1;
while (tam > 0)
{
for (i=0 ; i < tam; i++)
if (vetor[i] > vetor[i+1])
{
aux = vetor[i];
vetor[i] = vetor[i+1];
vetor[i+1] = aux;
switch (i)
{
case 0: bO0.Text = vetor[i].ToString();
bO1.Text = vetor[i+1].ToString();
bB0.Text = vetor[i].ToString();
bB1.Text = vetor[i + 1].ToString();
break;
bB1.Text = vetor[i].ToString();
bB2.Text = vetor[i + 1].ToString();
break;
bB2.Text = vetor[i].ToString(); bB3.Text = vetor[i + 1].ToString();
break;
bB3.Text = vetor[i].ToString(); bB4.Text = vetor[i + 1].ToString();
break;
}//switch
}//if
tam--;
}//while
}
52
10. LISTA ENCADEADA
10.1 Implementando Lista Encadeada com Interface Gráfica
using System;
using System.Collections.Generic;
using System.Text;
//ListaEncBiblioteca.cs
namespace ListaEncBiblioteca
{
class No
{
private object dado;
private No prox;
public No(object dadonovo)

: this(dadonovo, null)
{
}
53
public No(object dadonovo, No ligacao)

{
dado = dadonovo;
prox = ligacao;
}
public No Prox
{
get { return prox; }
set { prox = value; }
}
public object Dado

{
get { return dado; }
}
}// fecha class No
public class Lista

{
private No primeiro;
private No ultimo;
private string nomeDaLista;
public Lista(string name)

{
nomeDaLista = name;
primeiro = ultimo = null;
}
public Lista()
: this("Lista Teste")
{
}
public void InsereNaFrente(object item)

{
lock (this)
{
if (Vazia())
primeiro = ultimo = new No(item);
else
primeiro = new No(item, primeiro);
}
}
public void InsereNoFundo(object item)

{
lock (this)
{
if (Vazia())
primeiro = ultimo = new No(item);
else
ultimo = ultimo.Prox = new No(item);
}
}
public object RemoveDaFrente()

{
54
lock (this)
{
if (Vazia())
{
//throw new ExcecaoListaVazia(nomeDaLista);
return null;
}
object item = primeiro.Dado;
if (primeiro == ultimo)
else
primeiro = primeiro.Prox;
return item;
}
}
public object RemoveDoFundo()

{
lock (this)
{
if (Vazia())
{
//throw new ExcecaoListaVazia(nomeDaLista);
return null;
}
object item = ultimo.Dado;

if (primeiro == ultimo)
else
{
No atual = primeiro;
while (atual.Prox != ultimo)
atual = atual.Prox;
ultimo = atual;
atual.Prox = null;
}//else primeiro = ultimo
return item;
}
}//removeDoFundo
public bool Vazia()

{
lock (this)
return primeiro == null;
}//vazia

{
string temp="";
lock (this)
{
if (Vazia())
{
temp += "Vazia " + nomeDaLista;
return temp;
}//if vazia
temp += "A " + nomeDaLista + " contem \n\n";
No atual = primeiro;
55
while (atual != null)
{
temp += atual.Dado + ", ";
atual = atual.Prox;
}
temp += "\n";
return temp;
}//lock
}//ToString
public string exibePrim()

{
if (primeiro == null) return "Primeiro: null";
else return "Primeiro: "+primeiro.Dado.ToString();
}
public string exibeUlt()

{
if (ultimo == null) return "Ultimo: null";
else return "Ultimo: "+ultimo.Dado.ToString();
}
}// fecha class Lista
public class ExcecaoListaVazia : ApplicationException

{
public ExcecaoListaVazia(string nome)
: base("A " + nome + " esta vazia ")
{
}
}// excecao
}
using System;
using ListaEncBiblioteca;
namespace Lista_Enc_com_GUI
{
{
bool booleano;
char[] caracter=new char[1];
int inteiro;
double real;
string texto, frase;
Lista l;
public Form1()
{
}
private void tBInsere_TextChanged(object sender, EventArgs e)

{
texto = tBInsere.Text;
lRemove.Text = "";
try
{
if (rbBool.Checked)
{
56
if ((texto.IndexOf('T')==0)||(texto.IndexOf('t')==0))
booleano = true;
else
booleano =false;
lRemove.Text = booleano.ToString();
}
else if (rbChar.Checked)
{
if (texto.Length > 0)
{
string temp = texto.Substring(0,1);
lRemove.Text = temp.ToString();
caracter[0] = temp[0];
}
else caracter[0] = 'x';
}
else if (rbInt.Checked)
{
inteiro = Int32.Parse(texto);
lRemove.Text =inteiro.ToString();
}
else if (rbReal.Checked)
{
real = Double.Parse(texto);
lRemove.Text = String.Format("{0:F3}",real);
}
else if (rbString.Checked)
frase = texto;
}//try
catch (FormatException erro)
{
string temp = "Presta atenção: " + erro;
MessageBox.Show(temp, "formato invalido",
}
}
private void bInsFrente_Click(object sender, EventArgs e)

{
if (rbBool.Checked)
l.InsereNaFrente(booleano);
l.InsereNaFrente(caracter[0].ToString());
l.InsereNaFrente(inteiro);
l.InsereNaFrente(real);
l.InsereNaFrente(frase);
string temp = l.ToString();
lLista.Text = temp;
tBInsere.Clear();
lPrimeiro.Text = l.exibePrim();
lUltimo.Text = l.exibeUlt();
lRemove.Text = "";
}

{
l = new Lista("Lista com GUI");
lPrimeiro.Text = l.exibePrim();
57
lUltimo.Text = l.exibeUlt();
lRemove.Text = "";
}
private void rbBool_CheckedChanged(object sender, EventArgs e)

{
tBInsere.Text = "";
}
private void rbChar_CheckedChanged(object sender, EventArgs e)

{
tBInsere.Text = "";
}
private void rbInt_CheckedChanged(object sender, EventArgs e)

{
tBInsere.Text = "";
}
private void rbReal_CheckedChanged(object sender, EventArgs e)

{
tBInsere.Text = "";
}
private void rbString_CheckedChanged(object sender, EventArgs e)

{
tBInsere.Text = "";
}
private void bInsFundo_Click(object sender, EventArgs e)

{
if (rbBool.Checked)
l.InsereNoFundo(booleano);
l.InsereNoFundo(caracter[0].ToString());
l.InsereNoFundo(inteiro);
l.InsereNoFundo(real);
l.InsereNoFundo(frase);
string temp = l.ToString();
lLista.Text = temp;
tBInsere.Clear();
lPrimeiro.Text = l.exibePrim().ToString();
lUltimo.Text = l.exibeUlt().ToString();
lRemove.Text = "";
}
private void bDelFrente_Click(object sender, EventArgs e)

{
object temp = l.RemoveDaFrente();
if (temp != null)
lRemove.Text = "Removeu o "+temp.ToString();
lLista.Text = l.ToString();
}
58
private void bDelFundo_Click(object sender, EventArgs e)
{
object temp = l.RemoveDoFundo();
if (temp != null)
lRemove.Text = "Removeu o " + temp.ToString();
}
private void bExibe_Click(object sender, EventArgs e)

{
lRemove.Text = "";
}
private void bLimpa_Click(object sender, EventArgs e)

{
object te;
while (!l.Vazia())
te = l.RemoveDaFrente();
lRemove.Text = "";
}
}
}
10.2 Utilizando ArrayList (Coleção de Strings)
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Collections;
namespace TestaArrayList
{
{
private ArrayList arraylist = new ArrayList(1);
public Form1()
59
private void bAdd_Click(object sender, EventArgs e)
{
arraylist.Add(tbEntrada.Text);
status.Text = "Adicionado no final: " + tbEntrada.Text;
tbEntrada.Clear();
}
private void bRemove_Click(object sender, EventArgs e)

{
arraylist.Remove(tbEntrada.Text);
status.Text = "Removido " + tbEntrada.Text;
tbEntrada.Clear();
}
private void bPrimeiro_Click(object sender, EventArgs e)

{
try
{
status.Text = "Primeiro elemento: " + arraylist[0];
}
catch (ArgumentOutOfRangeException erro)
{
status.Text = erro.ToString();
}
}
private void bUltimo_Click(object sender, EventArgs e)

{
try
{
status.Text = "Ultimo elemento: " + arraylist[arraylist.Count-1];
}
catch (ArgumentOutOfRangeException erro)
{
status.Text = erro.ToString();
}
}
private void bVazia_Click(object sender, EventArgs e)

{
status.Text=(arraylist.Count==0 ?
"arraylist esta vazia":"arraylist NAO esta vazia");
}
private void bContem_Click(object sender, EventArgs e)

{
if (arraylist.Contains(tbEntrada.Text))
status.Text = "arraylist contem " + tbEntrada.Text;
else
status.Text = tbEntrada.Text + " NAO encontrado";
}
private void bLocaliza_Click(object sender, EventArgs e)

{
status.Text = "elemento esta localizado na posicao " +
arraylist.IndexOf(tbEntrada.Text);
}
private void bTrim_Click(object sender, EventArgs e)

{
arraylist.TrimToSize();
status.Text = "Vetor aparado para seu tamanho certo";
}
60
private void bEstatistica_Click(object sender, EventArgs e)

{
status.Text = "Tamanho= " + arraylist.Count +
" ; Capacidade= " + arraylist.Capacity;
}
private void bExibe_Click(object sender, EventArgs e)

{
//IEnumerator percorre os elementos de arraylist,
// um elemento por vez
IEnumerator enumera = arraylist.GetEnumerator();
//a primeira chamada de MoveNext posiciona no
// primeiro elemento de arraylist
StringBuilder tempor = new StringBuilder();
while (enumera.MoveNext())
tempor.Append(enumera.Current+" ");
status.Text=tempor.ToString();
}
}
}
10.3 Exercício utilizando Coleção do C# (LIST)
using System.Collections;
namespace ArrayList_de_Contas
{
{
List <Registro> arraylist = new List <Registro>();
IEnumerator enumeracao;
public Form1()
{
enumeracao = arraylist.GetEnumerator();
}
61
public void ClearTextBoxes()
{
tbConta.Text = "";
tbPrim.Text = "";
tbSobre.Text = "";
tbSaldo.Text = "";
}
..............// fazer as demais afuncionalidades para cada botão da Interface
class Registro
{
public int conta;
public string primNome;
public string ultNome;
public double saldo;
public Registro()
: this(0, "", "", 0.0)
{
}
public Registro(int numConta, string preNome,

string sobreNome, double sal)
{
conta = numConta;
primNome = preNome;
ultNome = sobreNome;
saldo = sal;
}
public int Conta

{
get { return conta; }
set { conta = value; }
}
public string PrimNome

{
get { return primNome; }
set { primNome = value; }
}
public string UltNome

{
get { return ultNome; }
set { ultNome = value; }
}
public double Saldo

{
get { return saldo; }
set { saldo = value; }
}//saldo
}//class Registro
62
11. LISTBOX, COMBOBOX, CHECKEDLISTBOX E LINKLABEL
LISTBOX
PROPRIEDADES Descrição
Items Relaciona a coleção de itens dentro da ListBox
SelectedIndex Retorna o índice do item atualmente selecionado. Se o usuário selecionar
múltiplos itens, esse método retornara arbitrariamente um dos índices
selecionados. Se nenhum tem tiver sido selecionado, o método retornará -
1
SelectedIndices Retorna uma coleção dos índices de todos os itens atualmente
selecionados
SelectedItem Retorna uma referência para o item atualmente selecionado (se múltiplos
itens forem selecionados, ela retornará o item com o menor numero de
índice).
SelectedItems Retorna uma coleção dos itens atualmente selecionados
Sorted Índice se os itens aparecem em ordem alfabética. True causa disposição
em ordem alfabética. O padrão é false
METODO
GetSelected Pega um índice e retorna True, caso o item corespondente esteja
selecionado
Evento Comum
SelectedIndexChanged Gerado quando o índice selecionado muda. É o padrão quando o controle
recebe um clique duplo do projetista
COMBOBOX
Items Relaciona a coleção de itens dentro do ComboBox
MaxDropDownItems Especifica o numero maximo de itens (entre 1 e 100)que podem aparecer
na lista suspensa. Se ultrapassar, aparece uma barra de rolagem.
SelectedIndex Retorna o índice do item atualmente selecionado. Se não houver nenhum
item atualmente, -1 será retornado
Sorted Especifica se itens em uma lista estão em ordem alfabética (true/false)
Evento Comum
SelectedIndexChanged Gerado quando o índice selecionado muda (como qdo uma caixa de
seleção tiver sido marcada ou desmarcada). É o padrão quando recebe um
clique duplo.
63
{
string[] vetor = { "solteiro", "casado", "viúvo", "desquitado", "separado",
"divorciado", "outros" };
public Form1()
{
}
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)

{
// se numero = -1 nenhum item selecionado no ComboBox
int numero = comboBox1.SelectedIndex;
label1.Text = vetor[numero];
}
private void button3_Click(object sender, EventArgs e)

{
lB.Items.Clear(); }

{
lB.Items.Add(textBox1.Text);
textBox1.Clear(); }

{
if (lB.SelectedIndex != -1)
lB.Items.RemoveAt(lB.SelectedIndex); }
private void cLB_SelectedIndexChanged_1(object sender, EventArgs e)

{
string item = cLB.SelectedItem.ToString();
if (lBox.Items.Contains(cLB.SelectedItem))
lBox.Items.Remove(item);
else
lBox.Items.Add(item);
}
}
CHECKEDLISTBOXES
CheckedItems Relaciona a coleção de itens que serão marcados. Isso é diferente dos itens
selecionados que serão destacados (mas não necessariamente marcados).
Nota: pode haver no máximo um item selecionado em dado momento.
CheckedIndices Retorna índices para os itens que estão marcados. Não é o mesmo que os
índices selecionados
SelectionMode Determina quantos itens podem ser marcados. Os únicos valores possíveis
são ONE (permite que marcações múltiplas sejam feitas) ou NONE (não
permite que nenhuma marcação seja feita)
SelectedItem Retorna o item selecionado
Evento
ItemCheck Gerado quando um item é marcado ou desmarcado.
Método Comum
GetItemChecked Recebe um índice e retorna TRUE se o item correspondente estiver
marcado
64
11.1 Exercicio ListBox & ComboBox
1) Escreva um programa que exiba os nomes de 15

estados em uma ComboBox. Quando um item for
selecionado na ComboBox, remova-o.
2) Modifique sua solução do exercício 1 para

adicionar uma ListBox, além da ComboBox.
Quando o usuário selecionar um item na
ComboBox, remova o item da ComboBox e
adicione-o na ListBox. Seu programa deve
verificar se a ComboBox contem pelo menos um
item . Se não contiver, imprima uma mensagem
em uma caixa de mensagem e termine a execução
do programa.
3) Escreva um programa que permita ao usuário

fornecer strings em uma TextBox. Cada entrada
de string é adicionada em uma ListBox. A medida
que cada string for adicionada a ListBox ,
certifique –se de que as strings estejam ordenadas.
Qualquer método de ordenamento pode ser usado.
11.2 LinkLabel

{
public Form1()
{ InitializeComponent();
}
private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)

{
linkLabel1.LinkVisited = true;
System.Diagnostics.Process.Start("C:\\");
}

{
System.Diagnostics.Process.Start("IExplore", "http://www.infounir.unir.br");
}

{
System.Diagnostics.Process.Start("notepad");
}
}
65
12. CRIANDO DLL´s (Dynamic Link Library)
12.1 Herança Visual
Atenção: Mude o nome da Classe no FORM1.cs

Mude para BaseUnir
1 pictureBox –propriedades: 1 pictureBox –propriedades:
Image: \bin\debug\ logotipo Unir.jpg Image: \bin\debug\ logoUnir.jpg
Size: 699 x 85 Size: 85 x 61
1 button – propriedades
Name bUnir
Text Informações
public partial class BaseUnir : Form

{
public Form1()
{
}

{
this.Text = "Herança Visual UNIR";
label1.Text = "Curso de Bacharelado em Informatica \n 2008";
}
private void bUnir_Click(object sender, EventArgs e)

{
MessageBox.Show("Duração: 4 anos \n Período: diurno \n Vagas: 40",
"Unir",MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
}
No Solution Explorer, clique com o lado direito do mouse sobre PROPRIEDADES

OPEN
em APPLICATION: Assembly Name: BaseUnir
Output Type: Class Library
Salve o Projeto.
66
Repare que ele não consegue mais executar sozinho pois é uma DLL
Atenção:
Verifique que foi criada uma DLL, dentro do \bin\Debug com o nome de BaseUnir.DLL
Crie um novo projeto, Mas um projeto vazio EMPTY PROJECT

Nome: Herança Derivada Unir
No menu PROJECT, escolha a opção ADD NEW ITEM

Escolha INHERITED FORM
Name: derivada, em seguida pressione o botão ADD
Abriu a ferramenta INHERITANCE PICKER

Clique em BROWSE e selecione o arquivo DLL da classe BaseUnir (que está dentro do
\bin\Debug de OUTRO projeto....)
Selecione o arquivo DLL e em seguida, OK
Acrescente o Main no derivada.cs:

public partial class derivada : BaseUnir.Form1
{
public derivada()
{
}

{
Application.Run(new derivada());
}
}
Acrescente 3 novos botões na janela, e coloque MESSAGEBOX em cada um dos botões (evento
CLICK do botão).
12.2 Utilizando UserControl
Os TIMERs (do System.Windows.Forms) são componentes inivisíveis que residem em formulário e

geram eventos TICK em um intervalo definido. Este intervalo é configurado pela propriedade Interval do
TIMER (temporizador) que define o número de milissegundos entre os eventos. Como padrão, os
temporizadores estão em estado inativo.
1. Crie um projeto Windows Control Library RelogioPersonalizado
67
2. Adicione controles e funcionalidades no UserControl1.cs
Isto exibe nosso controle vazio UserControl1.cs como um retângulo cinza.
3. Podemos adicionar controles (usando a ToolBox) e configurar propriedades neste retângulo

cinza.
Repare que não existe método MAIN na classe UserControl1. Adicione 1 Label
Adicione 1 Timer (dentro de Components): configure o intervalo (interval) de Timer = 100.
Mude o Enabled do Timer para True (o padrão é false).
Mude o evento Tick do timer, conforme ilustrado anteriormente.
namespace RelogioPersonal2
{
public partial class UserControl1 : UserControl
{
public UserControl1()
private void timer1_Tick(object sender, EventArgs e)

{
label1.Text = DateTime.Now.ToLongTimeString();
}
}
}//Pois estamos simplesmente criando um novo controle, composto de outros controles.
4. Vá no MENU PROJECT e na opção PROPRIEDADES.
5. Execute o projeto (gere o projeto).
Veja o nome da DLL que será gerada dentro da pasta \bin\Debug. RelogioPersonalizado.dll
Criamos um controle RELÓGIO. Trata-se de um UserControl composto de um Label e um
temporizador – quando o temporizador gera um evento, o label é atualizado para refletir a hora
atual.
6. Crie uma nova aplicação Windows

7. Importe o UserControl. Clique no menu na opção TOOLS e na subopção CHOOSE
TOOLBOX ITEMS. Escolha a guia .NET Framework Components. Clique no botão Browse.
Procure e selecione o arquivo .DLL que está na pasta \bin\Debug dentro do projeto
RelogioPersonalizado e, em seguida, OK.
8. O UserControl aparece no ToolBox e pode ser adicionado no Form.
68
9. No próprio ToolBox, clique com o mouse do lado direito sobre o UserControl1, e renomeie
para Relógio.
Observação: as classes de
controles (UserControl) não tem
um método Main – elas não
podem ser executadas sozinhas.
Para testar sua funcionalidade,
adicione-as em um aplicativo
Windows de exemplo e
execute-as lá.
13. BANCO DE DADOS MySQL

Instale o MySql 5.0 ou superior no seu computador
13.1 Instalação do BD LIVROS e do MySQL

1o Passo) copie o script LIVROS.SQL para dentro da pasta MySQL\BIN
(abra o arquivo livros.sql com o bloco de notas, pois ele é um arquivo texto.)
2º Passo) Execute o programa MySQL Command Line Client
Password: <não digite nada, apenas ENTER>
Cole o conteúdo do arquivo Livros.sql (Clique com o lado direito do mouse e peça
colar)
3º.Passo) Verifique as bases de dados existentes: show databases;
4º.Passo) Ative a base de dados LIVROS recém criada:

Use livros;
5oPasso) após ativar a base de dados LIVROS, veja as tabelas já criadas:

show tables;
OBS: o script deve gerar 4 tabelas: Autores, AutorISBN, Títulos e Editoras.

Veja diagrama a seguir.
69
13.2 Diagrama de Relacionamento de Entidades do banco de dados LIVROS
TITULOS
AUTORES AUTORISBN * isbn
* AutorID * AutorID Titulo
primNome * isbn NumeroEdicao
ultNome Ano
editoraID
Imagem
EDITORAS Preco
* editoraID
NomeEditora
13.3 Exercícios DML: Fazendo consultas e operações no BD Livros
a. Selecionar todos os dados da tabela AUTORES

SELECT * FROM autores OU
SELECT autorID, primNome, ultNome FROM autores
b. Selecionar os livros cujo ano seja maior que 2002
SELECT titulo, numeroEdicao, ano
FROM titulos WHERE ano > 2002;
c. Utilizando a clausula LIKE – localizar os autores cujo sobrenome comecem com D
SELECT autorID, ultNome, primNome
FROM autores WHERE ultNome LIKE ‘D%’;
d. Selecionar os autores cujos sobrenome comecem com qq caractere mas que em seguida
tenham a letra I, e após o i tenham qq número de caracteres adicionais.
SELECT autorID, ultNome, primNome
FROM autores WHERE ultNome LIKE ‘_i%’;
e. Selecionar os autores em ordem crescente por sobrenome
SELECT * FROM autores ORDER BY ultNome
f. Selecionar os autores em ordem decrescente por sobrenome
SELECT * FROM autores ORDER BY ultNome DESC
g. Selecionar os autores em ordem crescente por sobrenome e depois pelo nome
SELECT * FROM autores ORDER BY ultNome, primNome
h. Exibe títulos cujo título termine com ‘como programar’ e em ordem crescente pelo título
SELECT isbn, titulo, numeroedicao, ano, preco FROM titulos
WHERE titulos LIKE ‘%como programar’ ORDER BY titulo
i. Exibir lista de autores acompanhados pelos ISBN´s de livros escritos por cada autor:
SELECT autores.ultNome, autores.primNome, titulos.ISBN, titulos.titulo
FROM autores, titulos, autorISBN
WHERE autorISBN.autorID=autores.autorID AND autorISBN.isbn=titulos.ISBN
j. Insira uma linha na tabela autores:
INSERT INTO autores ( primNome, ultNome )
VALUES (‘Vilma’, ‘Pereira’);
70
// note que não é preciso especificar a coluna autorID porque ela é uma coluna auto-
incrementada
k. Atualiza uma linha na tabela autores, a instrução indica que ultNome receberá o valor
Carvalho para a linha em que ultNome é igual a Pereira e primNome é igual a Vilma.
UPDATE autores SET ultNome = ‘Carvalho’
WHERE ultNome = ‘Pereira’ and primNome = ‘Vilma’;
l. Excluir a linha para Vilma Carvalho na tabela autores:
DELETE FROM autores
WHERE ultNome = ‘Carvalho’ and primNome = ‘Vilma’;
14. ADO .NET

Atenção: é preciso instalar o mysql-connector-net-5.1.5
ADO. NET é uma biblioteca de acesso a banco de dados.
• System.Data é a API (Interface de Programação de Aplicativos) raiz do ADO .NET.
• MySql.Data.MySqlClient contem classes que permite ao programa conectar e modificar
fontes de dados, usando o banco de dados MySql.
O ADO. NET é implementado em várias classes.

Podemos dividi-las em 2 grandes grupos:
• DataClasses (contêm dados) = conjunto de classes desconectadas de um banco de dados.
Principal classe é o DataSet. Funciona como um “cache” em memória para armazenar os
dados. Outras classes que a compõem são: DataTable, DataRow, DataColumn,
DataRelation.
• Managed Providers (acessa dados) = não armazenam dados diretamente, mas sabem como
fazer para ler e escrever em banco de dados reais. São definidos em interfaces: Connection
(gerencia conexão com banco de dados), Command (encapsula um comando SQL e é
usada para executar consultas), DataReader (encapsula cursor só de leitura e só pra frente),
outras. O ADO .NET vem com 4 managed providers: SQL Server, OLEDB, Oracle,
ODBC (MySql).
DATASET = Funciona como um banco de dados em memória. Imita a estrutura de um banco de

dados relacional. Uma vantagem de usar a classe DataSet é que ela é desconectada – o programa
não precisa de uma conexão persistente com a fonte de dados para trabalhar com dados em um
objeto DataSet. O programa se conecta com a fonte de dados apenas durante o preenchimento
inicial do objeto DataSet e, então, armazena todas as alterações feitas no objeto DataSet. Assim, o
programa não exige nenhuma conexão ativa e permanente com a fonte de dados. As tabelas de um
dataset são enxergadas como um array. DataSet e DataTable podem ser ligados a DataControls,
como DataView, GridView, DataList.
DATATABLE = um DataSet consiste em um conjunto de objetos DataTable + DataRelation
(relacionamento entre as tabelas). As tabelas podem conter: Colunas, Colunas calculadas, Linhas,
Restrições e Chaves primárias.
Exemplo: DataSet FILMES
DataTable
DataTable FITAS DataTable
GENEROS CLIENTES
71
MYSQLCONNECTION = representa a conexão com uma fonte/base de dados. Principais métodos são
Open e Close. Ex:
MySqlConnection conDB = new MySqlConnection (
“database=Filmes; Data Source = localhost; User Id=root; Password=123”);
MYSQLDATAADAPTER = se conecta a uma fonte de dados (banco de dados) por meio de uma
instância da classe MySqlConnection e pode preencher um objeto DataTable com dados dessa fonte de
dados. Ou seja, o DataAdapter é um elo de ligação (intermediário) entre as informações que estão no banco
de dados com a aplicação em C#. Exemplo:
“database=Filmes; Data Source = localhost; User Id=root; Password=123”);
MySqlDataAdapter da = new MySqlDataAdapter (“SELECT * FROM fitas”,conDB);
DataAdapter
DataBase
SelectCommand
InsertCommand
UpdateCommand
DeleteCommand
DataSet
TableMappings
O DataAdapter sabe como carregar tabelas e como atualizá-las.

Suas principais propriedades são: comandos para consulta e atualização do BD
Os principais métodos do DataAdapter são:
• FILL (DataSet e DataTable)
• UpDate (DataSet e DataTable)
O programador pode fornecer comandos para Insert, Update e Delete.
MYSQLCOMMAND = representa um comando SQL arbitrário, a ser executado em uma fonte de dados.
Ou seja, é usada para executar consultas. Um programa pode usar instâncias da classe MySqlCommand
para manipular uma fonte de dados por meio de um objeto MySqlConnection. Atenção:
• Usar MySqlCommandBuilder quando utilizar o comando SQL SELECT.
• Usar MySqlCommand qdo utilizar os comandos SQL: INSERT, UPDATE e DELETE
Principais métodos:
• ExecuteReader: executa e retorna um DataReader, ou seja, retorna um cursor apontando para o
início dos dados (usado com o comando SQL SELECT) Representa um conjunto de resultado SQL
• ExecuteNonQuery: executa e não retorna nada (usado com os comandos SQL INSERT, UPDATE
e DELETE)
• ExecuteScalar: executa e retorna um “escalar” (um valor simples como string ou numero)
Exemplo:

“database=Filmes; server = localhost; User Id=root; Password=123”);
MySqlDataAdapter da = new MySqlDataAdapter (“SELECT * FROM fitas”,conDB);
MySqlCommandBuilder cb = new MySqlCommandBuilder(da);
DataTable data = new DataTable();
da.Fill (data);
dataGridView dgv.DataSource = data;
72
14.1 Primeira Aplicação ADO. NET (Controle Alunos)
(não se esqueça de fazer ADD References, no Solution Explorer, do MySql.Data)
DataBase CURSO
CADALUNO
Int *ID (automático)
varchar(45) matricula
varchar(255) nome
varchar(45) curso
int ano
date dataNasc
Para Remover uma linha, basta

selecioná-la e clicar em DELETE.
Não se esqueça de pedir a
atualização do BD (clique no botão
atualizar).
Repare na linha que possui o *.

Nela é possível Inserir um novo
aluno no cadastro.
73
using System.Data;
using MySql.Data.MySqlClient;
namespace cadastroAlunos
{
{
private DataTable data; // armazena resultado da consulta do comando SQL ioresult do Java
private MySqlDataAdapter da; // onde tem a string com o comando SQL (por ex.Select)
private MySqlCommandBuilder cb; // para conseguir executar no BD
public Form1()
{
}
private void btnInserir_Click(object sender, EventArgs e)

{
String strMat = this.txtmat.Text;
String strNome = this.txtNome.Text;
String strCurso = this.txtCurso.Text;
String strIngresso = this.txtIngresso.Text;
String strdia = this.txtDia.Text;
String strmes = this.txtMes.Text;
String strano = this.txtAno.Text;
String strNasc = strano + "-" + strmes + "-" + strdia;
String strInserir =
"INSERT INTO cadAluno VALUES (NULL,"+"'"+strMat+"'"+
","+"'"+strNome+"'"+
","+"'"+strCurso+"'"+
","+"'"+strIngresso+"'"+
","+"'"+strNasc+"'"+");";
MySqlConnection connDB = new MySqlConnection(

"Database=curso;server=localhost;UserId=root");
MySqlCommand cmdDB = new MySqlCommand(strInserir, connDB);
connDB.Open();
cmdDB.ExecuteNonQuery();
connDB.Close();
this.txtmat.Text = "";
this.txtNome.Text = "";
this.txtCurso.Text = "";
this.txtIngresso.Text = "";
this.txtDia.Text = "";
this.txtMes.Text = "";
this.txtAno.Text = "";
this.txtmat.Focus();
}
private void btnFechar_Click(object sender, EventArgs e)

{ Application.Exit(); }
private void btnAtualiza_Click(object sender, EventArgs e)

{
DataTable mudanca = data.GetChanges();
da.Update(mudanca);
data.AcceptChanges();
74
}
private void btnMat_Click(object sender, EventArgs e)
{
String txtMat = this.txtConsulta.Text;
data = new DataTable();

da = new MySqlDataAdapter("SELECT * FROM cadaluno WHERE matricula = " + "'" + txtMat
+ "'", connDB);
cb = new MySqlCommandBuilder(da);
da.Fill(data);
dataGridView1.DataSource = data;
this.txtConsulta.Text = "";
private void btnNome_Click(object sender, EventArgs e)

{
String txtNome = this.txtConsulta.Text;

da = new MySqlDataAdapter(
"SELECT * FROM cadaluno WHERE nome LIKE " + "'" + txtNome + "%'", connDB);
da.Fill(data);
}
private void btnLista_Click(object sender, EventArgs e)

{
da = new MySqlDataAdapter("SELECT * FROM cadaluno" , connDB);
da.Fill(data);
}
}
}
14.2 Utilizando um ComboBox para visualizar a descrição da Chave Estrangeira
75
DataBase = FILMES
FITAS
varchar(5) * codFita
varchar(50) titulo PRODUTORA
GENERO int codGenero
int codProdutora int codProdutora
int codGenero varchar(20) nomeProdutora
varchar(20) descrição varchar(10) dataCompra
real preco int anoProducao
int tempoDuracao
using System;
using System.Data;
namespace CadastroFilmes
{
public partial class cadFilmes : Form
{
private DataTable datatableG, datatableP;
private MySqlDataAdapter daG, daP;
private MySqlCommandBuilder cbG, cbP;
private MySqlConnection conDB;
private DataSet filmesDataSet1;
//variaveis das comboBox´s Genero e Produtora

int cdGenero;
int cdProdutora;
public cadFilmes(String titulo)

{
this.Text = titulo;
}
76
private void btnInsereFilme_Click(object sender, EventArgs e)

{
string strCodFita = this.txtCodFita.Text;
string strTitulo = this.txtTitulo.Text;
string strDia = this.txtDia.Text;
string strMes = this.txtMes.Text;
string strAno = this.txtAno.Text;
string strDataCompra = strDia + "-" + strMes + "-" + strAno;
int iProducao = Int32.Parse(this.txtProducao.Text);
int iDuracao = Int32.Parse(this.txtDuracao.Text);
if (cdGenero == -1) cdGenero = 0;
if (cdProdutora == -1) cdProdutora = 0;
string strInserir =
"INSERT INTO fitas VALUES (" + "'" + strCodFita + "'" +
"," + "'" + strTitulo + "'" +
"," + cdGenero +
"," + cdProdutora +
"," + "'" + strDataCompra + "'" +
"," + iProducao +
"," + iDuracao + ");";
MySqlCommand cmdDB = new MySqlCommand(strInserir, conDB);
conDB.Open();
cmdDB.ExecuteNonQuery();
this.txtCodFita.Text = "";
this.txtTitulo.Text = "";
this.txtDia.Text = "";
this.txtMes.Text = "";
this.txtAno.Text = "";
this.txtProducao.Text = "";
this.txtDuracao.Text = "";
cbProdutora.SelectedIndex = -1;
cbGenero.SelectedIndex = -1;
this.txtCodFita.Focus();
}
private void cadFilmes_Load(object sender, EventArgs e)

{
//carrega comboBox do Genero
conDB = new MySqlConnection(
"database=Filmes;server=localhost;User Id=root");
string strCBGenero;
strCBGenero = "SELECT codgenero,descricao FROM genero ";
strCBGenero += "ORDER BY descricao ";
datatableG = new DataTable();
filmesDataSet1 = new DataSet();
daG = new MySqlDataAdapter(strCBGenero, conDB);
cbG = new MySqlCommandBuilder(daG);
daG.Fill(datatableG);
//daG.Fill(filmesDataSet1,"genero");
cbGenero.DataSource = datatableG; // filmesDataSet1.Tables[0];
cbGenero.DisplayMember = datatableG.Columns["descricao"].ColumnName;
//recuperar a chave da tabela na combo
cbGenero.ValueMember = datatableG.Columns["codgenero"].ColumnName;
cbGenero.SelectedIndex = -1;
// fim do carregamento do comboBox do Genero
77
//carrega comboBox do Produtora
string strCBProdutora;
strCBProdutora= "SELECT codprodutora,nomeprodutora FROM produtora ";
strCBProdutora += "ORDER BY nomeprodutora ";
datatableP = new DataTable();
daP = new MySqlDataAdapter(strCBProdutora, conDB);
daP.Fill(filmesDataSet1,"produtora");
cbP = new MySqlCommandBuilder(daP);
daP.Fill(datatableP);
cbProdutora.DataSource = datatableP;
cbProdutora.DisplayMember = datatableP.Columns["nomeprodutora"].ColumnName;
cbProdutora.ValueMember = datatableP.Columns["codprodutora"].ColumnName;
cbProdutora.SelectedIndex = -1;
// fim do carregamento do comboBox do Produtora
}
private void cbProdutora_SelectedIndexChanged(object sender, EventArgs e)

{
if (cbProdutora.SelectedIndex > -1)
{
String teste= cbProdutora.SelectedValue.ToString();
int.TryParse(teste, out cdProdutora);
}
}
private void cbGenero_SelectedIndexChanged(object sender, EventArgs e)

{
if (cbGenero.SelectedIndex > -1)
{
string teste = cbGenero.SelectedValue.ToString();
int.TryParse(teste, out cdGenero);
}//if
private void cadFilmes_Leave(object sender, EventArgs e)

{
conDB.Close();
}
}
}
78
Comando SQL para exibir os dados neste DATAGRIDVIEW anterior:
da = new MySqlDataAdapter("SELECT fitas.codFita,fitas.titulo, " +

" genero.descricao, genero.preco, " +
" produtora.nomeprodutora, " +
" fitas.dataCompra,fitas.anoproducao,fitas.tempoduracao " +
" FROM Fitas,Genero,Produtora " +
" WHERE genero.codgenero = fitas.codgenero " +
" and produtora.codprodutora = fitas.codprodutora ", conDB);
14.3 Relatórios: Utilizando Crystal Report
OBS: não se esqueça de fazer o ADD References, no Solution Explorer:

(MySQL.Data e Crystal Report for .NET Framework 2.0)
Crie um FORM somente para o relatório (relatFilmes).

No FORM relatFilmes, mude a propriedades:
• WindowState: maximized
No Visual Studio, execute as ações:
DataSource: New DataSource

New Connection localhost(filmes)
ConnectionString Database=filmes;server=localhost;user id=root
filmesConexao
Tables (selecionar as tabelas envolvidas)
DataSet Name: filmesDataSet1
Project – ADD new Item

Crystal Report (relatFita.rpt) - ADD
79
Usar o assistente do Crystal Report
Using report wizard
Standard OK
(Standard Report Crystal Wizard) Create New Connection
ADO.NET
No items found….avançar…..
DataSet Names (file Path): filmesDataSet1
DATA
Available DataSource Select Tables

filmesDataSet1 >> filmesDataSet1
Clicar sobre o filmesDataSet1 do Selected Tables. >>. Avançar

Link (tudo OK) avançar
FIELDS
(escolher os campos das tabelas e selecionar >>)
Avançar
Grouping (não tem)
Record selection (não tem)
Report Style (table)
concluir
Voltar no FORM relatFilmes (design)

Acrescentar um Crystal Report Viewer
Mudar as propriedades:
Name crystalreportviewer1
Report Source relatfita.rpt
DisplayGroupTree (false)
using System;
using System.Data;
namespace CadastroFilmes
{
public partial class relatFilmes : Form
{
public relatFilmes(string titulo)
{
this.Text = titulo;
}
private void relatFilmes_Load(object sender, EventArgs e)

{
relatfita _report = new relatfita();
//carrega comboBox do Genero
MySqlConnection conDB = new MySqlConnection(
"database=Filmes;server=localhost;User Id=root");
80
string stre = "SELECT codfita,titulo,codgenero, codprodutora,

datacompra, anoproducao,tempoduracao FROM fitas ";
DataSet filmesDataSet1 = new DataSet();

MySqlCommand cb1 = new MySqlCommand();
cb1.CommandText = stre;
cb1.CommandType = CommandType.Text;
cb1.Connection = conDB;
MySqlDataAdapter daG = new MySqlDataAdapter();
daG.SelectCommand = cb1;
daG.Fill(filmesDataSet1,"fitas");
_report.SetDataSource(filmesDataSet1);
crystalReportViewer1.ReportSource=_report;
crystalReportViewer1.RefreshReport();
}
}
}
Antes de executar, verifique que são utilizados, no código acima, os objetos:

• “crystalReportViewer1”: controle/componente do Visual Studio (ToolBox) que deve ser
adicionado no Form relatFilmes
• “relatfita”: RELATFITA é o nome do relatório previamente elaborado através do
assistente (wizard) do crystal report
81

ApostilaC Muito Boa

Transféré par

Informations du document

Description originale:

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

ApostilaC Muito Boa

Transféré par

Droits d'auteur :

Formats disponibles

Bacharelado em Informática

Programação Visual (C#)

Profa. Msc. Liliane Jacon

1. HISTÓRICO E PRIMEIROS EXEMPLOS

O C# tem raízes em C, C++ e Java.

1.1 Ambiente do Visual Studio

2o. exemplo) Exibindo uma caixa de texto

3º. Exemplo) Somando dois números

Console. Write( “favor entre com primeiro numero inteiro: “);

Console. Write( “favor entre com segundo numero inteiro: “);

Console.WriteLine(“\n A soma eh {0 } ”, soma);

Operador Precedência == Igualdade

Faça um algoritmo para ler as notas de 10 alunos. Calcular a média da classe.

while (contador <= 10)

somaTotal = somaTotal + nota;

while (nota != -1)

if (nota >= 60)

Console.Write( “entre com a nota do aluno (-1 finaliza): “);

2. MÉTODOS DE PROGRAMA EM C# double

Console.WriteLine ( Math.PI ); // exibe 3,14159265358979323846

Cos (x ) Cos (0.0) é 1.0

2.2 Utilizando Arrays (vetores)

public void geracao()

2.3 Passagem de Parâmetros (VETORES) por Valor e por Referência

public void inicializa()

Console.writeLine(“\nTestando passagem primVetor por Valor\n”);

int [] segVetor = {1,2,3};

Console.writeLine(“\nTestando passagem segVetor por Referência\n”);

ModificaPorReferencia ( ref segVetor);

Console.writeLine(“\nExibe segVetor depois do Método ModificaPorReferencia \n”);

// o metodo modifica o vetor que recebe. O original será modificado

2.4 Método da Bolha (Ordenação/Classificação)

public void inicializa()

Console.writeLine(“\n Entrada dos elementos do Vetor\n”);

Console.writeLine(“\n Vetor Ordenado\n”);

public void Bolha ( int [] b )

3.1 Encapsulamento, Atributos e métodos, Ocultação da informação

private void bVerifica_Click(object sender, EventArgs e)

3.2 Modificadores de Acesso (public e private)

public ClasseTempo() // constructor

Ligando a interface (Form) com a classe ClasseTempo

private void bVerifica_Click(object sender, EventArgs e)

private void bValida_Click(object sender, EventArgs e)

3.4 Utilização de SET´s e GET´s / Propriedades

- uma casa <é composta por> ..

Exemplo: Classe Datas – Classe Empregado – Classe TestaEmpregado(main)

public class Date {

public Date(int d, int m, int a)

public class Empregado

public Empregado(string n, int dn,int mn, int an,

public string ToEmpregadoString()

}// class Empregado

public class TestaComposicao

3.6 Usando a referência THIS

public class Tempo4

public Tempo4(int hora, int minuto, int segundo)

public string ToIniciaString()

Cilindro área = (Π r 2) + ( 2 Π r h ) onde h é a altura

public Ponto(int xvalor,int yvalor)

// toda classe em C# herda da classe System.Object

class circulo : Ponto

public circulo(int xvalor, int yvalor,double r): base(xvalor,yvalor)

public double Raio