Introduction C#

Langage C# :

Dans ce cours, C# est utilisé afin d’assembler une application développée avec .NET.

La compilation en C# ne donne pas un programme binaire, contrairement au C et au C++. Le code C# est en transformé dans un langage intermédiaire (CIL ou MSIL) que l'on peut ensuite distribuer. Ce code, bien sûr, n'est pas exécutable lui-même.

Le code en langage intermédiaire (CIL) prend l'apparence d'un .exe comme les programmes habituels, mais il ne contient en revanche pas de binaire. Lorsqu'on l’exécute, il est lu par un autre programme (analyseur de programmes, appelée CLR) qui vérifie la sécurité du code et le compile en vrai programme binaire.

Il est possible de créer des programmes .EXE qui pourront directement être exécuté par le CLR, et également possible de créer des bibliothèques sous la forme d'un fichier possédant l'extension « .DLL ». On appelle ces deux formes de programmes des « Assembly », ayant une signature unique (Strong Name).

Les fichiers .EXE sont des Assembly de processus (lancer une application) et les fichiers .DLL sont des Assembly de bibliothèques (partagées entre plusieurs applications .exe afin de réutiliser du code déjà écrit). Le DLL doit résider dans le même répertoire que le fichier EXE.

On considère 2 types d’Assembly :

Privée : dédié à l’utilisation d’un programme particulier et se situe dans l’arborescence du programme qui l’utilise.
Partagée : utilisé par un ensemble de programmes différents et se situe dans le GAC (Global Assemblies Cache) où une vérification d’intégrité est effectuée lors de l’ajout.

Classes, Héritage, Polymorphisme…

L’orienté objet est un ensemble de règles, de concepts, d’outils du langage de programmation pour rendre le développement plus aisé grâce au groupement d’éléments.

Classe :

Le mot clé class est précédé par le niveau d'accès : Public signifie que n'importe qui peut créer des objets à partir de cette classe, Private restreint l’accès à la classe, Protected (recommandé), et Internal retire l’accès à toutes les méthodes et tous les éléments qui ne partagent pas la même Assembly (qui ne font pas parti du même fichier compilé).

Les méthodes peuvent retourner une valeur à l'appelant.

Si le type de retour, le type répertorié avant le nom de la méthode, n'est pas void, la méthode peut retourner la valeur à l'aide du mot clé return . Le mot clé return arrête également l'exécution de la méthode.

Si le type de retour est void, une instruction return sans valeur est quand même utile pour arrêter l'exécution de la méthode. Sans le mot clé return, la méthode arrête de s'exécuter quand elle atteint la fin du bloc de code.

Objet :

Bien qu'ils soient quelquefois utilisés l'un à la place de l'autre, une classe et un objet sont des choses différentes. Une classe définit un type d'objet, mais il ne s'agit pas d'un objet en soi. Un objet est une entité concrète basée sur une classe ; quelquefois appelé une instance d'une classe.

Lorsqu'une instance d'une classe est créée, une référence à l'objet est renvoyée au programmeur.

Constructeur :

À chaque fois qu'une classe ou qu'une structure est créé, son constructeur est appelé : il permet à l’utilisateur de définir des valeurs par défaut, de limiter l'instanciation et d'écrire un code souple et facile à lire. Si l’utilisateur n’en fournit pas, C# en créera un par défaut (sans paramètres).

Héritage de classe :

L'héritage se fait par le biais d'une dérivation, ce qui signifie qu'une classe est déclarée à l'aide d'une classe de base à partir de laquelle elle hérite des données et comportements (à l'exception des constructeurs).

Une classe peut être déclarée comme abstraite : elle contient des méthodes abstraites ayant une définition de signature mais aucune implémentation et ne peut pas être instanciées. En revanche, une classe sealed ne permet pas à d'autres classes de dériver d'elle.

Polymorphisme :

C’est le mot grec qui signifie « plusieurs formes » et il prend deux aspects distincts :

Au moment de l'exécution, les objets d'une classe dérivée peuvent être traités comme des objets d'une classe de base. Lorsque cela se passe, le type déclaré de l'objet n'est plus identique à son type au moment de l'exécution.
Les classes de base peuvent définir et implémenter des méthodes virtuelles et les classes dérivées peuvent les substituer, ce qui signifie qu'elles fournissent leur propre définition et implémentation. Au moment de l'exécution, quand le code client appelle la méthode, le CLR recherche le type et appelle cette substitution de la méthode virtuelle.

