Programação V

 

Organização deste Livro .............................................. .......................................... 9

Convenções usadas neste livro ............................................. ................................. 9

Como entrar em contato conosco .............................................. .................................................. .... 10

Agradecimentos ................................................. .................................................. .. 11

Capítulo 1. Introdução ................................................. .................................................. .. 13

1.1 Qual é a Microsoft. NET Framework ?......................................... ......... 13

1.2 O que é Visual Basic. NET? .................................................. .......................... 14

1,3 Um Exemplo do Visual Basic. Programa NET .......................................... ......... 14

Capítulo 2. O Visual Basic. NET ............................................ ................... 23

2,1 arquivos de origem ............................................... .................................................. ........ 23

2,2 Identificadores ................................................ .................................................. ........... 23

Palavras-chave ................................................ 2,3 .................................................. ............ 24

2,4 literais ................................................ .................................................. ................. 27

2.5 Tipos ................................................ .................................................. .................... 31

2,6 Namespaces ................................................ .................................................. ...... 40

2,7 constantes simbólicas ............................................... ........................................... 42

2,8 Variáveis ................................................ .................................................. ............. 43

2,9 Âmbito ................................................ .................................................. .................... 44

2,10 Modificadores de acesso ............................................... ............................................... 44

Atribuição ................................................ 2,11 .................................................. ...... 45

Operadores e expressões 2,12 .............................................. ........................... 46

Demonstrações ................................................ 2,13 .................................................. ...... 52

2,14 Classes ................................................ .................................................. .............. 60

2,15 Interfaces ................................................ .................................................. ......... 85

Estruturas ................................................ 2,16 .................................................. ........ 88

2,17 Enumerações ................................................ .................................................. . 91

Exceções ................................................ 2,18 .................................................. ........ 93

Delegados ................................................ 2,19 .................................................. ......... 98

Eventos ................................................ 2,20 .................................................. .............. 101

2,21 módulos padrão ............................................... .......................................... 104

Atributos ................................................ 2,22 .................................................. ....... 104

2,23 compilação condicional ............................................... .............................. 108

Resumo ................................................ 2,24 .................................................. ........ 109

Capítulo 3. O quadro. NET .............................................. .................................... 111

3,1 Common Language Infrastructure (CLI) ea linguagem comum

Runtime (CLR) .............................................. .................................................. .......... 111

3,2 Common Type System (CTS) ........................................... .......................... 111

3,3 Partes do CLI ............................................. ............................................. 112

3,4 módulos e assemblies .............................................. ................................. 113

3,5 Domínios de Aplicação ............................................... ........................................ 116

3,6 Common Language Specification (CLS) ........................................... ...... 116

3,7 Intermediate Language (IL) e Just-In-Time (JIT) Compilação de 117

3,8 Metadados ................................................ .................................................. ........... 117

3.9 Gestão de Memória e de coleta de lixo .................................... 118

3,10 Uma Breve Tour de namespaces. NET Framework ........................... 122

 

NET Programação Visual Basic.

 

 

Configuração ................................................ 3,11 .................................................. .125

Resumo ................................................ 3,12 .................................................. ........ 131

Capítulo 4. Windows Forms I: Desenvolvimento de Aplicações Desktop ............................. 133

4.1 Criando um formulário .............................................. .................................................. 133

4.2 Forma Eventos Manipulação .............................................. ...................................... 143

4,3 relações entre formas .............................................. ....................... 145

4,4 Aplicativos MDI ............................................... ................................................ 147

4,5 atributos componentes ............................................... ..................................... 155

4,6 2-D com programação de gráficos GDI + .......................................... ......... 160

4,7 impressão ................................................ .................................................. ............... 174

4.8 Síntese ................................................ .................................................. ........... 186

Capítulo 5. Windows Forms II: controles, caixas de diálogo comum, e os menus ...... 187

5.1 Comandos comuns e componentes ............................................. ............ 187

5,2 eventos de controle ............................................... .................................................. .. 204

5,3 a forma ea disposição de controle ............................................. ................................. 204

5,4 caixas de diálogo comum .............................................. ..................................... 210

5,5 Menus ................................................ .................................................. ................. 215

5,6 Criando um Controle .............................................. ............................................. 227

Resumo ................................................ 5,7 .................................................. ........... 236

Capítulo 6. ASP.NET e Web Forms: Desenvolvimento de Aplicações baseadas em Browser 237

6.1 Criar um formulário Web ............................................. ........................................ 238

6,2 Page Tratamento de eventos .............................................. ....................................... 251

6.3 Mais sobre controles de servidor ............................................. ........................... 253

6,4 Adicionando Validação ............................................... .............................................. 268

6,5 directivas usando para modificar a compilação de página da Web ............................. 283

6,6 ASP.NET Objetos: Interagindo com o quadro ........................... 291

6,7 Descobrindo Recursos do Navegador .............................................. ................. 296

6,8 Manutenção Estado ............................................... .............................................. 298

6,9 Nível de aplicativo de código e global.asax ......................................... ........ 304

6,10 Segurança de aplicativos Web ............................................. .............................. 307

6,11 Criando Custom Controls .............................................. ......................... 320

Resumo ................................................ 6,12 .................................................. ........ 328

Capítulo 7. Serviços Web ................................................ ................................................ 329

7.1 Criando um Web Service ............................................. .................................... 329

7.2 Teste de um Web Service com um navegador .......................................... .......... 333

7,3 descrições Serviço Web ............................................. ................................ 335

7,4 Consumindo um Web Service ............................................. ............................... 335

7,5 Discovery Service Web ............................................. ..................................... 340

7,6 limitações dos serviços Web ............................................. ........................... 340

Resumo ................................................ 7,7 .................................................. ........... 341

Capítulo 8. ADO.NET: Desenvolvendo aplicações de banco de dados ....................................... 343

8,1 Uma Breve História do Acesso Universal Data .......................................... ...... 343

8,2 gerenciado provedores ............................................... ........................................... 343

8,3 Conectando-se a um banco de dados SQL Server ........................................... ......... 344

Autenticação do SQL Server ............................................... .............................................. 347

8,4 Ligar a uma fonte de dados OLE DB .......................................... ......... 348

8,5 leitura de dados em um DataSet ............................................ ........................... 349

 

 

 

3

 

4

 

 

 

 

8,6 Relações entre tabelas em um DataSet ........................................ 360

8.7 O DataSet XML Recursos ............................................. .................... 362

8,8 DataSet uma vinculação a um DataGrid do Windows Forms .............................. 364

8,9 DataSet uma ligação a um Web Forms DataGrid ....................................... 367

8,10 DataSets tipados ............................................... .............................................. 368

8,11 leitura de dados usando um DataReader ............................................ ............. 370

8,12 Execução armazenados ProceduresThrough um objeto SqlCommand .... 371

Resumo ................................................ 8,13 .................................................. ........ 374

Apêndice A. Atributos personalizados definidos no namespace System ...................... 375

Apêndice B. As exceções definidas no namespace System ................................... 381

Apêndice D. Recursos para desenvolvedores ............................................ .......................... 391

D.1. Informação NET ............................................ ................................................. 391

D.2 Listas de Discussão ............................................. .................................................. . 392

Netiqueta ................................................. .................................................. ...................... 392

Funções matemáticas Apêndice E. ............................................. ............................................. 395

Colophon ................................................. .................................................. ........................ 398

 

NET Programação Visual Basic.

 

 

NET Programação Visual Basic.

 

Prefácio

Organização deste Livro

Convenções usadas neste livro

Como entrar em contato conosco

Agradecimentos

 

1. Introdução

1.1 Qual é a Microsoft. NET Framework?

1.2 O que é Visual Basic. NET?

1,3 Um Exemplo do Visual Basic. Programa NET

 

2. O Visual Basic. NET

2,1 arquivos de origem

2,2 Identificadores

2,3-chave

2,4 literais

2.5 Tipos

2,6 Namespaces

2,7 constantes simbólicas

2,8 Variáveis

2,9 Âmbito

2,10 Modificadores de acesso

Atribuição 2,11

2,12 Operadores e expressões

2,13 Demonstrações

2,14 Classes

2,15 Interfaces

Estruturas 2,16

2,17 Enumerações

Exceções 2,18

Delegados 2,19

2,20 Eventos

2,21 módulos standard

Atributos 2,22

2,23 compilação condicional

Resumo 2,24

 

3. O quadro. NET

3,1 Common Language Infrastructure (CLI) e Common Language Runtime (CLR)

3,2 Common Type System (CTS)

3,3 Partes do CLI

3,4 módulos e assemblies

3,5 Domínios de Aplicação

3,6 Common Language Specification (CLS)

3,7 Intermediate Language (IL) e Just-In-Time (JIT) Compilação

3,8 Metadados

3.9 Gestão de Memória e Coleta de Lixo

3,10 Uma Breve Tour de namespaces. NET Framework

Configuração 3,11

Resumo 3,12

 

4. Windows Forms I: Desenvolvimento de Aplicativos para Desktop

4.1 Criando um formulário

4.2 Forma Tratamento de eventos

4,3 relações entre formas

 

 

 

 

 

 

5

 

 

 

 

4,4 Aplicativos MDI

4,5 Componente Atributos

4,6 2-D com programação de gráficos GDI +

4,7 Impressão

4.8 Síntese

 

5. Windows Forms II: controles, caixas de diálogo comum, e os menus

5.1 Comandos comuns e componentes

5,2 eventos de controle

5,3 a forma ea disposição de controle

5,4 caixas de diálogo comum

5,5 Menus

5,6 Criando um Controle

5,7 Resumo

 

6. ASP.NET e Web Forms: Desenvolvimento de Aplicações baseadas em Browser

6.1 Criando um formulário da Web

6,2 Page Tratamento de eventos

6.3 Mais sobre controles de servidor

6,4 Adicionando Validação

6,5 directivas usando para modificar a compilação de página Web

6,6 ASP.NET Objetos: Interagindo com o quadro

6,7 Descobrindo Recursos do Navegador

6,8 Manutenção Estado

6,9 Nível de aplicativo de código e global.asax

6,10 Segurança de aplicativos Web

6,11 criação de controles personalizados

Resumo 6,12

 

7. Web Services

7.1 Criando um Web Service

7.2 Teste de um Web Service com um navegador

7,3 descrições de serviço Web

7,4 Consumindo um Web Service

7,5 Discovery Service Web

7,6 limitações dos serviços Web

7,7 Resumo

 

8. ADO.NET: Desenvolvendo aplicações de banco de dados

8,1 Uma Breve História do Acesso a Dados Universal

8,2 gerenciado provedores

8,3 Conectando-se a um banco de dados SQL Server

8,4 Ligar a uma fonte de dados OLE DB

8,5 leitura de dados em um DataSet

8,6 Relações entre tabelas em um DataSet

8.7 O DataSet Recursos XML

8,8 DataSet uma vinculação a um DataGrid do Windows Forms

8,9 DataSet uma ligação a um Web Forms DataGrid

8,10 DataSets tipados

8,11 leitura de dados usando um DataReader

8,12 ProceduresThrough armazenados em execução um objeto SqlCommand

Resumo 8,13

 

Custom A. Atributos definidos no namespace System

AttributeUsage

CLSCompliant

ContextStatic

 

 

6

 

 

 

 

Bandeiras

LoaderOptimization

MTAThread

NonSerialized

Obsoletos

ParamArray

Serializable

STAThread

ThreadStatic

 

NET Programação Visual Basic.

 

 

Exceções definidas no namespace System

 

C. Culturas

 

D. Recursos para desenvolvedores

D.1. Informação NET

Listas de discussão D.2

 

Funções matemáticas E.

 

Cólofon

 

 

largura constante

 

largura constante no corpo do texto indica uma construção de linguagem, tais como o nome de uma armazenados

procedimento, uma instrução SQL, um Visual Basic. declaração NET, uma enumeração, uma intrínseca ou

definidos pelo usuário constante, uma estrutura (ou seja, um tipo definido pelo usuário), ou uma expressão (como

dblElapTime = Timer - dblStartTime). Fragmentos de código e exemplos de código aparecem

exclusivamente no texto de largura constante. Em declarações sintaxe e protótipos, o texto definido em constante

width indica elementos de linguagem, tais como o nome da função ou procedimento e qualquer invariável

elementos exigidos pela sintaxe.

 

Constant largura itálico

 

itálico largura constante no corpo do texto indica nomes de parâmetro. Em declarações sintaxe ou

protótipos, itálico largura constante indica parâmetros substituíveis. Além disso, a largura constante

itálico é usado no corpo do texto para denotar variáveis.

 

Itálico

 

palavras em itálico no texto indicam função intrínseca ou definida pelo usuário e nomes de procedimento.

Muitos elementos do sistema, tais como os caminhos e nomes de arquivos, também estão em itálico. URLs e e-mail

endereços estão em itálico. Finalmente, os itálicos são usados para os novos termos em que estão definidos.

 

Este ícone indica uma dica, sugestão ou nota geral.

 

 

 

Este ícone indica uma advertência ou precaução.

 

 

Como entrar em contato conosco

 

Por favor, envie comentários e perguntas relativas a este livro para a editora:

 

O'Reilly & Associates, Inc.

1005 Auto-estrada do Norte Gravenstein

Sebastopol, CA 95472

(800) 998-9938 (nos Estados Unidos ou Canadá)

(707) 829-0515 (internacional / local)

(707) 829-0104 (fax)

 

Há uma página web para este livro, onde errata listamos, exemplos, ou qualquer outra informação adicional. Você

pode acessar essa página em:

 

http://www.oreilly.com/catalog/progvbdotnet

 

Para comentar ou fazer perguntas técnicas sobre este livro, envie um email para:

 

bookquestions@oreilly.com

 

Para mais informações sobre nossos livros, conferências, Centros de Recursos, e O'Reilly Network, consulte

nosso site em:

 

http://www.oreilly.com

 

 

 

 

10

 

 

 

 

Agradecimentos

 

NET Programação Visual Basic.

 

 

Obrigado ao pessoal da Microsoft, que se dispuseram a responder minhas perguntas incessantes, mesmo na

meio de ter de cumprir os seus prazos de entrega própria. Esta lista de pessoas de alto nível inclui Brad

Abrams, Alan Carter, George Kit, Scott Guthrie, Jim Hogg, Howard Rob, e Warren Susan. Vários

dessas pessoas também ler grandes porções do manuscrito e ofereceu comentários construtivos.

 

Obrigado aos meus colegas de trabalho em Tara Software, Inc., por me deixar usá-los como caixas de ressonância e para

ajudar com questões técnicas. Isso inclui Dan Boardman, Kevin Caswick, Varon Fugman, Anson

Goldade, Hauth Karl, Peterson Garrett, Phelps Dan, Rassbach Scott e Adam Steinert.

 

Obrigado a Tara Software, Inc., e em particular aos seus dirigentes, Roger Mills, Lynne Pilsner, e

Larry Kleopping, para apoiar este projeto (emocionalmente e financeiramente).

 

Obrigado a O'Reilly & Associates, Inc. para deixar-me escrever o livro que eu achava que deveria ser escrita.

Agradecemos em especial à minha editora, Ron Pietrucha, que sempre sabe o que mexer com o que e

deixar sozinho. Obrigado também a Budi Kurniawan por gentilmente conceder-me autorização para utilizar o material que

ele tinha escrito sobre os controles do Windows.

 

E, finalmente, agradeço ao meu amigo e sua esposa, Annemarie Newman. Annemarie, você tem todo o meu apoio

esforça-de shareware com muitos downloads e zero pagamentos aos livros que levam mais tempo para

escrever do que deveriam. Obrigado. Eu acho que você deve começar a preencher essa aplicação pós-graduação,

anjo. É a sua vez.

 

 

 

11

 

 

 

 

 

 

 

 

 

 

12

 

NET Programação Visual Basic.

 

 

Capítulo 1. Introdução

 

Com seu lançamento para a plataforma. NET, a linguagem Visual Basic sofreu mudanças dramáticas.

Por exemplo:

 

• A linguagem em si está totalmente orientada a objetos.

• Aplicações e componentes escritos em Visual Basic. NET tem pleno acesso ao. NET

Quadro, uma extensa biblioteca de classes que fornece serviços de sistema e aplicativo.

• Todas as aplicações desenvolvidas utilizando o Visual Basic. NET executado dentro de um ambiente de execução gerenciado,

. NET Common Language Runtime.

 

Nesta introdução, eu brevemente discutir essas mudanças e outras alterações antes de mostrar-lhe três muito

simples, mas completa, Visual Basic. NET.

 

1.1 Qual é a Microsoft. NET Framework?

 

. A NET Framework inclui o seguinte:

 

• Uma nova forma de expor APIs do sistema operacional e outros. Durante anos, o conjunto de Windows

funcionalidade que estava disponível para os desenvolvedores e da forma que a funcionalidade foi invocado foram

depende do ambiente de idioma a ser utilizado. Por exemplo, o funcionamento do Windows

sistema fornece a capacidade para criar janelas (obviamente). No entanto, a forma como esse recurso foi

chamado de um programa C + + foi muito diferente da forma como ele foi chamado de um

Programa Visual Basic. Com. NET, a forma que os serviços de sistema operacional são chamadas é

uniforme em todas as línguas (incluindo o código embutido em páginas ASP.NET).

 

Esta parte de. NET é comumente referido como o. NET Framework.

 

• A nova infra-estrutura para gerenciar a execução do aplicativo. Para fornecer um número de sofisticados

novos serviços do sistema operacional, incluindo a segurança no nível do código, classe cross-language

herança, a compatibilidade do tipo cross-language, e hardware e sistema operacional

independência, entre outros, a Microsoft desenvolveu um ambiente de execução, conhecido como o

Common Language Runtime (CLR). A CLR inclui o Common Type System (CTS) para

compatibilidade do tipo cross-language eo Common Language Specification (CLS) para

assegurar que as bibliotecas de terceiros pode ser usado de todos. NET idiomas habilitados.

 

Para suporte de hardware e independência de sistema operacional, a Microsoft desenvolveu o Microsoft

Intermediate Language (MSIL ou simplesmente IL). IL é um processador de linguagem de máquina independente de estilo

conjunto de instruções em qual. NET Framework programas são compilados. IL programas são compilados

para a linguagem de máquina real na plataforma de destino antes da execução (conhecido como "just-in-time,

ou JIT, a compilação). IL nunca é interpretado.

 

• Um paradigma novo servidor web. Para oferecer suporte a sites web de alta capacidade, a Microsoft substituiu seu

Active Server Pages (ASP), com a tecnologia ASP.NET. Embora os desenvolvedores que estão acostumados a

ASP clássico vai encontrar ASP.NET familiar na superfície, o mecanismo subjacente é diferente, e

muito mais recursos são suportados. Uma diferença, já mencionado neste capítulo, é que

Código da página web ASP.NET é compilado e não interpretado, aumentando

velocidade de execução.

• Um novo foco na aplicação distribuída architecture.Visual Studio. NET oferece uma top-notch

ferramentas para criar e consumir serviços da Web - Serviços de fornecedores de software independentes que

pode ser invocado pela Internet.

 

O. NET Framework é projetado de cima para baixo com a Internet em mente. Por exemplo,

ADO.NET, o próximo passo na evolução da visão da Microsoft de "acesso a dados universal",

assume que as aplicações irão trabalhar com dados desconectados por padrão. Além disso, o

 

 

 

 

13

 

 

 

 

classes ADO.NET oferecem recursos sofisticados XML, aumentando ainda mais a sua utilidade

em um ambiente distribuído.

 

Uma compreensão do. NET Framework é essencial para o desenvolvimento profissional do Visual Basic. NET

aplicações. O. NET Framework é explicado em detalhes no Capítulo 3.

 

1.2 O que é Visual Basic. NET?

 

Visual Basic. NET é a próxima geração do Visual Basic, mas é também um desvio considerável em

gerações anteriores. Experientes programadores Visual Basic 6 vai se sentir confortável com o Visual

Basic. NET e reconhecer a maioria das suas construções. No entanto, a Microsoft fez algumas

mudanças para tornar o Visual Basic. NET uma linguagem melhor e um jogador igual no mundo. NET. Estes

incluir complementos, como uma palavra-chave class para definir classes e uma palavra-chave Inherits para o objeto

herança, entre outros. Visual Basic 6 código não pode ser compilado pelo Visual Basic. NET

sem modificações significativas. A boa notícia é que a Microsoft forneceu uma ferramenta de migração para

lidar com a tarefa (na maior parte, de qualquer maneira). A migração de código é explicado no Apêndice A. O Visual Basic. NET

própria linguagem é detalhada no Capítulo 2.

 

Nos últimos meses eu passei quase todo o meu tempo jogando. NET e Visual escrito

Basic. NET programas. Como um usuário do Visual Basic desde a versão 4, eu posso te dizer que estou satisfeito com

esta nova tecnologia e com as mudanças que foram feitas para o Visual Basic. Na minha opinião,

A Microsoft fez o certo.

 

1,3 Um Exemplo do Visual Basic. Programa NET

 

O primeiro programa a escrever é a mesma para todas as línguas: Imprimir as palavras Olá, mundo

 

-Brian W. Kernighan e Dennis M. Ritchie, linguagem de programação C

 

Tornou-se uma tradição de livros de programação para começar com um exemplo do mundo Olá,. A idéia é que

entrar e executar um programa, qualquer programa pode ser o maior obstáculo enfrentado por experientes

programadores aproximando de uma nova plataforma ou idioma. Sem ultrapassar este obstáculo, nada mais

pode seguir. Este capítulo contém três exemplos: um que cria um aplicativo de console, um

que cria uma aplicação GUI, e que cria uma aplicação baseada em browser. Cada exemplo

está sozinho e pode ser executado como está. O console e aplicações gráficas podem ser elaboradas tanto a partir da

linha de comando (sim, o Visual Basic. NET tem um compilador de linha de comando!). A aplicação baseada em browser

requer um computador executando o Internet Information Server (IIS).

 

1.3.1 Olá, mundo

 

Este é um exemplo mundial de programação favorita, traduzido para o Visual Basic. NET:

 

Imports System

 

Olá Pública Módulo

   Sub Público Main ()

      Console.WriteLine ("Olá mundo")

   End Sub

End Module

 

Esta versão do Olá, mundo é um aplicativo de console - ele mostra sua saída em um comando no Windows

janela. Para compilar este programa, insira-lo usando qualquer editor de texto, como o Notepad do Windows,

salvá-lo em um arquivo cujo nome termina com. vb, como Hello.vb, e compilá-lo a partir do Windows

linha de comando com o comando:

 

Hello.vb vbc

 

 

14

 

NET Programação Visual Basic.

 

 

A VBC comando chama o Visual Basic. NET linha de comando, que acompanha o. NET

Framework SDK, e instrui-lo para compilar o arquivo chamado no argumento de linha de comando. Compilando

Hello.vb Hello.exe gera o arquivo. Após a compilação, digite Olá na linha de comando para executar o seu

programa. Figura 1-1 mostra os resultados da compilação e execução deste programa.

 

Figura 1-1. mundo Compilando e executando Olá,

 

 

 

 

 

 

 

 

 

 

 

Se você está acostumado a programação em Visual Basic 6, você poderá ver ainda a partir deste pequeno programa que

Visual Basic mudou dramaticamente. Aqui está uma explicação do que está acontecendo neste código.

 

A primeira linha:

 

Imports System

 

indica que o programa pode usar um ou mais tipos definidos no namespace System. (Os tipos são

agrupadas em namespaces para ajudar a evitar colisões de nomes e tipos de grupos relacionados.)

Especificamente, a Olá, programa mundial usa a classe Console, que é definido no âmbito do Sistema

namespace. A declaração Imports é meramente uma conveniência. Ela não é necessária se o desenvolvedor é

dispostos a qualificar nomes de tipo com os nomes de namespace. Por exemplo, o programa Olá Mundo,

poderia ter sido escrita desta maneira:

 

Olá Pública Módulo

   Sub Público Main ()

      System.Console.WriteLine ("Olá mundo")

   End Sub

End Module

 

No entanto, é costume usar a instrução Imports para reduzir a digitação e confusão visual.

 

Um espaço importante para os desenvolvedores Visual Basic é Microsoft.VisualBasic. Os tipos neste

espaço para expor os membros que formam funções intrínsecas do Visual Basic e sub-rotinas. Por exemplo,

o Visual Basic função Trim é um membro da classe Microsoft.VisualBasic.Strings, enquanto o

função MsgBox é um membro da classe Microsoft.VisualBasic.Interaction. Além disso, o Visual Basic

constantes intrínsecas vêm enumerações dentro deste espaço. Grande parte das funcionalidades disponíveis

neste espaço, no entanto, também é repetido dentro da Base. NET Framework Class Library.

Os desenvolvedores que não estão familiarizados com o Visual Basic 6, provavelmente, optar por ignorar este espaço,

favorecendo a funcionalidade fornecida pelo. NET Framework. O. NET Framework é introduzido em

Neste capítulo, e é explicado em detalhes no Capítulo 3.

 

Em seguida, considerar esta linha:

 

Olá Pública Módulo

 

Esta linha começa a declaração de um módulo padrão chamado Olá. O modelo de declaração de módulo

termina com esta linha:

 

End Module

 

 

 

15

 

 

 

 

No Visual Basic 6, vários objetos de programa foram definidos pelo código fonte colocação em arquivos com diferentes

extensões de arquivo. Por exemplo, o código que classes definidas foi colocado em arquivos. CLS, o código definido

módulos-padrão foi colocado em arquivos. baixos, e assim por diante. No Visual Basic. NET, todos os arquivos de origem têm. Vb

extensões de arquivo, e objetos de programa são definidos com uma sintaxe explícita. Por exemplo, as aulas são

definida com o End Class Class ... construir, e os módulos padrão são definidas com a

Módulo ... End Module construir. Qualquer vb particular. Pode conter muitas dessas declarações

como desejado.

 

A finalidade dos módulos padrão no Visual Basic 6 foi a realização de um código que estava fora de qualquer classe

definição. Por exemplo, as constantes globais, variáveis globais, e as bibliotecas procedimento eram colocados

em módulos padrão. Os módulos padrão no Visual Basic. NET servir a um propósito semelhante e pode ser usado

no da mesma maneira. No entanto, em Visual Basic. NET que definem tipos de dados que não podem ser

instanciado e cujos membros são todos estáticos. Isto será discutido em detalhes no Capítulo 2.

 

A próxima linha no exemplo começa a definição de uma subrotina chamada principal:

 

Sub Público Main ()

 

Ele termina com:

 

End Sub

 

Esta sintaxe é similar ao Visual Basic 6. A declaração Sub começa a definição de uma sub-rotina - uma

método que não tem valor de retorno.

 

A sub-rotina principal é o ponto de entrada para o aplicativo. Quando o Visual Basic. NET é

invocado, ele olha para uma subrotina chamada principal de uma das classes ou módulos padrão exposto pelo

o pedido. Se o principal for declarado em uma classe em vez de um módulo padrão, a sub-rotina deve ser

declarados com o modificador Shared. Este modificador indica que a classe não precisa ser

instanciado para a sub-rotina a ser invocada. Em qualquer caso, a sub-rotina principal deve ser pública. Um

exemplo, encerrar a sub-rotina principal em uma classe em vez de um módulo padrão é dada no

final desta seção.

 

Se não houver sub-rotina principal é encontrado, ou se mais de uma for encontrada, um erro do compilador é gerado. A

compilador de linha de comando tem um interruptor (/ principais: localização), que permite que você especifique qual a classe ou

módulo padrão contém a sub-rotina principal que está a ser utilizado, no caso em que houver mais de

um.

 

Por último, há a linha que faz o trabalho:

 

Console.WriteLine ("Olá mundo")

 

Este código chama o método WriteLine da classe Console, que gera o argumento para o console.

O método WriteLine é definida como um método compartilhado (também conhecido como static). métodos compartilhados não

exigem uma instância do objeto, a fim de ser invocada, métodos compartilhada fazer. métodos são compartilhados

invocada por qualificá-los com o seu nome de classe (neste caso, Console).

 

Aqui está um programa que usa uma classe em vez de um módulo padrão para a casa de sua sub-rotina principal. Nota

que o principal é declarado com o modificador Shared. Ele é compilado e executado da mesma forma como o

exemplo módulo padrão, e produz a mesma saída. Não há nenhuma razão técnica para escolher

uma aplicação sobre o outro.

 

Imports System

 

Public Class Olá

   Public Shared Sub Main ()

      Console.WriteLine ("Olá mundo")

 

 

16

1.3.2 Olá, Windows
 
NET Programação Visual Basic.
 

Aqui está a versão GUI da Olá, mundo:

Imports System
Imports System.Drawing
Imports System.Windows.Forms

Classe HelloWindows Pública

   Formulário Inherits

   Private Label Como lblHelloWindows

   Public Shared Sub Main ()
      Application.Run (HelloWindows Nova ())
   End Sub

   Sub New Public ()

      lblHelloWindows = New Label ()
      Com lblHelloWindows
         .
Situação = New Point (37, 31)
         . Size = Tamanho Nova (392, 64)
         . Font = Fonte Nova ("Arial", 36)
         .
Text = "Olá, Windows!"
         . TabIndex = 0
         . TextAlign ContentAlignment.TopCenter =
      End With

      Me.Text = "Programação Visual Basic.
NET"
      AutoScaleBaseSize Tamanho = Novo (5, 13)
      FormBorderStyle FormBorderStyle.FixedSingle =
      ClientSize Tamanho = Nova (466, 127)
      Controls.Add (lblHelloWindows)

   End Sub

End Class

Isso é semelhante à Olá, mundo aplicativo de console, mas com material extra necessária uma vez que esta é uma GUI
pedido. Duas declarações adicionais importações são necessários para desenhar a janela da aplicação:

Imports System.Drawing
Imports System.Windows.Forms

A classe HelloWindows tem algo que os programas de Visual Basic nunca viu antes, o
declaração Inherits:

Formulário Inherits

O Visual Basic. NET tem herança de classe. O HelloWindows classe herda da
classe Form, que é definido no namespace System.Windows.Forms. Herança de classe e as
declaração Inherits são discutidos no Capítulo 2.
 






























































17
 
 



A próxima linha declara um controle de rótulo que será usado para exibir o texto Olá, Windows:

Private Label Como lblHelloWindows

A classe Label é definido no namespace System.Windows.Forms.

Como é o caso do console, aplicativos GUI deve ter uma sub-rotina compartilhada chamada principal:

Public Shared Sub Main ()
   Application.Run (HelloWindows Nova ())
End Sub

Este método Main cria uma instância da classe HelloWindows e passa para o método Run
a classe Application (definido no namespace System.Windows.Forms). O método Run leva
cuidado da limpeza da criação de um loop de mensagem do Windows e ligar o formulário HelloWindows
para ele.

Em seguida é outro método especial:

Sub New Public ()

Como principal, Nova tem um significado especial para o Visual Basic. NET. Sub-rotinas chamado Novo são
compilados em construtores. Um construtor é um método que não tem valor de retorno (mas pode ter
argumentos) e é chamado automaticamente sempre que um novo objeto do tipo de dado é instanciado.
Construtores são explicadas no capítulo 2.

O construtor da classe HelloWindows instancia um objeto Label, define algumas de suas propriedades, conjuntos
algumas propriedades do formulário e, em seguida, adiciona o objeto Label para a coleção Controls do formulário. A
coisa interessante a se notar é como isto é diferente de como o Visual Basic 6 representada design do formulário. Em
Visual Basic 6, o layout do formulário foi representado por dados. Frm. Estes dados não foram código, mas sim uma
listagem das propriedades e os valores dos vários elementos no formulário. No Visual Basic. NET, este
abordagem está desaparecido. Em vez disso, as declarações Visual Basic. NET deve explicitamente instanciar objetos visuais e
definir suas propriedades. Quando os formulários são projetados no Visual Studio. NET usando o designer de arrastar e soltar,
Visual Studio. NET cria este código em seu nome.

A linha de comando para compilar o Olá, programa do Windows é:

HelloWindows.vb vbc
/ Referência: System.dll, System.Drawing.dll System.Windows.Forms.dll
/ Destino: winexe

(Note que não há quebra nessa linha.)

A linha de comando para a elaboração da Olá, o programa do Windows tem mais coisas nele do que aquele para o
baseado em console Olá, programa mundial. Além de especificar o nome do arquivo. Vb, este comando
linha usa as referências / switch para especificar três. dlls que contêm as implementações da biblioteca
classes utilizadas no programa (Form, Label, Point, etc.) O Olá mundo, aplicativo de console não
exigem referências ao ser compilada, pois tudo o que foi utilizado a classe Console, definido no
Namespace System. . O Visual Basic NET linha de comando inclui duas referências implicitamente:
mscorlib.dll (que contém o namespace System) e Microsoft.VisualBasic.dll (que contém
classes auxiliares utilizadas para implementar algumas das funcionalidades do Visual Basic. NET).

Além da opção referências /, a linha de comando para compilar o Olá, programa do Windows
Inclui a opção / target. A / controles chave alvo, que tipo de arquivo de código executável é
produzido. Os possíveis valores da opção / target são os seguintes:

exe


18
 






winexe



biblioteca
 
NET Programação Visual Basic.


Cria um aplicativo de console. O arquivo gerado tem a extensão. Exe. Este é o padrão.



Cria uma aplicação GUI. O arquivo gerado tem a extensão. Exe.



Cria uma biblioteca de classes. O arquivo gerado tem a extensão. Dll.
 

A saída da Olá, o Windows é mostrado na Figura 1-2.

Figura 1-2. Olá, Windows!










aplicações GUI são explicadas em detalhe no Capítulo 4 eo Capítulo 5.

1.3.3 Olá, Browser

Aqui está uma versão baseada em navegador da aplicação Olá Mundo. Porque a versão mais simples desse
uma aplicação pode ser realizada com apenas HTML, adicionei um pouco de tempero. Esta página da web
inclui três botões que permitem que o usuário final para mudar a cor do texto.

language="VB" runat="server"> <script

      Sub Page_Load (Sender As Object, E As EventArgs)
         lblMsg.Text = "Olá, Browser!"
      End Sub

      Sub btnBlack_Click (Sender As Object, E As EventArgs)
         lblMsg.ForeColor = System.Drawing.Color.Black
      End Sub

      Sub btnGreen_Click (Sender As Object, E As EventArgs)
         lblMsg.ForeColor = System.Drawing.Color.Green
      End Sub

      Sub btnBlue_Click (Sender As Object, E As EventArgs)
         lblMsg.ForeColor = System.Drawing.Color.Blue
      End Sub

</ Script>

<html>

   <head>
      <title> de programação Visual Basic.
NET </ title>
   </ Head>

   <body>


19
 
 



      <form action="HelloBrowser.aspx" method="post" runat="server">
         id="lblMsg" <asp:label <h1> runat="server"/> </ h1>
         <p>
            <asp: tipo = botão "submit" id = "btnBlack" text = "Black"
               Onclick = runat "btnBlack_Click" = "server" />
            <Asp: botão ID = "text btnBlue" = "Azul"
               Onclick = runat "btnBlue_Click" = "server" />
            <Asp: botão ID = "text btnGreen" = "Verde"
               Onclick = runat "btnGreen_Click" = "server" />
         </ P>
      </ Form>
   </ Body>

</ Html>

Para executar este programa, insira-o usando um editor de texto e salvá-lo em um arquivo chamado HelloBrowser.aspx.
Como o aplicativo é uma página web que se destina a ser entregue por um servidor web, ele deve ser salvo
em uma máquina que está executando o IIS e tem o. NET Framework instalado. Crie uma pasta virtual no IIS
para apontar para a pasta que contém HelloBrowser.aspx. Finalmente, no ponto de um navegador web para HelloBrowser.aspx.
A saída do Olá, aplicação Browser é mostrado na Figura 1-3.

Figura 1-3. Olá, Browser!















Certifique-se de fazer referência ao arquivo através da máquina do servidor web
nome ou local (se o servidor web está em sua máquina local), assim
que o servidor web é chamado. Por exemplo, se o arquivo estiver em uma
diretório virtual chamado teste no computador local, aponte o
browser para http://localhost/Test/HelloBrowser.aspx. Se você apontar
navegador diretamente para o arquivo usando um caminho de arquivos, na web
servidor não será chamado.

Entrar em detalhes sobre a Olá, o código do navegador seria demais para uma introdução. No entanto, eu gostaria
para chamar a atenção para as marcas e <asp:label> <asp:Button>. Essas marcas representam servidor
controles secundários. Um controle de servidor é uma classe que é instanciada no servidor web e gera
saída apropriada para se representar no navegador. Essas classes ricas e conjuntos coerentes de
propriedades e métodos, pode ser referenciado em código como controles em formulários são referenciados em GUI
aplicações.

ASP.NET tem muitas outras características interessantes, algumas das quais são:

• As páginas Web são compilados, resultando em um desempenho muito melhor ao longo do ASP clássico.
• O código pode ser puxado para fora das páginas da web inteira e colocados em arquivos. Vb (chamado de code-behind)
que são referenciados pelas páginas da web. Esta separação do layout da página web a partir dos resultados de código em
páginas que são mais fáceis de desenvolver e manter.


20
 
NET Programação Visual Basic.


• ASP.NET detecta automaticamente os recursos do navegador do usuário final e ajusta seu
saída de acordo.

aplicativos baseados em navegador são discutidos em detalhe no Capítulo 6.
 







































































21
 







































































22
 
NET Programação Visual Basic.


Capítulo 2. O Visual Basic. NET

Este capítulo aborda a sintaxe da linguagem Visual Basic. NET, incluindo conceitos básicos, tais
como variáveis, operadores, instruções, classes, etc algum material que você esperaria encontrar nesta
capítulo parece estar faltando. Por exemplo, funções matemáticas, arquivo I / O, e as declarações de forma
são todos uma parte muito importante de desenvolvimento de aplicativos do Visual Basic. NET, mas eles não são introduzidas no
Neste capítulo, porque eles não são intrínsecas ao Visual Basic. NET. Eles são fornecidos pela
. NET Framework e será discutido nos próximos capítulos. NET Além disso, Visual Basic.
funções que existem apenas para compatibilidade com o Visual Basic 6 não estão documentados neste
capítulo.

2,1 arquivos de origem

Visual Basic. NET código-fonte é salvo em arquivos com extensão vb.. A exceção a esta regra é quando
Visual Basic. NET é embutido em arquivos de páginas da Web ASP.NET. Esses arquivos têm uma extensão..

Os arquivos fonte são arquivos de texto simples que podem ser criados e editados com qualquer editor de texto, incluindo o nosso velho
amigo, o Bloco de Notas. O código-fonte pode ser dividido em tantas ou tão poucos arquivos, como desejado. Quando você usa
Visual Studio. NET, os arquivos de origem estão listados na janela Solution Explorer, e todas as fontes está incluído
a partir desses arquivos quando a solução é construída. Quando você está compilando a partir da linha de comando, todas as fontes
arquivos devem aparecer como argumentos de linha de comando para a compilação de comando. A localização das declarações
dentro de arquivos de origem não é importante. Enquanto todas as declarações aparecem referenciados em algum lugar em um
arquivo fonte a ser compilado, eles serão encontrados.

Ao contrário das versões anteriores do Visual Basic, sem extensões de arquivos especiais são usados para indicar diferentes
construções de linguagem (por exemplo,. cls para as aulas. frm para formulários, etc.) Sintaxe foi adicionado à
linguagem para diferenciar várias construções. Além disso, o pseudolanguage para especificar o
layout gráfico de formas foi removido. Forma layout é especificado pelas propriedades de configuração de forma
objetos explicitamente no código. Ou este código pode ser escrito manualmente, ou a forma WYSIWYG
designer no Visual Studio. NET pode escrevê-lo.

2,2 Identificadores

Os identificadores são nomes dados aos namespaces (discutido mais tarde neste capítulo), tipos (enumerações,
estruturas, classes, módulos standard, interfaces e delegados), tipo membros (métodos,
construtores, eventos, constantes, campos e propriedades), e variáveis. Os identificadores devem começar com o
um caractere alfabético ou sublinhado (_), pode ser de qualquer comprimento, e após o primeiro caractere deve
consistem apenas caracteres alfanuméricos e sublinhado. declarações de namespace pode ser declarado
quer com identificadores ou identificadores qualificados. identificadores qualificado composto por dois ou mais identificadores
relacionados com o caractere ponto (.). Somente declarações de namespace pode usar identificadores qualificados.

Considere o seguinte fragmento de código:

Imports System

Namespace ORelly.ProgVBNet

   Public Class Olá
      Public Shared Sub SayHello ()
         Console.WriteLine ("Olá mundo")
      End Sub
   End Class
End Namespace

Este fragmento de código declara três identificadores: OReilly.ProgVBNet (um nome de namespace), Olá (uma classe
nome), e SayHello (nome de um método). Além destes, o fragmento de código utiliza três identificadores


23
 



declarados em outro lugar: System (um nome de namespace), Console (um nome de classe) e WriteLine (um método
nome).

Embora o Visual Basic. NET não é case sensitive, o caso dos identificadores é preservada quando
aplicativos são compilados. Ao usar o Visual Basic. NET de linguagens entre maiúsculas e minúsculas,
o chamador deve usar o caso apropriado.

Normalmente, os identificadores podem não coincidir com o Visual Basic. NET palavras-chave. Caso seja necessário declarar ou uso
um identificador que corresponde a uma palavra-chave, o identificador deve ser entre colchetes ([]). Considere
este fragmento de código:

Public Class [Público]
   Public Shared Sub SayHello ()
      Console.WriteLine ("Olá mundo")
   End Sub
End Class
Classe SomeOtherClass Pública
   Public Shared Sub SomeOtherMethod ()
      [Público]. SayHello ()
   End Sub
End Class

Esse código declara uma classe chamada Pública e, em seguida, declara uma classe e método que utilizam o Públicos
classe. Pública é uma palavra-chave no Visual Basic. NET. Escapando com colchetes permite que ela seja usada como
um identificador, neste caso o nome de uma classe. Por uma questão de estilo, usando palavras-chave como identificadores devem
ser evitado, a menos que haja uma necessidade imperiosa. Esta facilidade permite que os aplicativos Visual Basic. NET
utilizar componentes externos que declare identificadores correspondentes Visual Basic palavras-chave. NET.

2,3-chave

Palavras-chave são palavras com significado especial em uma linguagem de programação. No Visual NET. Básica,
palavras-chave são reservados, isto é, eles não podem ser usados como símbolos para fins de nomeação de variáveis
e sub-rotinas. As palavras-chave no Visual Basic. NET estão apresentados na Tabela 2-1.


Tabela 2-1. Visual Basic. Keywords NET
 
Palavra
AddHandler
AddressOf
Alias
E
AndAlso
Ansi
 

Visual Basic. Declaração NET
Visual Basic. Declaração NET
Usado na instrução Declare
operador booleano
operador booleano
Usado na instrução Declare
 
Descrição
 
Anexar
Como
Assembléia
Auto
Binária
Boolean
ByRef
Byte
ByVal


24
 
Usado como uma constante simbólica na função FileOpen
Usado na declaração da variável (Dim, amigos, etc)
Assembléia nível especificador de atributo
Usado na instrução Declare
Usado na instrução Option Compare
Usado na declaração de variáveis (tipo de dados intrínseco)
Usado em listas de argumentos
Usado na declaração de variáveis (tipo de dados intrínseco)
Usado em listas de argumentos
 
 



Chamada
Processo
Capturas
CBool
CByte
CCHAR
CDate
CDec
CDbl
Char
CInt
Classe
CLng
CObj
Compare
CShort
CSng
CStr
CType
Data
Decimais
Declarar
Default
Delegado
Escurecer
Não
Duplo
Cada
Mais
ElseIf
Fim
EndIf
Enum
Apagar
Erro
Evento
Explícita
False
Para
Finalmente
Para
Amigo
Função
Obter
GetType
GoTo
Puxadores
 
NET Programação Visual Basic.


Visual Basic. Declaração NET
Usado na construção Select Case
Visual Basic. Declaração NET
A conversão de dados, função
A conversão de dados, função
A conversão de dados, função
A conversão de dados, função
A conversão de dados, função
A conversão de dados, função
Usado na declaração de variáveis (tipo de dados intrínseco)
A conversão de dados, função
Visual Basic. Declaração NET
A conversão de dados, função
A conversão de dados, função
Usado na instrução Option Compare
A conversão de dados, função
A conversão de dados, função
A conversão de dados, função
A conversão de dados, função
Usado na declaração de variáveis (tipo de dados intrínseco)
Usado na declaração de variáveis (tipo de dados intrínseco)
Visual Basic. Declaração NET
Usado na declaração de propriedade
Visual Basic. Declaração NET
instrução de declaração da variável
Visual Basic. Declaração NET
Usado na declaração de variáveis (tipo de dados intrínseco)
Usado no For Each ... Next construção
Usado na Se ... ElseIf ... Else ... End Se construir
Usado na Se ... ElseIf ... Else ... End Se construir
Usado para encerrar uma série de declarações
Usado na Se ... ElseIf ... Else ... End Se construir
Visual Basic. Declaração NET
Visual Basic. Declaração NET
Usado no erro e sobre as declarações de compatibilidade erro
Visual Basic. Declaração NET
Usado na instrução Option Explicit
Boolean literal
Usado no For ... Next e For Each ... Next construções
Visual Basic. Declaração NET
Visual Basic. Declaração NET
Declaração e modificador de acesso
Visual Basic. Declaração NET
Usado na construção de imóvel
Visual Basic. Operadora NET
Visual Basic. Declaração NET, usado com a instrução On Error
Define um manipulador de eventos em uma declaração de procedimento
 







































































25
 



Se
Implementa
Importações
Em
Herda
Entrada
Inteiro
Interface
É
Vamos
Lib
Gosto
Lock
Long
Loop
Me
Mid
Mod
Módulo
MustInherit
MustOverride
MyBase
MyClass
Namespace
Novo
Seguinte
Não
Nada
 



Visual Basic. Declaração NET
Visual Basic. Declaração NET
Visual Basic. Declaração NET
Usado no For Each ... Next construção
Visual Basic. Declaração NET
Usado na função FileOpen
Usado na declaração de variáveis (tipo de dados intrínseco)
Visual Basic. Declaração NET
Objeto operador de comparação
Reservado, mas não utilizados no Visual Basic. NET
Usado na instrução Declare
Visual Basic. Operadora NET
Nome da função
Usado na declaração de variáveis (tipo de dados intrínseco)
Usado em um loop
Declaração referindo-se à instância do objeto atual
String manipulação de instrução e função
Visual Basic. Operadora NET
Visual Basic. Declaração NET
Usado na construção de Classe
Usado na Sub e instruções de função
Declaração referindo-se a classe de um objeto de base
Declaração referindo-se à instância do objeto atual
Visual Basic. Declaração NET
A criação do objeto-chave, nome do construtor
Usado no For ... Next e For Each ... Next construções
Visual Basic. Operadora NET
É usado para remover uma referência de objeto
 
NotInheritable usado na classe construir
NotOverridable Usado no Sub, Propriedade e instruções de função
 
Objeto
Off
Em
Opção
Opcional
Ou
OrElse
Saída
Sobrecargas
Overridable
Substituições
ParamArray
Preservar
Privado
Imóvel
Protegidas
Público


26
 
Usado na declaração de variáveis (tipo de dados intrínseco)
Usado em declarações Opção
Usado em declarações Opção
Usado em declarações Opção
Usado nas demonstrações Declare, função, propriedade e Sub
operador booleano
operador booleano
Usado na função FileOpen
Usado na Sub e instruções de função
Usado na Sub e instruções de função
Usado na Sub, Propriedade e instruções de função
Usado nas demonstrações Declare, função, propriedade e Sub
Usado com a instrução ReDim
Declaração e modificador de acesso
Visual Basic. Declaração NET
Declaração e modificador de acesso
Declaração e modificador de acesso
 
 



RaiseEvent
Random
Leia
ReadOnly
ReDim
Rem
RemoveHandler
Retomar
Retorno
Procurar
Selecione
Definir
Sombras
Compartilhados
Curto
Único
Estático
Etapa
Parar
String
Estrutura
Sub
SyncLock
Texto
Em seguida,
Jogar
Para
True
Experimente
TypeOf
Unicode
Até
Variante
Quando
Enquanto
Com
WithEvents
WriteOnly
XOR

2,4 literais
 
NET Programação Visual Basic.


Visual Basic. Declaração NET
Usado na função FileOpen
Usado na função FileOpen
Usado na declaração de propriedade
Visual Basic. Declaração NET
Visual Basic. Declaração NET
Visual Basic. Declaração NET
Usado no On Error Resume e declarações
Visual Basic. Declaração NET
O acesso ao arquivo-declaração e função
Usado na construção Select Case
Usado na declaração de propriedade
Visual Basic. Declaração NET
Usado na Sub e instruções de função
Usado na declaração de variáveis (tipo de dados intrínseco)
Usado na declaração de variáveis (tipo de dados intrínseco)
instrução de declaração da variável
Usado na construção de For ... Next
Visual Basic. Declaração NET
Usado na declaração de variáveis (tipo de dados intrínseco)
Visual Basic. Declaração NET
Visual Basic. Declaração NET
Visual Basic. Declaração NET
Usado na instrução Option Compare
Usado na If ... Then ... Else ... EndIf construir
Visual Basic. Declaração NET
Usado no For ... Next Select Case e construções
Boolean literal
Visual Basic. Declaração NET
Usado em variações da Se ... Então ... EndIf construir
Usado na instrução Declare
Usado na construção de For ... Next
Reservado, mas não utilizados no Visual Basic. NET
Usado com o try ... catch ... Finalmente construir
Usado com o Do ... Loop e While ... End While construções
Visual Basic. Declaração NET
Usado na declaração da variável (Dim, Public, etc)
Usado na declaração de propriedade
Visual Basic. Operadora NET
 

Literais são representações de valores dentro do texto de um programa. Por exemplo, na linha do seguimento de
código 10 é um literal, mas X e Y não são os seguintes:

x * y = 10




27
 
 



Literais têm tipos de dados como variáveis fazer. Os 10 neste fragmento de código é interpretado pelo
compilador como tipo inteiro porque é um número inteiro que esteja dentro do intervalo do tipo Integer.

2.4.1 Literais numéricos

Qualquer número inteiro literal que está dentro do intervalo do tipo Integer (-2147483648 a 2147483647) é
interpretado como tipo inteiro, mesmo se o valor for pequeno o suficiente para ser interpretada como tipo Byte ou Short.
literais inteiros que estão fora do intervalo inteiro, mas estão dentro do intervalo do tipo Long (-
9223372036854775808 através 9223372036854775807) são interpretados como tipo Long. literais inteiros
fora da faixa Long causar um erro em tempo de compilação.

Literais numéricos também podem ser de um dos tipos de ponto flutuante, Single, Double e Decimal. Para
exemplo, esta linha de código, 3,14 é um literal do tipo Double:

z * y = 3,14

Na ausência de indicação expressa do tipo (discutido em breve), Visual Basic. NET interpreta flutuante
literais de ponto como o tipo de casal. Se o literal está fora do alcance do tipo Double (-
1.7976931348623157E308 através 1.7976931348623157E308), um erro em tempo de compilação ocorre.

Visual Basic. NET permite aos programadores especificar explicitamente os tipos de literais. Tabela 2-2 (mostrado
mais adiante neste capítulo), enumera Visual Basic. NET tipos de dados intrínseco, juntamente com o método para explicitamente
definição de um literal de cada tipo. Note que, para alguns tipos intrínsecos, não há nenhuma maneira de escrever um literal.

2.4.2 Literais String

Literais do tipo String composta de caracteres dentro caracteres de aspas. Por exemplo, em
a seguinte linha de código, "Olá, mundo" é um literal do tipo String:

Console.WriteLine ("Olá mundo")

Strings não podem ocupar várias linhas de origem. Em outras palavras, isso não é permitido:

'Wrong
Console.WriteLine ("Olá,
   mundo ")

Para escrever uma string literal contendo caracteres aspas, digite o personagem duas vezes para cada vez que
deve aparecer. Por exemplo:

Console.WriteLine ("Então Dave disse," Olá, "".") mundo

Esta linha produz o seguinte resultado:

Então Dave disse, "Olá, mundo".

2.4.3 Literais Caracteres

Visual Basic. NET é Char representa um único caractere. Este não é o mesmo que um único caractere
string; Strings e caracteres são tipos distintos. Literais do tipo Char consistem de um único personagem fechados
no prazo de caracteres de aspas, seguido do carácter c. Por exemplo, no código a seguir,
"A" c é um literal do tipo Char:

Dim MyChar Como Char
MyChar = "A" c


28
 
NET Programação Visual Basic.


Para ressaltar que esse é literal de um tipo de dados diferente do que uma cadeia de caracteres simples, note que este
código faz com que um erro em tempo de compilação se Option Strict On:

'Wrong
Dim MyChar Como Char
MyChar = "A"

O erro é:

Option Strict On não permite conversões implícitas de 'String' a 'Char'.

2.4.4 literais de data

Literais do tipo data são formadas colocando uma data / hora nos personagens seqüência sinal de número. Para
exemplo:

Dim MyDate como data
MyDate = # 2001/11/15 03:00:00 #

literais Data no Visual Basic. NET deve estar no formato m / d / aaaa, independentemente da regional
configurações do computador no qual o código está escrito.

2.4.5 Literais booleanos

As palavras-chave Verdadeiro e falso são apenas literais booleanos. Eles representam o verdadeiro eo falso
Boolean estados, respectivamente (claro!). Por exemplo:

As Boolean Dim myBoolean
MyBoolean = True

2.4.6 Nada

Há um literal que não tem nenhum tipo: Nada a palavra-chave. Nada é um símbolo especial que
representa um valor não inicializado de qualquer tipo. Ela pode ser atribuída a qualquer variável e passou, em qualquer
parâmetro. Quando usado no lugar de um tipo de referência, que representa uma referência que não faz referência
qualquer objeto. Quando usado no lugar de um tipo de valor, que representa um valor vazio desse tipo. Para numéricos
tipos, isto é 0 ou 0,0. Para o tipo String, esta é a seqüência de caracteres vazia (""). Para o tipo booleano, isto é
False. Para o tipo Char, este é o caractere Unicode que tem um código numérico de 0. Para
Tipos de valor definido pelo programador, Nada representa uma instância do tipo que foi criado
mas não foi atribuído um valor.

2.4.7 Resumo dos formatos Literal

A Tabela 2-2 mostra todos Visual Basic. Tipos intrínsecos da NET, bem como o formato para a escrita de literais
esses tipos de programas.


Tabela 2-2. literais de Formação
 
Dados
tipo
Boolean True, False

Char C
 

Literal
 

Exemplo
As Boolean Dim bFlag
= False
Dim chVal Como Char =
"X" C


29
 
 




Data # #

Decimal D



Duplo Qualquer número de ponto flutuante, ou R
 



Como Dim datMillen
Data = # 2001/01/01 #
Como Dim decValue
Decimal = 6.14D
Como Dim dblValue
Duplo = 6,142

Como Dim dblValue
Duplo = 6.142R
Como Dim iValue
Integer = 362

Como Dim iValue
Integer = 362I
 
Integer valor de uma integral no intervalo do tipo Integer (-2.147.483.648 a Dim iValue como
 











Long
 
2147483647), ou eu








Um valor integral fora do alcance do tipo Integer (-
9.223.372.036.854.775.808 de -2147483649, ou
2147483648 para 9,223,372,036,854,775,807), ou L
 
Integer = & H16AI
(Hexadecimal)

Como Dim iValue
Integer = & O552I
(Octal)
Dim lValue As Long =
362L

Dim lValue As Long =
& H16AL (hexadecimal)

Dim lValue As Long =
& O552L (octal)
As Short Dim shValue
= 362S

As Short Dim shValue
 
Curta S




F Único

String "


Observe os seguintes fatos sobre a formação de literais em Visual Basic. NET:
 
= & H16AS (hexadecimal)

As Short Dim shValue
= & O552S (octal)
Como Dim sngValue
Single = 6.142F
Como Dim strValue
String = "Esta é uma
string "
 














30
 

• Não há nenhuma maneira de representar um literal do tipo Byte. No entanto, isso não significa que literais
não pode ser usado em situações em que tipo Byte é esperado. Por exemplo, o código a seguir é
multa:

Dim MyByte As Byte = 100

• Mesmo que o Visual Basic. NET considera 100 a ser do tipo Integer neste
exemplo, reconhece que o número é pequeno o suficiente para caber em uma variável do tipo Byte.
• Tipos não mostrada na Tabela 2-2 não pode ser expresso como literais.
 
 



2.5 Tipos
 
NET Programação Visual Basic.
 

. Tipos no Visual Basic NET estão divididos em duas categorias: tipos de valor e tipos referência. Valor
tipos de minimizar a sobrecarga de memória e aumentar a velocidade de acesso, mas faltam alguns recursos de um
design totalmente orientada a objetos (como herança). Tipos de referência dar pleno acesso ao orientada a objeto
recursos, mas impõem uma sobrecarga de memória e velocidade para gerenciar e acessar objetos.
Quando uma variável tem um tipo de valor, os dados em si é armazenado na variável. Quando uma variável tem um
tipo de referência, uma referência para os dados (também conhecido como um ponteiro) é armazenado na variável, e os dados
é guardada em outro lugar. Visual Basic. NET tipos primitivos incluem os dois tipos de valor e
tipos de referência (ver "Tipos Fundamentais" nesta seção). Para estender o sistema de tipos, Visual
Basic. NET fornece uma sintaxe para a definição de ambos os tipos de novos valores e novos tipos de referência (ver "Custom
Tipos de "mais adiante nesta seção).

Todos os tipos de referência derivam do tipo de objeto. Para unificar o sistema de tipos, tipos de valor podem ser tratados
como tipos de referência quando necessário. Isto significa que todos os tipos podem derivar do tipo Object. Tratar
tipos de valor como tipos de referência (um processo conhecido como boxe) é tratada mais adiante neste capítulo, em
Secção 2.16.

2.5.1 Tipos Fundamentais

Visual Basic. NET tem vários tipos built-in. Cada um desses tipos é um apelido para um tipo fornecido pela
da. arquitectura NET. Porque o Visual Basic. NET são equivalentes aos correspondentes
subjacente. NET fornecido, não há problemas de compatibilidade de tipo quando passar argumentos para
componentes desenvolvidos em outras línguas. No código, não faz diferença para o compilador se
tipos são especificados usando o nome da palavra-chave para o tipo ou usando a base. nome do tipo NET. Para
exemplo, o teste neste fragmento de código bem-sucedida:

Dim x inteiro como
Dim y Como System.Int32
Se x.GetType () É y.GetType () Em seguida,
   Console.WriteLine ("Eles são do mesmo tipo!")
Mais
   Console.WriteLine ("Eles não são do mesmo tipo.")
End If

. O fundamental Visual Basic NET são:

Boolean

O tipo Boolean é limitado a dois valores: True e False. Visual Basic. NET inclui muitos
operadores lógicos, que resultam em um tipo Boolean. Por exemplo:

Public Shared Sub MySub (ByVal x As y Integer, ByVal As Integer)
   Dim b As Boolean = y> x
   'Outro código
MySub Sub End '

O resultado do operador maior do que (>) é do tipo Boolean. A variável b é atribuída a
valor True se o valor de x é maior que o valor em Y e False se ele não é. A
subjacente. NET é System.Boolean.

Byte

O tipo byte pode conter um intervalo de números inteiros de 0 a 255. Ela representa os valores que
pode ser realizada em oito bits de dados. O subjacente. NET é System.Byte.

Char


31
 
 










Data
 



O tipo char pode conter qualquer caractere Unicode [1]. O tipo de dados Char é novo no Visual
Basic. NET. O subjacente. NET é System.Char.

[1] Unicode é um sistema de 16 bits de codificação de caracteres que é padrão em todas as plataformas, programas e linguagens (humanas
e máquina). Veja http://www.unicode.org para obter informações sobre Unicode.



O tipo de data contém valores que especificar datas e horários. O intervalo de valores é a partir da meia-noite
em 01 de janeiro de 0001 (0001-01-01T00: 00:00) por meio de um segundo antes da meia-noite de dezembro
31, 9999 (9999-12-31T23: 59:59). O tipo Date contém muitos membros de acesso,
comparação e manipulação de datas e horários. O subjacente. NET é System.DateTime.
 

Decimais

O tipo Decimal mantém números decimais com uma precisão de 28 dígitos decimais significativos. Sua
objetivo é representar e manipular números decimais, sem os erros de arredondamento da
tipo Single e Double. O tipo Decimal substitui Visual Basic 6 é o tipo de moeda. A
subjacente. NET é System.Decimal.

Duplo

O tipo de casal tem um valor de 64 bits em conformidade com padrão IEEE 754 para flutuante binário
aritmética de ponto. O tipo de casal tem números de ponto flutuante no intervalo -
1.7976931348623157E308 através 1.7976931348623157E308. O menor não negativo
número (diferente de zero) que pode ser realizada em um casal é 4.94065645841247E-324. A
subjacente. NET é System.Double.

Inteiro

O tipo inteiro contém inteiros na faixa de -2147483648 a 2147483647. O Visual
Basic. NET tipo de dados inteiro corresponde ao VB 6 Long tipo de dados. O subjacente. NET
tipo é System.Int32.

Long

O tipo Long contém inteiros na faixa -9223372036854775808 através
9223372036854775807. No Visual Basic. NET, Long é um 64-bit tipo de dados inteiro. A
subjacente. NET é System.Int64.

Objeto

O tipo de objeto é o tipo básico do qual todos os outros tipos são derivados. O Visual
Basic. NET tipo de dados Object substitui a Variant no VB 6, como o tipo de dados universal. A
subjacente. NET é System.Object.

Curto

O tipo Short contém inteiros na faixa de -32768 a 32767. O tipo de dados Short
corresponde a 6 milhões VB tipo de dados. O subjacente. NET é System.Int16.

Único

O tipo tem um valor único de 32 bits que está de acordo com padrão IEEE 754 para flutuante binário
aritmética de ponto. O tipo Single mantém números de ponto flutuante no intervalo-3.40282347E38
através 3.40282347E38. O menor número não negativo (diferente de zero) que pode ser realizada
em dobro é 1,401298 E-45. O subjacente. NET é System.Single.


32
 
 



String
 
NET Programação Visual Basic.




O tipo String contém uma seqüência de caracteres Unicode. O subjacente. NET é
System.String.
 

Dos tipos fundamentais, Boolean, Byte, Char, Date, Decimal, Double, Integer, Long, Short, e
Único (ou seja, todos eles, exceto Object e String) são tipos de valor. Object e String são referência
tipos.

2.5.2 Tipos personalizados

Visual Basic. NET fornece uma sintaxe rica para o alargamento do sistema de tipos. Os programadores podem definir tanto
novos tipos de valor e tipos referência nova. Tipos declarados com o Visual Basic. NET Estrutura e
demonstrações Enum são tipos de valor, como são todos. NET Framework que derivam
System.ValueType. Tipos de referência incluem Object, String, todos os tipos declarados com o Visual
Classe Basic. NET, Interface, e as declarações do delegado, e tudo mais. NET Framework que
não derivam de System.ValueType.

2.5.3 Matrizes

declarações de matriz em Visual Basic. NET são semelhantes aos de Visual Basic 6 e outras linguagens. Para
exemplo, aqui está uma declaração de uma matriz de inteiros que tem cinco elementos:

Integer Dim a (4) como

Os 4 literal nesta declaração especifica o limite superior da matriz. Todas as matrizes no Visual Basic. NET
ter um limite inferior de 0, por isso esta é uma declaração de uma matriz com cinco elementos, tendo os índices 0, 1, 2,
3 e 4.

A declaração anterior é de uma variável nomeada, que é do tipo "array de inteiros." tipos de matriz
implicitamente herdam o tipo. NET Framework Array (definido no namespace System) e,
portanto, têm acesso aos métodos definidos no tipo. Por exemplo, o código a seguir exibe
os limites inferior e superior de uma matriz chamando GetLowerBound a classe Array e
GetUpperBound métodos:

Integer Dim a (4) como

Console.WriteLine ("limites mínimos é" & a.GetLowerBound (0). ToString ())
Console.WriteLine ("limites máximos é" & a.GetUpperBound (0). ToString ())

A saída é:

LowerBound é 0
Limites superiores a 4

Note-se que o limite superior do array é dinâmico: ele pode ser alterado por métodos disponíveis no
Tipo Array.

Elementos de matriz são inicializados com o valor padrão do tipo de elemento. O valor de um tipo de padrão é
determinada como segue:

• Para tipos numéricos, o valor padrão é 0.
• Para o tipo Boolean, o valor padrão é False.
• Para o tipo Char, o valor padrão é o caractere Unicode cujo valor é 0.




33
 
 



• Para os tipos de estrutura (descritos mais adiante neste capítulo), o valor padrão é uma instância da
tipo de estrutura com todos os seus campos definidos para seus valores padrão.
• Para os tipos de enumeração (descritos mais adiante neste capítulo), o valor padrão é uma instância da
tipo de enumeração com sua representação interna definida como 0, o que pode ou não corresponder à
um valor legal na enumeração.
• Para tipos de referência (incluindo cordas), o valor padrão é Nothing.

Você pode acessar elementos da matriz pelo sufixo do nome de matriz com o índice do elemento desejado
entre parênteses, como mostrado aqui:

Para i = 0 a 4
   Console.WriteLine (a (i))
Seguinte

Matrizes podem ser multidimensional. As vírgulas separam as dimensões da matriz quando usado em
declarações e no acesso aos elementos. Aqui está a declaração de uma matriz tridimensional,
onde cada dimensão tem um tamanho diferente:

Integer Dim a (5, 10, 15) Como

Tal como acontece com as matrizes unidimensionais, os elementos de matriz são inicializados para seus valores padrão.

2.5.3.1 Inicializando arrays

Arrays de tipos primitivos podem ser inicializados colocando os valores iniciais entre chaves ({}). Para
exemplo:

Dim a () As String = {"Primeiro", "Segundo", "Third", "Quarto", "Quinta"}

Observe que quando as matrizes são inicializados desta forma, a declaração de matriz não é permitido para especificar
uma dimensão explícita. O compilador infere o tamanho do número de elementos no inicializador.

Para inicializar matrizes, incluir o número apropriado de vírgulas na matriz de nome
declaração e uso colchetes aninhados no inicializador. Aqui está uma declaração de uma bi-dimensional
matriz com três linhas e duas colunas:

Dim a () As Integer = {{1, 2}, {3, 4}, {5, 6}}

Essa declaração produz a matriz a seguir:

um (0,0) = 1 A (0,1) = 2
um (1,0) = 3 um (1,1) = 4
um (2,0) = 5 um (2,1) = 6

Ao inicializar as matrizes, os suportes mais íntimos cacheados correspondem à direita
dimensão.

2.5.3.2 alocar dinamicamente arrays

Use a palavra-chave New para alocar matrizes de qualquer tipo. Por exemplo, este código cria uma matriz de cinco
Inteiros e inicializa os elementos como mostrado:

Integer Dim a () Em
um Integer = Nova (4) {1, 2, 3, 4, 5}




34
 
NET Programação Visual Basic.


Se os elementos da matriz não será inicializado através da repartição, ainda é necessário incluir o crespo
entre parênteses:

Integer Dim a () Em
"Aloca um array não inicializado de cinco inteiros
um Integer = Nova (5) {}

colchetes são necessários para o compilador não irá confundir a sintaxe array com uma sintaxe do construtor.

Observe também o significado desta declaração, por si só:

Integer Dim a () Em

Esta é a declaração de uma referência que poderia apontar para uma matriz unidimensional de inteiros, mas
ainda não. O seu valor inicial não é nada.

2.5.4 Coleções

A coleção é qualquer tipo que expõe a interface ICollection (definido no System.Collections
namespace). (Interfaces são explicados mais adiante neste capítulo. Resumidamente, uma interface é um acordo em
qual o tipo vai expor certos métodos, propriedades e outros membros. Ao expor o
interface ICollection, um tipo garante que ela pode ser usada em qualquer uma coleção é esperada.) Em
geral, as coleções armazenar valores múltiplos e fornecem uma maneira para iterar os valores.
tipos de coleções especializadas também podem fornecer outros meios para a adição e leitura de valores. Para
exemplo, o tipo Stack (definido no namespace System.Collections) fornece métodos, como
Push e Pop, para realizar operações que sejam apropriadas para a estrutura de dados pilha.

O Visual Basic. NET Runtime possui um tipo chamado Collection (definido no Microsoft.VisualBasic
namespace) que imita o comportamento de Visual Basic 6 coleções e expõe o ICollection
interface. Exemplo 2-1 mostra a sua utilização.

Exemplo 2-1. Usando o tipo de coleção
'Criar um objeto de coleção nova.
Dim col Como nova coleção ()

"Dê alguns itens à coleção.
col.Add ("um valor")
col.Add ("outro valor")
col.Add ("Um terceiro valor")

'Iterar na coleção e saída das cordas.
Dim obj As Object
Para cada obj Em col
   Dim str As String = CType (String, obj)
   Console.WriteLine (str)
Seguinte

O tipo de método de coleta de Add adiciona itens à coleção. Embora as seqüências são adicionados ao
coleta no Exemplo 2-2, o método Add é definido para pegar itens do tipo Object, o que significa que qualquer
tipo pode ser passado para o método. Depois que os itens são adicionados à coleção, que pode ser iterado usando
o For Each (discutido mais tarde neste capítulo, sob a Secção 2.13). Porque o
classe Collection é definida para armazenar itens do tipo Object, a variável do laço na instrução For Each
deve ser do tipo Object. Como os itens são na verdade cordas, o código no Exemplo 2-1 converte o
As referências de objetos com referências String usando a função CType. As conversões de tipo são discutidos mais tarde
nesta seção. A saída do código no Exemplo 2-1 é:




35
 



Alguns valor
Algum outro valor
Um terceiro valor

Os itens em um objeto de coleção também pode ser iterado usando um índice numérico. O objeto Collection
possui uma propriedade Count que indica o número de itens na coleção. Exemplo 2-2 é precisamente
o mesmo caso do exemplo 2-1, exceto que itera através da coleção de objetos usando um modelo numérico
índice e um padrão de ciclo.

Exemplo 2-2. Usando um índice numérico em um objeto de coleção
'Criar um objeto de coleção nova.
Dim col Como nova coleção ()
"Dê alguns itens à coleção.
col.Add ("um valor")
col.Add ("outro valor")
col.Add ("Um terceiro valor")
'Iterar na coleção e saída das cordas.
Dim i As Integer
Para i = 1 To col.Count
   Dim str As String = CType (col (i) String)
   Console.WriteLine (str)
Seguinte

Note que para acessar um item do índice, o número de índice é colocado entre parênteses após o
nome da variável de referência Collection, como mostra aqui novamente:

col (i)

A sintaxe do método Add é:

Sub Público Add (_
   ByVal
Item As Object, _
   Opcional ByVal
Chave Como nada String = _
   Opcional ByVal
Antes Nada Como Object = _
   Opcional ByVal
Após Nada como objeto = _
)

Os parâmetros são:

Item

O item a ser adicionado à coleção.

Key

Um valor string opcional que pode ser usado como um índice para recuperar o item associado. Para
exemplo, o código a seguir adiciona um item a uma coleção e, em seguida, utiliza o valor de chave para
recuperar o item:

Dim col Como nova coleção ()
col.Add ("algum valor", "Alguns chave")


36
 



'...
 
NET Programação Visual Basic.
 
Dim str As String = CType (col ("Some-chave") String)
Console.WriteLine (str)

A saída é:

Alguns valor
Antes

O item antes que o novo item deve ser adicionada.

Depois

O item após o qual o novo item deve ser adicionada.

O. NET Framework fornece vários tipos de coleções adicionais, que são listados e
brevemente discutidos no Capítulo 3.

2.5.5 Conversões de Tipo

Visual Basic. NET fornece uma variedade de maneiras para que os valores de um tipo a ser convertido em valores de
outro tipo. Existem duas categorias principais de conversões: conversões alargamento e estreitamento
conversões. Alargar as conversões são conversões em que não há possibilidade de perda de dados ou
resultados incorretos. Por exemplo, converter um valor do tipo inteiro para um valor do tipo Long é uma ampliação
conversão, porque o tipo de Long pode receber todo o valor possível do tipo Integer.
Estreitando é o inverso operação de conversão de um longo para um número inteiro, pois alguns valores de
tipo Long não pode ser representada como valores do tipo Integer.

Visual Basic. NET executa alargamento conversões automaticamente sempre que necessário. Por exemplo, um
ampliação conversão ocorre na segunda linha do código a seguir. O valor inteiro no
lado direito da atribuição é automaticamente convertido para um valor Long para que ele possa ser armazenado no
variável b:

Dim a As Integer = 5
Dim b As Long = a

Uma conversão que acontece automaticamente é chamado de conversão implícita.

Agora considere a situação inversa:

Dim a As Long = 5
Dim b As Integer = a

A segunda linha de código aqui tenta executar uma conversão de restrição implícita. Se o
compilador permite que essa linha de código depende do valor definido para a opção de compilador Option Strict.
Quando Option Strict é On, tenta executar uma conversão implícita resultado ampliação em um compilador
erro. Quando Option Strict é Off, o compilador adiciona automaticamente o código por trás das cenas
executar a conversão. Durante a execução, se o valor real que está sendo convertido está fora do intervalo que pode ser
representado pelo tipo de alvo, uma exceção de tempo de execução ocorre.

Option Strict pode ser definido de duas maneiras. Primeiro, ela pode ser definida no código na parte superior de um arquivo de origem,
como este:

Option Strict On
'...



37
 
 



ou:

Option Strict Off
'...

A outra maneira é definir uma opção de compilador, que afeta todos os arquivos de origem no pedido. Se você está
compilação da linha de comando, especifique / optionstrict + na linha de comando para definir a opção
Strict On.
Precisar / optionstrict para definir Option Strict Off. Por exemplo:

MySource.vb vbc / optionstrict +

Para definir Option Strict no Visual Studio.
NET:

1. Botão direito do mouse sobre o nome do projeto na janela Solution Explorer e escolha Propriedades. Este
Projeto traz a caixa de diálogo Property Pages. (Se a janela Solution Explorer não estiver visível,
escolha Exibir Solution Explorer do Visual Studio. NET menu principal para fazê-la aparecer.)
2. Dentro da caixa de diálogo Project Property Pages, escolha a pasta de propriedades comuns. Dentro
Nessa pasta, escolha a página de propriedade de compilação. Isso faz com que o projeto-build opções para aparecer na
do lado direito da caixa de diálogo.
3. Defina o valor desejado para a opção Option Strict.

Por padrão, Option Strict é Off, o que significa que implícito conversões redutoras são permitidos. Este
corresponde à configuração padrão do Visual Basic 6. No entanto, os desenvolvedores mais experientes consideram
benéfico para definir Option Strict On assim o compilador pode ajudar a detectar erros de codificação antes
tornam-se erros de execução. A tentativa de atribuir um Long para um número inteiro, por exemplo, é geralmente um sinal ou
de que algo foi digitado incorretamente ou que há um problema com a concepção do programa. Ambiente
Option Strict On ajuda o desenvolvedor descobrir esses erros em tempo de compilação. Por outro lado,
Pode haver uma necessidade legítima de realizar uma conversão de restrição. Talvez a aplicação
é uma interface para outra aplicação que passa um valor como uma longa, mas é garantido que o real
valor passado nunca vai estar fora do alcance do tipo inteiro. Option Strict poderia ser definido como Off
para permitir conversões redutoras implícita, mas a melhor alternativa é ter Option Strict On (por isso
pode proteger a maior parte do programa) e para especificar uma conversão de restrição explícita. Por exemplo:

Dim a As Long = 5
Dim b Como Integer = CInt (a)

Isso é conhecido como uma conversão explícita porque o programador explicitamente solicitando uma conversão
para Integer. Se em um tempo de execução contém um valor que está fora do intervalo inteiro, uma exceção é lançada.

A Tabela 2-3 mostra as funções do Visual Basic. NET é a conversão.


Tabela 2-3. As funções de conversão
 

CBool
CByte
CCHAR
CDate
CDbl
CDec
CInt
CLng
CObj



38
 
função de conversão
 

Um booleano
Um Byte
Um Char
A Data
Um casal
Um Decimal
Um inteiro
A Long
Um Object
 
Converte seu argumento em
 
 



CSng
CStr
 
NET Programação Visual Basic.


Um único
Um String
 

As funções mostradas na Tabela 2-3 todos têm um único argumento. Se o argumento não pode ser convertido em
o tipo de dado, uma exceção é lançada. Observe o seguinte:

• Quando a conversão de qualquer valor numérico para Boolean, zero converte para False e diferente de zero
converte para True.
• Ao converter de Boolean para um valor numérico, False converte a 0 e converte True para
-1.
• Ao converter de String para Boolean, seqüência de caracteres deve conter a palavra "false",
que se converte em falso, ou a palavra "true", que se converte em verdade. O caso da cadeia
não é importante.
• Ao converter de String para Boolean, True se converte em "True" e False se converte em
"Falso".
• Qualquer coisa pode ser convertido para o tipo Object.

Também é possível converter entre tipos de referência. Qualquer referência a objeto de conversão de um derivado
tipo para um tipo de base é considerada uma conversão de expansão e pode ser feito de forma implícita.
Por outro lado, a conversão de um tipo de base para um tipo derivado é uma conversão de restrição. Como anteriormente
discutido, para o estreitamento de conversões de compilar, ou Option Strict deve estar desligado ou uma
conversão explícita deve ser realizada. Conversões explícitas de tipos de referência são feitas com o
CType função. A função CType tem dois argumentos. O primeiro é uma referência a algum objeto, e
o segundo é o nome do modelo no qual a referência será convertido. Em tempo de execução, se a conversão for
possível, o valor de retorno da função é uma referência de objeto do tipo apropriado. Se não
conversão é possível, uma exceção é lançada.

Aqui está um exemplo de conversão entre base e classes derivadas:

"Esta é uma classe base.
Público classe Animal
   '...
End Class

"Esta é uma classe derivada.
Público Cat Class
   Herda Animal
   '...
End Class
"Esta é uma outra classe derivada.
Público classe Dog
   Herda Animal
   '...
End Class

"Esta é uma classe de teste.
Público AnimalTest Classe
   Public Shared Sub SomeMethod ()
      Dim myCat As New Cat ()
      Dim myDog As New Dog ()
      Dim myDog2 Como cão
      Dim myAnimal Como conversão Animal myCat = 'implícita OK
      conversão myDog myAnimal = 'implícita OK
      myDog2 = CType (myAnimal, cão) «conversão explícita exigida
   End Sub
End Class



39
 
 



As referências de objeto também pode ser convertido implicitamente em qualquer interface exposta pela classe do objeto.

2,6 Namespaces

Milhares de tipos são definidos no. NET Framework. Além disso, os programadores podem definir novas
tipos para uso em seus programas. Com tantos tipos, os confrontos são inevitáveis nome. Para evitar que o nome
confrontos, os tipos são considerados a residir dentro de namespaces. Muitas vezes, este fato pode ser ignorado. Para
. Exemplo, no Visual Basic NET uma classe pode ser definida assim:

Classe someClass Pública
   '...
End Class

Esta definição de classe pode estar em uma biblioteca de classes usadas por clientes de terceiros, ou pode ser na
mesmo arquivo ou o mesmo projeto do código do cliente. O código do cliente que usa essa classe pode parecer
algo parecido com isto:

Dim x As someClass New ()
x.DoSomething ()

Agora considere o que acontece se o cliente de terceiros também adquire biblioteca de classe de outro fornecedor,
que também expõe uma classe someClass. O Visual Basic. NET não é possível saber qual a definição de
SomeClass será usado. O cliente deve usar o nome completo do modelo, também conhecida como a sua plena
nome qualificado. Código que precisa usar os dois tipos pode ser algo parecido com isto:

"O espaço é" FooBarCorp.SuperFoo2100 ".
Dim x As FooBarCorp.SuperFoo2100.SomeClass New ()
x.DoSomething ()
'...
"O espaço é" MegaBiz.ProductivityTools.WizardMaster ".
Dim y Como MegaBiz.ProductivityTools.WizardMaster.SomeClass New ()
y.DoSomethingElse ()

Note-se que um nome de namespace pode conter próprio pontos (.). Ao olhar para um tipo totalmente qualificado
nome, tudo antes do prazo final é o nome do namespace. O nome após o período final
o nome do tipo.

Microsoft recomenda que os namespaces ser nomeado de acordo com o formato
CompanyName.TechnologyName. Por exemplo, "Microsoft.VisualBasic".

2.6.1 A Declaração do Namespace

Então como é que um desenvolvedor de componentes especificar um tipo de espaço? No Visual Basic. NET, isso pode ser
feito de várias maneiras. Uma delas é utilizar a palavra-chave namespace, como este:

Namespace MegaBiz.ProductivityTools.WizardMaster

   Classe someClass Pública
      '...
   End Class
End Namespace

Observe que é permitido para tipos diferentes no mesmo arquivo de origem para ter espaços diferentes.





40
 
NET Programação Visual Basic.


Uma segunda maneira de proporcionar um espaço de nomes é usar a opção / rootnamespace no Visual
Basic. NET linha de comando. Por exemplo:

src.vb vbc / t: library / rootnamespace: MegaBiz.ProductivityTools.WizardMaster

Todos os tipos definidos dentro do arquivo compilado (s), então, o espaço dado.

Se você está compilando no Visual Studio. NET IDE, o namespace raiz é especificado no Projeto
Caixa de diálogo Property Pages, que pode ser alcançado pelo botão direito do mouse no nome do projeto na solução
Explorer da janela do IDE, em seguida, escolha Properties (veja a Figura 2-1 para o wizardmaster resultando
Diálogo Property Pages). Por padrão, o Visual Studio. NET define o namespace raiz igual ao nome do
o projeto.

Figura 2-1. Definir o namespace raiz no Visual Studio. NET























Note-se que, independentemente de qual compilador é utilizado (linha de comando ou Visual Studio. NET), se uma raiz
namespace é especificado e palavra-chave namespace é usada, o espaço resultante será o
concatenação do nome do namespace raiz eo nome especificado usando a palavra-chave namespace.

2.6.2 A Declaração Imports

Até agora, a discussão tem implicado que não é necessário que o usuário de um tipo para especificar o tipo de cheia
nome a menos que há um conflito de nome. Isso não é exatamente verdade. Os negócios com os tipos CLR só em termos de
seus nomes completos. No entanto, porque os seres humanos não gostam de lidar com nomes longos, Visual Basic. NET
oferece um atalho. Como exemplo, o. NET Framework fornece uma biblioteca de desenho, em que um tipo
chamado ponto está definida. namespace Este tipo é chamado de System.Drawing, assim do tipo totalmente qualificado
nome é System.Drawing.Point. O código que usa este tipo pode ter este aspecto:

Dim PT como System.Drawing.Point
pt.X 10 =
pt.Y 20 =
'...

Digitando o nome completo de cada tipo sempre que é utilizado seria muito complicado, embora, assim Visual
Basic. NET oferece a instrução Imports. Essa declaração indica para o compilador que os tipos de
um determinado espaço para nome aparecerá sem qualificação no código. Por exemplo:



41
 



"No topo do arquivo de código fonte:
Imports System.Drawing
'...
'Em algum lugar dentro do arquivo de código-fonte:
Dim PT como ponto
pt.X 10 =
pt.Y 20 =
'...

Para importar vários espaços de nomes, a lista de cada um na sua própria instrução Imports. Tudo bem se múltiplas
namespaces importados têm alguns conflitos de nomes. Para os tipos cujos nomes confronto, o nome completo
deve ser especificado sempre que o tipo é usado.

A declaração Imports é apenas uma conveniência para o desenvolvedor. Não defina uma referência para o
assembléia em que os tipos são definidos. Veja a discussão de montagens no Capítulo 3 para aprender
referência aos conjuntos que contêm os tipos que você precisa.

Finalmente, note que namespaces, também, são apenas uma conveniência para o desenvolvedor de escrever código fonte. Para
o tempo de execução, um tipo não é "em" um espaço de nomes de namespace é apenas uma outra parte de um nome do tipo. É
perfeitamente aceitável para qualquer conjunto dado a ter em namespaces diferentes tipos, e mais
uma assembléia pode definir os tipos em um único espaço para nome.

2,7 constantes simbólicas

Considere esta função:

Função Pública RemainingCarbonMass compartilhados (_
   ByVal InitialMass Como casal, _
   Anos ByVal _ Long
) As Double
   * Retorno InitialMass ((0,5 ^ (Anos / 5730)))
End Function

O que há de errado com esse código? Um problema é a legibilidade. O que significa a dividir por 5730 anos?
Nesse código, 5730 é conhecido como um número mágico - cujo sentido não é facilmente visível a partir
examinar o código. As seguintes alterações corrigir esse problema:

CarbonHalfLifeInYears Const Pública As Double = 5730

Função Pública RemainingCarbonMass compartilhados (_
   ByVal InitialMass Como casal, _
   Anos ByVal _ Long
) As Double
   * Retorno InitialMass ((0,5 ^ (Anos / CarbonHalfLifeInYears)))
End Function

Agora não há ambigüidade sobre o significado do divisor.

Outro problema com o primeiro fragmento de código é que um programa repleto de tal código é difícil de manter.
E se o programador descobre mais tarde que a meia-vida do carbono é mais perto de 5730,1 anos, e ela
quer fazer o programa mais precisa? Se este número é usado em muitos lugares em todo o
programa, deve ser mudado em cada caso. O risco é alto de um caso de falta ou de alteração de um número
que não deve ser alterado. Com o segundo fragmento de código, o número precisa ser mudado em apenas
um só lugar.

Veja também a discussão dos campos de leitura e só mais tarde neste capítulo, na secção 2.14.




42

2,8 Variáveis
 
NET Programação Visual Basic.
 

Uma variável é um identificador que é declarado em um método e que representa um valor dentro desse método.
Seu valor é permitida a mudança no método. Cada variável é de um tipo específico, e que tipo é
indicada na declaração da variável. Por exemplo, esta linha declara uma variável chamada i, cuja
tipo é Integer:

Dim i As Integer

A palavra-chave Dim indica uma declaração da variável. Dim é curto para a dimensão e remonta ao
dia original da linguagem de programação BASIC no final dos anos 1960. Nessa linguagem, as variáveis foram
não declarados, eram utilizados apenas quando necessário (exceto para matrizes). Devido à forma como as matrizes foram definidas
na memória, o interpretador da linguagem BASIC tinha que ser dito das dimensões de uma matriz antes da
matriz foi usado. Este foi o objetivo da declaração Dim. Nos anos posteriores, se a declaração de todos os
variáveis foi acordado para ser uma coisa boa, o uso da instrução Dim foi ampliado para incluir
todas as declarações de variáveis.

identificadores de variáveis podem ser terminam com caracteres de tipo, que servem para indicar o tipo da variável. Para
exemplo, esta linha declara uma variável do tipo Integer:

Dim x%

O efeito é exatamente o mesmo que para esta declaração:

Dim x inteiro como

O conjunto de caracteres de tipo é mostrada na Tabela 2-4, nota que nem todos os tipos de dados têm um tipo de personagem.


Tabela 2-4. Escreva os caracteres
 
Tipo de dados
Decimais
Duplo
Inteiro
Long
Único
String
 

@
#
%
&
!
$
 
Tipo de caráter
 
Exemplo
Dim decValue @ = 132,24
Dim dblValue # = 0,0000001327
Dim% iCount = 100
Dim lLimit = 1000000 &
Dim sngValue! = 3,1417
Dim strInput $ = ""
 

Por uma questão de estilo, os caracteres do tipo devem ser evitadas em detrimento de soletrar nomes de tipo e
usando nomes de variáveis descritivos.

2.8.1 Inicializadores Variável

Novo no Visual Basic. NET é a capacidade de combinar declaração da variável e atribuição. Por exemplo,
Esse código declara um inteiro i e lhe dá um valor inicial de 10:

Dim i As Integer = 10

Isso é equivalente ao seguinte código:

Dim i As Integer
i = 10



43
 
 



2,9 Âmbito

Escopo refere-se à visibilidade chamados de identificadores no código fonte. Ou seja, dado um particular
identificador de declaração, o âmbito do identificador determina que ela é legal para fazer referência a esse identificador
no código. Por exemplo, essas duas funções, cada CoffeeBreaks declarar uma variável. Cada declaração
é invisível para o código no outro método. O escopo de cada variável é o método em que é
declarou.

Público MyFirstMethod Sub ()
   CoffeeBreaks Dim Inteiro
   '...
End Sub

Público MySecondMethod Sub ()
   CoffeeBreaks Dim Long
   '...
End Sub

Ao contrário das versões anteriores do Visual Basic, Visual Basic. NET tem o escopo de bloco. Variáveis declaradas dentro
um conjunto de instruções que terminam com End, Loop, ou Próximo são locais para essa categoria. Por exemplo:

Dim i As Integer
Para i = 1 a 100
   Dim j As Integer
   Para j = 1 a 100
      '...
   Seguinte
Seguinte
J 'não é visível aqui

Visual Basic. NET não permite o mesmo nome de variável deve ser declarado, tanto a nível de método e
nível do bloco. Além disso, a vida da variável nível de bloco é igual à vida do método. Isso significa que
que se o bloco é re-inserido, a variável pode conter um valor antigo (não contar com esse comportamento, pois
não é garantida e é o tipo de coisa que pode mudar em futuras versões do Visual Basic).

2,10 Modificadores de acesso

modificadores de controle de acesso a acessibilidade dos tipos (incluindo enumerações, estruturas, classes,
módulos-padrão, e delegados) e membros de tipo (incluindo os métodos, construtores, eventos,
constantes, campos de dados [membros], e as propriedades) de outros elementos do programa. Eles fazem parte da
declarações de tipos e membros tipo. No seguinte fragmento de código, por exemplo, as palavras-chave
Públicos e privados são modificadores de acesso:

Classe someClass Pública

   Público DoSomething Sub ()
      '...
   End Sub

   InternalHelperSub Private Sub ()
      '...
   End Sub

End Class

A lista completa dos modificadores de acesso e seus significados é mostrada na Tabela 2-5.




44
 






Acesso
modificador
Amigo

Privado
 
NET Programação Visual Basic.



Tabela 2-5. modificadores de acesso
Descrição
Define um tipo que só é acessível a partir do programa em que é declarada.
Define um tipo que só é acessível de dentro do contexto em que é declarada.
Por exemplo, uma variável declarada privados dentro de um módulo de classe só é acessível a partir de
dentro desse módulo de classe. A aula particular é acessível apenas a partir de classes em que se
está aninhado.
 
Aplica-se aos membros protegidos da classe única. Define um tipo que só é acessível de dentro de sua
 
Protegidas
Amigo
Público
 
própria classe ou de uma classe derivada.
Define um tipo que é acessível a partir do programa em que é declarada como bem
a partir de classes derivadas.
Define um tipo que é acessível ao público. Por exemplo, um método público de uma classe pode
ser acessado de qualquer programa que instancia dessa classe.
 

Atribuição 2,11

. No Visual Basic NET, declarações de atribuição são da forma:

variável,
campo, ou
property =
expressão

Ou o tipo de expressão deve ser a mesma que a do item a receber a cessão ou
deve existir uma adequada conversão implícita ou explícita do tipo de expressão para o
tipo de item de receber a missão. Para obter informações sobre conversões implícitas e explícitas, consulte
Secção 2.5.5, anteriormente neste capítulo.

Quando um trabalho é feito para um tipo de valor, o valor da expressão é copiado para o destino. Em
contraste, quando uma atribuição é feita para um tipo de referência, uma referência para o valor está armazenado na
alvo. Esta é uma distinção importante que é digno de se entender bem. Considere o código no Exemplo
2-3.

Exemplo 2-3. atribuição de valor versus tipo de atribuição de referência do tipo
Público SomeStructure Estrutura
   Público MyPublicMember As String
Fim Estrutura
Classe someClass Pública
   Público MyPublicMember As String
End Class
Público AssignmentTest Classe

   Public Shared Sub TestValueAndReferenceAssignment ()

      Dim a, b Como SomeStructure
      Dim c, d Como someClass

      'Teste de atribuição para tipo de valor.
      a.MyPublicMember = "Para ser copiado para 'b'"
      b = a
      a.MyPublicMember = "Novo valor para 'a'"
      Console.WriteLine ("O valor da b.MyPublicMember é" "" _


45
 
 



         & & B.MyPublicMember """")

      'Teste de atribuição para o tipo de referência.
      c someClass = Novo ()
      c.MyPublicMember = "Para ser copiado para 'd'"
      d = c
      c.MyPublicMember = "Novo valor para 'c'"
      Console.WriteLine ("O valor da d.MyPublicMember é" "" _
         & & D.MyPublicMember """")

   End Sub

End Class

A saída do método TestValueAndReferenceAssignment no Exemplo 2-3 é:

O valor da b.MyPublicMember é "Para ser copiado para 'b'"
O valor da d.MyPublicMember é "Novo valor para 'c'"

No Exemplo 2-3, a estrutura SomeStructure ea classe someClass têm definições idênticas,
exceto que uma é uma estrutura e outra é uma classe. Isso leva a um comportamento muito diferente durante
atribuição. Quando um tipo de valor é copiado, o valor real é copiado. Quando um tipo de referência é copiada,
apenas a referência é copiada, resultando em duas referências para o mesmo valor. Se o valor for posteriormente
alterados através de uma das referências, o novo valor também é visto através da referência de outros.

Essa diferença é mostrada na saída do Exemplo 2-3. O tipo de valor em uma variável é copiada para
variável b. O valor da a.MyPublicMember é então modificada. Posteriormente, a chamada para
Console.WriteLine mostra que esta alteração não afecta b.MyPublicMember. Em contraste, o
atribuição de c para d cópias apenas uma referência, o que significa que, após a atribuição, ambos c e d
referência o mesmo objeto. O valor da c.MyPublicMember é então modificada. A chamada subseqüente
para Console.WriteLine mostra que essa modificação afetou d.MyPublicMember. Na verdade,
d.MyPublicMember refere-se a mesma memória que c.MyPublicMember.

2,12 Operadores e expressões

Operadores são símbolos (caracteres ou palavras-chave) que especificam as operações a serem executadas em um ou dois
operandos (ou argumentos). Os operadores que usam um operando são chamados operadores unários. Os operadores que
dois operandos são chamados de operadores binários. Os operadores unários usar a notação de prefixo, o que significa que o
operador precede o operando (por exemplo, -5). operadores binários (com exceção de um caso) notação infixa utilização,
o que significa que o operador está entre os operandos (por exemplo, 1 + 2). O TypeOf ... É o operador é um
operador binário, que usa uma forma especial que não é nem o prefixo notação infixa.

2.12.1 Os operadores unários

Visual Basic suporta os seguintes operadores unários:

+ (Mais unário)

O operador unário mais leva algum operando numérico. Não é de grande utilidade prática, porque
o valor da operação é igual ao valor do operando.

- (Menos unário)

O operador unário menos tem qualquer operando numérico (exceto como observado mais adiante). O valor da
operação é o negativo do valor do operando. Em outras palavras, o resultado é calculado por
subtraindo-se o operando a partir de zero. Se o tipo de operando é Short, Integer, ou Long, eo valor


46
 
NET Programação Visual Basic.


do operando é o valor máximo negativo para esse tipo, em seguida, aplicar o menos unário
operador irá causar um erro OverflowException, como no seguinte fragmento de código:

Dim sh As Short = -32768
Dim i As Integer = sh-
Não (negação lógica)

O operador lógico de negação leva um operando booleano. O resultado é a negação lógica de
o operando. Ou seja, se o operando é falso, o resultado da operação é verdade, e vice-
versa.

AddressOf

O operador AddressOf retorna uma referência para um método. Dois tipos diferentes de referências
pode ser obtido, dependendo do contexto em que o operador é usado:

• Quando o operador AddressOf é usado dentro da lista de argumentos de uma chamada para um método,
que é disponibilizado através da instrução Declare, ele retorna um ponteiro de função que
é apropriado para essas chamadas.
• Quando o operador AddressOf é usado em qualquer outro contexto, um objeto de delegação é
devolvido. Consulte a Secção 2,19 mais adiante neste capítulo para obter informações.

2.12.2 Operadores aritméticos

Os operadores aritméticos executam operações aritméticas padrão em valores numéricos. A aritmética
. Operadores suportados pelo Visual Basic NET são:

* (Multiplicação)

O operador de multiplicação é definida para todos os operandos numéricos. O resultado é o produto da
operandos.

/ (Divisão regular)

O operador de divisão regular é definido para todos os operandos numéricos. O resultado é o valor da
primeiro operando dividido pelo segundo operando.

\ (Divisão inteira)

O operador de divisão inteira está definido para operandos inteiros (Byte, Short, Integer e Long).
O resultado é o valor do primeiro operando dividido pelo segundo operando, e arredondadas para a
número inteiro mais próximo de zero.

Mod (modulo)

O operador de módulo é definido para operandos inteiros (Byte, Short, Integer e Long). A
resultado é o resto depois da divisão inteira dos operandos.

^ (Exponenciação)

O operador de exponenciação definido para operandos do tipo Double. Operandos de outros
tipos numéricos são convertidos para o tipo de casal que o resultado é calculado. O resultado é a
valor do primeiro operando elevado à potência do segundo operando.

+ (Adição)



47
 



O operador de adição é definida para todos os operandos numéricos e os operandos de um tipo enumerado.
O resultado é a soma dos operandos. Para tipos enumerados, a soma é calculado sobre o
tipo subjacente, mas o tipo de retorno é o tipo enumerado. Veja a discussão sobre enumerados
tipos na "Enumerações" mais adiante neste capítulo, para obter mais informações sobre os tipos que
podem estar subjacentes a um tipo enumerado. Veja também a Seção 2.12.4 posteriormente nesta seção.

- (Subtração)

O operador de subtração está definida para todos os operandos numéricos e os operandos de um enumerado
tipo. O resultado é o valor do primeiro operando menos o segundo operando. Para enumerado
tipos, a subtração é calculada sobre o tipo subjacente, mas o tipo de retorno é o
tipo enumerado. Veja a discussão sobre tipos enumerados no ponto 2.17, mais adiante neste
capítulo para obter mais informações sobre os tipos que podem estar subjacentes a um tipo enumerado.

2.12.3 Os operadores relacionais

Os operadores relacionais todos desempenham alguma comparação entre dois operandos e retornam um valor booleano
valor indicando se os operandos satisfazem a comparação. Os operadores relacionais suportados pelo
. Visual Basic NET são:

= (Igualdade)

O operador de igualdade é definida para todos os tipos de valores primitivos e todos os tipos de referência. Para
tipos de valores primitivos e para o tipo String, o resultado é verdadeiro se os valores dos operandos
são iguais, False se não. Para tipos de referência diferente String, o resultado é True se o
referências se referem ao mesmo objeto; False se não. Se os operandos são do tipo Object e
tipos primitivos valor de referência, a comparação de valor é realizada em vez de referência
comparação.

<> (Desigualdade)

O operador de desigualdade é definido para todos os tipos de valores primitivos e tipos referência. Para
tipos de valores primitivos e para o tipo String, o resultado é verdadeiro se os valores dos operandos
não forem iguais, False se iguais. Para tipos de referência diferente String, o resultado é True se o
referências se referem a objetos diferentes, False se referem ao mesmo objeto. Se os operandos forem
do tipo Object e eles fazem referência tipos de valores primitivos, a comparação de valor é realizada em vez
de comparação de referência.

<(Menor que)

O operador menor do que é definido para todos os operandos numéricos e os operandos de um enumerado
tipo. O resultado é Verdadeiro se o primeiro operando é menor que o segundo, False se não. Para
tipos enumerados, a comparação é feita com o tipo subjacente.

> (Maior que)

O operador maior do que é definido para todos os operandos numéricos e os operandos que são de uma
tipo enumerado. O resultado é Verdadeiro se o primeiro operando é maior que o segundo; False se
não. Para tipos enumerados, a comparação é feita com o tipo subjacente.

<= (Menor ou igual a)

As menos-que-ou-igual-para operador é definido para todos os operandos numéricos e os operandos de uma
tipo enumerado. O resultado é Verdadeiro se o primeiro operando é menor ou igual ao segundo
operando; False se não.



48
 



> = (Maior ou igual a)
 
NET Programação Visual Basic.
 

O maior-ou-igual-para operador é definido para todos os operandos numéricos e os operandos de uma
tipo enumerado. O resultado é Verdadeiro se o primeiro operando é maior ou igual ao segundo
operando; False se não.

TypeOf ... É

O TypeOf ... É o operador é definido para ter uma referência como o primeiro parâmetro eo nome
de um tipo como segundo parâmetro. O resultado é True se a referência remete a um objeto que é
tipo compatível com o determinado tipo de nome; False se a referência for Nothing ou se ele se refere à
um objeto que não é de tipo compatível com o nome de determinado tipo.

Use o TypeOf ... É o operador para determinar se um determinado objeto:

• É uma instância de uma determinada classe
• É uma instância de uma classe que é derivado de uma determinada classe
• Expõe uma determinada interface

Em qualquer destes casos, a expressão retorna True TypeOf.

É

O operador Is é definida para todos os tipos de referência. O resultado é True se as referências referem-se a
o mesmo objeto; False se não.

Gosto

O operador Like é definido apenas para operandos do tipo String. O resultado é Verdadeiro se o primeiro
operando correspondem ao padrão dado no segundo operando; False se não.

As regras de correspondência são:

• A? (Interrogação) caracteres corresponde a qualquer caractere único.
• O * (asterisco) caractere corresponde a zero ou mais caracteres.
• O caractere # (número de sinal) corresponde a qualquer dígito.
• Uma seqüência de caracteres entre [] (colchetes) corresponde a qualquer caractere único em
a seqüência.

Dentro dessa lista entre colchetes, dois caracteres separados por um - (hífen) significa uma grande
de caracteres Unicode, começando com o primeiro caractere e terminando com a segunda
personagem. A - personagem em si pode ser igualada por colocá-lo no início ou no final de
a seqüência entre colchetes.

Precedendo a seqüência de caracteres com um! (Exclamação) caracteres
corresponde a qualquer caractere único que não aparece na seqüência.

• A?, *, #, E [os personagens podem ser encontrados, colocando-os dentro de [] no padrão
string. Por conseguinte, não pode ser usada em seu sentido universal dentro de [].
• A personagem] não precisa ser escapado de ser explicitamente correspondido. No entanto, ele
não pode ser usado dentro de [].






49
 
 



2.12.4 Os operadores de concatenação de String-

O & (e comercial) e + (plus) caracteres significa concatenação. concatenação de string é
definido para operandos do tipo String só. O resultado é uma seqüência que consiste em os personagens do
primeiro operando seguido pelos personagens do segundo operando.

2.12.5 Bitwise

Às vezes é necessário para manipular os bits individuais que compõem um valor de um inteiro
tipos (Byte, Short, Integer e Long). Este é o objetivo dos operadores bit a bit. Eles são definidos
para os quatro tipos inteiros e de tipos enumerados. Quando os operadores bit a bit são aplicadas a
tipos enumerados, a operação é feita do tipo de base, mas o resultado é dos enumerados
tipo.

O trabalho dos operadores bit a bit, aplicando a operação booleana dada a cada um dos bits correspondentes
nos dois operandos. Por exemplo, considere esta expressão:

37 E 148

Para calcular o valor dessa expressão, considera a representação binária de cada operando. É
útil escrever um sobre o outro de modo que a linha de bit colunas acima:

00100101 (37)
10010100 (148)

Em seguida, aplique o Boolean e funcionamento para os bits em cada coluna:

       00100101 (37)
10010100 e (148)
--------
       00000100 (4)

37 e 148, portanto, é igual a 4.

Os operadores bit a bit são:

E

Executa uma operação booleana AND sobre os bits. (O pouco resultado é 1 se e somente se ambas as
bits de origem são: 1.)

AndAlso

O resultado é True se e somente se ambos os operandos são verdadeiros, caso contrário, o resultado é falso.
AndAlso realiza um curto-circuito lógico: se o primeiro operando da expressão é falso, o
segundo operando não será avaliado.

Ou

Executa uma operação booleana ou sobre os bits. (O resultado é um pouco se um ou ambos da fonte
bits são: 1.)

OrElse




50
 








Xor




Não
 
NET Programação Visual Basic.


O resultado é verdadeiro se um ou ambos os operandos é verdadeiro, caso contrário, o resultado é falso.
OrElse realiza um curto-circuito lógico: se o primeiro operando da expressão é True, o
segundo operando não será avaliado.



Executa uma operação booleana exclusiva ou sobre os bits. (O resultado é um pouco se uma das
bits é uma fonte, mas não ambos.)



Executa uma operação booleana Não é sobre os bits no operando. Este é um operador unário. (A
resultado é 1 se o bit de origem é 0 e 0 se o bit de origem é 1.)
 

2.12.6 Os operadores lógicos

Os operadores lógicos são operadores que necessitam de operandos booleanos. São eles:

E

O resultado é True se e somente se ambos os operandos são verdadeiros, caso contrário, o resultado é falso.

Ou

O resultado é verdadeiro se um ou ambos os operandos é verdadeiro, caso contrário, o resultado é falso.

Xor

O resultado é True se e somente um dos operandos for verdadeiro, caso contrário, o resultado é falso.

Não

Este é um operador unário. O resultado é Verdadeiro se o operando é falso e falso se o operador é
True.

2.12.7 Precedência de operador

precedência dos operadores define a ordem na qual os operadores são avaliados. Por exemplo, a expressão
1 + 2 * 3 tem o valor 9 se a adição é executada primeiro, mas tem o valor 7, se a multiplicação é
realizada em primeiro lugar. Para evitar tal ambigüidade, línguas deve definir a ordem na qual as operações são
avaliados. Visual Basic. NET divide os operadores em grupos e define a prioridade de cada grupo
em relação aos outros. Os operadores de maior precedência grupos são avaliados antes dos operadores na Baixa
grupos de precedência. Operadores dentro de cada grupo têm a mesma precedência em relação ao outro.
Quando uma expressão contém vários operadores de um único grupo, esses operadores são avaliados
da esquerda para a direita.

Tabela 2-6 mostra os operadores do Visual Basic. NET, agrupadas por prioridade maior para a menor ordem
de avaliação.


Tabela 2-6. A precedência dos operadores do Visual Basic. NET
 
Categoria
Aritmética e
 

Exponenciação
 
Operador
 





51
 
 



concatenação
 





Negação
A multiplicação e divisão
Divisão de inteiros
Módulo aritmético
Adição e subtração, concatenação (+)
String de concatenação (&)
 
Os operadores de comparação de igualdade, desigualdade, maior, menor, maior ou igual a menos
 
Lógicos e bit a bit
operadores
 
ou igual a, é, TypeOf, como
Negação (não)
Conjunção (E, AndAlso)
Disjunção (Ou, OrElse, Xor)
 

Parênteses substituir a ordem padrão de avaliação. Por exemplo, na expressão * 1 + 2 3, o
multiplicação é realizada antes da adição, gerando um valor de 7. Para executar a primeira adição, o
expressão pode ser reescrita como (1 + 2) * 3, gerando um resultado de 9.

2.12.8 Operator Overloading

Sobrecarga de operadores é um recurso que algumas linguagens (C #, por exemplo) fornecem para permitir que desenvolvedores
para especificar como o built-in operadores (+, -, *, /, =, etc) devem se comportar quando aplicado programador
tipos definidos. Por exemplo, o desenvolvedor de um tipo que representa números complexos poderiam usar o operador
sobrecarga para especificar a funcionalidade adequada para o built-in operadores aritméticos quando aplicada a
operandos do tipo personalizado.

O. NET Framework oferece suporte a sobrecarga de operador, mas. NET não são obrigados a fazê-lo.
A versão atual do Visual Basic. NET não suporta sobrecarga de operadores, embora não haja nenhuma
razão que a Microsoft não poderia adicioná-lo no futuro. Os componentes que são escritos em outras línguas podem
sobrecarga de operadores, mas o Visual Basic. NET não estará ciente das sobrecargas. Bem-concebidas
componentes fornecem um mecanismo alternativo para acessar a funcionalidade fornecida pelo
sobrecargas. Por exemplo, se um componente escrito em C # fornece uma classe que sobrecarrega o operador +, que
também deve fornecer um método que usa dois parâmetros e retorna a soma deles. Assim, o que seria
escrito como:

c = a + b

em uma linguagem que suporta a sobrecarga seria escrito como:

c MyCustomType.Add = (a, b)

NET no Visual Basic..

O nome do atual método dependeria executor do componente.

2,13 Demonstrações

Visual Basic. NET é uma linguagem orientada a linha, em que as quebras de linha geralmente indicam as extremidades dos
declarações. No entanto, há momentos em que um programador pode querer estender uma declaração sobre
várias linhas ou ter mais de uma instrução numa única linha.






52
 
 
NET Programação Visual Basic.


Para estender uma instrução em várias linhas, use o caractere de continuação de linha, um sublinhado (_). É
deve ser o último caractere em sua linha, e deve ser imediatamente precedido por um caractere de espaço.
Linhas conectados desta forma tornar-se uma única linha lógica. Aqui está um exemplo:

Dim strSQL As String = "SELECT Customers.CompanyName", _
   & "COUNT (Orders.OrderID) AS OrderCount" _
   & "FROM Clientes INNER JOIN Pedidos" _
   & "ON Customers.CustomerID = Orders.CustomerID" _
   & "GROUP BY Customers.CompanyName" _
   & "ORDER BY DESC OrderCount"

Uma quebra de linha só pode ocorrer em branco é permitida.

Para colocar duas ou mais instruções em uma única linha, use os dois pontos (:) entre as afirmações, como esta:

i = 5, j = 10

O restante desta seção discute as declarações em Visual Basic. NET.

2.13.1 As declarações Opção

Há três declarações de Opção, que afetam o comportamento do compilador. Se for utilizado, devem
aparecer antes de qualquer declaração no mesmo arquivo de origem. Eles controlam a compilação da fonte
código no arquivo em que eles aparecem. São eles:

Option Compare

A instrução Option Compare controla a maneira pela qual as seqüências são comparados uns com os
outras. A sintaxe é:

Option Compare [binários | Texto]

Se o binário é especificado, as seqüências são comparadas com base na sua representação binária interna (isto é,
comparações de string são case-sensitive). Se o texto for especificado, as seqüências são comparadas com base em
maiúsculas e minúsculas ordem alfabética. O padrão é binário.

Option Explicit

A declaração Option Explicit determina se o compilador requer que todas as variáveis para
ser declarado explicitamente. A sintaxe é:

Option Explicit [on | off]

Se está especificado, o compilador requer que todas as variáveis a serem declaradas. Se Desligado for especificado, o
compilador considera o uso de uma variável a ser uma declaração implícita. Ele é considerado bom
prática de programação para exigir declaração de variáveis. O padrão é Ativado.

Option Strict

A instrução Option Strict controla as conversões de tipo implícito que o compilador
permitir. A sintaxe é:

Option Strict [on | off]




53
 



Se está especificado, o compilador só permite conversões implícitas alargamento; conversões redutoras devem
ser explícita. Se fora está especificado, o compilador permite conversões redutoras implícita também. Isso pode
resultar em exceções de tempo de execução não previstas pelo dono da obra. É considerada uma boa programação
a exigir a verificação de tipo estrito. O padrão é Desligado.

Veja Seção 2.5.5, anteriormente neste capítulo para as definições de conversões estreitamento e alargamento.

2.13.2 As declarações de ramificação

Visual Basic. NET suporta um número de ramificações declarações que interrompem o fluxo seqüencial de
execução do programa e sim permitir que ela para saltar de uma parte de um programa para outro. Estes podem
ser instruções condicionais (como se ou Select Case) ou incondicional (como chamadas e
Exit).

2.13.2.1 Call

A declaração Call chama uma subrotina ou função. Por exemplo:

Call SomeMethod ()

Ao terminar o chamado sub-rotina ou função, a execução continua com a seguinte declaração do
Call comunicado. Se a função é invocada, o valor de retorno da função é descartado.

A instrução Call é redundante porque sub-rotinas e funções pode ser chamado simplesmente por
nomeá-los:

SomeMethod ()

2.13.2.2 Sair

A declaração de saída faz a execução sair do bloco em que a declaração de saída aparece. É
geralmente usados para prematuramente sair de um loop ou procedimento quando alguma condição incomum ocorre.

A declaração de saída deve ser evitado quando possível, porque prejudica a estrutura da
bloco no qual ela aparece. Por exemplo, as condições de saída de um loop deve ser imediatamente
Resulta simplesmente por olhar para a instrução For. Não deve ser necessário ler através de toda a
loop para determinar se existem outras circunstâncias em que o loop pode sair. Se um dado para
loop realmente precisa de uma declaração Exit, investigar se construir um circuito diferente seria melhor
adequado para a tarefa. Se um determinado procedimento realmente precisa de uma declaração Exit, investigar se o
procedimento é consignado de forma adequada.

A declaração de saída tem uma forma diferente para cada tipo de bloco no qual ele pode ser usado, como listados a seguir:

Exit Do

Sai de um loop. A execução continua com a primeira instrução após a instrução Loop.

Para Sair

Sai de um loop For. A execução continua com a primeira instrução após a instrução Next.

Exit Function




54
 
NET Programação Visual Basic.


Sai uma função. A execução continua com a primeira instrução após a instrução que
chamou a função.

Exit Property

Sai uma propriedade get ou procedimento conjunto de propriedades. A execução continua com a primeira declaração
após a instrução que invocou a propriedade get ou procedimento conjunto de propriedades.

Exit Sub

Sai de uma rotina. A execução continua com a primeira instrução após a instrução que
chamou a subrotina.

Exit Try

Sai da cláusula try de um bloco Try. Se o bloco Try tem uma cláusula Finalmente, a execução
continua com a primeira instrução na cláusula Finally. Se o bloco Try não
Finalmente cláusula, a execução continua com a primeira instrução após o bloco Try.

2.13.2.3 Goto

A instrução Goto transfere a execução para a primeira declaração após o rótulo especificado. Para
exemplo:

   '...
   Goto MyLabel
   '...
MyLabel:
   '...

O rótulo deve estar no mesmo processo que a instrução Goto.

A instrução Goto é geralmente evitada em programação estruturada, porque muitas vezes leva ao código
que é difícil de ler e depurar.

2.13.2.4 Se

A declaração Se os controles se um bloco de código é executado com base em algumas condições. A
forma mais simples da instrução If é:

Se a expressão seguida
demonstrações
End If

expressão é qualquer expressão que possa ser interpretado como um valor booleano. Se a expressão for verdadeira,
as declarações dentro do bloco, se forem executados. Se a expressão for falsa, as declarações são
pulado.

Para fornecer um conjunto alternativo de instruções para executar quando a expressão é falsa, adicione um Else
cláusula, como mostrado aqui:

Se a expressão seguida
demonstrações
Mais
demonstrações


55
 



End If

Se a expressão for verdadeira, somente as instruções na cláusula Se forem executados. Se a expressão for falsa,
apenas as instruções na cláusula Else são executadas.

Finalmente, uma seqüência de expressões podem ser avaliadas, incluindo uma ou mais cláusulas ElseIf, como
mostrado aqui:

Se a expressão seguida
demonstrações
Então ElseIf expressão
demonstrações
Então ElseIf expressão
demonstrações
Mais
demonstrações
End If

O primeiro caso ou ElseIf cláusula cuja expressão avalia como True terão suas demonstrações executado.
Demonstrações nas cláusulas subseqüentes ElseIf não será executado, mesmo que a sua correspondente
expressões são verdadeiras. Se nenhuma das expressões avaliadas como True, as declarações do Else
cláusula será executada. A cláusula Else pode ser omitido, se desejar.

2.13.2.5 RaiseEvent

A declaração RaiseEvent aciona o evento dado. Após o evento foi disparado para todos os ouvintes,
a execução continua com a primeira instrução após a instrução RaiseEvent. Veja Seção 2.20
mais adiante neste capítulo para obter mais informações.

2.13.2.6 Retorno

As saídas da instrução return de uma função e fornece um valor de retorno para o chamador da função.
A execução continua com a primeira instrução após a instrução que chamou a função. Aqui está um
exemplo:

Public Shared Function MyFactorial (ByVal valor As Integer) As Integer
   Dim retval As Integer = 1
   Dim i As Integer
   Para i = 2 para o valor
      retval *= i
   Seguinte
   retval Retorno
End Function

Outra maneira de retornar um valor para o chamador da função é a de atribuir o valor ao nome da função
e depois simplesmente abandonam o fundo da função. Isto é como foi feito em Visual Basic 6 (e
ainda pode ser feito em Visual Basic. NET). Aqui está um exemplo:

Public Shared Function MyFactorial (ByVal valor As Integer) As Integer
   Dim retval As Integer = 1
   Dim i As Integer
   Para i = 2 para o valor
      retval *= i
   Seguinte
   MyFactorial retval =
End Function



56
 
NET Programação Visual Basic.


No Visual Basic 6, a instrução de retorno foi usado para retornar
execução para a instrução na sequência de uma declaração GoSub. No Visual
Basic. NET, a declaração GoSub não existe mais, eo
instrução Return é agora utilizada como descrito aqui.

2.13.2.7 Select Case

A instrução Select Case escolhe um bloco de instruções para executar com base em algum valor. Para
exemplo:

Selecione strColor processo
   Case "vermelho"
      '...
   Case "verde"
      '...
   Case "azul"
      '...
   Case "amarelo"
      '...
   Case Else
      '...
End Select

Se strColor neste exemplo contém "azul", somente as instruções na cláusula Case "azul" são
executados. Se nenhuma das cláusulas processo coincide com o valor na declaração Select Case, o
demonstrações na cláusula Case Else são executadas. Se mais de uma cláusula Case coincide com o dado
valor, apenas as instruções na cláusula primeira caixa de correspondência são executadas.

declarações processo pode incluir vários valores a serem comparados com o valor indicado no Select
Caso comunicado. Por exemplo:

Case "vermelho", "verde", strSomeColor, "azul"

Este processo vai ser acompanhado, se o valor na declaração Select Case é "vermelho", "verde", "azul", ou
o valor contido na strSomeColor. A palavra-chave pode ser usado para combinar um conjunto de valores, como
mostrado aqui:

Case "maçãs" para "laranjas"

Esta declaração processo coincide com qualquer valor de cadeia que cai em ordem alfabética dentro desta faixa.

A palavra-chave Is pode ser usado para combinar um intervalo aberto:

Case Is> "laranjas"

Não confunda esse uso da palavra-chave Is Is com o operador de comparação.

2.13.3 Instruções iteração

instruções de iteração, também conhecido como declarações de looping, permitir que um grupo de instruções a serem executadas
mais de uma vez. O grupo de comandos é conhecido como o corpo do loop. Três declarações queda
nesta categoria no Visual Basic. NET: fazer, pois, e para cada um.




57

 

2.13.3.1 Não

O loop executa um bloco de instruções até que uma condição se torne verdadeira, ou enquanto uma condição
continua a ser verdade. A condição pode ser testado no início ou no final de cada iteração. Se o teste for
realizada no final de cada iteração, o bloco de instruções é garantido para executar pelo menos uma vez.
O loop também pode ser escrita sem quaisquer condições, caso em que é executado repetidamente até que e
a menos que uma declaração Exit Do é executado dentro do corpo do loop. Aqui estão alguns exemplos de fazer
loops:

Do While i <10
   '...
Loop

Do Until i> = 10
   '...
Loop

Não
   '...
Loop While i <10

Não
   '...
Loop até que eu> = 10

Não
   '...
Loop

2.13.3.2 Para

O laço for executa um bloco de declarações num número específico de vezes. O número de iterações é
controlado por uma variável do laço, que é inicializada com um determinado valor pela instrução for, então é
incrementado a cada iteração do loop. As declarações contidas no corpo do loop são repetidamente
executado até que a variável 'loop' ultrapassa um dado limite superior.

A sintaxe do loop for é:

Para variável = expressão a expressão [expressão Passo]
demonstrações
[Variable_list] Next

A variável do laço pode ser de qualquer tipo numérico. A variável é igual ao valor do primeiro
expressão antes de entrar na primeira iteração do corpo do laço. Antes de executar cada iteração do
loop, a variável do laço é comparado com o valor da segunda expressão. Se o valor do loop
variável é maior do que a expressão (ou menos do que a expressão se a expressão passo é negativo),
o loop ea execução continua com a primeira instrução após a instrução Next.

A expressão passo é um valor numérico que é adicionado à variável de loop entre as iterações do loop. Se
Passo a cláusula for omitida, a expressão passo é levado para ser 1.

A declaração seguinte marca o final do corpo do laço. A palavra-chave seguida podem aparecer por si só em
a instrução ou ser seguido pelo nome da variável do laço. Se, por declarações são aninhados, um único
instrução Next pode rescindir os corpos de vários loops. Por exemplo:

Para i = 1 To 10
   Para j = 1 a 10


58
 



      Para k = 1 To 10
         '...
k Em seguida, J, I
 
NET Programação Visual Basic.
 

Este código é equivalente ao seguinte:

Para i = 1 To 10
   Para j = 1 a 10
      Para k = 1 To 10
         '...
      Seguinte
   Seguinte
Seguinte

Eu recomendo o último estilo, pois ela é considerada mais estruturada para terminar cada bloco de forma explícita.

É interessante notar que o loop for é equivalente ao seguinte faz construção de alça (supondo
step_expression que é não-negativo):

from_expression loop_variable =
Do While <loop_variable to_expression =
demonstrações
   loop_variable step_expression + =
Loop

Step_expression Se for negativo, o loop for é equivalente a este (só a comparação no Do
declaração é diferente):

from_expression loop_variable =
Do While> loop_variable to_expression =
   demonstrações
   loop_variable step_expression + =
Loop

2.13.3.3 Para cada

O For Each é semelhante à instrução For, exceto que a variável de laço não precisa ser
iterações numéricas, e não sucessivos incrementos da variável do loop. Em vez disso, a variável do laço tem
valores sucessivos de uma coleção de valores. Aqui está a sintaxe:

Para cada variável na expressão
   demonstrações
[Variável] Next

A variável de laço pode ser de qualquer tipo. A expressão deve ser uma referência a um objeto que expõe
a interface IEnumerable (interfaces são discutidas mais adiante neste capítulo). Geralmente, os tipos que são
coleções consideradas expor essa interface. O. NET Framework fornece várias
útil tipos de coleções, que são listados no Capítulo 3. (Ver item 2.5.4 anteriormente neste capítulo, para
uma explicação sobre o que constitui um tipo de coleção.) O tipo de itens na coleção deve ser
compatível com o tipo da variável do laço. As declarações contidas no corpo do loop é executado uma vez para
cada item da coleção. Durante cada iteração, a variável do laço é igual a cada consecutivos
item na coleção.

Como todas as matrizes de Visual Basic. NET expor a interface IEnumerable, o For Each
pode ser usado para percorrer os elementos de uma matriz. Por exemplo:

Dim a () As Integer = {1, 2, 3, 4, 5}


59
 
 



Dim b inteiro como
Para cada b Em um
   Console.WriteLine (b)
Seguinte

Isso é equivalente ao seguinte código:

Dim a () As Integer = {1, 2, 3, 4, 5}
Dim b inteiro como
Dim i As Integer
Para i = a.GetLowerBound (0) Para a.GetUpperBound (0)
   b = a (i)
   Console.WriteLine (b)
Seguinte

Como todas as matrizes em Visual Basic. NET implicitamente derivam do tipo Array (no âmbito do Sistema
namespace), a matriz, no presente exemplo, tem acesso aos métodos definidos no tipo Array (especificamente
GetLowerBound e GetUpperBound).

No caso de você estiver interessado, aqui está o código equivalente usando um loop. Isto é essencialmente o que o Para
Cada instrução está fazendo por baixo dos panos, embora destinada a cada construção é provável que a compilação
código mais rápido.

Dim a () As Integer = {1, 2, 3, 4, 5}
Dim b inteiro como
Dim e como objeto a.GetEnumerator = ()
Do While CType (e.GetType ().
InvokeMember ("MoveNext", _
   Reflection.BindingFlags.InvokeMethod, Nada, e Nada), Boolean)
   b = CType e.GetType (().
InvokeMember ("atual", _
      Reflection.BindingFlags.GetProperty, Nada, e Nada), Integer)
   Console.WriteLine (b)
Loop

2.13.4 Funções matemáticas

Funções matemáticas são fornecidos através da classe Math (definido no namespace System). A
constantes da classe Math e métodos são listadas no Apêndice E.

2.13.5 Entrada / Saída

Arquivo da Internet e recursos de I / O são fornecidos pelo. NET Framework e será brevemente
abordadas no capítulo 3. Além disso, Visual Basic. NET oferece uma biblioteca de sua própria classe que inclui
Funções para abrir, ler e fechar arquivos. O acesso ao arquivo e programação protocolo de rede são
não serão discutidos neste livro. Em vez disso, a preferência é dada para as tarefas mais comuns de banco de dados
acesso e programação de serviços web.

2,14 Classes

Uma classe é uma forma de tipo de dados. Como tal, uma classe pode ser usado em contextos onde os tipos são esperados,
em declarações de variável, por exemplo. No projeto orientado a objetos, as aulas são destinadas a representar a
definição dos objetos do mundo real, como cliente, pedido de produto, etc A classe é apenas a definição,
não um objeto em si. Um objeto seria um cliente, uma ordem, ou um produto. Uma declaração de classe define
o conjunto de membros de campos, propriedades, métodos e eventos que cada objeto da classe
possui. Junto, estes membros definir o estado de um objeto, bem como a sua funcionalidade. Um objeto é
também referido como uma instância de uma classe. Criando um objeto de uma determinada classe é chamada de instanciar um
objeto da classe.



60
 
NET Programação Visual Basic.


Considere a definição da classe no Exemplo 2-4.

Exemplo 2-4. Uma definição de classe
Funcionário público de classe
   Público EmployeeNumber As Integer
   Público FamilyName As String
   Público GivenName As String
   Público DateOfBirth como data
   Público salário como Decimal

   Formato de função pública () As String
      GivenName Retorno & "" & FamilyName
   End Function

End Class

O código no Exemplo 2-4 define uma classe chamada Empregado. Ela tem cinco campos públicos (também conhecido como
membros de dados) para armazenar estado, bem como uma função de membro. A classe poderia ser utilizado como mostrado
no Exemplo 2-5.

Exemplo 2-5. Usando uma classe
Dim emp como funcionário Novo ()

emp.EmployeeNumber = 10
emp.FamilyName = "Rodriguez"
emp.GivenName = "Celia"
emp.DateOfBirth = # 1965/01/28 #
emp.Salary = 115000

Console.WriteLine ("Nome do Funcionário:" & emp.Format ())
Console.WriteLine ("Número do Funcionário:" & emp.EmployeeNumber)
Console.WriteLine ("Data de Nascimento:" & emp.DateOfBirth.ToString ("D",
Nada))
Console.WriteLine ("Salário:" & emp.Salary.ToString ("C", Nothing))

A saída resultante é:

Nome do Funcionário: Celia Rodrigues
Empregado Número: 10
Data de Nascimento: quinta-feira, 28 de janeiro, 1965
Salário: $ 115.000,00

2.14.1 instanciação de objetos e Nova

instanciação do objeto é feito usando a palavra-chave Novo. A palavra-chave Novo é, com efeito, um operador unário
que utiliza um tipo de identificador do seu operando. O resultado da operação é uma referência a um recém-criado
objeto do tipo de dado. Considere o seguinte:

Imports System.Collections
'...
Dim HT em Hashtable
Hashtable ht = new ()

A instrução Dim declara uma variável que é capaz de conter uma referência a um objeto do tipo
Hashtable, mas ele realmente não criar o objeto. O código na linha após a instrução Dim
instancia um objeto do tipo Hashtable e atribui à variável de uma referência para o recém-criado


61
 



objeto. Como acontece com qualquer declaração de outra variável, a cessão pode ser feito na mesma linha como a
declaração, conforme mostrado aqui:

Imports System.Collections
'...
Dim Como Hashtable ht = new Hashtable ()

. Visual Basic NET permite digitar um atalho que produz o mesmo resultado:

Imports System.Collections
'...
Dim HT em new Hashtable ()

2.14.2 Construtores

Quando uma classe é instanciada, algumas vezes de inicialização deve ser realizada antes do tipo podem ser usados.
Para fornecer essa inicialização, uma classe pode definir um construtor. Um construtor é um tipo especial de
método. Ele é automaticamente executado sempre que um objeto da classe é instanciado. declarações Construtor
usar a mesma sintaxe como declarações de método normal, exceto que no lugar do nome do método, o
declaração construtor usa a palavra-chave Novo. Por exemplo:

Classe someClass Pública
   Sub New Public ()
      'Fazer qualquer inicialização necessária do objeto aqui.
   End Sub
End Class

Para chamar o construtor, um novo objeto deve ser instanciado:

Dim obj someClass Como Novo ()

Note os parênteses (()) após o nome da classe. Até você se acostumar com isso, esse método de estilo
sintaxe a seguir um nome de classe pode parecer estranho. No entanto, os parênteses vazios indicam que o
construtor da classe não tem argumentos.

Construtores podem ter argumentos, se forem necessários para a inicialização do objeto:

Classe someClass Pública

   As Integer Dim m_value

   Sub New Public (ByVal InitialValue As Integer)
      m_value = InitialValue
   End Sub

End Class

Quando os objetos dessa classe são instanciados, um valor deve ser fornecido para o argumento do construtor:

Dim obj Como someClass Nova (27)

Construtores podem ser sobrecarregados, se desejar. Por exemplo:

Classe someClass Pública

   As Integer Dim m_value



62
 



   Sub New Public ()
 
NET Programação Visual Basic.
 
      m_value = Date.Today.Day ", por exemplo
   End Sub

   Sub New Public (ByVal InitialValue As Integer)
      m_value = InitialValue
   End Sub

End Class

O construtor que é chamado depende dos argumentos que são fornecidos quando a classe é
instanciado, como mostrado aqui:

Dim obj1 As New someClass () 'chama o construtor sem parâmetros
Dim obj2 como nova someClass (100) 'chama o construtor parametrizado

Construtores são geralmente marcados Pública. No entanto, há momentos em que pode ser desejável para marcar
um construtor como protegidos ou privados. acesso protegido proíbe a classe seja instanciada
por qualquer outra classe de uma classe derivada desta classe. Acesso privado proíbe a classe que está sendo
instanciada por qualquer outro código que não o seu. Por exemplo, um projeto de classe especial pode exigir que
a própria classe estar no controle de saber se e quando as instâncias são criadas. Exemplo 2-6 mostra uma classe
que implementa uma forma grosseira de pool de objetos.

Exemplo 2-6. Usando um construtor privado
Imports System.Collections
'...
Classe MyPooledClass Pública

   'Este campo compartilhado controla instâncias que podem ser entregues.
   Private m_pool Compartilhada como Nova Stack ()

   "Este método de mãos repartidas instâncias.
   Função Pública GetInstance compartilhados () As MyPooledClass
      Se m_pool.Count> 0 Then
         "Nós temos um ou mais objetos na piscina. Retire uma das
         'Piscina e dá-lo ao chamador.
         Retorno CType (m_pool.Pop (), MyPooledClass)
      Mais
         "Nós não temos quaisquer objetos na piscina. Criar uma nova.
         MyPooledClass novo retorno ()
      End If
   End Function

   "Este método deve ser chamado para significar que o cliente está concluída
   "Com o objeto.
   Público ImDone Sub ()
      "Colocar o objeto na piscina.
      m_pool.Push (Me)
   End Sub

   'Declarando um construtor privado significa que a única forma de
   "Instanciar essa classe é através do método GetInstance.
   Private Sub New ()
   End Sub

End Class

A classe no Exemplo 2-6 seria usado assim:



63
 
 



Dim obj Como MyPooledClass.GetInstance MyPooledClass = ()
'...
obj.ImDone ()

Às vezes, quando os construtores estão sobrecarregados, não faz sentido implementar um construtor em termos
de outro. Por exemplo, aqui é uma classe que tem um construtor que leva um objeto SqlConnection como
parâmetro. No entanto, ele também tem um construtor sem parâmetros que cria um objeto SqlConnection e
passa para o construtor parametrizado da classe. Observe o uso da palavra-chave MyClass para acessar
membros do tipo:

Imports System.Data.SqlClient
'...
Classe someClass Pública

   Sub New Public ()
      MyClass.New (New SqlConnection ())
   End Sub

   Sub Público Novo (CN ByVal SqlConnection)
      "Faça alguma coisa com o objeto de conexão.
   End Sub

End Class

Da mesma forma, MyBase.New pode chamar um construtor da classe base. Se isso for feito, deve ser feito como o primeiro
instrução no construtor da classe derivada. Observe que, se não houver nenhuma chamada explícita é feita, o compilador cria um
chamada ao construtor sem parâmetros o construtor da classe. Mesmo se a classe base expõe um
construtor parametrizado com a mesma assinatura (ou seja, o mesmo número e tipos de parâmetros)
como construtor da classe derivada, por padrão, o compilador gera o código que chama a classe base
construtor sem parâmetros.

Se uma classe tem os campos comuns que devem ser inicializados antes do acesso, e que a inicialização não pode ser
realizado por inicializadores em declarações dos campos, um construtor pode ser compartilhado por escrito para inicializar o
campos, conforme mostrado aqui:

Classe someClass Pública

   Public Shared SomeStaticField As Integer

   Shared Sub New ()
      SomeStaticField Date.Today.Day =
   End Sub

End Class

O construtor compartilhada está garantido para correr um pouco antes de os membros do tipo são referenciados.
Se algum campos compartilhados tem inicializadores nas suas declarações, os inicializadores são atribuídos aos campos
antes que o construtor é executado comum.

construtores compartilhados não podem ser sobrecarregados, nem podem ter modificadores de acesso (público, privado,
etc.) Nenhum recurso é significativo no contexto dos construtores compartilhada.

2.14.3 Campos

Campos, também conhecido como membros de dados, mantenha o estado interno de um objeto. Suas declarações parecem
apenas dentro de declarações de classe e estrutura. declarações de campo inclui um modificador de acesso, que
determina como o campo é visível a partir do código fora da definição da classe que contém. modificadores de acesso
foram discutidos anteriormente neste capítulo, sob a Secção 2.10.


64
 
NET Programação Visual Basic.


O valor armazenado em um campo é específico para uma instância de objeto particular. Dois exemplos podem ter diferentes
valores nos campos correspondentes. Por exemplo:

Dim Emp1 Como Novo Empregado ()
Dim EMP2 Como Novo Empregado ()

emp1.EmployeeNumber = 10
emp2.EmployeeNumber = 20 "não afecta Emp1.

Às vezes é desejável para compartilhar um único valor entre todas as instâncias de uma classe particular. Declarando uma
campo utilizando a palavra-chave Shared faz isso, como mostrado aqui:

Public Class X
   Public Shared a As Integer
End Class

Alterando o valor do campo através de um exemplo que afeta todos os outros casos ver. Por exemplo:

Dim q As New X ()
r Dim X ()

q.a 10 =
r.A 20 =

Console.WriteLine (q.a) 'Grava 20, e não 10.

Campos compartilhados também são acessíveis através do nome da classe:

Console.WriteLine (X.a)

2.14.3.1 campos somente leitura

Campos podem ser declarados com o modificador ReadOnly, o que significa que o valor do campo pode ser definido
apenas em um construtor para a classe de fechamento. Isto proporciona o benefício de uma constante quando o valor da
constante não é conhecido em tempo de compilação ou não pode ser expresso em um inicializador constante. Aqui está um
exemplo de uma classe que tem um campo só de leitura inicializado no construtor da classe:

Público MyDataTier Classe

   Public ReadOnly ActiveConnection Como System.Data.SqlClient.SqlConnection

   Sub New Public (ConnectionString ByVal As String)
      _ ActiveConnection =
         Nova System.Data.SqlClient.SqlConnection (ConnectionString)
   End Sub

End Class

O modificador ReadOnly se aplica somente ao campo em si, não aos membros de qualquer objeto referenciado por
no campo. Por exemplo, dada a declaração anterior da classe MyDataTier, o código a seguir é
legal:

Dim mydata como nova MyDataTier (strConnection)
strSomeOtherConnection mydata.ActiveConnection.ConnectionString =






65
 



2.14.4 Tratamento de eventos

Quando um campo é de um tipo de objeto que expõe eventos, de classe envolvendo o campo pode definir os métodos de
para lidar com esses eventos. Para obter uma explicação dos acontecimentos, ver a seção 2.20, mais adiante neste capítulo.

Aqui está um exemplo:

Imports System.Data.SqlClient

Público EventHandlingTest Classe

   m_cn WithEvents Privado Como SqlConnection

   Public Sub MySqlInfoMessageEventHandler (_
      ByVal sender As Object, _
      ByVal e As _ SqlInfoMessageEventArgs
   ) Handles m_cn.InfoMessage
      Dim sqle Como SqlError
      Para cada sqle Em e.Errors
         Debug.WriteLine (sqle.Message)
      Seguinte
   End Sub

   '...

End Class

Essa classe tem um campo m_cn, que mantém uma conexão com o banco. O campo é declarada com a
WithEvents palavra-chave, portanto, a classe é capaz de receber e tratar eventos gerados pelo
Objeto de conexão. A fim de manipular o evento do objeto Connection InfoMessage, a classe define um
método com a lista de parâmetros adequados e uma cláusula Handles:

Public Sub MySqlInfoMessageEventHandler (_
   ByVal sender As Object, _
   ByVal e As _ SqlInfoMessageEventArgs
) Handles m_cn.InfoMessage

Esta declaração significa que quando o evento InfoMessage é gerado pelo objeto referenciado em m_cn,
MySQLInfoMessageEventHandler o método deve ser chamado para lidar com isso. O corpo do evento
manipulador, neste caso simplesmente exibe as mensagens recebidas a partir do SQL Server.

2.14.5 Herança

Herança é uma forma de reutilizar e estender o código escrito anteriormente. Um projeto do programa muitas vezes exige
várias classes como variações de um tema comum. Considere um programa de desenho que lida com muitas
formas. Tal programa, provavelmente, definir uma classe para cada tipo de forma. No entanto, haveria
ser muito em comum entre essas classes, incluindo muitos dos seus campos, métodos e eventos.
A herança permite que essas características comuns a serem extraídos em uma classe base da qual os diversos
aulas de forma específica são derivadas. Exemplo 2-7 mostra uma classe base denominada Shape, dois utilitários
classes usadas por forma (Ponto e Extensão), e duas classes derivadas de Shape (círculo e quadrado).

Exemplo 2-7. herança de classe
"Essa estrutura representa um ponto em um plano.
Público Point Estrutura
   Público X inteiro como
   Público Y As Integer
Fim Estrutura


66
 
NET Programação Visual Basic.



"Essa estrutura representa um tamanho ou offset.
Extensão Estrutura Pública
   Público XExtent As Integer
   Público YExtent As Integer
Fim Estrutura

"Esta classe representa a funcionalidade que é comum para
'Todas as formas. Esta classe não pode ser instanciada em si, porque
'Da "MustInherit" modificador.
Público MustInherit forma de classe

   "O canto superior esquerdo da forma.
   Como ponto de origem pública

   "A largura ea altura da forma.
   Tamanho público como extensão

   "Isso força todas as classes derivadas de implementar um método
   'Chamado Draw. Observe que um método marcado com MustInherit
   "Não tem corpo na classe base.
   MustOverride Pública Draw Sub ()

   'Esta sub-rotina se move de uma forma.
   Sub Público Offset (Valor ByVal Extensão)
      Origin.X + = Amount.XExtent
      Origin.Y + = Amount.YExtent
   End Sub

   "Esta propriedade permite que o usuário da classe para encontrar ou definir o
   "Centro de uma forma.
   Centro Público de Propriedade () como o ponto
      Obter
         Dim retval Como Point
         retval.X Origin.X = + (Size.XExtent \ 2)
         retval.Y Origin.Y = + (Size.YExtent \ 2)
         retval Retorno
      End Get
      Definir
         Dim currentCenter Como ponto = Centro
         Origin.X + = Value.X - currentCenter.X
         Origin.Y + = Value.Y - currentCenter.Y
      Definir Fim
   End Property

End Class

Público classe Circle
   Herda Forma
   Substitui Pública Draw Sub ()
      "Apenas uma declaração dummy para o exemplo.
      Console.WriteLine ("Circle.draw () foi chamado.")
   End Sub
End Class

Praça pública da classe
   Herda Forma
   Substitui Pública Draw Sub ()
      "Apenas uma declaração dummy para o exemplo.
      Console.WriteLine ("Square.Draw () foi chamado.")
   End Sub
 







































































67
 



End Class

Observe o seguinte:

• O modificador MustInherit na declaração da classe Shape indica que esta classe não pode ser
instanciado, ele só pode ser usado como uma classe base em uma derivação. No projeto orientado a objeto
terminologia, uma classe como é conhecida como uma classe abstrata.
• O Círculo e Quadrado classes herdam os membros públicos declarados na classe Shape.
• Usar o modificador MustOverride na declaração do método Draw nas forças classe Shape
classes derivadas para fornecer uma implementação para este método.
• Construtores não são herdados. As aulas, portanto, Rectangle e Ellipse declarar suas próprias
construtores.

Quando nenhum construtor é expressamente previsto em uma definição de classe, o compilador automaticamente
cria um. Portanto, todas as classes têm pelo menos um construtor. A autoprodução
construtor (também conhecido como o construtor padrão) criado pelo compilador é o mesmo que se
o código a seguir foram escritas na definição de classe:

Sub New Public ()
   MyBase.New ()
End Sub

Ou seja, o construtor padrão simplesmente chama o construtor sem parâmetros da classe base. Se não houver
há construtor sem parâmetros na classe base, o compilador gera um erro. Se uma classe
define um construtor com parâmetros, o compilador não gera um construtor padrão.
Portanto, se ambos os construtores sem parâmetros e parâmetros são necessários, ambos devem ser
explicitamente escrito na definição da classe.

É possível definir uma classe da qual não é possível herdar. Isso é feito com o
palavra-chave NotInheritable na declaração da classe, conforme mostrado aqui:

Público NotInheritable someClass Classe
   '...
End Class

2.14.6 Métodos

Os métodos são os membros que contêm o código. Eles são ou sub-rotinas (que não têm um valor de retorno)
ou funções (que tem um valor de retorno).

definições Subroutine esta aparência:

[Method_modifiers] Sub [attribute_list] _
   method_name ([parameter_list]) [handles_or_implements]
[Method_body]
End Sub

As definições de função semelhante a este:

[Method_modifiers] Função [attribute_list] _
   method_name ([parameter_list]) [Como type_name] _
   [Handles_or_implements]
[Method_body]
End Function

Os elementos de definição de método são:



68
 



method_modifiers
 
NET Programação Visual Basic.
 

Palavras-chave que afetam a acessibilidade ou a utilização do método. Estes incluem o seguinte:

modificadores de acesso

Public, Protected, Friend, Protected Friend, ou privados, conforme descrito na Tabela 2 -
5. Se nenhuma palavra-chave modificador de acesso é dado, assume-se público.

Substituir modificadores

Substituições, MustOverride, Overridable ou NotOverridable. Consulte a Seção 2.14.6.6.

Sobrecargas palavra-chave

Especifica que este método é uma sobrecarga. Consulte a Seção 2.14.6.7 mais adiante nesta seção.

Compartilhados palavra-chave

Especifica que este método não acesso estado do objeto. Isso significa que o método não
acessar qualquer membro não compartilhado.

Sub ou Function palavra-chave

Especifica se este método é uma subrotina ou função.

attribute_list

Uma lista de atributos a serem aplicadas ao método. Consulte a Secção 2,22 neste
capítulo.

method_name

O nome do método.

parameter_list

Uma lista de parâmetros formais para o método. Consulte a Seção 2.14.6.1.

Como type_name

Para funções apenas, o tipo de dados do valor retornado desta função. Se Option Strict é
fora, a cláusula como type_name é opcional, caso contrário, ela é necessária. Se for omitido, o
de retorno da função padrão para o tipo de objeto. Subrotina declarações não têm como
cláusula type_name.

handles_or_implements

Ou a palavra-chave Handles seguido por uma lista de eventos a partir de dados da classe delimitador de
membros, ou a palavra-chave Implements seguido por uma lista de métodos de uma interface
implementado pela classe delimitador. Consulte a Seção 2.20 e 2,15 ponto, mais adiante neste
capítulo.

method_body


69
 
 



Visual Basic. Declarações NET.

End Sub ou palavras-chave End Function

Indica o final da definição do método.

2.14.6.1 Parâmetros do método

Métodos podem ser definidos para ter argumentos. Como já foi demonstrado, as definições de método pode levar um opcional
lista de parâmetros. A lista de parâmetros parecido com este:

{parâmetro, parâmetro}

Ou seja, uma lista de parâmetros é um ou mais parâmetros separados por vírgulas. Cada parâmetro na lista
é da forma:

[Opcional] [ParamArray] [ByRef | ByVal] [attribute_list] _
   parameter_name [Como type_name] [constant_expression =]

Os elementos de cada declaração de parâmetro são:

Palavra chave

Especifica que um argumento real podem ser omitidos para este parâmetro em uma chamada para este método. Se
Opcional é especificado, o constant_expression =, que define o valor padrão de um
argumento omitido, também deve ser especificado. parâmetros Nonoptional não pode seguir opcional
parâmetros em uma lista de parâmetros. Parâmetros opcionais e ParamArray não pode aparecer na
lista de parâmetros mesmo.

ParamArray palavra-chave

Especifica que o interlocutor pode fornecer um número variável de argumentos. Os argumentos reais
são passados para o método em uma matriz. Apenas o último parâmetro em uma lista pode ter o
ParamArray palavra-chave ligadas a ele. Parâmetros opcionais e ParamArray não pode aparecer em
a lista mesmo parâmetro. matrizes de parâmetros são discutidos mais adiante nesta seção, sob a Secção
2.14.6.3.

ByRef ou palavra-chave ByVal

Especifica se o argumento de reais serão passados para o método por referência ou por valor.
Quando um argumento é passado por referência, o endereço do argumento é passado para o
de rotina, como resultado, as atribuições para o parâmetro dentro do método afeta o argumento da
chamando ambiente. Quando um argumento é passado por valor, uma cópia do argumento é passado
à rotina, como resultado, as atribuições para o parâmetro dentro do método não afetam o
argumento no ambiente de chamada.
Considere o seguinte código:

  Public Shared Sub TestByRef (MyParameter ByRef As Integer)
     MyParameter + = 1
  End Sub

  Public Shared Sub TestByVal (MyParameter ByVal As Integer)
     MyParameter + = 1
  End Sub

  Public Shared Sub DoTest ()




70
 
NET Programação Visual Basic.


     
Integer Dim x As = 1
     TestByRef (x)
     Console.WriteLine ("x =" & x)

     Dim y As Integer = 1
     TestByVal (y)
     Console.WriteLine ("y =" y &)

  End Sub

A saída do método DoTest é:

  x 2 =
  y = 1

O TestByRef e métodos TestByVal tanto incrementar os valores dos argumentos passados para elas
por um. No entanto, porque o parâmetro do método TestByRef é ByRef, o novo valor é escrito
de volta para o argumento do chamador (neste caso, a variável x no método DoTest). Em contraste, o
parâmetro TestByVal método é ByVal, para a atribuição ao parâmetro não afeta o chamador.

Esteja ciente dos efeitos da ByRef e ByVal sobre os argumentos que são tipos de referência. ByRef meios
que uma referência para a referência está sendo passado; ByVal significa que a referência em si está sendo
passado. Isso significa que dentro do método, a referência pode ser usada para modificar o estado do
objeto no ambiente de chamada. Por exemplo:

Classe someClass Pública
   Pública a As Integer
End Class

Classe TestSomeClass Pública

   Public Shared Sub TestByRef (MyParameter ByRef Como someClass)
      MyParameter.a + = 1
   End Sub

   Public Shared Sub (MyParameter ByVal someClass) TestByVal
      MyParameter.a + = 1
   End Sub

   Public Shared Sub DoTest ()

      Dim x As someClass New ()
      x.a 1 =
      TestByRef (x)
      Console.WriteLine ("x.a =" x.a &)

      Dim y Como someClass New ()
      y.a 1 =
      TestByRef (y)
      Console.WriteLine ("y.a =" y.a &)

   End Sub
End Class

A saída do DoTest método neste código é:

x.a 2 =
y.a 2 =



71
 



Observe que, embora a variável y é passado por valor para o método TestByVal, um dos seus
membros, no entanto, é atualizado. Neste caso, ByVal apenas mantém a referência em y de ser
substituído por outro de referência.

attribute_list

Especifica uma lista de atributos personalizados para aplicar o parâmetro. Os atributos são discutidos mais tarde
neste capítulo.

parameter_name

Especifica o nome do parâmetro.

Como type_name

Especifica o tipo de dados do parâmetro. Quando o método é chamado, o tipo de reais
argumento deve ser compatível com o tipo do parâmetro. Como o elemento é type_name
opcional se Option Strict estiver desligado, caso contrário, ela é necessária. Se for omitido, o objeto é assumido.

constant_expression

Especifica uma expressão constante que especifica o valor do parâmetro deve fazer se não
argumento real é fornecida. Isso é permitido apenas em parâmetros opcionais.

2.14.6.2 Passando arrays como parâmetros

Para declarar um parâmetro como capaz de receber um array, incluir parênteses após o nome do parâmetro
da declaração. O chamador deixa de fora os parênteses ao nomear o argumento real. Por exemplo:

Public Shared Sub SomeMethod (ByVal x () As String)
   Dim str As String
   Para cada STR em x
      Console.WriteLine (str)
   Seguinte
End Sub

Public Shared Sub TestSomeMethod ()
   Dim uma String (5) Como
   um (0) = "Primeiro"
   uma (1) = "Segundo"
   um (2) = "Third"
   um (3) = "Quarta"
   um (4) = "Quinta"
   SomeMethod (a)
End Sub

No método SomeMethod, o parâmetro x representa um array de objetos String. Na
TestSomeMethod método, uma matriz de String é atribuído, os seus elementos são atribuídos, e da matriz como um
inteiro é passado para o método SomeMethod, que em seguida, imprime o conteúdo da matriz.

Todos os tipos de matriz são tipos de referência. Isso significa que, quando passar uma matriz como um parâmetro, apenas um
referência para a matriz é passado. Como o método de destino recebe uma referência para a matriz, o
elementos de matriz podem ser alterados pelo método, mesmo que a matriz de referência foi passado por valor. Se o
matriz de referência é passado por referência, a referência própria matriz pode ser alterado pelo método. Para
exemplo, o método poderia atribuir uma nova matriz e devolvê-lo através do parâmetro ByRef, como este:

Public Shared Sub DumpArray (ByVal x () As String)

 

72
 



   Dim str As String
   Para cada STR em x
 
NET Programação Visual Basic.
 
      Console.WriteLine (str)
   Seguinte
End Sub

Public Shared Sub CreateNewArray (ByRef x () As String)
   Dim newval (7) As String
   newval (0) = "1"
   newval (1) = "2"
   newval (2) = "3"
   newval (3) = "4"
   newval (4) = "5"
   newval (5) = "6"
   newval (6) = "7"
   x = newval
End Sub

Public Shared Sub DoTest ()

   "Configurar uma matriz de seqüência de cinco elementos e mostrar seu conteúdo.
   Dim uma String (5) Como
   um (0) = "Primeiro"
   uma (1) = "Segundo"
   um (2) = "Third"
   um (3) = "Quarta"
   um (4) = "Quinta"
   Console.WriteLine ("a () antes de chamar o método CreateNewArray:")
   DumpArray (a)

   "Agora, passar para o método CreateNewArray e depois mostrar a sua
   «Novos conteúdos.
   CreateNewArray (a)
   Console.WriteLine ()
   Console.WriteLine ("a () depois de chamar o método CreateNewArray:")
   DumpArray (a)

End Sub

Nesse código, o método DoTest cria uma matriz de seqüência de cinco elementos e passa para a DumpArray
mostrar o conteúdo da matriz. O método chama DoTest CreateNewArray, que atribui uma nova
matriz de cadeia, desta vez com sete elementos. Não seria possível, porém, a passar de volta uma matriz
com um número diferente de dimensões, porque o parâmetro é declarado explicitamente como um
dimensional. Visual Basic. NET considera a dimensionalidade de uma matriz para ser parte de seu tipo, mas o
tamanho de qualquer dimensão particular não faz parte do tipo da matriz.

2.14.6.3 parâmetro de comprimento variável listas

Alguns métodos necessidade de ter um número variável de argumentos. Por exemplo, uma função para calcular a
média dos números passados para ele deve acomodar como poucos ou tantos números, conforme necessário.
Visual Basic. NET oferece esse recurso através de matrizes de parâmetro. Uma matriz de parâmetro é um
parâmetro que o método se parece com uma matriz, mas para o chamador se parece com um número variável de
parâmetros. Aqui está o método de cálculo da média acima referida:

Public Shared Function Avg (Números ParamArray ByVal () As Integer) como
Duplo
   Dim soma As Integer = 0
   Dim contagem As Integer = 0
   Dim n As Integer
   Para cada n Em Números


73
 
 



      soma + n =
      contador + = 1
   Seguinte
   Retorno soma / contagem
End Function

Este método declara apenas um único parâmetro, um array de inteiros. No entanto, ele inclui o
ParamArray palavra-chave na declaração, que diz ao compilador para permitir chamadas como este:

"Calcule a média de alguns números.
Dim d Como Avg (31, 41, 59, 26, 53, 58) Duplo =

É importante notar que uma matriz real pode ser passada através do parâmetro algo ParamArray-
que não foi possível em Visual Basic 6. Por exemplo:

"Calcule a média de alguns números.
Dim args () As Integer = {31, 41, 59, 26, 53, 58}
Dim d As Double = Avg (args)

2.14.6.4 método Main

Quando um aplicativo executável é compilado, um código deve ser identificada como a rotina de inicialização. Este
parte é o que é executado quando o aplicativo é executado. O Visual Basic. NET procura por um
método chamado Main para atender esta necessidade. Em. NET, todo o código existe como métodos dentro de classes, até mesmo os
Principal método. Para torná-lo acessível sem precisar instanciar a classe, o método principal deve ser
declarados como compartilhada. Por exemplo:

Público App Classe
   Public Shared Sub Main ()
      '...
   End Sub
End Class

O nome da classe não é importante. Em tempo de compilação, o Visual Basic. NET procura por um
subrotinas compartilhadas pública denominada principal em algum lugar do código. Se mais de uma classe tem um tal
método, o desenvolvedor deve especificar qual usar, definindo o objeto de inicialização no Projeto
Caixa de diálogo Propriedades. Se você estiver usando o compilador de linha de comando, especificar o objeto de inicialização desejado
com o / principais: switch <class>.

Um método principal programa também pode aparecer dentro de um Visual Basic. módulo NET (não confundir
com os módulos. NET, que são descritos no Capítulo 3). Porque o Visual Basic módulos. NET são
classes onde tudo é compartilhado, a palavra-chave Shared não é utilizado na referida declaração:

Módulo App
   Sub Público Main ()
      '...
   End Sub
End Module

2.14.6.5 implementando métodos de interface

As classes podem ser declaradas como de execução de uma ou mais interfaces. (Veja a Seção 2.15.) Implementar
uma interface, a classe deve expor os métodos que correspondem aos métodos definidos pela interface.
Isso é feito declarando os métodos da forma habitual, mas com uma cláusula de Implementos como parte do
declaração. Observe a palavra-chave Implements adicionada à declaração do método CompareTo neste
exemplo:



74
 



Classe someClass Pública
 
NET Programação Visual Basic.
 
   Implementa IComparable

   Função Pública CompareTo (_
      ByVal obj As Object _
   ) As Integer Implementa IComparable.CompareTo
      '...
   End Function

End Class

Quando aparecer em uma declaração de método, a palavra-chave Implements deve ser seguido pelo nome de
a interface e método que implementa o método indicado. O método de classe devem ter o mesmo
assinatura e tipo de retorno, como método da interface, mas eles não precisam ter o mesmo nome.

2.14.6.6 Substituindo métodos herdados

Exemplo 2-7 mostra como uma classe base pode ser escrito de tal ordem que as forças de classes derivadas
implementar certos métodos. Neste caso, a classe Shape contém a seguinte declaração:

MustOverride Pública Draw Sub ()

Este declara o método Draw, que leva sem argumentos. A palavra-chave MustOverride especifica
que a classe base não prevê uma implementação para este método e que as classes derivadas devem
fazê-lo.

Às vezes, é preferível permitir que a classe base para fornecer uma implementação padrão, permitem ainda
classes derivadas para substituir suas próprias implementações. As classes que não fornecem seus próprios
implementações usam implementação da classe base por padrão. Considere a seguinte classe
definições:

Classe BaseClass
   Público SomeMethod Sub Overridable ()
      Console.WriteLine ("BaseClass definição")
   End Sub
BaseClass End Class '

Classe DerivedClass
   Herda BaseClass
   Substitui Pública SomeMethod Sub ()
      Console.WriteLine ("DerivedClass definição")
   End Sub
DerivedClass End Class '

Classe DerivedClass2
   Herda BaseClass
End Class 'DerivedClass2

A classe BaseClass define um método chamado SomeMethod. Além de proporcionar uma
implementação deste método, a declaração especifica a palavra-chave Overridable. Isso sinaliza para
o compilador que não há problema em substituir o método em classes derivadas. Sem este modificador, derivado
classes não pode substituir o método. A classe DerivedClass substitui esse método, definindo um
método com o mesmo nome e assinatura, especificando a palavra-chave substituições. O Visual
compilador Basic. NET requer que a palavra-chave Substitui estar presente para garantir que o desenvolvedor
realmente significou para substituir um método de classe base. A classe DerivedClass2 não se sobrepõe à
SomeMethod método. Chamadas para SomeMethod através de objetos de DerivedClass2 tipo irá chamar a
BaseClass definição de SomeMethod. Aqui está um exemplo:



75
 
 



Dim b Como BaseClass New ()
Dim d Como DerivedClass New ()
Dim d2 Como DerivedClass2 New ()

b.SomeMethod ()
d.SomeMethod ()
d2.SomeMethod ()

Esse código resulta na seguinte saída:

definição BaseClass
definição DerivedClass
definição BaseClass

A implementação SomeMethod na classe DerivedClass próprio pode ser substituído por uma classe
decorrentes DerivedClass. Isto pode ser evitado, se desejar, especificando o NotOverridable
palavra-chave na definição do método SomeMethod da classe DerivedClass, como mostrado aqui:

Classe DerivedClass
   Herda BaseClass
   Público NotOverridable Substitui SomeMethod Sub ()
      '...
   End Sub
DerivedClass End Class '

2.14.6.7 Sobrecarga

Quando dois ou mais métodos diferentes conceitualmente executar a mesma tarefa em argumentos de diferentes
tipos, é conveniente dar aos métodos com o mesmo nome. Esta técnica é chamada de sobrecarga e
suportados pelo Visual Basic. NET. Por exemplo, o código a seguir define um SquareRoot sobrecarregado
método que pode levar qualquer um longa ou um casal como um parâmetro:

Função Pública SquareRoot (_
   _ ByVal valor como Long
) As Double
   '...
End Function

Função Pública SquareRoot (_
   _ ByVal valor como dupla
) As Double
   '...
End Function

Quando uma chamada é feita para o método SquareRoot, a versão chamada é determinada pelo tipo de
parâmetro passado para ele. Por exemplo, o código a seguir chama a versão do método que utiliza um
Long:

Dim resultado As Double = SquareRoot (10)

E esse código chama a versão que leva um casal:

Dim resultado As Double = SquareRoot (10.1)

Cuidado leitores vão notar que no primeiro caso, o tipo de argumento é, na verdade não Integer, Long.
A versão longa do método é chamado, porque é a melhor correspondência para o argumento dado. Se
Havia também uma versão inteira do método, essa versão teria sido chamado, porque é
uma melhor adequação para o argumento dado. O. NET runtime (discutido no Capítulo 3) tenta sempre


76
 
NET Programação Visual Basic.


chamar a versão mais adequada de uma função sobrecarregada, dado os argumentos fornecidos. Se não
sobrecarga adequada for encontrada, um erro de compilação ocorre (se Option Strict) ou uma exceção de runtime
ocorre (se Option Strict estiver desligado).

O nome de um método juntamente com o número e tipos de seus argumentos são chamados a assinatura do
o método. A assinatura identifica uma versão específica sobrecarregado de um método específico. Nota
que o tipo de retorno não faz parte da assinatura. Duas versões de um método sobrecarregado não são
permitido diferem apenas pelo tipo de retorno.

2.14.6.8 Sobrecarregar métodos herdados

Um método também pode sobrecarregar um método em uma classe base. Tenha o cuidado de observar a diferença entre
sobrecarregar um método de classe base e substituir um método de classe base. Substituindo significa que o
classe base, o método eo método da classe derivada tem a mesma assinatura e que o da classe derivada
método é substituir o método de classe base. Além disso, o método da classe base deve ser marcada com
a palavra-chave Overridable. Sobrecarga significa que eles têm assinaturas diferentes e que ambos
existem métodos como sobrecargas na classe derivada. Quando a sobrecarga de um método definido em uma classe base,
a declaração do método da classe derivada deve incluir a palavra-chave Sobrecargas, mas a base de classe
método não tem nenhuma palavra-chave especial anexado a ele. Está aqui um exemplo:

Classe BaseClass Pública
   Public Sub SomeMethod ()
      '...
   End Sub
End Class

Classe DerivedClass Pública
   Herda BaseClass
   Sobrecargas Pública SomeMethod Sub (ByVal i As Integer)
      '...
   End Sub
End Class

O requisito para a palavra-chave Sobrecargas ajuda a documentar o fato de que um método de classe base é
sendo sobrecarregado. Não há nenhuma razão técnica que o compilador exigir isso, mas é necessário
no entanto, para ajudar a evitar o erro humano.

2.14.6.9 Sombreamento

A palavra-chave Shadows permite que um método da classe derivada para esconder todos os métodos de classe base com o mesmo
nome. Considere o seguinte código, que não use a palavra chave Shadows:

Classe BaseClass Pública
   Público SomeMethod Sub Overridable ()
      '...
   
End Sub
   Público SomeMethod Sub Overridable (ByVal i As Integer)
      '...
   
End Sub
End Class

Classe DerivedClass Pública
   Herda BaseClass
   Sobrecargas Público substitui SomeMethod Sub ()
      '...
   End Sub
End Class



77
 



A base de sobrecargas de classe, o método SomeMethod, ea classe derivada substitui a versão do
método sem parâmetros. Instâncias da classe derivada não apenas possuir a parâmetros
versão definida na classe derivada, mas elas também herdam a versão parâmetros definidos no
classe base. Em contraste, considere o seguinte código, que é o mesmo, exceto para a declaração do
SomeMethod método na classe derivada:

Classe BaseClass Pública
   Público SomeMethod Sub Overridable ()
      '...
   
End Sub
   Público SomeMethod Sub Overridable (ByVal i As Integer)
      '...
   
End Sub
End Class
Classe DerivedClass Pública
   Herda BaseClass
   Sombras Pública SomeMethod Sub ()
      '...
   End Sub
End Class

Nesta versão, as instâncias da classe derivada possui apenas a versão sem parâmetros declarados no
classe derivada. Nenhuma versão na classe base pode ser chamado através de uma referência para a classe derivada.

2.14.7 Propriedades

As propriedades são os membros que são acessados como campos, mas são realmente chamadas de método. A idéia é que um
designer de classe pode querer expor alguns valores de dados, mas precisa exercer maior controle sobre suas
leitura e escrita do que o previsto pelos campos. Propriedades também são úteis para expor os valores que são
calculado. Isso é demonstrado pela propriedade Center na classe Shape do Exemplo 2-7. A
propriedade pode ser lido e escrito como a Origem e os campos de tamanho. No entanto, não há dados reais
membro chamado Center. Quando o código lê a propriedade Center, uma chamada é gerada para o Centro
getter da propriedade. Quando um novo valor é atribuído à propriedade Center, uma chamada é gerada para o
setter da propriedade.

declarações de propriedade assim:

Propriedade [modificadores] Propriedade [atributos] property_name _
   ([Lista de parâmetros]) [Como type_name] [implementa a lista]
[Getter]
[Compositor]
End Property

Os componentes da declaração são:

modificadores de propriedade

Mais definido como:

[Default] [modificador de acesso] [override modificador] _
   [Sobrecarga modificador] [
compartilhado modificador] [
leitura / escrita] modificador

Se a palavra-chave padrão estiver presente, ele especifica a propriedade como a propriedade padrão da classe.
Apenas uma propriedade em uma classe pode ser de propriedade da classe padrão, e apenas com parâmetros (ou



78
 
NET Programação Visual Basic.


indexados) propriedades podem ser as propriedades padrão. Então o que é uma propriedade padrão? Um padrão
propriedade é apenas uma propriedade que pode ser referenciado sem realmente especificando o de propriedade
nome. Por exemplo, se uma classe tem uma propriedade padrão chamado Item, leva um argumento inteiro,
e é do tipo String, as duas linhas seguintes são equivalentes entre si:

myObject.Item (3) = "Olá mundo",
myObject (3) = "Olá mundo",

Observe que as versões anteriores do Visual Basic não constranger propriedades parametrizadas como a
só é possível as propriedades padrão.

O modificador de acesso, substituir modificador, modificador de sobrecarga, e recomendou
cláusulas modificadoras têm os mesmos significados como discutido mais adiante neste capítulo em relação ao
definições de método. A leitura / gravação cláusula modificador é definido como:

ReadOnly | WriteOnly

Esta cláusula determina se a propriedade é leitura / gravação (representado pela ausência de
ReadOnly e WriteOnly), read-only (representado por ReadOnly), ou somente gravação (representado por
WriteOnly).

Propriedade palavra-chave

Identifica-a como uma definição de propriedade.

atributos

Representa uma lista separada por vírgulas dos atributos a serem armazenados como metadados com a propriedade.
Os atributos são discutidos anteriormente neste capítulo.

Property_name

Representa o nome da propriedade.

lista de parâmetros

propriedades Permite que ter parâmetros. propriedades com parâmetros também são chamados indexados
propriedades. Veja a discussão de listas de parâmetros na Seção 2.14.6, anteriormente neste capítulo.

Como type_name

Indica o tipo de dados da propriedade. Esta cláusula é opcional, se Option Strict estiver desligado;
Caso contrário, ela é necessária. Se esta cláusula for omitida, o padrão de propriedade para o tipo Object.

implementa lista

Tem o mesmo significado que para a definição do método.

getter

Fornece o método que é executado quando a propriedade é lido. Sua forma é:

Obter
   "Código
End Get



79
 



O valor retornado pelo getter é retornado como o valor da propriedade. Para retornar um valor
do getter, use a instrução de retorno com um argumento ou atribuir um valor para o
propriedade nome. O valor retornado deve ser compatível com o tipo de dados da propriedade.

É um erro para fornecer um getter se a propriedade tem sido marcada WriteOnly.

ajustador

Fornece o método que é executado quando a propriedade está escrito. Sua forma é:

Ajuste [([Valor ByVal] type_name)]
   "Código
Definir Fim

O valor atribuído ao imóvel é passado para o método através do parâmetro especificado em
a instrução SET. O tipo especificado na declaração de Ajuste deve coincidir com o tipo especificado na
a declaração de propriedades. Alternativamente, a declaração de parâmetro pode ser omitido da
Definir declaração. Neste caso, o valor atribuído ao imóvel é passado para o método
através de uma chave especial chamado Valor. Por exemplo, esse cópias setter do passado em
valor a um membro de dados chamado classe MyDataMember:

Definir
   MyDataMember Valor =
Definir Fim

O tipo de dados de Valor é o mesmo que o tipo de dados da propriedade.

Palavras-chave End Property

Indica o final da definição de propriedade.

Revisão da definição de propriedade do Exemplo 2-7:

   "Esta propriedade permite que o usuário da classe para encontrar ou definir o
   "Centro de uma forma.
   Centro Público de Propriedade () como o ponto
      Obter
         Dim retval Como Point
         retval.X Origin.X = + (Size.XExtent \ 2)
         retval.Y Origin.Y = + (Size.YExtent \ 2)
         retval Retorno
      End Get
      Definir
         Dim currentCenter Como ponto = Centro
         Origin.X + = Value.X - currentCenter.X
         Origin.Y + = Value.Y - currentCenter.Y
      Definir Fim
   End Property

Esta é uma propriedade pública chamada Center, que tem um tipo de ponto. O getter retorna um valor de
Ponto tipo que é calculado a partir de alguns outros membros da classe. O compositor usa o
passou em valor a definir alguns outros membros da classe.








80
 
NET Programação Visual Basic.


2.14.8 O Me and palavras-chave MyClass

Existem várias maneiras de código para acessar os membros da classe em que o código está sendo executado. Contanto
como o membro que está sendo acessado não é escondido por uma declaração de nome, como no âmbito mais imediato,
ele pode ser referenciado sem qualificação:

Classe someClass Pública

   Público SomeValue As Integer

   Public Sub SomeMethod ()
      '...
      SomeValue = 5
      '...
   End Sub

End Class

Se o membro estiver oculto por uma declaração mais imediato, a palavra-chave Me pode ser usado para qualificar os
referência. As referências não qualificadas se referir a declaração mais local, como mostrado aqui:

Classe someClass Pública

   Público SomeValue As Integer

   Sub Público SomeMethod (SomeValue ByVal As Integer)
      '...
      "Atribuir o passado, no valor de um campo.
      Me.SomeValue SomeValue =
      '...
   End Sub

End Class

A palavra-chave Me é uma variável implícita que mantém uma referência à instância do objeto a execução do código.
Relacionado com a palavra-chave Me, mas sutilmente diferente, é a palavra-chave MyClass. Enquanto a palavra-chave Me pode ser
usado em qualquer contexto no qual uma referência de objeto é esperado, a palavra-chave MyClass é usado apenas para
o acesso de membros, que deve ser sempre seguido por um período eo nome de um membro, como mostrado aqui:

Classe someClass Pública

   Público SomeValue As Integer

   Sub Público SomeMethod (SomeValue ByVal As Integer)
      '...
      "Atribuir o passado, no valor de um campo.
      MyClass.SomeValue SomeValue =
      '...
   End Sub

End Class

Como você pode ver, há sobreposição de contextos em que estas duas palavras-chave pode ser usada, e para
maioria dos casos eles podem ser considerados sinônimos. No entanto, existem situações em que o
duas palavras diferentes:

• A palavra-chave que a mim não pode ser usado em métodos compartilhados, pois representa um objeto específico
instância da classe, métodos ainda compartilhada pode ser executado quando existe nenhuma instância.


81

 

As palavras-chave pode se comportar de maneira diferente quando usado em uma classe da qual outras classes são
derivados. Considere o seguinte código:
 

















 
Classe BaseClass Pública
   Sub Público Method1 ()
      Console.WriteLine ("Chamando Me.Method2 ...")
      
Me.Method2 ()
      Console.WriteLine ("Chamando MyClass.Method2 ...")
      MyClass.Method2 ()
   End Sub
   Sub Pública Overridable Method2 ()
      Console.WriteLine ("BaseClass.Method2")
   End Sub
End Class

Classe DerivedClass Pública
   Herda BaseClass
   Sub Público substitui Method2 ()
      Console.WriteLine ("DerivedClass.Method2")
   End Sub
End Class

Esse código define duas classes: BaseClass e DerivedClass.
BaseClass define dois métodos:
Method1 e Method2. DerivedClass herda Method1 mas prevê a sua própria implementação
para Method2.

Agora considere o seguinte instanciação de DerivedClass, bem como uma chamada por ele ao
Method1 método:

Dim d Como DerivedClass New ()
d.Method1 ()

Isso produz o seguinte resultado:

Invocando Me.Method2 ...
DerivedClass.Method2
Invocando MyClass.Method2 ...
BaseClass.Method2

A chamada para Method1 através do exemplo DerivedClass chama a implementação Method1
herdadas BaseClass. Method1 chama Method2 duas vezes: uma por meio da palavra e Me
uma vez através da palavra-chave MyClass. A palavra-chave Me é uma referência para o objeto real
exemplo, que é de DerivedClass tipo. Portanto, Me.Method2 () invoca o
execução DerivedClass classe de Method2. Em contraste, a palavra-chave MyClass é usado
para os membros de referência na classe em que o código for definido, o que neste caso é o
BaseClass classe. Portanto, MyClass.Method2 () chama a classe de BaseClass
implementação de Method2.
 

2.14.9 A Palavra MyBase

A palavra-chave MyBase é usado para acessar os métodos na classe base. Este recurso é comumente usado
quando um método de substituição deve chamar a implementação base-classe do mesmo método:

Classe BaseClass Pública
   Público DoSomething Sub Overridable ()
      '...


82
 
 



   End Sub
End Class
 
NET Programação Visual Basic.
 

Classe DerivedClass Pública
   Herda BaseClass
   Substitui Pública DoSomething Sub ()
      "Comece por chamar o implemenation da classe base DoSomething.
      MyBase.DoSomething ()
      "Então continue com o material adicional exigida pelo DerivedClass.
      '...
   End Sub
End Class

2.14.10 classes aninhadas

As definições de classe podem ser aninhados. A classe aninhada é considerado um membro da classe de fechamento. Como
com outros membros, a notação de ponto é usado para acessar a definição da classe interna. Considere esta aninhadas
definição de classe:

Classe OuterClass Pública
   Classe innerClass Pública
      Public Sub SomeMethod ()
         Console.WriteLine ("Olá de InnerClass.SomeMethod!")
      End Sub
   End Class
End Class

Instanciando um objeto do tipo innerClass exige a qualificação do nome com o nome do delimitador
classe:

Dim x As OuterClass.InnerClass New ()
x.SomeMethod ()

A acessibilidade da declaração da classe interna pode ser controlada com acesso a declaração de classe
modificador. Por exemplo, na seguinte definição, innerClass foi declarada com o privado
modificador, tornando-se visível somente dentro dos limites da classe OuterClass:

Classe OuterClass Pública
   Private innerClass Classe
      '...
   End Class
End Class

As aulas podem ser aninhados tão profundamente como desejado.

2.14.11 Destrutores

Assim como os construtores são métodos que são executados quando objetos são instanciados, muitas vezes é conveniente
definir métodos que são executados quando os objetos são destruídos (ou seja, quando a memória que foi alocada para
lhes é devolvida ao pool de memória livre). Tal método é chamado de destruidor. Visual Basic. NET
não tem sintaxe especial para declarar destruidores, como faz para construtores. Em vez disso, Visual
Basic. NET usa os métodos especialmente nomeados Finalize e Dispose para realizar o trabalho normalmente
associados destruidores. Como esse mecanismo é realmente parte do. NET Framework e não
do Visual Basic. NET, é explicado no capítulo 3, sob o título "Gerenciamento de memória e de lixo
Coleção ".





83
 
 



2.14.12 precoce e tardia Encadernação

Declarações permitir que o compilador conhece o tipo de dados do item que está sendo declarado. Aqui está o
declaração de uma variável do tipo String:

Dim s As String

Sabendo o tipo de dados de uma variável (ou parâmetro, campo, etc) permite que o compilador para determinar o que
operações são permitidas em qualquer objeto referenciado pela variável. Por exemplo, dado o anterior
declaração de s como String, o compilador sabe que o s.Trim expressão () é permitido (porque
é definido na classe String), enquanto s.Compact () não é (porque não há nenhum método como no
Classe String). Durante a compilação, o compilador Visual Basic. NET reclama se tais encontros
erros.

Há, no entanto, um caso em que o colaborador está autorizado a relaxar esta restrição. Se Option
Strict é desligado, o compilador renuncia a esse tipo de controlo sobre as variáveis do tipo Object. Para
exemplo, o seguinte código irá compilar sem dificuldade, mesmo que a classe Object não tem um
método chamado "Whatever":

Option Strict Off
'...
Dim obj As Object
obj.Whatever ()

Com off Option Strict, o compilador compila obj.Whatever () para código que verifica se o
Tipo de tempo de execução do objeto referenciado por obj é um tipo que possui um método que quer. Se isso acontecer,
Seja qual for o método é chamado. Se não, uma exceção de runtime será gerado. Aqui está um tal cenário:

Option Strict Off

Classe WhateverClass Pública
   Sub Público quer que ()
      Console.WriteLine ("Whatever!")
   End Sub
End Class

ClasseTeste Pública
   Public Shared Sub TestMethod ()
      Dim obj As Object
      obj WhateverClass = Nova ()
      obj.Whatever ()
   End Sub
End Class

Porque Option Strict estiver desligado, o código compila muito bem. Como referências obj objeto a
tempo de execução que é de uma classe que implementa um método que quer, ele também funciona muito bem. No entanto, consideramos
o que acontece se o método que quer que seja removido da classe WhateverClass:

Option Strict Off

Classe WhateverClass Pública
End Class

ClasseTeste Pública
   Public Shared Sub TestMethod ()
      Dim obj As Object
      obj WhateverClass = Nova ()
      obj.Whatever ()


84
 



   End Sub
End Class
 
NET Programação Visual Basic.
 

O código ainda compila sem nenhum problema, porque Option Strict estiver desligado. No entanto, em tempo de execução não
é um problema, como mostrado na Figura 2-2.

Figura 2-2. Um problema











A técnica de membros acessando através de um objeto genérico do tipo Object é chamada de ligação tardia.
"Late" significa que se o membro desejado está realmente lá não se sabe até que a instrução é
realmente executados. Em contraste, deixando Option Strict e acesso a membros somente através
variáveis que tenham sido declarados como o tipo apropriado é conhecido como ligação antecipada. "Cedo" significa
que se o acesso de membros é legítimo é conhecido em tempo de compilação.

Late binding é menos eficiente que a vinculação antecipada porque as verificações adicionais são necessários em tempo de execução
determinar se o membro realmente existe solicitada sobre o objeto em tempo de execução e, se isso acontecer, a
acesso desse membro. A pior parte de ligação tardia é que ele pode mascarar certos erros de programa (como o
mistyped nomes de membros), até a execução. Em geral, esta é uma prática má programação.

2,15 Interfaces

É útil fazer uma distinção entre a interface de uma classe e sua implementação. Conceitualmente, o
interface de uma classe é o conjunto de membros que são visíveis para os usuários da classe, ou seja, a classe é pública
membros. Os membros públicos são considerados como sendo o interface da classe, pois eles são os
única maneira que o código fora da classe podem interagir (ou seja, interface) com objetos dessa classe. Em
contrapartida, a aplicação é composta de código da classe mais o conjunto de membros que não são
públicas.

É possível levar este conceito de interface de definição de interface, distinta da definição de classe
completamente. Isso tem vantagens que serão mostradas em breve. Para definir uma interface, use a interface
declaração:

Público ISomeInterface Interface
   Sub SomeSub ()
   Função someFunction () As Integer
   Propriedade SomeProperty () As String
   Evento SomeEvent (_
      ByVal sender As Object, _
      ByVal e As _ SomeEventArgs
   )
End Interface

Uma declaração de interface define os métodos, propriedades e eventos que acabará por ser executado
por alguma definição de classe ou estrutura. Porque interfaces não inclui qualquer aplicação, o
declarações são apenas cabeçalhos, nunca nenhum código de implementação; End Sub End Function ou End
declarações de propriedade, ou propriedade get ou definir blocos. Não existem modificadores de acesso (público,
Privadas, etc), pois todos os membros de uma interface são públicos por definição. Por convenção, a interface
nomes começam com a letra "I".


85
 
 



Para fornecer uma implementação para uma determinada interface, é necessário definir uma classe ou estrutura. Para
exemplo, a seguinte classe implementa a interface definida anteriormente:

Classe someClass Pública
   "Isso indica que a classe implementa os métodos,
   "Propriedades e eventos da interface ISomeInterface.
   Implementa ISomeInterface

   'Este método implementa o método SomeSub do
   'Interface ISomeInterface.
   Private Sub SomeSub () Implementa ISomeInterface.SomeSub
      '...
   End Sub

   'Este método implementa o método someFunction do
   'Interface ISomeInterface.
   SomeFunction Private Function () As Integer _
      Implementa ISomeInterface.SomeFunction
      '...
   End Function

   "Esta propriedade implementa a propriedade da SomeProperty
   'Interface ISomeInterface.
   SomeProperty Propriedade Privada () As String _
      Implementa ISomeInterface.SomeProperty
      Obter
         '...
      End Get
      Definir
         '...
      Definir Fim
   End Property
   "Este evento implementa o evento SomeEvent do
   'Interface ISomeInterface.
   SomeEvent Evento Privado (_
      ByVal sender As Object, _
      ByVal e As _ SomeEventArgs
   ) Implementa ISomeInterface.SomeEvent
End Class

Os elementos-chave desta definição de classe são:

• O cabeçalho da declaração de classe é imediatamente seguida pela instrução Implements,
indicando que esta classe irá expor a interface ISomeInterface:
 

















86
 



 
Classe someClass Pública
   "Isso indica que a classe implementa os métodos,
   "Propriedades e eventos da interface ISomeInterface.
   Implementa ISomeInterface

Esta informação é compilada para a classe. usuários de classe podem descobrir se uma determinada classe
implementa uma determinada interface, tentando atribuir a referência de objeto para uma variável que
tenha sido declarado o tipo de interface, como este:

Dim obj As Object
Dim IFCE Como ISomeInterface
'...
"Obter uma referência de objeto de algum lugar.
 
 
NET Programação Visual Basic.


obj someClass = Nova ()
'...
"Tentar converter a referência de objeto a uma referência do tipo
"ISomeInterface. Se o objeto implementa a ISomeInterface
'Interface, a conversão bem-sucedida. Se o objeto não
"Implementar a interface ISomeInterface, uma exceção de
"InvalidCastException tipo (definido no namespace System)
"É lançada.
IFCE = CType (obj, ISomeInterface)

• Para cada método, propriedade e evento na interface, há um método correspondente,
propriedade, ou de evento na classe que tem exatamente a mesma assinatura e valor de retorno. A
nomes não tem de corresponder, apesar de coincidir com o exemplo.
• O cabeçalho da declaração de cada método, propriedade e evento na classe que implementa um
item correspondente na interface deve ter uma cláusula implements. Esta é a palavra-chave
Implements seguido pelo nome qualificado da interface de propriedade, método ou evento que está sendo
implementadas.

Outras coisas a notar sobre interfaces de aplicação incluem:

• O acesso modificadores na declaração da classe-membro não precisa ser público. Observe que no
exemplo, todos os membros são marcados como privados. Isto significa que os membros são
acessível somente quando acessado através da interface ISomeInterface. Isso será mostrado
em um momento.
• A definição de classe pode incluir membros que não fazem parte da interface implementada.
Estes podem ser públicos, se desejar. Isso resulta em uma classe que efetivamente tem duas interfaces: a
interface padrão, que é o conjunto de membros definido como público na definição de classe e
a interface implementada, que é o conjunto de membros definido na interface chamada no
Implementa comunicado.
• As aulas estão autorizados a implementar várias interfaces.

Para acessar membros definidos por uma interface, declare uma variável como o tipo de interface e manipular
o objeto através dessa variável. Por exemplo:

Dim x As someClass ISomeInterface = Novo ()
x.SomeFunction ()

Esse código declara x como uma referência a um objeto do tipo ISomeInterface. Isso mesmo: interface
definições definir novos tipos. Declarada desta forma, x pode ter uma referência a qualquer objeto que
implementa a interface ISomeInterface e aceder a todos os membros que ISomeInterface
define, confiante de que o objeto subjacente pode lidar com essas chamadas. Este é um recurso poderoso de
definição e implementação de interfaces explícitas. Objetos que explicitamente implementa uma interface pode ser
usado em qualquer contexto no qual a interface é esperado; objetos que podem implementar várias interfaces
ser usado em qualquer contexto no qual qualquer uma das interfaces é esperado.

As definições de interface pode herdar as definições de interface da mesma forma que as classes podem herdar
de outras classes. Por exemplo:

Público ISomeNewInterface Interface
   Herda ISomeInterface
   Sub SomeNewSub ()
End Interface

Isso define uma nova interface chamada ISomeNewInterface que tem todos os membros da
ISomeInterface interface mais um membro novo, chamado SomeNewSub. Qualquer classe ou estrutura que
implementa a interface ISomeNewInterface deve implementar todos os membros de ambas as interfaces. Qualquer



87
 



tal classe é então considerada como implementar ambas as interfaces e poderia ser usado em qualquer contexto onde
quer ISomeInterface ou ISomeNewInterface é necessária.

Estruturas 2,16

Estruturas de definir tipos de valor. Variáveis de uma loja tipo de valor um valor real, em oposição a uma
referência a um valor armazenado em outros lugares. Compare isso com as classes que definem tipos de referência.
Variáveis de uma loja tipo de referência de uma referência (um ponteiro) para o valor real. Veja a discussão sobre
tipos de valor versus tipos de referência na Seção 2.5, anteriormente neste capítulo. Exemplo 2-8 mostra um
estrutura de definição.

Exemplo 2-8. A definição da estrutura
Público complexa estrutura
   "A interface IFormattable fornece um mecanismo genérico para
   "Pedindo um valor para representar a si mesmo como uma string.
   Implementa IFormattable

   "Estes membros privados armazenar o valor do número complexo.
   m_RealPart Private As Double
   m_ImaginaryPart Private As Double

   "Estes campos fornecer valores potencialmente útil, semelhante ao
   'Valores correspondentes no tipo Double. Eles são inicializados
   "No construtor compartilhada. O modificador ReadOnly indica que
   'Eles só pode ser definido em um construtor.
   Public Shared ReadOnly MaxValue tão complexo
   Public Shared ReadOnly MinValue tão complexo

   "Este é um construtor compartilhada. Ele é executado uma vez pelo tempo de execução
   "Antes de qualquer outro acesso ao Complexo tipo ocorre. Note novamente
   'Que este é executado apenas uma vez na vida do programa - não uma vez
   'Para cada instância. Note também que nunca há um acesso
   "Modificador de construtores compartilhada.
   Shared Sub New ()
      MaxValue Complexo = Novo (Double.MaxValue, Double.MaxValue)
      MinValue Complexo = Novo (Double.MinValue, Double.MinValue)
   End Sub
   "A propriedade realpart dá acesso à parte real da
   'Número complexo.
   Público realpart Propriedade () As Double
      Obter
         m_RealPart Retorno
      End Get
      Set (ByVal Valor As Double)
         m_RealPart = Valor
      Definir Fim
   End Property
   "A propriedade ImaginaryPart dá acesso à parte imaginária
   'Do número complexo.
   Público ImaginaryPart Propriedade () As Double
      Obter
         m_ImaginaryPart Retorno
      End Get
      Set (ByVal Valor As Double)
         m_ImaginaryPart = Valor
      Definir Fim
   End Property


88
 
NET Programação Visual Basic.



   "Este é um construtor parametrizado permitindo a inicialização do
   "Um número complexo com os seus valores reais e imaginários.
   Sub New Public (_
      _ ByVal realpart Como casal,
      Como ImaginaryPart ByVal _ Double
   )
      m_RealPart = realpart
      m_ImaginaryPart = ImaginaryPart
   End Sub

   'Esta função calcula a soma dos dois valores complexos.
   Adicionar Função Pública Compartilhada (_
      ByVal Valor1 tão complexo, _
      _ ByVal Value2 Como Complexo
   ) Como complexo
      Dim retval tão complexo
      retval.RealPart = Value1.RealPart + Value2.RealPart
      retval.ImaginaryPart = Value1.ImaginaryPart + Value2.ImaginaryPart
      retval Retorno
   End Function

   'Esta função calcula a diferença de dois valores complexos.
   Public Shared Function Subtrai (_
      ByVal Valor1 tão complexo, _
      _ ByVal Value2 Como Complexo
   ) Como complexo
      Dim retval tão complexo
      retval.RealPart = Value1.RealPart - Value2.RealPart
      retval.ImaginaryPart = Value1.ImaginaryPart - Value2.ImaginaryPart
      retval Retorno
   End Function

   'Esta função calcula o produto dos dois valores complexos.
   Public Shared Function Multiply (_
      ByVal Valor1 tão complexo, _
      _ ByVal Value2 Como Complexo
   ) Como complexo
      Dim retval tão complexo
      retval.RealPart = Value1.RealPart * _ Value2.RealPart
         - Value1.ImaginaryPart Value2.ImaginaryPart *
      retval.ImaginaryPart = Value1.RealPart * _ Value2.ImaginaryPart
         + Value2.RealPart * Value1.ImaginaryPart
      retval Retorno
   End Function

   'Esta função calcula o quociente de dois valores complexos.
   Divida Pública função compartilhada (_
      ByVal Valor1 tão complexo, _
      _ ByVal Value2 Como Complexo
   ) Como complexo
      Dim retval tão complexo
      As Double Dim numerator1
      As Double Dim numerator2
      As Double Dim denominador

      numerator1 = Value1.RealPart * _ Value2.RealPart
         + Value2.ImaginaryPart * Value1.ImaginaryPart
      numerator2 = Value1.ImaginaryPart * _ Value2.RealPart
         - Value1.RealPart Value2.ImaginaryPart *
      denominador = ^ ^ Value2.RealPart 2 + 2 Value2.ImaginaryPart
 







































































89
 




      retval.RealPart numerator1 denominador = /
      retval.ImaginaryPart numerator2 denominador = /
      retval Retorno
   End Function

   "Essa função implementa IFormattable.ToString. Porque é
   Declarados privados, essa função não faz parte do Complexo
   'Interface padrão do tipo. Note que o nome da função precisa
   Não coincidir com o nome, conforme declarado na interface, nem precisa
   "Será no formato mostrado aqui.
   IFormattable_ToString Private Function (_
      formato ByVal As String, _
      ByVal formatProvider Como IFormatProvider _
   ) As String Implements IFormattable.ToString
      Dim realFormatter Como IFormattable m_RealPart =
      Dim imaginaryFormatter Como IFormattable m_ImaginaryPart =
      realFormatter.ToString Retorno (formato, formatProvider) & "+" _
         & ImaginaryFormatter.ToString (formato, formatProvider) e "i"
   End Function

   "Essa função formata o valor do complexo como uma cadeia.
   Substitui Função Pública ToString () As String
      CType Retorno (Me, IFormattable). ToString (nada, nada)
   End Function

End Structure 'Complex

definições de estrutura pode incluir campos, propriedades, métodos, construtores e muito mais, qualquer membro, em
fato, que uma definição de classe pode ter. Ao contrário de definições de classe, no entanto, as estruturas são limitados em
várias maneiras:

• As estruturas não estão autorizados a herdar de qualquer outro tipo. (No entanto, as estruturas implicitamente
herdam System.ValueType, que por sua vez herda de Object.)
• As estruturas não podem substituir métodos herdados implicitamente System.ValueType.
• Nenhum tipo pode herdar de uma estrutura.
• As estruturas não estão autorizados a ter um construtor sem parâmetros. Considere esta matriz
declaração:

Dim a (1000000) Como SomeStructure

Quando um array de tipos de valor é criada, ela é imediatamente preenchida com instâncias do valor
tipo. Esse comportamento corresponde ao que você esperaria de um array mantendo um tipo primitivo
(Como Integer). Se construtores sem parâmetros foram autorizados para as estruturas, esta matriz
declaração resultaria em 1.000.000 chamadas para o construtor. Ouch.

• As estruturas não estão autorizados a ter destruidores.
• Os membros do campo em estruturas não estão autorizados a ser inicializado em suas declarações. Este
inclui os casos especiais de uso como novo tipo na declaração ou especificando um tamanho inicial
em uma declaração de matriz.

2.16.1 Boxing e Unboxing

Tipos de valor são otimizados para o tamanho ea velocidade. Eles não carregam a mesma quantidade de sobrecarga
como tipos de referência. Não seria muito eficiente se cada inteiro de quatro bytes também levou em torno de quatro
referência byte. Há tempos, porém, ao tratar os tipos de valor e tipos referência em um
forma polimórfica seria bom. Considere esta declaração de método, que leva qualquer número de
argumentos de qualquer tipo e processa-los de alguma forma:


90
 
NET Programação Visual Basic.


Public Shared Sub impressão (ParamArray objArray ByVal () As Object)

   Dim obj As Object

   Para cada obj Em objArray
      '...
   Seguinte

End Sub

Claramente, objArray é uma matriz de tipos de referência, e obj é um tipo de referência. No entanto, seria bom
passe tipos por valor e referência ao método, como este:

Print ("Olá, mundo", someObject, 4, True)

Na verdade, isso é possível. Quando um tipo de valor é atribuída a uma variável do tipo Object ou passados em uma
parâmetro do tipo Object, ele passa por um processo conhecido como boxe. Para caixa de um tipo de valor significa
alocar memória para armazenar uma cópia do valor, em seguida, copiar o valor para que a memória e, finalmente,
manipular ou armazenar uma referência para o valor. Unboxing é o processo inverso: tendo uma referência a um
tipo de valor e copiar o valor referenciado em um tipo de valor real.

Boxing e unboxing são feitas em seu nome pelo. NET, não há nada que você tem que fazer para
facilitá-la. Você deve estar ciente de que, no entanto, porque a caixa e as operações de desencaixotar não são livres.

2,17 Enumerações

Uma enumeração é um tipo cujos valores são explicitamente nomeados pelo criador do tipo. A NET.
Framework e Visual Basic. NET definir enumerações muitos para o seu e usar o seu. Além disso,
Visual Basic. NET fornece uma sintaxe para a definição de enumerações novo. Aqui está um exemplo:

Público Rainbow Enum
   Vermelho
   Laranja
   Amarelo
   Verde
   Blue
   Índigo
   Violeta
End Enum

Esta declaração estabelece um novo tipo, chamado de arco-íris. Os identificadores listados dentro do corpo do
declaração se valores constantes que podem ser atribuídas a variáveis do tipo arco-íris. Aqui está um
declaração de uma variável do tipo arco-íris e uma atribuição inicial para ele:

Dim myRainbow como arco-íris = Rainbow.Blue

Note que o nome do valor é qualificado pelo nome do tipo.

Enumerações são tipos de valor que implicitamente herdam o tipo. NET Framework System.Enum
(Que por sua vez herda de System.ValueType). Isso significa que cada enumeração tem acesso à
membros definidos pelo System.Enum. Um desses membros é o método ToString, que retorna um string
contendo o nome do valor. Isso é útil para impressão:

Dim myRainbow como arco-íris = Rainbow.Blue
Console.WriteLine ("O valor da myRainbow é:" & myRainbow.ToString ())

Esse código resulta na seguinte saída:


91
 



O valor da myRainbow é: Azul

Os valores de uma enumeração são considerados como requisitado. Assim, as comparações são permitidas entre
variáveis do tipo de enumeração:

Dim myRainbow como arco-íris
Dim yourRainbow como arco-íris
'...
Se yourRainbow <myRainbow seguida
   '...
End If

Variáveis de um tipo de enumeração pode ser usado como índice em declarações For ... Next. Por exemplo:

Para myRainbow = Rainbow.Red Para Rainbow.Violet
   '...
Seguinte

Internamente, o Visual Basic. NET e. NET Framework usam valores do tipo inteiro para representar a
valores da enumeração. O compilador começa com 0 e atribui valores crescentes a cada Inteiro
nome na enumeração. Às vezes, é útil para substituir os valores padrão que são Integer
atribuído a cada nome. Isto é feito adicionando um inicializador para cada enumeração constante. Para
exemplo:

Enum MyLegacyErrorCodes Pública
   NoError 0 =
   FileNotFound -1000 =
   OutOfMemory -1001 =
   InvalidEntry -2000 =
End Enum

Também é possível especificar o tipo de valor subjacente. Por exemplo:

Público Rainbow ENUM como Byte
   Vermelho
   Laranja
   Amarelo
   Verde
   Blue
   Índigo
   Violeta
End Enum

Esta poderia ser uma importante medida de economia de espaço, se muitos valores da enumeração será armazenado
em algum lugar. Os únicos tipos que podem ser especificados para uma enumeração são Byte, Short, Integer e
Long.

Às vezes, enumerações são usadas como bandeiras, com a idéia de que vários sinalizadores podem ser combinados em um
único valor. Essa enumeração de um pode ser definida usando o atributo Flags. (Atributos são
. Discutido mais tarde neste capítulo) Aqui está um exemplo:

<Flags( )> Rainbow Enum Pública
   Red 1 =
   Laranja = 2
   Amarelo = 4
   Verde = 8
   Azul 16 =
   Indigo 32 =


92
 



   Violeta = 64
End Enum
 
NET Programação Visual Basic.
 

Observe duas coisas importantes nesta definição:

• A primeira linha da definição começa com )> <Flags(. Isso indica que os valores deste tipo
pode ser composto de vários itens da enumeração.
• Os itens na enumeração tem valores que são potências de dois. Isto assegura que cada
combinação de itens tem um valor único. Por exemplo, a combinação de amarelo, azul e
Violeta tem uma soma de 84, que não pode ser alcançado com qualquer outra combinação de itens.

Os valores individuais são combinados usando o operador OR.

O método ToString é inteligente o suficiente para resolver os nomes de valor ao criar uma seqüência de
representação do valor. Por exemplo, dada a atribuição anterior, considere a seguinte chamada para
o método ToString:

Console.WriteLine (myRainbow.ToString ())

Essa declaração produz o seguinte resultado:

Verde, Azul

Exceções 2,18

Às vezes, erros ou condições excepcionais proibir um programa de continuar a sua atividade atual. A
exemplo clássico é a divisão por zero:

Integer Dim x As = 0
y Dim Inteiro As = 1 \ x

Quando o processo atinge a linha que contém a divisão inteira, ocorre uma exceção. Uma exceção é
qualquer ocorrência que não é considerada parte do fluxo normal do programa, o esperado. O detecta a execução, ou
capturas, essa exceção e toma as medidas apropriadas, geralmente resultando no término do delito
programa. Figura 2-3 mostra a caixa de mensagem que é exibida quando esse código é executado dentro do Visual
Studio. NET IDE.

Figura 2-3. A divisão por zero exceção











Visual Basic. NET programas podem e devem ser escritas para capturar exceções si. Isso é feito
por quebra de código potencialmente perigoso em Try End ... Tente blocos. Exemplo 2-9 mostra como
pegar a divisão por zero exceção.

Exemplo 2-9. Pegar uma exceção
Experimente
   Integer Dim x As = 0
   y Dim Inteiro As = 1 \ x


93
 
 



Catch e As Exception
   Console.WriteLine (e.Message)
End Try

Quando o programa tenta a divisão por zero, ocorre uma exceção, e execução do programa salta
para a primeira instrução no bloco Catch. A instrução Catch declara uma variável do tipo Exception
que recebe informações sobre a exceção que ocorreu. Esta informação pode então ser usado dentro
bloco catch para gravar ou o relatório de exceção, ou de tomar medidas correctivas. O código anterior
apenas exibe a mensagem associada a exceção que ocorreu, como mostrado aqui:

Tentativa de divisão por zero.

Depois de executar os comandos do bloco catch, a execução do programa continua com o que se segue
End Try. Tente em blocos em que nenhuma exceção ocorrer, a execução continua até
a última declaração do bloco Try e ignora as instruções no bloco Catch.

A variável declarada na instrução Catch do Exemplo 2-9 é do tipo Exception (definido no
Namespace System). Todas as exceções são representadas por tipos que derivam, direta ou indiretamente,
do tipo Exception. A cláusula type_name da instrução Catch especifica o tipo de
ressalva de que o bloco de código associado pode manipular. As exceções do tipo indicado, ou de qualquer
tipo derivado (directa ou indirectamente) a partir do tipo indicado, são manipuladas pelo bloco dos associados
código.

Olhe novamente para a instrução Catch do Exemplo 2-9:

Catch e As Exception

Porque todas as exceções derivam do tipo de exceção, qualquer exceção que ocorre durante a execução do
o bloco Try no Exemplo 2-9 resulta na execução do bloco Catch. Este comportamento pode ser modificado
fornecendo um tipo de exceção mais específica na declaração Catch. Exemplo 2-10 é idêntico ao
Exemplo 2-9, exceto que ela só apreende a dividir por zero exceções.

Exemplo 2-10. Pegar uma exceção específica
Experimente
   Integer Dim x As = 0
   y Dim Inteiro As = 1 \ x
catch e como System.DivideByZeroException
   Console.WriteLine (e.Message)
End Try

Se qualquer exceção que não DivideByZeroException viesse a ocorrer no bloco try do Exemplo 2-10,
não seria detectada pelo código mostrado. O que acontece, nesse caso, depende do resto do código
no programa. Tente Fim ... Tente blocos podem ser aninhados, por isso, se há uma volta Try End ... Experimente
bloco com uma instrução Catch adequado, ele vai pegar a exceção. Alternativamente, se a chamada de rotina
sofás da chamada de método dentro de um Try End ... Tente ter um bloco de instrução Catch adequado,
execução salta para fora do método atual e para o bloco CATCH associado na rotina de chamada.
Se nenhum bloco Catch adequado existe na rotina de chamada, a busca por um prendedor apropriado continua até
a cadeia de chamada até que seja encontrado ou até que todas as chamadas foram analisados. Se nenhum bloco Catch adequado
existe em qualquer lugar na cadeia de chamada, o ambiente runtime captura a exceção e finaliza a
pedido.

Tente Fim ... Tente blocos pode incluir vários blocos Catch, que permite exceções diferente a ser
tratada de formas diferentes. Por exemplo, o código a seguir lida com duas excepções específicas, permitindo
todos os demais, não tratada:

Experimente


94
 



   '...
 
NET Programação Visual Basic.
 
catch e como System.DivideByZeroException
   '...
catch e como OverflowException
   '...
End Try

Como todos os tipos de exceções são derivadas do tipo de exceção, as propriedades e métodos do
Tipo de exceção estão disponíveis em todos os tipos de exceção. Na verdade, a maioria dos tipos de exceção não define qualquer
propriedades ou métodos adicionais. A única razão que eles são definidos como tipos específicos é assim que eles podem
especificamente ser capturado. As propriedades da classe Exception são:

HelpLink

Uma URN ou URL que vincula a um tópico de ajuda de arquivo que explica o erro com mais detalhes. O tipo é
String.

HResult

Um HRESULT COM representa a exceção. Isto é usado para interoperar com COM
componentes (um tópico que não é discutido neste livro). O tipo é inteiro.

InnerException

Às vezes, um método pode optar por lançar uma exceção porque ele pegou uma exceção
alguns chamam de outro método interno. O método externo gera uma exceção que é
significativo para ele e seu interlocutor, mas a exceção lançada pelo método interno também deve ser
comunicada para o chamador. Este é o propósito da propriedade InnerException. Esta propriedade
contém uma referência para o exceção interna (se houver) que levou à exceção atual. A
tipo é exceção.

Mensagem

A mensagem associada a exceção. Em geral, esta é uma descrição do estado
que levou à exceção e, sempre que possível, uma explicação de como corrigi-lo. O tipo é
String.

Fonte

O nome do aplicativo ou objeto no qual a exceção ocorreu. O tipo é String.

StackTrace

Uma representação textual da chamada do programa da pilha no momento em que ocorreu a exceção. A
tipo é String.

TargetSite

Uma referência a um objeto do tipo MethodBase (definido no namespace System.Reflection)
que representa o método no qual a exceção ocorreu. Se o sistema não é possível obter essa
informação, esta propriedade contém nada.

Os métodos da classe Exception são:

GetBaseException




95
 
 



Conforme discutido para a propriedade InnerException, indica que a exceção atual pode ser a
exceção final de uma cadeia de exceções. O método GetBaseException retorna a primeira
exceção na cadeia. Este método leva sem parâmetros. O tipo de retorno é exceção.

GetObjectData

Serializa o objeto em um objeto de exceção SerializationInfo (um processo não será discutido neste
livro). A sintaxe é:

Overridable GetObjectData Sub Pública (_
   Como ByVal info SerializationInfo, _
   No contexto ByVal _ StreamingContext
) Implementa ISerializable.GetObjectData
ToString

Retorna uma representação de texto da exceção. Isso inclui o tipo de exceção, a mensagem
o rastreamento de pilha, e outras informações semelhantes para todas as exceções interior.

Quando ocorre uma exceção, não existe a possibilidade de repetir a declaração que causou a exceção. Se
tal comportamento é desejado, ele deve ser explicitamente codificado. Aqui está uma possibilidade:

Dim bSuccess As Boolean = False
Não
   Experimente
      "Alguns de código que deve ser protegido.
      '...
      bSuccess = True
   Catch e As Exception
      "Algumas medidas de recuperação.
      '...
   End Try
Loop Até bSuccess

Às vezes, você deve garantir que determinado código é executado, independentemente de haver ou não uma exceção.
Por exemplo, se um arquivo é aberto, o arquivo deve ser fechado, mesmo quando ocorre uma exceção. Tente ... Fim
Tente blocos podem incluir Finalmente blocos para esta finalidade. Código que aparece em um bloco Finally é
executado independentemente de uma exceção ocorre. Se nenhuma exceção ocorrer, os comandos do
Por último bloco são executados após as declarações no bloco Try foram executados. Se um
exceção ocorre, as declarações no bloco Finally é executado após as declarações na
bloco catch que lida com a exceção são executados. Se a exceção não é tratada, ou se houver
nenhum bloco catch, as declarações no último bloco são executadas antes de encaminhar a exceção
encerrando a qualquer manipuladores de exceção. Aqui está um exemplo do uso de um bloco Finally:

Dim s Como System.IO.Stream _ =
   System.IO.File.Open ("c: teste.txt \", System.IO.FileMode.CreateNew)
Experimente
   "Faça alguma coisa com o fluxo livre.
   '...
Catch e As Exception
   "Manipular exceções.
   '...
Finalmente
   "O fluxo deve ser fechado ou não existe um erro.
   s.Close ()
End Try

Visual Basic aplicações. NET pode deliberadamente lançar exceções para indicar erros ou incomuns outros
ocorrências. Por exemplo, se um método está esperando um argumento que está dentro de uma faixa específica e os


96
 
NET Programação Visual Basic.


valor real passado para o método está fora dessa faixa, o método pode lançar uma exceção do tipo
ArgumentOutOfRangeException (definido no namespace System). Isto é feito com a reposição
declaração, conforme mostrado no Exemplo 2-11.

Exemplo 2-11. Lançando uma exceção
Sub Público SomeMethod (MyParameter ByVal As Integer)
   "Certifique-se que o argumento é válido.
   Se (MyParameter <10) ou (MyParameter> 100) então
      Jogue ArgumentOutOfRangeException New ()
   End If
   "Resto do método.
   '...
End Sub

A declaração Throw exige uma instância de algum tipo derivado do tipo Exception. Quando o
Throw é atingido, o tempo de procura por um bloco Catch apropriados no código de chamada para
tratar a exceção. Se nenhum bloco Catch adequado é encontrado, o tempo de captura a exceção e se
encerra o aplicativo. Consulte o Apêndice B para uma lista de tipos de exceção definida no Sistema
namespace.

Visual Basic. NET pode criar seus próprios tipos de exceções simplesmente declarando tipos que
derivam do tipo Exception. Exemplo 2-12 mostra como a manipulação de exceção do Exemplo 2-11
pode ser mais específica para o erro real que ocorre. No Exemplo 2-12, um novo tipo de exceção
MyParameterOutOfRangeException chamada é declarada. Em seguida, é mostrado um método que gera esta
exceção. Por fim, é mostrado um método que manipula a exceção.

Exemplo 2-12. Definindo e usando uma exceção personalizada
"Definir uma classe de exceção personalizada para representar uma condição de erro específica.
Público MyParameterOutOfRangeException Classe
   Herda Exceção
   Sub New Public ()
      "O tipo de exceção tem um construtor que leva uma mensagem de erro
      'Como seu argumento. Porque a propriedade Message da exceção
      'Type é somente leitura, usando esse construtor é a única maneira que
      "A propriedade de mensagem pode ser definido.
      MyBase.New ("O valor passado no parâmetro MyParameter" _
         E "está fora do intervalo. O valor deve estar na faixa de" _
         E "10 a 100.")
   End Sub
End Class
'...

   "Definir um método que pode lançar uma exceção personalizada.
   Sub Público SomeMethod (MyParameter ByVal As Integer)
      "Certifique-se que o argumento é válido.
      Se (MyParameter <10) ou (MyParameter> 100) então
         Jogue MyParameterOutOfRangeException New ()
      End If
      "Resto do método.
      '...
   End Sub
'...

   "Chame o método SomeMethod, pegando apenas os
   «Excepção MyParameterOutOfRangeException.
   Público SomeCaller Sub ()


97

 

Try

         SomeMethod(500)

      Catch e As MyParameterOutOfRangeException

         ' ...

      End Try

   End Sub

What About On Error?

Visual Basic 6 não tinha objetos de exceção e Try ... Catch blocos.
Em vez disso, usou a declaração On Error para especificar uma linha dentro da atual
procedimento para que a execução deve saltar se ocorreu um erro. O código em
que momento do procedimento poderia, então, examinar o objeto Err intrínseca à
determinar o erro que havia ocorrido. Para compatibilidade com versões anteriores
versões, o Visual Basic. NET continua a apoiar o On Error e afins
declarações, mas não deve ser utilizado em empreendimento, para o
pelas seguintes razões:

• manipulação de exceção estruturada é mais flexível.
• manipulação de exceção estruturada não utiliza os códigos de erro. (Application-
códigos de erro definidos, muitas vezes entrou em choque com códigos de erro definidos por outros
aplicações.)
• manipulação de exceção estruturada existe no. Nível NET Framework,
o que significa que, independentemente do idioma no qual cada componente é
escrito, exceções podem ser geradas e capturadas através de componentes
limites.

Tratamento de erros com o On Error e as declarações relacionadas não são discutidos
neste livro.

Delegados 2,19

Um delegado é um tipo definido pelo programador que abstrai a capacidade de chamar um método. Um delegado de tipo
declaração inclui a declaração do tipo de assinatura e de retorno que o delegate encapsula.
Instâncias do tipo de delegado pode então envolver qualquer método que expõe a mesma assinatura e retorno
tipo, independentemente da classe em que o método é definido e se o método é uma instância
método ou método compartilhado da classe definição. O método, portanto, envolvido pode ser chamado através do
delegado objeto. O mecanismo delegado fornece polimorfismo para métodos com o mesmo
assinatura e tipo de retorno.

Delegados são muitas vezes utilizados para implementar mecanismos de retorno. Imagine uma classe que será usada por um
programa que você está escrevendo. Essa classe fornece algumas funcionalidades úteis, incluindo a capacidade de chamar a
um método que você deve implementar no seu programa. Talvez esse mecanismo de callback é fornecida
para alimentar os dados do programa, ela se torna disponível na classe que você está usando. Uma maneira de alcançar este
capacidade é através do uso de delegados. Veja como:

1. O escritor da classe que você está usando (chamemos-lhe uma classe de servidor), declara um tipo de representante público que
define o valor da assinatura e de retorno do método que irá implementar.
2. O escritor da classe de servidor expõe um método para os clientes da classe para passar em uma instância
do tipo delegado.
3. Você implementar um método com a assinatura apropriada e retornar o valor.
4. Você instanciar um novo objeto do tipo delegado.
5. Você conecta o seu método para a instância delegado.
6. Você chamar o método definido na etapa 2, que passa na sua instância do delegate.



98
 
NET Programação Visual Basic.


7. A classe de servidor agora tem uma instância do delegate que envolve o seu método. A classe pode chamar de seu
método através do delegado a qualquer momento.
8. Dependendo da aplicação, ele pode ser apropriado para o escritor da classe de servidor para
fornecer um método que permite que o aplicativo cliente para desconectar seu delegado do servidor para
parar de receber callbacks.

Exemplo 2-13 mostra um exemplo deste mecanismo.

Exemplo 2-13. Definindo e usando um tipo de delegado para implementar um
mecanismo de callback

 

' This class is defined in the server component.

Public Class ServerClass

 

   ' Even though the following declaration looks similar to a

   ' method declaration, it is actually a type declaration. It

   ' compiles to a type that ultimately derives from the

   ' System.Delegate type. The purpose of the method syntax in

   ' this declaration is to define the signature and return type

   ' of the methods that instances of this delegate type are able

   ' to wrap.

   Public Delegate Sub MessageDelegate(ByVal msg As String)

 

   ' The following is a private field that will hold an instance of

   ' the delegate type. The instance will be provided by the client

   ' by calling the RegisterForMessages method. Even though this

   ' field can hold only a single delegate instance, the

   ' System.Delegate class itself is designed such that a

   ' delegate instance can refer to multiple other delegate

   ' instances. This feature is inherited by all delegate types.

   ' Therefore, the client will be able to register multiple

   ' delegates, if desired. See the RegisterForMessages and

   ' UnregisterForMessages methods in the current class to see

   ' how multiple delegates are saved.

   Private m_delegateHolder As MessageDelegate = Nothing

 

   ' The client calls the RegisterForMessages method to give the

   ' server a delegate instance that wraps a suitable method on

   ' the client. 

   Public Sub RegisterForMessages(ByVal d As MessageDelegate)

      ' The System.Delegate class's Combine method takes two

      ' delegates and returns a delegate that represents them

      ' both. The return type is System.Delegate, which must be

      ' explicitly converted to the appropriate delegate type.

      Dim sysDelegate As System.Delegate = _

         System.Delegate.Combine(m_delegateHolder, d)

      m_delegateHolder = CType(sysDelegate, MessageDelegate)

   End Sub

 

   ' The client calls the UnregisterForMessages method to tell

   ' the server not to send any more messages through a

   ' particular delegate instance.

   Public Sub UnregisterForMessages(ByVal d As MessageDelegate)

      ' The System.Delegate class's Remove method takes two

      ' delegates. The first is a delegate that represents a list

      ' of delegates. The second is a delegate that is to be

      ' removed from the list. The return type is

      ' System.Delegate, which must be explicitly converted to

      ' the appropriate delegate type.

      Dim sysDelegate As System.Delegate = _

         System.Delegate.Remove(m_delegateHolder, d)

 

 

99


 

 

 

      m_delegateHolder = CType(sysDelegate, MessageDelegate)

   End Sub

 

   ' The DoSomethingUseful method represents the normal

   ' processing of the server object. At some point during normal

   ' processing, the server object decides that it is time to

   ' send a message to the client(s).

   Public Sub DoSomethingUseful(  )

      ' ...

      ' Some processing has led up to a decision to send a

      ' message. However, do so only if a delegate has been

      ' registered.

      If Not (m_delegateHolder Is Nothing) Then

         ' The delegate object's Invoke method invokes the

         ' methods wrapped by the delegates represented by

         ' the given delegate.

         m_delegateHolder.Invoke("This is the msg parameter.")

      End If

      ' ...

   End Sub

 

End Class ' ServerClass

 

' This class is defined in the client component.

Public Class ClientClass

 

   ' This is the callback method. It will handle messages

   ' received from the server class.

   Public Sub HandleMessage(ByVal msg As String)

      Console.WriteLine(msg)

   End Sub

 

   ' This method represents the normal processing of the client

   ' object. As some point during normal processing, the client

   ' object creates an instance of the server class and passes it

   ' a delegate wrapper to the HandleMessage method.

   Public Sub DoSomethingUseful(  )

      ' ...

      Dim server As New ServerClass(  )

      ' The AddressOf operator in the following initialization

      ' is a little misleading to read. It's not returning an

      ' address at all. Rather, a delegate instance is being

      ' created and assigned to the myDelegate variable.

      Dim myDelegate As ServerClass.MessageDelegate _

         = AddressOf HandleMessage

      server.RegisterForMessages(myDelegate)

      ' ...

      ' This represents other calls to the server object, which

      ' might somehow trigger the server object to call back to

      ' the client object.

      server.DoSomethingUseful(  )

      ' ...

      ' At some point, the client may decide that it doesn't want

      ' any more callbacks.

      server.UnregisterForMessages(myDelegate)

   End Sub

 

End Class ' ClientClass

 

NET Programação Visual Basic.


Os delegados não oferecem quaisquer recursos que não pode ser alcançada de outras formas. Por exemplo, o
solução no Exemplo 2-13 poderia ter sido conseguido em pelo menos duas maneiras que não envolvem delegados:

• O componente servidor pode definir uma classe base abstrata que define o método a ser
implementada pelo cliente. O cliente, então, definir uma classe que herda a partir do servidor
classe abstrata de base, proporcionando uma aplicação para o método da classe um. O servidor
, então, fornecer métodos para registrar e cancelar registro objetos derivados do resumo
classe base.
• O componente servidor pode definir uma interface que inclui a definição do método para
ser implementada pelo cliente. O cliente, então, definir uma classe que implementou este
interface, eo servidor que fornecer métodos para registrar e cancelar registro de objetos que
expor a determinada interface.

Qualquer um desses métodos (incluindo delegados) poderia ser uma solução razoável para um determinado problema.
Escolha o que parece se encaixar melhor.

Delegados são às vezes caracterizados como ponteiros de função segura. Eu não acho que esse
caracterização auxilia o processo de aprendizagem, porque os delegados não são qualquer tipo de ponteiro de segurança ou
em contrário. São objetos que encapsulam o método de acesso. Delegado objetos podem invocar métodos
sem saber para onde os métodos atuais são implementadas. Com efeito, isto permite que os métodos individuais
a ser tratada de uma forma polimórfica.

2,20 Eventos

Um evento é um mecanismo de callback. Com ele, os objetos podem notificar os usuários que tem algo interessante
aconteceu. Se desejado, os dados podem ser transmitidos a partir do objeto para o cliente como parte da notificação.
Em toda esta seção, eu uso o produtor de eventos termos, a classe produtora, e objeto de produtores para falar
sobre uma classe (e suas instâncias), capaz de gerar eventos. Eu uso o consumidor de eventos termos, o consumidor
classe, e objeto de consumo para falar sobre uma classe (e suas instâncias) capaz de receber e agir sobre
eventos gerados por um produtor do evento.

Aqui é uma classe que expõe um evento:

Público EventProducer Classe

   Público SomeEvent Evento ()

   Público DoSomething Sub ()
      '...
      RaiseEvent SomeEvent ()
      '...
   End Sub

End Class

A declaração do evento neste fragmento de código declara que essa classe é capaz de elevar um evento
chamado SomeEvent. Os parênteses vazios na declaração indicar que o evento não vai passar qualquer
de dados. Um exemplo mais adiante nesta seção irá mostrar como definir eventos que passam os dados.

A declaração RaiseEvent no método DoSomething gera o evento. Qualquer cliente do objeto
que tenham registrado seu desejo de receber este evento irá recebê-lo neste momento. Receber um evento
significa que o método será chamado no cliente para manipular o evento. Aqui está a definição de um cliente
classe que recebe e trata os eventos da classe EventProducer:

Público EventConsumer Classe

   Como produtor WithEvents privados EventProducer



101
 



   Público producer_SomeEvent Sub () Handles producer.SomeEvent
      Console.WriteLine ("Hey, um evento que aconteceu!")
   
End Sub

   Sub New Public ()
      produtor () = New EventProducer ()
   End Sub

   Público DoSomething Sub ()
      '...
      
produtor (). DoSomething ()
      '...
   End Sub

End Class

Os aspectos-chave são:

• O objeto de consumo tem um campo que contém uma referência ao objeto do produtor.
• O objeto de consumo tem um método capaz de lidar com o evento. Um método é capaz de
tratamento de um evento se o método e os eventos têm a mesma assinatura. O nome do método
não é importante.
• A declaração do método manipulador tem uma cláusula de alças.
• As alças cláusula especifica o evento a ser tratado. O identificador antes do ponto indica
o campo com o objeto para gerar eventos. O identificador após o ponto indica o nome do
o evento.

O método é chamado de manipulador de forma síncrona, o que significa que a instrução seguinte ao
RaiseEvent declaração do produtor do evento não é executado até que o manipulador de método na
consumidor completa. Se um evento tem vários consumidores, cada consumidor manipulador de eventos é chamado em
sucessão. A ordem na qual os vários consumidores são chamados não é especificado.

Aqui está uma classe que expõe um evento com parâmetros:

Público EventProducer Classe

   Público AnotherEvent evento (MyData ByVal As Integer)

   Público DoSomething Sub ()
      '...
      RaiseEvent AnotherEvent (42)
      '...
   End Sub

End Class

E aqui está uma classe que consome:

Público EventConsumer Classe

   Como produtor WithEvents privados EventProducer

   Sub New Public ()
      produtor = Novo EventProducer ()
   End Sub

   Public Sub producer_AnotherEvent (ByVal MyData As Integer) _
      producer.AnotherEvent Handles
      Console.WriteLine ("Recebido o evento 'AnotherEvent'.")


102
 
NET Programação Visual Basic.


      Console.WriteLine ("O valor de MyData é {0}." Format (MyData))
   End Sub

   Público DoSomething Sub ()
      '...
      produtor (). DoSomething ()
      '...
   End Sub

End Class

O resultado de chamar o método da classe EventConsumer de DoSomething é:

Recebeu o evento 'AnotherEvent.
O valor de MyData é 42.

2.20.1 Usando Eventos e representantes Juntos

Nos bastidores,. NET usa delegados como parte de sua arquitetura de eventos. Os delegados são necessários
esta arquitetura porque permitem ligar o método da classe do consumidor de manipulador de eventos para o
produtor do evento (lembre-se que os delegados encapsular a invocação de método). O Visual Basic. NET
esconde os detalhes do mecanismo, discretamente criando delegados quando necessário, sob a superfície. No entanto,
o programador é livre para fazer este processo explícito. A seguinte definição da EventProducer
classe é semanticamente equivalente à anterior:

Público EventProducer Classe

   Delegado Pública SomeDelegate Sub (MyData ByVal As Integer)

   Público AnotherEvent eventos como SomeDelegate

   Público DoSomething Sub ()
      '...
      RaiseEvent AnotherEvent (42)
      '...
   End Sub

End Class

Note-se aqui que a declaração de SomeDelegate define um delegado capaz de envolver qualquer
subrotina cuja assinatura coincide com a assinatura que consta na declaração. O subsequente
declaração de AnotherEvent define um evento que vai usar a assinatura definida pela SomeDelegate.
Independentemente de qual sintaxe está sendo usado, os eventos são na verdade campos cujo tipo é algum tipo delegado.

Variações na sintaxe são possíveis no lado do consumidor, também. Quando o WithEvents e puxadores
palavras-chave são usadas, Visual Basic. NET cria um delegado que encapsula o método de manipulador de dados e
em seguida, registra que o delegado com o objeto eo evento determinado na cláusula Handles. O WithEvents
e palavras-chave Handles podem ser omitidos, bem como a declaração de delegado e conexão pode ser feita
explicitamente, como mostrado aqui:

Público EventConsumer Classe

   Como produtor privado EventProducer

   Sub New Public ()
      produtor = Novo EventProducer ()
      AddHandler producer.AnotherEvent, _
         Nova EventProducer.SomeDelegate (producer_AnotherEvent AddressOf)
   End Sub


103
 




   Public Sub producer_AnotherEvent (ByVal MyData As Integer)
      Console.WriteLine ("Recebido o evento 'AnotherEvent'.")
      Console.WriteLine ("O valor de MyData é {0}." Format (MyData))
   End Sub

   Público DoSomething Sub ()
      '...
      producer.DoSomething ()
      '...
   End Sub

End Class

A conexão do método de manipulador para o produtor do evento é feito com esta declaração no
construtor EventConsumer classe:

AddHandler producer.AnotherEvent, _
   Nova EventProducer.SomeDelegate (producer_AnotherEvent AddressOf)

A declaração AddHandler e sua companheira, a declaração RemoveHandler, permitem evento
manipuladores para ser dinamicamente registradas e não registradas. A declaração RemoveHandler leva
exatamente os mesmos parâmetros que a instrução AddHandler.

2,21 módulos standard

Um módulo padrão é uma declaração de tipo. É introduzido com a declaração do módulo, conforme mostrado aqui:

Público ModuleTest Módulo
   '...
End Module
Não confunda o Visual Basic. NET módulo, termo-padrão, com
. NET módulo prazo. Eles são independentes uns dos outros. Veja
Capítulo 3 para obter informações sobre os módulos. NET.

definições padrão do módulo são semelhantes às definições de classe, com as seguintes diferenças:

membros módulo • Padrão são implicitamente compartilhados.
• Os módulos padrão não pode ser herdada.
• Os membros de um módulo padrão pode ser referenciado sem ser qualificado com o
nome do módulo padrão.

Os módulos padrão é um bom lugar para colocar as variáveis globais e procedimentos que não são logicamente
está associado a nenhuma classe.

Atributos 2,22

Um atributo é um elemento de programa que modifica alguma declaração. Aqui está um exemplo simples:

<SomeAttribute( )> Pública someClass Classe
   '...
End Class

Este exemplo mostra um atributo SomeAttribute fictícia que se aplica a uma declaração de classe.
Atributos aparecem dentro de colchetes angulares (<>) e estão a seguir entre parênteses (()), o que pode


104
 
NET Programação Visual Basic.


conter uma lista de argumentos. Para aplicar vários atributos de uma única declaração, separe-os com
vírgulas em um único conjunto de colchetes, assim:

<SomeAttribute(), SomeOtherAttribute( )> Pública someClass Classe
   '...
End Class

Os atributos podem ser colocados os seguintes tipos de declarações:

Tipos

Isso inclui as classes, os delegados, enumerações, eventos, interfaces, Visual Basic. NET
módulos padrão e estruturas.

O atributo é colocado no início da primeira linha da declaração do tipo:

<SomeAttribute( )> Pública someClass Classe
   '...
End Class
Construtores

O atributo é colocado no início da primeira linha da declaração do construtor:

<SomeAttribute()> Sub New Public ()
   '...
End Sub
Campos

O atributo é colocado no início da declaração de campo:

<SomeAttribute( SomeField )> Pública As Integer
Métodos

O atributo é colocado no início da primeira linha da declaração do método:

<SomeAttribute()> SomeMethod Sub Pública ()
'...
End Sub
Parâmetros

O atributo é colocada imediatamente antes da declaração de parâmetro. Cada parâmetro pode
têm seus próprios atributos:

Public Sub SomeMethod (<SomeAttribute( SomeParameter )> ByVal
Integer)
Propriedades

Um atributo que se aplica a uma propriedade é colocada no início da primeira linha da propriedade
declaração. Um atributo que se aplica especificamente a uma ou ambas de uma propriedade Get ou Set
métodos é colocado no início da primeira linha da declaração respectiva modalidade:

SomeProperty Propriedade <SomeAttribute()> Pública () As Integer
Obter
   '...
End Get
<SomeOtherAttribute( )> Set (ByVal Value As Integer)
   '...


105
 



Definir Fim
End Property
Os valores de retorno

O atributo é colocado após a palavra chave AS e antes do nome do tipo:

Função Pública someFunction () As Integer <SomeAttribute( )>
   '...
End Function
Assembleias

O atributo é colocado no topo do arquivo fonte do Visual Basic. NET, na sequência de qualquer Importações
declarações e declarações anteriores. O atributo deve ser qualificado com o
Assembléia palavra-chave para que o compilador sabe aplicar o atributo ao conjunto bastante
que o módulo. Assembléias e módulos são explicados no Capítulo 3.

Importações ...
<Assembly: SomeAttribute( )>
Classe pública ...
Módulos

O atributo é colocado no topo do arquivo fonte do Visual Basic. NET, na sequência de qualquer Importações
declarações e declarações anteriores. O atributo deve ser qualificado com o Módulo
palavra-chave para que o compilador sabe aplicar o atributo para o módulo ao invés do
montagem. Assembléias e módulos são explicados no Capítulo 3.

Importações ...
<Module: SomeAttribute( )>
Classe pública ...

Alguns atributos são utilizáveis apenas em um subconjunto desta lista.

O. NET Framework fornece vários atributos padrão. Por exemplo, o atributo Obsolete
fornece uma indicação de que a declaração marcada não deve ser usado em código novo. Isso permite que
desenvolvedores de componentes para deixar declarações obsoletas no componente para compatibilidade com versões anteriores,
enquanto continua a fornecer uma dica para usuários componente que certas declarações não deve mais ser utilizado.
Está aqui um exemplo:

<Obsolete("Use ISomeInterface2 instead.")> Pública Interface ISomeInterface
   '...
End Interface

Quando este código é compilado, o atributo Obsolete ea mensagem associada são compilados em
o pedido. Ferramentas ou outro código pode fazer uso dessa informação. Por exemplo, se o compilado
aplicação é uma biblioteca de códigos referenciados por algum projeto no Visual Studio. NET, Visual Studio. NET
avisa o desenvolvedor quando ela tenta fazer uso de todos os itens que são marcados como obsoletos. Usando
No exemplo anterior, se o desenvolvedor declara uma classe que implementa ISomeInterface, Visual
. Studio NET exibe o seguinte aviso:

Obsoleto: Use ISomeInterface2 vez.

Veja o Apêndice A para obter a lista de atributos definidos pelo. NET Framework.







106
 
NET Programação Visual Basic.


2.22.1 Criar atributos personalizados

O mecanismo de atributo é extensível. Um novo atributo é definido pelo que declara uma classe que deriva de
o tipo de atributo (no namespace System) e que fornece uma indicação de que as declarações do
atributo deve ser autorizado a modificar. Está aqui um exemplo:

<AttributeUsage(AttributeTargets.All)> SomeAttribute Public Class
   Herda System.Attribute
End Class

Esse código define um atributo chamado SomeAttribute. A classe SomeAttribute si é modificado por
o atributo AttributeUsage. O atributo AttributeUsage é um padrão. NET Framework
atributo que indica que as declarações podem ser modificadas pelo novo atributo. Neste caso, o valor
de AttributeTargets.All indica que o atributo SomeAttribute pode ser aplicado a todo e
todas as declarações. O argumento do atributo AttributeUsage é de AttributeTargets tipo (definido
no namespace System). Os valores nessa enumeração são: Assembleia, Módulo, classe, estrutura,
Enum, construtor, método, propriedade, campo, eventos, Interface, parâmetro do delegado,
ReturnValue, e tudo.

Para criar um atributo que tem um ou mais argumentos, adicione um construtor com parâmetros para o
atributo da classe. Está aqui um exemplo:

<AttributeUsage(AttributeTargets.Method)> _
Público MethodDocumentationAttribute Classe
   Herda System.Attribute

   Público Autor ReadOnly As String
   Public ReadOnly Descrição As String

   Sub New Public (Autor ByVal As String, ByVal Descrição String)
      Autor Me.Author =
      Descrição Me.Description =
   End Sub

End Class

Esse código define um atributo que tem dois parâmetros: Autor e Descrição. Poderia ser
usados para modificar uma declaração de método como este:

<MethodDocumentation("Dave Grundgeiger", "This é meu method.")> _
Public Sub SomeMethod ()
   '...
End Sub
Por convenção, atributo nomes terminam com a palavra atributo.
Visual Basic. Referências NET atributos quer pela sua completa
nomes, por exemplo, ou MethodDocumentationAttribute
pelo menos os seus nomes à direita atributo, por exemplo,
MethodDocumentation. Atributos cujos nomes não acabam
com a palavra atributo são simplesmente referenciado por seu pleno
nomes.

2.22.2 Atributos de leitura

aplicações compiladas podem ser examinados para determinar programaticamente os atributos que, se houver,
associados com as declarações dos aplicativos diversos. Por exemplo, é possível escrever um Visual


107
 



Basic. NET programa que busca um componente compilado para o atributo Obsolete e produz um
relatório. Isso é feito usando a capacidade. NET Framework reflexão. A reflexão é a capacidade de
programaticamente analisar informações de tipo. O. NET Framework fornece uma grande quantidade de apoio
reflexão da classe Type (no namespace System) e dos tipos encontrados no
Namespace System.Reflection.

Reflexão merece um livro próprio, mas aqui está um breve olhar para você começar:

Imports System
Imports System.Reflection
'...
Dim typ como tipo = GetType (System.Data.SqlClient.SqlConnection)
objs Dim () As Object = typ.GetCustomAttributes (falso)
Dim obj As Object

Para cada obj Em objs
   Console.WriteLine (obj.GetType (). FullName)
Seguinte

Este fragmento de código faz o seguinte:

• Usa a função GetType para obter um objeto Type que representa o tipo SqlConnection
(Definido no namespace System.Data.SqlClient). Você pode experimentar colocar qualquer tipo de
nome aqui (incluindo os tipos que você criar). Eu escolhi SqlConnection porque eu sei que
por acaso tem um atributo associado a ele.
• Chama o método GetCustomAttributes do objeto Type para obter uma matriz de objetos que
representam os atributos associados com o tipo. Cada objeto da matriz representa um
atributo.
• Loops através da matriz de objeto e imprime o nome do tipo de cada objeto. O nome do tipo é o
nome do atributo.

A saída é mostrada aqui:

System.ComponentModel.DefaultEventAttribute

A reflexão não é discutido neste livro. Reveja o. NET documentação para a
Namespace System.Reflection para mais informações.

2,23 compilação condicional

compilação condicional é a habilidade de especificar que um determinado bloco de código será compilado no
aplicação somente sob certas condições. directivas de compilação condicional usa pré-compilador para afetar
que as linhas estão incluídas no processo de compilação. Este recurso é freqüentemente usado para embrulhar o código utilizado apenas
para depuração. Por exemplo:


# DEBUG = True Const

Public Sub SomeMethod ()
# Se DEBUG seguida
   Console.WriteLine ("Entrando SomeMethod ()")
# End If

   '...
# Se DEBUG seguida
   Console.WriteLine ("Saindo SomeMethod ()")


108
 



# End If
End Sub
 
NET Programação Visual Basic.
 

A diretiva # Const define uma constante simbólica para o compilador. Esta constante é referenciado posteriormente na
# Se o directivas. Se a constante for avaliada como True, as declarações dentro do bloco # Se são
compilado no aplicativo. Se a constante for avaliada como False, as declarações dentro do # Se o bloco
são ignorados.

O âmbito de aplicação constantes definidas pela directiva Const # é o arquivo de origem em que a directiva
aparece. No entanto, se a constante é referenciado antes da definição, seu valor não é nada. É
Portanto, o melhor para definir constantes no topo do arquivo. Alternativamente, constantes do compilador podem ser
definida na linha de comando ou dentro do Visual Studio. NET. Se você está compilando a partir do
linha de comando, use a opção de compilador / definir, como este:

MySource.vb vbc / define: DEBUG = True

Você pode definir constantes múltiplas dentro de um único parâmetro / definir, separando o símbolo = valor
pares com vírgulas, como este:

MySource.vb vbc / define: DEBUG = True, SOMECONSTANT = 42

Para atribuir constantes do compilador no Visual Studio. NET:

1. Botão direito do mouse sobre o nome do projeto na janela Solution Explorer e escolha Propriedades. Este
Projeto traz a caixa de diálogo Property Pages. (Se a janela Solution Explorer não estiver visível,
escolha Exibir Solution Explorer do Visual Studio. NET menu principal para fazê-la aparecer.)
2. Dentro da caixa de diálogo Project Property Pages, escolha a pasta Configuration Properties.
Dentro dessa pasta, escolha a página de propriedades Build. Isso faz com que a configuração de opções de compilação
apareça no lado direito da caixa de diálogo.
3. Adicionar valores para a caixa de texto personalizado constantes do lado direito da caixa de diálogo.

Resumo 2,24

Este capítulo forneceu uma visão geral da sintaxe da linguagem Visual Basic. NET. No capítulo 3,
você vai aprender sobre o Framework.-parte integrante do desenvolvimento em qualquer linguagem. NET.
Os capítulos seguintes vão ensiná-lo a realizar tarefas específicas de programação em Visual
Basic. NET.

 

Capítulo 3. O quadro. NET

O. NET Framework é a próxima iteração da plataforma Microsoft para o desenvolvimento baseado em componentes
software. Ele oferece avanços fundamentais em serviços de tempo real para aplicação de software. Ele também
apóia o desenvolvimento de aplicações que podem ser livre de dependências em hardware, operando
sistema, e compilador de linguagem.

Este capítulo fornece uma visão geral da arquitetura do sistema. NET Framework e descreve a base
recursos encontrados no núcleo de sua biblioteca de classes.

3,1 Common Language Infrastructure (CLI) ea linguagem comum
Runtime (CLR)

No coração do. NET Framework é um novo mecanismo para carregar e executar programas e
gerir as suas interacções. Esse mecanismo é descrito no Common Language Infrastructure
(CLI), uma especificação para um ambiente de execução que permite que componentes de software:

• Passe os dados entre si sem levar em conta a linguagem de programação na qual cada
componente é escrito
• Executa em diferentes sistemas operacionais e em diferentes plataformas de hardware sem ter que
recompilar o código fonte de alto nível (uma compilação de baixo nível ainda ocorre automaticamente no
plataforma de destino, como será discutido neste capítulo)

Embora a especificação CLI foi criado pela Microsoft, que desde então tem sido apresentado à ECMA
normas de organização (http://www.ecma.ch), que tem agora a responsabilidade e controle sobre ele.

O CLI é apenas uma especificação, ele tem que ser implementadas a fim de ser útil. Uma implementação de
CLI é conhecido como Common Language Runtime (CLR). implementação da Microsoft sobre o CLR
plataforma Windows não está sob controle ECMA, mas é intenção da Microsoft de que o CLR ser totalmente
implementação compatível do CLI. Como desta escrita, a CLI não foi aplicado sobre a não-
plataformas Windows, mas a Microsoft e outras empresas anunciaram a intenção de fazê-lo.

O CLI especifica como o código executável é carregado, executar e gerenciados. A parte do CLR que
executa as tarefas de carga, execução e gerenciamento de aplicações. NET é chamado de execução virtual
sistema (SEV). Código executado pelo SEV é chamado de código gerenciado.

O CLI expande os conceitos que existem no Microsoft Component Object Model (COM). Como
sua característica fundamental, COM especifica como interfaces de objetos são definidos na memória. Qualquer componente que pode
criar e consumir este esquema pode compartilhar dados com outros componentes que fazem o mesmo. COM era um
grande passo em frente quando ele foi introduzido (circa 1992), mas tem suas limitações. Por exemplo, apesar de
de seu nome, COM realmente não tem noção de interfaces objeto-objeto só. Portanto, COM não pode
suporte à passagem tipos nativos de um componente para outro.

3,2 Common Type System (CTS)

A especificação CLI define um sistema de tipos rico que ultrapassa de longe as capacidades do COM. É o chamado
Common Type System (CTS). O CTS define a nível de tempo de execução como os tipos são declarados e usados.
Anteriormente, compiladores de linguagem controlada a criação e uso de tipos, incluindo a sua disposição em
memória. Isso levou a problemas quando um componente escrito em uma linguagem tentou passar dados para um
componente escrito em um idioma diferente. Qualquer um que tenha escrito Visual Basic 6 código para chamar
funções API do Windows, por exemplo, ou que tenha tentado passar uma matriz JavaScript para um componente
escritos em Visual Basic 6 ou C + +, está ciente do problema. Coube ao promotor de traduzir
que os dados sejam compreensíveis para o componente de recepção. O CTS elimina esse problema
fornecendo as seguintes funcionalidades:




111
 



• Tipos primitivos (Integer, String, etc) são definidas a nível de tempo de execução. Componentes podem facilmente
casos passam de tipos primitivos entre si porque todos eles concordam sobre a forma como os dados
está formatado.
• Os tipos complexos (estruturas, classes, enumerações, etc) são construídas de uma maneira que é
definidos a nível de tempo de execução. Os componentes podem passar facilmente instâncias de tipos complexos entre
uns aos outros, porque todos eles concordam sobre como tipos complexos são construídos a partir de tipos primitivos.
• Todos os tipos de transportar informações tipo rico com eles, o que significa que um componente que é entregue um
objeto pode encontrar a definição do tipo de que o objeto é um exemplo. Esta é
análogas às bibliotecas de tipo no COM, mas o CTS é diferente porque o tipo de informação é
muito mais rica e tem a garantia de estar presente.

3.2.1 Namespaces

Namespaces foram introduzidas no Capítulo 2, como forma de agrupar tipos relacionados. Eles são mencionados
novamente aqui, porque eles não são apenas um conceito do Visual Basic NET;. eles também são usados pelo CLR e
por outras linguagens que o objectivo da plataforma. NET. É importante ter em mente que a CLR, uma
namespace é apenas parte do nome de um tipo totalmente qualificado, e nada mais. Veja Seção 3.4.2 posteriormente
neste capítulo, para obter mais informações.

3,3 Partes do CLI

A especificação CLI reconhece que a CLR não pode ser implementada da mesma forma em todos os
plataformas. Por exemplo, a versão do CLR implementado em um telefone celular não vai ser tão versáteis quanto
o implementado no Windows 2000 ou Windows XP. Para resolver esse problema, o CLI define um conjunto
das bibliotecas. Cada biblioteca contém um conjunto de classes que implementam uma determinada parcela da CLI's
funcionalidade. Além disso, o CLI define os perfis. Um perfil é um conjunto de bibliotecas que devem ser implementadas
em uma determinada plataforma.

As bibliotecas definidos pela CLI são:

Runtime Library Infrastructure

Esta biblioteca oferece os serviços básicos que são necessários para compilar e executar um aplicativo que
metas da CLI.

Base Classe Library

Esta biblioteca oferece os serviços de execução que são necessários por uma programação mais modernas
línguas. Entre outras coisas, os tipos de dados primitivos são definidos nesta biblioteca.

Rede de Bibliotecas

Esta biblioteca fornece serviços de rede simples.

Reflexão Biblioteca

Esta biblioteca fornece a capacidade de analisar informações de tipo em tempo de execução e para invocar os membros
de tipos, fornecendo o nome do membro em tempo de execução, ao invés de em tempo de compilação.

XML Biblioteca

Esta biblioteca fornece um parser XML simples.

Biblioteca de ponto flutuante

Esta biblioteca fornece suporte para tipos de ponto flutuante e operações.


112
 



Biblioteca de Extensão Matriz
 
NET Programação Visual Basic.
 

Esta biblioteca fornece suporte para matrizes multidimensionais.

Os perfis definidos pela CLI neste momento são:

Kernel perfil

Este perfil define a funcionalidade mínima de qualquer sistema reivindicado como uma implementação de
CLI. CLRs que atendem ao perfil do Kernel deve implementar a Base Class Library e
Infra-estrutura da Biblioteca Runtime.

Compact perfil

Este perfil inclui a funcionalidade do kernel do perfil, além da Rede de Bibliotecas, o
Reflexão Library ea Biblioteca XML. Pretende-se que a implementação do Pacto
Perfil pode ser leve, mas fornecer funcionalidade suficiente para ser útil.

perfis complementares serão definidas em futuras versões da especificação CLI. Qualquer aplicação dada
da CLI é livre para implementar mais do que a funcionalidade especificada por esses perfis mínimos. Para
exemplo, uma determinada implementação poderá apoiar o perfil compacto mas também o apoio flutuante
Biblioteca Point. O. NET Framework no Windows 2000 suporta todas as bibliotecas CLI, além de outras
bibliotecas não definidos pela CLI.

Note que a CLI não inclui tais bibliotecas de classes principais como Windows Forms, ASP.NET e
ADO.NET. Estes são específicas da Microsoft bibliotecas de classes para desenvolvimento de aplicativos no Windows
plataformas. Os aplicativos que dependem dessas bibliotecas não ser portáveis para outras implementações
CLI menos que a Microsoft faz as bibliotecas de classes disponíveis sobre essas outras implementações.

3,4 módulos e assemblies

Um módulo é um arquivo. Exe ou. Dll. Um conjunto é um conjunto de um ou mais módulos que juntos compõem uma
pedido. Se o aplicativo está totalmente contido em um arquivo. Exe, tudo bem que é uma montagem de um módulo. Se
o exe. é sempre empregado com duas. dll e um pensa de todos os três arquivos, englobando um
unidade inseparável, em seguida, os três módulos juntos, formam um conjunto, mas nenhum deles faz isso
em si. Se o produto é uma biblioteca de classes que existe em um arquivo. Dll, então este single. Dll é uma montagem. Para
colocá-lo em termos da Microsoft, o conjunto é a unidade de implementação em. NET.

Um conjunto é mais do que apenas uma forma abstrata de pensar sobre conjuntos de módulos. Quando um assembly é
implantado, um (e apenas um) dos módulos na assembléia deve conter o manifesto do assembly,
que contém informações sobre o conjunto como um todo, incluindo a lista dos módulos contidos em
a montagem, a versão do conjunto, sua cultura, etc O compilador de linha de comando eo Visual
compilador Studio. NET criar montagens de módulo único, por padrão. Vários conjuntos de módulos não são
utilizadas neste livro.

limites afetam a resolução da Assembleia tipo. Quando um arquivo fonte é compilado, o compilador deve resolver
digite os nomes usados no arquivo de definições dos tipos '. Para tipos que são definidos na mesma fonte
projeto, o compilador se as definições a partir do código é compilado. Para tipos que são definidos
outra parte, o compilador deve ser informado onde encontrar as definições. Isso é feito por referência a
conjuntos que contêm as definições de tipo compilado. Quando o compilador de linha de comando é usado, o
Parâmetro / referência identifica conjuntos contendo os tipos usados no projeto a ser compilado. Um
assembléia tem o mesmo nome que o módulo que contém o manifesto do assembly, exceto para o arquivo
extensão. Em alguns casos, no entanto, um conjunto é especificado, dando o nome completo do módulo
que contém o manifesto do assembly. Por exemplo, para compilar uma aplicação que utiliza o
System.Drawing.Point classe, você poderia usar o seguinte comando:

vbc MySource.vb / referência: System.Drawing.dll


113
 
 



A documentação para o compilador linha de comando que o argumento para o parâmetro de referência é
uma montagem. Isso não é muito preciso. O argumento é o nome do módulo que contém o
manifesto do assembly para uma assembléia.

Se mais de um conjunto deve ser referenciado, você pode listá-los todos na referência / mesmo
switch, separados por vírgulas, como este:

MySource.vb vbc / referência: System.Drawing.dll System.Windows.Forms.dll

. O Visual Basic NET linha de comando automaticamente as referências de dois conjuntos: mscorlib.dll,
que contém a maioria dos tipos encontrados no namespace System; e Microsoft.VisualBasic.dll,
que contém os tipos encontrados no namespace Microsoft.VisualBasic.

Quando você está trabalhando dentro do Visual Studio. NET, montagens externas são referenciados por fazer
o seguinte:

1. Na janela Solution Explorer, clique com o botão direito em References, clique em Adicionar Referência. A
Caixa de diálogo Adicionar Referência será exibida, como mostrado na Figura 3-1.
2. Desça até encontrar o conjunto desejado.
3. Clique duas vezes ou selecione o nome do conjunto, e pressione o botão Selecionar. A montagem
nome aparece no quadro de componentes selecionados da caixa de diálogo.
4. Selecione conjuntos adicionais, ou clique em OK.

Figura 3-1. A caixa de diálogo Adicionar Referência


























3.4.1 Global Assembly Cache (GAC)

Por padrão, os conjuntos não são compartilhadas. Quando um assembly é dependente de outro, os dois
conjuntos são normalmente implantados em um diretório único aplicativo. Isto torna mais fácil de instalar e
remover uma aplicação. Para instalar uma aplicação, basta criar o diretório do aplicativo e copiar o
arquivos para ela. Para excluir o aplicativo, basta apagar o diretório do aplicativo. O Registro do Windows não é
usada por todos.





114
 
NET Programação Visual Basic.


Se um conjunto deve ser compartilhado entre mais de um programa, ou ele pode ser copiado em cada
diretório do aplicativo adequado ou pode ser instalado no cache de assembly global (GAC). O GAC
é um espaço em disco (normalmente, é o subdiretório montagem do diretório do Windows) que mantém
assembléias para ser compartilhado entre todos os aplicativos. Todas as. NET Framework residir no
GAC. (Veja a Figura 3-2 para uma visão parcial das assembléias em GAC típica.) Colocação de uma montagem em
GAC deve ser evitado, se possível: ele faz a instalação do aplicativo e remoção mais difícil.
Isso ocorre porque o Windows Installer ou gacutil.exe deve ser usado para manipular o GAC, você pode
já não basta copiar ou remover o diretório do aplicativo. Instalar conjuntos no GAC não é
abordados neste livro. Para obter informações, apontar seu navegador para http://msdn.microsoft.com e
realizar uma busca por "Implantando componentes compartilhados."

Figura 3-2. Vista parcial de uma típica GAC



























3.4.2 Comparação das Assembléias, Módulos e Namespaces

É fácil confundir os três conceitos de espaço, módulo e montagem. Aqui está um resumo:

Namespace

Uma porção de um nome do tipo. Especificamente, é a parte que antecede o período final em pleno
nome do tipo qualificado.

Módulo

Um arquivo que contém o código executável (. Exe ou. Dll).

Assembléia

Um conjunto de um ou mais módulos que são implementados como uma unidade. O nome do conjunto é o mesmo que
o nome do módulo que contém o manifesto do assembly, menos a extensão do arquivo.

Dependendo de como as coisas são nomeados, pode parecer que esses três termos são intercambiáveis. Para
exemplo, System.Drawing.dll é o nome de um módulo que será implantado como parte do. NET Framework.


115
 



Acontece que, este módulo faz parte de um conjunto de módulo único. Como os assemblies são nomeados após
o módulo que contém o manifesto do assembly, o assembly é chamado de System.Drawing. Um compilador
fará referência a esse assembly como System.Drawing.dll. Muitos (mas não todos) dos tipos desta assembléia
ter um espaço de System.Drawing. (Outros tipos no assembly System.Drawing têm
namespaces de System.Drawing.Design, System.Drawing.Drawing2D, System.Drawing.Imaging
System.Drawing.Printing e System.Drawing.Text.) Observe que embora o espaço para nome, módulo
e montagem são igualmente nomeados neste caso, são conceitos distintos. Note em particular que
importar um namespace e uma referência de montagem são operações diferentes com propósitos diferentes.
A declaração:

Imports System.Drawing

permite que o desenvolvedor para evitar a digitação dos nomes totalmente qualificado do tipo no System.Drawing
namespace. Ele não faz referência a assembléia em que os tipos são definidos. Para utilizar os tipos,
a montagem System.Drawing (contidos no módulo System.Drawing.dll) deve ser referenciado como
descrito anteriormente nesta seção. A declaração Imports foi introduzido no Capítulo 2.

Em outros casos, os nomes de espaço e montagem não correspondem. Um exemplo é o Sistema
namespace. Alguns tipos com este espaço encontram-se na montagem mscorlib, e outros são
encontrada no conjunto do sistema. Além disso, cada um desses conjuntos tem com outros tipos
namespaces. Por exemplo, a montagem do sistema contém os tipos com o Microsoft.VisualBasic
namespace, embora a maioria dos tipos com esse namespace são encontrados no
Microsoft.VisualBasic montagem. (A razão para esta aparente incongruência é realmente muito boa.
tipos de grupo Namespaces acordo com a funcionalidade, enquanto conjuntos tendem a agrupar tipos de acordo com
quais tipos são mais prováveis de serem usados juntos. Isso melhora o desempenho, pois minimiza o
número de assembléias que devem ser carregados durante a execução.)

Quando pensar em espaços para nome, basta lembrar que os tipos podem ter qualquer espaço a todos,
independentemente do local onde está definido o espaço de nomes é apenas parte do nome do tipo.

3,5 Domínios de Aplicação

Domínios de aplicativos são para o CLR os processos que estão em um sistema operacional. Pode ser surpreendente
notar que a CLR pode executar vários aplicativos. NET em um único processo, sem qualquer alegação
ou dificuldades de segurança. Como o CLR tem completo controle sobre o carregamento e execução de programas,
e por causa da presença de informações sobre o tipo, o que garante CLR. NET não pode
ler ou escrever uns dos outros, memória, mesmo quando em execução no mesmo processo. Porque há menos
sobrecarga de desempenho na passagem entre os domínios de aplicação do que na passagem entre os processos,
isso proporciona um ganho de desempenho. Isso é especialmente benéfico para aplicações web rodando na Internet
Information Services (IIS), onde a escalabilidade é um problema.

3,6 Common Language Specification (CLS)

O CLI define um tempo de execução que é capaz de mais apoio, se não todas, as características encontradas nos mais modernos
linguagens de programação. Não se pretende que todas as línguas que o objectivo da CLR vai apoiar todas as CLR
recursos. Isso pode causar problemas quando os componentes escritos em linguagens diferentes tentativa de
interoperar. O CLI, portanto, define um subconjunto de recursos que são considerados compatíveis com todos
limites da linguagem. Este subconjunto é chamado de Common Language Specification (CLS).

Vendedores criação de componentes para utilização por outros necessidade de assegurar que todas as construções visíveis externamente
(Por exemplo, os tipos de público, os métodos públicos e protegidos, os parâmetros de métodos públicos e protegidos, etc)
são compatíveis com CLS. Isso garante que seus componentes poderão ser usados dentro de uma ampla gama de
linguagens, incluindo Visual Basic. NET. Desenvolvedores de autoria componentes em Visual Basic. NET tem
uma tarefa fácil porque todos Visual Basic. NET é compatível com CLS (a menos que o programador explicitamente
expõe um membro tipo público ou protegido ou o parâmetro do método que é de um tipo não compatível com CLS).





116
 
NET Programação Visual Basic.


Porque o Visual Basic. NET gera automaticamente os componentes compatíveis com CLS, este livro não
descrever as regras CLS. No entanto, para lhe dar uma noção do tipo de coisa que especifica o CLS,
Consideramos que algumas linguagens suportam um recurso chamado de sobrecarga de operador. Isso permite que o
desenvolvedor especificar as ações que devem ser tomadas se os símbolos operador padrão (+, -, *, /, =, etc)
são usados em classes definidas pelo usuário. Porque não é razoável esperar que todas as línguas devem
implementar tal recurso, a CLS tem uma regra sobre isso. A regra estabelece que se um compatível com CLS
componente tem tipos de públicos que fornecem operadores sobrecarregados, os tipos devem fornecer acesso à
que a funcionalidade de outra forma, bem como (normalmente através de um método público que realiza o mesmo
operação).

3,7 Intermediate Language (IL) e Just-In-Time (JIT) Compilação

Todos os compiladores que visam o CLR compila o código fonte para Intermediate Language (IL), também conhecido como
Common Intermediate Language (CIL). IL é uma linguagem de máquina que não esteja vinculado a nenhum específico
máquina. A Microsoft projetou a partir do zero para apoiar conceitos de programação da CLI. O CLI
especifica que todas as implementações CLR pode compilar ou interpretar IL na máquina em que o CLR está
em execução. Se o IL é compilado (versus interpretado), a compilação pode ocorrer em qualquer um dos dois tempos:

• Imediatamente antes de um método de aplicação a ser executada
• Em tempo de implantação

No primeiro caso, cada método é compilado somente quando for realmente necessário. Depois que o método é
compilados, chamadas subseqüentes ignorar o mecanismo de compilação e chamar o código compilado diretamente.
O código compilado não é salva no disco, por isso, se o pedido for interrompida e reiniciada, a compilação
deve ocorrer novamente. Isso é conhecido como "just-in-time (JIT) de compilação e é o cenário mais comum.

No segundo caso, a aplicação é compilada na sua totalidade no momento da implantação.

IL é salvo. Exe e. Dll. Quando tal IL um arquivo que contém é executado, o CLR sabe
chamar o compilador JIT e executar o código resultante.

Note-se que nas plataformas Microsoft Windows, IL sempre é compilada nunca interpretadas.

3,8 Metadados

O código fonte é composto de algumas construções que são de natureza processual e outras que são declarativas
na natureza. Um exemplo de uma construção é processual:

someObject.SomeMember = 5

Esta é processual, pois ele compila em código executável que executa uma ação em tempo de execução.
Ou seja, ele atribui o valor 5 para o membro SomeMember do objeto someObject.

Em contraste, aqui é uma construção declarativa:

Dim someObject Como someClass

Esta é declarativa, porque não realizar uma ação. Afirma que o símbolo é um someObject
variável que contém uma referência a um objeto do tipo someClass.

Na informação, o passado declarativa normalmente era usado apenas pelo compilador e não compilar diretamente
no executável. No CLR, no entanto, a informação declarativa é tudo! O CLR usa tipo
e informações de assinatura para garantir que a memória é sempre referenciado em uma maneira segura. O compilador JIT
utiliza informações sobre o tipo ea assinatura para resolver chamadas de método para o código de destino adequado a JIT
tempo de compilação. A única maneira para que isso funcione é que esta informação declarativa para ser incluído ao lado
suas informações associadas processuais. Compiladores que o objectivo da CLR, portanto, armazenar processuais


117
 



e informação declarativa no resultado. exe ou. dll. As informações processuais são armazenados como IL,
e as informações declarativas são armazenados como metadados. Metadados é apenas o nome CLI para declarativa
da informação.

O CLI tem um mecanismo que permite aos programadores incluir metadados arbitrários no compilados
aplicações. Esse mecanismo é conhecido como atributos personalizados e está disponível no Visual Basic. NET.
atributos personalizados foram discutidos em detalhe no Capítulo 2.

3.9 Gestão de Memória e Coleta de Lixo

Em qualquer ambiente de programação orientada a objetos, surge a necessidade de instanciar e destruir
objetos. objetos instanciados ocupam memória. Quando os objetos não estão mais em uso, a memória que eles
ocupar devem ser recuperadas para uso por outros objetos. Reconhecer quando os objetos não são mais
utilizado é o chamado gerenciamento de vida útil, o que não é um problema trivial. A solução utiliza o CLR tem
implicações para a concepção e utilização dos componentes que você escreve, por isso, é importante compreender.

No mundo COM, o cliente de um objeto notificado o objeto sempre que um novo objeto de referência foi
passado para outro cliente. Inversamente, quando qualquer cliente de um objeto foi terminado com ele, o cliente
notificado o objeto do fato. O objeto manteve um registro de quantos clientes tiveram referências a ele. Quando
que a contagem chega a zero, o objeto estava livre para se excluir (ou seja, dar a sua memória de volta ao
memória heap). Este método de gerenciamento de vida útil é conhecido como contagem de referência. Visual Basic
programadores não eram necessariamente consciente desse mecanismo, pois o compilador do Visual Basic
gerado automaticamente o código de baixo nível para executar esta limpeza. C + + não tinha
tal luxo.

Contagem de referência tem algumas desvantagens:

• Uma chamada de método é necessário toda vez que uma referência de objeto é copiado de uma variável para outra
e cada vez que uma referência de objeto é substituído.
bugs • Dificuldade para a via pode ser introduzida se as regras de contagem de referência não são precisamente
seguido.
• Cuidados devem ser tomados para garantir que as referências circulares são especialmente tratado (porque circular
referências podem resultar em objetos que nunca vão embora).

O mecanismo CLR para a gestão da vida é bem diferente. Contagem de referência não é usado.
Em vez disso, o gerenciador de memória mantém um ponteiro para o endereço no qual a memória livre (conhecido como o
heap) é iniciado. Para satisfazer um pedido de memória, apenas as mãos para trás uma cópia do ponteiro e, em seguida,
incrementa o ponteiro pelo tamanho do pedido, deixando-o em condições de satisfazer a memória próxima
pedido. Isso faz com que a alocação de memória muito rápido. Nenhuma ação é tomada por todos quando um objeto não é mais
sendo usado. Enquanto a pilha não se esgota, a memória não é recuperada até a saída do aplicativo. Se
a pilha é grande o suficiente para satisfazer todos os pedidos de memória durante a execução do programa, este método de
alocação de memória é mais rápido que é teoricamente possível, porque a sobrecarga só é incrementado
o ponteiro de pilha em alocações de memória.

Se a pilha ficar sem memória, não há mais trabalho a fazer. Para satisfazer um pedido de memória quando a pilha
está esgotado, o gerenciador de memória olha para qualquer memória alocada anteriormente que pode ser recuperada.
Ele faz isso através da análise das variáveis de aplicativo que mantenha referências de objeto. Os objetos que estes
variáveis de referência (e, portanto, a memória associada) são consideradas em uso, pois podem ser
alcançado através de variáveis do programa. Além disso, porque o tempo de execução tem acesso completo
informações do aplicativo, tipo o gerenciador de memória sabe se os objetos contêm membros
que os objetos de referência de outros, e assim por diante. Desta forma, o gerenciador de memória pode encontrar toda a memória
que está em uso. Durante esse processo, que consolida o conteúdo de toda a memória presente em uma contíguos
bloco no início da pilha, deixando o restante da pilha livre para satisfazer os pedidos de memória.
Este processo de liberação de memória é conhecida como a coleta de lixo (GC), um termo que também se aplica aos
este método global de gestão da vida. A parte do gerenciador de memória que executa
coleta de lixo é chamado de coletor de lixo.

Os benefícios da coleta de lixo são:


118
 
NET Programação Visual Basic.


• Nenhuma sobrecarga é incorrido a menos que a pilha se esgota.
• É impossível para aplicações de causar vazamentos de memória.
• O requerimento não precisa ser cuidadoso com referências circulares.

Embora o processo de coleta de lixo é caro (da ordem de uma fração de segundo quando
ocorre), a Microsoft alega que o overhead total da coleta de lixo, em média, muito menos do que
a sobrecarga total de contagem de referência (como mostrado pelos seus valores de referência). Isto, naturalmente, é altamente
dependente do modelo exato da alocação e desalocação de objeto que ocorre em um determinado programa.

3.9.1 Finalize

Muitos objetos exigem algum tipo de limpeza (ou seja, a finalização) quando eles são destruídos. Um exemplo
pode ser um objeto de negócios que mantém uma conexão com um banco de dados. Quando o objeto não está mais em
uso, a conexão do banco de dados deve ser liberado. O. NET Framework fornece uma maneira para que os objetos
ser notificado quando eles estão prestes a ser liberada, permitindo-los para liberar recursos não-memória.
(Recursos de memória na posse do objeto pode ser ignorada, porque eles serão tratados automaticamente pelo
. Coletor de lixo) Veja como funciona: a classe Object (definido no namespace System) tem um
Finalize método chamado que pode ser substituído. Sua implementação padrão não faz nada. Se for
substituído em uma classe derivada, no entanto, o coletor de lixo automaticamente chama-lo em uma instância de
essa classe, quando essa instância está prestes a ser recuperada. Aqui está um exemplo de substituir o Finalize
método:

Classe someClass Pública
   Protegido Overrides Sub Finalize ()
      'Release nonmanaged recursos aqui.
      MyBase.Finalize () 'Importante
   End Sub
End Class

O método Finalize deve liberar os recursos nonmanaged que o objeto foi alocado.
recursos Nonmanaged quaisquer outros recursos de memória (por exemplo, conexões de banco de dados,
identificadores de arquivo, ou outros sistemas operacionais alças). Em contrapartida, recursos gerenciados são referências de objeto. Como já
mencionado, não é necessário para liberar recursos gerenciados em um método Finalize-lixo
coletor irá lidar com isso. Após liberar os recursos alocados pela classe, o método Finalize deve
Finalize sempre chamar a implementação da classe base para que ele possa liberar os recursos alocados pelo
código da classe base. Se a classe é derivada diretamente da classe Object, tecnicamente esta poderia ser omitida
(Porque o método Finalize da classe Object não faz nada). No entanto, chamando-o de não se machucar
nada, e é um bom hábito de entrar.

Um método Finalize do objeto não deve ser chamado pelo código do aplicativo. O método Finalize tem especial
significado para a CLR e destina-se a ser chamado apenas pelo coletor de lixo. Se você estiver familiarizado com
destrutores em C + +, vai reconhecer que o método Finalize é o conceito idêntico. A única
diferença entre o método Finalize e C + + destruidores é que C + + destruidores chamar automaticamente
seus destruidores da classe base, enquanto que no Visual Basic. NET, o programador deve lembrar de colocar em
a chamada para o método Finalize da classe base. É interessante notar que a linguagem C #, outro sobre
. NET plataforma tem realmente destruidores (como C + + faz), mas eles são automaticamente compilados em
Finalize métodos que funcionam como descrito aqui.

3.9.2 Descarte

A desvantagem de coleta de lixo eo método Finalize é a perda de finalização determinística.
Com a contagem de referência, a finalização ocorre logo que a última referência a um objeto é lançado (este
é determinista, porque a finalização objeto é controlada pelo fluxo do programa). Em contraste, um objeto em um
sistema de coleta de lixo não será destruído até que a coleta de lixo ocorre ou até que o aplicativo será encerrado.
Esta é determinístico, pois o programa não tem controle sobre quando isso acontece. Este é um problema
porque um objeto que mantém os recursos escassos (como uma conexão de banco de dados) devem libertar os
recursos assim que o objeto não é mais necessário. Se isso não for feito, o programa pode funcionar fora do
recursos, muito antes de esgotar a memória.


119
 



Infelizmente, ninguém descobriu uma solução elegante para esse problema. Microsoft não tem uma
recomendação, no entanto. Objetos que detêm recursos nonmanaged deve implementar o
interface IDisposable (definido no namespace System). A interface IDisposable expõe um
método único, chamado Dispose, que não tem parâmetros e não retorna nenhum resultado. Chamá-lo diz o
objeto que ele não é mais necessária. O objeto deve responder por liberar todos os recursos que detém,
ambos gerenciados e nonmanaged, e deve chamar o método Dispose em quaisquer objetos subordinados que
também expor a interface IDisposable. Desta forma, os recursos escassos são liberados tão logo
não são mais necessários.

Esta solução exige que o usuário de um objeto de saber quando é feito com o objeto. Esta é
muitas vezes triviais, mas se existem vários usuários de um objeto, pode ser difícil saber qual o usuário deve
chamar Dispose. No momento da redação deste artigo, é simplesmente para o programador para resolver isso. Em certo sentido,
o método Dispose é um destruidor de suplente para abordar a questão da finalização não-determinística
quando os recursos nonmanaged estão envolvidos. No entanto, a CLR si nunca chama o método Dispose. É
é até o cliente do objeto para chamar o método Dispose no momento oportuno, com base no cliente
conhecimento de quando é feito usando o objeto. Isto implica responsabilidades tanto o autor da classe
e autor do cliente. O autor da classe deve documentar a presença do método Dispose para que o
autor cliente sabe que é necessário chamá-lo. O autor cliente deve fazer um esforço para determinar
se determinada classe tem um método Dispose e, em caso afirmativo, para chamá-lo no momento oportuno.

Mesmo quando uma classe expõe a interface IDisposable, que ainda deve substituir o método Finalize,
apenas no caso de o cliente deixa de chamar o método Dispose. Isso garante que os recursos nonmanaged
são eventualmente liberados, mesmo se o cliente se esquece de fazê-lo. Um simples (mas incompleta) técnica seria
é o de colocar uma chamada ao método Dispose do objeto em seu método Finalize, como este:

"Solução incompleta. Não faça isso.
Sub público Dispose () Implementa IDisposable.Dispose
   'Liberação dos recursos aqui.
End Sub

Protegido Overrides Sub Finalize ()
   Dispose ()
   MyBase.Finalize ()
End Sub

Desta forma, se o cliente do objeto deixa de chamar o método Dispose, o próprio objeto irá fazê-lo
quando o coletor de lixo destrói. A Microsoft recomenda que o método Dispose ser escrito assim
não é um erro chamá-lo mais de uma vez. Dessa forma, mesmo se o cliente chama-lo no momento correto, está tudo bem
para ser chamado novamente no método Finalize.

Se o objeto contém referências a outros objetos que implementam a interface IDisposable, o código
mostrado apenas pode causar um problema. Isso ocorre porque a ordem de destruição de objeto não é garantido.
Especificamente, se o método Finalize é execução, isso significa que a coleta de lixo está ocorrendo. Se o
objeto contém referências a outros objetos, o coletor de lixo já pode ter recuperado os
outros objetos. Se o objeto de tentativas de chamar o método Dispose em um objeto recuperado, um erro
ocorrem. Esta situação só existe durante a chamada para finalizar-se o cliente chama o método Dispose,
objetos subordinados ainda estará lá. (Eles não podem ter sido recuperado pelo coletor de lixo
porque eles são acessíveis a partir do código do aplicativo.)

Para resolver essa condição de corrida, é necessário ter um pouco de ação diferente na finalização do que quando
eliminação. Aqui está o código modificado:

Sub público Dispose () Implementa IDisposable.Dispose
   DisposeManagedResources ()
   DisposeUnmanagedResources ()
End Sub

Protegido Overrides Sub Finalize ()
   DisposeUnmanagedResources ()


120
 



   MyBase.Finalize ()
End Sub
 
NET Programação Visual Basic.
 

Private Sub DisposeManagedResources ()
   'Call objetos subordinados "métodos Dispose.
End Sub

Private Sub DisposeUnmanagedResources ()
   'Liberação dos recursos não gerenciados, como conexões de banco de dados.
End Sub

Aqui, o método Finalize só libera recursos não gerenciados. Ele não se preocupa com a chamada
Dispose método em todos os objetos subordinados, assumindo que se os objetos subordinados também são
inatingível, eles serão recuperados pelo coletor de lixo e seus finalizadores (e daí o seu
métodos Dispose) será executado.

Uma otimização pode ser feita para o método Dispose. Quando o método Dispose é chamado pelo cliente,
já não há qualquer razão para o método Finalize a ser chamado quando o objeto é destruído.
Manter o controle de chamadas e métodos dos objetos Finalize impõe uma sobrecarga sobre o coletor de lixo. Para
remover esta sobrecarga para um objeto com seu método Dispose chamado, o método Dispose deve chamar o
SuppressFinalize método compartilhado da classe GC, como este:

Sub público Dispose () Implementa IDisposable.Dispose
   DisposeManagedResources ()
   DisposeUnmanagedResources ()
   GC.SuppressFinalize (Me)
End Sub

O designer tipo deve decidir o que irá ocorrer se o cliente tenta usar um objeto depois de chamar a sua
Dispose método. Se possível, o objeto deve automaticamente readquirir os seus recursos. Se isso não for
possível, o objeto deve lançar uma exceção. Exemplo 3-1 mostra o último.

Exemplo 3-1. A Finalize completo / Dispose exemplo
Classe someClass Pública
   Implements IDisposable

   'Este membro mantém o controle de saber se o objeto foi descartado.
   Privados dispostos As Boolean = False

   "O método Dispose libera os recursos mantidos pelo objeto.
   "Ele deve ser chamado pelo cliente quando o cliente não precisa mais
   "O objeto.
   Sub público Dispose () Implementa IDisposable.Dispose
      Então, se não forem descartadas
         DisposeManagedResources ()
         DisposeUnmanagedResources ()
         GC.SuppressFinalize (Me)
         eliminados = True
      End If
   End Sub

   "O método Finalize nonmanaged libera recursos no caso
   'Que o cliente esqueceu de chamar Dispose. Por causa da
   "SuppressFinalize chamar o método Dispose, o método Finalize
   'Será chamado apenas se o método Dispose não é chamado.
   Protegido Overrides Sub Finalize ()
      DisposeUnmanagedResources ()
      MyBase.Finalize ()
   End Sub


121
 
 




   Private Sub DisposeManagedResources ()
      'Call objetos subordinados "métodos Dispose.
   End Sub

   Private Sub DisposeUnmanagedResources ()
      'Liberação dos recursos não gerenciados, como conexões de banco de dados.
   End Sub

   DoSomething Private Sub ()
      "Chame o método EnsureNotDisposed no topo de cada método que
      'Precisa acessar os recursos mantidos pelo objeto.
      EnsureNotDisposed ()
      '...
   End Sub

   Private Sub EnsureNotDisposed ()
      "Certifique-se que o objeto não foi descartado.
      "Em vez de lançar uma exceção, esse método poderia ser escrito
      'Para resgatar os recursos que são necessários pelo objeto.
      Se descartados Então
         Jogue ObjectDisposedException Novo (Me.GetType (). Nome)
      End If
   End Sub

Fim
 Classe

3,10 Uma Breve Tour de namespaces. NET Framework

O. NET Framework fornece uma enorme biblioteca de classes, algo da ordem de 6.000 tipos. Para ajudar
desenvolvedores navegar embora a hierarquia grande variedade de tipos, a Microsoft dividiu-os em espaços para nome.
No entanto, mesmo o número de espaços pode ser assustador. Aqui estão os espaços de nomes mais comuns
e uma visão geral do que eles contêm:

Microsoft.VisualBasic

Suporte de execução para aplicações escritas em Visual Basic. NET. Este namespace contém o
funções e procedimentos incluídos no Visual Basic NET..

Microsoft.Win32

Tipos que acessar o Registro do Windows e fornecer acesso a eventos do sistema (tais como baixa
memória, alterou as configurações de exibição e logout do usuário).

Sistema

tipos de sistemas de Core, incluindo:

• Implementações para o Visual Basic. Tipos fundamentais da NET (veja "Tipos", no Capítulo
2 para uma lista de tipos fundamentais e as classes. NET que implementá-las).
• Personalizar atributos comuns usados em todo o. NET Framework (ver
mais Apêndice A), bem como a classe de atributo, que é a classe base para
(Embora não todos) atributos personalizados. NET.
• exceções comum utilizado em todo o. NET Framework (ver
Apêndice B), bem como a classe Exception, que é a classe base para todos os
excepções. NET.



122
 
NET Programação Visual Basic.


• A classe Array, que é a classe base da qual todas as matrizes de Visual Basic. NET
implicitamente herdam.
• A classe Convert, que contém métodos para converter valores entre vários
tipos.
• A classe Enum, a partir da qual derivam todas as contagens implicitamente.
• A classe de Delegado, da qual derivam todos os delegados implicitamente.
• A classe Math, que tem muitos métodos compartilhados para a realização comum
funções matemáticas (por exemplo, Abs, Min, Max, do pecado e Cos). Essa classe também define
dois campos constantes, E e PI, que dão os valores dos números e e pi,
respectivamente, dentro da precisão do tipo de dados Double.
• A classe Random para gerar números pseudo-aleatórios.
• A classe Version, que encapsula informações sobre a versão. NET.

System.CodeDom

Tipos para geração automática de código-fonte (usada por ferramentas como os assistentes no Visual
Studio. NET e pelo compilador de página ASP.NET).

System.Collections

Tipos para gerenciamento de coleções, incluindo:

ArrayList

Cadastradas como uma matriz unidimensional iterada e como um array, mas muito mais flexível do que
uma matriz. Com um ArrayList, é possível adicionar elementos sem ter de se preocupar com a
tamanho da lista (a lista aumenta automaticamente quando necessário), inserir e remover elementos em qualquer lugar
na lista, encontrar o índice de um elemento dado o seu valor, e classificar os elementos na lista.

BitArray

Representa uma matriz de bits. Cada elemento pode ter um valor de Verdadeiro ou Falso. O BitArray
classe define um número de operadores bit a bit que operam em toda a matriz de uma vez.

Hashtable

Representa uma coleção de pares chave / valor. Tanto a chave eo valor pode ser qualquer objeto.

Fila

Representa uma fila, que é um first-in-first-out lista (FIFO).

SortedList

Como um Hashtable, representa uma coleção de pares chave / valor. Ao enumerar, porém, o
elementos são ordenados em ordem da chave. Além disso, os itens podem ser recuperados por meio do índice, que o
Hashtable não pode fazer. Não surpreendentemente, as operações SortedList pode ser mais lento do que comparáveis
operações Hashtable por causa do trabalho crescente que deve ser feito para manter a estrutura
na ordem de classificação.

Pilha

Representa uma pilha, que é um passado-in-first-out (LIFO) lista.






123

 

Esteja ciente de que, para além desses tipos, há também o tipo Array, definida no Sistema
namespace, e do tipo Collection, definido no namespace Microsoft.VisualBasic. A
Este último é um tipo de coleção que imita o comportamento de Visual Basic 6 objetos de coleção.

System.ComponentModel

Suporte para componentes de construção que pode ser adicionado ao Windows Forms e Web Forms.

System.Configuration

Suporte para leitura e escrita de configuração do programa.

System.Data

Suporte para acesso a dados. Os tipos neste espaço constituem ADO.NET.

System.Diagnostics

Suporte para depuração e rastreamento.

System.Drawing

Gráficos de desenho suporte.

System.EnterpriseServices

suporte para processamento de transacções.

System.Globalization

O apoio à internacionalização.

System.IO

Suporte para ler e escrever arquivos e fluxos.

System.Net

Suporte para comunicar através de redes, incluindo a Internet.

System.Reflection

Suporte para a descoberta do tipo de execução.

System.Resources

Suporte para leitura e escrita dos recursos do programa.

System.Security

Suporte para acessar e manipular informações de segurança.

System.ServiceProcess

Tipos de execução dos serviços do sistema.


124
 



System.Text
 
NET Programação Visual Basic.
 

Tipos de manipulação de texto e cordas.

Nota em determinado tipo StringBuilder o. Quando as cordas são construídas a partir de peças menores, o
métodos na classe StringBuilder é mais eficiente do que métodos semelhantes sobre a classe String.
Isso ocorre porque as instâncias da classe String não pode ser modificada no lugar, cada vez que um
alteração é feita para um objeto String, um novo objeto String na verdade é criada para armazenar o novo
valor. Em contraste, os métodos StringBuilder que modificar a seqüência de realmente modificar a seqüência
no lugar.

System.Threading

Suporte para programação multithread.

System.Timers

Fornece a classe Timer, que pode gerar um evento em intervalos pré-determinados. Este
trata de uma das limitações do Visual Basic controle Timer 6: tinha de ser hospedado em um
recipiente e, portanto, só podia ser usado em uma aplicação com uma interface de usuário.

System.Web

O suporte para construir aplicações web. Os tipos neste espaço constituem Web Forms e
ASP.NET.

System.Windows.Forms

Apoio para a construção de GUI (cliente gordo) aplicações. Os tipos neste espaço constituem
Windows Forms.

System.Xml

O suporte para a análise, geração, transmissão e recepção XML.

Configuração 3,11

Sistema e configuração do aplicativo é gerenciado por arquivos XML com uma extensão. Config. Configuração
arquivos existentes no aparelho e no nível de aplicação. Há um único arquivo de configuração no nível da máquina,
localizado na runtime_install_path \ CONFIG \ machine.config. Por exemplo,
C: \ WINNT \ Microsoft.NET \ Framework \ v1.0.2914 \ CONFIG \ machine.config. Aplicação de configuração
arquivos são opcionais. Quando existem, elas residem na pasta raiz do aplicativo e são nomeados
application_file_name.config. Por exemplo, MyApplication.exe.config. Aplicação Web
arquivos de configuração são sempre chamado web.config. Eles podem existir na pasta raiz do aplicativo da Web
e em subpastas da aplicação. Definições em arquivos de subpastas "configuração aplicam-se apenas às páginas
Obtido a partir da mesma pasta e suas pastas de criança e substituem as configurações dos arquivos de configuração em
pastas de nível superior.

Os arquivos de configuração deve ser utilizado por todas as informações de configuração do aplicativo, o Windows Registry
não deve mais ser usada para configurações do aplicativo.

3.11.1 Formato do arquivo de configuração

Os arquivos de configuração são documentos XML, onde o elemento raiz é <configuration>. Por exemplo:




125
 
 



<? Xml version = "1.0" encoding = "UTF-8"?>

<configuration>
   <! - Mais coisas vai aqui. ->
</ Configuration>

Para ser o mais flexível possível. Arquivos de configuração de rede usam um esquema em que o desenvolvedor do aplicativo
pode decidir sobre os nomes dos sub-elementos dentro do elemento <configuration>. Isso é feito
usando o <configSections>, <seção> e elementos <sectionGroup>. Exemplo 3-2 mostra
como isto é feito usando o <configSections> e <section> elementos, o <sectionGroup>
elemento é discutido mais tarde nesta seção.

Exemplo 3-2. Definição de uma seção em um arquivo de configuração
<? Xml version = "1.0" encoding = "UTF-8"?>

<configuration>

   <configSections>
      seção <
         name = "mySectionName"
         type = "System.Configuration.SingleTagSectionHandler" />
   </ ConfigSections>

   mySectionName <
      someSetting = "SomeValue"
      anotherSetting = "AnotherValue" />

</ Configuration>

O atributo name do elemento <section> especifica o nome de um elemento que vai (ou pode)
aparecer mais tarde no arquivo. O atributo type especifica o nome de um manipulador da seção de configuração, que
é uma classe que sabe como ler uma seção XML é formatado de uma maneira particular. A NET.
Framework fornece manipuladores de seção de configuração de ações (nomeadamente o SingleTagSectionHandler e
NameValueSectionHandler as classes, os quais serão discutidos mais adiante nesta seção), que são
suficiente para a maioria dos casos. Embora esteja além do escopo deste livro, uma configuração personalizada
manipulador da seção pode ser criada por escrever uma classe que implementa a
IConfigurationSectionHandler interface.

O SingleTagSectionHandler manipulador de seção de configuração XML lê seções que são da forma:

<Key1Name nome_da_seção key2Name = "valor1" = "valor2", etc .. />

O elemento pode conter qualquer número de pares chave / valor.

O manipulador da seção de configuração da classe não é usado diretamente no código. Para ler informações de uma
arquivo de configuração do aplicativo, use o método GetConfig na classe ConfigurationSettings (definido no
namespace System.Configuration). A sintaxe do método GetConfig é:

Public Shared Function GetConfig (ByVal
nome_da_seção As String) As Object

Veja como funciona o mecanismo (um exemplo a seguir):

1. A aplicação chama o método GetConfig, passando o nome da seção de configuração
que é para ser lido.
2. Internamente, o método GetConfig instancia a classe de manipulador de seção de configuração que é
apropriado para a leitura desta seção. (Lembre-se que são os valores encontrados na


126
 
NET Programação Visual Basic.


<configSections> parte do arquivo de configuração que identificam a configuração adequada
classe de manipulador de seção de uso).
3. O método de criar o manipulador de seção de configuração é chamado e é passado o XML
a seção de configuração solicitada.
4. O manipulador de seção de configuração é criar o método retorna um objeto que contém os valores
ler a seção de configuração.
5. O objeto retornado do método Create é passado de volta para o chamador do GetConfig
método.

O tipo de objeto retornado de GetConfig é determinada pelo manipulador de seção de configuração específica
que trata a seção de configuração dada. O chamador do método GetConfig deve ter o suficiente
informações sobre o manipulador de seção de configuração para saber como usar o objeto que é retornado. Dois
manipuladores de seção de configuração de ações e os objetos que eles criam, serão discutidos nesta seção.

Exemplo 3-3 mostra como ler o arquivo de configuração mostrado no Exemplo 3-2. Para executar esse exemplo,
faça o seguinte:

1. Crie um novo diretório para o aplicativo.
2. Salve o código do Exemplo 3-3 em um arquivo chamado ConfigurationTest.vb.
3. Compilar o código com esta linha de comando:

vbc ConfigurationTest.vb / referência: System.dll

A referência ao conjunto do sistema é necessário porque o conjunto do sistema contém a
definição da classe ConfigurationSettings.

O compilador cria um arquivo executável chamado ConfigurationTest.exe.

4. Salve o arquivo de configuração do Exemplo 3-2 em um arquivo chamado ConfigurationTest.exe.config.
Execute o executável a partir do prompt de comando. O aplicativo imprime os valores de configuração
na janela de comando.

Exemplo 3-3. Lendo o arquivo de configuração mostrado no Exemplo 3-2
Imports System
Imports System.Collections
Imports System.Configuration
Público SomeModule Módulo

   Sub Público Main ()

      Dim cfg Como Hashtable
      As String Dim strSomeSetting
      As String Dim strAnotherSetting

      cfg = CType (ConfigurationSettings.GetConfig ("mySectionName"), _
         Hashtable)
      Se não (cfg Is Nothing) Then
         strSomeSetting = CType (CFG ("someSetting"), String)
         strAnotherSetting = CType (CFG ("anotherSetting"), String)
      End If
      Console.WriteLine (strSomeSetting)
      Console.WriteLine (strAnotherSetting)

   End Sub

End Module


127
 



Para ler as definições de configuração, o código no Exemplo 3-3 chama o método do GetConfig
ConfigurationSettings classe.
O SingleTagSectionHandler manipulador da seção de configuração cria uma
Hashtable objeto (definido no namespace System.Collections) para manter os pares chave / valor encontrado na
o arquivo de configuração. É por isso que o código no Exemplo 3-3 chama a função CType para converter o
referência retornada pelo método GetConfig a uma referência Hashtable. Depois de feito isto, o código pode
nada adequado para um objeto Hashtable, incluindo a recuperação de valores específicos por chave (como mostrado na
Exemplo 3-3) ou iterar itens do objeto Hashtable é. Observe também que, devido Hashtable
objetos armazenar valores do tipo Object, as referências a objetos recuperados do Hashtable tem que ser
convertidos para o tipo de referência adequado, que neste caso é String. O CStr Visual Basic
função poderia ter sido usado aqui, embora neste caso o Visual Basic função CType é chamado
em vez disso.

O pedido não especifica o nome do arquivo de configuração em que olhar para a configuração
da informação. O sistema automaticamente procura na application_file_name.config arquivo encontrado no
diretório do aplicativo. Se a seção solicitado não for encontrado no arquivo, o sistema automaticamente procura
para ele no arquivo de configuração de máquina.

Outra fotografia manipulador de seção de configuração é a classe NameValueSectionHandler. Este manipulador também
lê pares chave / valor, mas em um formato diferente. Exemplo 3-4 é o mesmo caso do exemplo 3-2, mas
reescrito para usar NameValueSectionHandler.

Exemplo 3-4. Utilizando a seção de configuração NameValueSectionHandler
manipulador
<? Xml version = "1.0" encoding = "UTF-8"?>

<configuration>
   <configSections>
      seção <
         name = "mySectionName"
         type = "System.Configuration.NameValueSectionHandler" />
   </ ConfigSections>

   <mySectionName>
      <add key="someSetting" value="SomeValue" />
      <add key="anotherSetting" value="AnotherValue" />
   </ MySectionName>

</ Configuration>

Exemplo 3-5 mostra o código que lê essa seção de configuração.

Exemplo 3-5. Lendo o arquivo de configuração mostrado no Exemplo 3-4
Imports System
Importações System.Collections.Specialized
Imports System.Configuration

Público SomeModule Módulo

   Sub Público Main ()

      Dim cfg Como NameValueCollection
      As String Dim strSomeSetting
      As String Dim strAnotherSetting

      cfg = CType (ConfigurationSettings.GetConfig ("mySectionName"), _
         NameValueCollection)
      Se não (cfg Is Nothing) Then


128
 
NET Programação Visual Basic.


         strSomeSetting = CType (CFG ("someSetting"), String)
         strAnotherSetting = CType (CFG ("anotherSetting"), String)
      End If

      Console.WriteLine (strSomeSetting)
      Console.WriteLine (strAnotherSetting)

   End Sub

End Module

A principal diferença notar no Exemplo 3-5 é que o NameValueSectionHandler cria um objeto
NameValueCollection de tipo (definido no namespace System.Collections.Specialized).

3.11.2 Seção Grupos de Configuração

Se as informações de configuração do aplicativo é para ser armazenado no arquivo de configuração da máquina, é uma boa
idéia de introduzir grupos de seção de configuração na imagem. (Lembre-se que, se o tempo de execução não encontra
a seção solicitada no arquivo de configuração do aplicativo, ele automaticamente procura por ele na máquina
arquivo de configuração.) Este grupo simplesmente configurações de um aplicativo em um elemento do grupo abrangendo no
arquivo de configuração, de modo que os elementos contidos não entrar em conflito com elementos como o chamado para
outras aplicações. Exemplo 3-6 mostra como a introdução de um grupo de seção. Ele é idêntico ao
arquivo de configuração mostrado no Exemplo 3-2, exceto que um grupo de seção é definida.

Exemplo 3-6. Criar um grupo da secção
<? Xml version = "1.0" encoding = "UTF-8"?>
<configuration>

   <configSections>
      <sectionGroup name="myGroupName">
         seção <
            name = "mySectionName"
            type = "System.Configuration.SingleTagSectionHandler" />
      </ SectionGroup>
   </ ConfigSections>
   <myGroupName>
      mySectionName <
         someSetting = "SomeValue"
         anotherSetting = "AnotherValue" />
   </ MyGroupName>

</ Configuration>

Exemplo 3-7 mostra como ler esse arquivo de configuração em código.

Exemplo 3-7. Lendo o arquivo de configuração mostrado no Exemplo 3-6
Imports System
Imports System.Collections
Imports System.Configuration

Público SomeModule Módulo

   Sub Público Main ()

      Dim cfg Como Hashtable
      As String Dim strSomeSetting


129
 



      As String Dim strAnotherSetting

      cfg = CType (_
         ConfigurationSettings.GetConfig ("myGroupName / mySectionName"), _
         Hashtable)
      Se não (cfg Is Nothing) Then
         strSomeSetting = CType (CFG ("someSetting"), String)
         strAnotherSetting = CType (CFG ("anotherSetting"), String)
      End If

      Console.WriteLine (strSomeSetting)
      Console.WriteLine (strAnotherSetting)

   End Sub

End Module

A única diferença entre Exemplo 3-7 e 3-3 Exemplo é a sintaxe de caminho de estilo no Exemplo 3 -
7 usada para especificar o nome da seção: "myGroupName / mySectionName". definições de grupo pode ser
aninhados, se desejar.

3.11.3 A Seção <appSettings>

A maioria dos aplicativos só precisa de uma forma simples que armazena pares chave / valor. Para apoiar esta iniciativa, o machine.config
arquivo contém uma seção de definição predefinida chamada <appSettings>. É sempre legal para incluir uma
<appSettings> seção em qualquer arquivo de configuração. O manipulador da seção de configuração para o
seção <appSettings> é a classe NameValueSectionHandler, portanto, a seção deve ser da seguinte forma:

<appSettings>
   <add key="setting1" value="value1" />
   <add key="setting2" value="value2" />
   <add key="setting3" value="value3" />
</ AppSettings>

Embora a seção <appSettings> pode ser lido através do método GetConfig como qualquer outro
seção, a classe ConfigurationSettings tem uma propriedade que se destina especificamente para ajudar com
leitura da seção <appSettings>. A propriedade somente leitura AppSettings da
ConfigurationSettings classe retorna um objeto NameValueCollection que contém a chave / valor pares
encontradas na seção <appSettings>. Exemplo 3-8 mostra como ler as definições apresentadas no
listagem de código anterior.

Exemplo 3-8. Ao ler o capítulo <appSettings>
Imports System
Importações System.Collections.Specialized
Imports System.Configuration

Público SomeModule Módulo

   Sub Público Main ()

      Dim cfg Como NameValueCollection
      As String Dim strSetting1
      As String Dim strSetting2
      As String Dim strSetting3

      cfg = CType (ConfigurationSettings.AppSettings, NameValueCollection)
      Se não (cfg Is Nothing) Then
         strSetting1 = CType (CFG ("setting1"), String)


130
 
NET Programação Visual Basic.


         strSetting2 = CType (CFG ("setting2"), String)
         strSetting3 = CType (CFG ("setting3"), String)
      End If

      Console.WriteLine (strSetting1)
      Console.WriteLine (strSetting2)
      Console.WriteLine (strSetting3)

   End Sub

End Module

Os pares nome / valor na seção <appSettings> são definidos pelo desenvolvedor.
O CLR não
atribuir qualquer significado intrínseco de qualquer nome especial / valor par.

Resumo 3,12

O. NET Framework é uma base ampla e profunda novo para desenvolvimento de aplicações. Na sua essência é um
tempo de execução que fornece serviços que anteriormente eram encontrados em bibliotecas do compilador. Este tempo de execução elimina
necessidade da aplicação de possuir conhecimentos do sistema operacional e hardware, enquanto
proporcionando um desempenho a par com o código compilado nativamente.











































131
 







































































132
 
NET Programação Visual Basic.


Capítulo 4. Windows Forms I: Desenvolvimento Desktop
Aplicações

Windows Forms é um conjunto de classes que encapsula a criação da interface gráfica do usuário (GUI)
parte de uma aplicação desktop típico. Anteriormente, cada linguagem de programação tinha sua própria maneira de
criação de janelas, caixas de texto, botões, etc Esta funcionalidade tem todos foram movidos para o. NET
Quadro biblioteca de classe para os tipos localizada no namespace System.Windows.Forms. Intimamente
relacionados é o namespace System.Drawing, que contém vários tipos utilizados na criação de GUI
aplicações. Os recursos fornecidos pelos tipos no namespace System.Drawing são comumente
referido como GDI + (discutido mais detalhadamente mais adiante neste capítulo).

Neste capítulo, vamos examinar a forma (ou janela) como o componente central de um desktop clássico
pedido. Veremos como os formulários são criados através de programação e como eles estão conectados a eventos.
Também vamos examinar como as múltiplas formas em um único aplicativo se relacionam entre si e como você
lidar com formulários em um aplicativo que tem uma ou mais formas criança. Por último, vamos discutir dois temas,
impressão e gráficos 2-D, que são relevantes para o desenvolvimento de aplicações desktop.

4.1 Criando um formulário

A maneira mais fácil criar um formulário é usar o Windows Forms Designer no Visual Studio. NET. A
desenvolvedor pode usar ferramentas visuais para criar o formulário, com o designer traduzir o layout em Visual
Basic. NET código-fonte. Se você não tiver o Visual Studio. NET, você pode escrever o Visual Basic. NET
código diretamente, e não usar o designer de todo. Esta seção irá demonstrar ambos os métodos.

Programática, um formulário é definida por derivar uma classe da classe Form (definido no
System.Windows.Forms). A classe Form contém o know-how para a exibição de uma forma vazia,
incluindo a sua barra de título e outras amenidades que espera de um formulário do Windows. Somando-se os membros do
nova classe dominante e os membros herdados da classe Form adicionar elementos visuais e de comportamento para
o novo formulário.

4.1.1 Criando um formulário usando o Visual Studio. NET

Para criar uma aplicação GUI em Visual Studio. NET:

1. Selecionar novo arquivo de projeto. O Novo Projeto caixa de diálogo aparece, como mostrado na Figura 4-1.

Figura 4-1. O Novo Projeto caixa de diálogo






















133
 


























2. Selecione Projetos do Visual Basic no painel Project Types no lado esquerdo da caixa de diálogo.
3. Selecione Windows Application no painel Templates no lado direito da caixa de diálogo.
4. Digite um nome na caixa de texto Nome.
5. Clique em OK. Visual Studio. NET cria um projeto com um formulário e exibe o formulário em um
designer, como mostrado na Figura 4-2.

Figura 4-2. O Windows Forms Designer




































134
 
NET Programação Visual Basic.


Para ver o código criado pelo formulário Windows Forms Designer, clique com o botão direito do mouse no formulário, em seguida, selecione
Exibir Código. Fazer isso para o formulário em branco mostrado na Figura 4-2 mostra o código mostrado aqui:

Public Class Form1
    Inherits System.Windows.Forms.Form

 Windows Form Designer gerou código

End Class

Isso mostra a definição de uma classe chamada Form1 que herda da classe Form. O Windows
Forms Designer cria também um monte de código clichê que não devem ser modificados pelo desenvolvedor. Por
padrão, ele esconde esse código do ponto de vista. Para ver o código, clique no símbolo "+" que aparece à esquerda do
a linha que diz "Windows Form Designer gerou código". Se o fizer, revela o código mostrado na
Exemplo 4-1.

Exemplo 4-1. O Windows Forms Designer código gerado para um espaço em branco
forma
Public Class Form1
   Inherits System.Windows.Forms.Form

# Region "Windows Form Designer gerou código"

   Sub New Public ()
      MyBase.New ()

      "Este convite é exigido pelo Windows Form Designer.
      InitializeComponent ()

      "Adicionar qualquer inicialização após a chamada InitializeComponent ()

   End Sub

   substitui Forma "dispor para limpar a lista de componentes.
   Protegido Overloads Overrides Sub Dispose (ByVal eliminação As Boolean)
      Ao descartar Então
         Se não (componentes Is Nothing) Then
            components.Dispose ()
         End If
      End If
      MyBase.Dispose (eliminação)
   End Sub

   "Necessário para o Windows Form Designer
   componentes e privadas, como System.ComponentModel.Container

   "NOTA: O procedimento a seguir é requerido pelo Windows Form Designer
   "Ele pode ser modificado usando o Windows Form Designer.
   "Não modificá-lo usando o editor de código.
   Sub <System.Diagnostics.DebuggerStepThrough( )> Privada
InitializeComponent ()
      componentes = Novo System.ComponentModel.Container ()
      Me.Text = "Form1"
   End Sub

# Fim Região

End Class



135
 



O Windows Forms Designer gera automaticamente o código de quatro membros da classe:

Novo método (o construtor da classe)

O construtor chama o construtor da classe base e, em seguida, chama o InitializeComponent
método. código de inicialização fornecida pelo desenvolvedor deve seguir a chamada InitializeComponent.
Depois que o construtor é gerado, o designer não tocá-la novamente.

método Dispose

O método Dispose é onde o objeto se livrar de quaisquer recursos caros. Neste caso, ele
chama o método Dispose da classe base para lhe dar uma chance para liberar os recursos caros
que podem realizar, em seguida, ele chama o método Dispose do campo de componentes. (Para mais informações sobre o
campo de componentes, consulte o próximo item.) Este, por sua vez chama os métodos Dispose em cada um
componente individual na coleção. Se a classe derivada usa todos os recursos caros, a
desenvolvedor deve adicionar o código aqui para liberá-los. Quando um formulário não é mais necessário, o código de todos os
que utiliza o formulário deve chamar o método Dispose do formulário. Depois que o método Dispose é
gerado, o designer não tocá-la novamente.

campo de Componentes

O campo de componentes é um objeto do tipo IContainer (definido no System.ComponentModel
namespace). O código gerado pelo designer usa o campo de componentes para gerenciar finalização
de componentes que podem ser adicionados a um formulário (por exemplo, o componente Timer).

método InitializeComponent

O código deste método não deve ser modificado ou adicionado pelo desenvolvedor de forma alguma. A
Windows Forms Designer atualiza automaticamente, conforme necessário. Quando os controles são adicionados à
formulário usando o designer, o código é adicionado a este método para instanciar os controles em tempo de execução
e definir suas propriedades iniciais. Note-se também no Exemplo 4-1 que as propriedades do próprio formulário
(Tais como texto e nome) são inicializados neste método.

Uma coisa que falta a partir desta definição de classe é um método Main. Lembre-se do capítulo 2, que. NET
aplicações deve expor uma pública, compartilhada método Main. Este método é chamado pelo CLR quando um
aplicação é iniciada. Então, por que não a forma gerado pelo designer incluem um método Main? É
porque o Visual Basic. NET no Visual Studio. NET cria automaticamente uma vez que
compila o código. Em outras palavras, o código compilado tem um método principal em que, embora a fonte
código não. O método Main no código compilado é um membro da classe Form1 e é
equivalente a este:

<System.STAThreadAttribute( )> Público Shared Sub Main ()
   System.Threading.Thread.CurrentThread.ApartmentState _ =
      System.Threading.ApartmentState.STA
   System.Windows.Forms.Application.Run (New Form1 ())
End Sub

Observe que o Visual Basic. NET linha de comando não gera automaticamente o principal
método. Este método deve aparecer no código-fonte, se o compilador de linha de comando é para ser usado.

Os próximos passos na elaboração do formulário são do nome do arquivo de código algo significativo e de definir algumas
propriedades no formulário, como o texto da barra de título. Para alterar o nome do arquivo de código do formulário, clique com o botão direito
sobre o nome do arquivo na janela Solution Explorer e selecione Renomear. Se você está seguindo junto com este
exemplo, digite HelloWindows.vb como o nome do arquivo.






136
 
NET Programação Visual Basic.


Mudar o nome do arquivo não muda o nome da classe. Para alterar o nome da classe,
direito do mouse no formulário no designer e escolha Propriedades. Na janela Propriedades, altere o valor
da propriedade Name. Para este exemplo, mudar o nome para "HelloWindows".

Para alterar a legenda do formulário, defina a propriedade Text do formulário para um novo valor. Defina a propriedade Text neste
exemplo, a "Programação Visual Basic. NET".

Em seguida, os controles podem ser adicionados ao formulário da caixa de ferramentas do Visual Studio. NET. Para exibir a caixa de ferramentas,
selecione Exibir caixa de ferramentas do Visual Studio. NET menu principal. Para este exemplo, clique duas vezes sobre o
Label controle na caixa de ferramentas para adicionar um controle Label no formulário. Use a janela Propriedades para alterar
propriedade do rótulo de texto para "Olá, o Windows!" e sua propriedade Fonte para 24pt Arial.

Em seguida, clique duas vezes no controle Button na caixa de ferramentas para adicionar um controle Button ao formulário. Use o
janela Propriedades para alterar a propriedade do botão de nome para "okbutton" e sua propriedade Text para "OK".

Finalmente, a posição dos controles, como desejado, o tamanho do controle Label e do formulário para ser atraente, e definir
propriedade FormBorderStyle a forma de "FixedToolWindow". A forma resultante deve ser algo
como o mostrado na Figura 4-3.

Figura 4-3. Um formulário com os controles

























Pressione a tecla F5 para compilar e executar o programa. O resultado deve ser algo como a Figura 4-4.

Figura 4-4. Olá, Windows!, Criada pelo Windows Forms Designer






O código gerado pelo designer é mostrado no Exemplo 4-2.

Exemplo 4-2. Olá, Windows! código, gerado pelo Windows Forms
Designer



137
 



Classe HelloWindows Pública
   Inherits System.Windows.Forms.Form

# Region "Windows Form Designer gerou código"

   Sub New Public ()
      MyBase.New ()

      "Este convite é exigido pelo Windows Form Designer.
      InitializeComponent ()

      "Adicionar qualquer inicialização após a chamada InitializeComponent ()

   End Sub

   substitui Forma "dispor para limpar a lista de componentes.
   Protegido Overloads Overrides Sub Dispose (ByVal eliminação As Boolean)
      Ao descartar Então
         Se não (componentes Is Nothing) Then
            components.Dispose ()
         End If
      End If
      MyBase.Dispose (eliminação)
   End Sub
   Amigo WithEvents Label1 Como System.Windows.Forms.Label
   Amigo WithEvents okbutton Como System.Windows.Forms.Button

   "Necessário para o Windows Form Designer
   componentes e privadas, como System.ComponentModel.Container

   "NOTA: O procedimento a seguir é requerido pelo Windows Form Designer
   "Ele pode ser modificado usando o Windows Form Designer.
   "Não modificá-lo usando o editor de código.
   <System.Diagnostics.DebuggerStepThrough( )> _
   InitializeComponent Private Sub ()
      Me.Label1 System.Windows.Forms.Label = Novo ()
      Me.OkButton System.Windows.Forms.Button = Novo ()
      Me.SuspendLayout ()
      »
      'Label1
      »
      Me.Label1.Font System.Drawing.Font = Novo ("Arial", 24!, _
         System.Drawing.FontStyle.Regular, _
         System.Drawing.GraphicsUnit.Point, CType (0, Byte))
      Me.Label1.Location System.Drawing.Point = Novo (8, 8)
      Me.Label1.Name = "Label1"
      Me.Label1.Size System.Drawing = Nova (264, 48)
      Me.Label1.TabIndex 0 =
      Me.Label1.Text = "Olá, Windows!"
      »
      "Okbutton
      »
      Me.OkButton.Location System.Drawing.Point = Nova (280, 16)
      Me.OkButton.Name = "okbutton"
      Me.OkButton.TabIndex 1 =
      Me.OkButton.Text = "OK"
      »
      "HelloWindows
      »
      Me.AutoScaleBaseSize System.Drawing = Novo (5, 13)
      Me.ClientSize System.Drawing = Nova (362, 58)


138
 
NET Programação Visual Basic.


      Me.Controls.AddRange (System.Windows.Forms.Control New () _
         {Me.OkButton, Me.Label1})
      Me.FormBorderStyle _ =
         System.Windows.Forms.FormBorderStyle.FixedToolWindow
      Me.Name = "HelloWindows"
      Me.Text = "Programação Visual Basic. NET"
      Me.ResumeLayout (falso)

   End Sub

# Fim Região

End Class

Observe que o designer fez as seguintes alterações para o código:

• Dois campos de amigos foram adicionados à classe, um para cada um dos controles que foram adicionados ao
forma:
 

 
Amigo WithEvents Label1 Como System.Windows.Forms.Label
Amigo WithEvents okbutton Como System.Windows.Forms.Button

A palavra-chave amigo faz os membros visíveis para outro código dentro do projeto, mas ele esconde
los a partir do código em execução em outras montagens.

A palavra-chave WithEvents permite que a classe HelloWindows para lidar com os eventos gerados pelo
controles. No código mostrado, não manipuladores de eventos foram adicionados, mas você verá como fazer
que mais tarde nesta seção.

Observe que os nomes correspondem aos nomes de campo de controle, como mostrado na janela Propriedades.
 

• O código foi adicionado ao método InitializeComponent para instanciar os dois controles e atribuir
suas referências aos campos membro:
 

 
Me.Label1 System.Windows.Forms.Label = Novo ()
Me.OkButton System.Windows.Forms.Button = Novo ()
 

• O código foi adicionado ao método InitializeComponent para definir várias propriedades da etiqueta,
botão, e formulário. Algumas dessas atribuições correspondem diretamente com os ajustes feitos no
janela de propriedades, enquanto outros são o resultado implícito de outras ações realizadas no designer
(Como o dimensionamento do formulário).

4.1.1.1 Adicionando manipuladores de eventos

O Olá, Windows! aplicação construída até agora tem um botão OK, mas o pedido ainda não
responder a cliques de botão. Para adicionar um manipulador de eventos Click para o botão OK, clique duas vezes sobre o botão no
o Windows Forms Designer. O designer responde mudando para visualizar o código do formulário e
inserção de um sub-rotina que manipula o evento Click (ie, ele será chamado quando o usuário da corrida
cliques no botão OK aplicação). A sub-rotina o designer cria se parece com esta nota (que eu adicionei
o carácter de continuação de linha para a impressão deste livro):

Private Sub OkButton_Click (ByVal sender As System.Object, _
   ByVal e As System.EventArgs) Handles OkButton.Click

End Sub

O corpo da subrotina pode ser adicionada. Esta seria uma execução provável para este evento
manipulador:



139
 
 



Private Sub OkButton_Click (ByVal sender As System.Object, _
   ByVal e As System.EventArgs) Handles OkButton.Click
   Me.Close ()
   Me.Dispose ()
End Sub

Uma forma alternativa para adicionar um manipulador de eventos é usar a lista drop-down na parte superior do código do formulário-
vista da janela. Na lista do lado esquerdo drop-down, escolha o objeto para o qual você gostaria de acrescentar uma
manipulador de eventos. Em seguida, na lista do lado direito drop-down, escolha o evento desejado. Veja a Figura 4-5.

Figura 4-5. Adicionar um manipulador de eventos usando a visualização de código é suspensa
listas



















Os manipuladores de eventos pode ser digitado diretamente no código do formulário, se você sabe a assinatura correta para o
manipulador. assinaturas de manipulador de eventos estão documentados no Microsoft Developer Network (MSDN)
Biblioteca.

4.1.2 Criando um formulário no Código

Embora os criadores de formulários são convenientes, é certamente possível codificar uma forma directa. Para fazer isso, siga
estas etapas:

1. Defina uma classe que é derivada da classe Form (definido no System.Windows.Forms
namespace). Se o formulário deve ser o formulário de inicialização para um aplicativo, incluir uma pública, compartilhada
Principal método. Por exemplo:
2. Imports System.Windows.Forms
3.
4. Classe HelloWindows Pública
5. Formulário Inherits
6.
7. "Incluir este método apenas se esta é a inicialização do aplicativo
formulário.
8. «Em alternativa, coloque esse método em um módulo separado no
9. 'Aplicação. Se for colocada em um módulo separado, remova o
10.
'Palavra-chave compartilhada.
11. <System.STAThreadAttribute( )> Público Shared Sub Main ()
12. System.Threading.Thread.CurrentThread.ApartmentState _ =
13. System.Threading.ApartmentState.STA
14. Application.Run (HelloWindows Nova ())
15. End Sub 'Main
16.


140
 



End Class
 
NET Programação Visual Basic.
 

17. Declare um membro de dados para cada controle que é exibido no formulário. Se você deseja manipular
eventos a partir do controle, use a palavra-chave WithEvents na declaração. Por exemplo:
18. Imports System.Windows.Forms
19.
20. Classe HelloWindows Pública
21. Formulário Inherits
22.
23. Private Label Como lblHelloWindows
24. btnOk WithEvents e privadas, como Button
25.
26. <System.STAThreadAttribute( )> Público Shared Sub Main ()
27. System.Threading.Thread.CurrentThread.ApartmentState _ =
28. System.Threading.ApartmentState.STA
29. Application.Run (HelloWindows Nova ())
30. End Sub 'Main
31.
End Class

 

A visibilidade (Private, Friend, Protected ou público) desses membros de dados é um projeto
questão que depende do projeto e sobre as preferências do desenvolvedor.
Minha preferência é
fazer todos os membros de dados privados. Se o código externo à classe precisa modificar os dados mantidos
por esses membros, métodos de acesso específicos podem ser adicionados para o efeito.
Isso impede que
mudanças internas da empresa de design de afetar os usuários externos da classe.

32. Declare um construtor. Execute as seguintes operações no construtor:
a. Instancie cada controle.
b. Definir propriedades para cada controle e para a forma.
c. Adicione todos os controles para a coleção Controls do formulário.

Por exemplo:


Imports System.Drawing
Imports System.Windows.Forms

Classe HelloWindows Pública
   Formulário Inherits

   Private Label Como lblHelloWindows
   btnOk WithEvents e privadas, como Button
   Sub New Public

      'Instanciar um controle de rótulo e defina suas propriedades.
      
lblHelloWindows = New Label ()
      Com lblHelloWindows
         
. Font = Fonte Nova ("Arial", 24)
         . Situação = New Point (16, 8)
         
.
Size = Tamanho Nova (248, 40)
         . TabIndex = 0
         . Text = "Olá, Windows!"
      
End With

      'Instanciar um controle de botão e definir suas propriedades.
      btnOk = Novo Button ()
      Com btnOk
         
. Situação = New Point (320, 16)
         . TabIndex = 1


141
 
 



         . Text = "OK"
      End With

      "Definir as propriedades do formulário.
      FormBorderStyle FormBorderStyle.FixedToolWindow =
      ClientSize Tamanho = Nova (405, 61)
      
Texto "NET de programação Visual Basic." =

      "Adicionar os controles para a coleção Controls do formulário.
      Controls.Add (lblHelloWindows
      Controls.Add (btnOk)
   
End Sub

   <System.STAThreadAttribute( )> Público Shared Sub Main ()
      
System.Threading.Thread.CurrentThread.ApartmentState _ =
         System.Threading.ApartmentState.STA
      
Application.Run (HelloWindows Nova ())
   End Sub 'Main

End Class

Uma instrução Imports foi adicionado para dar acesso aos tipos no namespace System.Drawing,
como Point e tamanho.

4.1.2.1 Adicionando manipuladores de eventos

Defina os manipuladores de eventos diretamente no código para os eventos que você deseja tratar. Por exemplo:

Private Sub btnOK_Click (ByVal sender As Object, _
   ByVal e As System.EventArgs) Handles btnOK.Click
   
Close ()
   Dispose ()
End Sub

O código completo para um autônomo aplicativo Windows Forms é mostrado no Exemplo 4-3.
Compilá-lo
a partir da linha de comando com o comando:

HelloWindows.vb vbc
/ R: System.dll, System.Drawing.dll System.Windows.Forms.dll / t: winexe

(Note que o comando deve ser digitado em uma única linha.)

Exemplo 4-3. Olá, Windows! código gerado fora do Visual Studio
Imports System.Drawing
Imports System.Windows.Forms
Classe HelloWindows Pública
   
Formulário Inherits
   Private Label Como lblHelloWindows
   btnOk WithEvents e privadas, como Button

   
Private Sub btnOK_Click (ByVal sender As Object, _
      ByVal e As System.EventArgs) Handles btnOK.Click
      
Close ()
      Dispose ()
   
End Sub
   Sub New Public
      'Instanciar um controle de rótulo e defina suas propriedades.
      
lblHelloWindows = New Label ()


142
 
NET Programação Visual Basic.


      Com lblHelloWindows
         . Font = Fonte Nova ("Arial", 24)
         
.
Situação = New Point (16, 8)
         . Size = Tamanho Nova (248, 40)
         . TabIndex = 0
         
. Text = "Olá, Windows!"
      End With
      'Instanciar um controle de botão e definir suas propriedades.
      
btnOk = Novo Button ()
      Com btnOk
         
. Situação = New Point (320, 16)
         . TabIndex = 1
         . Text = "OK"
      
End With
      "Definir as propriedades do formulário.
      FormBorderStyle FormBorderStyle.FixedToolWindow =
      
ClientSize Tamanho = Nova (405, 61)
      Texto "NET de programação Visual Basic." =
      
"Adicionar os controles para a coleção Controls do formulário.
      Controls.Add (lblHelloWindows)
      Controls.Add (btnOk)
   
End Sub

   <System.STAThreadAttribute()> Público Shared Sub Main ()
      System.Threading.Thread.CurrentThread.ApartmentState _ =
         System.Threading.ApartmentState.STA
      
Application.Run (HelloWindows Nova ())
   End Sub 'Main
End Class

4.2 Forma Tratamento de eventos

A classe Form base às vezes pode gerar eventos. Esses eventos podem ser tratadas pela forma derivada
classe. Uma maneira de fazer isso é definir uma subrotina que utiliza a palavra-chave MyBase na
Puxadores cláusula, como este:

"Esta não é a técnica preferida.
Form_Closing Private Sub (_
   ByVal sender As Object, _
   ByVal e As _ System.ComponentModel.CancelEventArgs
) Handles MyBase.Closing
   '...
End Sub

Entretanto, a melhor técnica é a de substituir os métodos protegidos, que são fornecidos pelo Formulário
classe para esta finalidade. Por exemplo, o método a seguir poderia ser colocado na classe derivada
definição, proporcionando uma forma de responder ao encerramento iminente do formulário:

"Assume System.ComponentModel Imports
Protected Sub Substitui OnClosing (_
   
ByVal e As _ CancelEventArgs
)
   '...
   MyBase.OnClosing (e) "Importante
End Sub

Note-se que a aplicação do método OnClosing inclui uma chamada para a classe base de
implementação. Isso é importante. Se isso não for feito, o evento de encerramento não será gerado, o que
afetar o comportamento de qualquer outro código que tenha sido registrado para o evento.


143
 



Segue abaixo a lista de eventos da classe Form define, incluindo uma breve descrição de cada evento e
A sintaxe para substituir o método protegido que corresponde a cada evento. Note também que o
classe Form indiretamente deriva da classe de controle e que a classe de controle também expõe eventos
e métodos substituíveis que não são mostrados aqui.

Ativada

Acionado quando o formulário é ativado. Sua sintaxe é:

Substitui Sub Protected OnActivated (ByVal e As System.EventArgs)
Fechado

Acionado quando o formulário foi fechado. Sua sintaxe é:

Protegido substituições Sub OnClosed (ByVal e As System.EventArgs)
Fechar

Acionado quando o formulário está prestes a fechar. Sua sintaxe é:

Protected Sub Substitui OnClosing (_
   
ByVal e As System.ComponentModel.CancelEventArgs)

A propriedade CancelEventArgs.Cancel pode ser definida como True para impedir que o formulário de encerramento, a sua
valor padrão é False.

Desativar

Acionado quando o formulário é desativado. Sua sintaxe é:

Sub Protected Substitui OnDeactivate (ByVal e As System.EventArgs)
InputLanguageChanged

Acionado quando a linguagem do formulário de entrada foi alterado. Sua sintaxe é:

Sub Protected Substitui OnInputLanguageChanged (_
   
ByVal e As System.Windows.Forms.InputLanguageChangedEventArgs)

A classe InputLanguageChangedEventArgs tem três propriedades que identificam o novo
idioma: CharSet, que define o conjunto de caracteres associados com o idioma de entrada nova;
Cultura, que contém o código de cultura (ver Anexo C) do novo idioma de entrada e
InputLanguage, que contém um valor que indica o novo idioma.

InputLanguageChanging

Disparado quando a linguagem de entrada do formulário está prestes a ser mudado. Sua sintaxe é:

Protegido substituições OnInputLanguageChanging Sub (_
   ByVal e As System.Windows.Forms.InputLanguageChangingEventArgs)

A classe InputLanguageChangingEventArgs tem uma propriedade que identifica a Cultura
proposto novo idioma e localidade. Ele também tem uma propriedade Cancel que pode ser definida como True
dentro do manipulador de eventos para cancelar a mudança de idioma de entrada, o valor padrão do
Cancelar propriedade é False.

Carga



144
 
NET Programação Visual Basic.


Acionado quando o formulário é carregado. Sua sintaxe é:

Substitui Sub Protected OnLoad (ByVal e As System.EventArgs)
MaximizedBoundsChanged

Acionado quando o valor da propriedade do formulário MaximizedBounds (que determina o tamanho da
a forma maximizada) é alterado. Sua sintaxe é:

Sub Protected Substitui OnMaximizedBoundsChanged (_
   ByVal e As System.EventArgs)
MaximumSizeChanged

Acionado quando o valor da propriedade do formulário MaximumSize (que define o tamanho máximo para
que o formulário pode ser redimensionado) é alterado. Sua sintaxe é:

Protegido substituições Sub OnMaximumSizeChanged (ByVal e As
System.EventArgs)
MdiChildActivate

Acionado quando uma janela filho MDI é ativado. Sua sintaxe é:

Sub Protected Substitui OnMdiChildActivate (ByVal e As
System.EventArgs)
MenuComplete

Acionado quando a selecção do menu está terminado. Sua sintaxe é:

Sub Protected Substituições (ByVal e As System.EventArgs) OnMenuComplete
MenuStart

Acionado quando um menu é exibido. Sua sintaxe é:

Protegido substituições OnMenuStart Sub (ByVal e As System.EventArgs)
MinimumSizeChanged

Acionado quando o valor da propriedade do formulário MinimumSize (que define o tamanho mínimo para
que o formulário pode ser redimensionado) é alterado. Sua sintaxe é:

Protegido substituições Sub OnMinimumSizeChanged (ByVal e As
System.EventArgs)

4,3 relações entre formas

A classe Form tem duas propriedades que controlam a relação de um formulário para outras formas: a propriedade Parent
(Herdada da classe Control) ea propriedade do Proprietário. A definição da propriedade dos pais faz com que o
forma restrita para aparecer apenas dentro dos limites do pai e sempre apareça no topo do
mãe. Isso dá um efeito semelhante ao aplicações MDI (que tem outras características bem e são
discutido mais adiante neste capítulo). Quando um formulário tem um pai, ele pode ser encaixado nas bordas do pai, apenas
como qualquer outro controle. O código no Exemplo 4-4 demonstra isso. Ele pode ser compilado a partir do
linha de comando com o comando:

filename.vb vbc / r: System.dll, System.Drawing.dll System.Windows.Forms.dll
/ T: winexe

O resultado é apresentado na Figura 4-6.




145
 



Figura 4-6. Um formulário com um pai



















Exemplo 4-4. Criando um formulário com um dos pais
Imports System.Drawing
Imports System.Windows.Forms

modMain Módulo
   Sub <System.STAThreadAttribute( )> Pública Main ()
      System.Threading.Thread.CurrentThread.ApartmentState _ =
         
System.Threading.ApartmentState.STA
      System.Windows.Forms.Application.Run (MyParentForm Nova ())
   End Sub
End Module

Público MyParentForm Classe
   Formulário Inherits
   
Sub New Public ()
      "Definir o meu tamanho.
      Me.ClientSize System.Drawing = Nova (600, 400)
      "Criar e mostrar um formulário filho.
      Dim frm Como MyChildForm Novo (Me)
      
frm.Show ()
   End Sub
End Class

Público MyChildForm Classe
   
Formulário Inherits
   Sub New Public (ByVal Parent Control)
      "TopLevel deve ser falso para mim ter um pai.
      
Me.TopLevel = False
      "Definir o meu pai.
      Me.Parent pai =
      
'Dock para margem esquerda do meu pai.
      Me.Dock DockStyle.Left =
   
End Sub
End Class

Se o formulário filho estiver maximizada, ela se expande para preencher o formulário pai. Se o formulário filho é minimizado, ele encolhe
a um pequeno retângulo na parte inferior da janela pai. Porque o formulário filho neste exemplo tem uma
barra de título e uma borda de tamanho considerável, que pode ser movido e dimensionado, embora tenha sido cortada. Este
comportamento pode ser alterado, modificando a propriedade FormBorderStyle do formulário.




146
 
NET Programação Visual Basic.


A configuração da propriedade Owner de uma forma faz com que uma outra forma de possuir o primeiro. Uma forma de propriedade não é
constrangido a aparecer dentro dos limites do seu dono, mas quando ele faz cobertura de seu dono, é sempre
em cima. Além disso, a forma de propriedade é sempre minimizado, restaurado ou destruído quando seu dono é
minimizado, restaurado ou destruído.
formas de propriedade são bons para ferramenta de janelas flutuantes ou Find/Replace-
tipo de caixas de diálogo. O código no Exemplo 4-5 cria um proprietário / relações públicas. Compilá-lo com
este comando:

filename.vb vbc / r: System.dll, System.Drawing.dll System.Windows.Forms.dll
/ T: winexe

Exemplo 4-5. Criando um formulário com o proprietário
Imports System.Drawing
Imports System.Windows.Forms

modMain Módulo
   Sub <System.STAThreadAttribute( )> Pública Main ()
      System.Threading.Thread.CurrentThread.ApartmentState _ =
         
System.Threading.ApartmentState.STA
      System.Windows.Forms.Application.Run (MyOwnerForm Nova ())
   End Sub
End Module

Public Class MyOwnerForm
   Formulário Inherits
   
Sub New Public ()
      "Definir o meu tamanho.
      Me.ClientSize System.Drawing = Nova (600, 450)
      
"Criar e mostrar uma forma de propriedade.
      Dim frm Como MyOwnedForm Novo (Me)
      
frm.Show ()
   End Sub
End Class
Público MyOwnedForm Classe
   Formulário Inherits
   
Sub New Public (Proprietário ByVal "Forma")
      "Definir o meu dono.
      Me.Owner Proprietário =
   
End Sub
End Class

4,4 Aplicativos MDI

Multiple Document Interface (MDI) permite mais de um documento a ser aberto ao mesmo tempo.
Isto está em contraste com a interface de documento único (SDI) aplicações, que pode manipular apenas um
documento de cada vez. Visual Studio. NET é um exemplo de uma aplicação MDI arquivos de origem-e muitas
vistas do projeto pode ser aberto de uma vez. Em contraste, o Bloco de Notas é um exemplo de uma abertura aplicativo SDI-
um documento encerra qualquer documento anteriormente aberto.

Há mais para aplicativos MDI do que sua capacidade de ter vários arquivos abertos ao mesmo tempo. O Microsoft
Windows Platform SDK especifica vários comportamentos interface do usuário que deve executar aplicativos MDI. A
Sistema operacional Windows fornece suporte para esses comportamentos, e este apoio é exposta através de
Windows Forms também.









147
 



4.4.1 Pais e formulários filho

aplicações MDI consistem de um formulário principal, que ela própria não exibir quaisquer dados, e um ou mais filhos
formas, que aparecem apenas no formulário principal e são usados para a exibição de documentos.
A principal forma
é chamado de pai MDI, e as formas da criança são chamados filhos MDI.

A classe Form tem duas propriedades que controlam se uma determinada forma é um pai MDI, MDI filho, ou
nenhum dos dois. As Boolean propriedade IsMdiContainer determina se um formulário se comporta como um pai MDI.
A propriedade MdiParent (que é do tipo Form) controla se um formulário se comporta como um filho MDI.
Definir a propriedade MdiParent de um formulário para fazer referência a forma da aplicação MDI pai faz com que o
formulário de um formulário MDI filho.
Exemplo 4-6 mostra a quantidade mínima de código necessário para exibir um MDI
formulário principal que contém um formulário único filho MDI.

Exemplo 4-6. Uma aplicação MDI mínima
Imports System
Imports System.Windows.Forms

Público AppModule Módulo
   
Sub Público Main ()
      Application.Run (MainForm Nova ())
   End Sub
End Module
Public Class MainForm
   Formulário Inherits

   Sub New Public ()
      
"Definir a legenda da janela principal.
      Text = "Pedido Meu MDI"
      "Definir este é um formulário pai MDI.
      
IsMdiContainer = True
      "Criar um formulário filho.
      
Dim myChild como nova DocumentForm ("Meus Documentos", Me)
      myChild.Show
   
End Sub
End Class

Público DocumentForm Classe
   Formulário Inherits

   
Public Sub New (ByVal nome As String, ByVal pai Como Forma)
      "Definir a legenda da janela do documento.
      Texto name =
      "Defina esta opção para ser um formulário MDI filho.
      
MdiParent mãe =
   End Sub

End Class

Supondo que o código no Exemplo 4-6 é salvo em um arquivo chamado MyApp.vb, ele pode ser compilado a partir de
linha de comando com o comando:

vbc MyApp.vb / r: System.dll, System.Windows.Forms.dll

Correr o executável resultante produz a tela mostrada na Figura 4-7.





148
 
NET Programação Visual Basic.


Figura 4-7. Uma aplicação MDI mínima (a saída do código em
Exemplo 4-6)






















A classe Form tem duas propriedades somente leitura relacionadas ao comportamento MDI. A propriedade retorna IsMdiChild
um valor booleano que indica se o formulário é um filho MDI. A propriedade MdiChildren de um pai
formulário contém uma coleção de referências a formas a forma da criança. O IsMdiChild e MdiChildren
propriedades são mantidas automaticamente em resposta à definição das formas criança MdiParent
propriedades.

4.4.2 Criando um Menu Janela

aplicações MDI têm geralmente um item de menu principal chamada janela. Neste menu aparecem itens de série
em cascata, azulejos, janelas filho e ativar e organizar os ícones das janelas minimizadas criança.
Figura 4-8 mostra um exemplo típico.

Figura 4-8. Um menu Janela típica









Tal menu é fácil de criar usando o suporte do Windows Forms. Supondo que você fosse fazer isso
programaticamente, Exemplo 4-7 mostra uma versão revisada do Exemplo 4-6 que foi modificado para
incluem um menu Janela, o código adicionado é mostrado em negrito. Para mais detalhes sobre como trabalhar com menus
a partir do IDE do Visual Studio, bem como programação, consulte a Seção 5.5 do Capítulo 5.

Exemplo 4-7.
Uma aplicação MDI com um menu Janela
Imports System
Imports System.Windows.Forms

Público AppModule Módulo
   Sub Público Main ()
      Application.Run (MainForm Nova ())



149
 



   End Sub
End Module

Public Class MainForm
   Formulário Inherits

   'Menu Declare MainForm principais
   
myMainMenu Privado Como MainMenu

   'Declare menu do Windows
   
Protegido mnuWindow WithEvents Como MenuItem
   Protegido mnuTileHoriz WithEvents Como MenuItem
   Protegido mnuCascade WithEvents Como MenuItem
   
Protegido WithEvents mnuTileVert Como MenuItem
   Protegido mnuArrangeAll WithEvents Como MenuItem

   
Sub New Public ()
      "Definir a legenda da janela principal.
      
Text = "Pedido Meu MDI"
      "Definir este é um formulário pai MDI.
      IsMdiContainer = True
      
"Criar menu principal
      MyMainMenu MainMenu = Novo ()
      
"Definir os itens de menu
      mnuWindow = Novo MenuItem ()
      mnuTileHoriz = Novo MenuItem ()
      
mnuTileVert = Novo MenuItem ()
      mnuCascade = Novo MenuItem ()
      mnuArrangeAll = Novo MenuItem ()
      "Propriedades do menu Set
      mnuWindow.Text = "Janela"
      
mnuWindow.MdiList = True
      mnuTileHoriz.Text = "Lado a Lado Horizontalmente"
      mnuTileVert.Text = "Lado a Lado Verticalmente"
      
mnuCascade.Text = "Cascata"
      mnuArrangeAll.Text = "Organizar ícones"
      
'Adicionar itens ao menu
      MyMainMenu.MenuItems.Add (mnuWindow)
      mnuWindow.MenuItems.Add (mnuCascade)
      
mnuWindow.MenuItems.Add (mnuTileHoriz)
      mnuWindow.MenuItems.Add (mnuTileVert)
      mnuWindow.MenuItems.Add (mnuArrangeAll)
      
'Menu Atribuir a forma
      Me.Menu MyMainMenu =
      
"Criar um formulário filho.
      Dim myChild como nova DocumentForm ("Meus Documentos", Me)
      
myChild.Show
   End Sub

   Public Sub mnuCascade_Click (o As Object, e As EventArgs) _
              mnuCascade.Click Handles
      
LayoutMdi (MdiLayout.Cascade)
   End Sub

   Public Sub mnuTileHoriz_Click (o As Object, e As EventArgs) _
              mnuTileHoriz.Click Handles
      
LayoutMdi (MdiLayout.TileHorizontal)
   End Sub

   Public Sub mnuTileVert_Click (o As Object, e As EventArgs) _
              mnuTileVert.Click Handles


150
 
NET Programação Visual Basic.


      LayoutMdi (MdiLayout.TileVertical)
   End Sub

   Public Sub mnuArrangeAll_Click (o As Object, e As EventArgs) _
              
mnuArrangeAll.Click Handles
      LayoutMdi (MdiLayout.ArrangeIcons)
   
End Sub

End Class

Público DocumentForm Classe
   
Formulário Inherits

   Public Sub New (ByVal nome As String, ByVal pai Como Forma)
      "Definir a legenda da janela do documento.
      
Texto name =
      "Defina esta opção para ser um formulário MDI filho.
      MdiParent mãe =
   
End Sub

End Class

Para adicionar um menu Janela para o formulário pai de uma aplicação MDI, execute os seguintes passos. Em primeiro lugar,
adicionar um item de menu para o menu principal do formulário pai MDI, definindo sua propriedade de texto para qualquer coisa desejada
(Geralmente Janela) e sua propriedade MdiList como True. É a propriedade MdiList que faz o Window
menu de um menu Janela. Definindo a propriedade MdiList True faz com que o Windows Forms para enquadramento
adicionar e excluir itens do menu de e para este item de menu, conforme necessário. Este, por sua vez, irá exibir sempre
a lista actual de janelas filho MDI do menu.

Em seguida, adicione os itens de menu em cascata, horizontal Tile, Tile verticalmente, e Organizar ícones.
No Clique
manipulador de eventos para cada um desses itens de menu, chamada de método da classe do formulário LayoutMdi, passando o
valor do parâmetro adequado para a ação desejada.

A sintaxe do método LayoutMdi é:

Public Sub LayoutMdi (ByVal
Como o valor MdiLayout)

único argumento do método deve ser um valor da enumeração MdiLayout (definido no
System.Windows.Forms namespace). Os valores nessa enumeração são:

ArrangeIcons

Indica que os ícones para as janelas filho MDI deve ser minimizado dispostas ordenadamente.

Cascata

Indica que as janelas filho MDI deve ser em cascata (exibido sobrepostos uns aos outros).

TileHorizontal

Indica que as janelas filho MDI deve estar lado a lado (exibidos sem sobreposição), com cada
janela filho preenchendo a largura do pai MDI.

TileVertical

Indica que as janelas filho MDI deve estar lado a lado, com cada janela filho de enchimento à altura
do pai MDI.


151
 



4.4.3 Mesclando Menus

Muitas vezes, os itens que devem aparecer no menu principal de um aplicativo MDI são dependentes do tipo de
documento que está sendo exibido ou se qualquer documento é exibido em todos.
É claro que esse efeito poderia
ser alcançado no código dinamicamente adicionar e remover itens do menu cada vez que uma janela filho é
ativado. No entanto, a estrutura do Windows Forms fornece uma maneira mais fácil.

Se um formulário filho MDI tem um menu principal de seu próprio, e que no menu principal do formulário pai MDI são mesclados
para produzir o menu que será mostrado para o usuário quando o formulário filho é exibido.
Duas propriedades do
classe MenuItem afetam o modo como os itens do menu são mesclados. Em primeiro lugar, a propriedade MergeOrder determina o
ordem em que os itens do menu são exibidos. Esta propriedade pode ser definida para qualquer valor inteiro, e os
Os valores não precisam ser contíguos. Os itens do menu dos dois menus são classificados neste valor a
determinar a ordem em que os itens do menu são exibidos na tela.

Por exemplo, considere um formulário pai MDI que tem um menu principal com três itens de menu que representa
Arquivo, da janela, menus e ajuda. Além disso, dizer que as propriedades MergeOrder desses itens de menu são
10, 20 e 30, respectivamente. Agora, se um formulário filho MDI é apresentado e seu menu principal tem, por
exemplo, um Edit item com um valor de propriedade MergeOrder de 15, o menu apresentado para o usuário
ter quatro itens: Arquivo, Editar, Janela e Ajuda, nessa ordem. Exemplo 4-8 mostra uma versão revista do
Exemplo 4-6 que contém o código necessário para criar um menu desses; linhas mostradas em negrito têm
foi adicionado para definir o menu principal e seus itens de menu.

Exemplo 4-8. Uma aplicação MDI com menus mesclados
Imports System
Imports System.Windows.Forms

Público AppModule Módulo
   Sub Público Main ()
      Application.Run (MainForm Nova ())
   
End Sub
End Module
Public Class MainForm
   
Formulário Inherits
   'Menu Declare MainForm principais.
   
myMainMenu Privado Como MainMenu

   'Declare o menu Janela.
   
Protegido mnuFile WithEvents Como MenuItem
   Protegido mnuWindow WithEvents Como MenuItem
   
Protegido mnuHelp WithEvents Como MenuItem

   Sub New Public ()
      
"Definir a legenda da janela principal.
      Text = "Pedido Meu MDI"
      "Definir este é um formulário pai MDI.
      
IsMdiContainer = True
      "Criar menu principal
      
MyMainMenu MainMenu = Novo ()
      "Definir os itens de menu
      mnuFile = Novo MenuItem ()
      
mnuWindow = Novo MenuItem ()
      mnuHelp = Novo MenuItem ()
      "Propriedades do menu Set
      
mnuFile.Text = "& Arquivo"
      mnuFile.MergeOrder = 10
      
mnuWindow.Text = "Janela"
      mnuWindow.MergeOrder = 20


152
 
NET Programação Visual Basic.


      mnuWindow.MdiList = True
      mnuHelp.Text = "& Ajuda"
      
mnuHelp.MergeOrder = 30
      'Adicionar itens ao menu
      
MyMainMenu.MenuItems.Add (mnuFile)
      MyMainMenu.MenuItems.Add (mnuWindow)
      MyMainMenu.MenuItems.Add (mnuHelp)
      
'Menu Atribuir a forma
      Me.Menu MyMainMenu =
      "Criar um formulário filho.
      Dim myChild como nova DocumentForm ("Meus Documentos", Me)
      
myChild.Show
   End Sub

End Class

Público DocumentForm Classe
   
Formulário Inherits

   'Declare menu
   mdiMenu Privado como novo MainMenu
   'Declare os itens do menu
   
Protegido mnuEdit WithEvents Como MenuItem

   Public Sub New (ByVal nome As String, ByVal pai Como Forma)
      "Definir a legenda da janela do documento.
      
Texto name =
      "Defina esta opção para ser um formulário MDI filho.
      MdiParent mãe =
      
'Instanciar menu e itens de menu
      mdiMenu = New MainMenu ()
      
mnuEdit = Novo MenuItem ()
      "Propriedades do menu Set
      mnuEdit.Text = "Editar"
      
mnuEdit.MergeOrder = 15
      "Adicionar item ao menu principal
      mdiMenu.MenuItems.Add (mnuEdit)
      
"Adicionar menu de janela filho
      Me.Menu mdiMenu =
   
End Sub

End Class

Se um item de menu no menu formulário filho MDI tem o valor MergeOrder mesmo como um item de menu no MDI
menu formulário pai, uma segunda propriedade entra em jogo. A propriedade de ambas as MergeType MenuItem
objetos são examinados, bem como o comportamento é determinado pela combinação de seus valores. A
MergeType propriedade é do tipo MenuMerge (uma enumeração definida no System.Windows.Forms
namespace) e pode ter um dos seguintes valores:

Adicionar

O item de menu aparece como um item separado no menu de destino, independentemente da configuração do
propriedade MergeType item de menu outros.

MergeItems

Se a propriedade MergeType o item de menu do outro também é definido como MergeItems, os dois itens de menu
são fundidos em um único item no menu de destino. A fusão é então recursivamente aplicada ao
subitens dos menus fonte, usando as suas propriedades e MergeOrder MergeType.



153
 



Se a propriedade MergeType o item de menu do outro é definido como Adicionar, ambos os itens do menu aparecem na
menu de destino (como se ambos tinham especificado Adicionar).

Se a propriedade MergeType o item de menu do outro é definido como remover apenas um item do menu aparece na
o menu de destino (de novo, o mesmo que especificar Adicionar para este item de menu).

Se a propriedade MergeType o item de menu do outro está definido para substituir, só o menu do formulário filho
item é exibido, independentemente de qual é definida como MergeItems e qual é definida como
Substituir. (Este parece ser um comportamento incoerente e pode ser um bug).

Remover

O item de menu não é exibido no menu de destino, independentemente da configuração do menu de outros
propriedade MergeType item.

Substituir

Se a propriedade MergeType o item de menu do outro é definido como Adicionar, ambos os itens do menu aparecem na
menu de destino (como se ambos tinham especificado Adicionar).

Se a propriedade MergeType o item de menu do outro é definido como MergeItems ou substituir, somente o filho
item de formulário do menu é mostrada. (Este parece ser um comportamento incoerente e pode ser um bug).

Se a propriedade MergeType o item de menu do outro também está definido para substituir, apenas a forma da criança
item de menu é exibido.

4.4.4 Detecção de ativação de janela MDI Child

Código da classe do formulário pai MDI pode ser notificado quando um formulário MDI filho torna-se ativa dentro de um
MDI formulário pai. ("Ativos" significa que o formulário criança recebe o foco de entrada após o outro filho MDI
forma ou o formulário pai MDI tinha o foco de entrada.) Para receber a notificação, o formulário pai MDI
deve substituir o método OnMdiChildActivate (definido na classe Form).
Por exemplo:

"Coloque isso dentro da definição da classe do formulário pai MDI.
Sub Protected Substitui OnMdiChildActivate (ByVal e As EventArgs)
   
MyBase.OnMdiChildActivate (e) "Importante
   '...
End Sub

É importante chamar a implementação base-classe de OnMdiChildActivate dentro da imperiosa
função, de modo que qualquer tratamento necessário da classe base (incluindo a subida do evento MdiChildActivate)
pode ocorrer.

O parâmetro e não carrega nenhuma informação. Para saber qual formulário MDI filho tornou-se ativo, leia o
propriedade ActiveMdiChild do formulário pai MDI. Esta propriedade é do tipo Form. Convertê-lo para o MDI
Tipo de formulário filho para ter acesso a todos os membros do público que são específicos para esse tipo. Por exemplo:

Sub Protected Substitui OnMdiChildActivate (ByVal e As EventArgs)
   
MyBase.OnMdiChildActivate (e)
   "Assume-se que SomeFormType definidas em qualquer lugar e herda
   'Do formulário.
Também assume que os formulários filho MDI na
   aplicação são sempre deste tipo.
   Dim ChildForm Como SomeFormType _ =
      CType (ActiveMdiChild, SomeFormType)
   
"Faça alguma coisa com ChildForm aqui.
   '...


154
 



End Sub
 
NET Programação Visual Basic.
 

Para ter o código fora da classe de formulário pai MDI notificado quando um formulário MDI filho se torna ativa,
escrever um manipulador para o evento MdiChildActivate o formulário pai MDI.
Este evento é definido no Formulário de
classe como:

Evento Público MdiChildActivate (_
   
ByVal sender As Object, _
   ByVal e As EventArgs _
)

O parâmetro do remetente é o formulário pai MDI, e não o formulário filho MDI que foi ativado. O e-
parâmetro não contém qualquer informação adicional sobre o evento. Como quando substituindo o
OnMdiChildActivate método, ler a propriedade do formulário pai MDI ActiveMdiChild para descobrir quais
MDI filho formulário foi ativado.

4,5 Componente Atributos

Como explicado no capítulo 2, os atributos podem ser adicionados ao código para fornecer elementos adicionais
informações sobre esses elementos. O namespace System.ComponentModel define vários
atributos para o uso do componente, controle e declarações formulário. Esses atributos não afetam
comportamento do componente. Em vez disso, eles fornecem informações que são usadas ou exibido pelo Visual
Studio. NET IDE. O seguinte é uma descrição de cada atributo:

AmbientValueAttribute

Para propriedades do ambiente, especifica o valor da propriedade que vai significar "obter essa propriedade real
valor a partir de onde os valores ambientais vêm para esta propriedade. "propriedades ambientais são
propriedades capazes de obter os seus valores de outra fonte. Por exemplo, a propriedade BackColor
de um controle Label pode ser definida como um valor de cor específico ou para o valor especial
Color.Empty, que faz com que a cor da etiqueta do fundo a ser o mesmo que o fundo
cor da forma em que é colocado.

Colocando este atributo em uma definição de propriedade não é o que faz com que a propriedade de se comportar como um
propriedade do ambiente: o controle em si deve ser escrito de tal forma que quando o valor especial é escrito
para a propriedade, o controle recebe o valor real do local apropriado. Este atributo
simplesmente fornece o Windows Forms Designer com uma maneira de descobrir qual é o valor especial.

Ao especificar esse atributo, passar o valor especial para o atributo do construtor. Para
exemplo, <AmbientValue(0)>.

BindableAttribute

Indica se uma propriedade é normalmente utilizável para a ligação de dados. Especifique <Bindable(True)>
para indicar que a propriedade pode ser usada para ligação de dados ou <Bindable(False)> para indicar
que a propriedade não é tipicamente usado para a ligação de dados. Esse atributo afeta o modo como uma propriedade é
exibido no IDE, mas não afeta se uma propriedade pode ser vinculada a execução. Por
padrão, as propriedades são consideradas como não ligáveis.

BrowsableAttribute

Indica se uma propriedade deve ser visível na janela Propriedades do IDE. Especifique
<Browsable(True)> Para indicar que a propriedade deve aparecer na janela de propriedades ou
<Browsable(False)> Para indicar que ele não deveria. Por padrão, as propriedades são consideradas
navegável.




155
 
 



CategoryAttribute

Indica a categoria para a qual um evento ou propriedade pertence ("Aparência", "Comportamento", etc.)
O IDE usa esse atributo para classificar as propriedades e eventos na janela Properties. Especifique
o nome da categoria como um argumento de seqüência de caracteres para o atributo. Por exemplo,
<Category("Appearance")>. O argumento pode ser qualquer string. Se não é um dos
strings padrão, a janela Propriedades de adicionar um novo grupo para ele. Os caracteres padrões são:

Ação

Usado para eventos que indicam uma ação do usuário, como o evento Click.

Aparência

Usado para propriedades que afetam a aparência de um componente, como o BackColor
propriedade.

Comportamento

Usado para propriedades que afetam o comportamento de um componente, tal como propriedade AllowDrop.

Dados

Usado para as propriedades que dizem respeito aos dados, tais como a propriedade CasasDecimais do
NumericUpDown controle.

Design

Usado para as propriedades que se relacionam com o aparecimento de tempo de design ou o comportamento de um componente.

DragDrop

Usado para propriedades e eventos que se relacionam com arrastar e soltar. Nenhum componentes do Windows Forms
possui propriedades ou eventos marcados com esta categoria.

Foco

Usado para propriedades e eventos que se relacionam com o foco de entrada, tais como a propriedade e CanFocus
o evento GotFocus.

Formato

Usado para propriedades e eventos que se relacionam com os formatos. Nenhum componente do Windows Forms têm
quaisquer propriedades ou eventos marcados com esta categoria.

Key

Usado para eventos que se relacionam com a entrada do teclado, como o evento KeyPress.

Layout

Usado para propriedades e eventos que se relacionam com o layout visual de um componente, como o
Altura da propriedade e o evento Resize.

Mouse



156
 
NET Programação Visual Basic.


Usado para eventos que se relacionam com a entrada do mouse, como o evento MouseMove.

WindowStyle

Usado para propriedades e eventos que se relacionam com o estilo da janela de formas de nível superior. Não Windows
componentes Forms possui propriedades ou eventos marcados com esta categoria.

Se não CategoryAttribute é especificado, a propriedade é considerada uma categoria de
Misc.

DefaultEventAttribute

Indica o nome do evento que é considerado o evento padrão de um componente. Para
exemplo, <DefaultEvent("Click")>. Quando um componente é clicado duas vezes no
Windows Forms Designer, o designer alterna para visualização de código e exibe o manipulador de eventos
para o evento padrão. Esse atributo pode ser usado somente em declarações de classe.

DefaultPropertyAttribute

Indica o nome da propriedade que deve ser considerada a propriedade padrão de um
componente.
Por exemplo, <DefaultProperty("Text")>. Este atributo só pode ser utilizado
sobre as declarações de classe. A propriedade padrão é a propriedade que o Windows Forms Designer
destaques na janela Propriedades quando um componente é clicado em vista do projeto.

Não confunda esse uso da propriedade padrão prazo com a
uso associado com o modificador padrão de uma propriedade
declaração. Os dois conceitos são independentes. Consulte o Capítulo 2
Para mais detalhes sobre o modificador padrão.
DefaultValueAttribute

Indica o valor default de uma propriedade. Por exemplo, <DefaultValue(0)>. Se o IDE é
usado para definir um valor de propriedade para algo diferente do valor padrão, o gerador de código
gerar a declaração de atribuição adequada do código. No entanto, se o IDE é usado para definir um
propriedade para o valor padrão, nenhuma instrução de atribuição é gerado.

DescriptionAttribute

Fornece uma descrição para o elemento de código. Por exemplo, <Description ("O texto
contidos no controle .")>. O IDE usa esta descrição em dicas de ferramentas e
IntelliSense.

DesignerAttribute

Identifica a classe que atua como designer de um componente. Por exemplo,
<Designer("MyNamespace.MyClass")>. A classe do designer deve implementar a
IDesigner interface. Esse atributo pode ser usado somente em declarações de classe e é necessário
somente se o built-in designer não é suficiente. Criar designers personalizados não é discutido neste
livro.

DesignerCategoryAttribute

Usado com designers personalizados para especificar a categoria para a qual o designer classe pertence.

DesignerSerializationVisibilityAttribute


157
 



Usado com designers personalizados para especificar como uma propriedade em um componente é salvo pelo
designer.

DesignOnlyAttribute

Indica quando uma propriedade pode ser definida. Especifique <DesignOnly(True)> para indicar que o
propriedade pode ser definida em tempo de design ou <DesignOnly(False)> apenas para indicar que o
propriedade pode ser definida em tempo de design e tempo de execução (o padrão).

EditorAttribute

Identifica o "editor", para usar no IDE para permitir que o usuário defina os valores de propriedades que
ter o tipo em que o atributo EditorAttribute aparece. Deste modo, um componente
pode declarar novos tipos e pode declarar as propriedades com os tipos, e ainda permitir que o usuário
para definir os valores das propriedades em tempo de design. Criando editores de tipo personalizado não é
discutidos neste livro.

EditorBrowsableAttribute

Indica se uma propriedade é visível em um editor. O argumento para o atributo do
construtor deve ser um dos valores definidos pela enumeração EditorBrowsableState
(Definido no namespace System.ComponentModel). Os valores dessa enumeração são:

Avançado

Somente usuários avançados devem ver a propriedade. Cabe ao editor para determinar quando é
adequado para exibir as propriedades avançadas.

Sempre

A propriedade deve ser sempre visível no editor.

Nunca

A propriedade nunca deve ser mostrada dentro do editor.

ImmutableObjectAttribute

Indica se uma declaração de tipo define um estado que pode mudar depois que um objeto dessa
tipo é construído.
Especifique <ImmutableObject(True)> para indicar que um objeto do
determinado tipo é imutável. Especifique <ImmutableObject(False)> para indicar que um objeto de
o tipo de dado não é imutável.










este livro.





158
 
NET Programação Visual Basic.






















































Extender





159
 












livro.




alterações.






















4,6 2-D com programação de gráficos GDI +





Este





A




   



160
 
NET Programação Visual Basic.


   
      
         
   
End Sub

   Sub New Public ()
      
   
End Sub

End Class
















Gráficos
































161
 












namespace).


























A




















162
 








 
NET Programação Visual Basic.
 





































É





   
   

   
   
   
   


163
 
 




   
   
End Sub



























cores.






o objeto.

elas.













Veja






164
 
NET Programação Visual Basic.









   
   
   
   

   
   
   
   

   
   
End Sub



























Mostrar



Documento



Nails





165

 

Milímetro

As unidades são especificadas em milímetros.

Pixel

As unidades são especificadas em pixels.

Ponto

As unidades são especificadas nos pontos (1 / 72 de polegada).

A propriedade DashStyle do objeto Pen determina a se a linha é contínua ou tracejada, bem
como o estilo do traço. A propriedade é DashStyle da enumeração tipo DashStyle (definido no
System.Drawing.Drawing2D namespace), que define os seguintes valores:

Custom

Especifica um estilo de traço definido pelo programador. Se esse valor for utilizado, outras propriedades da Caneta
objeto de controle a aparência exata dos traços na linha. Criação de estilos de traço personalizado é
não serão discutidos neste livro.

Traço

Especifica uma linha tracejada.

DashDot

Especifica uma linha composta por traços e pontos alternados.

DashDotDot

Especifica uma linha composta de traços alternando e dois pontos.

Ponto

Especifica uma linha pontilhada.

Sólidos

Especifica uma linha sólida.

Os estilos de traço padrão são mostrados na Figura 4-11.

Figura 4-11. O padrão de valores DashStyle













166
 



4.6.3 Classe A escova
 
NET Programação Visual Basic.
 

objetos Brush mantenha as configurações usadas ao preencher áreas gráficas. Todos da classe Graphics
Preencha ... métodos (FillClosedCurve, FillEllipse, etc) exigem que o chamador fornecer um objeto Brush. A
objeto Brush fornecido determina como o interior da figura vão ser pintadas. Exemplo 4-11 mostra
OnPaint um método que pode ser usado para desenhar uma elipse em um controle de usuário ou um formulário. É semelhante ao
Exemplo 4-9, mas desenha uma elipse preenchida em vez de um esboço. As linhas que diferem do Exemplo 4-9
são exibidas em negrito. A tela resultante é mostrado na Figura 4-12.

Exemplo 4-11. Desenho de uma elipse preenchida em um formulário
Protegido substituições OnPaint Sub (ByVal e As PaintEventArgs)
   Como SolidBrush Dim br Novo (Me.ForeColor)
   Dim rect como retângulo

   rect.X Me.ClientRectangle.X = + (Me.ClientRectangle.Width \ 4)
   rect.Y Me.ClientRectangle.Y = + (Me.ClientRectangle.Height \ 4)
   rect.Width Me.ClientRectangle.Width = \ 2
   rect.Height Me.ClientRectangle.Height = \ 2
   e.Graphics.FillEllipse (br, rect)
   br.Dispose ()
End Sub

Figura 4-12. A elipse desenhada por o código no Exemplo 4-11


















Note que o exemplo de 11/04 não é inteiramente paralelo ao Exemplo 4-9. Especificamente Exemplo, 4-9
instanciado um objeto Pen diretamente, mas Exemplo 4-11 instancia um objeto de uma classe que deriva
da classe Brush, em vez de diretamente da classe Brush. Os objetos não podem ser diretamente instanciada
da classe Brush. As classes que derivar de Brush são:

HatchBrush

Preenche uma área com um padrão de hachura. Hatch padrões são padrões de linhas e espaços. A
propriedade HatchStyle HatchBrush classe determina o padrão exato da escotilha. Ela é definida
no namespace System.Drawing.Drawing2D.

LinearGradientBrush

Preenche uma área com um gradiente de mistura de duas ou mais cores. Ela é definida no
System.Drawing.Drawing2D namespace.



167
 
 



PathGradientBrush

Preenche a área interna de um objeto GraphicsPath com um gradiente de mistura de duas ou mais cores. É
definidos no namespace System.Drawing.Drawing2D.

SolidBrush

Preenche uma área com uma cor sólida. Ela é definida no namespace System.Drawing.

TextureBrush

Preenche uma área com uma imagem. Ela é definida no namespace System.Drawing.

O. NET Framework fornece uma série de pincéis predefinidos através das propriedades das escovas
e classes SystemBrushes (definido no namespace System.Drawing). Por exemplo, o azul
propriedade da classe Brushes retorna um objeto Brush que preenche áreas com azul sólido. Assim, os seguintes
linha de código desenha um sólido azul elipse:

e.Graphics.FillEllipse (Brushes.Blue, rect)

Da mesma forma, a propriedade da classe SystemBrushes's Window retorna um objeto Brush cuja cor é definida como a
cor de fundo do sistema de área cliente da janela. Usando os pincéis padrão fornecido pela
Pincéis e classes SystemBrushes pode ser mais eficiente do que instanciar novos objetos Brush.
No entanto, suas propriedades não podem ser alterados.

Consulte a Tabela 4-1 para a lista de objetos Brush disponíveis através da classe Brushes. Veja Seção 4.6.4.1
para a lista de objetos Brush disponíveis através da classe SystemBrushes.

4.6.4 Estrutura Color

As cores são representadas por valores de cor tipo. A estrutura de cores define 141 cores nomeadas e
expõe como compartilhada propriedades somente leitura cujos valores são de cor tipo. Eles servem o propósito
de constantes de cores. Por exemplo, o seguinte fragmento de código define a cor de fundo do formulário
frm para branco:

frm.BackColor = Color.White

As propriedades de cor exposta pela estrutura de cor têm os mesmos nomes que as propriedades da caneta
expostos pela classe Pens e as propriedades escova expostos pela classe Brushes. A lista é longa,
por isso é impressa aqui uma só vez, na Tabela 4-1.


Tabela 4-1. Propriedades comuns às classes de cor, canetas e pincéis
 
Aliceblue
Água-marinha
Lambuja
Blue
BurlyWood
Chocolate
Cornsilk
DarkBlue
DarkGray
DarkMagenta


168
 
AntiqueWhite
Azul
Black
BlueViolet
CadetBlue
Coral
Carmesim
DarkCyan
Darkgreen
DarkOliveGreen
 
Aqua
Bege
BlanchedAlmond
Brown
Cor verde-amarelada
CornflowerBlue
Ciano
DarkGoldenrod
DarkKhaki
DarkOrange
 
 



DarkOrchid
DarkSeaGreen
DarkTurquoise
DeepSkyBlue
Tijolo refratário
Fúcsia
Ouro
Verde
HotPink
Marfim
LavenderBlush
LightBlue
LightGoldenrodYellow
LightPink
LightSkyBlue
LightYellow
Roupa
MediumAquamarine
MediumPurple
MediumSpringGreen
MidnightBlue
Mocassim
OldLace
Laranja
PaleGoldenrod
PaleVioletRed
Peru
Powderblue
RosyBrown
Salmão
SeaShell
SkyBlue
Snow
Bronzeado
Tomate
Violeta
WhiteSmoke

4.6.4.1 Sistema de cores
 
NET Programação Visual Basic.


DarkRed
DarkSlateBlue
DarkViolet
DimGray
FloralWhite
Gainsboro
Goldenrod
GreenYellow
IndianRed
Caqui
LawnGreen
LightCoral
LightGray
LightSalmon
LightSlateGray
Cal
Magenta
MediumBlue
MediumSeaGreen
MediumTurquoise
MintCream
NavajoWhite
Azeitona
OrangeRed
PaleGreen
Papayawhip
Pink
Purple
Deeppink
Sandybrown
Sienna
SlateBlue
SpringGreen
Cerceta
Transparente
Trigo
Amarelo
 



DarkSalmon
DarkSlateGray
DeepPink
DodgerBlue
ForestGreen
GhostWhite
Gray
Honeydew
Índigo
Lavanda
LemonChiffon
LightCyan
Lightgreen
LightSeaGreen
LightSteelBlue
LimeGreen
Maroon
MediumOrchid
MediumSlateBlue
MediumVioletRed
MistyRose
Marinha
OliveDrab
Orquídea
PaleTurquoise
PeachPuff
Ameixa
Vermelho
SaddleBrown
SeaGreen
Prata
SlateGray
Steelblue
Cardo
Turquesa
Branco
YellowGreen
 

É útil para descobrir as cores que o Windows usa para desenhar elementos janela específica, como a
barra de título da janela ativa. Se a cor se for necessário, ele pode ser obtido a partir da classe SystemColors.
Se uma caneta ou pincel da cor apropriada é necessário, a caneta ou pincel pode ser obtido a partir da
propriedade correspondente da classe de canetas ou pincéis, respectivamente. Os nomes de propriedades expostas por
estas três classes de sobreposição e, portanto, são aqui apresentados em uma única lista:

ActiveBorder





169
 
 



A cor da área preenchida da borda da janela ativa. (Não disponível em Canetas
classe).

ActiveCaption

A cor de fundo da barra de título da janela ativa. (Não disponível na classe Pens.)

ActiveCaptionText

A cor do texto na barra de título da janela ativa.

AppWorkspace

A cor de fundo das janelas do pai MDI. (Não disponível na classe Pens.)

Controle

A cor de fundo dos controles.

ControlDark

A cor da sombra de controles (para efeitos 3-D).

ControlDarkDark

A cor da sombra mais escura dos controles (para efeitos 3-D).

ControlLight

A cor de destaque dos controles (para efeitos 3-D).

ControlLightLight

A cor de destaque muito leve dos controles (para efeitos 3-D).

ControlText

A cor do texto em controles.

Desktop

A cor do desktop de Windows. (Não disponível na classe Pens.)

GrayText

A cor do texto de controles deficientes ou outros elementos com deficiência visual. (Não disponível na
Escovas de classe.)

Destaque

A cor de fundo do texto em destaque (seleccionado).

HighlightText

A cor do texto do destaque de texto (selecionado).


170
 



HotTrack
 
NET Programação Visual Basic.
 

A cor de fundo de um item quente controlado. acompanhamento quente é um item de destaque como o mouse
move-se sobre ele. usar o controle de menus do Windows quente. (Não disponível na classe Pens.)

InactiveBorder

A cor das áreas preenchidas das fronteiras de janelas inativas. (Não disponível em Canetas
classe).

InactiveCaption

A cor de fundo das barras de título das janelas inativas. (Não disponível na classe Pens.)

InactiveCaptionText

A cor do texto nas barras de título das janelas inativas. (Não disponível na classe Brushes.)

Info

A cor de fundo de dicas de ferramentas. (Não disponível na classe Pens.)

Texto informativo

A cor do texto de dicas de ferramentas. (Não disponível na classe Brushes.)

Menu

A cor de fundo dos menus. (Não disponível na classe Pens.)

MenuText

A cor do texto dos menus. (Não disponível na classe Brushes.)

ScrollBar

A cor das barras de rolagem na área não ocupada pela caixa de rolagem (ou polegar). (Não disponível em
a classe Pens.)

Janela

A cor de fundo das áreas de cliente do Windows. (Não disponível na classe Pens.)

WindowFrame

A cor dos quadros ao redor das janelas. (Não disponível na classe Brushes.)

WindowText

A cor do texto nas áreas de cliente do Windows.

Note-se que algumas dessas propriedades não estão disponíveis em qualquer classe Pens ou a classe Brushes. Em
tais casos, ainda é possível obter uma caneta ou pincel objeto da cor apropriada ao instanciar um
Nova caneta ou um objeto Brush, passando ao seu construtor o valor da cor desejada, como este:



171
 
 



Como SolidBrush Dim br Novo (SystemColors.InfoText)

4.6.5 Alpha Blending

Alpha blending é um processo que permite que um objeto Graphics para aparecer transparente, causando Graphics
objetos debaixo dele para ser vista através do objeto. O grau de transparência pode ser controlada em
passos completamente transparente (invisível) completamente opaco (obscurecendo todos os objetos abaixo dele).
Para desenhar um objeto transparente, instanciar Pen e Brush objetos com cores cuja alfa
componente é menor que o valor máximo de 255. componente de uma cor alpha é dada pela A
propriedade da estrutura Color. Esta propriedade é um Byte, para que ele possa assumir valores de 0 (invisíveis) a 255
(Completamente opaco).

Exemplo 4-12 mostra um método OnPaint que desenha o texto e, em seguida, desenha duas sobrepostas,
elipses transparente no mesmo espaço como o texto. Normalmente, as elipses que obscurecer o texto, e
a segunda elipse seria obscurecer o primeiro. Neste caso, porém, o texto pode ser visto através da
elipses porque as elipses são transparentes, ea primeira elipse pode ser visto através do segundo.
O resultado é mostrado na Figura 4-13.

Exemplo 4-12. Desenho de figuras transparentes
Protegido substituições OnPaint Sub (ByVal e As PaintEventArgs)

   "Determinar o texto a ser exibido e sua fonte.
   Dim str As String = "Aqui você encontra o texto a ser exibido em um formulário."
   Dim fnt como nova fonte ("Arial", 10, GraphicsUnit.Point, FontStyle.Regular)

   "Determinar a coordenadas X e Y no qual desenhar o texto de forma
   'Que é centrada na janela.
   Dim SZF Como SizeF e.Graphics.MeasureString = (str, FNT)
   Dim xtext As Single = (Me.DisplayRectangle.Width - szf.Width) / 2
   Dim yText As Single = (Me.DisplayRectangle.Height - szf.Height) / 2

   "Desenhar o texto.
   e.Graphics.DrawString (str, FNT, Brushes.Black, xtext yText)

   'Criar um pincel azul que é mais transparente.
   Como SolidBrush Dim br Novo (Color.FromArgb (160, Color.Blue))

   "Determinar o retângulo delimitador para a primeira elipse.
   Dim rect como retângulo
   rect.X Me.DisplayRectangle.X = + (Me.DisplayRectangle.Width \ 8)
   rect.Y Me.DisplayRectangle.Y = + (Me.DisplayRectangle.Height \ 8)
   rect.Width Me.DisplayRectangle.Width = \ 2
   rect.Height Me.DisplayRectangle.Height = \ 2

   "Desenhar a primeira elipse.
   e.Graphics.FillEllipse (br, rect)

   »Lançamento do pincel.
   br.Dispose ()

   'Criar um pincel vermelho que é mais transparente.
   br SolidBrush = Novo (Color.FromArgb (160, Color.Red))

   "Determinar o retângulo delimitador para a segunda elipse.
   rect.X + = (Me.DisplayRectangle.Width \ 4)
   rect.Y + = (Me.DisplayRectangle.Height \ 4)

   "Desenhar a segunda elipse.
   e.Graphics.FillEllipse (br, rect)


172
 




   »Lançamento do pincel.
   br.Dispose ()

End Sub
 
NET Programação Visual Basic.
 

Figura 4-13. O visor desenhado pelo código no Exemplo 4-12


















4.6.6 Suavização

Antialiasing é uma técnica para fazer as bordas das figuras gráficos aparecem menos dentadas. Para ativar
antialiasing, defina a propriedade SmoothingMode o objeto Graphics para SmoothingMode.AntiAlias.
(SmoothingMode é uma enumeração definida no namespace System.Drawing.Drawing2D.) Compare
os arcos mostrado na Figura 4-14. Ambos os arcos foram desenhados por chamar o método drawArc do Graphics
classe, mas o arco da esquerda foi tirada com a propriedade definida para SmoothingMode
SmoothingMode.None (o padrão), eo arco da direita foi desenhada com o SmoothingMode
propriedade definida como SmoothingMode.AntiAlias. Figura 4-15 mostra uma visão estreita de comparação-up
a parte superior de ambos os arcos.

Figura 4-14. Nonantialiased versus arcos antialiased





Figura 4-15. close-up de arcos e nonantialiased antialiased








Como mostra a Figura 4-15, antialiasing aparece para melhorar a resolução de pixels usando máscaras de gradiente
a cor que está sendo processado e da cor de fundo (neste caso, preto e branco, respectivamente).

A desvantagem de suavização é que leva mais tempo para processar.






173
 
 



4,7 Impressão

A maioria dos programas de Visual Basic. NET não terão necessidade de utilizar a impressão nativa. NET Framework
capacidades. As ferramentas de relatórios como o Crystal Reports, bem como ferramentas RAD para o layout de relatórios,
fornecer a maioria dos equipamentos de impressão típica que Visual Basic. NET programas necessidade. No entanto, para o
casos em que uma ferramenta de relatório não é suficientemente flexível, esta seção descreve o. NET Framework
suporte para saída de texto e gráficos diretamente para uma impressora.

4.7.1 Olá, impressora!

Exemplo 4-13 mostra um exemplo de impressão mínima.

Exemplo 4-13.
Olá, impressora!
Imports System.Drawing
Importações System.Drawing.Drawing2D
Importações System.Drawing.Printing

'...
'Estas duas linhas iniciar a impressão. Coloque esse código em um
'Lugar adequado na aplicação.
Dim pd Como HelloPrintDocument New ()
pd.Print ()
'...

"Essa classe gerencia o processo de impressão.
Público HelloPrintDocument Classe
   Herda PrintDocument

   Protegido substituições OnPrintPage Sub (ByVal e As PrintPageEventArgs)
      MyBase.OnPrintPage (e)

      "Desenhar texto para o dispositivo de elementos gráficos da impressora.
      Dim fnt como nova fonte ("Arial", 10, FontStyle.Regular, _
         GraphicsUnit.Point)
      e.Graphics.DrawString ("Olá, impressora!", FNT, Brushes.Black, 0, 0)
      fnt.Dispose ()

      "Indicar que não há mais páginas.
      e.HasMorePages = False
   End Sub

End Class

A impressão é gerida através da definição de uma classe que herda da classe PrintDocument (definido no
namespace System.Drawing.Printing). A impressão é iniciada por instanciar a classe derivada e chamando
seu método de impressão (herdado da classe PrintDocument). O método Print chama repetidamente a
OnPrintPage método, até que a propriedade HasMorePages do PrintPageEventArgs parâmetro é definido como
False. É o trabalho do método OnPrintPage para gerar cada página de saída que é enviada para o
impressora.

Dê uma olhada no método OnPrintPage no Exemplo 4-13, começando com a primeira linha:

MyBase.OnPrintPage (e)

Essa linha de código chama o método OnPrintPage implementado pela classe PrintDocument base,
passando o mesmo argumento que foi passado para o método da classe derivada OnPrintPage. Esta chamada
É importante porque o método da classe PrintDocument é OnPrintPage é responsável por disparar o



174
 
NET Programação Visual Basic.


evento objeto PrintDocument PrintPage. Se isso não for feito, qualquer código que tenha sido registrado para este evento
não vai recebê-lo. Este não é um problema neste pequeno exemplo, mas é, no entanto, uma boa programação
prática.

As próximas três linhas de código são responsáveis pela manipulação da impressão:

"Desenhar texto para o dispositivo de elementos gráficos da impressora.
Dim fnt como nova fonte ("Arial", 10, FontStyle.Regular, _
   GraphicsUnit.Point)
e.Graphics.DrawString ("Olá, impressora!", FNT, Brushes.Black, 0, 0)
fnt.Dispose ()

Este código desenha um texto para o objeto Graphics fornecido por PrintPageEventArgs
parâmetro. Tudo o que você aprendeu na seção anterior sobre o objeto Graphics é aplicável neste caso.

Finalmente, uma vez que estamos imprimindo apenas uma página no nosso programa de exemplo,
PrintPageEventArgs.HasMorePages é definida como False:

"Indicar que não há mais páginas.
e.HasMorePages = False

Esta linha indica que o método de impressão que o fim do documento tenha sido atingido. Se as páginas mais
precisam ser impressos, o método OnPrintPage deve definir a propriedade HasMorePages como True.

4.7.2 Classe A PrintPageEventArgs

A classe PrintPageEventArgs é declarado no namespace System.Drawing.Printing como:

Classe PrintPageEventArgs Pública
   Herda System.EventArgs

Suas propriedades são:

Cancelar

Uma indicação de que o trabalho de impressão está sendo cancelado. Essa propriedade é definida como True, o
sistema de impressão se o usuário cancelar o trabalho de impressão. O código no método OnPrintPage pode ler
esse valor e tomar as providências adequadas. No entanto, como definir programaticamente esta propriedade
voltar para False não retomar o trabalho de impressão. Por outro lado, como definir programaticamente para
True se cancelar o trabalho de impressão, mesmo se o usuário não clicou no botão Cancelar. A sintaxe
da propriedade Cancel é:

Propriedade Pública Cancelar () As Boolean
Gráficos

O objeto Graphics que representa a superfície da página. A sintaxe da propriedade Graphics é:

Public ReadOnly Property Graphics () As System.Drawing.Graphics
HasMorePages

O mecanismo para o método OnPrintPage para indicar ao sistema de impressão a existência
mais páginas a serem impressas após a página atual. O método deve definir este OnPrintPage
propriedade como True, quando há mais páginas para impressão e False quando não há mais
páginas para impressão. A sintaxe da propriedade HasMorePages é:

HasMorePages Propriedade Pública () As Boolean


175
 



MarginBounds

Um Retangular que especifica a área da página que está dentro das margens do documento (ou seja, o
domínio da página na qual processamento deve ocorrer). A sintaxe da propriedade MarginBounds
é o seguinte:

Public ReadOnly Property MarginBounds () As System.Drawing.Rectangle
PageBounds

Um Retangular que especifica a área total da página, incluindo a área fora das margens. A
sintaxe da propriedade PageBounds é:

Public ReadOnly Property PageBounds () As System.Drawing.Rectangle
PageSettings

A página de configurações que se aplicam à página a ser impressa. A sintaxe da
propriedade PageSettings é:

Public ReadOnly Property PageSettings () As _
   System.Drawing.Printing.PageSettings

A classe PageSettings é descrito mais tarde nesta seção.

4.7.3 Os Métodos OnBeginPrint e OnEndPrint

A classe PrintDocument fornece a OnBeginPrint OnEndPrint e métodos para gerenciar o início
e acabamento dos trabalhos de impressão. O método OnBeginPrint é chamado antes da primeira chamada para OnPrintPage e
OnEndPrint o método é chamado após a chamada final para OnPrintPage. O método é um OnBeginPrint
bom lugar para criar objetos que serão utilizados ao longo da vida do trabalho de impressão, canetas, pincéis e
fontes, por exemplo. A classe HelloPrintDocument no Exemplo 4-13 instancia um objeto Font durante
o método OnPrintPage. Isto é aceitável aqui porque apenas uma página está sendo impresso. No entanto,
na prática, os documentos podem conter muitas páginas, por isso é melhor mover este código para o OnBeginPrint
método. Exemplo 4-14 mostra como o HelloPrintDocument olha quando modificado desta maneira.

Exemplo 4-14. Usando OnBeginPrint e OnEndPrint configurar e lágrima
baixo objetos utilizados durante a impressão
Público HelloPrintDocument Classe
   Herda PrintDocument

   "Membro privado para manter a fonte que será usada para a impressão.
   m_fnt privado como fonte
   Protegido substituições OnBeginPrint Sub (ByVal e As PrintEventArgs)
      MyBase.OnBeginPrint (e)

      "Criar a fonte que será usada para a impressão.
      m_fnt = New Font ("Arial", 10, FontStyle.Regular, _
         GraphicsUnit.Point)
   End Sub

   Protegido substituições OnEndPrint Sub (ByVal e As PrintEventArgs)
      MyBase.OnEndPrint (e)

      "Solte a fonte.
      m_fnt.Dispose ()
   End Sub



176
 
NET Programação Visual Basic.


   Protegido substituições OnPrintPage Sub (ByVal e As PrintPageEventArgs)
      MyBase.OnPrintPage (e)

      "Desenhar texto para o dispositivo de elementos gráficos da impressora.
      Dim rect Como Rectangle = e.MarginBounds
      e.Graphics.DrawString ("Olá, impressora!", m_fnt, Brushes.Black, 0, 0)

      "Indicar que não há mais páginas.
      e.HasMorePages = False
   End Sub

End Class

4.7.4 Escolhendo uma impressora

O código dado no contexto Exemplo 4-13 e 4-14 Exemplo simplesmente imprime na impressora padrão.
Para permitir ao usuário selecionar uma impressora específica e definir outras opções da impressora, passe o PrintDocument
objeto para um objeto PrintDialog e chamar o método ShowDialog o objeto do PrintDialog. O ShowDialog
exibe uma caixa de diálogo método PrintDialog (mostrado na Figura 5-19 no capítulo 5). Quando o usuário clica
OK na caixa de diálogo PrintDialog, o método ShowDialog define os valores apropriados nos dado
PrintDocument objeto. O método do objeto PrintDocument de impressão podem ser chamados para imprimir o
documento para a impressora selecionada. Aqui está o código:

'Criar o objeto PrintDocument eo objeto caixa de diálogo.
Dim pd Como HelloPrintDocument New ()
Dim dlg Como PrintDialog New ()
"Passe o objeto PrintDocument para o objeto caixa de diálogo.
dlg.Document = pd
"Mostrar a caixa de diálogo. Certifique-se de testar o resultado de modo que a impressão
'Ocorre somente se o usuário clicar em OK.
Se DialogResult.OK dlg.ShowDialog = Em seguida,
   »Imprima o documento.
   pd.Print ()
End If

Esse código pressupõe a presença da classe HelloPrintDocument definido no Exemplo 4-13 ou
Exemplo 4-14. Observe que a classe HelloPrintDocument em si não precisa ser modificado para suportar
escolher uma impressora.

4.7.5 Classe A PageSettings

Como mencionado anteriormente, o PrintPageEventArgs objeto passado para o método tem uma OnPrintPage
propriedade PageSettings que contém um objeto PageSettings. Esse objeto contém as definições aplicáveis às
imprimir uma única página. As propriedades da classe PageSettings são:

Bounds

Representa um retângulo que especifica a área total da página, incluindo a área fora da
margens. Este é o mesmo valor encontrado na propriedade PageBounds do PrintPageEventArgs
classe. A sintaxe da propriedade Bounds é:

Public ReadOnly Property Bounds () As System.Drawing.Rectangle
Cor

Indica se a página deve ser impresso em cores. A sintaxe da propriedade color é:

Cor Propriedade Pública () As Boolean


177
 



Paisagem

Indica se a página está sendo impresso na orientação paisagem. A sintaxe da
A paisagem é de propriedade:

Paisagem Propriedade Pública () As Boolean
Margens

Indica o tamanho das margens. A sintaxe da propriedade margens é:

Margens da Propriedade Pública () As System.Drawing.Printing.Margins

A classe Margins tem quatro propriedades, esquerda, cima, direita e inferior, cada uma das quais é uma
Inteiro que representa o tamanho da respectiva margem.

PaperSize

Indica o tamanho do papel. A sintaxe da propriedade PaperSize é:

Público PaperSize Propriedade () As System.Drawing.Printing.PaperSize

A classe PaperSize tem quatro propriedades:

Largura

Um inteiro que representa a largura do papel. Este é o mesmo valor encontrado na largura
membro da propriedade Bounds do objeto PageSettings.

Altura

Um inteiro que representa a altura do papel. Este é o mesmo valor encontrado na Altura
membro da propriedade Bounds do objeto PageSettings.

Tipo

Uma enumeração do tipo PaperKind expressar o tamanho do papel em termos de padrão
tamanhos nomeados, como Letter e Legal.

PaperName

Uma seqüência de caracteres indicando o nome do tamanho do papel, como "Carta" e "Legal".

PaperSource

Indica a bandeja de papel a partir do qual a página será impressa. A sintaxe da PaperSource
propriedade é:

Público PaperSource Propriedade () As
System.Drawing.Printing.PaperSource

A classe PaperSource tem duas propriedades:

Tipo





178
 
NET Programação Visual Basic.


Uma enumeração do tipo PaperSourceKind expressando a origem do papel, em termos de padrão
nomes, como superiores e inferiores.

SourceName

Uma seqüência de caracteres indicando o nome da origem do papel, como "Baixa" e "superior".

PrinterResolution

Indica a capacidade de resolução da impressora. A sintaxe da propriedade PrinterResolution é:

Público PrinterResolution Propriedade () As _
   System.Drawing.Printing.PrinterResolution

A classe PrinterResolution tem três propriedades:

X

Um inteiro que representa a resolução horizontal da impressora em pontos por polegada.

Y

Um inteiro que representa a resolução vertical da impressora em pontos por polegada.

Tipo

Uma enumeração do tipo PrinterResolutionKind expressando o modo de resolução. Os valores de
essa enumeração são Projecto, Baixo, Médio, Alto e personalizado.

PrinterSettings

Indica as configurações aplicáveis para a impressora a ser utilizado. A sintaxe da PrinterSettings
propriedade é:

PrinterSettings Propriedade Pública () As _
   System.Drawing.Printing.PrinterSettings

A classe PrinterSettings é descrito na próxima seção.

4.7.6 Classe A PrinterSettings

A classe PrinterSettings contém valores que descrevem os recursos e configurações de uma impressora específica. É
expõe essas propriedades:

CanDuplex

Indica se a impressora pode imprimir em ambos os lados do papel. A sintaxe da
propriedade CanDuplex é:

Público CanDuplex Propriedade ReadOnly () As Boolean
Confrontar

Indica se o documento a ser impresso será agrupada. A sintaxe da Intercalar
propriedade é:



179
 




Cópias
 



Agrupar Propriedade Pública () As Boolean


Indica o número de cópias a imprimir. A sintaxe da propriedade Cópias é:

Cópias da Propriedade Pública () As Short
 
DefaultPageSettings

Indica as configurações de página padrão para esta impressora. A sintaxe da DefaultPageSettings
propriedade é:

Public ReadOnly Property DefaultPageSettings () As _
   System.Drawing.Printing.PageSettings

A classe PageSettings foi descrito na seção anterior.

Duplex

Indica se o trabalho de impressão para imprimir em ambos os lados do papel. A sintaxe do Duplex
propriedade é:

Duplex Propriedade Pública () As System.Drawing.Printing.Duplex

O tipo duplex é uma enumeração com os seguintes valores:

Simplex

O documento será impresso em apenas um lado de cada página.

Horizontal

O documento será impresso usando ambos os lados de cada página.

Vertical

O documento será impresso usando ambos os lados de cada página e, o outro lado será invertido para
trabalho com ligação vertical.

Default

O documento será impresso usando o modo duplex da impressora padrão.

FromPage

Especifica a primeira página para imprimir PrintRange se a propriedade é definida como SomePages. A sintaxe da
a propriedade FromPage é:

Público FromPage Propriedade () As Integer
InstalledPrinters

Indica os nomes das impressoras instaladas no computador. Esta lista inclui apenas os
impressoras fisicamente conectado à máquina (se houver), não necessariamente todas as impressoras configuradas na
Painel de controle.
A sintaxe da propriedade InstalledPrinters é:

Public Shared ReadOnly Property InstalledPrinters () As _



180
 
 
NET Programação Visual Basic.


   System.Drawing.Printing.PrinterSettings.StringCollection

A classe StringCollection é uma coleção de strings.
Ele pode ser iterado usando um código como este:

"Suponha Pontos de PrinterSettings é tipo.
Dim str As String
Para cada str Em pts.InstalledPrinters
   Console.WriteLine (str)
Seguinte
IsDefaultPrinter

Indica se esta impressora é a impressora padrão do usuário. A sintaxe da IsDefaultPrinter
propriedade é:

Público IsDefaultPrinter Propriedade ReadOnly () As Boolean

Se a propriedade PrinterName é explicitamente definida como outra coisa do que nada, esta propriedade
sempre retorna False.

IsPlotter

Indica se esta impressora é um plotter. A sintaxe da propriedade IsPlotter é:

Público IsPlotter Propriedade ReadOnly () As Boolean
IsValid

Indica se a propriedade PrinterName designa uma impressora válida. A sintaxe da
propriedade IsValid é:

Público IsValid Propriedade ReadOnly () As Boolean

Essa propriedade é útil se a propriedade PrinterName está sendo definida explicitamente. Se o PrinterName é
definido como um resultado de permitir ao usuário selecionar uma impressora através da caixa de diálogo PrintDialog, este
propriedade será sempre verdadeiro.

LandscapeAngle

Indica o ângulo (em graus), através da qual a orientação retrato é girado para a produção de paisagem
orientação. A sintaxe da propriedade LandscapeAngle é:

Público LandscapeAngle Propriedade ReadOnly () As Integer

Este valor só pode ser 90 ou 270. Se a orientação da paisagem não é suportado, este valor só pode
ser 0.

MaximumCopies

Indica o número máximo de cópias que a impressora pode imprimir em uma hora. A sintaxe da
a propriedade MaximumCopies é:

Public ReadOnly Property MaximumCopies () As Integer
MaximumPage

Indica o maior número de páginas que podem ser inseridos em uma caixa de diálogo PrintDialog. A sintaxe
da propriedade MaximumPage é:



181
 



Público MaximumPage Propriedade () As Integer

Defina esse valor antes de chamar o método ShowDialog o objeto PrintDialog de proibir o usuário
a entrada de um número de página que é muito alto.

MinimumPage

Indica o menor número de páginas que podem ser inseridos em uma caixa de diálogo PrintDialog. A sintaxe
da propriedade MinimumPage é:

Público MinimumPage Propriedade () As Integer

Defina esse valor antes de chamar o método ShowDialog o objeto PrintDialog de proibir o usuário
a entrada de um número de página que é muito baixo.

PaperSizes

Indica que os tamanhos de papel que são suportados por esta impressora. A sintaxe da PaperSizes
propriedade é:

Public ReadOnly Property PaperSizes () As _
   System.Drawing.Printing.PrinterSettings + PaperSizeCollection

O PaperSizeCollection é uma coleção de objetos do tipo PaperSize. O tipo foi PaperSize
descrito na seção anterior, sob a descrição para a propriedade PaperSize do
PageSettings classe. O PaperSizeCollection pode ser iterado usando o seguinte código:

"Suponha Pontos de PrinterSettings é tipo.
Dim pprSize Como PaperSize
Para cada pprSize Em pts.PaperSizes
   Console.WriteLine (pprSize.PaperName)
Seguinte
PaperSources

Indica as fontes de papel que estão disponíveis na impressora. A sintaxe da PaperSources
propriedade é:

Public ReadOnly Property PaperSources () As _
   System.Drawing.Printing.PrinterSettings + PaperSourceCollection

O PaperSourceCollection é uma coleção de objetos do tipo PaperSource. O PaperSource
tipo foi descrito na seção anterior, sob a designação para o PaperSource
propriedade da classe PageSettings. O PaperSourceCollection pode ser iterado usando o
seguinte código:

"Suponha Pontos de PrinterSettings é tipo.
Dim pprSource Como PaperSource
Para cada pprSource Em pts.PaperSources
   Console.WriteLine (pprSource.SourceName)
Seguinte
PrinterName

Indica o nome da impressora. A sintaxe da propriedade PrinterName é:

Público PrinterName Propriedade () As String

A menos que uma seqüência de caracteres tem sido explicitamente atribuído à propriedade, seu valor é nulo.


182
 



PrinterResolutions
 
NET Programação Visual Basic.
 

Indica a resolução suportada pela impressora. A sintaxe da PrinterResolutions
propriedade é:

Public ReadOnly Property PrinterResolutions () As _

System.Drawing.Printing.PrinterSettings.PrinterResolutionCollection

O PrinterResolutionCollection é uma coleção de objetos do tipo PrinterResolution. A
PrinterResolution tipo foi descrito na seção anterior, sob a designação para o
PrinterResolution propriedade da classe PageSettings. O PrinterResolutionCollection pode ser
iterado usando o seguinte código:

"Suponha Pontos de PrinterSettings é tipo.
Dim ptrResolution Como PrinterResolution
Para cada ptrResolution Em pts.PrinterResolutions
   Console.WriteLine (ptrResolution.Kind.ToString ())
Seguinte
PrintRange

Indica o intervalo de páginas a serem impressas. A sintaxe da propriedade PrintRange é:

Público PrintRange Propriedade () As System.Drawing.Printing.PrintRange

O tipo é uma enumeração PrintRange ter os seguintes valores:

Allpages

Imprime o documento inteiro.

Seleção

Imprime apenas a parte selecionada do documento.

SomePages

Imprime as páginas começando na página especificada na propriedade FromPage e terminando no
página especificada na propriedade ToPage.

SupportsColor

Indica se a impressora suporta a impressão a cores. A sintaxe da propriedade SupportsColor
é o seguinte:

Público SupportsColor Propriedade ReadOnly () As Boolean
ToPage

Especifica a página final de imprimir, se a propriedade é definida como PrintRange SomePages. A sintaxe da
a propriedade ToPage é:

Público ToPage Propriedade () As Integer

Os métodos da classe PrinterSettings são:

Clone


183
 
 



Cria uma cópia do objeto PrinterSettings. A sintaxe do método Clone é:

Função Pública Clone NotOverridable () As Object _
   Implementa System.ICloneable.Clone
GetHdevmode

Retorna um identificador para um DEVMODE Windows (dispositivo de modo) correspondente a esta estrutura
PrinterSettings objeto. O método GetHdevmode tem duas formas:

Função Pública GetHdevmode Overloads () As System.IntPtr

e:

Função Pública GetHdevmode Overloads (_
   PageSettings ByVal _ System.Drawing.Printing.PageSettings
) Como System.IntPtr

A estrutura DEVMODE é parte da API do Windows e não é discutida neste livro.

GetHdevnames

Retorna um identificador para uma estrutura DEVNAMES Windows correspondente a esta PrinterSettings
objeto. A sintaxe do método GetHdevnames é:

GetHdevnames Função Pública () As System.IntPtr

A estrutura DEVNAMES é parte da API do Windows e não é discutida neste livro.

SetHdevmode

Define propriedades deste objeto PrinterSettings com base em valores na estrutura DEVMODE dado.
A sintaxe do método SetHdevmode é:

Public Sub SetHdevmode (ByVal hdevmode Como System.IntPtr)

A estrutura DEVMODE é parte da API do Windows e não é discutida neste livro.

SetHdevnames

Define propriedades deste objeto PrinterSettings com base em valores na estrutura DEVNAMES dado.
A sintaxe do método SetHdevnames é:

Public Sub SetHdevnames (hdevnames ByVal System.IntPtr)

A estrutura DEVNAMES é parte da API do Windows e não é discutida neste livro.

4.7.7 Configurar página caixa de diálogo

Windows Forms fornece uma caixa de diálogo comum para a página de configuração (como mostrado na Figura 5-18 no capítulo 5).
Configurações digitada pelo usuário na caixa de diálogo são salvas em um objeto PageSettings. Este PageSettings
objeto pode ser salva pela aplicação e passado para o objeto PrintDocument antes de chamar a
PrintDocument objeto método de impressão. O objeto PrintDocument usará as definições dadas para
impressão. Aqui está o código que exibe a caixa de diálogo:

ShowPageSetup Private Sub ()


184
 
NET Programação Visual Basic.


   "Mostrar a página de configurações caixa de diálogo. Isso pressupõe que há
   "Uma variável de nível de classe de PageSettings tipo chamado m_pgSettings.
   Dim pgSetupDlg como nova PageSetupDialog ()
   pgSetupDlg.PageSettings = m_pgSettings
   pgSetupDlg.ShowDialog ()
End Sub

Este código depende da existência de uma variável de nível de classe de PageSettings tipo chamado
m_pgSettings. Aqui está uma definição adequada para essa variável:

"Membro privado para manter as configurações de página do aplicativo.
"Este poderia ser colocado no formulário principal de um aplicativo ou em outro
"Classe que seja acessível para o código que terá de imprimir.
m_pgSettings Privado como novo PageSettings ()

Observe o uso da palavra-chave Novo para garantir que o objeto é instanciado PageSettings tão logo o
juntando classe é instanciado.

Tudo o que resta é a mão do PageSettings objeto para o objeto PrintDocument quando é hora de imprimir.
Aqui está o código:

PrintTheDocument Private Sub ()
   'Criar o objeto PrintDocument.
   Dim pd Como HelloPrintDocument New ()
   "Entregue-o objeto PageSettings.
   pd.DefaultPageSettings = m_pgSettings
   'Criar o objeto caixa de diálogo.
   Dim dlg Como PrintDialog New ()
   "Passe o objeto PrintDocument para o objeto caixa de diálogo.
   dlg.Document = pd
   "Mostrar a caixa de diálogo. Certifique-se de testar o resultado de modo que a impressão
   'Ocorre somente se o usuário clicar em OK.
   Se DialogResult dlg.ShowDialog = (). OK, então
      »Imprima o documento.
      pd.Print ()
   End If
End Sub

4.7.8 Visualização de Impressão

Gerando uma visualização da impressão é trivial. Uma instância do objeto PrintDocument é criada e passada para
um objeto PrintPreviewDialog, cujo método ShowDialog é então chamado para mostrar o preview de impressão. Aqui
é o código:

ShowPrintPreview Private Sub ()
   'Criar o objeto PrintDocument.
   Dim pd Como HelloPrintDocument New ()
   "Entregue-o objeto PageSettings.
   pd.DefaultPageSettings = m_pgSettings
   'Criar o objeto de visualização de impressão de diálogo caixa.
   Dim dlg Como PrintPreviewDialog New ()
   "Passe o objeto PrintDocument para o objeto caixa de diálogo.
   dlg.Document = pd
   "Mostrar a caixa de diálogo.
   dlg.ShowDialog ()
End Sub

O resultado é mostrado na Figura 4-16.



185
 



Figura 4-16. Olá, impressora! em uma janela de visualização de impressão




















Ordem 4.7.9 Resumo da Imprensa

O. NET Framework esconde a mecânica da impressão. As aplicações não têm de saber como encontrar
impressoras, eles não têm capacidades para saber o que uma determinada impressora são, e eles não tem que saber
como emitir comandos que são significativos para uma determinada marca de impressora. Os resumos Framework todos
desta distância. No entanto, o quadro não se sabe nada sobre os documentos de uma determinada aplicação é.
Cabe ao desenvolvedor da aplicação para saber como paginar documentos do aplicativo e prestar
cada página, em resposta a cada chamada para o método da classe PrintDocument é OnPrintPage.

4.8 Síntese

Neste capítulo, você viu como trabalhar com formulários do Windows na criação de uma aplicação desktop. A
formulário do Windows, no entanto, é simplesmente um contêiner para componentes do aplicativo interface do usuário. Na
próximo capítulo, você vai completar sua análise do desenvolvimento de aplicações desktop, olhando para
controles, caixas de diálogo comuns, e os menus.




























186
 
NET Programação Visual Basic.


Capítulo 5. Windows Forms II: Controles Comuns
Caixas de diálogo e menus

Por si só, uma ou mais formas de fornecer funcionalidade muito pouco para a maioria das aplicações desktop. Para o
maior parte dos casos, os formulários são importantes na medida em que servem como recipientes para os controles. Neste capítulo, vamos
completa a nossa discussão sobre a construção de aplicações desktop, centrando-se sobre os objetos que as formas
conter, em particular, controles e componentes, os diálogos comuns, e os menus.

5.1 Comandos comuns e componentes

Esta seção contém um resumo dos controles e componentes definidos no
System.Windows.Forms namespace. Os componentes são classes derivadas da classe Component
(Definido no namespace System.ComponentModel). Eles podem ou não fornecer uma interface visual.
Eles são freqüentemente usados como elementos de formas, mas não tem que ser. Os controles são classes derivadas da
Controle de classe (definido no namespace System.Windows.Forms). Controles geralmente são usados para
construir a aparência visual de um formulário. A classe Control é derivado da classe Component, para
controles também são componentes.

As caixas de diálogo comum não são listadas aqui, mesmo que todos eles derivam da classe Component.
Elas são dadas a sua própria secção, Secção 5.4 mais adiante neste capítulo.

5.1.1 A classe Button

Esta classe representa um controle de botão, que é um dos controles mais comumente usado no Windows
aplicações. A classe de evento Click do botão, que herda de Control, é o mais comumente usado
evento.

A classe Button herda duas propriedades importantes da ButtonBase: FlatStyle e Imagem. O primeiro
determina a aparência do botão e pode assumir qualquer valor da enumeração FlatStyle: Flat,
Popup, Standard (padrão), e do sistema. Botões com essas quatro configurações são mostrados na Figura 5 -
1. Atribuindo FlatStyle.System como o valor da propriedade FlatStyle faz a aparência do
botão depende do sistema operacional.

Figura 5-1. Várias aparências do controle Button







A propriedade da imagem permite-lhe inserir uma imagem em um botão. O código a seguir mostra como
programaticamente definir a propriedade Imagem do botão:

Button1.Image = Novo System.Drawing.Bitmap (filepath)

5.1.2 A classe CheckBox

A classe CheckBox representa uma caixa de controle. Sua aparência é determinada por sua aparência
propriedade, que pode assumir qualquer valor da enumeração Aparência: Button ou Normal (o
padrão). O valor Button é raramente utilizada porque essa configuração faz o olhar como um botão de opção
controle.





187
 



A propriedade Checked classe CheckBox pode ser definida como True para fazer a caixa de seleção marcada ou False
para desmarcá-lo.

5.1.3 A classe ComboBox

Tanto o ComboBox e ListBox classes derivam da classe ListControl, portanto, o ComboBox
classe é muito parecida com a classe ListBox e tem propriedades e métodos semelhantes aos dos
ListBox classe. Consulte a Seção 5.1.9 para obter informações sobre essas propriedades e métodos comuns.

As seguintes propriedades são específicas para a classe ComboBox:

DropDownStyle

Define o estilo drop-down do ComboBox. Ele pode assumir qualquer valor do ComboBoxStyle
enumeração: DropDown (o valor padrão), DropDownList e simples. Ambos DropDown
DropDownList e exigem que o usuário clique no botão de seta para exibir o drop-down
parte da ComboBox, no entanto, DropDown permite ao usuário editar a parte de texto da
ComboBox. Simples faz parte de um ComboBox de texto editável e sua porção suspensa
sempre visíveis.

DroppedDown

Especifica se a parte suspensa de um ComboBox é visível.

5.1.4 Classe A DateTimePicker

A classe DateTimePicker representa um controle que permite aos usuários selecionar uma data no calendário, apenas
como o controle MonthCalendar. Ao contrário MonthCalendar, no entanto, o controle DateTimePicker somente
exibe uma caixa, que parece uma caixa de combinação, contendo a data selecionada. Quando o usuário clica no
seta, o controle exibe um calendário drop-down semelhante ao controle MonthCalendar, do qual o
usuário pode selecionar uma data. Essa parte suspensa fecha assim que o usuário seleciona uma data. O usuário
também pode clicar no dia, dia, mês, ano ou parte do controle para edição.

A classe DateTimePicker tem MinDate e MaxDate propriedades que são semelhantes aos da
MonthCalendar classe. Para definir a data actual ou para obter a data selecionada, use a propriedade Value
a classe DateTimePicker. A data selecionada é prontamente disponível como um tipo de dados DateTime.

5.1.5 A Classe GroupBox

Como o nome indica, um controle GroupBox é utilizado para agrupar outros controles, como botões de rádio ou
caixas, que corresponde ao controle Frame no Visual Basic 6.0. Um agrupamento de rádio em dois GroupBox
botões é mostrado na Figura 5-2.

Figura 5-2. Um GroupBox agrupamento dois botões de rádio










A propriedade Controls do GroupBox representa uma classe Control.ControlCollection. Tem esses métodos
Adicionar como, AddRange, Clear, GetEnumerator, e remover, que se comportam exatamente como fazer o mesmo


188
 
NET Programação Visual Basic.


métodos Form.ControlCollection. Por exemplo, você pode adicionar vários controles ao mesmo tempo para um GroupBox
usando o método AddRange, como demonstrado pelo seguinte código que adiciona dois botões de rádio para uma
GroupBox chamado GroupBox1:

groupBox1.Controls.AddRange (New Control () {RadioButton1, RadioButton2})

5.1.6 A classe ImageList

A classe ImageList permite que você gerencie uma coleção de imagens. A propriedade mais importante desse
classe é de Imagens, que retorna um objeto ImageList.ImageCollection. O ImageList.ImageCollection
classe possui métodos para adicionar e remover imagens da coleção.

O método Add da classe ImageList.ImageCollection adiciona uma imagem bitmap ou um ícone para o
coleção de imagens do ImageList. O método Add tem três sobrecargas, cujas assinaturas são dadas como
seguinte forma:

Sobrecargas Public Sub Adicionar (ByVal value As System.Drawing.Icon)
Sobrecargas Public Sub Adicionar (ByVal valor As System.Drawing.Image)
Sobrecargas Public Sub Adicionar (ByVal valor As System.Drawing.Image, _
  ByVal transparentColor como System.Drawing.Color)

A primeira sobrecarga permite que você adicione um ícone, eo segundo sobrecarga é usada para adicionar um objeto do tipo
System.Drawing.Image. A sobrecarga de terceiros é utilizado para adicionar uma imagem e fazer uma cor dessa imagem
transparente. Por exemplo, se você tiver uma imagem com uma cor de fundo azul, você pode fazer o
adicionou imagem transparente, passando de uma cor azul como o segundo argumento para a sobrecarga terço dos
Adicionar método.

O método RemoveAt da classe ImageList.ImageCollection permite remover uma imagem.

Uma vez que você instancia um objeto ImageList, você pode começar a adicionar imagens ou ícones. O código a seguir,
por exemplo, adiciona três imagens e ícones usando três diferentes sobrecargas do método Add:

Imports System.Drawing
Dim imageList1 Como ImageList1 = Novo ImageList ()
ImageList1.Images.Add (novo ícone ("C: \ Palm.ico"))
ImageList1.Images.Add (Bitmap Novo ("C: \ TV.bmp"))
ImageList1.Images.Add (Bitmap Novo ("C: \ Dog.bmp"), Color.White)

As propriedades mais importantes da classe ImageList incluem ColorDepth e ImageSize. O ColorDepth
propriedade determina o número de cores disponíveis para o ImageList. Por exemplo, um valor 4 significa
que 2 ^ 4 = 16 cores estão disponíveis.

A propriedade ImageSize determina os tamanhos de todas as imagens na lista. Por padrão, o valor é
System.Drawing (16, 16).

Você pode atribuir um objeto ImageList à propriedade ImageList de controles, como Label, Button e
ListView. Você pode então selecionar uma imagem da ImageList a ser exibida no controle utilizando o
propriedade de controle de ImageIndex. Por exemplo, o código a seguir usa um ImageList para um botão e
seleciona a primeira imagem como imagem de fundo para o botão:

button1.ImageList = imageList1
button1.ImageIndex = 0

5.1.7 O Selo de Classe

Esta classe representa um controle Label. Sua aparência é determinada por duas propriedades: BorderStyle e
FlatStyle. A propriedade BorderStyle define a aparência da borda do controle e leva qualquer um dos


189
 



os três membros da enumeração BorderStyle: Nenhum (o padrão), FixedSingle e Fixed3D.
Figura 5-3 mostra três etiquetas com três valores diferentes de BorderStyle.

Figura 5-3. Três etiquetas com diferentes valores BorderStyle









A propriedade FlatStyle define a aparência do controle e pode ter como valor qualquer membro da
enumeração FlatStyle: Flat, Pop-up, padrão, e System. No entanto, se o valor da
propriedade BorderStyle é definido como Nenhum, de propriedade da gravadora FlatStyle não poderá ter qualquer valor diferente de
FlatStyle.Standard. Para mais informações sobre a propriedade FlatStyle, consulte a Seção 5.1.1 anteriormente
neste capítulo.

Normalmente você atribuir uma string à propriedade Text do rótulo. No entanto, você também pode atribuir uma imagem para
sua propriedade Image. Por exemplo, o seguinte código de programação define a propriedade Image de um
no rótulo:

Label1.Image = Novo System.Drawing.Bitmap (filepath)

Outra propriedade importante é TextAlign, que determina como o texto do rótulo está alinhado. Esta propriedade
pode tomar qualquer membro da enumeração ContentAlignment, incluindo BottomCenter, BottomLeft,
BottomRight, MiddleCenter, MiddleLeft, MiddleRight, TopCenter, topLeft (o padrão
valor), e topright.

A propriedade UseMnemonic pode ser definido como True para que o rótulo aceita um caractere e comercial em
a propriedade de texto como um caractere de prefixo de acesso chave.

5.1.8 Classe A LinkLabel

A classe LinkLabel representa um rótulo que pode funcionar como um hiperlink, que é uma URL para um site.
Suas duas propriedades importantes são textos e links. A propriedade Text é uma String que define a
rótulo do objeto LinkLabel. Você pode especificar que alguns ou todos o valor da propriedade Text é um hiperlink.
Por exemplo, se a propriedade tem o valor de texto "Clique aqui para obter mais detalhes", você pode fazer todo o
texto de um hiperlink, ou você pode fazer parte dela (por exemplo, a palavra "aqui") um hiperlink. Como fazer isso irá
ficou claro após a segunda propriedade é explicada.

Para um LinkLabel para ser útil, ele deve conter pelo menos um hiperlink. A propriedade Links representa um
LinkLabel.LinkCollection classe do objeto LinkLabel. Você usa o método Add da
LinkLabel.LinkCollection classe para adicionar um objeto LinkLabel.Link. O método Add tem duas sobrecargas, a
que será aqui utilizado tem a seguinte assinatura:

Sobrecargas Adicionar Funções Públicas (_
  ByVal começar As Integer, _
  comprimento ByVal As Integer, _
  ByVal Linkdata como objeto _
) Como Link

O argumento inicial é o primeiro caractere da substring a propriedade Text é que você vai se transformar em um
hiperlink. O argumento de comprimento indica o comprimento da substring. O argumento é Linkdata
normalmente uma String contendo uma URL, como "www.oreilly.com". Por exemplo, se sua propriedade Text



190
 
NET Programação Visual Basic.


contém "Vá ao nosso site web", e você quer "site" para ser o link, aqui está como você usaria
o método Add:

linkLabel1.Links.Add (10, 8, "www.oreilly.com")

10 é a posição do caractere w na propriedade Text, e 8 é o comprimento do "web site" substring.

A classe LinkLabel tem um evento LinkClicked que você pode capturar de forma que você pode executar o código quando um
LinkLabel objeto é clicado. O exemplo a seguir cria um objeto LinkLabel que está vinculado a URL
www.oreilly.com e inicia e dirige o navegador padrão para que quando a URL LinkLabel é clicado:

Dim WithEvents linkLabel1 Como LinkLabel LinkLabel = new ()
linkLabel1.Text = "Ir para o nosso site web"
linkLabel1.Links.Add (10, 8, "www.oreilly.com")
linkLabel1.Location = Novo System.Drawing.Point (64, 176)
linkLabel1.Name = "linkLabel1"
linkLabel1.Size = Novo System.Drawing (120, 16)
»Adicionar a um formulário.
Me.Controls.Add (linkLabel1)

Private Sub LinkLabel1_LinkClicked (_
  ByVal sender As Object, _
  ByVal e As LinkLabelLinkClickedEventArgs) _
  Puxadores linkLabel1.LinkClicked
  'Iniciar o navegador padrão e direcioná-lo para "www.oreilly.com".
  System.Diagnostics.Process.Start (e.Link.LinkData.ToString ())
End Sub

A classe LinkLabel tem um número de propriedades que estão relacionadas com a aparência de um LinkLabel
objeto:

ActiveLinkColor

Representa a cor da LinkLabel quando ele está sendo acessado (isto é, quando você pressiona o
botão do mouse, mas antes de soltá-lo). Por padrão, o valor é de ActiveLinkColor
System.Drawing.Color.Red.

DisabledLinkColor

Representa a cor da LinkLabel quando ele está desativado.

LinkColore

Representa a cor da LinkLabel em sua condição normal. Por padrão, o valor é
System.Drawing.Color.Blue.

VisitedLinkColor

Representa a cor de um LinkLabel que foi visitado. Por padrão, o valor da propriedade é
System.Drawing.Color.Purple. O LinkLabel não exibe automaticamente no seu
VisitedLinkColor depois que ele é clicado. Você deve alterar sua propriedade LinkVisited como True. Normalmente,
fazê-lo dentro do manipulador de eventos LinkClicked do objeto LinkLabel. Portanto, na
exemplo anterior, se você quiser que o LinkLabel a mudar de cor depois que for clicado, você pode modificar
seu manipulador de eventos LinkClicked com o seguinte:

Private Sub LinkLabel1_LinkClicked (_
  ByVal sender As Object, _


191
 



  ByVal e As LinkLabelLinkClickedEventArgs) _
  Puxadores linkLabel1.LinkClicked

  LinkLabel1.LinkVisited = True

  'Iniciar o navegador padrão e direcioná-lo para "www.oreilly.com".
  System.Diagnostics.Process.Start (e.Link.LinkData.ToString ())
End Sub
LinkBehavior

Determina como o LinkLabel é exibida. Esta propriedade pode assumir qualquer membro da
LinkBehavior enumeração: AlwaysUnderline, HoverUnderline, NeverUnderline e
SystemDefault (o valor padrão).

5.1.9 A Classe ListBox

A classe ListBox representa uma caixa que contém uma lista de itens. A seguir, são suas mais importantes
propriedades:

MultiColumn

Este é um booleano que indica se a caixa de listagem tem mais de uma coluna. Seu padrão
valor é False.

ColumnWidth

Em uma listagem de várias colunas, esta propriedade representa a largura de cada coluna em pixels. Por padrão,
o valor dessa propriedade é zero, o que faz com que cada coluna tem uma largura padrão.

Itens

Esta é a propriedade mais importante da classe ListBox. Ele retorna o ListBox ObjectCollection
classe, que é basicamente a coleção de itens na ListBox. Você pode adicionar programaticamente um
item usando o método Add, ou adicionar uma série de itens usando o método AddRange do
ListBox ObjectCollection classe. Por exemplo, o código a seguir adiciona os nomes dos legumes
e frutas para um ListBox objeto chamado listBox1:

listBox1.Items.AddRange (New Object () _
  {"Maçã", "avocado", "banana", "cenoura", _
  "Tangerina", "laranja"})

Para obter mais informações sobre a classe ListBox ObjectCollection, consulte a Seção 5.1.10.

SelectionMode

Esta propriedade determina se a seleção multi-ponto é possível em um objeto ListBox. Pode ser
atribuído qualquer membro da enumeração SelectionMode: Nenhum, Um (o valor padrão),
MultiSimple e MultiExtended. Ambos MultiSimple e MultiExtended permitir que o
usuário para selecionar mais de um item. No entanto, MultiExtended permite o uso da tecla Shift, Ctrl
e as teclas de seta para fazer uma seleção.

SelectedIndex

Este é o índice do item selecionado. O índice é baseado em zero. Se mais de um item é
selecionado, esta propriedade representa o menor índice. Se nenhum item for selecionado, a propriedade retorna
-1.


192
 



SelectedIndices
 
NET Programação Visual Basic.
 

Esta propriedade somente leitura retorna os índices de todos os itens selecionados em um objeto ListBox no formulário
de um objeto ListBox.SelectedIndexCollection. A classe tem um ListBox.SelectedIndexCollection
Propriedade Count que retorna o número de índices seleccionados e uma propriedade Item que retorna
o número de índice. Por exemplo, o código a seguir retorna o número de índice de todos os selecionados
itens em um controle ListBox chamado listBox1:

selectedIndices Dim ListBox.SelectedIndexCollection
"Obter os índices selecionados.
selectedIndices = listBox1.SelectedIndices
"Obter o número de índices.
As Integer Dim contar selectedIndices.Count =
Dim i As Integer
Para i = 0 To count - 1
  Console.WriteLine (selectedIndices (i))
Seguinte
SelectedItem

Esta propriedade somente leitura retorna o item selecionado como um objeto do tipo Object. Você deve converter
o valor retornado de um tipo apropriado, que normalmente é String. Se mais de um item é
selecionado, a propriedade retorna o item com o menor índice.

SelectedItems

Esta propriedade somente leitura retorna todos os itens selecionados em um objeto ListBox na forma de um
ListBox.SelectedObjectCollection objeto. A classe tem um ListBox.SelectedObjectCollection
Propriedade Count que retorna o número de itens na coleção e uma propriedade Item que você
pode usar para obter o item selecionado. Por exemplo, o seguinte código exibe todos os selecionados
itens de um controle ListBox chamado listBox1:

selectedItems Dim ListBox.SelectedObjectCollection
selectedItems = listBox1.SelectedItems
As Integer Dim contar selectedItems.Count =
Dim i As Integer
Para i = 0 To count - 1
  Console.WriteLine (selectedItems (i))
Seguinte

 

Ordenado

 

Um valor de true significa que os itens são classificados. Caso contrário, os itens não são ordenados. Por

padrão, o valor da propriedade é False.

 

Texto

 

Este é um texto do item atualmente selecionado.

 

TopIndex

 

Este é o índice do primeiro item visível no ListBox. O valor muda conforme o usuário rola

através dos itens.

 

5.1.10 Classe A ListBox ObjectCollection

 

Esta classe representa todos os itens em um objeto ListBox. Ele tem uma propriedade Count que retorna o número

de itens na ListBox e uma propriedade Item que retorna o objeto de item em uma posição determinado índice.

 

 

 

193

 

 

 

 

 

O código de exemplo a seguir reitera todos os itens em um controle ListBox chamado listBox1:

 

itens Dim ListBox ObjectCollection

items = ListBox1.Items

As Integer Dim contar items.Count =

Dim i As Integer

Para i = 0 To count - 1

  Console.WriteLine (itens (i))

Seguinte

 

Além disso, a classe ListBox ObjectCollection tem os seguintes métodos:

 

Adicionar

 

Adiciona um item para o objeto ListBox. Sua sintaxe é:

 

ListBox.ObjectCollection.Add (item)

 

onde o item é um dado do tipo Object, que deve ser adicionado à coleção. O método retorna o

índice baseado em zero do novo item na coleção.

 

AddRange

 

Adiciona um ou mais itens para o objeto ListBox. Sua sintaxe mais comum é:

 

ListBox.ObjectCollection.AddRange (itens ())

 

onde os itens é um array de objetos contendo os dados a ser adicionado ao ListBox.

 

Limpar

 

Limpa a caixa de listagem, removendo todos os itens. Sua sintaxe é:

 

ListBox.ObjectCollection.Clear ()

Contém

 

Verifica se um item pode ser encontrado na lista de itens. Sua sintaxe é:

 

ListBox.ObjectCollection.Contains (valor)

 

onde o valor é um objeto que contém o valor para localizar no ListBox. O método retorna

Verdadeiro se o valor for encontrado, caso contrário, retorna False.

 

CopyTo

 

Cópias de todos os itens para um array de objetos. Sua sintaxe é:

 

ListBox.ObjectCollection.CopyTo (dest (), arrayIndex)

 

dest onde é a matriz de objetos para que os itens de caixa de listagem devem ser copiados e arrayIndex

é a posição inicial dentro dest em que a cópia é para começar.

 

IndexOf

 

Retorna o índice de um item específico. Sua sintaxe é:

 

 

194

 

 

 

 

 

 

 

 

 

 

Inserir

 

NET Programação Visual Basic.

 

 

De ListBox (valor)

 

onde o valor é um objeto representando o item para localizar na coleção. O método retorna

Índice do item. Se o item não pode ser encontrado, o método retorna -1.

 

 

 

Insere um item na ListBox na posição de índice especificada. Sua sintaxe é:

 

ListBox.ObjectCollection.Insert (índice, item)

 

onde índice é a posição baseada em zero ordinal na qual o item deve ser inserido, eo item

é um objeto que contém os dados a serem inseridos na coleção.

 

 

Remover

 

Remove o item que é passada como um argumento para este método a partir do ListBox. Sua sintaxe é:

 

ListBox.ObjectCollection.Remove (valor)

 

onde o valor é um objeto representando o item para remover da coleção.

 

RemoveAt

 

Remove um item na posição de índice especificada. Sua sintaxe é:

 

ListBox.ObjectCollection.RemoveAt (índice)

 

onde índice é a posição baseada em zero ordinal na coleção do item a ser removido.

 

5.1.11 Classe A ListView

 

A ListView é um controle de recipiente que pode conter uma coleção de itens. Cada item em uma ListView pode ter

texto descritivo e uma imagem, e os itens podem ser vistos em quatro modos. O painel do lado direito da

Windows Explorer é um controle ListView.

 

Um item em uma ListView é representado por um objeto do tipo ListViewItem. Os construtores de vários pontos do

classe ListViewItem permitir uma ListViewItem a ser construída com uma corda ou uma String e um índice

número. Se um número de índice é usado, ele representa o índice da imagem do item no ImageList

referenciado pelo ListView.

 

O código a seguir cria dois objetos ListViewItem. O primeiro tem o texto "Item1" e usa o

primeira imagem da ImageList. O segundo tem o texto "Item2" e usa a segunda imagem do

ImageList:

 

Dim listViewItem1 Como ListViewItem = New ListViewItem ("Item1", 0)

Dim listViewItem2 Como ListViewItem = New ListViewItem ("Item2", 1)

 

Depois de ter referências a objetos ListViewItem um ou mais, você pode adicionar os itens para o seu

ListView objeto. Para adicionar um item ou um grupo de itens, primeiro você precisa fazer referência ao

ListView.ListViewItemCollection coleção do objeto ListView. Esta coleção pode ser facilmente

referenciada usando a propriedade Items da classe ListView. O ListView.ListViewItemCollection tem

Adicionar e métodos AddRange que você pode usar para adicionar um item ou um grupo de itens. Por exemplo, o

código a seguir usa o método AddRange para adicionar dois objetos ListViewItem a um objeto ListView:

 

 

 

 

195

 

 

 

 

 

listView1.Items.AddRange (New ListViewItem () _

  {ListViewItem1, listViewItem2})

 

O método Add da ListView.ListViewItemCollection tem três sobrecargas, duas das quais permitem que você

Adicionar a uma ListViewItem sem primeiro criar um objeto ListViewItem.

 

Para adicionar um objeto ListViewItem para a coleção, você pode usar o seguinte sobrecarga do método Add:

 

Sobrecargas Overridable Função Pública _ Adicionar

  (Valor ByVal ListViewItem) _

  Como ListViewItem

 

Ou, para adicionar uma String e convertê-lo em um objeto ListViewItem, use a sobrecarga seguinte:

 

Sobrecargas Overridable Função Pública _ Adicionar

  (ByVal texto As String) _

  Como ListViewItem

 

Alternativamente, você pode passar uma String e um índice de imagem para a sobrecarga de terceiros:

 

Sobrecargas Overridable Função Pública _ Adicionar

  (ByVal texto As String, _

   ByVal ImageIndex As Integer) _

  Como ListViewItem

 

O código a seguir demonstra como adicionar dois objetos ListViewItem para um ListView. O ListView é

ligados a um ImageList que tem duas imagens de sua coleção. Quando o código for executado, ele produz

algo semelhante à Figura 5-4.

 

Figura 5-4. Um controle ListView com dois objetos ListViewItem

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

'Declare e instanciar um ImageList chamado imageList1.

Dim imageList1 Como ImageList ImageList = Novo ()

"Definir o ColorDepth e ImageSize propriedades de imageList1.

imageList1.ColorDepth = ColorDepth.Depth8Bit

imageList1.ImageSize = Novo System.Drawing (48, 48)

"Juntar duas imagens para imageList1.

imageList1.Images.Add (New Icon ("c: \ Spotty.ico"))

imageList1.Images.Add (New Bitmap ("c: \ StopSign.bmp"))

 

'Declare e instanciar dois objetos ListViewItem nomeado

"ListViewItem1 e listViewItem2.

"O texto para listItem1 é" Item1 ", ea imagem é a primeira

 

 

196

 

NET Programação Visual Basic.

 

 

"Imagem na imageList1.

"O texto para listItem1 é" Item2 ", ea imagem é o segundo

"Imagem na imageList1.

Dim listViewItem1 Como ListViewItem = New ListViewItem ("Item1", 0)

Dim listViewItem2 Como ListViewItem = New ListViewItem ("Item2", 1)

 

'Declare e instanciar um ListView chamado listView1.

Dim listView1 Como ListView ListView = Novo ()

"Defina suas propriedades.

listView1.View = View.LargeIcon

listView1.LargeImageList = imageList1

listView1.Location = Novo System.Drawing.Point (16, 16)

listView1.Name = "ListView1"

listView1.Size = Novo System.Drawing (264, 224)

listView1.SmallImageList = Me.ImageList1

 

»Adicionar listViewItem1 e listViewItem2.

listView1.Items.AddRange (New ListViewItem () _

  {ListViewItem1, listViewItem2})

 

»Adicionar listView1 ao formulário.

Me.Controls.AddRange (New Control () {} listView1)

 

Duas propriedades da classe ListView dizer qual item (s) estão selecionadas: SelectedIndices e

SelectedItems. O primeiro método retorna um objeto ListView.SelectedIndexCollection, eo segundo retorna um

ListView.SelectedListViewItemCollection objeto.

 

A classe ListView.SelectedIndexCollection possui uma propriedade Count que indica quantos itens estão

selecionados e uma propriedade Item que retorna o índice do item designado. Por exemplo, você pode

recuperar o índice do primeiro item selecionado passando 0 para a propriedade Item, conforme segue:

 

Índice ListView1.SelectedIndices.Item = (0)

 

A classe ListView.SelectedListViewItemCollection é muito semelhante ao ListView.SelectedIndexCollection.

Sua propriedade Count indica quantos itens são selecionados. No entanto, a sua propriedade Item retorna o item

si só, não um número índice.

 

5.1.12 A Classe MonthCalendar

 

A classe MonthCalendar representa um controle que exibe dias de um mês. Um controle MonthCalendar

é mostrado na Figura 5-5. Por padrão, quando exibido pela primeira vez, o controle exibe o mês atual sobre a

sistema do computador do usuário. Os usuários podem selecionar um dia, clicando nele ou selecione um intervalo de datas de realização

a tecla Shift enquanto clica a data no final do intervalo desejado. Os usuários também podem retroceder

e em frente ao mês anterior ou próximo, ou eles podem clicar sobre a parte do mês e mais depressa

selecionar um dos 12 meses. Para alterar o ano, os usuários podem clicar sobre a parte do ano e clique no

barra de rolagem que aparece.

 

Figura 5-5. Um controle MonthCalendar

 

 

 

 

 

 

 

 

 

 

 

 

 

197

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Duas propriedades determinar o intervalo de data que os usuários podem selecionar: MinDate e MaxDate. O MinDate

propriedade é um valor DateTime que representa a data mínima permitida, o padrão é 01 de janeiro de 1753.

A propriedade MaxDate determina a data máxima permitida. Por padrão, o valor é de MaxDate

31 de dezembro de 9998.

 

Se você quiser que o seu MonthCalendar para exibir um determinado intervalo de datas, é necessário alterar estas duas

propriedades. Por exemplo, o seguinte código permite que o usuário selecione uma data entre 01 de janeiro de 1980

e 14 de dezembro de 2010:

 

MonthCalendar1.MinDate DateTime = Nova (1980, 1, 1)

MonthCalendar1.MaxDate DateTime = Nova (2010, 12, 14)

 

A classe tem uma propriedade MonthCalendar TodayDate que representa a data de hoje. O usuário selecionando

uma nova data não muda automaticamente o valor do TodayDate. Se você quiser a data selecionada pelo

o usuário deve ser refletida como a data de hoje, você pode usar o manipulador de eventos Date_Changed para alterar a sua

valor explicitamente, como mostra o seguinte código:

 

Private Sub MonthCalendar1_DateChanged (_

  ByVal sender As System.Object, _

  ByVal e As DateRangeEventArgs) _

  Puxadores MonthCalendar1.DateChanged

 

    MonthCalendar1.TodayDate e.Start =

End Sub

 

Um objeto DateRangeEventArgs é passado como um argumento para o manipulador de eventos DateChanged. Sua

membros incluem uma propriedade Start, que representa o início do intervalo de datas selecionadas, e

Fim de uma propriedade, que representa o final do intervalo de datas selecionadas. O código anterior simplesmente

atribui o valor da propriedade Start para TodayDate. Mais tarde, se você precisa saber o valor do usuário

data marcada, você pode consultar a propriedade TodayDate.

 

Observe que o controle MonthCalendar tem um tamanho fixo. Ele vai ignorar qualquer tentativa de alterar o seu tamanho

propriedade. Se precisar de mais flexibilidade em termos de espaço que ele ocupa, use um controle DateTimePicker.

 

5.1.13 Classe O Painel

 

Um painel é um recipiente que pode conter outros controles. Os painéis são normalmente usados para agrupar controles relacionados

em um formulário. Como a classe PictureBox, a classe Panel tem uma propriedade BorderStyle que define o

borda do painel e pode tomar como valor qualquer membro da enumeração BorderStyle: Nenhum (a

valor padrão), FixedSingle e Fixed3D.

 

Você pode adicionar controles a um painel de objeto usando o método Add ou o método AddRange do

Control.ControlCollection classe. O seguinte código adiciona um botão e uma caixa de texto para um controle Panel

chamado panel1:

 

 

 

198

 

NET Programação Visual Basic.

 

 

Dim panel1 Como Novo Painel Painel = ()

Dim textBox1 Como TextBox = New TextBox ()

Dim WithEvents button1 como Button

 

button1 = Novo Button ()

 

"Button1

button1.Location = Novo System.Drawing.Point (104, 72)

button1.Name = "button1"

button1.Size = Novo System.Drawing (64, 48)

button1.TabIndex = 0

Button1.Text = "Button1"

 

"TextBox1

textBox1.Location = Novo System.Drawing.Point (128, 48)

textBox1.Name = "TextBox1"

textBox1.TabIndex = 1

 

panel1.Controls.AddRange (New Control () {textBox1, button1})

panel1.Location = Novo System.Drawing.Point (24, 24)

panel1.Name = "Panel1"

panel1.Size = Novo System.Drawing (336, 216)

Me.Controls.Add (panel1)

 

5.1.14 A Classe PictureBox

 

A classe representa um controle PictureBox para exibir uma imagem. Carregando uma imagem para esse controle é

conseguido através da atribuição de um objeto System.Drawing.Bitmap à sua propriedade de imagem, como o seguinte código

faz:

 

Dim pictureBox1 Como PictureBox PictureBox = Novo ()

pictureBox1.Image = Novo System.Drawing.Bitmap ("c: \ tv.bmp")

pictureBox1.Location = Novo System.Drawing.Point (72, 64)

pictureBox1.Size = Novo System.Drawing (144, 128)

Me.Controls.Add (pictureBox1)

 

Além disso, a classe PictureBox tem as propriedades BorderStyle e SizeMode. O BorderStyle

propriedade determina a borda do objeto PictureBox e pode tomar como valor qualquer membro da

BorderStyle enumeração: None (o valor padrão), FixedSingle e Fixed3D.

 

A propriedade SizeMode determina como a imagem atribuída à propriedade da imagem é exibida. A

propriedade SizeMode pode tomar qualquer um dos membros da enumeração PictureBoxSizeMode: AutoSize,

CenterImage, Normal (o valor padrão), e StretchImage.

 

5.1.15 Classe A RadioButton

 

A classe RadioButton representa um botão de rádio. Quando você adicionar mais de um botão a um formulário,

os botões de rádio tornam-se automaticamente um grupo, e você pode selecionar somente um botão de cada vez. Se

você quer ter vários grupos de botões em um formulário, você precisará usar um GroupBox ou Painel

controle para adicionar botões de rádio do mesmo grupo a um GroupBox única ou de painel.

 

O código a seguir mostra como você pode adicionar dois botões de rádio para um GroupBox e depois adicionar o

GroupBox a um formulário. Observe que você não precisa adicionar cada botão de opção individual a um formulário:

 

'Declare e instanciar um GroupBox e dois botões de rádio.

Dim GroupBox1 Como GroupBox GroupBox = Novo ()

Dim RadioButton1 Como RadioButton RadioButton = new ()

Dim RadioButton2 Como RadioButton RadioButton = new ()

 

 

199

 

 

 

 

 

"Definir o tamanho ea localização de cada controle.

groupBox1.Size = Novo System.Drawing (248, 88)

groupBox1.Location = Novo System.Drawing.Point (112, 168)

radioButton1.Location = Novo System.Drawing.Point (16, 10)

radioButton1.Size = Novo System.Drawing (104, 20)

radioButton2.Location = Novo System.Drawing.Point (16, 50)

radioButton2.Size = Novo System.Drawing (104, 20)

»Adicionar RadioButton1 e RadioButton2 ao GroupBox.

groupBox1.Controls.AddRange (New Control () {RadioButton1, RadioButton2})

 

»Adicionar o GroupBox para o formulário.

Me.Controls.Add (GroupBox1)

 

Como uma opção, a aparência de um botão de rádio é determinada por sua aparência de propriedade, que

pode ter um dos dois membros da enumeração Aparência: Normal (padrão) e Button. Você

normalmente não uso Appearance.Button porque vai fazer seu botão como um botão.

 

A propriedade CheckAlign determina o alinhamento do texto do botão de rádio. Seu valor é um dos

membros da enumeração ContentAlignment: BottomCenter, BottomLeft, bottomRight,

MiddleCenter, MiddleLeft (o padrão), MiddleRight, TopCenter, topLeft e topright.

A propriedade Checked leva um booleano. A definição dessa propriedade como True seleciona o botão de rádio (e

desmarca outros membros do grupo), definindo-o como False unselects-lo.

 

5.1.16 A classe TextBox

 

Esta classe representa um controle de caixa de texto, um controle que pode aceitar o texto como entrada do usuário. Suas principais

propriedades são:

 

Multiline

 

Esta propriedade pode ser definida como True (indicando que várias linhas são permitidos) ou Falso

(Modo single-line). Por padrão, o valor desta propriedade é False.

 

AcceptsReturn

 

Se for True (o valor padrão), e se a propriedade Multiline também é verdadeiro, pressionando a tecla Enter irá

passar para a próxima linha na caixa de texto. Caso contrário, pressione Enter terá o mesmo efeito que

clicando no botão do formulário padrão.

 

CharacterCasing

 

Esta propriedade determina como os caracteres que são introduzidos pelo utilizador aparecem na caixa de texto. É

pode tomar qualquer membro da enumeração CharacterCasing: Normal (padrão), superior, e

Inferior. Definir essa propriedade como CharacterCasing.Upper traduz todos os caracteres de entrada para

maiúsculas. Atribuindo CharacterCasing.Lower a esta propriedade converte todas as entradas para

minúsculas. CharacterCasing.Normal significa que nenhuma conversão é feita na entrada.

 

PasswordChar

 

Esta propriedade define um caractere de máscara para ser exibido no lugar de cada caractere entrada pela

do usuário, transformando assim a caixa de texto em uma caixa de senha. Essa propriedade se aplica somente a um único

caixa de linha de texto (ou seja, uma caixa de texto Multiline cuja propriedade é False). Ela afeta a exibição, mas não

o valor da propriedade Text.

 

ScrollBars

 

 

200

 

NET Programação Visual Basic.

 

 

Em uma caixa de texto de várias linhas, essa propriedade determina se as barras de rolagem são mostradas no controle.

A propriedade pode assumir qualquer membro da enumeração ScrollBars: Nenhum (o padrão),

Horizontal, vertical, e dois.

 

TextAlign

 

Esta propriedade determina como o texto é alinhado na caixa de texto. Pode levar qualquer membro da

enumeração HorizontalAlignment: Centro, Esquerda e Direita.

 

5.1.17 A Classe Timer

 

A classe Timer representa um timer que pode acionar um evento em um intervalo especificado. A cada intervalo, uma

objeto Timer gera o evento Tick. Você pode escrever código no manipulador de eventos Tick que funciona regularmente.

 

O temporizador irá aumentar seu evento Tick somente depois que você chamar o método Start. Para parar o temporizador, chamar seu Stop

método.

 

O intervalo para o timer é definido atribuindo um valor à sua propriedade Interval. Ele aceita um número

representando o intervalo em milissegundos. O código a seguir, que imprime um inteiro incrementado de

1-20 para o console, mostra como usar um timer:

 

Dim i As Integer

Amigo WithEvents timer1 Como Timer

timer1 = Novo Timer ()

timer1.Interval = 1000

timer1.Start ()

 

"O manipulador de eventos Tick.

Timer1_Tick Private Sub (_

  ByVal sender As System.Object, _

  ByVal e As System.EventArgs) _

  Puxadores Timer1.Tick

  Se i <20 então

    i = i + 1

    Console.WriteLine (i)

  Mais

    timer1.Stop ()

  End If

End Sub

 

5.1.18 Outros Controles e Componentes

 

Além dos controles que já discutimos em alguns detalhes nas seções anteriores, o. NET

Quadro inclui uma série de outros controles e componentes para a aplicação de Windows

de desenvolvimento. Estes incluem:

 

AxHost

 

Quebra de controles ActiveX para deixá-los ser usado dentro do Windows Forms.

 

CheckedListBox

 

O mesmo que o controle ListBox, exceto que caixas são exibidas à esquerda de cada item.

O controle CheckedListBox deriva do controle ListBox.

 

ContainerControl

 

 

201

 

 

 

 

Um recipiente para outros controles. A ênfase deste controle é sobre como gerenciar o estado de foco de

controles contidos. Por exemplo, tem um método que pode ser chamado para forçar a ativação de um

dado o controle contido (ActivateControl) e um método substituível que é invocado quando o

guias de usuário entre os controles contidos (ProcessTabKey).

 

O controle ContainerControl fornece suporte automático para a navegação, porque deriva de

ScrollableControl.

 

Quando os controles contidos são ancoradas ou encaixada, se enraízam ou encaixar às bordas da

contendo controle.

 

ContextMenu

 

Fornece um método para exibir um menu de contexto (também conhecido como um menu pop-up). Contexto

menus geralmente são exibidos em resposta ao usuário clique-direito do mouse. Consulte a Seção

5,5 mais adiante neste capítulo para obter detalhes.

 

DataGrid

 

Um controle de grade para exibir dados ADO.NET. Consulte o Capítulo 8 para obter exemplos.

 

DomainUpDown

 

Um controle Windows up-down (também conhecido como um botão de rotação), que permite ao usuário selecionar a partir de um

lista de valores de texto clicando no controle de cima e para baixo. Veja também NumericUpDown,

posteriormente nesta lista.

 

HScrollBar

 

A barra de rolagem horizontal padrão do Windows.

 

MainMenu

 

Fornece um método para a exibição do menu principal do aplicativo. Veja Secção 5.5 mais adiante neste

capítulo para obter detalhes.

 

MenuItem

 

Representa um item de menu dentro de um menu. Veja Secção 5.5 mais adiante neste capítulo para obter detalhes.

 

NotifyIcon

 

Fornece uma maneira de colocar um ícone na bandeja do sistema Windows.

 

NumericUpDown

 

Um controle Windows up-down (também conhecido como um botão de rotação), que permite ao usuário selecionar a partir de um

lista de valores numéricos, clicando no controle para cima e para baixo. Veja também DomainUpDown,

anteriormente nesta lista.

 

PrintPreviewControl

 

Exibe uma visualização da imagem de um documento a ser impresso. O PrintPreviewControl geralmente não é

usado diretamente. É encontrado na forma PrintPreviewDialog discutido mais adiante neste capítulo,

Seção 5.4.

 

 

 

202

 

 

 

 

ProgressBar

 

NET Programação Visual Basic.

 

 

Uma barra de progresso padrão do Windows.

 

PropertyGrid

 

Uma interface de usuário para exibir e definir as propriedades de qualquer objeto.

 

RichTextBox

 

Um padrão do Windows caixa de rich text (também conhecido como um controle rich edit). O controle RichTextBox

pode manipular texto em Rich Text Format (RTF).

 

ScrollableControl

 

Não é usada diretamente. O controle ScrollableControl serve como a classe base para controles que

necessidade de fornecer suporte automático para a rolagem. O controle ContainerControl eo Painel

de controle são provenientes de ScrollableControl.

 

Splitter

 

Fornece o usuário com uma forma de redimensionar controles encaixados usando o mouse. Este será

discutido mais adiante neste capítulo, na secção 5.3.

 

StatusBar

 

Uma barra de status padrão do Windows.

 

TabControl

 

Um recipiente que fornece páginas para conter outros controles e guias de clicar para se mover entre

as páginas. As páginas são as instâncias do controle TabPage, que é derivado do Painel

controle.

 

ToolBar

 

Uma barra de ferramentas padrão do Windows.

 

TrackBar

 

Um TrackBar padrão do Windows (também conhecido como um controle deslizante)

 

TreeView

 

A exibição em árvore padrão do Windows.

 

UserControl

 

Não é usada diretamente. UserControl serve como a classe base para o recipiente criadas pelo desenvolvedor

controles. Veja Secção 5.6 mais adiante neste capítulo.

 

VScrollBar

 

A barra de rolagem vertical padrão do Windows.

 

 

 

203

 

 

 

 

 

5,2 eventos de controle

 

Controles em um formulário são representados no código como campos de campo, uma para cada controle. Por exemplo, quando

o Visual Studio. NET Windows Forms Designer é usado para adicionar uma caixa de texto a um formulário, as seguintes

declaração é adicionado à classe de formulário:

 

Private WithEvents TextBox1 Como System.Windows.Forms.TextBox

 

Esta declaração não instanciar o controle, mas apenas define um campo que pode conter uma referência a um

controle do tipo TextBox. O controle é instanciado na sub-rotina InitializeComponent, que é

chamada no construtor da classe do formulário. O código que instancia o controle parecido com este:

 

Me.TextBox1 System.Windows.Forms.TextBox = Novo ()

 

Conforme discutido no Capítulo 2, quando uma declaração de campo inclui a palavra-chave WithEvents, o pai

classe pode manipular eventos que o objeto referenciado levanta. Para isso, a classe pai deve definir um

método de manipulador de ter a assinatura apropriada, ea definição do método deve incluir um

cláusula Handles para vincular o método apropriado para o evento no objeto apropriado. Por exemplo,

aqui é a definição de um método de manipulador para o evento Click do TextBox1:

 

TextBox1_Click Private Sub (_

   ByVal sender As Object, _

   ByVal e As System.EventArgs _

) Handles TextBox1.Click

   '...

End Sub

 

O método de manipulador de eventos pode ser dado qualquer nome, mas é uma convenção comum a utilização de um nome de

o FieldName_EventName formulário. A assinatura do método manipulador de eventos deve corresponder ao

assinatura do evento que está sendo manipulado. Por convenção, o evento tem as assinaturas de dois parâmetros: o remetente

e E. O parâmetro do remetente é sempre do tipo Object e mantém uma referência ao objeto que gerou

o evento. O parâmetro e é do tipo EventArgs ou de um tipo que herda de EventArgs e detém

uma referência a um objeto que fornece qualquer informação extra necessária para o evento. Eventos que passam por um

argumento EventArgs genéricos não têm informações sobre o evento para passar. Eventos que passar um argumento de um

tipo EventArgs derivados passar informações adicionais dentro dos campos do objeto passado.

 

A assinatura correta para lidar com um evento específico pode ser determinado por referência ao

documentação de controle ou usando o Visual Studio. NET embutido no navegador de objetos. Além disso, o Visual

Studio. NET Windows Forms Designer gera automaticamente uma declaração de método manipulador para

qualquer caso exposto por qualquer controle sobre uma determinada forma.

 

5,3 a forma ea disposição de controle

 

Windows Forms permite aos desenvolvedores expor interfaces sofisticadas que são capazes de

redimensionamento inteligente sem escrever uma linha de código. Anteriormente, os desenvolvedores a escrever aplicações para desktop

para o Windows normalmente gasta uma boa parte do tempo escrevendo código de redimensionamento para lidar com a colocação de

controles no formulário quando o usuário redimensionar o formulário. A plataforma. NET, no entanto, permite que você defina

layout de um controle e de tamanho ao ajustar algumas propriedades.

 

5.3.1 A propriedade Anchor

 

A propriedade Anchor permite um controle de âncora a todas ou algumas partes de seu recipiente. Cada lado do ancorada

o controle é mantido dentro de uma distância constante do lado correspondente do seu recipiente. Quando o

container é redimensionado, seus controles ancorados são reposicionadas e redimensionadas como necessárias para executar esta

regra. A propriedade Anchor é definido pela classe de controle (no namespace System.Windows.Forms)

e assim é herdada por todos os controles e formulários. Sua sintaxe é:

 

 

204

 

NET Programação Visual Basic.

 

 

Public Property Overridable Âncora () As System.Windows.Forms.AnchorStyles

 

O tipo AnchorStyles é uma enumeração que define os valores Left, Top, Right, Bottom, e

Nenhum. Para ancorar um controle em mais de uma aresta, combinar os valores com o operador ou, como mostrado

aqui:

 

"Assume Imports System.Windows.Forms

SomeControl.Anchor AnchorStyles.Top = Ou AnchorStyles.Right

 

Por padrão, os controles são ancorados nos lados superior e esquerdo. Isto significa que se um formulário é redimensionado, a sua

controles de manter uma distância constante das margens superior e esquerda do formulário. Esse comportamento corresponde

o comportamento de Visual Basic 6 formas.

 

Por exemplo, a Figura 5-6 mostra uma configuração de botões comuns, onde os botões OK e Cancelar

deve controlar a borda direita da forma como o formulário é redimensionado. Nas versões anteriores do Visual Basic,

Foi necessário adicionar o código ao manipulador do formulário evento Resize para reposicionar os botões como a forma

foi redimensionada. No Visual Basic. NET, no entanto, é necessário apenas definir a propriedade do botão de âncora

apropriadamente. Isso pode ser feito no Visual Studio. NET janela Propriedades ou no código (na

construtor do formulário).

 

Figura 5-6. Uma forma considerável com os controles que devem ser ancorada na

margens superior e direita

 

 

 

 

 

 

 

 

 

 

O código para ancorar um botão nas bordas superior e direita parecido com este:

 

"Assume Imports System.Windows.Forms

btnOk.Anchor = AnchorStyles.Top Ou AnchorStyles.Right

 

Às vezes, um controle deve esticar como o formulário é redimensionado. Isso é conseguido ancorar a

controle em dois lados opostos do formulário. Por exemplo, a caixa de texto na Figura 5-7 sempre deve preencher

o espaço entre a borda esquerda do formulário eo botão OK do lado direito do formulário.

 

Figura 5-7. Neste formulário, a caixa de texto deve se expandir e encolher para preencher o

espaço disponível

 

 

 

 

 

 

 

 

 

 

Para fazer isso, criar o formulário, como mostrado, âncora os botões nas bordas superior e direita, como

já foi discutido, então âncora na caixa de texto no topo, esquerda e direita bordas. Por padrão, o rótulo de

o formulário já está ancorado nas margens superior e esquerda. O código parecido com este:

 

"Assume Imports System.Windows.Forms

 

 

205

 

 

 

 

 

'Anchor os botões OK e Cancelar nas bordas superior e direita.

btnOk.Anchor = AnchorStyles.Top Ou AnchorStyles.Right

btnCancel.Anchor = AnchorStyles.Top Ou AnchorStyles.Right

 

"Âncora na caixa de texto Nome do arquivo no topo, à esquerda, e as bordas direita.

"Isso faz com que a caixa de texto para redimensioná-se como necessário.

txtFilename.Anchor = AnchorStyles.Top Ou AnchorStyles.Left _

   Ou AnchorStyles.Right

 

5.3.2 A propriedade Dock

 

A propriedade Dock permite um controle ser encaixado em qualquer um dos lados do seu recipiente ou deixa-la encher o recipiente.

Docking um controle para o lado de um contentor que se assemelha a de controle com três de suas bordas

adjacentes e ancorada às três arestas correspondentes de seu recipiente. Figura 5-8 mostra um texto

controle de caixa acoplada ao lado esquerdo de sua forma.

 

Figura 5-8. Um TreeView acoplado ao lado esquerdo de um formulário

 

 

 

 

 

 

 

 

 

 

 

 

A propriedade Dock é definida pela classe de controle (no namespace System.Windows.Forms) e assim

é herdada por todos os controles e formulários. Sua sintaxe é:

 

Público Dock Propriedade Overridable () As System.Windows.Forms.DockStyle

 

O tipo DockStyle é uma enumeração que define os valores Left, Top, Right, Bottom, Preenchimento e

Nenhum. Apenas um valor pode ser usado ao mesmo tempo. Por exemplo, um controle não pode ser encaixada tanto à esquerda

e margens direita de seu recipiente. Definindo a propriedade Dock para DockStyle.Fill faz o controle

expandir para preencher o espaço disponível em sua embalagem. Se o controle é o único controle encaixado no

recipiente, que se expande para encher o recipiente. Se houver outros controles encaixada no contêiner, o controle

se expande para preencher o espaço não ocupado por outros controles encaixados. Por exemplo, na Figura 5-9, o

Dock propriedade de textBox1 está definido para DockStyle.Left ea propriedade Dock do textBox2 é definido como

DockStyle.Fill.

 

Figura 5-9. Um controle de esquerda encaixado e um controle de preenchimento ancorada

 

 

 

 

 

 

 

 

 

 

 

 

5.3.2.1 Para dock Controle

 

 

 

206

 

NET Programação Visual Basic.

 

 

Controles têm uma ordem intrínseca dentro de seu recipiente. Isso é conhecido como a sua ordem z (pronuncia-se "zee

ordem "). A ordem z de cada controle é único dentro de um recipiente determinado. Quando dois controles se sobrepõem em

mesmo recipiente, o controle com os eclipses maior ordem z do controle com o menor z-ordem.

 

Docking comportamento é afetado por z-ordem. Quando dois ou mais controles são encaixados no mesmo lado de uma

forma, eles são encaixados lado a lado. Por exemplo, os dois controles de caixa de texto mostrado na Figura 5-10 são

ancorada tanto para a esquerda.

 

Figura 5-10. Docking dois controles para o mesmo lado de um formulário

 

 

 

 

 

 

 

 

 

 

 

 

Em tal situação, a posição relativa de cada controle encaixado é determinada pelo seu z-ordem. A

controle com o menor ordem z é posicionado próximo à borda do formulário. O controle com o próximo

maior ordem z é colocado próximo a isso, e assim por diante. Na Figura 5-10, textBox1 tem a menor ordem z, e

textBox2 tem a maior z-ordem.

 

Então, como é de ordem z é determinado? No código, z-ordem é determinada pela ordem em que os controles são adicionados

para a sua recolha recipiente Controls. O primeiro controle adicionado através do método da coleção Adicione tem

maior a ordem z; o último controle adicionado tem a menor z-ordem. Por exemplo, para produzir a exposição

mostrado na Figura 5-10, textBox2 deve ser adicionado à coleção Controls em primeiro lugar, como mostrado aqui:

 

Me.Controls.Add (Me.textBox2)

Me.Controls.Add (Me.textBox1)

 

Isso resulta em textBox1 ter o menor z-ordem e, portanto, ficando encaixado diretamente para a borda da

o formulário.

 

Se o método AddRange a coleção Controls é usado para adicionar uma série de controles para um recipiente, o

primeiro controle na matriz tem a maior z-ordem e do último controle na matriz tem a menor z-ordem.

Por exemplo, textBox1 e textBox2 na Figura 5-10 poderia ter sido adicionadas ao seu recipiente usando

este código:

 

"Assume Imports System.Windows.Forms

Me.Controls.AddRange (New Control () {Me.textBox2, Me.textBox1})

 

Depois controles foram adicionados à coleção Controls do seu recipiente, você pode mudar sua ordem z

chamando os métodos da classe Control ou SendToBack BringToFront. O método dá SendToBack

o controle de mais baixo a ordem z dentro de seu recipiente (fazendo-a mais próxima estação para a borda da forma).

O método BringToFront dá o controle maior da z-ordem dentro de seu recipiente (fazendo-a doca

mais distante da borda da forma). Por exemplo, o código a seguir força o controle de um porto,

mostrado na Figura 5-10, independentemente da ordem em que foram adicionados aos controles do formulário

coleção:

 

Me.textBox2.BringToFront ()

 

A ordem na qual os controles são instanciados no código e na ordem em que seus respectivos Dock

propriedades são definidas não afetam os controles 'z-ordens.

 

 

 

207

 

 

 

 

Quando você faz design usando o Visual Studio. NET Windows Forms Designer, os controles adicionados

mais recentemente, têm a maior z-ordens e, portanto, mais se encaixe das bordas de seus recipientes.

O Z-ordens dos comandos pode ser alterado dentro do designer com o botão direito do mouse em um controle e

escolhendo "Trazer para a Frente" ou "Enviar para trás."

 

Quando um dos controles em um contêiner é encher-encaixado, que o controle deve ser o último na ordem da doca (ou seja,

ele deve ter mais a ordem z), para que ele use apenas o espaço que não é usada pelos outros ancorada

controles.

 

Para Dock também entra em jogo quando os controles são encaixados em lados adjacentes de um recipiente, como mostrado

na Figura 5-11.

 

Figura 5-11. Docking dois controles para os lados adjacentes de uma forma

 

 

 

 

 

 

 

 

 

 

 

 

O controle com o menor ordem z é encaixado em primeiro lugar. Na Figura 5-11, textBox1 tem a menor ordem z

e assim está encaixado totalmente para o lado esquerdo do formulário. textBox2 é então cortada para o que resta do topo

o formulário. Se a z-ordem é invertida, a aparência é alterada, como mostrado na Figura 5-12.

 

Figura 5-12. Invertendo a ordem da doca

 

 

 

 

 

 

 

 

 

 

 

 

Na Figura 5-12, textBox2 tem a menor z-ordem e por isso é encaixado em primeiro lugar, ocupando toda a extensão da

lado em que ele está encaixado (no topo). Então textBox1 é encaixado o que resta do lado esquerdo da

formulário. Esse comportamento pode ser explorado para estabelecer regimes de encaixe complexos, tais como a

mostrado na Figura 5-13.

 

Figura 5-13. regime de acoplamento complexos são facilmente criados

 

 

 

 

 

 

 

 

 

 

 

 

 

 

208

 

NET Programação Visual Basic.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

As caixas de texto na Figura 5-13 são em ordem crescente ordem z (textBox1 é menor; textBox6 é maior). A

Dock propriedades dos controles são definidos assim:

 

textBox1.Dock = DockStyle.Left

textBox2.Dock = DockStyle.Top

textBox3.Dock = DockStyle.Right

textBox4.Dock = DockStyle.Bottom

textBox5.Dock = DockStyle.Left

textBox6.Dock = DockStyle.Fill

 

5.3.2.2 O controle Splitter

 

Por padrão, as bordas internas dos controles encaixados não são arrastáveis. Para fazer a ponta de uma dada

arrastável controle encaixado, adicione um controle Splitter para o formulário. O controle Splitter deve aparecer na

Para encaixar imediatamente após o controle cuja borda é para ser arrastado, portanto, o controle Splitter é z

ordem deve ser um pouco acima que o controle da z-ordem. Além disso, o controle Splitter deve ser acoplado à

mesma borda da forma como o controle cuja borda é para ser arrastado. O controle Splitter fornece uma

divisão vertical se ela for cortada a esquerda ou direita e uma divisão horizontal, se superior ou inferior encaixada.

 

Considere novamente a Figura 5-9. Para fazer a borda entre os dois controles de caixa de texto arrastáveis, um divisor

controle deve ser adicionado ao formulário (chamemos-lhe splitter1), eo z-ordem deve ser textBox2 (mais alto), então

splitter1 e, em seguida textBox1 (mais baixo). Isso pode ser feito no Visual Studio. NET Windows

Forms Designer, adicionando os controles para o formulário no fim da doca (TextBox1, splitter1, textBox2). Como

mencionado anteriormente, se os controles já foram adicionados ao formulário, a sua ordem z pode ser

reorganizados clicando os controles de um por um, a fim doca e escolhendo "Trazer para a Frente". A

z-ordem também pode ser controlado no código, como discutido anteriormente.

 

É possível automatizar a tarefa de criação de Splitter. A sub-rotina no Exemplo 5-1 toma como

parâmetro uma referência para um controle acoplado e cria um controle de Splitter, que faz com que o dado

borda interna do controle arrastável.

 

Exemplo 5-1. Dinamicamente criar um controle Splitter

Compartilhados AddSplitter Sub (ByVal ctl As Control)

 

   "Criar um controle de Splitter.

   Dim dividir como nova Splitter ()

 

   'Get a coleção Controls do recipiente do controle de dado.

   Dim controles como System.Windows.Forms.Control.ControlCollection _

      = Ctl.Parent.Controls

 

   »Adicionar o divisor no mesmo recipiente, como o controle de dados.

   Controls.Add (split)

 

 

 

209

 

 

 

 

 

   'Move o controle Splitter ser imediatamente anterior ao determinado

   "Controle da coleção Controls. Isso faz com que o divisor

   "Controle de z-ordem para ser um pouco acima do determinado controle de ordem z,

   "O que significa que o controle Splitter será encaixado

   "Imediatamente a seguir controlam o dado.

   controls.SetChildIndex (split, controls.GetChildIndex (CTL))

 

   "Dock controlar o divisor para a mesma vantagem que o controle dado.

 

   split.Dock = ctl.Dock

 

End Sub

 

5,4 caixas de diálogo comum

 

Existem várias classes que implementam as caixas de diálogo comuns, como a seleção de cor e impressão

instalação. Essas classes de todos derivam da classe CommonDialog e, portanto, todos herdam o

ShowDialog método. A sintaxe do método ShowDialog é:

 

Função Pública ShowDialog () As System.Windows.Forms.DialogResult

 

Chamar o método ShowDialog faz com que a caixa de diálogo a ser exibido de forma modal, o que significa que outros

janelas no aplicativo não pode receber foco de entrada até a caixa de diálogo é descartada. A chamada é

assíncrona, o que significa que o código após a chamada para o método ShowDialog não é executada até o

caixa de diálogo é indeferido.

 

O valor de retorno do método ShowDialog é de DialogResult tipo (definido no

System.Windows.Forms namespace). DialogResult é uma enumeração que define vários valores que

uma caixa de diálogo poderia retornar. As caixas de diálogo comum, no entanto, o retorno OK ou Cancelar apenas, indicando

se o usuário selecionar o botão OK ou Cancelar, respectivamente.

 

No Visual Studio. NET Windows Forms Designer, caixas de diálogo comuns são adicionados aos formulários em grande

Da mesma forma que os controles e componentes não visuais são. Basta selecionar a caixa de diálogo desejado da

Guia do Windows Forms da caixa de ferramentas. Tal como acontece com componentes não visuais, uma representação da caixa de diálogo

aparece em um painel separado ao invés de diretamente sobre a forma que está sendo projetado. As propriedades

do componente pode então ser definido no Visual Studio. NET janela Propriedades. O Windows Forms

Designer cria código que declara e instancia a caixa de diálogo, mas você deve adicionar código para mostrar

a caixa de diálogo e usar os valores encontrados em suas propriedades.

 

Alternativamente, os componentes comuns caixa de diálogo pode ser instanciado e inicializado diretamente no código,

ignorando o Windows Forms Designer. Por exemplo, este método instancia e mostra uma

componente ColorDialog:

 

"Assume Imports System.Windows.Forms

Classe someClass Pública

   Public Sub SomeMethod ()

      Dim clrDlg como nova ColorDialog ()

      Se DialogResult.OK clrDlg.ShowDialog = Em seguida,

         "Faça alguma coisa com o valor encontrado na clrDlg.Color.

      End If

   End Sub

End Class

 

O restante desta seção descreve brevemente cada um dos componentes comuns caixa de diálogo.

 

 

 

 

 

 

210

 

 

 

 

5.4.1 ColorDialog

 

NET Programação Visual Basic.

 

 

O componente ColorDialog exibe uma caixa de diálogo que permite ao usuário escolher uma cor. Depois que o usuário

clica em OK, a cor escolhida está disponível na propriedade do objeto ColorDialog da cor. A propriedade Color

também pode ser definido antes de mostrar a caixa de diálogo. Isso faz com que a caixa de diálogo para exibir o dado inicialmente

cor. Figura 5-14 mostra um exemplo da caixa de diálogo ColorDialog.

 

Figura 5-14. A caixa de diálogo ColorDialog

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

5.4.2 FontDialog

 

O componente FontDialog exibe uma caixa de diálogo que permite ao usuário escolher uma fonte. Depois que o usuário

clica em OK, a fonte escolhida está disponível na propriedade do objeto FontDialog da Fonte. A propriedade Font pode

também ser definido antes de mostrar a caixa de diálogo. Isso faz com que a caixa de diálogo para exibir a fonte inicialmente dada.

Figura 5-15 mostra um exemplo da caixa de diálogo FontDialog.

 

Figura 5-15. A caixa de diálogo FontDialog

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

211

 

 

 

 

 

5.4.3 OpenFileDialog

 

O componente OpenFileDialog exibe uma caixa de diálogo que permite que o usuário escolha um arquivo para abrir.

Após o usuário clicar em OK, o nome do arquivo (incluindo o caminho) está disponível no OpenFileDialog

imóvel objeto FileName. A propriedade FileName pode ser definido antes de mostrar a caixa de diálogo. Este

faz com que a caixa de diálogo para exibir inicialmente o nome de arquivo dado. Figura 5-16 mostra um exemplo do

OpenFileDialog caixa de diálogo.

 

Figura 5-16. A caixa de diálogo OpenFileDialog

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Na maioria dos casos, os aplicativos devem definir o InitialDirectory, Filtro e propriedades FilterIndex prévia

a chamar ShowDialog. Isso não é necessário para o bom funcionamento da caixa de diálogo, mas vai dar

sua aplicação um olhar mais profissional e sentem.

 

A propriedade InitialDirectory determina qual diretório é exibido quando a caixa de diálogo aparece pela primeira vez.

O padrão é uma seqüência vazia, o que faz com que a caixa de diálogo para exibir o usuário Meus Documentos

diretório.

 

A propriedade de filtro contém um valor String que controla as opções em "Arquivos do tipo" drop-down list.

O objetivo desta lista drop-down é deixar o usuário limitar os arquivos mostrados na caixa de diálogo com base em

extensão de arquivo. Um exemplo típico é mostrado na Figura 5-17.

 

Figura 5-17. Um típico "Arquivos do tipo" drop-down list

 

 

 

 

Mesmo que o "Arquivos do tipo" lista pode incluir diversos itens e cada item pode representar muitos

extensões de arquivo, uma propriedade String única representa a coisa toda. Veja como funciona:

 

• Cada item na lista drop-down é representado por uma substring tendo duas partes separadas por

o caractere de barra vertical (|). A primeira parte é a descrição que aparece na lista drop-down

(Por exemplo, "Todos os arquivos (*.*)"). A segunda parte é a correspondente (por exemplo filtro, "*.*").

Levando-los juntos e acrescentando o caractere de barra vertical, o primeiro item na lista na Figura

17/05 é representada pela substring:

 

"Todos os arquivos (*.*)|*.*"

 

 

 

 

212

 

NET Programação Visual Basic.

 

 

• Se um determinado item tem vários filtros, os filtros são separados por ponto e vírgula (;). O segundo item

na lista da Figura 5-17 é, portanto, representada por:

 

"Arquivos executáveis (*. exe, *. dll) | *. exe, *. dll"

 

• O valor a atribuir a propriedade Filter é a concatenação de todos os textos, assim

atingido, novamente, separados pelo caractere barra vertical. Portanto, o valor da propriedade Filter

que produziu a lista suspensa na Figura 5-17 é a seguinte:

 

"Todos os arquivos (*.*)|*.*| arquivos executáveis (*. exe, *. dll) | *. exe, *. dll"

 

O valor padrão da propriedade filtro é uma seqüência vazia, o que resulta em um vazio "Arquivos do tipo"

drop-down list.

 

A propriedade FilterIndex determina qual o filtro está em vigor quando a caixa de diálogo é mostrada inicialmente. Este

é um índice baseado em 1 que se refere à cadeia de filtro. Por exemplo, referindo-se novamente a Figura 5-17, se o

FilterIndex propriedade é definida como 1, o "All Files" item será selecionado quando a caixa de diálogo é mostrada. Se o

FilterIndex é definido como 2, o "Arquivos executáveis" item será mostrado. O valor padrão é 1.

 

5.4.4 PageSetupDialog

 

O componente PageSetupDialog exibe uma caixa de diálogo que permite ao usuário escolher as configurações de página

para um documento. Certas propriedades no objeto PageSetupDialog deve ser definida antes de mostrar a

caixa de diálogo. Após o usuário clicar em OK, as novas configurações podem ser lidos a partir do objeto. Consulte "Impressão" na

Capítulo 4 para mais detalhes. Figura 5-18 mostra um exemplo da caixa de diálogo PageSetupDialog.

 

Figura 5-18. A caixa de diálogo PageSetupDialog

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

5.4.5 PrintDialog

 

O componente PrintDialog exibe uma caixa de diálogo que permite ao usuário escolher as configurações da impressora para uma

documento. Certas propriedades no objeto PrintDialog deve ser definida antes de mostrar a caixa de diálogo.

Após o usuário clicar em OK, as novas configurações podem ser lidos a partir do objeto. Consulte "Imprimir" no Capítulo 4 para

detalhes. Figura 5-19 mostra um exemplo da caixa de diálogo PrintDialog.

 

 

213

 

 

 

 

Figura 5-19. A caixa de diálogo PrintDialog

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

5.4.6 PrintPreviewDialog

 

O componente PrintPreviewDialog exibe uma caixa de diálogo que permite ao usuário visualizar um documento

antes de imprimi-lo. Antes de mostrar a caixa de diálogo, o objeto PrintPreviewDialog deve ser carregado com

informações sobre o documento a ser impresso. Consulte "Imprimir" no Capítulo 4 para mais detalhes. A caixa de diálogo

se mostra um preview da versão impressa do documento, permitindo ao usuário navegar por ele.

Figura 5-20 mostra um exemplo da caixa de diálogo PrintPreviewDialog, embora este exemplo não

ter um documento carregado.

 

Figura 5-20. A caixa de diálogo PrintPreviewDialog

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

5.4.7 SaveFileDialog

 

O componente SaveFileDialog exibe uma caixa de diálogo que permite ao usuário especificar um nome de arquivo a ser

usado para salvar. Após o usuário clicar em OK, o nome do arquivo (incluindo o caminho) está disponível no

SaveFileDialog propriedade FileName do objeto (que pode ser definido antes de mostrar a caixa de diálogo). Este

faz com que a caixa de diálogo para exibir inicialmente o nome de arquivo dado. Figura 5-21 mostra um exemplo do

SaveFileDialog caixa de diálogo.

 

Figura 5-21. A caixa de diálogo SaveFileDialog

 

 

 

214

 

NET Programação Visual Basic.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Tal como acontece com o componente OpenFileDialog, a maioria dos aplicativos deve definir o InitialDirectory, Filtro e

propriedades FilterIndex antes de chamar ShowDialog. Seu uso com o componente SaveFileDialog é

precisamente o mesmo que com OpenFileDialog.

 

5,5 Menus

 

A biblioteca do Windows Forms fornece três componentes para a criação e gestão de menus:

 

• A classe MainMenu gerencia a exibição de um menu na parte superior de um formulário.

• A classe ContextMenu gerencia a exibição de um menu de contexto (também conhecido como um pop-up

menu).

• A classe MenuItem representa um item de menu específico dentro de um menu principal ou menu de contexto.

 

Menus podem ser criadas no Visual Studio. NET Windows Forms Designer ou programaticamente.

 

5.5.1 Adicionando menus no Visual Studio. NET Windows Forms

Designer

 

Visual Studio. NET inclui um editor de menu no local WYSIWYG que é uma melhoria dramática sobre

o editor de menu no Visual Basic 6. Para criar um menu de aplicativos no Windows Forms Designer, adicione

um componente MainMenu para o formulário. Isso faz com que uma representação do componente a aparecer no

painel inferior da vista de desenho do formulário. Quando o componente é selecionado, o Visual Studio. NET adiciona um

Editor WYSIWYG para o topo da forma, como mostrado na Figura 5-22.

 

Figura 5-22. No lugar de edição de um menu principal

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

215

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Para criar um item de menu, digite um valor para o "Type Here" caixa. O editor de menu adiciona automaticamente

"Type Here" caixas à direita e embaixo da caixa na qual você está digitando. Como foi o caso em

anteriores do Windows ambientes de desenvolvimento, digitando um e comercial (&) no nome do menu

faz com que o caractere após o comercial a ser uma tecla de atalho. Digitando um hífen (-)

dentro de um "Type Here" caixa cria uma barra separadora de menu. Figura 5-23 mostra um menu contendo

vários itens.

 

Figura 5-23. Um menu contendo diversos itens

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Depois de um item de menu tem sido adicionadas, suas propriedades podem ser definidas na janela Propriedades. As propriedades

janela do item Colar Editar mostrado na Figura 5-23 é mostrado na Figura 5-24.

 

Figura 5-24. A janela Propriedades de vídeo para o menu Editar Colar

item mostrado na Figura 5-23

 

 

 

 

 

 

 

 

 

 

 

 

 

216

 

NET Programação Visual Basic.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

As propriedades mostradas na Figura 5-24 são:

 

Verificados

 

Indica se uma marca de seleção aparece ao lado do item de menu. O tipo é Boolean. A

padrão é False.

 

DefaultItem

 

Indica se o item de menu é o item padrão em seu menu ou submenu. menu padrão

os itens são exibidos em negrito. O tipo é Boolean. O padrão é False.

 

Habilitado

 

Indica se o item de menu está ativado. Se isso é falso, o item de menu é cinza e

não podem ser selecionados. O tipo é Boolean. O padrão é True.

 

MdiList

 

Em aplicações MDI, indica se o item de menu deve ter subitens para cada um dos

formulários filho MDI abertos. Essa propriedade deve ser definida como True para o item de menu do Windows. A

tipo é Boolean. O padrão é False.

 

MergeOrder

 

Em aplicações onde dois menus podem ser mescladas (como um aplicativo MDI, onde uma criança

menu formulário pode ser mesclado com o seu menu formulário pai), classifica os itens de menu baseado mesclado

sobre essa propriedade. O tipo é Integer. O padrão é 0. Consulte "Aplicativos MDI" no Capítulo 4 para

mais informações.

 

MergeType

 

Indica como dois itens de menu com o valor MergeOrder mesmos deveriam ser fundidas. A

valor é do tipo MenuMerge (definido no namespace System.Windows.Forms). O padrão

é MenuMerge.Add. Consulte "Aplicativos MDI" no Capítulo 4 para obter mais informações.

 

 

217

 

 

 

 

Modificadores

 

Especifica os modificadores de declaração de que são colocados na declaração do campo menu item dentro

o código gerado. Esta não é realmente uma propriedade da classe MenuItem. Pelo contrário, torna-se

parte da declaração de campo no código fonte. O padrão é privado.

 

OwnerDraw

 

Indica se o item de menu requer desenho personalizado. Se você definir essa propriedade como True,

você deve manipular o evento do item de menu DrawItem. O tipo é Boolean. O padrão é False.

 

RadioCheck

 

Se a propriedade Checked é True, indica se para exibir a marca como um botão de rádio

em vez disso. O tipo é Boolean. O padrão é False.

 

Atalho

 

Especifica a combinação de teclas de atalho que chama o menu. O valor é do tipo

Atalho (definido no namespace System.Windows.Forms). A enumeração de atalho

define um único valor para cada combinação de atalho de chave. Os valores dos atalhos

enumeração são apresentados na Tabela 5-1. O padrão é Shortcut.None.

 

 

Tabela 5-1. Valores definidos pela System.Windows.Forms.Shortcut

enumeração

 

Nenhum

F2

F6

F10

ShiftDel

ShiftF4

ShiftF8

ShiftF12

CtrlB

CtrlF

CtrlJ

CtrlN

CTRLR

CtrlV

CtrlZ

CtrlF4

CtrlF8

CtrlF12

CtrlShiftD

CtrlShiftH

CtrlShiftL

CtrlShiftP

CtrlShiftT

CtrlShiftX

CtrlShiftF2

 

 

218

 

Ins

F3

F7

F11

ShiftF1

ShiftF5

ShiftF9

CtrlIns

CtrlC

CtrlG

CtrlK

CtrlO

CtrlS

CtrlW

CtrlF1

CtrlF5

CtrlF9

CtrlShiftA

CtrlShiftE

CtrlShiftI

CtrlShiftM

CtrlShiftQ

CtrlShiftU

CtrlShiftY

CtrlShiftF3

 

Del

F4

F8

F12

ShiftF2

ShiftF6

ShiftF10

CtrlDel

CTRLD

CtrlH

CtrlL

CtrlP

CtrlT

CtrlX

CtrlF2

CtrlF6

CtrlF10

CtrlShiftB

CtrlShiftF

CtrlShiftJ

CtrlShiftN

CtrlShiftR

CtrlShiftV

CtrlShiftZ

CtrlShiftF4

 

F1

F5

F9

ShiftIns

ShiftF3

ShiftF7

ShiftF11

CtrlA

CtrlE

CtrlI

CtrlM

CtrlQ

CtrlU

CtrlY

CtrlF3

CtrlF7

CtrlF11

CtrlShiftC

CtrlShiftG

CtrlShiftK

CtrlShiftO

CtrlShiftS

CtrlShiftW

CtrlShiftF1

CtrlShiftF5

 

 

 

 

 

CtrlShiftF6

 

NET Programação Visual Basic.

 

 

CtrlShiftF7 CtrlShiftF8

 

 

 

 

CtrlShiftF9

 

CtrlShiftF10

AltF1

AltF5

AltF9

ShowShortcut

 

CtrlShiftF11

AltF2

AltF6

AltF10

 

CtrlShiftF12

AltF3

AltF7

AltF11

 

AltBksp

AltF4

AltF8

AltF12

 

 

 

 

 

Texto

 

 

 

 

Visível

 

 

Se a combinação de teclas de atalho está definido para o item de menu, indica se a chave

associação deve ser mostrado no menu. O tipo é Boolean. O padrão é True.

 

 

 

Representa o texto que aparece no item de menu. O tipo é String. O padrão é um vazio

string.

 

 

 

Indica se o item de menu deve estar visível. O tipo é Boolean. O padrão é True.

 

 

O Windows Forms Designer cria código que declare um campo para o objeto MainMenu, bem como

campos para os objetos MenuItem que representa cada item de menu no menu. O designer também cria

código que instancia os objetos em tempo de execução e define suas propriedades de acordo com os valores fixados no

janela Propriedades do IDE. Além disso, os objetos MenuItem de nível superior são adicionados ao MenuItems

objetos MenuItem coleção do objeto MainMenu, e os de baixo nível são adicionados ao MenuItems

cobrança do menu de que são submenus. Finalmente, o objeto MainMenu é atribuído ao

propriedade formulário Menu.

 

Para criar um menu de contexto do Windows Forms Designer, adicionar um componente ContextMenu para o formulário.

Isso faz com que uma representação do componente a aparecer na parte inferior do painel de vista de design do formulário.

Quando o componente é selecionado, o Visual Studio. NET adiciona um editor WYSIWYG para o topo da forma.

Clicando sobre o editor desce um "Type Here" de caixa, como mostrado na Figura 5-25.

 

Figura 5-25. No lugar de edição de um menu de contexto

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Adicionando itens de menu e configurar suas propriedades o mesmo trabalho com menus de contexto como com os principais

menus. Para um menu de contexto a ser exibido, ele deve ser associado com algum controle sobre a forma ou

com o próprio formulário. Quando o usuário clica no botão direito do que o controle ou formulário, o menu de contexto é exibido.

Para fazer essa associação, execute essas etapas:

 

1. No Windows Forms Designer, clique com o botão de controle ou formulário que deve ser associado com o

menu de contexto, e escolha Propriedades.

 

 

 

 

219

 

 

 

 

 

2. Na janela Propriedades, localize a propriedade ContextMenu, e clique na seta do drop-down

lista de associados.

3. O drop-down exibe os objetos ContextMenu que são definidos no formulário atual.

Escolha o pretendido.

 

O mesmo efeito pode ser conseguido no código atribuindo o objeto ContextMenu para o ContextMenu

propriedade de um controle ou formulário, como este:

 

'Em algum lugar dentro da definição de uma classe de formulário.

Me.Button1.ContextMenu Me.ContextMenu1 =

 

5.5.2 programática Criando Menus

 

menus principais e menus de contexto pode ser instanciado e preenchido diretamente no código. Exemplo 5-2

mostra como criar um simples menu principal, tendo Arquivo e Editar itens, com o item Ficheiro ter uma saída

item. Compilar a partir da linha de comando com o comando:

 

filename.vb vbc / r: System.dll, System.Drawing.dll System.Windows.Forms.dll

/ T: winexe

 

O código no Exemplo 5-2 é semelhante ao código que será criado pelo Windows Forms

Designer, se seu editor menu visual, foram usados para criar este menu. Os passos essenciais são:

 

1. Declare um objeto MainMenu para representar o menu.

2. Declare um objeto MenuItem para cada item do menu.

3. Instanciar o objeto MainMenu e todos os objetos MenuItem.

4. Defina as propriedades dos objetos MenuItem (tais como a propriedade Text), como desejado.

5. Adicionar os objetos MenuItem de nível superior para a coleção MenuItems do objeto MainMenu, em seguida,

adicionar os objetos MenuItem de nível inferior para a coleção MenuItems do objeto MenuItem

sob as quais eles devem aparecer.

 

Exemplo 5-2. Criando um menu principal em código

Imports System.Drawing

Imports System.Windows.Forms

 

modMain Módulo

   Sub <System.STAThreadAttribute( )> Pública Main ()

      System.Threading.Thread.CurrentThread.ApartmentState _ =

         System.Threading.ApartmentState.STA

      System.Windows.Forms.Application.Run (New Form1 ())

   End Sub

End Module

 

Public Class Form1

   Formulário Inherits

 

   'Declare o componente de menu principal.

   Atalhos e privadas, como MainMenu

 

   'Declare os itens do menu que vai estar no menu. Use o

   'WithEvents palavra-chave para que os manipuladores de eventos podem ser adicionados posteriormente.

   WithEvents privados mnuFile Como MenuItem

   WithEvents privados mnuFileExit Como MenuItem

   WithEvents privados mnuEdit Como MenuItem

 

   Sub New Public ()

 

      'Instanciar o objeto menu.

 

 

220

 

NET Programação Visual Basic.

 

 

      Atalhos = New MainMenu ()

      mnuFile = Novo MenuItem ()

      mnuFileExit = Novo MenuItem ()

      mnuEdit = Novo MenuItem ()

 

      "Definir as propriedades dos itens do menu.

      mnuFile.Text = "& Arquivo"

      mnuFileExit.Text = "& Sair"

      mnuEdit.Text = "Editar"

 

      'Ligar os itens de menu para si e para o menu principal.

      mnuFile.MenuItems.Add (mnuFileExit)

      myMenu.MenuItems.Add (mnuFile)

      myMenu.MenuItems.Add (mnuEdit)

 

      'Conectar no menu principal para o formulário.

      Me.Menu Atalhos =

 

   End Sub

 

End Class

 

5.5.3 Menu Tratamento de eventos

 

A interação do usuário com um menu faz com que os eventos de menu a ser demitido. O evento menu mais comum é a

Clique em evento da classe MenuItem, que é acionado quando um usuário clica em um item de menu. Aqui está um exemplo de

um manipulador de evento Click (este código pode ser adicionado à classe Form1 do Exemplo 5-2):

 

Private Sub mnuFileExit_Click (_

   ByVal sender As Object, _

   ByVal e As EventArgs _

) Handles mnuFileExit.Click

   Me.Close ()

End Sub

 

Os eventos da classe MenuItem são os seguintes:

 

Clique

 

Acionado quando o item de menu é escolhido clicando com o mouse ou pressionando uma

combinação de teclas de atalho definidas para o item de menu. A sintaxe do evento Click é:

 

Clique Público de eventos como System.EventHandler

 

Isso é equivalente a:

 

Clique Evento Público (ByVal sender As Object, ByVal e As

System.EventArgs)

Eliminados

 

Acionado quando o método do objeto MenuItem de Dispose é chamado. A sintaxe do Disposto

evento é:

 

Evento Público descartados como System.EventHandler

 

Isso é equivalente a:

 

Evento Público Disposed (ByVal

 

 

221

 

 

 

 

sender As Object, ByVal

e As System.EventArgs)

 

O evento é herdado da classe Component.

 

DrawItem

 

Acionado quando o item de menu deve ser feita, quando o objeto MenuItem é OwnerDraw

propriedade é True. A sintaxe do evento DrawItem é:

 

Público DrawItem eventos como System.Windows.Forms.DrawItemEventHandler

 

Isso é equivalente a:

 

Público DrawItem evento (_

   ByVal sender As Object, _

   ByVal e As _ System.Windows.Forms.DrawItemEventArgs

)

 

O parâmetro e, de DrawItemEventArgs tipo, fornece informações adicionais que é necessário

para desenhar o item de menu. As propriedades da classe DrawItemEventArgs são:

 

BackColor

 

A cor de fundo que deve ser usado na elaboração do item. O tipo é da cor (definida

no namespace System.Drawing).

 

Bounds

 

O retângulo do item de menu. O tipo é retângulo (definido no

Espaço para nome System.Drawing).

 

Fonte

 

A fonte que deve ser usado na elaboração do item. O tipo é Fonte (definido no

Espaço para nome System.Drawing).

 

ForeColor

 

A cor de primeiro plano que deve ser usado na elaboração do item. O tipo é da cor (definida em

namespace System.Drawing).

 

Gráficos

 

A superfície do gráfico sobre o que desenhar o item. O tipo é Graphics (definido no

Espaço para nome System.Drawing).

 

Índice

 

O índice do item de menu no seu menu principal. O tipo é Integer.

 

Estado

 

O estado do item de menu. O tipo é DrawItemState (definido no

System.Windows.Forms namespace). DrawItemState é uma enumeração que define o

 

 

 

222

 

NET Programação Visual Basic.

 

 

Nenhum valores, selecionados, desabilitadas, condicionada, Quadriculado, Focus, Padrão, HotLight,

Inativo, NoAccelerator, NoFocusRect, e ComboBoxEdit.

 

MeasureItem

 

Demitido antes de disparar o evento DrawItem quando a propriedade do objeto MenuItem é OwnerDraw é

True. O evento MeasureItem permite ao cliente especificar o tamanho do item a ser desenhado.

A sintaxe do evento MeasureItem é:

 

Público MeasureItem eventos como

System.Windows.Forms.MeasureItemEventHandler

 

Isso é equivalente a:

 

Público MeasureItem evento (_

   ByVal sender As Object, _

   ByVal e As _ System.Windows.Forms.MeasureItemEventArgs

)

 

O parâmetro e, de MeasureItemEventArgs tipo, fornece informações adicionais necessárias pelo

o manipulador de eventos e oferece os campos que o manipulador de eventos pode ser configurado para comunicar o item

tamanho do objeto MenuItem. As propriedades do MeasureItemEventArgs são:

 

Gráficos

 

O dispositivo de elementos gráficos em que o item de menu será elaborado. Isso é necessário para que o cliente pode

determinar a escala do dispositivo sobre o qual o item de menu será processado. O tipo é

Graphics (definido no namespace System.Drawing).

 

Índice

 

O índice do item de menu no seu menu principal. O tipo é Integer.

 

ItemHeight

 

A altura do item de menu. O tipo é Integer.

 

ItemWidth

 

A largura do item de menu. O tipo é Integer.

 

Popup

 

Acionado quando o submenu está prestes a ser apresentado, quando um item de menu possui subitens associados

com ele. Isto proporciona ao cliente uma oportunidade para definir os estados do menu (marcado, habilitado

etc) dos itens do submenu para coincidir com o estado actual programa. A sintaxe do evento Popup

é o seguinte:

 

Público do evento Popup Como System.EventHandler

 

Isso é equivalente a:

 

Evento Público Popup (ByVal sender As Object, ByVal e As

System.EventArgs)

Selecione

 

 

 

223

 

 

 

 

Acionado quando o usuário coloca o mouse sobre o item de menu ou quando o usuário destaca o

item de menu, navegando até ele com as setas do teclado. A sintaxe do evento select é:

 

Evento Público Escolha como System.EventHandler

 

Isso é equivalente a:

 

Evento Público Escolha (ByVal sender As Object, ByVal e As

System.EventArgs)

 

A classe ContextMenu também expõe um evento de pop-ups, que é acionado imediatamente antes do menu de contexto é

exibida. A sintaxe do evento pop-up é:

 

Público do evento Popup Como System.EventHandler

 

Isso é equivalente a:

 

Evento Público Popup (ByVal sender As Object, ByVal e As System.EventArgs)

 

5.5.4 Menus Clonagem

 

Às vezes, os itens de menu e seus submenus devem aparecer em mais de um menu. Um comum

exemplo é um aplicativo que tem menus de contexto contendo algumas das mesmas funcionalidades como o

menu principal da aplicação. No entanto, objetos MenuItem não funcionam corretamente se forem atribuídas a mais

de um menu. Para dar uma solução fácil para os desenvolvedores que precisam duplicar a funcionalidade de

vários menus, a classe MenuItem fornece o método CloneMenu. Esse método retorna uma nova

MenuItem objeto cujas propriedades são definidas as mesmas que as do objeto MenuItem em que o

CloneMenu método é chamado. Se o objeto MenuItem original tem submenus, o MenuItem submenu

objetos são clonados também.

 

Exemplo 5-3 mostra o código completo para um programa que tem tanto um menu principal e um contexto

menu. Ele pode ser compilado a partir da linha de comando com o comando:

 

filename.vb vbc / r: System.dll, System.Drawing.dll System.Windows.Forms.dll

/ T: winexe

 

O código no Exemplo 5-3 configura um item de menu rotulado formato que tem quatro opções por baixo: Fonte,

ForeColor, BackColor e Reset. Após essa estrutura do menu é configurado, ele é adicionado ao MainMenu

objeto, que é então anexado ao formulário, como mostrado aqui:

 

MainMenu1.MenuItems.Add (mnuFormat)

Menu MainMenu1 =

 

Uma estrutura idêntica menu é então criada e atribuída ao objeto ContextMenu, que é então

anexado ao controle Label1, conforme mostrado aqui:

 

ContextMenu1.MenuItems.Add (mnuFormat.CloneMenu ())

Label1.ContextMenu contextMenu1 =

 

O método CloneMenu detecta até os manipuladores de eventos que estão definidos para o MenuItems sendo

clonados e registra automaticamente os manipuladores de eventos com o correspondente no recém-criado

objetos MenuItem. Isto significa que os manipuladores de eventos mostrado no Exemplo 5-3 manipular os eventos tanto

a partir do menu principal e no menu de contexto. Figura 5-26 mostra o aplicativo em execução com o

menu de contexto exibido (o controle Label foi clicado direita).

 

Figura 5-26. A exposição produzida por Exemplo 5-3

 

 

224

 

NET Programação Visual Basic.

 

 

 

 

 

 

 

 

 

 

 

Exemplo 5-3. Clonagem menus

Imports System

Imports System.Drawing

Imports System.Windows.Forms

 

modMain Módulo

   Sub <STAThreadAttribute( )> Pública Main ()

      System.Threading.Thread.CurrentThread.ApartmentState _ =

         System.Threading.ApartmentState.STA

      Application.Run (New Form1 ())

   End Sub

End Module

Public Class Form1

   Formulário Inherits

 

   "Este referências membro do rótulo utilizado para exibir texto.

   Private Label WithEvents Label1 Como Novo ()

 

   "Esses membros armazenar fonte original e as propriedades de cor da

   "Controle Label1.

   origFont privado como fonte

   origForeColor e privadas, como de cor

   origBackColor e privadas, como de cor

 

   "Esses membros na posse dos objectos MainMenu e ContextMenu.

   Private WithEvents MainMenu1 Como MainMenu New ()

   Private WithEvents contextMenu1 Como ContextMenu New ()

 

   "Esses membros segurar a objetos MenuItem.

   mnuFormat WithEvents Privado como novo MenuItem ()

   mnuFormatFont WithEvents Privado como novo MenuItem ()

   mnuFormatForeColor WithEvents Privado como novo MenuItem ()

   mnuFormatBackColor WithEvents Privado como novo MenuItem ()

   mnuSeparator Privado como novo MenuItem ()

   WithEvents privados mnuFormatReset como novo MenuItem ()

 

   Sub New Public ()

      MyBase.New ()

 

      'Menu Configure o formato.

 

      mnuFormat.Text "F & ormat" =

      mnuFormatFont.Text = "& Fonte ..."

      mnuFormatForeColor.Text "F & oreColor ..."

      mnuFormatBackColor.Text = "BackColor ..."

      mnuSeparator.Text = "-"

      mnuFormatReset.Text = "Reset"

      mnuFormat.MenuItems.AddRange (Nova MenuItem () {mnuFormatFont, _

         mnuFormatForeColor, mnuFormatBackColor mnuSeparator, _

         mnuFormatReset})

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

225

 

 

 

 

 

      "Prenda o menu Formatar para o menu principal e anexar os principais

      'Menu para o formulário.

 

      MainMenu1.MenuItems.Add (mnuFormat)

      Menu MainMenu1 =

 

      'Clone no menu Formatar, anexar o clone para o menu de contexto, e

      "Anexar o menu de contexto para o controle Label.

 

      ContextMenu1.MenuItems.Add (mnuFormat.CloneMenu ())

      Label1.ContextMenu contextMenu1 =

 

      "Configurar propriedades não relacionadas com menu do formulário e da etiqueta.

      AutoScaleBaseSize Tamanho = Novo (5, 13)

      ClientSize Tamanho = Nova (312, 81)

      Controls.Add (Label1)

      Menu MainMenu1 =

      Name = "Form1"

      Text = "Menu Clonagem Test"

      Label1.Text = "algum texto Display"

      Label1.AutoSize = True

 

      "Salvar a fonte original e propriedades de cor do controle Label1.

      origFont = Label1.Font

      origForeColor = Label1.ForeColor

      origBackColor = Label1.BackColor

 

   End Sub

 

   'Font Clique manipulador de eventos

   Private Sub mnuFormatFont_Click (_

      ByVal sender As Object, _

      ByVal e As EventArgs _

   ) Handles mnuFormatFont.Click

      Dim dlg Como FontDialog New ()

      dlg.Font = Label1.Font

      Se DialogResult.OK dlg.ShowDialog = Em seguida,

         Label1.Font dlg.Font =

      End If

      dlg.Dispose ()

   End Sub

 

   "ForeColor Clique manipulador de eventos

   Private Sub mnuFormatForeColor_Click (_

      ByVal sender As Object, _

      ByVal e As EventArgs _

   ) Handles mnuFormatForeColor.Click

      Dim dlg Como ColorDialog New ()

      dlg.Color = Label1.ForeColor

      Se DialogResult.OK dlg.ShowDialog = Em seguida,

         Label1.ForeColor dlg.Color =

      End If

      dlg.Dispose ()

   End Sub

 

   'BackColor Clique manipulador de eventos

   Private Sub mnuFormatBackColor_Click (_

      ByVal sender As Object, _

      ByVal e As EventArgs _

   ) Handles mnuFormatBackColor.Click

 

 

226

 

NET Programação Visual Basic.

 

 

      Dim dlg Como ColorDialog New ()

      dlg.Color = Label1.BackColor

      Se DialogResult.OK dlg.ShowDialog = Em seguida,

         Label1.BackColor dlg.Color =

      End If

      dlg.Dispose ()

   End Sub

 

   "Resent Clique manipulador de eventos

   Private Sub mnuFormatReset_Click (_

      ByVal sender As Object, _

      ByVal e As EventArgs _

   ) Handles mnuFormatReset.Click

      Label1.Font origFont =

      Label1.ForeColor origForeColor =

      Label1.BackColor origBackColor =

   End Sub

 

End Class

 

5,6 Criando um Controle

 

Um controle é um componente com uma representação visual. A biblioteca do Windows Forms fornece a classe

funcionalidade básica de controles por meio da classe Control (definido no System.Windows.Forms

namespace). Todos os controles derivam direta ou indiretamente da classe Control. Além disso, o Windows

Forms fornece uma classe chamada UserControl com o propósito de torná-lo fácil de escrever controle personalizado

classes. A derivação da classe UserControl é mostrado na Figura 5-27.

 

Figura 5-27. A hierarquia de derivação da classe UserControl

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

5.6.1 Controles de Construção de outros controles

 

A maneira mais fácil criar um novo controle é de agregar e modificar a funcionalidade de um ou mais

controles existentes. Para fazer isso no Visual Studio. NET Windows Forms Designer, faça o seguinte

etapas:

 

Escolha Adicionar Projeto de Controle do Usuário no menu principal.
2. Digite o nome do arquivo vb. Que conterá o código para o controle, e clique em OK. O designer
exibe um controle de usuário em branco no modo de design, como mostrado na Figura 5-28.

Figura 5-28. Um controle de usuário em branco no Visual Studio. NET Windows
Forms Designer





227
 
















3. Adicionar controles a partir da janela Toolbox exatamente como faria ao colocar para fora um formulário. Os controles que
fazem parte integrante de outro controle são chamados controles constituintes. Figura 5-29 mostra um usuário
controle que tem dois controles constituintes: um Label e um TextBox.

Figura 5-29. Um controle de usuário com dois controles constituintes






O controle de usuário mostrado na Figura 5-29 é um bom começo em uma caixa de texto de controle de um texto-legenda
caixa que carrega em torno de sua própria legenda. Estes passos adicionais também seria útil:

a. Defina o controle Label AutoSize para True para que o rótulo se expande para o tamanho
necessários para a exibição de seu texto.
b. Dock do controle Label para o lado esquerdo do controle de usuário. Isso permite que o TextBox
controle para ser encaixado ao controle Label. O benefício de encaixe do controle TextBox
para o controle Label é que o controle TextBox irá mover sempre que o controle Label
redimensionado.
c. Dock do controle TextBox para preencher o restante do espaço.
4. Adicione as propriedades adequadas para o controle do usuário. Isso pode envolver propriedades imperiosa
herdadas de classes base ou criar novas propriedades. Para o controle da legenda de caixa de texto do usuário,
faça o seguinte:
a. Substituir a propriedade Text. O objetivo dessa propriedade é permitir que o cliente
ambiente para definir e ler o texto exibido no controle TextBox componente.
Aqui está o código:
 
b.
c.
d.
e.
f.
g.
h.
 
Texto Propriedade Pública substituições () As String
Obter
   txtText.Text Retorno
End Get
Set (ByVal Value As String)
   txtText.Text = Valor
Definir Fim
End Property

Como pode ser visto a partir do código, a propriedade do controle de usuário de texto é simplesmente mapeados para
propriedade do controle TextBox texto.
 

i. Criar uma nova propriedade para definir o texto da legenda. Aqui está o código:
 









228
 
j.
k.
l.
m.
n.
o.
p.
 
Público Propriedade Caption () As String
Obter
   lblCaption Return (). Texto
End Get
Set (ByVal Value As String)
   lblCaption (). Texto = Valor
Definir Fim
 
 
NET Programação Visual Basic.


End Property

Neste caso, a propriedade Caption é mapeada para a propriedade do controle Label de texto.

5. Adicione quaisquer eventos apropriados para o controle do usuário. Isso pode envolver invocando eventos da classe base
ou criar e invocar novos eventos. Para o controle da legenda de caixa de texto do usuário, faça o seguinte:
a. Adicione um manipulador de propriedade TextChanged do controle TextBox Constituinte. Dentro do
manipulador, chamar o evento TextChanged classe base. Aqui está o código:
 
b.
c.
d.
e.
f.
 
Private Sub txtText_TextChanged (_
   ByVal sender As Object, _
   ByVal e As EventArgs _
) Handles txtText.TextChanged
   Me.OnTextChanged (e)
End Sub

Observe que esse código chama o método OnTextChanged, que é declarada no
Controle de classe. O objetivo deste método é a ocorrência do evento TextChanged, que é
também declarados na classe de controle (Visual Basic. NET não fornecem uma maneira de um incêndio
evento de classe base diretamente.) Existem métodos OnEventName para cada um dos eventos
definida na classe Control.

O método OnTextChanged é substituível. Se você substituí-lo em sua classe derivada,
certeza de que o método de substituição chamadas MyBase.OnTextChanged. Se não o fizer, o
evento TextChanged não será demitido.
 

g. Declare um novo evento para notificar o cliente quando a propriedade do controle de usuário legenda é
alterado. Nome do evento CaptionChanged. Adicionar um manipulador para o controle Label
TextChanged evento e aumentar o evento CaptionChanged de lá. Aqui está o código:
 
h.
i.
j.
k.
l.
m.
n.
 
Evento CaptionChanged Como EventHandler

Private Sub lblCaption_TextChanged (_
   ByVal sender As Object, _
   ByVal e As EventArgs _
) Handles lblCaption.TextChanged
   RaiseEvent CaptionChanged (Me, EventArgs.Empty)
End Sub

Observe os argumentos para o evento CaptionChanged. O valor me é passado como o
remetente do evento, e EventArgs.Empty é passada como argumentos do evento. A
Campo vazio da classe EventArgs retorna um novo objeto EventArgs vazia.
 

6. Adicione os atributos adequados para os elementos da sintaxe da classe. Por exemplo, a legenda
propriedade vai beneficiar de ter um atributo de categoria e um atributo de descrição, como mostrado na
negrito aqui:
7.
8. <Categoria ("Aparência"), _
9. Description ("O texto que aparece ao lado da caixa de texto.")>
_
10. Public Property _
11. Caption () As String
12. Obter
13. lblCaption Return (). Texto
14. End Get
15.
Set (ByVal Value As String)
16. lblCaption (). Texto = Valor
17. Definir Fim
End Property

Esses atributos são compilados em código e são captados pelo Visual Studio. NET.
O atributo da categoria determina em qual categoria o imóvel irá aparecer na


229
 
 



Propriedades janela. O atributo Descrição determina o texto da ajuda que será exibida
na janela Propriedades quando o usuário clica sobre essa propriedade. Consulte "Atributos Component" em
Capítulo 4 para uma lista de atributos definidos no namespace System.ComponentModel.

Isso tudo é muito semelhante à criação de formulários. Como com formulários, controles personalizados podem ser definidas diretamente no código.
Exemplo 5-4 mostra uma definição de classe completa para o controle caixa de texto-legenda, criado sem a
ajuda do Windows Forms Designer. Ele pode ser compilado a partir da linha de comando com o comando:

filename.vb vbc / r: System.dll, System.Drawing.dll System.Windows.Forms.dll
/ T: library

(Nota do / t:... Switch biblioteca para criar uma DLL ao invés de um arquivo exe)

Exemplo 5-4. Uma classe de controle personalizado
Imports System
Imports System.ComponentModel
Imports System.Drawing
Imports System.Windows.Forms

Público myControl Classe
   Inherits UserControl

   lblCaption WithEvents Private Label como
   txtText WithEvents e privadas, como TextBox
   Evento CaptionChanged Como EventHandler

   Sub New Public ()
      MyBase.New ()

      'Instanciar um objeto Label e defina suas propriedades.
      
lblCaption = New Label ()
      Com lblCaption
         . AutoSize = True
         . Dock = DockStyle.Left
         .
Size = Tamanho Nova (53, 13)
         . TabIndex = 0
         . Text = "lblCaption"
      End With
      'Criar um objeto TextBox e definir suas propriedades.
      
txtText = New TextBox ()
      Com txtText
         . Dock DockStyle.Fill =
         . Situação = New Point (53, 0)
         .
Size = Tamanho Nova (142, 20)
         . TabIndex = 1
         . Text = "txtText"
      End With

      »Adicionar a caixa de rótulo e texto para a coleção Controls do formulário.
      Me.Controls.AddRange (New Control () {txtText lblCaption,})

      "Definir o tamanho do formulário.
      Me.Size Tamanho = Nova (195, 19)

   End Sub

   "Substituir a propriedade da classe Control texto. Mapa-lo para o


230
 
NET Programação Visual Basic.


   «Propriedade do controle TextBox componente de texto.
   <Categoria ("Aparência"), _
   Description ("O texto contido na caixa de texto.")> _
   Texto Propriedade Pública substituições () As String
   Obter
      txtText.Text Retorno
   End Get
   Set (ByVal Value As String)
      txtText.Text = Valor
   Definir Fim
   End Property

   "Adicionar uma propriedade Legenda. Mapa-lo para o componente Label
   «Propriedade do controle Text.
   <Categoria ("Aparência"), _
   Description ("O texto que aparece ao lado da caixa de texto.")> _
   Public Property _
      Caption () As String
   Obter
      lblCaption.Text Retorno
   End Get
   Set (ByVal Value As String)
      lblCaption.Text = Valor
   Definir Fim
   End Property

   "Quando o evento TextChanged do controle TextBox componente é
   'Recebidos, acionar o evento TextChanged do controle de usuário.
   Private Sub txtText_TextChanged (_
      ByVal sender As Object, _
      ByVal e As EventArgs _
   ) Handles txtText.TextChanged
      Me.OnTextChanged (e)
   End Sub

   "Quando o evento TextChanged do controle Label constituinte é
   'Recebidos, acionar o evento CaptionChanged o controle do usuário.
   Private Sub lblCaption_TextChanged (_
      ByVal sender As Object, _
      ByVal e As EventArgs _
   ) Handles lblCaption.TextChanged
      RaiseEvent CaptionChanged (Me, EventArgs.Empty)
   End Sub

End Class

Depois de compilar o código no Exemplo 5-4, ou o controle personalizado pode ser adicionado ao Visual
Studio. Toolbox NET e acrescentou às formas como outros controles, ou ele pode ser referenciado e
instanciado a partir de um aplicativo compilado na linha de comando.

Para adicionar o controle personalizado para a caixa de ferramentas do Visual Studio. NET:

1. Implantar o controle personalizado do arquivo. Dll no diretório do aplicativo cliente bin. (O diretório bin
é um diretório criado pelo Visual Studio. NET quando a aplicação cliente é criado.)
2. A partir do menu Visual Studio. NET, selecione Ferramentas Customize Toolbox. A Personalize
Caixa de ferramentas caixa de diálogo aparece, como mostrado na Figura 5-30.

Figura 5-30. A caixa de diálogo Personalizar caixa de ferramentas




231
 



























3. Clique na guia. NET Framework Components, clique no botão Procurar.
4. Procure e selecione o arquivo dll. Compilado a partir do código do Exemplo 5-4.
5. Os controles no arquivo dll. São adicionados à caixa de diálogo Personalizar caixa de ferramentas, como mostrado na
Figura 5-31. (Neste caso só há um controle na dll. Controlam os myControl).

Figura 5-31. Adicionando um controle para a caixa de diálogo Customize Toolbox

























6. Certifique-se que aparece uma marca junto ao nome do controle, e clique em OK.

O controle deve aparecer na guia Geral da janela de ferramentas, como mostrado na Figura 5-32.

Figura 5-32. A janela Toolbox, mostrando o controle personalizado a partir de
Exemplo 5-4



232
 
NET Programação Visual Basic.

















Depois de adicionar o controle personalizado para a caixa de ferramentas, o controle pode ser adicionado a uma forma como qualquer outro
controle.

. Para usar o controle personalizado a partir de um não Visual Studio NET, estes passos são necessários:

1. Implantar o controle personalizado do arquivo. Dll no mesmo diretório como o cliente. Vb.
2. Declarar, instanciar e usar o controle no código do aplicativo cliente, da mesma forma que tem
sido feito ao longo deste capítulo para controles padrão.
3. montagem de Referência controlar o no comando de compilação.

O código no Exemplo 5-5 mostra como usar o controle. Ele pode ser compilado com o comando:

MyApp.vb vbc
/ R: System.dll, System.Windows.Forms.dll, System.Drawing.dll MyControl.dll
/ T: winexe

(Note que o comando deve ser digitado em uma única linha.)

Exemplo 5-5. Usando um controle personalizado
Imports System.Drawing
Imports System.Windows.Forms

modMain Módulo
   Sub <System.STAThreadAttribute( )> Pública Main ()
      System.Threading.Thread.CurrentThread.ApartmentState _ =
         System.Threading.ApartmentState.STA
      System.Windows.Forms.Application.Run (New Form1 ())
   End Sub
End Module

Public Class Form1
   Inherits System.Windows.Forms.Form

   ctrl Privado como novo myControl ()

   Sub New Public ()
      ctrl.Caption = "Esta é a legenda."
      
ctrl.Text = "Este é o texto."
      Controls.Add (ctrl)
   End Sub

End Class

A tela resultante é mostrado na Figura 5-33.


233
 



Figura 5-33. Usando um controle personalizado




5.6.2 Controles de construção que se atraem

Adicionando controles constituintes de um controle de usuário é apenas uma maneira de fazer um controle personalizado. Outra forma é
para desenhar a interface do usuário do controle diretamente na superfície do controle. Exemplo 5-6 mostra a
definição de um controle que chama a si próprio (embora simples) interface de usuário. Figura 5-34 mostra o controle
depois de ter sido colocado em um formulário no modo de design no Windows Forms Designer.

Exemplo 5-6. Um controle que torna-se
Público myControl Classe
   Inherits UserControl

   Protegido substituições OnPaint Sub (ByVal e As PaintEventArgs)
      e.Graphics.FillEllipse (New SolidBrush (Me.ForeColor), _
         Me.ClientRectangle)
   End Sub

   Sub New Public ()
      Me.ResizeRedraw = True
   End Sub

End Class

Figura 5-34. O controle myControl como ele aparece em um formulário no
Windows Forms Designer





















O controle neste exemplo substitui o método OnPaint declarados na classe de controle. Windows
invoca o método OnPaint sempre que o controle precisa de pintura. O objeto PaintEventArgs
passados para o método OnPaint fornece informações úteis no âmbito do método OnPaint. A
tipo PaintEventArgs foi discutido em detalhes no Capítulo 4 na Secção 4.6. O método OnPaint
no Exemplo 5-6 desenha uma elipse dimensionada para preencher a área cliente do controle.

Definindo a propriedade do controle ResizeRedraw como True faz com que o método OnPaint para ser chamado
sempre que o controle é redimensionado. Porque a aparência do controle no Exemplo 5-6 depende


234
 
NET Programação Visual Basic.


o tamanho do controle, o construtor do controle define a propriedade como True ResizeRedraw. Quando
ResizeRedraw for False (o padrão), o redimensionamento do controle não faz com que o método OnPaint para ser
chamado.

Embora o código do Exemplo 5-6 foi construído à mão, o método OnPaint também podem ser adicionados (por
mão) para o código construído pelo Windows Forms Designer. Além disso, as técnicas de utilização
controles constituintes e desenhar diretamente sobre o controle de usuário podem ser usados dentro do mesmo usuário
controle.

5.6.3 Construindo Controles não retangulares

Os controles do usuário são retangulares por padrão, mas os controles com outras formas podem ser feitas pela configuração de
propriedade de controle da Região. A propriedade Region aceita um valor de tipo de região (definido no
Espaço para nome System.Drawing). Objetos da Região tipo de definição de áreas complexas e são comumente usados
para a janela de recorte. Considere novamente Exemplo 5-6 e Figura 5-34. Observe na Figura 5-34 que a
pontos de grade no formulário não mostrar através do fundo do controle. Exemplo 5-7 mostra como
clip da área do controle para coincidir com a elipse sendo desenhada no método OnPaint. Baseia-se em
Exemplo 5-6, com o novo código mostrado em negrito.

Exemplo 5-7. Clipping da área de um controle
"Assume Imports System.Drawing.Drawing2D
Público myControl Classe
   Inherits UserControl
   CreateRegion Private Function () como a região
      Dim gp Como GraphicsPath New ()
      gp.AddEllipse (Me.ClientRectangle)
      Dim rgn Como Nova Região (gp)
      rgn Retorno
   End Function

   Sub Protected Substitui OnResize (ByVal e As EventArgs)
      Me.Region Me.CreateRegion = ()
   End Sub

   Protegido substituições OnPaint Sub (ByVal e As PaintEventArgs)
      e.Graphics.FillEllipse (New SolidBrush (Me.ForeColor), _
         Me.ClientRectangle)
   End Sub

   Sub New Public ()
      Me.ResizeRedraw = True
   End Sub

End Class

O método CreateRegion no Exemplo 5-7 cria uma região em forma de uma elipse de tamanho para encher o
área cliente do controle. Para criar regiões não retangulares, você deve criar um GraphicsPath
objeto, use os métodos de desenho da classe GraphicsPath para definir uma forma complexa na
objeto GraphicsPath e, em seguida instanciar um objeto Região, inicializando-o do objeto GraphicsPath.
Exemplo 5-7 chama o método da classe GraphicsPath AddEllipse para criar uma elipse dentro da
GraphicsPath objeto. Métodos adicionais podem ser chamados para adicionar mais formas (incluindo a linha desenhada
formas) para o objeto GraphicsPath. O método OnResize no Exemplo 5-7 garante que o controle
propriedade Region é redefinir toda vez que o controle é redimensionado. Figura 5-35 mostra o controle depois de ter
foi colocado em um formulário no modo de design no Windows Forms Designer. Observe que a grade de pontos agora
mostrar através dos cantos do controle. Esta área é cortada nenhuma parte mais considerada do controle. Se
o usuário clica sobre esta área, o clique passa para o objeto sob o controle (neste caso,
do formulário).


235
 



Figura 5-35. Um controle com sua propriedade definida como Região clip tudo
fora da elipse





















5,7 Resumo

A arquitetura do Windows Forms é largo e profundo. Este capítulo apresentou tudo o que precisa
saber para começar a desenvolver aplicativos de desktop GUI, mas não há mais poder esperando por você
depois de assimilar o que está aqui. Depois de dominar o material neste capítulo, você pode escrever complexas
aplicações GUI. Você também será capaz de enfrentar e entender os tipos e funções adicionais
documentados no online. NET material de referência.



































236
 
NET Programação Visual Basic.


Capítulo 6. ASP.NET e Web Forms: Desenvolvendo
Aplicações baseadas em Browser

ASP.NET é uma tecnologia para desenvolvimento de páginas web dinâmicas. Ela tem evoluído a partir do ASP da Microsoft
tecnologia, então a experiência com ASP transferências razoavelmente bem para o ASP.NET. Embora eu não assumir neste
capítulo que você tem essa experiência, eu supor que você tenha, pelo menos, uma certa familiaridade com o passar
HTML.

ASP.NET funciona com o Microsoft Internet Information Services (IIS) para criar dinamicamente HTML
conteúdo, de modo que possa ser enviada a um navegador web. Esta tecnologia é compatível com todos os navegadores, porque o ASP.NET
roda inteiramente no servidor e envia apenas HTML (e, opcionalmente, JavaScript client-side) para o
browser.

Com o ASP.NET, navegação na web funciona assim:

1. O usuário digita um endereço de página web em um browser (ou links para o endereço de outro web
página). Por exemplo http://www.gotdotnet.com/default.aspx.
2. O navegador envia uma solicitação ao servidor (neste caso, www.gotdotnet.com), pedindo a
determinada página da Web (neste caso, default.aspx).
3. O servidor recebe o pedido e as tentativas de realizá-lo. Como o servidor preenche o pedido
depende do tipo de página solicitada, conforme indicado pela extensão do arquivo. Arquivos com
um html. ou. htm são supostos conter texto simples e HTML são enviados para o
browser como está. Os arquivos com uma extensão. Assume-se que contêm aplicação ASP.NET
código e, portanto, compilado e executado. Executando o código ASP.NET geralmente resulta
na geração de conteúdo HTML e enviá-lo para o navegador. Observe o seguinte:
O navegador é o conhecimento de que o conteúdo é gerado dinamicamente. A partir da
perspectiva do navegador, a resposta poderia ser a partir de um arquivo HTML estático.
o A. aspx é compilado apenas uma vez. A primeira vez que um navegador solicita o arquivo, o
estrutura do ASP.NET compila o arquivo e armazena o código executável no servidor.
As solicitações subseqüentes para a mesma página chamada diretamente para o código executável.

O termo Web Forms refere-se a um conjunto de classes no. NET Framework que fornece suporte para
construção de aplicações web. Com o Visual Studio. NET IDE's built-in consciência de Web Forms,
construção de páginas web agora tem (quase) a simplicidade de arrastar e soltar mesmo que construir com base em formulário
aplicações de desktop.

No âmbito do ASP.NET,. Aspx pode conter tags HTML padrão (que são enviados como é o
browser), etiquetas de Web Forms (que representam classes Web Forms e são interpretadas pelo ASP.NET
tempo de execução, ao invés de ser enviado para o navegador), eo código escrito em uma das línguas. NET.

As páginas ASP.NET são compilados. Mesmo que um arquivo aspx. Contém apenas HTML, ainda é compilado. Esta é
bastante interessante feito. Durante o processo de compilação, o ASP.NET lê o arquivo. Aspx e cria uma
classe capaz de produzir o HTML encontrado no arquivo. Se o arquivo aspx. Contiver Visual incorporado
Basic. NET (ou outra. NET) código, este código é compilado para a classe. Por exemplo, se
o arquivo aspx. contém uma declaração de sub-rotina incorporada, a sub-rotina torna-se um método de
compilados classe. Durante a execução, a classe compilada é solicitado a gerar seus HTML, que é então enviada para o
browser.

A classe compilada que representa uma página ASP.NET é um arquivo. NET classe. Como tal, deve herdar
de uma outra classe. Por padrão, as classes criadas pelo ASP.NET herda da classe Page (definido no
namespace System.Web.UI). Isto significa que as classes geradas têm todas as capacidades que são
incorporado na classe Page. Esses recursos são descritos mais adiante neste capítulo, no ponto 6.2.

Se desejar, páginas ASP.NET pode especificar uma classe da qual herda, enquanto a classe especificada
se, em última análise herda da classe Page. Este é o fundamento para a separação de um código de página de
seu HTML. O código é colocado em uma classe que herda da classe Page. A página web, em seguida, especifica um
directiva, indicando que a sua classe compilada deve derivar da classe personalizada, ao invés de diretamente


237
 



da classe Page. Esta técnica é conhecida como code-behind. O vb. Que contém a base
definição de classe é referido como o arquivo code-behind. A classe da qual herda a classe da página web
é chamado de classe code-behind. Esses conceitos são explicados mais detalhadamente ao longo deste capítulo.

6.1 Criando um formulário da Web

A maneira mais fácil criar um formulário web é usar o Web Forms Designer no Visual Studio. NET. A
desenvolvedor utiliza ferramentas visuais para criar o formulário eo designer converte o layout em uma página web
e seu código-fonte associados Visual Basic. NET. arquivos de página da Web (. aspx) e seus associados Visual
arquivos Basic. NET de código-fonte (. vb) são editáveis como texto simples, se desejar. Se você não tiver o Visual
Studio. NET, você pode escrever as páginas da Web eo código-fonte manualmente usando um editor de texto. Os seguintes
duas seções demonstrar ambos os métodos.

6.1.1 Criando um formulário usando o Visual Studio. NET

Para criar um aplicativo baseado na Web no Visual Studio. NET:

1. Selecionar novo arquivo de projeto. O Novo Projeto caixa de diálogo aparece, como mostrado na Figura 6-1.

Figura 6-1. O Novo Projeto caixa de diálogo
























2. Selecione "Visual Basic Projects" no painel de Tipos de Projeto, no lado esquerdo da caixa de diálogo.
3. Selecione "ASP.NET Web Application" no painel de Templates no lado direito da caixa de diálogo.
4. Digite um nome na caixa de texto Nome. Esse nome é usado como o nome de uma nova pasta, em que
Visual Studio. NET coloca o projeto.
5. Digite um local na caixa de texto Localização (por exemplo, ou http://localhost/
http://localhost/MyProjects/. A localização física desta pasta é determinado pelas configurações do IIS,
como configurado no Internet Services Manager.

Os valores declarados para determinar a localização eo nome do caminho completo para o projeto. Por exemplo,
Se o local é http://localhost/MyProjects/ eo nome é SomeProject, o caminho completo virtual
para os arquivos no projeto é http://localhost/MyProjects/SomeProject/. Além disso, se o
MyProjects virtual mapeia para a pasta C pasta física: \ Documents and Settings \ DAVEG \ My
Documentos \ My Code \, o caminho físico completo para os arquivos do projeto é o C: \ Documents and
Configurações DAVEG \ \ Meus Documentos \ My Code \ SomeProject \.



238
 
NET Programação Visual Basic.


Se o local é dado simplesmente como http://localhost/ (ou seja, como o nome da máquina sem pasta virtual
nome), o caminho físico é determinado pelas configurações do IIS para o host do site da Web padrão (mais uma vez,
como configurado no Internet Services Manager). Por padrão, esta é C: \ Inetpub \ wwwroot \. Para
exemplo, se o nome é SomeProject ea localização é http://localhost/, o caminho físico completo
para os arquivos do projeto é o C: \ Inetpub \ wwwroot \ SomeProject \.

6. Clique em OK. Visual Studio. NET cria um projeto com um formulário web em e exibe o formulário no
o designer, conforme mostrado na Figura 6-2.

Figura 6-2. O Web Forms Designer no modo de design





























Existem três maneiras de ver e trabalhar com um formulário web. O primeiro está no modo de design, que é o modo
mostrado na Figura 6-2. No modo de design, os controles podem ser adicionados ao formulário da Caixa de ferramentas e
posicionado como desejado. Isso é semelhante à concepção de um formulário em um aplicativo desktop GUI. Veja mais adiante neste
seção de exemplos de como adicionar controles a um formulário.

A segunda maneira de trabalhar com um formulário web é editando diretamente o HTML. Para exibir um formulário HTML, clique em
a tag HTML no Web Forms Designer. A tela resultante é mostrado na Figura 6-3.

Figura 6-3. O Web Forms Designer no modo de exibição HTML















239
 

































O clichê HTML produzido por um formulário web em branco é mostrado no Exemplo 6-1.

Exemplo 6-1. O clichê Web Forms Designer de HTML para um espaço em branco
formulário on-line
<% @ Page Language = "vb" AutoEventWireup = "false"
   Codebehind = "WebForm1.aspx.vb" Inherits => "IdeExamples.WebForm1"%
<! DOCTYPE HTML PUBLIC "- / / W3C / / DTD HTML 4.0 Transitional / / EN">
<html>
   <head>
      <title> </ title>
      name="GENERATOR" <meta content="Microsoft Visual Studio .NET 7.0">
      name="CODE_LANGUAGE" <meta content="Visual Basic 7.0">
      <meta name="vs_defaultClientScript" content="JavaScript">
      <Meta name = "vs_targetSchema"
         content = "http://schemas.microsoft.com/intellisense/ie5">
   </ Head>
   MS_POSITIONING="GridLayout"> <body
      <form id="Form1" method="post" runat="server">
      </ Form>
   </ Body>
</ Html>

O código no Exemplo 6-1 tem as seguintes qualidades:

• A diretiva de página no início do arquivo fornece informações sobre como ASP.NET
deve processar a página. As directivas são descritos em detalhe mais adiante neste capítulo, na Seção
6.5. A diretiva de página mostrado no Exemplo 6-1 especifica as seguintes definições:

Language = "vb"




240
 
NET Programação Visual Basic.


Especifica qual idioma compilador para usar ao compilar o código embutido no arquivo.
Exemplo 6-1 não tem qualquer código incorporado, mas o desenvolvedor pode adicionar o código mais tarde.

AutoEventWireup = "false"

Determina como os eventos gerados pelos controles do lado do servidor são manipuladas. Isso é explicado mais adiante
Neste capítulo, na secção 6.2.1 no ponto 6.2.

Codebehind = "WebForm1.aspx.vb"

Especifica o nome do arquivo code-behind.

Inherits = "IdeExamples.WebForm1"

Especifica o nome da classe da qual esta página devem herdar. Este deve ser o nome do
uma classe definida em um dado arquivo code-behind. Neste exemplo, o nome da classe é no WebForm1
IdeExamples um namespace chamado.

• As marcas <meta> contêm informações que são significativas para o Web Forms Designer. Sua
presença não é necessária para o correto funcionamento da página.
• O <body> contém um atributo específico da Microsoft chamado MS_POSITIONING. Este
atributo é usado pelo criador de formulários da Web e pelo compilador do ASP.NET para determinar como
para formatar o HTML gerado pela página compilada. O atributo em si não é realmente enviado ao
o navegador.
• A marca <form> é central para a Web Forms. Web Forms usa os recursos do HTML
mecanismo <form> tag's post para implementar a interação com o usuário. Isso será discutido no
mais detalhes ao longo deste capítulo. Observe no Exemplo 6-1 que a marca tem a <form>
runat = "server" atributo. Isso significa que essa marca não é enviado como é o browser. Em vez disso,
o compilador do ASP.NET processa essa marca e seu conteúdo para determinar a melhor maneira de tornar
a forma que ele representa.

A terceira maneira de trabalhar com um formulário web é através da edição do código sob a forma de página code-behind. Para ver
o código criado pelo designer clique, o botão direito sobre o formulário, em seguida, selecione Exibir Código. Fazer isso para o
formulário em branco mostrado na Figura 6-2 mostra o código mostrado aqui:

Public Class WebForm1
   Inherits System.Web.UI.Page

 Web Form Designer Generated Code

   Private Sub Page_Load (ByVal sender As System.Object, _
      ByVal e As System.EventArgs) Handles MyBase.Load
      "Coloque o código do usuário para inicializar a página aqui.
   End Sub

End Class

Isso mostra a definição de uma classe, WebForm1, que herda da classe Page. O designer também
cria um monte de código clichê que não devem ser modificados pelo desenvolvedor. Por padrão, ele esconde isso
Código de vista. Para ver o código, clique no símbolo "+" que aparece à esquerda da linha que diz:
"Web Form Designer Generated Code". Se o fizer, revela o código mostrado no Exemplo 6-2. (Algumas das
as linhas em Exemplo 6-2 foram quebradas para impressão neste livro.)

Exemplo 6-2. O código Web Forms Designer gerado por um formulário em branco
Public Class WebForm1
   Inherits System.Web.UI.Page



241
 




# Region "Web Form Designer gerou código"

   "Este convite é exigido pelo Web Form Designer.
   <System.Diagnostics.DebuggerStepThrough( )> _
   InitializeComponent Private Sub ()

   End Sub

   Private Sub Page_Init (ByVal sender As System.Object, _
      ByVal e As System.EventArgs) Handles MyBase.Init
      "CODEGEN: Esta chamada de método é exigido pelo Web Form Designer
      "Não modificá-lo usando o editor de código.
      InitializeComponent ()
   End Sub

# Fim Região

   Private Sub Page_Load (ByVal sender As System.Object, _
      ByVal e As System.EventArgs) Handles MyBase.Load
      "Coloque o código do usuário para inicializar a página aqui
   End Sub

End Class

O Web Forms Designer gera automaticamente o código para três membros da classe:

método InitializeComponent

O código deste método não deve ser modificado ou adicionado pelo desenvolvedor de forma alguma. A
Web Forms Designer atualiza automaticamente, conforme necessário.

método Page_Init

Este é um manipulador de eventos que trata de eventos da classe base Init. O evento Init é herdada
da classe Control (definido no System.Web.UI) e é disparado quando o objeto da página é
criado. Este é o primeiro evento que é disparado quando o objeto é criado. O código que inicializa a
instância do objeto deve ser colocado neste método. As referências aos controles da página ainda não estão
disponíveis quando o evento Init é gerado.

método Page_Load

Este é um manipulador de evento que manipula o evento de classe base de carga. O evento Load é herdada
da classe Control (definido no System.Web.UI) e é gerado depois que o objeto Page tem
foi inicializado. As referências aos controles da página estão disponíveis no momento.

Os próximos passos na elaboração do formulário são o nome do arquivo. Aspx e definir algumas propriedades do formulário,
como o título da página web. Para alterar o nome do formulário, clique em arquivo, com o botão direito sobre o nome do arquivo
a janela Solution Explorer e selecione Renomear. Se você está seguindo junto com este exemplo, insira
HelloBrowser.aspx como o nome do arquivo. Isso também muda automaticamente o nome do código-
por trás de arquivos para HelloBrowser.aspx.vb.

Mudar o nome do arquivo não muda o nome da classe code-behind. Para alterar o
nome desta classe, clique com o formulário, selecione View Code, em seguida, alterar o nome da classe na classe
declaração de WebForm1 para HelloBrowser. Para manter o arquivo code-behind em sincronia com o arquivo aspx.,
você também deve fazer uma mudança correspondente ao atributo Inherits do arquivo. aspx's Page
directiva, como mostrado aqui:




242
 
NET Programação Visual Basic.


<% @ Page Language = "vb" AutoEventWireup = "false"
   Codebehind = "HelloBrowser.aspx.vb" Inherits => "IdeExamples.HelloBrowser"%

Para alterar o título da página web, clique com o formulário no designer e escolha Propriedades. Role para baixo
a janela Propriedades para encontrar o imóvel título, digite um novo valor, "Programação Visual
Basic. NET ". Isso é mostrado na Figura 6-4.

Figura 6-4. Alterando o título de uma página web





























Em seguida, você pode adicionar controles ao formulário web a partir do Visual Studio caixa de ferramentas. NET. Para exibir o
caixa de ferramentas, selecione Exibir caixa de ferramentas do Visual Studio. NET menu principal. Para este exemplo, com dupla
clique no controle Label na caixa de ferramentas para adicionar um controle Label no formulário. Use a janela Propriedades
a mudança de propriedade do rótulo de texto para "Olá, Browser!". Defina o Nome da propriedade Font para
"Arial" e membro do tamanho de "X-Large".

Em seguida, clique duas vezes no controle Button na caixa de ferramentas para adicionar um botão de controlo para o formulário. Use o
janela Propriedades para alterar a propriedade do botão de identificação para "btnBlack" e sua propriedade Text para "Black".

Adicione mais dois botões, definindo suas propriedades de ID para "btnBlue" e "btnGreen" e suas propriedades Text
com "Blue" e "Verde", respectivamente.

Finalmente, a posição dos controles, como desejado. A forma resultante deve ser algo como o mostrado
na Figura 6-5.

Figura 6-5. Um formulário web com controles









243
 

































Pressione a tecla F5 para compilar e executar o programa. O resultado deve ficar parecido com a Figura 6-6.

Figura 6-6. Olá, Browser!, Criada pelo designer de formulários Web














O HTML gerado pelo designer é mostrado no Exemplo 6-3.

Exemplo 6-3. Olá, Browser! HTML, gerado pelo Web Forms
Designer
<% @ Page Language = "vb" AutoEventWireup = "false"
   Codebehind = "HelloBrowser.aspx.vb"
   Inherits = "IdeExamples.HelloBrowser"%>
<!
DOCTYPE HTML PUBLIC "- / / W3C / / DTD HTML 4.0 Transitional / / EN">
<HTML>
  <HEAD>
      <title> Programação Visual Basic. NET </ title>
      name="GENERATOR" <meta content="Microsoft Visual Studio .NET 7.0">
      name="CODE_LANGUAGE" <meta content="Visual Basic 7.0">
     
 <meta name="vs_defaultClientScript" content="JavaScript">
      <Meta name = "vs_targetSchema"


244
 
NET Programação Visual Basic.


         content = "http://schemas.microsoft.com/intellisense/ie5">
  </ HEAD>
   MS_POSITIONING="GridLayout"> <body
      <form id="Form1" method="post" runat="server">
         <Asp: Label ID = "Label1"
            style = "Z-INDEX: 101; ESQUERDA: 8px; position: absolute;
               TOP: 8px "
            runat = "server" font-size = "X-Large"
            Font-Names = "Arial"> Olá Browser, </ asp:> Label
         <Asp: button id = "btnGreen"
            style = "Z-INDEX: 104; LEFT: 112px; position: absolute;
               TOP: 56px "
            runat = "server" Text = "Green"> </ asp: Button>
         <Asp: button id = "btnBlue"
            style = "Z-INDEX: 103; ESQUERDA: 64px; position: absolute;
               TOP: 56px "
            runat = "server" Text = "Blue"> </ asp: Button>
         <asp: button id = "btnBlack"
            style = "Z-INDEX: 102; ESQUERDA: 8px; position: absolute;
               TOP: 56px "
            runat = "server" Text = "Black"> </ asp: Button>
      </ Form>
   </ Body>
</ HTML>

O Visual Basic. NET code-behind código é mostrado no Exemplo 6-4.

Exemplo 6-4. Olá, Browser! code-behind código, gerado pela Web
Forms Designer
Público HelloBrowser Classe
   Inherits System.Web.UI.Page
   Protegido btnBlack WithEvents Como System.Web.UI.WebControls.Button
   Protegido btnBlue WithEvents Como System.Web.UI.WebControls.Button
   Protegido btnGreen WithEvents Como System.Web.UI.WebControls.Button
   Protegido WithEvents Label1 Como System.Web.UI.WebControls.Label

# Region "Web Form Designer gerou código"

   "Este convite é exigido pelo Web Form Designer.
   <System.Diagnostics.DebuggerStepThrough( )> _
      InitializeComponent Private Sub ()

   End Sub

   Private Sub Page_Init (ByVal sender As System.Object, _
      ByVal e As System.EventArgs) Handles MyBase.Init
      "CODEGEN: Esta chamada de método é exigido pelo Web Form Designer
      "Não modificá-lo usando o editor de código.
      InitializeComponent ()
   End Sub
# Fim Região

   Private Sub Page_Load (ByVal sender As System.Object, _
      ByVal e As System.EventArgs) Handles MyBase.Load
      "Coloque o código do usuário para inicializar a página aqui
   End Sub
End Class



245
 



O HTML que é enviado para o navegador é mostrado no Exemplo 6-5.

Exemplo 6-5. O HTML enviado ao navegador da Olá, Browser!
aplicação
<! DOCTYPE HTML PUBLIC "- / / W3C / / DTD HTML 4.0 Transitional / / EN">
<HTML>
  <HEAD>
      <title> Programação Visual Basic. NET </ title>
      name="GENERATOR" <meta content="Microsoft Visual Studio .NET 7.0">
      name="CODE_LANGUAGE" <meta content="Visual Basic 7.0">
      <meta name="vs_defaultClientScript" content="JavaScript">
      <Meta name = "vs_targetSchema"
         content = "http://schemas.microsoft.com/intellisense/ie5">
  </ HEAD>
   MS_POSITIONING="GridLayout"> <body
      <Form name = método "Form1" = "post" action = "HelloBrowser.aspx"
         id = "Form1">
         <Input type = name "escondida" = "_ _VIEWSTATE"
            value = "dDwtMTc0NzM4OTU5Ozs +" />
         <Span id = "Label1"
            style = "font-family: Arial; font-size: X-Large, Z-INDEX: 101;
               ESQUERDA: 8px; position: absolute; TOP: 8px ">
            Olá, Browser </ span>
         <Input type = "submit" name = valor "btnGreen" = "Green" id = "btnGreen"
            style = "Z-INDEX: 104; LEFT: 112px; position: absolute;
               TOP: 56px "/>
         <Input type = "submit" name = valor "btnBlue" = "Azul" id = "btnBlue"
            style = "Z-INDEX: 103; ESQUERDA: 64px; position: absolute;
               TOP: 56px "/>
         <Input type = "submit" name = "btnBlack" value = "Black" id = "btnBlack"
            style = "Z-INDEX: 102; ESQUERDA: 8px; position: absolute;
               TOP: 56px "/>
      </ Form>
   </ Body>
</ HTML>


Quando os quatro controles foram adicionados ao formulário na Web Forms Designer, o designer acrescentou quatro
tags para HTML do formulário: um para a etiqueta e três para os três botões. Considere marca o primeiro para o
controle Label:

<Asp: Label ID = "Label1"
   style = "Z-INDEX: 101; ESQUERDA: 8px; position: absolute; TOP: 8px"
   runat = "server" font-size = "X-Large"
   Font-Names = "Arial"> Olá Browser, </ asp:> Label

Esta é uma etiqueta <asp:label>, que claramente não é uma tag HTML padrão. Pelo contrário, é reconhecido e
agido em pelo runtime do ASP.NET. Quando o runtime do ASP.NET vê essa marca, o tempo de execução instancia
um objeto do tipo Label (definido no namespace System.Web.UI.WebControls) no servidor web.
O tempo de execução inicia este controle de acordo com os valores dos atributos da marca <asp:label>. A
tempo de execução, em seguida, define a propriedade Text do controle com o texto encontrado entre a tag e <asp:label>
sua tag de fechamento </ asp: Label>. O objeto Label é responsável pela saída de HTML padrão que
processa o valor do objeto. Neste caso, que o HTML pode ser visto no Exemplo 6-5. A parcela de
Exemplo 6-5 relacionado com o controle Label é aqui reproduzido:

<Span id = "Label1"
   style = "font-family: Arial; font-size: X-Large, Z-INDEX: 101;
      ESQUERDA: 8px; position: absolute; TOP: 8px ">


246
 
NET Programação Visual Basic.


   Olá, Browser </ span>

Como você pode ver, o controle Label prestados se como texto simples (Olá, Browser!), Rodeado por um
<span> tag. O objectivo da marca <span> é aplicar os atributos id e estilo para o texto.

Da mesma forma, considerar o primeiro Controlarar Button adicionado ao formulário web. O Web Forms Designer gerado
esta representação em HTML do controle:

<Asp: button id = "btnGreen"
   style = "Z-INDEX: 104; LEFT: 112px; position: absolute; TOP: 56px"
   runat = "server" Text = "Green"> </ asp: Button>

A marca <asp:Button> representa o controle Button. Quando o tempo vê essa marca, ele instancia
um objeto do tipo Button (definido no namespace System.Web.UI.WebControls) no servidor. Este
objeto é então responsável pela saída de HTML padrão que torna o valor (e, neste caso,
funcionalidade) do objeto. O HTML enviado ao navegador para este botão é:

<Input type = "submit" name = valor "btnGreen" = "Green" id = "btnGreen"
   style = "Z-INDEX: 104; LEFT: 112px; position: absolute; TOP: 56px" />

Note-se que o controle Button prestados se como uma marca <input> com type = "submit". Isto mostra uma
botão na janela do navegador. Os outros atributos da marca especificar seu nome, texto e estilo.

controles Label e Button são exemplos de controles de servidor. O conjunto completo de controles de servidor está listado tarde
neste capítulo, na Seção 6.3.

6.1.1.1 Adicionando manipuladores de eventos

O Olá, Browser! aplicação construída até agora tem três botões, mas o pedido ainda não faz
nada em resposta a cliques de botão. Para adicionar um manipulador de eventos Click para o código existente no Visual
. Studio.NET, siga estes passos:

1. Alterne para a janela de exibição de código para o formulário web.
2. No topo da janela de código-fonte são dois lado a lado as listas drop-down. Selecione o desejado
btnBlack controle, na lista do lado esquerdo, em seguida, selecione o evento desejado btnBlack_Click, no
lista do lado direito. O Web Forms Designer adiciona um manipulador de eventos para o código (ver Figura 6-7).

Figura 6-7. Escolhendo um controle e eventos para que a adicionar um manipulador






















247
 



























3. Adicione código ao manipulador de eventos. Para este exercício, que o manipulador de eventos define a cor da
Label controle para preto:
4. Private Sub btnBlack_Click (_
5. ByVal sender As Object, _
6. ByVal e As System.EventArgs _
7. ) Handles btnBlack.Click
8. Label1.ForeColor System.Drawing.Color.Black =
  End Sub

9. Da mesma forma, adicionar manipuladores de eventos para o btnBlue e controles btnGreen Button. O evento terminou
manipuladores deve ficar assim:
10. Private Sub btnBlue_Click (_
11. ByVal sender As System.Object, _
12. ByVal e As System.EventArgs _
13. ) Handles btnBlue.Click
14. Label1.ForeColor System.Drawing.Color.Blue =
15. End Sub
16.
17. Private Sub btnGreen_Click (_
18. ByVal sender As System.Object, _
19. ByVal e As System.EventArgs _
20. ) Handles btnGreen.Click
21. Label1.ForeColor = System.Drawing.Color.Green
End Sub

O formulário on-line criada aqui permite ao usuário mudar a cor das palavras "Olá, Browser!" por
clicando em uma das modalidades de três botões. Isso foi feito por controles arrastando para o formulário e
criar manipuladores de eventos. Durante a execução, a estrutura do ASP.NET gera HTML padrão que
implementa o comportamento determinado. O desenvolvedor pode agora trabalhar com um modelo familiar orientada a eventos e
ignoram largamente as exigências do HTML.

6.1.2 Criando um formulário no Código

Embora a Web Visual Studio. NET Forms Designer é conveniente para o desenvolvimento de formas de web, não é
necessário. Para criar um formulário web, sem a assistência do Visual Studio NET, siga estes passos.




248
 
NET Programação Visual Basic.


1. Criar uma. Vb que servirá como o arquivo code-behind. Este arquivo pode ser qualquer nome
porque o próprio nome será referenciado no arquivo aspx associados.. No arquivo code-behind,
local de uma classe que herda da classe Page, como este:
2. Imports System.Web.UI
3.
4. Público HelloBrowser Classe
5. Page Inherits
6.
End Class

7. Adicionar variáveis de membro e manipuladores de eventos para os controles que devem constar no formulário. Para
exemplo:
8. Imports System.Web.UI
9. Imports System.Web.UI.WebControls
10.
11. Público HelloBrowser Classe
12. Page Inherits
13.
14. Protegido WithEvents Label Label1 como
15. Protegido btnBlack WithEvents como Button
16. Protegido btnBlue WithEvents como Button
17. Protegido btnGreen WithEvents como Button
18.
19. Protected Sub btnBlack_Click (_
20. ByVal sender As Object, _
21. ByVal e As System.EventArgs _
22. ) Handles btnBlack.Click
23. Label1.ForeColor System.Drawing.Color.Black =
24. End Sub
25.
26. Protected Sub btnBlue_Click (_
27. ByVal sender As System.Object, _
28. ByVal e As System.EventArgs _
29. ) Handles btnBlue.Click
30. Label1.ForeColor System.Drawing.Color.Blue =
31. End Sub
32.
33. Protected Sub btnGreen_Click (_
34. ByVal sender As System.Object, _
35. ByVal e As System.EventArgs _
36. ) Handles btnGreen.Click
37. Label1.ForeColor = System.Drawing.Color.Green
38. End Sub
39.
End Class

40. Criar um arquivo. Aspx para servir como página principal do aplicativo. Referência o código de classe por trás
utilizando o SRC e Inherits atributos da diretiva Page, e incluem marcas <asp:...>
para os controles que devem constar no formulário. Por exemplo:
41. <% @ Page Language = "vb" AutoEventWireup = "false"
42. Src = "HelloBrowser.vb" Inherits => "HelloBrowser"%
43. <html>
44. <head>
45. <title> Programação Visual Basic. NET </ title>
46. </ Head>
47. <body>
48. <form id="Form1" method="post" runat="server">
49. <asp: Label id = runat "Label1" = "server" font-size = "X-Large"
50. Font-Names = Texto "Arial" = "Olá Browser!" > <br>
51. <asp:Button id="btnGreen" runat="server" Text="Green" />



249
 



52. <asp:Button id="btnBlue" runat="server" Text="Blue" />
53. <asp:Button id="btnBlack" runat="server" Text="Black" />
54. </ Form>
55. </ Body>
</ Html>

. Aqui, o vb code-behind é referenciado usando o atributo Src; no Visual Studio NET.
código mostrado anteriormente, o arquivo code-behind foi referenciada no atributo CodeBehind. Esta é
uma distinção importante. O CodeBehind atributo é usado apenas pela NET Visual Studio,. Ele é
ignorados pelo compilador do ASP.NET.

Certifique-se que o valor do atributo id de cada tag <asp:...> corresponde ao nome do
variável de membro associado na classe code-behind. Este nome é como o ASP.NET
quadro corresponde a cada variável membro com o controle de servidor correspondente.

Para executar esta aplicação, entre os dois fragmentos de código e salvá-los em dois arquivos, chamados
HelloBrowser.vb e HelloBrowser.aspx, respectivamente. Os arquivos devem estar localizados em um IIS virtual
diretório em uma máquina com o. NET Framework instalado. Depois de salvar os arquivos, um ponto de web
browser para HelloBrowser.aspx. O tempo de execução o ASP.NET automaticamente compila e executa o aplicativo,
entregar a saída para o navegador.

6.1.2.1 Definindo propriedades de controle utilizando os atributos

As propriedades dos objetos de controle do servidor pode ser inicializado, especificando valores para os atributos dentro do
tags <asp:...>. Por exemplo, o botão criado pela marca a seguir tem sua propriedade Text definida para
"Verde":

<asp:Button id="btnGreen" runat="server" Text="Green" />

Esta missão poderia sim ter sido tratado em outras posições do código ou em um bloco ou <script>
em uma classe code-behind. Em geral, qualquer propriedade gravável pode ser definido usando um atributo do mesmo
nome.

6.1.2.2 Adicionando manipuladores de eventos

Defina os manipuladores de eventos diretamente na classe code-behind para qualquer evento que você deseja tratar. Para
exemplo:

Private Sub btnBlack_Click (_
   ByVal sender As Object, _
   ByVal e As System.EventArgs _
) Handles btnBlack.Click
   Label1.ForeColor System.Drawing.Color.Black =
End Sub

Private Sub btnBlue_Click (_
   ByVal sender As System.Object, _
   ByVal e As System.EventArgs _
) Handles btnBlue.Click
   Label1.ForeColor System.Drawing.Color.Blue =
End Sub

Private Sub btnGreen_Click (_
   ByVal sender As System.Object, _
   ByVal e As System.EventArgs _
) Handles btnGreen.Click
   Label1.ForeColor = System.Drawing.Color.Green


250
 



End Sub
 
NET Programação Visual Basic.
 

6,2 Page Tratamento de eventos

A classe base Page pode às vezes gerar eventos. Esses eventos podem ser tratadas pela página derivados
classe (a classe code-behind) ou por código embutido na página web. Embora seja possível definir
uma sub-rotina de manipulador de eventos, a resposta preferida para eventos disparados pela classe Page é substituir
os métodos de proteção fornecida pela classe Page. Por exemplo, o método a seguir poderia ser
colocado na classe code-behind, fornecendo uma maneira de responder ao carregamento da página:

Substitui Protegido OnLoad Sub (e As EventArgs)
   MyBase.OnLoad (e)
   '...
End Sub
Ao substituir um método OnEvent estilo, garantir que a
método de substituição chama a implementação de classe base, além
a sua própria transformação. O trabalho de implementação da classe base é
para aumentar o evento correspondente. Se a implementação da classe base
não é chamado, o evento não será disparado.

Segue abaixo a lista de eventos de um objeto Page poderia levantar. A classe Page si não define estas
eventos: ela herda-los de suas classes pai. Esta lista de eventos inclui uma breve descrição de cada
evento, a classe em que o evento é definido, ea sintaxe para substituir o método protegido que
corresponde ao evento.

AbortTransaction (herdadas System.Web.UI.TemplateControl)

Ocorre quando uma transação COM +, em que a página está participando é abortada. Sua sintaxe é:

    Protegido substituições OnAbortTransaction Sub (ByVal e As EventArgs)
CommitTransaction (herdadas System.Web.UI.TemplateControl)

Ocorre quando uma transação COM +, em que a página está participando está comprometida. Sua sintaxe é:

    Protegido substituições OnCommitTransaction Sub (ByVal e As EventArgs)
DataBinding (herdadas System.Web.UI.Control)

Ocorre quando a página se liga a uma fonte de dados. Sua sintaxe é:

    Sub Protected Substituições (ByVal e As EventArgs) OnDataBinding
Disposto (herdadas System.Web.UI.Control)

Gerado após o método do objeto Página Dispose tiver terminado o seu processamento. O Dispose
método é chamado pelo framework ASP.NET depois que a página tenha sido prestado eo objeto
não é mais necessária. Não há um método correspondente OnDisposed. Para adicionar um manipulador para este
evento em uma classe derivada, use o seguinte código:

Private Sub Page_Disposed (_
   ByVal sender As Object, _
   ByVal e As EventArgs _
) Handles MyBase.Disposed
   '...
End Sub
Erro (herdadas System.Web.UI.TemplateControl)




251
 
 



Ocorre quando uma exceção não tratada é lançada. Isso fornece uma oportunidade de última oportunidade para
graciosamente lidar com erros inesperados (talvez exibindo um amigável "Lamentamos, mas o nosso
aplicação Web tem barfed "mensagem de Sua sintaxe é.:

   Protegido substituições OnError Sub (ByVal e As EventArgs)
Init (herdadas System.Web.UI.Control)

Ocorre quando o objeto Page foi criada, mas antes o estado de exibição foi carregado. Sua
sintaxe é:

   Protegido substituições OnInit Sub (ByVal e As EventArgs)
Carga (herdadas System.Web.UI.Control)

Ocorre quando o objeto Page terminar de carregar. Sua sintaxe é:

   Substitui Sub Protected OnLoad (ByVal e As EventArgs)
PreRender (herdadas System.Web.UI.Control)

Levantadas imediatamente anterior à página de processamento em si. Sua sintaxe é:

   Substitui Protegido OnPreRender Sub (ByVal e As EventArgs)
Unload (herdadas System.Web.UI.Control)

Ocorre depois que a página foi processada, mas antes o método do objeto Página Dispose é
chamado. Sua sintaxe é:

   Substitui Sub Protected OnUnload (ByVal e As EventArgs)

Os quatro últimos eventos são gerados em cada solicitação de página, pela ordem indicada. Os três eventos que são
levantadas antes da renderização da página (Init, Load e PreRender) são criados em diferentes pontos durante o
criação da página:

• O evento Init é gerado depois que o objeto Page foi criada, mas antes ele foi carregado valores
em seus controles constituintes ou processados todos os dados de postback.
• O evento Load é gerado após controles constituintes foram carregados com seus valores.
Entretanto, o processamento de postagem não é garantida para ser concluído.
• O evento PreRender é gerado após todo o processamento de carga e postagem está terminado eo
página está prestes a ser prestado em HTML.

6.2.1 AutoEventWireup

Se o desenvolvedor de uma página web ou classe code-behind escolhe para lidar com os eventos da classe base explicitamente,
os métodos de manipulador de eventos deve ser associado com os eventos que estão a lidar. No Visual
Basic. NET que é normalmente feito com uma cláusula Handles na definição do método, como descrito no
Capítulo 2 e mostrado por exemplo aqui:

Protected Sub Page_Load (_
   ByVal sender As Object, _
   ByVal e As EventArgs _
) Handles MyBase.Load
   '...
End Sub

Além de esta sintaxe, o ASP.NET fornece uma maneira alternativa para ligar manipuladores de eventos de página para
seus eventos associados. Se todas as seguintes condições forem satisfeitas, o quadro ASP.NET
automaticamente conecta-se a eventos de página com os métodos de manipulação correta:



252
 
NET Programação Visual Basic.


• O atributo AutoEventWireup da diretiva @ Page é definido como "true" (que é por
padrão). Isso significa que o valor do atributo AutoEventWireup é verdadeiro se o atributo é
omitidos da diretiva @ Page, bem como se a diretiva @ Page si é omitido.
• O nome do método manipulador é do Page_EventName formulário.
• A assinatura do método manipulador de jogos da assinatura do correspondente evento.

Por exemplo, se estas condições forem satisfeitas, o seguinte código é automaticamente ligado à página
evento Load:

Protected Sub Page_Load (_
   ByVal sender As Object, _
   ByVal e As EventArgs _
)
   '...
End Sub

O método de manipulador pode aparecer em qualquer página ou a classe code-behind (se houver).

Para não permitir autowiring de eventos, especificar "false" para o atributo AutoEventWireup, como este
(Outros atributos omitidos por brevidade):

<% @ Page AutoEventWireup = "false"%>

Não há clara vantagem para qualquer definição. autowiring evento pode sentir-se mais familiar para desenvolvedores
que têm utilizado o Visual Basic 6, onde apropriadamente chamado métodos automaticamente lidou com a
eventos correspondentes. Por outro lado, alguns desenvolvedores podem se sentir mais confortável forçando-evento
métodos de manipulador de declarar explicitamente os eventos que estão lidando. Além disso, a declaração explícita
libera o desenvolvedor de ter que nomear o método de acordo com o padrão Page_EventName.

6.3 Mais sobre controles de servidor

O ASP.NET fornece dois conjuntos de controles de servidor: os controles da Web e controles HTML. Web controles
(Definido no namespace System.Web.UI.WebControls) são similares aos controles encontrados no padrão
aplicações de desktop. Eles protegem o desenvolvedor tanto quanto possível de representar os controles
HTML. Em outras palavras, os controles da Web são tão semelhantes quanto possível aos controles aplicação desktop, deixando
-lo a cada controle que se preocupar com a forma como irá apresentar-se em HTML. Isso permite que o desenvolvedor de projeto
uma interface sem se preocupar muito sobre as limitações do HTML. Os controles apresentados até agora são web
controles.

Em contraste, os controles HTML (definido no namespace System.Web.UI.HtmlControls) são uma fina
wrapper sobre HTML do cliente de controles definidos no padrão HTML. Controles de servidor HTML deixar o
desenvolvedor omitir controles de cliente HTML específicos, mantendo as capacidades de programação que o servidor
controles fornecem. os desenvolvedores de páginas da Web são propensos a usar controles de servidor HTML somente quando eles querem
gerar e manipular controles específicos HTML do cliente com a tecnologia do lado do servidor. Microsoft faz
qualquer declaração sobre o conjunto de controles de servidor é "melhor" para usar. Apresentam-se ambos, ficando a cargo da
desenvolvedor decidir que controla encaixar melhor em uma determinada aplicação.

6.3.1 Web controles

Os controles da Web podem ser criados usando a sintaxe do HTML, bem como de programação. Quando você cria um
controle usando a sintaxe HTML, o nome do controle tag consiste no asp prefixo: seguido do nome da
o controle. Por exemplo, a instrução a seguir cria um controle CheckBox Web:

<Asp: checkbox id = "text chkMail" = "ser colocado na nossa lista?"
              AutoPostBack = "false" checked = runat "true" = "Server" />




253
 



Instâncias de controles web declarados usando a sintaxe HTML têm um número de atributos comuns que são
dignas de nota. O atributo ID define o nome da instância de controle da web e deve ser usado
em todas as declarações que criar controles web. Ela corresponde à propriedade da classe de controle de identificação, que
define o nome pelo qual o controle está relacionado de forma programática. A segunda é AutoPostBack,
um atributo opcional comuns a vários controles, que determina se o estado do controle é
enviada de volta para o servidor sempre que ele for clicado. Por padrão, seu valor é False. Ela corresponde diretamente
de propriedade da classe controle AutoPostBack. Finalmente, o atributo runat é necessária a criação de uma
controle da web, sem ela, o navegador a jusante tentativa de interpretar a tag HTML e simplesmente
deixar de processar o controle.

Cada controle da web também tem uma definição de classe no namespace System.Web.UI.WebControls de
da. NET Framework. Ao usar o atributo ID ou a propriedade ID, você pode fazer referência em código
um controle da Web criados usando a sintaxe HTML. Por exemplo, o seguinte desmarca a declaração do
CheckBox controle, definida no fragmento de código anterior:

chkMail.Checked = False

controles da Web também podem ser criados através de programação, como o seguinte fragmento de código, que cria uma
CheckBox controle idêntico ao definido anteriormente usando a sintaxe HTML, mostra:

Dim chkMail como novo CheckBox
chkMail.Text = "ser colocado na nossa lista?"
chkMail.Checked = True
chkMail.AutoPostBack = False

Note-se que, exceto para Runat, os atributos disponíveis para um controle usando a sintaxe HTML correspondem
diretamente a uma propriedade da classe de controle, tanto em nome e no tipo de dados.

O documento seguintes seções da web controles disponíveis no. NET Framework.

6.3.1.1 O controle Button

O controle de servidor Button representa um botão de comando e pode ser usado como um botão Enviar (sua
comportamento padrão) ou qualquer outro tipo de botão de comando em um formulário. O botão Enviar tem o seguinte
sintaxe HTML:

<Asp: Button id = "buttonname"
     Text = "rótulo"
     Onclick = "OnClickMethod"
     runat = "server" />

Quando usado como um botão de comando para algum outro propósito, o controle Button possui o seguinte HTML
sintaxe:

<Asp: Button id = "buttonname"
     Text = "rótulo"
     CommandName = "comando"
     CommandArgument = "CommandArgument"
     OnCommand = "OnCommandMethod"
     runat = "server" />

O atributo OnClick define o manipulador de evento que é executado quando o botão é clicado. A
atributo de texto determina a legenda exibida na face do botão. Se utilizado como um botão Enviar, o
atributos CommandName e CommandArgument não são utilizados, caso contrário, no mínimo, a
CommandName atributo, que indica o comando que o botão é para levar a cabo, deve estar presente.
O atributo CommandArguments opcional fornece quaisquer argumentos necessários para executar o comando.



254
 
NET Programação Visual Basic.


O texto, CommandName e CommandArgument todos os atributos correspondem aos nomes idênticos
propriedades da classe System.Web.UI.WebControls.Button.

Quando o botão Enviar for clicado, o manipulador de eventos definido pelo atributo OnClick é executado.
A assinatura do evento é:

Sub OnClickMethod (sender As Object, e As EventArgs)

Para qualquer botão de comando, o evento Command corresponde ao Enviar evento Click do botão,
eo manipulador de eventos definido pelo atributo OnCommand é executado. O manipulador de eventos deve ter
a seguinte assinatura:

Sub OnCommandMethod (sender As Object, e As CommandEventArgs)

O objeto CommandEventArgs tem duas propriedades: CommandName, que corresponde à
CommandName atributo e representa o nome do comando, e CommandArgument, que
corresponde ao atributo CommandArgument e representa um argumento fornecido para o
comando. Estes valores de propriedade podem ser usadas para identificar qual botão foi clicado, no caso de uma
manipulador de eventos único é usado por mais de um controle Button.

6.3.1.2 O controle CheckBox

O controle CheckBox representa uma opção que pode ter um valor de Verdadeiro ou Falso (ou Sim ou Não).
Ela tem a seguinte sintaxe HTML:

<Asp: CheckBox ID = "CheckBoxName"
     AutoPostBack = "true | false"
     Text = "CheckBoxCaption"
     TextAlign = "right | Esquerda"
     Checked = "true | false"
     OnCheckedChanged = "OnCheckedChangedMethod"
     runat = "server" />

O atributo Checked determina se a caixa estará inicialmente marcada. Ela corresponde à
propriedade Checked CheckBox classe, que é um valor booleano. O atributo de texto define a legenda que
parece tanto da esquerda (o padrão) ou à direita da caixa em si, dependendo do valor do
TextAlign atributo. A propriedade Text da classe CheckBox contém igualmente a opção de
legenda, enquanto seu alinhamento é determinado pela propriedade da classe CheckBox TextAlign. O valor da
a propriedade TextAlign é um dos dois membros da enumeração TextAlign: TextAlign.Left,
que posiciona o texto à esquerda da caixa de seleção (o padrão) e TextAlign.Right, que
posiciona o texto à direita da caixa de seleção.

O atributo OnCheckedChanged define um manipulador de eventos que será executado sempre que o
Verificado propriedade da caixa de seleção é alterado. O manipulador de eventos designado pelo
atributo OnCheckedChanged deve ter a seguinte assinatura:

Sub OnCheckedChangeMethod (sender As Object, e As EventArgs)

6.3.1.3 O controle DropDownList

O controle DropDownList permite que o usuário faça uma única seleção em uma caixa de listagem drop-down. A
controle DropDownList tem a seguinte sintaxe HTML:

<asp: DropDownList ID = "DropDownListName" runat = "server"
     DataSource = "<%% databindingexpression>"
     DataTextField = "DataSourceField"


255
 



     DataValueField = "DataSourceField"
     AutoPostBack = "true | false"
     OnSelectedIndexChanged = "OnSelectedIndexChangedMethod">

   value="value" <asp:ListItem selected="True|False">
Texto
   </ Asp: ListItem>

</ Asp: DropDownList>

Ao invés de fornecer os dados ou usando HTML ou de programação, você pode preencher o listbox
a partir de uma fonte de dados. O atributo DataSource define a fonte de dados para que a listagem está vinculada,
o atributo DataTextField define o campo que irá determinar quais os itens que são exibidos na
listbox, eo atributo DataValueField define o campo cujas linhas irá fornecer o valor de cada
lista de itens. Cada um desses atributos corresponde diretamente a uma propriedade do
System.Web.UI.WebControls.DropDownList classe, que também permite que você preencher dinamicamente uma
caixa de listagem suspensa a execução.

Além disso, a classe DropDownList tem duas propriedades importantes que não correspondem aos atributos de
a tag DropDownList. A propriedade SelectedIndex retorna o índice do item selecionado. A
SelectedItem propriedade retorna o objeto ListItem selecionado na lista drop-down. Desde o
objeto DropDownList permite ao usuário selecionar apenas um único item, essas propriedades permitem na maioria dos casos
você pule diretamente trabalhando com objetos ListItem individual.

Se o DropDownList não está vinculado a uma fonte de dados, a marca ListItem é utilizado para definir cada item
da lista. O texto determina o texto do item que é exibido na caixa de listagem. O valor do atributo determina
valor do item. O atributo selecionado determina se o item está inicialmente selecionada quando
a caixa de listagem é exibida.

Finalmente, o atributo OnSelectedIndexChanged define um manipulador de eventos que serão executados
sempre que um novo item é selecionado na caixa de listagem drop-down. O manipulador de eventos designado pelo
atributo OnSelectedIndexChanged deve ter a seguinte assinatura:

Sub OnSelectedIndexChangedMethod (sender As Object, e As EventArgs)

Programática, os itens na caixa de listagem drop-down consistir de objetos ListItem. Estes podem ser
acessada através da propriedade da classe ListBox 'Itens, que retorna um objeto ListItemCollection
consistindo de todos os objetos ListItem na caixa de listagem. Você pode adicionar itens ao final da listagem por
chamando o método do objeto ListItemCollection do Add, que tem a seguinte sintaxe:

ListItemCollection.Add (item)

onde o item é uma string ou um objeto ListItem. Para adicionar um item a um lugar especial no drop-
baixo listbox, você pode chamar o método Insert, que tem a seguinte sintaxe:

ListItemCollection.Insert (índice, item)

onde índice é a posição baseada em zero na caixa de listagem na qual o item deve ser acrescentado e é um item
String ou um objeto ListItem a ser adicionado à lista. Você também pode remover itens da
ListItemCollection chamando seu Remover e RemoveAt métodos. A sintaxe do método Remove
é o seguinte:

ListItemCollection.Remove (item)

onde o item é uma String ou um ListItem objeto representando o item a ser removido. A sintaxe da
RemoveAt método é:



256

 

ListItemCollection.RemoveAt (índice)

 

onde índice é a posição do item a ser removido da lista. O número de itens na

caixa de listagem drop-down é fornecido pela propriedade do objeto ListItemCollection de Contagem.

 

Três propriedades dos objetos ListItem individual também tornam possível o trabalho com os itens na

lista. A propriedade Text contém o texto do objeto ListItem como ele é exibido na caixa de listagem. O Valor

propriedade contém o valor associado ao objeto ListItem. Finalmente, a propriedade Selected retorna um

Booleano que indica se o item é selecionado.

 

6.3.1.4 O controle de imagem

 

A imagem exibe um controle de imagem em uma página web. A sintaxe da linguagem HTML é a seguinte:

 

<asp: Image id = "ImageName" runat = "server"

     ImageUrl = "string"

     AlternateText = "string"

     ImageAlign = "NotSet | base | absmiddle | AbsBottom |

                 Bottom | esquerda | meio | direita | texttop | Top "/>

 

O atributo ImageUrl contém a URL na qual a imagem foi encontrada. O atributo AlternateText

define o texto a ser apresentado no evento que o navegador não suporta ou está configurado

para não exibir imagens. O atributo ImageAlign determina o alinhamento da imagem em relação ao

outros elementos na página. Todos os três atributos correspondem às propriedades de nome idêntico do

Imagem de classe. O valor da propriedade ImageAlign é um membro da enumeração e ImageAlign

pode ser um dos seguintes procedimentos:

 

ImageAlign.AbsBottom

 

A borda inferior da imagem está alinhada com a borda inferior do elemento maior na mesma

linha.

 

ImageAlign.AbsMiddle

 

A meio da imagem é alinhado com o centro da maior elemento na mesma linha.

 

ImageAlign.Baseline

 

A borda inferior da imagem está alinhada com a borda inferior da primeira linha do texto.

 

ImageAlign.Bottom

 

A borda inferior da imagem está alinhada com a borda inferior da primeira linha do texto.

 

ImageAlign.Left

 

A imagem está alinhada com a borda esquerda da página web, com moldagem de texto à direita.

 

ImageAlign.Middle

 

O centro da imagem está alinhada com a borda inferior da primeira linha do texto.

 

ImageAlign.NotSet

 

O alinhamento da imagem não está definido.

 

 

 

257

 

 

 

 

ImageAlign.Right

 

A imagem é alinhada na margem direita da página web, com moldagem de texto à esquerda.

 

ImageAlign.TextTop

 

topo A imagem está alinhada com a borda superior dos maiores de texto na linha.

 

ImageAlign.Top

 

topo A imagem está alinhada com a borda superior do elemento mais alto na mesma linha.

 

6.3.1.5 O controle Label

 

O controle Label normalmente exibe texto estático. Talvez o mais simples dos comandos, que tem o seguinte

sintaxe HTML:

 

<Asp: Label ID = "Label1"

     Text = "rótulo"

     runat = "server" />

 

O texto exibido pelo rótulo é representado pelo atributo Text. Ela corresponde diretamente ao

com nome idêntico de propriedade do controle System.Web.UI.WebControls.Label.

 

6.3.1.6 O controle ListBox

 

O controle ListBox apresenta ao usuário uma lista de itens e permite ao usuário selecionar um único

ou vários itens. O controle ListBox tem a sintaxe HTML abaixo:

 

<Asp: ListBox id = "ListboxName"

     DataSource = "<%% databindingexpression>"

     DataTextField = "DataSourceField"

     DataValueField = "DataSourceField"

     AutoPostBack = "true | false"

     Linhas = "número de linhas"

     SelectionMode = "Single | Múltiplo"

     OnSelectedIndexChanged = "OnSelectedIndexChangedMethod"

     runat = "server">

 

   value="value" <asp:ListItem selected="True|False">

Texto

   </ Asp: ListItem>

 

</ Asp: ListBox>

 

O atributo SelectionMode determina se o usuário pode selecionar apenas um único item (o padrão)

ou vários itens. O atributo linhas determina o número de linhas exibidas na caixa de listagem.

 

Ao invés de fornecer os dados ou usando HTML ou de programação, você pode preencher a caixa de listagem

a partir de uma fonte de dados. O atributo DataSource define a fonte de dados para que a listagem está vinculada,

o atributo DataTextField define o campo que irá determinar quais os itens que são exibidos na

listbox, eo atributo DataValueField define o campo cujas linhas irá fornecer o valor de cada

lista de itens.

 

Cada um desses atributos (SelectionMode, linhas DataSource, DataTextField,

DataValueField) corresponde diretamente a uma propriedade do System.Web.UI.WebControls.ListBox

 

 

258

 

NET Programação Visual Basic.

 

 

classe. O valor da propriedade SelectionMode deve ser um membro do ListSelectionMode

enumeração; seus dois valores possíveis são ListSelectionMode.Single e

ListSelectionMode.Multiple. A propriedade Rows é um inteiro que determina quantas linhas

exibe listbox.

 

Além disso, a classe ListBox tem duas propriedades importantes que não correspondem aos atributos do

ListBox tag. A propriedade SelectedIndex retorna o menor índice de um item selecionado. A

SelectedItem propriedade retorna o objeto ListItem primeiro selecionado no listbox. Para a seleção única

listboxes, essas propriedades retornam o índice do item selecionado eo item selecionado em si,

, respectivamente. Para listboxes multi-seleção, você tem que iterar a coleção ListItemCollection para

determinar quais itens estão selecionados.

 

Se a caixa de listagem não está vinculado a uma fonte de dados, a marca ListItem é utilizado para definir cada item na lista.

O texto determina o texto do item que é exibido na caixa de listagem. O valor do atributo determina o

valor do item. O atributo selecionado determina se ou não o item é inicialmente selecionado quando o

listagem é exibida.

 

Finalmente, o atributo OnSelectedIndexChanged define um manipulador de eventos que serão executados

sempre que um novo item é selecionado no listbox. O manipulador de eventos designado pelo

atributo OnSelectedIndexChanged deve ter a seguinte assinatura:

 

Sub OnSelectedIndexChangedMethod (sender As Object, e As EventArgs)

 

Programática, os itens da listbox consistir de objetos ListItem. Elas podem ser acessadas através de

propriedade da classe ListBox 'Itens, que retorna um objeto ListItemCollection composto por todos os

objetos ListItem na caixa de listagem. Você pode adicionar itens ao final da listagem, chamando o

método ListItemCollection objeto Add, que tem a seguinte sintaxe:

 

ListItemCollection.Add (item)

 

onde o item é uma string ou um objeto ListItem. Para adicionar um item a um lugar especial na caixa de listagem,

você pode chamar o método Insert, que tem a seguinte sintaxe:

 

ListItemCollection.Insert (índice, item)

 

onde índice é a posição baseada em zero na caixa de listagem na qual o item deve ser acrescentado e é um item

String ou um objeto ListItem a ser adicionado à lista. Você também pode remover itens da

ListItemCollection chamando seu Remover e RemoveAt métodos. A sintaxe do método Remove

é o seguinte:

 

ListItemCollection.Remove (item)

 

onde o item é uma String ou um ListItem objeto representando o item a ser removido. A sintaxe da

RemoveAt método é:

 

ListItemCollection.RemoveAt (índice)

 

onde índice é a posição do item a ser removido da lista. O número de itens na

listbox é fornecido pela propriedade do objeto ListItemCollection de Contagem.

 

Três propriedades dos objetos ListItem individual também tornam possível o trabalho com os itens na

lista. A propriedade Text contém o texto do objeto ListItem como ele é exibido na caixa de listagem. O Valor

propriedade contém o valor associado ao objeto ListItem. Finalmente, a propriedade Selected retorna um

Booleano que indica se o item é selecionado. No caso de caixas de listagem de seleção múltipla, você pode

determinar se um item é selecionado iterando os membros do objeto ListItemCollection e

examinando a propriedade Selected de cada um, como mostra o seguinte fragmento de código:

 

 

259

 

 

 

 

Como ListItem Dim oList

Para cada oList Em oListBox.Items

   Se oList.Selected seguida

      "Faça alguma coisa

   End If

Seguinte

 

6.3.1.7 O controle RadioButton

 

O controle RadioButton corresponde a um único botão em um grupo de botões usados para indicar mutuamente

opções exclusivas. Ela tem a seguinte sintaxe HTML:

 

<Asp: RadioButton id = "RadioButtonName"

     AutoPostBack = "true | false"

     Checked = "true | false"

     GroupName = "GroupName"

     Text = "rótulo"

     TextAlign = "right | Esquerda"

     OnCheckedChanged = "OnCheckedChangedMethod"

     runat = "server" />

 

Tal como no controle CheckBox, o atributo Checked determina se o controle é verificada. Só

um controle no grupo designado por GroupName pode ser definida como True. O valor padrão do

atributo CHECKED é False. No entanto, uma vez que é possível para o Checked atributos de todas as rádio

botões de um grupo para ser falsa, é importante inicialmente definir o atributo checked de um membro da

o grupo a True. O atributo GroupName fornece um nome comum pelo qual todos os botões de rádio em

o grupo pode ser identificado. O atributo de texto define a legenda que aparece tanto para a esquerda (o

padrão) ou à direita do botão de rádio, dependendo da configuração do atributo TextAlign.

 

Cada um desses atributos do controle RadioButton corresponde diretamente a um nome idêntico

propriedade da classe System.Web.UI.WebControls.RadioButton. O valor da propriedade é TextAlign

qualquer um dos dois membros da enumeração TextAlign: TextAlign.Left, que posiciona o texto

à esquerda da caixa de seleção (o padrão) e TextAlign.Right, que posiciona o texto à direita

da caixa de seleção. A propriedade Checked é um booleano que pode ser definido através de programação e também pode

mudar como resultado da interação do usuário. Observe que o usuário mudar a propriedade Checked de outro

botão de opção no grupo de False para True muda automaticamente o valor do Checked

bens de qualquer botão de rádio controlados de True para False.

 

Finalmente, o atributo OnCheckedChanged define um manipulador de evento que será executado sempre que

a propriedade Checked do botão de rádio é alterado. O manipulador de eventos designado pelo

atributo OnCheckedChanged deve ter a seguinte assinatura:

 

Sub OnCheckedChangedMethod (sender As Object, e As EventArgs)

 

6.3.1.8 O controle da Tabela

 

O controle de quadro corresponde a uma tabela que consiste em várias linhas, cada uma com mais ou

colunas. Uma tabela não precisam ser simétricas, ou seja, ele não precisa ter o mesmo número de colunas em

cada linha. O controle de mesa tem a sintaxe HTML abaixo:

 

<Asp: Table id = "TableName"

     BackImageUrl = "url"

     Cellspacing = "cellspacing"

     Cellpadding = "cellpadding"

     GridLines = "Nenhuma | Horizontal | Vertical | Tanto"

     HorizontalAlign = "Center | Justificar | left | NotSet | Direito"

     runat = "server">

 

 

260

 

 

 

 

 

   <asp:TableRow>

 

      <asp:TableCell>

texto da célula

      </ Asp: TableCell>

 

   </ Asp: TableRow>

 

</ Asp: Table>

 

NET Programação Visual Basic.

 

 

A marca TableRow define uma nova linha da tabela, enquanto a marca TableCell define uma nova célula dentro de um

linha específica. O conteúdo da célula individual são definidos pelo texto da célula. O HorizontalAlign

atributo determina o alinhamento horizontal da tabela na página. O atributo GridLines

determina a aparência das linhas de grade da tabela. O atributo CellSpacing determina o

número de pixels que separam as células individuais da tabela, enquanto o atributo CellPadding

determina o número de pixels entre a borda da célula e seu conteúdo. O BackImageUrl

atributo contém a URL de uma imagem a ser usada como fundo para a tabela.

 

Cada um desses atributos corresponde a uma propriedade com nome idêntico da classe Table. A

propriedades CellPadding e CellSpacing são do tipo Integer. O valor da propriedade HorizontalAlign

é um dos seguintes membros da enumeração HorizontalAlign: Centro, Justificar, Esquerda,

NotSet e Direita. O valor da propriedade GridLines é um dos seguintes membros do

GridLines enumeração: Ambos, Nenhum horizontal e vertical.

 

Você manipular programaticamente uma tabela através da manipulação de suas linhas e suas células individuais. A tabela

linhas são acessíveis através da propriedade do objeto de tabela de linhas, que retorna um TableRowCollection

objeto contendo objetos TableRow que representam as linhas da tabela. O TableRowCollection

coleção permite que você adicione linhas ao final do quadro chamando seu método Add, que tem o

seguinte sintaxe:

 

TableRowCollection.Add (

linha)

 

que linha é um objeto TableRow que representa uma linha da tabela. Para adicionar uma linha para um determinado local

na tabela, você pode chamar o método Insert, que tem a seguinte sintaxe:

 

TableRowCollection.Insert (índice de linha)

 

onde índice é a posição baseada em zero na tabela em que a linha deve ser adicionada e é uma linha

RowTable objeto que representa a linha a ser adicionada à tabela. Você também pode remover linhas da

tabela, chamando métodos Remove e RemoveAt o objeto do TableRowCollection. A sintaxe da

Remover método é:

 

TableRowCollection.Remove (linha)

 

em linha é uma TableRow objeto que representa a linha a ser excluída. A sintaxe da RemoveAt

método é:

 

TableRowCollection.RemoveAt (índice)

 

onde índice é a posição da linha a ser removida da tabela. O número de itens na tabela

é fornecida pela propriedade do objeto TableRowCollection de Contagem. Objetos individuais TableRow

representando as linhas individuais da tabela podem ser recuperadas usando a propriedade Item, cuja sintaxe é:

 

TableRowCollection.Item (índice)

 

 

 

261

 

 

 

 

 

onde índice é a posição baseada em zero ordinal da linha cujo TableRow objeto que você deseja

recuperar.

 

Depois de ter recuperado uma referência a uma linha da tabela individual, você pode usar sua propriedade Cells para recuperar

uma referência a um objeto TableCellCollection, que contém uma coleção de objetos TableCell

representando as células individuais da linha. Como a classe TableRowCollection, o TableCellCollection

classe possui membros para acrescentar e remover as células individuais, bem como para determinar quantas células estão em

da coleção. Sua sintaxe para adicionar e remover células é idêntico ao do TableRowCollection

classe, exceto que os objetos TableCell são usadas em vez de objetos TableRow. Finalmente, para recuperar um

célula individual, você usa o método do objeto TableCellCollection do item, que tem a seguinte sintaxe:

 

TableCellCollection.Item (índice)

 

onde índice é a posição baseada em zero ordinal da célula na linha. A propriedade retorna um TableCell

objeto que representa a célula.

 

Finalmente, a classe TableCell tem um número de propriedades que controlam o conteúdo e aparência do

célula. A propriedade de texto determina o conteúdo da célula. As Boolean propriedade Wrap determina se

o conteúdo do envoltório celular na cela, e seu valor padrão é True. O RowSpan e ColumnSpan

propriedades são valores inteiros que indicam quantas linhas da tabela e quantas colunas da tabela a célula

vãos. A propriedade HorizontalAlign, cujo valor é um membro da enumeração HorizontalAlign

discutido anteriormente nesta seção, determina o alinhamento horizontal do conteúdo da célula. A

propriedade VerticalAlign determina o alinhamento vertical do conteúdo da célula. Seu valor deve ser um

membro da enumeração VerticalAlign, que tem os seguintes membros: Baixo, Médio,

NotSet e Top.

 

6.3.1.9 O controle TextBox

 

O controle TextBox corresponde a uma única caixa de texto ou de várias linhas para a exibição de informações e

ficando entrada textual do usuário. Ela tem a seguinte sintaxe HTML:

 

<Asp: TextBox ID = "TextBoxName"

     AutoPostBack = "true | false"

     Colunas = "personagens"

     MaxLength = "personagens"

     Linhas = "linhas"

     Texto = "text"

     TextMode = "Single | Senha | Multiline"

     Wrap = "true | false"

     OnTextChanged = "OnTextChangedMethod"

     runat = "server" />

 

O atributo de texto define o texto atual a ser armazenados na caixa de texto quando o controle é processado.

O atributo Colunas determina o número de caracteres que o texto exibe a caixa, enquanto o

atributo MaxLength determina o número total de caracteres que podem ser introduzidos na caixa de texto.

O atributo TextMode determina se o controle TextBox tem uma linha (o padrão), várias

linhas ou uma única linha em que o usuário está a digitar uma senha. Para uma caixa de texto multi-linha, as linhas

atributo determina quantas linhas a caixa de texto eo atributo automático determina se

texto é moldado para a próxima linha. Por padrão, o envoltório é falso, a entrada será exibido em uma única linha até o

usuário insere um retorno de carro.

 

Cada um desses atributos corresponde diretamente a uma propriedade com nome idêntico do

System.Web.UI.WebControls.TextBox classe. As propriedades MaxLength, colunas e linhas são de

Tipo inteiro e todos têm um valor padrão de 0. No caso de a propriedade MaxLength, isso significa que

não há limite para o número de caracteres que pode ser entrada para a caixa de texto. Para as colunas e

Linhas propriedades, isso significa que tantas colunas ou (no caso das caixas de texto multi-linha) linhas,

possível, serão exibidos com base no tamanho da caixa de texto. O valor do imóvel deve TextMode

 

 

262

 

NET Programação Visual Basic.

 

 

ser um membro da enumeração TextBoxMode; valores possíveis são TextBoxMode.SingleLine

(O padrão), TextBoxMode.MultiLine e TextBoxMode.Password. A propriedade de texto, de

Claro, é a propriedade mais importante do controle. Seu valor inclui qualquer retorno e

caracteres de nova linha (o carácter vbCrLf) digitado pelo usuário, se a propriedade TextMode é definida como

TextBoxMode.MultiLine. Além disso, se a propriedade é definida como TextMode TextBoxMode.Password,

asteriscos são exibidos sempre que o usuário entra em um personagem, no entanto, a entrada de cadeia efectiva pela

usuário é armazenado como está na propriedade Text.

 

Finalmente, o atributo OnTextChanged define um manipulador de eventos que será executado sempre que o

Texto de propriedade da caixa de texto é alterado. O manipulador de eventos designado pelo OnTextChanged

atributo deve ter a seguinte assinatura:

 

Sub OnTextChangedMethod (sender As Object, e As EventArgs)

 

6.3.1.10 Outros controles web

 

Os controles restantes definidos no namespace System.Web.UI.WebControls são:

 

AdRotator

 

Exibe um anúncio. O controle AdRotator pode ser configurado para mostrar um anúncio diferente cada

vez que a página é visualizada.

 

Calendário

 

Exibe um calendário de um mês na página da web e permite ao usuário selecionar uma data.

 

CheckBoxList

 

Mostra um grupo de checkboxes na página web.

 

CompareValidator

 

Valida o valor inserido em um controle, comparando-a com o valor em outro controle ou a um

valor constante. Veja Secção 6.4 mais adiante neste capítulo para obter mais informações.

 

CustomValidator

 

Valida o valor inserido em um controle executando o código de validação personalizada. Consulte a Seção

6,4 mais adiante neste capítulo para obter mais informações.

 

DataGrid

 

Exibe os valores de uma fonte de dados em um formato de tabela na página web. Consulte o Capítulo 8 para

mais informações.

 

DataGridItem

 

Representa uma linha no controle DataGrid.

 

DataList

 

Exibe os valores de uma fonte de dados em um formato de controle de lista na página da web.

 

DataListItem

 

 

263

 

 

 

 

Representa um item no controle DataList.

 

HyperLink

 

Exibe um link para outra página web. O link pode ser de texto ou uma imagem.

 

ImageButton

 

Exibe uma imagem na página web. Este controle é diferente do controle da imagem em que

gera um evento no lado do servidor quando a imagem for clicado.

 

LinkButton

 

Exibe um link para outra página web. O controle LinkButton tem a mesma aparência que o

HyperLink controle, mas tem o mesmo comportamento que o controle Button.

 

Literal

 

Exibe o texto estático na página web.

 

Painel

 

Contém outros controles na página web.

 

RadioButtonList

 

Exibe uma lista de botões de rádio na página da web.

 

RangeValidator

 

Valida o valor inserido em um controle, comparando-a com um determinado intervalo de valores. Veja

Secção 6.4 mais adiante neste capítulo para obter mais informações.

 

RegularExpressionValidator

 

Valida o valor inserido em um controle combinando-o contra uma determinada expressão regular.

Veja Seção 6.4 para mais informações.

 

RequiredFieldValidator

 

Valida um valor digitado em um controle, garantindo que o valor é diferente do

valor original do controle. Veja Seção 6.4 para mais informações.

 

TableHeaderCell

 

Representa uma célula de cabeçalho em um controle Table.

 

ValidationSummary

 

Exibe um resumo dos erros de validação na página web. Veja Seção 6.4 para mais

da informação.

 

 

 

 

 

 

 

264

 

 

 

 

6.3.2 Controles HTML

 

NET Programação Visual Basic.

 

 

Os controles definidos no namespace System.Web.UI.HtmlControls são:

 

HtmlAnchor

 

Quebra o tag <a> HTML.

 

HtmlButton

 

Quebra o <button> tag HTML.

 

HtmlForm

 

Quebra o tag <form> HTML.

 

HtmlGenericControl

 

Representa qualquer tag HTML (como <body>) que não é envolvida por um servidor específico de HTML

controle.

 

HtmlImage

 

Quebra o tag HTML IMG.

 

HtmlInputButton

 

Quebra o type="button"> <input HTML, type="submit"> <input e <entrada

type = "reset" tags>.

 

HtmlInputCheckBox

 

Quebra a tag HTML <input type="checkbox">.

 

HtmlInputFile

 

Quebra a tag HTML <input type="file">.

 

HtmlInputHidden

 

Quebra a tag HTML type="hidden"> <input.

 

HtmlInputImage

 

Quebra a tag HTML <input type="image">.

 

HtmlInputRadioButton

 

Quebra a tag HTML type="radio"> <input.

 

HtmlInputText

 

Quebra o type="text"> <input tags HTML e type="password"> <input.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

265

 

 

 

 

 

HtmlSelect

 

Quebra o <select> tag HTML.

 

HtmlTable

 

Quebra o tag <table> HTML.

 

HtmlTableCell

 

Quebra o <td> tags HTML e <th>.

 

HtmlTableRow

 

Quebra o tag <tr> HTML.

 

HtmlTextArea

 

Quebra o <textarea> tag HTML.

 

6.3.3 Controle de Tratamento de eventos

 

Controles em um formulário web são representadas na classe code-behind como campos de campo, uma para cada controle.

Por exemplo, quando o Visual Studio. NET Web Forms Designer é usado para adicionar uma caixa de texto a um formulário,

A declaração seguinte é adicionado à classe code-behind:

 

Protegido WithEvents TextBox1 Como System.Web.UI.WebControls.TextBox

 

Esta declaração não instanciar o controle, mas apenas define um campo que pode conter uma referência a um

controle do tipo TextBox. Além disso, o designer adiciona essa tag na página web:

 

id = TextBox "TextBox1": <asp

   style = "Z-INDEX: 105; ESQUERDA: 8px; position: absolute;

   TOP: "runat =" 8px servidor ">

</ Asp: TextBox>

 

A marca <asp:TextBox> significa que o ASP.NET deve instanciar um controle TextBox quando um navegador

pedidos desta página. A id = "TextBox1" nomes de atributos do controle TextBox1. Esse nome é o que

associa o controle com o campo TextBox1 na classe code-behind.

 

Se o código por trás não está sendo usado, não é necessário declarar uma variável de membro para manter uma referência

para o controle. A estrutura do ASP.NET implicitamente fazer isso quando a página é compilada.

 

Conforme discutido no Capítulo 2, quando uma declaração de campo inclui a palavra-chave WithEvents, o

classe que contém pode manipular eventos gerados pelo objeto referenciado. Para isso, a classe que contém

define um método manipulador com uma assinatura correspondente à assinatura do evento. O método inclui manipulador

uma cláusula Handles para vincular o método para o evento desejado sobre o objeto. Por exemplo, aqui é o

definição de um método de manipulador para o evento TextChanged do TextBox1:

 

Private Sub TextBox1_TextChanged (_

   ByVal sender As System.Object, _

   ByVal e As System.EventArgs _

) Handles TextBox1.TextChanged

   '...

End Sub

 

 

266

 

NET Programação Visual Basic.

 

 

O método de manipulador de eventos pode ser dado qualquer nome, mas é uma convenção comum a utilização de um nome de

o FieldName_EventName formulário.

 

Também por convenção, as assinaturas de eventos para controles em conformidade com a assinatura mostrada, com excepção

do parâmetro e ser algum outro tipo derivado do tipo EventArgs. O parâmetro do remetente

passados para o método manipulador tem uma referência ao objeto que disparou o evento, eo parâmetro e

mantém uma referência a um objeto que fornece qualquer informação extra necessária para o evento. Eventos que

passar um argumento EventArgs genéricos não têm informações sobre o evento para passar. Eventos que passar um argumento

de um tipo derivado de EventArgs passar informações adicionais dentro dos campos do objeto passado.

 

Você pode determinar a assinatura correta para lidar com um evento específico, referindo-se a de controle

documentação ou usando o Visual Studio. NET embutido no navegador de objetos. Além disso, o Visual

Studio. NET Web Forms Designer gera automaticamente uma declaração de método manipulador para qualquer

caso exposto por qualquer controle sobre uma determinada forma.

 

6.3.4 Instanciando controles programaticamente

 

É fácil instanciar dinamicamente controles de servidor em tempo de execução. Um local conveniente para fazer isso está em um

substituição do método OnPreRender da classe Page. Lembre-se que o método é chamado OnPreRender

após a página e seus controles foram instanciados e inicializados, mas antes de qualquer processamento.

Controles criados aqui e adicionados à coleção do objeto Página Controls será processado na página.

O código é simples:

 

Private WithEvents ctl Como TextBox

 

Substitui Protegido OnPreRender Sub (ByVal e As EventArgs)

 

   'Instanciar um controle TextBox e definir algumas de suas propriedades.

   ctl = New TextBox ()

   ctl.ID = "TextBox1"

   ctl.Text = "Esta é a minha caixa de texto."

 

   »Adicionar o controle à página.

   Me.Controls.Add (CTL)

   "Vamos aumentar a classe base do evento PreRender.

   MyBase.OnPreRender (e)

 

End Sub

 

Este código pode ser colocado em uma classe code-behind ou diretamente dentro de um bloco <script> no aspx o.

página.

 

A propriedade Controls da classe Page é de ControlCollection tipo. O método Add da

classe ControlCollection adiciona o controle dado ao final da coleção. Visualmente, o recém-adicionada

controle aparece como o último elemento na página processada. Para adicionar o controle em um local específico em

a coleção, use o método da classe ControlCollection AddAt é. A sintaxe do método AddAt parece

isso:

 

Público AddAt Sub Overridable (_

   ByVal índice As Integer, _

   ByVal criança Como System.Web.UI.Control)

 

Os parâmetros do método AddAt são:

 

Índice

 

 

 

 

267

 

 

 

 

 

 

 

 

criança

 

 

 

 

Especifica a posição na coleção na qual se insere o novo controle. Este número é zero

base.

 

 

 

Especifica o controle para adicionar à coleção.

 

 

O método AddAt é ainda mais útil quando usado com IndexOf da classe ControlCollection's

método. O método IndexOf retorna o índice inteiro dentro da coleção de um determinado controle. Para

exemplo, supondo que uma página web tem um controle chamado Label2 e que a variável contém um ctl

referência a um controle recém-criada, a linha a seguir adiciona o novo controle para a página, tornando-o

imediatamente antes do controle Label2:

 

Me.Controls.AddAt (Me.Controls.IndexOf (Label2) ctl)

 

6,4 Adicionando Validação

 

Validando entrada de usuário é uma exigência comum de qualquer aplicativo que depende que o usuário forneça

de dados. A estrutura do ASP.NET fornece ferramentas para fazer a validação de entrada fácil. ASP.NET suporta

validação, fornecendo controles de servidor que lidar com o processo de validação. Cada controle de servidor colocado

em um formulário é responsável por validar o valor em algum outro controle no formulário. A validação

processo ocorre tanto no cliente (se o navegador for capaz) e no servidor, ou apenas no servidor (se

o navegador não pode lidar com isso). Validação ocorre no servidor, mesmo que ocorre no cliente, proibir a

cliente hostil de envio de dados inválidos.

 

Os controles de servidor que se relacionam com a validação são:

 

CompareValidator

 

Compara o valor em um controle com um valor constante ou o valor em outro controle.

O desenvolvedor escolhe a comparação a ser executada (igual, inferior, superior, etc.)

A validação for bem-sucedido se a comparação for True.

 

CustomValidator

 

Permite que o aplicativo para executar a lógica de validação que não está previsto pela norma

controles de comparação.

 

RangeValidator

 

Compara o valor de um controle para um determinado intervalo. A validação bem-sucedida se o valor for

dentro do intervalo.

 

RegularExpressionValidator

 

Compara o valor de um controle para uma determinada expressão regular. A validação bem-sucedida se o

valor é correspondido pela expressão regular.

 

RequiredFieldValidator

 

Verifica se um valor que foi digitado em um controle. A validação bem-sucedida se o valor for

não vazio.

 

ValidationSummary

 

Fornece um resumo na tela dos erros de validação que ocorreram na página.

 

 

268

 

 

NET Programação Visual Basic.

 

 

Esses controles são definidos no namespace System.Web.UI.WebControls.

 

O primeiro passo para usar controles de validação é a construção de uma página da web da maneira usual. Exemplo 6-6 mostra

o código para uma página simples de entrada de dados na web. Controles de validação ainda não foram adicionados a esta página

que será feito em seguida. Figura 6-8 mostra a tela resultante.

 

Figura 6-8. A saída do Exemplo 6-6

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Exemplo 6-6. Um formulário web simples entrada de dados

<% @ Page Explicit = "True" Strict = "true"%>

 

<html>

 

   <head>

      <title> Validação de Teste </ title>

   </ Head>

 

   <body>

      <form action="ValidationTest.aspx" method="post" runat="server">

         <table>

            <tr>

               <td Align="right"> Nome completo: </ td>

               <asp:TextBox <td> id="txtFullName" runat="server" /> * </ td>

            </ Tr>

            <tr>

               <td align="right"> Cargo: </ td>

               <asp:TextBox <td> id="txtJobTitle" runat="server" /> </ td

 

 

269

 

 

 

 

            </ Tr>

            <tr>

               <td Align="right"> Empresa: </ td>

               <asp:TextBox <td> id="txtCompany" runat="server" /> </ td>

            </ Tr>

            <tr>

               <td align="right"> Endereço Linha 1: </ td>

               <td> <asp: TextBox ID = "txtAddressLine1" runat = "server"

/>*</ Td>

            </ Tr>

            <tr>

               <td align="right"> Linha de endereço 2: </ td>

               <asp:TextBox <td> id="txtAddressLine2" runat="server" /> </ td>

            </ Tr>

            <tr>

               <td align="right"> Cidade: </ td>

               <asp:TextBox <td> id="txtCity" runat="server" /> * </ td>

            </ Tr>

            <tr>

               <td align="right"> Estado / Província: </ td>

               <td> <asp: TextBox ID = "txtStateProvince" runat = "server"

/>*</ Td>

            </ Tr>

            <tr>

               <td align="right"> CEP: </ td>

               <asp:TextBox <td> id="txtPostalCode" runat="server" /> * </ td>

            </ Tr>

            <tr>

               <td align="right"> País: </ td>

               <asp:TextBox <td> id="txtCountry" runat="server" /> </ td>

            </ Tr>

            <tr>

               <td align="right"> Telefone Comercial: </ td>

               <td> <asp: TextBox ID = runat "txtBusinessPhone" = "server"

/> </ Td>

            </ Tr>

            <tr>

               <td align="right"> Telefone Residencial: </ td>

               <asp:TextBox <td> id="txtHomePhone" runat="server" /> </ td>

            </ Tr>

            <tr>

               <td align="right"> Fax comercial: </ td>

               <asp:TextBox <td> id="txtBusinessFax" runat="server" /> </ td>

            </ Tr>

            <tr>

               <td align="right"> E-mail: </ td>

               <asp:TextBox <td> id="txtEmailAddress" runat="server" /> </ td>

            </ Tr>

            <tr>

               <td Align="right"> Aniversário: </ td>

               <asp:TextBox <td> id="txtBirthday" runat="server" /> </ td>

            </ Tr>

            <tr>

               colspan="2"> <td

                  * <i> Itens marcados com um asterisco são obrigatórios. </ I>

               </ Td>

            </ Tr>

            <tr>

               <td colspan="2" align="center">

                  <asp: button id = "text btnSubmit" = "Enviar" runat = "server"

/>

 

 

270

 

 

 

 

               </ Td>

            </ Tr>

         </ Table>

      </ Form>

   </ Body>

 

</ Html>

 

NET Programação Visual Basic.

 

 

Controles de validação podem ser adicionados manualmente no código ou graficamente usando o Web Forms

Designer no Visual Studio. NET. Esta seção mostra como adicionar os controles em código. Todos os

informações contidas nesta seção também é aplicável quando se utiliza o Visual Studio. NET.

 

As validações seguinte será acrescentado o código no Exemplo 6-6:

 

• Nome Completo, Endereço Linha 1, Cidade, Estado / Província, e CEP será de preenchimento obrigatório.

• Se o endereço de email está preenchido, será marcada para o formato correto.

• Se o aniversário é digitada, ele irá ser verificados para garantir que a data inserida é o mais tardar no

data atual do sistema no servidor web.

 

O código modificado é mostrado no Exemplo 6-7. Código que difere do Exemplo 6-6 é mostrado em negrito.

 

Exemplo 6-7. Um formulário web simples entrada de dados com controles de validação

<% @ Page Explicit = "True" Strict = "true"%>

 

language="vb" runat="server"> <script

 

   Private Sub Page_Load (ByVal sender As Object, ByVal e As EventArgs)

      cmpBirthday.ValueToCompare DateTime.Today.ToString = ("yyyy-MM-dd")

   End Sub

 

</ Script>

 

<html>

 

   <head>

      Validação <title> Teste 2 </ title>

   </ Head>

 

   <body>

      <form action="ValidationTest2.aspx" method="post" runat="server">

         <table>

            <tr>

               <td Align="right"> Nome completo: </ td>

               <asp:TextBox <td> id="txtFullName" runat="server" /> * </ td>

               <td>

                  <asp: RequiredFieldValidator ID = "recFldFullName"

                     ControlToValidate = "txtFullName"

                     ErrorMessage = "Nome completo é necessário."

                     runat = "server" />

               </ Td>

            </ Tr>

            <tr>

               <td align="right"> Cargo: </ td>

               <asp:TextBox <td> id="txtJobTitle" runat="server" /> </ td

            </ Tr>

            <tr>

               <td Align="right"> Empresa: </ td>

               <asp:TextBox <td> id="txtCompany" runat="server" /> </ td>

            </ Tr>

 

 

271

 

 

 

 

 

            <tr>

               <td align="right"> Endereço Linha 1: </ td>

               <td> <asp: TextBox ID = "txtAddressLine1" runat = "server"

/>*</ Td>

               <td>

                  <Asp: RequiredFieldValidator ID = "recFldAddressLine1"

                     ControlToValidate = "txtAddressLine1"

                     ErrorMessage = "Linha de endereço 1 é necessária."

                     runat = "server" />

               </ Td>

            </ Tr>

            <tr>

               <td align="right"> Linha de endereço 2: </ td>

               <asp:TextBox <td> id="txtAddressLine2" runat="server" /> </ td>

            </ Tr>

            <tr>

               <td align="right"> Cidade: </ td>

               <asp:TextBox <td> id="txtCity" runat="server" /> * </ td>

               <td>

                  <asp: RequiredFieldValidator ID = "recFldCity"

                     ControlToValidate = "txtCity"

                     ErrorMessage = "City é necessária."

                     runat = "server" />

               </ Td>

            </ Tr>

            <tr>

               <td align="right"> Estado / Província: </ td>

               <td> <asp: TextBox ID = "txtStateProvince" runat = "server"

/>*</ Td>

               <td>

                  <asp: RequiredFieldValidator ID = "recFldStateProvince"

                     ControlToValidate = "txtStateProvince"

                     ErrorMessage = "Estado / Província é necessária."

                     runat = "server" />

               </ Td>

            </ Tr>

            <tr>

               <td align="right"> CEP: </ td>

               <asp:TextBox <td> id="txtPostalCode" runat="server" /> * </ td>

               <td>

                  <asp: RequiredFieldValidator ID = "recFldPostalCode"

                     ControlToValidate = "txtPostalCode"

                     ErrorMessage = "CEP é necessária."

                     runat = "server" />

               </ Td>

            </ Tr>

            <tr>

               <td align="right"> País: </ td>

               <asp:TextBox <td> id="txtCountry" runat="server" /> </ td>

            </ Tr>

            <tr>

               <td align="right"> Telefone Comercial: </ td>

               <td> <asp: TextBox ID = runat "txtBusinessPhone" = "server"

/> </ Td>

            </ Tr>

            <tr>

               <td align="right"> Telefone Residencial: </ td>

               <asp:TextBox <td> id="txtHomePhone" runat="server" /> </ td>

            </ Tr>

            <tr>

               <td align="right"> Fax comercial: </ td>

 

 

272

 

NET Programação Visual Basic.

 

 

               <asp:TextBox <td> id="txtBusinessFax" runat="server" /> </ td>

            </ Tr>

            <tr>

               <td align="right"> E-mail: </ td>

               <asp:TextBox <td> id="txtEmailAddress" runat="server" /> </ td>

               <td>

                  <asp: RegularExpressionValidator id = "regExEmailAddress"

                     ControlToValidate = "txtEmailAddress"

                     ErrorMessage = "Formato de e-mail deve ser name@company.com".

                     ValidationExpression =

                        "^ [\ W-] + @ [\ w-] + \. (COM | rede | Edu | | org mil) $"

                     runat = "server" />

               </ Td>

            </ Tr>

            <tr>

               <td Align="right"> Aniversário: </ td>

               <asp:TextBox <td> id="txtBirthday" runat="server" /> </ td>

               <td>

                  <asp: CompareValidator id = "cmpBirthday"

                     ControlToValidate = "txtBirthday"

                     Type = "Data"

                     Operador = "LessThanEqual"

                     ErrorMessage = "aniversário não deve ser posterior a hoje".

                     runat = "server" />

               </ Td>

            </ Tr>

            <tr>

               colspan="2"> <td

                  * <i> Itens marcados com um asterisco são obrigatórios. </ I>

               </ Td>

            </ Tr>

            <tr>

               <td colspan="2" align="center">

                  <asp: button id = "text btnSubmit" = "Enviar" runat = "server"

/>

               </ Td>

            </ Tr>

         </ Table>

      </ Form>

   </ Body>

 

</ Html>

 

Quando a página web do Exemplo 6-7 é exibida em um navegador, parece idêntica à Figura 6-8.

O que há de diferente nesta versão é que se algum dos campos obrigatórios estão vazios, se o campo Endereço de email

não está no formato correto, ou se o campo contém uma data de aniversário, no futuro, as mensagens adequadas

são mostrados quando o usuário clica no botão Enviar. Figura 6-9 mostra a tela resultante. Note-se que

na tela do computador, as mensagens de erro são mostradas em vermelho por default.

 

Figura 6-9. A saída do Exemplo 6-7 quando os campos estão em falta ou

inválido

 

 

 

 

 

 

 

 

 

 

 

273

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Observe o seguinte no Exemplo 6-7:

 

• Para fazer os campos de dados necessários, controles RequiredFieldValidator foram adicionados, um por campo.

• Proibir entradas inválidas no campo Endereço de e-mail, um controle RegularExpressionValidator

foi acrescentado [1].

 

[1] A expressão regular usada aqui é uma simples retirada da documentação da Microsoft. Isso corresponde apenas a mais simples

endereços de e-mail do user@company.com forma e não deve ser utilizado em sistemas de produção. Acontece que a adequação

Endereços de email da Internet, no caso geral não é uma tarefa trivial. Veja o livro Dominando Expressões Regulares por Jeffrey

EF Friedl (O'Reilly) para uma descrição do problema e sua solução.

 

• Proibir datas futuras no campo de aniversário, um controle CompareValidator foi adicionado. Nota

que o valor para o qual se comparar (a data atual) não pode ser especificado dentro do

tag <asp:CompareValidator>, então isso foi codificado no método Page_Load perto do topo

do exemplo.

 

O controle RequiredFieldValidator é o controle de validação só

que verifica se há uma entrada em falta. A validação de outros controlos

desempenhar as suas validações somente se os dados foram inseridos no

campos correspondentes. Se não tiverem sido introduzidos dados, validação da

bem-sucedido. Se for necessário para reforçar a entrada de um campo, um

controle RequiredFieldValidator deve ser usado para além de qualquer

validação de outros controles associados com o campo.

 

 

 

 

 

 

274

 

NET Programação Visual Basic.

 

 

6.4.1 Mais sobre o Tag Control Validação Atributos

 

Além dos atributos suportados por todos os controles da Web, os controles de validação reconhecer a

seguintes atributos dentro de suas respectivas marcas:

 

ControlToValidate

 

Representa o nome do controle para validar, como determinado pela propriedade do controle de identificação.

 

Mostrar

 

Especifica se o espaço visual para a mensagem de erro deve ser reservado na página web,

mesmo se a mensagem não está sendo exibido atualmente. Os valores possíveis são:

 

"Dynamic"

 

Espaço para a mensagem de erro é adicionado à página, se a validação falhar.

 

"Static"

 

Espaço para a mensagem de erro é adicionado à página, independentemente de a mensagem é

realmente mostrado. Este é o padrão.

 

"Nenhum"

 

A mensagem de erro não é exibida, mesmo se a validação falhar. Esta configuração é usada quando o

mensagem de erro é exibida apenas em um controle de resumo de validação.

 

EnableClientSideScript

 

Especifica se a permitir a validação do lado do cliente (se for suportado pelo navegador). O padrão é

"True".

 

ErrorMessage

 

Fornece a mensagem exibida para o usuário se a validação falhar. O padrão é uma seqüência vazia.

 

ForeColor

 

Define a cor em que a mensagem de erro é exibida. O padrão é "vermelho". Os valores válidos

para este atributo é dado pela estrutura de cor (definida no namespace System.Drawing).

Veja Capítulo 4 para informações sobre a estrutura de cores.

 

O controle CompareValidator reconhece esses atributos adicionais:

 

ControlToCompare

 

O nome do controle que contém o valor para comparar. Se este atributo for especificado, o

ValueToCompare atributo não deve ser especificado.

 

Operador

 

A comparação a ser realizada. Os valores possíveis são:

 

"DataTypeCheck"

 

 

275

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Tipo

 

 

 

 

Validação for bem-sucedido se o valor no controle para validar pode converter para o tipo especificado pelo

o atributo Type.

 

"Equal"

 

Validação for bem-sucedido se o valor no controle para validar é igual ao valor de comparação.

 

"GreaterThan"

 

Validação for bem-sucedido se o valor no controle para validar é maior que o valor de comparação.

 

"GreaterThanEqual"

 

Validação for bem-sucedido se o valor no controle para validar é maior ou igual ao

comparação de valores.

 

"Menor que"

 

Validação for bem-sucedido se o valor no controle para validar é inferior ao valor de comparação.

 

"LessThanEqual"

 

Validação for bem-sucedido se o valor no controle para validar for inferior ou igual ao

comparação de valores.

 

"Notequal"

 

Validação for bem-sucedido se o valor no controle para validar não é igual ao valor de comparação.

 

 

 

O tipo de dados e os valores comparados. Os valores são convertidos para este tipo antes da

comparação é feita. Os valores possíveis são "Moeda", "Data", "Double",

"Inteiro" e "String".

 

 

ValueToCompare

 

O valor a ser usado para comparação. Se este atributo for especificado, o ControlToCompare

atributo não deve ser especificado.

 

O controle CustomValidator reconhece esse atributo adicional:

 

ClientValidationFunction

 

O nome da função de script do lado do cliente para chamar para realizar a validação do lado do cliente.

 

do lado do servidor de validação personalizada é executada por responder ao controle de CustomValidator

ServerValidate evento. Veja Seção 6.4.4, mais adiante neste capítulo para obter detalhes.

 

O controle RangeValidator reconhece esses atributos adicionais:

 

MaximumValue

 

O valor máximo do intervalo. O padrão é uma seqüência vazia.

 

 

 

276

 

MinimumValue

 

NET Programação Visual Basic.

 

 

 

 

Tipo

 

 

O valor mínimo do intervalo. O padrão é uma seqüência vazia.

 

 

 

O tipo de dados o valor que está sendo validado. O valor que está sendo validado, bem como o máximo

e os valores mínimo, são todos convertidos para este tipo, antes de as comparações são feitas. A

valores possíveis são "Moeda", "Data", "Double", "Inteiro" e "String". A

padrão é "String".

 

 

O controle RegularExpressionValidator reconhece esse atributo adicional:

 

ValidationExpression

 

A expressão regular contra o qual a validar.

 

O controle RequiredFieldValidator reconhece esse atributo adicional:

 

InitialValue

 

O valor considerado como um valor "em branco". O padrão é uma seqüência vazia. A validação falhará se e

somente se o valor no controle a ser validado corresponde ao valor indicado no InitialValue

atributo.

 

6.4.2 Usando propriedades de controle de validação

 

Os nomes dos atributos listados na secção anterior também estão os nomes dos correspondentes

propriedades das classes de controle. Estas propriedades podem ser lidas ou definido no código, se desejar. Por exemplo,

depois que um valor especificado para o atributo ErrorMessage, esse valor pode ser lido no código através da leitura

o ErrorMessage propriedade do controle. Da mesma forma, os atributos não precisam ser usados. Em vez disso, os valores

pode ser escrito diretamente às propriedades correspondentes em código.

 

Além das propriedades que correspondem aos atributos na seção anterior, o validador controla todos os

ter as seguintes propriedades:

 

Habilitado

 

Esta propriedade Boolean especifica se o controle de validação está habilitado. Quando essa propriedade

é definido como False, o controle não tenta executar a validação. O padrão é True.

 

IsValid

 

Esta propriedade Booleano indica se o valor no controle associado passa a validação.

 

PropertiesValid

 

Esta propriedade somente leitura booleano indica se o valor especificado pelo

propriedade ControlToValidate é um controle válido na página.

 

RenderUplevel

 

Esta propriedade somente leitura booleano indica se o browser suporta renderização de nível superior.

 

 

 

 

277

 

 

 

 

 

6.4.3 Fornecer um breve resumo da falha na validação

 

Além disso, a colocação de cada mensagem de erro ao lado do campo que está em erro, não há outra opção.

Usando o controle ValidationSummary, você pode exibir um resumo dos erros de uma página web de validação

quer na página, em uma caixa de mensagem (se o navegador está habilitado para JavaScript client-side), ou ambos. Para

exemplo, você poderia adicionar o seguinte fragmento de código no Exemplo 6-7 (novo código é mostrado na

negrito, as linhas circundantes é mostrada para o contexto):

 

<body>

   <form action="ValidationTest2.aspx" method="post" runat="server">

      <Asp: ValidationSummary

         HeaderText = "Algumas informações estão faltando ou mal digitado. Favor

            fazer as correções para os seguintes itens, clique no

            Envie novamente o botão. Obrigado! "

         runat = "server" />

      <table>

         <tr>

 

O controle ValidationSummary detecta automaticamente os controles de validação que estão na mesma página. Se

validação falhar, o controle ValidationSummary exibe o ErrorMessage validação de todos os

controles que relataram falhas. Isto mostra, além da exibição de cada indivíduo de validação

controle. Na prática, é improvável que ambas as telas são desejados, por isso o atributo de exibição de cada

controle de validação pode ser definida como "None" para suprimir a exibição individual, como este:

 

<asp: RequiredFieldValidator ID = "recFldFullName"

    ControlToValidate = "txtFullName"

   ErrorMessage = "Nome completo é necessário."

   Display = "None"

   runat = "server" />

 

Figura 6-10 mostra como essas mudanças afetam a página da Web quando a validação falhar.

 

Figura 6-10. Usando o controle ValidationSummary

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

278

 

NET Programação Visual Basic.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Os atributos reconhecidos pelo controle ValidationSummary são:

 

DisplayMode

 

Especifica o formato em que as mensagens de erro são exibidas. Os valores possíveis são:

 

"BulletList"

 

Exibe as mensagens de erro em uma lista com marcadores. Este é o padrão.

 

"Lista"

 

Exibe as mensagens de erro em uma lista sem balas.

 

"SingleParagraph"

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

279

 

 

 

 

Exibe mensagens de erro na forma de parágrafo.

 

EnableClientScript

 

Especifica se deve permitir que um script do lado do cliente (se for suportado pelo navegador). O padrão é

"True".

 

ForeColor

 

Define a cor em que o resumo é exibida. O padrão é "vermelho". Os valores válidos para

esse atributo é dado pela estrutura de cor (definida no namespace System.Drawing).

Veja Capítulo 4 para informações sobre a estrutura de cores.

 

HeaderText

 

Exibe uma mensagem sobre o resumo itens. O padrão é uma seqüência vazia.

 

ShowMessageBox

 

Indica se a mostrar o resumo em uma caixa de mensagem usando um script do lado do cliente. Se isso

atributo é definido como "True" eo navegador oferece suporte a JavaScript, o resumo é mostrado em uma

caixa de mensagem (veja a Figura 6-11). Se definido como "Falso", nenhuma caixa de mensagem é mostrada. O padrão é

"Falso".

 

Figura 6-11. Mostrando o resumo de validação em uma caixa de mensagem

 

 

 

 

 

 

 

 

 

ShowSummary

 

Indica se o resumo na página da web. Se este atributo é definido como "True", o

resumo é mostrado na página web. Se definido como "Falso", o resumo não é exibido na web

página. O padrão é "True".

 

Observe que o ShowMessageBox ShowSummary e atributos são independentes uns dos outros. Se ambos

são definidas como "True", o resumo é mostrado nos dois sentidos.

 

Estes atributos correspondem a todos os nomeados como propriedades da classe ValidationSummary e pode ser

lido e modificado no código.

 

6.4.4 Validação de Execução sob encomenda

 

Para as situações em que os controles de validação padrão não forem suficientes, o ASP.NET fornece o

CustomValidator controle. Este controle permite ao desenvolvedor especificar as funções personalizadas em ambos os

cliente eo servidor que valida o conteúdo do controle associado. A validação do lado do cliente

função deve ser um JavaScript ou VBScript bloco de código que faz parte da página web. O lado do servidor

função de validação é um método definido na classe de página da web.

 

Exemplo 6-8 mostra o código usando um controle CustomValidator. O código gera uma página com um único

caixa de texto no qual o usuário deverá digitar uma expressão matemática. A validação que ocorre

 

 

280

 

NET Programação Visual Basic.

 

 

sobre o valor simplesmente garante que há um número igual de parênteses esquerdos e direitos. Figura 6 -

12 mostra o visor antes da validação ocorre. Figura 6-13 mostra o visor quando a validação falhar.

 

Figura 6-12. A tela do Exemplo 6-8 antes da validação ocorre

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Figura 6-13. A tela do Exemplo 6-8 quando a validação falhar

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Exemplo 6-8. Usando o controle CustomValidator

<% @ Page Explicit = "True" Strict = "true"%>

 

language="VB" runat="server"> <script

 

   Private Sub cstExpression_ServerValidate (_

      ByVal sender As Object, _

      ByVal e As _ ServerValidateEventArgs

   )

      _ E.IsValid =

         (CountSubString (e.Value ", (") = CountSubString (e.Value, ")"))

   End Sub

 

   CountSubString Private Function (_

      strSearchThis ByVal As String, _

      StrSearchFor ByVal _ As String

   ) As Integer

      Dim contagem As Integer = 0

      Dim pos As Integer = strSearchThis.IndexOf (strSearchFor)

      Do While pos <> -1

         contador + = 1

         pos = strSearchThis.IndexOf _ (strSearchFor,

            pos + strSearchFor.Length)

      Loop

      contagem de Retorno

 

 

281

 

 

 

 

   End Function

 

</ Script>

 

<script language="JavaScript">

 

   função countSubString (searchThis, searchFor) {

      contagem var i = 0;

      var pos = searchThis.indexOf (searchFor);

      enquanto pos! = -1 {

         count + +;

         pos = searchThis.indexOf (searchFor, pos searchFor.length +);

      }

      retornar a contagem;

   }

 

   função cstExpression_ClientValidate (remetente, e) {

      e.IsValid =

         (CountSubString (e.Value ", (") == countSubString (e.Value, ")"))

   }

 

</ Script>

 

<html>

 

   <head>

      <title> CustomValidator Teste </ title>

   </ Head>

 

   <body>

      <form action="CustomValidatorTest.aspx" method="post" runat="server">

         <table>

            <tr>

               <td align="right"> Digite uma expressão: </ td>

               <asp:TextBox <td> id="txtExpression" runat="server" /> </ td>

            </ Tr>

            <tr>

               colspan="2"> <td

                  <asp: CustomValidator id = "cstExpression"

                     ControlToValidate = "txtExpression"

                     OnServerValidate = "cstExpression_ServerValidate"

                     ClientValidateFunction = "cstExpression_ClientValidate"

                     ErrorMessage = "O número de parênteses à esquerda na

                        a expressão deve ser o mesmo que o número

                        de parênteses à direita. "

                     runat = "server" />

               </ Td>

            </ Tr>

            <tr>

               <td colspan="2" align="center">

                  <asp: button id = "text btnSubmit" = "Enviar"

                     runat = "server" />

               </ Td>

            </ Tr>

         </ Table>

      </ Form>

   </ Body>

 

</ Html>

 

 

 

 

282

 

NET Programação Visual Basic.

 

 

O código no Exemplo 6-8 é simples. Em primeiro lugar, um método server-side chamado

cstExpression_ServerValidate é adicionada à página para lidar com a validação do lado do servidor. Este método é

na verdade, um manipulador de eventos com uma assinatura que é apropriado para o controle do CustomValidator

ServerValidate evento. Definindo o atributo OnServerValidate do <asp:customvalidator>

fios tag método de manipulador para o evento. Em segundo lugar, uma função do lado do cliente,

cstExpression_ClientValidate, é adicionada à página para lidar com a validação do lado do cliente. Esta função é

chamado pelo código de validação do lado do cliente quando é o momento para o campo txtExpression para ser validado.

Definindo o atributo ClientValidateFunction dos fios tag <asp:customvalidator> esta

função.

 

6,5 directivas usando para modificar a compilação de página Web

 

Você pode modificar a compilação de página web, incluindo directivas. As directivas são as palavras-chave

reconhecidas e agiu em pelo compilador de página ASP.NET. Eles afetam a compilação de uma página, ao invés de

sua apresentação. As directivas são delimitados pelos caracteres <% @ e%> e podem aparecer em qualquer local

no arquivo de origem (embora a Microsoft diz que "a prática corrente é colocá-los na parte superior da

arquivo). Por exemplo, o <% @ Page%> seguinte directiva foi mostrado no Exemplo 6-1, no início deste

capítulo:

 

<% @ Page Language = "vb" AutoEventWireup = "false"

   CodeBehind = "WebForm1.aspx.vb" Inherits => "IdeExamples.WebForm1"%

 

As directivas são semelhantes na forma de tags HTML. Não é a própria directiva, seguido por um ou mais

atributos que especificar várias configurações associadas com a directiva. A directiva tem sem atributos

nenhum efeito. As directivas são diferentes das tags de HTML em que os delimitadores são diferentes e que

directivas não têm marcas de fechamento.

 

ASP.NET define as seguintes diretrizes e atributos associados:

 

@ Assembleia

 

Fornece uma maneira de conjuntos de referência definida em outro lugar. Os atributos desta directiva são:

 

Nome

 

Especifica o nome de um assembly no cache global de assemblies. Por exemplo:

 

<% @ Assembly Name = "System.Windows.Forms"%>

SRC

 

Especifica o caminho de um arquivo de origem Visual Basic. NET para ser compilado e referenciados. O caminho

é relativo à pasta virtual do aplicativo da web. Por exemplo:

 

<% @ Assembléia SRC = "SomeClass.vb"%>

 

O nome ou o atributo SRC pode ser especificado, mas não ambos. Se múltiplas montagens são

a ser referenciado, a diretiva @ Assembly deve aparecer várias vezes, como este:

 

<% @ Assembly Name = "System.Windows.Forms"%>

<% @ Assembly Name = "System.Drawing"%>

 

Observe o seguinte ao usar a diretiva @ Assembly:

 

• Assembléias localizado na pasta do aplicativo / bin são automaticamente referenciados-lá

há necessidade de usar a diretiva @ Assembly.

 

 

 

283

 

 

 

 

 

 

 

 

 

 

@ Controle

 

 

 

 

• A diretiva @ Assembly não pode assemblies de referência que não são compilados na

cache de assemblagem global.

• Arquivos de origem referenciado com o atributo SRC deve estar localizado em algum lugar debaixo

pasta virtual do aplicativo da web.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

284

 

 

Modifica a compilação de um controle de usuário. (Controles de usuário são discutidos na Seção 6.11.1 posteriormente

. Neste capítulo) atributos da presente directiva são:

 

AutoEventWireup

 

Indica se os eventos do controle são autowired para manipuladores apropriado for encontrado dentro do

Controle de classe. Os valores permitidos são "verdadeiro" e "falso". O padrão é "true". Esta é

idêntica para o mesmo conceito nas classes Page. Consulte a Seção 6.2.1 na Seção 6.2

anteriormente neste capítulo.

 

ClassName

 

Especifica um nome de classe para o controle compilado. Isso pode ser qualquer nome que seja válido por um

Visual Basic. NET classe. Por padrão, o nome é construído a partir do nome do usuário

controle. Se o nome é "filename.ascx", então o valor é ClassName

"Filename_ascx".

 

CodeBehind

 

É usado pelo Visual Studio. NET ao invés do atributo SRC para especificar um code-behind

arquivo.

 

CompilerOptions

 

Especifica argumentos arbitrários sejam passados para o Visual Basic NET.. O formato do

esses argumentos é o mesmo que para o Visual Basic. compilador de linha de comando NET. O padrão

é a cadeia vazia. (Opções do compilador de linha de comando não são documentados neste livro.)

 

Depurar

 

Especifica se a compilar o controle no modo de depuração. Os valores permitidos são "verdadeiro" e

"Falso". O padrão é "falso". Compilando no modo de depuração permite recursos como ricos

mensagens de erro (para desenvolvedores) e ajuste de breakpoints.

 

Descrição

 

É um lugar para o desenvolvedor para descrever o controle. Nem ASP.NET ou Visual Studio. NET

usa-lo de qualquer forma.

 

EnableViewState

 

Especifica se o estado de exibição será mantido em solicitações de página. Os valores permitidos são

"Verdadeiro" e "falso". O padrão é "true". Veja Seção 6.8 mais adiante neste capítulo para mais

da informação.

 

Explícita

 

 

NET Programação Visual Basic.

 

 

Especifica se o controle será compilado com Option Explicit ligado. Admitidos

Os valores são "verdadeiros" e "falso". O padrão é "true". Consulte o Capítulo 2 para uma discussão de

esta opção de compilador.

 

Herda

 

Especifica uma classe da qual a classe de controle compilado herdarão. O valor pode ser o nome

acessíveis de qualquer classe que herda da classe UserControl (definido no System.Web.UI

namespace). Se esse atributo não é especificado, a classe herda compilado controle diretamente

a classe UserControl.

 

Idioma

 

Especifica a linguagem de programação embutida código é escrito. Isso pode ser diferente

da língua em que o código do controle-behind class está escrito.

 

Src

 

Especifica um arquivo que contém a fonte para o controle de classe code-behind, se houver. Por padrão,

controles de usuário não tiver uma classe code-behind.

 

Estrita

 

Especifica se o controle será compilado com Option Strict ativada. Valores permitidos

são "verdadeiros" e "falso". O padrão é "falso". Consulte o Capítulo 2 para uma discussão do presente

opção de compilador.

 

WarningLevel

 

Especifica o nível de alerta em que o compilador anula a compilação do controle. Admitidos

valores são "0", "1", "2", "3" e "4".

 

@ Implements

 

Especifica o nome de uma interface que é implementado pela página web. Esta diretiva serve

a mesma função que a instrução Implements em Visual Basic. NET. O @ Implements

directiva tem um atributo:

 

Interface

 

Designa a interface implementada. Apenas uma interface pode aparecer em cada Implementa @

directiva. Para especificar mais de uma interface, fornecem múltiplas diretivas @ Implements.

 

Lembre-se que. Aspx são compilados em classes. É por isso que uma página web pode implementar um

interface. A execução propriamente dita deve ser fornecido exatamente como seria em um Visual

Basic. NET definição de classe. Neste caso, porém, a aplicação aparece como o Visual

Basic. NET dentro de um bloco <script> no arquivo aspx..

 

@ Import

 

Importa um namespace na página, permitindo que classes a serem chamadas pelos seus nomes curtos

e não por seus nomes totalmente qualificados. Esta directiva tem a mesma função como a

As importações de palavras-chave no Visual Basic. NET. A diretiva @ Import tem um atributo:

 

Namespace

 

 

 

285

 

 

 

 

Designa o espaço para a importação. Apenas um espaço para nome pode aparecer em cada um @ Import

directiva. Para importar mais do que um espaço, proporcionar várias directivas @ Import.

 

namespaces Só que existem dentro de assemblies referenciados podem ser incluídos na importação @

directiva. No Visual Studio projetos. NET assemblies referenciados aparecem sob a

Referências item na janela Solution Explorer. Você pode adicionar referências para o assembly

projeto clicando no item referências, selecionando Add Reference e, em seguida, escolhendo

ou navegando para o conjunto desejado na caixa de diálogo Adicionar referência. Em projetos que são

criado sem a ajuda da NET. Visual Studio, assembléias são referenciados em uma de três maneiras.

Assemblies que estão no cache de assembly global (GAC) pode ser referenciada usando o @

Assembléia directiva. Conjuntos que não estão no GAC pode ser referenciado por colocá-los em

um diretório bin dentro do diretório raiz do aplicativo. Finalmente, na linha de comando, a DLL no

que reside um conjunto pode ser referenciado utilizando a referência (ou / r) switch.

 

Veja também a diretiva @ Referência posteriormente nesta lista.

 

@ OutputCache

 

Especifica as configurações de cache de saída. Além dos atributos listados aqui, o cache não é discutido

neste livro.

 

Duração

 

O número de segundos para o cache da página ou controle de usuário. Não há nenhum padrão este atributo

deve ser especificado se a diretiva @ OutputCache é usado.

 

Localização

 

A localização do cache de saída. Os valores permitidos são "Qualquer" (permite o enquadramento de escolher

onde colocar a cache), "O Cliente" (o cache é colocado no cliente navegador)

"Downstream" (o cache é colocado em um servidor que está a jusante do servidor

processamento do pedido), "Nenhum" (saída não está em cache), e "Server" (o cache é colocado

no servidor de processamento do pedido).

 

Os restantes atributos, VaryByCustom, VaryByHeader, VaryByParam, e

VaryByControl, estão fora do escopo deste livro.

 

@ Page

 

Modifica a compilação de uma página web. Os atributos desta directiva são:

 

Aspcompat

 

Indica se para executar nesta página em um apartamento single-threaded (STA) de discussão. Admitidos

Os valores são "verdadeiros" e "falso". O padrão é "falso". Executando a página em um STA

discussão permite que se chame a componentes que requerem um thread STA, como componentes escritos em

Visual Basic 6.

 

Apesar de seu nome, esse atributo não permitir a incorporação ASP clássico em uma página ASP.NET

(. Aspx) arquivo de origem.

 

AutoEventWireup

 

 

 

 

 

 

286

 

NET Programação Visual Basic.

 

 

Indica se os eventos da página são autowired para manipuladores apropriado for encontrado dentro do

Página de classe. Os valores permitidos são "verdadeiro" e "falso". O padrão é "true". Consulte a Seção

6.2.1 no item 6.2, anteriormente neste capítulo.

 

Buffer

 

Indica se a permitir uma resposta buffer para a página. Os valores permitidos são "verdadeiro" e

"Falso". O padrão é "true". Quando o buffer de resposta estiver ativado, toda a resposta é

gerados antes que ele é enviado para o navegador. Se o buffer de resposta for desativado, os dados são enviados

para o navegador como ele é gerado.

 

ClassName

 

Especifica um nome de classe para a página compilada. Isso pode ser qualquer nome que seja válido para um Visual

Basic. NET. Por padrão, o nome é construído a partir do nome da página web. Se

o nome do arquivo é "filename.aspx", o valor ClassName é "filename_aspx".

 

ClientTarget

 

Substitui a detecção automática da estrutura do ASP.NET de recursos do navegador. Defina esta

atribuem ao "nível superior" ou "nível inferior" para forçar o ASP.NET para renunciar a detecção do navegador e

simplesmente assumir os recursos correspondentes. Em alternativa, definir esse atributo para o valor dado

pela configuração do navegador na seção <browserCaps> de um aplicativo web. arquivo de configuração para

causar ASP.NET para assumir as capacidades definidas nessa seção. O padrão é um vazio

string. Este atributo corresponde à propriedade ClientTarget da classe Page.

 

CodeBehind

 

Usado por projetos Visual Studio. NET ao invés do atributo SRC para especificar um arquivo code-behind.

 

CodePage

 

Especifica a página de código (ou seja, o conjunto de caracteres) para usar na renderização da página web. A

valor pode ser qualquer página de código válido. O padrão é a página de código padrão para o servidor web.

 

CompilerOptions

 

Especifica argumentos arbitrários sejam passados para o Visual Basic NET.. O formato do

esses argumentos é o mesmo que para o Visual Basic. compilador de linha de comando NET. O padrão

é a cadeia vazia. (Opções do compilador de linha de comando não são documentados neste livro.)

 

ContentType

 

Especifica o tipo de dados a ser processado pela página. O valor pode ser qualquer tipo de conteúdo válido

conforme definido pelo Multipurpose Internet Mail Extensions (MIME) especificação. O padrão é

"Text / html".

 

Cultura

 

Especifica a cultura a ser utilizada pela página. A cultura especifica linguagem e formatação

convenções utilizadas na renderização de conteúdo. O valor pode ser qualquer nome de cultura padrão, conforme determinado

no Apêndice C. O padrão é determinada pela configuração do servidor web.

 

Depurar

 

 

 

 

287

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

288

 

 

 

 

Especifica se para compilar a página no modo de depuração. Os valores permitidos são "verdadeiro" e

"Falso". O padrão é "falso". Compilando no modo de depuração permite recursos como ricos

mensagens de erro (para desenvolvedores) e ajuste de breakpoints.

 

Descrição

 

Fornece um local para o desenvolvedor para descrever a página. Nem ASP.NET ou Visual

Studio. NET usa-lo de qualquer maneira.

 

EnableSessionState

 

Especifica a disponibilidade de estado da sessão para a página. Os valores permitidos são "true" (indicando

que o estado da sessão está a ser habilitado), "false" (indicando que o estado da sessão não é para ser

habilitado), e "ReadOnly" (indicando que o estado da sessão está ativado, mas somente para leitura). A

padrão é "true". Veja Seção 6.8, mais adiante neste capítulo para obter mais informações.

 

EnableViewState

 

Especifica se o estado de exibição será mantido em solicitações de página. Os valores permitidos são

"Verdadeiro" e "falso". O padrão é "true". Veja Seção 6.8 deste capítulo para mais

da informação.

 

EnableViewStateMac

 

Especifica se usar uma maior segurança para verificar se o usuário não tiver violado o

estado de exibição recebido em um postback. Os valores permitidos são "verdadeiro" e "falso". O padrão é

"Falso".

 

ErrorPage

 

Especifica a URL de uma página web para o qual o usuário deve ser redirecionado, se um não manipulado

exceção ocorre durante o processamento da solicitação de página.

 

Note-se que esse redirecionamento só ocorre se os erros personalizados estão habilitados. Isso é controlado pela

<customErrors> seção no arquivo web.config do aplicativo ou na máquina

arquivo machine.config. Por padrão, o arquivo machine.config contém esta entrada:

 

customErrors <

   mode = "RemoteOnly" />

 

Isto significa que se um não manipulado exceção ocorre, o redirecionamento para a página especificada pelo

atributo ErrorPage ocorre somente se o navegador não está rodando no servidor web. Esta é uma

boa configuração padrão, já que um teste do desenvolvedor em um servidor web provavelmente gostaria de

consulte a página do IIS exceção gerada, em vez de uma página de erro para o cliente. Veja

Capítulo 3 para obter mais informações sobre arquivos de configuração.

 

Explícita

 

Especifica se a página será compilado com Option Explicit ligado. Admitidos

Os valores são "verdadeiros" e "falso". O padrão é "true". Consulte o Capítulo 2 para uma discussão de

esta opção de compilador.

 

Herda

 

NET Programação Visual Basic.

 

 

Especifica uma classe da qual a classe de página compilado herdarão. O valor pode ser o nome

acessíveis de qualquer classe que herda da classe Page (definido no System.Web.UI

namespace). Se esse atributo não é especificado, a classe herda compilado página diretamente do

Página de classe.

 

Idioma

 

Especifica a linguagem de programação embutida código é escrito. Isso pode ser diferente

da língua em que o código da página-behind class está escrito.

 

LCID

 

Especifica a localidade para ser utilizado por esta página (LCID representa identificador de localidade). O LCID é um

quatro bytes inteiro sem sinal que identifica a cultura utilizados quando o processamento da página. Especificando

um valor para LCID é uma alternativa para especificar um valor para o atributo de Cultura. Veja

Apêndice C para uma lista de culturas e LCIDs correspondente.

 

ResponseEncoding

 

Especifica o formato de codificação de caracteres para usar para a página da web. O padrão é "UTF-8".

 

Src

 

Especifica o nome de um arquivo que contém a fonte para a página code-behind, se houver. Por

padrão, as páginas web não tem uma classe code-behind.

 

Estrita

 

Especifica se a página será compilado com Option Strict ativada. Valores permitidos

são "verdadeiros" e "falso". O padrão é "falso". Consulte o Capítulo 2 para uma discussão do presente

opção de compilador.

 

Traço

 

Especifica se deve ativar o rastreamento. Os valores permitidos são "verdadeiro" e "falso". O padrão é

"Falso".

 

TraceMode

 

Quando o rastreamento é ativado, especifica como rastrear mensagens serão ordenadas. Os valores permitidos são

"SortByCategory" e "SortByTime". O padrão é "SortByTime".

 

Transação

 

Especifica se e como a página participa de operações. Os valores permitidos são

"NotSupported", "Apoiado", "necessário" e "RequiresNew". O padrão é

"NotSupported". O processamento de transações não é discutida neste livro.

 

WarningLevel

 

Especifica o nível de alerta em que o compilador anula a compilação da página. Admitidos

valores são "0", "1", "2", "3" e "4".

 

@ Referência

 

 

 

289

 

 

 

 

Fornece uma maneira para fazer referência ao tipo de dados para um controle ou página, que irá ser dinamicamente

carregado a partir da página atual usando o método da classe Página LoadControl. Esta directiva

atributos são:

 

Página

 

O nome de um arquivo. Aspx que define uma página web para ser referenciadas de forma dinâmica a partir da

página atual.

 

Controle

 

O nome de um arquivo. Ascx que define um controle web para ser referenciadas de forma dinâmica a partir da

página atual.

 

Apenas um atributo (ou página ou Control) é permitida em uma única diretiva @ Referência. Para

especificar várias páginas ou controles, especificar várias diretivas @ Referência em linhas separadas.

 

A diretiva @ Referência é útil se a página tem um código semelhante a este:

 

language="VB" runat="server"> <script

   Substitui Sub Protected OnLoad (ByVal e As EventArgs)

      Dim ctl As Control

      ctl LoadControl = ("SomeControl.ascx")

      Controls.Add (CTL)

   End Sub

</ Script>

 

Esse código carrega um controle de um arquivo. Ascx e adiciona à coleção da página atual de

controles. Isto funciona muito bem, mas se esse código precisa acessar propriedades e métodos do

controle de carga, sem recorrer a ligação tardia, ele está em apuros. Não tem nenhuma maneira de converter a

Controle referência no ctl para o tipo de dados apropriado. É aí que o @ Referência

directiva vem dentro referenciar o arquivo. ascx em uma diretiva @ Referência torna os dados

tipo disponível para o código-fonte para o resto da página. Veja como ficaria:

 

<% @ Control Referência = "SomeControl.ascx"%>

language="VB" runat="server"> <script

   Substitui Sub Protected OnLoad (ByVal e As EventArgs)

      Dim ctl Como SomeControl

      ctl = CType (LoadControl ("SomeControl.ascx"), SomeControl)

      ctl.SomeProperty = "SomeValue"

      Controls.Add (CTL)

   End Sub

</ Script>

 

ctl agora é fortemente tipado, e do tipo SomeControl está disponível para o código do aplicativo.

 

@ Register

 

Permite que o usuário controla e controles personalizados de servidor a ser adicionado a uma página web. Tem duas formas.

A primeira forma permite que todos os controles em um namespace inteiro para ser referenciado. É parecido com este:

 

<% @ Register

   TagPrefix = "tagprefix_name"

   Namespace = "namespace_name"

   Assembléia = "assembly_name"

%>

 

 

 

290

 

NET Programação Visual Basic.

 

 

Quando este formato é usado, você pode usar qualquer um dos controles no namespace referenciado

na página web, incluindo uma tag desta forma:

 

<tagprefix_name:class_name runat="server" />

 

A segunda forma de a diretiva @ Register registra um único controle que reside em um

arquivo de origem. É parecido com este:

 

<% @ Register

   TagPrefix = "tagprefix_name"

   TagName = "tagname"

   Src = "caminho"

%>

 

Quando este formato é usado, você pode usar o controle específicas encontradas no arquivo de origem na web

página, incluindo uma tag desta forma:

 

<tagprefix_name:tagname runat="server" />

 

De qualquer forma, você pode definir as propriedades do objeto de controle, especificando as propriedades como

atributos da marca, como esta:

 

<tagprefix_name:tagname MyPropertyName="some value" runat="server" />

 

Consulte a Secção 6,11, mais adiante neste capítulo para exemplos adicionais.

 

Os atributos da diretiva @ Register são:

 

TagPrefix

 

Um nome que representa o espaço que está sendo referenciado

 

TagName

 

Um nome que representa a classe que está sendo referenciado

 

Namespace

 

O namespace de referência

 

Src

 

O arquivo que contém o controle

 

6,6 ASP.NET Objetos: Interagindo com o quadro

 

A estrutura do ASP.NET expõe funcionalidades para aplicações web através de um número de chamadas

objetos intrínsecos. Esses objetos estão disponíveis através do Server, sessão do aplicativo, cache,

Request, Response e propriedades do objeto Page. Esta secção dá uma visão geral desses objetos.

 

6.6.1 O Object Server

 

O objeto Server é uma instância da classe HttpServerUtility (definido no System.Web

namespace). Este objeto fornece informação e serviços relacionados com o servidor web. A

HttpServerUtility classe tem duas propriedades:

 

 

291

 

 

 

 

MachineName

 

Obtém o nome da máquina na qual o aplicativo está sendo executado. O tipo é String.

 

ScriptTimeout

 

Obtém ou define o tempo limite de pedido na web em poucos segundos. O tipo é Integer. O padrão é 90

segundos.

 

Alguns dos métodos usados são:

 

ClearError

 

Limpa a última exceção que ocorreu (ver também GetLastError nesta lista). A sintaxe é:

 

Público ClearError Sub ()

Executar

 

Executa um pedido para outra página. Depois a outra página é processada, o processamento da

Página corrente continua. O método Execute possui duas sobrecargas. A primeira é:

 

Público overloads Sub Execute (ByVal path as String)

 

O parâmetro path especifica o caminho do arquivo da página Web para ser executado. Com esta forma de

Executar método, a saída da página web está misturado com a saída da página de chamada.

 

A sobrecarga do segundo é:

 

Público overloads Sub Execute (ByVal caminho As String, _

   Como escritor ByVal System.IO.TextWriter)

 

Novamente, o parâmetro de caminho especifica o caminho do arquivo da página web para ser executado. O escritor

parâmetro especifica um objeto do tipo TextWriter (definido no namespace System.IO), que é

receber a saída da página web da executada. (A classe TextWriter não está documentada neste livro.)

 

GetLastError

 

Obtém a última exceção que foi lançada (ver também ClearError nesta lista). A sintaxe é:

 

Função Pública GetLastError () As System.Exception

HtmlEncode e HtmlDecode

 

seqüências de codificar e decodificar, respectivamente, que pode conter caracteres HTML. Cada método

tem duas substituições: um que retorna a seqüência codificada ou decodificada como uma String e um que

escreve a string codificada ou decodificada em um objeto do tipo TextWriter (definido no

Namespace System.IO). (A classe TextWriter não está documentada neste livro.) A sintaxe para

estes métodos é a seguinte:

 

Sobrecargas Função Pública (s ByVal As String) As String HtmlEncode

 

O parâmetro s é a seqüência de caracteres para codificar. O valor de retorno da função é a string codificada.

 

Sobrecargas Pública HtmlEncode Sub (s ByVal As String, _

   ByVal saída como System.IO.TextWriter)

 

 

 

 

292

 

NET Programação Visual Basic.

 

 

O parâmetro s é a seqüência de caracteres para codificar. A string codificada é escrita para o objeto TextWriter passado

no parâmetro de saída.

 

Sobrecargas Função Pública (s ByVal As String) As String HtmlDecode

 

O parâmetro s é a seqüência para decodificar. O valor de retorno da função é a string decodificada.

 

Sobrecargas Pública HtmlDecode Sub (s ByVal As String, _

   ByVal saída como System.IO.TextWriter)

 

O parâmetro s é a seqüência para decodificar. A string decodificada é escrita para o objeto TextWriter passado

no parâmetro de saída.

 

MapPath

 

Retorna o caminho físico que corresponde ao determinado caminho virtual. A sintaxe é:

 

Função Pública MapPath (ByVal caminho As String) As String

Transferência

 

Interrompe a execução da página atual e começa a execução da página especificado. Este método

difere do método Redirect do objeto Response. O método Redirect dirige o

navegador para solicitar uma nova página, enquanto o método de transferência, simplesmente começa a executar um novo

página. O método de transferência tem duas substituições. A primeira é:

 

Público overloads Sub Transfer (ByVal path as String)

 

O parâmetro path especifica o caminho virtual da nova página. A substituição segundo é:

 

Público overloads Sub Transfer (ByVal caminho As String, _

   ByVal preserveForm As Boolean)

UrlEncode e urldecode

 

seqüências de codificar e decodificar, respectivamente, de modo que eles podem ser usados dentro de URLs. Cada método

tem duas substituições: um que retorna a seqüência codificada ou decodificada como uma String e um que

escreve a string codificada ou decodificada em um objeto do tipo TextWriter (definido no

Namespace System.IO). (A classe TextWriter não está documentada neste livro.) A sintaxe para

estes métodos é a seguinte:

 

Sobrecargas Função Pública (s ByVal As String) As String UrlEncode

 

O parâmetro s é a seqüência de caracteres para codificar. O valor de retorno da função é a string codificada.

 

Sobrecargas Pública UrlEncode Sub (s ByVal As String, _

   ByVal saída como System.IO.TextWriter)

 

O parâmetro s é a seqüência de caracteres para codificar. A string codificada é escrita para o objeto TextWriter

passado no parâmetro de saída.

 

Sobrecargas Função Pública (s ByVal As String) As String urldecode

 

O parâmetro s é a seqüência para decodificar. O valor de retorno da função é a string decodificada.

 

Sobrecargas Pública urldecode Sub (s ByVal As String, _

   ByVal saída como System.IO.TextWriter)

 

 

 

293

 

 

 

 

O parâmetro s é a seqüência para decodificar. A string decodificada é escrita para o objeto TextWriter

passado no parâmetro de saída.

 

6.6.2 O objeto Application

 

O objeto Application é uma instância da classe HttpApplicationState (definido no System.Web

namespace). Esse objeto contém o estado do aplicativo a ser usado por todas as solicitações da Web em um aplicativo. Veja

Seção 6.8 mais adiante neste capítulo para obter mais informações.

 

6.6.3 O Objeto Session

 

O objeto Session é uma instância da classe HttpSessionState (definido no

System.Web.SessionState). Este objeto contém o estado do aplicativo que é específico para o

sessão de solicitação da web atual. Consulte "Manutenção do Estado", posteriormente neste capítulo, para obter mais informações.

 

6.6.4 O objeto Cache

 

O objeto de Cache é uma instância da classe Cache (definido no namespace System.Web.Caching).

Este caches de objetos criados dinamicamente objetos no servidor, melhorando assim o desempenho médio

para os usuários do site. O cache não é discutido neste livro.

 

6.6.5 O Objeto Request

 

A solicitação objeto é uma instância da classe HttpRequest (definido no namespace System.Web).

Este objeto fornece informação e serviços relacionados com a solicitação da web atual. Estes são os

comumente utilizado as propriedades da classe HttpRequest:

 

ApplicationPath

 

O caminho virtual da pasta raiz do aplicativo. Esta é uma propriedade somente leitura. O tipo é

String.

 

Browser

 

Informações sobre as capacidades do navegador do cliente. Esta é uma propriedade somente leitura. O tipo de

é HttpBrowserCapabilities (definido no namespace System.Web). As propriedades do

tipo HttpBrowserCapabilities estão listados posteriormente neste capítulo, na secção 6.7.

 

Cookies

 

A coleção de cookies do lado do cliente enviado pelo navegador. Esta é uma propriedade somente leitura. A

tipo é HttpCookieCollection (definido no namespace System.Web). Veja a discussão sobre

cookies, posteriormente neste capítulo sob a Seção 6.8.

 

FilePath

 

O caminho virtual da solicitação atual. O tipo é String.

 

IsAuthenticated

 

Uma indicação de se o usuário foi autenticado. O tipo é Boolean.

 

IsSecureConnection

 

 

 

294

 

NET Programação Visual Basic.

 

 

Uma indicação de se solicitar a corrente é através de uma conexão segura (HTTPS).

 

6.6.6 O Objeto Response

 

O objeto Response é uma instância da classe HttpResponse (definido no System.Web

namespace). Este objeto fornece informação e serviços relacionados com a resposta que resulta da

solicitação da web atual. Estas são as propriedades normalmente utilizado para o objeto de resposta:

 

BufferOutput

 

Uma indicação se a saída que serão colocados ao ser gerado. O tipo é Boolean.

Quando essa propriedade é False, a saída é enviada para o cliente como ele é gerado. Quando é verdade (a sua

valor padrão), a produção é protegida até que esteja completamente gerado, então ele é enviado para o

cliente. Se uma solicitação de página em particular requer muito processamento, mas partes da página

se tornam disponíveis durante esse tratamento, é benéfico para definir essa propriedade como False para

que o cliente recebe pelo menos alguns de saída o mais rapidamente possível. Por outro lado, o benefício para

Configuração esta propriedade como True é que a saída pode ser interrompida ou alterada, ou a página pode ser

redirecionada, no meio do processamento de página sem o envio de saída falsa para o cliente.

 

Cache

 

A política de cache de uma página web. O tipo é HttpCachePolicy (definido no System.Web

namespace). O cache não é discutida neste livro.

 

Charset

 

O conjunto de caracteres usado no fluxo de saída. O tipo é String. O padrão é "UTF-8".

 

ContentEncoding

 

A codificação de caracteres usado no fluxo de saída. O tipo é a codificação (definido no

System.Text namespace). O padrão é uma instância da classe UTF8Encoding (definido no

namespace System.Text).

 

ContentType

 

O tipo de conteúdo MIME do fluxo de saída. O tipo é String. O padrão é "text / html".

 

Cookies

 

Uma coleção de objetos que representam HttpCookie cookies para ser transmitido para o navegador cliente.

O tipo é HttpCookieCollection (definido no namespace System.Web). Veja o

discussão dos "cookies", posteriormente neste capítulo sob a Seção 6.8.

 

Expira

 

O número de minutos para que o navegador do cliente deve armazenar em cache a saída da página web. A

tipo é Integer. O padrão é 0.

 

ExpiresAbsolute

 

A data e hora até à qual o navegador do cliente deve armazenar em cache a saída da página web. O tipo de

é Data. O padrão é DateTime.MinValue.

 

Status

 

 

295

 

 

 

 

O texto de status HTTP deve ser retornado para o navegador cliente. O tipo é String. O padrão é

"200 OK".

 

StatusCode

 

O código de status HTTP deve ser retornado para o navegador cliente. O tipo é Integer. O padrão é

200.

 

StatusDescription

 

A descrição do status HTTP deve ser retornado para o navegador cliente. O tipo é String. A

padrão é "OK".

 

Estes são alguns métodos comumente utilizados da classe HttpResponse:

 

Redirecionar

 

Envia uma mensagem de redirecionamento para o navegador cliente. Os navegadores cliente responder, solicitando a

página web especificada na mensagem de redirecionamento. A sintaxe é:

 

Sub Público Redirect (url ByVal As String)

 

O parâmetro url especifica o endereço da nova página a ser solicitado.

 

Escrever

 

Grava um valor diretamente para o fluxo de saída. Este método é útil dentro de blocos de script que são

incorporado na página web. Existem versões deste método que escrever um único personagem,

uma matriz de caracteres, um objeto, e uma corda. A sintaxe para a versão que escreve uma string é:

 

Sub Overloads publico para escrita (s ByVal As String)

 

6,7 Descobrindo Recursos do Navegador

 

Um dos pontos fortes do ASP.NET é que ele acomoda as diferenças de navegadores do cliente sem a necessidade de

nenhum esforço especial por parte do desenvolvedor do aplicativo. No entanto, muitas vezes é desejável para uma aplicação web para

descobrir os recursos do navegador de fazer uma determinada solicitação. Para este efeito, o ASP.NET faz

browser informações disponíveis para a aplicação web. s ASP.NET "objeto de solicitação (disponível através do

Página objeto imóvel) tem uma propriedade Browser que retorna um objeto do tipo

HttpBrowserCapabilities. As propriedades deste objeto são:

 

ActiveXControls

 

Indica se o browser cliente suporta os controles ActiveX. O tipo é Boolean.

 

AOL

 

Indica se o navegador do cliente é um navegador de America Online. O tipo é Boolean.

 

BackgroundSounds

 

Indica se o browser cliente suporta sons de fundo. O tipo é Boolean.

 

Beta

 

 

 

296

 

Indica se o navegador do cliente é uma versão beta. O tipo é Boolean.

 

Browser

 

Indica a seqüência de navegador (por exemplo, "IE") recebeu no cabeçalho User-Agent do HTTP

pedido. O tipo é String.

 

CDF

 

Indica se o browser suporta Channel Definition Format para webcasting. O tipo é

Boolean.

 

ClrVersion

 

Indica a versão do. NET CLR instalado no cliente (se houver). O tipo é a versão

(Definido no namespace System).

 

Cookies

 

Indica se o browser cliente suporta cookies. O tipo é Boolean.

 

Crawler

 

Indica se o navegador do cliente é um web crawler (programa automatizado usado por online

motores de busca para descobrir o conteúdo da web). O tipo é Boolean.

 

EcmaScriptVersion

 

Indica a versão do ECMA Script que o browser cliente suporta. O tipo é a versão

(Definido no namespace System).

 

Frames

 

Indica se o browser cliente suporta Frames. O tipo é Boolean.

 

JavaApplets

 

Indica se o browser cliente suporta applets Java. O tipo é Boolean.

 

JavaScript

 

Indica se o browser cliente suporta JavaScript. O tipo é Boolean.

 

MajorVersion

 

Indica o número de versão principal do navegador do cliente. O tipo é Integer.

 

MinorVersion

 

Indica o número de versão secundária do navegador do cliente. O tipo é dupla. Por exemplo, se

a versão do navegador do cliente é 8,15, o valor da propriedade MinorVersion é de 0,15.

 

MSDomVersion

 

 

 

 

297

 

 

 

 

Indica a versão do modelo de objeto Microsoft XML documento que o browser do cliente

suporta. O tipo é a versão (definido no namespace System).

 

Plataforma

 

Indica que a plataforma sobre a qual o navegador do cliente está em execução. O tipo é String. Por exemplo,

para um navegador rodando no Windows 2000 Professional, a Plataforma propriedade retorna "WinNT".

 

Tabelas

 

Indica se o browser do cliente suporta tabelas HTML. O tipo é Boolean.

 

Tipo

 

Indica o nome eo número da versão principal do navegador do cliente (por exemplo, "IE6"). O tipo é

String.

 

VBScript

 

Indica se o browser cliente suporta VBScript. O tipo é Boolean.

 

Versão

 

Indica o número da versão completa do navegador do cliente (por exemplo, "8,15"). O tipo é String.

 

W3CDomVersion

 

Indica a versão do modelo de objeto XML do W3C documento que o browser cliente suporta.

O tipo é a versão (definido no namespace System).

 

Win16

 

Indica se o navegador do cliente está sendo executado em um sistema operacional de 16 bits do Windows. A

tipo é Boolean.

 

Win32

 

Indica se o navegador do cliente está sendo executado em um sistema operacional de 32 bits do Windows. A

tipo é Boolean.

 

6,8 Manutenção Estado

 

O processo de servir páginas web é inerentemente apátridas. Por padrão, cada solicitação para um servidor web é

isoladas de cada solicitação de outros que um usuário pode fazer. Este é um modelo bem para servir web estáticas

páginas, mas não é muito útil para aplicações full-featured. Para serem úteis, as candidaturas devem acompanhar

do Estado. Esta seção descreve as diferentes opções que os desenvolvedores web têm para estado.

 

6.8.1 O Objeto Session

 

Quando um usuário navega para uma página web servidos pelo IIS, o IIS considera o início de uma sessão para esse usuário.

Uma sessão é um conceito abstrato que se refere ao período de tempo em que um determinado usuário é

interagir com uma aplicação web. Embora seja fácil determinar quando uma sessão é iniciado, ele não é tão

fácil saber quando a sessão terminar. Isso é por causa da desconexão inerente web

navegação. Depois de solicitar a qualquer dado de teia é atendido, o IIS não sabe realmente se o usuário irá emitir

mais pedidos (ver as páginas mais). Por este motivo, o IIS cria um período de tempo limite da sessão. Se não

 

 

298

 

NET Programação Visual Basic.

 

 

novas solicitações forem recebidas de um usuário após um determinado período de tempo, o IIS considera que a sessão ter

terminou.

 

Uma sessão corresponde a uma única utilização de uma aplicação web por um único usuário. Para auxiliar na web

aplicação na manutenção do estado para a duração de uma sessão, o ASP.NET fornece um objeto intrínseco

chamado o objeto Session. Quando a sessão começa, ASP.NET instancia um objeto de sessão. Durante

processamento de solicitações web, o aplicativo pode armazenar informações para o objeto de sessão em

pares nome / valor. Mais tarde, os pedidos recebidos durante a mesma sessão pode ler as informações armazenadas no

o objeto de sessão. O objetivo da sessão é do tipo HttpSessionState (definido no

System.Web.SessionState) e está disponível através da propriedade da classe Page's Session.

Aqui está um exemplo de salvar informações em um objeto de sessão:

 

Session ("Nome") = txtFirstName.Text

 

Por exemplo, este código pode ser executado em resposta ao usuário clicar em um botão Enviar em um formulário. A

de código pressupõe que a página tem uma caixa de texto chamado txtFirstName, no qual o usuário tem presumivelmente

digitado um nome. O valor assim salvou está disponível (até que a sessão termina) a todos os web subseqüente

pedidos pelo mesmo usuário. Por exemplo, uma página subseqüente pode usar este valor para personalizar um

mensagem, como esta:

 

Response.Write ("Olá," & Session ("Nome") & ", bem-vindo ao ASP.NET!")

 

As propriedades comumente utilizados da classe HttpSessionState são:

 

Contagem

 

O número de itens armazenados no objeto Session. O tipo é Integer.

 

IsNewSession

 

Uma indicação de se a solicitação atual criou a sessão. O tipo é Boolean.

 

Chaves

 

Uma coleção de todas as teclas utilizadas no objeto Session. A chave é o nome dos dados que são armazenados

no objeto de sessão, ao contrário do valor dos dados. Por exemplo, na linha seguinte

de código, a chave é "Nome":

 

Session ("Nome") = txtFirstName.Text

 

O fragmento de código a seguir percorre todas as chaves no objeto de sessão:

 

Dim str As String

Para cada str Em Session.Keys

   '...

Seguinte

 

O tipo da propriedade Keys é KeysCollection (definido dentro da classe NameObjectCollectionBase

no namespace System.Collections.Specialized).

 

StaticObjects

 

Uma coleção de objetos declarados com a tag scope="Session"> <object na

processo de requerimento do global.asax. O tipo é HttpStaticObjectsCollection (definido no

Namespace System.Web). Veja Secção 6.9 mais adiante neste capítulo.

 

 

 

 

299

 

 

 

 

Timeout

 

O tempo limite da sessão, em minutos. Se um novo pedido não for recebido neste tempo, o

sessão termina. O tipo é Integer. O padrão é 20.

 

Alguns métodos comumente utilizados da classe HttpSessionState são:

 

Abandonar

 

Encerra a sessão atual. A sintaxe é:

 

Sub Público Abandon ()

Limpar

 

Limpa todos os valores a partir do objeto Session. A sintaxe é:

 

Sub Público Clear ()

Remover

 

Apaga um único item do objeto Session. A sintaxe é:

 

Public Sub Remove (ByVal nome As String)

 

6.8.2 O objeto Application

 

Algumas estado deve ser mantido no nível do aplicativo e não no nível da sessão, o que significa que

as informações de estado está disponível para todas as sessões do aplicativo. Isto é o que o objeto Aplicativo for

para. Ele é usado apenas como o objeto de sessão, exceto que os valores armazenados no objeto de aplicativo são visíveis

a todas as sessões do aplicativo. O objeto Application é instanciado quando começa a primeira sessão,

e termina quando não existem mais sessões.

 

Tenha cuidado ao escrever os novos valores para o objeto Application. Como um objeto único pedido é

compartilhado por todas as sessões simultâneas (que pode ser executado em segmentos separados em IIS),-threading

problemas de concorrência entram em jogo. Por exemplo, considere um aplicativo no qual cada sessão de lojas

nome do seu usuário em uma matriz que é armazenado no objeto Application. O aplicativo pode usar este

informações para exibir uma tela de resumo de todos os usuários ativos da aplicação. Simplista código

para realizar essa tarefa pode parecer como este:

 

"Errado!

nomes Dim ArrayList = Application ("Nomes")

Se nomes não é nada então

   nomes = New ArrayList ()

   Application ("Nome") = nomes

End If

names.Add (txtName.Text)

 

Novamente, esse código pode ser executado em resposta a um evento de clique de botão em que o usuário envia alguns

informações coletadas em um formulário. Ela assume que há uma caixa de texto chamado txtName no formulário. A

informações assim coletadas podem ser usadas por qualquer sessão na aplicação. Note-se que todas as sessões no

aplicação adicionar os seus dados para a lista de mesma matriz. Uma simples página para ver esta informação pode parecer

isso:

 

<% @ Page AutoEventWireup = "false" Language = "VB" Debug = "true"%>

 

<script runat="server">

 

   Substitui Protegido OnLoad Sub (e As EventArgs)

 

 

300

 

NET Programação Visual Basic.

 

 

      lstNames.DataSource = Application ("Nomes")

      lstNames.DataBind ()

   End Sub

 

</ Script>

 

<html>

   <body>

      Atualmente os usuários ativos: <br>

      <asp:ListBox id="lstNames" runat="server" />

   </ Body>

</ Html>

 

Aqui, o código é carregar um controle ListBox com o conteúdo da lista de matriz guardadas na aplicação

objeto. (A ligação de dados é explicado no Capítulo 8.)

 

Não há nada conceitualmente errado com essa abordagem, mas o código que salva as necessidades de informação

um pouco mais de atenção. O problema é que dois pedidos separados no mesmo aplicativo, mas em

diferentes sessões, poderia tentar modificar a lista de matriz ao mesmo tempo. A lista de matriz não é thread-

seguro, por isso pode acarretar problemas, possivelmente resultando em perda de dados ou exceções do aplicativo. Para resolver esse

problema, envolver o código que define os valores de chamadas a métodos do objeto Application travar e destravar,

como este:

 

Application.Lock ()

nomes Dim ArrayList = Application ("Nomes")

Se nomes não é nada então

   nomes = New ArrayList ()

   Application ("Nome") = nomes

End If

names.Add (txtName.Text)

nomes = Nothing

Application.UnLock

 

Durante o tempo depois que o método Lock foi chamado, mas antes o método Unlock tem sido chamado,

se o código em outro thread chama o método de bloqueio, que o segmento irá bloquear (parar temporariamente de funcionar) até

o código no primeiro segmento, chama o método de desbloqueio. Isso garante que os dois segmentos não estão acessando

a lista de matriz ao mesmo tempo. O lado ruim disso é que o desempenho é prejudicado quando vários segmentos estão

bloqueados à espera de acesso aos dados do mesmo aplicativo. Isso torna imperativa a chamada UnLock como

mais rapidamente possível e não esquecer de chamá-lo.

 

O objeto Application é uma instância da classe HttpApplicationState (definido no System.Web

namespace). propriedades comumente utilizados da classe HttpApplicationState são:

 

AllKeys

 

Uma matriz de todas as teclas utilizadas no objeto Aplicativo. A chave é o nome dos dados que são armazenados

no objeto Application, ao contrário do valor dos dados. Por exemplo, nos seguintes

linha de código, a chave de sessão é "nomes":

 

Application ("Nome") = nomes

 

O fragmento de código a seguir percorre todas as chaves no objeto Application:

 

Para cada str Em Application.AllKeys

   '...

Seguinte

 

O tipo da propriedade AllKeys é String Array.

 

 

301

 

 

 

 

Contagem

 

 

 

 

 

 

 

O número de itens armazenados no objeto Aplicativo. O tipo é Integer.

 

 

StaticObjects

 

Uma coleção de objetos declarados com a tag scope="Application"> <object na

processo de requerimento do global.asax. O tipo é HttpStaticObjectsCollection (definido no

Namespace System.Web). Veja Secção 6.9 mais adiante neste capítulo.

 

Os métodos comumente utilizados da classe HttpApplicationState são:

 

Limpar

 

Limpa todos os valores do objeto Application. A sintaxe é:

 

Sub Público Clear ()

Lock

 

Como explicado anteriormente, o código proíbe em outras sessões de escrita para o objeto Application

até UnLock é chamado. A sintaxe é:

 

Public Sub Lock ()

Remover

 

Apaga um único item do objeto Application. A sintaxe é:

 

Public Sub Remove (ByVal nome As String)

UnLock

 

Desbloqueia o objeto Application após uma chamada para Lock. A sintaxe é:

 

Sub Público unlock ()

 

6.8.3 Cookies

 

Outra forma de guardar informações entre solicitações de página da web é para salvá-lo no cliente um cookie. A

cookie é um par nome / valor que o navegador grava no nome do aplicativo. Cookies são desenhados para

o domínio da aplicação que os criou. Quando o navegador solicita uma página, ele automaticamente

transmite os cookies que pertencem a esse domínio como parte da solicitação de página. O aplicativo pode

ler os valores dos cookies e tomar medidas adequadas. Os cookies são um padrão da indústria e

deve funcionar com qualquer browser. Entretanto, esteja ciente que os usuários podem desligar os cookies no seu navegador

configurações, portanto, uma aplicação que depende de cookies não podem ser acessíveis a todos os usuários.

 

Cookies geralmente são usados de duas maneiras. Uma delas é economizar algum tipo de informação de identificação sobre o

usuário, de modo que quando o usuário retornar a um determinado site, o aplicativo sabe quem é o usuário. Os outros

forma é a de poupar algum tipo de informação, indicando o estado do aplicativo entre requisições de páginas web

dentro de uma única sessão. Isso permite que o aplicativo para recuperar seu estado de cada solicitação de página. Embora

qualquer informação pode ser guardada em um cookie, a melhor prática é usar uma espécie de chave para procurar o

informações reais do lado do servidor. Esta prática minimiza o tráfego de e para o cliente, ajuda a

garantir que as informações potencialmente confidenciais não são armazenados no cliente, e ajuda a garantir que a

cliente não pode falsificar o servidor, substituindo as informações incorretas no cookies.

 

Cookies são criadas adicionando itens à coleção Cookies do objeto Response ASP.NET

(Disponível através da propriedade Response da classe Page). Por exemplo:

 

 

 

302

 

 

NET Programação Visual Basic.

 

 

Dim cookie como novo HttpCookie ("MyCookieName", "MyCookieValue")

Response.Cookies.Add (cookies)

 

Isso é tudo o que preciso. O ASP.NET cópias quadro as informações para a resposta HTTP para o

browser cliente. O navegador armazena a informação no computador do cliente de uma forma que é

determinada pelo tipo de navegação utilizado.

 

O construtor da classe HttpCookie tem duas versões. O mostrada anteriormente tem duas seqüências: a

primeiro é o nome do cookie, eo segundo é o seu valor. A outra versão da classe HttpCookie

construtor recebe um único parâmetro: a seqüência de caracteres que é o nome do cookie. O valor do cookie é

em seguida, definir, atribuindo um valor para o valor do objeto ou propriedade HttpCookie Valores (discutido no

lista a seguir). As propriedades da classe HttpCookie são:

 

Domínio

 

Representa o domínio associado ao cookie. O valor padrão é o domínio da web

solicitação de página que está sendo atendido. Se o servidor web é / / localhost, o valor padrão dessa propriedade

não é nada. O tipo é String.

 

Expira

 

Representa a data ea hora em que o cookie expira. O padrão é

DateTime.MinValue, o que resulta em um cookie que não expira. O tipo é Date.

 

HasKeys

 

Indica se o cookie tem subchaves. Subkeys permitir um cookie para ter mais de um

valor. Veja também a propriedade Values. O padrão é False. O tipo é Boolean.

 

Item

 

Fornece uma maneira de acessar os valores de subchaves para bolinhos de subchaves. A propriedade Item é

uma propriedade indexada que leva o nome da subchave que o índice e retorna seu valor. Este

propriedade é fornecida pela similaridade sintática com o ASP clássico. Novo código deve usar o

coleta de valores para acessar os valores de subchaves.

 

Nome

 

Representa o nome do cookie, como determinado no construtor da classe HttpCookie. O tipo é

String.

 

Caminho

 

Representa o caminho associado com o cookie. O padrão é "/". O tipo é String.

 

Secure

 

Indica se o cookie deve ser transmitido apenas através de uma conexão segura (HTTPS).

O padrão é False. O tipo é Boolean.

 

Valor

 

Representa o valor do cookie. O padrão é uma seqüência vazia. O tipo é String.

 

Valores

 

 

 

303

 

 

 

 

Se o cookie tem subchaves, a propriedade de Valores é um exemplo de NameValuesCollection

(Definido no namespace System.Collections.Specialized). Esta coleção contém a subchave

pares nome / valor.

 

Em solicitações subseqüentes, os cookies estão disponíveis para a leitura da coleção Cookies do

ASP.NET objeto de solicitação (disponível através do imóvel da classe Page). Por exemplo:

 

Dim cookie Como HttpCookie = Request.Cookies ("MyCookie")

Label1.Text = cookie.Value

 

6,9 Nível de aplicativo de código e global.asax

 

Todo o código mostrado até agora foi escrito no nível da página, aparecendo tanto em um arquivo aspx. Ou em um

ficheiro de código subjacente que implementa uma classe derivada de Page. No entanto, é preciso haver uma maneira de lidar com

eventos e manipular propriedades no nível do aplicativo, bem como, sem levar em conta qualquer página.

Para este efeito existe o arquivo Global.asax. global.asax é um arquivo que, opcionalmente, pode aparecer em uma teia

diretório raiz do aplicativo. Se ele estiver presente, ele pode conter código e configurações que são automaticamente

processados pelo framework ASP.NET nos momentos adequados.

 

6.9.1 Sessão e Aplicação de inicialização e desligamento

 

Algumas aplicações podem precisar executar determinado código, sempre que uma nova sessão é iniciada, ou está prestes a terminar,

ou quando o aplicativo como um todo é iniciado pela primeira vez ou está prestes a acabar. Isto é feito, colocando o código em

o arquivo do aplicativo global.asax, como mostrado no Exemplo 6-9.

 

Exemplo 6-9. Respondendo a sessão e aplicação de início e fim em um

arquivo global.asax

language="vb" runat="server"> <script

 

   Público Session_OnStart Sub ()

      '...

   End Sub

 

   Public Sub Session_OnEnd ()

      '...

   End Sub

 

   Public Sub Application_OnStart ()

      '...

   End Sub

   Público Application_OnEnd Sub ()

      '...

   End Sub

 

</ Script>

 

Observe que o código é colocado em <script> blocos.

 

O código no Exemplo 6-9 define quatro sub-rotinas:

 

Session_OnStart

 

Chamado pela estrutura ASP.NET quando uma sessão é iniciada

 

Session_OnEnd

 

 

304

 

NET Programação Visual Basic.

 

 

Chamado pela estrutura ASP.NET quando uma sessão é encerrada

 

Application_OnStart

 

Chamado pela estrutura quando um aplicativo ASP.NET inicia (ou seja, quando da aplicação

começa a primeira sessão)

 

Application_OnEnd

 

Chamado pela estrutura quando uma aplicação ASP.NET termina (ou seja, quando da aplicação

sessão últimos remanescentes termina)

 

Estes quatro sub-rotinas não são manipuladores de eventos são simplesmente sub-rotinas que são automaticamente

executado, quando presentes. Eles são tipicamente usados para criar e dispor de informações necessárias ao

sessão ou em nível de aplicativo. Por exemplo, um pedido de compras online pode usar o

subrotina Application_OnStart para ler informações sobre o produto popular a partir de um banco de dados e cache-lo em

o objeto Application, melhorando assim o desempenho para os usuários do aplicativo.

 

6.9.2 Compila global.asax a uma classe

 

A primeira vez que um aplicativo é acessado, o arquivo global.asax é compilado em uma classe que herda

a classe HttpApplication (definido no namespace System.Web). As sub-rotinas declaradas em

global.asax-se os métodos da classe compilada. Embora os membros do HttpApplication

classe não são discutidos neste livro, estar ciente de que, se necessário, os membros podem ser acessados

por código no Global.asax. Além disso, eventos expostos pela classe HttpApplication podem ser tratados por

manipuladores de eventos adicionando global.asax. Cada manipulador de eventos deve ter a assinatura de direito, tal como definido pela

documentação do evento e uma cláusula Handles MyBase.EventName para registrar o manipulador com

o evento. Novamente, os fatos expostos pela classe HttpApplication não são discutidos neste livro.

No entanto, no caso de você gostaria de persegui-lo em seu próprio país, Exemplo 6-10 mostra como um evento como esse

manipulador pode ser declarada no global.asax.

 

Exemplo 6-10. Manipulação de um evento de classe HttpApplication no global.asax

language="vb" runat="server"> <script

 

   '...

 

   'Punho evento BeginRequest da classe base. O nome do

   "Manipulador de evento não é importante, mas a assinatura eo

   "Cláusula Handles são.

   HttpApplication_BeginRequest Private Sub (_

      ByVal sender As Object, _

      ByVal e As EventArgs _

   ) Handles MyBase.BeginRequest

      '...

   End Sub

 

</ Script>

 

6.9.3 Adicionando objetos Global

 

Um aplicativo freqüentemente precisa instanciar um objeto e torná-la disponível a todas as páginas dentro de uma sessão

ou dentro de todo o aplicativo. Uma maneira de fazer isso é instanciar o objeto no Session_OnStart

ou métodos Application_OnStart e guardar a referência do objeto na Sessão do ASP.NET ou

Aplicação do objeto, respectivamente. Páginas poderá ler a referência do objeto da sessão ou

Aplicação de objetos e usá-lo como necessário.

 

 

 

 

305

 

Uma forma um pouco mais conveniente para alcançar um resultado similar é colocar um elemento <object> na

arquivo Global.asax. O elemento <object> indica que uma instância de determinada classe deve ser

criado e disponibilizado a todas as páginas na sessão ou aplicação (dependendo dos atributos

especificada). ASP.NET torna o objeto disponível para todas as páginas do aplicativo, adicionando uma propriedade para

cada página do aplicativo. A propriedade é chamada de forma idêntica ao atributo ID do <object>

elemento. Por exemplo, aqui é um elemento <object> que cria um objeto Hashtable que está disponível

aplicação à escala:

 

<Objeto

   id = "myHashtable"

   runat = "server"

   scope = "Aplicação"

   class = "System.Collections.Hashtable" />

 

Esta declaração especifica o seguinte:

 

• Uma instância da classe Hashtable (definido no namespace System.Collection) será

criado (class = "System.Collections.Hashtable").

• Este única instância da classe Hashtable será compartilhado por todas as páginas do aplicativo

(Scope = "Aplicação"). Se houver de ser uma instância separada para cada sessão, especificar

scope = "Sessão".

• Uma propriedade denominada myHashtable será adicionado a cada página no aplicativo para permitir a web

código de acesso fácil para a página do objeto (id = "myHashtable").

 

Código para acessar a instância do objeto de uma página web ficaria assim:

 

<% @ Page Language = "vb"%>

 

<script runat="server">

   Substitui Sub Protected OnLoad (ByVal e As EventArgs)

      "Faça alguma coisa com o objeto criado no global.asax.

      myHashtable.Add ("SomeKey", "SomeValue")

   End Sub

</ Script>

 

'...

 

A propriedade que é compilado automaticamente na página (neste caso, a propriedade myHashtable) é

compilados para a classe que é compilada a partir do arquivo aspx.. Não é compilado em código da página-

por trás de classe (se houver). Isso significa que o imóvel está disponível para o código que está incorporado em

o arquivo aspx., mas não ao código na classe code-behind.

 

Todos os objetos criados como resultado dos elementos constantes <object> global.asax são adicionados ao

StaticObjects coleção de qualquer objeto Session ou o objeto Application (dependendo do valor

especificado para o atributo escopo do elemento <object>). Por exemplo, o objeto myHashtable

pode ser acessado da seguinte forma:

 

<% @ Page Language = "vb"%>

 

<script runat="server">

   Substitui Sub Protected OnLoad (ByVal e As EventArgs)

      "Faça alguma coisa com o objeto criado no global.asax.

      Dim HT em Hashtable

      ht = CType (Application.StaticObjects ("myHashTable"), Hashtable)

      ht.Add ("foo", "bar")

   End Sub

</ Script>

 

 

 

306

 

 

 

 

'...

 

NET Programação Visual Basic.

 

 

Isto tem a vantagem de também trabalhar a partir da classe code-behind, ou de qualquer código que tenha acesso

para o aplicativo ASP.NET (ou Session) do objeto.

 

6,10 Segurança de aplicativos Web

 

Muitas aplicações web têm porções que devem ser vistos ou usados apenas por determinados usuários. Em tal

aplicações, os utilizadores devem de alguma forma se identificam com o pedido para que o aplicativo pode

em seguida, determinar quais os usuários podem acessar. Na terminologia de segurança, o processo de identificação do usuário

é conhecido como autenticação. Após a autenticação ocorre, o sistema deve determinar se o dado

usuário tem permissão para acessar o recurso solicitado. Esta autorização é chamado. A parte do

aplicação a ser protegida é conhecido como um recurso protegido.

 

6.10.1 Autenticação

 

A autenticação é o processo pelo qual uma aplicação web de forma confiável descobre a identidade de um

aplicação do usuário. A fim de descobrir a identidade do usuário é determinar se o usuário é

autorizados a acessar um determinado recurso. Dependendo da aplicação, a precisão deste processo

pode ser crítica. Uma aplicação bancária on-line, por exemplo, deve ter a certeza que o usuário

afirma ser que você realmente é você antes que ele permite ao usuário transferir todo o seu dinheiro a um banco em Bora-

Bora. Existem diferentes formas que este pode ser feito, dependendo do tipo de aplicação que está sendo

escrita e sobre o nível de protecção exigido.