具有泛型的Unity配置

Question

I am currently in the process of designing a new message translation system at work and have the following question concerning DI and Unity.

I have the following interface:

public interface ITranslate<TInput, TOutput>
{
    TOutput TranslateMessage(TInput message);
}

With a concrete implementation of below (where InternalMessage is a custom class I have developed)

public class TestTranslate : ITranslate<byte[], InternalMessage>
{
    InternalMessage Translate(byte[] message)
    {
        // Do the translation here and return the result....
    }
}

However I want to using unity inject a translator instance into my Translator service through the constructor. To be used in a method within the service.

public class TranslatorService
{    
    private readonly ITranslator translator;
    public TranslatorService(ITranslate translator)
    {
        this.translator = translator;
    }

    public byte[] DoTranslate(string message)
    {
        return translator.TranslateMessage(message);
    }
}

However I have 2 questions:

1) Is it possible to have the ITranslate in the constructor without specifiying the types that the translator will deal with (I am trying to keep the Service and Translator as generic as possible, so if another translation was needed I would only need to swap out the Concrete implementation of the Translator interface).

2) If this is possible how would I do it and then what would I have in my unity configuration to do that. Note I am using the XML configuration (not my choice) to configure my dependenciues etc.

Thanks In Advance

Stuart

Answer 1

After some thinking, I assume you want to do the following:

1. At some point, messages of different types come in and have to be
   translated to other types, somehow.
2. The component/client that receives these messages is and should be unaware of how different types of messages should be translated.
3. Therefore, you want to implement a generic TranslatorService-class that takes any message and magically translates is to the correct type, based on the input-message.
4. For each specific translation, you want to define a specific, generic Translator-class that is automatically instantiated and used by the TranslatorService-class, preferrably using dependency injection of some sort.

If my assumptions are correct, I would advise the following design.

First of all, define a generic interface that must be implemented by each specialized Translator-class. Only make the input-type generic:

interface IMessageTranslator<TMessage>
{
    object Translate(TMessage message);
}

Then create the TranslatorService such that clients can just push in arbitrary messages and gives them back the result, if and only if a Translator for that message exists:

class TranslatorService
{
    object Translate(object message)
    {

    }
}

Now the TranslatorService has to instantiate the correct IMessageTranslator<T> based on the type of message. You can do this with Unity by having the TranslatorService-class encapsulate a container that contains all IMessageTranslator<T> -types that you have implemented and then simply instantiate one based on the message type:

class TranslatorService
{
    private readonly IUnityContainer _container;

    public TranslatorService()
    {
        _container = new UnityContainer();
        _container.RegisterType(typeof(IMessageTranslator<A>), typeof(MessageTranslatorA));
        _container.RegisterType(typeof(IMessageTranslator<B>), typeof(MessageTranslatorB));
        // Etc...
    }

    object Translate(object message)
    {
        if (message == null)
        {
           throw new ArgumentNullException("message");
        }
        var genericTranslatorDefinition = typeof(IMessageTranslator<>);
        var translatorType = genericTranslatorDefinition.MakeGenericType(message.GetType());
        var translator = _container.Resolve(translatorType);
        var translateMethod = translatorType.GetMethod("Translate", new [] { message.GetType() });

        return translateMethod.Invoke(translator, new object[] { message });
    }
}

Note that this is a naive implementation as to whether a translator actually exists/is registered for the specified message, and also in the way it finds the Translate-method (better to get it through the InterfaceMap), but you get the idea.

If you want even more flexibility, you could create a mechanism that auto-fills your container by scanning the assembly for IMessageTranslator-implementors. That way, you just add a new implementation and you're ready to go.