Andreas M. Antonopoulos é um grego especialista em segurança da informação atualmente reside na califórnia, empresário e autor de um podcast sobre tecnologia e Bitcoin. Atua no ensino sob…Descrição completa
manual paciente
Descrição completa
Descrição completa
manual paciente
Uma jornada além das fronteiras da consciência.Full description
Descrição completa
Uma jornada além das fronteiras da consciência.Descrição completa
Descrição: Osciloscopo automotivo
Amp
Descrição completa
Descripción: Quais as técnicas para dominar a terapia familiar
Descrição: Armando Vilas-Boas
Full description
Descrição: Quais as técnicas para dominar a terapia familiar
Descrição: muitobomdo
Fábio Camara
Dominando o Visual Studio .NET com C# 2a Edição Atualizada e Ampliada
Visual Vis isua uall
Books
Sumário Prefácio.................................................................... XIII 1 Introdução ................................................................. 1
1.1 Quem Deve Ler este Livro? ..................................................... 1 1.2 Visão Geral do Conteúdo ........................................................ 1 1.3 Código de Exemplo ............................................................... 2 2 Começando... ............................................................3
2.1 Versões do Visual Studio .NET .................................................. 5 2.1.1 Visual Studio .NET Professional .............................................. 5 2.1.2 Visual Studio .NET Enterprise Developer ................................... 5 2.1.3 Visual Studio .NET Enterprise Architect .................................... 5 2.2 Comparação entre as Versões .................................................. 6 2.3 Visual Studio .NET – A Ferramenta IDE .......................................10 2.4 Requerimentos para a Plataforma .NET ......................................11 2.5 NET Framework - Redistribuição ..............................................11 3 Tendo a Programação como Profissão ............................. 13
3.1 Lógica de Programação .........................................................15 3.1.1 Seqüência Lógica e Instruções ..............................................15 3.1.2 Algoritmo.......................................................................16 3.2 Programação para Windows ...................................................17 3.2.1 Interface Windows............................................................18 3.3 Dica para Aprender Novas Linguagens .......................................19 4 Conhecendo o Visual Studio .NET.................................. 21
4.1 Gerenciando o Ambiente de Desenvolvimento .............................. 21 4.2 Conhecendo as Janelas do Ambiente de Desenvolvimento ................24 4.2.1 Janela Solution Explorer .....................................................24 4.2.2 Janela ToolBox.................................................................25 4.2.3 Janela Properties .............................................................26 4.2.4 Janela OutPut .................................................................27 4.2.5 Janela Object Browser .......................................................27 4.2.6 Janela Class View .............................................................28 4.2.7 Janela Web Browser ..........................................................29 4.2.8 Janela Favorites ..............................................................30 4.2.9 Janela Server Explorer .......................................................30 4.3 Macro Explorer...................................................................31 4.4 Task List ..........................................................................31 4.5 Command Window ..............................................................32 4.6 Atalhos da IDE ...................................................................32 4.6.1 Comentários ...................................................................33 4.6.2 Atalho para Tarefas ...........................................................33
4.6.3 Abrindo/Fechando Blocos de Código .......................................33 4.6.4 Linhas de Código .............................................................34 4.6.5 Encontrando o Final do Método .............................................34 4.6.6 Informações de Parâmetro .................................................. 34 4.7 Criando Aplicações Baseadas em Templates .................................35 4.8 Ocultamento do Texto ..........................................................36 4.9 IntelliSense .......................................................................37 4.10 Obtendo Ajuda .................................................................38 4.11 Personalizando o Text Editor ................................................. 39 5 Trabalhando com o Visual Studio .NET............................ 43
5.1 O Primeiro Contato .............................................................43 5.2 Declarando as Propriedades .................................................... 46 5.2.1 Identificadores ................................................................47 5.3 Conhecendo as Propriedades mais Comuns ..................................47 5.3.1 Name ...........................................................................47 5.3.2 Text .............................................................................48 5.3.3 Location “X e Y” ..............................................................48 5.3.4 Size “Height e Width” .......................................................48 5.3.5 Font .............................................................................48 5.3.6 BackColor ......................................................................49 5.3.7 TabIndex .......................................................................49 5.4 Desvendando Eventos ..........................................................49 5.4.1 Click ............................................................................50 5.4.2 KeyPress ........................................................................ 50 5.4.3 Enter ............................................................................50 5.4.4 Leave ...........................................................................51 5.4.5 Resize ..........................................................................51 5.4.6 TextChanged ................................................................... 51 5.5 Métodos Simples ................................................................51 5.5.1 Show( ) .........................................................................51 5.5.2 Close( ) ......................................................................... 51 5.5.3 Refresh( ) ......................................................................51 5.5.4 Dispose( ) ......................................................................52 5.5.5 Hide( ) ..........................................................................52 5.6 Melhorando nosso Primeiro Contato ..........................................52 5.7 Debugando uma Aplicação .....................................................53 5.8 Um Giro pelos Componentes...................................................55 6 Anatomia de Nosso Projeto C#...................................... 61
6.1 Alternativas Gratuitas ..........................................................62 6.1.1 Sharp Develop .................................................................63 6.1.2 WebMatrix .....................................................................64 6.2 Namespaces ......................................................................65 6.3 Class ..............................................................................67 6.3.1 O Assistente Add Class ....................................................... 68
6.4 Procedimentos e Funções ......................................................69 6.4.1 Métodos ........................................................................69 6.4.2 O Assistente Add Method ....................................................70 6.5 Compilando e Executando um Programa ..................................... 71 6.6 Assemblies .......................................................................72 6.6.1 Código Gerenciado ...........................................................74 6.6.2 Verificações em Tempo de Compilação .................................... 75 6.7 Opções de Compilação..........................................................75 6.8 Extensões de Arquivos no Visual Studio .NET ...............................76 6.8.1 Arquivos .SLN .................................................................76 6.8.2 Arquivos .CSPROJ .............................................................77 6.8.3 Arquivos .CSPROJ.USER .....................................................77 6.8.4 Arquivos ASPX .................................................................77 6.8.5 Arquivos ASMX.................................................................77 6.8.6 Arquivos CS ....................................................................77 6.9 Explorando o ILDASM ...........................................................78 6.10 .NET Remoting .................................................................80 6.11 Documentação de Código no .NET...........................................81 6.11.1 Documentação XML .........................................................84 6.11.2 Integração com IntelliSense. ..............................................84 7 Variáveis na Linguagem C# .......................................... 89
7.1 Tipos ..............................................................................89 7.1.1 Tudo é Objeto .................................................................90 7.2 Inteiros Assinados ...............................................................91 7.2.1 Tipo Short ......................................................................92 7.2.2 Tipo Int .........................................................................92 7.2.3 Tipo long .......................................................................92 7.3 Inteiros não Assinados ..........................................................92 7.3.1 Tipo byte .......................................................................92 7.3.2 Tipo ushort ....................................................................93 7.3.3 Tipo uint .......................................................................93 7.3.4 Tipo ulong ......................................................................93 7.4 Tipos Lógicos ....................................................................93 7.4.1 Tipo bool .......................................................................93 7.5 Tipo de Caractere ...............................................................93 7.5.1 char .............................................................................93 7.6 Ponto Flutuante .................................................................. 94 7.6.1 float ............................................................................94 7.6.2 double ..........................................................................94 7.6.3 decimal .........................................................................94 7.7 Tipos de Data e Hora ...........................................................94 7.7.1 DateTime.......................................................................95 7.7.2 Regionalizando o Formato da Data .........................................96 7.8 Tipo String (texto) ............................................................ 100 7.9 Tipos Referência versus Tipos Valor ........................................ 100
7.10 Orientações Importantes sobre Variáveis ................................ 102 7.10.1 Variáveis Automáticas .................................................... 102 7.10.2 Variáveis de Instância .................................................... 102 7.10.3 Variáveis Estáticas ........................................................ 103 8 Modificadores ........................................................ 105
8.1 Modificadores de Parâmetros................................................ 105 8.2 Modificadores para Tudo ..................................................... 106 8.2.1 Modificadores de Classe ................................................... 107 8.2.2 Modificadores de Membros ................................................ 107 8.2.3 Modificadores de Acesso ................................................... 108 9 Conscientizando C# ................................................. 109
9.1 Palavras Reservadas (Keywords) ............................................ 109 9.2 Expressões ..................................................................... 110 9.2.1 Condicionais ................................................................. 110 9.3 Loops............................................................................ 112 9.3.1 For ............................................................................ 113 9.3.2 Foreach / in ................................................................. 114 9.3.3 While ......................................................................... 115 9.3.4 Do/while ..................................................................... 115 9.4 A Infame Instrução Goto...................................................... 116 9.4.1 Uma História (muito) Breve ............................................... 116 9.4.2 Utilizando a Instrução Goto ............................................... 116 9.5 A Instrução Return ............................................................. 119 9.6 Operadores ..................................................................... 120 9.6.1 Operadores Lógicos ........................................................ 122 9.6.2 Operadores Unários ........................................................ 122 9.6.3 Operadores Binários ........................................................ 123 9.6.4 Operadores de Atribuição.................................................. 125 9.6.5 Precedência de Operadores................................................ 126 9.6.6 Uma Confusão Conhecida.................................................. 127 10 Conversão de Valores e Arrays .................................. 129
12.1 Um Exemplo MDI ............................................................. 158 12.2 O Projeto SDI ................................................................. 161 12.2.1 O Primeiro Passo: Os Forms ............................................. 161 12.2.2 Passando Valores entre os Forms........................................ 163 12.3 Propriedades de um Form .................................................. 169 12.4 Adicionando Componentes .................................................. 170 12.5 Eventos e Delegações ....................................................... 171 12.5.1 Por que Precisamos de Delegates ....................................... 177 12.6 Técnicas de Redimensionamento de Forms .............................. 178 13 Programação Orientada a Objetos (POO) .................... 185
13.1 Objetos........................................................................ 186 13.2 Construtores .................................................................. 187 13.3 Destrutores ................................................................... 187 13.4 Propriedades.................................................................. 188 13.5 Herança e Inherit Forms .................................................... 189 13.5.1 Herdando Componentes Visuais ......................................... 190 13.5.2 Sobreposição de Métodos ................................................ 191 13.5.3 Sobrecarga de Métodos ................................................... 193 13.5.4 O Projeto do Form Base .................................................. 194 13.5.5 O Form Filho ............................................................... 196 13.5.6 Códigos entre Pai e Filho ................................................. 197 13.6 Polimorfismo ................................................................. 201 13.7 Interface ...................................................................... 203 13.8 Por que é Importante Usar POO? ........................................... 203 14 Criando Componentes ............................................. 205
14.1 Meu Primeiro Componente ................................................. 205 14.2 Evoluindo o Componente ................................................... 207 14 .3 Adicionando Propriedades ao Componente .............................. 212 15 Input e Output de Arquivos ..................................... 215
16.1 Manipulando Strings ......................................................... 229 16.1.1 Imutabilidade e a Classe StringBuilder ................................. 230 16.1.2 Teste de Performance: String versus StringBuilder ................... 231 16.2 Estruturas ..................................................................... 233 16.2.1 O que Você não Pode Fazer com Struct ................................. 234 16.3 Tipos Enumerados ........................................................... 234 16.4 Aplicações Assíncronas (MSMQ)............................................ 235 16.4.1 Por que Usar o MSMQ? .................................................... 235 16.4.2 Motivos para se utilizar o MSMQ? ....................................... 236 16.4.3 Cenários Típicos para Comunicação Assíncrona ...................... 236 16.4.4 Implementando ............................................................ 237 16.4.5 Dicas sobre o MS Message Queue ....................................... 237 16.5 Encriptação e Decriptação com o C# ...................................... 238
17.1 Classes de Exceções mais Comuns ........................................ 244 17.2 O Comando Throw ........................................................... 245 17.3 Liberando Recursos .......................................................... 246 17.3.1 Tipos de Tratamentos de Exceções Suportadas em C# .............. 247 17.3.2 Try / Catch / Finally ...................................................... 247 17.4 A Classe Exception ........................................................... 248 17.5 O Componente ErrorProvider ............................................... 249 18 XML – A Base do .NET ............................................. 251
18.1 Introdução .................................................................... 251 18.1.1 Objetivos do Desenvolvimento da XML ................................ 251 18.2 O Documento XML ........................................................... 252 18.3 Uma Agenda – WinForms e XML ........................................... 252 18.4 Classes XML mais Usadas ................................................... 256 19 Trabalhando com Bases de Dados .............................. 259
20.1 Adicionando ao Projeto um Arquivo de Resources Padrão .............. 301 20.2 Compilando o Arquivo de Resources Padrão .............................. 303 20.3 Criando Arquivos de Resources Dependentes da Cultura ............... 304 20.4 Satellite Assemblies ......................................................... 305 20.4.1 Trabalhando com Satellite Assemblies.................................. 306
Apêndice B .............................................................. 337
Garbage Collection ................................................................. 337 Funcionamento do Gerenciamento de Objetos COM .......................... 339 Nos Bastidores do Garbage Collector ............................................ 339 Trabalhando em Parceria com o Garbage Collector ........................... 340 Considerações Finais .............................................................. 340 Apêndice C .............................................................. 341
O SQL ................................................................................ 341 Comandos SQL-DML ............................................................... 342 Pesquisa (SELECT) ................................................................. 342 GROUP BY ........................................................................... 343 Cláusula HAVING ................................................................... 344 Cláusula ORDER BY ................................................................. 344 Inserindo (INSERT INTO) .......................................................... 344 UPDATE .............................................................................. 345 Exclusão (DELETE) ................................................................. 346 Subconsultas SQL .................................................................. 347 Apêndice D .............................................................. 351
Exercícios ........................................................................... 351 Primeiro Problema: Palavras Proibidas .......................................... 351 Segundo Problema: Movendo o Form ............................................ 353 Terceiro Problema: A Calculadora ................................................ 354 Quarto Problema: Chamando uma Função VB .NET em C# ................... 355 Quinto Problema: Adicionando uma Nova Característica a um Objeto ..... 356 Sexto Problema: Como Copiar e Colar Textos e Imagens com o C#......... 359 Sétimo Problema: Trabalhando com Operações de Datas .................... 363 Oitavo Problema: Construindo um Visualizador de Imagens ................. 370 Nono Problema: Escrevendo um Editor de Texto Simples .................... 373 Último Problema: A “Saideira” ................................................... 383 Apêndice E .............................................................. 387
Nomes para Componentes (Notação Húngara)................................. 387 Windows Forms .................................................................... 387 Data .................................................................................. 389 Bibliografia ......................................................................... 389 Apêndice F .............................................................. 391
Operadores ......................................................................... 391 Apêndice G .............................................................. 393