Já estamos na oitava postagem do assunto, aqui estão os links das anteriores:

[Parte I] – Olá mundo -> características da linguagem, declaração de variáveis, Consoles Applications e o “Olá Mundo”.
[Parte II] – Variáveis -> tipos de variáveis, operadores, strings e valores lógicos.
[Parte III] – Estruturas Condicionais -> operadores lógicos, estruturas “If” e “Select Case”.
[Parte IV] – Windows Forms Applications -> ambiente de desenvolvimento gráfico, controles, propriedades, métodos, eventos e a instrução Handles.
[Parte V] – Estruturas de Repetição -> instrução Option Explicit, estruturas de repetição “Do”, “While” e “For”. Usando a função Trim().
[Parte VI] – Vetores -> declaração, funções e o laço “For Each”.
[Parte VII] – Strings e conversões de tipos -> instrução Option Strict, funções de strings e conversões entre tipos diferentes de variáveis.

Começando com procedimentos e funções. Consoles Applications e vamos em frente.

Procedimentos

Um procedimento (ou sub-rotina) é um bloco de comandos refenciado por um nome. Então, toda vez que eu quiser executar os comandos que estão dentro de um procedimento, é só chamá-lo pelo nome, como se fosse um comando da linguagem. Esse tipo de código não retorna valores.

A definição simples de um procedimento é:

Sub <nome> ([lista de parâmetros])

<bloco de comandos>

End Sub

<nome> segue os mesmos requisitos para os nomes de variáveis, e [lista de parâmetros] é opcional, algo que veremos mais adiante.

O Sub Main() criado por padrão pelas Console Applications é um exemplo de procedimento.

Quando ocorre a chamada de um procedimento, o Visual Basic entrará na execução do procedimento, e quando terminar continuará na linha seguinte, onde aconteceu a chamada. Para forçar a saída do procedimento, o comando usado é Exit Sub.

Parâmetros

Parâmetros são valores de variáveis que são informados à sub-rotina para que ela possa trabalhar com eles. Existe a passagem por valor, que é a padrão do Visual Basic (ByVal), onde a Sub vai receber uma cópia do valor original. Então, se mudamos dentro da Sub o valor do parâmetro, a variável original não se altera.

A passagem por referência (ByRef) faz com que seja passado um ponteiro para a variável original, ou seja, se o valor do parâmetro muda dentro da Sub, a variável original também muda.

Escopo de variáveis é a abrangência que uma variável tem na aplicação. As Subs podem ter variáveis declaradas dentro delas. Mas variáveis declaradas dentro das Subs só valem lá dentro, depois que a execução sai delas, as variáveis não serão mais consideradas. Veja o exemplo abaixo:

Criei duas Subs que recebem um parâmetro. Na chamada do procedimento, o valor da variável “numero” é passado para “Param1″.

Dentro de cada Sub existe uma variável “fator”, que só existe lá dentro (a variável “fator” dentro de PassValor não é a mesma dentro de PassRef, e não podem ser “enxergadas” fora dos procedimentos).

Acompanhe a ordem das saídas na tela e veja que depois que a variável “numero” é passada por referência, o valor dela muda.

Funções

As funções também são blocos de comandos, mas diferente dos procedimentos sempre vão retornar algum valor. Imagine uma função que faz a soma de dois números: as parcelas seriam os parâmetros, e o retorno seria o total.

A declaração fica:

Function <nome> ([lista de parâmetros]) As <tipo>

<bloco de comandos>

End Function

As formas de passagem de valores são as mesmas. Para o retorno da função, usamos o comando Return, seguido do valor retornado. Quando o Return é executado, a função termina. Dessa forma, poderíamos por exemplo associar uma variável ao resultado da função. Veja abaixo:

A função acima tem dois parâmetros, sendo que Param2 é opcional, indicado pela palavra-chave Optional. Caso na chamada da função esse parâmetro não seja informado, o valor atribuído será o default, indicado na declaração do parâmetro na função (no caso, 3).

No nosso caso, de acordo com o valor de Param1 a função vai retornar a soma ou o produto com Param2. O Visual Studio sempre vai alertar caso o seu código tenha deixado alguma possibilidade de não haver retorno por causa das condicionais.

O mais simples foi isso. Até a próxima.
.NET do it better

Calcular é uma coisa que fazemos todos os dias.

Neste capítulo irei mostrar como criar uma calculadora simples, trabalhar com variáveis globais e estruturas de condição.

Além da calculadora, iremos aprender a trabalhar com bordas em nossos formulários, deixando-os mais estilizados.

Bom aprendizado.

Espero que todos gostem.

Bom aprendizado!

Hoje, vamos ver as funções existentes para manipulação de valores do tipo string, além de funções de conversão entre dados. Mas antes, vamos ver o comportament de algumas declarações importantes.

Criem suas Consoles Applications e mão na massa.

Option Strict

A gente já conhece o Option Explicit, que impede que você use uma variável sem declará-la. Para habilitá-la, o comando Option Explicit On pode ser escrito no início do código, antes de qualquer outra declaração. O comando Option Explicit Off desativa a declaração obrigatória, sendo que o default é obrigar a declaração.

Agora, veja o código abaixo, que à primeira vista tem um problema:

Dim ValorReal As Double = 4.56

Dim ValorInteiro As Integer

ValorInteiro = ValorReal

Se você não identificou o “problema” do código acima, clique aqui e leia o post sobre variáveis.

A princípio, a atribuição que foi feita é inválida, mas na verdade ela não é. O que acontece é que o VB automaticamente faz a conversão do tipo Double para o tipo Integer, e o que vai ser armazenado na variável ValorInteiro é o arredondamento de ValorReal.

O VB arredonda para mais quando o valor da primeira casa decimal foi maior ou igual a cinco, e arredonda para menos se for menor ou igual a quatro.

Veja que a parte fracionária é perdida. Mas você pode desabilitar essa conversão.

Isso é feito com a declaração Option Strict. Quando declarada como Option Strict On, ela impede que conversões implícitas que possam resultar em perda de dados sejam feitas, e declarada como Option Strict Off, deixa que você tente essas conversões (se der certo, que bom, senão…)

Option Strict On

Dim ValorReal As Double = 4.56

Dim ValorInteiro As Integer

ValorInteiro = ValorReal

A atribuição passa a ser inválida, porque você vai perder a parte fracionária da variável. Isso também impede atribuições de String para valores numéricos, pois também é um processo que implicaria em perda de informações. Simples, não é ?

O Visual Studio vai te avisar na hora que a atribuição acima causaria um erro. Você escolhe.