Les méthodes virtuelles permettent d'utiliser des groupes d'objets liés de façon uniforme.

Le polymorphisme peut être utilisé en deux étapes :

Créer une hiérarchie de classe dans laquelle chaque classe de forme dérive d'une classe de

base commune.

Utiliser une méthode virtuelle pour appeler la méthode appropriée dans une classe dérivée

via un seul appel à la méthode de classe de base.

Les membres virtuels :

Quand une classe dérivée hérite d'une classe de base, elle gagne toutes les méthodes, les champs, les propriétés et les événements de la classe de base. Le concepteur de la classe dérivée peut choisir de :

Substituer les membres virtuels dans la classe de base,
Hériter de la méthode de classe de base la plus proche sans la substituer,
Définir une nouvelle implémentation non virtuelle de ces membres qui masque les implémentations de la classe de base.

Une classe dérivée peut substituer un membre de classe de base, uniquement si le membre de classe de base est déclaré virtual ou abstrait . Le membre dérivé doit utiliser le mot clé override pour indiquer explicitement que la méthode est conçue pour participer dans l'appel virtuel.

Conversion de type et exception

Les types :

La bibliothèque de classes .NET Framework définit un ensemble de types numériques intégrés, ainsi que des types plus complexes de constructions logiques, telles que le système de fichiers, les connexions réseau, les collections et les tableaux d'objets, ainsi que les dates.

Le compilateur intègre les informations de type dans le fichier exécutable sous forme de métadonnées. Le Common Language Runtime (CLR) utilise ces métadonnées au moment de l'exécution pour garantir davantage la sécurité de type quand il alloue et récupère la mémoire.

Les types Built-in : Ensemble standard de types intégrés numériques (bool, float, int, etc.)

Les types de système commun (CTS) : Les types dérivés d'autres types, appelés types de base. Chaque type dans le CTS est défini soit comme un type de valeur (définit avec le mot clé struct ) ou d'un type de référence (définit avec le mot clé class ). Cela comprend tous les types personnalisés dans la bibliothèque de classes .NET Framework et aussi les types définis par l'utilisateur.

Les types personnalisés : créées en utilisant une structure, une classe, une interface ou une énumération. La bibliothèque de classes du Framework .NET est une collection de types personnalisés fournis par Microsoft.

Les types de valeur : Ils héritent directement de System.ValueType, qui hérite de System.Object et ont un comportement spécial dans le CLR. Ils contiennent directement leurs valeurs, ce qui signifie que la mémoire est allouée tant que la variable est déclarée.

Enum est utilisé pour déclarer une énumération.

Strcut est un type de valeur utilisé pour encapsuler des petits groupes de variables connexes. Une structure partage la même syntaxe que les classes.

Une structure peut implémenter des interfaces, mais ne peut ni déclarer un constructeur par défaut ou un destructeur, ni initialiser des champs sauf s’ils sont déclarées comme const ou static, ni hériter d'une autre structure ou de classe.

Contrairement aux classes, les structures peuvent être instanciées sans l'aide d'un opérateur new.

Les types de référence : défini comme une classe, délégué, tableau ou interface. Au moment de l'exécution, la variable contient la valeur null jusqu'à ce qu’il y ait création d’une instance de l'objet en utilisant l’opérateur new, ou assignation à un objet qui a été créé.

Cast et conversions de types :

C# est typé statiquement lors de la compilation : une fois déclarée, une variable ne peut donc plus être redéclarée ou utilisée pour stocker des valeurs d'un autre type, sauf si ce type peut être converti au type de la variable.

Toutefois, l’utilisateur peut avoir besoin de copier une valeur dans une variable d'un autre type. Par exemple, une variable de type entier doit passer à une méthode dont le paramètre est de type double. Ces types d'opérations sont appelés conversions de types :

Conversions implicites : aucune syntaxe spéciale n'est requise parce que la conversion est de type sécurisé et que les données ne seront pas perdues. Pour les types numériques intégrés, une conversion implicite peut être effectuée lorsque la valeur à stocker peut être stockée dans la variable en n’étant ni tronquée ni arrondie.

