Unity Resolving objects with inherited interfaces

Question

4.00/5 (2 votes)

See more:

Consider the two classes below.

C#

public abstract class BaseService<tmodel> : IService<tmodel> where TModel : IModel

public class AccountCodeService : BaseService<accountcode> ,IAccountCodeService
 
BaseService implements IService<tmodel>.

Since AccountCodeSevice inherits from BaseService, it implements the IService<tmodel> interface as well as IAccountCodeService

I now register AccountCodeService in Unity:

C#

container.RegisterType<iaccountcodeservice,>();

Then resolve:

C#

_accountCodeService = container.Resolve<iaccountcodeservice>();

The Problem:
_accountCodeService does not expose the elements in IService<tmodel>.

I tried:

C#

container.RegisterType<iaccountcodeservice,>().RegisterType<iservice><accountcode>,AccountCodeService>();

Then resolve:

C#

_accountCodeService = container.Resolve<iaccountcodeservice>();

Same issue:
_accountCodeService does not expose the elements in IService<tmodel>.

For sanity sake I tried:

C#

var o = container.Resolve<iservice><accountcode>>();

Verified that o exposes the the elements in IService<tmodel>.

How do I get Unity to Resolve the class in a way that it exposes the elements from IService<tmodel> and IAccountCodeService?

Note: I found that if I duplicated the IService<tmodel> properties in IAccountCodeService, the app would compile and then the IService<tmodel> elements were exposed and were able to be called. I do not want to implement this way though.

Posted 29-May-12 4:45am

Wbehning

Updated 29-May-12 4:50am

Herman<T>.Instance

v2

Add a Solution

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

BobJanova · Accepted Answer · 2012-05-29T06:28:00

In short, Unity container resolution resolves interfaces. So if you want a resolved reference which implements both IService<T> and IAccountCodeService, you need an interface which implements both. In this case it appears that IAccountCodeService should be that interface, so try interface IAccountCodeService extends IService<AccountCode> (and, obviously, have AccountCodeService implement it).

If your naming is bad, and you're actually after the more general case which can be summarised:

interface IService<T> { ... }
interface ISomethingElse { ... }
class Example implements ISomethingElse, IService<DataClass> { ... }

container.RegisterType<???, Example>();
var example = container.Resolve<???>(); // What can I put here?

... then you need to introduce a new interface which you can use to register:

interface IExample extends IService<DataClass>, ISomethingElse {}
class Example implements IExample { ... }

... and then you can use that interface for registration and resolution:

container.RegisterType<IExample, Example>();
var example = container.Resolve<IExample>();

Alternatively, if you are simply using Unity for service singleton reasons, it's possible to register concrete types directly, or just use a simpler singleton pattern and not bother with Unity at all. Dependency injection is greatly over-rated in my opinion.