I'm having difficulty integrating Ninject with XNA.
static class Program
{
/**
* The main entry point for the application.
*/
static void Main(string[] args)
{
IKernel kernel = new StandardKernel(NinjectModuleManager.GetModules());
CachedContentLoader content = kernel.Get<CachedContentLoader>(); // stack overflow here
MasterEngine game = kernel.Get<MasterEngine>();
game.Run();
}
}
// constructor for the game
public MasterEngine(IKernel kernel)
: base(kernel)
{
this.inputReader = kernel.Get<IInputReader>();
graphicsDeviceManager = kernel.Get<GraphicsDeviceManager>();
Components.Add(kernel.Get<GamerServicesComponent>());
// Tell the loader to look for all files relative to the "Content" directory.
Assets = kernel.Get<CachedContentLoader>();
//Sets dimensions of the game window
graphicsDeviceManager.PreferredBackBufferWidth = 800;
graphicsDeviceManager.PreferredBackBufferHeight = 600;
graphicsDeviceManager.ApplyChanges();
IsMouseVisible = false;
}
Ninject.cs:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Ninject.Modules;
using HWAlphaRelease.Controller;
using Microsoft.Xna.Framework;
using Nuclex.DependencyInjection.Demo.Scaffolding;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
namespace HWAlphaRelease
{
public static class NinjectModuleManager
{
public static NinjectModule[] GetModules()
{
return new NinjectModule[1] { new GameModule() };
}
/// <summary>Dependency injection rules for the main game instance</summary>
public class GameModule : NinjectModule
{
#region class ServiceProviderAdapter
/// <summary>Delegates to the game's built-in service provider</summary>
/// <remarks>
/// <para>
/// When a class' constructor requires an IServiceProvider, the dependency
/// injector cannot just construct a new one and wouldn't know that it has
/// to create an instance of the Game class (or take it from the existing
/// Game instance).
/// </para>
/// <para>
/// The solution, then, is this small adapter that takes a Game instance
/// and acts as if it was a freely constructable IServiceProvider implementation
/// while in reality, it delegates all lookups to the Game's service container.
/// </para>
/// </remarks>
private class ServiceProviderAdapter : IServiceProvider
{
/// <summary>Initializes a new service provider adapter for the game</summary>
/// <param name="game">Game the service provider will be taken from</param>
public ServiceProviderAdapter(Game game)
{
this.gameServices = game.Services;
}
/// <summary>Retrieves a service from the game service container</summary>
/// <param name="serviceType">Type of the service that will be retrieved</param>
/// <returns>The service that has been requested</returns>
public object GetService(Type serviceType)
{
return this.gameServices;
}
/// <summary>Game services container of the Game instance</summary>
private GameServiceContainer gameServices;
}
#endregion // class ServiceProviderAdapter
#region class ContentManagerAdapter
/// <summary>Delegates to the game's built-in ContentManager</summary>
/// <remarks>
/// This provides shared access to the game's ContentManager. A dependency
/// injected class only needs to require the ISharedContentService in its
/// constructor and the dependency injector will automatically resolve it
/// to this adapter, which delegates to the Game's built-in content manager.
/// </remarks>
private class ContentManagerAdapter : ISharedContentService
{
/// <summary>Initializes a new shared content manager adapter</summary>
/// <param name="game">Game the content manager will be taken from</param>
public ContentManagerAdapter(Game game)
{
this.contentManager = game.Content;
}
/// <summary>Loads or accesses shared game content</summary>
/// <typeparam name="AssetType">Type of the asset to be loaded or accessed</typeparam>
/// <param name="assetName">Path and name of the requested asset</param>
/// <returns>The requested asset from the the shared game content store</returns>
public AssetType Load<AssetType>(string assetName)
{
return this.contentManager.Load<AssetType>(assetName);
}
/// <summary>The content manager this instance delegates to</summary>
private ContentManager contentManager;
}
#endregion // class ContentManagerAdapter
/// <summary>Initializes the dependency configuration</summary>
public override void Load()
{
// Allows access to the game class for any
components with a dependency
// on the 'Game' or 'DependencyInjectionGame' classes.
Bind<MasterEngine>().ToSelf().InSingletonScope();
Bind<NinjectGame>().To<MasterEngine>().InSingletonScope();
Bind<Game>().To<MasterEngine>().InSingletonScope();
// Let the dependency injector construct a graphics device manager for
// all
components depending on the IGraphicsDeviceService and
// IGraphicsDeviceManager interfaces
Bind<GraphicsDeviceManager>().ToSelf().InSingletonScope();
Bind<IGraphicsDeviceService>().To<GraphicsDeviceManager>().InSingletonScope();
Bind<IGraphicsDeviceManager>().To<GraphicsDeviceManager>().InSingletonScope();
// Some clever adapters that hand out the Game's IServiceProvider and allow
// access to its built-in ContentManager
Bind<IServiceProvider>().To<ServiceProviderAdapter>().InSingletonScope();
Bind<ISharedContentService>().To<ContentManagerAdapter>().InSingletonScope();
Bind<IInputReader>().To<UserInputReader>().InSingletonScope().WithConstructorArgument("keyMapping", Constants.DEFAULT_KEY_MAPPING);
Bind<CachedContentLoader>().ToSelf().InSingletonScope().WithConstructorArgument("rootDir", "Content");
}
}
}
}
NinjectGame.cs
/// <summary>Base class for Games making use of Ninject</summary>
public class NinjectGame : Game {
/// <summary>Initializes a new Ninject game instance</summary>
/// <param name="kernel">Kernel the game has been created by</param>
public NinjectGame(IKernel kernel) {
Type ownType = this.GetType();
if(ownType != typeof(Game)) {
kernel.Bind<NinjectGame>().To<MasterEngine>().InSingletonScope();
}
kernel.Bind<Game>().To<NinjectGame>().InSingletonScope();
}
}
} // namespace Nuclex.DependencyInjection.Demo.Scaffolding
When I try to get the CachedContentLoader, I get a stack overflow exception. I'm basing this off of this tutorial, but I really have no idea what I'm doing. Help?
