Erreur de structure de structure lors de l'utilisation de HttpContextBase dans le constructeur

Question

Je crée une application ASP.NET MVC 2.0 sur .NET 4.0 et j'utilise Structuremap 2.6.1 pour IoC. J'ai récemment ajouté une classe ICookie et Cookie, la classe Cookie prend HttpContextBase en tant que paramètre constructeur (voir ci-dessous) et maintenant quand j'exécute mon application, j'obtiens cette erreur: Aucune instance par défaut définie pour PluginFamily System.Web.HttpContextBase.

J'ai déjà utilisé cette méthode dans une autre application MVC avec la même pile mais je n'ai pas eu cette erreur. Est-ce que je manque quelque chose? Si je dois ajouter du code de mappage pour HttoContextBase dans mon fichier de configuration structuremap, que dois-je utiliser?

Et l'aide serait géniale !!!

Cookie.cs

public class Cookie : ICookie 
{ 
    private readonly HttpContextBase _httpContext; 
    private static bool defaultHttpOnly = true; 
    private static float defaultExpireDurationInDays = 1; 
    private readonly ICryptographer _cryptographer; 
    public Cookie(HttpContextBase httpContext, ICryptographer cryptographer) 
    { 
     Check.Argument.IsNotNull(httpContext, "httpContext"); 
     Check.Argument.IsNotNull(cryptographer, "cryptographer"); 
     _cryptographer = cryptographer; 
     _httpContext = httpContext; 
    } 
    public static bool DefaultHttpOnly 
    { 
     [DebuggerStepThrough] 
     get { return defaultHttpOnly; } 

     [DebuggerStepThrough] 
     set { defaultHttpOnly = value; } 
    } 

    public static float DefaultExpireDurationInDays 
    { 
     [DebuggerStepThrough] 
     get { return defaultExpireDurationInDays; } 

     [DebuggerStepThrough] 
     set 
     { 
      Check.Argument.IsNotZeroOrNegative(value, "value"); 
      defaultExpireDurationInDays = value; 
     } 
    } 

    public T GetValue<T>(string key) 
    { 
     return GetValue<T>(key, false); 
    } 

    public T GetValue<T>(string key, bool expireOnceRead) 
    { 
     var cookie = _httpContext.Request.Cookies[key]; 
     T value = default(T); 
     if (cookie != null) 
     { 
      if (!string.IsNullOrWhiteSpace(cookie.Value)) 
      { 
       var converter = TypeDescriptor.GetConverter(typeof(T)); 
       try 
       { 
        value = (T)converter.ConvertFromString(_cryptographer.Decrypt(cookie.Value)); 
       } 
       catch (NotSupportedException) 
       { 
        if (converter.CanConvertFrom(typeof(string))) 
        { 
         value = (T)converter.ConvertFrom(_cryptographer.Decrypt(cookie.Value)); 
        } 
       } 
      } 
      if (expireOnceRead) 
      { 
       cookie = _httpContext.Response.Cookies[key]; 

       if (cookie != null) 
       { 
        cookie.Expires = DateTime.Now.AddDays(-100d); 
       } 
      } 
     } 
     return value; 
    } 

    public void SetValue<T>(string key, T value) 
    { 
     SetValue(key, value, DefaultExpireDurationInDays, DefaultHttpOnly); 
    } 

    public void SetValue<T>(string key, T value, float expireDurationInDays) 
    { 
     SetValue(key, value, expireDurationInDays, DefaultHttpOnly); 
    } 

    public void SetValue<T>(string key, T value, bool httpOnly) 
    { 
     SetValue(key, value, DefaultExpireDurationInDays, httpOnly); 
    } 