Pour les types référence, il existe toujours une conversion implicite entre une classe et l'une de ses interfaces ou classes de base directes ou indirectes. Aucune syntaxe spéciale n'est nécessaire parce qu'une classe dérivée contient toujours tous les membres d'une classe de base.

Conversions explicites (casts) : Si une conversion ne peut pas être faite sans risque de perte d'informations, le compilateur exige une conversion explicite, appelée cast. C’est une façon d'informer explicitement le compilateur que qu’une conversion va avoir lieu et qu'une perte de données peut se produire. Le programme ne se compile pas sans le cast.

Pour effectuer un cast, il faut spécifier le type voulu entre parenthèses devant la variable à convertir.

Les exceptions :

Les fonctionnalités de gestion des exceptions du langage C# aident à gérer les situations inattendues ou exceptionnelles qui surviennent pendant l'exécution. Les exceptions sont créées à l'aide du mot clé throw et leur gestion utilise les mots clés try, catch et finally .

Les exceptions peuvent être générées par le Common Language Runtime (CLR), par le .NET Framework ou des bibliothèques tierces ou par le code d'application.

Type anonyme, expression Lambda, Méthode d’extension

Méthodes d’extension :

Elles permettent d’étendre les fonctionnalités offertes par un type, en définissant de nouvelles méthodes qui seront invoquées en utilisant la syntaxe normale d’appel d’une méthode. Ce sont des méthodes statiques, déclarées en utilisant le mot clé this comme modificateur de portée, pour le premier paramètre de la méthode.

Expression Lambda :

Elles représentent un moyen plus simple d’écrire les méthodes anonymes. Elle est composée de 3 parties : une liste de paramètres, le signe =>, et une expression.

Les variables à gauche de l’expression sont les paramètres et l’expression à droite le traitement.

Les paramètres peuvent être explicites ou implicites. Dans le second cas, le type est déduit de l’expression.

Types anonymes :

C# 3 propose la possibilité de créer des types anonymes et de retourner des instances de ce type, au moyen du mot clé new .

LINQ (Langage Integrated Query)

Les requêtes LINQ est un langage de requêtage pour interroger des BD SQL, des documents XML, des collections .Net, etc. Exemple LINQ

Toutes les opérations de requêtage LINQ se déroulent en trois étapes :

Récupérer la source de données.
Créer la requête.
Exécuter la requête.

Dans le langage LINQ, l’exécution de la requête est indépendante de la requête en soit.

Exécution des requêtes LINQ :

Exécution différée : L’exécution s’effectue en différé lorsqu’il y a itération de ladite variable dans une boucle foreach .

Forcer l’exécution immédiate : Les requêtes qui exécutent des fonctions d'agrégation sur un intervalle d'éléments récupérés à partir d’une source de données doivent d'abord parcourir ces éléments. Ceci est le cas des requêtes Count, Max, Average et First. Ces requêtes s’exécutent donc sans expliciter la boucle d’exécution foreach . Ce type de requêtes retourne une seule valeur.

Afin de force l’exécution immédiate de n’importe quelle requête et stocker son résultat dans le cash, on peut faire appel aux méthodes ToList ou ToArray, ou bien en plaçant la boucle foreach directement après la déclaration de la requête.

Les requêtes LINQ de base :

Filtrage : Les requêtage de filtrage sont les plus utilisées. Il s’agit de filtrer une liste de données selon une expression booléenne.

L’exemple suivant illustre un filtre qui exclue tous les customers dont la « city » n’est pas London. Autrement dit ceux pour qui (cust.city == « london » ) = false

Ordonnancement : La clause orderby permet d’ordonner la séquence retournée selon le comparateur par défaut du type à ordonner.

Par exemple, la requête suivante retourne une liste de customers ordonnés par nom. Parce que name est de type string, le comparateur par défaut effectue un ordonnancement alphabétique de A à Z.

Groupement : La clause group permet de grouper les résultats selon une clé (key) qu’on spécifie. Chaque élément de la liste est un objet qui a une clé et une liste d’élément groupés selon cette clé.

