O que é o .NET Framework? É uma plataforma de programação desenvolvida pela Microsoft. O C# foi especificamente escrito como uma linguagem que usará o .NET Framework. A estrutura é feita de dois elementos diferentes:
1.
Uma enorme biblioteca de código que podemos chamar a partir de nossos programas C#. Isso nos poupa de escrever tudo sozinhos.
2.
Um módulo “runtime”, que executa os programas para nós quanto estamos prontos (isso acontece invisivelmente – você não precisa se preocupar com isso)
Quando você escreve um programa em C# (ou um programa em qualquer uma das outras linguagens do .NET), você normalmente chama algum código residente na biblioteca, além de escrever alguns dos seus próprios códigos.
Bb297402.Bb2974026c6d7e77-2a45-440b-838b-f8ba56345f7b(pt-br,VS.80).png
Existem tantas classes no .NET Framework e algumas delas são bem complicadas, então certamente não tentaremos tratar de todo o assunto aqui. Em vez disso, os capítulos desta seção tratarão de algumas das classes do .NET Framework que imaginamos que você irá considerar mais úteis. À medida que você fica mais experiente, descobrirá que existem certas classes que você usa mais freqüentemente e você as conhecerá bem – é como pegar seu livro favorito da biblioteca; com o tempo, você saberá exatamente onde encontrá-lo.
É muito importante entender que a parte III não é apenas para ler – esses capítulos incluem muitos programas de exemplo e espera-se que você coloque todos à prova e tente alterá-los para fazer coisas novas.
Bb297402.clear(pt-br,VS.80).gifHow to Try Out the Examples
Nos capítulos a seguir, sempre que você visualizar um bloco com as palavras "código para programa...”, poderá executar esse código usando o Visual C# Express. Embora a maioria desses programas seja pequena, eles são todos programas que realmente funcionam. São estas as etapas que você normalmente seguirá:
*
Abra o Visual C# Express. Selecione Arquivo -> Abrir Projeto e vá até onde salvou os programas de exemplo. Abra qualquer arquivo com uma extensão ".csproj"
(ou você pode usar o Windows Explorer para encontrar o exemplo que deseja e simplesmente clicar duas vezes no arquivo .csproj).
*
Pressione F5 para executar o programa (ou clique na seta verde).
Como alterar e estender os exemplos
Não há problemas em dizer que "você pode alterar os exemplos", mas como saber de que forma você pode alterá-los? Os exemplos mostram alguns métodos e classes do .NET Framework em uso – como saber que outros estão disponíveis? Há algumas formas de descobrir:
*
Examine a biblioteca de classes do SDK do .NET Framework incluída na ajuda do Visual C# Express.
*
Ao programar no Visual C# Express, para ver as classes, métodos, campos etc. disponíveis para uma classe, pressione a tecla "." diretamente após digitar um namespace ou um nome de classe. Por exemplo, digite "Console." e você verá uma lista de métodos e outros membros disponíveis na classe Console.
Bb297402.Bb297402801d3030-ca61-4f90-a9de-ee6dd391d979(pt-br,VS.80).png
No caso de um método, se você digitar um parênteses aberto no final do nome do método, também poderá ver os tipos de parâmetro que o método espera. Muitas vezes, um método é escrito de uma maneira especial para permitir diferentes conjuntos de parâmetros – então, você pode percorrê-los pressionando as teclas de seta para baixo e para cima. O exemplo a seguir mostra o que acontece quando você digita "Console.WriteLine(". O Visual C# Express mostra que existem 19 maneiras diferentes para se chamar WriteLine. Na figura abaixo, pressionamos a seta para baixo até atingirmos a 11.ª.
Bb297402.Bb297402650cc188-6805-44ae-8e1d-3d3ab53bf3d4(pt-br,VS.80).png
Bb297402.Bb297402d547e250-3cf4-478c-a471-520d6bd39eef(pt-br,VS.80).png
Bb297402.clear(pt-br,VS.80).gifSystem.Console
Introdução
A idéia de um “Console” vem da época em que grandes computadores de mainframe eram muito populares. Uma empresa teria um computador gigante escondido em um quartinho nos fundos e as pessoas do lado de fora teriam um teclado e uma tela simples, chamada de console, presa à fera do quarto dos fundos. Essas telas não eram capazes de exibir gráficos verdadeiros – apenas texto. O teclado era o dispositivo de entrada, enviando informações ao computador e o console era o dispositivo de saída principal, permitindo ao computador enviar informações de volta ao usuário.
Bb297402.Bb2974020526ef15-d598-47b4-9790-7061f617e6e8(pt-br,VS.80).png
O mundo progrediu e hoje em dia a maioria dos computadores usa telas que podem mostrar muito mais representações naturais às pessoas do que linhas de texto – fotografias, por exemplo.
Existe, em geral, uma necessidade, no entanto, de fazer coisas que não precisam mostrar nada especial ao usuário. Você pode, por exemplo, ter um programa que colete alguns dados de um servidor de Internet de algum lugar e os coloque em um arquivo ou no seu PC. Se tudo o que você precisa que ele faça é “ocupado buscando dados” e, em seguida, “concluído”, por que perder muito mais tempo e memória em uma interface de usuário sofisticada? É por essa razão que a biblioteca do .NET nos oferece uma classe para escrever facilmente aplicativos de console.
Não ridicularize aplicativos de console, como se “eles não fossem legais”. Na verdade, você descobrirá que os programadores realmente inteligentes se cansam de perder tempo com interfaces sofisticadas e fazem a maior parte do seu próprio trabalho em aplicativos de console.
É claro que, se você planeja escrever um programa que outra pessoa irá usar, provavelmente você desejará ser um pouco mais gentil e oferecer a ela algo mais amigável do que uma interface de console.
Alguns métodos úteis
1.
Console.ReadLine – lê uma linha de texto do teclado (ou algum outro dispositivo de entrada)
2.
Console.Read – lê um número do teclado (ou algum outro dispositivo de entrada)
3.
Console.WriteLine – escreve texto na tela (ou outro dispositivo de saída), começando em uma nova linha
4.
Console.Write – escreve alguns caracteres na tela sem começar uma nova linha
Programa de exemplo 1
O seguinte programa simplesmente escreve a palavra "Yo!" na tela e aguarda até que a tecla ENTER seja pressionada.
Código para o programa 1
using System;
class PleaseSayYo
{
static void Main()
{
// Write a word to the screen
Console.Write("Yo!");
// Wait until enter is pressed
Console.ReadLine();
}
}
Bb297402.Bb2974027f874be6-42cd-435f-a82f-06cac76835fa(pt-br,VS.80).png
Programa de exemplo 2
O programa a seguir
*
Pede ao usuário para digitar uma palavra no teclado
*
Pergunta ao usuário quantas vezes a palavra deve ser escrita
*
Escreve, em uma nova linha de cada vez, a palavra digitada, quantas vezes tiver sido solicitado
Código para o programa 2
using System;
class WriteAFewLines
{
static void Main()
{
Console.WriteLine("Type in your favourite word : ");
// Store, in a string variable, the word that the user entered
string favouriteWord = Console.ReadLine();
Console.WriteLine("How many times shall I write it? ");
// Store, in an integer variable, the number they type in
// (And they'll get an error if they don't type a true number)
int numberOfTimes = Convert.ToInt32(Console.ReadLine());
// Write the word out as many times as was requested
for (int i = 0; i < numberOfTimes; i++)
{
Console.WriteLine(favouriteWord);
}
// Wait until ENTER is pressed
Console.ReadLine();
}
}
Bb297402.Bb297402b31ba935-7068-48b9-9faf-2929319fb424(pt-br,VS.80).png
Bb297402.clear(pt-br,VS.80).gifSystem.Windows.Forms
Introdução
Se você deseja escrever programas que pareçam com os que você está acostumado a usar em um ambiente do Windows, você sem dúvida usaria as classes no namespace System.Windows.Forms. Eles permitem que você trabalhe com botões, caixas de listagem, caixas de texto, menus, caixas de mensagem e muitos outros “controles”. Os controles são coisas que você coloca em um formulário – eles mostram coisas como texto (um controle Label) e imagens (um controle Picture Box) ou permitem que você execute ações como selecionar um valor ou clicar em um botão para passar a outro formulário. Você provavelmente usará as classes abaixo de System.Windows.Forms na maioria dos seus programas em C#.
Obviamente que a idéia de um “formulário” vem dos formulários de papel amplamente usados no mundo “real”. Um formulário é algo que permite a colocação de várias coisas (texto, imagens, caixas de entrada etc.) em um layout bem organizado. Geralmente, uma pessoa irá ler algumas informações no formulário e preencher algumas informações em certas regiões.
Bb297402.Bb2974027bf0436f-3349-4c18-85cf-985e5772d9f7(pt-br,VS.80).png
A idéia no computador é semelhante – um formulário permite a colocação de texto, imagens, caixas de entrada, botões etc., possibilitando que eles sejam precisamente organizados na tela – muito diferente de um aplicativo de console, que pode apenas tratar de linhas de texto uma após a outra.
A Microsoft forneceu, na biblioteca de classe do .NET Framework, um número enorme de “controles” para o uso em formulários. Depois que você aprende como colocar um controle em um formulário, pode criar um aplicativo sofisticado muito rapidamente, simplesmente usando esses controles existentes.
Algumas classes úteis no namespace System.Windows.Forms
Veja a seguir exemplos de classes com código para controles que você pode colocar nos seus formulários
*
Label
*
Button
*
ListBox
*
CheckBox
*
RadioButton
*
ListBox
*
Menu
*
TabControl
*
Toolbar
*
TreeView
*
DataGrid
*
PictureBox
*
RichTextBox
Uma observação sobre como trabalhar com os exemplos do Windows Forms usando o Visual C# Express
Para brincar com os seguintes exemplos no C# Express, você pode selecionar Arquivo -> Abrir Projeto e abrir os programas de exemplo .csproj do livro a partir de onde desejar salvá-los no disco do seu computador.
Se, no entanto, você desejar digitá-los a partir do zero sozinho, precisará estar ciente de que quando cria um novo projeto de "Aplicativo do Windows", o C# Express anota alguns arquivos .cs para você (chamados Form1.cs e Program.cs) e insere alguns códigos C# para que você fique preparado para começar. Ele, na verdade, cria para você um programa básico, mas totalmente funcional. Enquanto estiver trabalhando com os exemplos abaixo, para manter as coisas simples, você deverá provavelmente:
*
excluir o Form1.cs e
*
substituir o código em Program.cs pelo código do exemplo com o qual está trabalhando
Isso não é necessário se você mais exatamente abrir os exemplos usando Arquivo -> Abrir Projeto.
Programa de exemplo 3
Este é um aplicativo de formulários do Windows absolutamente simples. Tudo o que ele faz é começar um novo formulário e escrever algum texto na barra de títulos da janela.
Código para o programa 3
using System.Windows.Forms;
class SimpleWindowsForm : Form
{
// The constructor method for our class
public SimpleWindowsForm()
{
// Set the window title
this.Text = "A really Simple Form";
}
static void Main()
{
// Start a new instance of a forms application, using our class above
Application.Run(new SimpleWindowsForm());
}
}
Bb297402.Bb29740268b6cffa-8903-4b10-885b-1d3e5d2b3d45(pt-br,VS.80).png
Programa de exemplo 4
Este exemplo também é simples, mas nos leva para o próximo nível – colocando um botão no formulário
Código para o programa 4
using System.Windows.Forms;
class SimpleWindowsFormWithButton : Form
{
Button button1;
// The constructor method for our class
public SimpleWindowsFormWithButton()
{
// Set the window title
this.Text = "A simple form with a button";
// Add a button to the form's collection of controls
// Although the button says "click me", nothing happens when you do!
button1 = new Button();
button1.Text = "Click me";
this.Controls.Add(button1);
}
static void Main()
{
// Start a new instance of a forms application, using our class above
Application.Run(new SimpleWindowsFormWithButton());
}
}
Bb297402.Bb297402413d98d8-e3a7-406b-9120-27a752282ffb(pt-br,VS.80).png
Programa de exemplo 5
Ter um botão no formulário é bom, mas no exemplo acima nada acontece quando o usuário clica no botão. Chato.
Precisamos escrever um método que fará algo quando o botão for clicado – vamos apenas fazer com que ele altere a barra de título, neste caso. Chamamos tal método de um manipulador de eventos, uma vez que ele irá esperar um evento (um clique, neste caso) e então decidirá como tratar dele. Também precisamos vincular o evento de clique do botão ao manipulador de eventos.
Código para o programa 5
using System;
using System.Windows.Forms;
using System.Drawing;
class FormWithWorkingButton : Form
{
// The constructor method for our class
public FormWithWorkingButton()
{
// Set the window title
this.Text = "Simple form with working button";
// Add a button and hook it up to an event handler method
Button button1 = new Button();
button1.Text = "Click me";
button1.Click += new System.EventHandler(Button1_Click);
this.Controls.Add(button1);
}
static void Main()
{
// Start a new instance of a forms application, using our class above
Application.Run(new FormWithWorkingButton());
}
// An event handler that will be run when the button is clicked
void Button1_Click(object sender, EventArgs e)
{
// Change the window title
this.Text = "Button was clicked";
}
}
Bb297402.Bb2974026c99e945-505b-41b2-b43f-5ddf0a365098(pt-br,VS.80).png
Programa de exemplo 6
Certo, o programa faz todas as coisas básicas. Agora vamos adicionar alguns outros tipos de controles ao formulário, expô-los de uma forma legal e trabalhar um pouco com eles. Usaremos 4 tipos de controles: Button, ListBox, MessageBox e PictureBox.
Observe que, além do System.Windows.Forms, também usaremos o namespace System.Drawing aqui. Isso é necessário porque estamos usando um PictureBox – e trabalhar com imagens requer as classes Drawing.
Código para o programa 6
using System.Windows.Forms;
using System.Drawing;
class MyForm : Form
{
// Declare a listbox outside the methods, since we'll
// want to talk to it from more than one method
ListBox listBox1;
// The constructor method for our class
public MyForm()
{
// Create a picture box, put a picture in it and add it to this form
PictureBox pictureBox1 = new PictureBox();
pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage;
Bitmap image1 = new Bitmap("../../images/seashore.jpg");
pictureBox1.ClientSize = new Size(this.Width, 100);
pictureBox1.Image = (Image)image1;
this.Controls.Add(pictureBox1);
// Create a button object, set some of it's properties and add it to the form
Button button1 = new System.Windows.Forms.Button();
button1.Location = new System.Drawing.Point(10, 120);
button1.Text = "Click me";
button1.Click += new System.EventHandler(button1_Click);
this.Controls.Add(button1);
// Create a listbox object, set some of it's properties and add it to the form
listBox1 = new System.Windows.Forms.ListBox();
listBox1.Location = new System.Drawing.Point(10, 160);
listBox1.Items.Add("Sparkly");
listBox1.Items.Add("Dull");
listBox1.Items.Add("Vivacious");
listBox1.Items.Add("Plain");
listBox1.Items.Add("Outstanding");
listBox1.SelectedIndex = 3;
this.Controls.Add(listBox1);
}
// An event handler method that will run when the button is clicked
void button1_Click(object sender, System.EventArgs e)
{
// Show a message indicating which item in the listbox is selected
MessageBox.Show(this, "You have selected " + listBox1.SelectedItem, "Notification", MessageBoxButtons.OK);
}
static void Main()
{
// Start a new instance of a forms application, using our class above
Application.Run(new MyForm());
}
}
Bb297402.Bb297402da530f93-393b-4d00-b0b1-91b98ce8552b(pt-br,VS.80).png
Programa de exemplo 7
Tudo bem, agora vamos explorar o inexplorado. Para ilustrar como usar alguns dos outros controles, escreveremos um programa realmente grande incluindo vários controles úteis. Isso tornará o código assustadoramente longo, mas será um programa útil para você consultar quando precisar usar um determinado controle.
Você não precisa ler o programa inteiro em detalhes, mas quando tiver interesse em usar, por exemplo, um CheckBox, volte a este programa, encontre as partes que falam de CheckBox e estude essas partes.
Observe que para usar PictureBox e DataGridView de maneiras interessantes, também usaremos os namespaces System.Drawing, System.Data e System.Xml;
Código para o programa 7
using System;
using System.Windows.Forms;
using System.Drawing;
using System.Data;
using System.Xml;
class FormWithManyControls : Form
{
TreeView treeView1;
Panel panel1;
CheckBox checkBox1, checkBox2;
RadioButton radiobutton1, radioButton2;
ListBox listBox1;
// The constructor method for our class
public FormWithManyControls()
{
// Set window title and size
this.Text = "A form dealing with many types of controls";
this.Width = 700;
this.Height = 500;
// Add a tree view as a kind of menu
treeView1 = new TreeView();
treeView1.BackColor = Color.BurlyWood;
treeView1.Dock = DockStyle.Left;
treeView1.AfterSelect +=
new System.Windows.Forms.TreeViewEventHandler(treeView1_AfterSelect);
TreeNode tn = new TreeNode("Controls");
tn.Expand();
tn.Nodes.Add(new TreeNode("[Wipe clean]"));
tn.Nodes.Add(new TreeNode("Label"));
tn.Nodes.Add(new TreeNode("Button"));
tn.Nodes.Add(new TreeNode("CheckBox"));
tn.Nodes.Add(new TreeNode("RadioButton"));
tn.Nodes.Add(new TreeNode("ListBox"));
tn.Nodes.Add(new TreeNode("TextBox"));
tn.Nodes.Add(new TreeNode("TabControl"));
tn.Nodes.Add(new TreeNode("DataGridView"));
tn.Nodes.Add(new TreeNode("MainMenu"));
tn.Nodes.Add(new TreeNode("ToolBar"));
tn.Nodes.Add(new TreeNode("PictureBox"));
tn.Nodes.Add(new TreeNode("RichTextBox"));
treeView1.Nodes.Add(tn);
this.Controls.Add(treeView1);
// Add a panel to put all the other controls on
panel1 = new Panel();
panel1.Dock = DockStyle.Right;
panel1.BorderStyle = BorderStyle.Fixed3D;
panel1.Width = this.Width - treeView1.Width;
this.Controls.Add(panel1);
}
// An eventhandler that runs when something in the treeview is selected
private void treeView1_AfterSelect
(object sender, System.Windows.Forms.TreeViewEventArgs e)
{
// Do something appropriate for whichever node was clicked
if (e.Node.Text == "[Wipe clean]")
{
// Wipe the panel clean of any controls
panel1.Controls.Clear();
}
else if (e.Node.Text == "Button")
{
// Add a button to the panel
Button button1 = new Button();
button1.Text = "I'm a button";
button1.Location = new Point(150, 80);
button1.Click += new EventHandler(button1_Click);
panel1.Controls.Add(button1);
}
else if (e.Node.Text == "Label")
{
// Add a label to the panel
Label label1 = new Label();
label1.Text =
"This is a label. Labels are simply used " +
"to write text at a point on the screen";
label1.Location = new Point(150, 10);
label1.Width = 400;
label1.Click += new EventHandler(label1_Click);
panel1.Controls.Add(label1);
}
else if (e.Node.Text == "CheckBox")
{
// Add some checkboxes to the panel
checkBox1 = new CheckBox();
checkBox1.Text = "I am sharp";
checkBox1.Location = new Point(10, 50);
checkBox1.CheckedChanged +=
new EventHandler(CheckBox_CheckedChanged);
panel1.Controls.Add(checkBox1);
checkBox2 = new CheckBox();
checkBox2.Text = "I am modest";
checkBox2.Location = new Point(10, 70);
checkBox2.CheckedChanged +=
new EventHandler(CheckBox_CheckedChanged);
panel1.Controls.Add(checkBox2);
}
else if (e.Node.Text == "RadioButton")
{
// Add some radio buttons to the panel
radiobutton1 = new RadioButton();
radiobutton1.Text = "I am sharp";
radiobutton1.Location = new Point(370, 210);
radiobutton1.CheckedChanged +=
new EventHandler(RadioButton_CheckedChanged);
panel1.Controls.Add(radiobutton1);
radioButton2 = new RadioButton();
radioButton2.Text = "I am dim-witted";
radioButton2.Location = new Point(370, 230);
radiobutton1.CheckedChanged +=
new EventHandler(RadioButton_CheckedChanged);
panel1.Controls.Add(radioButton2);
}
else if (e.Node.Text == "ListBox")
{
// Add a listbox to the panel
listBox1 = new ListBox();
listBox1.Items.Add("Green");
listBox1.Items.Add("Beige");
listBox1.Items.Add("White");
listBox1.Location = new Point(200, 180);
listBox1.SelectedIndexChanged +=
new EventHandler(listBox1_SelectedIndexChanged);
panel1.Controls.Add(listBox1);
}
else if (e.Node.Text == "TextBox")
{
// Add a text box to the panel
TextBox TextBox1 = new TextBox();
TextBox1.Text = "You can type here";
TextBox1.Location = new Point(10, 110);
panel1.Controls.Add(TextBox1);
}
else if (e.Node.Text == "DataGridView")
{
// Add a datagrid, populated with data from an xml file, to the panel
DataSet dataSet1 = new DataSet("A sample DataSet");
dataSet1.ReadXml("../../data/grades.xml");
DataGridView dataGridView1 = new DataGridView();
dataGridView1.Width = (panel1.Width / 2) - 10;
dataGridView1.Height = 150;
dataGridView1.Location =
new Point(2, panel1.Height - dataGridView1.Height - 5);
dataGridView1.DataSource = dataSet1;
dataGridView1.DataMember = "subject";
panel1.Controls.Add(dataGridView1);
}
else if (e.Node.Text == "TabControl")
{
// Add a tab control to the panel
// and add some content to each tab page
TabControl tabControl1 = new TabControl();
tabControl1.Location = new Point(10, 150);
tabControl1.Size = new Size(165, 146);
TabPage tabPage1 = new TabPage("Robynne");
PictureBox pictureBox1 = new PictureBox();
pictureBox1.Image = new Bitmap("../../images/robynne.jpg");
pictureBox1.Size = new Size(160, 120);
tabPage1.Controls.Add(pictureBox1);
tabControl1.TabPages.Add(tabPage1);
TabPage tabPage2 = new TabPage("Her Dog");
PictureBox pictureBox2 = new PictureBox();
pictureBox2.Image = new Bitmap("../../images/chocolate.jpg");
pictureBox2.Size = new Size(160, 120);
tabPage2.Controls.Add(pictureBox2);
tabControl1.TabPages.Add(tabPage2);
TabPage tabPage3 = new TabPage("Info");
tabPage3.BackColor = Color.White;
Label label1 = new Label();
label1.Text =
"Robynne lives in Cape Town, South Africa.\n\n" +
"She has a dog named Chocolate, from the planet Woof," +
" rapidly growing into her oversized ears.";
label1.Dock = DockStyle.Fill;
tabPage3.Controls.Add(label1);
tabControl1.TabPages.Add(tabPage3);
panel1.Controls.Add(tabControl1);
}
else if (e.Node.Text == "PictureBox")
{
// Add a picture to the panel
PictureBox pictureBox1 = new PictureBox();
pictureBox1.Image = new Bitmap("../../images/ocean.jpg");
pictureBox1.BorderStyle = BorderStyle.Fixed3D;
pictureBox1.Location = new Point(250, 25);
pictureBox1.Size = new Size(300, 130);
panel1.Controls.Add(pictureBox1);
}
else if (e.Node.Text == "RichTextBox")
{
// Add a box for typing rich text in
// Load some data from an XML file into it
RichTextBox richTextBox1 = new RichTextBox();
richTextBox1.LoadFile("../../data/grades.xml",
RichTextBoxStreamType.PlainText);
richTextBox1.WordWrap = false;
richTextBox1.BorderStyle = BorderStyle.Fixed3D;
richTextBox1.BackColor = Color.Beige;
richTextBox1.Size = new Size((panel1.Width / 2) - 10, 150);
richTextBox1.Location =
new Point((panel1.Width / 2) + 10,
panel1.Height - richTextBox1.Height - 5);
panel1.Controls.Add(richTextBox1);
}
else if (e.Node.Text == "MainMenu")
{
// Add a classic "menu" (appears at the top of the window)
MainMenu mainMenu1 = new MainMenu();
MenuItem menuItem1 = new MenuItem("File");
menuItem1.MenuItems.Add("Exit",
new EventHandler(mainMenu1_Exit_Select));
mainMenu1.MenuItems.Add(menuItem1);
MenuItem menuItem2 = new MenuItem("Background");
menuItem2.MenuItems.Add("Choose",
new EventHandler(mainMenu1_ColorOwn_Select));
menuItem2.MenuItems.Add("White",
new EventHandler(mainMenu1_ColorWhite_Select));
mainMenu1.MenuItems.Add(menuItem2);
this.Menu = mainMenu1;
MessageBox.Show("A main menu has been added at the top " +
"left of the window. Try it out after clicking OK.");
}
else if (e.Node.Text == "ToolBar")
{
// Add a shortcuts toolbar to the panel
ToolBar toolBar1 = new ToolBar();
ImageList imageList1 = new ImageList();
imageList1.Images.Add(new Bitmap("../../images/open.gif"));
imageList1.Images.Add(new Bitmap("../../images/close.gif"));
imageList1.Images.Add(new Bitmap("../../images/undo.gif"));
toolBar1.ImageList = imageList1;
ToolBarButton toolBarbutton1 = new ToolBarButton("Open");
toolBarbutton1.ImageIndex = 0;
toolBar1.Buttons.Add(toolBarbutton1);
ToolBarButton toolBarbutton2 = new ToolBarButton("Close");
toolBarbutton2.ImageIndex = 1;
toolBar1.Buttons.Add(toolBarbutton2);
ToolBarButton toolBarButton3 = new ToolBarButton("Huh");
toolBarButton3.ImageIndex = 3;
toolBar1.Buttons.Add(toolBarButton3);
toolBar1.ButtonClick +=
new ToolBarButtonClickEventHandler(toolBar1_Click);
panel1.Controls.Add(toolBar1);
}
}
/* All other event handlers - for the controls added above */
// An eventhandler that will be run if the label is clicked
void label1_Click(object sender, System.EventArgs e)
{
MessageBox.Show
("Yes, labels can be clicked, although it's not normal to do so.");
}
// An eventhandler that will be run if the button is clicked
void button1_Click(object sender, System.EventArgs e)
{
MessageBox.Show("Yup, you were supposed to click me");
}
// An eventhandler that will be run if a checkbox is checked/unchecked
void CheckBox_CheckedChanged(object sender, System.EventArgs e)
{
if (checkBox1.Checked && checkBox2.Checked)
{
MessageBox.Show("Good for you");
}
else if (checkBox1.Checked)
{
MessageBox.Show("It's not good to be sharp without being modest");
}
else if (checkBox2.Checked)
{
MessageBox.Show("Modesty is good. Pity you're not sharp too.");
}
else
{
MessageBox.Show("Oh dear, neither sharp nor modest eh?");
}
}
// An eventhandler that will be run if a radiobutton is clicked
void RadioButton_CheckedChanged(object sender, System.EventArgs e)
{
if (radiobutton1.Checked)
{
MessageBox.Show("Glad to hear it");
}
else if (radioButton2.Checked)
{
MessageBox.Show("What a shame");
}
}
// An eventhandler that will be run if an item in the listbox is selected
void listBox1_SelectedIndexChanged(object sender, System.EventArgs e)
{
if (listBox1.SelectedItem.ToString() == "Green")
{
treeView1.BackColor = Color.LightSeaGreen;
}
else if (listBox1.SelectedItem.ToString() == "Beige")
{
treeView1.BackColor = Color.Beige;
}
else if (listBox1.SelectedItem.ToString() == "White")
{
treeView1.BackColor = Color.White;
}
}
// An eventhandler that will be run if "white" is selected at the menu
void mainMenu1_ColorWhite_Select(object sender, System.EventArgs e)
{
treeView1.BackColor = Color.White;
}
// An eventhandler that will be run if a color is selected at the menu
void mainMenu1_ColorOwn_Select(object sender, System.EventArgs e)
{
ColorDialog colorDialog1 = new ColorDialog();
colorDialog1.Color = treeView1.BackColor;
colorDialog1.ShowDialog();
treeView1.BackColor = colorDialog1.Color;
}
// An eventhandler that will be run if the user chooses "exit" at the menu
void mainMenu1_Exit_Select(object sender, System.EventArgs e)
{
if (
MessageBox.Show("Are you sure you want to exit?",
"Exit confirmation", MessageBoxButtons.YesNo)
== DialogResult.Yes
)
{
this.Dispose();
}
}
// An eventhandler that will be run if a toolbar shortcut is selected
void toolBar1_Click
(object sender, System.Windows.Forms.ToolBarButtonClickEventArgs e)
{
if (e.Button.Text == "Open")
{
MessageBox.Show("This could have opened a file, for example");
}
else if (e.Button.Text == "Close")
{
MessageBox.Show("This could have closed a file, for example");
}
else if (e.Button.Text == "Huh")
{
MessageBox.Show("Huh?");
}
}
static void Main()
{
// Start a new instance of a forms application, using our class above
Application.Run(new FormWithManyControls());
}
}
Bb297402.Bb2974021f5a9537-844f-4f63-94cd-02e2fc570e4b(pt-br,VS.80).png
Bb297402.clear(pt-br,VS.80).gifSystem.Drawing
Introdução
As classes agrupadas no namespace “Drawing” permitem que trabalhemos com diferentes tipos de imagens. Nos computadores, nós normalmente lidamos com dois tipos gerais de imagens:
Gráficos de varredura ou bitmap
Gráficos vetoriais
Bb297402.Bb297402a61ceb9e-d624-4d58-b4ff-8b4d79a7b9db(pt-br,VS.80).png
Bb297402.Bb2974021f864ac9-5a7e-416d-a80b-6deac317df1f(pt-br,VS.80).png
Gráficos de bitmap são imagens feitas de vários pontos. Por exemplo, fotografias e ícones podem ser representados bem como bitmaps.
Gráficos vetoriais são imagens feitas de formas específicas como linhas, círculos, retângulos etc. A planta de uma casa, por exemplo, pode ser muito bem representada por gráficos vetoriais.
Bb297402.clear(pt-br,VS.80).gifBitmap Graphics
Primeiro, mostrarei alguns exemplos de como trabalhar com gráficos de bitmap. É muitas vezes útil trabalhar com imagens como fotografias no computador, e a biblioteca de classe do .NET Framework inclui muitos códigos úteis para fazer isso.
Programa de exemplo 8
Este programa simplesmente busca uma imagem de bitmap (um arquivo JPEG, neste caso) a partir do disco e o exibe em um formulário.
Para exibir uma imagem em um formulário, é útil usar algum controle capaz de exibir imagens. O controle PictureBox é perfeito para essa finalidade.
Código para o programa 8
using System;
using System.Windows.Forms;
using System.Drawing;
class PictureDisplayer : Form
{
Bitmap image1;
PictureBox pictureBox1;
// The constructor method for our class
public PictureDisplayer()
{
// Set the window title and size
this.Text = "Picture Displayer";
this.Size = new Size(302, 240);
// Prepare a box to hold a picture
pictureBox1 = new PictureBox();
pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage;
pictureBox1.BorderStyle = BorderStyle.Fixed3D;
pictureBox1.ClientSize = new Size(300, 196);
// Add a picture to the box
image1 = new Bitmap(@"../../images/lama.jpg");
pictureBox1.Image = (Image)image1;
// Add the box (with it's picture) to the form
this.Controls.Add(pictureBox1);
}
static void Main()
{
// Start a new instance of a forms application, using our class above
Application.Run(new PictureDisplayer());
}
}
Bb297402.Bb29740268488091-620c-4fca-98e8-d9b707629b32(pt-br,VS.80).png
Programa de exemplo 9
Este próximo programa carrega uma fotografia a partir do disco e também permite que o usuário gire-a horizontalmente clicando no botão "Flip" (Girar).
Código para o programa 9
using System;
using System.Windows.Forms;
using System.Drawing;
class PictureFlipper : Form
{
Button button1;
Bitmap image1;
PictureBox pictureBox1;
// The constructor method for our class
public PictureFlipper()
{
// Set the window title and size
this.Text = "Picture Flipper";
this.Size = new Size(302, 240);
// Add a button to the form
button1 = new Button();
button1.Text = "Flip";
button1.Location = new Point(100, 150);
button1.Click += new System.EventHandler(button1_Click);
this.Controls.Add(button1);
// Add a picture box to the form
pictureBox1 = new PictureBox();
pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage;
pictureBox1.BorderStyle = BorderStyle.Fixed3D;
pictureBox1.ClientSize = new Size(300, 196);
// Add an image to the picture box
image1 = new Bitmap(@"../../images/elephants.jpg");
pictureBox1.Image = (Image)image1;
// Add the picture box (with its image) to the form
this.Controls.Add(pictureBox1);
}
static void Main()
{
// Start a new instance of a forms application, using our class above
Application.Run(new PictureFlipper());
}
// An eventhandler that will run when the button is clicked
void button1_Click(object sender, EventArgs e)
{
// Flip the image along the X axis (horizontally)
image1.RotateFlip(RotateFlipType.RotateNoneFlipX);
// Re-insert the image into the picture box
pictureBox1.Image = (Image)image1;
// Update the window title
this.Text = "Picture was flipped";
}
}
Bb297402.Bb297402faa2acd8-fcca-43d5-aeda-b724f79c4e1b(pt-br,VS.80).png
Bb297402.clear(pt-br,VS.80).gifVector Graphics
Agora, vamos passar para exemplos que tratam de gráficos vetoriais – imagens feitas de formas específicas.
Em todos esses exemplos, criaremos um botão e um método de manipulador de eventos para detectar o evento de clique do botão. Apenas depois que o botão for clicado é que executaremos o código que funciona com o gráfico.
Veja alguns conceitos importantes a entender. Eles são muito lógicos – mas se você não os conhecia, poderá ficar um pouco confuso:
1.
No mundo real, para desenhar uma linha, um círculo, um retângulo etc., você precisa primeiro selecionar uma caneta de cor e espessura corretas.
Da mesma forma, para desenhar uma forma simples no computador, você deve primeiro criar um objeto Pen. Por exemplo, esse código cria um objeto Pen que desenhará em verde com uma espessura de 3 pixels:
Pen myGreenPen = new Pen( Color.Green, 3 );
2.
Para criar uma forma colorida, você poderia usar algo como um pincel.
No computador, formas coloridas podem apenas ser criadas se você tiver criado um objeto Brush com alguma cor escolhida. Existem diferentes tipos de pincéis disponíveis; o seguinte trecho de código criará um objeto SolidBrush azul:
SolidBrush myBlueBrush = new SolidBrush( Color.Blue );
Programa de exemplo 10
Neste programa, o método DrawSomeShapes cria uma linha, um retângulo e uma elipse (um círculo achatado).
Código para o programa 10
using System;
using System.Windows.Forms;
using System.Drawing;
class SimpleShapeMaker : Form
{
// The constructor method for our class
public SimpleShapeMaker()
{
// Set the form background to white
this.BackColor = Color.White;
// Add a button, hooked up to an event handler, to the form
Button button1 = new Button();
button1.Text = "click me";
button1.Location = new Point(110, 10);
button1.BackColor = Color.SteelBlue;
button1.Click += new System.EventHandler(button1_Click);
this.Controls.Add(button1);
}
// An eventhandler that will run when the button is clicked
void button1_Click(object o, System.EventArgs e)
{
// Execute a specific method we wrote
DrawSomeShapes();
}
// A method that draws a few shapes on the form surface
void DrawSomeShapes()
{
// Prepare a drawing surface for this form
Graphics g = this.CreateGraphics();
// Prepare a pen that draws red and with a width of 3
Pen redPen = new Pen(Color.Red, 3);
// Use the pen to draw a straight line, a rectangle and an oval
g.DrawLine(redPen, 140, 170, 140, 230);
g.DrawRectangle(redPen, 50, 60, 50, 60);
g.DrawEllipse(redPen, 150, 100, 100, 60);
// Clean up
g.Dispose();
}
static void Main()
{
// Start a new instance of a forms application, using our class above
Application.Run( new SimpleShapeMaker() );
}
}
Bb297402.Bb29740211320f02-ead5-4d5c-b273-4d98ef05a048(pt-br,VS.80).png
Programa de exemplo 11
Que tal nos divertirmos um pouco com o mouse agora? Fazer coisas gráficas interessantes é normalmente mais fácil com um mouse do que com um teclado. Neste próximo exemplo, trabalhamos com gráficos de bitmap e vetoriais, mas também aproveitamos a oportunidade para usar alguns eventos do mouse.
Fazemos algumas coisas novas interessantes abaixo – particularmente com bitmaps. Embora não desejemos escrever um artigo sobre isso, veja um pouquinho dos fundamentos para ajudá-lo a entender os conceitos por trás do código:
*
Os programas de computadores fazem os gráficos aparecerem na tela mudando a cor e o brilho de pontos minúsculos chamados pixels.
*
Cada pixel é composto das três cores primárias: vermelho, verde e azul (muitas vezes abreviado para RGB em linguagens de programação). Você altera a cor/o brilho do pixel variando as intensidades de R, G e B, normalmente entre os valores de 0 e 255. Por exemplo:
o
se vermelho=255 e verde=0 e azul=0, o pixel aparecerá vermelho brilhante.
o
se vermelho=255 e verde=255 e azul=0, o pixel aparecerá amarelo brilhante.
*
A posição do mouse pode ser detectada pelo computador e é especificada em termos das coordenadas X e Y (coordenadas horizontais e verticais). O lado esquerdo superior da tela, por exemplo, é especificado por X=0 e Y=0.
Código para o programa 11
using System;
using System.Windows.Forms;
using System.Drawing;
class FunWithTheMouse : Form
{
// Declare some objects we'll want to talk to from several methods
PictureBox pictureBox1;
Label label1;
Point spotClicked;
// The constructor method for our class
public FunWithTheMouse()
{
// Set the window size
this.Size = new Size(640, 480);
// Load a photo into a picture box and add it to the form
pictureBox1 = new PictureBox();
pictureBox1.Image = (Image)new Bitmap(@"../../images/foal.jpg");
pictureBox1.SizeMode = PictureBoxSizeMode.Normal;
pictureBox1.Dock = DockStyle.Fill;
this.Controls.Add(pictureBox1);
// Add a label to the bottom, carrying some instructions
label1 = new Label();
label1.BackColor = Color.Wheat;
label1.Dock = DockStyle.Bottom;
label1.Text =
"Drag rectangle with left mouse button (draw) or another " +
"mouse button (lighten). To scribble, hold SHIFT and move mouse.";
label1.TextAlign = ContentAlignment.MiddleCenter;
this.Controls.Add(label1);
// Hook up the picturebox to event handlers for doing mousy things
this.pictureBox1.MouseDown += new MouseEventHandler(MouseButtonIsDown);
this.pictureBox1.MouseUp += new MouseEventHandler(MouseButtonIsUp);
this.pictureBox1.MouseMove += new MouseEventHandler(TheMouseMoved);
}
// An event handler that will run when the mouse is MOVED
public void TheMouseMoved(object sender, MouseEventArgs e)
{
// If the user is holding down a SHIFT key on the keyboard
if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
{
// Prepare a drawing surface on the picture
System.Drawing.Graphics g = this.pictureBox1.CreateGraphics();
// Use a yellow pen
System.Drawing.Pen yellowPen = new System.Drawing.Pen(Color.Yellow, 3);
// Draw a circle (an ellipse with equal width & height)
// at the current X and Y co-ordinates of the mouse
g.DrawEllipse(yellowPen, e.X, e.Y, 40, 40);
// Clean up
g.Dispose();
}
}
// An event handler that will run when a mouse button is pressed DOWN
public void MouseButtonIsDown(object sender, MouseEventArgs e)
{
// Just remember WHERE the mouse was clicked. When the
// button is released, we'll want to retrieve this location
spotClicked.X = e.X; // horizontal co-ordinate
spotClicked.Y = e.Y; // vertical co-ordinate
}
// An event handler that will run when a mouse button is released
public void MouseButtonIsUp(object sender, MouseEventArgs e)
{
/* Ah, the user let go the button they were holding down! */
// Define a rectangle (not yet a visual one) that describes
// the area of the picture the user wants to do something with
Rectangle r = new Rectangle();
// The left, top corner is where they pressed the mouse down,
// which we "remembered" in the method above
r.X = spotClicked.X;
r.Y = spotClicked.Y;
// The width and height of the rectangle can be worked out
// by subtracting the original point clicked from where
// the mouse is now (when the user is letting go)
r.Width = e.X - spotClicked.X;
r.Height = e.Y - spotClicked.Y;
if (e.Button == MouseButtons.Left)
{
/* If left button was pressed/released, just draw
a visual rectangle so they can see it */
// Prepare a drawing surface on the picture box
Graphics g = this.pictureBox1.CreateGraphics();
// Draw a rectangle in red
Pen redPen = new Pen(Color.Red, 2);
g.DrawRectangle(redPen, r);
}
else
{
// If it was another button, call our more complicated
// method that knows how to "lighten" an area of the photo
ChangeLightness(r);
}
}
// A method that increases the lightness of the image portion
// selected, by increasing the lightness of each pixel in that area
public void ChangeLightness(Rectangle rect)
{
int newRed, newGreen, newBlue;
Color pixel;
// Get a copy of the picture that's in the picture box
System.Drawing.Bitmap picture = new Bitmap(this.pictureBox1.Image);
// Since brightening an area can take a long time,
// warn the user about this if they select a big area
if ( (rect.Width>150) || (rect.Height>150 ) )
{
DialogResult result =
MessageBox.Show
(
"The area you selected is large and may take a long time to lighten",
"Warning",
MessageBoxButtons.OKCancel
);
// If they click "cancel", jump out of this method
// and return to whatever called it
if ( result == DialogResult.Cancel ) return;
}
/* Step through all pixels in the given block, doubling the
brightness of each pixel's RGB (red, green and blue) colors */
// From left to right, across the width of the area selected ...
for (int x = rect.X; x < rect.X + rect.Width; x++)
{
// And from top to bottom, down the height of the area selected ...
for (int y = rect.Y; y < (rect.Y + rect.Height); y++)
{
// Read the pixel we're at
pixel = picture.GetPixel(x, y);
// Prepare a brighter version of the three primary colors in that pixel
newRed = (int)Math.Round(pixel.R * 2.0, 0);
if (newRed > 255) newRed = 255;
newGreen = (int)Math.Round(pixel.G * 2.0, 0);
if (newGreen > 255) newGreen = 255;
newBlue = (int)Math.Round(pixel.B * 2.0, 0);
if (newBlue > 255) newBlue = 255;
// Apply the new colors to the pixel
picture.SetPixel
(
x,
y,
Color.FromArgb((byte)newRed,(byte)newGreen, (byte)newBlue)
);
}
}
// Put the modified copy of the picture into the pictureBox
// so the user can see the changes
this.pictureBox1.Image = picture;
}
static void Main()
{
// Create a new instance of our form class
Application.Run(new FunWithTheMouse());
}
}
Bb297402.Bb2974023f5c3780-ee73-4399-8b34-196bad5f783b(pt-br,VS.80).png
Bb297402.clear(pt-br,VS.80).gifSystem.Data
Introdução
A maioria dos aplicativos existentes precisa trabalhar com bancos de dados. Pergunte a qualquer programador de uma grande empresa e você o ouvirá falar sobre a importância dos bancos de dados no mundo da informática. Um programador que possa trabalhar com bancos de dados estará em uma posição de criar muitos aplicativos realmente úteis.
Você pode possuir um banco de dados como o Microsoft Access no seu computador. Por outro lado, você poderia instalar o Microsoft SQL Server Express Edition, que é uma ótima maneira de aprender sobre o banco de dados do SQL Server, usado em várias das maiores empresas do mundo. O SQL Server Express está disponível como parte da instalação do Visual C# Express, então é provável que você já o tenha instalado.
As classes System.Data no .NET Framework permitem que você trabalhe com bancos de dados. Um banco de dados é bem diferente de coisas como imagens e documentos do processador de texto, muitas vezes chamados de não-estruturados. Um banco de dados é mais estruturado. Ele contém com mais freqüência várias linhas com os mesmos tipos de dados, agrupados em blocos chamados tabelas. A tabela contém uma ou mais colunas e cada coluna contém informações particulares para aquela linha.
As linhas são às vezes chamadas de registros e as colunas são às vezes chamadas de campos.
Veja uma representação de uma tabela de banco de dados contendo informações sobre planetas. As colunas, neste caso, são NomedoPlaneta, DistânciadoSol e Habitantes.
PLANETA
NomedoPlaneta
DistânciadoSol
Habitantes
Mercúrio
57909
Mercurianos
Vênus
108200
Venusianos
Terra
149600
Terrestres
Marte
227940
Marcianos
Júpiter
778400
Jupiterianos
Znock
7208100
Znockers
Saturno
1423600
Saturnianos
Urano
2867000
Uranianos
Netuno
4488400
Netunianos
Plutão
5909600
Plutonianos
Você pode ver, por exemplo, que o planeta Vênus fica a 108.200 quilômetros do Sol e que as criaturas que vivem lá são chamadas de venusianos.
Veja outra tabela, desta vez mostrando quantas criaturas foram encontradas vivendo nos planetas em cada ano.
Essas são informações supersecretas nunca reveladas antes. Elas foram recuperadas de uma nave alienígena que caiu em uma parte remota do deserto de Gobi. Você deve se sentir privilegiado por ter uma cópia. Aparentemente, eles também usam bancos de dados do SQL Server Express, o que facilitou para que agrupássemos uma cópia com os exemplos de códigos.
POPULAÇÃO
NomedoPlaneta
Ano
População
Mercúrio
2000
40000
Vênus
2000
25
Terra
2000
6000000000
Marte
2000
325000
Júpiter
2000
8426300200
Znock
2000
550000
Saturno
2000
1000000
Urano
2000
753425370
Netuno
2000
Plutão
2000
Mercúrio
2001
35000
Vênus
2001
3
Terra
2001
6500000000
Marte
2001
326000
Júpiter
2001
8426300202
Znock
2001
8700
Saturno
2001
75000
Urano
2001
844360002
Netuno
2001
Plutão
2001
Olhando todas as linhas que se referem a Vênus, você observará que existem duas. Você pode ver que no ano 2000 existiam 25 venusianos em Vênus, mas em 2001 sobraram apenas 3 deles. Acho que os vulcões os exterminaram.
Não confunda tabelas de bancos de dados com planilhas. Embora seja verdade que as planilhas podem mostrar dados de uma maneira parecida com as tabelas acima, o modo com que elas trabalham com os dados é bem diferente.
A linguagem SQL
Existem diversos bancos de dados diferentes no mundo todo: Microsoft Access, Oracle, DB2, Microsoft SQL Server, Informix, mySQL, e a lista continua. Então como você conversa com um banco de dados em C#? Eles todos entenderão o que estamos pedindo?
A resposta simples é que você usa uma linguagem como C# para empacotar e enviar alguma "linguagem de banco de dados" ao banco de dados e ele decide como buscar e enviar de volta as colunas e linhas que você solicitou.
(Para dizer a verdade, existe outra camada intermediária chamada ADO.NET, mas não falaremos muito sobre isso aqui.)
Muitos anos atrás, devido a todos os diferentes bancos de dados, algumas pessoas se reuniram e concordaram com "uma linguagem de banco de dados" que poderia falar para a maioria dos bancos de dados do mundo. Essa linguagem é chamada de SQL (abreviação de Structured Query Language). Não confunda a linguagem SQL com o produto da Microsoft chamado SQL Server – a maioria dos bancos de dados suporta a linguagem SQL.
Bb297402.Bb297402f4937c5d-f14e-48dc-a4f8-d072654eb976(pt-br,VS.80).png
Antes de falarmos sobre como trabalhar com bancos de dados em C#, vamos nos familiarizar com os conceitos básicos da linguagem SQL. Veja alguns exemplos de instruções escritas em SQL e o que acontece quando você as executa.
Os três tipos principais de ações são SELECT para exibir alguns dados, INSERT para inserir novos dados e UPDATE para alterar dados existentes – daremos exemplos de cada um deles.
Normalmente, a maneira com que você escreve instruções Select é a seguinte:
SELECT
FROM
WHERE
SELECT *
FROM PLANET
Recupera todas as linhas e todas as colunas da tabela chamada PLANETA. (O asterisco * significa todas as colunas.)
NomedoPlaneta
DistânciadoSol
Habitantes
Mercúrio
57909
Mercurianos
Vênus
108200
Venusianos
Terra
149600
Terrestres
Marte
227940
Marcianos
Júpiter
778400
Jupiterianos
Znock
7208100
Znockers
Saturno
1423600
Saturnianos
Urano
2867000
Uranianos
Netuno
4488400
Netunianos
Plutão
5909600
Plutonianos
SELECT PlanetName, Inhabitants
FROM PLANET
Recupera apenas as colunas "NomedoPlaneta" e "Habitantes" para todas as linhas da tabela PLANETA.
NomedoPlaneta
Habitantes
Mercúrio
Mercurianos
Vênus
Venusianos
Terra
Terrestres
Marte
Marcianos
Júpiter
Jupiterianos
Znock
Znockers
Saturno
Saturnianos
Urano
Uranianos
Netuno
Netunianos
Plutão
Plutonianos
SELECT PlanetName, Inhabitants
FROM PLANET
WHERE PlanetName='Venus'
Recupera apenas as colunas "NomedoPlaneta" e "Habitantes" para apenas aquelas linhas da tabela PLANETA que possuem o NomedoPlaneta "Vênus".
NomedoPlaneta
Habitantes
Vênus
Venusianos
SELECT PlanetName
FROM POPULATION
WHERE Population<100000
Recupera o NomedoPlaneta e a População, da tabela POPULATION, onde quer que a coluna de população possua um valor inferior a 100000.
NomedoPlaneta
População
Mercúrio
40000
Vênus
25
Netuno
Plutão
Mercúrio
35000
Vênus
3
Saturno
75000
Netuno
Plutão
Normalmente, a maneira com que você escreve instruções Insert é a seguinte:
INSERT INTO
(
INSERT INTO PLANET
(PlanetName, DistanceFromSun, Inhabitants)
VALUES
('Fluff', 23500000, 'Fluffies')
Adiciona uma nova linha à tabela PLANETA. Isso é na verdade uma ação "silenciosa" (ela não recupera nenhuma linha para o seu programa em C#), mas mostramos a tabela aqui para que você tenha uma idéia do que aconteceu.
PLANETA
NomedoPlaneta
DistânciadoSol
Habitantes
Mercúrio
57909
Mercurianos
Vênus
108200
Venusianos
Terra
149600
Terrestres
Marte
227940
Marcianos
Júpiter
778400
Jupiterianos
Znock
7208100
Znockers
Saturno
1423600
Saturnianos
Urano
2867000
Uranianos
Netuno
4488400
Netunianos
Plutão
5909600
Plutonianos
Penugem
23500000
Penugianos
Normalmente, a maneira com que você escreve instruções Update é a seguinte:
UPDATE
SET
UPDATE PLANET
SET PlanetName='Stuff', Inhabitants='Stuffies'
WHERE PlanetName='Fluff'
Altera alguns dos valores na linha que possui um NomedoPlaneta "Penugem". Nós mostramos a tabela resultante aqui, mas, na verdade, essa é uma ação "silenciosa" e não recuperará nenhuma linha para o seu programa em C#.
PLANETA
NomedoPlaneta
DistânciadoSol
Habitantes
Mercúrio
57909
Mercurianos
Vênus
108200
Venusianos
Terra
149600
Terrestres
Marte
227940
Marcianos
Júpiter
778400
Jupiterianos
Znock
7208100
Znockers
Saturno
1423600
Saturnianos
Urano
2867000
Uranianos
Netuno
4488400
Netunianos
Plutão
5909600
Plutonianos
Coisa
23500000
Coisianos
Relações e junções
Se você pensar nisso, perceberá que existe uma relação entre as duas tabelas PLANETA e POPULAÇÃO acima. Ambas possuem uma coluna chamada "NomedoPlaneta". Dizemos que as duas tabelas estão relacionadas na coluna "NomedoPlaneta" e isso nos permite coletar todas as informações para um determinado planeta
Poderíamos pegar, por exemplo, todas as linhas relacionadas a Vênus, das duas tabelas...
PLANETA
NomedoPlaneta DistânciadoSol Habitantes
Vênus 108200 Venusianos
POPULAÇÃO
NomedoPlaneta Ano População
Vênus 2000 25
Vênus 2001 3
e reuni-las no que parece ser uma grande tabela...
SELECT *
FROM PLANET INNER JOIN POPULATION ON PLANET.PlanetName=POPULATION.planetName
WHERE PlanetName='Venus'
PLANETAS_E_POPULAÇÃO
NomedoPlaneta DistânciadoSol Habitantes NomedoPlaneta Ano População
Vênus 108200 Venusianos Vênus 2000 25
Vênus 108200 Venusianos Vênus 2001 3
Que banco de dados você está usando?
Existem razões pelas quais os programadores podem querer fazer coisas especiais para bancos de dados ou situações especiais. No ambiente do .NET, por exemplo, existem várias maneiras diferentes de trabalhar com dados. Se você sabe que está usando um banco de dados do Microsoft SQL Server, por exemplo, você pode usar objetos especiais para enviar suas consultas SQL e, por isso, funcionará muito rápido. Mas se você estiver falando com o Microsoft Access, não poderá usar esse objeto especial.
O código difere levemente então, dependendo se você está usando o SQL Server ou não e não temos certeza se você está. Então, veja o que fizemos até agora:
*
Os três programas de exemplo de banco de dados desta seção (12a, 13a e 14a) são escritos supondo que você possui o SQL Server Express instalado (ou uma das outras versões do SQL Server).
*
Mas caso você não possua, também incluímos, com os exemplos de disco, uma versão de cada que usa o Microsoft Access. Esses são os programas 12b, 13b e 14b e eles serão executados sem a necessidade de nenhuma configuração de banco de dados.
Incentivamos você a instalar o SQL Server Express em algum estágio, no entanto; ele é um banco de dados muito melhor com o qual programar. Além disso, as habilidades do SQL Server são mais valiosas no mundo dos negócios – então, quanto antes você conhecer o SQL Server, melhor. Você pode baixá-lo gratuitamente em http://msdn.microsoft.com/vstudio/express/sql/download/.
Se você possui o Microsoft SQL Server Express instalado e em funcionamento, use os exemplos 12a, 13a e 14a. Se não possui ou se tiver problemas ao fazê-lo funcionar, você pode recorrer aos exemplos 12b, 13b e 14b, que fazem a mesma coisa sem a necessidade de um banco de dados instalado.
Conversando com um banco de dados em C#
Nos seguintes exemplos de C#, usaremos as classes SqlConnection e SqlCommand para se comunicarem com o banco de dados de exemplo do SQL Server Express chamado “Planetas”. Essas são classes especiais para conversar com qualquer versão do Microsoft SQL Server. Trabalharemos mais com os dados de duas maneiras diferentes:
1.
Usando a classe SqlDataReader.
A classe SqlDataReader permite a você muito controle de programação, uma vez que você pode percorrer cada linha de dados sozinho e escolher o que fazer com os valores que recebe.
2.
Usando as classes SqlDataAdapter e DataSet.
Datasets são úteis se você deseja ter as linhas de dados automaticamente exibidas em um controle de formulário como um datagrid. Essa abordagem requer algumas linhas de código para que se obtenham os dados do banco de dados, mas evitará muitos problemas em exibir esses mesmos dados – porque controles inteligentes, como o DataGridView, entendem como se vincular a um dataset.
Programa de exemplo 12
O seguinte programa se conecta a um banco de dados do SQL Server Express e envia a ele uma consulta SQL. Ele então recupera os resultados, percorre cada linha e escreve cada valor NomedoPlaneta em uma nova linha em um controle Label.
Código para o programa 12a (versão do SQL Express – consulte o exemplo 12b do disco para a versão do Microsoft Access)
using System.Windows.Forms;
using System.Data;
using System.Data.SqlClient; // Namespace for working with SQL Server data
class SimpleDataAccess : Form
{
public SimpleDataAccess()
{
// Set the window title
this.Text = "A simple databasing program";
// Determine the physical path to the PLANETS sample database
string dbLocation =
System.IO.Path.GetFullPath("../../../database/SqlServer/planets.mdf");
// Add a label that fills the form
Label label1 = new Label();
label1.Dock = DockStyle.Fill;
this.Controls.Add(label1);
// Connect to the SQL Server database
SqlConnection connection1 = new SqlConnection
(
@"data source=.\SQLEXPRESS;" +
"User Instance=true;Integrated Security=SSPI;AttachDBFilename="
+ @dbLocation
);
connection1.Open();
// Talk to the database - ask it for data on planets
string sql = "SELECT * FROM PLANET";
SqlCommand command1 = new SqlCommand(sql, connection1);
SqlDataReader dataReader1 = command1.ExecuteReader();
// Loop through the records returned and add each planet name to the label
while (dataReader1.Read())
{
label1.Text = label1.Text + dataReader1["PlanetName"] + "\n";
}
// Clean up
dataReader1.Close();
connection1.Close();
}
static void Main()
{
// Start a new instance of a forms application, using our class above
Application.Run(new SimpleDataAccess());
}
}
Bb297402.Bb297402274846ec-eea5-4448-8753-f920ed697b01(pt-br,VS.80).png
Programa de exemplo 13
Neste próximo programa, queremos exibir várias colunas de dados, o que seria muito confuso em um Label – então usamos um DataGridView.
Executamos a mesma consulta do programa anterior, mas dessa vez colocamos o resultados em um DataSet. Vinculamos então o DataGridView ao DataSet e ele exibe automaticamente todos os dados.
Vincular alguns dados de back-end invisíveis a um controle visual é conhecido como vinculação de dados.
Código para o programa 13a (versão do SQL Express – consulte o exemplo 13b do disco para a versão do Microsoft Access)
using System.Windows.Forms;
using System.Data;
using System.Data.SqlClient; // Namespace for working with SQL Server databases
class DataInGrid : Form
{
public DataInGrid()
{
// Set the window title
this.Text = "One-Way Database Grid Binding";
// Determine the physical path to the PLANETS sample database
string dbLocation =
System.IO.Path.GetFullPath("../../../database/SqlServer/planets.mdf");
// Add a DataGridView to the form
DataGridView DataGridView1 = new DataGridView();
DataGridView1.Width = this.Width;
DataGridView1.Height = 250;
DataGridView1.DataMember = "Table";
DataGridView1.Dock = DockStyle.Fill;
this.Controls.Add(DataGridView1);
// Connect to the SQL Server database
SqlConnection connection1 = new SqlConnection
(
@"data source=.\SQLEXPRESS; +
"User Instance=true;Integrated Security=SSPI;AttachDBFilename="
+ @dbLocation
);
connection1.Open();
// The DataSet will hold the data in memory (in structures called DataTables)
DataSet dataSet1 = new DataSet();
// The DataAdapter will be the bridge between the database and the dataset
SqlDataAdapter sqlDataAdapter1 = new SqlDataAdapter();
// Tell the DataAdapter what we want it to fetch, and where from
sqlDataAdapter1.SelectCommand =
new SqlCommand("SELECT * FROM PLANET", connection1);
// Fill the in-memory DataSet with the data now
sqlDataAdapter1.Fill(dataSet1);
// Hook the DataGridView (the visual grid) to the in-memory data
DataGridView1.DataSource = dataSet1;
// Close the database connection
connection1.Close();
}
static void Main()
{
// Start a new instance of a forms application, using our class above
Application.Run(new DataInGrid());
}
}
Bb297402.Bb29740205788b30-9bd6-429e-b730-f7c1643e4feb(pt-br,VS.80).png
Programa de exemplo 14
Exibir dados em um DataGridView tudo bem, mas você perceberá que, se alterar os dados, eles não serão salvos de volta no banco de dados. Então, vamos modificar a abordagem para permitir uma “vinculação de dados bidirecional”.
Nós iremos trapacear um pouquinho aqui (ei, isso é chamado de “aumentar nossa produtividade”) não escrevendo nossos próprios comandos do SQL UPDATE e INSERT – o namespace System.Data possui uma pequena classe inteligente chamada CommandBuilder que pode descobrir como escrevê-los sozinha e trata deles nos bastidores.
Código para o programa 14a (versão do SQL Express – consulte o exemplo 14b do disco para a versão do Microsoft Access)
using System.Windows.Forms;
using System.Data;
using System.Data.SqlClient; // Namespace for working with SQL Server databases
class PlanetsForm : Form
{
// Declare some objects we'll be talking to from different methods
DataGridView dg;
SqlDataAdapter da;
public PlanetsForm()
// This is the "constructor" method for the PlanetsForm class
{
// Set the window title
this.Text = "Two-way Database Grid Binding";
// Determine the physical path to the PLANETS sample database
string dbLocation =
System.IO.Path.GetFullPath("../../../database/SqlServer/planets.mdf");
// Prepare to connect to the SQL Server database
string connectionString =
@"data source=.\SQLEXPRESS;" +
"User Instance=true;Integrated Security=SSPI;AttachDBFilename="
+ @dbLocation;
/* Add a "Save" button to the form */
Button btnSave = new Button();
btnSave.Text = "Save";
btnSave.Click += new System.EventHandler(BtnSave_Click);
btnSave.Dock = DockStyle.Top;
this.Controls.Add(btnSave);
/* Add a DataGridView to the form */
dg = new DataGridView();
dg.Width = this.Width;
dg.Height = 250;
dg.Dock = DockStyle.Fill;
this.Controls.Add(dg);
/* Instantiate a few objects that are smart with data and use them
together to "bind" the DataGridView to the back-end data we want */
// DataAdapter will act as bridge between database and in-memory DataTable
da = new SqlDataAdapter("SELECT * FROM PLANET", connectionString);
// CommandBuilder will handle UPDATE and INSERT automatically
SqlCommandBuilder cb = new SqlCommandBuilder(da);
// DataTable will keep track, in memory, of changes
DataTable dt = new DataTable();
// Fill the DataTable with the data now
da.Fill(dt);
// Link the DataTable to the DataGridView now
dg.DataSource = dt;
}
static void Main()
{
// Start a new instance of a forms application, using our class above
Application.Run(new PlanetsForm());
}
private void BtnSave_Click(object sender, System.EventArgs e)
{
// Since the save button was clicked, update the database with
// any changes made to the DataGridView's underlying source, which
// in this case is a DataTable.
da.Update((DataTable)dg.DataSource);
MessageBox.Show
("Data has been saved", "For your information", MessageBoxButtons.OK);
}
}
Bb297402.Bb297402a4f1627a-25a2-49b7-a965-74b5125d83ae(pt-br,VS.80).png
Tente modificar alguns valores e inserir novos. Clique em “Salvar” e feche o formulário. Se você executar o programa novamente, verá que os dados realmente foram atualizados/inseridos no banco de dados.
E se eu não estiver usando o SQL Server Express?
Aqueles de vocês que não possuírem uma versão do Microsoft SQL Server instalado, e possuírem um banco de dados diferente com o qual você deseja falar, precisarão fazer alguns pequenos ajustes.
Em primeiro lugar, a cadeia de caracteres da conexão que descreve o local, o tipo etc. do banco de dados deve ser alterada.
Uma cadeia de caracteres da conexão para o SQL Server Express pode ser parecida com isto:
string connectionString =
"Integrated Security=SSPI;Persist Security Info=False; Initial
Catalog=Northwind;Data Source=localhost";
ou com isto, se você estiver se conectando diretamente ao arquivo do banco de dados (como nos exemplos deste livro):
string connectionString =
@"data source=.\SQLEXPRESS;Integrated Security=SSPI;
AttachDBFilename=c:\C#4#KIDS\examples\database\SqlServer\planets.mdf;
User Instance=true”;
(Devido a restrições de espaço, estamos reunindo tudo isso em algumas linhas, mas, nesse formato, a parte entre aspas realmente precisa estar em uma linha.)
Uma cadeia de caracteres da conexão para o Microsoft Access pode ser parecida com isto:
string connectionString =
@"Provider=Microsoft.Jet.OLEDB.4.0; Data Source
c:\C#4#KIDS\examples\database\Access\planets.mdb;";
(como explicado mais acima, você precisaria escrever isso em uma linha.)
Outros bancos de dados terão cada um seu formato particular. Você pode encontrar exemplos na documentação de ajuda do Visual C# Express ou na documentação que acompanha seu banco de dados.
Além de alterar a cadeia de caracteres da conexão, você pode alterar também as classes “Sql” para classes “OleDb”.
Comece incluindo o namespace System.Data.OleDb no lugar do namespace System.Data.SqlClient. Este contém classes que podem funcionar com uma variedade de bancos de dados.
using System.Data.OleDb;
Em seguida, troque as classes que você usa para funcionar com os dados, da seguinte forma:
SQL Server
Bancos de dados gerais
SqlCommand
OleDbCommand
SqlCommandBuilder
OleDbCommandBuilder
SqlDataAdapter
OleDbDataAdapter
SqlConnection
OleDbConnection
Bb297402.clear(pt-br,VS.80).gifSystem.Xml
Introdução
As classes em System.Xml o ajudam a trabalhar com dados XML de várias maneiras. Tarefas comuns compreendem:
*
abrir um documento XML
*
ler um trecho de XML para extrair alguns valores específicos
*
escrever um arquivo XML no disco
Uma breve introdução ao XML
O XML (Extensible Markup Language) está em todos os lugares hoje em dia e provavelmente você já ouviu falar dele. O XML é um grande exemplo de uma linguagem que as pessoas e os computadores podem entender. Enquanto alguns sistemas de computadores funcionam com dados que parecem ser uma bagunça confusa aos humanos, o XML é escrito em texto simples e pode ser lido pelo caipira comum.
Você pode, por exemplo, reunir um documento XML como o seguinte para manter alguns dados geográficos em disco:
South America
Chile
Argentina
Asia
Iraq
India
Todo documento XML possui essa primeira linha simplesmente para que programas saibam que há XML por vir
O bloco mais externo
Um bloco aninhado (recuado) com informações sobre o continente sul-americano
Blocos mais profundamente aninhados com informações sobre dois países do continente asiático
É muito igual a HTML, mas você é livre para criar seus próprios nomes de marca em XML.
Vamos falar de dois termos que você precisará entender se for ler mais sobre XML.
Elementos
Os dados XML são mantidos dentro de elementos. Um elemento possui um nome e normalmente armazena um valor. No exemplo abaixo, o elemento "País" possui o valor "Argentina".
elementname
elementvalue
Argentina
Como você pode ver acima, um elemento é representado com uma marca de abertura e uma marca de fechamento. A marca de fechamento deve ser nomeada exatamente como a marca de abertura, mas deve incluir uma barra "/".
Se o elemento não possuir valores, é legal usar no lugar apenas uma marca e fechá-lo imediatamente.
elementname
Atributos
Mas podemos querer descrever várias coisas especiais sobre um elemento. Podemos, por exemplo, querer indicar que um país possui uma capital – então, como um exemplo, podemos criar um atributo de nosso elemento chamado "capital". No exemplo abaixo, o atributo "capital" do elemento “País” “Argentina” é igual a “Buenos Aires”.
elementname
attributename
attributevalue
elementvalue
capital
=
"Buenos Aires"
>
Argentina
Tudo isso é muito fácil para nós, humanos, lermos e, como há uma estrutura clara para ele, você pode imaginar que os computadores podem facilmente aprender a ler também. "Computador, examine este documento, quando você se deparar com um "<", saberá que está para ler um nome de elemento. Quando você atingir o próximo ">", saberá procurar o valor do elemento... e assim por diante.
Programa de exemplo 15
O programa a seguir transmite alguns dados geográficos de um arquivo XML e os exibe em um formulário.
Ele usa três classes do namespace System.Xml:
*
XmlDocument (cria um objeto que pode carregar dados XML para que possamos trabalhar)
*
XmlNodeList (útil para hospedar a lista de elementos que lemos do arquivo)
*
XmlNode (armazena um elemento XML)
Essa classe permite que o usuário digite algo chamado de expressão xPath para dizer que elementos obter do arquivo xml. Uma expressão xPath, como //terra/continente/país significa "encontrar todos os elementos chamados ‘país’, onde quer que eles apareçam abaixo de um elemento chamado ‘continente’, que, por sua vez, aparece abaixo de um elemento chamado ‘terra’".
Código para o programa 15
using System;
using System.Windows.Forms;
using System.Drawing;
using System.Xml; // Namespace for working with XML generally
using System.Xml.XPath; // Namespace for working with XML "paths"
class XmlRetriever : Form
{
ComboBox comboBox1;
Button button1;
ListBox listBox1;
RichTextBox richTextBox1;
XmlDocument xmlDoc;
// Constructor method for our class
public XmlRetriever()
{
// Set the window title and height
this.Text = "XML Retrieval";
this.Size = new Size(400, 400);
// Load an XML file from disk into an XmlDocument object in memory
xmlDoc = new XmlDocument();
xmlDoc.Load("../../data/earthData.xml");
// Prepare a large text box to show the data in
richTextBox1 = new RichTextBox();
richTextBox1.Dock = DockStyle.Top;
richTextBox1.AcceptsTab = true;
richTextBox1.Height = 180;
richTextBox1.ReadOnly = true;
richTextBox1.BackColor = Color.Silver;
// Put the XML into the text box and add the textbox to the form
richTextBox1.Text = xmlDoc.OuterXml;
this.Controls.Add(richTextBox1);
// Add a combobox control that allows the user to either type
// an Xpath expression or to choose an existing one. Add some
// as examples to help the user learn to write XPath expressions.
// (A combo box is a combination of a textbox and a listbox)
comboBox1 = new ComboBox();
comboBox1.Location = new Point(0, 200);
comboBox1.Width = 300;
comboBox1.Items.Add("//Earth/Continent");
comboBox1.Items.Add("//Earth/Continent/Country");
comboBox1.Items.Add("//Earth/Continent/Country[@capital='Nairobi']");
comboBox1.SelectedIndex = 0;
this.Controls.Add(comboBox1);
// Add a button that will cause the matching items to be displayed
button1 = new Button();
button1.Text = "Get data";
button1.Location = new Point(310, 200);
button1.Click += new EventHandler(Button1_Click);
this.Controls.Add(button1);
// Add a listbox to display the items returned
listBox1 = new ListBox();
listBox1.Dock = DockStyle.Bottom;
listBox1.Location = new Point(10, 10);
this.Controls.Add(listBox1);
}
static void Main()
{
// Start a new instance of a forms application, using our class above
Application.Run( new XmlRetriever() );
}
// An eventhandler that will run when the button is clicked
void Button1_Click(object sender, EventArgs e)
{
XmlNodeList xmlNodes;
XmlNode xmlElement;
string elementValue;
// Use a try-catch structure to catch and handle any XPath errors
// neatly instead of just letting the program crash
try
{
// From the XML document, select the items specified by the
// XPath query chosen in the combobox
xmlNodes = xmlDoc.SelectNodes(comboBox1.Text);
listBox1.Items.Clear();
// Loop through all the macthing items that were found,
// adding each item to the listbox
for (int i = 0; i < xmlNodes.Count; i++)
{
xmlElement = xmlNodes[i];
if (xmlElement.HasChildNodes)
{
elementValue = xmlElement.FirstChild.Value.Trim();
listBox1.Items.Add(elementValue);
}
}
}
catch (XPathException ex)
{
// If an XPath error was encountered, tell the user neatly and carry on
MessageBox.Show
(
"No matching data was found. Try another xPath expression.",
"Error Encountered. " + ex.Message
);
}
}
}
O programa mostra o arquivo xml bruto em um controle "RichTextBox". Em seguida, abaixo da expressão xPath, que o usuário pode modificar, os valores do elemento resultante são exibidos. Então, depois que você fizer esse programa funcionar, tente alterar a expressão e clicar no botão "Get data" (Obter dados).
Nenhum comentário:
Postar um comentário