Ah, o default é a permissão das atribuições, ou seja, Option Strict por padrão vem como Off.

Manipulando Strings

Existem muitas funções relacionadas à classe System.String:

- System.String.Concat(args As Object) As String
Dim Nome = String.Concat(“Guanabara”,”.Info”) ‘Retorna Guanabara.Info

Concatena (junta) os valores passados como parâmetro.

- Contains(value As String) As Boolean
If (VariavelString.Contains(“Guanabara”) Then Console.WriteLine(“Contém Guanabara”)

Verifica se a variável possui a string value em seu interior. Retorna True ou False.

- EndsWith(value As String) As Boolean
If (VariavelString.EndsWith(“#”) Then Console.WriteLine(“Pode ser que seja C#”)

Verifica se a varíavel possui a string value em seu interior, sendo que value deve ser o fim do conteúdo da variável.

- StartsWith(value As String) As Boolean
If (VariavelString.StartsWith(“Visual”) Then Console.WriteLine(“Pode ser que seja Visual Basic”)

Verifica se a varíavel possui a string value em seu interior, sendo que value deve ser o início do conteúdo da variável.

- Replace(oldChar As Char, NewChar) As String
Console.WriteLine(Variavel.Replace(“,”,”.”))

Substitui todas as ocorrências de oldChar por NewChar na string.

- Remove(startIndex As Integer, count As Integer) As String
Dim NovaVariavel As String = VariavelString.Insert(4,2)

Remove a partir da posição startIndex um número count de caracteres da string.

- Insert(index As Integer, value As String) As String
Dim NovaVariavel As String = VariavelString.Insert(4,”VB”)

Insere no índice especificado da varíavel a string value passada como parâmetro.

- System.String.Join(separator As String, value() As String) As String
Dim NovaVariavel = Join(“\”, ArrayValores)

Concatena em uma string os valores de um array de strings value, separando os elementos dos índices com o valor passado em separator.

- ToLower/ ToUpper() As String
Dim NovaVariavel = VariavelString.ToLower

Retorna uma string com todos os caracteres da variável transformados em minúsculos (Lower Case) ou todos transformados em maiúsculos (Upper Case).

- Trim() As String
Dim NovaVariavel = VariavelString.Trim

Retorna uma string onde os espaços em branco existentes no início e no fim do conteúdo da variável são removidos. Útil para desconsiderar strings cujo conteúdo seja somente composto por espaços.

- SubString(startIndex As Integer, length As Integer)
Dim NovaVariavel = VariavelString.SuBString(2, 3)

Retorna uma string cujo valor será o conteúdo da varíavel, a partir da posição startIndex, contando length caracteres.

Conversões de Tipos

Algumas vezes, vamos necessitar realizar conversões de um tipo de varíavel para outro tipo, explicitamente. Antigamente, no VB existiam funções como CStr para converter para strings, CInt para converter para Integer, e muitos outros. No Visual Basic.NET, pode ser feito usando métodos das próprias classes.

A conversão para o tipo String pode ser feita com o método ToString:

Dim MeuNumero As Double = 5.67

Console.WriteLine( MeuNumero.ToString() )

Quando a conversão desejada é feita para um tipo numérico, podemos usar os métodos Parse e TryParse das classes. O método Parse faz a conversão, e em caso de erro uma exception será disparada (em outras palavras, vai causar um erro). Se você usar a função TryParse, será feita uma tentativa de conversão, e em caso de erro o retorno será False.

- <classe>.Parse (s As String) As <classe>
Dim X As Byte = Byte.Parse(“3″)
Dim Y As Long = Long.Parse(“2424″)

ou

- <classe>.TryParse (s As String, ByRef result As <classe>) As Boolean
Byte.TryParse(“3″, X)
Long.TryParse(“2424″, Y)

Veja um exemplo de como seria essa conversão:

- Usando o Parse

Dim NumeroReal As Double

Dim NumeroInteiro As Integer = 7

NumeroReal = Double.Parse(NumeroInteiro.ToString())

- Usando o TryParse

Dim NumeroReal As Double

Dim NumeroInteiro As Integer = 7

If Double.TryParse(NumeroInteiro.ToString(), NumeroReal) = False Then

Console.WriteLine(“A conversão resultou em erro”)

End If

Seguindo esse modelo, é possível fazer conversões usando os demais tipos, como SByte, Decimal, Short, e etc.

Por hoje foi só isso. No próximo post, o assunto vai ser sobre uma classe que eu já mencionei várias vezes: Exception. Até lá.

Aula 2 – Alterando cores / Aula 1 – Introdução ao Visual basic

Nesta aula veremos como passar os valores de uma caixa de texto para outra em um formulários diferentes.

Espero que todos gostem!

Bom aprendizado!

Olá pessoal, vamos dar continuidade às postagens de Visual Basic.NET, só um pouquinho atrasadas… Infelizmente não vai dar para manter a regularidade de um post por semana.

O assunto é vetores, então, vamos lá.

Declaração

Um array é um tipo de dado capaz de armazenar um conjunto de valores, diferente das variáveis que armazenam somente um valor de cada vez. E cada um dos elementos armazenados no array é referenciado por um índice.

É como se fosse um armário com várias gavetas, onde cada gaveta é etiquetada. Os índices são as etiquetas, que usamos para identificar as gavetas, e as gavetas são as posições do array onde guardamos o dado (só um dado por índice).

Ah, os valores armazenados em cada posição do array devem ser do mesmo tipo, a não ser que você declare um array do tipo Object.

Os arrays podem ter uma ou mais dimensões. Vamos ver por enquanto só arrays unidimensionais, que chamamos carinhosamente de vetores. Os arrays de duas dimensões ou mais são conhecidos como matrizes. Uma matriz com duas dimensões é semelhante a uma tabela, com linhas e colunas. A partir de três dimensões, a visualização já fica mais complicada.

A declaração de vetores pode ser feita nas formas:

Dim Vetor(0 To 5) As String

‘ou

Dim Vetor(5) As String

Os índices dos arrays sempre começam com 0 (no VB 6, havia a instrução Option Base para fazer com que o início dos índices fosse igual a 1, mas essa opção não existe mais). Ou seja, o array declarado acima vai de 0 até 5, o que significa que podemos ter as seguintes referências para posições:

Vetor(0) = “valor qualquer”
Vetor(1) = “outro valor”
Vetor(2) = “Guanabara”
Vetor(3) = “Teste”
Vetor(4) = “Olá Mundo”
Vetor(5) = “Hostnet”

Isso nos dá 6 posições para guardar valores somente do tipo String, porque de acordo com a declaração, o array é do tipo String.

Associando valores

Como vimos acima, os elementos dos arrays são referenciados por índices, sendo o menor deles sempre zero. Esses índices podem ser usados para ler os valores ou atribuir um valor ao “endereço” que desejarmos.

No momento da declaração de um array, os elementos podem ser definidos dessa forma:

Dim Vetor() As String = {“Qualquer coisa”, “Outra coisa”, “Terceira coisa”}

No caso acima, automaticamente o array vai ter três posições. É como se declarássemos Dim Vetor(2) As String (lembrem-se que há a posição zero, não esqueçam!)

A leitura e associação de valores é feita da mesma forma que variáveis comuns, só que precisamos dizer qual é o índice desejado:

Console.WriteLine(Vetor(1)) ‘Escrevendo o valor na tela

Dim PrimeiroValor As String = Vetor(0)

Cuidado para não informar um índice que esteja fora dos limites do array, caso contrário você vai gerar um erro nada legal – uma exceção, do tipo IndexOutOfRangeException.

Funções de Array

Quem já trabalhou com arrays no Visual Basic 6, sabe que existe uma lista de funções que são úteis para trabalhar com arrays. O Visual Basic 9 (2008) traz essas funções também, mas eu pessoalmente prefiro não mais trabalhar com elas, pelos seguintes motivos:

1° – Existem métodos e funções da plataforma .NET que fazem a mesma coisa que essas funções antigas faziam, então é melhor se acostumar com os novos e deixar os antigos para trás. Até porque esses mesmos métodos funcionarão no C#;

2º – Métodos da plataforma .NET deixam a aplicação mais rápida do que os métodos mantidos por questões de compatibilidade com versões antigas do VB;

3° – Não me surpreenderia se esses métodos antigos fossem retirados da linguagem em versões futuras.

Vamos aos principais:

- GetUpperBound(dimension As Integer) (antigo Ubound)
Console.WriteLine( (Vetor.GetUpperBound).ToString)

Retorna o maior índice de uma dimensão passada como parâmetro. A primeira dimensão é igual a zero, a segunda igual a um e assim vai.

- GetLowerBound(dimension As Integer) (antigo LBound)
Console.WriteLine( (Vetor.GetLowerBound).ToString)

Parecida com função anterior, retorna o menor índice de uma dimensão passada como parâmetro.

- SetValue(value As Object, index As Integer)
Vetor.SetValue(“valor qualquer”, 1)

- Armazena um valor em um índice específico do array.

- Length() As Integer
Console.WriteLine(Vetor.Length.ToString)

Propriedade que retorna o número total de elementos do array.

- Rank() As Integer
Console.WriteLine(Vetor.Rank.ToString)

Propriedade que retorna o número total de dimensões do array.

- System.Array.Reverse(array As System.Array)
Dim VetorReverso = Array.Reverse(Vetor)

Inverte os elementos do array

- System.Array.Resize(ByRef array As System.Array, newSize As Integer)
Array.Resize(Vetor, Vetor.Length + 2)

Modifica o tamanho do array

- System.Array.Sort(array As System.Array)
Dim VetorOrdenado = Array.Sort(Vetor)

Ordena os elementos do array

Redimensionando de outra forma

Além do método Resize, existe uma palavra reservada chamada ReDim. Com o uso dela, podemos redimensionar um array, como abaixo:

Dim Vetor() As Integer = {1, 3, 5, 7}

ReDim Vetor(9)

Assim, Vetor vai ter 10 posições (de 0 a 9), e não somente as 4 posições (de 0 a 3) que tinha no momento da declaração.

Mas há um problema: o ReDim apaga os valores que já estão armazenados no array.  Ou seja, se você redimensionar um array usando essa declaração,  o array estará todo “em branco” depois de ser redimensionado;

Se não quiser que isso aconteça, acrescente a palavra Preserve após o ReDim. Usando o exemplo acima, fica Redim Preserve Vetor(9).

O laço For Each

Essa variação do laço For…Next tradicional pode ser utilizada em arrays, coleções, enumerações e vários outros tipos de dados, que armazenem conjuntos de valores. Ele permite, a cada repetição do laço, trabalharmos com um valor de cada vez que esteja presente no array desejado. A sintaxe é:

For Each <variável> [As <tipo>] In <array>

<bloco de comandos>

Next [<variável>]

Veja abaixo um exemplo:

A variável Numero recebe, a cada loop, um valor associado a um índice do array Vetor, começando do índice zero. Veja que a cada loop elevamos ao quadrado cada um dos números existentes no array.

Essa estrutura é útil quando se deseja efetuar certas operações que envolvam os elementos do array, trabalhando um de cada vez, como foi o caso acima.

Galera, acho que deu para deixar algumas coisas sobre arrays.

Eu gostaria de saber a opinião de vocês sobre as postagens. Estão compreendendo o que é escrito ou existem dúvidas sobre o conteúdo? Alguma pergunta a respeito da linguagem?

A única forma de eu saber o quanto vocês estão aprovando ou desaprovando a coluna é lendo a opinião de vocês nos comentários, pois só assim eu posso fazer postagens realmente boas. Tem algo desagradando? Mandem sugestões. Abraços e até a próxima.

O VBScript (Visual Basic Scripting Edition) é uma adaptação simplificada feita do Visual Basic para utilização como uma linguagem de scripts. O código pode ser escrito em um editor de texto qualquer (até o nosso velho amigo Bloco de Notas serve muito bem) e gravado em um arquivo de extensão .vbs .  Sites feitos em ASP, por padrão, usam como linguagem o VBScript.

Existem algumas diferenças entre o código que usamos no Visual Basic 2008 e no VBScript:

- Como a adaptação foi feita há muitos anos, a sintaxe é semelhante às versões antigas do VB, quando a linguagem nem era orientada a objetos. Por exemplo, os laços de repetição que começam com While terminam em Wend, e não End While.

- As variáveis não têm tipo, então a declaração fica somente Dim <variável>.

- Não existe uma estrutura para tratamento de erros.

É claro que desenvolver um script no Bloco de Notas pode ser extremamente incômodo para alguns, dependendo do que se estiver desenvolvendo. A falta de um ambiente de desenvolvimento incomoda bastante. Então, por que usar VBScript ?

Às vezes, temos a necessidade de executar alguma tarefa de forma automática, sem proceder pelo ambiente gráfico do Windows, ou periodicamente (a cada hora, por exemplo). Um exemplo seria fazer uma consulta a um banco de dados, recuperar algumas informações e criar uma conta de usuário ou um site no IIS em um servidor. E isso pode ser feito com VBScript.

Existem outras linguagens que fazem a mesma coisa, como o PERL e o PowerShell, que podem ser até mais cômodas e poderosas que o VBScript, mas a vantagem principal é que usando VBScript, você não precisa instalar nenhum programa adicional para a execução dos códigos.

Exemplos simples

Para ver o funcionamento da coisa, abra o seu Bloco de Notas e digite o seguinte:

Option Explicit
Dim contador
For contador = 1 To 7
Wscript.Echo “Uma linguagem de script”
Next

Salve esse arquivo como “teste.vbs”, onde você desejar. Em seguida, abra o Prompt de Comando, acesse o diretório onde o arquivo se encontra e digite o comando: Cscript teste.vbs.

Se você não digitou nada errado, deve aparecer o seguinte:

E é assim que os scripts são executados. Se houver algum erro de código, a mensagem de erro será mostrada na janela do prompt, informando em qual linha o erro ocorreu.

O script também pode ser executado dando-se dois cliques ou digitando “Wscript teste.vbs”. O problema é que as mensagens escritas com o comando WScript.Echo seriam mostradas como se fossem caixas de diálogo, e aí você terá que clicar em Ok para que o script prossiga.

Veja abaixo um exemplo mais poderoso. O script criará uma conta de usuário no Windows. As contas de usuário,  para quem não sabe, podem ser vistas em Iniciar -> Configurações -> Painel de Controle -> Ferramentas Administrativas -> Gerenciamento do Computador -> Usuários e Grupos Locais -> Usuários.

Depois de executado esse código, o resultado é esse:

Para algumas pessoas, um script com uma função dessas seria bastante útil.

Em matéria de acesso a banco de dados, os objetos “ADODB.Connection” e “ADODB.Recordset” podem ser usados (esses objetos são conhecidos por quem já trabalhou com banco de dados no VB 6). Para acesso a pastas e arquivos, o componente usado pode ser o “Scripting.FileSystemObject”.

Existem muitas outras tarefas que podemos automatizar com o VBScript, desde tarefas simples até tarefas mais complexas, que envolvam consultas e alterações de dados do sistema.

Quem pretende editar arquivos .vbs poderá usar o AptEdit Lite. No site, há uma versão free. Outro que pode ajudar um pouco é o editor de textos Notepad ++, um ótimo editor de textos que além de VBScript reconhece uma lista enorme de códigos.

Tela do Apt-Edit Lite

O nosso foco é VB.NET, mas se a galera gostar, de vez em quando eu posto alguma coisa sobre VBScript. É só deixar pedidos nos comentários. Pedidos e idéias para as postagens são sempre bem-vindos. Abraços e até a próxima.

Abram o Visual Basic 2008 Express Edition, e vamos começar. Agora vai ser mais rápido!

O Option Explicit

Antes de começar as repetições, vamos ver mais um comando da linguagem.

Por padrão, o VB 2008 não deixa que o usuário use uma variável sem declará-la, já que é uma boa prática de programação sempre definir nome e tipo das variáveis. Porém, isso pode ser desabilitado usando-se o Option Explicit.

Essa instrução deve vir antes de qualquer outro comando, na primeira linha de código e pode ser declarada com o parâmetro On ou Off. Se estiver com On, quer dizer que a declaração é obrigatória (padrão). Se estiver com Off, a declaração não é mais obrigatória. Por exemplo, o código abaixo é válido:

Mas esse aqui não é válido:

Como acima não declaramos Option Explicit Off, o Visual Studio avisará que a variável não foi definida.

Existem outras declarações, como Option Strict e Option Infer, mas não se preocupe com elas agora.

Let’s continue…

While … End While

A sintaxe dessa “estrutulha” é a seguinte:

While <condição>
<bloco de comandos>
End While

Enquanto a condição que especificamos na estrutura for verdadeira, o bloco de comandos será executado até o final e em seguida será executado novamente, até que a condição não seja mais verdadeira.

Veja o exemplo:

No VB 6 e no VBScript, o End While terminava com a instrução Wend. Não havia como interromper o laço de repetição, a única forma de sair era a condição tornar-se falsa. No VB 2008, temos a instrução Exit While para forçar a saída.

Veja abaixo:

Do… Loop

Somente com as instruções acima, criamos uma repetição bem simples. Os comandos são executados repetidamente, e se não for incluída uma instrução que force a saída do laço, o loop não terminará.

A sintaxe é:

Do
<bloco de comandos>
Loop

Simples e perigoso. Loops infinitos podem travar a aplicação, então tenha certeza de não permitir que isso aconteça.

Para criarmos uma condição de saída para a repetição, podemos fazer de duas formas. A primeira é criar uma “estrutulha” condicional dentro do bloco, dizendo que dentro de uma certa condição, a repetição termina. Isso é feito com a instrução Exit Do.

No bloco acima, usamos a função InputBox que abre uma janela solicitando ao usuário que digite alguma informação, que é armazenada na variável Valor. Dentro do laço de repetição, escrevemos o valor, incrementamos o valor da variável e testamos se ela é maior que 5, se for a aplicação sai da repetição.

-> InputBox(“Mensagem exibida”, “Título da Janela”, “Valor default”)

Se não tivéssemos esse teste lógico, se dependesse da aplicação o loop ficaria rodando eternamente.

A outra forma é usando os modificadores While e Until. Esses comandos têm a seguinte finalidade:

While <condição> -> faz um teste com uma condição, e o loopse repete enquanto a condição for verdadeira

Until <condição> -> faz um teste com uma condição, e o loop se encerra quando a condição tornar-se verdadeira.

Esses comandos podem acompanhar ou o Do ou o Loop, não acompanham os dois no mesmo bloco. Ou seja, podemos ter repetições em que usamos Do While…Loop, Do Until…Loop, Do…Loop While ou Do…Loop Until.

Qual é a diferença entre usarmos os comandos no início e usarmos no fim do bloco de repetição? Quando colocamos os comandos no final, estamos garantindo que o bloco será executado pelo menos uma vez, pois o teste da condição é feito no final. Se colocarmos no início, o teste será feito antes de entrar no loop, então se a condição que estabelecemos implicar na saída da repetição, ela não é executada nenhuma vez.

Leia-se:

Do While… Loop -> enquanto isso for verdadeiro, repita

Do Until… Loop -> até que isso seja verdadeiro, repita

Do… Loop While -> repita enquanto isso for verdadeiro

Do… Loop Until -> repita até que isso seja verdadeiro

Você pode usar o While ou o Until dependendo da forma que você usa a condição. Veja um exemplo abaixo com dois loops que executam a mesma coisa, mas usando os comandos diferentes:

O primeiro loop enquanto Repetir for menor ou igual a 5, repete escrever Guanabara.INFO, e o segundo até que Repetir maior que 5 repete escrever Guanabara.INFO.

Lembrando que podemos testar mais de uma condição nos loops, usando os conhecidos And, Or, Not, AndAlso e OrElse.

For… Next

Esse é o nosso “para”. Usamos esse laço quando tivermos uma variável contadora para auxiliar na repetição. A sinxate completa é:

For <variável> As <tipo> = <início> To <fim> Step <incremento>
<bloco de comandos>
Next <variável>

Funciona da seguinte forma: declaramos uma variável com um tipo numérico, atribuindo um valor a ela que será o valor inicial, definimos um valor máximo ao qual ela pode chegar e um incremento. A cada vez que a repetição terminar e voltar ao início, o valor de variável será incrementado, e caso seja maior ou igual ao valor máximo, o loop se encerra. Veja um exemplo:

No exemplo acima, eu não precisei escrever a estrutura completa porque declarei a variável antes do loop, o valor padrão do incremento Step é igual a 1 e o Next não me obriga a repetir o nome da variável ao lado dele.

Também existe a instrução Exit For.

Recebi do nosso visitante veterano Garu um código sobre o último post, quem não viu clique aqui e veja o que foi pedido. O código que ele enviou foi o seguinte:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnMostra.Click

Dim msg As String
msg = txtValor.Text

If txtValor.Text <> “” Then

btnMostra.Enabled = False
MsgBox(msg, MsgBoxStyle.OkOnly, “”)
Label1.Text = “Parebns! Sua mensagem ser exibida!”
Else
Label1.Text = “Erro! Nenhuma mensagem foi digitada!”

End If

End Sub

Isso mesmo, tá certo!

O programa faz um teste verificando se o conteúdo da caixa de texto é vazio, se for ele avisa que não foi digitado nada. Mas aí temos um problema, o usuário pode digitar um espaço e clicar em OK. Aí o conteúdo deixa de ser vazio. Para contornarmos esse problema, podemos usar a função Trim.

A função retira os espaços em branco do início e do final da string. Assim, se o usuário digitare só espaços, sem outros caracteres, esses espaços são removidos. Podemos usar a propriedade Length, depois de retirar os espaços, e verificar se o tamanho da string é igual a zero:

If (msg.Trim().Length) = 0 Then

Console.WriteLine(“Está vazia, sua mula!”)

End If

Aproveita a dica, Garu, junto com os outros visitantes do site. Semana que vem, vetores! Pessoal que vai participar da OAH, estudem MUITO vetores. Até a próxima.

Olá galera. Para tirar o atraso do último post, resolvi colocar a parte IV com algumas diferenças. Me pediram uma super-postagem, então toma!  Vamos usar o Visual Basic para criar um tipo diferente de aplicação.

Até o momento, só trabalhamos com Consoles Applications (sem um ambiente gráfico). Agora, abram o seu Visual Basic Express e criem uma nova Windows Forms Application.

Mudanças no Ambiente de Desenvolvimento

Windows Forms Applications permitem o desenvolvimento de aplicativos com um ambiente gráfico. Você poderá criar as janelas do seu programa (forms), criar botões, colocar imagens, e muitos outros itens, como os programas para Windows. Esses componentes gráficos ficam na Toolbox, no lado esquerdo da tela. Expanda a seção “All Windows Forms” dessa barra para ver a lista de todos os controles que você tem a disposição (mas nem todos são visíveis em tempo de execução).

Aos poucos, vamos usando o objetos e descobrindo para quê eles servem. Vamos começar com algo bem simples.

Propriedades e Eventos

No centro da tela, você vê um quadrado cinza, que é o seu primeiro formulário. Você pode acrescentar outros, mas só precisaremos de um por enquanto. Os controles da Toolbox podem ser arrastados para essa área. Experimente com o controle Label, clicando sobre o item e arrastando-o para o interior do formulário.

Será criado na tela um controle Label, com o nome Label1. Uma label é um rótulo, ou seja, esse controle serve para exibir informações diretamente no formulário.

Agora vamos falar das outras barras. A Solution Explorer vai mostrar os itens que estão presentes no seu projeto até o momento (formulários, conexões com banco de dados, etc). Até agora, temos só um formulário, que é o Form1.vb .

Abaixo dessa tela, existe a Properties Window. Essa tela é muito importante, pois através dela podemos definir as propriedades dos controles que estão na nossa aplicação em tempo de desenvolvimento.

As propriedades definem as características do controle, e variam de controle para controle. Vamos ver o exemplo da Label. Clique sobre o Label1 que foi inserido no formulário e dê uma olhada na Properties Window:

Name – define o nome do controle. Através desse nome, podemos fazer referência a esse controle por meio do código. É sempre bom colocarmos três caracteres inicias ao nome para que possamos lembrar no código que tipo de controle ele é. No nosso caso, como é uma Label, dê um nome a ela bem intuitivo: lblMensagem .

BorderStyle – define a borda que o controle terá. Por padrão, ele não tem borda, mas podemos definir um tipo para ele, mudando essa propriedade.

ForeColor – define a cor da letra da Label.

Text – define a mensagem que a Label terá. Altere essa propriedade para “Nossa mensagem de hoje é:”.

Visible – define se a Label estará visível no formulário (True) ou invisível (False).

Enabled - define se a Label estará ativada (True) ou desativada (False). Um controle desativado fica com a cor mais clara. É mais útil no caso de botões, pois quando estão nesse estado não recebem cliques.

Existem outras propriedades, mas não vamos mexer nelas agora. Quando estivermos no código, essas propriedades podem ser acessadas ou modificadas na forma:

<nome do controle>.<nome da propriedade> = valor

Exemplo:

Label1.Text = “Mensagem da Label” ‘A label mostrará o conteúdo da string passado como valor

Label1.Visible = False ‘A label ficará invisível

Console.WriteLine(Label1.Text) ‘Escreve a mensagem da label

Existem também os eventos, que são ações às quais os controles respondem em tempo de execução. Imagine que um carro seja um objeto. Teríamos algumas propriedades como “Número de Rodas”, “Cor”, “Tipo de Combustível” e eventos poderíamos ter “Ligação” ou “Aceleração”.

Os controles podem responder a eventos como clique de botão, passagem do ponteiro sobre o controle, e muitos outros. Existem eventos que são específicos para alguns controles. Você pode conferir os eventos disponíveis de um controle clicando sobre o mesmo, indo até a Properties Window e clicando no botão “Events“, que possui a figura de um raio. A finalidade dos eventos pode ser deduzida pelo nome, em alguns casos, e sempre há uma descrição do evento selecionado abaixo da lista.

Também podemos ver os eventos através da área de código, como você vê abaixo:

Para termos uma noção melhor, arraste um controle Button para a tela, mude o nome dele para “btnMensagem” (propriedade Name), o texto mostrado para “Clique aqui” (propriedade Text) e dê um duplo clique no controle.

Você será levado à área de edição do código, onde o Visual Basic terá criado um procedimento padrão que responderá ao evento clique do botão:

Private Sub btnMensagem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnMensagem.Click

End Sub

O comando Handles é responsável por apontar o código do procedimento ao evento clique do botão.  Sempre que quisermos fazer a referência entre um evento de um controle ou objeto e um procedimento, usamos o Handles. O nome do procedimento (no caso Private Sub btnMensagem_Click) não importa para que funcione – o que importa é o evento ao qual ele se prende (Handles btnMensagem.Click)

Dentro do bloco criado, digite o seguinte trecho de código:

A função MsgBox() exibe uma caixa de diálogo na tela. O primeiro parâmetro é o valor da mensagem, o segundo representa os tipos de botões que serão exibidos, e o terceiro o título da janela. Observe que passamos strings no primeiro e no terceiro parâmetros (nesse caso, uma string vazia). O segundo parêmetro é um valor da enumeração MsgBoxStyle. Você pode conferir todos os valores possível no IntelliSense, no nosso caso ele só mostrará o botão “OK”.

Compilem, pressionando F5, e vejam como fica o formulário durante a execução. Agora cliquem no botão e vejam o que o programa acha do Luiz. .

Talvez o post tenha explicado muita coisa em pouco espaço, mas em resumo significa: programando com Windows Applications, temos a possibilidade de trabalhar com formulários e inserir controles nele , desde botões e rótulos até grids com tabelas de bancos de dados e imagens. E esses controles têm eventos, que são ações que acontecem, como clique do mouse, pressionamento de uma tecla, etc.

Agora quero ver quem é que está estudando e lendo o post com atenção. Atendendo a pedidos, vou lançar dois pequenos desafios:

1 – Já vimos que a propriedade Text dos controles representa o valor de texto que ele tem, como em Labels e Buttons. O controle TextBox cria uma caixa de texto comum, e com essa propriedade podemos definir e recuperar o valor que foi digitado nela.

Crie uma caixa de texto, com o nome txtValor. Depois crie um controle Button e dê o nome btnMostra.

Agora vem a parte trabalhosa. Por meio de código, faça o evento Click do botão fazer o seguinte: mostrar uma mensagem com a função MsgBox() contendo o que foi escrito na caixa de texto.

2 – Usando o mesmo exemplo acima, faça com que o botão só mostre a mensagem se houver algum conteúdo na caixa de texto. E, depois de mostrar a mensagem, o botão deve ser desabilitado e a caixa de texto deve ficar invisível.

Exercite a mente! Enviem os códigos para marcelo@guanabara.info, com seu nome, idade e de onde é. No próximo post, vou publicar os nomes daqueles que acertaram, apontar os erros daqueles que errarem indicando a solução, mostrar outros códigos e tirar as dúvidas. Não deixem de comentar.  Comentários, elogios e críticas dão um gás na nossa disposição de escrever esses posts. Até a próxima.

Motivo: essa semana comecei minha faculdade, e a coisa está feia. Estou com 60% de mim cansado (e a semana está só na metade), 10% de mau humor e 30% com disposição de trabalhar. Como eu não estava conseguindo preparar o post do jeito que eu queria, resolvi deixar esse comunicado e quando tiver mais tempo, preparar a próxima postagem (que amanhã seria de estruturas de repetição).

Peço desculpas por não ter preparado o post dessa semana, mas deixem sugestões ou dúvidas nos comentários desse aviso. Mestre Guanabara, desculpe. Abraços a todos e até a próxima.

Olá amantes da tecnologia. Aqui é Marcelo Vieira, e hoje vamos ver as estruturas condicionais e operadores lógicos. Preparem-se porque vem bastante coisa.

“Continue lendo…” e vamos começar.

Estruturas Condicionais – If

Podemos usar expressões lógicas ou variáveis do tipo Boolean para testar determinadas condições, através de seu valor de retorno True ou False. A estrutura usada para isso é o If, conforme o exemplo abaixo:

A forma da condicional segue o tipo:

If <condição> Then
<comandos para verdadeiro>
Else
<comandos para falso>
End If

ou

If <condição> Then
<comandos para primeira condição>
ElseIf <outra condição> Then
<comandos para segunda condição>
Else
<comandos para falso em todas as condições>
End If

Na “estrutulha” da imagem acima, será impresso na tela a mensagem “É maior que 25″

Não somos obrigados a informar uma instrução Else. A estrutura pode ser montada somente com If…Then…End If.

Operadores Lógicos

Usados nos testes condicionais, são os seguintes:

And – retorna True se as duas condições forem verdadeiras e False se ambas forem falsas.
Or – retorna True se pelo menos uma das condições for verdadeira e False se as duas forem falsas.
Xor – retorna True se somente uma condição é verdadeira e False se as duas forem True ou False.
Not – retorna True se o valor da condição for False e False se o valor for True (“inverte” o sentido da verificação)

O Visual Basic, em comparações de duas expressões lógicas, faz os testes com as duas antes de definir o valor dela, se usamos o And ou o Or. Podemos fazer com que o compilador faça essa verificação de maneira diferente, usando os operadores AndAlso e OrElse. Com esses operadores, somente a primeira condição é testada, e caso ela seja falsa, nem se preocupa em testar a segunda.

AndAlso – similar ao And, mas se a primeira condição for falsa, ele não verificar a  outra.
OrElse – similar ao Or, mas se a primeira condição for verdadeira, ele não testa a outra.

Vamos fazer um teste: digite um código similar ao que você vê abaixo:

É um teste lógico bobo, mas que demonstra como funciona. A primeira condição é verdadeira e a segunda é falsa, mas há um problema com a segunda. Não podemos comparar uma string com um número, então isso gerará uma exception assim que você compilar e executar.

Se você substituir o Or por OrElse, o código acima compilará. Isso porque o OrElse testa só a primeira condição, e verificando que ela é verdadeira, não verifica a outra. O Or faz a verificação das duas, logo ocorre a exception.

Se estivermos fazendo comparações, temos os operadores:

< – menor
> – maior
<= – menor ou igual
>= – maior ou igual
= – igual
<> – diferente

Outras formas de usar o If

Podemos colocar um bloco de instruções entre o If e a próxima instrução (Else, ElseIf ou End If). Mas se tivermos um só comando a ser executado, ele pode ser colocado do lado do Then. Essa regra vale também para o comando que segue o Else e o ElseIf. Assim:

Dim Numero As Byte = 5
If (Numero < 3) Then Console.WriteLine (“É menor que três”)
Else Console.WriteLine(“Não é menor que três”)

Existe também o If inline, que é um teste lógico feito em uma linha. O comando segue abaixo:

IIf (<condição>, <comando para verdadeiro>, <comando para falso>)

O IIf pode ser usado quando temos apenas um comando para verdadeiro e um para falso.

Estrutura Condicional – Select Case

Existe um outro tipo de estrutura condicional, o Select Case… End Select. Ela é útil quando temos um valor exato a comparar. É utilizado da seguinte maneira:

Select Case <variável>
Case <valor 1>
<comandos para valor1>
Case <valor 2>
<comandos para valor 2>
Case Else
<comandos para nenhum dos anteriores>
End Select

Veja um exemplo:

No exemplo acima, usamos a instrução Select Case para selecionar uma variável, e trabalhar com possíveis valores para ela. E cada um desses valores é acompanhado de uma instrução Case. Testamos as condições de o valor ser igual a 1, 2 ou 3, e há uma instrução Case Else que ocorre caso não seja nenhuma das anteriores.

No próximo post, vamos ver as diferentes formas de fazer loops (laços de repetição). Aí, vamos praticar com a frase já conhecida “Luis é uma mula”. Qualquer dúvida, contato, crítica ou sugestão, e-mails para marcelo@guanabara.info. Abraços a todos e até mais.

Hoje, vamos ver os tipos de variáveis do Framework, com ênfase no grupo de variáveis numéricas. Abra o Microsoft Visual Basic 2008 Express Edition, cria um novo projeto do tipo Console Application e clique em “Continue lendo…”. Espero que gostem.

Tipos de Variáveis

String – armazena cadeias de caracteres (letras);
Boolean – armazena valores lógicos (True ou False/ Verdadeiro ou Falso);
Char – armazena apenas um caractere;
Object (antigo Variant) – tipo indefinido, pode armazenar dados compatíveis com todos os outros tipos.
Tipos numéricos – armazenam valores numéricos, usados para realizar cálculos. O .NET Framework fornece diversos tipos numéricos, com capacidade de armazenamento variadas.

Existem tipos inteiros e os tipos de ponto flutuante (armazenam valores fracionários). Cada tipo inteiro tem uma variação signed (com sinal) e unsigned (sem sinal). Veja a lista abaixo:

Byte – inteiro de 8 bits, tem uma faixa de abrangência de 0 a 255.
SByte – inteiro de 8 bits, vai de -128 a 127.
UShort – inteiro de 16 bits, vai de 0 a 65535.
Short – inteiro de 16 bits, vai de -32768 a 32767.
UInteger – inteiro de 32 bits, vai de 0 a 4294967295.
Integer – inteiro de 32 bits, vai de –2147483648 a 2147483647
ULong – inteiro de 64 bits, vai de 0 até 18446744073709551615.
Long – inteiro de 64 bits, vai de –9223372036854775808 a 9223372036854775807.
Single – ponto flutuante de 32 bits, vai de -3,4 x 1038 até 3,4 x 1038 com 7 casas decimais de precisão.
Double – ponto flutuante de 64 bits, vai de -1,7 x 10308 até 1,7 x 10308 com 15 casas decimais de precisão.
Decimal (antigo Currency) – tipo especial de ponto flutuante com 128 bits, o menor valor é 1,0 x 10-28 e o maior valor é 1,0 x 1028, com 28 dígitos de precisão. Usado para cálculos monetários.

Não entendeu a relação de número de bits com os tipos de variáveis? Lembre-se que a forma que as pessoas usam para contar números não é a mesma forma que os computares usam. Nós estamos acostumados a usar algarismos que vão de 0 a 9, mas o computador só conta em binário (zeros e uns, os bits).

O número 255, por exemplo: para nós, ele aparece com um número decimal, mas o computador o enxerga como um binário (11111111). Repare que são exatos oito bits, ou um byte, o maior valor aceito pelo tipo Byte. Se quisermos armazenar um número maior, como 256, vamos precisar de um bit a mais, logo o tipo Byte não pode receber esse valor.

Lembrando que o Visual Basic não é case-sensitive.

- Operadores Aritméticos

Podemos usar os seguintes operadores:
+ (Adição)
- (Subtração)
* (Multiplicação)
/ (Divisão)
^ (Exponenciação)
Mod (Resto da Divisão)

No exemplo acima, teremos as variáveis declaradas com os valores 8, 4, 18 e 2, respectivamente.

Acima, será impresso o valor 1 na tela (o resto da divisão de 5 por 2). Note que usamos a função .ToString para fazer uma conversão de um valor numérico para string, a fim de escrevê-lo com o método Console.WriteLine.

Assim como na matemática, multiplicação e divisão têm prioridade de cálculo sobre as demais operações. Se quisermos interferir na ordem, podemos usar parêntestes:

No exemplo acima, será impresso na tela o valor 15.

Aqui vai uma dica: imagine que desejamos atribuir a uma variável o seu valor atual somado a outro valor. É uma situação bem simples.

Mas saiba que existe uma forma “abreviada” de fazer isso. Podemos nos livrar do incômodo de ter que repetir o nome da variável se usarmos o operador += , dessa forma:

De acordo com o código acima, será escrito na tela o valor 11. A variável receberá o valor que ela já tinha mais 5.

Essa mesma notação vale para os outros operadores. Temos então outros operadores que seguem a mesma lógica, que são -=, *=, /= e ^=.

- Strings

Variáveis do tipo string recebem os seus valores informados entre aspas duplas:

Para concatenar (juntar) duas ou mais strings, usamos o operador & (E comercial).

- Valores lógicos

Variáveis do tipo Boolean armazenam somente dois valores: True (verdadeiro) ou False (falso). Podemos usar essas variáveis para testar condições.

Por enquanto é só isso pessoal. No próximo artigo, vamos usar valores lógicos em estruturas condicionais, e algumas funções muito úteis, entre elas para conversões entre tipos diferentes de variáveis além da função ToString. Como a lista de funções é grande, talvez tenhamos uma postagem antes da próxima quinta-feira. Dúvidas, sugestões, críticas e contato, mandem e-mails para marcelo@guanabara.info. Até lá .

Olá amantes da tecnologia. Aqui é Marcelo Vieira, e hoje começamos com mais uma iniciativa diretamente ligada à programação, aqui no Guanabara.INFO: a primeira de muitas postagens (se vocês visitantes assíduos gostarem, é claro) sobre mais uma linguagem .NET: O Visual Basic.

Se você é novo na área e deseja aprender programação, recomendo que ouça antes os seguintes podcasts:

- Episódio 19 – Construindo Algoritmos (Parte I)
- Episódio 21 – Construindo Algoritmos (Parte II)
- Episódio 25 – Construindo Algoritmos (Parte III)
- Episódio 29 – Construindo Algoritmos (Parte IV)

Recomendo também que leia o post [C#]: Olá Mundo , publicado por Renan e Luiz, que além de ensinarem a linguagem C#, explicam como funciona a integração da linguagem com o .NET Framework.

Espero que todos gostem desta primeira postagem, pratiquem e anseiem pelas próximas, e farei o possível para seguir o nível de qualidade que temos no site. Se você gosta de programar e quer aprender VB, não deixe de nos visitar, e clique em “Continue Lendo…” – vamos começar.

A Evolução do Visual Basic

Vamos começar com um resumo da história da linguagem:

No início da década de 60, foi criada uma linguagem chamada BASIC (Beginners All-Purpose Symbolic Instruction Code) com o propósito de facilitar o ensino dos conceitos lógicos de programação naquela época. Só que mesmo depois de introduzida pela Microsoft, ainda era uma linguagem muito simples, indicada apenas para prática de principiantes.

O aperfeiçoamento do BASIC, que incluía uma interface gráfica de desenvolvimento, foi conhecido como “Visual Basic”. A versão mais atual da linguagem é a versão 9, e até o momento algumas variações surgiram:

- VBScript: usada por padrão em Active Server Pages (ASP) e em desenvolvimento de scripts para ambiente Windows;

- VBA: usada para a criação de módulos com integração aos componentes da família Microsoft Office.

Antes da integração da linguagem com a plataforma .NET, a versão 6 era a mais utilizada. Os códigos eram desenvolvidos seguindo uma base de orientação a eventos (event driver).
Quando a linguagem foi integrada ao Framework, os recursos que uma boa linguagem orientada a objetos deve ter foram implementados, sempre tendo a preocupação de manter a sintaxe com a intenção de que quem estivesse familiarizado com as versões anteriores não tivesse problemas para se adaptar. Foi rebatizada de VB.NET.

A Linguagem

- Não é case sensitive, ou seja, variáveis com os nomes “Info”, “info” e “iNfO” seriam consideradas iguais;
- O caracter terminador de linha de comando é a quebra de linha, não precisamos colocar ponto-e-vírgula;
- É uma linguagem simples. Como o C# oferece um controle maior das ações, pode ser um pouco complicado para quem é iniciante.
- É totalmente orientada a objetos;
- Possui um grande número de palavras reservadas, a maioria com nomes intuitivos.
- Como diria o Rafael, as “estrutulhas”, como funções, condicionais e de repetição, são delimitadas por palavras reservadas (e não por chaves, como no C#). Por exemplo, uma “estrutulha” condicional If termina com um End If.
- Blocos de Comandos: existem as Subs (procedimentos, não têm valor de retorno) e as Functions (sempre retornam um valor). Os dois tipos aceitam passagem de parâmetros.
- Pode ser usada para o desenvolvimento de aplicações para a Web com ASP.NET, assim como o C#.

OBS: Para quem leu o post sobre C#, percebeu que a sintaxe do VB tem muitas diferenças. Não se preocupe quanto a isso agora: a sintaxe do VB é simples e direta, e o Visual Studio ajuda muito nos momentos de “branco” dos comandos com seu IntelliSense.

- Declaração de variáveis

Para declararmos uma variável, usamos o comando:

Dim <variável> As <tipo>

Exemplos:

Dim contador As Integer ‘variável “contador” do tipo inteiro
Dim nome, sobnome As String ‘duas variáveis do tipo String (caracter)

Uma variável pode receber um valor no momento de sua declaração:

Dim Nome As String = “Gustavo Guanabara”

Observe que o operador “=” é o operador de atribuição. No exemplo acima, declaramos a variável Nome, automaticamente atribuindo o valor “Gustavo Guanabara” à mesma.

- Comentários

Um comentário é uma instrução que não é executada. Serve para descrever trechos de código ou a função de uma variável, por exemplo. Podem ser feitos iniciando a linha com uma aspa simples ou a palavra REM (herdada da época do BASIC):

‘Só estou comentando
REM Mais um comentário

A maldição do Olá Mundo

Para desenvolvermos em Visual Basic.NET, você precisará dos seguintes itens, que podem ser baixados gratuitamente:

- Microsoft Visual Studio 2008 Express Edition
- Microsoft .NET Framework 3.5

Como alguns já devem saber, existe uma maldição comprovada de que o primeiro programa a ser feito com uma linguagem nova é o “Olá Mundo”. Então, faremos esse para ficarmos livres!

Abra o Visual Studio e crie um novo Projeto, do tipo Console Application. Uma Console Application é uma aplicação que roda em ambiente de linha de comando, sem interface gráfica.

- O método Main ()

O método Main(), entre as linhas Sub Main() e End Sub, define o bloco de comandos principal da aplicação.

Para o nosso “Olá Mundo”, digite o código que você vê abaixo entre as linhas do método Main():

A classe System.Console nos permite interagir com o ambiente onde a aplicação é executada. Os métodos/ funções abaixo são os mais utilizados:

- Console.WriteLine() – procedimento que escreve uma mensagem na tela e quebra a linha. Se não for informado um parâmetro, será escrita uma linha em branco

- Console.ReadLine() – função que guarda informações digitadas pelo usuário na tela do Console. Aguarda o pressionamento da tecla ENTER para continuar a execução.

- Console.ReadKey() – função que recebe o valor de apenas uma tecla pressionada pelo usuário.

- Console.Clear() – procedimento que efetua a limpeza da tela.

Após digitar o código, pressione a tecla F5 para compilar e executar a aplicação, e veja o resultado na tela:

Devido à instrução Console.ReadLine(), o programa aguardará o pressionamento da tecla ENTER pra continuar.

Bom, por hoje é só isso. Espero que tenham gostado. Agora vocês podem criar programas que escrevam “Renan, não olhe pra luz!!”. Qualquer elogio, dúvida, crítica ou sugestão, podem mandar mensagens para marcelo@guanabara.info ou comentarem. O próximo post deverá sair na próxima quinta-feira. Até lá .