Crie um novo projeto Windows Form e coloque 3 checkbox com três linguagens de programação, Java, C++ e C#, e os names deles, coloque também um botão e coloque no evento do click esse código:
private void btnClick_Click(object sender, EventArgs e) {
string saida = "";
// Ifs independentes
if(cxJav.Checked) {
saida += "Java\n";
}
if(cxCpp.Checked) {
saida += "C++\n";
}
if(cxCs.Checked) {
saida += "C#\n";
}
MessageBox.Show("Linguagens marcadas:\n\n" + saida, "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
saida = ""; // Limpando a variável
}
Para colocar um grupo de radio buttons num formulário de C#, coloque um groupbox ou um panel, e dentro dele coloque os radio buttons.
Num exemplo, coloque três radio buttons com textos Erro, Aviso e Informação, mude as variáveis deles, nas propriedades coloque o checked true em apenas um deles e coloque também um botão e também mude o texto dele.
Esse é o código do clique do botão:
private void btnClick_Click(object sender, EventArgs e) {
if(rdErr.Checked) {
MessageBox.Show("Exemplo de Notificação de Erro", rdErr.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else if(rdAvi.Checked) {
MessageBox.Show("Exemplo de Notificação de Aviso", rdAvi.Text, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else if(rdInf.Checked) {
MessageBox.Show("Exemplo de Notificação de Informação", rdInf.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
Podemos usar outras formas de leitura e impressão no console em C#, veja por exemplo esse programa aqui:
int n1, n2, res;
Console.Write("Digite um número: ");
n1 = int.Parse(Console.ReadLine());
Console.Write("Digite outro número: ");
n2 = int.Parse(Console.ReadLine());
res = n1 + n2;
Console.Clear();
Console.WriteLine("A soma entre {0} e {1} é igual à {2}.", n1, n2, res);
Console.ReadKey();
PS: O ReadKey lê apenas um caractere. E o Clear limpa a tela do console.
Alterado pra nova forma, ele ficaria assim:
int n1, n2, res;
Console.Write("Digite um número: ");
int.TryParse(Console.ReadLine(), out n1);
Console.Write("Digite outro número: ");
int.TryParse(Console.ReadLine(), out n2);
res = n1 + n2;
Console.WriteLine($"A soma entre {n1} e {n2} é igual à {res}.");
Console.ReadKey();
Isso facilita muito em determinados casos.
Crie um projeto de Windows Form e nessa janela, coloque um botão com texto Abrir Janela e o nome btnAbrir, se desejar aumente o tamanho dele e da fonte.
Clique com o botão direito na pasta do projeto e crie um novo WindowsForm com o nome NovaJanela, e nela coloque um label com um texto qualquer.
A forma mais comum é ir no evento de clique do botão do Form1 e colocar esse código:
private void btnAbrir_Click(object sender, EventArgs e) {
NovaJanela j2 = new NovaJanela();
j2.Show();
}
Para ocultar a primeira janela ao abrir a segunda, colocariamos esse método no evento:
this.Hide();
Só que isso, ao fechar a segunda janela, o programa continua rodando mesmo com ele não visível.
O mais recomendado é usar um thread para isso. Para isso coloque a diretiva using System.Threading no começo do programa. E altere o código dessa forma:
Thread t1;
public Form1() {
InitializeComponent();
}
private void btnAbrir_Click(object sender, EventArgs e) {
this.Close();
t1 = new Thread(abrirJanela); // Sem parênteses mesmo!
t1.SetApartmentState(ApartmentState.STA);
t1.Start();
}
private void abrirJanela(object obj) {
Application.Run(new NovaJanela());
}
Dessa forma ele abrirá a nova janela fechando de verdade a primeira, fazendo que o programa seja encerrado de verdade.
Por padrão o primeiro form criado no C# é a tela inicial. Mas podemos mudar esse padrão.
Vá no Gerenciador de Soluções e clique em Program.cs, e veja essa parte do código:
static void Main() {
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
Basta alterar o código de Run assim:
Application.Run(new NovaJanela());
Dessa forma podemos configurar a tela da qual o programa inicia, independente de quantas tivermos.
Assim como o List, temos também outros tipos de containers, mas com algumas diferenças entre eles.
O Stack (pilha) é como um tubo fechado de um lado e aberto de outro, onde o primeiro elemento inserido é o último a sair e vice-versa. Veja um exemplo de uso de Stack:
// Inclua System.Collections.Generic
Stack<char> vogais = new Stack<char>();
vogais.Push('A');
vogais.Push('E');
vogais.Push('I');
vogais.Push('O');
vogais.Push('U');
while(vogais.Count > 0) {
Console.WriteLine($"Elemento do topo: {vogais.Peek()}");
Console.WriteLine($"Número de elementos: {vogais.Count}");
vogais.Pop();
}
Esses são os métodos básicos das pilhas:
| Método | Funcionalidade |
|---|---|
| Push() | Adiciona um elemento à pilha |
| Pop() | Remove um elemento da pilha |
| Count | Exibe o tamanho da pilha |
| Peek() | Exibe o último elemento da pilha |
Alguns dos exemplos em que uma pilha pode ser usada é em mecanismos de desfazer/refazer de editores, navegação entre páginas web, etc.
Já na Queue (fila), os primeiros elementos a entrarem também são os primeiros a saírem, como um túnel, aberto dos dois lados. Veja um exemplo de uso de Queue:
// Inclua System.Collections.Generic
Queue<char> vogais = new Queue<char>();
vogais.Enqueue('A');
vogais.Enqueue('E');
vogais.Enqueue('I');
vogais.Enqueue('O');
vogais.Enqueue('U');
while(vogais.Count > 0) {
Console.WriteLine($"Primeiro elemento: {vogais.Peek()}");
Console.WriteLine($"Número de elementos: {vogais.Count}");
vogais.Dequeue();
}
PS: Alguns métodos da Queue são diferentes, são esses:
| Método | Funcionalidade |
|---|---|
| Enqueue() | Adiciona um elemento à fila |
| Dequeue() | Remove um elemento da fila |
| Count | Exibe o tamanho da fila |
| Peek() | Exibe o primeiro elemento da fila |
Alguns dos exemplos em que uma fila pode ser usada é em controle de documentos (para impressão, por exemplo), troca de mensagem entre dispositivos numa rede, etc.
Já o Dictionary, equivalente ao Map de outras linguagens, recebe dois parâmetros, a chave e o valor, se usa assim:
// Inclua System.Collections.Generic
Dictionary<int, char> vogais = new Dictionary<int, char>();
vogais.Add(1, 'A');
vogais.Add(2, 'E');
vogais.Add(3, 'I');
vogais.Add(4, 'O');
vogais.Add(5, 'U');
foreach(KeyValuePair<int, char> v in vogais) {
Console.WriteLine($"Chave: {v.Key} - Elemento: {v.Value}");
}
vogais.Clear(); // Isso limpa o Dictionary
Como exercício, tente outros tipos de elementos nesses contâiners.
Quando usamos passagem de parâmetros para a função main, podemos chamar um programa através do terminal pelo nome, podendo enviar um valor, que pode ser tratado dentro do programa através de um parâmetro, args, na função main.
A string[] args é um array de string que armazena os argumentos.
Veja um exemplo de programa que receberá um parâmetro (rodando pelo terminal):
class Program {
static void Main(string[] args) {
int cont = 0;
Console.WriteLine($"Argumentos: {args.Length}");
Console.WriteLine("");
while(cont < args.Length) {
Console.WriteLine($"Parâmetro Nº{cont + 1}: {args[cont]}");
cont++;
}
}
}
Como exercício, tente passar vários tipos de parâmetro, lembrando que quando um parâmetro só tem espaços, passe eles entre aspas.
Para esse exemplo, crie um aplicativo Windows form com um campo de texto (textBox), dois botões (um pra escrever e outro pra ler) e uma área de texto (textBox multiline).
Para escrever em arquivos, podemos fazer dessa forma:
private void btnEscr_Click(object sender, EventArgs e) {
string texto = txtEntr.Text;
// Adicione System.IO
try {
StreamWriter arq = new StreamWriter("arquivo.txt", true, Encoding.UTF8); // O parâmetro true adiciona dados ao arquivo, se for false ele o sobrescreverá.
arq.WriteLine(texto);
MessageBox.Show("O texto foi inserido no arquivo com sucesso!", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
arq.Close();
}
catch(Exception ex) {
MessageBox.Show($"ERRO: {ex.Message}", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
Para ler, podemos fazer assim:
private void btnLer_Click(object sender, EventArgs e) {
string texto;
string saida = "";
// Adicione System.IO
try {
StreamReader arq = new StreamReader("arquivo.txt");
texto = arq.ReadLine();
while(texto != null) {
saida += texto + Environment.NewLine;
texto = arq.ReadLine();
}
txtSaid.Text = saida;
arq.Close();
}
catch(Exception ex) {
MessageBox.Show($"ERRO: {ex.Message}", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
Crie um aplicativo Windows form com dois botões (verificar Diretório de Usuários e abrir Bloco de Notas) e um textBox multiline.
No primeiro botão, colocamos isso:
private void btnDir_Click(object sender, EventArgs e) {
// Incluir System.Diagnostics
using(Process inicia = new Process()) {
inicia.StartInfo.FileName = Environment.GetEnvironmentVariable("comspec");
inicia.StartInfo.Arguments = "/c dir C:\\Users"; // Não esqueça o /c antes
inicia.StartInfo.RedirectStandardOutput = true;
inicia.StartInfo.UseShellExecute = false;
inicia.StartInfo.CreateNoWindow = true;
inicia.Start();
inicia.WaitForExit();
string saida = inicia.StandardOutput.ReadToEnd();
txtDir.Text = saida;
}
}
A estrutura using é pra garantir o uso correto de objetos IDisposable.
PS: Podemos colocar praticamente qualquer comando do Prompt no lugar do dir.
Para programas externos, no entanto, podemos fazer de forma mais simples:
private void btnNot_Click(object sender, EventArgs e) {
// Incluir System.Diagnostics e System.ComponentModel
try {
Process.Start("notepad.exe");
}
catch(Win32Exception ex) {
MessageBox.Show($"ERRO: {ex.Message}", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
PS: Para colocar caminhos em pastas diferentes ou fora do path, use duas barras invertidas (\\) ao invés de uma (\).
Isso pode ser usado para navegar entre pastas:
Environment.CurrentDirectory = Environment.GetEnvironmentVariable("userprofile"); // Inclua System.IO
string dirAtual = Directory.GetCurrentDirectory() + "\\Desktop";
MessageBox.Show(dirAtual, "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);