Jointure : La clause join associe deux séquences d’éléments qui ne sont pas explicitement liés dans la source de données. On peut, par exemple, effectuer une jointure pour récupérer les customers et les distributors qui ont la même location.

Transformation des données avec LINQ :

Le LINQ permet aussi de transformer les données de maintes façons pour en créer un output différent. Il est possible de :

Joindre de multiples entrés dans une seule séquence de sortie.
Sélectionner un sous-ensemble de chaque élément source en :
- Sélectionner uniquement un membre de l’élément source. (Ex : select cust.City ; )
- Créer des éléments qui continent une ou plusieurs propriétés de l’élément source. (Ex : select new {Name = cust.Name, City = cust.City} ; )
Transformer des objets en mémoire en XML.

Types de relations dans les requêtes LINQ :

Les requêtes LINQ sont fortement typées aux éléments sources à l’intérieur de la requête ellemême et lors de l’exécution de la requête. Le type de variable à l’intérieur de la requête doit donc être compatible au type de l’élément source et au type de la variable d’itération. Les requêtes peuvent transformer ou pas la sources de données.

Introduction Framework .NET

Qu’est-ce que .NET ?

C’est un modèle de programmation unifié, une plate-forme de déploiement et d’exécution intégrée à Windows.

L'infrastructure de développement .NET Framework s'appuie sur la norme Common Language Infrastructure (CLI), ayant ainsi accès à toutes les bibliothèques installées dans l'environnement

d'exécution.

Composants de l’architecture .NET :

Common Language Runtime : moteur d'exécution.

Base Class Library : bibliothèque de fonctionnalités composées de classes, interfaces de types réutilisables.

Bibliothèque de classes portable : projet dans Visual Studio qui permet de développer et de construire des assemblages managés.

Managed Extensibility Framework (MEF) : bibliothèque pour créer des applications extensibles permettant d'utiliser les extensions sans aucune configuration requise.

Dynamic Language Runtime : fournit l'environnement d'exécution sous contrôle du CLR.

WinRT ou Windows Runtime API : fournit les éléments de l'interface utilisateur et donne accès aux fonctionnalités de l’OS.

Asp.Net : utilisé pour construire des applications web riche basé sur Internet.

Windows Store Apps : permet de profiter de nouvelles API de WinRT.

WPF : permet de créer des applications en incluant l'interface utilisateur, les 2D et 3D et le

multimédia. Il rend l'interface utilisateur plus rapide, évolutive et indépendante de la résolution.

Silver Light : technologie basée cross-browser web qui permet de fournir des applications Internet riches (RIA) embarqués dans des pages Web.

Ado.Net : utilisé pour créer la couche d'accès aux données.

LINQ : permet d'interroger les différentes sources de données (BD SQL, XML docs, jeux de données

ADO.NET etc.) à l'aide de requêtes SQL.

Ado.Net Entity Framework : utilisé pour interroger et stocker des données dans les BD relationnelles en mode ORM.

Parallel Extension : permet de distribuer le code sur plusieurs processeurs.

WCF : utilisé pour la construction et le développement de services basés sur les normes WS- *.

Asp.Net WebAPI : plateforme pour la construction de services http.

SignalR : bibliothèque simplifiant l'ajout de fonctionnalités Web en temps réel.

WF : utilisé pour construire un moteur de workflow de l'entreprise et les règles orientée processus.

Microsoft (/ Common) Intermediate Language : langage de programmation, de format intermédiaire, indépendant de la machine qui peut être converti en langage machine par le CLR.

Global Assembly Cache : permet de partager un Assembly au niveau d’une machine.

Architecture en couches :

Une application typique n-tiers comprend une couche de présentation, une couche intermédiaire et une couche d’accès aux données. La meilleure façon de les séparer est de créer des projets distincts pour chaque niveau. Cela augmente la maintenabilité et l'évolutivité de l'application, et permet l'adoption plus facile des nouvelles technologies appliquées à un seul niveau, sans revoir

l'ensemble de la solution.

Les principes SOLID :

SOLID combinés ensemble, permettent la création des logiciels faciles à entretenir et à étendre.

S – Single-Responsiblity Principle : un sous-système, un module, une classe ou une fonction ne

devrait pas avoir plus d’une responsabilité (un objectif).

