[C#] Injection de dépendances

C’est un sujet assez populaire dans le monde du .NET. Une pratique de développement de plus en plus utilisée par les équipes de développement.

Nous allons voir ici de quoi il s’agit, et les erreurs à éviter dans l’implémentation d’injection de dépendances.

Définition

Une injection de dépendance est un pattern qui fait parti de ce que l’on appelle les IoC (Inversion Of Control) Containers. En .NET on en retrouve plusieurs parmis les plus connus : Spring.NET, Unity, Ninject… L’un ou plusieurs de ces noms doivent vous dire quelque chose 🙂

A savoir toutefois :

  • Vous pouvez effectuer une injection de dépendances sans avoir besoin d’un IoC container ou d’un outil externe.
  • Vous pouvez utiliser un IoC container sans faire d’injection de dépendance et, en fait, c’est une pratique extrêmement courante (qui n’est pas la plus top).

Partons d’un exemple de code et implémentation simple :

public class CustomerService : ICustomerService
{
private readonly CustomerRepository _customerRepository;

public CustomerService ()
{
_customerRepository = new CustomerRepository();
}

public Customer GetCustomerById(int id)
{
return _customerRepository.GetCustomerById(id);
}
}

Dans ce cas présent, notre service « CustomerService » est fortement dépendant du repository « CustomerRepository ». Il en a effet besoin pour requêter la liste des clients et en récupérer un en particulier.

Comment dans ce cas utiliser l’injection de dépendances pour éviter ce fort couplage ? On va utiliser une interface qui va servir de contrat pour le repository « CusomerRepository » :

public interface ICustomerRepository
{
Customer GetCustomerById(int id);
}

public class CustomerService : ICustomerService
{
private readonly ICustomerRepository _customerRepository;

public CustomerService (ICustomerRepository customerRepository)
{
_customerRepository = customerRepository;
}

public Customer GetCustomerById(int id)
{
return _customerRepository.GetCustomerById(id);
}
}

Et c’est ainsi fait ! En interfaçant ainsi notre repository, on découple ce lien entre notre service Customer et le Repository.

Il nous faut ensuite, via l’utilisation d’un des containers vus plus haut, configurer le mapping (Interfaces et implémentations) de nos injections de dépendances. Prenons ici l’exemple avec Unity :

private static IUnityContainer BuildUnityContainer()
{
var container = new UnityContainer();

container.RegisterType(typeof (ICustomerRepository), typeof (CustomerRepository));

return container;
}

A noter : ce mapping peut aussi bien se faire dans un app.config ou web.config. Ici nous l’avons fait directement en dur dans le code. Il peut être judicieux, pour des questions d’évolutivité, de placer ce mapping dans des fichiers de configuration !

Lien intéressant sur le sujet : https://www.martinfowler.com/articles/injection.html

Partagez:

Initiation WPF MVVM avec Prism et MEF

En ce moment, je travaille sur une application WPF utilisant Prism.
Du coup ca m’inspire pas mal pour en faire un article afin de partager les connaissances que j’ai pu glaner sur cette techno et ce pattern !

Quelques rappels tout d’abord :

Qu’est-ce que PRISM ?
Alors, Prism, c’est un Framework nous aidant à appliquer le pattern MVVM (Model-View-ViewModel) de façon à respecter les bonnes pratiques de conception/développement. Ceci afin de réaliser une application stable, facilement maintenable et testable !

Et MEF ?
Parfois, pour développer de grosses applications, on aura besoin de découper celle-ci en plusieurs modules fonctionnels.
MEF (Managed Extensibility Framework) est, comme son nom l’indique, un Framework permettant de développer des applications modulaires. Unity permet aussi de concevoir des applications modulaires comme MEF.
La spécificité de MEF c’est l’utilisation des attributs « Import » (utiliser des services) et « Export » (pour fournir des services).

Développons un exemple :

Contexte
On désire créer une application de gestion de classes pour des professeurs : les professeurs peuvent gérer les informations les concernant, ainsi que les informations de leurs élèves et les cours/classes associées.
Il s’agira donc de créer une application multi-fenêtrée (MDI) en WPF, dans laquelle on peut d’ores et déjà y voir 2 modules principaux : un pour tout ce qui concerne les élèves et professeurs, et un concernant les cours.

Définissons la base de données :

BDD

  Continuer la lecture de Initiation WPF MVVM avec Prism et MEF

Partagez:

[C#] Les méthodes d’extension

Définition

Pour commencer, une rapide définition des méthodes d’extension (ou Extension Methods) :
Ce sont des méthodes qui vous permettent d’ajouter des méthodes à un type, même si vous n’avez pas le code source pour le type.

Il existe déjà des méthodes d’extension dans le Framework .NET, qui se distinguent par un logo différent sur IntelliSense : une flèche bleue pointant vers le bas.
Par exemple la méthode « First<>() » présente dans l’espace « System.Linq; » :

Exemple d’application

Afin d’illustrer comment créer notre propre méthode d’extension, créons le besoin suivant : Nous avons besoin dans notre application d’avoir une méthode qui permette de mettre la première lettre d’une chaine String en majuscule. Cette méthode devra être une méthode « étendue » de la classe String.

Continuer la lecture de [C#] Les méthodes d’extension

Partagez:

[ASP.Net Ajax] Initiation

Je vais vous faire une brève présentation de l’utilisation d’Ajax avec la technologie ASP.Net :

Présentation

Nous allons créer une simple page qui permettra à l’utilisateur d’afficher l’heure actuelle lors d’un clic de boutton.

Pour cela nous utiliserons le composant UpdatePanel pour afficher dynamiquement du texte, ainsi que les différents boutons et labels nécessaires.

Page ASPX

Voici le code de la page ASPX, notez que nous avons obligatoirement besoin de la balise ScriptManager pour l’exécution :

Continuer la lecture de [ASP.Net Ajax] Initiation

Partagez:

Créer une application WPF avec MVVM

Pour commencer cet article, je vais faire une brève présentation du design pattern MVVM (Model View ViewModel) :

C’est une méthode d’architecture logicielle qui est une variation du design pattern MVC (Model View Controller), consistant à séparer les différentes couches entre développeur et designer. Le terme designer sera ici la personne plutôt chargée de l’aspect graphique et de la réalisation de l’interface utilisateur (au sein du XAML via des outils comme Expression Blend).
Les différentes parties étant bien distinctes, cela facilitera le travail en équipe sur un même projet. Surtout si l’on travaille avec TFS et que plusieurs personnes ont besoin de passer en checkout un fichier pour le modifier, ca risque de coincer 🙂

Schématisons ces différentes parties

Exemple de création d’une application WPF simple se basant sur MVVM

Continuer la lecture de Créer une application WPF avec MVVM

Partagez: