Alternativa a HttpContext quando si utilizza Ninject con un servizio WCF ospitato nella stava usando MSMQ vincolante

Question

Ho un servizio WCF in un modo con il MSMQ Binding che si attiva utilizzando Windows servizio Attivazione in IIS 7.0.

Sono un grande fan su Ninject così ho usato l'estensione Ninject per WCF, che per un tipico servizio WCF HTTP sarebbe grande lavoro.

Tuttavia, nel settore dei servizi Attiva WAS non c'è gasdotto HTTP, quindi non posso utilizzare InRequestScope quando si associa i miei tipi perché System.Web.HttpContext.Current è nullo. Sto lottando per trovare un'alternativa quando si utilizza è che mi darà quello che voglio. attributo mode AspCompatibility non funziona in questo modo sia.

Ho pensato InThreadScope potrebbe funzionare, ma il servizio è stato creato in un thread separato di quello che viene eseguita in.

Quindi, in pratica ho bisogno l'equivalente del HttpContext per WCF + era di portata miei oggetti a livello di richiesta. C'è qualche oggetto statico in questo mondo che avrebbe funzionato allo stesso modo o Qualcun altro ha qualche idea su qualcosa che posso incidere insieme?

Answer 1

ho implementato le mie estensioni di WCF per Ninject 2.0 prima sapevo che c'era un questo su GitHub. La mia implementazione leggermente diverso, ma mi è venuto su con una soluzione di scoping oggetti:

using System;
using Ninject.Activation;

namespace Ninject.Contrib.Wcf {
  /// <summary>
  /// Defines Scope Callbacks for WCF Context.
  /// </summary>
  public class NinjectWcfScopeCallbacks {
    /// <summary>
    /// Defines WCF Context scope.
    /// </summary>
    public static readonly Func<IContext, object> WcfContext =
      ctx => (System.ServiceModel.OperationContext.Current != null
                ? System.ServiceModel.OperationContext.Current.
                    InstanceContext.
                    Extensions.Find<NinjectInstanceContext>()
                : null);

    /// <summary>
    /// Defines WCF Web Context scope.
    /// </summary>
    public static readonly Func<IContext, object> WcfWebContext = 
               ctx => System.ServiceModel.Web.WebOperationContext.Current;
  }
}

Per completezza, questo è il modo che uso la richiamata sopra definito:

Bind<IHelloWorldService>()
        .To<HelloWorldService>()
        .InScope(NinjectWcfScopeCallbacks.WcfWebContext);

servizi WCF

Il non sono ospitati in è stato, quindi non so se devi usare la WcfWebContext o WcfContext sopra definito, ma si può provare 'em out e vedere. Se WebOperationContext funziona, allora è tutto a posto. In caso contrario, ho trovato le cose sono un po 'più complicato. Noterete il frammento di codice precedente utilizza una classe NinjectInstanceContext che è collegato al OperationContext. Questa è una classe che ho scritto che utilizza "la cache e raccogliere" Ninject 2.0 del meccanismo che permette oggetti da smaltire in modo deterministico. Fondamentalmente, la classe è attrezzi IExtension<InstanceContext> che è un costrutto WCF per attaccare quasi nulla alla OperationContext. Questa classe anche implementare l'interfaccia INotifyWhenDisposed di Ninject che è quello che fornisce il supporto per lo smaltimento deterministica. Ecco cosa la definizione di classe appare come:

  /// <summary>
  /// Defines a custom WCF InstanceContext extension that resolves service instances
  /// using Ninject.  
  /// <remarks>
  /// The custom InstanceContext extension provides support for deterministic disposal
  /// of injected dependencies and service instances themselves by being hook into 
  /// Ninject's "cache and collect" mechanism (new in Ninject 2.0) for object life cycle 
  /// management.  This allows binding object instances to the lifetime of a WCF context
  /// and having them deterministically deactivated and disposed.
  /// </remarks>
  /// </summary>
  public class NinjectInstanceContext : 
                IExtension<InstanceContext>, INotifyWhenDisposed {
  }

Il resto della mia estensione WCF per Ninject è la stessa come il uno su GitHub. Quello che succede in pratica è che un fornitore di istanza viene creata, che è collegato alla "attivazione" catena WCF - non sto usando la loro terminologia specifica, quanto ho capito le cose. Così, l'idea è che il vostro fornitore di istanza dovrebbe fornire le istanze della classe servizio WCF richiesto. Quindi, ecco dove usiamo Ninject per produrre l'istanza del servizio. In questo modo, possiamo anche attivare e iniettare eventuali dipendenze. Quello che il fornitore di istanza fa nella mia implementazione è avvolgere il kernel Ninject in un caso se NinjectInstanceContext e collegarlo al OperationContext. La creazione del servizio è quindi delegata a questa estensione WCF. Quando il provider istanza è detto di rilasciare un servizio, il NinjectInstanceContext che era attaccato alla OperationContext è disposta che in attuazione INotifyWhenDisposed provoca lo smaltimento deterministica del servizio (e potenzialmente sue dipendenze).

Spero che questo aiuta discussione. Vedrò se riesco a ottenere un codice più concreto postato qui se siete interessati.

Answer 2

Sono sicuro OperationContext è quello che stai cercando per