O C# é conhecido por criar facilmente interfaces gráficas para programas Windows. Duas das tecnologias usadas para isso são a Windows Forms e a WPF.
Primeiramente, vamos abrir um novo projeto do C#, da mesma forma que fizemos com a aplicação de console, mas ao invés dele, escolha a opção referente ao tipo de formulário usado. A Windows Forms é mais antiga, usada desde o .NET, a WPF é a mais recente e a recomendada para utilizar pela Microsoft, por permitir outros recursos de estilização, áudio e vídeo com mais facilidade, só que exige mais da sua máquina ao rodar.
Abra um Windows Forms, e coloque alguns elementos, indo em caixa de ferramentas, só para vermos a visualização deles, são vários, como button, label, painel, picturebox (para colocar imagens), etc.
Faça o mesmo com o WPF, note que este utiliza um XML (de forma parecida com Java FX).
Primeiro, abra um projeto Windows Form, note que aparecerá uma janela, onde trabalharemos nela, ela na verdade é uma instância da classe Form do C#.
Observe que ao clicar no frame, podemos ver as propriedades dele, e alterar algumas, como o ícone padrão, maximação das janelas e etc.
Algumas delas são essas:
Veja que no raio, em propriedades, tem os eventos disparados, como o Load, que é disparado ao executar ao programa (onde também podemos acessar o código do mesmo).
Um aplicativo pode ter várias janelas, verifique elas no gerenciador de soluções. Clique no primeiro nome para ver a janela, e no name do formulário para ver o código.
Aproveitando, crie uma nova janela Form no nosso projeto, em gerenciador de soluções. Podemos renomear os forms também, e clique em sim para refatorar, caso apareça a notificação.
Ao executar, só aparecerá a primeira janela, para a segunda janela aparecer, devemos usar um evento.
Vá na primeira janela, e vá em Load para ver o código dela, no código manipulador de evento (abaixo do construtor), colocaremos o código que fará aparecer a outra janela.
Para testarmos o evento Load, coloque esse código na primeira janela:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace ClasseForm {
public partial class ClasseForm : Form {
public ClasseForm() {
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e) {
MessageBox.Show("Evento Load Disparado!");
}
}
}
Para aparecer a outra janela, vá ainda na primeira, em eventos e no click, onde criaremos uma instância da classe da segunda janela (objeto), dessa forma:
public ClasseForm() {
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e) {
MessageBox.Show("Evento Load Disparado!");
}
private void ClasseForm_Click(object sender, EventArgs e) {
Janela2 tela = new Janela2();
tela.Show();
}
Na segunda janela, vamos colocar um calendário (MonthCalendar), e execute o programa de novo.
PS: Se quiser colocar um ícone de imagem para o programa, vá em gerenciador de soluções e na pasta principal do projeto, vá em propriedades, aplicativo e em ícone e manifesto. Isso pode ser usado em aplicações de console também.
Vamos criar um Window Form, e nele colocaremos um button.
Nas propriedades do botão, altere o name do método do botão, e o texto do botão, que será Clique Aqui. Podemos mudar outras propriedades, como as cores e etc.
No evento clique (que pode ser acessado também clicando duas vezes no botão do formulário), coloque esse código:
private void botaoClicar_Click(object sender, EventArgs e) {
MessageBox.Show("Botão Clicado!");
}
Agora crie um segundo botão, altere o nome e o texto dele, mas coloque o enabled false. Verifique que o botão aparece desabilitado, e altere o evento do primeiro botão dessa forma:
private void botaoClicar_Click(object sender, EventArgs e) {
MessageBox.Show("Habilitando o botão 2!");
botaoSeg.Enabled = true;
}
E também podemos criar um evento no segundo botão, que seria esse:
private void botaoSeg_Click(object sender, EventArgs e) {
MessageBox.Show("O botão foi habilitado!");
}
Um parâmetro é especificado como opcional quanto ele temos um valor padrão atribuído a ele. Caso passamos argumentos, ele usa os valores normalmente, se não passarmos ele usará os valores atribuídos aos mesmos.
PS: Os parâmetros obrigatórios deverão vir antes dos opcionais, sempre. O C# usa a opsição de cada argumento passado ao método para determinar a quais parâmetros elels se referem (em ordem).
Veja um exemplo abaixo:
using System;
namespace MetodosParametrosOpcionais {
class Program {
static void Main(string[] args) {
int param1;
string param2;
Console.WriteLine("Sem passar o parâmetro opcional!");
Console.Write("Digite o parâmetro obrigatório (número): ");
param1 = int.Parse(Console.ReadLine());
parametros(param1);
Console.WriteLine("");
Console.WriteLine("Passando o parâmetro opcional!");
Console.Write("Digite o parâmetro obrigatório (número): ");
param1 = int.Parse(Console.ReadLine());
Console.Write("Digite o parâmetro opcional (texto): ");
param2 = Console.ReadLine();
parametros(param1, param2);
Console.Read();
}
static void parametros(int par1, string par2 = "Texto Padrão do Método") {
string resultado = "\nParâmetro obrigatório: " + par1.ToString() + "\nParâmetro opcional: " + par2 + ".";
Console.WriteLine(resultado);
}
}
}
Veja que acima, apenas o primeiro parâmetro é obrigatório, o segundo é atribuído automaticamente e substituído no caso de passarmos ele.
É possível passar os argumentos para um método em qualquer ordem usando os argumentos nomeados.
Veja como fazemos abaixo, no mesmo programa anterior:
Console.WriteLine("Passando o parâmetro opcional!");
Console.Write("Digite o parâmetro obrigatório (número): ");
param1 = int.Parse(Console.ReadLine());
Console.Write("Digite o parâmetro opcional (texto): ");
param2 = Console.ReadLine();
parametros(par2: param2, par1: param1);
Pode ver no código acima, que colocamos a passagem de parêmetros invertidos, mas colocamos os nomes do argumento na função seguido da nossa variável.
Um modificador de acesso permite determinar o nível de acessibilidade dos membros e tipos em um método, controlando assim como eles podem ou não, serem acessados por outros métodos ou a partir de outros assemblies. Os modificadores de acesso em C# são public, private, protected, internal e protected internal.
O tipo ou membro public pode ser acessado sem restriçõesp or qualquer outro código no mesmo assembly ou em outros assemblies que façam referência a ele. Portanto, são visível pelos métodos de qualquer classe. O tipo ou membro private só pode ser acessado por códigos que estejam na mesma classe ou struct. O protected só pode ser acessados por códigos da classe ou struct da qual pertencem, ou em uma classe que seja derivada dessa classe que contém o modificador. O internal pode ser acessado por código que esteja presente no mesmo assembly, mas não por códigos presentes em outros assemblies (montagens). O protected internal pode ser acessado por qualquer cóigo no mesmo assembly, ou de uma classe derivada em outro assembly.
PS: Isso já é um conceito aplicado em orientação a objetos.
Abra um projeto novo, e já crie nele uma classe com o nome Animal, dentro dessa classe coloque esse código:
using System;
namespace MetodosModificadoresDeAcesso {
class Animal {
private int idade = 10; // Não pode ser acessado por outra classe
double peso; // Também não pode ser acessado
public int obterIdade() {
return idade; // Retornará porque o método é público, mesmo com o atributo privado, pois foi encapsulado.
}
public double obterPeso { // Isso é variável, não método
get {return peso;}
}
}
}
PS: No C#, caso não indique a acessibilidade, ele será automaticamente considerado privado.
Na classe principal, podemos fazer assim, para criarmos nosso objeto.
using System;
namespace MetodosModificadoresDeAcesso {
class Program {
static void Main(string[] args) {
int idade;
double peso;
Animal bicho = new Animal();
idade = bicho.obterIdade();
peso = bicho.obterPeso;
Console.WriteLine("A idade é {0}\nO peso é {1:F}", idade, peso);
Console.Read();
}
}
}
PS: Como não inicializamos o valor peso, ele retorna como zero, podemos colocar uma atribuição na classe Animal assim:
double peso = 50.4;
E ele será acessado pela variável obterPeso no programa principal, já que a peso é privada, a não ser que ela seja especificada como pública.
Podemos usar a palavra-chave static para criarmos um método estático, de modo que não seja necessário instanciar a classe para usá-lo. O modificador static indica que o membro em questão pertence à classe em si, e não às instâncias da classe. Apenas uma cópia do membro estático existe na aplicação, mesmo que várias instâncias da classe sejam criadas.
Veja um exemplo de método, podemos colocar ele na classe Animal, criada no programa anterior:
public static void mensagem() {
Console.WriteLine("Método Estático!");
}
Na classe principal, note que não é possível chamar esse método diretamente, nem pelos métodos dos objetos criados, apenas com o nome da classe diretamente, por exemplo:
mensagem(); // Não funciona
bicho.mensagem(); // Não funciona
Animal.mensagem(); // Só assim funciona, chamando o nome da classe.
Dessa forma, um programa pode ter apenas esse método com o programa da classe, sem precisar criar quaisquer objeto.
PS: Muitos dos métodos internos do C# e de outras linguagens são estáticos, incluindo o main, funcionando de maneira bem similar. Veja um exemplo abaixo:
double pi;
pi = Math.PI;
Console.WriteLine(pi.ToString());