Comment utiliser l'Injection de Dépendance avec des Méthodes Statiques?

Imaginer qu'il y est un Customer classe avec une instance Load() méthode.

Lorsque le Load() méthode est appelée, elle récupère les détails de la commande, par exemple par des

var orders = Order.GetAll(customerId, ...);

GetAll() est une méthode statique de la Order classe et les paramètres d'entrée sont les champs définis dans la Customer classe.

Comme vous pouvez le voir, Order est une dépendance de la Customer classe, cependant, je ne peux pas il suffit de créer un IOrder et de l'injecter là que les interfaces ne peuvent pas avoir des méthodes statiques.

Par conséquent, la question est comment pourrais-je introduire l'injection de dépendance dans cet exemple?

Je ne veux pas faire GetAll() une méthode d'instance puisque c'est une méthode statique et de la nécessité de garder de cette façon.

Par exemple, j'ai utilisé l'utilitaire de classes dans ma conception, dont la plupart ne contiennent que des méthodes statiques.

OriginalL'auteur The Light | 2011-06-29

dependency-injection static-methods

12

Si vous doit garder la méthode statique, je tourne la statique des appels dans un Référentiel de l'objet.

Comme ceci:
```
interface IOrderRepository {
   IEnumerable<IOrder> GetAll(customerId, ..);
}

class OrderRepository : IOrderRepository {
   IEnumerable<IOrder> GetAll(customerId, ...)
   {
     Order.GetAll(customerId,...); //The original static call.
   }
}
```
Maintenant vous injectez ce référentiel dans votre Customer classe.

(Je suis en supposant que vous êtes en train de faire ce que vous pouvez injecter de faux IOrders lors de l'exécution à des fins de test. Je dois dire qu'en général, les méthodes statiques sont un sérieux obstacle à l'essai.)

Merci, ces classes du référentiel d'interfaces et d'être une partie de la couche d'accès aux données? Ma Commande de classe est une entité mappé à partir de la table de l'Ordre (à l'aide de LINQ to SQL).
c'est juste un wrapper autour de votre fonction. donc, chaque fois que la fonction appartient logiquement couche-sage, je voudrais aussi mettre le wrapper.

OriginalL'auteur Paul Phillips

De voir que votre regroupement de la racine pour aller chercher des commandes est votre modèle client je fortement vous conseillons de créer un dossier client et de les injecter que pour n'importe quel service l'exige.

Voici un exemple:

public class CustomerService
{
    private readonly ICustomerRepository _customerRepository;

    public CustomerService(ICustomerRepository customerRepository)
    {
        if (customerRepository == null)
        {
            throw new ArgumentNullException("customerRepository");
        }

        _customerRepository = customerRepository;
    }

    public IEnumerable<IOrder> GetOrdersForCustomerId(int customerId)
    {
        return _customerRepository.GetOrdersForCustomerId(customerId);
    }
}

public interface ICustomerRepository
{
    IEnumerable<IOrder> GetOrdersForCustomerId(int customerId);
}

class CustomerRepository : ICustomerRepository
{
    public IEnumerable<IOrder> GetOrdersForCustomerId(int customerId)
    {
        throw new NotImplementedException();
    }
}

OriginalL'auteur Mike

1

Le Pointeur De La Fonction D'Injection De

TLDR:

Injecter un pointeur de fonction dans le Customer classe. La valeur de ce pointeur de fonction peut être Order.GetAll dans la production, et MockOrder.GetAll dans les tests.

EXEMPLE:

La dépendance (problématique fonction statique nous dépendons):
```
class Order {
    static func GetAll() -> [Order] {
        var orders = ... //Load from production source
        return orders
    }
}
```
Notre classe dépendante (dépend de la fonction statique):
```
class Customer {
    func Init(getAllOrdersFunction) { //Arg is a func pointer
        self.getAllOrdersFunction = getAllOrdersFunction
    }

    func Load() {
        var orders = self.getAllOrdersFunction()
        //Do stuff...
    }
}
```
De Production de classe client (effectue l'injection de dépendance):
```
class BusinessLogicManager {
    func DoBusinessLogic() {
        var customer = Customer(Order.GetAll) //Prod func injected here
        customer.Load()
        //Do stuff...
    }
}
```
De test de classe client (comment test unitaire peut injecter un faux dépendance):
```
class CustomerUnitTests {
    static func GetFakeOrders() {
        var orders = ... //Hardcoded test data
        return orders
    }

    func TestLoad() {
        var customer = Customer(CustomerUnitTests.GetFakeOrders) //Fake func injected here
        customer.Load()
        //Verify results given known behavior of GetFakeOrders
    }
}
```
DISCUSSION:

Comment effectivement injecter le "pointeur de fonction" dépendra de la syntaxe et les fonctionnalités disponibles dans votre langue. Ici, je suis juste de parler du concept général.

Ce n'est pas exactement une jolie solution. Il serait probablement plus facile si vous pouvez changer GetAll à une méthode d'instance (peut-être par l'introduction d'un OrdersLoader objet, ou à l'aide de Paul Phillips réponse). Mais si vous voulez vraiment garder aussi une fonction statique, alors cette solution fonctionne.

OriginalL'auteur tboyce12

Vous devez vous connecter pour publier un commentaire.