C# do básico ao avançado

Prévia do material em texto

ContentsContents
 Documentação do C#
 Introdução
 Visão geral
 Introdução à linguagem C# e ao .NET Framework
 Tutoriais
 Visão geral
 Introdução à programação com C#
 Escolha sua primeira lição
 Hello world
 Números em C#
 Loops e branches
 Coleções de lista
 Trabalhar em seu ambiente local
 Configurar seu ambiente
 Números em C#
 Loops e branches
 Coleções de lista
 Introdução às classes
 Explorar o C# 6
 Explorar a interpolação de cadeia de caracteres – interativo
 Explorar a interpolação de cadeia de caracteres – em seu ambiente
 Cenários avançados de interpolação de cadeia de caracteres
 Atualizar interfaces de forma segura com membros de interface padrão
 Criar funcionalidade mixin com métodos de interface padrão
 Explore os índices e os intervalos
 Trabalhar com tipos de referência nula
 Atualizar um aplicativo para tipos de referência nula
 Gerar e consumir fluxos assíncronos
 Estender as funcionalidades de dados usando a correspondência de padrões
https://docs.microsoft.com/dotnet/csharp/index
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/hello-world
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/numbers-in-csharp
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/branches-and-loops
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/list-collection
https://docs.microsoft.com/dotnet/csharp/tutorials/exploration/csharp-6
https://docs.microsoft.com/dotnet/csharp/tutorials/exploration/interpolated-strings
 Aplicativo do Console
 Cliente REST
 Herança em C# e .NET
 Trabalhar com o LINQ
 Usar atributos
 Tour do C#
 Introdução
 Estrutura do programa
 Tipos e variáveis
 Expressões
 Instruções
 Classes e objetos
 Matrizes
 Interfaces
 Delegados
 Atributos
 Novidades no C#
 C# 8.0
 C# 7.3
 C# 7.2
 C# 7.1
 C# 7.0
 C# 6
 Alterações da falha no compilador
 Histórico de versão do C#
 Relações entre linguagem e estrutura
 Considerações sobre versão e atualização
 Conceitos de C#
 Sistemas do tipo C#
 Tipos de referência anuláveis
 Descrever APIs anuláveis usando atributos e restrições
 Namespaces
 Tipos Básicos
 Classes
 Tuplas
 Desconstruindo tuplas e outros tipos
 Interfaces
 Métodos
 Expressões lambda
 Propriedades
 Indexadores
 Descartes
 Genéricos
 Iterators
 Delegados e eventos
 Introdução a Delegados
 System.Delegate e a palavra-chave delegado
 Delegados Fortemente Tipados
 Padrões Comuns para Delegados
 Introdução a eventos
 Padrões de evento .NET padrão
 Padrão de Evento .NET Atualizado
 Distinção entre Delegados e Eventos
 LINQ (Consulta Integrada à Linguagem)
 Visão geral de LINQ
 Noções básicas sobre expressões de consulta
 LINQ em C#
 Escrever consultas LINQ em C#
 Consultar uma coleção de objetos
 Retornar uma consulta de um método
 Armazenar os resultados de uma consulta na memória
 Agrupar resultados de consultas
 Criar um grupo aninhado
 Executar uma subconsulta em uma operação de agrupamento
 Agrupar resultados por chaves contíguas
 Especificar filtros predicados dinamicamente em runtime
 Executar junções internas
 Executar junções agrupadas
 Executar junções externas esquerdas
 Ordenar os resultados de uma cláusula join
 Unir usando chaves compostas
 Executar operações de junção personalizadas
 Manipular valores nulos em expressões de consulta
 Tratar exceções em expressões de consulta
 Programação assíncrona
 Correspondência padrão
 Escrever código eficiente e seguro
 Árvores de expressão
 Introdução à Árvores de expressão
 Árvores de Expressão Explicadas
 Tipos de Framework com suporte a árvores de expressão
 Executando Expressões
 Interpretando Expressões
 Compilando Expressões
 Traduzindo Expressões
 Resumo
 Interoperabilidade nativa
 Documentando seu código
 Controle de versão
 Artigos de instruções sobre C#
 Índice do artigo
 Analisar cadeias de caracteres usando `String.Split`
 Concatenar cadeias de caracteres
 Converter uma cadeia de caracteres em um DateTime
 Pesquisar cadeias de caracteres
 Modificar o conteúdo de uma cadeia de caracteres
 Comparar cadeias de caracteres
 Converter usando a correspondência de padrões e os operadores is e as com
segurança
 O SDK do .NET Compiler Platform (APIs do Roslyn)
 Visão geral do SDK do .NET Compiler Platform (APIs do Roslyn)
 Entender o modelo de API do compilador
 Trabalhar com sintaxe
 Trabalhar com semântica
 Trabalhar com um workspace
 Explorar código com o visualizador de sintaxe
 Inícios rápidos
 Análise sintática
 Análise semântica
 Transformação de sintaxe
 Tutoriais
 Crie seu primeiro analisador e correção de código
 Guia de programação em C#
 Visão geral
 Por dentro de um programa em C#
 Fique por dentro de um programa em C#
 Hello World -- seu primeiro programa
 Estrutura geral de um programa em C#
 Nomes de identificadores
 Convenções de codificação em C#
 Main() e argumentos de linha de comando
 Visão geral
 Argumentos de linha de comando
 Como exibir argumentos de linha de comando
 Valores de retorno de Main()
 Conceitos de programação
 Visão geral
 Programação assíncrona com async e await
 Visão geral
 Modelo de programação assíncrona de tarefa
 Passo a passo: acessar a Web usando async e await
 Como estender o passo a passo assíncrono usando Task.WhenAll
 Como fazer várias solicitações da Web em paralelo usando async e await
 Tipos de retorno assíncronos
 Fluxo de controle em programas assíncronos
 Cancelamento de tarefas e processamento de tarefas concluídas
 Visão geral
 Cancelar uma tarefa assíncrona ou uma lista de tarefas
 Cancelar tarefas assíncronas após um período
 Cancelar tarefas assíncronas restantes após a conclusão de uma delas
 Iniciar várias tarefas assíncronas e processá-las na conclusão
 Tratar a reentrada em aplicativos assíncronos
 Usando o Async para acessar arquivos
 Atributos
 Visão geral
 Criando atributos personalizados
 AttributeUsage
 Acessando atributos usando reflexão
 Como criar uma união do C/C++ usando atributos
 Atributos comuns
 Informações do chamador
 Coleções
 Covariância e contravariância
 Visão geral
 Variação em interfaces genéricas
 Criar interfaces genéricas variáveis
 Usar variação em interfaces para coleções genéricas
 Variação em delegações
 Usar variação em delegações
 Usar variação para delegações genéricas Func e Action
 Árvores de expressão
 Visão geral
 Visão geral
 Como executar árvores de expressão
 Como modificar árvores de expressão
 Como usar árvores de expressão para compilar consultas dinâmicas
 Depurar árvores de expressão no Visual Studio
 Sintaxe do DebugView
 Iterators
 LINQ (Consulta Integrada à Linguagem)
 Visão geral
 Introdução a LINQ em C#
 Introdução a consultas LINQ
 LINQ e tipos genéricos
 Operações de consulta LINQ básicas
 Transformações de dados com LINQ
 Relacionamentos de tipo em operações de consulta LINQ
 Sintaxe de consulta e sintaxe de método em LINQ
 funcionalidades do C# que dão suporte a LINQ
 Passo a passo: Escrevendo consultas em C# (LINQ)
 Visão geral de operadores de consulta padrão
 Visão geral
 Sintaxe de expressão da consulta para operadores de consulta padrão
 Classificação de operadores de consulta padrão por maneira de execução
 Classificar dados
 Operações de conjunto
 Filtrar dados
 Operações de quantificador
 Operações de projeção
 Particionar dados
 Operações de junção
 Agrupar dados
 Operações de geração
 Operações de igualdade
 Operações de elemento
 Converter tipos de dados
 Operações de concatenação
 Operações de agregação
 Objetos LINQ to
 Visão geral
 LINQ e cadeias de caracteres
 Artigos de instruções
 Como contar ocorrências de uma palavra em uma cadeia de caracteres (LINQ)
 Como consultar sentenças que contenham um conjunto especificado de
palavras (LINQ)
 Como consultar caracteres em uma cadeia de caracteres (LINQ)
 Como combinar consultas LINQ com expressões regulares
 Como localizar a diferença de conjunto entre duas listas (LINQ)
 Como classificar ou filtrar dados de texto por qualquer palavra ou campo
(LINQ)
 Como reorganizar os campos de um arquivo delimitado (LINQ)
 Como combinare comparar coleções de cadeias de caracteres (LINQ)
 Como preencher coleções de objetos por meio de várias fontes (LINQ)
 Como dividir um arquivo em vários arquivos usando grupos (LINQ)
 Como unir conteúdo por meio de arquivos diferentes (LINQ)
 Como computar valores de coluna em um arquivo de texto CSV (LINQ)
 LINQ e reflexão
 Como consultar metadados de um assembly com reflexão (LINQ)
 LINQ e diretórios de arquivos
 Visão geral
 Como consultar arquivos com um atributo ou nome especificado
 Como agrupar arquivos por extensão (LINQ)
 Como consultar o número total de bytes em um conjunto de pastas (LINQ)
 Como comparar o conteúdo de duas pastas (LINQ)
 Como consultar o maior arquivo ou os arquivos em uma árvore de diretório
