Apostila C#

Prévia do material em texto

Tratando eventos do mouse 
Imprimir 
Imagine uma situação em que você está em São Paulo tentando curtir 5 dias na praia no período das festas de fim de ano e após todo o engarrafamento do mundo você encontra-se trancado em uma casa com uma criança de 3 anos. Isto não é uma visão surreal, é apenas o efeito chuva!
Minha missão é arrumar alguma coisa para meu filho fazer enquanto esperamos avidamente pelo sol. O primeiro pensamento foi instalar alguns joguinhos em meu laptop, contudo sempre fui contra jogos em máquinas de trabalho e em face disto nem o paintbrush estava disponível.
Eis a solução que pensei, instalar o paintbrush! Depois de algumas tentativas frustradas, não nos restou outra alternativa – vamos ligar o Visual Studio.NET e fazer um.
Há muito tempo atrás já havia feito um com a ferramenta Delphi por motivo de estudo, por isso eu tinha em meu pensamento a certeza que mesmo não encontrando nada parecido no help off line do VS.NET, seria mais fácil de implementar em comparação ao Delphi por dois motivos: A classe System.Drawing e MouseEventHandler [1].
Após um breve estudo no help compreendi as diretrizes de meu desafio e mapeei as seguintes instruções:
Eventos do Mouse
Eventos do mouse (object sender, event arguments EventArgs)
MouseEnter – É disparado no momento em que o mouse entra na área de controle.
MouseLeave – É disparado no momento em que o mouse deixa a área de controle.
Eventos do mouse (object sender, event arguments MouseEventArgs)
MouseDown – É disparado se o botão do mouse é pressionado enquanto o cursor está na área de controle.
MouseHover – É disparado se o mouse “flutua” sobre a área de controle.
MouseMove – É disparado se o mouse for movido sobre a área de controle.
MouseUp – É disparado se o botão do mouse for liberado enquanto o cursor está na área de controle.
Classe MouseEventargs : Propriedades
Button – O botão do mouse que foi pressionado (left, right, middle ou none).
Clicks – O número de vezes que o mouse foi pressionado.
X – Coordenada.
Y – Coordenada.
Com estas instruções em mãos e o help aberto nos exemplos de System.Drawing, iniciamos nosso desenvolvimento propriamente dito, em outras palavras – colocamos a mão na massa.
Corretamente você leitor pode questionar sobre alguma especificação prévia, por mais singela que seja. Concordo plenamente com seu questionamento contudo eu, como a grande maioria dos programadores, sofremos do mal de IVSF[2] que nos impede de agir desta forma, tornando, talvez por um prazer “sadomasoquista”, as implementações mais difícies.
Como primeira ação, após estar com nosso projeto C# Windows Application preparado, conferimos o “cabeçalho” necessário ao desenvolvimento, ou seja, as classes que utilizaremos do .NET Framework.
O código é demonstrado na listagem 1.
Listagem 1. Declaração das classes que serão utilizadas.
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
Felizmente o próprio Template C# Windows Application nos provê as classes que necessitaríamos para este desenvolvimento, dispensando a inclusão manual.
Determinamos (organizando o pensamento) que precisamos de um controle que verifique se o mouse está ou não pressionado para pintar o formulário. Isso é útil para que nosso controle de desenho seja somente ativado se realmente o botão esquerdo do mouse está pressionado. Para escrever os códigos necessários, ativamos os eventos MouseDown e MouseUp através da janela de propriedades considerando que estamos com o form1 selecionado.
Verifique a implementação na listagem 2.
Listagem 2. Controle de estado do botão do mouse
bool shouldPaint = false;
private void Form1_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
{
shouldPaint = true;
}
private void Form1_MouseUp(object sender, System.Windows.Forms.MouseEventArgs e)
{
shouldPaint = false;
}
O pensamento seguinte, depois de alguns goles na latinha de cerveja, foi de desenhar no formulário enquanto o mouse se move e o botão está pressionado. 
Meu filho já estava insistentemente solicitando – Quero desenhar, papai... quero desenhar, papai...
Minha estratégia deveria ser rápida e suja, algo próximo a uma linha de código somente e imediatamente em seguida liberar para um desktop “todo acabado”[3] . Alguns parentes estavam chamando para irmos a praia comer alguns petiscos e eu verdadeiramente considerei a opção como a melhor proposta para a minha vida naquele instante, ou seja, escapar da confusão das crianças. Não que os parentes fossem “preferência”, mas a circunstância era dramática.
São estes os momentos mágicos de uma profissão que você ratifica suas escolhas e isso faz todo o sentido para uma enorme satisfação pessoal. Acredite, na primeira, mais na primeira busca navegando pelo help da classe, lá estava o código. “Olhando para mim como estivesse me dizendo – Ei, estou aqui e vou te salvar!”
Implementamos, um sentimento desejar muitos anos de vida ao .NET ecoou em meu pensamento com um sorriso estampado no rosto.
Verifique a implementação na listagem 3.
Listagem 3. Desenhando enquanto o mouse se move e esta pressionado
private void Form1_MouseMove(object sender, System.Windows.Forms.MouseEventArgs e)
{
if (shouldPaint)
{
Graphics graph = CreateGraphics();
graph.FillEllipse(new SolidBrush(Color.Blue), e.X, e.Y, 4, 4);
}
}
Compilado e superficialmente verificado, fiz questão de colocar para que meu filho fizesse a imagem que demonstraria o resultado. Eis um pai “coruja” e o desenho de seu filho utilizando o seu programa recém elaborado, conforme figura 1.
IMAGEM1
Figura 1. Programa para desenhar em execução.
Antes de permitir-me questionamentos, como por exemplo re-desenhos e outros mais, fui ao desejado encontro para os petiscos na praia (mesmo com chuva). Felizmente ninguém telefonou reclamando de bugs ou funcionalidades ausentes, acho que meu filho está muito novo para isso, e pude permanecer pelo resto da tarde em companhia da chuva, latinhas de cerveja e um camarão ao alho e óleo que proporcionou-me uma indisposição intestinal no dia seguinte.
Para compreender a “mágica” programada, necessitamos somente entender o método FillEllipse e seus quatro argumentos. Acreditamos que o método SolidBrush e a classe Color são intuitivas e liberam-nos do detalhamento na explicação.
O método FillEllipse possui como argumentos as duas coordenadas posicionais para o desenho, que fornecemos com o evento do mouse “ponto” X e Y, e as duas coordenadas que tratam sobre o tamanho do desenho, “height” e “width”, no qual fornecemos o valor 4 que significa 4 pixels cada. Maiores informações podem ser obtidas no help do Visual Studio .NET 2003 (ms-help://MS.VSCC.2003/MS.MSDNQTR.2004OCT.1033/cpref/html/frlrfSystemDrawingGraphicsMembersTopic.htm) e no livro “C# for experienced programmers” da Deitel.
Curso Básico de C# - Parte 1 
Imprimir 
Introdução
Este curso destina-se aqueles que desejam iniciar o aprendizado na linguagem C# desenvolvida especialmente para a plataforma .NET. Ao acompanhar este artigo você aprenderá a criar pequenos aplicativos para desktop.
Veremos aqui os conceitos básicos da linguagem C# e a IDE Visual Studio, para um melhor aproveitamento do .NET Framework.
Para um melhor entendimento dos artigos que se seguem, é importante conhecimento em lógica de programação.
A linguagem.
A linguagem de programação C# (lê-se C Sharp) surge como uma evolução da linguagem "C" e destina-se a aplicações utilizando o .NET Framework, utilizando os novos conceitos de Orientação a Objetos (OO).
O .NET Framework.
Basicamente definido como um componente integral do Windows responsável por fornecer os serviços necessários, para construção e carregamento de aplicações para Windows e Web.
O . NET Framework utiliza o CLR (Common Language Run Time) sendo uma base para o .NET Framework, disponibilizando:
•Interoperabilidade de linguagem;•Suporte de versões aprimorado;
•Segurança aprimorada;
•Garbage Collection.
Também utiliza o Framework Class Library (Biblioteca de Classes) e tem como agente um serviço de Run Time que gerencia o código durante a execução do aplicativo.
Definição de variáveis
Veremos aqui os tipos de variáveis mais utilizadas no desenvolvimento de softwares.
Variáveis são definidas como locais de armazenamento temporário de diferentes tipos como: números, palavras, datas e outros, que podem receber resultados de cálculos ou entrada de dados pelo usuário.
As variáveis devem receber um nome único (dentro de um escopo), para que seja usado como referência ao decorrer do desenvolvimento e deve ter um nome curto e de fácil memorização, não sendo recomendado utilizar variáveis com o mesmo nome diferenciando-as somente por maiúsculas e minúsculas. 
Exemplo: 
nomecliente
nomeCliente
Isso pode causar confusão para o desenvolvedor, ou seja, usualmente as variáveis são escritas com a primeira letra minúscula e se tiver mais de uma palavra a segunda palavra com a primeira letra maiúscula. 
Exemplo: 
nomeCliente
sobrenomeCliente
idadeCliente
Outra prática muito utilizada hoje pelas empresas para um melhor entendimento das variáveis e também para facilitar a manutenção do seu código é no início de cada variável inserir letras minúsculas indicando o tipo da variável que você declarou no inicio do código.
Exemplo: 
strNomeCliente (variável do tipo string)
intIdadeCliente (variável do tipo int)
Veja abaixo as variáveis mais utilizadas no desenvolvimento de softwares em C#:
Descrição dos tipos de dados:
int = Números inteiros (32 bits por padrão)
long = Números inteiros (64 bits por padrão)
float = Números de ponto flutuante (32 bits por padrão)
double = Números de ponto flutuante (63 bits por padrão)
decimal = Valores monetários (128 bits por padrão)
string = Para seqüências de caracteres (16 bits por caractere)
char = Para somente um caractere (16 bits)
bool = Valor booleano que pode ser (true) ou (false)
Para atribuição de valores as variáveis citadas acima você deve utilizar o sinal de (=) que se trata de um operador lógico que veremos nas próximas aulas.
Exemplos de uso das variáveis:
int intIdade = 10;
bool booFumante = false; 
decimal decPagamento = 1000;
double dblComissão = 1.27;
char chrSexo = M;
string strNome = "Einstein";
Ao término da declaração de cada variável deve-se usar (;) para que o Visual Studio entenda que ali se encerra a declaração da variável.
Curso Básico de C# - Parte 2 
Imprimir 
Operadores
Neste segundo artigo iremos falar sobre operadores e veremos alguns exemplos de utilização no desenvolvimento de software.
Operadores aritméticos:
Os operadores aritméticos abaixo são usados para efetuar cálculos.
“+” = Adição
“-“ = Subtração
“*” = Multiplicação
“/” = Divisão
“%” = Módulo (resto da divisão) 
Exemplo, na declaração de variáveis:
int a = 5;
int b = 15;
int c = 24;
int d = 30;
Exemplo das formas de cálculo:
Console.WriteLine (a + b);
Console.WriteLine (d – c);
Console.WriteLine (c * a);
Console.WriteLine (d / b);
Console.WriteLine (c % a);
Os resultados dos cálculos acima após a compilação resultarão respectivamente em:
20 
6
120
2
4 (Na utilização do módulo o resultado final será o resto da divisão de 24 por 5)
Operadores aritméticos de atribuição reduzida:
+= = Mais igual
-= = Menos igual
*= = Vezes igual
/= = Divisão igual
%= = Módulo igual
int a = 5;
a += 10; 
Quanto se executa a expressão acima o Visual Studio interpreta da seguinte forma:
a = a + 10;
a = 15;
Podendo ser usado todos os operadores de atribuição acima interpretados da mesma forma.
Operadores incrementais e decrementais:
Estes operadores tem a função de aumentar ou diminuir o valor exato "1" em uma variável.
• Incremental (++)
1. Pré-incremental:
Colocado o sinal antes da variável, será somado o valor "1" antes do restante da expressão.
Exemplo:
int x = 10;
Console.WriteLine (“Número inicial” +x.ToString());
Console.WriteLine (++x +5); (A ordem será: 10 + 1 = 11 e depois 11 + 5 = 16)
Após compilado os resultados serão respectivamente:
Número inicial: 10
16
2. Pós-incremental:
Colocado o sinal depois da variável, será feito o cálculo da expressão e depois a soma do valor "1".
Exemplo:
int x = 10;
Console.WriteLine (“Número inicial” +x.ToString());
Console.WriteLine (x++ +5); (A ordem será: 10 + 5 = 15)
Após compilado os resultados serão respectivamente:
Número inicial: 10
15
• Decremental (--)
1. Pré-decremental:
Colocado o sinal antes da variável, será subtraído o valor "1" antes do restante da expressão.
Exemplo:
int x = 10;
Console.WriteLine (“Número inicial” +x.ToString());
Console.WriteLine (--x +5); (A ordem será: 10 - 1 = 9 e depois 9 + 5 = 14)
Após compilado os resultados serão respectivamente:
Número inicial: 10
14
2. Pós-decremental: 
Colocado o sinal depois da variável, será feito o cálculo da expressão e depois a subtração do valor "1".
Exemplo:
int x = 10;
Console.WriteLine (“Número inicial” +x.ToString());
Console.WriteLine (x-- +5); (A ordem será: 10 + 5)
Após compilado os resultados serão respectivamente:
Número inicial: 10
15
Os operadores citados acima tem maior usabilidade em laços de repetição, que veremos nos próximos artigos publicados.
Operadores relacionais:
== = igual a
!= = Diferente de
> = Maior do que
< = Menor do que
>= = Maior ou igual a
<= = Menor ou igual a
Exemplo:
int a = 5;
int b = 9;
int c = 14;
int d = 9;
Console.WriteLine(b == d);
Console.WriteLine(c != d);
Console.WriteLine(c > d);
Console.WriteLine(d < c);
Console.WriteLine(b <= d);
Console.WriteLine(c >= a);
Após compilado os resultados mostrados serão de “True”, pois conforme os operadores acima usados e os valores das variáveis os indicadores são verdadeiros. Estes operadores tem maior usabilidade em condições que veremos nos próximos artigos publicados.
(Experimente efetuar a compilação trocando os valores das variáveis e verão que os resultados podem alternar entre “True” ou “False”). 
Operadores lógicos:
Os operadores lógicos tem o resultado booleano (true ou false), usados somente em expressões lógicas e são eles:
Exemplo:
&& - AND = Será usado quando todas as expressões tiverem que ser avaliadas como verdadeiras
int a = 10;
int b = 30;
int c = 10;
int d = 25;
Console.WriteLine (a < d) && (b != c);
Após compilado o resultado será:
TRUE
|| - OR = Será usado quando somente umas das expressões tiver que ser avaliada como verdadeira.
int a = 10;
int b = 30;
int c = 10;
int d = 25;
Console.WriteLine (a > d) || (b != c);
Após compilado o resultado também será:
TRUE - Mesmo a primeira expressão sendo falsa.
! - NOT = Será usado para inverter a lógica de uma expressão.
Console.WriteLine(! (a >= b);
Após compilado o resultado será:
TRUE - A expressão (a >= b) teria o resultado de “False”, mas utilizando o operador (! ) o resultado é invertido.
Terminamos por aqui o segundo artigo sobre “operadores” que utilizaremos em nosso próximo artigo sobre condições e laços de repetição.
Curso Básico de C# - Parte 3 
Imprimir 
Neste terceiro artigo veremos os comandos de decisão, usaremos os operadores que estudamos no artigo anterior para demonstrar alguns exemplos.
Os comandos de decisão um fluxo de informações, para que possamos controlar esse fluxo utilizamos os caracteres ({}), esse fluxo chamamos de comandos em bloco, que podem ser únicos ou aninhados.
1 - Comandos de decisão:
Os comandos de decisão que utilizamos nos blocos são:
IF/ELSE 
Estes comandos verificarão se uma situação é verdadeira ou falsa, para que possam executar uma determinada função.
Começaremos estudando os comandos IF/ELSE:
Podemos determinar estas duas palavras como:
IF = SE
ELSE = SENÃO 
Então utilizamos oscomandos na seguinte estrutura:
if (Condição)
{
Comandos
}
else
{
Comandos
}
Como citamos anteriormente os caracteres ({}) abrem e fecham um bloco, no exemplo acima o Visual Studio irá verificar o primeiro bloco, se o resultado da verificação for "TRUE" os comandos dentro daquele bloco serão executados, caso contrário o Visual Studio executará o segundo bloco.
Exemplo:
int a = 10;
int b = 15;
int c = 20;
int d = 25;
if (a==b)
{
Console.WriteLine("Condição 1 verdadeira");
}
else
{
Console.WriteLine("Condição 2 verdadeira");
} 
Conforme exemplo acima a primeira condição tem o resultado de "FALSE", sendo assim o Visual Studio executa a segunda condição, aparecendo neste exemplo acima a mensagem: "Condição 2 verdadeira".
Podemos ter vários blocos para verificação de condições.
Exemplo:
int a = 10;
int b = 15;
int c = 20;
int d = 25;
if (a == b)
{
Console.WriteLine("Execute o primeiro bloco");
}
else if (a > d)
{
Console.WriteLine("Execute o segundo bloco");
}
else
{
Console.WriteLine("Execute o terceiro bloco");
}
Neste novo exemplo é mostrado que podemos declarar mais de uma condição com o comando "else if" ou seja "senão se".
Até agora somente vimos exemplos que os primeiros blocos tem como resultado "FALSE", se o primeiro bloco de condição tiver como resultado "TRUE", os outros blocos serão ignorados pelo Visual Studio.
Veremos agora um exemplo de blocos aninhados:
int a = 10;
int b = 15;
int c = 20;
int d = 25;
if (a < b)
{
if (a == b)
{
Console.WriteLine("Execute o primeiro bloco");
}
else if (a > d)
{
Console.WriteLine("Execute o segundo bloco");
}
else
{
Console.WriteLine("Execute o terceiro bloco");
}
}
else 
{
Console.WriteLine("Ignore o bloco acima")
}
Neste exemplo acima é feito um exemplo de bloco aninhado, ou seja, bloco dentro de outro bloco, para que o bloco interno seja executado, é necessário que o primeiro "IF" ou bloco externo seja "TRUE", caso contrário será executado o "ELSE" do bloco externo.
Curso Básico de C# - Parte 4 
Imprimir 
Neste quarto artigo veremos os comandos de decisão SWITCH/CASE, usaremos os exemplos do segundo artigo para demonstrar alguns exemplos.
Usando a instrução SWITCH você pode simular assim como no IF/ELSE a utilização de várias instruções, podendo somente verificar uma relação de igualdade (==), 
não se pode usar os operadores (&&, || ou !) os quais vimos no segundo artigo.
A instrução CASE avalia o argumento que apresenta o tipo definido na instrução SWITCH, caso mais de uma condição seja igual ela não será válida.
Exemplo:
int media;
Console.WriteLine ("Digite a média do aluno:");
media = Convert.ToInt32(Console.ReadLine());
switch(media)
{
case 1:
Console.WriteLine ("Aluno reprovado");
break;
case 2:
Console.WriteLine ("Aluno reprovado");
break;
case 3:
Console.WriteLine ("Aluno reprovado");
break;
case 4:
Console.WriteLine ("Aluno reprovado");
break;
case 5:
Console.WriteLine ("Aluno reprovado");
break;
case 6:
Console.WriteLine ("Aluno aprovado");
break;
case 7:
Console.WriteLine ("Aluno aprovado");
break;
case 8:
Console.WriteLine ("Aluno aprovado");
break;
case 9:
Console.WriteLine ("Aluno aprovado");
break;
case 10:
Console.WriteLine ("Aluno aprovado");
break;
}
Acima vemos que ao receber o valor digitado pelo usuário na variável "media", é usado o comando CONVERT.TOINT32, o qual veremos em artigos futuros.
Assim como nos comandos IF/ELSE é necessário o uso dos caracteres ({}) para o controle do fluxo das informações.
Devemos sempre usar o comando BREAK para separar cada condição, finalizando o caso anterior.
No exemplo anterior vimos 10 condições, veremos abaixo um exemplo o qual tem um valor DEFAULT, que caso nenhuma condição seja a do CASE correspondente.
Exemplo:
string dia;
Console.WriteLine("Digite um dia da semana");
dia = Console.ReadLine();
switch(dia)
{
case "segunda":
Console.WriteLine("Primeiro dia da semana.");
break;
case "terca":
Console.WriteLine("Segundo dia da semana.");
break;
case "quarta":
Console.WriteLine("Terceiro dia da semana.");
break;
case "quinta":
Console.WriteLine("Quarto dia da semana.");
break;
case "sexta":
Console.WriteLine("Quinto dia da semana.");
break;
case "sabado":
Console.WriteLine("Sexto dia da semana.");
break;
case "domingo":
Console.WriteLine("Sétimo dia da semana.");
break;
default:
Console.WriteLine("Dia da semana inexistente"); 
break;
}
Quando utilizamos valores como uma string no CASE é necessário utilizar ("").
Curso Básico de C# - Parte 5 
Imprimir 
Neste quinto artigo veremos sobre laços de repetição, os quais são utilizados para repetir um bloco de execução até que uma determinada condição seja verdadeira ou uma quantidade de vezes seja satisfeita.
Começaremos pelo comando WHILE, que é usado quando não sabemos quantas vezes é necessário repetir um bloco para que obtenhamos uma condição verdadeira, essa condição de retorno deve ser booleana.
Exemplo:
int numero = 0;
while (numero < 1500)
{
numero += 10;
Console.WriteLine (“Valor de número é: “ +numero);
}
O Visual Studio verifica o valor da variável e o valor a se alcançar que em nosso caso é 1500, assim efetua a soma de 10 em 10 até que o valor da variável iguale o valor da condição 1500, quando isso acontecer a condição torna-se falsa finalizando o laço de repetição
Se a instrução “Console.WriteLine” estiver dentro do bloco será demonstrado cada número somado, caso esteja fora do bloco de execução, será mostrado somente o valor final de 1500.
int numero = 1510;
while (numero < 1500)
{
numero += 10;
Console.WriteLine (“Valor de número é: “ +numero);
}
No exemplo acima o valor da variável é maior do que o valor da condição, neste caso o Visual Studio não efetua a execução deste bloco.
Do/While
O comando DO/WHILE tem o mesmo funcionamento que o comando WHILE, tendo como única diferença que mesmo que a variável tenha um valor maior do que o valor da condição, ele será executado ao menos uma vez.
Exemplo:
int num = 10;
do
{
num += 5;
Console.WriteLine("valor de número é: " + num);
}
while (num > 100);
No exemplo acima será efetuado a soma do número 5, mesmo que a condição num>100 seja falsa.
Podemos testar o processo invertendo a condição.
Exemplo:
int num = 10;
do
{
num += 5;
Console.WriteLine("valor de número é: " + num);
}
while (num < 100);
No exemplo acima a condição DO/WHILE assume o mesmo funcionamento do WHILE, efetua a soma do número 5 acumulando o valor até chegar ao número 100.
Curso Básico de C# - Parte 6 
Imprimir 
Neste sexto artigo continuaremos a ver sobre laços de repetição, os quais são utilizados para repetir um bloco de execução até que uma determina condição seja verdadeira ou uma quantidade de vezes seja satisfeita.
O comando FOR é utilizado quando sabemos o número de vezes que um bloco deve se repetir, para que seja concluída uma condição.
Exemplo:
for(int a = 0; a < 20; a++)
{
Console.WriteLine(a.ToString());
}
No exemplo acima declaramos uma variável “a” que inicializa seu valor em “0” e efetuará a execução do bloco até que o valor da variável alcance o valor solicitado (a<20).
Caso seja necessário a declaração e inicialização de mais de uma variável, às dividimos por vírgulas, como mostra o exemplo abaixo:
for(int a = 0, b = 1; ((a < 10) && (b < 10)); a++,b++)
{
Console.WriteLine(“O valor de a é: “ + a.ToString());
Console.WriteLine(“O valor de b é: ” + b.ToString());
}
Podemos efetuar a declaração da variável fora do laço.
Exemplo:
int a;
for (a = 0; a < 10; a++)
{
Console.WriteLine(a.ToString());
}
Declarando a variável fora do laço podemos exibi-la fora, exibindo-a fora do laço de repetição será exibido somente o valor final.
Curso Básico de C# - Parte 7 
Imprimir 
Neste artigo iremos aprender como utilizar os comandos BREAK e CONTINUE utilizando-os nos comandos de laço derepetição e condicionais que vimos nos artigos anteriores.
BREAK
Quando o comando BREAK é utilizado ele interrompe o laço assim que a condição desejada é atendida, fazendo o programa efetuar a leitura da próxima linha após o laço.
Exemplo:
int number;
for (number = 0; number < 10; ++number)
{
if (number == 7)
break;
Console.WriteLine (“ O valor de number é: “ + number.ToString());
}
Console.WriteLine (“Mensagem após o laço”);
No exemplo acima mesmo o laço FOR solicitando a condição “number < 10”, assim que a condição do IF for alcançada o laço é interrompido, não mostrando a frase (“O valor de number é: “ +number), fazendo assim o programa efetuar a leitura da linha (“Mensagem após o laço”).
Exemplo:
int number = 0;
while (number < 1000)
{
number +=5;
if (number == 270)
break;
Console.WriteLine (“O valor de number é: “ +number)
}
Console.WriteLine (“Mensagem após o laço”)
Acima um exemplo com laço de repetição com utilização do comando WHILE, ele solicita que o laço se repita por até 1000 vezes, mas alcançando a condição de if (number == 270) o comando BREAK interrompe o laço, efetuando a leitura da linha após o laço (“Mensagem após o laço”) .
Você pode efetuar o teste retirando o comando BREAK de ambos os exemplos e verá que aparecerá no monitor ambas as linhas de mensagem.
CONTINUE
O comando CONTINUE somente é utilizado em laços de repetição, mesmo havendo uma condição no meio do laço como nos exemplos anteriores, ele termina de executar todo o laço.
Exemplo:
int number = 0;
while (number < 1000)
{
number += 1;
if (number == 270)
{
continue;
}
Console.WriteLine("O número é: " + number); 
} 
No exemplo acima há uma condição de IF, mas devido ao comando CONTINUE o laço termina todo o seu processo.
Exemplo:
int number;
for (number = 0; number < 10; ++number)
{
if (number == 7)
{
continue;
}
Console.WriteLine ("O valor de number é: " +number);
}
No laço FOR ocorre da mesma forma, o laço é executado completamente mesmo sendo utilizada em meio ao laço uma condição.
Ao contrário do comando BREAK que faz o programa parar a execução do laço, o comando CONTINUE força que o mesmo seja executado até o final.
Curso Básico de C# - Parte 8 
Imprimir 
NAMESPACE
Neste artigo iremos aprender sobre as funcionalidades de um NAMESPACE.
Quando se efetua o desenvolvimento de um software o crescimento de códigos acontece a cada dia, o que torna mais difícil a sua compreensão.
Havendo uma grande quantidade de códigos, costumamos utilizar mais nomes (classes, métodos e dados nomeados). Isso pode provocar um conflito entre dois ou mais nomes e gerar uma falha de desenvolvimento aumentando ainda mais, quando se utiliza bibliotecas de terceiros.
Podemos diminuir os conflitos utilizando prefixos qualificadores, mas também existe a desvantagem de deixar os nomes mais extensos, o que faz com que os programadores percam mais tempo digitando, sendo assim define-se que este método não é escalonável.
Com a utilização do NAMESPACE o conflito é resolvido, cria-se um contêiner nomeado para outros identificadores, como classes. Pode haver duas classes de mesmo nome, estando elas uma em cada NAMESPACE não haverá conflito.
Vamos tomar como exemplo a classe SqlConnection encontra-se no NAMESPACE System.Data.SqlClient que agrupa todas as classes relacionadas ao SQLServer, portanto o nome desta classe é System.Data.SqlClient.SqlConnection.
O comando using é usado para especificar uma NAMESPACE.
Exemplo:
using System.Windows.Forms;
class MinhaClasse
{
void Main()
{
MessageBox.Show(“Minha mensagem”);
}
}
Sem a utilização do comando using teriamos que digitar a seguinte sintaxe:
{
void Main()
{
System.Windows.Forms.MessageBox.Show(“Minha mensagem”);
}
}
Curso Básico de C# - Parte 9 
Imprimir 
Classes
Definimos as classes como sendo conjuntos de objetos que são agrupados por terem similaridades de comportamento e características.
Contamos no .NET com as classes, que servem como base para quando o código for implementado, essas classes são modelo, mas não temos a implementação de códigos específicos, somente a estrutura e comportamento referente a classe.
Para compreender as classes, consideremos a necessidade de criar um objeto Carro, listaremos as características que um Carro tem:
Nome do objeto: Carro (modelo)
Características: cor, marca (atributos)
Agora veremos como declarar um classe em C#:
class Carro
{
string sCor;
string sMarca;
}
Curso Básico de C# - Parte 10 
Imprimir 
Antes de começar é importante entendermos o que o visual studio tem para nos ajudar. Você pode observar a figura abaixo que se chama "Start Page".
Nesta figura temos ao lado direito uma caixa onde ficam o "Solution Explorer", que nos mostra todos os itens adicionados ao projeto, e a "Properties" esta por sua vez nos mostra todas as propriedades do controle selecionado.
Ao lado esquerdo uma caixa onde esta escrito "Recent Project", como não foi criado nenhum projeto ainda esta caixa esta em branco, vamos então usar a opção "Create: Project..."
Vamos escolher entre os templates do Visual C# na subdivisão Windows a opção "Windows Forms Application", definir o nome do projeto como "Controles" e clicar em "OK".
Feito isso a "Solution Explorer" ao lado direito nos mostrará o projeto criado com apenas um formulário criado chamado Form1 por padrão, é nele que vamos trabalhar! E para isso basta clicar duas vezes em cima do Form1 para que ele se abra.
Quando o Form1 estiver aberto click apenas uma vez em cima dele para que a janela "Properties" se carregue com suas propriedades, se você clicar duas vezes nele abrirá a janela de código, onde você codifica o formulário, mas não veremos isso agora. Vamos estudar a janela de propriedades.
A propriedade mais importante aqui é a "Name", que é propriemamente o nome que damos ao controle para utilizarmos via código!
A propriedade AcceptButton é onde denominamos qual o botão é o botão padrão, ou seja quando apertamos ENTER o botão especificado aqui é apertado automaticamente.
BackColor é a cor de fundo do formulário, ou a cor da parede, e ForeColor a cor das fonte ou das palavras que aqui escreveremos.
Também podemos usar a propriedade BackgroundImage para ler imagens do tipo GIF, JPG, BMP e PNG.
BackgroundImageLayout define como a figura será carregada no fundo do formulário, em modo título, em modo esticado, etc.
CancelButton é semelhante ao AcceptButton porém funciona quando a tecla ESC é pressionada.
ControlBox desativa os controles do formulário para maximizar, minimizar e fechar. Assim como a função de mover o formulári.
FormBorderStyle muda as configurações de visualização da caixa, se ela aparece com mais ou menos relevo, em formato 3D, ou ainda se é em formato fixo ou se o usuário pode mudar seu tamanho.
Icon é usado para definirmos um ícone para este formulário, aqui usei um ícone meu para personalizar o meu formulário, pode ser usado qualquer imagem do tipo ICO.
IsMdiContainer configura este formulário para que outros abram e sejam filhos dentro dele, ou seja vira um container.
MaximizeBox permite ou não ao usuário maximizar a caixa.
MinimizeBox permite ou não ao usuário minimizar a caixa.
Opacity define quanto do formulário será transparente em porcetagem.
ShowIcon define se mostra o ícone escolhido ou não.
ShowInTaskbar define se este formulário será mostrada na barra de tarefas ao lado do botão iniciar do windows.
Size define a largura e a altura do formulário.
StartPosition define como o formulário será aberto, na última posição, centralizado, etc.
Text, texto que aparece na barra de título.
WindowState, define o modo como o formulário abrirá, maximizado, minimizado, etc.
Vimos aqui que poucas alterações conseguimos fazer um formulário personalizado rapidamente!
Curso Básico de C# - Parte 11 
Imprimir 
Usando o projeto Controles do artigo anterior,onde temos o formulário de nome "frmPrimeiroFormulario", vamos abrir a "ToolBox" onde encontramos o controle chamado "Button".
Basta arrastá-lo segurando-o com o mouse. E você terá um novo controle no formulário como mostra a figura abaixo.
Selecionando este controle vemos que a janela de propriedades se re-configura e podemos mudar suas configurações, veja, aqui temos:
Name, é o nome do controle, nome que usaremos para referenciá-lo quando estivermos codificando. Aqui chamei de btnHelloWorld.
BackColor é a cor de fundo do formulário, ou a cor da parede, e ForeColor a cor das fonte ou das palavras que aqui escreveremos.
Também podemos usar a propriedade BackgroundImage para ler imagens do tipo GIF, JPG, BMP e PNG.
BackgroundImageLayout define como a figura será carregada no fundo do botão, em modo título, em modo esticado, etc.
Dock, define se queremos o componente literalmente grudado em um ou mais cantos.
Enabled, define se este botão esta habilitado ou não, ou seja, se o usuário pode usá-lo ou não.
Image, semelhante ao BackgroundImage, só que aqui colocamos uma imagem que não cubrirá o fundo todo, apenas uma pequena imagem, como um ícone.
Location, define a posição Top (distância do botão em relação a margen superior do formulário) e a posição Left (distância do botão em relação a margen esquerda do formulário)
Size, define a largura e a altura do botão.
TabIndex, define a ordem que este controle esta em relação aos demais controles do formulário quando apertamos a tecla TAB para mudar de controle.
TabStop, define se ao apertarmos a tecla TAB o FOCO irá para neste controle ou se para para o próximo ignorando a TabIndex.
Text, texto apresentado ao usuário de modo a ele entender para que serve o botão.
Visible, define se este botão esta visível ou não, ou seja, se o usuário pode usá-lo ou não.
Após algumas modificações temos um botão personalizado.
Se clicar-mos duas vezes em cima dele podemos mudar o evento, ou seja, o código que é executado quando clicar-mos nele.
Aqui vou definir o código como uma simples exibição da mensagem "Hello World".
Agora basta apertar a tecla F5 para ver a aplicação rodando, e quando clicamos no botão, ele exibe a mensagem, como esta escrito em seu evento CLICK.
Curso Básico de C# - Parte 12 
Imprimir 
Usando o projeto Controles do artigo anterior, onde temos o formulário de nome "frmPrimeiroFormulario", vamos abrir a "ToolBox" onde encontramos o controle chamado "TextBox".
Basta arrastá-lo segurando-o com o mouse. E você terá um novo controle no formulário como mostra a figura abaixo.
Selecionando este controle vemos que a janela de propriedades se re-configura e podemos mudar suas configurações, veja, aqui temos:
Name, é o nome do controle, nome que usaremos para referenciá-lo quando estivermos codificando. Aqui chamei de txtNome.
BackColor é a cor de fundo do formulário, ou a cor da parede, e ForeColor a cor das fonte ou das palavras que aqui escreveremos.
Dock, define se queremos o componente literalmente grudado em um ou mais cantos.
Enabled, define se esta TextBox esta habilitada ou não, ou seja, se o usuário pode usá-lo ou não.
Image, semelhante ao BackgroundImage, só que aqui colocamos uma imagem que não cubrirá o fundo todo, apenas uma pequena imagem, como um ícone.
AutoCompleteSource, dados utilizados para que o texto se auto complete.
AutoCompleteMode, define o modo como o texto será auto completado, modo sugestão, modo anexo, etc.
CharacterCasing, muda a forma como o texto é apresentado, todo o texto em letras maísculas, ou letras minúsculas, ou como o usuário digitar. 
MaxLenght, tamanho máximo em número de caracteres.
Multiline, abrange o uso da tecla para que seja possível o uso de quebra de linha.
PasswordChar, caracter que é utilizado quando estamos usando o TextBox para coletar informações de senha, ou seja, quando não queremos mostrar o que esta sendo escrito.
Location, define a posição Top (distância do TextBox em relação a margen superior do formulário) e a posição Left (distância do TextBox em relação a margen esquerda do formulário)
ReadOnly, mostra o texto mas não permite que seja alterado.
TabIndex, define a ordem que este controle esta em relação aos demais controles do formulário quando apertamos a tecla TAB para mudar de controle.
Size, define a largura e a altura do controle.
Text, é o texto que esta na caixa, através desta propriedade podemos colocar ou pegar a informação.
TextAlign, define se o texto será colocado a direita ou a esquerda ou centralizado.
Com algumas simples modificações, temos um TextBox customizado e pronto para coletar o nome do usuário.
Curso Básico de C# - Parte 13 
Imprimir 
Usando o projeto Controles do artigo anterior, onde temos o formulário de nome "frmPrimeiroFormulario", vamos abrir a "ToolBox" onde encontramos o controle chamado "Label".
Basta arrastá-lo segurando-o com o mouse. E você terá um novo controle no formulário como mostra a figura abaixo.
Selecionando este controle vemos que a janela de propriedades se re-configura e podemos mudar suas configurações, veja, aqui temos:
Name, é o nome do controle, nome que usaremos para referenciá-lo quando estivermos codificando. Aqui chamei de lblNome.
BackColor é a cor de fundo do formulário, ou a cor da parede, e ForeColor a cor das fonte ou das palavras que aqui escreveremos.
Dock, define se queremos o componente literalmente grudado em um ou mais cantos.
Enabled, define se esta label esta habilitada ou não, ou seja, se o usuário pode usá-lo ou não.
Image, semelhante ao BackgroundImage, só que aqui colocamos uma imagem que não cubrirá o fundo todo, apenas uma pequena imagem, como um ícone.
Location, define a posição Top (distância do controle em relação a margen superior do formulário) e a posição Left (distância do controle em relação a margen esquerda do formulário)
Size, define a largura e a altura do controle.
Text, é o texto que esta na caixa, através desta propriedade podemos colocar ou pegar a informação.
TextAlign, define se o texto será colocado a direita ou a esquerda ou centralizado.
Com algumas simples modificações, temos uma Label customizada que auxilia o usuário no entendimento do que ele deve escrever no TextBox abaixo dela.
Curso Básico de C# - Parte 14 
Imprimir 
Usando o projeto Controles do artigo anterior, onde temos o formulário de nome "frmPrimeiroFormulario", vamos abrir a "ToolBox" onde encontramos o controle chamado "ComboBox".
Basta arrastá-lo segurando-o com o mouse. E você terá um novo controle no formulário como mostra a figura abaixo.
Selecionando este controle vemos que a janela de propriedades se re-configura e podemos mudar suas configurações, veja, aqui temos:
Name, é o nome do controle, nome que usaremos para referenciá-lo quando estivermos codificando. Aqui chamei de lblNome.
AutoCompleteMode, define a forma como o Text do ComboBox sugere um item a ser selecionado.
AutoCompleteSource, é a lista onde temos os valores que serão usados para a sugestão de auto preenchimento.
BackColor é a cor de fundo do formulário, ou a cor da parede, e ForeColor a cor das fonte ou das palavras que aqui escreveremos.
DataSource, se temos uma fonte de dados como uma DataTable, podemos usar aqui.
DisplayMember, se usarmos a propriedade DataSource, como sugerido acima com um DataTable, teremos várias colunas na tabela, então definimos qual das colunas será a informação que o usuário irá enxergar.
ValueMember, como a DisplayMember define qual informação o usuário ve, aqui definimos qual informação é útil ao sistema, por exemplo o IdUsuario. Ou seja o valor que aquela informação representa para o sistema.
Dock, define se queremos o componente literalmente grudado em um ou mais cantos.
Enabled, define se este ComboBox esta habilitado ou não, ou seja, se o usuário pode usá-lo ou não.Location, define a posição Top (distância do controle em relação a margen superior do formulário) e a posição Left (distância do controle em relação a margen esquerda do formulário)
Text, é a informação selecionada. Também pode ser usado como se fosse um TextBox.
DropDownStyle, modo como o combo funciona, sendo uma lista somente leitura, lista com TextBox, ou somente um TextBox.
Items, lista de valores que o ComboBox disponibiliza ao usuário para seleção.
Size, define a largura e a altura do controle.
Veja como é fácil alimentar a lista de itens do ComboBox, na propriedade Items, ao lado da palavra (Collection), clique nos três pontos a direita.
Será aberto um editor para gerar uma coleção de strings possibilitando a criação de uma lista, veja.
Assim na propriedade AutoCompleteSource, podemos dizer ao ComboBox para consultrar em sua própria lista.
Quando rodamos a aplicação vemos que os dados automaticamente são lançados como opção de escolha para nós.
E se começarmos a digitar uma palavra que conste nesta lista o ComboBox sugere a palavra existe utilizando a função AutoComplete.
Curso Básico de C# - Parte 15 
Imprimir 
Usando o projeto Controles do artigo anterior, onde temos o formulário de nome "frmPrimeiroFormulario", vamos abrir a "ToolBox" onde encontramos o controle chamado "ListBox".
Basta arrastá-lo segurando-o com o mouse. E você terá um novo controle no formulário como mostra a figura abaixo.
Selecionando este controle vemos que a janela de propriedades se re-configura e podemos mudar suas configurações, veja, aqui temos:
Name, é o nome do controle, nome que usaremos para referenciá-lo quando estivermos codificando. Aqui chamei de lstEnderecos.
BackColor é a cor de fundo do formulário, ou a cor da parede, e ForeColor a cor das fonte ou das palavras que aqui escreveremos.
DataSource, se temos uma fonte de dados como uma DataTable, podemos usar aqui.
DisplayMember, se usarmos a propriedade DataSource, como sugerido acima com um DataTable, teremos várias colunas na tabela, então definimos qual das colunas será a informação que o usuário irá enxergar.
ValueMember, como a DisplayMember define qual informação o usuário ve, aqui definimos qual informação é útil ao sistema, por exemplo o IdUsuario. Ou seja o valor que aquela informação representa para o sistema.
Dock, define se queremos o componente literalmente grudado em um ou mais cantos.
Enabled, define se este controle esta habilitado ou não, ou seja, se o usuário pode usá-lo ou não.
Location, define a posição Top (distância do controle em relação a margen superior do formulário) e a posição Left (distância do controle em relação a margen esquerda do formulário)
Items, lista de valores que o controle disponibiliza ao usuário para seleção.
Size, define a largura e a altura do controle.
MultiColumn, se precisarmos separar as informações em mais de uma coluna, bem semelhante a uma grid! (veremos a grid mais a frente)
SelectionMode, aqui definimos se a lista permitirá escolher um ou mais itens de uma só vez.
Veja como é fácil alimentar a lista de itens deste controle, na propriedade Items, ao lado da palavra (Collection), clique nos três pontos a direita.
Será aberto um editor para gerar uma coleção de strings possibilitando a criação de uma lista, veja.
Assim configurada a ListBox oferece ao usuário uma lista de opções que onde ele pode escolher entre os valores predefinidos.
Veja mais um exemplo abaixo.
Curso Básico de C# - Parte 16 
Imprimir 
Usando o projeto Controles do artigo anterior, onde temos o formulário de nome "frmPrimeiroFormulario", vamos abrir a "ToolBox" onde encontramos o controle chamado "ToolTip".
Basta arrastá-lo segurando-o com o mouse. E você terá um novo controle no formulário como mostra a figura abaixo.
Selecionando este controle vemos que a janela de propriedades se re-configura e podemos mudar suas configurações, veja, aqui temos:
Name, é o nome do controle, nome que usaremos para referenciá-lo quando estivermos codificando. Aqui chamei de ttpPrimeiro, em referência ao formulário ao qual ele pertence.
Active, define se este controle esta habilitado ou não, ou seja, se o usuário verá seu funcionamento ou não.
AutomaticDelay, define o tempo em milisegundos para os demais delays abaixo de forma automática, sendo 10x o valor para AutoPopDelay, igual para InitialDelay e 1/5 para ReshowDelay.
AutoPopDelay, tempo em milisegundos para que a informação saia da tela.
InitialDelay, define o tempo em milisegundos para que a informação apareça.
ReshowDelay, tempo em milisegundos que necessário para o controle ficar disponível a reaparecer!
IsBallon, mostra a informação em um balão.
ShowAlways, o padrão é falso, porém desta maneira a informação só aparecerá uma única vez no formulário, se queremos visualizar mais vezes devemos usar esta opção como verdadeira.
OBS - Importante lembrar que não é necessário mais que um ToolTip em um formulário e você verá agora o porque.
Tendo configurado este componente corretamente ele extenderá as propriedades dos botões que o formulário contém. Assim podemos usar o botão que ja temos no formulário. Veja.
Temos uma nova propriedade chamada "ToolTip on ttpPrimeiro", ou seja o ToolTip deste botão será utilizado atravéz do controle ToolTip. e como só visualizamos uma informação por vez só precisamos de um controle ToolTip no formulário. 
Onde definirei a informação como "Cuidado ao apertar!!!"
E quando rodamos a aplicação e colocamos o mouse em cima do botão temos a informação em um balão como mostra a figura abaixo.
Curso Básico de C# - Parte 17 
Imprimir 
Usando o projeto Controles do artigo anterior, onde temos o formulário de nome "frmPrimeiroFormulario", vamos abrir a "ToolBox" onde encontramos o controle chamado "GroupBox".
Basta arrastá-lo segurando-o com o mouse. E você terá um novo controle no formulário como mostra a figura abaixo.
Selecionando este controle vemos que a janela de propriedades se re-configura e podemos mudar suas configurações, veja, aqui temos:
Name, é o nome do controle, nome que usaremos para referenciá-lo quando estivermos codificando. Aqui chamei de gpPrimeiro.
BackColor é a cor de fundo do formulário, ou a cor da parede, e ForeColor a cor das fonte ou das palavras que aqui escreveremos.
AutoSize, se verdadeiro o controle é redimensionado automaticamente.
Dock, define se queremos o componente literalmente grudado em um ou mais cantos.
Enabled, define se este controle esta habilitado ou não, ou seja, se o usuário pode usá-lo ou não.
Location, define a posição Top (distância do controle em relação a margen superior do formulário) e a posição Left (distância do controle em relação a margen esquerda do formulário)
Text, define o texto que aparece logo acima do controle.
Size, define a largura e a altura do controle.
Visible, define se o controle aparece no formulário ou não.
Assim configurada a GroupBox oferece ao usuário uma forma mais organizada de mostrar os componentes.
Aqui coloquei dois RadioButton para melhor ilustrar este controle (veremos as funcionalidades do RadioButton mais a frente).
Para uma pequena demonstração de potencial, veja que se clicarmos em qualquer dos RadioButtons da tela o GroupBox gbPrimeiro terá sua propriedade Enabled setada para False, o que automaticamente muda as propriedades Enabled do controles que estão dentro dele. Veja. 
Aqui o controle, esta habilitado, logo após termos dado início a execução do sistema.
Logo após clicarmos em um dos RadioButtons, o GroupBox gbPrimeiro se desabilita, desabilitando os demais controles, veja.
Curso Básico de C# - Parte 18 
Imprimir 
Usando o projeto Controles do artigo anterior, onde temos o formulário de nome "frmPrimeiroFormulario", vamos abrir a "ToolBox" onde encontramos o controle chamado "RadioButton".Basta arrastá-lo segurando-o com o mouse. E você terá um novo controle no formulário como mostra a figura abaixo.
Aqui eu coloquei três para testarmos de maneira eficiente!
Selecionando este controle vemos que a janela de propriedades se re-configura e podemos mudar suas configurações, veja, aqui temos:
Name, é o nome do controle, nome que usaremos para referenciá-lo quando estivermos codificando. Aqui chamei de rb1Mes, rb2Meses e rb3Meses.
Appearance, forma como o controle é mostrado ao usuário, normal como todos costumam utilizar ou em forma de botão.
BackColor é a cor de fundo do formulário, ou a cor da parede, e ForeColor a cor das fonte ou das palavras que aqui escreveremos.
AutoSize, se verdadeiro o controle é redimensionado automaticamente.
Checked, se verdadeiro o controle ja aparece no formulário marcado. Lembre-se que só podemos marcar um por formulário ou por grupo.
Dock, define se queremos o componente literalmente grudado em um ou mais cantos.
Enabled, define se este controle esta habilitado ou não, ou seja, se o usuário pode usá-lo ou não.
Location, define a posição Top (distância do controle em relação a margen superior do formulário) e a posição Left (distância do controle em relação a margen esquerda do formulário)
Text, define o texto que aparece logo acima do controle.
Size, define a largura e a altura do controle.
Visible, define se o controle aparece no formulário ou não.
Veja que com apenas algumas configurações já temos o RadioButton no formulário.
Uma observação importante, é que não importa a quantidade de RadioButtons que temos no formulário, só poderemos selecionar um valor. Porém se tivermos muitos controles separados por GroupBox, poderemos selecionar mais de um RadioButton como mostra a figura abaixo.
Curso Básico de C# - Parte 19 
Imprimir 
Usando o projeto Controles do artigo anterior, onde temos o formulário de nome "frmPrimeiroFormulario", vamos abrir a "ToolBox" onde encontramos o controle chamado "CheckBox".
Basta arrastá-lo segurando-o com o mouse. E você terá um novo controle no formulário como mostra a figura abaixo.
Aqui eu coloquei três para testarmos de maneira eficiente, ja dentro de um GroupBox como vimos anteriormente!
Selecionando este controle vemos que a janela de propriedades se re-configura e podemos mudar suas configurações, veja, aqui temos:
Name, é o nome do controle, nome que usaremos para referenciá-lo quando estivermos codificando. Aqui chamei de cbMatutino, cbVespertino e cbNoturno.
Appearance, forma como o controle é mostrado ao usuário, normal como todos costumam utilizar ou em forma de botão.
BackColor é a cor de fundo do formulário, ou a cor da parede, e ForeColor a cor das fonte ou das palavras que aqui escreveremos.
AutoSize, se verdadeiro o controle é redimensionado automaticamente.
Checked, se verdadeiro o controle ja aparece no formulário marcado. Lembre-se que diferente do RadioButton podemos marcar mais de um por formulário ou por grupo.
Dock, define se queremos o componente literalmente grudado em um ou mais cantos.
Enabled, define se este controle esta habilitado ou não, ou seja, se o usuário pode usá-lo ou não.
Location, define a posição Top (distância do controle em relação a margen superior do formulário) e a posição Left (distância do controle em relação a margen esquerda do formulário)
Text, define o texto que aparece logo ao lado do controle.
Size, define a largura e a altura do controle.
Visible, define se o controle aparece no formulário ou não.
Veja que com apenas algumas configurações já temos o CheckBox no formulário.
Lembre-se que o CheckBox permite que no mesmo formulário seja marcado mais de um item, e por isso deve ser utilizado para flags e não para condições onde o resultado deve ser múltiplo e não único.