Comment utiliser le Référentiel d'Interface qui utilise les Génériques avec l'Injection de Dépendance?

Est-ce OK?

Sûr. Il y a des préférences personnelles quant à l'utilisation du constructeur d'injection que vous avez de la ou des biens de l'injection. Constructeur d'injection est plus propre puisque vous n'avez pas à avoir beaucoup de paramètres de votre constructeur, mais il est plus sûr ainsi.

quel est le point de l'Unité pour vous inscrire Interface de type de béton

L'une des raisons en est ainsi que vous pouvez unité de test MyClass sans avoir à utiliser votre référentiel qui touche à une base de données. Vous pouvez "faux" le dépôt de retourner valeurs codées en dur à tester.

Vous pourriez envisager d'utiliser un Globale De Service que les faisceaux de plusieurs autres services, mais vous devriez aussi regarder attentivement pour voir si votre MyClass est essayer d'en faire trop; avoir un très grand nombre de dépendances peuvent être une indication de cela.

J'avais besoin de faire cela en utilisant le fichier de configuration. C'est en fait assez facile, mais m'a fallu un certain temps pour comprendre.

Dans cet exemple, nous avons une interface IRepository<T> et il a 2 versions:

1. OneRepository
2. TwoRepository

Nous avons ensuite une classe nommée Worker qui dépend IRepository<One> et IRepository<Two>. Nous demandons à l'unité pour créer une instance de Worker pour nous et de comprendre les dépendances à partir du fichier de configuration.

De l'Interface et la mise en Œuvre

Tous ces éléments sont dans l'espace de noms ConsoleApplication1 dans cet exemple.

public class Worker
{
    private readonly IRepository<One> one;
    private readonly IRepository<Two> two;

    public Worker(IRepository<One> one, IRepository<Two> two)
    {
        this.one = one;
        this.two = two;
    }

    public string DoOne()
    {
        return this.one.Add(new One());
    }

    public string DoTwo()
    {
        return this.two.Add(new Two());
    }
}

public interface IRepository<T>
{
    string Add(T t);
}

public class OneRepository : IRepository<One>
{
    public string Add(One t)
    {
        return "One";
    }
}

public class TwoRepository : IRepository<Two>
{
    public string Add(Two t)
    {
        return "Two";
    }
}

public class One { }
public class Two { }

L'Unité De Configuration

Veuillez noter que nous demandons à l'unité et de la dire au nom de l'assemblée. Ensuite, nous enregistrons le 2 implémentations.

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration" />
  </configSections>
  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
    <assembly name="ConsoleApplication1" />
    <container>
      <register type="ConsoleApplication1.IRepository[[ConsoleApplication1.One]]" mapTo="ConsoleApplication1.OneRepository" />
      <register type="ConsoleApplication1.IRepository[[ConsoleApplication1.Two]]" mapTo="ConsoleApplication1.TwoRepository" />
    </container>
  </unity>
</configuration>

Application

C'est le La Composition De La Racine.

public class Program
{
    static void Main()
    {
        UnityContainer container = new UnityContainer();
        var res = container.LoadConfiguration();
        Worker worker = res.Resolve<Worker>();
        Console.WriteLine(worker.DoOne());
        Console.WriteLine(worker.DoTwo());
        Console.Read();
    }
}

La sortie comme prévu est:

One
Two