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 ?

How it will be automatically created? using reflection? Elaborate more on how that instance is created. — Sriram Sakthivel, May 27 '14 at 04:30

Uffe · Accepted Answer · 2014-05-27T06:42:54.367

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.

edited May 27 '14 at 06:42

answered May 27 '14 at 05:39

Uffe

2,275
1
13
9

Cheers for the quick reply Uffe :). Will this simple get the `Bar` because it implements the `IBar`, and what happens if I have a `public class AnotherBar : IBar` (which is the point of multiples implementations of an interface) ? I guess another workaround is setting the specific class in the controller's constructor (so giving a specific `Bar` to `bar`) ... – Noctis May 27 '14 at 05:59
Must have a typo, since you suggest using `GetExports` instead of `GetExports` :) – Noctis May 27 '14 at 06:46
What? GetExport would expect you to have 1 and only one impletentation of T, GetExports will expect 1 - n implementations and actually return a IList – Uffe May 27 '14 at 06:49
good lord ... It's been a way too long day ...I'm sorry, I totally missed that `s`neaky `s` ...my bad ... – Noctis May 27 '14 at 06:53
:) Not fair, my day just started. Just arrived at work! It was a sneaky little 's' Thought you had me there for a while ;) – Uffe May 27 '14 at 06:56

Uffe · Answer 2 · 2014-05-27T08:39:14.170

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; }
}

sounds interesting ... work's a bit hectic, but might give it a spin ... (any updates for the documentation for v4 ? :) ) — Noctis, May 27 '14 at 09:32
The team has just started on the v4 docs. It will be very much improved over the current documentation more features and much more details. — Uffe, May 27 '14 at 09:45

Dependency Injection on Xsockets constructor

2 Answers2