    public void SetValue<T>(string key, T value, float expireDurationInDays, bool httpOnly) 
    { 
     TypeConverter converter = TypeDescriptor.GetConverter(typeof(T)); 
     string cookieValue = string.Empty; 
     try 
     { 
      cookieValue = converter.ConvertToString(value); 
     } 
     catch (NotSupportedException) 
     { 
      if (converter.CanConvertTo(typeof(string))) 
      { 
       cookieValue = (string)converter.ConvertTo(value, typeof(string)); 
      } 
     } 
     if (!string.IsNullOrWhiteSpace(cookieValue)) 
     { 
      var cookie = new HttpCookie(key, _cryptographer.Encrypt(cookieValue)) 
      { 
       Expires = DateTime.Now.AddDays(expireDurationInDays), 
       HttpOnly = httpOnly 
      }; 
      _httpContext.Response.Cookies.Add(cookie); 
     } 
    } 
} 

IocMapping.cs

public class IoCMapping 
{ 
    public static void Configure() 
    { 

     var connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["ProjectName.Core.Properties.Settings.ProjectNameConnectionString"].ConnectionString; 
     MappingSource mappingSource = new AttributeMappingSource(); 
     ObjectFactory.Initialize(x => 
     { 
      x.Scan(scan => 
      { 
       scan.Assembly("ProjectName.Core"); 
       scan.Assembly("ProjectName.WebUI"); 
       scan.WithDefaultConventions(); 
      }); 
      x.For<IUnitOfWork>().HttpContextScoped().Use<UnitOfWork>(); 
      x.For<IDatabase>().HttpContextScoped().Use<Database>().Ctor<string>("connection").Is(connectionString).Ctor<MappingSource>("mappingSource").Is(mappingSource); 
      x.For<ILogger>().Singleton().Use<NLogLogger>(); 
      x.For<ICacheManager>().Singleton().Use<CacheManager>().Ctor<System.Web.Caching.Cache>().Is(HttpRuntime.Cache); 
      x.For<IEmailSender>().Singleton().Use<EmailSender>(); 
      x.For<IAuthenticationService>().HttpContextScoped().Use<AuthenticationService>(); 
      x.For<ICryptographer>().Use<Cryptographer>(); 
      x.For<IUserSession>().HttpContextScoped().Use<UserSession>(); 
      x.For<ICookie>().HttpContextScoped().Use<Cookie>(); 
      x.For<ISEORepository>().HttpContextScoped().Use<SEORepository>(); 
      x.For<ISpotlightRepository>().HttpContextScoped().Use<SpotlightRepository>(); 
      x.For<IContentBlockRepository>().HttpContextScoped().Use<ContentBlockRepository>(); 
      x.For<ICatalogRepository>().HttpContextScoped().Use<CatalogRepository>(); 
      x.For<IPressRoomRepository>().HttpContextScoped().Use<PressRoomRepository>(); 
      x.For<IEventRepository>().HttpContextScoped().Use<EventRepository>(); 
      x.For<IProductRegistrationRepository>().HttpContextScoped().Use<ProductRegistrationRepository>(); 
      x.For<IWarrantyRepository>().HttpContextScoped().Use<WarrantyRepository>(); 
      x.For<IInstallerRepository>().HttpContextScoped().Use<InstallerRepository>(); 
      x.For<ISafetyNoticeRepository>().HttpContextScoped().Use<SafetyNoticeRepository>(); 
      x.For<ITradeAlertRepository>().HttpContextScoped().Use<TradeAlertRepository>(); 
      x.For<ITestimonialRepository>().HttpContextScoped().Use<TestimonialRespository>(); 
      x.For<IProjectPricingRequestRepository>().HttpContextScoped().Use<ProjectPricingRequestRepository>(); 
      x.For<IUserRepository>().HttpContextScoped().Use<UserRepository>(); 
      x.For<IRecipeRepository>().HttpContextScoped().Use<RecipeRepository>(); 
     }); 

     LogUtility.Log.Info("Registering types with StructureMap"); 
    } 
} 

Answer 1

Je crois que vous devez enregistrer le HttpContextBase sur chaque demande dans votre gestionnaire Begin_Request comme ceci:

For<HttpContextBase>().Use(() => new HttpContextWrapper(HttpContext.Current)); 

Mise à jour: Assurez-vous d'enregistrer un lambda, sinon StructureMap stockera le fichier HttpContext ava utilisable lors de l'enregistrement en tant que singleton.