Enregistrez RavenDb en utilisant Autofac?

Question

Quelqu'un peut-il me guider sur la façon dont je pourrais enregistrer RavenDB en utilisant Autofac?

builder.Register<DocumentStore>( .. après quoi?

Answer 1

Voici un programme de console exemple qui illustre non seulement comment câbler le magasin de documents, mais aussi comment le configurer de sorte que vous pouvez simplement injecter votre session de document:

using System.Threading.Tasks; 
using Autofac; 
using Raven.Client; 
using Raven.Client.Document; 

namespace ConsoleApplication1 
{ 
    internal class Program 
    { 
    private static void Main() 
    { 
     var builder = new ContainerBuilder(); 

     // Register the document store as single instance, 
     // initializing it on first use. 
     builder.Register(x => 
     { 
      var store = new DocumentStore { Url = "http://localhost:8080" }; 
      store.Initialize(); 
      return store; 
     }) 
      .As<IDocumentStore>() 
      .SingleInstance(); 

     // Register the session, opening a new session per lifetime scope. 
     builder.Register(x => x.Resolve<IDocumentStore>().OpenSession()) 
      .As<IDocumentSession>() 
      .InstancePerLifetimeScope() 
      .OnRelease(x => 
      { 
       // When the scope is released, save changes 
       // before disposing the session. 
       x.SaveChanges(); 
       x.Dispose(); 
      }); 

     // Register other services as you see fit 
     builder.RegisterType<OrderService>().As<IOrderService>(); 

     var container = builder.Build(); 


     // Simulate some activity. 5 users are placing orders simultaneously. 
     Parallel.For(0, 5, i => 
     { 
      // Each user gets their own scope. In the real world this would be 
      // a new inbound call, such as a web request, and you would let an 
      // autofac plugin create the scope rather than creating it manually. 
      using (var scope = container.BeginLifetimeScope()) 
      { 
      // Let's do it. Again, in the real world you would just inject 
      // your service to something already wired up, like an MVC 
      // controller. Here, we will resolve the service manually. 
      var orderService = scope.Resolve<IOrderService>(); 
      orderService.PlaceOrder(); 
      } 
     }); 
    } 
    } 

    // Define the order service 
    public interface IOrderService 
    { 
    void PlaceOrder(); 
    } 

    public class OrderService : IOrderService 
    { 
    private readonly IDocumentSession _session; 

    // Note how the session is being constructor injected 
    public OrderService(IDocumentSession session) 
    { 
     _session = session; 
    } 

    public void PlaceOrder() 
    { 
     _session.Store(new Order { Description = "Stuff", Total = 100.00m }); 

     // we don't have to call .SaveChanges() here because we are doing it 
     // globally for the lifetime scope of the session. 
    } 
    } 

    // Just a sample of something to save into raven. 
    public class Order 
    { 
    public string Id { get; set; } 
    public string Description { get; set; } 
    public decimal Total { get; set; } 
    } 
} 

Notez que DocumentStore est unique instance, mais DocumentSession est une instance par étendue de durée de vie. Pour cet exemple, je crée manuellement les étendues de durée de vie et je le fais en parallèle, en simulant comment 5 utilisateurs différents peuvent passer des commandes en même temps. Ils auront chacun leur propre session.

La mise en place de SaveChanges dans l'événement OnRelease est facultative, mais vous évitera d'avoir à le mettre dans chaque service.

Dans le monde réel, il peut s'agir d'une application Web ou d'une application de bus de service, auquel cas votre session doit porter sur la requête Web unique ou la durée de vie du message, respectivement.

Si vous utilisez ASP.Net WebApi, vous devez récupérer le package Autofac.WebApi de NuGet et utiliser leur méthode .InstancePerApiRequest(), qui crée automatiquement l'étendue de durée de vie appropriée.