Dependency Injection on Xsockets constructor

Question

I'm trying to use XSockets to implement a server, and I want to abstract the DB layer using DI.

This is what I have:

public class FooController : XSocketController
{
    // constructor
    public FooController()
    {
        // initialize some data here
    }
    //... rest of class
}

This is what I want (in order to be able to use some DI on the controller which serves as server) :

public class FooController : XSocketController
{
    private IBar _myBar;

    // constructor
    public FooController(IBar BarImplementation)
    {
        // ...
        _myBar = BarImplementation;
    }
    //... 
}

The problem is: I don't actually create the FooController myself, it's being called when some clients try to connect to it.
This is a typical usage to start your server:

_serverContainer = Composable.GetExport<IXSocketServerContainer>();
_serverContainer.StartServers();

// Write info for each server found.
foreach (var server in _serverContainer.Servers)
{
    Console.WriteLine(server.ConfigurationSetting.Endpoint);
    Console.WriteLine(  "Allowed Connections (0 = infinite): {0}",
                        server.ConfigurationSetting.NumberOfAllowedConections);
}

If I'm not mistaken (and I might well be), when a client tries to connect he gets he's own private controller as a server.

Any ideas on how this can be solved ?

Answer 1

There are several ways of doing this, but there is no way (currently) of having constructor injection on controllers. You can have it on other classes defined by your self though...

This is one way of doing it.

/// <summary>
/// Interface with export attribute
/// </summary>
[Export(typeof(IBar))]
public interface IBar
{
    void SomeMethod();
}

/// <summary>
/// Implementation of IBar
/// </summary>
public class Bar : IBar
{
    public void SomeMethod()
    {

    }
}

/// <summary>
/// Controller with IBar property
/// </summary>
public class Foo : XSocketController
{
    private IBar bar;

    public Foo()
    {
        bar = Composable.GetExport<IBar>();
    }
}

EDIT: To answer the question in the comment. The

GetExport<T> 

expects to find ONLY ONE instance implementing that interface. If you have multiple classes implementing your interface you should use

GetExports<T>

The reason for us not having constructor injection etc is that most of the time people add some kind of IService or IRepository. That would open up a database connection which would be open for as long as the controller lives, That would be for as long as the client is connected. That is bad :) So when needing data access you should use

GetExport<IMyService>

use it and then when you exit the method the connection will be closed.

You can ofcourse use Ninject etc as well, but you should still only create object with data access for as short time as possible.

Answer 2

Just some additional information. In the next release (4.0 alpha tomorrow) you will be able to to like this

/// <summary>
/// Interface with export attribute
/// </summary>
[Export(typeof(IBar))]
public interface IBar
{
    void SomeMethod();
}

/// <summary>
/// Implementation of IBar
/// </summary>
public class Bar : IBar
{
    public void SomeMethod()
    {

    }
}

And then use either a ImportingConstrcutor like this...

/// <summary>
/// Controller with IBar property
/// </summary>
public class Foo : XSocketController
{
    public IBar Bar { get; set; }

    public Foo(){}

    [ImportingConstructor]
    public Foo(IBar bar)
    {
        this.Bar = bar;
    }
}

Or use the ImportOne like this...

/// <summary>
/// Controller with IBar property
/// </summary>
public class Foo : XSocketController
{
    [ImportOne(typeof(IBar))]
    public IBar Bar { get; set; }
}