GUIA DA DOCUMENTAÇÃO DO VISUAL
C#....................................................................................................................
17 I NTRODUÇÃO À LINGUAGEMC# E AO
.NET FRAMEWORK ............................................................................................
18 O QUE HÁ DE NOVO NO VISUAL
C# 2005.......................................................................................................................
20 O QUE HÁ DE NOVO NA C# 2.0 IDIOMA E
COMPILER ......................................................................................................
22 ATUALIZANDO APLICATIVOS VISUAL C# PARA VISUAL STUDIO
2005..........................................................................
24 CRIANDO SEU PRIMEIRO APLICATIVO
C#.....................................................................................................................
25 USANDO STARTER K ITS
C#...........................................................................................................................................
26 R ECURSOS DE AJUDA ADICIONAIS (VISUAL
C#)...........................................................................................................
26 COMO FAZER EM C#
.....................................................................................................................................................
27
USANDO O IDE DO VISUAL C#
.......................................................................................................................
29
I NTRODUÇÃO À IDE (VISUAL
C#).................................................................................................................................
29 CRIANDO UM PROJETO (VISUAL
C#).............................................................................................................................
31 PROJETANDO UMA INTERFACE DE USUÁRIO (VISUAL C#)
.............................................................................................
34 O I NTELLISENSE
...........................................................................................................................................................
36 LISTAS DE CONCLUSÃO
.................................................................................................................................................
37 I NFORMAÇÕES
RÁPIDAS................................................................................................................................................
37 MEMBROS DA
LISTA......................................................................................................................................................
37 I NFORMAÇÕES DE
PARÂMETRO.....................................................................................................................................
37 ADICIONANDO DIRETIVAS
'USING'.................................................................................................................................
38
R EFATORAÇÃO..............................................................................................................................................................
38 TRECHOS DE CÓDIGO
....................................................................................................................................................
38 SUBLINHADO
ONDULADO..............................................................................................................................................
38 AJUDA DE
LEGIBILIDADE..............................................................................................................................................
39
MODELAGEM E ANÁLISE DE CÓDIGO (VISUAL
C#)............................................................................46
ADICIONANDO E EDITANDO RECURSOS (VISUAL C#)
....................................................................49
OBTENDO AJUDA (VISUAL C#)
......................................................................................................................
51
IMPLANTANDO APLICATIVOS C#
.................................................................................................................
54
R ECURSOS DO CODE EDITOR DO VISUAL
C#.................................................................................................................
54 Refatoração
.............................................................................................................................................................54
TRECHOS DE CÓDIGOS
(C#)...........................................................................................................................................
55 CÓDIGO
COLORIZATION................................................................................................................................................
56 METADADOS COMO
FONTE............................................................................................................................................
58 CONFIGURAÇÕES DO IDE VISUAL
C#...........................................................................................................................
59 ATALHOS DE TECLADO VISUAL
C#...............................................................................................................................
60
ESCREVENDO APLICATIVOS COM O VISUAL C#
..................................................................................64
CRIANDO COMPONENTES (VISUAL
C#)....................................................................................................
68
DESENVOLVENDO NA PLATAFORMA DO OFFICE (VISUAL C#)
......................................................................................
68 Programação do Office (Como Fazer em
C#).........................................................................................................68
Como: Atualizar soluções das Ferramentas do Visual Studio para o
Office
..........................................................69
O EXCEL USANDO EXPLICAÇÕES
PASSO-A-PASSO.............................................................................71
O WORD USANDO EXPLICAÇÕES PASSO-A-PASSO
..........................................................................116
WALKTHROUGH: CHANGING DOCUMENT FORMATAÇÃO USANDO CONTROLES
CHECK BOX .......................................116
EXIBINDO TEXTO EM UMA CAIXA DE TEXTO EM UM DOCUMENTO USANDO UM
BOTÃOWALKTHROUGH:....................119
WALKTHROUGH: CRIANDO MENUS DE ATALHO PARA
INDICADORES...........................................................................
121 WALKTHROUGH: ATUALIZANDO UM GRÁFICO EM UM DOCUMENTO
USANDO BOTÕES DE OPÇÃO................................124
VINCULAÇÃO DE DADOS PARA CONTROLES EM UM PAINEL AÇÕES DO WORD
WALKTHROUGH: ................................128 WALKTHROUGH:
CRIAR UMA MARCA INTELIGENTE QUE CONVERTETEMPERATURES DE FAHRENHEIT
PARA CELSIUS133 IMPLANTANDO UM WORD OU SOLUTION DO EXCEL
USANDO UM MANIFESTO DEPLOYMENT WALKTHROUGH:..........135
IMPLANTANDO UM WORD OU SOLUTION DO EXCEL USANDO UM ARQUIVO DO
WINDOWS I NSTALLER WALKTHROUGH:
....................................................................................................................................................................................139
PASSO-A-PASSO: CONCEDENDO E REMOVENDO PERMISSÕES PARA
UMA SOLUÇÃO DOOFFICE ...................................144
COMO: ADICIONAR CONTROLES A DOCUMENTOS DO OFFICE
...................................................................................147
COMO: EXECUTAR CÁLCULOS DO EXCEL
POR PROGRAMAÇÃO.................................................................................149
COMO: CRIAR MENUS DO OFFICE
PROGRAMATICAMENTE...........................................................................................149
COMO: CRIAR BARRAS DE FERRAMENTAS DO OFFICE
POR PROGRAMAÇÃO
.............................................................150
DESENVOLVIMENTO CORPORATIVO (VISUAL C#)
...........................................................................152
MIGRANDO PARA O VISUAL C#
...................................................................................................................155
C# PARA DESENVOLVEDORES JAVA
............................................................................................................................155
CONVERTENDO APLICATIVOS JAVA PARA VISUAL
C#.................................................................................................155
PARA DESENVOLVEDORES C++ C#
...............................................................
..............................................................
155
MAIN() E ARGUMENTOS DE LINHA DE COMANDO (GUIA DE PROGRAMAÇÃO C#)
...................................................... ..160
ARGUMENTOS DE LINHA DE COMANDO (GUIA DE PROGRAMAÇÃO
C#)........................................................................161
COMO: EXIBIR ARGUMENTOS DE LINHA DE COMANDO (GUIA DE
PROGRAMAÇÃO C#)..............................................162
COMO: ACESSAR ARGUMENTOS DE LINHA DE COMANDO USANDO
FOREACH(GUIA DE PROGRAMAÇÃO C#).............163 MAIN()
RETORNA VALORES (GUIA DE PROGRAMAÇÃO
C#).........................................................................................163
TIPOS DE DADOS (GUIA DE PROGRAMAÇÃO C#)
.................................................................
.........................................164
MATRIZES (GUIA DE PROGRAMAÇÃO DO
C#).....................................................................................165
MATRIZES COMO OBJETOS (GUIA DE PROGRAMAÇÃO
C#)...........................................................................................165
ESPECIFICAÇÃO DA LINGUAGEM C#
........................................................................................................173
O QUE HÁ DE NOVO NA C# 2.0 IDIOMA E
COMPILER ....................................................................................................340
Usando Starter Kits C#
..................................................................
.............................................................
..........340 Especificação da Linguagem C#
.............................................................
..............................................................
341 Main() e argumentos de linha de comando (Guia de
programação C#).................................................
..............341 Main() retorna valores (Guia de
programação
C#)...................................................................................
...........343 base (Referência do C#)
....................................................................
....................................................................
343 Construtores de instância (Guia de programação C#)
................................................................
.........................345
CLASSES GENÉRICAS NO
.NET FRAMEWORK ..............................................................................................................357
Visão geral sobre Generics no .NET
Framework..................................................................................................357
Tipos e Generics aninhadas
......................................................
..................................................................
..........358
System.Collections.Generic...................................................................................................................................359
.NET FRAMEWORK (COMO FAZER EM
C#).......................................................................................................397
I NTRODUÇÃO À LINGUAGEMC# E AO
.NET FRAMEWORK ..........................................................................................408
Visão geral sobre o .NET
Framework...................................................................................................................410
Visão Geral Conceitual Sobre o .NET Framework
..........................................................................
.....................410
ASSEMBLIES NO COMMON LANGUAGE
R UNTIME........................................................................................................436
Visão Geral Sobre
Assemblies...............................................................................................................................437
Benefícios do Assembly
...........................................................
...................................................................
...........438 Sumário de assembly
..................................................................
.................................................................
..........439 Manifesto do Assembly...
.....................................................................
..................................................................
440 Cache Global de Assemblies
...............................................................
..................................................................
442 Assemblies de Nomes Fortes
.............................................................
....................................................................
443 Considerações sobre segurança de
assemblies.....................................................................................................443
Versionamento de Assembly
..................................................................
................................................................
445 Número de Versão do Assembly
.......................................................................
.....................................................446
Versão Informativa do
Assembly...........................................................................................................................447
Posicionamento do Assembly
..................................................................
.............................................................
.447 Assemblies e execução lado a
lado...........................................
.................................................................
............448 Visão Geral da Biblioteca de Classes do
.NET
Framework..................................................................................448
Localizador rápido de
tecnologia.....................................................................................................
.....................451 Criando Novas Seqüências de
Caracteres.............................................................................................................458
Aparando e Removendo Caracteres
.............................................................
.........................................................460
Preenchendo Seqüências de
Caracteres................................................................................................................461
Comparando Seqüências de
Caracteres................................................................................................................462
Alterando a
Caixa.............................................................................................
.....................................................466
Usando a Classe StringBuilder
......................................................................
.......................................................467
Acrescentar..................................................................
.....................................................................
.....................468 Coleções e Estruturas de
Dados............................................................................................................................472
Definir coleções............................................
.........................................................................
................................472 Comumente usados tipos da
coleção.....................................................................................................................474
Coleções de
bits.....................................................................................................................................................474
APLICATIVOS DO WINDOWS (COMO FAZER EM C#)
........................................................
............................................786 Componente
Timer (Windows
Forms)...................................................................................................................797
Visão geral do componente de timer (Windows
Forms)........................................................................................797
Limitações do componente Timer de formulários do Windows na
propriedade
Interval......................................798
Controle toolBar Windows
(formulários)..............................................................................................................800
Visão geral sobre de controle toolBar (formulários do
Windows)........................................................................800
Como adicionar botões a um controle ToolBar usando o
criador:.......................................................................801
PÁGINAS DA WEB E SERVIÇOS DA WEB (COMO FAZER EM
C#)................................................................806
O que há de novo no desenvolvimento para Web no Visual
Studio.......................................................................806
Servidor de Desenvolvimento do
ASP.NET...........................................................................................................807
Publicação de Web Sites
....................................................................
...................................................................
808 Extensibilidade de Controle
..................................................................
................................................................
811 Ligação de Dados com Controles de Fonte de Dados
.................................................................
.........................812 Controles de dados
avançados..............................................................................................................................812
Vinculação bidirecional de dados
.....................................................................
....................................................813
Armazenamento de seqüência de caracteres de
conexão...........
...........................................................................
813 Acesso a dados em duas e três camadas
................................................................
...............................................813
Compatibilidade com Versões Anteriores para Acesso a Dados
...............................................................
...........814
I NTRODUÇÃO A PÁGINAS DAWEB DO
ASP.NET.........................................................................................................815
Postagem cruzada de páginas
...................................................................
............................................................816
Preservando o estado da página
......................................................
.....................................................................
816 Controles de servidor
...................................................................
.........................................................................
817 Compatibilidade do navegador
.....................................................................
........................................................818
Documentos e dados
XML.......................................................
...................................................................
...........818 O que há de novo no System.Xml
.............................................................
.............................................................818
Migrando de versão 1.1 das classes
XML...........................................................................
..................................819 Arquitetura
Overview of XML no .NET Framework
............................................................................
.................822 Segurança e seus aplicativos System.Xml
................................................................
.............................................822
Considerações sobre segurança
System.Xml.........................................................................................................823
ACESSO A DADOS (COMO FAZER EM C#)
.............................................................
.......................................................900
Criando os controles para exibir os pedidos para cada cliente
(registros
filho)..................................................902
Visão geral sobre como conectar-se a dados no Visual
Studio.............................................................................903
Visão Geral do Adaptador de
Tabela....................................................................................................................921
PROGRAMAÇÃO DO OFFICE (COMO FAZER EM
C#)...................................................................................................1080
Como: Atualizar soluções das Ferramentas do Visual Studio
para o Office
......................................................1080 O
Excel Usando Explicações
Passo-a-passo.......................................................................................................1081
Coleta de dados usando um formulário do Windows
Walkthrough:...................................................................1081
Para criar um novo
projeto.................................................................................................................................1081
Para adicionar um intervalo nomeado para
Sheet1............................................................................................1081
Para adicionar um formulário do
Windows........................................................................................................1082
Para exibir o formulário e coletar
informações..................................................................................................1082
Para enviar informações para a planilha
............................................................................
...............................1083 Para testar sua pasta de
trabalho
...........................................................................
............................................1083
Alterando planilha formatação usando controles CheckBox
Walkthrough:
.......................................................1083
Para criar um novo
projeto.................................................................................................................................1084
Para adicionar três caixas de
seleção.................................................................................................................1084
Para adicionar texto a um controle NamedRange
..........................................................................
....................1085 Exibindo texto em uma caixa de texto
em uma planilha usando um botão Walkthrough:
..................................1086 Para testar sua
pasta de trabalho
...........................................................................
............................................1088
Programação contra eventos de um controle NamedRange Walkthrough:
........................................................1088
Walkthrough: vinculação células para várias colunas em uma tabela
...............................................................
1099 Criando uma relação mestre / detalhes usando um DataSet
em cache Walkthrough:........................................
1103 Para criar um novo
projeto.................................................................................................................................1104
Armazenar em cache
DataSet.................................................
.....................................................................
........1105 Para percorrer os
registros.................................................................................................................................1106
Para testar o cache de dados
............................................................
..................................................................
1106 Para adicionar os dados
..............................................................
...............................................................
........1107 Para adicionar um gráfico
..................................................................
................................................................
1108 Para criar um novo
projeto.................................................................................................................................1108
Para alterar o nome do controle
gráfico.............................................................................................................1109
Para adicionar um controle de
usuário...............................................................................................................1109
Para adicionar controles Windows Form ao controle de usuário
......................................................................
1109 Para criar um evento e propriedade em um controle de
usuário........................................................................1110
Para manipular o evento CheckedChanged dos botões de
opção.......................................................................1110
Para adicionar o controle do usuário sua planilha
........................................................................
....................1111 Para alterar o tipo de gráfico que é
exibido na planilha
............................................................................
........1111 Para testar sua pasta de trabalho
...........................................................................
............................................1112 Vinculação
de Dados para controles em um painel Ações do Excel
Walkthrough:............................................1112
Para criar um novo
projeto.................................................................................................................................1113
Para adicionar uma nova fonte de dados para o
projeto....................................................................................1113
Para adicionar um NamedRange e um controle
ListObject................................................................................1114
Para adicionar um controle painel
Ações...........................................................................................................1114
Para adicionar controles Windows Forms ligados a dados a um
controle painel Ações ...................................1114
Para definir propriedades de vinculação de dados do
controle..........................................................................1115
Para mostrar o painel
Ações...............................................................................................................................1115
Para testar seu documento
........................................................
.................................................................
.........1115 Implantando um Word ou Solution do Excel
usando um manifesto Deployment Walkthrough:
.........................1116 Para criar um novo
projeto.................................................................................................................................1117
Para adicionar uma caixa de mensagem a um evento de inicialização
..............................................................1117
Para publicar a solução
....................................................................
..................................................................
1117 Para atualizar o manifesto do aplicativo
incorporado........................................................................................1118
Para atualizar a manifesto de
implantação.........................................................................................................1119
Para atualizar o manifesto do aplicativo externo
.........................................................................
......................1119 Para copiar os arquivos de solução
para o servidor
.....................................................................
.....................1120 Para conceder confiança total para
a pasta de
rede...........................................................................................1120
DISPOSITIVOS I NTELIGENTES
....................................................................................................................................1168
O que há de novo em projetos Smart
Device.......................................................................................................1168
O que há de novo no desenvolvimento visual aplicativos dispositivos
C++.......................................................1168
Destino vários sistemas operacionais
........................................................................
.........................................1168 Sistema
do
projeto...............................................................................................................................................1168
O IntelliSense
........................................................
................................................................
..............................1168 Modo misto
Solutions
.....................................................................
.....................................................................
1168 Instalar do aplicativo
..............................................................
...................................................................
.........1168 Aplicativos personalizados e
assistentes de
classe..................................................
............................................1168 Editor
de recursos
...................................................................
...................................................................
.........1169
ATL............................................................
...............................................................
...........................................1169 MFC
........................................................
................................................................
............................................1170 O que há de
novo no Managed projetos de
dispositivo.......................................................................................1170
Como Iniciar o Emulador de Dispositivo no Visual
Studio.................................................................................1171
Visão geral do acesso de dados (projetos do dispositivo
gerenciado)................................................................1172
Visão geral Solutions do dispositivo de embalagem
...................................................................
........................1173 Alternar plataformas em
projetos de
dispositivo......................................................
...........................................1174 Ferramentas
Remotas para Projetos de Dispositivos
......................................................................
...................1174 Visão geral sobre segurança
(dispositivos).........................................................................................................1175
Seleção método de
conexão.................................................................................................................................1176
Atualizando Projetos Criados com Ferramentas
Anterior...............................................
...................................1178 Selecionando
uma Linguagem de
Desenvolvimento............................................................................................1179
Visual C# Consolidado 16
VISUAL C# Microsoft Visual C# 2005, pronunciado C sharp, é uma
linguagem de programação projetada para criar uma ampla variedade
de aplicativos executados no .NET Framework. C# é simples,
poderoso, com segurança de tipos, e orientada a objetos. Com suas
muitas inovações, C# permite o desenvolvimento rápido de
aplicativos mantendo a expressividade e elegância das linguagens do
estilo C.
Visual Studio oferece suporte ao Visual C# com um editor de códigos
completo, modelos de projeto, designers, assistentes de código,
depurador poderoso e de fácil uso, e outras ferramentas. A
biblioteca de classes do .NET Framework fornece acesso a uma grande
variedade de serviços do sistema operacional e outras classes
úteis, e bem estruturadas que aceleram o ciclo de desenvolvimento
significativamente.
Nesta seção
Guia de Introdução ao Visual C#
Apresenta os recursos do C# 2.0 para programadores novos para
a linguagem ou novos para o Visual Studio, e fornece um roadmap
para encontrar ajuda no Visual Studio. Isso também está localizado
nas páginas "Como Fazer".
Usando o Visual C# IDE
Apresenta o ambiente de desenvolvimento do Visual C#.
Escrevendo aplicativos com Visual C#
Fornece uma orientação de alto nível abrangendo tarefas comuns de
programação usando C# e o .NET Framework, com links para a
documentação mais detalhada.
Migrando para o Visual C#
Compara a linguagem C# com Java e C++ e descreve como usar o Java
Language Conversion Assistant para converter aplicativos Java
e Visual J++ para Visual C#.
Guia de programação C #
Fornece informações e exemplos práticos sobre como usar construções
de linguagem C#.
Referência C#
Especificação da linguagem C#
Links para a versão mais recente das especificações C# no formato
Microsoft Word.
Exemplos de Visual C#
GUIA DE INTRODUÇÃO AO VISUAL C#
Os tópicos a seguir ajudam a iniciar o desenvolvimento de
aplicativos usando o Microsoft Visual C# 2005. Esses tópicos também
lhe introduzirão a muitos novos recursos no Microsoft Visual Studio
2005 como versão 2.0 da linguagem C#.
Nesta seção
Fornece uma orientação de alto nível sobre o conteúdo da
documentação Visual C#.
Introdução à linguagem C# e ao Framework .NET
Fornece uma visão geral sobre a linguagem C# e a plataforma
.NET.
O Que Há de Novo no Visual C-# 2005
O que há de novo no Microsoft Visual C# 2005.
O Que Há de Novo na Linguagem e Compilador C# 2.0
O que há de novo na versão 2.0 do C#.
Atualizando Aplicativos Visual C# para Visual Studio 2005
Atualizando seus projetos existentes para o Microsoft Visual
Studio 2005.
Criando Seu Primeiro Aplicativo C#
Usando Starter Kits C#
Recursos de ajuda adicionais (Visual C#)
Como Fazer em C#
Links para tópicos que mostram como executar uma variedade de
tarefas específicas.
Guia da Documentação do Visual C# A documentação do Microsoft
Visual C# 2005 contém informações que são específicas para a
linguagem C#, como palavras-chave, opções de compilador, mensagens
de erro e conceitos de programação. Esta documentação também
oferece uma visão geral de como usar o ambiente de desenvolvimento
integrado (IDE). Além disso, existem muitos links para obter ajuda
detalhada sobre classes .NET Framework, desenvolvimento da Web do
ASP.NET, depuração, programação de banco de dados SQL e muito
mais.
Introdução à linguagem C# e ao .NET Framework C# é uma linguagem
elegante orientada a objetos e fortemente tipada que permite aos
desenvolvedores criar uma ampla variedade de aplicativos seguros e
eficientes que são executados sob o .NET Framework. Você pode usar
C# para criar aplicativos clientes tradicionais do Windows , XML
Web services, componentes distribuídos, aplicativos
cliente-servidor, aplicativos de banco de dados, e muito, muito
mais. Microsoft Visual C# 2005 fornece um editor de código
avançado, designers de interface de usuário convenientes, depurador
integrado, e muitas outras ferramentas para facilitar o rápido
desenvolvimento de aplicativos com base na versão 2.0 da linguagem
C# e do .NET Framework.
Observação
A documentação Visual C# presume que você tenha uma
compreensão dos conceitos básicos existentes de programação. Se
você for um completo principiante, convém explorar Visual C#
Express Edition, que está disponível na Web. Você também pode
aproveitar qualquer um dos diversos livros excelentes e recursos da
Web em C# para aprender técnicas de prática de programação.
Linguagem C#
Visual C# Consolidado 19
Como uma linguagem orientada a objetos, C# suporta os conceitos de
encapsulamento, herança e polimorfismo. Todas as variáveis e
métodos, incluindo o método Main, ponto de entrada do aplicativo,
são encapsulados em definições da classe. Uma classe pode herdar
diretamente de uma classe pai, mas ela pode implementar qualquer
número de interfaces. Métodos que substituem métodos virtuais em
uma classe pai exigem a palavra-chave override como uma forma para
evitar redefinição acidental. No C#, uma estrutura é como uma
classe simplificada; ele é um tipo alocado na pilha que pode
implementar interfaces mas não tem suporte a herança.
Além desses princípios orientados a objetos, C# facilita o
desenvolvimento de componentes de software através de vários
construtores inovadores da linguagem, incluindo:
• Assinaturas de métodos encapsulados chamadas
delegações, que permitem notificações de eventos fortemente
tipados.
• Propriedades, que servem como accessadores de variáveis
membros privadas.
• Atributos, que fornecem metadados declarativos sobre
tipos no tempo de execução.
• Comentários internos da documentação XML.
Se você precisar interagir com outro software Windows como objetos
COM ou DLLs nativas Win32, você pode fazer isso em C# através de um
processo denominado "Interoperabilidade". Interoperabilidade
permite que programas C# façam praticamente tudo que um aplicativo
C++ nativo pode fazer. C# também suporta ponteiros e o conceito de
código "inseguro" para os casos no qual o acesso direto a memória é
absolutamente essencial.
O processo de compilação C# é simples comparado ao C e C++ e mais
flexível do que em Java. Não há nenhum arquivo cabeçalho separado,
e nenhum requisito de que métodos e tipos sejam declarados em uma
ordem específica. Um arquivo fonte C# pode definir qualquer número
de classes, estruturas, interfaces, e eventos.
Arquitetura da plataforma .NET Framework
Programas C# são executados no .NET Framework, um componente
integrante do Windows que inclui um sistema de execução virtual
chamado de Common Language Runtime (CLR) e um conjunto unificado de
bibliotecas de classe. O CLR é implementação comercial da Microsoft
do Common Language Infrastructure (CLI), um padrão internacional
que é a base para criar ambientes de execução e
desenvolvimento nos quais linguagens e bibliotecas trabalham
perfeitamente juntas.
Código fonte escrito em C# é compilado em uma linguagem
intermediária (IL) que está em conformidade com a especificação
CLI. O código IL, juntamente com recursos como bitmaps e seqüências
de caracteres, é armazenado em disco em um arquivo executável
chamado de assembly, normalmente com uma extensão .exe ou .dll. Um
assembly contém um manifesto que fornece informações sobre tipos do
assembly, versão, cultura, e requisitos de segurança.
A interoperabilidade da linguagem é um recurso chave do .NET
Framework. Por estar em conformidade com o Common Type
Specification (CTS), o código IL produzido pelo compilador C# pode
interagir com código que foi gerado a partir das versões .NET do
Visual Basic, Visual C++, Visual J#, ou qualquer uma das outras
mais de 20 linguagens CTS-Compliant. Um conjunto único pode conter
vários módulos escritos em linguagens .NET diferentes, e os tipos
podem se referenciar como se eles fossem escritos na mesma
linguagem.
Além dos serviços de tempo de execução, o .NET Framework
também inclui uma biblioteca abrangente com mais de 4000 classes
organizadas em namespaces que fornecem uma variedade de
funcionalidades úteis para tudo desde entrada e saída de arquivo
até manipulação de seqüência para análise XML e controles de
Windows Forms. Uma aplicação C# típica usa amplamente a biblioteca
de classe do .NET Framework para manipular tarefas comuns de
"conexões internas".
O que há de novo no Visual C# 2005 O Microsoft Visual C# 2005
inclui novos recursos nas áreas a seguir:
• Linguagem e Compilador
• Editor de códigos
• Ambiente de desenvolvimento
• Depuração
Linguagem e Compilador
Editor de códigos
O Editor de códigos contém os seguintes recursos novos para Visual
C# 2005.
Trechos de código
Visual C# Consolidado 21
Trechos de códigos aumentam a velocidade de entrada de códigos de
construção comuns fornecendo um modelo que pode ser preenchido.
Trechos são armazenados como arquivos XML que podem ser facilmente
editados e personalizados.
• Trechos de códigos (C#)
Refatoração
Ferramentas de refactoração podem automaticamente reestruturar seu
código fonte, por exemplo, promovendo as variáveis locais para
parâmetros ou convertendo um bloco de código em um método.
• COMO: Promover variável local para parâmetro
• Extrair o método
• Encapsular o campo
• Extrair a interface
Ambiente de Desenvolvimento
O ambiente de desenvolvimento inclui os seguintes aperfeiçoamentos
para Visual C# 2005.
O IntelliSense
O IntelliSense foi aprimorado com os novos recursos a seguir:
• A lista de conclusão de List Members aparece
automaticamente quando você volta com o cursor para um operador de
escopo que precede um objeto, ou quando você desfaz a ação de
conclusão.
• Quando você escreve código de tratamento de erros, o
Membros lista o ajuda a descobrir qual exceção atrair
filtrando membros irrelevantes da lista de conclusão em uma
cláusula catch.
• Quando você precisa inserir código padronizado, o Automatic
Code Generation agora permite que você determine que o IntelliSense
insira o código para você.
• IntelliSense está disponível ao criar aplicativos da
Web.
Class Designer
O Class Designer é um novo editor que exibe graficamente classes e
tipos e permite que os métodos sejam adicionados ou modificados.
Também é possível usar ferramentas de refatoração a partir da
janela Class Designer.
• Consulte Projetando e exibindo classes e tipos.
Banco de Testes de Objeto
O banco de testes de objeto é projetado para teste simples a nível
de objeto. Permite criar uma instância de um objeto e chamar seus
métodos.
• Consulte Banco de Testes de Objeto.
Implantação ClickOnce
Suporte a Ferramentas para Assemblies Fortemente Nomeados
A caixa de diálogo Project Properties foi reprojetada, e
agora inclui suporte para assinatura a assemblies.
• Consulte Propriedades do Projeto.
• Assistente para o método C#
• Assistente para a propriedade C#
• Assistente para o campo C#
• Assistente para o indexador C#
Documentação e Especificação de Linguagem
Amplamente a documentação de referência do C# tem sido
regravada para fornecer informações mais completas para perguntas
comuns assim como avançadas de uso que os desenvolvedores podem
encontrar ao criar aplicativos em C#.
O especificador de linguagem do C# está mais integrado para o
ambiente de Ajuda, mas é fornecido em dois arquivos .doc. Esses
arquivos são instalados por padrão em \\Microsoft Visual Studio
8\vcsharp\specifications\1033\. As versões mais atualizadas podem
ser baixadas na Central de Desenvolvimento do C# no MSDN. Para mais
informações, consulte Especificação de Linguagem do C#.
Melhorias na Depuração Específica do C#
Novos recursos, incluindo Edit e Continue, foram adicionados para
auxiliar o desenvolvedor C#.
O que há de novo na C# 2.0 idioma e Compiler Com o lançamento
do Visual Studio 2005, a linguagem C# foi atualizada para versão
2.0, que oferece suporte os seguintes recursos novos:
Tipos genéricos
Tipos genéricos são adicionados ao idioma para ativar os
programadores para atingir um nível alto de reutilização e
desempenho avançado para classes coleção. Tipos genéricos podem
diferir somente por aridade. Parâmetros também podem ser forçados a
ser tipos específicos. Para obter mais informações, consulte
Parâmetros genéricos tipo.
Iteradores
Iterators facilitam para ditar um foreach loop como será iterar
sobre uma coleção o conteúdo.
Classes parciais
Definições de tipo parcial permitem que um tipo simples, a ser
dividida em vários arquivos, como uma classe,. O designer visual
studio utiliza esse recurso para separar seu código gerado do
código do usuário.
Tipos anulável
Tipos anuláveis permitem que uma variável para conter um valor que
é indefinido. Tipos anuláveis são úteis quando trabalhar com bancos
de dados e outras estruturas de dados que podem conter elementos
que contêm sem valores específicos.
Métodos anônimo
Visual C# Consolidado 23
Agora é possível para passar um bloco de código como um
parâmetro. Qualquer Lugar um representante é esperado, um bloco de
código poderá ser usado: não é necessário para definir um novo
método.
Qualificador alias Namespace
O qualificador alias espaço para nome. proporciona mais controle
sobre acessar membros espaço para nome (::) O global:: alias
permite acesso a raiz que pode estar ocultas por uma entidade
em seu código.
Classes estáticas
Classes estáticas são uma maneira segura e conveniente de declarar
uma classe que contém métodos estáticos que não podem ser
instanciados. Em C# versão 1.2 você seria tenha definido o
construtor de classe como particular para impedir que a classe
sendo instanciado.
Alias assembly externo
Referência versões diferentes do mesmo componente contidos no mesmo
conjunto com esse uso expandido de palavra-chave extern.
Propriedade acessibilidade Accessor
Do get agora é possível para definir diferentes níveis de
acessibilidade para e set assessores em Propriedades.
Covariância e Contravariance em representantes
O método passado para um representante agora podem ter maior
flexibilidade no seu tipo de retorno e parâmetros.
HOW TO: Declare, Instantiate, e usar um representante
Método conversão de grupo fornece uma sintaxe simplificada para
declarar representantes.
Buffers tamanho fixo
Em um bloco código desprotegido, agora é possível para declarar
estruturas de tamanho fixo com matrizes incorporados.
Conjuntos de amigo
Conjuntos podem fornecer acesso a tipos não-públicos para outros
conjuntos.
Controle de aviso embutido
A #pragma diretiva de aviso pode ser usada para desativar e
ativar determinados avisos do compilador.
volátil
Agora pode ser aplicada a IntPtr palavra-chave volatile e
UIntPtr.
O compilador C# apresenta os seguintes adições e alterações para
esta versão:
Opção /errorreport
Pode ser usado para relatar erros de compilador interno à Microsoft
através da Internet.
Opção /incremental
Foi removido.
Opção /langversion
Opção /moduleassemblyname
Permite que você se criar um.netmodule tipos de arquivo e acesso
não-públicos em um conjunto existente.
Opção /PDB
Opção /Platform
Permite que você para arquiteturas Family (IPF) Itanium e x 64 de
destino.
Aviso # pragma
Usado para desativar e ativar individuais avisos no código.
Atualizando Aplicativos Visual C# para Visual Studio 2005
Quando você abre um arquivo de projeto ou de solução criado por uma
versão anterior do Visual Studio, o Assistente para Atualização
guia você através do processo de converter seu projeto para Visual
Studio 2005. O Assistente para Atualização executa várias tarefas,
entre elas: cria novas propriedades e atributos e exclui os
obsoletos, mas como a verificação de erros tornou-se mais rígida,
você pode encontrar novos erros ou mensagens de aviso que não foram
produzidos pela versão anterior do compilador. Assim, a etapa final
na atualização de um aplicativo existente é fazer as alterações de
código necessárias para resolver quaisquer novos erros.
Freqüentemente, um código que produzia uma certa mensagem nas
versões anteriores do compilador de C# produz uma mensagem
diferente na versão atual. Normalmente, isso se deve ao fato de que
uma mensagem geral foi substituída por uma mais específica. Como
nenhuma alteração no código é necessária, essas diferenças não
foram documentadas.
A seguir, estão as novas mensagens que o 'Assistente para
Atualização' gera devido à verificação de erros mais
rigorosa.
Novas Mensagem de Erro e de Aviso
CS0121: Ambiguous call (Chamada ambígua)
Devido a uma conversão implícita, o compilador não foi capaz de
chamar uma implementação específica de um método sobrecarregado.
Você pode resolver este erro das seguintes formas:
• Especificar os parâmetros do método de tal forma que a
conversão implícita não exista.
• Remover todos as outras implementações do método.
• Converter para um tipo apropriado antes de chamar o
método.
CS0122: Method inaccessible due to its protection level (Método
inacessível devido ao seu nível de proteção)
Você poderá receber este erro ao fazer referência um tipo em um
assembly compilado pelo C++ que foi compilado com a opção de
compilador /d1PrivateNativeTypes.
Este erro ocorre porque, na versão atual, um assembly C++ produz
uma assinatura que usa um tipo que não está marcado como
público.
Você pode contornar esse problema usando a opção
/test:AllowBadRetTypeAccess do compilador. Esta opção será
removida quando este recurso foi corrigido.
CS0429: Unreachable expression code detected (Expressão de código
inatingível detectada)
Visual C# Consolidado 25
Este erro ocorre sempre que parte de uma expressão em seu código é
inatingível. Por exemplo, a condição false && myTest() casa
com esse critério, pois o método myTest() nunca será executado já
que o lado esquerdo da operação && é sempre falso. Para
corrigir isso, refaça o teste lógico para eliminar o código
inacessível.
CS0441: A class cannot be both static and sealed (Uma classe não
pode ser ao mesmo tempo estática e lacrada)
Todas as classes estáticas são também classes lacradas. A
especificação de linguagem C# proíbe a especificação de ambos os
modificadores em uma classe e o compilador agora relata isso como
um erro.
Para corrigir esse erro, remova sealed da classe.
CS1699: Warning on use of assembly signing attributes (Alerta no
uso de atributos de assinatura de assembly)
Os atributos de assembly que especificam assinatura foram movidos
do código para opções do compilador. Usar os
atributos AssemblyKeyFile ou AssemblyKeyName no código
produz este aviso.
Em vez desses atributos, você deve usar as opções de compilador a
seguir:
• Use a opção de compilador /keyfile (Especifica um Arquivo
Chave de Nome Forte) (Opções do Compilador de C#) ao invés do
atributo AssemblyKeyFile, e use /keycontainer
(Especifica um Contêiner de Chave de Nome Forte) (Opções do
Compilador de C#) ao invés de AssemblyKeyName.
Não mudar para as opções de linha de comando não pode dificultar os
diagnósticos do compilador quando friend assemblies estiverem sendo
usados.
Se você estiver usando /warnaserror (Trata Aviso como Erros) (Opção
do Compilador de C#), você pode converter de volta para um aviso
adicionando /warnaserror-:1699 a linha de comando do seu
compilador. Se necessário, você pode desativar o aviso usando
/nowarn:1699.
Incremental compilation removed (Compilação incremental
removida)
A opção /incremental do compilador foi removida. O recurso de
Edição e Continuação substitui essa funcionalidade.
Criando Seu Primeiro Aplicativo C# Somente leva um minuto para
criar um aplicativo C#. Siga estas etapas para criar um programa
que abre uma janela e reage a um pressionamento de botão.
Procedimentos
Para criar um aplicativo C#
1. No menu File, aponte para New, e em seguida, clique em
Project
2. Verifique se o modelo Windows Application está selecionado, no
campo Name, digite MyProject , e clique em OK.
Você verá um Windows Form no designer de Windows Forms. Essa é a
interface de usuário para seu aplicativo.
3. No menu View, clique em Toolbox para tornar a lista de controles
visível.
Visual C# Consolidado 26
6. Clique duas vezes no novo botão para abrir o Editor de Código.
Visual C# inseriu um método chamado button1_Click que é
executado quando o botão for clicado.
7. Altere o método para ter esta aparência:
private void button1_Click(object sender, EventArgs e) {label1.Text
= "Hello, World!";}
8. Pressione F5 para compilar e executar o aplicativo.
Quando você clicar no botão, é exibida uma mensagem de texto.
Parabéns! Você acabou de escrever seu primeiro aplicativo C#.
Usando Starter Kits C# Um Starter Kit é um aplicativo completo e
independente pronto para você carregar e compilar. Um Starter Kit
vem com sua própria documentação, incluindo descrições de técnicas
de programação, e sugestões para como ele pode ser personalizado.
Starter Kit é uma maneira excelente de ver um aplicativo C#
que funciona em ação.
Para carregar e compilar um Starter Kit Visual C#
1. No menu File, clique em New Project.
A caixa de diálogo New Project será exibida. Esta caixa de
diálogo lista os diferentes tipos de aplicativos padrão que Visual
C# pode criar.
2. Selecione um tipo de aplicativo Starter Kit, e clique em
OK.
O Starter Kit é carregado no Visual C#.
3. Para compilar e iniciar o projeto Starter Kit, pressione
F5.
Recursos de Ajuda Adicionais (Visual C#) Os sites e grupos de
notícias a seguir lhe ajudarão a encontrar respostas para problemas
comuns e não tão comuns.
Recursos Microsoft
Os sites a seguir são mantidos pela Microsoft e hospedam artigos e
grupos de discussão sobre tópicos de interesse para os
desenvolvedores C#.
Na Web
A Ajuda do Microsoft e Suporte
Fornece acesso a artigos da KB, downloads e atualizações, WebCasts
de suporte e outros serviços.
O Microsoft Visual C# Developer Center
Fornece exemplos de código, informações sobre atualização, e
conteúdo técnico.
Grupos de discussão MSDN
Fornece uma maneira para conectar-se a uma comunidade de
especialistas de todo o mundo.
Fóruns
Forums técnico da Microsoft
Fóruns discussão baseados na Web para muitas tecnologias Microsoft
incluindo C# e o Framework .NET.
Grupos de notícias
microsoft.public.dotnet.languages.csharp
Fornece um fórum para perguntas e problemas no Visual Studio.
microsoft.public.vsnet.IDE
Fornece um fórum para perguntas sobre como trabalhar no ambiente
Visual Studio.
microsoft.public.vsnet.documentation
Fornece um fórum para perguntas e problemas na documentação Visual
C#.
Recursos de terceiros
O site do MSDN fornece informações sobre sites de terceiros e
grupos de notícias de atual interesse. Para a lista mais atual dos
recursos disponíveis, consulte o Site MSDN Community.
Como Fazer em C# Como Fazer é sua porta de entrada para
tópicos-chave baseados em tarefas sobre programação e
desenvolvimento de aplicativos em C#. As categorias essenciais
sobre o que você pode fazer com C# estão listadas neste
tópico. Os links fornecem referências para páginas de ajuda
importantes baseadas em procedimento.
A Linguagem C#
Especificação da Linguagem C# ... Threading… Genéricos... Trechos
de Código… Exemplos… mais
O Framework .NET
Entrada e Saída em Arquivos… Strings… Coleções… Serialização…
Componentes… Módulos (assemblies) e Domínios de Aplicativo…
mais
Aplicativos do Windows
Páginas Web e Web Services
Pages Web do ASP.NET… XML Web Services… mais
Depuração
Usando o Depurador VS… Classe Trace .Framework NET… Depuração de
Transações SQL… mais
Accesso a Dados
Conectando a Fontes de Dados… O SQL Server... Vinculação de Dados…
mais
Criando Classes
Class Designer... Trabalhando com Classes e Outros Tipos... Criando
e Modificando Membros-tipo... Linhas-mestras para a Criação de
Bibliotecas de Classes… mais
Segurança
Segurança no Acesso ao Código… Práticas Recomendadas de Política de
Segurança… Conjuntos de Permissões… mais
Programação do Office
Dispositivos Inteligentes
O que há de novo em Projetos para Dispositivos Inteligentes...
Programação para Dispositivos Inteligentes... Depuração em
Dispositivos Inteligentes... mais
Implantação
Visual Studio 2005 Developer Center
Contém vários artigos e recursos sobre o desenvolvimento de
aplicativos usando o Visual Studio 2005. Este site é atualizado
regularmente com novo conteúdo.
Visual C# Developer Center
Contém vários artigos e recursos sobre desenvolvimento de
aplicativos C#. Este site é atualizado regularmente com novo
conteúdo.
Microsoft .NET Framework Developer Center
Visual C# Consolidado 29
USANDO O IDE DO VISUAL C# Esta seção lhe apresenta ao
ambiente de desenvolvimento integrado (IDE) do Visual C# e descreve
como ele é usado em todas as fases do ciclo de desenvolvimento,
indo desde como configurar um projeto até distribuir o aplicativo
concluído para usuários finais.
Introdução à IDE (Visual C#) O ambiente de desenvolvimento
integrado (IDE) do Visual C# é uma coleção de ferramentas de
desenvolvimento expostas por meio de uma interface de usuário
comum. Algumas das ferramentas são compartilhados com outras
linguagens do Visual Studio, e algumas, como o compilador C#, são
exclusivas para Visual C#. A documentação nesta seção fornece uma
visão geral de como usar as ferramentas mais importantes do Visual
C# enquanto você trabalha na IDE em várias fases do processo de
desenvolvimento.
Observação
Se você estiver desenvolvendo um aplicativo ASP.NET 2.0, você irá
usar a IDE Visual Web Developer, que é uma parte totalmente
integrada do Visual Studio 2005. Entretanto, se suas páginas
code-behind estiverem em Visual C#, você estará utilizando o Editor
de Códigos do Visual C# dentro do Visual Web Developer. Portanto,
alguns tópicos nesta seção, como Projetando uma interface de
usuário (Visual C#), talvez não sejam completamente aplicáveis a
aplicativos da Web.
Ferramentas Visual C#
A seguir estão as mais importantes ferramentas e janelas no
Visual C#. As janelas para a maioria dessas ferramentas podem ser
abertas a partir do menu View.
• O Editor de Códigos, para escrever código fonte.
• O compilador C#, para converter código fonte C# em um
programa executável.
• O depurador do Visual Studio, para testar seu
programa.
• O Toolbox (Caixa de Ferramentas) e o Designer, para o
desenvolvimento rápido de interfaces de usuário usando o
mouse.
• Solution Explorer (Gerenciador de Soluções) para exibir e
gerenciar arquivos de projeto e configurações.
• Designer de Projeto, para configurar opções do compilador,
caminhos de implantação, recursos, e mais.
• Modo de Exibição de Classe, para navegar através de código
fonte de acordo com tipos, não arquivos.
• Janela Properties (Janela de Propriedades), para configurar
propriedades e eventos nos controles na sua interface de
usuário.
• Pesquisador de objetos para exibir os métodos e as classes
disponíveis em bibliotecas de vínculo dinâmico incluindo assemblies
do .NET Framework e objetos COM.
• Gerenciador de Documento, para navegação e pesquisa de
documentação do produto em sua máquina local e na Internet.
Como a IDE expõe as ferramentas
Rapidamente você pode acessar qualquer janela de ferramenta aberta
ou arquivos, pressionando CTRL + TAB. Para mais informações,
consulte Navegando e procurando (Visual C#).
Janelas do Editor e do Windows Form Designer
A janela principal é usada pelo Editor de Códigos e pelo
Windows Forms Designer. Você pode alternar entre o modo Código e o
modo Design pelo pressionamento da tecla F7, ou clicando em Code ou
Designer no menu View. Enquanto estiver no modo Design, você pode
arrastar controles da Caixa de Ferramentas para a janela ,
que você poderá tornar visível clicando na guia Toolbox na margem
esquerda. Para obter mais informações sobre o Editor de Códigos,
consulte Editando Código (Visual C#). Para obter mais informações
sobre o Windows Forms Designer, consulte O Windows Forms
Designer.
A janela Properties no canto inferior direito é povoada
somente no modo Design. Ela permite a você definir propriedades e
ligar eventos a controles de interface de usuário como botões,
caixas de texto, e assim por diante. Quando você define esta janela
como Ocultar Automaticamente, ela será colapsada na margem direita
sempre que você alternar para o Modo Código. Para obter mais
informações sobre a janela Properties e o Designer, consulte
Projetando uma interface de usuário (Visual C#).
Gerenciador de Soluções e Designer de Projeto
A janela na parte superior direita é a do Gerenciador de
Soluções, que mostra todos os arquivos em seu projeto em um modo de
exibição de árvore hierárquica. Quando você usa o menu Project para
adicionar novos arquivos ao seu projeto, você os verá refletidos no
Gerenciador de Soluções. Além dos arquivos, o Gerenciador de
Soluções também exibe as configurações do projeto, e referências a
bibliotecas externas exigidas pelo seu aplicativo.
As páginas de propriedades do Designer de Projeto são
acessadas com o botão direito do mouse no nó Properties no
Gerenciador de Soluções, e clicando Open. Use essas páginas para
modificar opções de compilação, requisitos de segurança, detalhes
de implantação, e muitas outras propriedades do projeto. Para obter
mais informações sobre o Gerenciador de Soluções e o Designer de
Projeto, consulte Criando um Projeto (Visual C#).
Janela do Compilador, do Depurador, e de Lista de Erros
O compilador C# não tem nenhuma janela porque ele é não uma
ferramenta interativa, mas você pode definir opções do compilador
no Designer de Projeto. Quando você clica em Build no menu Build ,
o compilador C# é chamado pela IDE. Se a compilação for bem
sucedida, o painel de status exibe uma mensagem compilação bem
sucedida. Se houver erros de compilação, a janela Error List
aparece abaixo da janela Editor/Designer com uma lista de erros. Dê
um duplo clique em um erro para ir para a linha com problema no seu
código fonte. Pressione F1 para consultar a documentação de Ajuda
para o erro realçado.
Personalizando a IDE
Toda janela no Visual C# pode ser feita ancorável ou flutuante,
oculta ou visível, ou pode ser movida para novos locais. Para
alterar o comportamento de uma janela, clique nos ícones da seta
para baixo ou push-pin na barra de título e selecione dentre as
opções disponíveis. Para mover uma janela ancorada para um
novo local ancorado, arraste a barra de título até que os ícones de
conta-gotas da janela apareçam. Mantendo pressionado o botão
esquerdo do mouse, mova o ponteiro do mouse sobre o ícone no novo
local. Posicione o ponteiro sobre os ícones esquerda, direita,
superior ou inferior para encaixar a janela no lado especificado.
Posicione o ponteiro sobre o ícone meio para tornar a janela uma
janela com guias. Como você posiciona o ponteiro, um retângulo azul
semi-transparente aparece, o qual indica onde a janela será
ancorada no novo local.
Você pode personalizar muitos outros aspectos da IDE clicando em
Options no menu Tools. Para mais informações, consulte Opções de
Caixa de Diálogo do Visual Studio.
Criando um Projeto (Visual C#) Quando você estiver pronto para
iniciar a codificação, a primeira etapa é configurar um projeto. O
projeto contém todos os materiais processados para seu aplicativo,
incluindo não apenas arquivos de código fonte, mas também arquivos
de recursos como ícones, referências a arquivos externos que seu
programa depende, e dados de configuração como configurações do
compilador. Quando você cria um projeto, Visual C# chama o
compilador C# e outras ferramentas internas para criar um
conjunto executável usando os arquivos em seu projeto.
Criando um novo projeto
Você cria um novo projeto, clicando no menu File, apontando para
New, e clicando em Project.
Observação
Se você selecionar Web Site em vez de Project, a IDE (ambiente
de desenvolvimento integrado) Visual Web Developer abre. Este é um
ambiente separado e distinto dentro do Visual Studio para criar
aplicativos ASP.NET. A IDE Visual Web Developer usa o editor de
código do Visual C# para edição de arquivos code-behind no C#. Se
você estiver criando aplicativos da Web, você deve usar a
documentação do Visual Web Developer principalmente, mas consulte
Editando código (Visual C#) para obter informações sobre o editor
C#.
Starter Kits são outros tipos de modelo de projeto. Se você
instalar um Starter Kit, você o verá listado na caixa de diálogo
New Project. Para mais informações, consulte Starter Kits.
Propriedades
O nó Properties representa definições de configuração que se
aplicam a seu projeto inteiro e são armazenados no arquivo .csproj
na sua pasta solução. Essas configurações incluem opções de
compilação, segurança, configurações de implantação e muito mais.
Você faz modificações em seu projeto usando o Designer de Projeto,
que é um conjunto de Páginas de Propriedades que você acessa
clicando com o botão direito do mouse em Properties, e selecionando
Open. Para mais informações, consulte Modificando propriedades de
projeto (Visual C#).
Referências
No contexto de um projeto, uma referência simplesmente identifica
um arquivo binário que seu aplicativo requer para executar.
Normalmente, uma referência identifica um arquivo DLL como um dos
arquivos de biblioteca de classe do .NET Framework. Ele também pode
fazer referência um assembly .NET (chamado de um shim) que permite
seu aplicativo chamar métodos em um objeto COM ou DLL Win32 nativa.
Se seu programa cria uma instância de uma classe que está definida
em algum outro assembly, você deve adicionar uma referência a esse
arquivo em seu projeto antes de você compilar o projeto. Para
adicionar uma referência, clique em Add Reference no menu Project.
Todos os projetos C# por padrão incluem uma referência à
mscorlib.dll, que contém as classes principais do .NET Framework.
Você pode adicionar referências a DLLs adicionais do .NET Framework
e outros arquivos, clicando no menu Project, e selecionando Add
Reference.
Observação
Não confunda o conceito de uma referência de projeto com o conceito
de tipos referência em C# ou outras linguagens de programação. O
primeiro refere-se a um arquivo e seu local esperado no disco. O
último refere-se a tipos C#, que são declarados usando a
palavra-chave class.
Recursos
Um recurso é um dado que está incluído no seu aplicativo mas pode
ser armazenado de tal forma que pode ser modificado
independentemente de outro código fonte. Por exemplo, você pode
armazenar todas as suas seqüências como recursos em vez de
embutí-las no código fonte. Você pode converter as seqüências em
diferentes idiomas mais adiante, e adicioná-las à pasta do
aplicativo que você entrega a clientes sem precisar recompilar seu
assembly. Os cinco tipos de recursos definidos pelo Visual C# são:
seqüências, imagens, ícones, áudio, e arquivos. Você adiciona,
remove ou edita recursos usando o Designer de Recursos, que é
acessado na guia Resources no Designer de Projeto.
Formulários
Quando você cria um projeto Windows Forms, o Visual C# adiciona um
formulário no projeto por padrão e chama-o Form1. Os dois
arquivos que representam o formulário são chamados Form1.cs e
Form1.designer.cs. Você escreve seu código no Form1.cs; o arquivo
designer.cs é onde o Windows Forms Designer escreve o código que
implementa todas as ações que você realizou arrastando e soltando
controles da Caixa de Ferramentas.
Você pode adicionar um novo formulário, clicando no item de menu
Project, e selecionando Add Windows Form. Cada formulário tem dois
arquivos associados a ele. Form1.cs, ou qualquer outro nome que
você dê, contém o código fonte que você escreveu para configurar o
formulário e seus controles, como caixas de listagem e caixas de
texto, e responde a eventos como clique de botão e pressionamento
de tecla. Em projetos simples do Windows Forms, você faz a maioria
ou toda a sua codificação nesse arquivo.
Observação
Obviamente, se você criar um projeto de aplicativos de console, ele
não conterá arquivos código fonte para Windows Forms.
Outros arquivos de código fonte
Um projeto pode incluir qualquer número de arquivos .cs adicionais
que pode ou não estar associado a um Windows Form específico.
Na ilustração anterior do Gerenciador de Soluções, program.cs
contém o ponto de entrada para o aplicativo. Um único arquivo .cs
pode conter qualquer número de definições de classe e estrutura.
Você pode adicionar arquivos novos ou existentes ou classes no seu
projeto, clicando em Add New Item ou Add Existing Item no
menu Project.
Projetando uma interface de usuário (Visual C#) No Visual C#, a
maneira mais rápida e conveniente de criar sua interface de usuário
(UI) é fazê-la visualmente, usando o Windows Forms Designer e o
Toolbox. Há três etapas básicas para criar todas as interfaces de
usuário:
• Adicionar controles a superfície de criação.
• Definir propriedades iniciais para os controles.
• Escrever manipuladores para eventos especificos.
Embora você também possa criar sua UI escrevendo seu próprio
código, designers permitem que você realize este trabalho muito
mais rapidamente que na codificação manual.
Observação
Você pode usar Visual C# para criar aplicativos de console que
possuem uma interface simplesmente baseada em texto. Para mais
informações, consulte Criando aplicativos de console (Visual
C#).
Adicionando controles
Enquanto você trabalha visualmente, o designer converte suas ações
em código fonte C# e os grava em um arquivo de projeto chamado
<nome>designer.cs onde <nome> é o nome que você deu
para o formulário. Quando seu aplicativo é executado, esse código
fonte irá posicionar e dimensionar os elementos de UI para que elas
apareçam da mesma maneira que na superfície de projeto. Para mais
informações, consulte O Windows Forms Designer.
Definindo propriedades
Após você adicionar um controle ao seu formulário, você pode
usar a janela Properties para definir suas propriedades, como cor
do plano de fundo e texto padrão. Os valores que você especificar
na janela Properties são simplesmente os valores iniciais que serão
atribuídos a essa propriedade quando o controle é criado em tempo
de execução. Em muitos casos, esses valores podem ser acessados ou
alterados programaticamente em tempo de execução simplesmente
obtendo ou definindo a propriedade na instância da classe de
controle em seu aplicativo. A janela Properties é útil em tempo de
criação porque ela permite que você procure por todas as
propriedades, eventos e métodos suportados por um controle. Para
mais informações, consulte Janela Properties.
Tratamento de eventos
Programas com interfaces de usuário gráficas são principalmente
direcionadas a eventos. Elas aguardam até que um usuário faça algo
como inserir texto em uma caixa de texto, clicar em um botão, ou
alterar uma seleção em uma caixa de listagem. Quando isso acontece,
o controle, que é apenas uma instância de uma classe do .NET
Framework, envia um evento para seu aplicativo. Você pode optar por
manipular um evento escrevendo um método especial em seu aplicativo
que será chamado quando o evento é recebido.
Você pode usar a janela Properties para especificar que eventos
deseja tratar em seu código; selecione um controle no designer e
clique no botão Events, com o ícone de um raio, na barra de
ferramentas da janela Properties para ver os seus eventos. O
diagrama a seguir mostra o botão de eventos.
Visual C# Consolidado 36
escrever o código para que o método faça algo útil. A maioria dos
controles geram um número grande de eventos, mas na maioria dos
casos, um aplicativo somente precisará manipular alguns deles, ou
mesmo somente um. Por exemplo, você provavelmente precisa manipular
um evento de Click de botão, mas não é necessário manipular seu
evento Paint a menos que você deseje personalizar a aparência de
alguma maneira avançada.
Próximas Etapas
Para obter mais informações sobre interfaces de usuário do Windows
Forms, consulte os seguintes tópicos:
• Criando aplicativos baseados no Windows
• Passo a passo: Criando um formulário do Windows
simples
• Elementos de interface de usuário do Windows Forms
Designer
Na biblioteca de classe do. NET Framework, System.Windows.Forms e
namespaces relacionados contém as classes usadas no desenvolvimento
do Windows Forms.
Editando Código Este é um conteúdo traduzido automaticamente
que os membros da comunidade podem editar. Como tal, a Microsoft
não pode garantir a exatidão ou fidelidade em relaçao ao conteúdo
original. Você pode melhorá-lo usando os controles à direita.
guest : fazer logon
Editando código (Visual C#)
O Editor de códigos do Visual C# é um processador de texto para
escrever código fonte. Assim como o Microsoft Word fornece
suporte abrangente para frases, parágrafos, e gramática, o editor
de códigos C# faz o mesmo para sintaxe C# e para o .NET Framework.
Este suporte pode ser agrupado em cinco categorias
principais:
• O IntelliSense: Documentação continuamente atualizada sobre
as classes .NET Framework e os métodos básicos à medida que você
digita no editor, e a geração de código automática.
• Refactoring: reestruturação inteligente de sua base de
código à medida que ela evolui durante o período de um projeto de
desenvolvimento.
• Trechos de código: Você pode procurar uma biblioteca que
contém padrões de código repetidos freqüentemente.
• Sublinhado ondulado: Notificações visuais de palavras
incorretas, erro de sintaxe e situações de aviso conforme você
digita.
• Auxílios de legibilidade: Estrutura de tópicos e
colorização.
O IntelliSense
Visual C# Consolidado 37
Observação Muitos dos recursos do IntelliSense são
compartilhados com outras linguagens do Visual Studio e estão
documentadas com ilustrações no nó Ajuda de Codificação da
biblioteca do MSDN. As seções a seguir fornecem uma visão geral
sobre o IntelliSense, com links para a documentação mais
completa.
Listas de conclusão
Quando você insere código-fonte no editor, o IntelliSense exibe uma
caixa de listagem que contém todas as palavras-chave C# e classes
.NET Framework. Se ele encontrar uma correspondência na caixa
de listagem para o nome que você está digitando, ele seleciona o
item. Se o item selecionado for o que você deseja, simplesmente
você pode teclar TAB e o IntelliSense terminará a digitação do nome
ou palavra-chave para você. Para mais informações, consulte Listas
de conclusão no C#.
Informações rápidas
Quando você passa o cursor sobre um tipo .NET Framework, o
IntelliSense exibirá um Quick Info ToolTip que contém a
documentação sobre esse tipo básico. Para mais informações,
consulte Informações rápidas.
Membros da lista
Quando você inserir um tipo .NET Framework no Editor de Có