O – Open-Closed Principle : les classes devraient être ouvertes pour l'extension, mais fermée pour modification (elle ne peut être modifiée que par extension, sans modification de son code source).

L – Liskov substitution Principle : si S est un sous-type de T, alors tout objet de type T peut être remplacé par un objet de type S.

I – Interface Segregation Principle : aucun client ne dépend de méthodes qu'il n'utilise pas.

D – Dependency Inversion Principle : Les modules de haut niveau ne doivent pas dépendre des modules de bas niveau. Les deux doivent dépendre d'abstractions. Les abstractions ne doivent pas dépendre des détails. Les détails doivent dépendre des abstractions.

Entity Framework

ORM (Object Relational Mapping) :

C’est un outil qui sert à manipuler d'une manière automatisée les données de l’objet vers la base de données relationnelle. L’ORM comprend trois parties principales qui sont les objets de classe, les objets de la BD et les informations de Mappage pour les objets de la BD (Tables, Vues et Procédures de stockage).

Entity Framework :

EDM (Entity Data Model) : ensemble de concepts qui décrivent la structure des données. Il se compose de trois parties principales :

Modèle conceptuel : contient les entités et leurs relations.
Modèle de stockage : modèle de conception de BD qui contient des tables, vues, procédures stockées, ainsi que leurs relations et les clés.
Mapping : contient des informations sur la façon dont le modèle conceptuel est mappé sur le modèle de stockage.

LINQ to Entities : permet d'écrire des requêtes par rapport au modèle conceptuel Entity Framework à l'aide du langage Visual Basic ou C#.

EntitySQL : langage similaire à SQL qui permet d'interroger des entités dans Entity Framework.

