Update dependency-injection.md

aspnetcore/fundamentals/dependency-injection.md

@@ -17,17 +17,19 @@ ms.custom: H1Hack27Feb2017
 
 <a name=fundamentals-dependency-injection></a>
 
-By [Steve Smith](https://ardalis.com/) and [Scott Addie](https://scottaddie.com)
+Por [Steve Smith](https://ardalis.com/) e [Scott Addie](https://scottaddie.com)
 
-ASP.NET Core is designed from the ground up to support and leverage dependency injection. ASP.NET Core applications can leverage built-in framework services by having them injected into methods in the Startup class, and application services can be configured for injection as well. The default services container provided by ASP.NET Core provides a minimal feature set and is not intended to replace other containers.
+O ASP.NET Core foi desenvolvido desde a base até o topo para suportar proporcionar a injeção de dependência. As aplicações ASP.NET Core podem usufluir de serviços de framework prontos por os terem injetado em seus métodos na classe Startup, e serviços de aplicação também podem ser configurados para injeção. O recipiente padrão de serviços fornecido pelo ASP.NET Core proporciona um conjunto mínimo de funcinalidades e não tem a intenção de substituir outros recipientes.
 
-[View or download sample code](https://github.com/aspnet/Docs/tree/master/aspnetcore/fundamentals/dependency-injection/sample)
+[Visualizar ou baixar código demonstrativo](https://github.com/aspnet/Docs/tree/master/aspnetcore/fundamentals/dependency-injection/sample)
 
-## What is Dependency Injection?
+## O que é Injeção de Dependência?
 
-Dependency injection (DI) is a technique for achieving loose coupling between objects and their collaborators, or dependencies. Rather than directly instantiating collaborators, or using static references, the objects a class needs in order to perform its actions are provided to the class in some fashion. Most often, classes will declare their dependencies via their constructor, allowing them to follow the [Explicit Dependencies Principle](http://deviq.com/explicit-dependencies-principle/). This approach is known as "constructor injection".
+Injeção de Dependência, abreviado em inglês como DI, é uma técnica para alcançar baixo acoplamento entre objetos e seus colaboradores, ou dependências. Em vez de instanciar diretamente colaboradores, ou usar referências estáticas, os objetos que a classe precisa para executar suas ações são fornecidos para a ela da mesma forma. Mais frequentemente, as classes vã declarar suas dependências através de seus construtores, permitindo a eles seguir o [Princípio das Dependências Explícitas](http://deviq.com/explicit-dependencies-principle/). Esta abordagem é conhecida como "Injeção de Construtor".
 
-When classes are designed with DI in mind, they are more loosely coupled because they do not have direct, hard-coded dependencies on their collaborators. This follows the [Dependency Inversion Principle](http://deviq.com/dependency-inversion-principle/), which states that *"high level modules should not depend on low level modules; both should depend on abstractions."* Instead of referencing specific implementations, classes request abstractions (typically `interfaces`) which are provided to them when the class is constructed. Extracting dependencies into interfaces and providing implementations of these interfaces as parameters is also an example of the [Strategy design pattern](http://deviq.com/strategy-design-pattern/).
+Quando classes são desenvolvidas com o DI em mente, elas são fracamente acopladas porque elas não possuem diretamente dependências hard-coded em seus colaboradores. Isto segue o [Princípio da Inversão de Dependência](http://deviq.com/dependency-inversion-principle/), que afirma que *"módulos de alto nível não devem depender de módulos de baixo nível; ambos devem depender de abstrações."* Em vez de referênciar implementações específicas, classes requerem abstrações (geralmente `interfaces`) que são fornecidas no momento da construção das classes. Extração de dependências em interfaces e fornecimento de implementações destas interfaces como parâmetros é também um exemplo do [Padrão de Design Estratégia](http://deviq.com/strategy-design-pattern/).
+
+Quando o sistema é desenvolvido usando DI, com muitas classes requisitando suas dependências através de seus construtores (ou propriedades), é útil ter um classe dedicada para criar estas classes com suas dependências associadas. Estas classes são referenciadas como *containers* (recipientes), ou mais especificamente, recipientes de [Inversão de Controle, sigla em inglês (IoC)](http://deviq.com/inversion-of-control/) ou de Injeção de Dependência (DI). Um recipiente é essencialmente uma fábrica que é responsável por fornecer instâncias de tipos que são requisitadas. Se um determinado tipo for declarado 
 
 When a system is designed to use DI, with many classes requesting their dependencies via their constructor (or properties), it's helpful to have a class dedicated to creating these classes with their associated dependencies. These classes are referred to as *containers*, or more specifically, [Inversion of Control (IoC)](http://deviq.com/inversion-of-control/) containers or Dependency Injection (DI) containers. A container is essentially a factory that is responsible for providing instances of types that are requested from it. If a given type has declared that it has dependencies, and the container has been configured to provide the dependency types, it will create the dependencies as part of creating the requested instance. In this way, complex dependency graphs can be provided to classes without the need for any hard-coded object construction. In addition to creating objects with their dependencies, containers typically manage object lifetimes within the application.