L'Unité De Programme D'Amorçage (À L'Unité.Mvc), Unité 3, MVC 5, EF6 Recevoir l'Erreur: sans paramètre Constructeur Public sur le Contrôleur

Ok, après une recherche Google, et plusieurs ASP/MVC forums je me suis lié d'avoir à demander ce que l'enfer je fais de mal ici.

J'ai un bon début de mon application, ok compréhension de la DI, le Cio et suis en utilisant le Référentiel, de Service et de UnitOfWork modèles. Lorsque je tente de charger un contrôleur qui a besoin de la DI de l'Unité, c'est comme si l'unité n'est pas la résolution de l'un quelconque des éléments enregistrés, ou que j'ai fait de mal. De tous les exemples que je peux voir pour cette version (pas la version qui crée le Bootstrap.cs fichier qui est ensuite appelé à partir d'Mondiale.asax) je suis en train de faire ce que les autres ont fait sans l'amour de l'Unité.

Ma question est: Ai-je d'installation/configuré l'Unité d'injecter les éléments dans le contrôleur de constructeur comme nécessaire ou pas. Si j'ai des idées pourquoi il ne fonctionne pas comme les exemples que j'ai vu?

Je reçois l'erreur que le AssetController doit avoir un sans paramètre constructeur public. Si j'ajoute un, il l'utilise sans le DI et si je ne suis pas d'en ajouter un, alors il crie au sujet de ne pas l'avoir.

Merci, le code ci-dessous.

UnityConfig.cs

namespace CARS.web.App_Start
{
    ///<summary>
    ///Specifies the Unity configuration for the main container.
    ///</summary>
    public class UnityConfig
    {
        #region Unity Container
        private static Lazy<IUnityContainer> container = new Lazy<IUnityContainer>(() =>
        {
            var container = new UnityContainer();
            RegisterTypes(container);
            return container;
        });

        ///<summary>
        ///Gets the configured Unity container.
        ///</summary>
        public static IUnityContainer GetConfiguredContainer()
        {
            return container.Value;
        }
        #endregion

        ///<summary>Registers the type mappings with the Unity container.</summary>
        ///<param name="container">The unity container to configure.</param>
        ///<remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to 
        ///change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
        public static void RegisterTypes(IUnityContainer container)
        {
            //NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
            //container.LoadConfiguration();

            //TODO: Register your types here
            //container.RegisterType<IProductRepository, ProductRepository>();
            container.RegisterType<IDataContext, CARSDEMOContext>(new PerRequestLifetimeManager())
                .RegisterType<IAssetService, AssetService>()
                .RegisterType<IUnitOfWork, UnitOfWork>()
                .RegisterType<IRepository<Asset>, Repository<Asset>>();
                //.RegisterType<AssetController>(new InjectionConstructor(typeof(IAssetService), typeof(IUnitOfWork)));
        }
    }
}