(LINQ)
 Como consultar arquivos duplicados em uma árvore de diretório (LINQ)
 Como consultar o conteúdo de arquivos em uma pasta (LINQ)
 Como consultar um ArrayList com LINQ
 Como adicionar métodos personalizados para consultas LINQ
 LINQ to XML
 Guia de introdução (LINQ to XML)
 Visão geral de LINQ to XML
 LINQ to XML e DOM
 LINQ to XML e outras tecnologias XML
 Guia de programação (LINQ to XML)
 Visão geral da programação LINQ to XML
 Árvores XML
 Trabalhando com namespaces XML
 Serializando árvores XML
 Eixos LINQ to XML
 Consultando árvores XML
 Modificar árvores XML (LINQ to XML)
 Desempenho (LINQ to XML)
 Programação LINQ to XML avançada
 Segurança LINQ to XML
 Documentos XML de exemplo (LINQ to XML)
 Referência (LINQ to XML)
 LINQ to ADO.NET (página do portal)
 Habilitando uma fonte de dados para consulta LINQ
 Suporte do Visual Studio IDE e ferramentas para LINQ
 Programação orientada a objeto
 Reflexão
 Serialização (C#)
 Visão geral
 Como gravar dados de objeto em um arquivo XML
 Como ler dados de objeto provenientes de um arquivo XML
 Passo a passo: persistir um objeto no Visual Studio
 Instruções, expressões e operadores
 Visão geral
 Instruções
 Expressões
 Membros aptos para expressão
 Funções anônimas
 Visão geral
 Expressões lambda
 Como usar expressões lambda em uma consulta
 Igualdade e comparações de igualdade
 Comparações de igualdade
 Como definir a igualdade de valor para um tipo
 Como testar a igualdade de referência (identidade)
 Tipos
 Usar e definir tipos
 Conversões cast e conversões de tipo
 Conversão boxing e unboxing
 Como converter uma matriz de bytes em um int
 Como converter uma cadeia de caracteres em um número
 Como converter entre cadeias de caracteres hexadecimais e tipos numéricos
 Usando o tipo dynamic
 Passo a passo: criar e usar objetos dinâmicos (C# e Visual Basic)
 Classes e structs
 Visão geral
 Classes
 Objetos
 Herança
 Polimorfismo
 Visão geral
 Controle de versão com as palavras-chave override e new
 Quando usar as palavras-chave override e new
 Como substituir o método ToString
 Membros
 Visão geral dos membros
 Classes e membros de classes abstract e sealed
 Classes static e membros de classes static
 Modificadores de acesso
 Campos
 Constantes
 Como definir propriedades abstract
 Como definir constantes em C#
 Propriedades
 Visão geral das propriedades
 Usando propriedades
 Propriedades de interface
 Restringindo a acessibilidade ao acessador
 Como declarar e usar propriedades de leitura/gravação
 Propriedades autoimplementadas
 Como implementar uma classe leve com propriedades autoimplementadas
 Métodos
 Visão geral dos métodos
 Funções locais
 Ref returns e ref locals
 Parâmetros
 Passando parâmetros
 Passando parâmetros de tipo de valor
 Passando parâmetros de tipo de referência
 Como saber a diferença entre passar um struct e passar uma referência de classe
para um método
 Variáveis Locais Tipadas Implicitamente
 Como usar matrizes e variáveis locais de tipo implícito em uma expressão de
consulta
 Métodos de extensão
 Como implementar e chamar um método de extensão personalizado
 Como criar um novo método para uma enumeração
 Argumentos nomeados e opcionais
 Como usar argumentos nomeados e opcionais na programação do Office
 Construtores
 Visão geral dos construtores
 Usando construtores
 Construtores de instância
 Construtores particulares
 Construtores estáticos
 Como escrever um construtor de cópia
 Finalizadores
 Inicializadores de objeto e coleção
 Como inicializar objetos usando um inicializador de objeto
 Como inicializar um dicionário com um inicializador de coleção
 Tipos aninhados
 Classes parciais e métodos
 Tipos anônimos
 Como retornar subconjuntos de propriedades de elementos em uma consulta
 Interfaces
 Visão geral
 Implementação de interface explícita
 Como implementar membros de interface explicitamente
 Como implementar membros de duas interfaces explicitamente
 Delegados
 Visão geral
 Usando delegados
 Delegados com Métodos Nomeados vs. Métodos anônimos
 Como combinar delegados (delegados multicast) (Guia de Programação em C#)
 Como declarar e usar um delegado e criar uma instância dele
 Matrizes
 Visão geral
 Matrizes como Objetos
 Matrizes unidimensionais
 Matrizes multidimensionais
 Matrizes denteadas
 Usar foreach com matrizes
 Passar matrizes como argumentos
 Matrizes de tipo implícito
 Cadeias de caracteres
 Programando com cadeias de caracteres
 Como determinar se uma cadeia de caracteres representa um valor numérico
 Indexadores
 Visão geral
 Usando indexadores
 Indexadores em interfaces
 Comparação entre propriedades e indexadores
 Eventos
 Visão geral
 Como realizar e cancelar a assinatura de eventos
 Como publicar eventos em conformidade com as diretrizes do .NET Framework
 Como acionar eventos de classe base em classes derivadas
 Como implementar eventos de interface
 Como implementar acessadores de eventos personalizados
 Genéricos
 Visão geral
 Parâmetros de tipo genérico
 Restrições a parâmetros de tipo
 Classes genéricas
 Interfaces genéricas
 Métodos genéricos
 Genéricos e matrizes
 Delegados genéricos
 Diferenças entre modelos C++ e genéricos C#
 Genéricos em tempo de execução
 Genéricos e reflexão
 Genéricos e atributos
 Namespaces
 Visão geral
 Visão geral
 Usar namespaces
 Como usar o My Namespace
 Código não seguro e ponteiros
 Visão geral e restrições
 Buffers de tamanho fixo
 Tipos de ponteiro
 Visão geral
 Conversões de ponteiro
 Como usar ponteiros para copiar uma matriz de bytes
 Comentários da documentação XML
 Visão geral
 Marcas recomendadas para comentários de documentação
 Processando o arquivo XML
 Delimitadores para marcações de documentação
 Como usar as funcionalidades da documentação XML
 Referência de marcação de documentação
 <c>
 <code>
 atributo cref
 <example>
 <exception>
 <include>
 <list>
 <para>
 <param>
 <paramref>
 <permission>
 <remarks>
 <returns>
 <see>
 <seealso>
 <summary>
 <typeparam>
 <typeparamref>
 <value>
 Exceções e manipulação de exceções
 Visão geral
 Usando exceções
 Tratamento de Exceção
 Criar e lançar exceções
 Exceções geradas pelo compilador
 Como manipular uma exceção usando try/catch
 Como executar código de limpeza usando finally
 Como capturar uma exceção não compatível com CLS
 Sistema de arquivos e o Registro
 Visão geral
 Como iterar em uma árvore de diretório
 Como obter informações sobre arquivos, pastas e unidades
 Como criar um arquivo ou uma pasta
 Como copiar, excluir e mover arquivos e pastas
 Como fornecer uma caixa de diálogo de progresso para operações de arquivo
 Como escrever em um arquivo de texto
 Como ler de um arquivo de texto
 Como ler um arquivo de texto uma linha de cada vez
 Como criar uma chave no Registro
 Interoperabilidade
 Interoperabilidade .NET
 Visão geral sobre interoperabilidade
 Como acessar objetos de interoperabilidade do Office usando recursos do C#
 Como usar propriedades indexadas na programação para interoperabilidade COM
 Como usar invocação de plataforma para executar um arquivo WAV
 Passo a passo: Programação do Office (C# e Visual Basic)
 Exemplo de classe COM
 Referência de linguagem
 Visão geral
 Visão geral
 Configurar versão da linguagem
 Palavras-chave de C#
 Visão geral
 Tipos
 Tipos de valor
 Visão geral
 Tipos numéricosintegrais
 Tipos numéricos de ponto flutuante
 Conversões numéricas internas
 bool
 char
 Tipos de enumeração
 Tipos de estrutura
 Tipos de valor anuláveis
 Tipos de referência
 Recursos dos tipos de referência
 Tipos de referência internos
 classe
 interface
 void
 var
 Tipos internos
 Tipos não gerenciados
 Valores padrão
 Modificadores
 Modificadores de acesso
 Referência rápida
 Níveis de acessibilidade
 Domínio de acessibilidade
 Restrições ao uso de níveis de acessibilidade
 interno
 particulares
 protegidos
 públicos
 internos protegidos
 privado protegido
 abstract
 async
 const
 event
 extern
 in (modificador genérico)
 new (modificador de membro)
 out (modificador genérico)
 override
 readonly
 sealed
 static
 unsafe
 virtual
 volatile
 Palavras-chave de instrução
 Categorias de instrução
 Instruções de seleção
 if-else
 switch
 Instruções de iteração
 do
 for
 foreach, in
 while
 Instruções de atalho
 break
 continue
 goto
 return
 Instruções para manipulação de exceções
 throw
 try-catch
 try-finally
 try-catch-finally
 Contexto verificado e não verificado
 Visão geral
 checked
 unchecked
 Instrução fixed
 Instrução lock
 Parâmetros de método
 Passando parâmetros
 params
 in (modificador de parâmetro)
 ref
 out (modificador de parâmetro)
 Palavras-chave de namespace
 namespace
 using
 Contextos de uso
 Diretiva de uso
 Diretiva using static
 Instrução using
 extern alias
 Palavras-chave de teste de tipo
 is
 Tipo genérico de palavras-chave de restrição
 nova restrição
 where
 Palavras-chave de acesso
 base
 this
 Palavras-chave literais
 null
 true e false
 default
 Palavras-chave contextuais
 Referência rápida
 add
 get
 partial (tipo)
 partial (método)
 remove
 set
 when (condição de filtro)
 value
 yield
 Palavras-chave de consulta
 Referência rápida
 Cláusula from
 Cláusula where
 Cláusula select
 Cláusula group
 into
 Cláusula orderby
 Cláusula join
 Cláusula let
 ascending
 descending
 on
 equals
 by
 in
 Operadores e expressões C#
 Visão geral
 Operadores aritméticos
 Operadores lógicos boolianos
 Operadores shift e bit a bit
 Operadores de igualdade
 Operadores de comparação
 Operadores de acesso do membro e expressões
 Operadores cast e teste de tipo
 Operadores de conversões definidas pelo usuário
 Operadores relacionados ao ponteiro
 Operadores de atribuição
 + e operadores +=
 - e operadores -=
 Operador ?:
 ! Operador do (null-forgiving)
 ?? e operadores ??=
 Operador =>
 Operador ::
 Operador await
 Expressões de valor padrão
 operador delegate
 expressão nameof
 Operador new
 Operador sizeof
 expressão stackalloc
 expressão switch
 operadores true e false
 Sobrecarga de operador
 Caracteres especiais de C#
 Visão geral
 Interpolação de cadeia de caracteres -- $
 @ – identificador textual
 Diretivas de pré-processador do C#
 Visão geral
 #if
 #else
 #elif
 #endif
 #define
 #undef
 #warning
 #error
 #line
 #region
 #endregion
 #pragma
 #pragma warning
 #pragma checksum
 Opções do compilador de C#
 Visão geral
 Compilando pela linha de comando com csc.exe
 Como configurar variáveis de ambiente para a linha de comando do Visual Studio
 Opções do compilador de C# listadas por categoria
 Opções do compilador de C# listadas em ordem alfabética
 @
 -addmodule
 -appconfig
 -baseaddress
 -bugreport
 -checked
 -codepage
 -debug
 -define
 -delaysign
 -deterministic
 -doc
 -errorreport
 -filealign
 -fullpaths
 /help, /?
 -highentropyva
 -keycontainer
 -keyfile
 -langversion
 -lib
 -link
 -linkresource
 -main
 -moduleassemblyname
 -noconfig
 -nologo
 -nostdlib
 -nowarn
 -nowin32manifest
 -optimize
 -out
 -pathmap
 -pdb
 -platform
 -preferreduilang
 -publicsign
 -recurse
 -reference
 -refout
 -refonly
 -resource
 -subsystemversion
 -target
 -target:appcontainerexe
 -target:exe
 -target:library
 -target:module
 -target:winexe
 -target:winmdobj
 -unsafe
 -utf8output
 -warn
 -warnaserror
 -win32icon
 -win32manifest
 -win32res
 Erros do compilador de C#
 Especificação de rascunho do C# 6.0
 Propostas do C# 7.0 - 8.0
 Passo a passo
minutes to read • Edit Online
Seções relacionadas
Esta seção fornece breves tutoriais simples que permitem que você compile rapidamente um aplicativo usando C#
e .NET Core. Há tópicos iniciais para Visual Studio e Visual Studio Code. Esses artigos supõem experiência prévia
em programação. Se você for iniciante em programação, experimente nossos tutoriais interativos de Introdução ao
C#.
Os seguintes tópicos estão disponíveis:
Introdução à língua C# e ao Quadro .NET
Fornece uma visão geral da linguagem C# e da plataforma .NET.
Crie um aplicativo C# Hello World com .NET Core no Visual Studio
O Visual Studio permite codificar, compilar, executar, depurar, perfilar e publicar seus aplicativos a partir de
um ambiente de desenvolvimento integrado para Windows ou Mac.
O tópico permite criar e executar um aplicativo simples Hello World e, em seguida, modificá-lo para executar
um aplicativo Hello World um pouco mais interativo. Quando terminar de compilar e executar seu aplicativo,
você também poderá aprender como depurá-lo e como publicá-lo para que ele possa ser executado em
qualquer plataforma com suporte do .NET Core.
Crie uma biblioteca de classes com C# e .NET Standard no Visual Studio
Uma biblioteca de classes permite definir tipos e membros de tipo que podem ser chamados de outro
aplicativo. Este tópico permite criar uma biblioteca de classes com um único método que determina se uma
cadeia de caracteres começa com um caractere maiúsculo. Após criar a biblioteca, você pode desenvolver
um teste de unidade para garantir que ela funciona conforme o esperado e, em seguida, você pode torná-la
disponível para aplicativos que desejam consumi-la.
Comece com C# e Visual Studio Code
O Visual Studio Code é um editor de código gratuito e otimizado para compilação e depuração de
aplicativos Web e de nuvem modernos. Ele dá suporte ao IntelliSense e está disponível para Windows, Linux
e macOS.
Este tópico mostra como criar e executar um aplicativo Olá, Mundo simples com o código do Visual Studio e
do .NET Core.
C# Guia de Programação
Fornece informações sobre conceitos de programação C# e descreve como executar várias tarefas no C#.
C# Referência
Fornece informações de referência detalhadas sobre palavras-chave, operadores, diretivas de pré-
processamento, opções do compilador, erros do compilador e avisos do #C.
Instruções passo a passo
Fornece links para explicações passo a passo sobre programação em C# e uma breve descrição sobre cada
explicação passo a passo.
https://github.com/dotnet/docs.pt-br/blob/live/docs/csharp/getting-started/index.md
https://docs.microsoft.com/pt-br/dotnet/core/tutorials/with-visual-studio
https://docs.microsoft.com/pt-br/dotnet/core/tutorials/debugging-with-visual-studio
https://docs.microsoft.com/pt-br/dotnet/core/tutorials/publishing-with-visual-studio
https://docs.microsoft.com/pt-br/dotnet/core/tutorials/library-with-visual-studio
https://docs.microsoft.com/pt-br/dotnet/core/tutorials/testing-library-with-visual-studio
https://docs.microsoft.com/pt-br/dotnet/core/tutorials/consuming-library-with-visual-studio
https://docs.microsoft.com/pt-br/dotnet/core/tutorials/with-visual-studio-code
Confira também
Desenvolvimento em C# com o Visual Studio
https://docs.microsoft.com/visualstudio/get-started/csharp/
minutes to read • Edit Online
NOTENOTE
Linguagem C#
C# é uma linguagem elegante, orientada a objeto e fortemente tipada, que permite que os desenvolvedores criem
uma variedade de aplicativos robustos e seguros executados no .NET Framework. Você pode usar C# para criar
aplicativos de cliente do Windows, serviços Web XML, componentes distribuídos, aplicativos cliente-servidor,
aplicativos de banco de dados e muito, muito mais. O Visual C# fornece um editor de código avançado, designers
de interface do usuário convenientes, depurador integrado e muitas outras ferramentas para facilitar o
desenvolvimento de aplicativos com base na linguagem C# e no.NET Framework.
A documentação do Visual C# considera que você já tenha conhecimento dos conceitos básicos de programação. Se você é
principiante, convém explorar o Visual C# Express, que está disponível na Web. Você também pode tirar proveito de livros e
recursos da Web sobre C# para aprender técnicas de programação práticas.
A sintaxe de C# é altamente expressiva, mas também é simples e fácil de aprender. A sintaxe de cinta encaracolada
de C# será instantaneamente reconhecível para qualquer pessoa familiarizada com C, C++ou Java. Normalmente,
os desenvolvedores que conhecem qualquer uma dessas linguagens são capazes de começar a trabalhar de forma
produtiva em C# dentro de um período muito curto. A sintaxe C# simplifica muitas das complexidades do C++ e
fornece recursos poderosos, como tipos anulados, enumerações, delegados, expressões lambda e acesso direto à
memória. C# oferece suporte a tipos e métodos genéricos, o que proporciona mais segurança e desempenho para
os tipos, e iteradores, que permitem aos implementadores das classes de coleção definir os comportamentos
personalizados da iteração simples de usar pelo código do cliente. As expressões LINQ (Language-Integrated
Query, consulta integrada ao idioma) tornam a consulta fortemente digitada uma construção de idioma de
primeira classe.
Por ser uma linguagem orientada a objeto, o C# oferece suporte aos conceitos de encapsulamento, herança e
polimorfismo. Todas as variáveis e métodos, incluindo o método Main , o ponto de entrada do aplicativo, são
encapsulados em definições de classe. Uma classe pode herdar diretamente de uma classe pai, mas pode
implementar qualquer quantidade de interfaces. Métodos que substituem métodos virtuais em uma classe pai
exigem a palavra-chave override como uma forma de evitar uma redefinição acidental. Em C#, um struct é como
uma classe simplificada; é um tipo alocado na pilha que pode implementar interfaces, mas não oferece suporte a
herança.
Além desses princípios básicos orientados a objeto, C# facilita o desenvolvimento de componentes de software por
meio de várias construções de linguagem inovadoras, incluindo o seguinte:
Assinaturas de método encapsulado chamadas de delegados, que permitem as notificações de eventos
fortemente tipados.
Propriedades, que servem como acessadores para variáveis de membro privado.
Atributos, que fornecem metadados declarativos sobre os tipos no tempo de execução.
Comentários embutidos da documentação XML.
A LINQ (Language-Integrated Query, consulta integrada ao idioma), que fornece recursos de consulta
incorporados em uma variedade de fontes de dados.
https://github.com/dotnet/docs.pt-br/blob/live/docs/csharp/getting-started/introduction-to-the-csharp-language-and-the-net-framework.md
Arquitetura da plataforma do .NET Framework
Se você precisar interagir com outros softwares do Windows, como objetos COM ou DLLs Win32 nativas, faça isso
em C# através de um processo denominado "Interoperabilidade". A interoperabilidade permite que programas em
C# façam quase tudo que um aplicativo C++ nativo pode fazer. C# ainda suporta ponteiros e o conceito de código
"inseguro" para os casos em que o acesso direto à memória é crítico.
O processo de compilação de C# é simples comparado ao C e C++, e mais flexível do que em Java. Não há
arquivos de cabeçalho separado, e nenhum requisito de que os métodos e os tipos sejam declarados em uma
ordem específica. Um arquivo de código-fonte de C# pode definir qualquer quantidade de classes, estruturas,
interfaces e eventos.
Veja a seguir recursos adicionais de C#:
Para uma boa introdução geral à linguagem, consulte o Capítulo 1 da Especificação da linguagem C#.
Para obter informações detalhadas sobre aspectos específicos da linguagem C#, consulte a Referência de C#.
Para obter mais informações sobre linq, consulte LINQ (Linguagem Integrada de Consulta).
Programas em C# são executados no .NET Framework, um componente integral do Windows que inclui um
sistema de execução virtual chamado de CLR (Common Language Runtime) e um conjunto unificado de
bibliotecas de classes. O CLR é a implementação comercial da Microsoft da CLI (Common Language Infrastructure),
um padrão internacional que é a base para a criação de ambientes de execução e de desenvolvimento nos quais
linguagens e bibliotecas funcionam de forma integrada.
O código fonte escrito em C# é compilado em uma língua intermediária (IL) que está em conformidade com a
especificação CLI. O código e os recursos de IL, como bitmaps e cadeias de caracteres, são armazenados 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 os tipos, a versão, a cultura e os requisitos de segurança do
assembly.
Quando o programa em C# é executado, o assembly é carregado no CLR, que pode executar várias ações de
acordo com as informações no manifesto. Em seguida, se os requisitos de segurança forem atendidos, a CLR
realizará a compilação Just-In-Time (JIT) para converter o código IL em instruções de máquina nativa. O CLR
também oferece outros serviços relacionados à coleta automática de lixo, tratamento de exceções e gerenciamento
de recursos. O código executado pela CLR é às vezes referido como "código gerenciado", em contraste com o
"código não gerenciado", que é compilado em linguagem de máquina nativa que tem como alvo um sistema
específico. O diagrama a seguir ilustra as relações em tempo de compilação e em tempo de execução dos arquivos
de código-fonte em C#, as bibliotecas de classe do .NET Framework, assemblies e o CLR.
https://docs.microsoft.com/dotnet/csharp/language-reference/language-specification/introduction
https://docs.microsoft.com/pt-br/dotnet/standard/managed-code
Confira também
Interoperabilidade de linguagem é um recurso importante do .NET Framework. Como o código de IL produzido
pelo compilador de C# está em conformidade com a CTS (Especificação de tipo comum), o código de IL gerado a
partir de C# pode interagir com código gerado a partir das versões .NET do Visual Basic, Visual C++ ou qualquer
uma das mais de 20 linguagens compatíveis com CTS. Um único assembly pode conter vários módulos escritos em
linguagens .NET diferentes, e os tipos podem fazer referencia entre si, como se tivessem sido escritos na mesma
linguagem.
Além dos serviços de tempo de execução, o .NET Framework também inclui uma biblioteca abrangente de mais de
4000 classes organizadas em namespaces, fornecendo uma ampla variedade de funcionalidades úteis para tudo,
desde entrada e saída de arquivo para manipulação de cadeia de caracteres até análise XML, além de controles do
Windows Forms. O aplicativo típico em C# usa bastante a biblioteca de classes do .NET Framework para lidar com
tarefas comuns de "encanamento".
Para saber mais sobre o .NET Framework, confira Visão geral do Microsoft .NET Framework.
Guia de Introdução ao Visual C#
https://docs.microsoft.com/pt-br/dotnet/framework/get-started/overview
https://docs.microsoft.com/visualstudio/ide/quickstart-csharp-console
minutes to read • Edit Online
Tutoriais interativos de introdução ao C#
Olá, mundo
Números em C#
Loops e branches
Coleções de lista
Introdução ao C# – trabalhar localmente
Bem-vindo aos tutoriais do C#. Eles começam com lições interativas que podem ser executadas em seu navegador.
Os tutoriais posteriores e os tutoriais mais avançados ajudam você a trabalhar com as ferramentas de
desenvolvimento do .NET para criar programas em C# em seu computador.
Se você quiser iniciar sua exploração em formato de vídeo, a série de vídeo C# 101 fornece uma introdução ao C#.
Você aprenderá sobre conceitos que você pode explorar nestes tutoriais.
As primeiras lições explicam os conceitos de C# usando pequenos snippets de código. Você aprenderá os conceitos
básicos da sintaxe de C# e como trabalhar com tipos de dados como cadeias de caracteres, números e valores
boolianos. É tudo interativoe você começará a gravar e executar o código em questão de minutos. Estas primeiras
lições não exigem conhecimento prévio de programação ou da linguagem C#.
No tutorial Olá, Mundo, você criará o programa C# mais básico. Você explorará o tipo string e como trabalhar
com texto.
No tutorial Números em C#, você aprenderá como os computadores armazenam números e como executar
cálculos com diferentes tipos de número. Você aprenderá os conceitos básicos de arredondamento e como
executar cálculos matemáticos usando C#. Este tutorial também está disponível para execução local no seu
computador.
Esse tutorial pressupõe a conclusão da lição Olá, Mundo.
O tutorial Branches e loops ensina os conceitos básicos da seleção de diferentes caminhos de execução de código
com base nos valores armazenados em variáveis. Você aprenderá os conceitos básicos do fluxo de controle, que
são os fundamentos de como os programas tomam decisões e escolhem ações diferentes. Este tutorial também
está disponível para execução local no seu computador.
Esse tutorial pressupõe a conclusão das lições Olá, Mundo e Números em C#.
A lição Coleções de lista fornece um tour pelo tipo Coleções de lista que armazena as sequências de dados. Você
aprenderá a adicionar e remover itens, pesquisar itens e classificar listas. Você explorará os diferentes tipos de
listas. Este tutorial também está disponível para execução local no seu computador.
Esse tutorial pressupõe a conclusão das lições listadas acima.
Todos os tutoriais de introdução posteriores à lição Olá, Mundo estão disponíveis em seu próprio ambiente de
desenvolvimento local. No final de cada tutorial, você decidirá se deseja continuar com a próxima lição online ou
https://github.com/dotnet/docs.pt-br/blob/live/docs/csharp/tutorials/index.md
https://aka.ms/dotnet3-csharp
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/hello-world
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/hello-world
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/numbers-in-csharp
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/numbers-in-csharp
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/hello-world
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/branches-and-loops
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/branches-and-loops
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/hello-world
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/numbers-in-csharp
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/list-collection
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/list-collection
Explore novos recursos no C#
Tutoriais gerais
no próprio computador. Há links para ajudar você a configurar seu ambiente e continuar com o próximo tutorial no
computador.
Experimente novos recursos em C# 6 interativamente: Explore os recursos adicionados em C# 6 interativamente
em seu navegador.
Interpolação de cadeia de caracteres: demonstra como usar interpolação de cadeia de caracteres para criar
cadeias de caracteres formatadas em C#.
Tipos de referência nula: demonstra como usar tipos de referência nula para expressar sua intenção para
referências nulas.
Atualizar um projeto para usar tipos de referência que permitem valor nulo: demonstra técnicas para atualizar
um projeto existente a fim de usar tipos de referência que permitem valor nulo.
Estender recursos de dados usando a correspondência de padrões: demonstra como usar a correspondência de
padrões a fim de estender os tipos para além dos principais recursos.
Trabalhe com seqüências de dados usando índices e faixas: Demonstra nova sintaxe conveniente para acessar
elementos únicos ou intervalos de um contêiner de dados seqüencial.
Os tutoriais a seguir permitem que você compile programas em C# usando .NET Core:
Aplicativo de console: demonstra a E/S de console, a estrutura de um aplicativo de console e os conceitos
básicos do modelo de programação assíncrono baseado em tarefa.
Cliente REST: demonstra as comunicações da Web, serialização JSON e recursos orientados a objeto na
linguagem C#.
Herança em C# e .NET: demonstra herança em C#, incluindo o uso de herança para definir classes derivadas,
classes base e classes base abstratas.
Trabalhar com LINQ: demonstra muitos recursos do LINQ e os elementos de linguagem que dão suporte a ele.
Usando atributos: demonstra como criar e usar atributos em C#.
O tutorial Interpolação de cadeia de caracteres mostra como inserir valores em uma cadeia de caracteres. Você
aprenderá como criar uma cadeia de caracteres interpolada com expressões de C# incorporadas e como
controlar a aparência do texto dos resultados de expressão na cadeia de caracteres de resultado. Este tutorial
também está disponível para execução local no seu computador.
https://docs.microsoft.com/dotnet/csharp/tutorials/exploration/csharp-6
https://docs.microsoft.com/dotnet/core/index
https://docs.microsoft.com/dotnet/csharp/tutorials/exploration/interpolated-strings
minutes to read • Edit Online
Olá, mundo
Números em C#
Ramificações e loops
Coleções de lista
Introdução às classes
Bem-vindo aos tutoriais de introdução ao C#. Eles começam com lições interativas que podem ser executadas em
seu navegador. Você pode aprender o básico de C# da série de vídeoC# 101 antes de iniciar essas lições
interativas.
As primeiras lições explicam os conceitos de C# usando pequenos snippets de código. Você aprenderá os
conceitos básicos da sintaxe de C# e como trabalhar com tipos de dados como cadeias de caracteres, números e
valores boolianos. É tudo interativo e você começará a gravar e executar o código em questão de minutos. Estas
primeiras lições não exigem conhecimento prévio de programação ou da linguagem C#.
Todos os tutoriais de introdução posteriores à lição Olá, Mundo estão disponíveis por meio da experiência de
navegador online ou em seu próprio ambiente de desenvolvimento local. No final de cada tutorial, você decidirá
se deseja continuar com a próxima lição online ou no próprio computador. Há links para ajudar você a configurar
seu ambiente e continuar com o próximo tutorial no computador.
No tutorial Olá, Mundo, você criará o programa C# mais básico. Você explorará o tipo string e como trabalhar
com texto.
No tutorial Números em C#, você aprenderá como os computadores armazenam números e como executar
cálculos com diferentes tipos de número. Você aprenderá os conceitos básicos de arredondamento e como
executar cálculos matemáticos usando C#. Este tutorial também está disponível para execução local no seu
computador.
Esse tutorial pressupõe a conclusão da lição Olá, Mundo.
O tutorial Branches e loops ensina os conceitos básicos da seleção de diferentes caminhos de execução de código
com base nos valores armazenados em variáveis. Você aprenderá os conceitos básicos do fluxo de controle, que
são os fundamentos de como os programas tomam decisões e escolhem ações diferentes. Este tutorial também
está disponível para execução local no seu computador.
Esse tutorial pressupõe a conclusão das lições Olá, Mundo e Números em C#.
A lição Coleções de lista fornece um tour pelo tipo Coleções de lista que armazena as sequências de dados. Você
aprenderá a adicionar e remover itens, pesquisar itens e classificar listas. Você explorará os diferentes tipos de
listas. Este tutorial também está disponível para execução local no seu computador.
Esse tutorial pressupõe a conclusão das lições listadas acima.
Este tutorial final está disponível apenas para execução no seu computador usando seu próprio ambiente de
https://github.com/dotnet/docs.pt-br/blob/live/docs/csharp/tutorials/intro-to-csharp/index.md
https://aka.ms/dotnet3-csharp
https://channel9.msdn.com/Series/CSharp-101/What-is-C/player?nocookie=true
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/hello-world
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/hello-worldhttps://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/numbers-in-csharp
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/numbers-in-csharp
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/hello-world
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/branches-and-loops
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/branches-and-loops
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/hello-world
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/numbers-in-csharp
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/list-collection
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/list-collection
desenvolvimento local e o .NET Core. Você compilará um aplicativo de console e verá os recursos básicos
orientados para objeto que fazem parte da linguagem C#.
Este tutorial pressupõe a conclusão dos tutoriais de introdução online e a instalação do SDK do .NET Core e do
Visual Studio Code.
https://dotnet.microsoft.com/download
https://code.visualstudio.com/
minutes to read • Edit Online
Fluxo de desenvolvimento de aplicativos básico
Escolha seu tutorial
Números em C#
Ramificações e loops
Coleções de lista
Introdução às classes
A primeira etapa para executar um tutorial em seu computador é configurar um ambiente de desenvolvimento. O
tutorial .NET Hello World em 10 minutos tem instruções para configurar seu ambiente de desenvolvimento local
no Windows, Linux ou macOS.
Como alternativa, você pode instalar o SDK do .NET Core e o Visual Studio Code.
Você criará aplicativos usando dotnet new o comando. Este comando gera os arquivos e ativos necessários para
o seu aplicativo. Todos os tutoriais de introdução ao C# usam o tipo de aplicativo console . Depois de conhecer as
noções básicas, você poderá expandir para outros tipos de aplicativo.
Os outros comandos que dotnet build você usará são para dotnet run construir o executável, e para executar o
executável.
Você pode iniciar com qualquer um dos seguintes tutoriais:
No tutorial Números em C#, você aprenderá como os computadores armazenam números e como executar
cálculos com diferentes tipos de número. Você aprenderá os conceitos básicos de arredondamento e como
executar cálculos matemáticos usando C#.
Esse tutorial pressupõe a conclusão da lição Olá, Mundo.
O tutorial Branches e loops ensina os conceitos básicos da seleção de diferentes caminhos de execução de código
com base nos valores armazenados em variáveis. Você aprenderá os conceitos básicos do fluxo de controle, que
são os fundamentos de como os programas tomam decisões e escolhem ações diferentes.
Esse tutorial pressupõe a conclusão das lições Olá, Mundo e Números em C#.
A lição Coleções de lista fornece um tour pelo tipo Coleções de lista que armazena as sequências de dados. Você
aprenderá a adicionar e remover itens, pesquisar itens e classificar listas. Você explorará os diferentes tipos de
listas.
Esse tutorial pressupõe a conclusão das lições listadas acima.
Esse tutorial final de introdução ao C# está disponível apenas para execução no seu computador usando seu
próprio ambiente de desenvolvimento local e o .NET Core. Você compilará um aplicativo de console e verá os
recursos básicos orientados para objeto que fazem parte da linguagem C#.
https://github.com/dotnet/docs.pt-br/blob/live/docs/csharp/tutorials/intro-to-csharp/local-environment.md
https://dotnet.microsoft.com/learn/dotnet/hello-world-tutorial/intro
https://dotnet.microsoft.com/download
https://code.visualstudio.com/
https://docs.microsoft.com/pt-br/dotnet/core/tools/dotnet-new
https://docs.microsoft.com/pt-br/dotnet/core/tools/dotnet-build
https://docs.microsoft.com/pt-br/dotnet/core/tools/dotnet-run
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/hello-world
https://docs.microsoft.com/dotnet/csharp/tutorials/intro-to-csharp/hello-world
minutes to read • Edit Online
Explorar a matemática de inteiros
dotnet new console -n NumbersInCSharp -o .
int a = 18;
int b = 6;
int c = a + b;
Console.WriteLine(c);
// subtraction
c = a - b;
Console.WriteLine(c);
// multiplication
c = a * b;
Console.WriteLine(c);
// division
c = a / b;
Console.WriteLine(c);
Este tutorial ensina sobre os tipos numéricos em C# de maneira interativa. Você escreverá pequenas quantidades
de código, depois compilará e executará esse código. O tutorial contém uma série de lições que exploram
números e operações matemáticas em C#. Estas lições ensinam os princípios básicos da linguagem C#.
Este tutorial espera que você tenha um computador que possa usar para desenvolvimento. O tutorial .NET Hello
World em 10 minutos tem instruções para configurar seu ambiente de desenvolvimento local no Windows,
Linux ou macOS. Uma visão geral dos comandos que você usará está em Familiarize-se com as ferramentas de
desenvolvimento, com links para obter mais detalhes.
Crie um diretório chamado numbers-quickstart. Faça disso o diretório atual e execute o seguinte comando:
Abra Program.cs em seu editor favorito e substitua a linha Console.WriteLine("Hello World!"); pelo seguinte:
Execute este código digitando dotnet run na janela de comando.
Você viu apenas uma das operações matemáticas fundamentais com números inteiros. O int tipo representa
um inteirointeiro, um número inteiro zero, positivo ou negativo. Você usa o símbolo + para adição. Outras operações
matemáticas comuns para inteiros incluem:
- para subtração
* para multiplicação
/ para divisão
Comece explorando essas diferentes operações. Adicione estas linhas após a linha que grava o valor de c :
Execute este código digitando dotnet run na janela de comando.
Você também pode experimentar, executando várias operações matemáticas na mesma linha, se quiser.
https://github.com/dotnet/docs.pt-br/blob/live/docs/csharp/tutorials/intro-to-csharp/numbers-in-csharp-local.md
https://dotnet.microsoft.com/learn/dotnet/hello-world-tutorial/intro
TIPTIP
using System;
namespace NumbersInCSharp
{
 class Program
 {
 static void WorkingWithIntegers()
 {
 int a = 18;
 int b = 6;
 // addition
 int c = a + b;
 Console.WriteLine(c);
 // subtraction
 c = a - b;
 Console.WriteLine(c);
 // multiplication
 c = a * b;
 Console.WriteLine(c);
 // division
 c = a / b;
 Console.WriteLine(c);
 }
 static void Main(string[] args)
 {
 WorkingWithIntegers();
 }
 }
}
Explorar a ordem das operações
//WorkingWithIntegers();
Experimente c = a + b - 12 * 17; , por exemplo. É permitido misturar variáveis e números constantes.
À medida que explora C# (ou qualquer linguagem de programação), você cometerá erros ao escrever o código. O
compiladorcompilador encontrará esses erros e os reportará a você. Quando a saída contiver mensagens de erro, analise
atentamente o código de exemplo e o código em sua janela para ver o que deve ser corrigido. Esse exercício ajudará você a
conhecer a estrutura do código C#.
Você terminou a primeira etapa. Antes de iniciar a próxima seção, vamos passar o código atual para um método
separado. Isso facilita o começo do trabalho com um exemplo novo. Renomeie seu método Main como 
WorkingWithIntegers e escreva um novo método Main que chama WorkingWithIntegers . Quando você terminar,
seu código deve ficar assim:
Comente a chamada para WorkingWithIntegers() . Isso tornará a saída menos congestionada enquanto você
trabalha nesta seção:
O // inicia um comentár iocomentár io em C#. Os comentários são qualquer texto que você queira manter em seu código-
fonte, mas não queria executar como código. O compilador não gera qualquer código executável a partir dos
comentários.
int a = 5;
int b = 4;
int c = 2;
int d = a + b * c;
Console.WriteLine(d);
d = (a + b) * c;
Console.WriteLine(d);d = (a + b) - 6 * c + (12 * 4) / 3 + 12;
Console.WriteLine(d);
int e = 7;
int f = 4;
int g = 3;
int h = (e + f) / g;
Console.WriteLine(h);
A linguagem C# define a precedência de operações matemáticas diferentes com regras consistentes às regras
que você aprendeu em matemática. Multiplicação e divisão têm precedência sobre adição e subtração. Explore
isso adicionando o seguinte código ao seu método Main e executando dotnet run :
A saída demonstra que a multiplicação é executada antes da adição.
Você pode forçar uma ordem diferente de operações, adicionando parênteses para delimitar a operação, ou
operações, que você quer realizar primeiro. Adicione as seguintes linhas e execute novamente:
Explore mais, combinando várias operações diferentes. Adicione algo parecido com as seguintes linhas na parte
inferior de seu método Main . Tente dotnet run novamente.
Talvez você tenha observado um comportamento interessante com relação aos números inteiros. A divisão de
inteiros sempre produz um resultado inteiro, mesmo quando você espera que o resultado inclua uma parte
decimal ou fracionária.
Se você ainda não viu esse comportamento, tente o seguinte código ao final de seu método Main :
Digite dotnet run novamente para ver os resultados.
Antes de avançarmos, pegue todo código que você escreveu nesta seção e coloque-o em um novo método.
Chame esse novo método de OrderPrecedence . O resultado final será algo semelhante a isto:
using System;
namespace NumbersInCSharp
{
 class Program
 {
 static void WorkingWithIntegers()
 {
 int a = 18;
 int b = 6;
 // addition
 int c = a + b;
 Console.WriteLine(c);
 // subtraction
 c = a - b;
 Console.WriteLine(c);
 // multiplication
 c = a * b;
 Console.WriteLine(c);
 // division
 c = a / b;
 Console.WriteLine(c);
 }
 static void OrderPrecedence()
 {
 int a = 5;
 int b = 4;
 int c = 2;
 int d = a + b * c;
 Console.WriteLine(d);
 d = (a + b) * c;
 Console.WriteLine(d);
 d = (a + b) - 6 * c + (12 * 4) / 3 + 12;
 Console.WriteLine(d);
 int e = 7;
 int f = 4;
 int g = 3;
 int h = (e + f) / g;
 Console.WriteLine(h);
 }
 static void Main(string[] args)
 {
 WorkingWithIntegers();
 OrderPrecedence();
 }
 }
}
Explorar a precisão de inteiros e limites
Esse último exemplo mostrou que uma divisão de inteiros trunca o resultado. Você pode obter o restanterestante
usando o % operador de módulo,módulo, o personagem. Experimente o seguinte código em seu método Main :
int a = 7;
int b = 4;
int c = 3;
int d = (a + b) / c;
int e = (a + b) % c;
Console.WriteLine($"quotient: {d}");
Console.WriteLine($"remainder: {e}");
int max = int.MaxValue;
int min = int.MinValue;
Console.WriteLine($"The range of integers is {min} to {max}");
int what = max + 3;
Console.WriteLine($"An example of overflow: {what}");
Trabalhar com o tipo Double
double a = 5;
double b = 4;
double c = 2;
double d = (a + b) / c;
Console.WriteLine(d);
double e = 19;
double f = 23;
double g = 8;
double h = (e + f) / g;
Console.WriteLine(h);
O tipo de inteiro C# difere do inteiros matemáticos de outra forma: o tipo int tem limites mínimo e máximo.
Adicione este código ao seu método Main para ver esses limites:
Se um cálculo produzir um valor que excede esses limites, você terá uma condição de estouro negativoestouro negativo ou
estouroestouro. A resposta parece quebrar de um limite para o outro. Adicione estas duas linhas ao seu método Main
para ver um exemplo:
Observe que a resposta é muito próxima do mínimo inteiro (negativo). É o mesmo que min + 2 . A operação de
adição estourouestourou os valores permitidos para números inteiros. A resposta é um número negativo muito grande,
pois um estouro "envolve" do maior valor de inteiro possível para o menor.
Há outros tipos numéricos com limites e precisão diferentes que você usaria quando o tipo int não atendesse
às suas necessidades. Vamos explorá-los na sequência.
Novamente, vamos passar o código que você escreveu nesta seção para um método separado. Nomeie-o 
TestLimits .
O tipo numérico double representa um número de ponto flutuante de precisão dupla. Esses termos podem ser
novidade para você. Um número de ponto flutuantede ponto flutuante é útil para representar números não integrais que podem
ser muito grandes ou pequenos em magnitude. Precisão duplaPrecisão dupla significa que esses números são armazenados
usando uma precisão maior do que a precisão únicaprecisão única. Em computadores modernos, é mais comum usar
precisão dupla que números de precisão única. Vamos explorar. Adicione o seguinte código e veja o resultado:
Observe que a resposta inclui a parte decimal do quociente. Experimente uma expressão ligeiramente mais
complicada com duplos:
double max = double.MaxValue;
double min = double.MinValue;
Console.WriteLine($"The range of double is {min} to {max}");
double third = 1.0 / 3.0;
Console.WriteLine(third);
Trabalhar com tipos de ponto fixo
decimal min = decimal.MinValue;
decimal max = decimal.MaxValue;
Console.WriteLine($"The range of the decimal type is {min} to {max}");
double a = 1.0;
double b = 3.0;
Console.WriteLine(a / b);
decimal c = 1.0M;
decimal d = 3.0M;
Console.WriteLine(c / d);
O intervalo de um valor duplo é muito maior do que valores inteiros. Experimente o código a seguir abaixo do
código que você escreveu até o momento:
Esses valores são impressos em notação científica. O número à esquerda do E é o significando. O número à
direita é o expoente, como uma potência de 10.
Assim como os números decimais em matemática, os duplos em C# podem ter erros de arredondamento.
Experimente esse código:
Você sabe que a repetição de 0.3 não é exatamente o mesmo que 1/3 .
DesafioDesafio
Experimente outros cálculos com números grandes, números pequenos, multiplicação e divisão usando o tipo 
double . Experimente cálculos mais complicados.
Após algum tempo no desafio, pegue o código que você escreveu e coloque-o em um novo método. Chame esse
novo método de WorkWithDoubles .
Você viu os tipos numéricos básicos em C#: inteiros e duplos. Ainda há outro tipo : o tipo decimal . O tipo 
decimal tem um intervalo menor, mas precisão maior do que double . O termo ponto fixoponto fixo significa que a
virgula decimal (ou ponto binário) não muda. Vamos analisar :
Observe que o intervalo é menor do que o tipo double . Veja a precisão maior com o tipo decimal
experimentando o código a seguir :
O sufixo M nos números é o modo como você indica que uma constante deve usar o tipo decimal .
Observe que o cálculo usando o tipo decimal tem mais dígitos à direita da vírgula decimal.
DesafioDesafio
Agora que você viu os diferentes tipos numéricos, escreva um código que calcula a área de um círculo cujo raio é
de 2,50 centímetros. Lembre-se de que a área de um círculo é o quadrado do raio multiplicado por PI. Uma dica:
o .NET contém uma constante para PI, Math.PI, que você pode usar para esse valor.
https://docs.microsoft.com/dotnet/api/system.math.pi
Você deve obter uma resposta entre 19 e 20. Você pode verificar sua resposta olhando para o código de amostra
acabado no GitHub.
Experimente outras fórmulas, se quiser.
Você concluiu o início rápido "Números em C#". Continue com o início rápido Branches e loops em seu próprio
ambiente de desenvolvimento.
Saiba mais sobre os números em C# nos tópicos a seguir :
Tipos numéricos integrais
Tipos numéricos de ponto flutuante
Conversões numéricas internas
https://github.com/dotnet/samples/tree/master/csharp/numbers-quickstart/Program.cs#L104-L106
minutes to read • Edit Online
Tome decisões usando a instrução if
dotnet new console -n BranchesAndLoops-o .
int a = 5;
int b = 6;
if (a + b > 10)
 Console.WriteLine("The answer is greater than 10.");
int b = 3;
TIPTIP
Este tutorial ensina a escrever código que examina variáveis e muda o caminho de execução com base nessas
variáveis. Escreva o código em C# e veja os resultados da compilação e da execução. O tutorial contém uma série
de lições que exploram construções de branches e loops em C#. Estas lições ensinam os princípios básicos da
linguagem C#.
Este tutorial espera que você tenha um computador que possa usar para desenvolvimento. O tutorial .NET Hello
World em 10 minutos tem instruções para configurar seu ambiente de desenvolvimento local no Windows,
Linux ou macOS. Uma visão geral dos comandos que você usará está em Familiarize-se com as ferramentas de
desenvolvimento, com links para obter mais detalhes.
Crie um diretório chamado branches-tutorial. Faça disso o diretório atual e execute o seguinte comando:
Esse comando cria um novo aplicativo de console .NET Core no diretório atual.
Abra Program.cs em seu editor favorito e substitua a linha Console.WriteLine("Hello World!"); pelo seguinte
código:
Experimente este código digitando dotnet run na sua janela do console. Você deve ver a mensagem "A resposta
é maior do que 10." impressa no console.
Modifique a declaração de b para que a soma seja inferior a 10:
Digite dotnet run novamente. Como a resposta é inferior a 10, nada é impresso. A condiçãocondição que você está
testando é falsa. Não há qualquer código para execução, porque você escreveu apenas uma das ramificações
possíveis para uma instrução if : a ramificação verdadeira.
À medida que explora C# (ou qualquer linguagem de programação), você cometerá erros ao escrever o código. O
compilador encontrará e reportará esses erros. Verifique atentamente a saída do erro e o código que gerou o erro. O erro
do compilador geralmente pode ajudá-lo a localizar o problema.
Este primeiro exemplo mostra o poder dos tipos if e Booliano. Um Booliano é uma variável que pode ter um
dos dois valores: true ou false . C# define um tipo especial, bool para variáveis Boolianas. A instrução if
verifica o valor de um bool . Quando o valor é true , a instrução após if é executada. Caso contrário, é
https://github.com/dotnet/docs.pt-br/blob/live/docs/csharp/tutorials/intro-to-csharp/branches-and-loops-local.md
https://dotnet.microsoft.com/learn/dotnet/hello-world-tutorial/intro
Faça if e else funcionam juntas
int a = 5;
int b = 3;
if (a + b > 10)
 Console.WriteLine("The answer is greater than 10");
else
 Console.WriteLine("The answer is not greater than 10");
IMPORTANTIMPORTANT
int a = 5;
int b = 3;
if (a + b > 10)
{
 Console.WriteLine("The answer is greater than 10");
}
else
{
 Console.WriteLine("The answer is not greater than 10");
}
TIPTIP
ignorada.
Esse processo de verificação de condições e execução de instruções com base nessas condições é muito eficiente.
Para executar um código diferente nos branches true e false, crie um branch else que será executado quando a
condição for false. Experimente isto. Adicione as duas últimas linhas do código abaixo ao seu método Main
(você já deve ter os quatro primeiros):
A instrução após a palavra-chave else é executada somente quando a condição que estiver sendo testada for 
false . A combinação de if e else com condições Boolianas fornece todos os recursos que você precisa para
lidar com uma condição true e false .
O recuo sob as instruções if e else é para leitores humanos. A linguagem C# não considera recuos ou espaços em
branco como significativos. A instrução após a palavra-chave if ou else será executada com base na condição. Todos
os exemplos neste tutorial seguem uma prática comum para recuar linhas com base no fluxo de controle de instruções.
Como o recuo não é significativo, você precisa usar { e } para indicar quando você quer que mais de uma
instrução faça parte do bloco executado condicionalmente. Os programadores em C# normalmente usam essas
chaves em todas as cláusulas if e else . O exemplo a seguir é igual ao que você acabou de criar. Modifique o
código acima para coincidir com o código a seguir :
No restante deste tutorial, todos os exemplos de código incluem as chaves, seguindo as práticas aceitas.
Você pode testar condições mais complicadas. Adicione o seguinte código ao seu método Main após o código
que você escreveu até agora:
int c = 4;
if ((a + b + c > 10) && (a == b))
{
 Console.WriteLine("The answer is greater than 10");
 Console.WriteLine("And the first number is equal to the second");
}
else
{
 Console.WriteLine("The answer is not greater than 10");
 Console.WriteLine("Or the first number is not equal to the second");
}
if ((a + b + c > 10) || (a == b))
{
 Console.WriteLine("The answer is greater than 10");
 Console.WriteLine("Or the first number is equal to the second");
}
else
{
 Console.WriteLine("The answer is not greater than 10");
 Console.WriteLine("And the first number is not equal to the second");
}
O símbolo == testa a igualdade. Usar == distingue o teste de igualdade de atribuição, que você viu em a = 5 .
O && representa "e". Isso significa que as duas condições devem ser verdadeiras para executar a instrução no
branch verdadeiro. Estes exemplos também mostram que você pode ter várias instruções em cada branch
condicional, desde que você coloque-as entre { e } .
Você também pode usar || para representar "ou". Adicione o código a seguir após o que você escreveu até o
momento:
Modifique os valores de a , b e c e alterne entre && e || para explorar. Você obterá mais compreensão de
como os operadores && e || funcionam.
Você terminou a primeira etapa. Antes de iniciar a próxima seção, vamos passar o código atual para um método
separado. Isso facilita o começo do trabalho com um exemplo novo. Renomeie seu método Main como 
ExploreIf e escreva um novo método Main que chama ExploreIf . Quando você terminar, seu código deverá
parecer com isto:
using System;
namespace BranchesAndLoops
{
 class Program
 {
 static void ExploreIf()
 {
 int a = 5;
 int b = 3;
 if (a + b > 10)
 {
 Console.WriteLine("The answer is greater than 10");
 }
 else
 {
 Console.WriteLine("The answer is not greater than 10");
 }
 int c = 4;
 if ((a + b + c > 10) && (a > b))
 {
 Console.WriteLine("The answer is greater than 10");
 Console.WriteLine("And the first number is greater than the second");
 }
 else
 {
 Console.WriteLine("The answer is not greater than 10");
 Console.WriteLine("Or the first number is not greater than the second");
 }
 if ((a + b + c > 10) || (a > b))
 {
 Console.WriteLine("The answer is greater than 10");
 Console.WriteLine("Or the first number is greater than the second");
 }
 else
 {
 Console.WriteLine("The answer is not greater than 10");
 Console.WriteLine("And the first number is not greater than the second");
 }
 }
 static void Main(string[] args)
 {
 ExploreIf();
 }
 }
}
//ExploreIf();
Use loops para repetir operações
Comente a chamada para ExploreIf() . Isso tornará a saída menos congestionada enquanto você trabalha nesta
seção:
O // inicia um comentár iocomentár io em C#. Os comentários são qualquer texto que você queira manter em seu código-
fonte, mas não queria executar como código. O compilador não gera qualquer código executável a partir dos
comentários.
Nesta seção, você usa loopsloops repetir as instruções. Tente este código em seu método Main :
int counter = 0;
while (counter < 10)
{
 Console.WriteLine($"Hello World! The counter is {counter}");counter++;
}
IMPORTANTIMPORTANT
int counter = 0;
do
{
 Console.WriteLine($"Hello World! The counter is {counter}");
 counter++;
} while (counter < 10);
Trabalhar com o loop for
for (int index = 0; index < 10; index++)
{
 Console.WriteLine($"Hello World! The index is {index}");
}
A instrução while verifica uma condição e executa a instrução, ou bloco de instruções, após o while . Ela verifica
repetidamente a condição e executa essas instruções até que a condição seja falsa.
Há outro operador novo neste exemplo. O ++ após a variável counter é o operador incrementincrement. Ele adiciona 1
ao valor de counter e armazena esse valor na variável counter .
Verifique se a condição de loop while muda para false ao executar o código. Caso contrário, crie um loop infinitoloop infinito, para
que seu programa nunca termine. Isso não é demonstrado neste exemplo, porque você tem que forçar o programa a
encerrar usando CTRL-CCTRL-C ou outros meios.
O loop while testa a condição antes de executar o código seguindo while . O loop do ... while executa o
código primeiro e, em seguida, verifica a condição. O loop do while é mostrado no código a seguir :
Esse loop do e o loop while anterior produzem a mesma saída.
O loop forfor é usado normalmente em C#. Tente este código em seu método Main():
Ele faz o mesmo trabalho que o loop while e o loop do que você já usou. A instrução for tem três partes que
controlam o modo como ela funciona.
A primeira parte é o int index = 0; para index inicializadorinicializador : declara que é 0 a variável loop, e define seu
valor inicial para .
A parte do meio index < 10 é a for condição paracondição para: declara que este loop continua a ser executado desde que
o valor do contador seja menor que 10.
A parte final é o index++ para iteratorpara iterator : especifica como modificar a for variável loop após a execução do
bloco após a declaração. Aqui, ela especifica que index deve ser incrementado com 1 sempre que o bloco for
executado.
Experimente você mesmo. Tente o seguinte:
Altere o inicializador para iniciar em um valor diferente.
Combinar branches e loops
Altere a condição para parar em um valor diferente.
Quando terminar, vamos escrever um código para usar o que você aprendeu.
Agora que você viu a instrução if e as construções de loop na linguagem C#, verifique se você pode escrever o
código C# para encontrar a soma de todos os inteiros de 1 a 20 divisíveis por 3. Veja algumas dicas:
O operador % retorna o restante de uma operação de divisão.
A instrução if retorna a condição para ver se um número deve ser parte da soma.
O loop for pode ajudar você a repetir uma série de etapas para todos os números de 1 a 20.
Tente você mesmo. Depois verifique como você fez. Você deve obter 63 como resposta. Veja uma resposta
possível exibindo o código completo no GitHub.
Você concluiu o tutorial "branches e loops".
Continue com o tutorial Matrizes e coleções em seu próprio ambiente de desenvolvimento.
Saiba mais sobre esses conceitos nestes tópicos:
Instrução if e else
Enquanto declaração
Instrução do
Para declaração
https://github.com/dotnet/samples/tree/master/csharp/branches-quickstart/Program.cs#L46-L54
Saiba como gerenciar coleções de dados usando o
tipo de lista genérico
18/03/2020 • 9 minutes to read • Edit Online
Um exemplo de lista básica
using System;
using System.Collections.Generic;
namespace list_tutorial
{
 class Program
 {
 static void Main(string[] args)
 {
 var names = new List<string> { "<name>", "Ana", "Felipe" };
 foreach (var name in names)
 {
 Console.WriteLine($"Hello {name.ToUpper()}!");
 }
 }
 }
}
Modificar conteúdo da lista
Este tutorial de introdução fornece uma introdução à linguagem C# e os conceitos básicos da classe List<T>.
Este tutorial espera que você tenha um computador que possa usar para desenvolvimento. O tutorial .NET Hello
World em 10 minutos tem instruções para configurar seu ambiente de desenvolvimento local no Windows,
Linux ou macOS. Uma visão geral de comandos que você usará está em Familiarizar-se com as ferramentas de
desenvolvimento, com links para obter mais detalhes.
Crie um diretório chamado list-tutorial. Torne-o o diretório atual e execute dotnet new console .
Abra Program.cs em seu editor favorito e substitua o código existente pelo seguinte:
Substitua <name> pelo seu nome. Salve o Program.cs. Digite dotnet run na janela de console para testá-lo.
Você criou uma lista de cadeias de caracteres, adicionou três nomes a essa lista e imprimiu os nomes em
MAIÚSCULAS. Você está usando conceitos que aprendeu em tutoriais anteriores para executar um loop pela
lista.
O código para exibir nomes utiliza o recurso de interpolação de cadeia de caracteres. Quando você precede um 
string com o caractere $ , pode inserir o código C# na declaração da cadeia de caracteres. A cadeia de
caracteres real substitui esse código C# pelo valor gerado. Neste exemplo, ela substitui o {name.ToUpper()} por
cada nome, convertido em letras maiúsculas, pois você chamou o método ToUpper.
Vamos continuar explorando.
A coleção que você criou usa o tipo List<T>. Esse tipo armazena sequências de elementos. Especifique o tipo dos
elementos entre os colchetes.
Um aspecto importante desse tipo List<T> é que ele pode aumentar ou diminuir, permitindo que você adicione
https://github.com/dotnet/docs.pt-br/blob/live/docs/csharp/tutorials/intro-to-csharp/arrays-and-collections.md
https://docs.microsoft.com/dotnet/api/system.collections.generic.list-1
https://dotnet.microsoft.com/learn/dotnet/hello-world-tutorial/intro
https://docs.microsoft.com/dotnet/api/system.string.toupper
https://docs.microsoft.com/dotnet/api/system.collections.generic.list-1
https://docs.microsoft.com/dotnet/api/system.collections.generic.list-1
Console.WriteLine();
names.Add("Maria");
names.Add("Bill");
names.Remove("Ana");
foreach (var name in names)
{
 Console.WriteLine($"Hello {name.ToUpper()}!");
}
Console.WriteLine($"My name is {names[0]}");
Console.WriteLine($"I've added {names[2]} and {names[3]} to the list");
Console.WriteLine($"The list has {names.Count} people in it");
Pesquisar e classificar listas
var index = names.IndexOf("Felipe");
if (index == -1)
{
 Console.WriteLine($"When an item is not found, IndexOf returns {index}");
}
else
{
 Console.WriteLine($"The name {names[index]} is at index {index}");
}
index = names.IndexOf("Not Found");
if (index == -1)
{
 Console.WriteLine($"When an item is not found, IndexOf returns {index}");
}
else
{
 Console.WriteLine($"The name {names[index]} is at index {index}");
}
ou remova elementos. Adicione este código antes do } de fechamento no método Main :
Você adicionou mais dois nomes ao final da lista. Também removeu um. Salve o arquivo e digite dotnet run
para testá-lo.
O List<T> também permite fazer referência a itens individuais por índiceíndice. Coloque o índice entre os tokens [ e 
] após o nome da lista. C# usa 0 para o primeiro índice. Adicione este código diretamente abaixo do código que
você acabou de adicionar e teste-o:
Você não pode acessar um índice além do fim da lista. Lembre-se de que os índices começam com 0, portanto, o
maior índice válido é uma unidade a menos do que o número de itens na lista. Você pode verificar há quanto
tempo a lista está usando a propriedade Count. Adicione o código a seguir ao final do método Main:
Salve o arquivo e digite dotnet run novamente para ver os resultados.
Nossos exemplos usam listas relativamente pequenas, mas seus aplicativos podem criar listas com muitos
outros elementos, chegando, às vezes, a milhares. Para localizar elementos nessas coleções maiores, pesquise
por itens diferentes na lista. O método IndexOf procura um item e retorna o índice do item. Adicione este código
à parte inferior de seu método Main :
https://docs.microsoft.com/dotnet/api/system.collections.generic.list-1https://docs.microsoft.com/dotnet/api/system.collections.generic.list-1.count
https://docs.microsoft.com/dotnet/api/system.collections.generic.list-1.indexof
names.Sort();
foreach (var name in names)
{
 Console.WriteLine($"Hello {name.ToUpper()}!");
}
Os itens em sua lista também podem ser classificados. O método Sort classifica todos os itens na lista na ordem
normal (em ordem alfabética, no caso de cadeias de caracteres). Adicione este código à parte inferior de nosso
método Main :
Salve o arquivo e digite dotnet run para experimentar a versão mais recente.
Antes de iniciar a próxima seção, vamos passar o código atual para um método separado. Isso facilita o começo
do trabalho com um exemplo novo. Renomeie seu método Main como WorkingWithStrings e escreva um novo
método Main que chama WorkingWithStrings . Quando você terminar, seu código deverá parecer com isto:
https://docs.microsoft.com/dotnet/api/system.collections.generic.list-1.sort
using System;
using System.Collections.Generic;
namespace list_tutorial
{
 class Program
 {
 static void Main(string[] args)
 {
 WorkingWithStrings();
 }
 static void WorkingWithStrings()
 {
 var names = new List<string> { "<name>", "Ana", "Felipe" };
 foreach (var name in names)
 {
 Console.WriteLine($"Hello {name.ToUpper()}!");
 }
 Console.WriteLine();
 names.Add("Maria");
 names.Add("Bill");
 names.Remove("Ana");
 foreach (var name in names)
 {
 Console.WriteLine($"Hello {name.ToUpper()}!");
 }
 Console.WriteLine($"My name is {names[0]}");
 Console.WriteLine($"I've added {names[2]} and {names[3]} to the list");
 Console.WriteLine($"The list has {names.Count} people in it");
 var index = names.IndexOf("Felipe");
 if (index == -1)
 {
 Console.WriteLine($"When an item is not found, IndexOf returns {index}");
 }
 else
 {
 Console.WriteLine($"The name {names[index]} is at index {index}");
 }
 index = names.IndexOf("Not Found");
 if (index == -1)
 {
 Console.WriteLine($"When an item is not found, IndexOf returns {index}");
 }
 else
 {
 Console.WriteLine($"The name {names[index]} is at index {index}");
 }
 names.Sort();
 foreach (var name in names)
 {
 Console.WriteLine($"Hello {name.ToUpper()}!");
 }
 }
 }
}
Listas de outros tipos
var fibonacciNumbers = new List<int> {1, 1};
var previous = fibonacciNumbers[fibonacciNumbers.Count - 1];
var previous2 = fibonacciNumbers[fibonacciNumbers.Count - 2];
fibonacciNumbers.Add(previous + previous2);
foreach (var item in fibonacciNumbers)
 Console.WriteLine(item);
TIPTIP
Desafio
Desafio concluído
Você usou o tipo string nas listas até o momento. Vamos fazer List<T> usar um tipo diferente. Vamos compilar
um conjunto de números.
Adicione o seguinte à parte inferior do novo método Main :
Isso cria uma lista de números inteiros e define os primeiros dois inteiros como o valor 1. Estes são os dois
primeiros valores de uma sequência Fibonacci, uma sequência de números. Cada número Fibonacci seguinte é
encontrado considerando a soma dos dois números anteriores. Adicione este código:
Salve o arquivo e digite dotnet run para ver os resultados.
Para se concentrar apenas nesta seção, comente o código que chama WorkingWithStrings(); . Coloque apenas dois
caracteres / na frente da chamada, desta forma: // WorkingWithStrings(); .
Veja se você consegue combinar alguns dos conceitos desta lição e de lições anteriores. Expanda o que você
compilou até o momento com números Fibonacci. Tente escrever o código para gerar os 20 primeiros números
na sequência. (Como uma dica, o vigésimo número Fibonacci é 6765.)
Veja um exemplo de solução analisando o código de exemplo finalizado no GitHub.
Com cada iteração do loop, você está pegando os últimos dois inteiros na lista, somando-os e adicionando esse
valor à lista. O loop será repetido até que você tenha adicionado 20 itens à lista.
Parabéns, você concluiu o tutorial de lista. Continue com o tutorial Introdução às classes em seu próprio
ambiente de desenvolvimento.
Saiba mais sobre como trabalhar com o tipo List no tópico Guia de .NET em coleções. Você também aprenderá
muitos outros tipos de coleção.
https://docs.microsoft.com/dotnet/api/system.collections.generic.list-1
https://github.com/dotnet/samples/tree/master/csharp/list-quickstart/Program.cs#L13-L23
https://docs.microsoft.com/pt-br/dotnet/standard/index
https://docs.microsoft.com/pt-br/dotnet/standard/collections/index
minutes to read • Edit Online
Criar o aplicativo
using System;
namespace classes
{
 class Program
 {
 static void Main(string[] args)
 {
 Console.WriteLine("Hello World!");
 }
 }
}
Definir o tipo de conta bancária
Este tutorial espera que você tenha um computador que possa usar para desenvolvimento. O tutorial .NET Hello
World em 10 minutos tem instruções para configurar seu ambiente de desenvolvimento local no Windows, Linux
ou macOS. Uma visão geral dos comandos que você usará está em Familiarize-se com as ferramentas de
desenvolvimento, com links para obter mais detalhes.
Usando uma janela de terminal, crie um diretório chamado classes. Você compilará o aplicativo nesse diretório.
Altere para esse diretório e digite dotnet new console na janela do console. Esse comando cria o aplicativo. Abra
Program.cs. O resultado deve ser assim:
Neste tutorial, você criará novos tipos que representam uma conta bancária. Normalmente, os desenvolvedores
definem cada classe em um arquivo de texto diferente. Isso facilita o gerenciamento à medida que o tamanho do
programa aumenta. Crie um novo arquivo chamado BankAccount.cs no diretório classes.
Esse arquivo conterá a definição de uma conta bancáriaconta bancária . A programação Orientada a Objeto organiza o código
por meio da criação de tipos na forma de classesclasses . Essas classes contêm o código que representa uma entidade
específica. A classe BankAccount representa uma conta bancária. O código implementa operações específicas por
meio de métodos e propriedades. Neste tutorial, a conta bancária dá suporte a este comportamento:
1. Ela tem um número com 10 dígitos que identifica exclusivamente a conta bancária.
2. Ela tem uma cadeia de caracteres que armazena o nome ou os nomes dos proprietários.
3. O saldo pode ser recuperado.
4. Ela aceita depósitos.
5. Ele aceita saques.
6. O saldo inicial deve ser positivo.
7. Os saques não podem resultar em um saldo negativo.
Você pode começar criando as noções básicas de uma classe que define esse comportamento. Ela deve ter esta
aparência:
https://github.com/dotnet/docs.pt-br/blob/live/docs/csharp/tutorials/intro-to-csharp/introduction-to-classes.md
https://dotnet.microsoft.com/learn/dotnet/hello-world-tutorial/intro
using System;
namespace classes
{
 public class BankAccount
 {
 public string Number { get; }
 public string Owner { get; set; }
 public decimal Balance { get; }
 public void MakeDeposit(decimal amount, DateTime date, string note)
 {
 }
 public void MakeWithdrawal(decimal amount, DateTime date, string note)
 {
 }
 }
}
Abrir uma nova conta
public BankAccount(string name, decimal initialBalance)
{
 this.Owner = name;
 this.Balance = initialBalance;
}
var account = new BankAccount("<name>", 1000);
Console.WriteLine($"Account {account.Number} was created for {account.Owner} with {account.Balance} initial 
balance.");
Antes de continuar, vamos dar uma olhada no que você compilou. A declaração namespace fornece