Você está na página 1de 81

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
Programação Visual – C#
Profa. Liliane Jacon
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; // acrescentando biblioteca
using System.Windows.Forms;
class Segundo
{
static void Main (string[] args)
{
MessageBox.Show(“Inicio da programação com C# \n parte 2”);
} /* comentario
} */

3º. Exemplo) Somando dois números


using System; // acrescentando biblioteca
class SomaNumeros
{
static void Main (string[] args)
{
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);
string pausa = Console.ReadLine();
} /* 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
Programação Visual – C#
Profa. Liliane Jacon
using System; // acrescentando biblioteca
class MediaClasse
{
static void Main (string[] args)
{
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);
string pausa = Console.ReadLine();
} /* 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
{
static void Main (string[] args)
{
int media, somaTotal, contAprovado, contReprovado, nota;
somaTotal = 0;
contAprovado = 0; contReprovado = 0;
Console.Write( “entre com a nota do aluno (-1 finaliza): “);
nota = Int32.Parse(Console.ReadLine());

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): “);


nota = Int32.Parse(Console.ReadLine());
}
media = somaTotal / 10;

5
Programação Visual – C#
Profa. Liliane Jacon
Console. WriteLine( “\n\nMedia da classe = {0} “, media);
Console. WriteLine( “\nAprovados = {0} e Reprovados = {1} “, contAprovado, contReprovado);
string pausa = Console.ReadLine();
} /* 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
{
static void Main (string[] args)
{
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”);
for (int i = 0; i < vetor.Length; i++)
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]);
string pausa = Console.ReadLine();
}

6
Programação Visual – C#
Profa. Liliane Jacon
// 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
{
static void Main (string[] args)
{
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
Programação Visual – C#
Profa. Liliane Jacon
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 )
{
for (int i = 0; i < v.Length; i++)
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)
{
for (int i = 0; i < v.Length; i++)
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
{
static void Main (string[] args)
{
Ordenacao r = new Ordenacao ();
r.inicializa();
}

public void inicializa()


{
int [] vetor = new int[10];

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


for (int i = 0; i < vetor.Length; i++)
{
Console. writeLine( “\nVetor [ {0}] = “, i);
vetor[i] = Int32.Parse(Console.ReadLine());
}

8
Programação Visual – C#
Profa. Liliane Jacon

Bolha(vetor);

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


for (int i = 0; i < vetor.Length; i++)
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
Programação Visual – C#
Profa. Liliane Jacon
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
Programação Visual – C#
Profa. Liliane Jacon

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
Programação Visual – C#
Profa. Liliane Jacon
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
{
public partial class Form1 : Form
{
ClasseTempo T = new ClasseTempo();

public Form1()
{ InitializeComponent(); }

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==""))
{
h = Int32.Parse(tbHora.Text);
m = Int32.Parse(tbMinuto.Text);
T = new ClasseTempo(h, m, 0); //hora+minuto
}
else// todos diferentes de null
{
h = Int32.Parse(tbHora.Text);
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
Programação Visual – C#
Profa. Liliane Jacon
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" +
"\n " + tempo2.ToUniversalString() +
"\n " + tempo2.ToAmericanoString();
saida += "\nTempo3: especificos Hora e minutos, segundos são default" +
"\n " + tempo3.ToUniversalString() +
"\n " + tempo3.ToAmericanoString();
saida += "\nTempo4: especificos Hora, minutos e segundos" +
"\n " + tempo4.ToUniversalString() +
"\n " + tempo4.ToAmericanoString();
saida += "\nTempo5: tempo com Hora, minutos e segundos invalidos" +
"\n " + tempo5.ToUniversalString() +
"\n " + tempo5.ToAmericanoString();
saida += "\nTempo6: tempo setado com o Tempo4" +
"\n " + tempo6.ToUniversalString() +
"\n " + tempo6.ToAmericanoString();
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
Programação Visual – C#
Profa. Liliane Jacon
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
}
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;
}
}

14
Programação Visual – C#
Profa. Liliane Jacon
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
Programação Visual – C#
Profa. Liliane Jacon
}// 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;
using System.Windows.Forms;

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
Programação Visual – C#
Profa. Liliane Jacon
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;
using System.Windows.Forms;

class TestaTHIS
{
static void Main(string[] args)
{
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
Programação Visual – C#
Profa. Liliane Jacon

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
public override string ToString()
{
return "["+x+", "+y+"]";
}
}

using System;

class circulo : Ponto

18
Programação Visual – C#
Profa. Liliane Jacon
{
private double raio;

public circulo()
{ // chamada implicita ao contrsuctor de Ponto ocorre aqui
}

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


{ // chamada implicita ao contrsuctor de Ponto ocorre aqui
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);
}

public override string ToString()


{
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
Programação Visual – C#
Profa. Liliane Jacon
}

public override double Area()


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

public double Volume()


{
return base.Area() * Altura;
}

public override string ToString()


{
return base.ToString() + "\n Altura "+Altura;
}
}// fim da classe cilindro

using System;
using System.Windows.Forms;

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
Programação Visual – C#
Profa. Liliane Jacon
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
public override string ToString()
{
return "[" + x + ", " + y + "]";

21
Programação Visual – C#
Profa. Liliane Jacon
}
}

class Circulo : Ponto


{
private double raio;

public Circulo()
{ // chamada implicita ao contrsuctor de Ponto ocorre aqui
}

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


: base(xvalor, yvalor)
{ // chamada implicita ao contrsuctor de Ponto ocorre aqui
Raio = r;
}

~Circulo()
{
Console.WriteLine("\n Destruindo objeto circulo {0}", this);
}

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);
}

public override string ToString()


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

public class TestaDestrutor


{
public static void Main(string[] args)
{
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
Programação Visual – C#
Profa. Liliane Jacon
c1= null;
c2 = null;

System.GC.Collect();

string pausa = Console.ReadLine();


}
}

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

Constructor sem args


Operador Britadeira
Constructor com args
ToString
Insalubridade
Propriedades
verifica()
Constructor sem args
getData()
Constructor com args
bissexto()
CalculaSalario
ToString
propriedades

Técnico de Explosivos

Adicional Periculosidade

Constructor sem args


Constructor com args
CalculaSalario
ToString
propriedades

23
Programação Visual – C#
Profa. Liliane Jacon

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
Programação Visual – C#
Profa. Liliane Jacon
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
Programação Visual – C#
Profa. Liliane Jacon
public override string ToString()
{
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


{
// variaveis de instancia
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


{
// variaveis de instancia
private double periculosidade;

// metodos

26
Programação Visual – C#
Profa. Liliane Jacon
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
{
static void Main(string[] args)
{
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);
string pausa = Console.ReadLine();

operadorBritadeira op = new operadorBritadeira("operadTil", "2345",


1300, 13, 08, 2002, 500);
op.calculaSalario();
temp = "\n\nOperador Britadeira " + op.ToString()+"
Liquido="+op.SalarioLiquido;
Console.WriteLine(temp);
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;
Console.WriteLine(temp);
pausa = Console.ReadLine();
}
}
===============================================================

27
Programação Visual – C#
Profa. Liliane Jacon
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; }
}
public override string ToString()
{
return "["+X+", "+Y+"]";
}
}

using System;
class Circulo: Ponto
{
private double raio;
public Circulo()
{
}
public Circulo(int xValor, int yValor, double r)
: base(xValor, yValor)
{
raio = r;
}
public double Raio
{
get { return raio; }
set { raio = ((value > 0) ? value : 1); }
}

28
Programação Visual – C#
Profa. Liliane Jacon
public double Diametro()
{
return raio * 2;
}
public double circunferencia()
{
return Math.PI * Diametro();
}
public virtual double Area()
{
return Math.PI * Math.Pow(raio, 2);
}
public override string ToString()
{
return "Centro= "+base.ToString()+"; Raio= "+Raio;
}
}

using System;
using System.Windows.Forms;

class testaConversao
{
static void Main(string[] args)
{
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
Programação Visual – C#
Profa. Liliane Jacon
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
public virtual double Area()
{
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; }
}

public override string ToString()


{
return "[" + X + ", " + Y + "]";
}

public override string Nome


{
get { return " Ponto "; }
}

30
Programação Visual – C#
Profa. Liliane Jacon
}
public class Circulo: Ponto
{
private double raio;

public Circulo()
{
}

public Circulo(int xValor, int yValor, double r)


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

public double Raio


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

public double Diametro()


{
return raio * 2;
}

public double Circunferencia()


{
return Math.PI * Diametro();
}

public override double Area()


{
return Math.PI * Math.Pow(raio, 2);
}

public override string ToString()


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

public override string Nome


{
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
Programação Visual – C#
Profa. Liliane Jacon
public double Altura
{
get { return altura; }
set { altura = ((value >= 0) ? value : 0); }
}

public override double Area()


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

public override double Volume()


{
return base.Area()* Altura;
}

public override string ToString()


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

public override string Nome


{
get { return " Cilindro "; }
}
}
using System;
using System.Windows.Forms;
public class testaAbstrata
{
public static void Main(string[] args)
{
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
Programação Visual – C#
Profa. Liliane Jacon
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
Programação Visual – C#
Profa. Liliane Jacon
public string Nome
{
get { return primNome + " " + ultNome; }
}
}

using System;
using System.Windows.Forms;

public class TestaInterface


{
public static void Main(string[] args)
{
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;
using System.Windows.Forms;

public class Divisao


{
static void Main(string[] args)
{
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
Programação Visual – C#
Profa. Liliane Jacon
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",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}

}// 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;
using System.Windows.Forms;
public class raizQuadrada
{
static void Main(string[] args)
{
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",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
catch (NumeroNegativoExcecao erroNegativo)
// tentou dividir por zero
{
MessageBox.Show(erroNegativo.Message,
"raiz quadrada de Nro Negativo não existe",

35
Programação Visual – C#
Profa. Liliane Jacon
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}// fim do main
}// fim da classe

7.3 Testando estouros com os operadores CHECKED e UNCHECKED


using System;
class Overflow
{
static void Main(string[] args)
{
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);
string pausa = Console.ReadLine();
}// 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
Programação Visual – C#
Profa. Liliane Jacon
• 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
Programação Visual – C#
Profa. Liliane Jacon
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:
public partial class Form1 : Form
{
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)
private void b0_Click(object sender, EventArgs e)
{
}
Mude para o seguinte:
private void botao_Click(object sender, EventArgs e)
{
if (sender==b1)
NumAtual = NumAtual+'1';
else if (sender==b2)
NumAtual = NumAtual+'2';
else if (sender==b3)
NumAtual = NumAtual+'3';
else if (sender==b4)
NumAtual = NumAtual+'4';
else if (sender==b5)
NumAtual = NumAtual+'5';
else if (sender==b6)

38
Programação Visual – C#
Profa. Liliane Jacon
NumAtual = NumAtual+'6';
else if (sender==b7)
NumAtual = NumAtual+'7';
else if (sender==b8)
NumAtual = NumAtual+'8';
else if (sender==b9)
NumAtual = NumAtual+'9'; faça para os demais
else NumAtual = NumAtual+'0'; botões b1 até b9
visor.Text = NumAtual;
}

private void b0_Click(object sender, EventArgs e)


{
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)
private void bsoma_Click(object sender, EventArgs e)
{
}

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
Programação Visual – C#
Profa. Liliane Jacon
private void bsoma_Click(object sender, EventArgs e)
{
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
Programação Visual – C#
Profa. Liliane Jacon
Dentro de cada TabPage, coloque RadioButton´s (mude Name e Text)

Form1.cs
public partial class Form1 : Form
{
public Form1()
{ InitializeComponent(); }

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)


{ msg.Font = new Font(msg.Font.Name, 14); }

private void dezesseis_CheckedChanged(object sender, EventArgs e)


{ msg.Font = new Font(msg.Font.Name, 16); }

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

static void Main(string[] args)


{
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
Programação Visual – C#
Profa. Liliane Jacon

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

static void Main(string[] args)


{
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


static void Main(string[] args)
{
string str1 = "alo";
string str2 = "adeus";
string str3 = "Feliz Aniversario";
string str4 = "feliz aniversario";
string saida;

saida = "str1 = \"" + str1 + "\"" +


"\nstr2 = \"" + str2 + "\"" +
"\nstr3 = \"" + str3 + "\"" +

42
Programação Visual – C#
Profa. Liliane Jacon
"\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) " +
str2.CompareTo(str1) + "\n" +
"str1.CompareTo(str1) " +
str1.CompareTo(str1) + "\n" +
"str3.CompareTo(str4) " +
str3.CompareTo(str4) + "\n" +
"str4.CompareTo(str3) " +
str4.CompareTo(str3) + "\n\n";

MessageBox.Show(saida, "Demosntracao de comparacao de strings",


MessageBoxButtons.OK, MessageBoxIcon.Information);
}

8.8 Localizando caracteres e substrings


em strings

static void Main(string[] args)


{
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
Programação Visual – C#
Profa. Liliane Jacon
//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",


MessageBoxButtons.OK, MessageBoxIcon.Information);
}

8.9 Exercicio

44
Programação Visual – C#
Profa. Liliane Jacon
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;
using System.Windows.Forms;

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

45
Programação Visual – C#
Profa. Liliane Jacon

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)


{
tipoBotao_CheckedChanged(sender, e);
}

private void rbARI_CheckedChanged(object sender, EventArgs e)


{
tipoBotao_CheckedChanged(sender, e);
}

private void rbYNC_CheckedChanged(object sender, EventArgs e)


{
tipoBotao_CheckedChanged(sender, e);
}

private void rbYN_CheckedChanged(object sender, EventArgs e)


{
tipoBotao_CheckedChanged(sender, e);
}

private void rbRC_CheckedChanged(object sender, EventArgs e)


{
tipoBotao_CheckedChanged(sender, 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
Programação Visual – C#
Profa. Liliane Jacon
tipoIcone_CheckedChanged(sender, e);
}

private void rbExclama_CheckedChanged(object sender, EventArgs e)


{
tipoIcone_CheckedChanged(sender, e);
}

private void rbInfo_CheckedChanged(object sender, EventArgs e)


{
tipoIcone_CheckedChanged(sender, e);
}

private void rbQuestao_CheckedChanged(object sender, EventArgs e)


{
tipoIcone_CheckedChanged(sender, 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
Programação Visual – C#
Profa. Liliane Jacon
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 partial class Form1 : Form


{
public Form1()
{
InitializeComponent();
}

private void janela1ToolStripMenuItem_Click(object sender, EventArgs e)


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

private void janela2ToolStripMenuItem_Click(object sender, EventArgs e)


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

private void janela3ToolStripMenuItem_Click(object sender, EventArgs e)


{
Filho janFilho = new Filho("Janela 3", "\\dado3.gif");
janFilho.MdiParent = this;
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
Programação Visual – C#
Profa. Liliane Jacon
{
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)
{
InitializeComponent();
Text = titulo;
pBox.Image = Image.FromFile(Directory.GetCurrentDirectory() + filename);
}
}

Cascata TileHorizontal TileVertical

49
Programação Visual – C#
Profa. Liliane Jacon
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
Programação Visual – C#
Profa. Liliane Jacon

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.MdiParent = this;
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)


{
InitializeComponent();
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
Programação Visual – C#
Profa. Liliane Jacon
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;
case 1: bO1.Text = vetor[i].ToString();
bO2.Text = vetor[i+1].ToString();
bB1.Text = vetor[i].ToString();
bB2.Text = vetor[i + 1].ToString();
break;
case 2: bO2.Text = vetor[i].ToString();
bO3.Text = vetor[i+1].ToString();
bB2.Text = vetor[i].ToString(); bB3.Text = vetor[i + 1].ToString();
break;
case 3: bO3.Text = vetor[i].ToString();
bO4.Text = vetor[i+1].ToString();
bB3.Text = vetor[i].ToString(); bB4.Text = vetor[i + 1].ToString();
break;
}//switch
}//if
tam--;
}//while
}

52
Programação Visual – C#
Profa. Liliane Jacon
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
Programação Visual – C#
Profa. Liliane Jacon

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
Programação Visual – C#
Profa. Liliane Jacon
lock (this)
{
if (Vazia())
{
//throw new ExcecaoListaVazia(nomeDaLista);
return null;
}
object item = primeiro.Dado;
if (primeiro == ultimo)
primeiro = ultimo = null;
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)
primeiro = ultimo = null;
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

public override string ToString()


{
string temp="";
lock (this)
{
if (Vazia())
{
temp += "Vazia " + nomeDaLista;
return temp;
}//if vazia
temp += "A " + nomeDaLista + " contem \n\n";
No atual = primeiro;

55
Programação Visual – C#
Profa. Liliane Jacon
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 System.Windows.Forms;
using ListaEncBiblioteca;

namespace Lista_Enc_com_GUI
{
public partial class Form1 : Form
{
bool booleano;
char[] caracter=new char[1];
int inteiro;
double real;
string texto, frase;
Lista l;

public Form1()
{
InitializeComponent();
}

private void tBInsere_TextChanged(object sender, EventArgs e)


{
texto = tBInsere.Text;
lRemove.Text = "";
try
{
if (rbBool.Checked)
{

56
Programação Visual – C#
Profa. Liliane Jacon
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",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}

private void bInsFrente_Click(object sender, EventArgs e)


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

private void Form1_Load(object sender, EventArgs e)


{
l = new Lista("Lista com GUI");
lPrimeiro.Text = l.exibePrim();

57
Programação Visual – C#
Profa. Liliane Jacon
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);
else if (rbChar.Checked)
l.InsereNoFundo(caracter[0].ToString());
else if (rbInt.Checked)
l.InsereNoFundo(inteiro);
else if (rbReal.Checked)
l.InsereNoFundo(real);
else if (rbString.Checked)
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();
lPrimeiro.Text = l.exibePrim().ToString();
lUltimo.Text = l.exibeUlt().ToString();
}

58
Programação Visual – C#
Profa. Liliane Jacon
private void bDelFundo_Click(object sender, EventArgs e)
{
object temp = l.RemoveDoFundo();
if (temp != null)
lRemove.Text = "Removeu o " + temp.ToString();
lLista.Text = l.ToString();
lPrimeiro.Text = l.exibePrim().ToString();
lUltimo.Text = l.exibeUlt().ToString();
}

private void bExibe_Click(object sender, EventArgs e)


{
lLista.Text = l.ToString();
lPrimeiro.Text = l.exibePrim().ToString();
lUltimo.Text = l.exibeUlt().ToString();
lRemove.Text = "";
}

private void bLimpa_Click(object sender, EventArgs e)


{
object te;
while (!l.Vazia())
te = l.RemoveDaFrente();
lLista.Text = l.ToString();
lPrimeiro.Text = l.exibePrim().ToString();
lUltimo.Text = l.exibeUlt().ToString();
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;
using System.Windows.Forms;

namespace TestaArrayList
{
public partial class Form1 : Form
{
private ArrayList arraylist = new ArrayList(1);
public Form1()
{ InitializeComponent(); }

59
Programação Visual – C#
Profa. Liliane Jacon
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
Programação Visual – C#
Profa. Liliane Jacon

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
{
public partial class Form1 : Form
{
List <Registro> arraylist = new List <Registro>();
IEnumerator enumeracao;

public Form1()
{
InitializeComponent();
enumeracao = arraylist.GetEnumerator();
}

61
Programação Visual – C#
Profa. Liliane Jacon
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
Programação Visual – C#
Profa. Liliane Jacon

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
PROPRIEDADES Descrição
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
Programação Visual – C#
Profa. Liliane Jacon
public partial class Form1 : Form
{
string[] vetor = { "solteiro", "casado", "viúvo", "desquitado", "separado",
"divorciado", "outros" };

public Form1()
{
InitializeComponent();
}

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(); }

private void button1_Click(object sender, EventArgs e)


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

private void button2_Click(object sender, EventArgs e)


{
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
PROPRIEDADES Descrição
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
Programação Visual – C#
Profa. Liliane Jacon
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 partial class Form1 : Form


{
public Form1()
{ InitializeComponent();
}

private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)


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

private void linkLabel2_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)


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

private void linkLabel3_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)


{
linkLabel3.LinkVisited = true;
System.Diagnostics.Process.Start("notepad");
}
}

65
Programação Visual – C#
Profa. Liliane Jacon
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()
{
InitializeComponent();
}

private void Form1_Load(object sender, EventArgs e)


{
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
Programação Visual – C#
Profa. Liliane Jacon
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()
{
InitializeComponent();
}

public static void Main(string[] args)


{
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
Programação Visual – C#
Profa. Liliane Jacon
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()
{ InitializeComponent(); }

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
Programação Visual – C#
Profa. Liliane Jacon
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
Programação Visual – C#
Profa. Liliane Jacon
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
Programação Visual – C#
Profa. Liliane Jacon
// 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
Programação Visual – C#
Profa. Liliane Jacon

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:
MySqlConnection conDB = new MySqlConnection (
“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:

MySqlConnection conDB = new MySqlConnection (


“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
Programação Visual – C#
Profa. Liliane Jacon
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
Programação Visual – C#
Profa. Liliane Jacon

using System.Data;
using System.Windows.Forms;
using MySql.Data.MySqlClient;

namespace cadastroAlunos
{
public partial class Form1 : Form
{
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()
{
InitializeComponent();
}

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
Programação Visual – C#
Profa. Liliane Jacon
}
private void btnMat_Click(object sender, EventArgs e)
{
String txtMat = this.txtConsulta.Text;

data = new DataTable();


MySqlConnection connDB = new MySqlConnection(
"Database=curso;server=localhost;UserId=root");
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;

data = new DataTable();


MySqlConnection connDB = new MySqlConnection(
"Database=curso;server=localhost;UserId=root");
da = new MySqlDataAdapter(
"SELECT * FROM cadaluno WHERE nome LIKE " + "'" + txtNome + "%'", connDB);
cb = new MySqlCommandBuilder(da);
da.Fill(data);
dataGridView1.DataSource = data;
this.txtConsulta.Text = "";
}

private void btnLista_Click(object sender, EventArgs e)


{
data = new DataTable();
MySqlConnection connDB = new MySqlConnection(
"Database=curso;server=localhost;UserId=root");
da = new MySqlDataAdapter("SELECT * FROM cadaluno" , connDB);
cb = new MySqlCommandBuilder(da);
da.Fill(data);
dataGridView1.DataSource = data;
this.txtConsulta.Text = "";
}
}
}

14.2 Utilizando um ComboBox para visualizar a descrição da Chave Estrangeira

75
Programação Visual – C#
Profa. Liliane Jacon

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;
using System.Windows.Forms;
using MySql.Data.MySqlClient;

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)


{
InitializeComponent();
this.Text = titulo;
}

76
Programação Visual – C#
Profa. Liliane Jacon

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
Programação Visual – C#
Profa. Liliane Jacon
//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
Programação Visual – C#
Profa. Liliane Jacon

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
Programação Visual – C#
Profa. Liliane Jacon
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;
using System.Windows.Forms;
using MySql.Data.MySqlClient;

namespace CadastroFilmes
{
public partial class relatFilmes : Form
{
public relatFilmes(string titulo)
{
InitializeComponent();
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
Programação Visual – C#
Profa. Liliane Jacon

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