AssetController.cs (constructeur de partie où je fais l'injection params)

namespace CARS.web.Controllers
{
    public class AssetController : Controller
    {
        private readonly IAssetService _assetService;
        private readonly IUnitOfWork _unitOfWork;

        public AssetController(IAssetService assetService, IUnitOfWork unitOfWork)
        {
            _assetService = assetService;
            _unitOfWork = unitOfWork;
        }
        //other methods for CRUD etc stripped for brevity
    }
}

IAssetService.cs (le premier paramètre est le assetService )

namespace CARS.service
{
    public interface IAssetService : IService<Asset>
    {
        Task<IEnumerable<Asset>> GetAsync();
        Task<Asset> FindAsync(Guid id);
        Asset Add(Asset asset);
        Asset Update(Asset asset);
        void Remove(Guid id);
    }
}

AssetService.cs (mise en œuvre concrète pour IAssetService interaction)

namespace CARS.service
{


    public class AssetService : Service<Asset>, IAssetService
    {
        private readonly IRepositoryAsync<Asset> _repository;

        public AssetService(IRepositoryAsync<Asset> repository) : base(repository)
        {
            _repository = repository;
        }

        public Task<IEnumerable<Asset>> GetAsync()
        {
            //return _repository.Query().SelectAsync();
            return _repository.Query().SelectAsync();
        }

        public Task<Asset> FindAsync(Guid id)
        {
            return _repository.FindAsync(id);
        }

        public Asset Add(Asset asset)
        {
            _repository.Insert(asset);
            return asset;
        }

        public Asset Update(Asset asset)
        {
            _repository.Update(asset);
            return asset;
        }

        public void Remove(Guid id)
        {
            _repository.Delete(id);
        }
    }

}

IUnitOfWork.cs (c'est depuis Longtemps Le Générique de UofW et Référentiel - http://genericunitofworkandrepositories.codeplex.com/)

namespace Repository.Pattern.UnitOfWork
{
    public interface IUnitOfWork : IDisposable
    {
        int SaveChanges();
        Task<int> SaveChangesAsync();
        void Dispose(bool disposing);
        IRepository<TEntity> Repository<TEntity>() where TEntity : IObjectState;
        void BeginTransaction();
        bool Commit();
        void Rollback();
    }
}

UnitOfWork.cs (nouveau depuis Longtemps Le cadre de l')

namespace Repository.Pattern.Ef6
{
public class UnitOfWork : IUnitOfWork, IUnitOfWorkAsync
{
#region Private Fields
private readonly IDataContextAsync _dataContext;
private bool _disposed;
private ObjectContext _objectContext;
private Dictionary<string, object> _repositories;
private DbTransaction _transaction;
#endregion Private Fields
#region Constuctor/Dispose
public UnitOfWork(IDataContextAsync dataContext)
{
_dataContext = dataContext;
}
public void Dispose()
{
if (_objectContext != null && _objectContext.Connection.State == ConnectionState.Open)
_objectContext.Connection.Close();
Dispose(true);
GC.SuppressFinalize(this);
}
public virtual void Dispose(bool disposing)
{
if (!_disposed && disposing)
_dataContext.Dispose();
_disposed = true;
}
#endregion Constuctor/Dispose
public int SaveChanges()
{
return _dataContext.SaveChanges();
}
public IRepository<TEntity> Repository<TEntity>() where TEntity : IObjectState
{
return RepositoryAsync<TEntity>();
}
public Task<int> SaveChangesAsync()
{
return _dataContext.SaveChangesAsync();
}
public Task<int> SaveChangesAsync(CancellationToken cancellationToken)
{
return _dataContext.SaveChangesAsync(cancellationToken);
}
public IRepositoryAsync<TEntity> RepositoryAsync<TEntity>() where TEntity : IObjectState
{
if (_repositories == null)
_repositories = new Dictionary<string, object>();
var type = typeof (TEntity).Name;
if (_repositories.ContainsKey(type))
return (IRepositoryAsync<TEntity>) _repositories[type];
var repositoryType = typeof (Repository<>);
_repositories.Add(type, Activator.CreateInstance(repositoryType.MakeGenericType(typeof (TEntity)), _dataContext, this));
return (IRepositoryAsync<TEntity>) _repositories[type];
}
#region Unit of Work Transactions
public void BeginTransaction()
{
_objectContext = ((IObjectContextAdapter) _dataContext).ObjectContext;
if (_objectContext.Connection.State != ConnectionState.Open)
{
_objectContext.Connection.Open();
_transaction = _objectContext.Connection.BeginTransaction();
}
}
public bool Commit()
{
_transaction.Commit();
return true;
}
public void Rollback()
{
_transaction.Rollback();
((DataContext)_dataContext).SyncObjectsStatePostCommit();
}
#endregion
//Uncomment, if rather have IRepositoryAsync<TEntity> IoC vs. Reflection Activation
//public IRepositoryAsync<TEntity> RepositoryAsync<TEntity>() where TEntity : EntityBase
//{
//   return ServiceLocator.Current.GetInstance<IRepositoryAsync<TEntity>>();
//}
}
} 

Mis à jour pour inclure le SetResolver info de UnityMvcActivator.cs

using System.Linq;
using System.Web.Mvc;
using Microsoft.Practices.Unity.Mvc;
[assembly: WebActivatorEx.PreApplicationStartMethod(typeof(CARS.web.App_Start.UnityWebActivator), "Start")]
namespace CARS.web.App_Start
{
///<summary>Provides the bootstrapping for integrating Unity with ASP.NET MVC.</summary>
public static class UnityWebActivator
{
///<summary>Integrates Unity when the application starts.</summary>
public static void Start() 
{
var container = UnityConfig.GetConfiguredContainer();
FilterProviders.Providers.Remove(FilterProviders.Providers.OfType<FilterAttributeFilterProvider>().First());
FilterProviders.Providers.Add(new UnityFilterAttributeFilterProvider(container));
DependencyResolver.SetResolver(new UnityDependencyResolver(container));
//TODO: Uncomment if you want to use PerRequestLifetimeManager
Microsoft.Web.Infrastructure.DynamicModuleHelper.DynamicModuleUtility.RegisterModule(typeof(UnityPerRequestHttpModule));
}
}
}

J'ai lu/essayé les informations/données, et rien n'a fixé:

Le type IUserStore`1 n'a pas un accessible constructeur

Comment ajouter MVC 5 de l'authentification de l'Unité du Cio?

Types pas résoudre avec l'Unité [MVC 5]

J'ai prêt où l'on doit écrire un ControllerFactory à l'Unité pour être en mesure de le faire, mais qui semble tout à fait un peu de travail quand tous les exemples que j'ai trouvé tout simplement la configuration enregistrée, et l'injection apparemment il se passe sur les contrôleurs et les autres classes ont besoin.

Et enfin l'erreur:

The following server error was encountered: 
An error occurred when trying to create a controller of type           'CARS.web.Controllers.AssetController'. Make sure that the controller has a parameterless     public constructor.Details are: 
at     System.Web.Mvc.DefaultControllerFactory.DefaultControllerActivator.Create(RequestContext    requestContext, Type controllerType) at    System.Web.Mvc.DefaultControllerFactory.CreateController(RequestContext requestContext,     String controllerName) at System.Web.Mvc.MvcHandler.ProcessRequestInit(HttpContextBase     httpContext, IController& controller, IControllerFactory& factory) at     System.Web.Mvc.MvcHandler.BeginProcessRequest(HttpContextBase httpContext, AsyncCallback     callback, Object state) at     System.Web.HttpApplication.CallHandlerExecutionStep.System.Web.HttpApplication.IExecutionSte    p.Execute() at System.Web.HttpApplication.ExecuteStep(IExecutionStep step, Boolean&     completedSynchronously)

Grâce

OriginalL'auteur SouthPlatte | 2014-04-18