Translate Chapter/your first application (#20)

Tranlated the first chapter.

chapters/your-first-application/README.md

@@ -1,10 +1,10 @@
-# Your first application
-Ready to build your first web app with ASP.NET Core? You'll need to gather a few things first:
+# A primeira aplicação
+Preparado para construir o seu primeiro web app utilizando ASP.NET Core? Antes de iniciar precisamos de algumas ferramentas:
 
-**Your favorite code editor.** You can use Atom, Sublime, Notepad, or whatever editor you prefer writing code in. If you don't have a favorite, give Visual Studio Code a try. It's a free, cross-platform code editor that has rich support for writing C#, JavaScript, HTML, and more. Just search for "download visual studio code" and follow the instructions.
+**Um editor de código** Você pode utilizar Atom, Sublime, Notepad, ou qualquer editor de sua preferencia. Se você não tem nenhum editor favorito, tente utilizar o Visual Studio Code. É de graça, tem suporte a multi-plataforma com um poderoso suporte para escrever C#, JavaScript, HTML, e muito mais. Procure por "download visual studio code" em qualquer buscador e siga as instruções.
 
-If you're on Windows, you can also use Visual Studio to build ASP.NET Core applications. You'll need Visual Studio 2017 version 15.3 or later (the free Community Edition is fine). Visual Studio has great code completion and refactoring support for C#, although Visual Studio Code is close behind.
+Se você está utilizando Windows, voce pode também instalar o Visual Studio para construir aplicações ASP.NET Core. Você vai precisar do Visual Studio 2017 versão 15.3 ou a mais recente (a versão Community é gratis e funciona perfeitamente). O Visual Studio possui um ótimo auto complete e suporte a refatoração para o C#, apesar de que o Visual Studio Code também cumpre bem o papel.
 
-**The .NET Core SDK.** Regardless of the editor or platform you're using, you'll need to install the .NET Core SDK, which includes the runtime, base libraries, and command line tools you need for building ASP.NET Core applications. The SDK can be installed on Windows, Mac, or Linux.
+**O SDK do .NET Core** Independente de qual editor ou plataforma você está utilizando, é necessario instalar o SDK do .NET Core, com ele você vai instalar o runtime, bibliotecas padrões, e ferramentas de linha de comando que você vai precisar para construir as aplicações ASP.NET Core. O SDK pode ser instalado no Windows, Mac ou Linux.
 
-Once you've decided on an editor, you'll need to get the SDK.
+Quando você decidir qual o editor, você vai precisar instalar o SDK.

chapters/your-first-application/create-aspnetcore-project.md

@@ -1,29 +1,29 @@
-## Create an ASP.NET Core project
-If you're still in the directory you created for the Hello World sample, move back up to your Documents or home directory:
+## Criar um projeto em ASP.NET Core
+Se voce ainda está no diretorio que criou para o exemplo Hello World, volte uma pasta acima para a sua pasta Documentos ou o diretório padrão:
 
 ```
 cd ..
 ```
 
-Next, create a new directory to store your entire project, and move into it:
+Em seguida, crie um novo diretorio para armazenar o seu projeto "TODO", e entre neste diretório:
 
 ```
 mkdir AspNetCoreTodo
 cd AspNetCoreTodo
 ```
 
-Next, create a new project with `dotnet new`, this time with some extra options:
+Em seguida, crie o seu projeto com o comando `dotnet new`, desta vez com algumas opções a mais:
 
 ```
 dotnet new mvc --auth Individual -o AspNetCoreTodo
 cd AspNetCoreTodo
 ```
 
-This creates a new project from the `mvc` template, and adds some additional authentication and security bits to the project. (I'll cover security in the *Security and identity* chapter.)
+Este comando vai criar um novo projeto com o template `mvc`, e adicionar a autenticação e segurança para o projeto. (Eu vou falar sobre segurança no capitulo *Segurança e identidade*.)
 
-> You might be wondering why you have a directory called `AspNetCoreTodo` inside another directory called `AspNetCoreTodo`. The top-level or "root" directory can contain one or more project directories. The root directory is sometimes called a **solution directory**. Later, you'll add more project directories side-by-side with the `AspNetCoreTodo` project directory, all within a single root solution directory.
+> Você deve estar se perguntando porque eu tenho um diretório chamado `AspNetCoreTodo` dentro de outro diretorio chamado `AspNetCoreTodo`. O diretório principal pode conter um ou mais diretorios de projetos, algumas vezes, ele é chamado de **diretório de solução**. Mais para frente, você vai adicionar mais diretorios de projetos, todos dentro de um diretório de soluções.
 
-You'll see quite a few files show up in the new project directory. Once you `cd` into the new directory, all you have to do is run the project:
+Você está vendo alguns arquivos dentro deste novo diretório do projeto. Tudo o que você precisa fazer para executar o projeto é:
 
 ```
 dotnet run
@@ -32,48 +32,48 @@ Now listening on: http://localhost:5000
 Application started. Press Ctrl+C to shut down.
 ```
 
-Instead of printing to the console and exiting, this program starts a web server and waits for requests on port 5000.
+Ao invés de imprimir no console e sair do programa, ele inicia um servidor web e aguarda as requisições na porta 5000.
 
-Open your web browser and navigate to `http://localhost:5000`. You'll see the default ASP.NET Core splash page, which means your project is working! When you're done, press Ctrl-C in the terminal window to stop the server.
+Abra o seu navegador e acesse a página `http://localhost:5000`. Voce vai ver a página padrão do ASP.NET Core, o que indica que o seu projeto está funcionando! Quando você quiser finalizar o servidor, pressione Ctrl-C na janela do terminal e o servidor web será finalizado.
 
-### The parts of an ASP.NET Core project
-The `dotnet new mvc` template generates a number of files and directories for you. Here are the most important things you get out of the box:
+### As partes de um projeto ASP.NET Core
+O template `dotnet new mvc` inicializa todos os arquivos e diretorios para você. Aqui está algumas informações importantes que você vai precisar:
 
-* The **Program.cs** and **Startup.cs** files set up the web server and ASP.NET Core pipeline. The `Startup` class is where you can add middleware that handles and modifies incoming requests, and serves things like static content or error pages. It's also where you add your own services to the dependency injection container (more on this later).
+* Os arquivos **Program.cs** e **Startup.cs** são responsaveis por inicializar o webserver e o pipeline do ASP.NET Core. A classe `Startup` é onde você pode adicionar o middleware que gerencia e modifica a chegada das requisições, e também provê os conteudos estaticos e as paginas de erros. É onde voce vai adicionar o seu próprio serviço para o conteiner de injeção de dependencia (vamos tratar sobre isso mais para frente).
 
-* The **Models**, **Views**, and **Controllers** directories contain the components of the Model-View-Controller (MVC) architecture. You'll explore all three in the next chapter.
+* O diretório **Models**, **Views**, e **Controllers** contém os componentes da arquitetura Model-View-Controller (MVC). Você vai conhecer os tres no próximo capitulo.
 
-* The **wwwroot** directory contains static assets like CSS, JavaScript, and image files. Files in `wwwroot` will be served as static content, and can be bundled and minified automatically.
+* O diretório **wwwroot** contém todos os arquivos estaticos, como CSS, JavaScript e as imagens. Arquivos dentro do `wwwroot` serão oferecidos como um conteudo estatico, e podem ser empacotados e minificados automaticamente.
 
-* The **appsettings.json** file contains configuration settings ASP.NET Core will load on startup. You can use this to store database connection strings or other things that you don't want to hard-code.
+* O arquivo **appsettings.json** contém todas as configurações do ASP.NET Core que serão carregadas na inicialização. Você pode utilizar para armazenar a sua string de conexão com a base de dados ou outras coisas que você não quer deixar hard-code no seu código.
 
-### Tips for Visual Studio Code
+### Dicas para o Visual Studio Code
 
-If you're using Visual Studio Code for the first time, here are a couple of helpful tips to get you started:
+Se você está utiliznado o Visual Studio Code pela primeira vez, aqui vão algumas dicas para te ajudar neste inicio:
 
-* **Open the project root folder**: In Visual Studio Code, choose File - Open or File - Open Folder. Open the `AspNetCoreTodo` folder (the root directory), not the inner project directory. If Visual Studio Code prompts you to install missing files, click Yes to add them.
+* **Abra a pasta raiz do projeto**: No Visual Studio Code, selecione Arquivo - Abrir ou Arquivo - Abrir Pasta. Abra a pasta `AspNetCoreTodo` (a pasta raiz), e não a pasta de dentro do projeto. Se o Visual Studio Code exibir uma mensagem para você instalar alguns arquivos que estão faltando, clique em Sim e adicione eles.
 
-* **F5 to run (and debug breakpoints)**: With your project open, press F5 to run the project in debug mode. This is the same as `dotnet run` on the command line, but you have the benefit of setting breakpoints in your code by clicking on the left margin:
+* **F5 para executar (e debugar os breakpoints)**: Com o seu projeto aberto, pressione F5 para executar o seu projeto em modo debug. Isso é o mesmo que `dotnet run` na linha de comando, mas você tem o beneficio de configurar os breakpoints no seu codigo clicando na margem da esquerda:
 
-![Breakpoint in Visual Studio Code](breakpoint.png)
+![Breakpoint no Visual Studio Code](breakpoint.png)
 
-* **Lightbulb to fix problems**: If your code contains red squiggles (compiler errors), put your cursor on the code that's red and look for the lightbulb icon on the left margin. The lightbulb menu will suggest common fixes, like adding a missing `using` statement to your code:
+* **Lampada para resolver os problemas**: Se o seu código contem linhas vermelhas (erros de compilação), coloque o cursor no código que está com a linha vermelha e mova o mouse para o icone de lampada na margem da esquerda. O menu vai sugerir algumas correções, como adicionar uma declaração `using` que está faltando no seu código:
 
-![Lightbulb suggestions](lightbulb.png)
+![Sugestões da Lampada](lightbulb.png)
 
-* **Compile quickly**: Use the shortcut `Command-Shift-B` or `Control-Shift-B` to run the Build task, which does the same thing as `dotnet build`.
+* **Compilar rapidamente**: Use as teclas de atalho `Command-Shift-B` ou `Control-Shift-B` para executar a tarefa de Build, isso é o mesmo que `dotnet build`.
 
-> These tips apply to Visual Studio (not Code) on Windows too. If you're using Visual Studio, you'll need to open the `.csproj` project file directly. Visual Studio will later prompt you to save the Solution file, which you should save in the root directory (the first `AspNetCoreTodo` folder). You can also create an ASP.NET Core project directly within Visual Studio using the templates in File - New Project.
+> Estas dicas aplicam também para o Visual Studio no Windows também. Se você está utilizando o Visual Studio, voce pode abrir o arquivo `.csproj` diretamente. O Visual Studio vai te perguntar para salvar o arquivo de Solução do projeto, que voce deve salvar da pasta raiz do projeto (A primeira pasta `AspNetCoreTodo`). Você pode criar um projeto ASP.NET Core diretamente do Visual Studio usando os templates que estão em Arquivo - Novo Projeto (File - New Project).
 
-### A note about Git
+### Uma nota sobre o Git
 
-If you use Git or GitHub to manage your source code, now is a good time to do `git init` and initialize a Git repository in the project root directory:
+Se voce utiliza Gi ou GitHub para gerenciar o seu código fonte, agora é uma boa hora para realizar um `git init` e inicializar o seu repositorio Git na pasta raiz do seu projeto:
 
 ```
 cd ..
 git init
 ```
 
-Make sure you add a `.gitignore` file that ignores the `bin` and `obj` directories. The Visual Studio template on GitHub's gitignore template repo (https://github.com/github/gitignore) works great.
+Não se esqueca de adicionar o arquivo `.gitignore` para não considerar as pastas `bin` e `obj`. O template do gitignore, no repositorio do Visual Studio, no GitHub(https://github.com/github/gitignore) atende perfeitamente.
 
-There's plenty more to explore, so let's dive in and start building an application!
+Há muito mais para explorar, então vamos mergulhar de cabeça e iniciar uma nova aplicação!

chapters/your-first-application/get-the-sdk.md

@@ -1,13 +1,13 @@
-## Get the SDK
-Search for "download .net core" and follow the instructions on Microsoft's download page to get the .NET Core SDK. After the SDK has finished installing, open up the Terminal (or PowerShell on Windows) and use the `dotnet` command line tool (also called a **CLI**) to make sure everything is working:
+## Instalar o SDK
+Procure por "download .net core" e siga as instruções para download e instalação do SDK do .NET Core na página da Microsoft. Quando o SDK estiver instalado, abra o seu terminal (ou PowerShell no Windows) e execute o comando `dotnet` (também conhecido como **CLI**) para garantir que tudo está funcionando:
 
 ```
 dotnet --version
 
 2.1.104
 ```
 
-You can get more information about your platform with the `--info` flag:
+Você consegue obter maiores informações sobre a sua plataforma, utilizando a flag `--info`:
 
 ```
 dotnet --info
@@ -25,4 +25,4 @@ Runtime Environment:
 (more details...)
 ```
 
-If you see output like the above, you're ready to go!
+Se o seu terminal exibiu a informação igual a acima, você está pronto para seguir em frente!

chapters/your-first-application/hello-world-in-csharp.md

@@ -1,25 +1,25 @@
-## Hello World in C# #
-Before you dive into ASP.NET Core, try creating and running a simple C# application.
+## Hello World em C# #
+Antes de aprofundarmos no ASP.NET Core, tente criar e executar uma simples aplicação C#.
 
-You can do this all from the command line. First, open up the Terminal (or PowerShell on Windows). Navigate to the location you want to store your projects, such as your Documents directory:
+Você pode executar todos os passos a seguir através da linha de comando. Primeiro, abra o Terminal (ou PowerShell no Windows). Navegue até a pasta que você quer armazenar os projetos, por exemplo, o seu diretorio de Documentos:
 
 ```
 cd Documents
 ```
 
-Use the `dotnet` command to create a new project:
+Utilize o comando `dotnet` para criar um novo projeto:
 
 ```
 dotnet new console -o CsharpHelloWorld
 ```
 
-The `dotnet new` command creates a new .NET project in C# by default. The `console` parameter selects a template for a console application (a program that outputs text to the screen). The `-o CsharpHelloWorld` parameter tells `dotnet new` to create a new directory called `CsharpHelloWorld` for all the project files. Move into this new directory:
+O comando `dotnet new` cria um novo projeto .NET em C# como padrão. O parâmetro `console` seleciona o template para um console application (um programa que exibe textos no seu terminal). O parâmetro `-o CsharpHelloWorld` diz ao comando `dotnet new` para criar um novo diretorio chamado `CsharpHelloWorld` com todos os arquivos do projeto. Entre neste diretório:
 
 ```
 cd CsharpHelloWorld
 ```
 
-`dotnet new console` creates a basic C# program that writes the text `Hello World!` to the screen. The program is comprised of two files: a project file (with a `.csproj` extension) and a C# code file (with a `.cs` extension). If you open the former in a text or code editor, you'll see this:
+`dotnet new console` cria um programa em C# básico que imprime o texto `Hello World!` no seu terminal. O programa é composto por dois arquivos: Um arquivo de projeto (com a extensão `.csproj`) e um arquivo com o código C# (com a extensão `.cs`). Se você abrir os arquivos no seu editor, você vai ver isso:
 
 **CsharpHelloWorld.csproj**
 
@@ -34,7 +34,7 @@ cd CsharpHelloWorld
 </Project>
 ```
 
-The project file is XML-based and defines some metadata about the project. Later, when you reference other packages, those will be listed here (similar to a `package.json` file for npm). You won't have to edit this file by hand very often.
+O arquivo do projeto é feito em XML e define todas as propriedades sobre o projeto. Posteriormente, quando você referenciar outros pacotes, eles serão listados aqui (muito proximo ao arquivo `package.json` do npm). Você não precisa editar este arquivo com muita frequência.
 
 **Program.cs**
 
@@ -53,14 +53,14 @@ namespace CsharpHelloWorld
 }
 ```
 
-`static void Main` is the entry point method of a C# program, and by convention it's placed in a class (a type of code structure or module) called `Program`. The `using` statement at the top imports the built-in `System` classes from .NET and makes them available to the code in your class.
+`static void Main` é o ponto de entrada de um programa C#, e por convenção ele é inserido em uma classe (um tipo de estrutura do codigo ou modulo) chamado `Program`. A declaração `using` no inicio é para importar a classe 'System' e disponibilizar para o código da sua classe.
 
-From inside the project directory, use `dotnet run` to run the program. You'll see the output written to the console after the code compiles:
+Dentro do diretorio do seu projeto, execute o comando `dotnet run` para executar o seu programa. Você vai ver escrito no seu console após a execução do programa:
 
 ```
 dotnet run
 
 Hello World!
 ```
 
-That's all it takes to scaffold and run a .NET program! Next, you'll do the same thing for an ASP.NET Core application.
+Isso é tudo para criar a estrutura e executar um programa em .NET! À seguir, você vai fazer exatamente a mesma coisa para uma aplicação ASP.NET Core.