54518448-Apostila-Visual-C-Consolidada-pt-Br.pdf

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#

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
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
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)

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.

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

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.

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

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ó

Documents

54518448-Apostila-Visual-C-Consolidada-pt-Br.pdf