Injeção de dependência com ASP.NET Core e Couchbase

First, you’ll need a Couchbase Server cluster running. You can:

Em seguida, você precisará criar um balde in Couchbase. This can be the “travel-sample” bucket that comes with Couchbase, or a bucket that you create yourself.

If you are using Couchbase Server 5.0, you’ll also need to create a user. Give that user Cluster Admin permission, and give it the same name as the bucket, just to keep things simple if you are following along.

O Couchbase.Extensions (GitHub) project aims to make working with Couchbase Server and ASP.NET Core simpler. Dependency Injection is just one of these extensions.

You can add it to your ASP.NET Core project with NuGet:

(Version 1.0.2 is the latest version at the time of writing).

Next, you’ll need to make changes to your Inicialização classe em Startup.cs.

In the blog post on caching, I hard-coded the configuration:

This is fine for demos and blog posts, but you’ll likely want to use a configuration file for a production project.

Assuming you’re using the default Configurações do aplicativo.json, update that file to add a Couchbase section:

By making a “Couchbase” section, the dependency injection module will read right from the appsettings.json text file.

After dependency injection is setup, you can start injecting useful objects into your classes. You might inject them into Controllers, services, or repositories.

Here’s an example of injecting into HomeController:

Next, let’s do a simple Obter operation on a well-known document in “travel-sample”. This token usage of the Couchbase .NET SDK will show dependency injection in action. I’ll make a change to the generated Sobre action method. In that method, it will retrieve a route document and write out the equipment number.

And the result is:

Success! Dependency injection worked, and we’re ready to use a Couchbase bucket.

If you aren’t using “travel-sample”, use a key from your own bucket.

You can use dependency injection for a single bucket instead of having to specify the name each time.

Start by creating an interface that implements INamedBucketProvider. Leave it empty. Here’s an example:

Then, back in Startup.cs, map this interface to a bucket using AddCouchbaseBucket:

Now, the ITravelSampleBucketProvider gets injected instead of the more general provider.

Until this point, we’ve only used dependency injection on Controllers. Dependency injection starts to pay dividends with more complex, deeper object graphs.

As an example, imagine a service class that uses a Couchbase bucket, but also uses an email service.

Next, let’s use this service in a controller (aka making it a dependency). But notice that the controller is not directly using either the bucket or the email service.

If I were to instantiate ComplexService manually, I would have to instantiate at least two other objects. It would look something like: new ComplexService(new BucketProvider(), new MyEmailService(). That’s a lot that I have to keep track of, and if any dependencies change, it’s a lot of manual maintenance.

Instead, I can have ASP.NET Core use dependency injection to do all this for me. Back in Inicialização:

Now, ASP.NET Core knows how to instantiate:

Finally, when ApproveController is instantiated, ASP.NET Core will know how to do it. It will create ComplexService by instantiating MyEmailService e ComplexService. It will inject ComplexService automatically into `ApproveController’s constructor. The end result:

For the complete example, be sure to check out the source code that accompanies this blog post on GitHub.

Don’t forget to clean up after yourself. When the ASP.NET Core application is stops, release any resources that the Couchbase .NET SDK is using. In the Configurar method in Startup, add a parameter of type IApplicationLifetime:

Within that Configurar method, setup an ApplicationStopped event:

Dependency injection is a rich subject. Entire books have been written about it and its benefits to your application. This blog post just scratched the surface and didn’t even cover the testability benefits.

Couchbase.Extensions.DependencyInjection makes it easier to inject Couchbase into ASP.NET Core.

If you have questions or comments, make sure to check out the Repositório do GitHub ou o Fóruns do SDK do Couchbase .NET.

And please reach out to me with questions by leaving a comment below or finding me on Twitter @mgroves.