Object Service : composant d'Entity Framework qui vous permet d’insérer, mettre à jour et supprimer des données exprimées sous forme d'objets. Il prend en charge les requêtes LINQ et les requêtes Entité SQL par rapport aux types définis dans un modèle EDM (Modèle de données d'entité).

Entity Client Data Provider : fournisseur de données.

ADO.Net Data Provider : couche qui communique avec la BD en utilisant ADO.Net standard.

Approche de l’Entity Framework :

Approche ModelFirst : dans le cas d’absence de BD, il est possible de commencer par créer un modèle en utilisant le concepteur Entity Framework qui crée la BD et les classes en fonction du modèle.

Approche Database First : dans le cas d’existance de BD, Entity Framework permet de générer

automatiquement un modèle de données (.edmx) qui se contient des classes et des propriétés qui correspondent à des objets de la BD telles que les tables et colonnes.

Approche CodeFirst : dans le cas d’existance ou non de BD, il est possible de coder ses propres classes et propriétés qui correspondent aux tables et colonnes et de les utiliser avec Entity Framework, sans un fichier. Edmx.

Code first :

Entity Framework 6.1 introduit l’approche Code-First qui permet de se concentrer sur la conception de la couche domaine et commencer à créer des classes avant la BD.

Principe :

Générer la base à partir d’un traitement de code. Pour ce faire il faut écrire les entités, définir leurs propriétés de navigation, développer la classe contexte, déclarer les entités qui vont être des tables en tant que DbS et puis exécuter l’application, EF-Code First va générer la nouvelle BD. Le Mapping des classes dans la BD sera fait d’une manière implicite en utilisant les conventions par défaut. Il est aussi possible de configurer les entités en utilisant Data Annotation ou Fluent API afin de remplacer les conventions par défaut.

Création de la solution et installation de l’Entity Framework 6 :

La solution contient les 3 couches ; deux projets Domain, Data de type ClasseLibrary et un de type

Console.

Création du modèle de données dans le projet :

Il faut créer des entités et leurs propriétés de navigation dans la couche Domain.

Création de la classe contexte :

Une fois les entités créées, l’approche Code-First exige aussi la classe contexte dérivée de

DbContext et contient les DbSet représentants les entités qui seront ensuite transformées en tables.

DbSet, responsable de l'interaction avec les données, est une collection d’entités, donc prend généralement le nom de l’entité au pluriel. Les DbSet représentent une image d'une table, par

exemple représente la table Etudiants.

Exécution de l’application et génération de la base de données.
Les conventions :

C’est un ensemble de règles par défaut afin de configurer les entités de la couche domaine et sont définies dans le namespace System.Data.Entity.ModelConfiguration.Conventions .

Convention Primary Key : EFCode-First crée automatiquement une clé primaire dans chaque table.

La convention par défaut pour la clé primaire est Id ou Id. Si la propriété clé est définie autre que Id ou Id, l’exception « ModelValidationException » sera déclenché.

Convention les relations entre les entités : Code-First déduit la relation entre deux entités en utilisant la propriété de navigation, qui peut être de type « objet » ou de type « collection ».

Convention Clé étrangère : (recommandée) EF-CodeFirst insère automatiquement une clé étrangère lorsqu'il rencontre une propriété de navigation.

Convention ComplexType : Lorsque Code First découvre une définition de classe dans laquelle une clé primaire ne peut pas être déduite, et aucune clé primaire n'est enregistrée via des annotations ou Fluent API, le type est automatiquement enregistré en tant que type complexe.

Les types complexes n'ont pas de clés et par conséquent, peuvent uniquement exister en tant que propriétés de types entité (elles sont dépendantes), ne peuvent pas contenir des propriétés de navigation et ne peuvent pas avoir la valeur null.

Initialisation de la BD :

Le constructeur « base » de la classe GestComptecontext peut avoir les paramètres suivants : Aucun paramètre ou le nom de la BD (dans ce cas, EFCode-First crée une BD) ou nom de la chaine de connexion (qui doit commencer par "name =" sinon il sera considéré comme nom de BD).

Configuration des Entités de la couche domaine :

Il est possible de remplacer les conventions en configurant les classes de domaine pour fournir EF

les informations dont il a besoin. Il existe deux façons de configurer les classes :

DataAnnotations : basée sur un simple attribut, on peut l’appliquer sur les classes et ses propriétés.

Fluent API : utilisé dans le cas où certains attributs n’existent pas dans DataAnnotation. Il prend en charge les types Mappage BD et EntityTypeConfiguration.

Héritage :

L’héritage dans Entity Framework-CodeFirst est similaire à l'héritage pour les classes en C #.

Table-per-Hierarchy (TPH) : Cette approche suggère une table pour l'ensemble de la hiérarchie d'héritage de classe.

Table-per-Type (TPT) : Cette approche suggère une table séparée pour chaque classe.

Table-per-Concrete-Type (TPC) : Cette approche suggère une table pour une classe concrète, mais pas pour la classe abstraite.

Stratégies d'initialisation de la BD :

Il y a quatre stratégies d'initialisation de BD :

CreateDatabaseIfNotExists : l’initialiseur va créer la BD si aucune n’existe selon la configuration.

DropCreateDatabaseIfModelChanges : l’initialiseur supprime une BD existante et crée une nouvelle BD, si les classes de modèle ont été modifiées.

DropCreateDatabaseAlways : l’initialiseur supprime une BD existante à chaque fois qu’il y a exécution de l'application, indépendamment du fait que les classes de modèles ont changé ou non.

DB personnalisé Initializer : créer d’un initialiseur personnalisé.

Pour utiliser l'une des stratégies, il faut définir la DB Initializer en utilisant la classe de BD dans la

classe GestCompteContext.

Seed DataBase :

Insertion des données dans les tables de BD au cours du processus d'initialisation. Cela est utile pour fournir des données de test ou des données de base par défaut à l’application.

Pour insérer des données dans la BD, il faut ajouter un initialiseur personnalisé dans la méthode seed().

Migration :

Mise à jour automatique du schéma de la BD, lorsque le modèle change sans perdre toutes les données existantes ou d’autres objets de la BD. Il utilise une nouvelle initialisation de BD appelée

MigrateDatabaseToLatestVersion . Il existe deux types de migration :

Migration automatique : exécution de enable-migrations dans la console de gestionnaire de

package. Une fois la commande exécutée avec succès, il crée une classe interne de configuration dans le dossier de la migration dans le projet.

Migration basée sur le code : utile lors d’une volonté de plus de contrôle. Il faut exécuter la commande Add-migration puis update-database .

Utilisation des données dans Entity Framework :

Afin d’utiliser les données, EF offre 3 possibilités pour requêter la source de données :

Linq to Entities : (la plus utilisée) Utilisation d’un support de LinQ vers les entités. Elle offre l'avantage de la vérification des requêtes à la compilation et du support de l'autocomplétions.
Linq to Object : utilisation directe de requêtes LINQ avec n'importe quelle collection IEnumerable ou IEnumerable.

Design Patterns

Un patron de conception est un arrangement caractéristique de modules, reconnu comme bonne pratique en réponse à un problème de conception d'un logiciel.

Repository and Unit of Work Patterns :

Ils visent à créer une couche d'abstraction entre la couche d'accès aux données et la couche logique

métier d'une application. L'application de ces patrons de conception peut aider à l’application de changements dans la source de données et peut faciliter les tests unitaires automatisés.

Implémentation de pattern Repository :

Il faut commencer par créer une classe Repository générique qui englobe les CRUD destinées aux différentes entités. A chaque ajout de méthodes spécifiques à une entité EntityX il suffit d’étendre la classe Repositry par des méthodes d’extension.

Implémentation de pattern Unit of Work :

L'Unité de travail assure les mises à jour d’une source de données avec une seule transaction qui implique des opérations multiples d'insertion, modification, suppression, etc. Elle assure aussi

l’instanciation et le retour d’une classe Repository spécifique avec une méthode générique.

Disposable :

Il existe deux types de ressources dans le Framework .Net :

Les ressources gérées que le garbage collector peut supprimer quand il trouve des objets non référencés.
Les ressources non managées que le garbage collector ne peut pas gérer (Ex : les fichiers ouverts, les connexions de la BD...).

→ Utilisation de pattern Disposable qui est un patron de conception utilisé pour nettoyer des ressources non managées en fournissant un contrôle explicite et en mettant en œuvre la méthode Dispose fournie par l'interface IDisposable. L’appel de la méthode se fait après l’utilisation de l'objet.

La méthode Finalize () fournit une sauvegarde pour éviter la fuite de ressource définitive si le programmeur n’appelle pas Dispose.

Factory :

Avant de parler de ce patron de conception, il y a deux principes qui se dressent sur la base de nombreuses décisions de design et d'architecture.

Separation of Concerns (SoC) – garder le code pour chacune de ces concernes distincts. (Ex : la « logique d'entreprise » du logiciel est une concerne, et l'interface par laquelle une personne utilise cette logique est une autre.
Single Responsibility Principle (SRP) – C’est le premier principe des principes SOLID. Chaque objet doit avoir une responsabilité unique, et tous ses services doivent être étroitement aligné avec cette responsabilité.

La séparation permet de :

Travailler sur des morceaux individuels du système dans l’isolement ;
Faciliter la réutilisation ;
Assurer la maintenance d'un système ;
Ajouter de nouvelles fonctionnalités facilement ;
Permettre à chacun de mieux comprendre le système.

Par Conséquent, nous choisissons le patron Factory, qui sera responsable de l'instanciation du contexte et agira comme une usine qui crée l'objet de contexte. Cette classe peut être étendue en cas où l’utilisateur va ajouter une autre source de données.

ASP.NET

ASP (Active Server Pages) :

ASP.NET est un ensemble de technologies utilisé pour dynamiser les sites web. Pour cela, il faut qu’il y ait du code logique côté serveur.

ASP.NET inclut la génération du code HTML côté serveur, l’utilisation de la programmation orientée objet et des bibliothèques du framework .NET.

Il faut choisir avec quoi commencer l’application web, ASP.NET propose plusieurs modèles :

Le projet Vide : le projet sera créé à partir de zéro.
Le projet de WebForms : créer un projet ASP.NET Web Forms, basé sur les contrôles et le code évènementiel.
Le projet tourné vers MVC.
Le projet Web API : une application Internet préconfigurée avec le contrôleur Web.

Dès l’exécution de l’application, un fichier .DLL ainsi qu’un numéro de port sont générés. Ensuite, Visual Studio va démarrer IIS Express, qui est une version allégée de IIS. C’est le serveur web permettant d’exécuter une application ASP.NET. Visual Studio démarre ensuite le navigateur web et vous dirige automatiquement vers la page d’accueil.

La page web que visible à l’écran a été envoyée par le serveur IIS Express.

Introduction to C# and .NET Framework