As classes definem tipos de referência que são armazenadas no heap. Se uma classe contiver poucos dados haverá um grande overhead no gerenciamento do heap. Uma classe usa então duas áreas de memória para armazenar dados. Nesses casos, podemos utilizar uma estrutura que utiliza apenas uma área de memória.
Estruturas em C# são usadas para criar tipos de valor, e por isso são armazenadas na stack (pilha). Sendo assim, o overhead de gerenciamento de memória pode ser bastante reduzido. Uma estrutura pode ter campos, métodos e até mesmo contrutores (com algumas limitações).
Veja um exemplo abaixo de uso de estrutuas:
using System;
namespace EstruturasStructs {
class Program {
static void Main(string[] args) {
horario agora;
agora.hora = 10;
agora.minuto = 30;
Console.WriteLine("Horário: {0}:{1}", agora.hora, agora.minuto);
Console.Read();
}
struct horario {
public int hora, minuto, segundo;
}
}
}
Diferente de uma classe, as estruturas não precisamos instanciar elas, e não é uma boa ideia usar campos públicos nelas, até por uma questão de segurança, é melhor usar eles privados.
Veja um exemplo abaixo (de forma parecida com classes e objetos):
using System;
namespace EstruturasStructs {
class Program {
static void Main(string[] args) {
horario agora = new horario(11, 25, 00);
Console.WriteLine("Agora são {0} horas", agora.horaAt());
Console.Read();
}
struct horario {
private int hora, minuto, segundo;
public horario(int h, int m, int s) {
this.hora = h % 24;
this.minuto = m % 60;
this.segundo = s % 60;
}
public int horaAt() {
return this.hora;
}
}
}
}
Podemos também copiar os dados dessa forma:
horario agora = new horario(11, 25, 00);
Console.WriteLine("Agora são {0} horas", agora.horaAt());
horario copia = agora;
Console.WriteLine("Agora são {0} horas", copia.horaAt());
Essa classe permite que nós insiremos um controle que contém uma paleta de cores para alterar cores no nosso projeto. Ela pode ser inserida arrastando o controle pro projeto, e instanciando a classe ao clicar um botão.
Abra um Windows Form, coloque dois botões, um para cor de fundo e outro para cor de texto, altere os names dela. Coloque também um textbox e coloque uma fonte maior.
Da primeira forma, arrastaremos o controle ColorDialog pro formulário, ele não aparecerá lá, mas abaixo do frame tem a opção de trabalharmos nele.
Veja algumas das propriedades do controle:
Para programar o botão de cor de fundo, coloque esse código no evento de clicar:
private void btnCorFundo_Click(object sender, EventArgs e) {
if(cdgCaixaCores.ShowDialog() == DialogResult.OK) {
txtCores.BackColor = cdgCaixaCores.Color;
}
}
Dessa forma, já podemos alterar a cor da caixa de texto.
Para alterar a cor da letra, usaremos outra forma, instanciaremos a classe no evento click do segundo botão, onde as propriedades alteraremos todas via código. Ficaria assim o código do segundo botão:
private void btnCorTexto_Click(object sender, EventArgs e) {
ColorDialog cdgCaixaCores2 = new ColorDialog();
cdgCaixaCores2.AllowFullOpen = false;
cdgCaixaCores2.AnyColor = true;
cdgCaixaCores2.SolidColorOnly = false;
cdgCaixaCores2.Color = Color.Blue;
if(cdgCaixaCores2.ShowDialog() == DialogResult.OK) {
txtCores.ForeColor = cdgCaixaCores2.Color;
}
}
O ListBox é um elemento que utilizamos para criar uma lista de itens que podem ser selecionados, adicionados ou removidos da mesma, por meio de outros controles.
Crie um programa com uma caixa de texto, abaixo dele coloque os botões com adicionar item e preencher lista automaticamente, no meio coloque um listbox, e do lado direito coloque quatro botões, com limpar lista, remover selecionado, ler item da lista e classificar lista.
O ListBox tem várias propriedades, onde podemos alterar coisas como o name, backcolor para a cor de fundo e outras, datasource para puxar dados de fontes distintas, font e fontcolor, items (que usamos para preencher os items padrão).
Esse é o código do botão adicionar item:
private void btnAdd_Click(object sender, EventArgs e) {
if(string.IsNullOrWhiteSpace(txtAddItem.Text)) {
MessageBox.Show("Digite um item para adicionar à lista!", "Digite um Item");
txtAddItem.Focus();
}
else {
lstAnimais.Items.Add(txtAddItem.Text);
txtAddItem.Clear();
txtAddItem.Focus();
}
}
Esse é o código do botão preencher lista automaticamente:
private void btnPreench_Click(object sender, EventArgs e) {
if(lstAnimais.Items.Count == 0) {
string[] bichos = new string[10] {"Jacaré", "Onça", "Elefante", "Gato", "Cão", "Papagaio", "Lontra", "Golfinho", "Foca", "Tatu"};
lstAnimais.Items.AddRange(bichos);
}
else {
MessageBox.Show("Lista já preenchida!", "Lista preenchida");
}
}
No limpar lista basta simplesmente chamar o Clear, assim:
private void btnLimp_Click(object sender, EventArgs e) {
lstAnimais.Items.Clear();
}
No remover selecionado, coloque isso:
private void btnRem_Click(object sender, EventArgs e) {
for(int i = lstAnimais.SelectedIndices.Count - 1; i >= 0; i--) {
lstAnimais.Items.RemoveAt(lstAnimais.SelectedIndices[i]);
}
}
No ler item da lista, coloque isso:
private void btnLer_Click(object sender, EventArgs e) {
if(lstAnimais.SelectedIndex < 0) {
MessageBox.Show("Selecione um item da lista!", "Selecione um item");
}
else {
string item = lstAnimais.SelectedItem.ToString();
MessageBox.Show("Item selecionado: " + item, "Item selecionado");
}
}
E no classificar lista, coloque simplesmente isso:
private void btnClass_Click(object sender, EventArgs e) {
lstAnimais.Sorted = true;
}
Em C# existe a classe Random que permite a geração de números aleatórios, que podem ser usados em várias aplicações, como criptografia, jogos e análises estatísticas.
Crie um novo Windows form, com um botão de gerar números, e dois labels para aparecer os números, um para gerar números inteiros e outro para gerar números reais (double).
Esse é o código, onde usamos a classe Random:
private void btnGer_Click(object sender, EventArgs e) {
Random numAle = new Random();
int valInt = numAle.Next(); // Gera inteiros positivos.
double valDem = numAle.NextDouble(); // Gera reais positivos.
lblInt.Text = valInt.ToString();
lblDem.Text = valDem.ToString();
}
O random gera um valor entre 0 e aproximadamente 2 bilhões (mais exatamente, o valor máximo do tipo int).
PS: Para restringir o gerador a um intervalo específico, é só colocar o mínimo e o máximo (com um a mais) entre as aspas do next, assim:
int valInt = numAle.Next(1, 101); // Gera números de 1 a 100.
Para colocar um menu na parte superior do programa, crie um novo projeto Windows Form, e coloque nele o MenuStrip, note que tem uma parte exibida fora do frame, mas tem uma parte dentro dele para que possamos criar o nome do menu.
No primeiro menu, teremos o nome Arquivo (e nos itens dele podemos adicionar algumas coisas, como o sair), e teremos ao lado o segundo menu Ajuda (também com alguns itens).
PS: Nos itens de menu também podemos colocar outros tipos de itens, como caixas de texto e combobox.
Para programar, basta usar o evento click, veja o código do item sair de arquivo:
private void sairToolStripMenuItem_Click(object sender, EventArgs e) {
Application.Exit();
}
Para o sobre, vamos criar um novo item no nosso projeto, que será o Window Form, com o nome janela, e coloque um label com alguma frase.
Voltando ao formulário principal, no evento click do sobre de ajuda, coloque esse código:
private void sobreToolStripMenuItem_Click(object sender, EventArgs e) {
Janela tela = new Janela();
tela.Show();
this.Hide(); // Isso é para fechar o form principal, pode ser omitido caso não queira isso.
}
Só que isso causa um problema, o programa continua em execução ao fechar a segunda janela, já que a primeira foi apenas oculta e não fechada. Para resolver isso, vá na segunda janela, vá nas propriedades dela e em eventos, vá em FormClosed (onde define o código a ser executado ao clicar no X da janela). Esse é o código colocado no evento dela:
private void Janela_FormClosed(object sender, FormClosedEventArgs e) {
if(Application.OpenForms.Count == 0) { // Isso verifica se não tem formulário do programa aberto.
Application.Exit();
}
else { // Aqui controlaremos as outras janelas, no caso, a primeira.
foreach(Form formAber in Application.OpenForms) {
if(formAber is Form1) {
formAber.Show();
break;
}
}
}
}
PS: Podemos colocar também um menu na segunda janela, coloque o menu arquivo e o item sair, com o mesmo código do primeiro frame.
Também podemos colocar uma tecla de atalho, clicando no item, e nas propriedades dele, ir no evento ShortcutKeys, onde escolhemos as teclas dos atalhos.
Primeiramente, crie um formunlário com três botões, com nomes criar array, ordenar array e ordenar método sort, e quatro labels, array 1 não ordenado, array 1 ordenado, array 2 não ordenado e array 2 ordenado.
Na classe principal, fora de qualquer função, antes do construtor, declare os array assim:
int[] x = {2, 1, 8, 7, 5, 9, 15, 3, 6};
int[] y = {4, 2, 9, 7, 6, 18, 11, 4, 8};
O código do primeiro botão (criar array) é esse:
private void btnCri_Click(object sender, EventArgs e) {
lblArr1N.Text = "Itens do array na ordem original:\n";
for(int i = 0; i < x.Length; i++) {
lblArr1N.Text += " " + x[i];
}
lblArr2N.Text = "Itens do array na ordem original:\n";
for(int i = 0; i < y.Length; i++) {
lblArr2N.Text += " " + y[i];
}
}
Esse é o código do segundo botão:
private void btnOrd_Click(object sender, EventArgs e) {
bubblesort(x);
lblArr1O.Text = "Itens do array ordenados:\n";
for(int i = 0; i < x.Length; i++) {
lblArr1O.Text += " " + x[i];
}
}
Lembrando que o método bubblesort tem que ser criado, dentro da mesma classe, mas fora de qualquer outro método, dessa forma:
public void bubblesort(int[] n) {
for(int i = 1; i < n.Length; i++) {
for(int j = 0; j < n.Length - 1; j++) {
if(n[j] > n[j + 1]) {
troca(n, j);
}
}
}
}
public void troca(int[] g, int p) {
int aux;
aux = g[p];
g[p] = g[p + 1];
g[p + 1] = aux;
}
E no último botão, é bem mais simples, pois usaremos um método interno do C#, dessa forma:
private void btnOrdSort_Click(object sender, EventArgs e) {
Array.Sort(y);
lblArr2O.Text = "Itens do array ordenados:\n";
foreach(int item in y) {
lblArr2O.Text += " " + item.ToString();
}
}