Crie um novo projeto com Window Form, e na caixa de ferramentas, coloque um Textbox.
Basicamente, um Textbox é um campo de texto, usado principalmente para digitar dados.
Veja uma das propriedades do elemento, temos o Backcolor, pra mudar a cor de fundo, o Borderstyle para configurar a borda, o Caracterecasing que define a caixa alta e baixa do campo, Font para definir a fonte e o tamanho, Forecolor para definir a cor do texto, Enabled para habilitar ou desabilitar, Maxlength que define o máximo de caracteres digitados, ReadOnly para definir se o campo é somente leitura, etc.
PS: No C#, o componente de campo de texto, área de texto e campo de senha, são definidos pelo mesmo Textbox, sendo as áreas de texto configuradas marcando true em Multiline (e usamos o Scroolbars para configurar as barras de rolagem da mesma), e os campos de senha colocando o caractere * em PasswordChar.
Crie também um botão com o nome clique aqui e o name btnTest. Na nossa área de texto coloque o name txtEntr.
No código do evento de clicar botão, colocamos isso:
private void btnTest_Click(object sender, EventArgs e) {
txtEntr.Text = "Esse texto é chamado pelo clique do botão!";
}
Agora coloque mais uma área de texto igual, e no botão altere o método dessa forma:
private void btnTest_Click(object sender, EventArgs e) {
txtSaid.Text = txtEntr.Text;
}
No caso acima, tudo escrito na primeira caixa, será copiado pra segunda.
Vamos voltar ao nosso projeto anterior, e apague o código executado dentro do método do botão, para começarmos a trabalhar nele.
O primeiro evento que trabalharemos é o TextChanged, na primeira área de texto. Nesse caso, sempre que alterarmos o texto da caixa de texto, disparará o evento, que terá esse código:
txtSaid.Text = txtEntr.Text;
Basicamente, é o mesmo código anterior do botão. Ele fará que tudo que for escrito na primeira caixa apareça na segunda.
Na mesma caixa de texto (primeira), procure o evento click, que fará que o conteúdo da mesma caixa seja apagado ao clicar. Código dele é esse:
txtEntr.Text = "";
Outro evento interessante é o MouseHover, que é disparado ao passar a seta do mouse em cima dele. Vamos colocar ele na primeira caixa de texto também, junto ao evento de click. Esse é o código:
txtEntr.Text = "Digite seu Texto Aqui!";
Obviamente, esse método Hover deveria ser colocado em um condicional para verificar o conteúdo do texto.
Temos no C# vários métodos internos para os controles. Veremos alguns existentes para TextBox.
O método Focus() coloca o foco na caixa de texto, util para formulários, quando selecionado. Veja o evento, colocado no click do botão, que focará a primeira caixa de texto:
private void btnTest_Click(object sender, EventArgs e) {
txtEntr.Focus();
}
Temos também o método Clear(), que podemos usar para limpar as caixas (e é o método certo, ao invés de atribuir uma string vazia), veja como é usado, no evento do botão:
txtEntr.Clear();
Pra quem trabalha com textos, temos os eventos Cut(), Copy() e Paste(), respectivamente, recortar, copiar e colar.
Coloque esse código no botão para copiar:
txtEntr.Copy();
// txtEntr.Cut();
E crie o botão colar e coloque esse código:
private void btnColar_Click(object sender, EventArgs e) {
txtSaid.Paste();
}
Também podemos ocultar um componente usando o método Hide(), para isso, coloque um novo botão e esse evento aqui:
private void btnOcul_Click(object sender, EventArgs e) {
txtSaid.Hide();
}
E da mesma forma, podemos mostrar o mesmo usando o Show(), num quarto botão, assim:
private void btnMost_Click(object sender, EventArgs e) {
txtSaid.Show();
}
Crie um novo projeto e coloque nele um Numeric Up Down com o nome numEntr e um botão com o nome btnVerif. No evento do click do botão, coloque esse código aqui:
private void btnVerif_Click(object sender, EventArgs e) {
int num = (int)numEntr.Value;
int dobro = num * 2;
MessageBox.Show("O dobro de " + num + " é " + dobro + ".", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
Agora, coloque um Trackbar com o nome sliNum e um label com o texto "0" e o nome lblNum. Adicione o evento scroll e coloque esse código:
private void sliNum_Scroll(object sender, EventArgs e) {
lblNum.Text = sliNum.Value.ToString();
}
PS: Podemos escolher nas propriedades desses componentes o mínimo, o máximo e o step dos números.
É difícil assegurar que um trecho de código sempre funcione como esperado, falhas podem ocorrer por inúmeras razões, muitas além do nosso controle. Por isso nossas aplicações devem ser capazes de detectar falhas e manipulá-las de forma a evitar maiores problemas.
Para escrevermos programas que lidam com eventuais erros, precisamos de duas coisas basicamente: Escrever o código dentro de um bloco try, escrever um ou mais manipuladores catch logo após o bloco try, para manipular as condições de erro, opcionalmente podemos usar um bloco finally para definirmos códigos que sempre serão executados.
Veja um exemplo abaixo:
using System;
using System.Windows.Forms;
namespace TratamentoDeExcecoes {
class Program {
static void Main(string[] args) {
try {
Console.Write("Digite o primeiro número: ");
int num1 = int.Parse(Console.ReadLine());
Console.Write("Digite o segundo número: ");
int num2 = int.Parse(Console.ReadLine());
int resposta = num1 * num2;
MessageBox.Show("O resultado é: " + resposta.ToString());
}
catch(FormatException ex) {
MessageBox.Show(ex.Message, "Bloco Catch");
}
finally {
MessageBox.Show("Esse bloco sempre será executado!");
}
}
}
}
No código acima, o que estiver no try é o código, o catch é executado ao entrar um caractere inválido (como uma letra) e por isso impede travamentos do programa. O finally sempre é executado.
Em alguns casos, ao digitar números grandes, também pode dar erro, que também podem ser corrigidos. Existem várias classes de exceção em C#, e podem ser usadas mais de uma, veja o código acima com essas classes:
try {
Console.Write("Digite o primeiro número: ");
int num1 = int.Parse(Console.ReadLine());
Console.Write("Digite o segundo número: ");
int num2 = int.Parse(Console.ReadLine());
int resposta = num1 * num2;
MessageBox.Show("O resultado é: " + resposta.ToString());
}
catch(FormatException ex) {
MessageBox.Show("Digite apenas Valores Numéricos!", "Primeiro Bloco Catch");
}
catch(OverflowException ex) {
MessageBox.Show(ex.Message, "Segundo Bloco Catch");
}
catch(Exception ex) {
MessageBox.Show(ex.Message, "Terceiro Bloco Catch");
}
finally {
MessageBox.Show("Esse bloco sempre será executado!");
}
Agora tem três erros diferentes tratados, o primeiro é de erro de formato, o segundo é o erro de estouro (como os números muito grandes) e o terceiro pra erros gerais.
PS: Se for o caso, no Visual Studio, vá em projeto, propriedades, build, avançado, e lá podemos marcar a opção verificar estouro numérico.
Você pode dar um Ctrl Alt E para ver as classes de exceções do C#.
PS: Podemos também criar nossas próprias exceções, colocando um if com a condição e o lançamento da Exceção, dessa forma, ao atingir essa condição ele interrompe a execução e passa pro catch, por exemplo:
try {
Console.Write("Digite o primeiro número: ");
int num1 = int.Parse(Console.ReadLine());
Console.Write("Digite o segundo número: ");
int num2 = int.Parse(Console.ReadLine());
if(num1 == 0 || num2 == 0) {
throw new Exception("Não insira zeros!");
}
int resposta = num1 * num2;
MessageBox.Show("O resultado é: " + resposta.ToString());
}
catch(Exception ex) {
MessageBox.Show(ex.Message, "Bloco Catch");
}
Podemos também colocar a exceção em uma função, veja um exemplo com a exceção ArithmeticException:
static float divisao(int n1, int n2) {
if(n2 == 0) {
throw new ArithmeticException("É impossível Dividir por Zero!");
}
return n1 / n2;
}
E na função principal:
try {
Console.WriteLine(divisao(50, 0));
}
catch(ArithmeticException ex) {
Console.WriteLine(ex.Message);
}
Uma enumeração é um tipo de dados cujos valores são limitados a um conjunto de nomes simbólicos. Por exemplo, podemos criar uma enumeração cujos valores sejam os meses do ano. Esses valores são chamados de elementos ou membros. Definimos uma enumeração com o uso da palavra enum.
Após declarar uma enumeração, podemos usá-la da mesma forma como usamos qualquer outro tipo de dados. Podemos criar variáveis do tipo enum, campos em classes e parâmetros em métodos.
Veja um exemplo de uso de enum abaixo:
using System;
namespace EnumeracoesEnum {
class Program {
enum PontoCardeal {norte, sul, leste, oeste};
static void Main(string[] args) {
}
}
}
Antes de podermos ler o valor de uma variável do tipo enum devemos atribuir-lhe um valor. Porém, somente podemos atribuir valores que façam parte do conjunto e valores definidos para o tipo enum especificado.
Veja abaixo o uso dos tipos enum:
using System;
namespace EnumeracoesEnum {
class Program {
enum PontoCardeal {norte, sul, leste, oeste};
static void Main(string[] args) {
PontoCardeal direcao = PontoCardeal.norte;
Console.Write("Ponto cardeal: " + direcao);
Console.Read();
}
}
}
Internamente, uma enumeração associa um valor inteiro com cada um dos elementos da enumeração. A númeração começa em 0 (primeiro elemento) e é incrementada de um em um a cada elemento susequente. Esse valor é chamado de literal da enumeração, Podemos obter o valor inteiro de um elemento qualquer, basta converter o elemento para o tipo int, como podem ver:
Console.Write("Ponto cardeal: " + (int)direcao);
Podemos associar um valor inteiro constante específico para um dos elementos do enum, dessa forma:
enum PontoCardeal {norte = 10, sul, leste, oeste};
PS: Lembre-se que os outros elementos após ele, serão incrementados, no código acima, norte é 10, sul é 11, leste é 12 e oeste é 13.
Também podemos fazer uma associação entre os elementos do enum, por exemplo:
enum PontoCardeal {norte, sul, leste, este = leste, oeste};
No caso acima, tanto leste quanto este tem os mesmos valores de índice (no caso, 2).
Quando uma enumeração é declarada, os literais recebem valores do tipo int. Porém, podemos basear nossa enumeração em um tipo diferente para os literais. Por exemplo, se quisermos usar o tipo short em vez do int. A vantagem aqui é a economia de memória: O tipo short ocupa apenas 16 bits, contra 32 do tipo padrão int. Os tipos inteiros disponíveis para essa operação são byte, sbyte, short, ushort, int, uint, long e ulong.
Veja outro exemplo abaixo, onde usamos um função para mostrar valores:
using System;
namespace EnumeracoesEnum {
class Program {
enum PontoCardeal {norte, sul, leste, este = leste, oeste};
static void Main(string[] args) {
listaPontos();
Console.Read();
}
static void listaPontos() {
PontoCardeal ponto = PontoCardeal.norte;
for(int i = 0; i < 3; i++) {
Console.WriteLine("Ponto cardeal: " + ponto);
ponto++;
}
Console.WriteLine("Ponto cardeal: " + ponto);
}
}
}