Apostila desenvolvimento aplicações comerciais com C#
61 gostaram74,587 visualizações
O documento é um guia abrangente sobre o Microsoft .NET Framework, Visual Studio e a linguagem C#, explicando sua história, arquitetura, recursos e como iniciar o desenvolvimento de aplicações. Ele detalha as versões do .NET Framework, o funcionamento do Common Language Runtime (CLR) e o conceito de Garbage Collection, assim como fornece introduções práticas ao Visual Studio. O texto também inclui links para recursos adicionais e orientações sobre a estrutura básica de um projeto.
![3 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Arquitetura básica
O Microsoft .NET Framework é composto por 2 componentes principais: o CLR(Common Language Runtime) e a biblioteca de
classes. O Common Language Runtime é a base do Framework .NET. Você pode pensar no Runtime como um agente que gere
código em tempo de execução, fornecendo principalmente serviços como gerenciamento de memória, gerenciamento de segmento
e processamento remoto, ao mesmo tempo a segurança de tipos estritos e outras formas de precisão de código que promovem
segurança e robustez. Na verdade, o conceito de gerenciamento de código é um princípio fundamental do runtime. Código
rodando sobre o CLR é conhecido como código gerenciado, enquanto o código que não roda sobre ele é conhecido como código
não gerenciado. A biblioteca de classes, é o outro componente principal do .NET Framework, se trata de uma vasta coleção
orientada a objetos de tipos reutilizáveis que você pode usar para desenvolver aplicações que vão desde a tradicional linha de
comando até aplicativos com interface gráfica do usuário (GUI), para aplicativos com base em inovações mais recentes fornecidas
pelo ASP.NET, como Web Forms e Serviços Web XML.
Abaixo temos uma ilustração com uma visão holística da relação entre a biblioteca de classes, o.net framework, sua aplicação e o
sistema operacional ou o hardware.
O que é IL?
Uma grande quantidade de linguagens podem ser utilizadas para construção de aplicativos baseados no .net framework , na
verdade qualquer linguagem que possua um compilador IL pode ser utilizada, como exemplo podemos citar C#, VB.NET,
DELPHI.NET e J#, apesar de o C# ter sido adotado como linguagem oficial para o .net framework. O que acontece na verdade
acontece é que todo código é traduzido na compilação para IL que é a abreviação Itermediate language, ou seja, linguagem
intermediária e essa é a única linguagem que o CLR entende sendo interpretada e gerenciada por ele em tempo de execução e
transformando-a posteriormente em código de máquina(binário), os principais tipos de arquivos gerados por um compilador IL
variam dependendo do tipo de projeto são estes: EXE, DLL e ASPX.
Abaixo um pequeno exemplo “hello world” em c# e abaixo o mesmo programa em IL.
Versão C#;
using System;
namespace HelloWorldIL
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello, World !");
}
}
}](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-6-320.jpg)
![4 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Versão IL;
.assembly extern mscorlib {}
.assembly HelloWorldIL {}
.namespace HelloWorldIL
{
.class Program
{
.method static public void Main() cil managed
{
.entrypoint
.maxstack 8
ldstr "Hello, World !"
call void [mscorlib] System.Console::WriteLine(string)
call valuetype [mscorlib]System.ConsoleKeyInfo
[mscorlib]System.Console::ReadKey()
ret
}
}
}](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-7-320.jpg)
![17 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Capítulo 3-Microsoft C#
O que é?
C # é uma linguagem de programação multi-paradigma fortemente tipada, imperativa, declarativa, funcional, genérica, orientada
a objetos (class-based) e orientada a componentes. Ele foi desenvolvido pela Microsoft como parte da iniciativa
.net e posteriormente aprovada como padrão pelo Ecma (ECMA-334) e ISO (ISO / IEC 23270). C # é uma das linguagens de
programação projetadas para o Common Language Infrastructure.
C # é destinado a ser uma linguagem orientada a objetos, simples, moderna e de propósito geral. A sua equipe de
desenvolvimento é liderada por Anders Hejlsberg.
História
Durante o desenvolvimento do .net Framework as biblioteca de classes foram originalmente escrita utilizando um sistema
compilador de código gerenciado chamado Simple Managed C(SMC). Em janeiro de 1999 Anders Hejlsberg formou um time para
construir uma nova linguagem por hora chamada de Cool um Acrônimo para “Clique Object Oriented Language”. A Microsoft
chegou a considerar deixar Cool como o nome final da linguagem, mas mudou de ideia por razões comerciais. O C# foi anunciado
oficialmente em julho de 2000 e neste momento a biblioteca de classes do ASP.net já havia sido reescrita em c#.
Visão Conceitual Classes
Iniciaremos com uma visão conceitual sobre classes, pois o C# é totalmente orientado a objetos e tudo é baseado em classes, o
conceito de classe é basicamente a união entre os dados e as funções em uma mesma unidade lógica. Diferente de linguagens
como o C++ você não consegue escrever uma função sem que a mesma esteja dentro de uma classe. As classes são utilizadas
para criar instancias, ou seja armazenar dados na memória sobre operações e valores para que fiquem disponíveis em tempo
execução. Abaixo um exemplo de classe:
public. class MyClass
{
//No caso MyPropertie e MypropertieInt int seriam os dados da classe MyClass
private string MyPropertie;
private int MyPropertieInt;
//SetMyPropertie seria um método que manipula os dados dados da própria classe
public void SetMyPropertie(string MyPropertie) {
this.MyPropertie = MyPropertie;
}
}
A sintaxe básica de uma classe em C#
public class [Nome da classe]{
//Variaveis
private string var1;
private string varN...;
//Contrutores
public [Nome da classe]();
//Funções
public void Method1();
public void MethodN...();
}](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-20-320.jpg)
![18 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Sintaxe para criação de Instancia em C#;
MyClass obj = new MyClass();
Posteriormente nesse capítulo abordaremos as classes com mais profundidade.
Namespaces
Os Namespaces servem como uma forma de dividir os objetos em categorias, normalmente de acordo com sua natureza,
independente do projeto ou arquivo que estão.
Sintaxe básica
namespace [NomeNameEspace]{
...//Objetos definidos no namespace
}
Namespaces podem conter outros namespace formando uma estrutura hierárquica, veja o exemplo abaixo:
namespace Animal
{
namespace Caninos
{
namespace Cachorro
{
public class Poodle
{
}
}
}
}
Isso permite ter o mesmo nome de classe em namespaces diferentes, pois o nome completo da classe consiste em cada um de seus
namespaces separados por um ponto com o nome da classe no final, também separado por um ponto. Sendo assim o nome
completo da classe Poodle seria “Animal.Caninos.Cachorro.Poodle”, esse nome não precisa ser escrito completo a toda hora
graças ao comando using que será detalhado a seguir.
Using
Esse é outro elemento básico da sintaxe do C# ele serve para que todos os tipos definidos em um namespace fiquem disponíveis
sem escrever o seu nome completo. Abaixo um exemplo:
Temos 3 classes Poodle,PastorAlemao e Canil, as duas primeiras estão no namespace “Animais” e a última está no namespace
“Lugares”, precisamos declarar um objeto Poodle e um PastorAlemão na classe Canil, abaixo o código sem a utilização de using:
namespace Lugares
{
public class Canil
{
Animais.Poodle Cachorro1;
Animais.PastorAlemao Cachorro2;
public Canil(Animais.Poodle Cachorro1,Animais.PastorAlemao Cachorro2) {
this.Cachorro1 = Cachorro1;
this.Cachorro2 = Cachorro2;
}
}
}
Agora com a utilização do using:
using System;
using System.Collections.Generic;
using System.Linq;](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-21-320.jpg)
![19 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
using System.Text;
using Animais;
namespace Lugares
{
public class Canil
{
Poodle Cachorro1;
PastorAlemao Cachorro2;
public Canil(Poodle Cachorro1, PastorAlemao Cachorro2)
{
this.Cachorro1 = Cachorro1;
this.Cachorro2 = Cachorro2;
}
}
}
Observe os outros namespaces antes de Animais, são onde estão os tipos fundamentais do framework e por padrão são
adicionados ao criar uma classe.
Tipos de dados básicos
C# é uma linguagem fortemente tipada. Cada variável e constante tem um tipo explícito. Cada assinatura do método Especifica
um tipo para cada parâmetro de entrada e o valor de retorno. A.NET Framework class library define um conjunto de tipos
numéricos internos, como também os tipos mais complexos que representam uma ampla variedade de construções lógicas, como,
por exemplo, sistema de arquivos, conexões de rede, coleções e matrizes de objetos e as datas. Um programa C# típico usa tipos
da biblioteca de classes bem como tipos definidos pelo usuário que modelam os conceitos que são específicos para o domínio do
problema do programa.
As informações armazenadas em um tipo podem incluir o seguinte:
O espaço de armazenamento que necessita de uma variável do tipo.
Os valores máximo e mínimo que ele pode representar.
Os membros (métodos, campos, eventos e assim por diante) que ele contém.
O tipo base que ela herda.
O local de memória onde as variáveis serão alocadas em tempo de execução.
Os tipos de operações que são permitidos.
O compilador usa informações do tipo para verificar se todas as operações que são executadas em seu código são seguras. Por
exemplo, se você declarar uma variável do tipo int, o compilador permite usar a variável em operações de soma e subtração. Se
você tentar executar essas mesmas operações em uma variável do tipo bool, o compilador gera um erro.
Abaixo exemplo de código que geraria um erro no compilador
static void Main(string[] args)
{
int a = 5;
int b = a + 2; //OK
bool test = true;
// Error. Operator '+' cannot be applied to operands of type 'int'
and 'bool'.
int c = a + test;
}
O operador + não pode ser aplicado entre um int e um bool;](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-22-320.jpg)
![20 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Especificações dos principais tipos em C#.
Tipos inteiros
Tipo Abrangência Tamanho em bits
sbyte -128 to 127 8
byte 0 to 255 8
char U+0000 to U+ffff 16
short -32,768 to 32,767 16
ushort 0 to 65,535 16
int -2,147,483,648 to 2,147,483,647 32
uint 0 to 4,294,967,295 32
-9,223,372,036,854,775,808 to
long 64
9,223,372,036,854,775,807
ulong 0 to 18,446,744,073,709,551,615 64
Tipos de ponto flutuante e decimal
Tamanho
Abrangência
Tipo Precisão em bits
float ±1.5e−45 to ±3.4e38 7 dígitos 32
double ±5.0e−324 to ±1.7e308 15-16dígitos 64
28 28 0 to 28
decimal (-7.9 x 10 to 7.9 x 10 ) / (10 ) 28-29 dígitos significantes 128
Outros tipos de dados importantes
Tipo Descrição
string Representa uma cadeia de caracteres
DateTime Representa um espaço de tempo e contém uma série de funções para lidar com datas
Tipos de valor e de referência
Os tipos de valor são aqueles tipos que a variável fica diretamente ligada ao valor atribuído a mesma, e quando passado como
parâmetro para alguma função na verdade é copiado para o escopo da função, o que faz que alterações feitas nos valores dentro
dela não reflitam no valor original da variável, a menos que ela seja atribuída novamente no escopo em que foi declarada. Já com
tipo de referência o que ocorre é que a variável esta relacionada a um ponteiro para o espaço de memória onde o valor da mesma
está armazenado, então quando ela é passada como parâmetro para uma função a referência é passada e as alterações de valores
são feitas diretamente no espaço de memória que guarda o valor da variável alterando assim o valor da mesma no escopo original,
porém isso só ocorre quando a palavra reservada “ref” é colocada na assinatura da função. Abaixo um exemplo para ficar mais
fácil entender o que isso representa.
class Program
{
static void Main(string[] args)
{
string a = "5";](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-23-320.jpg)
![21 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
string b = "2";
String a2="5";
String b2 = "2";
Console.WriteLine("TIPOS DE VALOR...rnrn");
Console.WriteLine(string.Format("Valores de a e b no escopo que foram definidos a:{0}
b:{1}rn",a,b));
Swap(ref a,ref b);
Console.WriteLine(string.Format("Valores de a e b no escopo que foram definidos
continuam os mesmos a:{0} b:{1}rn",a2,b2));
Console.WriteLine("TIPOS DE REFERÊNCIA...rnrn");
Console.WriteLine(string.Format("Valores de a e b no escopo que foram definidos a:{0}
b:{1}rn",a2,b2));
Swap(ref a2,ref b2);
Console.WriteLine(string.Format("Valores de a e b no escopo que foram definidos mudam
a:{0} b:{1}rn",a2,b2));
Console.ReadKey();
}
public static void Swap(ref String a,ref String b)
{
string c;
c = a;
a = b;
b = c;
Console.WriteLine(string.Format("Valores de a e b no escopo da função a:{0}
b:{1}rn",a,b));
}
}
Escrevam esse código em um projeto do tipo Console Application do Visual Studio e percebam que os valores de a e b foram
alterados dentro da função, mas na classe main permaneceram os mesmos, já de a2 e b2 tiveram os seus valores alterados também
no escopo principal. Dos tipos apresentados nas tabelas acima apenas DateTime é de referência os demais são de valor, porém
todos os tipos citados tem um correspondente de referência que fazem parte do .net Framework.
Variáveis
Variáveis são simplesmente locais de armazenamento de dados. Você pode armazenar e recuperar os dados através de um nome
atribuído à variável. Quando criamos uma variável precisamos dizer o tipo de dado a ser armazenado na mesma e atribuir-lhe um
nome, a sintaxe para isso em C# é a seguinte:
[Tipos] [Nome Da Variável];
Exemplo:
int Numero;
As variáveis assim como as funções só podem ser definidas dentro de uma classe.
Operadores
Em C #, um operador é um elemento do programa que é aplicada a um ou mais operações em uma expressão ou
declaração. Operadores que levam um operando, como o operador de incremento (+ +), são referidos como operadores
unários. Operadores que usam dois operandos, como operadores aritméticos (+,-,*,/), são referidos como operadores binários. O
operador condicional (?:), leva três operandos e é o único operador ternário em C #.
Um operando pode ser uma expressão válida de qualquer tamanho, e pode ser composto por qualquer numero de outras
expressões. Em uma expressão que contenha múltiplos operadores, a ordem na qual os operadores serão aplicados é determinada
pela ordem de precedência do operador, associatividade e posicionamento de parênteses.](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-24-320.jpg)
![22 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Cada operador tem uma precedência definida. Em uma expressão que contenham múltiplos operadores com ordem de precedência
diferentes, a precedência dos operadores determina a ordem que os operadores serão executados. Por exemplo, a expressão
seguinte atribui o valor 3 para n1.
n1 = 11 - 2 * 4;
A multiplicação é executada primeiro, pois tem precedência sobre a subtração.
As tabelas a seguir separam os operadores em categorias baseadas no tipo de operações que realizam. As
categorias estão listadas em ordem de precedência.
Operações primárias
Expressão Descrição
x.y Acesso de associado
f(x) Invocação de métodos e delegates
a[x] Array and indexer access
x++ Pós-incremento
x-- Pós-decremento
new T(...) Criação de objetos e delegates
new T(...){...} Criação de objeto com inicializador.
new {...} Inicializador de objeto anônimo.
new T[...] Criação de array
typeof(T) Obtém o Sytem.Type para T
checked(x) Executa a expressão em um contexto checado
unchecked(x) Executa a expressão em um contexto não checado
default (T) Obtém o valor default para T
delegate {} Função anônima(Método anônimo)
Operadores unários
Expressão Descrição
+x Identidade
-x Negação
!x Negação lógica
~x Negação bit à bit
++x Pré-Incremento
--x Pré-decremento
(T)x Conversão explicita para o tipo T
Operadores multiplicativos
Expressão Descrição
* Multiplicação
/ Divisão
% Resto
Operadores Aditivos
Expressão Descrição
x+y Adição, concatenação de string, combinação de delegate.
x-y Subtração remoção de delegate.
Operadores de troca](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-25-320.jpg)
![24 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
//Saída "2"
//Operador pós-incremento
int PosIncremento = 1;
PosIncremento = PosIncremento++;
Console.WriteLine(PosIncremento);
//Saída "1", pois primeiro ele atribui o valor a variável e depois incrementa o valor.
bool NegacaoLogica = true;
Console.WriteLine(!NegacaoLogica);
//Saída "false"
NegacaoLogica = false;
Console.WriteLine(!NegacaoLogica);
//Saída "true", pois negar uma negação a torna em uma afirmação.
//Algumas operações aritmética
int n1=4, n2 = 2;
Console.WriteLine(n1 + n2);
//Saída "6", 4+2
Console.WriteLine(n1 * n2);
//Saída "8", 4*2
Console.WriteLine(n1 / n2);
//Saída "2", 4/2
Console.WriteLine(n1 - n2);
//Saída "2", 4-2
Console.ReadKey();
Desvios condicionais
A instrução ”if” é usada para realizar desvios condicionais no C#. Com ele o fluxo de execução pode ser alterado de acordo com o
retorno de expressões booleanas, a sintaxe do comando é a seguinte:
if( [Expressão booleana]){
Trecho de código...
}
Você pode definir o segmento “else” para um “if” que serve como fluxo alternativo caso a condição testada seja falsa.
if( [Expressão booleana]){
Trecho de código...
}else{
Trecho de código...
}
Você pode ainda testar várias condições em uma mesma instrução “if” adicionando segmentos “else if”, a execução
passará na primeira e somente na primeira condição verdadeira do “if” se houver.
if( [Expressão booleana]){
Trecho de código...
}else if([Expressão booleana]){](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-27-320.jpg)
![25 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Trecho de código...
}
Exemplos utilizando “if”:
bool Validado = true;
//Quando se tratar de um booleano não precisa fazer comparação porque ele mesmo já é um
valor booleano
if (Validado)
{
Console.WriteLine("Ok!");
}
string strRetorno = "Sucesso";
//Outros tipos de dados precisam de uma expressão booleano escrita.
//Obs: O == é um operador de comparação, que retorna true caso os valores sejam iguais
caso contrário false
if (strRetorno == "Sucesso")
{
Console.WriteLine("Missão comprida");
}
else {
Console.WriteLine("Tente novamente");
}
//Aqui temos um if sem delimitadores "{}", essa sintaxe pode ser utilizada quando formos
executar apenas uma instrução.
//Obs: o != é o inverso do == e retorna true para valores diferente caso contrário
false.
if (strRetorno != "Sucesso")
Console.WriteLine("Tente novamente");
else
Console.WriteLine("Sucesso");
DateTime Dt = DateTime.Now;
if (Dt.Hour < 8)
Console.WriteLine("Está muito cedo....");
else if (Dt.Hour == 8)
Console.WriteLine("Em cima da hora....");
else
Console.WriteLine("Atrasado!");
Switch
O comando switch serve para definirmos ações a serem executadas dependendo do valor de uma variável ou de uma expressão, é
muito utilizado com enumerações e quando temos um rol de valores conhecidos que a variável ou a expressão pode assumir.
A sintaxe básica para o switch é a seguinte
switch([Nome da variável]){
case [possível valor 1]
[Ações a serem executadas];
break;//Termina a execução da instrução switch
....
case[Possível valor n]
[Ações a serem executadas];
break;//Termina a execução da instrução switch](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-28-320.jpg)
![26 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
default://Opcional
[Ação padrão para caso o valor não esteja definido em nenhum dos Cases];
break;
}
int caseSwitch = 1;
switch (caseSwitch)
{
case 1:
Console.WriteLine("Case 1");
break;
case 2:
Console.WriteLine("Case 2");
break;
default:
Console.WriteLine("Default case");
break;
}
int switchExpression = 3;
switch (switchExpression)
{
// Uma seção de instruções podem ser iniciadas por mais de um valor no caso 0 e 1
case 0:
case 1:
Console.WriteLine("Case 0 or 1");
// para cada case é necessário um break, um return ou um goto.
break;
case 2:
Console.WriteLine("Case 2");
break;
// O código da linha abaixo causa um alerta na compilação, pois nunca será
executada pelo fato de estar depois do break;
Console.WriteLine("Código irrelevante");
// 7 - 4 abaixo o case está em função de um expressão matemática “7-4” então quando
o valor da variável for 3 essa condição será satisfeita.
case 7 - 4:
Console.WriteLine("Case 3");
break;
// Se o valor da váriavel não estiver entre 0, 1, 2, or 3, o código definido no
rótulo default será executado.
default:
Console.WriteLine("Default case (Opcional)");
break;
}
Estruturas de repetição
Estruturas de repetição são instruções que de acordo com uma condição, executam uma sequência de ações repetidas um
determinado número de vezes. Estruturas de repetição também são conhecidas como loops.
As principais instruções para execução de Loop são: “while”,”do”,”for” e “foreach”, vamos analisar cada uma separadamente.
WHILE
Um loop while verifica uma condição e em seguida executa um bloco de código enquanto a condição avaliada for verdadeira. A
sua sintaxe é a seguinte:
while ([Expressão booleana]) {
[Conjunto de instruções]](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-29-320.jpg)
![27 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
}
Ao terminar a execução das instruções dentro do bloco definido para o while a expressão booleana é verificada novamente e caso
seja verdadeira o conjunto de instruções é executado novamente esse ciclo se repete até que o valor da expressão avaliada no
segmento while seja falsa. No while se na primeira verificação o valor avaliado for falso o bloco de código não é executado nem
uma vez.
Exemplo:
//Declaração de uma variável
int i = 0;
//Segmento while, nesse caso verifica se o valor da váriavel i é menor que 10.
//O bloco de código será executado enquanto essa expressão for verdadeira
while (i<10)
{
//Conjunto de instruções a serem executadas
//Escreve o valor de i no console
Console.WriteLine(1);
//Soma 1 ao valor de i a cada execução do bloco de código.
i++;
}
//Espera que uma tecla seja digitada para encerrar a execução do programa.
Console.ReadKey();
DO
O loop “do” se comporta como o loop “while”, porém é garantido que o bloco de código seja executado ao menos uma vez, pois a
expressão booleana é avaliada depois da execução do bloco de código.
A sintaxe é a seguinte:
do{
[Conjunto de instruções]
}while([Expressão booleana]);
Exemplo:
//Declaração de uma variável
int i = 0;
do
{
//Conjunto de instruções a serem executadas.
//A diferença é que mesmo que neste ponto o valor de i seja maior que 10
//Esse bloco de código será executado ao menos 1 vez.
//Escreve o valor de i no console
Console.WriteLine(1);
//Soma 1 ao valor de i a cada execução do bloco de código.
i++;
}
while (i < 10);//Segmento while, nesse caso verifica se o valor da váriavel i é menor
que 10.
//O bloco de código será executado enquanto essa expressão for verdadeira
//Espera que uma tecla seja digitada para encerrar a execução do programa.
Console.ReadKey();](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-30-320.jpg)
![28 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
FOR
O Loop for também executa um bloco de código em função de uma expressão booleana, com a diferença de possuir em sua
sintaxe a possibilidade de incluir um inicializador e um modificador para uma variável que existirá somente em seu escopo. Essa
instrução é largamente utilizada para varrer listas, pois sua sintaxe garante uma semântica melhor em relação ao while quando é
necessário ter um contador das iterações ocorridas no loop.
Sintaxe:
for([Inicializador de variável];[Expressão booleana];[Modificador da variável]){
[Conjunto de instruções]
}
Exemplos:
//Declarando um array de inteiros, e já inicializando com valores.
int[] valores = new int[]{1,2,3,4,5,6,7,8,9,10};
/*No segmento for esta sendo feita inicialização de uma váriavel i que será incrementada
com mais 1
a cada iteração ocorrida, enquanto o valor da váriavel seja menor que o tamanho da
colação de inteiros obtida através da propriedade length do valor.
é importante lembrar que o ultimo índice da lista é sempre o tamanho da mesma menos 1,
pois a primeira posição é 0 e não 1.*/
for (int i = 0; i < valores.Length; i++)
{
//Escreve o valor que está na posição "i" da lista a cada iteração sendo que o "i"
vai sendo incrementado a cada iteração.
//Todos os valores da lista serão escritos na tela em ordem crescente.
Console.WriteLine(valores[i]);
}
Console.WriteLine("Ordem decrescente");
/*Podemos também escreve-los de forma decrescente.
Fazendo algumas alterações no nosso segmento for.
- Iniciando a váriavel i com a ultima posição do array em vez da primeira "0", a
melhor formam de fazer isso é
atribuindo o valor da propriedade length -1 ao seu valor.
- Invertendo o sinal da expressão booleana de < para >= e substituindo a propriedade
length pela constante 0.
- Por fim substituindo o operador unário de incremento(++) para o de decremento(--).
*/
for (int i = valores.Length-1; i >=0; i--)
{
//Escreve o valor que está na posição "i" da lista a cada iteração sendo que o "i"
vai sendo decrementado a cada iteração.
//Todos os valores da lista serão escritos na tela em ordem decrescente.
Console.WriteLine(valores[i]);
}
//Espera que uma tecla seja digitada para encerrar a execução do programa.
Console.ReadKey();
FOREACH
Este é um tipo de loop específico da linguagem C# que veio como uma forma de varrer coleções mais eficientemente. Com
foreach não é necessário verificar se o número de iterações é menor que o número de item em uma coleção e nem acessar o item
da coleção através do índice em função da variável do for, pois no foreach ocorre uma iteração para cada item da lista e uma](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-31-320.jpg)
![29 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
variável assume o valor deste item, qualquer objeto que herde da interface IEnumerable pode ser utilizado como fonte de dados
em um foreach. Listas serão exploradas com mais profundidade neste capítulo.
foreach ([Declaração da variável] in [Coleção a ser varrida]){
[Conjunto de instruções]
}
Exemplo:
//Declarando um array de inteiros, e já inicializando com valores.
int[] valores = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
/*Agora faremos a mesma coisa que nos dois exemplos utilizando for, ou seja mostraremos
os valores do array
* em ordem crescente e decrescente só que utilizando o foreach.*/
/*No segmento foreach temos a declaração de uma váriavel que assumira o valor de um item
da lista de cada vez
* Reparem que o tipo da váriavel devem representar o tipo que a lista reúne no caso
int. Depois a palavra reservada in
* que deve ser sucedida pela lista a ser varrida.
*/
foreach (int item in valores)
{
Console.WriteLine(item);
}
/*Agora em ordem decrescente
Basta utilizar o método reverse disponível para qualquer tipo de array, que a ordem dos
valores na lista será invertida completamente.
Como os valores estão organizados em forma crescente nesse exemplo, ao inverter serão
apresentados de forma decrescente.
*/
foreach (int item in valores.Reverse())
{
Console.WriteLine(item);
}
//Espera que uma tecla seja digitada para encerrar a execução do programa.
Console.ReadKey();
BREAK
O comando break pode ser utilizado dentro do bloco de código de qualquer Loop apresentado anteriormente e causa uma
interrupção imediata das iterações. Pode ser utilizado para quando estamos procurando a primeira ocorrência de um valor
específico, abaixo um exemplo.
//Declarando um array de inteiros, e já inicializando com valores.
int[] valores = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
foreach (int item in valores)
{
if (item == 3)
{
Console.WriteLine(item);
//Ao encontrar a primeira ocorrência do valor 3 o mesmo será escrito na tela e a
execução do Loop será interrompida.
break;](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-32-320.jpg)
![30 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
}
}
Tratamento de erro
O C# implementa uma funcionalidade do framework para tratamento de erros, que consiste na possibilidade de executar uma ação
que trata um exceção gerada pelo programa, de modo que não ocorra uma interrupção na execução, esse tratamento é feito através
da instrução “try”, cuja sintaxe básica é a seguinte:
try{
[Conjunto de instruções que podem lançar uma exceção]
}catch([Tipo de exceção] [Nome da variável](Opcional declaração da variável)){
[Conjunto de instrução que gerencia a exceção ocorrida]
}
Exemplo:
int[] vals=new int[]{0,1,2,3,4,5,6,7,8,9};
try
{
/*Nesse caso ocorrerá um erro, pois iniciei o contador do for em 1 o que vai causar
uma tentativa de acesso à uma posição que não existe na lista a posição 10 e
apesar da lista
ter 10 valores os índices vão de 0 a 9, isso provocará o lançamento de uma
exceção no sistema.
*/
for (int i = 1; i < vals.Length+1; i++)
{
Console.WriteLine(vals[i]);
}
}
//O Bloco catch escreverá a mensagem de erro retornada no console e evitará que a
execução do programa seja interrompida.
catch (Exception ex) {
Console.WriteLine(ex.Message);
}
Console.ReadKey();
Arrays e Lists
Muitas vezes no desenvolvimento de aplicações necessitamos de agrupar determinados tipos de dados em coleções, para efeitos de
comparação, ordenação, dentre outros. Em C# é possível fazer esse agrupamento de duas formas.
Através de Arrays e Lists, a diferença fundamental entre ambo é que o Array precisa ter o seu tamanho definido na sua
inicialização, já as Lists podem crescer indefinidamente. As Lists também oferecem mais recursos para tratamento das coleções
como consequência consumem mais processamento. As List foram implementadas sobre o conceito de tipos genéricos que serão
detalhados posteriormente nesse capítulo, por hora vamos analisar a sintaxe, a utilização em um contexto e a interoperabilidade
entre ambos.
Arrays
Um Array pode ser composto por várias dimensões, porém o mais comum é o unidimensional cuja sintaxe é a seguinte:
“[tipo de dado]”[] “[Nome da variável]”;](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-33-320.jpg)
![31 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Exemplo Array de inteiros:
int[] Inteiros;
Ou seja basta adicionar um par de colchetes ao lado do tipo da variável e este passa a representar uma lista unidimensional
daquele mesmo tipo.
Para declaração de um Array multidimensional basta colocar uma vírgula separando as dimensões, por exemplo, a declaração de
um array bidimensional de inteiros ficaria assim:
int[,] MatrizInteiros;
O acesso aos itens dos vetores se dá através de índices, sendo cada índice a posição de uma unidade na matriz, a coleção de
índices começa em 0 e termina no tamanho do vetor -1, o índice do último elemento de um vetor de tamanho n é igual a n-1.
Existem algumas maneiras de se inicializar um vetor abaixo exemplos comentados.
// Declaração e inicialização de um Array unidimensional de 5 posições.
int[] array1 = new int[5];
// Declaração e inicialização de um Array unidimensional de 5 posições,
// mas nesse caso o número de posições é definido pelo número de valores definido entre as
chaves na sintaxe de inicialização.
int[] array2 = new int[] { 1, 3, 5, 7, 9 };
// Sintaxe alternativa
int[] array3 = { 1, 2, 3, 4, 5, 6 };
// Declaração e inicialização de um Array bidimensional, sem atribuição de valores.
int[,] multiDimensionalArray1 = new int[2, 3];
// Declaração e inicialização de um Array bidimensional, com atribuição de valores.
int[,] multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } };
Para acessar o elemento de valor 3 do array “array2” a sintaxe seria a seguinte:
int Elemento = array2[1];
Para atribuir um novo valor a esta mesma posição a sintaxe seria a seguinte:
int Elemento=20;
array2[1]=Elemento;
Para acessar o elemento de valor 5 do array multidimensional “multiDimensionalArray2” a sintaxe seria a seguinte:
int elemento= multiDimensionalArray2[1,1];
Para atribuir um novo valor a esta mesma posição a sintaxe seria a seguinte:
int Elemento=20;
array2[1,1]=Elemento;
Lists
Os Lists são listas genéricas unidimensionais que assumem um determinado tipo. Não precisam ter seu tamanho especificado na
inicialização. A List provê algumas funcionalidades a mais que o Array como o método Find, que serve para encontrar
ocorrências de um determinado valor na lista. Para utilização do List o namespace System.Collections.Generic do assembly
“mscorlib.dll” deve estar acessível.
A sintaxe básica é a seguinte:
List<[Tipo de dado]> [Nome da variável];
Exemplo List de inteiros:](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-34-320.jpg)
![32 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
List<int> lst = new List<int>();
A inclusão de um elemento na lista pode ser feito através do método Add. Cuja sintaxe é a seguinte:
int Elemento=10;
lst.Add(Elemento);
A sintaxe de acesso e atribuição de elementos é idêntica à de Arrays unidimensionais.
Interoperabilidade
Uma lista pode ser transformada em um Array através do método “ToArray()”, exemplo abaixo:
int[] Myarray;
List<int> MyList = new List<int>();
Myarray = MyList.ToArray();
Um Array pode ser transformado em List através do método “ToList()”,exemplo abaixo:
List<int> MyList;
int[] Myarray=new int[10];
MyList = Myarray.ToList();
Todos os itens de um Array podem ser inserido em uma lista através do método AddRange([Fonte de dados enumerável]) da
classe List, Exemplo abaixo:
List<int> MyList=new List<int>();
int[] Myarray=new int[10];
MyList.AddRange(Myarray);
Tabela com os principais métodos comuns à Arrays e Lists.
Nome do método Descrição
Reverse() Inverte a ordem dos elementos na lista.
First() Retorna o primeiro elemento da lista.
OrderBy(Predicate) Ordena os valores da lista de acordo com o valor passado com
parâmetro.
Max() Retorna o elemento de valor máximo pela ordem de
precedência.
Min() Retorna o elemento de valor mínimo pela ordem de
precedência.
Windows Forms
Windows Forms é um conjunto de bibliotecas que fornecem funcionalidades para desenvolvimento de aplicações desktop que
utilizem interações através de janelas no padrão Windows. As principais funcionalidades estão na biblioteca
System.WindowsForms.dll. Nesse tópico iremos abordar os principais componentes do Windows forms.
Eventos
A orientação a eventos é um dos paradigmas da linguagem C#, isso quer dizer que os componentes executam as suas ações através
de eventos. Por exemplo, um componente do tipo botão tem o evento Click, esse evento será relacionado com um ou mais
métodos e quando o mesmo ocorrer as instruções contidas nesses métodos serão executadas.](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-35-320.jpg)
![36 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
O formulário pode ser customizado através de suas propriedades para altera-las acesse a janela “properties”, abaixo uma tabela
com as mais importantes e suas respectivas descrições:
Propriedade Descrição
(Name) O nome do objeto form.
Backcolor Cor de fundo do formulário.
BackgroundImage Indica uma imagem para o plano de fundo do formulário.
Determina como a imagem defina na propriedade BackGroundImage será apresentada.
BackgroundImage1Layout
ControlBox Determina quando o form tem um ControBox.
Cursor Aparência do cursor do mouse quando estiver sobre o form.
Enabled Determina se o form está habilitado, se estiver falso todos os controle hospedados também ficarão
desabilitados
Font Atribui a font padrão para textos do form.
ForeColor Determina uma cor de primeiro plano padrão, será utilizada para todos controle caso não seja
atribuída separadamente.
FormBorderStyle Indica a aparência e o comportamento das bordas do form.
HelpButton Indica quando o Form tem um botão de ajuda.
Icon Indica o ícone a ser apresentado no topo do form.
Location Determina o posicionamento do form na tela quando a propriedade StarPosition está com o valor
“Manual”.
MaximizeBox Indica se o form tem a opção de maximizar.
MaximumSize Determina o tamanho máximo que o form pode assumir.
MinimizeBox Indica se o form tem a opção de minimizar.
MinimumSize Determina o tamanho mínimo que o form pode assumir.
Opacity Representa o nível de transparência do formulário, quando maior mais transparente.
Size Atribui e recupera o tamanho inicial do form
StartPosition Posição do Form na sua primeira aparição.
Text Determina o texto que aparece no topo do forn.
TopMost Determina se o formulário aparece na frente de todas as outras aplicações.
Visible Determina se o formulário esta visível.
Windowstate Determina o estado inicial do formulário: Maximizado, Minimizado, etc.
Alterando o formulário inicial de um projeto
Esse é o primeiro form aberto ao executarmos um projeto, para alterar qual será esse formulário é necessário abrir o arquivo
program.cs e mudar a instância de form passada para o método Run([Instância form]) da classe application . Se o form criado
junto com o projeto não tiver sido renomeado estará assim:](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-39-320.jpg)
![43 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
BackgroundImage Determina uma imagem para servir com plano de fundo do controle.
Indica quando o controle executa métodos de validações, esses métodos servem para verificar
CausesValidation se a entrada de dados do usuário está de acordo com as regras de negócio.
ContainsFocus Indica quando o foco esta no próprio controle ou um em dos seus filhos.
Controls Retorna uma coleção dos controles filhos.
Cursor Determina o aspecto do cursor quando o mouse passar sobre o controle.
Determina se o controle está fixado em uma das extremidades do container pai ou preenchendo
Dock o mesmo.
Enabled Determina se o controle está habilitado e funcional.
Font Determina a fonte que será utilizada para escrever eventuais textos do controle.
ForeColor Determina a cor do primeiro plano do controle, borda, textos entre outros.
HasChildren Determina se o controle possui controles filhos.
Height Representa a altura do controle em pixels.
Location Representa a localização do controle em relação ao container.
MaximumSize Representa o tamanho máximo que o controle pode assumir.
MinimumSize Representa o tamanho mínimo que o controle pode assumir.
Atribui um nome ao controle para ser acessível via código, só pode ser atribuída durante o
Name design.
Parent Retorna o form pai ou o container que o controle está contido.
Region Atribui ou retorna a região Windows associada com o controle.
Size Representa o tamanho do controle em pixel.
Representa a ordem de precedência do controle quando a tecla Tab for utilizada para navegar
TabIndex controle a controle.
Tag Serve para o programador associar algum dado ao controle para auxilia-lo na programação.
Atribui ou retorna o texto associado com o controle, o texto pode ou não aparecer na
Text representação visual do controle depende de como o mesmo foi definido.
Atribui ou retorna a visibilidade do controle quando estiver como false o controle só aparece
Visible durante o design estando invisível na execução.
Width Atribui ou retorna a largura do controle em pixels.
Button
Um dos controles mais comuns é o Button, o controle essencial que provê interação de comando entre o usuário e a interface
gráfica. O botão pode exibir um texto curto a fim de identifica-lo e responder a clicks efetuados pelo usuário. O botão assume um
visual diferenciado quando é clicado e fornece um manipulador de evento para que o desenvolvedor escreva o código desejado. O
controle Button expõe uma série de propriedade que permite que você customize a aparência e o comportamento do mesmo. A
tabela abaixo demonstra as principais Propriedades de um botão.
Propriedade Descrição
AutoEllipsis Habilita a manipulação automática textos que excedam a largura do botão.
DialogResult Atribui um DialogResult ao botão, exemplo: DialogResult.Ok, DialogResult.Cancel.
FlatAppearance Determina como o botão parecerá quando a propriedade FlatStyle estiver com valor verdadeiro
Quando o valor está verdadeiro o padrão deixa de acompanhar a aparência padrão do Windows
FlatStyle e passa a respeitar o que desenvolvedor define no FlatAppearance
Text Atribui o texto que aparece no botão.
TextAlign Determina como o texto é apresentado no botão.
Interceptando um clique: Para escrever o código que será executado quando o clique do botão ocorrer você pode clicar duas vezes
sobre o botão durante o design e o código da janela abrirá com um método cujo nome é formado por:
[nome do botão]_Click
Basta escrever a implementação do método entre as chaves que delimitam seu escopo.](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-46-320.jpg)
![52 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
St.WriteLine("Qualquer texto pode ser escrito aqui.");
St.WriteLine("Qualquer texto pode ser escrito aqui.");
/*
No arquivo ficaria assim
*
* Qualquer texto pode ser escrito aqui.
* Qualquer texto pode ser escrito aqui.
*
*/
St.Write("Qualquer texto pode ser escrito aqui.");
St.Write("Qualquer texto pode ser escrito aqui.");
/*
No arquivo ficaria assim
*
* Qualquer texto pode ser escrito aqui. Qualquer texto pode ser escrito aqui.
*
*/
Ao acabar de realizar as operações feche o StreamWritter e o FileStream para liberar o arquivo.
St.Close();
fs.Close();
Ler de um arquivo
A primeira parte continua igual criar uma instância do FileStream no mode OpenOrCreate.
FileStream fs = new FileStream("C:MyText.txt", FileMode.OpenOrCreate);
Só que agora instanciaremos uma classe de leitura a StreamReader.
StreamReader sr = new StreamReader(fs);
E usaremos os métodos Read e ReadLine;
/*
No método Read é necessário passar como parâmetro um array de char que será populado
com os caracteres lido
* os outros 2 parâmetros são posição inicial da leitura em índice e a quantidade de
caracteres a serem lidos.
*/
char[] buffer=new char[20];
sr.Read(buffer, 0, 20);
/*
O ReadLine lê uma linha de cada vez e retorna os caracteres,
* em uma string, mas antes é necessário verificar se a string não chegou ao fim.
*/
string str;
if(!sr.EndOfStream)
str = sr.ReadLine();
Feche o StreamReader e o FileStream para liberar o arquivo.
sr.Close();
fs.Close();
Apagar um arquivo
Para apagar o arquivo usamos o método estático Delete da classe File.
File.Delete("CMyText.txt");](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-55-320.jpg)
![53 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Prática salvando em arquivo texto
Crie uma tela de cadastro de clientes com os campos: código, nome e documento.
O usuário pode salvar os dados digitados clicando em salvar.
Quando ele digitar um código já existente tem que recuperar os dados do cliente.
Modificadores de acesso.
Os modificadores de acessos são palavras reservadas utilizadas para definir a acessibilidade de um membro. Existem quatro deles:
public
protected
internal
private
public – Acesso irrestrito, qualquer elemento da aplicação pode acessar o recurso.
protected - Disponível para quem define e seus herdeiros.
internal – Disponível para todos os membros definidos no mesmo namespace.
private – Disponível somente ao próprio objeto que define.
Os modificadores de visibilidade podem acompanhar: Classes, Métodos, Atributos, Propriedades, Interface, Enums e construtores.
Atenção, quando nenhum modificador é definido é considerado o mais restritivo, ou seja, private.
Classes
Uma classe é uma unidade lógica que reúne as propriedades, ou seja, as características sobre ela mesma e as suas ações
representadas pelos métodos que serão abordados com maior profundidade nesse capítulo. Uma classe descreve os serviços
providos por seus objetos e quais informações eles podem armazenar. Em C# todas as ações são baseadas em classes de maneira
que não podemos definir um método fora do escopo de uma classe. Uma declaração de classe ou estrutura é como um desenho
que é usado para criar instâncias ou objetos em tempo de execução. Se você definir uma classe ou estrutura chamada Pessoa,
Pessoa é o nome do tipo. Se você declara e inicializa uma variável p tipo Pessoa, p é considerado um objeto ou instância de
Pessoa. Uma classe pode ter basicamente construtores, propriedade e métodos, cada um desses itens será abordado separadamente
sem seguida.
A sintaxe básica para criação de uma classe em c# é a seguinte.
[Modificador de visibilidade] class [Nome da classe]{
//Definição da classe
}
Tudo que está entre as duas chaves que delimitam o escopo da classe fazem parte da mesma.
Propriedades e variáveis
Propriedades e variáveis da classe são dados armazenados pela classe e a diferença entre ambas é que as variáveis normalmente
são utilizadas para processamentos internos da classe enquanto as propriedades são utilizadas para expor suas características à
outros objetos, em C# é entendido como propriedade dados que façam uso de getters e setters para que outros objetos acessem
suas informações, uma variável com modificador público não é considerada uma propriedade, pois os outros objetos tem acesso
direta a mesma e isso não é desejável. Já com getter e setter por mais que aparentemente o acesso é direto o valor passa por um
tratamento antes
.
A sintaxe básica de uma propriedade é:
[Modificador de visibilidade] [Tipo] [Nome da propriedade]{
//Ao menos um dos modificadores abaixo é necessário, mas não é obrigatório ter ambos ao mesmo tempo.
//O get significa que outros objetos poderão visualizar o valor da propriedade
get;
//O set significa que outros objetos poderão atribuir o valor da propriedade](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-56-320.jpg)
![55 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
[Modificador de visibilidade] [nome da classe]([parâmetros(opcional)]{
//Definição do construtor.
}
Exemplo:
class Pessoa {
string _nome;
string _cpf;
public string Nome {
get {
return _nome;
}
set {
_nome = value;
}
}
public string Cpf
{
get
{
return _cpf;
}
set
{
_cpf = value;
}
}
/*
Esse primeiro construtor não recebe nenhum parâmetro e só inicializa as variáveis
com um valor vazio.
*/
public Pessoa() {
_nome = string.Empty;
_cpf = string.Empty;
}
/*
Esse segundo construtor inicia a váriavel Nome com o valor passado como parâmetro.
Um construtor pode chamar outro, aqui está chamando o construtor default, que
inicializa as variáveis com valor vazio antes de atribuir valor ao nome, a parte onde
está escrito ":this()" é que indica que o construtor default deve ser chamado.
*/
public Pessoa(string Nome):this() {
this._nome = Nome;
}
/*
Esse terceiro construtor inicia a váriavel Cpf e repassa a tarefa de iniciar a váriavel
nome
* ao construtor que já sabe como fazer isso, dessa forma evitamos duplicar um código que
faz a mesma coisa.
* Nesse caso o que acontece, o terceiro construtor chama o segundo que chama o primeiro,
então primeiro as variáveis
* são atribuídas para valor vazio, depois a váriavel nome é atribuída e por último a
váriavel _cpf é atribuída.
*/
public Pessoa(string Nome, string Cpf):this(Nome) {
this._cpf = Cpf;
}
}
class Program
{
static void Main(string[] args)
{
//Declaração de uma váriavel pessoa.](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-58-320.jpg)
![56 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Pessoa pess;
//Criação do objeto através do construtor default
//O que define o construtor que será chamado é os parâmetros passado na hora da criação.
//Como não passei nenhum será chamado o construtor default.
pess = new Pessoa();
MostraNomeCpf(pess.Nome, pess.Cpf);
//Saída = Nome:Vazio;CPF:Vazio
//Como passei uma string o segundo construtor será chamado.
pess = new Pessoa("Joaquin");
MostraNomeCpf(pess.Nome, pess.Cpf);
//Saída = Nome:Joaquin;CPF:Vazio
//Como passei 2 strings o terceiro construtor será chamado.
pess = new Pessoa("Joaquin","35783627860");
MostraNomeCpf(pess.Nome, pess.Cpf);
//Saída = Nome:Joaquin;CPF:35783627860
Console.ReadKey();
}
static void MostraNomeCpf(string nome, string cpf) {
if(nome==string.Empty)
nome="Vazio";
if(cpf==string.Empty)
cpf="Vazio";
Console.WriteLine("Nome:{0}; CPF:{1}", nome, cpf);
}
}
Métodos
Um método é um bloco de código que contém uma série de instruções. O programa executa as instruções quando chamamos o
método e especificamos argumentos, em C# todas as instruções são executadas por métodos. O método Main é o ponto de entrada
para cada aplicativo C# e ele é chamado pelo CLR (Common Language Runtime) quando o programa é iniciado.
Assinatura de métodos
Métodos são declarados em uma classe ou struct, especificando-se o nível de acesso como public ou private, modificadores
opcionais como abstract ou sealed, o valor de retorno e o nome do método. Essas partes juntos são o assinatura do método.
Observação:
Um tipo de retorno de um método não é parte da assinatura do mesmo para fins de sobrecarga. No entanto, ele é parte da
assinatura do método ao determinar a compatibilidade entre um delegate e o método que ele aponta.
Os parâmetros do método são colocados entre parênteses e são separados por vírgulas. Parênteses vazios indicam que o método
não requer parâmetros.
Sintaxe do método:
[Modificador de visibilidade] [Modificador opcional] [Nome do método]([Lista de parâmetros]){
//Definição
}
Exemplo:
//O método abaixo não retorna nenhum valor, está acessível a qualquer elemento e recebe uma string
como parâmetro
public void Pessoa(string Nome) {
//Definição
}
Parâmetros
Os parâmetros são valores que o método necessita para realizar suas operações, ao declarar o método devem ser especificados
entre os parênteses com o tipo explicito.
Exemplo:
//O método abaixo aceita um inteiro e uma string como parâmetros, que necessariamente precisam ser
passados na chamada.
public void ExcutaAcao(int inteiro, string texto) {
}](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-59-320.jpg)
![57 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
A maneira mais comum de passar os parâmetros na chamada é como no código abaixo, respeitando a ordem em que foram
definidos.
pess.ExcutaAcao(1, "a");
Mas em C# os parâmetros podem ser passados fora de ordem, porém dessa manei precisa ser especificado o nome do parâmetro
seguido do valor desejado, exemplo:
pess.ExcutaAcao(texto: "a", inteiro: 1);
Os valores passados como parâmetros recebem o nome de argumentos.
Retorno
O retorno do método é o tipo de dado que o mesmo devolve ao terminar seu processamento, quando definimos um tipo de retorno
no método o compilador exige um código que garanta o retorno de dados com tipo compatível, a palavra reservada “void” é
utilizada em métodos que não precisam retornar nenhuma informação. A palavra chave para retorno de dados é “return” a
execução do método é interrompida quando a execução passar por um “return”.
Exemplos
//Esse método não retorna nenhuma informação à chamada
public void ExcutaAcao(int inteiro, string texto) {
//Definição
}
//Esse método retorna uma string concatenando os dois parâmetros
public string ExcutaAcao(int inteiro, string texto)
{
return texto + inteiro.ToString();
}
Sobrecarga
Sobrecarga de método é a possibilidade de termos métodos diferentes com o mesmo nome diferindo apenas em seus parâmetros,
Isso é possível porque o método é identificado na chamada não só pelo seu nome, mas também pelos argumentos recebidos. Esse
recurso nos ajuda a manter a semântica do código.
Exemplo
class Pessoa2 {
public string FormataDados(string Nome) {
return "Nome:" + Nome;
}
public string FormataDados(string Nome, string Cpf) {
return "Nome:" + Nome + " Cpf:" + Cpf;
}
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine(new Pessoa2().FormataDados("Vinicius"));
//Saída = Nome:Vinicius
Console.WriteLine(new Pessoa2().FormataDados("Vinicius", "01234567890"));
//Saída=Nome:Vinicius Cpf:01234567890
}
Parâmetros opcionais
Em C# podemos ter parâmetros opcionais nos métodos, isso significa que na chamada não é necessário passar todos os parâmetros
definidos na assinatura do método, isso é possível definindo um valor padrão para o parâmetro o qual é usado no caso de não ser
especificado na chamada. Isso pode ser útil quando precisamos acrescentar um novo parâmetro em um método usado muitas vezes
na aplicação e desejamos que ele continuasse funcionando da mesma maneira de antes onde já foi utilizado.
Exemplo
//Nesse caso se o cpf não for especificado na chamada.
//O nome será exibido e no lugar do Cpf a palavra "Vazio" aparecerá.
public string FormataDados(string Nome, string Cpf="") {
if (Cpf == "")
Cpf = "Vazio";
return "Nome:" + Nome + " Cpf:" + Cpf;
}](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-60-320.jpg)
![58 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Parâmetros de saída e por referência
Os parâmetros de saída são uma forma de um método retornar mais valores além do seu retorno, há situações em que, por
exemplo, precisamos converter um valor sem retornar exceção, podemos usar o retorno do método para dizer se a conversão foi
um sucesso e um parâmetro de saída com o valor do convertido. Os parâmetros de saída são identificados pela palavra reservada
“out” precedendo o tipo do parâmetro, um parâmetro de saída só pode receber como parâmetro um variável de tipo compatível e
nunca um valor literal, a palavra reservada “out” também tem que preceder o argumento na chamada, o método é obrigado pelo
compilador a atribuir um valor ao argumento. Passagem por referência é quando passamos a instância diretamente para o método
que consegue fazer modificações na mesma que refletem no escopo em que foi definida, quando não fazemos isso e alteramos
instância dentro do método isso não reflete no escopo em que ela foi definida.
Exemplos
class Program2
{
static void Main(string[] args)
{
//Parâmetro por referência
PessoaSimp pess = new PessoaSimp();
pess.Nome = "Nome escopo classe";
pess.CPF = "Cpf escopo classe";
Console.WriteLine("Classe");
pess.ExibeDados();
//Saida = Nome:Nome escopo classe Cpf:Cpf escopo classe
Console.WriteLine("Método");
AlteraPessoa(pess);
//Saida = Nome:Nome escopo método Cpf:Cpf escopo método
Console.WriteLine("Classe");
pess.ExibeDados();
//Saida = Nome:Nome escopo classe Cpf:Cpf escopo classe
Console.WriteLine("Método");
AlteraPessoa(ref pess);
//Saida = Nome:Nome escopo método Cpf:Cpf escopo método
Console.WriteLine("Classe");
pess.ExibeDados();
//Saida = Nome:Nome escopo método Cpf:Cpf escopo método
//Parâmetro de saída
int val;
if (StringToInt("1",out val))
Console.WriteLine("Conversão bem sucedida valor={0}", val);
else
Console.WriteLine("Conversão falhou");
Console.ReadKey();
}
static void AlteraPessoa(PessoaSimp pess) {
pess = new PessoaSimp();
pess.Nome = "Nome escopo método";
pess.CPF = "Cpf escopo método";
pess.ExibeDados();
}
static void AlteraPessoa(ref PessoaSimp pess) {
pess = new PessoaSimp();
pess.Nome = "Nome escopo método";
pess.CPF = "Cpf escopo método";
pess.ExibeDados();
}](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-61-320.jpg)
![59 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Enums
A palavra-chave enum é usada para declarar uma enumeração, um tipo distinto que consiste em um conjunto de constantes
nomeadas denominada lista de enumerador. Geralmente é melhor definir um enum dentro de um namespace para que todas as
classes no namespace possam acessá-lo com igual conveniência. No entanto, um enum também pode ser aninhado dentro de uma
classe ou struct. As constantes têm um valor numérico relacionado. Por padrão iniciando em 0 e aumentando em 1 a cada uma.
Mas esse valor também pode ser atribuído explicitamente.
Sintaxe básica de um enum:
Enum{[Constantes separadas por vírgula]};
Exemplo de um enumerador com os dias da semana.
enum Days {Sat, Sun, Mon, Tue, Wed, Thu, Fri};
Enumeradores podem usar os inicializadores para substituir os valores padrões, conforme mostrado no exemplo a seguir.
enum Days {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};
Utilizando um enum
enum DiasDaSemana {
Segunda,
Terça,
Quarta,
Quinta,
Sexta
}
static string AnalisaDiaSemana(DiasDaSemana Ds) {
switch (Ds)
{
case DiasDaSemana.Segunda:
return "Ta começando...";
case DiasDaSemana.Terça:
return "Força...";
case DiasDaSemana.Quarta:
return "Estamos na metade...";
case DiasDaSemana.Quinta:
return "Vespera de sexta...";
case DiasDaSemana.Sexta:
return "AwwwwwwwwwwwwwIeeeeeee";
default:
return "Final de semana";
}
}
O método retorna um texto em função do valor do enum recebido como parâmetro.
Herança
A herança, juntamente com o encapsulamento, polimorfismo e abstração, é uma das quatro principais características (ou pilares)
da programação orientada a objeto. A herança permite que você crie novas classes para reutilizar, estender e modificar o
comportamento que está definido nas outras classes. A classe cujos membros são herdados é chamada de classe base, e a classe
que herda a esses membros é chamada de classe derivada. Uma classe derivada pode ter apenas uma classe base direta. No
entanto, a herança é transitiva se ClassC é derivada da ClassB e ClassB é derivada da ClassA, ClassC herda os membros
declarados em ClassB e ClassA.](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-62-320.jpg)
![60 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Conceitualmente, uma classe derivada é uma especialização da classe base. Por exemplo, se você tiver uma classe base Animal,
você pode ter uma classe derivada que é denominada “Mamíferos” e outra classe derivada que é denominada “Répteis”. Tanto os
mamíferos quanto répteis são animais, mas cada classe derivada representa especializações diferentes da classe base.
Quando você definir uma classe para derivar de outra classe, a classe derivada implicitamente obtém todos os membros da classe
base, exceto para os construtores e destrutores. A classe derivada, assim, pode reutilizar o código da classe base sem ter que
rescrever. Na classe derivada, você pode adicionar mais membros. Dessa forma, a classe derivada estende a funcionalidade da
classe base.
Em C# para que uma classe herde de outra deve ser adicionado após o nome da mesma “:” seguido do nome da classe base.
Exemplo abaixo.
class Animais
{
//Definição
}
class Mamiferos : Animais {
//Definição
}
Nesse caso mamíferos passa a ser um animal e possuir todos os elementos da classe base que as restrições de visibilidade
permitam.
Classe e métodos estáticos
Uma classe estática é basicamente a mesma coisa que uma classe não estática, mas há uma diferença: uma classe estática não
pode ser instanciada. Em outras palavras, você não pode usar a Palavra-chave new para criar uma variável do tipo da classe. Como
não há nenhuma variável de instância, você acessa os membros de uma classe estática usando o nome da classe propriamente
dito. Por exemplo, se você tiver uma classe estática denominada UtilityClass contendo um método público chamado MethodA,
você chama o método conforme o exemplo abaixo:
UtilityClass.MethodA();
Uma classe estática pode ser usada como um recipiente conveniente para conjuntos de métodos que só operam nos parâmetros de
entrada e não precisará obter ou definir quaisquer campos internos de instância. Por exemplo, a biblioteca de classes do .NET
Framework contém a classe estática System.Math que contém métodos que executam operações matemáticas, sem a necessidade
de armazenar ou recuperar dados exclusivos de uma determinada instância da classe Math. Ou seja, basta utilizar os membros da
classe especificando o nome da classe e o nome do método, conforme mostrado no exemplo a seguir.
double dub = -3.14;
Console.WriteLine(Math.Abs(dub));
Console.WriteLine(Math.Floor(dub));
Console.WriteLine(Math.Round(Math.Abs(dub)));
// Output:
// 3.14
// -4
// 3
Uma classe estática não pode conter variáveis de instancia nem métodos não estáticos. Sintaxe para declaração de uma classe
estática.
[Modificador de visibilidade] static class [Nome da classe]{
//Definição
}
Exemplo:
public static class Matematica {
//Definição
}](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-63-320.jpg)
![61 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Uma classe não estática também pode conter métodos estáticos contanto que não acessem variáveis de instancia nem método não
estáticos. A sintaxe para criação de um método estático é a mesma de um método não estático a diferença é a adição da palavra-
chave “static” antes do tipo de retorno do método. Exemplo abaixo:
public static int Soma(int n1,int n2){
//Definição
}
Conversões
Em C# com algumas exceções todas as conversões devem ser explicitas. Quase todos os tipo elementares oferecem métodos para
conversão o Parse e o TryParse. Vamos realizar conversões para os tipos mais comuns.
//string para inteiro
string IntStr = "1";
//Só devemos usar o parse se tivermos certeza que o valor da string representa um número
inteiro.
//Pois se não representar uma exceção será lançada.
int Inteiro = int.Parse(IntStr);
//Quando não temos certeza se o valor da string é um inteiro é melhor utilizar o
TryParse.
//Retorna um booleano indicando se a conversão foi um sucesso.
bool Sucesso = int.TryParse(IntStr,out Inteiro);
//string para double
string DoubStr = "1,1";
double db = double.Parse(DoubStr);
Sucesso = double.TryParse(DoubStr, out db);
//string para float
string FloatStr = "1,1";
float fl = float.Parse(FloatStr);
Sucesso = float.TryParse(FloatStr, out fl);
//string para decimal
string decStr = "1,1";
decimal dc = decimal.Parse(decStr);
Sucesso = decimal.TryParse(decStr, out dc);
//string para DateTime
string DtStr = "10/01/2011";
DateTime dt = DateTime.Parse(DtStr);
Sucesso = DateTime.TryParse(DtStr, out dt);
Outra forma de conversão é a conhecida como “cast” ele é usado para converter um tipo da classe base para qualquer tipo
derivado, o tipo object, por exemplo, pode ser “castado” para qualquer outro tipo em C# pois todos derivam dele. Mas atenção se
o tipo que estiver na variável não for o mesmo que estamos tentando converter, uma exceção será lançada, a sintaxe do cast é a
seguinte:
([nome do tipo)[nome da variável];
Exemplo
object val = 1;
int intval = (int)val;
//A linha abaixo causa uma exceção.
string strval = (string)val;
Interfaces
A interface é uma espécie de contrato sobre as funcionalidades que os objetos que derivados dela devem ter. Ela não apresenta a
implementação das funcionalidades apenas as assinaturas, mas garante que as classe derivadas as implementarão. A sintaxe para
criação de interfaces é a seguinte:
[Modificador de visibilidade] interface [Nome da interface]{
//Definição
}
Nas interfaces definimos apenas assinaturas de métodos que os tipos derivados deverão ter, não precisamos definir o modificador
de visibilidade, pois se está na interface o método deve ter acessibilidade irrestrita.](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-64-320.jpg)
![63 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Exemplo de método para testar a conexão:
public string testConnect(string Connect)
{
string Mensagem;
try
{
GetConnection().Open();
Mensagem = "Conectado com sucesso";
}
catch (Exception e)
{
Mensagem = e.Message;
}
return Mensagem;
}
Executando uma query
Para executar um comando usamos uma derivada da classe dbCommand, para essa classe devemos passar o comando em forma
textual, uma instância da conexão e também o tipo do comando, no caso CommandText, veja no exemplo abaixo.
//Criamos um objeto DataTable onde o resultado do select será armazenado
System.Data.DataTable tb = new System.Data.DataTable();
//Criamos uma instância da conexão para o servidor onde o comando será executado, não
precisa ser aberta quando utilizamos o DataAdapter.
SqlConnection mycon = new SqlConnection("Data Source=myServerAddress;Initial
Catalog=myDataBase;User Id=myUsername;Password=myPassword;");
//Criamos um objeto SqlCommand passando o instrução sql e a conexão para o server
SqlCommand Cmd = new SqlCommand("select * from clientes", mycon);
//Aqui criamos um objeto DataAdpter passando o comando com parâmetro.
SqlDataAdapter da = new SqlDataAdapter(Cmd);
//Aqui chamamos o comando fill que é responsável por executar o comando e preencher o
DataTable com os resultado obtidos
da.Fill(tb);
//Fechamos a conexão
mycon.Close();
//Retornamos o DataTable preenchido para ser utilizado conforme necessário.
return tb;
Recuperando os dados do DataTable
O DataTable representa um conjunto de dados em formatos tabulares, por tanto linhas e colunas as linhas estão disponíveis,
através da propriedade Rows você acessa cada linha individualmente através de um índice ,por exemplo, Rows[0] acessaria a
primeira linha de um DataTable, cada linha do DataTable consiste em um DataRow que se trata de uma coleção de colunas que
também pode ser acessadas por índice ou pelo nome delas no select ,por exemplo, Rows[0][0] ou ainda Rows[0][“id_cliente”].
Vamos ver no exemplo como converteríamos o resultado da query executada anteriormente em uma lista de objetos do tipo
cliente.
public class Cliente {
public string nome{ get; set; }
public DateTime DataPrimeiraCompra { get; set; }
}
public class ClienteControl {
public List<Cliente> DtToList(DataTable dt) {
List<Cliente> lst = new List<Cliente>();
Cliente cli;
//Fazemos um for para passar a cada linha do DataTable e alimentaremos um objeto
cliente com os dados.
for (int i = 0; i < dt.Rows.Count; i++) {
//Essa é uma forma simplificada de inicializar um objeto.
//Melhora a semântica do código.
cli = new Cliente()
{](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-66-320.jpg)
![64 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
nome = dt.Rows[i]["nome"].ToString(),
DataPrimeiraCompra =
DateTime.Parse(dt.Rows[i]["data_ult_compra"].ToString())
};
//Adiciona na lista de cliente perceba que a váriavel é a mesma, mas a cada
iteração é criada uma nova instância.
lst.Add(cli);
}
return lst;
}
}
Executando comandos diferentes de consulta
Para executar outros comandos que não sejam consultas, como inserts,deletes e updates, o processo é o mesmo que executar uma
query as únicas diferenças é que não vamos utilizar um DataAdpter e executaremos o comando através do método da classe
DbCommand ExecuteNonQuery(). Veja abaixo um exemplo.
DbConnection Conn = new SqlConnection();
DbCommand Cmd = new SqlCommand("delete from clientes",(SqlConnection)Conn);
Cmd.CommandType = CommandType.Text;
//Aqui precisamos abrir a conexão antes
Conn.Open();
Cmd.Connection = Conn;
Cmd.CommandText = Cmd.CommandText;
Cmd.ExecuteNonQuery();
Conn.Close();
Passagem de parâmetros
Quando vamos utilizar um comando que necessita de parâmetro o ideal não é utilizar a concatenação de string, pois os dados
podem estar em formatos diferente na aplicação e no banco de dados, além de abrir uma vulnerabilidade para injeção de comando
sql na aplicação. A melhor maneira de se fazer é acessar a lista de parâmetros da classe derivada de DbCommand de acordo com o
SGBD que estiver utilizando no caso do SqlServer temos as seguinte sobrecargas:
Parameters.Add([SqlParameter]);
Parameters.Add([Nome do parâmetro(string),[SqlDbType(enum)]);
Parameters.Add([Nome do parâmetro(string),[SqlDbType(enum)],[Tamanho (para tipos que se aplica)]);
Parameters.Add([Nome do parâmetro(string),[SqlDbType(enum)],[Tamanho (para tipos que se aplica)],[Coluna utilizada
como fonte de dados]);
Para especificarmos o valor dos parâmetros acessamos a propriedade Value, pode ser diretamente ao utilizar o método Add sem
necessidade de criar um objeto SqlParameter antes.
Exemplo:
Cmd.Parameters.Add("nome", SqlDbType.VarChar, 5).Value="Jhony";
Passando parâmetro para um comando Texto
DataTable dt = new DataTable();
SqlConnection Conn = new SqlConnection"Server=myServerAddress;Database=
myDataBase;Uid=MyUser;Pwd=MyPwd;");
SqlCommand cmd = new SqlCommand("select * from clientes_tbl where
id_usuarios=@id_usuarios",Conn);
cmd.Parameters.Add("@id_usuarios", SqlDbType.Int).Value = 1;
SqlDataAdapter da = new SqlDataAdapter(cmd);
da.Fill(dt);
foreach (DataRow item in dt.Rows)
{
Console.WriteLine(item[2].ToString());
}
Console.ReadKey();
Passando parâmetro para uma procedure
DataTable dt2 = new DataTable();
SqlConnection Conn2 = new SqlConnection("Server=myServerAddress;Database=
myDataBase;Uid=MyUser;Pwd=MyPwd;");
SqlCommand cmd2 = new SqlCommand("sp_write_clientes", Conn);
cmd2.Parameters.Add("@id_clientes", SqlDbType.Int).Value = 1;
cmd2.Parameters.Add("@nome", SqlDbType.Int).Value = "João";
Conn.Open();](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-67-320.jpg)
![67 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
{
try
{
return (T)Enum.Parse(typeof(T), value.ToString());
}
catch (Exception e)
{
string msg = e.Message;
return Activator.CreateInstance<T>();
}
}
Lambda Expression
Uma expressão lambda é uma função anônima que pode conter expressões e instruções, e pode ser usada para criar ponteiros de
função ou tipos de árvores de expressão. Todas as expressões lambda usam o operador lambda = >, que é lido como "vai para". O
lado esquerdo do operador lambda especifica os parâmetros de entrada (se houver) e o direito contém a expressão ou o bloco de
instruções a expressão lambda x => x * x é lido " x recebe x vezes x. " Esta expressão pode ser atribuída a um ponteiro de função
da seguinte maneira:
delegate int del(int i);
static void Main(string[] args)
{
del myDelegate = x => x * x;
int j = myDelegate(5); //j = 25
}
Para criar um tipo de árvore de expressão:
Expression<del> myET = x => x * x;
As expressões lambdas são muito uteis ao trabalharmos com coleções, pois podemos passar uma expressão Lambda para os
métodos que filtram e ordenam a coleção veja alguns exemplos abaixo.
class Pessoa {
public string Nome { get; set; }
public int Idade { get; set; }
public Pessoa() {
Nome = "NomePadrao";
Idade = 12;
}
public object[] RetornaDados() {
return new object[] { Nome, Idade };
}
}
class Program
{
static void Main(string[] args)
{
List<Pessoa> lstpess = new List<Pessoa>();
lstpess.Add(new Pessoa() { Nome = "joão", Idade = 18 });
lstpess.Add(new Pessoa() { Nome = "joãozin", Idade = 12 });
lstpess.Add(new Pessoa() { Nome = "joãozão", Idade = 18 });
lstpess.Add(new Pessoa() { Nome = "robert", Idade = 15 });
lstpess.Add(new Pessoa() { Nome = "hebert", Idade = 18 });
lstpess.Add(new Pessoa() { Nome = "kenko", Idade = 21 });
lstpess.Add(new Pessoa() { Nome = "louis", Idade = 18 });
lstpess.Add(new Pessoa() { Nome = "hermes", Idade = 56 });
List<Pessoa> ListaFiltrada;
//Retorna todas pessoas com nome joãozin
ListaFiltrada=lstpess.FindAll(p => p.Nome == "joãozin");](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-70-320.jpg)
![68 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
//Retorna todos maiores de 18 anos
ListaFiltrada=lstpess.FindAll(p => p.Idade > 18);
//Retorna os maiores de 18 anos que tenham o nome começado em j.
ListaFiltrada=lstpess.FindAll(p => p.Nome.Substring(0, 1) == "j" && p.Idade > 18);
List<Pessoa> ListaOrdenada;
//Retorna lista ordenada por nome
ListaOrdenada=ListaFiltrada.OrderBy(p => p.Nome).ToList<Pessoa>();
//Retorna lista ordenada por ano de nascimento
ListaOrdenada = ListaFiltrada.OrderBy(p => DateTime.Now.Year-p.Idade).ToList<Pessoa>();
}
}
Reflection
Reflection é habilidade dos objetos observarem a sua própria estrutura e também a de outros objetos em tempo de execução, com
reflection podem ser criadas instância de tipos dinamicamente, carregar módulo compilados e seus tipos, varrer propriedades das
classes e atribuir valor a elas, varrer métodos do objeto e invocá-los entre outras coisas, tudo isso de maneira dinâmica. As
principais funções de reflection estão no namespace System.Reflection.
Principais classes com uma breve descrição.
Classe Descrição
Type Essa é a classe fundamental do namespace reflection ela abstrai
as principais informações que são relevantes a respeito de um
determinado tipo.
PropertyInfo Reúne informações sobre uma propriedade como nome e o tipo
da mesma.
Activator Utilizado para criação de instâncias dinamicamente.
Assembly Reúne informações sobre um módulo Assembly, como os tipos
contidos no mesmo.
Vamos ver na prática como realizar as tarefas mais comuns com Reflection;
Varrer as propriedade de uma classe e atribuir-lhes valores
static void VarrePropriedade() {
Pessoa pess = new Pessoa();
//Todos os objetos tem o método GetType() pois o mesmo está definido na classe elementar
object.
//O GetType retorna uma Type que tem o método GetProperties() que retorna uma lista com
informações sobre as propriedades da classe.
PropertyInfo[] PropI = pess.GetType().GetProperties();
int Contador=10;
//Nesse foreach escrevemos o nome e o tipo da propriedade na tela, e atribuímos um valor
para cada
// verificando pelo nome da mesma.
foreach (PropertyInfo item in PropI)
{
Console.WriteLine(item.Name);
Console.WriteLine(item.PropertyType.ToString());
if (item.Name == "Nome")
item.SetValue(pess, "Nome" + Contador.ToString(), null);
else
item.SetValue(pess, Contador, null);
Contador++;
}
//Nesse for exibiremos o valor de todas as propriedades da classe.
foreach (PropertyInfo item in PropI)
{](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-71-320.jpg)
![69 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Console.WriteLine(item.GetValue(pess, null));
}
}
Criar a instância de um tipo anônimo
//O método abaixo cria uma instância do tipo definido na hora da chamada, na definição não se sabe
qual tipo será criado.
static T CriaInstanciaAnonima<T>() {
return Activator.CreateInstance<T>();
}
Carrega dinamicamente um tipo contido em outro assembly
Essa eu considero a funcionalidade mais importante. Porém é mais complexo de ser feito por tanto vamos passo a passo.
1-)Crie um projeto do tipo Class Library com o nome Abstrações.
2-)Delete a classe de nome class1.cs que é criada por padrão.
3-)Adicione uma Interface de nome IReflexaoDb.
4-)Adicione a assinatura de método abaixo na interface:
object[] RetornaDados();
5-)Adicione um novo projeto ClassLibrary com o nome BusinessLayer.
6-)Altere o nome da classe padrão de Class1 para Clientes.
7-)Clique com o botão direito sobre o projeto selecione Add Reference->Aba projects->Abstracoes->Ok.
8-)No arquivo da classe Clientes coloque no início o comando abaixo:
Using Abstracoes
9-)Adicione a herança de IReflexaoDb para Clientes.
10-)Adicione 2 propriedade do tipo string na classe Clientes Nome e Cpf.
11-)Adicione um construtor default para incializar a variável.
Código:
public Clientes() {
Nome = "nome padrão";
Cpf = "Cpf padrão";
}
12-)Implemente o método da Interface na classe Clientes código abaixo:
public object[] RetornaDados()
{
return new object[]{Nome,Cpf};
}
13-)Compile os dois projetos em release.
14-)Copie as duas dlls geradas para um lugar fácil de encontrar.
15-)Crie um projeto do tipo Windows Forms chame de VisualizadorReflexao.
16-)Arraste um TextBox para tela e chame-o de txtCaminho.
17-)Arraste um Button e chame-o de btnAbrir, mude a propriedade text para “Localizar DLL” e a propriedade ReadOnly para
true.
18-)Arraste um novo TextBox para tela e chame-o de txtExibicao, mude a propriedade MultLine para true.](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-72-320.jpg)
![71 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Nome = "NomePadrao";
Idade = 12;
}
public object[] RetornaDados() {
return new object[] { Nome, Idade };
}
}
static void VarrerMetodos() {
Pessoa pess = new Pessoa();
MethodInfo[] MetInf = pess.GetType().GetMethods();
foreach (MethodInfo item in MetInf)
{
if (item.Name == "RetornaDados")
{
foreach (object item2 in (object[])item.Invoke(pess, null))
{
Console.WriteLine(item2.ToString());
}
}
}
Console.ReadKey();
}
LINKS
Artigo Wikipedia em inglês sobre o C# - http://en.wikipedia.org/wiki/C_Sharp_(programming_language)
Site ECMA sobre a padronização C# - http://www.ecma-international.org/publications/standards/Ecma-334.htm
Namespace Programming Guide C# MSDN - http://msdn.microsoft.com/pt-br/library/0d941h9d.aspx
Classes e estrutura C# - http://msdn.microsoft.com/pt-br/library/ms173109.aspx
Manual de referência do C# msdn - http://msdn.microsoft.com/pt-br/library/618ayhy6.aspx
Um pequeno curso gratuito de C# - http://www.oficinadanet.com.br/artigo/825/curso_de_c_sharp_licao_1_iniciando
Operadores C# MSDN - http://msdn.microsoft.com/pt-br/library/ms173145.aspx
ConnectionsStrings - http://www.connectionstrings.com/](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-74-320.jpg)
![73 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C#
Encapsulamento
Consiste na separação dos aspectos internos e externos de um objeto. Este mecanismo é utilizado amplamente para impedir o
acesso direto ao estado do objeto(seus atributos), disponibilizando aos outros objetos apenas os métodos que fazem a acesso a
esses objetos, no caso do C# os getters e setters que não deixam de ser métodos, apesar de na chamada ser parecida com o acesso
a um atributo. Exemplo você não precisa conhecer a composição química e nem como é produzido um remédio para toma-lo, você
apenas sabe o que ele se propõe a fazer e não se preocupa como ele faz isso.
Polimorfismo
Permite que uma mesma declaração de objeto contenha uma instância de uma classe derivada da mesma, sendo assim esse mesmo
objeto se comporta de maneiras diferentes dependendo da instância passada a ele. Alguns autores consideram a sobrecarga de
métodos como uma forma de polimorfismo.
Exemplo
Vamos utilizar as classes Cliente e Fornecedor do exemplo de herança, se declararmos um objeto pessoa e atribuir a ele uma
instancia de Cliente o método RetornaDados se comportará de uma maneira se for uma instancia de Fornecedor se comportará de
outro acompanhe no código abaixo:
static void Main(string[] args)
{
Pessoa pess;
pess = new Cliente();
pess.Nome = "jão";
//Como o objeto foi declarado com o tipo genérico para acessarmos membros da
especialização
//precisamos realizar um CAST.
((Cliente)pess).UltimaCompra = DateTime.Now;
//Cliente
ExibeDados(pess.RetornarDados());
/*Saida: jão
* Hora atual: exemplo 23/08/2011 09:04
*/
pess = new Fornecedor();
pess.Nome = "jão";
((Fornecedor)pess).Categoria = "Farmaceutico";
//Fornecedor
ExibeDados(pess.RetornarDados());
/*Saida: jão
* Farmaceutico
*/
Console.ReadKey();
}
static void ExibeDados(List<object> values) {
foreach (object item in values)
{
Console.WriteLine(item.ToString());
}
}
Princípios
A programação orientada a objetos tem seus pilares e não pode existir sem os mesmos, mas existem princípios que apesar de não
fazer parte da sua concepção são extremamente importantes e desejáveis em sistema bem desenhados. Abaixo comentaremos
sobre alguns dos mais importantes.
SOLID
Essa sigla é um acrônimo para a palavra inglesa “solid”, que significa sólido, solidez. Cada letra representa um acrônimo de um
princípio, ou seja, temos um acrônimo de acrônimos. Esse conjunto é o resultado de estudos e experiências de vários
desenvolvedores e foi primeiramente catalogado por Rober “Uncle bob” Martin(veja sessão de links) em seu livro “Applying
Principle and Patterns”. Vamos conhecer cada princípio.
S - Single responsibility principle (SRP)
Este é o principio da responsabilidade única, que recomenda que uma classe só deva ter um motivo para sofrer alguma alteração.
Sendo assim, podemos resumir que uma classe qualquer em seu sistema deva ter uma tarefa única e específica. Isso, contudo, não
quer dizer que se tenha apenas um único método, mas que todos os métodos criados trabalhem juntos em um único objetivo,](https://image.slidesharecdn.com/apostilatoslideshare-110921131550-phpapp02/85/Apostila-desenvolvimento-aplicacoes-comerciais-com-C-76-320.jpg)
Apostila desenvolvimento aplicações comerciais com C#
- 2. Sumário Conteúdo Página Capítulo 1- .NET 1 Framework O que é? 1 História 1 Versões do .NET Framework 2 Principais Recursos por versões 2 Arquitetura básica 3 O que é IL? 3 Garbage Collection 6 GAC 6 LINKS 7 Capítulo 2-Microsoft 8 Visual Studio 2010 O que é? 8 História 8 Funcionalidades por versões 8 Como iniciar? 8 Estrutura de um projeto e tipos de 10 arquivos básicos Templates 11 Code Snippet 12 Ferramentas de analise de código 13 Principais janelas do VS 2010 13 Debugando com VS 2010 13 IntelliTrace 14 Gerando um release 16 LINKS 16 Capítulo 3-Microsoft C# 17 O que é? 17 História 17 Visão conceitual classes 17 Namespaces 18 Using 18 Tipos de dados básicos 19 Tipos de valor e de referência 20 Varáveis 21 Operadores 21 Desvios condicionais 24 Switch 25 Estruturas de repetição 26 Tratamento de erro 30 Arrays e Lists 30 Windows Forms 32 Eventos 32 Guia rápido: Hello World 33 Principais componentes Windows 34
- 3. Forms Trabalhando com arquivo texto 51 Modificadores de acesso 53 Classes 53 Propriedades e variáveis 53 Construtores 54 Métodos 56 Sobrecarga 57 Enums 59 Herança 59 Classes e métodos estáticos 60 Conversões 61 Interfaces 61 ADO.net – Trabalhando com 62 bancos de dados Criação de controles 65 customizados Generics 66 Lambda Expressions 67 Reflection 68 LINKS 71 Capítulo 4 – Orientação a 72 objetos Pilares 72 Princípios 73
- 4. 1 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Capítulo 1 - Microsoft .NET Framework. O que é? Microsoft .NET é componente construído pela Microsoft, que visa uma plataforma única para desenvolvimento e execução de sistemas e aplicações. Todo e qualquer código gerado para .NET, pode ser executado em qualquer dispositivo que possua o framework de tal plataforma instalado. Dessa forma o programador deixa de escrever código para um sistema ou dispositivo específico, e passa a escrever para a plataforma.NET. O .net Framework é projetado para atender os seguintes objetivos: Fornecer um ambiente de programação orientada a objetos consistente, se o código é armazenado e executado localmente, executado localmente, mas distribuído pela Internet ou executado remotamente. Fornecer um ambiente de execução que minimiza conflitos de implantação de software e controle de versões. Fornecer um ambiente de execução que promove a execução segura do código, incluindo código criado por um desconhecido ou por um terceiro que não seja totalmente confiável. Fornecer um ambiente de execução que elimina os problemas de desempenho de ambientes interpretados ou com scripts. Tornar a experiência do desenvolvedor consistente, através dos diversos tipos de aplicações, tais como aplicativos baseados no Windows e aplicativos baseados na Web. Construir toda a comunicação em padrões da indústria para garantir que o código com base no .net framework possa interagir com qualquer outro código. História A Microsoft lançou o .net Framework em 2001 com a intenção de redefinir a maneira que escrevemos programas para Windows e também pra web, a iniciativa .net travou uma árdua briga com a Sun Microsystems em relação a versão da Microsoft da linguagem java que era a mais usada para desenvolvimento de aplicativos .net quando o framework surgiu. Esta implementação específica do java concebida pela Microsoft foi nomeada J++ e sua biblioteca de classe WFC(Windows foundation Classes) foi em grande parte desenhada por Ander Hejlsber um ex-funcionário da Borland que ficou conhecido pela sua participação nas linguagens Pascal, Turbo Pascal,Borland Pascal e Delphi. Posteriormente o Visual J + +( Visual Studio 6.0 foi o último a conter suporte a essa linguagem) foi descontinuado, Hejlsberg foi nomeado arquiteto-chefe da linguagem C # e um dos principais desenvolvedores do .NET Framework.
- 5. 2 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Versões do .net framework Principais recursos por versão do framework Cada versão do .net framework tem suas particularidades, porém toda versão é completamente compatíveis com as anteriores minimizando assim o impacto da migração de uma versão para outra, inclusive módulos compilados em uma versão mais antiga pode ser carregado em um aplicativo construído com uma versão mais atual. Na tabela abaixo temos os principais alterações ocorridas em cada versão do .net framework, notem que nem sempre o CLR é atualizado a cada versão do .net quer dizer que apenas novos módulos foram adicionados mas a forma de gerenciamento do código permanece a mesma. Versão do .NET Versão Versão do Visual Studio Descrição Framework do CLR 1.0 1.0 Visual Studio .NET Contém a primeira versão do CLR e a primeira versão da biblioteca de classes. 1.1 1.1 Visual Studio .NET 2003 Inclui atualizações para o ASP.NET e pra o ADO.NET. Essa versão foi posteriormente atualizada 2 vezes com o Service Pack 1(SP1) e Service Pack 2(SP2) Essa versão também introduziu a execução sibe-by-side a qual habilita aplicações em um único computador executar em várias versões do CLR . 2.0 2.0 Visual Studio 2005 Introduziu uma nova versão do CLR com adições para as bibliotecas de classes incluindo os tipos genéricos, coleções genéricas e acréscimos significativos para o ASP.NET. Esta versão foi posteriormente atualizada com o SP1 e o SP2. 3.0 2.0 Visual Studio 2005 Esta versão é essencialmente o .NET Framework 2.0 com a adição do Windows Presentation Foundation (WPF), o Windows Communications Foundation (WCF), o Windows Workflow Foundation (WF) e o CardSpace. Posteriormente foi atualizado com o SP1 e o SP2. 3.5 2.0 Visual Studio 2008 Acrescentou novas funcionalidades, tais como suporte a AJAX e LINQ. A atualização do SP1, acrescentou ao. NET Framework, dados dinâmicos, e um pequeno conjunto de melhorias adicionais. 4 4 Visual Studio 2010 Inclui uma nova versão do CLR, bibliotecas de classes básicas e novas funcionalidades, tais como o Managed Extensibility Framework (MEF) , dynamic language runtime (DLR) e code contracts.
- 6. 3 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Arquitetura básica O Microsoft .NET Framework é composto por 2 componentes principais: o CLR(Common Language Runtime) e a biblioteca de classes. O Common Language Runtime é a base do Framework .NET. Você pode pensar no Runtime como um agente que gere código em tempo de execução, fornecendo principalmente serviços como gerenciamento de memória, gerenciamento de segmento e processamento remoto, ao mesmo tempo a segurança de tipos estritos e outras formas de precisão de código que promovem segurança e robustez. Na verdade, o conceito de gerenciamento de código é um princípio fundamental do runtime. Código rodando sobre o CLR é conhecido como código gerenciado, enquanto o código que não roda sobre ele é conhecido como código não gerenciado. A biblioteca de classes, é o outro componente principal do .NET Framework, se trata de uma vasta coleção orientada a objetos de tipos reutilizáveis que você pode usar para desenvolver aplicações que vão desde a tradicional linha de comando até aplicativos com interface gráfica do usuário (GUI), para aplicativos com base em inovações mais recentes fornecidas pelo ASP.NET, como Web Forms e Serviços Web XML. Abaixo temos uma ilustração com uma visão holística da relação entre a biblioteca de classes, o.net framework, sua aplicação e o sistema operacional ou o hardware. O que é IL? Uma grande quantidade de linguagens podem ser utilizadas para construção de aplicativos baseados no .net framework , na verdade qualquer linguagem que possua um compilador IL pode ser utilizada, como exemplo podemos citar C#, VB.NET, DELPHI.NET e J#, apesar de o C# ter sido adotado como linguagem oficial para o .net framework. O que acontece na verdade acontece é que todo código é traduzido na compilação para IL que é a abreviação Itermediate language, ou seja, linguagem intermediária e essa é a única linguagem que o CLR entende sendo interpretada e gerenciada por ele em tempo de execução e transformando-a posteriormente em código de máquina(binário), os principais tipos de arquivos gerados por um compilador IL variam dependendo do tipo de projeto são estes: EXE, DLL e ASPX. Abaixo um pequeno exemplo “hello world” em c# e abaixo o mesmo programa em IL. Versão C#; using System; namespace HelloWorldIL { class Program { static void Main(string[] args) { Console.WriteLine("Hello, World !"); } } }
- 7. 4 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Versão IL; .assembly extern mscorlib {} .assembly HelloWorldIL {} .namespace HelloWorldIL { .class Program { .method static public void Main() cil managed { .entrypoint .maxstack 8 ldstr "Hello, World !" call void [mscorlib] System.Console::WriteLine(string) call valuetype [mscorlib]System.ConsoleKeyInfo [mscorlib]System.Console::ReadKey() ret } } }
- 8. 5 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# A imagem abaixo demonstra o fluxo ocorrido entre a compilação e a execução de um aplicativo .net. Você pode acessar o código em IL de um arquivo .net compilado através da ferramenta IL Disassembler que normalmente pode ser encontrado na pasta do Visual Studio 2010 no menu iniciar-> Microsoft Windows SDK Tools IL Disassemble ou no caminho: C:Program FilesMicrosoft SDKsWindowsv7.0ABinNETFX 4.0 Toolsx64ildasm.exe Você pode também escrever um aplicativo utilizando IL diretamente, mas infelizmente o Visual Studio 2010 não oferece suporte a essa linguagem então um editor de texto qualquer pode ser utilizado, para compilar utilize a ferramenta ILAsm que vem junto com o SDK do .net framework e é acessível através do prompt do Visual Studio e pode ser encontrado normalmente na pasta do menu iniciar do Visual Studio->Visual Studio Tools->Visual Studio Command Prompt. Apesar desta prática não ser muito
- 9. 6 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# comum nos ajuda a entender como funcionam as coisa “por baixo do capô” no .net framework e também pode ser utilizado para criar programas em tempo de execução(Reflection.Emitting). Garbage Collection O Garbage Collection é um recurso do Common Language Runtime que faz o gerenciamento automático da memória e oferece os seguintes benefícios: Permite que você desenvolva sua aplicação sem a necessidade de liberar memória. Aloca objetos no heap gerenciado de forma eficiente. Identifica objetos que não estão mais sendo usados, apaga-os da memória e a mantém disponível para futuras atribuições. Objetos gerenciados automaticamente têm o espaço para seus atributos previamente alocados, assim o construtor não precisa inicializar cada um deles. Fornece segurança de memória, certificando-se que um objeto não pode usar o conteúdo de outro objeto. Em que situações o Garbage Collection é acionado: O sistema tem memória física baixa. A memória que é usada por objetos alocados no heap gerenciado ultrapassa um limite aceitável. Este limiar é continuamente ajustado conforme o processo é executado. O método GC.Collect é chamado. Em quase todos os casos, você não precisa chamar esse método, porque o coletor de lixo é executado de forma contínua. Este método é usado principalmente para situações únicas e testes. Nota: Heap Gerenciado é o segmento de memória para armazenar e gerenciar os objetos. GAC GAC é a abreviações para Global Assembly Cache que consiste em um sistema robusto e unificado serviço de gerenciamento de DLL’S compartilhadas, com ele aplicações podem usar diferentes versões da mesma DLL instalada no disco.
- 10. 7 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# LINKS Visão conceitural do .net framework - http://msdn.microsoft.com/pt-br/library/zw4w595w.aspx Página oficial do .net framework - http://msdn.microsoft.com/en-us/netframework/default.aspx Versões e dependências do .net framework - http://msdn.microsoft.com/pt-br/library/bb822049.aspx Instalação do .net framework 4.0 runtime - http://www.microsoft.com/download/en/details.aspx?id=17718 Como o framework .net reconhece tantas linguagens - http://www.devmedia.com.br/post-14830-Como-o-framework--NET- reconhece-varias-linguagens-de-programacao.html .NET Framework Class library overview - http://msdn.microsoft.com/en-us/library/hfa3fa08.aspx Common language runtime overview- http://msdn.microsoft.com/en-us/library/ddk909ch.aspx Entrevistas de Anders Hejlsberg sobre o .net framework - http://www.bitwisemag.com/copy/programming/milestones/pm_dotnet.html Artigo Wikipédia j++ - http://en.wikipedia.org/wiki/Visual_J%2B%2B Fundamentos garbage collection - http://msdn.microsoft.com/en-us/library/ee787088.aspx Visão geral biblioteca .net - http://msdn.microsoft.com/en-us/library/hfa3fa08.aspx Mapa das principais classes .net framework 4.0 - http://brad_abrams.members.winisp.net/Projects/PDC2008/PDC2008- NETFX4.pdf Mapa de classes comuns do .net framework 3.5 - http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=19341
- 11. 8 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Capítulo 2 – Microsoft Visual Studio O que é? O Microsoft Visual Studio é uma IDE(integrated development enviroment) , se trata uma plataforma multi linguagem concebida pela Microsoft que apresenta facilidades significativas para o desenvolvimento de software englobando um série de funcionalidades que auxiliam nas rotinas de desenvolvimento, pode ser usada para desenvolver aplicações console ou gráficas através das bibliotecas Windows Forms, web sites, aplicações web e web services. Algumas das suas principais funcionalidades são Um editor de código com esquema de cores que visa facilitar o entendimento. Um sistema de auto completar para nome de funções, tipos de dados, namespaces e palavras reservadas (Intelissense). Um compilador/interpretador de código. Em versões mais avançadas até mesmo controle de versões. Editor gráfico para criação da interface de usuário. Refatoração de código. Dentre as linguagens suportadas de forma nativa estão: C#,VB.net,F#,XML,HTML,JavaScript e CSS. Apesar de ser um software proprietário, existem as versões gratuitas chamadas de express que possuem menos recursos e são voltadas para um linguagem específica como Visual C# Express,Visual C++ dentro outras. História A primeira versão do Visual Studio foi o Visual Studio 97 que agregou grande parte das ferramentas necessárias para o desenvolvimento de software pela primeira vez. O Visual Studio 97 teve duas versões, Visual Studio Professional e o Visual Studio Enterprise. As linguagem suportadas eram Visual Basic 5.0 e Visual C++ 5.0 voltados ao desenvolvimento para Windows, J++ 1.1 para programação para JVM, Visual Fox Pro 5.0 para programação de bancos de dados e também foi introduzido suporte à construção de sites de conteúdo dinâmico através do Active Server Page(ASP), em 2002 foi lançado o primeiro Visual Studio voltado a programação com .net. A versão atual da IDE é o Microsoft Visual Studio 2010 e esta será a que utilizaremos como ferramenta padrão de desenvolvimento em nosso curso, as principais alterações ocorridas nessa versão foram a reorganização da interface para torna-la mais simples utilizando as novas tecnologias para desenvolvimento de interface criadas pela própria Microsoft (WPF). Inclusão do DLR - Dynamic Language Runtime no pacote de instalação que dá suporte aos tipos dinâmico e à metaprogramação, Suporte ao .net framework 4.0 e Suporte ao desenvolvimento de aplicativos para o Windows phone 7. Funcionalidades por versão do Microsoft Visual Studio 2010 Como Iniciar? Agora faremos um rápido guia de como construir uma aplicação simples no VS2010. Para começar o desenvolvimento de um aplicativo com Visual Studio é relativamente simples basta abrir o programa ir até o menu superior na opção File->new->Project. Uma janela como a da imagem abaixo aparecerá:
- 12. 9 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Do lado direto temos uma lista hierárquica com o título “Instaled templates” o que seria modelos de projetos para cada tipo de aplicativo, os templates serão detalhados posteriormente nesse capítulo. No caso está selecionada a categoria “Windows” e dentro dela há subtipos como “Windows Forms Applications” e “Class Library Application”. Na parte superior temos versão do .net que será utilizado no projeto no caso selecionado .net framework 4. Na parte inferior temos o nome que queremos dar ao nosso projeto, e logo abaixo o caminho no computador que os projetos e os arquivos relacionados serão salvos e abaixo o nome da solução que funciona como uma agregadora de conteúdo para podermos organizar um sistema formado de vários projetos será melhor explicada posteriormente nesse capítulo. Temos ainda duas caixas de seleção a primeira indica se gostaríamos de criar um diretório para organizar fisicamente os arquivos da solução e o segundo indica se gostaríamos de já adicionar o projeto á um controle de versão. Feitas essas configurações iniciais podemos dar ok e será criado um projeto de acordo com o template escolhido e este normalmente é apresentado do lado direito na janela “Solution Explorer”. A partir de agora tomaremos como exemplo o template “Console Application” que é um dos mais simples para prosseguir esse guia rápido.
- 13. 10 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# A imagem abaixo mostra o que veremos após dar ok na janela anterior: Já será aberto o arquivo com a classe principal do projeto e o método de entrada basta editar a definição do mesmo implementando as ações que desejar e depois clicar no botão parecido com um play na parte superior da tela ao lado da palavra debug o seu aplicativo será executado para que o comportamento do mesmo seja analisado. Vamos supor que tudo correu bem, o próximo será alterar o a caixa de seleção onde está escrita a palavra Debug para Release, feito isso basta clicar com o botão direto sobre a solução na janela “Solution Explorer”, será aberto um menu contextual escolha a opção “rebuild” e isto iniciará a montagem do seu aplicativo para um arquivo executável. Agora basta ir até o diretório da solução, procurar a pasta do projeto, “ConsoleApplication1”->bin->release, o arquivo executável estará lá dentro, clique duas vezes no mesmo e sua aplicação será iniciada. Estrutura de um projeto e tipos de arquivos básicos O Visual Studio tem uma organização hierárquica que consiste basicamente em Soluções, Projetos, Configurações, itens do projeto e itens das soluções. -Soluções Funciona como uma forma de organizar os insumos necessários para execução e/ou construção de um sistema, uma solução pode ter diretório, projetos e qualquer outro tipo de arquivo que seja importante para o sistema, como uma imagem ou um documento de texto, cada projeto pode gerar um executável ou uma dll e pode ter dependências de outros projetos, a solução se encarrega de organizar a ordem de “build” para que todas dependências de um projeto que estejam também estejam na forma de projeto sejam compiladas antes do mesmo. A solução só existe em tempo de desenvolvimento depois de compilado não gera uma saída significativa e vai depender de como você organizar os arquivos gerados para realização com sucesso do deploy, no computador as soluções ficam armazenadas em arquivos com a extensão “.sln” e você pode abri-la clicando duas vezes no arquivo, porém para copiar com sucesso uma solução o computador deve estar configurado para mostrar arquivos oculto, pois existe um arquivo com o mesmo nome da solução com a extensão “.suo” que precisa ser copiado junto para a pasta destino. -Projetos O Projeto é a versão em tempo de desenvolvimento de uma aplicação, nele contém todos os arquivos de códigos não compilados os “.cs” no caso do c#, todas as configurações por exemplo, as plataformas suportada(X86,X64) e todas as referências externas necessárias para o seu funcionamento, na compilação é ele que de fato se transforma no produto final. No computador o projeto em c# ficam armazenados em arquivos com a extensão “.csproj” e você pode abri-lo no Visual Studio
- 14. 11 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# clicando sobre esse arquivo, porém na verdade ele se trata de um arquivo XML em um padrão estabelecido pelo VS, você pode acessar e editar diretamente esse arquivo XML clicando com o botão direito sobre o arquivo e seleciona abri com... notepad. -Propriedades Praticamente todos os templates de projetos criam um item chamado properties onde podem ser configurados os principais aspectos do projeto, apesar de poder ser considerado como um item do projeto merece uma atenção especial, abaixo as principais configurações que podem ser feitas no properties de um projeto para Windows. Plataforma(s) em que a aplicação funcionará depois de compilada. Versão do framework utilizada no projeto. Versão do arquivo compilado. Temos um espaço para colocarmos recursos que ficarão embarcados no arquivo compilado. As propriedades não são salvas em um arquivo único com uma extensão específica, mas estão distribuídas nos arquivos “.csproj”, no arquivo AssembyInfo.cs e quando adicionados recursos no arquivo também nos arquivos ” .resx” e no Resource.Design.cs, como os aplicativos .net foram projetados para serem xcopy ou seja basta colocar todas dependências em uma pasta sem precisar de criar valores no registro, a maioria dos arquivo que gravam dados sobre aplicativos são xmls em um padrão do Visual Studio e tiveram sua extensão relacionadas com o mesmo. -Itens do projeto O projeto como a solução pode ter praticamente quaisquer tipos de arquivos adicionados entre os seus itens, como imagens e documentos de textos, mas o principal em aplicações Windows podemos dizer que são os arquivos “.cs” que contêm o código fonte de nossos programas, esses arquivos servem apenas para organizar o código, que pode ser separado em arquivos da forma que for mais conveniente, facilitando o controle de versão e melhorando a semântica. Tabela de extensões básica do Visual Studio(C#) Extensão Do que se trata *.sln Arquivo onde ficam armazenadas as informações sobre as soluções do Visual Studio. *.suo Arquivo oculto complementar da solução precisa ser copiado com a solução para a pasta destino. *.csproj Arquivo onde ficam armazenados os dados sobre os projetos do Visual Studio. *.cs Arquivo onde fica armazenado o código não compilado do c#. *.resx Arquivo onde ficam contidas informações sobre os recursos de um projeto. TEMPLATES Os templates são modelos pré-definidos para facilitar a inclusão de um projeto, o template define quais as referências necessárias para um determinado tipo de projeto, por exemplo, a dll System.Windows.Forms do .net framework é adicionada no template “Windows application” mas não é adicionada no template “Console application”, porém nada impede que essa dll seja adicionada posteriormente, no template também estão definidos os item que serão adicionados ao projeto incialmente tomando novamente como exemplo “Windows Forms” e o “Console Applications” no primeiro um formulário já vem adicionado no projeto e no segundo não. No Visual Studio 2010 os templates instalados vão depender das suas escolhas na hora da instalação, mas de qualquer maneira você terá uma vasta gama de templates a sua disposição, ainda há templates disponibilizado na internet por terceiros como “Applications for twitter” e quando se tratar de algo muito específico você mesmo pode fazer os seus templates. Intellissense O Intellissense é um recurso do Visual Studio 2010 que auxilia na construção do código fonte ele tem o papel de sugerir o complemento da palavras que estamos digitando e também auxiliar na resolução de problemas, como identificar o namespace que precisa ser “importado”. Ao começar escrever uma palavra aparece uma lista do que possivelmente você pretende escrever, você
- 15. 12 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# pode navegar pela lista com as setas do teclado e encontrando a correspondência que deseja basta dar tab para que a palavra seja inserida no fonte. Imagem da janela de auto complemento do intellissense No caso de você escrever um tipo não reconhecido aparecerá um pequeno quadrado sobre ele, basta clicar com o mouse no mesmo e selecionar a ação desejada, ao renomear algum objeto também aparecerá o mesmo quadrado clicando nele terão as opções para ajudar a refatorar o código. Veja na imagem abaixo. Aqui a sugestão foi apenas de adicionar o namespace que já está disponível ao contexto atual. Code Snippet Os code snnipet’s além de auto completar a palavra inserem o restante de código que compõe um comando, um exemplo é o “for “ o auto completar ajudaria sugerindo “for” quando for digitado “f”, mas não incluiria uma espécie de esqueleto no editor com a sintaxe básica do comando. Toda vez que iniciar a digitação de um comando e houve uma espécie de um papel partido na frente da sugestão de complemento conforme a imagem abaixo: Basta apertar duas vezes o “Tab” que o complemento do comando será incluído, abaixo imagem com o código gerado ao apertar duas vezes o “Tab”. Se você continuar utilizar o “Tab” o cursor será direcionado as partes variáveis da função que são as que estão com o fundo amarelo na imagem acima.
- 16. 13 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Ferramentas de análise de código O Visual Studio tem algumas ferramentas que auxiliam a melhorar e manter a qualidade dos projetos uma é especialmente interessante. -Code metrics analysis Essa ferramenta fornece uma série de índices sobre a qualidade do código, ajuda avaliar o trabalho feito e também é interessante para analisar se as mudanças feitas melhoraram ou pioram os aspectos avaliados. Ela é muito simples de usar basta clicar com o botão direito sobre a solução ou sobre um projeto específico e selecionar a opção “Calculate Code Metrics”, será aberta uma janela e um índice geral é atribuído para cada item, inclusive ele ajuda você interpreta-los, é possível ir abrindo níveis até chegar nas funções que estão piorando os indíces. Principais janelas do Visual Studio 2010 ToolBox Concentra os itens que podemos utilizar dependendo do contexto, no desenvolvimento de aplicativos Windows estarão disponível na ToolBox os controles nativos para esse tipo aplicação como textbox,lable,combobox,datagrid e datetimepiker . Eventualmente poderá conter também controles definido pelo usuário. Pode ser acessada pelo menu:View->Toolbox ou pelo atalho Ctrl+W,X. Solution Explorer Essa janela apresenta uma lista hierárquica representando a solução com todos seus itens. Pode ser acessada através do menu:View->Solution Explorer ou pelo atalho Ctrl+W,S. Server Explorer Essa janela serve para gerenciar conexões com bancos de dados. Pode ser usada para localizar Windows Services ativos e servir como DataSources. Pode ser acessada através do menu:View->Server Explorer ou pelo atalho Ctrl+W,L. Properties Essa janela apresenta as propriedade da maioria dos itens selecionáveis no Visual Studio 2010 como controles e projetos. Pode ser acessada clicando com o botão direito sobre o item deseja e selecionando a opção “properties” no menu contextual, pelo menu principal: View->Propertie Window ou ainda pelo atalho Ctrl+W,P. Document Outline Essa janela apresenta uma lista hierárquica com todos os componentes contidos em um formulário, é uma ótima opção para navegar entre eles. Pode ser acessada pelo menu:View->Other Windows->Document Outline ou pelo atalho Ctrl+W,U. Immediate Essa só é acessível em tempo de depuração e serve para execução de comandos, utilizando os objetos carregados no escopo em que a aplicação foi pausada, é interessante usa-la para avaliar os comportamentos individuais dos objetos. Pode ser acessada pelo menu: Debug->Windows->Immediate ou pelo atalho Ctrl+D,I. Debugando com Visual Studio Para debugar o código no Visual Studio, basta selecionar a opção Debug na caixa de seleção da barra de ferramentas padrão e clicar no botão Start Debugging se trata do botão do lado da caixa onde foi escolhida a opção Debug com um ícone parecido com um “play” ou ainda apertar o atalho F5. O programa será executado no modo debbug. Pontos de parada podem ser adicionados ao código selecionando a linha em que deseja que ocorra a interrupção e apertando o atalho f9, uma bola vermelha será adicionada do lado esquerdo da linha e a mesma terá a cor do plano de fundo alterada para vermelho conforme imagem abaixo:
- 17. 14 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Assim a execução do programa será interrompida quando chegar a este ponto uma seta amarela apontará para a linha indicando que a execução está parada naquele ponto conforme a imagem abaixo. O desenvolvedor poderá fazer basicamente 3 coisas a partir desse ponto, executar o próximo passo sem passar na definição do método(F10), executar o próximo passo passando por dentro da definição do método(F11) ou voltar a execução normal do programa(F5). No Visual Studio você pode voltar à execução do programa arrastando a seta amarela para a linha desejada. Enquanto o programa estiver parado o desenvolvedor pode analisar os valores das variáveis colocando o mouse sobre elas, em quais condições a linha de execução entrou ao ver por onde a seta amarela está se movendo e fazer simulações com a Immediate Window, dentre outras coisas ou seja analisar passo a passo o que está acontecendo com o sistema afim de solucionar problemas. Para analisar valores de um objeto podemos utilizar a função QuickWatch, para acessa-la é só selecionar o objeto em questão e clicar com o botão direto sobre, como na imagem abaixo: Selecionar a opção QuickWatch, uma popup como a da imagem abaixo será exibida mostrando as informações do objeto: Nela temos o nome do objeto, o valor e o tipo, no caso de objetos que têm propriedades poderíamos navegar entre elas verificando cada um de seus valores. A execução do programa pode ser Interrompida também pelo botão “Break All” presente na barra de ferramentas “Debug”, o ícone do botão tem o aspecto de um símbolo de Pause ou pelo atalho Ctrl+Alt+Break. Para encerrar o Debug e consequentemente a execução da aplicação basta fecha-la ou selecionar o botão “Stop Debugging” na barra de ferramentas “Debug” ou ainda acionar o atalho Shift+F5. IntelliTrace Intellitrace é uma nova tecnologia de rastreamento disponível apenas para usuários do Visual Studio 2010 Ultimate. Com o Intellitrace mensagens sobre os eventos ocorrido na aplicação são automaticamente emitidas pelo Visual
- 18. 15 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Studio em segundo plano para um arquivo .iTrace, onde podem ser recuperadas e examinados para fins de depuração. O Intellitrace é altamente configurável no que diz respeito ao tipo e quantidade de informação que você deseja gravar e com as configurações padrão tem muito pouco impacto sobre a performance da execução durante a depuração. Habilitando o IntelliTrace O IntelliTrace já vem habilitado por padrão e os eventos do Intellitrace são registrados automaticamente. Esse evento representam os eventos da aplicação e as gravações dessas informações causam um impacto tão pequeno que se torna praticamente imperceptível na execução do aplicativo. Você pode também configurar o IntelliTrace para registrar as chamadas de função, informação sobre os parâmetros passados e eventos disparados por componentes. Porém registrando essas informação pode haver uma degradação da performance que por outro lado proporciona mais dados para depuração. Para habilitar o IntelliTrace: 1-Selecionar Tools->Options - Na lista da direita da popup que aparecer seleciona IntelliTrace e por fim marque a opção Enable IntelliTrace. 2-Para habilitar o registro sobre chamada de função e eventos selecione a opção IntelliTrace Events and Call Informations. Selecionando o local para salvar os arquivos do IntelliTrace Os arquivos do IntelliTrace podem ser salvos em disco para posterior analise. Para selecionar o local onde ficará esse arquivo pode ser escolhido seguindo os seguintes passos: 1- Selecionar Tools->Options->Na lista da direita da popup que aparecer expanda a opção IntelliTrace. 2-Selecione Advanced. 3-Se a opção “Store IntelliTrace recordings in this directory” estiver desmarcada, marque-a. 4-Clique no botão “Browse” e selecione o caminho em seu computador. Selecionando os eventos que o Intellitrace irá registrar. Os tipo de eventos a serem registrados pelo IntelliTrace são altamente configuráveis. Você pode registrar todos os eventos disponíveis ou limitar o registro apenas aos tipos de eventos que lhe interessar seguindo estes passos: 1- Selecionar Tools->Options->Na lista da direita da popup que aparecer expanda a opção IntelliTrace. 2-Selecione a opção IntelliTrace Events. 3-Aparecerá uma série de tipos de eventos, basta marca-los e desmarca-los para incluir ou excluir dos tipos de eventos a serem registrados pelo intellitrace. Visualizando eventos do IntelliTrace durante a depuração. Você pode ver os eventos do IntelliTrace em tempo de depuração através da janela do IntelliTrace. Os eventos só poderão ser visualizados quando a aplicação estiver pausada. Para o caminho para acessar a janela é: Debug->IntelliTrace->IntelliTrace events só disponível durante a depuração.
- 19. 16 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Gerando um release Para gerar um release no Visual Studio 2010 basta mudar o valor da caixa de seleção “Solutions Configurations” na barra de tarefas padrão para release clicar com um botão direto sobre um projeto ou sobre a solução no caso de querer compilar todos os projetos que estiverem contidos na mesma e no menu contextual selecionar “rebuild”. LINKS Página oficial do Visual Studio 2010 - http://msdn.microsoft.com/en-us/vstudio/default História Visual Studio - http://blogs.msdn.com/b/ricom/archive/2009/10/05/my-history-of-visual-studio-part-1.aspx Artigo Wikipedia - http://en.wikipedia.org/wiki/Microsoft_Visual_Studio
- 20. 17 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Capítulo 3-Microsoft C# O que é? C # é uma linguagem de programação multi-paradigma fortemente tipada, imperativa, declarativa, funcional, genérica, orientada a objetos (class-based) e orientada a componentes. Ele foi desenvolvido pela Microsoft como parte da iniciativa .net e posteriormente aprovada como padrão pelo Ecma (ECMA-334) e ISO (ISO / IEC 23270). C # é uma das linguagens de programação projetadas para o Common Language Infrastructure. C # é destinado a ser uma linguagem orientada a objetos, simples, moderna e de propósito geral. A sua equipe de desenvolvimento é liderada por Anders Hejlsberg. História Durante o desenvolvimento do .net Framework as biblioteca de classes foram originalmente escrita utilizando um sistema compilador de código gerenciado chamado Simple Managed C(SMC). Em janeiro de 1999 Anders Hejlsberg formou um time para construir uma nova linguagem por hora chamada de Cool um Acrônimo para “Clique Object Oriented Language”. A Microsoft chegou a considerar deixar Cool como o nome final da linguagem, mas mudou de ideia por razões comerciais. O C# foi anunciado oficialmente em julho de 2000 e neste momento a biblioteca de classes do ASP.net já havia sido reescrita em c#. Visão Conceitual Classes Iniciaremos com uma visão conceitual sobre classes, pois o C# é totalmente orientado a objetos e tudo é baseado em classes, o conceito de classe é basicamente a união entre os dados e as funções em uma mesma unidade lógica. Diferente de linguagens como o C++ você não consegue escrever uma função sem que a mesma esteja dentro de uma classe. As classes são utilizadas para criar instancias, ou seja armazenar dados na memória sobre operações e valores para que fiquem disponíveis em tempo execução. Abaixo um exemplo de classe: public. class MyClass { //No caso MyPropertie e MypropertieInt int seriam os dados da classe MyClass private string MyPropertie; private int MyPropertieInt; //SetMyPropertie seria um método que manipula os dados dados da própria classe public void SetMyPropertie(string MyPropertie) { this.MyPropertie = MyPropertie; } } A sintaxe básica de uma classe em C# public class [Nome da classe]{ //Variaveis private string var1; private string varN...; //Contrutores public [Nome da classe](); //Funções public void Method1(); public void MethodN...(); }
- 21. 18 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Sintaxe para criação de Instancia em C#; MyClass obj = new MyClass(); Posteriormente nesse capítulo abordaremos as classes com mais profundidade. Namespaces Os Namespaces servem como uma forma de dividir os objetos em categorias, normalmente de acordo com sua natureza, independente do projeto ou arquivo que estão. Sintaxe básica namespace [NomeNameEspace]{ ...//Objetos definidos no namespace } Namespaces podem conter outros namespace formando uma estrutura hierárquica, veja o exemplo abaixo: namespace Animal { namespace Caninos { namespace Cachorro { public class Poodle { } } } } Isso permite ter o mesmo nome de classe em namespaces diferentes, pois o nome completo da classe consiste em cada um de seus namespaces separados por um ponto com o nome da classe no final, também separado por um ponto. Sendo assim o nome completo da classe Poodle seria “Animal.Caninos.Cachorro.Poodle”, esse nome não precisa ser escrito completo a toda hora graças ao comando using que será detalhado a seguir. Using Esse é outro elemento básico da sintaxe do C# ele serve para que todos os tipos definidos em um namespace fiquem disponíveis sem escrever o seu nome completo. Abaixo um exemplo: Temos 3 classes Poodle,PastorAlemao e Canil, as duas primeiras estão no namespace “Animais” e a última está no namespace “Lugares”, precisamos declarar um objeto Poodle e um PastorAlemão na classe Canil, abaixo o código sem a utilização de using: namespace Lugares { public class Canil { Animais.Poodle Cachorro1; Animais.PastorAlemao Cachorro2; public Canil(Animais.Poodle Cachorro1,Animais.PastorAlemao Cachorro2) { this.Cachorro1 = Cachorro1; this.Cachorro2 = Cachorro2; } } } Agora com a utilização do using: using System; using System.Collections.Generic; using System.Linq;
- 22. 19 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# using System.Text; using Animais; namespace Lugares { public class Canil { Poodle Cachorro1; PastorAlemao Cachorro2; public Canil(Poodle Cachorro1, PastorAlemao Cachorro2) { this.Cachorro1 = Cachorro1; this.Cachorro2 = Cachorro2; } } } Observe os outros namespaces antes de Animais, são onde estão os tipos fundamentais do framework e por padrão são adicionados ao criar uma classe. Tipos de dados básicos C# é uma linguagem fortemente tipada. Cada variável e constante tem um tipo explícito. Cada assinatura do método Especifica um tipo para cada parâmetro de entrada e o valor de retorno. A.NET Framework class library define um conjunto de tipos numéricos internos, como também os tipos mais complexos que representam uma ampla variedade de construções lógicas, como, por exemplo, sistema de arquivos, conexões de rede, coleções e matrizes de objetos e as datas. Um programa C# típico usa tipos da biblioteca de classes bem como tipos definidos pelo usuário que modelam os conceitos que são específicos para o domínio do problema do programa. As informações armazenadas em um tipo podem incluir o seguinte: O espaço de armazenamento que necessita de uma variável do tipo. Os valores máximo e mínimo que ele pode representar. Os membros (métodos, campos, eventos e assim por diante) que ele contém. O tipo base que ela herda. O local de memória onde as variáveis serão alocadas em tempo de execução. Os tipos de operações que são permitidos. O compilador usa informações do tipo para verificar se todas as operações que são executadas em seu código são seguras. Por exemplo, se você declarar uma variável do tipo int, o compilador permite usar a variável em operações de soma e subtração. Se você tentar executar essas mesmas operações em uma variável do tipo bool, o compilador gera um erro. Abaixo exemplo de código que geraria um erro no compilador static void Main(string[] args) { int a = 5; int b = a + 2; //OK bool test = true; // Error. Operator '+' cannot be applied to operands of type 'int' and 'bool'. int c = a + test; } O operador + não pode ser aplicado entre um int e um bool;
- 23. 20 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Especificações dos principais tipos em C#. Tipos inteiros Tipo Abrangência Tamanho em bits sbyte -128 to 127 8 byte 0 to 255 8 char U+0000 to U+ffff 16 short -32,768 to 32,767 16 ushort 0 to 65,535 16 int -2,147,483,648 to 2,147,483,647 32 uint 0 to 4,294,967,295 32 -9,223,372,036,854,775,808 to long 64 9,223,372,036,854,775,807 ulong 0 to 18,446,744,073,709,551,615 64 Tipos de ponto flutuante e decimal Tamanho Abrangência Tipo Precisão em bits float ±1.5e−45 to ±3.4e38 7 dígitos 32 double ±5.0e−324 to ±1.7e308 15-16dígitos 64 28 28 0 to 28 decimal (-7.9 x 10 to 7.9 x 10 ) / (10 ) 28-29 dígitos significantes 128 Outros tipos de dados importantes Tipo Descrição string Representa uma cadeia de caracteres DateTime Representa um espaço de tempo e contém uma série de funções para lidar com datas Tipos de valor e de referência Os tipos de valor são aqueles tipos que a variável fica diretamente ligada ao valor atribuído a mesma, e quando passado como parâmetro para alguma função na verdade é copiado para o escopo da função, o que faz que alterações feitas nos valores dentro dela não reflitam no valor original da variável, a menos que ela seja atribuída novamente no escopo em que foi declarada. Já com tipo de referência o que ocorre é que a variável esta relacionada a um ponteiro para o espaço de memória onde o valor da mesma está armazenado, então quando ela é passada como parâmetro para uma função a referência é passada e as alterações de valores são feitas diretamente no espaço de memória que guarda o valor da variável alterando assim o valor da mesma no escopo original, porém isso só ocorre quando a palavra reservada “ref” é colocada na assinatura da função. Abaixo um exemplo para ficar mais fácil entender o que isso representa. class Program { static void Main(string[] args) { string a = "5";
- 24. 21 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# string b = "2"; String a2="5"; String b2 = "2"; Console.WriteLine("TIPOS DE VALOR...rnrn"); Console.WriteLine(string.Format("Valores de a e b no escopo que foram definidos a:{0} b:{1}rn",a,b)); Swap(ref a,ref b); Console.WriteLine(string.Format("Valores de a e b no escopo que foram definidos continuam os mesmos a:{0} b:{1}rn",a2,b2)); Console.WriteLine("TIPOS DE REFERÊNCIA...rnrn"); Console.WriteLine(string.Format("Valores de a e b no escopo que foram definidos a:{0} b:{1}rn",a2,b2)); Swap(ref a2,ref b2); Console.WriteLine(string.Format("Valores de a e b no escopo que foram definidos mudam a:{0} b:{1}rn",a2,b2)); Console.ReadKey(); } public static void Swap(ref String a,ref String b) { string c; c = a; a = b; b = c; Console.WriteLine(string.Format("Valores de a e b no escopo da função a:{0} b:{1}rn",a,b)); } } Escrevam esse código em um projeto do tipo Console Application do Visual Studio e percebam que os valores de a e b foram alterados dentro da função, mas na classe main permaneceram os mesmos, já de a2 e b2 tiveram os seus valores alterados também no escopo principal. Dos tipos apresentados nas tabelas acima apenas DateTime é de referência os demais são de valor, porém todos os tipos citados tem um correspondente de referência que fazem parte do .net Framework. Variáveis Variáveis são simplesmente locais de armazenamento de dados. Você pode armazenar e recuperar os dados através de um nome atribuído à variável. Quando criamos uma variável precisamos dizer o tipo de dado a ser armazenado na mesma e atribuir-lhe um nome, a sintaxe para isso em C# é a seguinte: [Tipos] [Nome Da Variável]; Exemplo: int Numero; As variáveis assim como as funções só podem ser definidas dentro de uma classe. Operadores Em C #, um operador é um elemento do programa que é aplicada a um ou mais operações em uma expressão ou declaração. Operadores que levam um operando, como o operador de incremento (+ +), são referidos como operadores unários. Operadores que usam dois operandos, como operadores aritméticos (+,-,*,/), são referidos como operadores binários. O operador condicional (?:), leva três operandos e é o único operador ternário em C #. Um operando pode ser uma expressão válida de qualquer tamanho, e pode ser composto por qualquer numero de outras expressões. Em uma expressão que contenha múltiplos operadores, a ordem na qual os operadores serão aplicados é determinada pela ordem de precedência do operador, associatividade e posicionamento de parênteses.
- 25. 22 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Cada operador tem uma precedência definida. Em uma expressão que contenham múltiplos operadores com ordem de precedência diferentes, a precedência dos operadores determina a ordem que os operadores serão executados. Por exemplo, a expressão seguinte atribui o valor 3 para n1. n1 = 11 - 2 * 4; A multiplicação é executada primeiro, pois tem precedência sobre a subtração. As tabelas a seguir separam os operadores em categorias baseadas no tipo de operações que realizam. As categorias estão listadas em ordem de precedência. Operações primárias Expressão Descrição x.y Acesso de associado f(x) Invocação de métodos e delegates a[x] Array and indexer access x++ Pós-incremento x-- Pós-decremento new T(...) Criação de objetos e delegates new T(...){...} Criação de objeto com inicializador. new {...} Inicializador de objeto anônimo. new T[...] Criação de array typeof(T) Obtém o Sytem.Type para T checked(x) Executa a expressão em um contexto checado unchecked(x) Executa a expressão em um contexto não checado default (T) Obtém o valor default para T delegate {} Função anônima(Método anônimo) Operadores unários Expressão Descrição +x Identidade -x Negação !x Negação lógica ~x Negação bit à bit ++x Pré-Incremento --x Pré-decremento (T)x Conversão explicita para o tipo T Operadores multiplicativos Expressão Descrição * Multiplicação / Divisão % Resto Operadores Aditivos Expressão Descrição x+y Adição, concatenação de string, combinação de delegate. x-y Subtração remoção de delegate. Operadores de troca
- 26. 23 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Expressão Descrição x << y Troca à direita x >> y Troca à esquerda Operadores relacionais e de tipo Expressão Descrição x<y Menor x>y Maior x <= y Menor ou igual x >= y Maior ou igual x is T Retorna se x é do tipo T. x as T Retorna x “tipado” como T ou nulo se não for possível. Operadores de igualdade Expressão Descrição x == y Igual x != y Diferente Operadores lógicos,condicionais e para tratamento de valores nulos Categoria Expressão Descrição Logical AND x&y AND bit à bit inteiro, AND lógico booleano Logical XOR x^y XOR bit à bit inteiro, XOR lógico booleano Logical OR x|y OR bit à bit inteiro, OR lógico booleano Conditional AND x && y Retorna verdadeiro para x e y verdadeiros. Conditional OR x || y Verdadeiro se x ou y verdadeiros. Null coalescing x ?? y Retorna y se x for nulo, caso contrário x Conditional x ?: y : z Retorna y para x verdadeiro, caso contrário z Operadores de atribuição e anônimos Expressão Descrição = Atribuição x op= y Compound assignment. Supports these operators: +=, -=, *=, /=, %=, &=, |=, !=, <<=, >>= (T x) => y Função anônima (lambda expression.) Alguns exemplos com operadores //Operador de negacao(-) inverte o sinal do número int Identidade = 1; Console.WriteLine(-Identidade); //Saída "-1" Identidade = -1; Console.WriteLine(-Identidade); //Saída "1" int Negacao = 1; //Operador de pré-incremento(++) int PreIncremento = 1; PreIncremento = ++PreIncremento; Console.WriteLine(PreIncremento);
- 27. 24 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# //Saída "2" //Operador pós-incremento int PosIncremento = 1; PosIncremento = PosIncremento++; Console.WriteLine(PosIncremento); //Saída "1", pois primeiro ele atribui o valor a variável e depois incrementa o valor. bool NegacaoLogica = true; Console.WriteLine(!NegacaoLogica); //Saída "false" NegacaoLogica = false; Console.WriteLine(!NegacaoLogica); //Saída "true", pois negar uma negação a torna em uma afirmação. //Algumas operações aritmética int n1=4, n2 = 2; Console.WriteLine(n1 + n2); //Saída "6", 4+2 Console.WriteLine(n1 * n2); //Saída "8", 4*2 Console.WriteLine(n1 / n2); //Saída "2", 4/2 Console.WriteLine(n1 - n2); //Saída "2", 4-2 Console.ReadKey(); Desvios condicionais A instrução ”if” é usada para realizar desvios condicionais no C#. Com ele o fluxo de execução pode ser alterado de acordo com o retorno de expressões booleanas, a sintaxe do comando é a seguinte: if( [Expressão booleana]){ Trecho de código... } Você pode definir o segmento “else” para um “if” que serve como fluxo alternativo caso a condição testada seja falsa. if( [Expressão booleana]){ Trecho de código... }else{ Trecho de código... } Você pode ainda testar várias condições em uma mesma instrução “if” adicionando segmentos “else if”, a execução passará na primeira e somente na primeira condição verdadeira do “if” se houver. if( [Expressão booleana]){ Trecho de código... }else if([Expressão booleana]){
- 28. 25 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Trecho de código... } Exemplos utilizando “if”: bool Validado = true; //Quando se tratar de um booleano não precisa fazer comparação porque ele mesmo já é um valor booleano if (Validado) { Console.WriteLine("Ok!"); } string strRetorno = "Sucesso"; //Outros tipos de dados precisam de uma expressão booleano escrita. //Obs: O == é um operador de comparação, que retorna true caso os valores sejam iguais caso contrário false if (strRetorno == "Sucesso") { Console.WriteLine("Missão comprida"); } else { Console.WriteLine("Tente novamente"); } //Aqui temos um if sem delimitadores "{}", essa sintaxe pode ser utilizada quando formos executar apenas uma instrução. //Obs: o != é o inverso do == e retorna true para valores diferente caso contrário false. if (strRetorno != "Sucesso") Console.WriteLine("Tente novamente"); else Console.WriteLine("Sucesso"); DateTime Dt = DateTime.Now; if (Dt.Hour < 8) Console.WriteLine("Está muito cedo...."); else if (Dt.Hour == 8) Console.WriteLine("Em cima da hora...."); else Console.WriteLine("Atrasado!"); Switch O comando switch serve para definirmos ações a serem executadas dependendo do valor de uma variável ou de uma expressão, é muito utilizado com enumerações e quando temos um rol de valores conhecidos que a variável ou a expressão pode assumir. A sintaxe básica para o switch é a seguinte switch([Nome da variável]){ case [possível valor 1] [Ações a serem executadas]; break;//Termina a execução da instrução switch .... case[Possível valor n] [Ações a serem executadas]; break;//Termina a execução da instrução switch
- 29. 26 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# default://Opcional [Ação padrão para caso o valor não esteja definido em nenhum dos Cases]; break; } int caseSwitch = 1; switch (caseSwitch) { case 1: Console.WriteLine("Case 1"); break; case 2: Console.WriteLine("Case 2"); break; default: Console.WriteLine("Default case"); break; } int switchExpression = 3; switch (switchExpression) { // Uma seção de instruções podem ser iniciadas por mais de um valor no caso 0 e 1 case 0: case 1: Console.WriteLine("Case 0 or 1"); // para cada case é necessário um break, um return ou um goto. break; case 2: Console.WriteLine("Case 2"); break; // O código da linha abaixo causa um alerta na compilação, pois nunca será executada pelo fato de estar depois do break; Console.WriteLine("Código irrelevante"); // 7 - 4 abaixo o case está em função de um expressão matemática “7-4” então quando o valor da variável for 3 essa condição será satisfeita. case 7 - 4: Console.WriteLine("Case 3"); break; // Se o valor da váriavel não estiver entre 0, 1, 2, or 3, o código definido no rótulo default será executado. default: Console.WriteLine("Default case (Opcional)"); break; } Estruturas de repetição Estruturas de repetição são instruções que de acordo com uma condição, executam uma sequência de ações repetidas um determinado número de vezes. Estruturas de repetição também são conhecidas como loops. As principais instruções para execução de Loop são: “while”,”do”,”for” e “foreach”, vamos analisar cada uma separadamente. WHILE Um loop while verifica uma condição e em seguida executa um bloco de código enquanto a condição avaliada for verdadeira. A sua sintaxe é a seguinte: while ([Expressão booleana]) { [Conjunto de instruções]
- 30. 27 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# } Ao terminar a execução das instruções dentro do bloco definido para o while a expressão booleana é verificada novamente e caso seja verdadeira o conjunto de instruções é executado novamente esse ciclo se repete até que o valor da expressão avaliada no segmento while seja falsa. No while se na primeira verificação o valor avaliado for falso o bloco de código não é executado nem uma vez. Exemplo: //Declaração de uma variável int i = 0; //Segmento while, nesse caso verifica se o valor da váriavel i é menor que 10. //O bloco de código será executado enquanto essa expressão for verdadeira while (i<10) { //Conjunto de instruções a serem executadas //Escreve o valor de i no console Console.WriteLine(1); //Soma 1 ao valor de i a cada execução do bloco de código. i++; } //Espera que uma tecla seja digitada para encerrar a execução do programa. Console.ReadKey(); DO O loop “do” se comporta como o loop “while”, porém é garantido que o bloco de código seja executado ao menos uma vez, pois a expressão booleana é avaliada depois da execução do bloco de código. A sintaxe é a seguinte: do{ [Conjunto de instruções] }while([Expressão booleana]); Exemplo: //Declaração de uma variável int i = 0; do { //Conjunto de instruções a serem executadas. //A diferença é que mesmo que neste ponto o valor de i seja maior que 10 //Esse bloco de código será executado ao menos 1 vez. //Escreve o valor de i no console Console.WriteLine(1); //Soma 1 ao valor de i a cada execução do bloco de código. i++; } while (i < 10);//Segmento while, nesse caso verifica se o valor da váriavel i é menor que 10. //O bloco de código será executado enquanto essa expressão for verdadeira //Espera que uma tecla seja digitada para encerrar a execução do programa. Console.ReadKey();
- 31. 28 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# FOR O Loop for também executa um bloco de código em função de uma expressão booleana, com a diferença de possuir em sua sintaxe a possibilidade de incluir um inicializador e um modificador para uma variável que existirá somente em seu escopo. Essa instrução é largamente utilizada para varrer listas, pois sua sintaxe garante uma semântica melhor em relação ao while quando é necessário ter um contador das iterações ocorridas no loop. Sintaxe: for([Inicializador de variável];[Expressão booleana];[Modificador da variável]){ [Conjunto de instruções] } Exemplos: //Declarando um array de inteiros, e já inicializando com valores. int[] valores = new int[]{1,2,3,4,5,6,7,8,9,10}; /*No segmento for esta sendo feita inicialização de uma váriavel i que será incrementada com mais 1 a cada iteração ocorrida, enquanto o valor da váriavel seja menor que o tamanho da colação de inteiros obtida através da propriedade length do valor. é importante lembrar que o ultimo índice da lista é sempre o tamanho da mesma menos 1, pois a primeira posição é 0 e não 1.*/ for (int i = 0; i < valores.Length; i++) { //Escreve o valor que está na posição "i" da lista a cada iteração sendo que o "i" vai sendo incrementado a cada iteração. //Todos os valores da lista serão escritos na tela em ordem crescente. Console.WriteLine(valores[i]); } Console.WriteLine("Ordem decrescente"); /*Podemos também escreve-los de forma decrescente. Fazendo algumas alterações no nosso segmento for. - Iniciando a váriavel i com a ultima posição do array em vez da primeira "0", a melhor formam de fazer isso é atribuindo o valor da propriedade length -1 ao seu valor. - Invertendo o sinal da expressão booleana de < para >= e substituindo a propriedade length pela constante 0. - Por fim substituindo o operador unário de incremento(++) para o de decremento(--). */ for (int i = valores.Length-1; i >=0; i--) { //Escreve o valor que está na posição "i" da lista a cada iteração sendo que o "i" vai sendo decrementado a cada iteração. //Todos os valores da lista serão escritos na tela em ordem decrescente. Console.WriteLine(valores[i]); } //Espera que uma tecla seja digitada para encerrar a execução do programa. Console.ReadKey(); FOREACH Este é um tipo de loop específico da linguagem C# que veio como uma forma de varrer coleções mais eficientemente. Com foreach não é necessário verificar se o número de iterações é menor que o número de item em uma coleção e nem acessar o item da coleção através do índice em função da variável do for, pois no foreach ocorre uma iteração para cada item da lista e uma
- 32. 29 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# variável assume o valor deste item, qualquer objeto que herde da interface IEnumerable pode ser utilizado como fonte de dados em um foreach. Listas serão exploradas com mais profundidade neste capítulo. foreach ([Declaração da variável] in [Coleção a ser varrida]){ [Conjunto de instruções] } Exemplo: //Declarando um array de inteiros, e já inicializando com valores. int[] valores = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; /*Agora faremos a mesma coisa que nos dois exemplos utilizando for, ou seja mostraremos os valores do array * em ordem crescente e decrescente só que utilizando o foreach.*/ /*No segmento foreach temos a declaração de uma váriavel que assumira o valor de um item da lista de cada vez * Reparem que o tipo da váriavel devem representar o tipo que a lista reúne no caso int. Depois a palavra reservada in * que deve ser sucedida pela lista a ser varrida. */ foreach (int item in valores) { Console.WriteLine(item); } /*Agora em ordem decrescente Basta utilizar o método reverse disponível para qualquer tipo de array, que a ordem dos valores na lista será invertida completamente. Como os valores estão organizados em forma crescente nesse exemplo, ao inverter serão apresentados de forma decrescente. */ foreach (int item in valores.Reverse()) { Console.WriteLine(item); } //Espera que uma tecla seja digitada para encerrar a execução do programa. Console.ReadKey(); BREAK O comando break pode ser utilizado dentro do bloco de código de qualquer Loop apresentado anteriormente e causa uma interrupção imediata das iterações. Pode ser utilizado para quando estamos procurando a primeira ocorrência de um valor específico, abaixo um exemplo. //Declarando um array de inteiros, e já inicializando com valores. int[] valores = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; foreach (int item in valores) { if (item == 3) { Console.WriteLine(item); //Ao encontrar a primeira ocorrência do valor 3 o mesmo será escrito na tela e a execução do Loop será interrompida. break;
- 33. 30 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# } } Tratamento de erro O C# implementa uma funcionalidade do framework para tratamento de erros, que consiste na possibilidade de executar uma ação que trata um exceção gerada pelo programa, de modo que não ocorra uma interrupção na execução, esse tratamento é feito através da instrução “try”, cuja sintaxe básica é a seguinte: try{ [Conjunto de instruções que podem lançar uma exceção] }catch([Tipo de exceção] [Nome da variável](Opcional declaração da variável)){ [Conjunto de instrução que gerencia a exceção ocorrida] } Exemplo: int[] vals=new int[]{0,1,2,3,4,5,6,7,8,9}; try { /*Nesse caso ocorrerá um erro, pois iniciei o contador do for em 1 o que vai causar uma tentativa de acesso à uma posição que não existe na lista a posição 10 e apesar da lista ter 10 valores os índices vão de 0 a 9, isso provocará o lançamento de uma exceção no sistema. */ for (int i = 1; i < vals.Length+1; i++) { Console.WriteLine(vals[i]); } } //O Bloco catch escreverá a mensagem de erro retornada no console e evitará que a execução do programa seja interrompida. catch (Exception ex) { Console.WriteLine(ex.Message); } Console.ReadKey(); Arrays e Lists Muitas vezes no desenvolvimento de aplicações necessitamos de agrupar determinados tipos de dados em coleções, para efeitos de comparação, ordenação, dentre outros. Em C# é possível fazer esse agrupamento de duas formas. Através de Arrays e Lists, a diferença fundamental entre ambo é que o Array precisa ter o seu tamanho definido na sua inicialização, já as Lists podem crescer indefinidamente. As Lists também oferecem mais recursos para tratamento das coleções como consequência consumem mais processamento. As List foram implementadas sobre o conceito de tipos genéricos que serão detalhados posteriormente nesse capítulo, por hora vamos analisar a sintaxe, a utilização em um contexto e a interoperabilidade entre ambos. Arrays Um Array pode ser composto por várias dimensões, porém o mais comum é o unidimensional cuja sintaxe é a seguinte: “[tipo de dado]”[] “[Nome da variável]”;
- 34. 31 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Exemplo Array de inteiros: int[] Inteiros; Ou seja basta adicionar um par de colchetes ao lado do tipo da variável e este passa a representar uma lista unidimensional daquele mesmo tipo. Para declaração de um Array multidimensional basta colocar uma vírgula separando as dimensões, por exemplo, a declaração de um array bidimensional de inteiros ficaria assim: int[,] MatrizInteiros; O acesso aos itens dos vetores se dá através de índices, sendo cada índice a posição de uma unidade na matriz, a coleção de índices começa em 0 e termina no tamanho do vetor -1, o índice do último elemento de um vetor de tamanho n é igual a n-1. Existem algumas maneiras de se inicializar um vetor abaixo exemplos comentados. // Declaração e inicialização de um Array unidimensional de 5 posições. int[] array1 = new int[5]; // Declaração e inicialização de um Array unidimensional de 5 posições, // mas nesse caso o número de posições é definido pelo número de valores definido entre as chaves na sintaxe de inicialização. int[] array2 = new int[] { 1, 3, 5, 7, 9 }; // Sintaxe alternativa int[] array3 = { 1, 2, 3, 4, 5, 6 }; // Declaração e inicialização de um Array bidimensional, sem atribuição de valores. int[,] multiDimensionalArray1 = new int[2, 3]; // Declaração e inicialização de um Array bidimensional, com atribuição de valores. int[,] multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } }; Para acessar o elemento de valor 3 do array “array2” a sintaxe seria a seguinte: int Elemento = array2[1]; Para atribuir um novo valor a esta mesma posição a sintaxe seria a seguinte: int Elemento=20; array2[1]=Elemento; Para acessar o elemento de valor 5 do array multidimensional “multiDimensionalArray2” a sintaxe seria a seguinte: int elemento= multiDimensionalArray2[1,1]; Para atribuir um novo valor a esta mesma posição a sintaxe seria a seguinte: int Elemento=20; array2[1,1]=Elemento; Lists Os Lists são listas genéricas unidimensionais que assumem um determinado tipo. Não precisam ter seu tamanho especificado na inicialização. A List provê algumas funcionalidades a mais que o Array como o método Find, que serve para encontrar ocorrências de um determinado valor na lista. Para utilização do List o namespace System.Collections.Generic do assembly “mscorlib.dll” deve estar acessível. A sintaxe básica é a seguinte: List<[Tipo de dado]> [Nome da variável]; Exemplo List de inteiros:
- 35. 32 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# List<int> lst = new List<int>(); A inclusão de um elemento na lista pode ser feito através do método Add. Cuja sintaxe é a seguinte: int Elemento=10; lst.Add(Elemento); A sintaxe de acesso e atribuição de elementos é idêntica à de Arrays unidimensionais. Interoperabilidade Uma lista pode ser transformada em um Array através do método “ToArray()”, exemplo abaixo: int[] Myarray; List<int> MyList = new List<int>(); Myarray = MyList.ToArray(); Um Array pode ser transformado em List através do método “ToList()”,exemplo abaixo: List<int> MyList; int[] Myarray=new int[10]; MyList = Myarray.ToList(); Todos os itens de um Array podem ser inserido em uma lista através do método AddRange([Fonte de dados enumerável]) da classe List, Exemplo abaixo: List<int> MyList=new List<int>(); int[] Myarray=new int[10]; MyList.AddRange(Myarray); Tabela com os principais métodos comuns à Arrays e Lists. Nome do método Descrição Reverse() Inverte a ordem dos elementos na lista. First() Retorna o primeiro elemento da lista. OrderBy(Predicate) Ordena os valores da lista de acordo com o valor passado com parâmetro. Max() Retorna o elemento de valor máximo pela ordem de precedência. Min() Retorna o elemento de valor mínimo pela ordem de precedência. Windows Forms Windows Forms é um conjunto de bibliotecas que fornecem funcionalidades para desenvolvimento de aplicações desktop que utilizem interações através de janelas no padrão Windows. As principais funcionalidades estão na biblioteca System.WindowsForms.dll. Nesse tópico iremos abordar os principais componentes do Windows forms. Eventos A orientação a eventos é um dos paradigmas da linguagem C#, isso quer dizer que os componentes executam as suas ações através de eventos. Por exemplo, um componente do tipo botão tem o evento Click, esse evento será relacionado com um ou mais métodos e quando o mesmo ocorrer as instruções contidas nesses métodos serão executadas.
- 36. 33 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Guia rápido hello World em Windows forms Vamos fazer passo a passo a criação de um aplicativo Windows forms simples. O famoso Hello World. Abra o Microsoft Visual Studio 2010. Vá até o menu:File->New->Project. A janela abaixo aparecerá: Escolha a categoria Windows e dentro dela escolha Windows Forms Application. Seleciona o nome do projeto na caixa de texto rotulada “Name”. Clique em Ok. O form principal do projeto aparecerá. Abra a toolbox e arraste um controle do tipo Button para o form. Clique no controle que acabou de adicionar com o botão direito e escolha a opção “Properties”. Na janela que aparecerá selecione o item “text” e mude o valor de “button1” para “Saudar”, conforme imagem abaixo: Agora clique na imagem de um raio no topo da janela properties.
- 37. 34 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Uma lista dos eventos existente para o botão será exibida, dê um duplo clique no evento “Click”. Você será redirecionado ao arquivo de código onde já terá um método criado e relacionado ao evento “Click”, coloque o trecho de código a seguir entre as chaves do método. //Aqui temos uma chamado ao método show da classe MessageBox , este método exibe uma caixa de dialogo com o texto passado como parâmetro à ele. MessageBox.Show("Hello World"); Agora basta apertar F5 para rodar o aplicativo. Clique no botão do formulário para visualizar a caixa de dialogo. Principais componentes Form O form é o elemento fundamental das aplicações Windows forms e pode hospedar uma série de outros controles. O form pode receber as interações do usuário através do mouse ou através do teclado, e também apresentar dados através dos controles hospedados. Aplicações mais complexas podem necessitar de uma série de forms para cumprir seu objetivo. Sempre que você criar um projeto do tipo Windows forms um form com o nome form1.cs é adicionado, você pode mudar o nome clicando sobre ele e apertando a tecla F2, se tudo correr bem todas as referências para o mesmo também serão alteradas. Você pode adicionar outros forms ao seu projeto clicando sobre ele com o botão direito, escolhendo a opção new->item no menu contextual. A janela abaixo aparecerá:
- 38. 35 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Selecione o item Windows Form, mude o nome na caixa de texto abaixo da lista conforme desejado. E clique no botão “Add”.
- 39. 36 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# O formulário pode ser customizado através de suas propriedades para altera-las acesse a janela “properties”, abaixo uma tabela com as mais importantes e suas respectivas descrições: Propriedade Descrição (Name) O nome do objeto form. Backcolor Cor de fundo do formulário. BackgroundImage Indica uma imagem para o plano de fundo do formulário. Determina como a imagem defina na propriedade BackGroundImage será apresentada. BackgroundImage1Layout ControlBox Determina quando o form tem um ControBox. Cursor Aparência do cursor do mouse quando estiver sobre o form. Enabled Determina se o form está habilitado, se estiver falso todos os controle hospedados também ficarão desabilitados Font Atribui a font padrão para textos do form. ForeColor Determina uma cor de primeiro plano padrão, será utilizada para todos controle caso não seja atribuída separadamente. FormBorderStyle Indica a aparência e o comportamento das bordas do form. HelpButton Indica quando o Form tem um botão de ajuda. Icon Indica o ícone a ser apresentado no topo do form. Location Determina o posicionamento do form na tela quando a propriedade StarPosition está com o valor “Manual”. MaximizeBox Indica se o form tem a opção de maximizar. MaximumSize Determina o tamanho máximo que o form pode assumir. MinimizeBox Indica se o form tem a opção de minimizar. MinimumSize Determina o tamanho mínimo que o form pode assumir. Opacity Representa o nível de transparência do formulário, quando maior mais transparente. Size Atribui e recupera o tamanho inicial do form StartPosition Posição do Form na sua primeira aparição. Text Determina o texto que aparece no topo do forn. TopMost Determina se o formulário aparece na frente de todas as outras aplicações. Visible Determina se o formulário esta visível. Windowstate Determina o estado inicial do formulário: Maximizado, Minimizado, etc. Alterando o formulário inicial de um projeto Esse é o primeiro form aberto ao executarmos um projeto, para alterar qual será esse formulário é necessário abrir o arquivo program.cs e mudar a instância de form passada para o método Run([Instância form]) da classe application . Se o form criado junto com o projeto não tiver sido renomeado estará assim:
- 40. 37 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Application.Run(new Form1()); Caso contrário no lugar de Form1 estará o nome atual do Form que foi criado junto com o projeto. Altere para o nome do formulário que deseja que seja inicializado. Prática; Crie 2 formulários. Os requisitos do primeiro são: 1. O título deve ser “formulário 1”. 2. O formulário deve abrir maximizado. 3. O formulário não pode ser minimizado. 4. O formulário deve ser parcialmente transparente. 5. O formulário deve aparecer acima de todas as outras telas abertas. 6. O formulário deve abrir junto canto superior direito da tela. Os requisitos do segundo são: 1. O título deve ser “formulário 2” 2. O formulário deve abrir no centro da tela. 3. A cor de fundo do formulário deve ser vermelha. 4. O Formulário deve apesentar um ícone ao lado do texto. 5. O formulário não pode ser redimensionado. 6. O Formulário não pode ser minimizado. Controles containers Os controles do tipo contêineres foram concebidos para reunir uma série de outros controles. Com eles é possível criar subdivisões lógicas e físicas no form que agrupam outros controles. Por exemplo, você pode colocar uma série de opções correlatas dentro de um groupbox onde somente uma pode ser escolhida. Quando um controle do tipo container hospeda outros controles, algumas propriedades do mesmo podem impactar em todos os seus filhos, por exemplo, se a propriedade Enable for atribuída como false todos os controles dentro do contêiner também ficarão desabilitados, assim como se a propriedade Visible for falsa, todos os itens também ficarão invisíveis. Para adicionar controles a um container basta arrasta-los da ToolBox para o mesmo. Existem propriedades de layout dos itens que tem relação com seu container. Por exemplo, a propriedade “Anchor” presente em todos os controles Windows Forms. Essa propriedade determina quais distâncias entre as extremidades do controle item e seu container serão mantidas quando o container for redimensionado. Observe as imagens abaixo para que esse conceito fique mais claro. Temos um botão dentro de um groupbox na imagem abaixo.
- 41. 38 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Quando a propriedade Anchor está atribuída da seguinte maneira: O botão manterá o seu posicionamento em relação ao seu canto superior direto. Então vamos observar o que acontece quando redimensionamos o groupbox: O botão mantém a mesma distância entre o seu canto superior esquerdo e o canto superior esquerdo do container. Agora vamos mudar a propriedade “Anchor” do botão conforma imagem abaixo: Ao redimensionarmos o grupo será mantida a distância entre o canto inferior direito do botão e o canto inferior direito do container. Observe na imagem abaixo: Execute esses mesmos passos no seu Visual Studio 2010 para ver tudo acontecendo, lembrando que o posicionamento do botão não foi alterado manualmente em nenhum momento. A propriedade “Dock” também está fortemente relacionada com o container pai do controle. Através dela você pode manter um controle fixado em uma das extremidades do container ou ainda preenchendo todo o espaço do mesmo. Exemplo: Abaixo temos um label fixado no topo do container.
- 42. 39 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Sendo assim o mesmo acompanhará qualquer redimensionamento ocorrido no container para que continue preenchendo toda sua parte superior, observe na imagem abaixo: Temos os seguintes containers disponíveis em Windows forms: GroupBox Panel FlowLayoutPanel TableLayoutPanel TabControl SplitContainer Vamos analisar cada um separadamente: GroupBox O GroupBox é um controle container que aparece no form com um título e rodeado por uma linha. Ele não prove barras de rolagens diferindo do controle Panel. O uso mais comum do GroupBox é para hospedar RadioButons que representam opções exclusivas. Por exemplo, um GroupBox com título “Sexo”, hospedando dois rádio buttons com os rótulos “Masculino” e “Feminino”. Tabela com as principais propriedades do GruopBox: Propriedade Descrição Text Representa o título do GroupBox Panel O Panel cria uma subseção do form e pode hospedar outros controles. O mesmo pode ser visualmente indistinguível do resto do form, embora possa ser configurado para apresentar bordas ao seu redor. O Panel dá suporte a barras de rolagem e estando a propriedade AutoScroll com o valor “true” as mesmas apareceram de acordo com a necessidade.
- 43. 40 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Tabela com as principais propriedades do controle Panel. Propriedade Descrição AutoScroll Indica se barras de rolagem apareceram automaticamente caso algum controle contido no Panel estiver ultrapassando seus limites. BorderStyle Define se o Panel será circundado por bordas e qual será o estilo das mesmas. FlowLayoutPanel O FlowLayoutPanel é uma especificação do controle Panel e assim como ele serve para criação de uma subseção no formulário, porém a principal diferença entre eles é que o FlowLayoutPanel reposiciona e redimensiona automaticamente os controles adicionados em seus itens durante o design e a execução, dessa forma ajusta-os em um fluxo continuo. Para que as barras de rolagem apareçam automaticamente a propriedade “AutorScroll” também deve ter o valor “true”. Por padrão a direção do fluxo do FlowLayoutPanel é da direita para a esquerda e do topo para a base, mas isso pode ser alterado através da propriedade “FlowDirection”. Uma nova linha é criada sempre que o limite horizontal é atingido isso se a propriedade “WrapContent” estiver com o valor verdadeiro, porém você pode fazer as quebras de linha manualmente setando esta mesma propriedade para falso e utilizando o método “SetFlowBreak” que recebe como parâmetro o controle filho em que a quebra de linha acontece por exemplo: flowLayoutPanel1.SetFlowBreak(btn, true); Sendo flowLayoutPanel1 o nome do nosso FlowLayoutPanel e btn o nome de um botão hospedado por ele. Tabela dos métodos e propriedades principais do FlowLayoutPanel: Propriedade Descrição AutoScroll Indica se barras de rolagem apareceram automaticamente caso algum controle contido no Panel estiver ultrapassando seus limites. BorderStyle Define se o Panel será circundado por bordas e qual será o estilo das mesmas. FlowDirection Define a ordem do fluxo dos componentes dentro do Panel WrapContents Indica se as quebras de linha acontecem automaticamente quando os componentes ultrapassam as extremidades do Panel SetFlowBrake Método, Seta manualmente em qual componente acontece a quebra de linha. GetFlowBrake Método, Retorna se o componente tem uma quebra de linha atribuída a ele. TableLayoutPanel Como o FlowLayoutPanel o TableLayoutPanel é uma especialização da classe Panel . O TableLayoutPanel é essencialmente uma tabela que provê células que hospedam controles individualmente. Como os outros Panels possui suporte a barras de rolagem automaticamente quando a propriedade “AutoScroll” está com valor verdadeiro. Durante o Design basta você arrastar os controles para as células para inclui-los na tabela. Somente um controle é permitido por célula, porém para designs mais complexo você pode colocar um container na mesma e dentro do dele incluir outros elementos. Você pode editar as linhas e as colunas da tabela através das propriedades “Rows” e “Columns” respectivamente. A tabela abaixo demonstra as principais propriedades de um TableLayoutPanel Propriedade Descrição AutoScroll Indica se barras de rolagem apareceram automaticamente caso algum controle contido no Panel estiver ultrapassando seus limites. CellBordeStyle Define se as células serão circundadas por bordas e qual será o estilo das mesmas. Column Count Define a quantidade colunas na tabela Columns Apresenta uma coleção editável das colunas da tabela, onde
- 44. 41 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# podemos configurar o tamanho das mesmas em valor absoluto e percentagem por exemplo. ColumnStyles Representa uma coleção de estilos das colunas da tabela. Disponível somente em Runtime. GrowStyle Determina como acontece o crescimento da tabela à medida que novos controles são adicionados, os possíveis valores são: AddColumns, AddRows, or FixedSize RowCount Define a quantidade de linhas da tabela Rows Apresenta uma coleção editável das linhas da tabela, onde podemos configurar o tamanho das mesmas em valor absoluto e percentagem por exemplo. RowStyles Representa uma coleção de estilos das linhas da tabela. Disponível somente em Runtime. TabControl O TabControl permite que você agrupe controles em abas, o TabControl funciona com um container de tabPages, sendo que cada uma dela pode ter seus próprio controle filhos. O usuário navega entre as páginas clicando nas abas rotuladas do TabControl. A propriedade mais importante do TabControl é a TabPages. Cada TabPages tem sua própria gama de propriedades você pode acessa-las assim como em qualquer outro controle selecionando-as e acessando a janela properties. Para gerenciar as TabPages de um TabControl basta acessar a propriedade TabPages que o gerenciador abaixo será aberto: Nele você pode adicionar ou remover TabPages assim como ordena-los e alterar suas propriedades sendo que as principais delas são Text que representa o título da aba, AutoScroll que funciona da mesma forma que nos Panels e BorderStyle que indica se terá uma borda circundando e qual o estilo da mesma.
- 45. 42 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Tabela com as principais propriedade de um TabControl. Propriedade Descrição Appereance Propriedade do TabControl; Determina o estilo visual do TabControl. Alignment Determina se as abas aparecerão em cima, em baixo, à direito ou à esquerda do TabControl. Multline Propriedade do TabControl; Indica se mais uma linha de abas pode existir na TabControl. TabPages Propriedade do TabControl; Coleção das TabPages, você pode edita-las nessa propriedade. AutoScroll Propriedade da TablePage; Indica quando as barras de rolagem aparecem automaticamente de acordo com a necessidade. BorderStyle Propriedade da TablePage; Determina se a aba será circundada por borda e qual será o estilo da mesma. Text Propriedade da TablePage; Representa o título da aba. SplitContainer O SplitContainer cria uma subseção do form onde há dois Panel separados por um divisor que pode ser movido em tempo de execução pelo usuário. Quando o tamanho de um Panel diminui o outro aumenta para preencher o espaço. O uso mais comum desse componente é na criação de Windows forms divididos. O SplitContainer expões as propriedade do Panel1 e Panel2, individualmente ambos são iguais à um Panel normal, porém o SplitContainer tem suas propriedades específicas. A orientação de um SplitContainer pode ser horizontal e vertical para alterar isso utilize a propriedade orientation. Abaixo uma tabela com as principais propriedades do SplitContainer Propriedade Descrição BorderStyle Determina se o SplitterContainer será circundada por borda e se sim, qual será o estilo da mesma. Fixed Panel Essa propriedade indica qual Panel do SplitContainer será fixado no tamanho essa propriedade assume os valores Panel1, Panel2 e none. IsSplitterFixed Determina se a posição do divisor poderá ser reajustada pelo usuário em tempo de execução. Orientation Determina se o divisor se movimentará horizontalmente ou verticalmente. Panel1 Expões as propriedades do primeiro Painel do SplitContainer Panel2Collapsed Retorna se o segundo painel do SplitContainer está recolhido. Panel2MinSize Determina o tamanho mínimo que o segundo painel do SplitContainer pode assumir. SplitterDistance Representa a distancia do divisor em relação à extremidade esquerda ou da extremidade superior dependendo da orientação SplitterWidth Representa a largura do divisor. Visão geral dos controles em Windows Forms Controles são componentes que combinam interface gráfica com funcionalidade pré-estabelecidas. São unidade de código concebidas para atender uma grande gama de tarefas particulares. Por Exemplo, o controle TextBox tem por objetivo exibir texto e receber entrada de dados na forma texto do usuário, ele provê propriedades, métodos e eventos que facilitam essa tarefa. Todos os controles tem a classe base “Control” como ancestral comum a qual compartilha uma séria de propriedade em relação a tamanho, localização e outros aspectos gerais dos controles. A tabela abaixo demonstra as principais propriedades da classe Control, às quais são comuns a todos os controles Windows Forms. Propriedade Descrição Anchor Determina como o controle fica amarrado ao container que foi adicionado. BackColor Determina a cor de fundo do controle.
- 46. 43 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# BackgroundImage Determina uma imagem para servir com plano de fundo do controle. Indica quando o controle executa métodos de validações, esses métodos servem para verificar CausesValidation se a entrada de dados do usuário está de acordo com as regras de negócio. ContainsFocus Indica quando o foco esta no próprio controle ou um em dos seus filhos. Controls Retorna uma coleção dos controles filhos. Cursor Determina o aspecto do cursor quando o mouse passar sobre o controle. Determina se o controle está fixado em uma das extremidades do container pai ou preenchendo Dock o mesmo. Enabled Determina se o controle está habilitado e funcional. Font Determina a fonte que será utilizada para escrever eventuais textos do controle. ForeColor Determina a cor do primeiro plano do controle, borda, textos entre outros. HasChildren Determina se o controle possui controles filhos. Height Representa a altura do controle em pixels. Location Representa a localização do controle em relação ao container. MaximumSize Representa o tamanho máximo que o controle pode assumir. MinimumSize Representa o tamanho mínimo que o controle pode assumir. Atribui um nome ao controle para ser acessível via código, só pode ser atribuída durante o Name design. Parent Retorna o form pai ou o container que o controle está contido. Region Atribui ou retorna a região Windows associada com o controle. Size Representa o tamanho do controle em pixel. Representa a ordem de precedência do controle quando a tecla Tab for utilizada para navegar TabIndex controle a controle. Tag Serve para o programador associar algum dado ao controle para auxilia-lo na programação. Atribui ou retorna o texto associado com o controle, o texto pode ou não aparecer na Text representação visual do controle depende de como o mesmo foi definido. Atribui ou retorna a visibilidade do controle quando estiver como false o controle só aparece Visible durante o design estando invisível na execução. Width Atribui ou retorna a largura do controle em pixels. Button Um dos controles mais comuns é o Button, o controle essencial que provê interação de comando entre o usuário e a interface gráfica. O botão pode exibir um texto curto a fim de identifica-lo e responder a clicks efetuados pelo usuário. O botão assume um visual diferenciado quando é clicado e fornece um manipulador de evento para que o desenvolvedor escreva o código desejado. O controle Button expõe uma série de propriedade que permite que você customize a aparência e o comportamento do mesmo. A tabela abaixo demonstra as principais Propriedades de um botão. Propriedade Descrição AutoEllipsis Habilita a manipulação automática textos que excedam a largura do botão. DialogResult Atribui um DialogResult ao botão, exemplo: DialogResult.Ok, DialogResult.Cancel. FlatAppearance Determina como o botão parecerá quando a propriedade FlatStyle estiver com valor verdadeiro Quando o valor está verdadeiro o padrão deixa de acompanhar a aparência padrão do Windows FlatStyle e passa a respeitar o que desenvolvedor define no FlatAppearance Text Atribui o texto que aparece no botão. TextAlign Determina como o texto é apresentado no botão. Interceptando um clique: Para escrever o código que será executado quando o clique do botão ocorrer você pode clicar duas vezes sobre o botão durante o design e o código da janela abrirá com um método cujo nome é formado por: [nome do botão]_Click Basta escrever a implementação do método entre as chaves que delimitam seu escopo.
- 47. 44 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Outra maneira de fazer a mesma coisa é acessar a lista de eventos na aba properties, clicando no ícone de um pequeno raio e dando um duplo clique sobre o evento “click”, especificado na lista de eventos que aparecerá conforme imagem abaixo. Exemplo 1. Crie um novo projeto Windows Forms, arraste um controle Button da ToolBox para o formulário padrão. 2. Altere o valor da propriedade Name para “btnMudaCor”. 3. Altere o valor da propriedade Text para “Mudar cor de fundo”. 4. Abra a lista de eventos do botão e dê um duplo click no evento “Click”. 5. Dentro do método criado no segmento de código com o nome “btnMudaCor_Click” coloque o código abaixo. //A classe random serve para geração de número aleatório, //nesse caso utilizaremos para criar uma cor passando a quantidade de vermelho,azul e vermelho que a compões aleatóriamente Random rn =new Random(); //A palavra this se refere a própria classe onde o método esta definido como no caso é form. //Estamos mudando a cor de fundo do mesmo. //A classe Color são abstrações de cores no .net framework, podem criar um cor pelo método RGB conforme abaixo. //O método Next da classe Random gera o número aleatório pegamos o resto da divisão deste número por 255. //Pois assim nunca ultrapassará o valor máximo que o parâmetro aceita. this.BackColor = Color.FromArgb(rn.Next() % 255, rn.Next() % 255, rn.Next() % 255); 6. Aperte F5 para roda a aplicação. TextBox TextBox é o principal controle utilizado para recebimento de entrada de dados do usuário na forma textual . Ele fornece a possibilidade de receber e exibir texto para usuário. Você pode criar caixas de texto que mostram texto em múltiplas linhas, você pode também criar caixas de texto que aceitam a entrada de senhas e omitem o conteúdo apresentando apenas um caractere escolhido pelo desenvolvedor, por exemplo, um “*”. As principais propriedades do mesmo estão expostas na tabela abaixo:
- 48. 45 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Propriedade Descrição Hospeda uma coleção de strings utilizadas para Auto Complemento quando AutoCompleteMode estiver com valor diferente de “none” e o AutoCompleteCustomSource “AutoCompleteSource” estiver com valor “custom”. AutoCompleteMode Atribui a forma do auto completar, os possíveis valores são: Normal,Upper e Lower Determina a fonte de dados utilizada para realizar o auto complemento, pode ser uma série de fontes de dados preestabelecidas pelo sistema ou uma customizada definida AutoCompleteSource pelo desenvolvedor. Determina a forma como os caracteres ficarão na caixa de texto, os valores são:Upper- Todos em maiúsculo, Lower-Todos em minúsculo e Normal-Permanece como o CharacterCasing usuário digitar. Representa uma coleção de strings que refletem o valor da caixa de texto separado em Lines linhas, só é significante quando a propriedade MuliLine estiver com valor verdadeiro. MaxLength Determina o número máximo de caracteres que o TextBox pode aceitar. MultiLine Determina se a caixa de texto aceita o caractere de quebra de linha. Quando um caractere é definido nesse campo, todo caractere digitado pelo usuário é substituído pelo mesmo na apresentação, porém via código o valor da propriedade PasswordChar Text traz a string real digitada. Amplamente utilizado para senhas. Determina quando uma caixa de texto não pode ter seu texto editado servindo apenas para apresentação, o foco ainda passa no campo e o usuário pode copiar o texto ReadOnly através da seleção do mesmo. Indica se barras de rolagem aparecerão na caixa de texto caso múltiplas linhas forem ScrollBars aceitas. Text Uma string representando o texto contido na caixa de texto. Determina se o texto atual deve ser substituído pelo caractere de senha padrão do UseSystemPasswordChar sistema na exibição. Indica quando as palavras são automaticamente direcionadas para outra linha quando ultrapassam a largura do textbox e a propriedade multiline estiver com o valor WordWrap verdadeiro. Exemplo 1. Crie um novo projeto Windows Forms, arraste um controle TextBox da ToolBox para o formulário padrão. 2. Altere a propriedade “Name” do TextBox para txtMensagem. 3. Arraste um controle Button da ToolBox para o formulário padrão. 4. Altere a propriedade “Name” do Button para “btnExibir” e a propriedade “Text” para “Exibir”. 5. Crie uma variável do tipo string no formulário chamada Mensagem e inicialize-a. Código abaixo: string Mensagem= string.empty; 6. Agora volte para o editor visual do form e selecione o TextBox, vá até a janela de propriedade e acesse a lista de eventos, dê um duplo clique no evento TextChanged. 7. No método criado no código do form com o nome “txtMensagem_TextChanged” escreva o código abaixo: Mensagem = txtMensagem.Text; 8. Agora acesse a lista de eventos do botão e dê um duplo clique do evento “Click”, no método criado no código do form coloque o código abaixo: MessageBox.Show(Mensagem); 9. Rode o programa, altere o texto do TextBox e veja que o texto da caixa de dialogo aberta ao clicar do botão estará sempre igual ao da caixa de texto. Label O label é o principal controle utilizado para apresentação de textos não editáveis na tela, largamente utilizado para identificar outros componentes. As suas principais propriedades são a Text que representa o texto que será apresentado por ele e TextAlign que representa como o texto será apresentado.
- 49. 46 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# CheckBox O CheckBox é um controle muito familiar aos usuários. Ele permite que o usuário marque uma caixa combinada com um texto, que indica concordância ou rejeição da opção apresentada. Os CheckBoxes diferem dos RadioButtons uma vez que não trabalham de forma exclusiva ou seja a escolha de uma opção não rejeita as demais. Principais propriedades de um CheckBox Propriedade Descrição Determina se o CheckBox será automaticamente marcado quando o usuário clicar no texto AutoCheck que o identifica. Determina se o CheckBox está Checked marcado Determina o estado da marcação do CheckBox, Indeterminate,Checked ou CheckState UnChecked Representa o texto que identifica Text o CheckBox para o usuário Determina se o CheckBox aceita ThreeState dois ou três estado de marcação. Exemplo 1)Crie um novo projeto Windows Forms, arraste da ToolBox um Label para o formulário padrão. 2)Altere a propriedade Name para lblIngredientes e a propriedade Text para Ingredientes. 3)Arraste 4 CheckBoxes para o formulário e altere as propriedades dos mesmos conforme a tabela abaixo: Propriedade “Name” Propriedade “Text” Primeiro chkCarneSeca Carne seca Segundo chkCatupiry Catupiry Terceiro chkBacon Bacon Quarto chkPalmito Palmito 4)Arraste um botão para o formulário coloque o valor da propriedade name para “btnMostraEscolha” e a Text para “Mostrar Escolha”. 5)Acerte o layout para ficar parecido com o da imagem abaixo.
- 50. 47 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# 6)Crie uma variável na classe do tipo List<string> chamada ingredientes e inicialize-a sintaxe abaixo. List<string> Ingredientes; 7)Agora vá até a lista de eventos de cada um dos CheckBoxes e dê um duplo clique no evento “CheckedChanged”. 8)Agora implemente a definição de cada um dos métodos criados de acordo com a tabela abaixo; Método Definição chkCarneSeca_CheckedChanged if (chkCarneSeca.Checked) { if(!Ingredientes.Contains(chkCarneSeca.Text)) { Ingredientes.Add(chkCarneSeca.Text); } } else { Ingredientes.Remove(chkCarneSeca.Text); } chkBacon_CheckedChanged if (chkBacon.Checked) { if (!Ingredientes.Contains(chkBacon.Text)) { Ingredientes.Add(chkBacon.Text); } } else { Ingredientes.Remove(chkBacon.Text); } chkCatupiry_CheckedChanged if (chkCatupiry.Checked) { if (!Ingredientes.Contains(chkCatupiry.Text)) { Ingredientes.Add(chkCatupiry.Text); } } else { Ingredientes.Remove(chkCatupiry.Text); } chkPalmito_CheckedChanged if (chkPalmito.Checked) { if (!Ingredientes.Contains(chkPalmito.Text)) { Ingredientes.Add(chkPalmito.Text); } } else { Ingredientes.Remove(chkPalmito.Text); }
- 51. 48 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# 9) Agora acesse a lista de eventos do btnMostraEscolha, e dê um duplo clique sobre o evento “Click”, coloque o código abaixo em sua definição. MessageBox.Show("Ingredientes:rn"+ string.Join("rn", Ingredientes.ToArray())); 10)Aperte F5 para rodar a aplicação. Radio Button O RadioButton é utilizado para representar uma opção exclusiva para o usuário. Abaixo um exemplo simples com um GroupBox com o título sexo e o usuário pode escolher entre masculino e feminino mas nunca ambos. Propriedade Descrição Indica se o Radio button esta Checked marcado. Representa o texto que identifica Text a opção par ao usuário. Exemplo 1)Utilize o mesmo formulário do exemplo anterior. 2)Arraste um GroupBox para o formulário e mude a propriedade “Name” para grpBorda e a propriedade “Text” para borda. 3)Arraste 2 RadioButtons para dentro do GroupBox. Altere as propriedades de ambos conforme a tabela abaixo. Propriedade “Name” Propriedade “Text” Propriedade “Checked” Primeiro rdbCheddar Cheddar true Segundo rdbMussarela Mussarela false 4)Deixe o design parecido com o da imagem abaixo. 1) Acesse a lista de eventos dos RadioButton e dê um duplo clique no evento CheckChanged. 2) Crie uma variável do tipo string chama borda e inicialize-a, sintaxe abaixo. string borda = "Cheddar"; 3) Escreva a definição dos métodos criados de acordo com a tabela abaixo. Método Definição rdbCheddar_CheckedChanged if (rdbCheddar.Checked) borda = rdbCheddar.Text; rdbMussarela_CheckedChanged if (rdbMussarela.Checked) borda = rdbMussarela.Text;
- 52. 49 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# 9)Altere a definição do método btnMostrarIngredientes_Click colocando o código abaixo. MessageBox.Show("Ingredientes:rn"+ string.Join("rn", Ingredientes.ToArray())+"rn Borda:rn"+borda); 10)Aperte F5 para rodar a aplicação. Masked TextBox O MaskedTextBox é um TextBox modificado que permite a definição de um padrão para aceitar ou rejeitar uma entrada de dados do usuário. A propriedade Mask fornece a possibilidade de especificar os caracteres opcionais e obrigatórios, especificar também quais caracteres são letras ou números e aplicar uma formatação para exibição de string. A tabela abaixo mostra as principais propriedades do MaskedTextBox: Propriedade Descrição AllowPromptAsInput Determina se o caractere utilizado como prompt é aceito como entrada de dados Determina se somente caracteres da tabela AscII serão aceitos como entrada de AsciiOnly dados Determina se um sinal sonoro será emitido quando o usuário digitar um caractere BeepOnError inválido para a posição da máscara. Determina quais os caracteres serão movido para o ClipBoard quando o texto for CutCopyMaskFormat recortado ou copiado. Determina se os caracteres prompt serão omitidos quando o foco sair do HidePromptOnLeave MaskedTextBox InsertKeyMode Atribui ou retorna a forma de inserção. Mask Determina a máscara de entrada de dados. PromptChar Determina o caractere para prompt, ou seja, posições editáveis da máscara. Determina se a entrada de dados será interrompida ao primeiro caractere inválido RejectInputOnFirstFailure digitado pelo usuário. Determina se a entrada de dados será interrompida quando o usuário digitar um ResetOnPrompt caractere utilizado com prompt. Determina se a entrada de dados será interrompida quando o usuário digita um ResetOnSpace espaço. Determina como a propriedade Text será retorna, somente com os caracteres literais, incluindo os caracteres de formatação, ou incluído os caracteres de formatação e os TextMaskFormat caracteres prompt. A Propriedade Mask A propriedade mais importante de um MaskedTextBox é a propriedade Mask, a qual habilita a definição de uma string que representa o formato requerido para entrada de dados do usuários. Abaixo os caracteres chaves que podem ser utilizados para criação de uma máscara e seus significados nesse contexto. Elemento da máscara Descrição Representa um dígito obrigatório 0 de 0-9 Representa um dígito opcional de 9 0-9 Representa um dígito opcional de 0-9 ou um espaço.+ e – também # são aceitos. Representa uma letra obrigatória, maiúscula (A-Z) ou minúscula L (a-z)
- 53. 50 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Representa uma letra opcional, maiúscula (A-Z) ou minúscula ? (a-z). Representa um caractere obrigatório de qualquer natureza se o Ascii only estiver com valor & verdadeiro funcionará como o L. Representa um caractere opcional de qualquer natureza se o Ascii only estiver com valor verdadeiro C funcionará como o &. Representa um caractere alfa numérico opcional, Se a propriedade Ascii estiver com valor verdadeiro só aceitará A, a valores entre a-z e A-Z. Separador decimal, esse caractere será substituído de acordo com a . “culture” definida para o campo. Separador de milhar, será substituído pelo separador de milhar definido no “culture” para , o MaskedTextBox. Separador de tempo, será substituído pelo separador de tempo do “culture” definido para : o MaskedTextBox. Separador de data, será substituído pelo separador de data do “culture” definido para o / MaskedTextBox. Símbolo de moeda, será substituído pelo símbolo de moeda do “culture” definido para $ o MaskedTextBox. Shift down, transforma os caracteres da esquerda em < minúsculo. Shift up, transforma os caracteres > da direita em maiúsculo. Desabilita Shift Down ou Shift | Up anteriores. Transforma em caractere que estão nessa lista em parte literal da string. Aparecem como eles mesmos no texto, mas não podem ser Todos outros caracteres movidos ou apagados. Exemplo 1)Crie um novo projeto Windows Forms, arraste um controle MaskedTextBox da ToolBox para o formulário padrão. 2)Altere a propriedade “Name” do MaskedTextBox para txtMensagem. 3)Arraste um controle Button da ToolBox para o formulário padrão. 4)Altere a propriedade “Name” do Button para “btnExibir” e a propriedade “Text” para “Exibir”. 5)Altere a propriedade “Mask” do MaskedTextBox para 999.999.999-9. 6)Crie uma variável do tipo string no formulário chamada Mensagem e inicialize-a. Código abaixo:
- 54. 51 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# string Mensagem= string.empty; 7)Agora volte para o editor visual do form e selecione o MaskedTextBox, vá até a janela de propriedade e acesse a lista de eventos, dê um duplo clique no evento TextChanged. 8)No método criado no código do form com o nome “txtMensagem_TextChanged” escreva o código abaixo: Mensagem = txtMensagem.Text; 9)Agora acesse a lista de eventos do botão e dê um duplo clique do evento “Click”, no método criado no código do form coloque o código abaixo: MessageBox.Show(Mensagem); 10)Rode o programa, altere a propriedade TextMaskFormat do MaskedTextBox para cada um dos valores possíveis e veja o que acontece quando o dialogo com a mensagem é exibida, faça a mesma coisa para a CutCopyMaskFormat e copie cole em um editor de texto o conteúdo do MaskedTextBox, veja as diferenças. Trabalhando com arquivo texto Com o .net Framework já temos disponível implementações para realizar as operações mais comuns com arquivos, essas implementações estão no namespace System.IO.O namespace System.IO contém tipos que permitem leitura e escrita em arquivos e streams de dados e tipo que fornecem as funcionalidades básica de suporte a diretórios e arquivos. Tabela com as classes que vamos utilizar nesse tópico e uma descrição sobre suas funcionalidades. Classe Descrição File Fornece métodos estáticos para criação, cópia, deleção, movimentação e abertura de arquivos. FileStream Fornece um fluxo sobre o arquivo, suportando operações síncronas e assíncronas de leitura e escrita. StreamWriter É um escritor de texto para streams em um enconding em particular. StreamReader É um leitor de texto para streams em um enconding em particular. Criar um arquivo Para criar um arquivo podemos utilizar o método estático Create da classe File que recebe como parâmetro uma string indicando o caminho onde o arquivo será criado. Sintaxe: File.Create("C:MyText.txt"); Atenção se um arquivo com mesmo nome já existir no mesmo local o mesmo será sobrescrito por um arquivo em branco. Escrever em um arquivo Para escrever em um arquivo texto precisamos de uma instancia da classe FileStream a maneira mais fácil de se fazer isso é passando o caminho do arquivo como parâmetro e também o FileMode OpenOrCreate que cria o arquivo se não existir e abre ele no modo adição se existir ou seja não apaga os dados e acrescenta o que escrevermos. FileStream fs = new FileStream("C:MyText.txt", FileMode.OpenOrCreate); Feito isso podemos usar a classe StreamWritter que facilita na hora de escrever no arquivo, uma instância também precisa ser criada, como parâmetro passamos a instância da classe FileStream que criamos acima com o nome “fs” fica assim o código: StreamWriter St=new StreamWriter(fs); Agora podemos usar os métodos Write e WriteLine passando o texto que será escrito, a diferença entre os dois é que o segundo já adiciona uma quebra de linha ao acabar de escrever o texto passado como parâmetro veremos um exemplo utilizando cada um dos métodos.
- 55. 52 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# St.WriteLine("Qualquer texto pode ser escrito aqui."); St.WriteLine("Qualquer texto pode ser escrito aqui."); /* No arquivo ficaria assim * * Qualquer texto pode ser escrito aqui. * Qualquer texto pode ser escrito aqui. * */ St.Write("Qualquer texto pode ser escrito aqui."); St.Write("Qualquer texto pode ser escrito aqui."); /* No arquivo ficaria assim * * Qualquer texto pode ser escrito aqui. Qualquer texto pode ser escrito aqui. * */ Ao acabar de realizar as operações feche o StreamWritter e o FileStream para liberar o arquivo. St.Close(); fs.Close(); Ler de um arquivo A primeira parte continua igual criar uma instância do FileStream no mode OpenOrCreate. FileStream fs = new FileStream("C:MyText.txt", FileMode.OpenOrCreate); Só que agora instanciaremos uma classe de leitura a StreamReader. StreamReader sr = new StreamReader(fs); E usaremos os métodos Read e ReadLine; /* No método Read é necessário passar como parâmetro um array de char que será populado com os caracteres lido * os outros 2 parâmetros são posição inicial da leitura em índice e a quantidade de caracteres a serem lidos. */ char[] buffer=new char[20]; sr.Read(buffer, 0, 20); /* O ReadLine lê uma linha de cada vez e retorna os caracteres, * em uma string, mas antes é necessário verificar se a string não chegou ao fim. */ string str; if(!sr.EndOfStream) str = sr.ReadLine(); Feche o StreamReader e o FileStream para liberar o arquivo. sr.Close(); fs.Close(); Apagar um arquivo Para apagar o arquivo usamos o método estático Delete da classe File. File.Delete("CMyText.txt");
- 56. 53 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Prática salvando em arquivo texto Crie uma tela de cadastro de clientes com os campos: código, nome e documento. O usuário pode salvar os dados digitados clicando em salvar. Quando ele digitar um código já existente tem que recuperar os dados do cliente. Modificadores de acesso. Os modificadores de acessos são palavras reservadas utilizadas para definir a acessibilidade de um membro. Existem quatro deles: public protected internal private public – Acesso irrestrito, qualquer elemento da aplicação pode acessar o recurso. protected - Disponível para quem define e seus herdeiros. internal – Disponível para todos os membros definidos no mesmo namespace. private – Disponível somente ao próprio objeto que define. Os modificadores de visibilidade podem acompanhar: Classes, Métodos, Atributos, Propriedades, Interface, Enums e construtores. Atenção, quando nenhum modificador é definido é considerado o mais restritivo, ou seja, private. Classes Uma classe é uma unidade lógica que reúne as propriedades, ou seja, as características sobre ela mesma e as suas ações representadas pelos métodos que serão abordados com maior profundidade nesse capítulo. Uma classe descreve os serviços providos por seus objetos e quais informações eles podem armazenar. Em C# todas as ações são baseadas em classes de maneira que não podemos definir um método fora do escopo de uma classe. Uma declaração de classe ou estrutura é como um desenho que é usado para criar instâncias ou objetos em tempo de execução. Se você definir uma classe ou estrutura chamada Pessoa, Pessoa é o nome do tipo. Se você declara e inicializa uma variável p tipo Pessoa, p é considerado um objeto ou instância de Pessoa. Uma classe pode ter basicamente construtores, propriedade e métodos, cada um desses itens será abordado separadamente sem seguida. A sintaxe básica para criação de uma classe em c# é a seguinte. [Modificador de visibilidade] class [Nome da classe]{ //Definição da classe } Tudo que está entre as duas chaves que delimitam o escopo da classe fazem parte da mesma. Propriedades e variáveis Propriedades e variáveis da classe são dados armazenados pela classe e a diferença entre ambas é que as variáveis normalmente são utilizadas para processamentos internos da classe enquanto as propriedades são utilizadas para expor suas características à outros objetos, em C# é entendido como propriedade dados que façam uso de getters e setters para que outros objetos acessem suas informações, uma variável com modificador público não é considerada uma propriedade, pois os outros objetos tem acesso direta a mesma e isso não é desejável. Já com getter e setter por mais que aparentemente o acesso é direto o valor passa por um tratamento antes . A sintaxe básica de uma propriedade é: [Modificador de visibilidade] [Tipo] [Nome da propriedade]{ //Ao menos um dos modificadores abaixo é necessário, mas não é obrigatório ter ambos ao mesmo tempo. //O get significa que outros objetos poderão visualizar o valor da propriedade get; //O set significa que outros objetos poderão atribuir o valor da propriedade
- 57. 54 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# set; } Exemplo de propriedade public string Nome { get; set; } Exemplos class Pessoa { //Variável privada somente a própria classe tem acesso a ela. int Idade; //Propriedade com get e set, outros objetos podem atribuir e visualizar seu valor. public string Nome { get; set; } string _Nome; /*O valor recebido em uma variável pode ser tratado assim como o valor retornado expandido os modificadores get e set. Normalmente quando precisamos fazer algum tipo de tratamento criamos uma variável privada e encapsulamos em uma propriedade * quando o valor é atribuído ou solicitado fazemos as modificações necessárias antes e dentro da classe utilizamos a variável privada. */ public string NomeTratado { get { return _nome.ToUpper(); } set { //O value assume o valor atribuído a váriavel, e também o tipo da mesma _nome = value.ToLower(); } } private string _nomeReadOnly; private string _nomeWriteOnly; //Outros exemplos //Quando definidos somente um operador de acesso precisamos definir o corpo do mesmo. public string NomeReadOnly { get { return _nomeReadOnly; } } public string NomeWriteOnly { set { _nomeWriteOnly = value; } } } Construtores Construtor é uma espécie de métodos especial que não precisa ser invocados explicitamente, pois isso ocorre quando realizamos a criação de um objeto do tipo da classe, eles devem ter o mesmo nome da classe, não possuir um tipo de retorno definido, uma mesma classe pode ter vários construtores, com tanto que cada um receba parâmetros diferentes, os construtores são amplamente utilizados para inicialização das propriedades e variáveis da classe. A sintaxe básica de um construtor é:
- 58. 55 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# [Modificador de visibilidade] [nome da classe]([parâmetros(opcional)]{ //Definição do construtor. } Exemplo: class Pessoa { string _nome; string _cpf; public string Nome { get { return _nome; } set { _nome = value; } } public string Cpf { get { return _cpf; } set { _cpf = value; } } /* Esse primeiro construtor não recebe nenhum parâmetro e só inicializa as variáveis com um valor vazio. */ public Pessoa() { _nome = string.Empty; _cpf = string.Empty; } /* Esse segundo construtor inicia a váriavel Nome com o valor passado como parâmetro. Um construtor pode chamar outro, aqui está chamando o construtor default, que inicializa as variáveis com valor vazio antes de atribuir valor ao nome, a parte onde está escrito ":this()" é que indica que o construtor default deve ser chamado. */ public Pessoa(string Nome):this() { this._nome = Nome; } /* Esse terceiro construtor inicia a váriavel Cpf e repassa a tarefa de iniciar a váriavel nome * ao construtor que já sabe como fazer isso, dessa forma evitamos duplicar um código que faz a mesma coisa. * Nesse caso o que acontece, o terceiro construtor chama o segundo que chama o primeiro, então primeiro as variáveis * são atribuídas para valor vazio, depois a váriavel nome é atribuída e por último a váriavel _cpf é atribuída. */ public Pessoa(string Nome, string Cpf):this(Nome) { this._cpf = Cpf; } } class Program { static void Main(string[] args) { //Declaração de uma váriavel pessoa.
- 59. 56 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Pessoa pess; //Criação do objeto através do construtor default //O que define o construtor que será chamado é os parâmetros passado na hora da criação. //Como não passei nenhum será chamado o construtor default. pess = new Pessoa(); MostraNomeCpf(pess.Nome, pess.Cpf); //Saída = Nome:Vazio;CPF:Vazio //Como passei uma string o segundo construtor será chamado. pess = new Pessoa("Joaquin"); MostraNomeCpf(pess.Nome, pess.Cpf); //Saída = Nome:Joaquin;CPF:Vazio //Como passei 2 strings o terceiro construtor será chamado. pess = new Pessoa("Joaquin","35783627860"); MostraNomeCpf(pess.Nome, pess.Cpf); //Saída = Nome:Joaquin;CPF:35783627860 Console.ReadKey(); } static void MostraNomeCpf(string nome, string cpf) { if(nome==string.Empty) nome="Vazio"; if(cpf==string.Empty) cpf="Vazio"; Console.WriteLine("Nome:{0}; CPF:{1}", nome, cpf); } } Métodos Um método é um bloco de código que contém uma série de instruções. O programa executa as instruções quando chamamos o método e especificamos argumentos, em C# todas as instruções são executadas por métodos. O método Main é o ponto de entrada para cada aplicativo C# e ele é chamado pelo CLR (Common Language Runtime) quando o programa é iniciado. Assinatura de métodos Métodos são declarados em uma classe ou struct, especificando-se o nível de acesso como public ou private, modificadores opcionais como abstract ou sealed, o valor de retorno e o nome do método. Essas partes juntos são o assinatura do método. Observação: Um tipo de retorno de um método não é parte da assinatura do mesmo para fins de sobrecarga. No entanto, ele é parte da assinatura do método ao determinar a compatibilidade entre um delegate e o método que ele aponta. Os parâmetros do método são colocados entre parênteses e são separados por vírgulas. Parênteses vazios indicam que o método não requer parâmetros. Sintaxe do método: [Modificador de visibilidade] [Modificador opcional] [Nome do método]([Lista de parâmetros]){ //Definição } Exemplo: //O método abaixo não retorna nenhum valor, está acessível a qualquer elemento e recebe uma string como parâmetro public void Pessoa(string Nome) { //Definição } Parâmetros Os parâmetros são valores que o método necessita para realizar suas operações, ao declarar o método devem ser especificados entre os parênteses com o tipo explicito. Exemplo: //O método abaixo aceita um inteiro e uma string como parâmetros, que necessariamente precisam ser passados na chamada. public void ExcutaAcao(int inteiro, string texto) { }
- 60. 57 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# A maneira mais comum de passar os parâmetros na chamada é como no código abaixo, respeitando a ordem em que foram definidos. pess.ExcutaAcao(1, "a"); Mas em C# os parâmetros podem ser passados fora de ordem, porém dessa manei precisa ser especificado o nome do parâmetro seguido do valor desejado, exemplo: pess.ExcutaAcao(texto: "a", inteiro: 1); Os valores passados como parâmetros recebem o nome de argumentos. Retorno O retorno do método é o tipo de dado que o mesmo devolve ao terminar seu processamento, quando definimos um tipo de retorno no método o compilador exige um código que garanta o retorno de dados com tipo compatível, a palavra reservada “void” é utilizada em métodos que não precisam retornar nenhuma informação. A palavra chave para retorno de dados é “return” a execução do método é interrompida quando a execução passar por um “return”. Exemplos //Esse método não retorna nenhuma informação à chamada public void ExcutaAcao(int inteiro, string texto) { //Definição } //Esse método retorna uma string concatenando os dois parâmetros public string ExcutaAcao(int inteiro, string texto) { return texto + inteiro.ToString(); } Sobrecarga Sobrecarga de método é a possibilidade de termos métodos diferentes com o mesmo nome diferindo apenas em seus parâmetros, Isso é possível porque o método é identificado na chamada não só pelo seu nome, mas também pelos argumentos recebidos. Esse recurso nos ajuda a manter a semântica do código. Exemplo class Pessoa2 { public string FormataDados(string Nome) { return "Nome:" + Nome; } public string FormataDados(string Nome, string Cpf) { return "Nome:" + Nome + " Cpf:" + Cpf; } } class Program { static void Main(string[] args) { Console.WriteLine(new Pessoa2().FormataDados("Vinicius")); //Saída = Nome:Vinicius Console.WriteLine(new Pessoa2().FormataDados("Vinicius", "01234567890")); //Saída=Nome:Vinicius Cpf:01234567890 } Parâmetros opcionais Em C# podemos ter parâmetros opcionais nos métodos, isso significa que na chamada não é necessário passar todos os parâmetros definidos na assinatura do método, isso é possível definindo um valor padrão para o parâmetro o qual é usado no caso de não ser especificado na chamada. Isso pode ser útil quando precisamos acrescentar um novo parâmetro em um método usado muitas vezes na aplicação e desejamos que ele continuasse funcionando da mesma maneira de antes onde já foi utilizado. Exemplo //Nesse caso se o cpf não for especificado na chamada. //O nome será exibido e no lugar do Cpf a palavra "Vazio" aparecerá. public string FormataDados(string Nome, string Cpf="") { if (Cpf == "") Cpf = "Vazio"; return "Nome:" + Nome + " Cpf:" + Cpf; }
- 61. 58 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Parâmetros de saída e por referência Os parâmetros de saída são uma forma de um método retornar mais valores além do seu retorno, há situações em que, por exemplo, precisamos converter um valor sem retornar exceção, podemos usar o retorno do método para dizer se a conversão foi um sucesso e um parâmetro de saída com o valor do convertido. Os parâmetros de saída são identificados pela palavra reservada “out” precedendo o tipo do parâmetro, um parâmetro de saída só pode receber como parâmetro um variável de tipo compatível e nunca um valor literal, a palavra reservada “out” também tem que preceder o argumento na chamada, o método é obrigado pelo compilador a atribuir um valor ao argumento. Passagem por referência é quando passamos a instância diretamente para o método que consegue fazer modificações na mesma que refletem no escopo em que foi definida, quando não fazemos isso e alteramos instância dentro do método isso não reflete no escopo em que ela foi definida. Exemplos class Program2 { static void Main(string[] args) { //Parâmetro por referência PessoaSimp pess = new PessoaSimp(); pess.Nome = "Nome escopo classe"; pess.CPF = "Cpf escopo classe"; Console.WriteLine("Classe"); pess.ExibeDados(); //Saida = Nome:Nome escopo classe Cpf:Cpf escopo classe Console.WriteLine("Método"); AlteraPessoa(pess); //Saida = Nome:Nome escopo método Cpf:Cpf escopo método Console.WriteLine("Classe"); pess.ExibeDados(); //Saida = Nome:Nome escopo classe Cpf:Cpf escopo classe Console.WriteLine("Método"); AlteraPessoa(ref pess); //Saida = Nome:Nome escopo método Cpf:Cpf escopo método Console.WriteLine("Classe"); pess.ExibeDados(); //Saida = Nome:Nome escopo método Cpf:Cpf escopo método //Parâmetro de saída int val; if (StringToInt("1",out val)) Console.WriteLine("Conversão bem sucedida valor={0}", val); else Console.WriteLine("Conversão falhou"); Console.ReadKey(); } static void AlteraPessoa(PessoaSimp pess) { pess = new PessoaSimp(); pess.Nome = "Nome escopo método"; pess.CPF = "Cpf escopo método"; pess.ExibeDados(); } static void AlteraPessoa(ref PessoaSimp pess) { pess = new PessoaSimp(); pess.Nome = "Nome escopo método"; pess.CPF = "Cpf escopo método"; pess.ExibeDados(); }
- 62. 59 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Enums A palavra-chave enum é usada para declarar uma enumeração, um tipo distinto que consiste em um conjunto de constantes nomeadas denominada lista de enumerador. Geralmente é melhor definir um enum dentro de um namespace para que todas as classes no namespace possam acessá-lo com igual conveniência. No entanto, um enum também pode ser aninhado dentro de uma classe ou struct. As constantes têm um valor numérico relacionado. Por padrão iniciando em 0 e aumentando em 1 a cada uma. Mas esse valor também pode ser atribuído explicitamente. Sintaxe básica de um enum: Enum{[Constantes separadas por vírgula]}; Exemplo de um enumerador com os dias da semana. enum Days {Sat, Sun, Mon, Tue, Wed, Thu, Fri}; Enumeradores podem usar os inicializadores para substituir os valores padrões, conforme mostrado no exemplo a seguir. enum Days {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri}; Utilizando um enum enum DiasDaSemana { Segunda, Terça, Quarta, Quinta, Sexta } static string AnalisaDiaSemana(DiasDaSemana Ds) { switch (Ds) { case DiasDaSemana.Segunda: return "Ta começando..."; case DiasDaSemana.Terça: return "Força..."; case DiasDaSemana.Quarta: return "Estamos na metade..."; case DiasDaSemana.Quinta: return "Vespera de sexta..."; case DiasDaSemana.Sexta: return "AwwwwwwwwwwwwwIeeeeeee"; default: return "Final de semana"; } } O método retorna um texto em função do valor do enum recebido como parâmetro. Herança A herança, juntamente com o encapsulamento, polimorfismo e abstração, é uma das quatro principais características (ou pilares) da programação orientada a objeto. A herança permite que você crie novas classes para reutilizar, estender e modificar o comportamento que está definido nas outras classes. A classe cujos membros são herdados é chamada de classe base, e a classe que herda a esses membros é chamada de classe derivada. Uma classe derivada pode ter apenas uma classe base direta. No entanto, a herança é transitiva se ClassC é derivada da ClassB e ClassB é derivada da ClassA, ClassC herda os membros declarados em ClassB e ClassA.
- 63. 60 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Conceitualmente, uma classe derivada é uma especialização da classe base. Por exemplo, se você tiver uma classe base Animal, você pode ter uma classe derivada que é denominada “Mamíferos” e outra classe derivada que é denominada “Répteis”. Tanto os mamíferos quanto répteis são animais, mas cada classe derivada representa especializações diferentes da classe base. Quando você definir uma classe para derivar de outra classe, a classe derivada implicitamente obtém todos os membros da classe base, exceto para os construtores e destrutores. A classe derivada, assim, pode reutilizar o código da classe base sem ter que rescrever. Na classe derivada, você pode adicionar mais membros. Dessa forma, a classe derivada estende a funcionalidade da classe base. Em C# para que uma classe herde de outra deve ser adicionado após o nome da mesma “:” seguido do nome da classe base. Exemplo abaixo. class Animais { //Definição } class Mamiferos : Animais { //Definição } Nesse caso mamíferos passa a ser um animal e possuir todos os elementos da classe base que as restrições de visibilidade permitam. Classe e métodos estáticos Uma classe estática é basicamente a mesma coisa que uma classe não estática, mas há uma diferença: uma classe estática não pode ser instanciada. Em outras palavras, você não pode usar a Palavra-chave new para criar uma variável do tipo da classe. Como não há nenhuma variável de instância, você acessa os membros de uma classe estática usando o nome da classe propriamente dito. Por exemplo, se você tiver uma classe estática denominada UtilityClass contendo um método público chamado MethodA, você chama o método conforme o exemplo abaixo: UtilityClass.MethodA(); Uma classe estática pode ser usada como um recipiente conveniente para conjuntos de métodos que só operam nos parâmetros de entrada e não precisará obter ou definir quaisquer campos internos de instância. Por exemplo, a biblioteca de classes do .NET Framework contém a classe estática System.Math que contém métodos que executam operações matemáticas, sem a necessidade de armazenar ou recuperar dados exclusivos de uma determinada instância da classe Math. Ou seja, basta utilizar os membros da classe especificando o nome da classe e o nome do método, conforme mostrado no exemplo a seguir. double dub = -3.14; Console.WriteLine(Math.Abs(dub)); Console.WriteLine(Math.Floor(dub)); Console.WriteLine(Math.Round(Math.Abs(dub))); // Output: // 3.14 // -4 // 3 Uma classe estática não pode conter variáveis de instancia nem métodos não estáticos. Sintaxe para declaração de uma classe estática. [Modificador de visibilidade] static class [Nome da classe]{ //Definição } Exemplo: public static class Matematica { //Definição }
- 64. 61 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Uma classe não estática também pode conter métodos estáticos contanto que não acessem variáveis de instancia nem método não estáticos. A sintaxe para criação de um método estático é a mesma de um método não estático a diferença é a adição da palavra- chave “static” antes do tipo de retorno do método. Exemplo abaixo: public static int Soma(int n1,int n2){ //Definição } Conversões Em C# com algumas exceções todas as conversões devem ser explicitas. Quase todos os tipo elementares oferecem métodos para conversão o Parse e o TryParse. Vamos realizar conversões para os tipos mais comuns. //string para inteiro string IntStr = "1"; //Só devemos usar o parse se tivermos certeza que o valor da string representa um número inteiro. //Pois se não representar uma exceção será lançada. int Inteiro = int.Parse(IntStr); //Quando não temos certeza se o valor da string é um inteiro é melhor utilizar o TryParse. //Retorna um booleano indicando se a conversão foi um sucesso. bool Sucesso = int.TryParse(IntStr,out Inteiro); //string para double string DoubStr = "1,1"; double db = double.Parse(DoubStr); Sucesso = double.TryParse(DoubStr, out db); //string para float string FloatStr = "1,1"; float fl = float.Parse(FloatStr); Sucesso = float.TryParse(FloatStr, out fl); //string para decimal string decStr = "1,1"; decimal dc = decimal.Parse(decStr); Sucesso = decimal.TryParse(decStr, out dc); //string para DateTime string DtStr = "10/01/2011"; DateTime dt = DateTime.Parse(DtStr); Sucesso = DateTime.TryParse(DtStr, out dt); Outra forma de conversão é a conhecida como “cast” ele é usado para converter um tipo da classe base para qualquer tipo derivado, o tipo object, por exemplo, pode ser “castado” para qualquer outro tipo em C# pois todos derivam dele. Mas atenção se o tipo que estiver na variável não for o mesmo que estamos tentando converter, uma exceção será lançada, a sintaxe do cast é a seguinte: ([nome do tipo)[nome da variável]; Exemplo object val = 1; int intval = (int)val; //A linha abaixo causa uma exceção. string strval = (string)val; Interfaces A interface é uma espécie de contrato sobre as funcionalidades que os objetos que derivados dela devem ter. Ela não apresenta a implementação das funcionalidades apenas as assinaturas, mas garante que as classe derivadas as implementarão. A sintaxe para criação de interfaces é a seguinte: [Modificador de visibilidade] interface [Nome da interface]{ //Definição } Nas interfaces definimos apenas assinaturas de métodos que os tipos derivados deverão ter, não precisamos definir o modificador de visibilidade, pois se está na interface o método deve ter acessibilidade irrestrita.
- 65. 62 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Exemplo public interface IAnimais { void Repirar(); string GetNome(); void SetNome(string Nome); } Classe derivada public class Mamiferos : IAnimais { public void Repirar() { throw new NotImplementedException(); } public string GetNome() { throw new NotImplementedException(); } public void SetNome(string Nome) { throw new NotImplementedException(); } } ADO.net O ADO.net é um conjunto de classe voltadas ao acesso de dados, ele fornece códigos consistente de acesso aos dados em fontes como o Microsoft SQL Server e XML, bem como a fontes de dados expostas através de OLE DB e ODBC. Aplicações cliente pode utilizar o ADO.NET para conectar-se a essas fontes de dados e recuperar, manipular e atualizar os dados que elas contêm. O ADO.net contém objetos bases sobre os quais implementações específicas para cada SGDB são feitas. Abaixo as classes que utilizaremos para acessar dados nos exemplos da apostila. Objeto Descrição DbConnection Encapsula uma conexão com banco de dados DbCommand Encapsula um comando SQL DataTable Representa um conjunto de dados em formato tabular. DbDataAdapter Executa comandos e preenche dados. DbParameter Encapsula um parâmetro de instrução SQL Acessando um banco de dados. Vamos realizar as operações básicas com banco de dados nesse tópico, para os exemplos nos conectaremos em um banco Sql Server. Estabelecendo uma conexão com o banco de dados Existe mais de uma maneira de estabelecer a conexão com um banco de dados em C# vamos aprender através da utilização da classe de conexão específica para o SGBD que utilizamos, os bancos mais utilizados tem uma implementação própria sobre o ADO.net como SQL Server, MySql, Oracel, Firebird, DB2 entre outros, mas também é possível acessar através de classe genéricas para bancos de dados OLE ou por ODBC. Se existir uma implementação especifica para o banco que irá utilizar nas suas aplicações é recomendado que a utilize, ela provavelmente saberá trabalhar melhor com aspectos específicos da distribuição. No exemplo abaixo utilizaremos a classe SqlConnection que é a derivada para Sql server da DbConnection do ADO.NET para qualquer outro banco de dados a sintaxe deve ser parecida. Devemos passar a string de conexão com parâmetros para o construtor da classe, assim já termos os dados necessários para que o sistema conecte no banco de dados, cada banco de dados interpreta a string de conexão de uma forma, na seção de links temos um site com uma série de exemplo de strings de conexão para os mais diversos bancos nas mais diversas situações. SqlConnection Conn = new SqlConnection("Data Source=myServerAddress;Initial Catalog=myDataBase;User Id=myUsername;Password=myPassword;"); No código acima criamos a conexão, porém só saberemos se está funcionamos quando tentarmos abrir a mesma através do método Open ou executar um comando com DataAdapter. Conn.Open();
- 66. 63 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Exemplo de método para testar a conexão: public string testConnect(string Connect) { string Mensagem; try { GetConnection().Open(); Mensagem = "Conectado com sucesso"; } catch (Exception e) { Mensagem = e.Message; } return Mensagem; } Executando uma query Para executar um comando usamos uma derivada da classe dbCommand, para essa classe devemos passar o comando em forma textual, uma instância da conexão e também o tipo do comando, no caso CommandText, veja no exemplo abaixo. //Criamos um objeto DataTable onde o resultado do select será armazenado System.Data.DataTable tb = new System.Data.DataTable(); //Criamos uma instância da conexão para o servidor onde o comando será executado, não precisa ser aberta quando utilizamos o DataAdapter. SqlConnection mycon = new SqlConnection("Data Source=myServerAddress;Initial Catalog=myDataBase;User Id=myUsername;Password=myPassword;"); //Criamos um objeto SqlCommand passando o instrução sql e a conexão para o server SqlCommand Cmd = new SqlCommand("select * from clientes", mycon); //Aqui criamos um objeto DataAdpter passando o comando com parâmetro. SqlDataAdapter da = new SqlDataAdapter(Cmd); //Aqui chamamos o comando fill que é responsável por executar o comando e preencher o DataTable com os resultado obtidos da.Fill(tb); //Fechamos a conexão mycon.Close(); //Retornamos o DataTable preenchido para ser utilizado conforme necessário. return tb; Recuperando os dados do DataTable O DataTable representa um conjunto de dados em formatos tabulares, por tanto linhas e colunas as linhas estão disponíveis, através da propriedade Rows você acessa cada linha individualmente através de um índice ,por exemplo, Rows[0] acessaria a primeira linha de um DataTable, cada linha do DataTable consiste em um DataRow que se trata de uma coleção de colunas que também pode ser acessadas por índice ou pelo nome delas no select ,por exemplo, Rows[0][0] ou ainda Rows[0][“id_cliente”]. Vamos ver no exemplo como converteríamos o resultado da query executada anteriormente em uma lista de objetos do tipo cliente. public class Cliente { public string nome{ get; set; } public DateTime DataPrimeiraCompra { get; set; } } public class ClienteControl { public List<Cliente> DtToList(DataTable dt) { List<Cliente> lst = new List<Cliente>(); Cliente cli; //Fazemos um for para passar a cada linha do DataTable e alimentaremos um objeto cliente com os dados. for (int i = 0; i < dt.Rows.Count; i++) { //Essa é uma forma simplificada de inicializar um objeto. //Melhora a semântica do código. cli = new Cliente() {
- 67. 64 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# nome = dt.Rows[i]["nome"].ToString(), DataPrimeiraCompra = DateTime.Parse(dt.Rows[i]["data_ult_compra"].ToString()) }; //Adiciona na lista de cliente perceba que a váriavel é a mesma, mas a cada iteração é criada uma nova instância. lst.Add(cli); } return lst; } } Executando comandos diferentes de consulta Para executar outros comandos que não sejam consultas, como inserts,deletes e updates, o processo é o mesmo que executar uma query as únicas diferenças é que não vamos utilizar um DataAdpter e executaremos o comando através do método da classe DbCommand ExecuteNonQuery(). Veja abaixo um exemplo. DbConnection Conn = new SqlConnection(); DbCommand Cmd = new SqlCommand("delete from clientes",(SqlConnection)Conn); Cmd.CommandType = CommandType.Text; //Aqui precisamos abrir a conexão antes Conn.Open(); Cmd.Connection = Conn; Cmd.CommandText = Cmd.CommandText; Cmd.ExecuteNonQuery(); Conn.Close(); Passagem de parâmetros Quando vamos utilizar um comando que necessita de parâmetro o ideal não é utilizar a concatenação de string, pois os dados podem estar em formatos diferente na aplicação e no banco de dados, além de abrir uma vulnerabilidade para injeção de comando sql na aplicação. A melhor maneira de se fazer é acessar a lista de parâmetros da classe derivada de DbCommand de acordo com o SGBD que estiver utilizando no caso do SqlServer temos as seguinte sobrecargas: Parameters.Add([SqlParameter]); Parameters.Add([Nome do parâmetro(string),[SqlDbType(enum)]); Parameters.Add([Nome do parâmetro(string),[SqlDbType(enum)],[Tamanho (para tipos que se aplica)]); Parameters.Add([Nome do parâmetro(string),[SqlDbType(enum)],[Tamanho (para tipos que se aplica)],[Coluna utilizada como fonte de dados]); Para especificarmos o valor dos parâmetros acessamos a propriedade Value, pode ser diretamente ao utilizar o método Add sem necessidade de criar um objeto SqlParameter antes. Exemplo: Cmd.Parameters.Add("nome", SqlDbType.VarChar, 5).Value="Jhony"; Passando parâmetro para um comando Texto DataTable dt = new DataTable(); SqlConnection Conn = new SqlConnection"Server=myServerAddress;Database= myDataBase;Uid=MyUser;Pwd=MyPwd;"); SqlCommand cmd = new SqlCommand("select * from clientes_tbl where id_usuarios=@id_usuarios",Conn); cmd.Parameters.Add("@id_usuarios", SqlDbType.Int).Value = 1; SqlDataAdapter da = new SqlDataAdapter(cmd); da.Fill(dt); foreach (DataRow item in dt.Rows) { Console.WriteLine(item[2].ToString()); } Console.ReadKey(); Passando parâmetro para uma procedure DataTable dt2 = new DataTable(); SqlConnection Conn2 = new SqlConnection("Server=myServerAddress;Database= myDataBase;Uid=MyUser;Pwd=MyPwd;"); SqlCommand cmd2 = new SqlCommand("sp_write_clientes", Conn); cmd2.Parameters.Add("@id_clientes", SqlDbType.Int).Value = 1; cmd2.Parameters.Add("@nome", SqlDbType.Int).Value = "João"; Conn.Open();
- 68. 65 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# cmd2.ExecuteNonQuery(); Prática de cadastro salvando em banco de dados Crie uma tela de cadastro de clientes com os campos código, nome e documento. O usuário pode salvar os dados digitados clicando em salvar. Quando ele digitar um código já existente tem que recuperar os dados do cliente. Criação de controles customizados O .net oferece uma vasta gama de controles para as mais variadas situações, porém existem momento em que uma necessidade específica não pode ser suprida por nenhum desses controle é nesse momento que entram os controles definidos pelo usuário. Tipos de controles customizados Controles composto, são a forma mais simples de criar um controle customizado, consiste em reunir controles existentes para criar um novo controle. Controle estendido, são controles que herdam de um controle como TextBox e Button e estendem suas funcionalidades. Para adicionar um controle customizado em seu projeto clique com o botão direito sobre ele na Solution Explorer e escolha no menu contextual a opção new->Item, selecione a categoria Windows Forms e depois User Control. Imagem abaixo. Mude o nome como quiser e clique em Add. Vamos fazer um exemplo de cada tipo de controle. Controle composto. 1- Em um projeto Windows Forms adicione um User Control. 2- Mude o nome para Cronometro e clique em Add. 3- Um painel que representa a área do controle aparecerá. 4- Arraste um label e um botão para o mesmo. 5- Renomeie o label para lblSegundo e coloque propriedade Text com o valor “0”. 6- Renomeie o botão para btnIniciar e mude o texto para “Iniciar”. 7- Deixe o layout do controle parecido com a imagem abaixo: 8- 9- Arraste um controle do tipo timer para o form. 10- Mude a propriedade interval para 1000. 11- Exiba o código do Controle e crie uma varável do tipo inteiro com o nome Segundos e inicialize-a com 0. 12- Vá até a lista de eventos do Timer e dê um duplo clique no evento Tick. 13- Dentro do método criado coloque o código abaixo: Segundos++; lblTempo.Text = Segundos.ToString(); 12-Agora crie o evento Click do botão e coloque o código abaixo: timer1.Start(); 13-Recompile seu projeto.
- 69. 66 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# 14-Se tudo correu certo vá até a ToolBox, o seu controle customizado estará logo no começo com o nome que você atribuiu ao mesmo arraste para um form execute; Clique no botão iniciar para ver o resultado. Controle estendido 1 – Em um projeto Windows Forms clique com o botão direito New->Item->Code->Class. 2-Coloque o nome TextBoxCustom. 3-Adicione uma herança para a classe TextBox e coloque o modificador publico sintaxe abaixo: public class TextBoxCustom:TextBox 4-Crie um construtor default mude a cor de fundo e a cor da letra, as propriedades fazem parte da sua classe agora por conta da herança então basta usar o “this”, sintaxe abaixo: public TextBoxCustom() { this.BackColor = Color.Black; this.ForeColor = Color.White; } 5-Recompile o projeto. 6-Vá até a ToolBox, na mesma seção onde se encontra o Cronometro teremos o TextBoxCustom, arraste-o para o form e mude a propriedade Text para perceber as customizações. Generics Os Generics foram adicionados à versão 2.0 da linguagem C# e do Common Language Runtime (CLR). Generics introduzem no .NET Framework o conceito de parâmetros de tipos, que tornam possíveis a estruturação de classes e métodos que adiam a especificação de um ou mais tipos até que a classe ou método seja declarada e instanciada pelo código do cliente. Por exemplo, usando um parâmetro de tipo genérico T você pode escrever uma única classe que outro código do cliente poderá usar sem aumentar o custo ou risco de conversões (cast) em tempo de execução (runtime) ou operações de boxing, conforme mostrado abaixo: // Declara a classe genérica public class GenericList<T> { void Add(T input) { } } class TestGenericList { private class ExampleClass { } static void Main() { // Declara uma lista do tipo int. GenericList<int> list1 = new GenericList<int>(); // Declara uma lista do tipo string. GenericList<string> list2 = new GenericList<string>(); // Declara uma lista de um tipo definido pelo usuário. GenericList<ExampleClass> list3 = new GenericList<ExampleClass>(); } } Visão genérica Usar tipos genéricos para maximizar reutilização de código, segurança de tipo, e desempenho. O uso mais comum de generics é para criar classes coleção. A biblioteca de classes do .NET Framework contém várias novas classes de coleções genéricas no namespace System.Collections.Generic. Eles devem ser usados sempre que possível, em vez de classes como ArrayList do namespace System.Collections. Você pode criar suas próprias interfaces genéricas, classes, métodos, eventos e delegates. Classes genéricas podem ser utilizadas para permitir acesso aos métodos usando tipos de dados específicos. Informações sobre os tipos que são usados em um tipo de dados genéricos podem ser obtidas em tempo de execução usando reflexão. Por exemplo, podemos fazer um método que converte qualquer string para um enum com o tipo correto. public static T StringToEnum<T>(char value) where T : struct,IConvertible
- 70. 67 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# { try { return (T)Enum.Parse(typeof(T), value.ToString()); } catch (Exception e) { string msg = e.Message; return Activator.CreateInstance<T>(); } } Lambda Expression Uma expressão lambda é uma função anônima que pode conter expressões e instruções, e pode ser usada para criar ponteiros de função ou tipos de árvores de expressão. Todas as expressões lambda usam o operador lambda = >, que é lido como "vai para". O lado esquerdo do operador lambda especifica os parâmetros de entrada (se houver) e o direito contém a expressão ou o bloco de instruções a expressão lambda x => x * x é lido " x recebe x vezes x. " Esta expressão pode ser atribuída a um ponteiro de função da seguinte maneira: delegate int del(int i); static void Main(string[] args) { del myDelegate = x => x * x; int j = myDelegate(5); //j = 25 } Para criar um tipo de árvore de expressão: Expression<del> myET = x => x * x; As expressões lambdas são muito uteis ao trabalharmos com coleções, pois podemos passar uma expressão Lambda para os métodos que filtram e ordenam a coleção veja alguns exemplos abaixo. class Pessoa { public string Nome { get; set; } public int Idade { get; set; } public Pessoa() { Nome = "NomePadrao"; Idade = 12; } public object[] RetornaDados() { return new object[] { Nome, Idade }; } } class Program { static void Main(string[] args) { List<Pessoa> lstpess = new List<Pessoa>(); lstpess.Add(new Pessoa() { Nome = "joão", Idade = 18 }); lstpess.Add(new Pessoa() { Nome = "joãozin", Idade = 12 }); lstpess.Add(new Pessoa() { Nome = "joãozão", Idade = 18 }); lstpess.Add(new Pessoa() { Nome = "robert", Idade = 15 }); lstpess.Add(new Pessoa() { Nome = "hebert", Idade = 18 }); lstpess.Add(new Pessoa() { Nome = "kenko", Idade = 21 }); lstpess.Add(new Pessoa() { Nome = "louis", Idade = 18 }); lstpess.Add(new Pessoa() { Nome = "hermes", Idade = 56 }); List<Pessoa> ListaFiltrada; //Retorna todas pessoas com nome joãozin ListaFiltrada=lstpess.FindAll(p => p.Nome == "joãozin");
- 71. 68 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# //Retorna todos maiores de 18 anos ListaFiltrada=lstpess.FindAll(p => p.Idade > 18); //Retorna os maiores de 18 anos que tenham o nome começado em j. ListaFiltrada=lstpess.FindAll(p => p.Nome.Substring(0, 1) == "j" && p.Idade > 18); List<Pessoa> ListaOrdenada; //Retorna lista ordenada por nome ListaOrdenada=ListaFiltrada.OrderBy(p => p.Nome).ToList<Pessoa>(); //Retorna lista ordenada por ano de nascimento ListaOrdenada = ListaFiltrada.OrderBy(p => DateTime.Now.Year-p.Idade).ToList<Pessoa>(); } } Reflection Reflection é habilidade dos objetos observarem a sua própria estrutura e também a de outros objetos em tempo de execução, com reflection podem ser criadas instância de tipos dinamicamente, carregar módulo compilados e seus tipos, varrer propriedades das classes e atribuir valor a elas, varrer métodos do objeto e invocá-los entre outras coisas, tudo isso de maneira dinâmica. As principais funções de reflection estão no namespace System.Reflection. Principais classes com uma breve descrição. Classe Descrição Type Essa é a classe fundamental do namespace reflection ela abstrai as principais informações que são relevantes a respeito de um determinado tipo. PropertyInfo Reúne informações sobre uma propriedade como nome e o tipo da mesma. Activator Utilizado para criação de instâncias dinamicamente. Assembly Reúne informações sobre um módulo Assembly, como os tipos contidos no mesmo. Vamos ver na prática como realizar as tarefas mais comuns com Reflection; Varrer as propriedade de uma classe e atribuir-lhes valores static void VarrePropriedade() { Pessoa pess = new Pessoa(); //Todos os objetos tem o método GetType() pois o mesmo está definido na classe elementar object. //O GetType retorna uma Type que tem o método GetProperties() que retorna uma lista com informações sobre as propriedades da classe. PropertyInfo[] PropI = pess.GetType().GetProperties(); int Contador=10; //Nesse foreach escrevemos o nome e o tipo da propriedade na tela, e atribuímos um valor para cada // verificando pelo nome da mesma. foreach (PropertyInfo item in PropI) { Console.WriteLine(item.Name); Console.WriteLine(item.PropertyType.ToString()); if (item.Name == "Nome") item.SetValue(pess, "Nome" + Contador.ToString(), null); else item.SetValue(pess, Contador, null); Contador++; } //Nesse for exibiremos o valor de todas as propriedades da classe. foreach (PropertyInfo item in PropI) {
- 72. 69 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Console.WriteLine(item.GetValue(pess, null)); } } Criar a instância de um tipo anônimo //O método abaixo cria uma instância do tipo definido na hora da chamada, na definição não se sabe qual tipo será criado. static T CriaInstanciaAnonima<T>() { return Activator.CreateInstance<T>(); } Carrega dinamicamente um tipo contido em outro assembly Essa eu considero a funcionalidade mais importante. Porém é mais complexo de ser feito por tanto vamos passo a passo. 1-)Crie um projeto do tipo Class Library com o nome Abstrações. 2-)Delete a classe de nome class1.cs que é criada por padrão. 3-)Adicione uma Interface de nome IReflexaoDb. 4-)Adicione a assinatura de método abaixo na interface: object[] RetornaDados(); 5-)Adicione um novo projeto ClassLibrary com o nome BusinessLayer. 6-)Altere o nome da classe padrão de Class1 para Clientes. 7-)Clique com o botão direito sobre o projeto selecione Add Reference->Aba projects->Abstracoes->Ok. 8-)No arquivo da classe Clientes coloque no início o comando abaixo: Using Abstracoes 9-)Adicione a herança de IReflexaoDb para Clientes. 10-)Adicione 2 propriedade do tipo string na classe Clientes Nome e Cpf. 11-)Adicione um construtor default para incializar a variável. Código: public Clientes() { Nome = "nome padrão"; Cpf = "Cpf padrão"; } 12-)Implemente o método da Interface na classe Clientes código abaixo: public object[] RetornaDados() { return new object[]{Nome,Cpf}; } 13-)Compile os dois projetos em release. 14-)Copie as duas dlls geradas para um lugar fácil de encontrar. 15-)Crie um projeto do tipo Windows Forms chame de VisualizadorReflexao. 16-)Arraste um TextBox para tela e chame-o de txtCaminho. 17-)Arraste um Button e chame-o de btnAbrir, mude a propriedade text para “Localizar DLL” e a propriedade ReadOnly para true. 18-)Arraste um novo TextBox para tela e chame-o de txtExibicao, mude a propriedade MultLine para true.
- 73. 70 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# 19-)Deixe o design da tela parecido com o da imagem abaixo. 20-)Clique com o botão direito sobre o projeto Add Reference->Aba projetos->Abstracoes. 21-)Crie o evento Click do botão e coloque o código abaixo na sua definição. OpenFileDialog ofp =new OpenFileDialog(); ofp.Multiselect=false; ofp.Filter="Arquivos IL|*.dll"; if(ofp.ShowDialog()==System.Windows.Forms.DialogResult.OK){ Assembly asm = null; try { asm = Assembly.LoadFrom(ofp.FileName); txtCaminho.Text = ofp.FileName; } catch { MessageBox.Show("Arquivo inválido"); return; } foreach(Type item in asm.GetTypes()){ if(item.GetInterface("IReflexaoDb")!=null){ string str = string.Empty; foreach (object values in ((IReflexaoDb)Activator.CreateInstance(item)).RetornaDados()) { str += values.ToString() + "rn"; } txtExibicao.Text = str; } } } 22-)Rode o programa clique no botão e vá até a pasta onde você havia guardado a DLL BusinessLayer compilada clique sobre ela, o programa carregará a DLL dinamicamente e exibirá os valores do método RetornaDados de todos as classes derivadas de IReflexaoDb, no caso somente a classe Clientes, notem que não temos uma referência à DLL onde a classe clientes está definida e nem conhecemos o tipo clientes durante o desenvolvimento, a aplicação só saberá disso no momento que usuário selecionar a DLL onde os tipos estão contidos. Dessa forma a nossa aplicação exibe os dados de qualquer derivada da interface IReflexaoDb, desde que indiquemos o caminho do módulo onde ela está contida. Varrer os métodos e invocá-los dinamicamente class Pessoa { public string Nome { get; set; } public int Idade { get; set; } public Pessoa() {
- 74. 71 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Nome = "NomePadrao"; Idade = 12; } public object[] RetornaDados() { return new object[] { Nome, Idade }; } } static void VarrerMetodos() { Pessoa pess = new Pessoa(); MethodInfo[] MetInf = pess.GetType().GetMethods(); foreach (MethodInfo item in MetInf) { if (item.Name == "RetornaDados") { foreach (object item2 in (object[])item.Invoke(pess, null)) { Console.WriteLine(item2.ToString()); } } } Console.ReadKey(); } LINKS Artigo Wikipedia em inglês sobre o C# - http://en.wikipedia.org/wiki/C_Sharp_(programming_language) Site ECMA sobre a padronização C# - http://www.ecma-international.org/publications/standards/Ecma-334.htm Namespace Programming Guide C# MSDN - http://msdn.microsoft.com/pt-br/library/0d941h9d.aspx Classes e estrutura C# - http://msdn.microsoft.com/pt-br/library/ms173109.aspx Manual de referência do C# msdn - http://msdn.microsoft.com/pt-br/library/618ayhy6.aspx Um pequeno curso gratuito de C# - http://www.oficinadanet.com.br/artigo/825/curso_de_c_sharp_licao_1_iniciando Operadores C# MSDN - http://msdn.microsoft.com/pt-br/library/ms173145.aspx ConnectionsStrings - http://www.connectionstrings.com/
- 75. 72 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Capítulo 4-Orientação a objetos A orientação a objetos é uma forma de se pensar em desenvolvimento de sistemas desde a sua modelagem até em sua concepção, como um agrupamento de objetos independentes análogos ao mundo real se comunicando em forma de mensagens. A análise de projeto orientada a objetos visa definir o melhor conjunto de objetos para descrever um sistema de software. O funcionamento desse sistema se dá pelo relacionamento entre esses objetos. A programação orientada a objetos esta fundamentada em quatro pilares sem os quais não se caracteriza. Vamos analisar cada um deles abaixo. Herança Consiste na possibilidade de classes compartilharem propriedades e métodos através da relação de herança. É utilizada com a intenção de evitar a repetição de código. Exemplo public class Pessoa { public string Nome { get; set; } //Método retorna dados marcado como virtual isso significa que pode ser sobrescrito pelas derivadas public virtual List<object> RetornarDados() { List<object> lst = new List<object>(); lst.Add(Nome); return lst; } } //A classe Cliente já tem a propriedade Nome e o método RetornaDados, pois herda da classe Pessoa public class Cliente : Pessoa { public DateTime UltimaCompra { get; set; } //A classe Cliente estende a classe pessoa adicionando na lista a propriedade UltimaCompra além do que já havia // sido adicionado pela classe base public override List<object> RetornarDados() { List<object> lst = base.RetornarDados(); lst.Add(UltimaCompra); return lst; } } //A classe fornecedor já tem a propriedade Nome e o método RetornaDados, pois herda da classe Pessoa public class Fornecedor:Pessoa { public string Categoria { get; set; } //A classe Fornecedor estende a classe pessoa adicionando na lista a propriedade Categoria além do que já havia // sido adicionado pela classe base public override List<object> RetornarDados() { List<object> lst = base.RetornarDados(); lst.Add(Categoria); return lst; } } Abstração Consiste em concentrar nos aspectos essenciais de um contexto qualquer, ignorando características menos importantes ou acidentais. Em modelagem orientada a objetos, uma classe é uma abstração de entidades existentes no domínio do sistema de software. Por exemplo, vamos abstrair uma pessoa temos uma série de características e ações que podem ser abstraídas, mas temos que escolher somente as que são significativas para o sistema.
- 76. 73 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# Encapsulamento Consiste na separação dos aspectos internos e externos de um objeto. Este mecanismo é utilizado amplamente para impedir o acesso direto ao estado do objeto(seus atributos), disponibilizando aos outros objetos apenas os métodos que fazem a acesso a esses objetos, no caso do C# os getters e setters que não deixam de ser métodos, apesar de na chamada ser parecida com o acesso a um atributo. Exemplo você não precisa conhecer a composição química e nem como é produzido um remédio para toma-lo, você apenas sabe o que ele se propõe a fazer e não se preocupa como ele faz isso. Polimorfismo Permite que uma mesma declaração de objeto contenha uma instância de uma classe derivada da mesma, sendo assim esse mesmo objeto se comporta de maneiras diferentes dependendo da instância passada a ele. Alguns autores consideram a sobrecarga de métodos como uma forma de polimorfismo. Exemplo Vamos utilizar as classes Cliente e Fornecedor do exemplo de herança, se declararmos um objeto pessoa e atribuir a ele uma instancia de Cliente o método RetornaDados se comportará de uma maneira se for uma instancia de Fornecedor se comportará de outro acompanhe no código abaixo: static void Main(string[] args) { Pessoa pess; pess = new Cliente(); pess.Nome = "jão"; //Como o objeto foi declarado com o tipo genérico para acessarmos membros da especialização //precisamos realizar um CAST. ((Cliente)pess).UltimaCompra = DateTime.Now; //Cliente ExibeDados(pess.RetornarDados()); /*Saida: jão * Hora atual: exemplo 23/08/2011 09:04 */ pess = new Fornecedor(); pess.Nome = "jão"; ((Fornecedor)pess).Categoria = "Farmaceutico"; //Fornecedor ExibeDados(pess.RetornarDados()); /*Saida: jão * Farmaceutico */ Console.ReadKey(); } static void ExibeDados(List<object> values) { foreach (object item in values) { Console.WriteLine(item.ToString()); } } Princípios A programação orientada a objetos tem seus pilares e não pode existir sem os mesmos, mas existem princípios que apesar de não fazer parte da sua concepção são extremamente importantes e desejáveis em sistema bem desenhados. Abaixo comentaremos sobre alguns dos mais importantes. SOLID Essa sigla é um acrônimo para a palavra inglesa “solid”, que significa sólido, solidez. Cada letra representa um acrônimo de um princípio, ou seja, temos um acrônimo de acrônimos. Esse conjunto é o resultado de estudos e experiências de vários desenvolvedores e foi primeiramente catalogado por Rober “Uncle bob” Martin(veja sessão de links) em seu livro “Applying Principle and Patterns”. Vamos conhecer cada princípio. S - Single responsibility principle (SRP) Este é o principio da responsabilidade única, que recomenda que uma classe só deva ter um motivo para sofrer alguma alteração. Sendo assim, podemos resumir que uma classe qualquer em seu sistema deva ter uma tarefa única e específica. Isso, contudo, não quer dizer que se tenha apenas um único método, mas que todos os métodos criados trabalhem juntos em um único objetivo,
- 77. 74 Apostila: Desenvolvimento de aplicações comerciais com Microsoft C# atender a responsabilidade da classe. Outros autores também chamam este princípio de coesão. Para entendermos o seu significado vamos imaginar um cenário que todos conhecem. Digamos que você possui uma classe que represente uma nota fiscal, a classe Nota-Fiscal. E você a codificou de tal forma que ela mesma, além de conter seus itens, seus cálculos, também sabe como se salvar e se recuperar do banco de dados até mesmo sabe se exportar nos mais diversos formatos. Se pararmos para pensar, temos uma série de responsabilidades agregadas que não deveriam ser da nota fiscal. Reparem que temos mais de um motivo para alterar a classe, por exemplo se mais um tipo de exportação aparecer teremos que refatorar nossa classe. O Ideal seriamos ter por exemplo um objeto exportador e ainda objetos específicos para cada formato de arquivo, deveríamos separar os métodos de gravação criar uma classe especifica para realizar as ações no banco O -Open closed principle(OCP) Este princípios é muito importante para se obter um bom design de software. Ele determina que suas classes(Classe de negócios, serviços etc.) devem ser abertas para extensão e fechadas para modificação. A ideia aqui é que você nunca altere uma classe que esteja em pleno funcionamento (salvo mudança de requisitos nela própria), mas sim, que possa estendê-la para ser reutilizada em outros cenários. Isto para evitar que bugs sejam adicionados ao que já está funcionando. Imagine que em um sistema seja necessário processar alguns pedidos de compra. Para isso então você desenvolve uma classe Pedido e uma classe ValidadorPedido. A classe ValidadorPedido é responsável por validar um pedido, indicando que o mesmo pode ser processado ou não. Por isso nela temos um método Validar. Nele estão todas as validações que um pedido, de acordo com a regra de negócio, pode sofrer. Caso algo não esteja correto isso é registrado em uma propriedade erros que se trata de uma string em forma de texto e o estado do pedido é então armazenado na propriedade EstaValido. Dessa forma caso uma nova regra de negócio aparecesse teríamos que alterar o Método Validar que está funcionando para adicionar a nova regra, o que fere o principio OCP o ideal seria termos uma interface que representa uma regra de validação com método Validar retornando uma string, na classe ValidadorPedido teríamos uma coleção de derivadas dessa interface e o Método Validar percorria cada uma dela chamando seu método validar. Sendo assim ao surgir uma nova regra criamos uma nova classe derivada da interface que representa uma regra de validação e adicionaríamos à lista da ValidadorPedido, assim adicionamos uma nova regra com menos risco de criar um bug. L- Liskov Substitution Principle(LSP) Este princípio diz que, se você possui um método ou função que utiliza outra classe, caso você passe para esse método uma derivação dessa mesma classe, esse método deverá continuar a funcionar conforme o esperado. Por Exemplo, você possui um método Impressão. Imprimir que deve listar os dados de uma Pessoa, supondo que a pessoa só tenha como propriedade Nome será isso que imprimirá, agora se tivermos uma especialização dessa classe chamada PessoaJurica que também tem a propriedade CNPJ, se chamarmos o método imprimir passando uma pessoa jurídica ele continuará a imprimir o nome da pessoa, mas esse resultado não corresponde a todos os dados de uma PessoaJuridica que também tem um CNPJ. Para adaptar esse cenário precisamos criar um método na classe Pessoa chamado retorna dados que pode ser sobrescrito pelas suas derivadas que retorna uma lista de string que representa os dados a serem impressos incluindo nessa lista somente o Nome e na classe PessoaJuridica sobrescreveríamos esse método adicionando também o CNPJ. No método Impressão.Imprimir chamamos esse método da classe pessoa e varremos a lista imprimindo todas as informações. I-Interface segregation principle(ISP) Este princípio está relacionado ao primeiro, SRP. Aqui o dito é que não devemos obrigar uma classe a implementar métodos de uma interface que ele não necessita. Isso cabe também a classes abstratas. Vamos imaginar que temos uma classe IObjetoNegócio que tem o método HouveAlteracao, todos nosso objetos necessitam desse comportamento? Essa interface está muito genérica seria melhor dividi-la melhor em módulos. D-Dependency inversion principle(DIP) A definição formal desse principio diz que módulo de alto nível não podem depender de módulo inferiores, mas que devem depender de abstrações. E que abstrações não devem depender de detalhes, mas os detalhes é que devem depender de abstrações. Vamos colocar tudo isso em uma linguagem mais objetiva: quando suas classes precisam de referências de outras classes, que essas sejam interfaces. A ideia é isolar nossa classe atrás de uma cerca bem definida. Essa cerca é a abstração na qual a classe depende. Estando presa a uma abstração e não a algo concreto, caso a implementação da abstração sofra alterações, a classes não sofrerá nada. Principios adicionais Dry-Don’t repeat yourself Não se repita. Duplicar uma lógica pelo sistema prejudica sua manutenção e estabilidade, porque caso você precise ajustar essa lógica que está duplicada, e esquecer algum ponto, seus sistema terá duas resposta diferentes para a mesma lógica. Kiss-Keep it simple stupid. Keep it simple stupid – Mantenha isso simples, idiota. O que esse princípio sugere é, codifique o código mais simples que resolva o problema. Código simples não significa código ruim, mas sim, simples mesmo. Um exemplo banal é que se você precisar percorrer uma lista do primeiro ao quarto elemento, o que você usa? Um comando For correto? Sim, mas tem gente que vai utilizar um while, para essa mesma tarefa. Porque complicar? E assim também para as demais rotinas de seu sistema, seja prático e simples, não complique o código (e seu entendimento) com desculpas de desempenho e processamento, a não ser é claro, que o desempenho seja significativamente diferente.