CodeFluent Entities et l'ADO.NET : comprendre le positionnement relatif

1

CodeFluent Entitieset l’ADO.NET Entity FrameworkComprendre le positionnement relatif

Equipe R&DSeptembre 2014

2

3

CodeFluent Entities & Entity Framework

Table des matièresI. Introduction: Objectifs du document ................................................................................................II. Vue d’ensemble .............................................................................................................................. 1. Qu’est-ce qu’ADO.NET Entity Framework? ........................................................................ 2. Qu’est-ce que CodeFluent Entities ..................................................................................... 3. En résumé ........................................................................................................................ 4. Feuille de route actuelle et passée ..................................................................................... 5. Ce qu’ADO.NET Entity Framework apporte ........................................................................ 6. Ce que CodeFluent Entities apporte ................................................................................... 7. Intégration dans Visual Studio ............................................................................................ a. Entity Framework ...................................................................................................... b. CodeFluent Entities ..................................................................................................III. Comparaison des schemas de référence ...................................................................................... 1. Vue d’ensemble des concepts ............................................................................................ a. Entity Framework ...................................................................................................... b. CodeFluent Entities .................................................................................................. 2. Vue d’ensemble des concepts clés ..................................................................................... a. Entity Framework ...................................................................................................... b. CodeFluent Entities .................................................................................................. 3. Attributs d’entité et de propriété .......................................................................................... a. Entité - Entity Framework ......................................................................................... b. Entité - CodeFluent Entities ...................................................................................... c. Propriété - Entity Framework property ...................................................................... d. Propriété - CodeFluent Entities property ..................................................................IV. Fonctionnalités exclusives ............................................................................................................ 1. Editeur graphique ................................................................................................................ a. Rendu vectoriel ........................................................................................................ b. Moteur de recherche de forme ................................................................................. c. Modélisation Multi-Surfaces ...................................................................................... d. «Model Grid» ............................................................................................................ 2. Modélisation avancée ......................................................................................................... a. Format de stockage lisible ....................................................................................... b. Stockage Multi-Fichier .............................................................................................. c. Editeur de règles ....................................................................................................... d. Editeur de formulaire indépendant de la plateforme ................................................. e. Aspects et modélisation dynamique ......................................................................... 3. «DBA-Friendly» .................................................................................................................. a. Génération continue et Moteur de différence ........................................................... b. Vues persistantes ..................................................................................................... c. Convention de nommage .........................................................................................V. Défis «ouverts» pour Entity Framework & Orms ............................................................................VI. Ressources ..................................................................................................................................

2

456689

1010111212131414141515161717181921232424272829303030313233343535363745

4

IIntroduction

3

5

I. Introduction : objectifs du documentEn tant qu’éditeur de logiciel offrant une solution complète pour le développement d’applications .NET, y compris pour la production d’une couche métier reliée à la base de données, nous continuons de re-cevoir des questions sur le positionnement de CodeFluent Entities par rapport à ADO.NET Entity Framework.

A vrai dire, on voit de plus en plus d’articles positionnant Entity Framework comme étant la solution ultime d’accès aux données dans Microsoft .NET. La réalité sur le terrain est un peu différente car il y a aujourd’hui de nombreuses solutions pour accéder aux données en .NET, la plus utilisée et la plus éprouvée pour les applications de Business étant tout simplement l’ADO.NET «classique», sur laquelle tous les outils peuvent reposer.

Les techniques de Mapping Objet Relationnel étant devenues populaires, ADO .NET Entity Framework est susceptible de devenir l’ORM le plus populaire sur la plate-forme de Microsoft. Cependant, les outils d’ORMs ne traitent qu’un aspect d’accès aux données. Au-delà, vous devrez faire face à beau-coup de défis techniques pour fournir des applications qui répondent, de manière efficace, aux besoins de vos utilisateurs.

Les deux outils se présentent comme une abstraction d’une base de données. CodeFluent Entities est une réelle alternative à l’ORM Entity Framework. L’outil apporte une continuité dans la génération des scripts de base de données et du code orienté objet (.NET). Ce code reste toujours lisible et les déve-loppeurs n’en perdent pas le contrôle.

Ce document va vous fournir plus de détails à la fois sur CodeFluent Entities et sur ADO .NET Entity Framework d’un point de vue technique. Cela vous permettra donc de mieux comprendre le position-nement, et les différences entre ces deux produits.

© SoftFluent 2011-2014 – Ne pas copier sans autorisation.CodeFluent Entities est une marque déposée de SoftFluent. Tous les autres noms de produits sont des marques commer-ciales ou des marques déposées auprès de leurs détenteurs respectifs.Le contenu de ce présent document est sujet par nature au changement, n’est pas contractuel et il est diffusé à des fins d’information générale.


54

6

II Vue d’ensemble

5

7

II. Vue d’ensemble1. Qu’est-ce qu’ADO.NET Entity Framework ?«ADO.Net Entity Framework de Microsoft® est un Framework de Mapping Objet Relationnel (Object/Relatio-nal Mapping - ORM) qui permet aux développeurs de travailler avec des données relationnelles spécifiques au domaine métier, ce qui permet d’éliminer la plupart du code de plomberie d’accès aux données que les développeurs ont généralement besoin d’écrire. En utilisant Entity Framework, les développeurs utilisent des requêtes LINQ, pour extraire et manipuler les données sous forme d’objets fortement typés. La mise en œuvre d’Entity Framework fournit des services comme le suivi des modifications, la résolution d’identité, le « Lazy Loading », et la traduction des requêtes (LINQ en SQL) afin que les développeurs puissent se concentrer sur leur application métier plutôt que sur les principes fondamentaux d’accès aux données.

Vue d’ensemble des possibilités offertes par Entity Framework :

Fonctionne avec une diversité de serveurs de bases de données (incluant Microsoft SQL Server, Oracle et DB2)

Contient un moteur de « mapping » riche, qui permet de gérer les schémas de bases de données et fonctionne bien avec les procédures stockées

Fournit des outils intégrés à Visual Studio pour créer visuellement des modèles d’entités et auto-générer des modèles à partir d’une base de données existante. Les nouvelles bases de données peuvent être déployées à partir d’un modèle, et peuvent aussi être modifiées manuellement pour un contrôle total

Fournit un environnement « Code First » pour créer des modèles d’entités à partir de code source. « Code First » peut être lié à une base de données existante ou générer une base de données depuis le modèle.

S’intègre à tous les modèles d’application .NET, incluant ASP.NET, Windows Presentation Foundation (WPF), Windows Communication Foundation (WCF), et WCF Data Services (anciennement ADO.NET Data Services)

Entity Framework est basé sur le modèle de provider d’ADO.NET. Les providers existants sont régulièrement mis à jour pour prendre en charge les dernières fonctionnalités d’Entity Framework. Ainsi, les applications ba-sées sur ADO.NET peuvent être facilement portées sur Entity Framework tout en conservant un modèle de programmation similaire à ADO.NET»

Source: http://msdn.microsoft.com/en-us/data/aa937709

2. Qu’est-ce que CodeFluent Entities ?

CodeFluent Entities est un produit unique, intégré à Visual Studio 2008/2010/2012/2013, qui permet aux développeurs de générer des composants tels que des scripts de bases de données (T-SQL, PL/SQL, MySQL, Pg/SQL, etc.), du code (C#, VB.NET), des services web (WCF, JSON/REST) et des interfaces utilisateurs (Windows 8, ASP.NET, MVC, SharePoint, WPF).

Le processus de génération du code est basé sur le principe Model-First et se passe en continu à par-tir de votre modèle déclaratif, le méta-modèle étant traduit en code grâce à des générateurs de code. Plus de 20 générateurs de code (ou Producteurs) sont fournis et peuvent être combinés entre eux pour


6

8

créer vos propres applications qui suivent l’architecture que vous souhaitez, et tout cela en utilisant les techno-logies de votre choix.

Le développement de votre application est piloté par ce modèle, votre logique métier est découplée de la tech-nologie et vous permet d’absorber rapidement et en douceur les changements. Appliquer des modifications à votre modèle mettra à jour automatiquement toutes vos couches en continu. Ajouter ou changer une technologie se fait simplement, principalement en changeant la configuration des générateurs de code.

CodeFluent Entities est conçu pour la plate-forme .NET et permet aux utilisateurs de rationaliser les développe-ments sur les plates-formes de Microsoft telles que SharePoint, SQL Server, C#, VB.NET, WCF, ASP.NET, WPF, les plates-formes mobiles et bien plus encore.

Le produit s’étend aussi vers des territoires non-Microsoft, tels qu’Oracle Database, MySQL et PostgreSQL.CodeFluent Entities peut être vu comme un sur-ensemble de ce qu’Entity Framework fournit (bien que Code-Fluent Entities ne repose directement sur aucune partie d’Entity Framework).

L’architecte commence par définir un modèle métier dans un endroit centralisé, il choisit ensuite une plate-forme cible pour la génération ou une technologie (ne se limitant pas à l’accès aux données), il ne lui reste alors plus qu’à générer, et il peut le faire en permanence autant de fois que nécessaire, au fil de l’évolution du modèle et sans perdre les données précédemment sauvegardées.

Les développeurs n’ont plus qu’à écrire du code focalisé sur les aspects métiers et des interfaces utilisateurs personnalisées, en s’appuyant à la fois sur les objets fortement typés qui ont été générés par CodeFluent Enti-ties, et sur les nombreuses bibliothèques de ‘class’ et contrôle d’IHM fournies dans la bibliothèque Runtime de CodeFluent Entities, une bibliothèque disponible gratuitement.

Vue d’ensemble des possibilités offertes par CodeFluent Entities :

• Définit plus de 40 concepts indépendants de la plate-forme pour la conception d’applications (les enti tés, les propriétés, les méthodes, les formulaires, les règles, les instances ...),

• Génère automatiquement des fichiers spécifiques à une plate-forme à partir de ces concepts : schémas de bases de données, tables, colonnes, contraintes, vues, procédures stockées et les données d’initialisations, la couche .NET d’accès aux données correspondantes, les services WCF, la configuration et les Proxies, les règles, la documentation, les artefacts d’IHM,

• Fonctionne et s’intègre avec une variété de technologies (qui comprend Microsoft SQL Server, SQL Azure, Oracle Database, ASP.NET, SharePoint, Excel, WPF, Silverlight, Windows Forms, WCF),

• Fournit des outils intégrés à Visual Studio pour créer visuellement des modèles, importer des modèles à partir de modèles existants (base de données, diagramme UML, et des modèles d’Entity Framework), et enfin pour générer tous les fichiers spécifiques à une plateforme à partir de ces modèles,

• Autorise l’architecte à définir des Aspects pour définir des comportements et des contraintesspécifiques aux entités du modèle. Par exemple, l’Aspect « localisation » fourni dans CodeFluent Entities permet la localisa-tion des colonnes dans la base de données sans aucun travail supplémentaire. Le principe d’un aspect est qu’il est défini une seule fois et peut s’appliquer sur l’ensemble du modèle.


7

9


3. En résuméL’ADO .NET Entity Framework est un ORM et c’est une nouvelle solution fournie par Microsoft pour accéder aux données, au-dessus d’ADO.NET, en minimisant l’écriture manuelle de SQL. Comme son nom l’indique, l’ADO.NET Entity Framework se concentre aujourd’hui exclusivement sur la partie accès aux données et en particulier pour SQL Server. D’autres implémentations de bases de données sont fournies seulement par des tierces par-ties.

Bien qu’il soit un bon outil pour accéder aux données, les développeurs ont tout de même besoin de beaucoup plus que l’accès aux données basé sur du mapping pour disposer d’une application complète. Et c’est là que CodeFluent Entities entre en jeu.

L’idée est que CodeFluent Entities va générer tout le code de bas niveau récurrent, mais nécessaire, de l’appli-cation, et il peut également générer toutes les couches de l’application et la plomberie entre chacune d’entre elles. Il peut également générer des fonctionnalités plus complexes telles que la sécurité, l’internationalisation, la mise en cache, la recherche, la validation des données, et bien plus encore… Et tout cela se fait sans aucune ligne de code et sans utiliser d’outils supplémentaires.

En fin de compte, plus qu’un outil d’accès aux données, CodeFluent Entities vous permet de contrôler la pro-duction de code de toutes les couches de l’application, qui à leur tour fournissent une structure de travail pour l’équipe, ce qui minimise les risques et améliore la visibilité. En outre, grâce à son modèle centralisé et indé-pendant de la plate-forme, votre logique métier est découplée de la technologie et vous permet d’absorber en douceur les changements fonctionnels, tout en étant prêt à absorber les futurs changements technologiques.

8

10

CodeFluent Entities ne repose pas sur un ORM embarqué ni sur aucun outil tiers de ce type. Il ne se base que sur ADO.NET. Pour des scénarios spécifiques qui nécessiteraient absolument la génération de SQL dynamique, le produit fournit en standard deux producteurs spécifiques :

1) Un producteur « Linq-To-Sql », capable d’ajouter les attributs customs .NET nécessaire à la prise en charge de Linq-To-Sql, automatiquement,2) Un producteur « Entity Framework » permettant de générer un fichier .EDMX automatiquement à partir mo-dèle CodeFluent Entities.

Un importeur Entity Framework est également disponible, il permet de réutiliser le travail déjà fourni dans un modèle Entity Framework existant.

4. Feuille de route actuelle et passéeCodeFluent Entities est présent sur le marché depuis 2005. Des clients ont donc en production des applications développées avec CodeFluent Entities depuis des années et ils ont déjà pu effectuer des sauts technologiques facilités par l’approche de génération. La feuille de route suivante (mise à jour Juin 2014) démontre l’étendue technologique couverte par le produit.


9

11

5. Ce qu’ADO.NET Entity Framework apporte«Entity Framework vous permet de créer un modèle en écrivant du code ou en utilisant des boîtes et des lignes grâce au Designer Entity Framework. Ces deux approches peuvent être utilisées pour cibler une base de données existante ou créer une nouvelle base de données.»

Source: http://msdn.microsoft.com/en-us/data/ee712907

«Utiliser l’Entity Framework pour écrire des applications orientées données offre les avantages suivants:

Temps de développement réduit : le Framework fournit les fonctionnalités d’accès aux données fondamentales pour que les développeurs puissent se concentrer sur la partie métier.

Les développeurs peuvent travailler autour d’un modèle de données orienté application, incluant les types et l’héritage, les membres complexes, et les relations. Dans le Framework .NET 4, Entity Framework prend en charge la « Persistence Ignorance » au travers des classes Plain Old CLR Objects (POCO).

Les applications ne contiennent plus de code spécifique lié à un moteur de données particulier ou à un schéma de stockage.

Le mappage entre le modèle conceptuel et le schéma de stockage spécifique à l’application peut changer sans avoir besoin de modifier du code.

LINQ fournit une validation de la syntaxe des requêtes lors de la compilation pour le modèle conceptuel.

Entity Framework utilise l’Entity Data Model (EDM) pour décrire les objets ou les modèles conceptuels spé-cifiques à l’application pour laquelle le développeur programme. L’EDM se construit sur le modèle largement connu de l’Entity Relationship (introduit par le Dr Peter Chen) pour élever le niveau d’abstraction au-dessus du schéma logique de la base de données. L’EDM a été développé par Microsoft avec pour but premier de devenir le modèle de données commun à une suite de technologies serveur et d’outils de développement. Par conséquent un EDM créé pour être utilisé avec Entity Framework peut aussi être utilisé avec WCF Data Ser-vices (anciennement ADO.NET Data Services), Windows Azure Table Storage, SharePoint 2010, SQL Server Reporting Services, et SQL Server PowerPivot pour Excel, et bien d’autres à venir.»

Source: http://msdn.microsoft.com/en-us/data/aa937709

6. Ce que CodeFluent Entities apporte

Évidemment, Entity Framework comprend une partie commune avec CodeFluent Entities concernant l’accès aux données, mais CodeFluent Entities ne s’arrête pas sur ce seul point et fournit en plus :

• Des blocs de code complet permettant de gérer : la sécurité, le tri, la pagination, la liaison de données, l’internationalisation, la mise en cache, la recherche, le streaming d’objets binaires volumineux, l’intégration dans Office, etc...

• Un contrôle sur la génération de code : plus de contrôle sur les délais et les coûts tout en assurant une qualité de code homogène, en minimisant le travail sur le socle de l’application ainsi que sur d’éventuels «frameworks» internes.


10

12


• Une structuration pour le travail en équipe : la cohérence de programmation dans l’équipe de dévelop-pement en définissant implicitement comment les choses doivent être faites et ainsi éviter le «syndrome de Superman».

• L’absorption des changements fonctionnels : le processus de production en continu permet d’absorber les changements fonctionnels en douceur. Vous améliorez ainsi votre flexibilité et renforcez vos relations avec vos utilisateurs et partenaires.

• Le découplage de la technologie : ceci sécurise votre investissement en autorisant des changements technologiques, car il vous suffit d’ajouter à votre projet des plates-formes cibles différentes pour supporter de nouveaux scénarios y compris ceux qui ne sont pas encore identifiés aujourd’hui.

D’un point de vue purement technique, CodeFluent Entities supporte les technologies suivantes(en plus de SQL Server, pour l’accès aux données) :

• Base de données Oracle,• MySQL,• SQL Azure,• WCF,• ASP.NET WebForms & MVC• Silverlight,• WPF• SharePoint,• Office• MySQL• PostegreSQL• MariaDB• SQLite

Du point de vue de l’architecture, Entity Framework ne prend pas en charge les couches autres que la base de données et le modèle objet. Vous pouvez bien sûr les développer vous-même ou utiliser des outils externes mais cela apportera des coûts et des risques supplémentaires à votre projet. De son côté, CodeFluent Entities peut générer les couches suivantes qui seront, bien sûr, 100% fonctionnelles :

• La couche de service• La couche d’interface utilisateur• Et le plus important : une cohérence entre toutes les couches.

11

13

7. Intégration dans Visual Studio a. Entity Framework

Entity Framework 6 est intégré à Visual Studio 2012 et 2013 à travers un type de projet appelé Entity Data Model. Il existe aussi des versions sous Visual Studio 2008 et 2010 qui utilisent une version antérieure d’Entity Framework, mais celle-ci n’atteint pas les fonctionnalités de la version 2013.

Dans la pratique, l’Entity Data Model est intégré à un projet en C# ou en VB.NET, par conséquent, il n’est pas complètement model-first car il est déjà lié à un langage. En outre, cela démontre qu’Entity Framework est plus un nouveau modèle d’accès aux données qui est une surcouche d’ADO.NET (rappelez-vous son nom «ADO.NET Entity Framework»), plutôt qu’une solution complète pour construire le socle d’une nouvelle application.

b. CodeFluent EntitiesCodeFluent Entities est présent sur le marché depuis 2005 et est composé de deux modules principaux :

• Le Modeleur de CodeFluent Entities : il fournit une interface graphique totalement intégrée à Visual Stu-dio 2008/2010/2012/2013 et possède les mêmes fonctionnalités de .NET 2.0 à .NET 4.5. Dans la pratique, il ajoute un nouveau type de projet à Visual Studio avec lequel vous pourrez concevoir vos modèles, importer des modèles, et générer les fichiers correspondants en utilisant comme cibles d’autres projets de la solution Visual Studio.

• Le Meta Compilateur de CodeFluent Entities : c’est un moteur de génération de code via des producteurs dont le code généré est prêt à être utilisé pour les technologies suivantes : scripts (T/SQL, PL/SQL, MySQL, PostgreSQL, MariaDB, SQLite), classes C#, interfaces WCF (Silverlight, .NET), webParts SharePoint, WPF, synchronisation de List Office, WebControls ASP.NET & Site Web. Le code source produit par ce compilateur, parfaitement clair et lisible, est généré avec de bonnes pratiques utilisant des patrons de conception. Il est de plus écrit pour être testable, facilement maintenable et performant.


12

14

IIIComparaison des schémas de référence

13

15

III. Comparaison des schémas de référence Rappelons qu’Entity Framework est un ORM alors que CodeFluent Entities est une usine logicielle complète qui permet de faire du développement orienté Model-First. Par conséquent, CodeFluent Entities couvre des zones beaucoup plus vastes qu’Entity Framework. Ci-après, la liste des attributs et des copies d’écrans permettant de se faire une idée sur le nombre de concepts disponibles entre les deux produits.

1. Vue d’ensemble des concepts a. Entity Framework

• Entité• Propriété• Type complexe• Association (1-N, N-1, N-N, héritage)• Fonction• Enumération• Paramètre

b. CodeFluent Entities

• Entité,• Entité allégée (Lightweight Entity) (représente des objets légers, tel que des structures ou des class non persistantes),• Enumération (incluant le multi-valeur)• Propriété• Méthode• Paramètre• Instance (représente une ligne de données et peut être utilisée pour initialiser la base de données générée)• Schéma (traduit en schémas SQL par le producteur de persistance)• Stockage (un modèle peut avoir plusieurs sources de données)• Espace de nommage (un modèle peut avoir plusieurs espaces de nommage)• Catégorie (Utilisé par les producteurs IHM pour regrouper les entités)• Relation (1-1, 1-N, N-1, N-N, non persistante, héritage)• Type utilisateur (définis des types de données personnalisées par l’utilisateur)• Moteur de rendu (indique comment sont rendus les éléments de la couche d’interface utilisateur)• Attribut (traduit en attributs .NET par le producteur de Business Object Model)• Argument d’Attribut• Aspect (permet aux développeurs de travailler sur le modèle inféré de façon à effectuer des modifications à travers toutes les couches de l’application, par exemple pour activer la localisation des données)• Règles (événement, transaction, validation, autorisation, implémentation, personnalisation)• Vues (et les vues persistantes)• Message (localisation, documentation, ressources)• Formulaire (le design est indépendant de la plate-forme, qui sera ensuite traduit par des formulaires spécifiques dans les couches d’interface utilisateur)


14

16

2. Vue d’ensemble des concepts clés a. Entity FrameworkEntity Framework ne traite que des données liées à des éléments, ce qui est normal étant donné que ce n’est

qu’un ORM.


Voici un exemple de deux entités liées. Nous ne pouvons visualiser que les propriétés (de type standard, com-plexe ou navigation) :

15

17

b. CodeFluent EntitiesVoici le schéma équivalent (en style Modern UI car l’utilisateur peut configurer le rendu des surfaces graphiques) dans une surface CodeFluent Entities :

Et le même schéma comprenant un certain nombre d’autres concepts gérés par le produit et rendus visuellement :


16

18

Points d’importance :

• Les entités peuvent être groupées en « namespaces » (deux « namespaces » sont montrés ici)• La boîte “Customer” n’est en fait pas une boîte, mais une Tree View complète démontrant un ensemble de concepts soigneusement hiérarchisés. Par exemple, le concept Property a aussi des sous concepts de type Attribute, ou Rule, comme le concept Entity.• Le concept d’Instance est un des concepts exclusifs au produit. C’est une manière puissante de décrire les données associées à une entité donnée. Dans notre cas, les instances “Bill” et “Joe” définies au niveau du modèle permettront de les persister automatiquement en tant que lignes de la table Customer.• Le concept de Form représente une manière indépendante de la plateforme de décrire des formulaires IHM qui deviendront des formulaires spécifiques à la cible après génération (Web, WPF, etc.)

3. Attributs d’entité et de propriétéLes copies d’écran qui suivent visent à démontrer la différence d’approches entre les deux produits, une différence qui peut être facilement justifiée par le fait qu’Entity Framework est clairement positionné et limité à l’aspect «mapping» de la couche de données.

Nous ne comparons que les concepts d’entité et de propriété, car ce sont quasiment les seuls concepts mani-pulés par Entity Framework, alors que CodeFluent Entities reconnait plus de 40 concepts.

a. Entité - Entity Framework EntityVoici les éléments que vous obtenez au niveau d’une entité dans Entity Framework :


17

19

b. Entité - CodeFluent EntitiesVoici les éléments que vous obtenez au niveau d’une entité dans CodeFluent Entities (à gauche ceux de base, à droite une partie des éléments avancés, une partie seulement car il faudrait une capture d’écran supplémentaire pour toutes les afficher) :


Vue simple Vue avancée

18

20

c. Propriété - Entity FrameworkVoici les attributs que vous obtenez au niveau des propriétés d’une entité dans Entity Framework. Il est intéres-sant de noter que le champ Type ne contient que des Types de SQL Server :


19

21

Et voici la liste des types pris en charge par Entity Framework (elle reprend en fait les types gérés par SQL Ser-ver, à noter que les nouveaux types spatiaux occupent la majeure partie de la liste) :


20

22


d. Propriété - CodeFluent EntitiesVoici les attributs que vous obtenez au niveau des propriétés d’une entité dans CodeFluent Entities (une partie seulement est visible car étant limitée par la taille de la page, la grille des propriétés aurait besoin de deux pages pour être affichée entièrement):

Vue simple Vue avancée

21

23


Et voici la liste des types pris en charge par CodeFluent Entities :

Il faut noter que tout type CLR existant et sérialisable peut aussi être utilisé comme type de propriété. Tout comme Entity Framework, il est possible d’utiliser les types SqlGeography, SqlGeometry et SqlHierarchyId (http://www.softfluent.com/forums/codefluent-entities/sql-server-2008-geography-type).

22

24

IVFonctionnalités

exclusives

23

25

IV. Fonctionnalités exclusivesVoici quelques fonctionnalités exclusives du produit :

1. Editeur Graphique a. Rendu vectorielContrairement à l’éditeur graphique d’Entity Framework basé sur la technologie « DSL-tools » obsolète, le mo-deler graphique CodeFluent Entities utilise un rendu graphique vectoriel basé sur le moteur de composition de WPF, prenant donc en charge l’accélération matérielle. Voici un exemple d’une surface rendu au sein de Visual Studio avec un effet de zoom important :


24

26


Au contraire, tout ce qui sort du cadre « textuel » est rapidement dégradé avec le Designer d’Entity Framework. De plus, le niveau de zoom est limité :

25

27

L’utilisateur a aussi accès à un menu lui permettant de customiser le rendu des surfaces graphiques, à l’aide de styles prédéfinis ou spécifiques :


26

28

b. Moteur de recherche de formeLe Shape Search Engine permet une recherche visuelle rapide à travers plusieurs dizaines de formes graphiques :


27

29

c. Modélisation Multi-SurfaceL’utilisateur peut définir autant de surfaces de travail graphiques qu’il le souhaite. Chaque surface est définie par une liste de « selectors ». Chaque sélecteur détermine quelles formes seront sélectionnées pour être dessinées sur cette surface. Par exemple dans l’image ci-dessous, l’utilisateur est en train de créer une surface qui ne comprendra que les formes dans un « namespace » nommé “Sales”:


28

30

d. «Model Grid»La « Model Grid » est une fonctionnalité d’édition spécifique et exclusive qui combine une Tree View et une List View et permet une édition de masse à travers l’ensemble des concepts du modèle, avec une navigation au clavier possible. En utilisant les boutons à gauche (des boutons customs peuvent être ajoutés), l’utilisateur peut sélectionner (on/off) les concepts qui doivent être ajoutés à la grille ou pas. La grille utilise les mêmes éditeurs que la Property Grid standard de Visual Studio. Dans l’exemple ci-dessous, l’utilisateur est en train de modifier l’instance “Bill” de l’entité Customer :


29

31


2. Modélisation avancée a. Format de stockage lisibleUn modèle CodeFluent Entities est entièrement stocké dans un ou plusieurs fichiers XML. Le schéma XML utilisé est facile à comprendre et le XML résultant lisible par des humains. Il est aussi facile à modifier avec un éditeur XML standard en dehors de Visual Studio. Voici à titre d’exemple un modèle définissant deux entités dans deux « namespaces » différents, avec quelques propriétés, dont une relation (Orders <-> Customer), et deux instances de l’entité Customer :

b. Stockage Multi-FichierLe format de stockage est XML mais un modèle CodeFluent Entities peut être stocké physiquement sur plu-sieurs fichiers XML. C’est à l’utilisateur de décider quel concept sera stocké dans quel fichier. Par exemple, on peut associer les fichiers aux « namespaces », ou spécifier un fichier par concept, ou tout autre découpage approprié à l’organisation du projet.

Cette fonctionnalité est extrêmement utile dans un contexte de travail en équipe (chaque équipe est alors res-ponsable de certains fichiers), ou quand les modèles ont une taille importante (plusieurs centaines d’entités), ou dans des environnements de travail sous contrôle de source (le fichier devient l’unité de travail/checkout/checkin).

30

32


c. Editeur de règlesLe sous-concept de Rule dans CodeFluent Entities peut s’appliquer aux concepts Project, Entity, Method, et Property. On trouve non seulement les règles de validation (IDataError, Data Annotations, etc.) sur les proprié-tés mais aussi des règles de transaction, de sécurité, de cycle de vie, ou des règles spécifiques développées dans le cadre du projet, etc.

Le modeler graphique inclut un éditeur de règles complet qui prend ces concepts en charge intégralement :

Le producteur Business Object Model (celui qui génère les classes .NET principales) se base entre autres sur ces règles pour générer du code automatiquement.

31

33


d. Editeur de formulaire Indépendant de la plateformeCodeFluent Entities définit un ensemble de concepts orientés IHM : Form, Tab, Zone, Column, Field, etc.

Ces concepts sont pris en charge par les producteurs IHM récents livrés en standard : Producteur ASP.NET V2 (avec 3 modèles : Ajax/JQuery/jqGrid, ASP.NET MVC 3 and ASP.NET WebForms classic), Producteur Smart Client, et Producteur SharePoint WebParts.

Le modeler graphique inclut un éditeur de formulaire indépendant de la plateforme qui permet à un développeur la modélisation de formulaire attachés à une entité donnée :

32

34


e. Aspects et modélisation dynamiqueCodeFluent Entities introduit une fonction unique, les “CodeFluent Aspects”. Les aspects sont des programmes .NET, écrits par un utilisateur du produit (en général un architecte), qui vont fonctionner pendant la phase d’infé-rence d’un modèle, avant la génération de code à proprement parler. Le nom vient de l’impact important qu’ils peuvent avoir sur le comportement des concepts qu’ils prennent en charge.

Par exemple, si un aspect custom ajoute une propriété “MyProp” dynamiquement et par programmation à toutes les entités d’un modèle, le moteur d’inférence va ajouter automatiquement tous les artefacts correspondants dans toutes les couches générées, comme les colonnes aux tables, les paramètres au procédures stockées, les expressions au code des procédures, le code .NET de sauvegarde dans les classes métier, les arguments aux interfaces WCF, etc., de la même manière que si la propriété avait été ajoutée manuellement par l’utilisateur à l’aide du modeleur graphique à toutes les entités du modèle.

Les aspects permettent réellement de mettre en œuvre le concept de “Software Factory”, avec l’automatisation de tout comportement commun à plusieurs concepts. Les modèles de taille importante bénéficient énormément de cette fonctionnalité.

Ces programmes Aspect (C# ou VB.NET) peuvent être stockés directement dans le XML (à l’aide de morceaux de code « snippet »), ou peuvent être compilés dans des assemblies externes, éventuellement dans la même solution Visual Studio. Ils peuvent aussi parfaitement être partagés entre plusieurs modèles, si leur propos est générique et réutilisable à travers différents scenarios. Pour fonctionner, ils utilisent l’API de CodeFluent Entities (« M3 »). Les Aspects peuvent être eux-mêmes auto-descriptifs à l’aide de métadonnées, afin de permettre leur accès au sein de Visual Studio au développeur qui n’a pas écrit l’aspect mais qui l’utilise, comme le montre l’image ci-dessous.

Le produit est livré en standard avec des aspects officiels. Un des plus utilisé est l’aspect “Localization” qui per-met la localisation de la base de données pour les propriétés d’une entité. L’aspect se charge automatiquement de la création des tables localisées, des colonnes, des vues persistantes, des procédures stockées, et du code .NET permettant de stocker les variantes localisées d’une propriété donnée.

Pour activer cet aspect sur une propriété donnée, un développeur se contente d’ajouter l’aspect au projet, et de déclarer quelles propriétés seront localisables :

33

35

3. «DBA-Friendly»CodeFluent Entities n’est pas un ORM. C’est un outil « model-first ». Cela signifie que la base de données n’a pas besoin d’être modélisée à part, et le code .NET non plus, car l’outil va en fait générer l’ensemble du code nécessaire (SQL, .NET, autre…) automatiquement à partir d’un modèle unique et centralisé.

Ceci étant dit, le code généré (base de données, et.NET) a été soigneusement revu et optimisé pour se rap-procher le plus possible de ce qu’un humain pourrait écrire « à la main », mais avec moins de risques d’erreur.

Cela signifie aussi que ce code en question va être généré au moment de la modélisation (ou de la génération), et non à l’exécution. CodeFluent Entities ne repose pas sur du code dynamique cryptique (.NET ou SQL) que vous n’aurez jamais l’occasion de comprendre, de déboguer, ou même de remplacer si vous ne l’aimez pas. Puisque le code est généré à l’avance, vous pourrez l’analyser et le comprendre. Puisque le produit repose sur l’utilisation des procédures stockées pour l’accès aux données, (sur SQL Server, Oracle Database et MySQL), vous pourrez aussi choisir de réécrire certaines des procédures générées si vous pensez pouvoir faire un meil-leur travail que la machine.


Model

1. Inference

2. Generation

Meta-Compiler

Aspects

.SQL code(SQL Server, MySQL,

Oracle, ...)

.NET Code(C#, VB.NET)

UI Code(ASP.NET, WebParts, XAML,...)

34

36

a. Génération continue et Moteur de différenceLe producteur SQL Server est équipé d’un moteur de différence qui permet une génération continue à partir du modèle, avec conservation des données existantes. Autant que possible, ce système va juste créer les tables, ajouter les nouvelles colonnes, supprimer les anciennes, ainsi que les contraintes d’intégrité nécessaires au modèle en cours, sans toucher aux données déjà écrites dans la base de développement.

b. Vues persistantesLe concept de View dans CodeFluent Entities est assez large. Une vue modélisée peut être traduite par le moteur d’inférence en une vue persistante (mais pas nécessairement, par exemple les producteurs orientés IHM utilisent les vues directement, non les vues persistantes). Le produit est donc fourni avec un éditeur de vue :


35

37

c. Convention de nommagePuisque CodeFluent Entities est un outil orienté DBA, et « model-first », il permet de choisir une convention de nommage adaptée pour le code SQL généré. Par défaut, le produit est livré avec des conventions de nommage standard, mais vous pouvez écrire une convention spécifique ou dérivée d’une convention existante. Cette option se trouve dans les propriétés du Project CodeFluent Entities :


36

38

VDéfis «ouverts»

pour Entity Framework et les ORMs

37

39

V. Défis «ouverts» pour Entity Framework et les ORMsEn prenant Entity Framework comme exemple, nous avons compilé une série de questions et de discussions qui démontrent que le chemin qui permettra de démocratiser l’approche du développement des applications business via des ORMs est encore long, si tant est qu’il permettrait de résoudre toutes les difficultés inhérentes aux applications.Les questions ci-dessous sont extraites de sites en anglais et montrent les enjeux qui restent «ouverts» pour les utilisateurs qui tentent d’appliquer une approche purement basée sur un ORM.

“Comment utiliser EF6 pour mettre à jour table ayant une relation Many-to-Many”, “Entity Framework : mapper une procédure stockée sur une entité EF existante “

“SQL Variant dans EF“, “SQL Server 2008 types de données et EF“

“Entity Framework CTP5 - Comment appeler une procédure stockée ?”

“Entity Framework CTP5 - Comment appeler une procédure stockée ?”

http://stackoverflow.com/questions/21289340/how-can-i-use-ef6-to-update-a-many-to-many-table

http://stackoverflow.com/questions/4739806/entity-framework-mapping-sproc-results-to-existing-ef-entity

http://stackoverflow.com/questions/4789788/entity-framework-ctp5-how-to-call-stored-procedure

http://social.msdn.microsoft.com/Forums/eu/adonetefx/thread/0862812c-b9a8-451f-ad1d-af478a21cce0

http://www.codeproject.com/KB/database/sql_variant_in_ef.aspx

http://thedatafarm.com/blog/data-access/sql-server-2008-data-types-and-entity-framework-4/

Entity Framework est très limité par les types qu’il prend en charge. En effet, il ne prend pas en charge complè-tement les énumérations .NET, les types définis par l’utilisateur dans SQL Server (UDT), les types «sql_variant» dans SQL Server, les objets .NET personnalisables (même ceux sérialisables). CodeFluent Entities fait tout cela.

“EF Performance : ComputeHashValue() lors de la compilation d’une requête”

“Pourquoi mon code fait toujours du Lazy Loading alors que j’ai désactivé toutes les options possibles ?”

“L’ordre des clauses LINQ devrait-il influer sur les performances d’Entity Framework ?”

“Le temps d’exécution de LINQ to SQL est 50 fois supérieur à celui d’une requête SQL dans le SSMS”

http://stackoverflow.com/questions/23360660/ef-performance-computehashvalue-in-query-compilation

http://stackoverflow.com/questions/22626976/why-is-my-code-doing-lazy-loading-even-after-i-turned-it-off-at-every-possible-p


38

40

http://stackoverflow.com/questions/17323547/should-the-order-of-linq-query-clauses-affect-entity-framework-performance

http://stackoverflow.com/questions/14928939/linq-to-sql-execution-time-is-50x-longer-than-ssms-sql

La génération du code produit par CodeFluent Entities est parfaitement prédictible et il est possible d’agir sur celle-ci afin de résoudre d’éventuels problèmes de performances. Cet article, http://blog.codefluententities.com/2014/03/27/fetch-performance-of-codefluent-entities/, illustre parfaitement les capacités d’adaptation de CodeFluent Entities du point de vue de la génération.

“Meilleure option pour supprimer en cascade dans Entity Framework”

“Comment fonctionnent réellement les suppressions en cascade dans EF”

“Suppression en cascade sur les entités dérivés”

http://stackoverflow.com/questions/22582585/best-option-to-cascade-delete-in-entity-framework

http://blogs.msdn.com/b/alexj/archive/2009/08/19/tip-33-how-cascade-delete-really-works-in-ef.aspx

http://stackoverflow.com/questions/13461534/cascading-deletes-on-derived-entities

http://social.msdn.microsoft.com/Forums/en-US/040e7eaa-a561-4c3b-84af-851e5ec67c60/delete-does-not-cascade-to-inherited-entity-tables?forum=adodotnetentityframework

Les suppressions en cascade sont pleinement supportées par CodeFluent Entities.

«Entity Framework 4 – Manipulation de gros modèles de données (plus de 1000 tables) ?»

“Plusieurs diagrammes dans un modèle, un gros fichier EDMX, plusieurs fichiers EDMX […] Quelle est la meilleure option ?”

http://stackoverflow.com/questions/2981054/entity-framework-4-handling-very-large-1000-tables-data-models

http://stackoverflow.com/questions/14956785/multiple-diagrams-in-model-vs-one-large-edmx-vs-multiple-edmx

We have customers using CodeFluent Entities (even 32-bits version) with models containing more than 600 entities.

“Entity Framework 4 Generate Database From Model With Multiple Schemas”

http://stackoverflow.com/questions/3669766/entity-framework-4-generate-database-from-model-with-multiple-schemas

Nous avons des clients qui utilisent CodeFluent Entities (même la version 32 bits) avec des modèles contenant plus de 600 entités.

“Entity Framework 4 : générer une base de données à partir d’un Model avec de multiple Schémas”

http://stackoverflow.com/questions/3669766/entity-framework-4-generate-database-from-model-with-multiple-schemas


39

41

Entity Framework ne prend pas en charge les fonctionnalités de regroupement que ce soit sur des schémas de base de données ou des « namespaces » .NET. CodeFluent Entities le prend en charge aussi bien pour les schémas de bases de données que pour les « namesapces » .NET, et offre en plus la possibilité de les mapper automatiquement.

“Entity framework: Besoin d’une solution facile, pour la migration de bases de données”

“EF – Recréer la base de données si le modèle change“

“Garder le contenu d’une base de données lors du changement d’un modèle”

http://stackoverflow.com/questions/4580776/entity-framework-need-a-easy-going-clean-database-migration-so-lution

http://stackoverflow.com/questions/5463121/keep-database-content-on-model-change

Entity Framework ne permet pas d’appliquer la différence de structure entre deux versions de modèle de base de données. CodeFluent Entities est capable de mettre à jour une base de données SQL Server en continu pour chaque modification apportée au modèle, tout en préservant les données existantes (dès lors que c’est techni-quement possible).

“Comment éviter d’écrire beaucoup de code répétitif pour la mise en place du mapping ?”

http://stackoverflow.com/questions/4542561/how-to-evade-writing-a-lot-of-repetitive-code-when-mapping

http://stackoverflow.com/questions/4531128/entity-framework-many-to-many-relationship-include-extremely-slow

C’est la principale raison pour laquelle nous avons créé CodeFluent Entities. Quel que soit l’outil d’ORM que vous allez utiliser, vous aurez toujours beaucoup de code répétitif à écrire, ou allez devoir définir des modèles personnalisés complexes que vous aurez par la suite besoin de maintenir, ou encore d’utiliser divers outils de tierce partie ce qui va introduire une gestion des dépendances dans votre organisation.with the following model (XML version):

Le code SQL de la procédure stockée généré serait tout simplement :


40

42

“Comment mettre à jour une entité nouvellement créée à partir d’une nouvelle entité”, “Y a-t-il une solu-tion pour faire des copies en cascade d‘entités avec Entity Framework ?”

http://stackoverflow.com/questions/2358575/how-to-update-entity-from-new-created-detached-entity

http://stackoverflow.com/questions/7326489/is-there-a-way-to-accomplish-cascading-copies-of-entities-in-enti-tyframework

CodeFluent Entities implémente automatiquement les méthodes Clone et CopyTo dans vos entités.

“Manipulation de BLOB dans la version 4.0 d’Entity Framework”

http://stackoverflow.com/questions/4784367/handling-blobs-in-entity-framework-4-0-in-a-stream-fashion

CodeFluent Entities définit des types avancés tels que «fichier», «image», «vidéo», «audio» et «blob». Lorsque ces types sont utilisés dans des propriétés, le producteur va générer du code dans toutes les couches de l’appli-cation qui apporteront des capacités de développement supplémentaires, tels que le streaming de bout en bout (y compris les accès séquentiels à partir d’une base de données), la mise en cache, les métadonnées (nom de fichier, taille du fichier, les attributs, le type de contenu), la création de vignettes, et le Binding automatique (Win-forms, WPF). Il n’existe pas à ce jour sur le marché d’autre outil permettant l’équivalent.

“Comment créer une entité en lecture seule avec Entity Framework ?”

http://stackoverflow.com/questions/4828935/how-to-create-read-only-entity-in-entity-framework

Cela démontre qu’Entity Framework a été développé essentiellement en ayant à l’esprit le concept d’accès aux données. CodeFluent Entities supporte quant à lui les Entités non persistantes.

“Comment s’en sort EF4 comparé à NHibernate ?”

http://stackoverflow.com/questions/4847210/how-does-ef4-compare-with-nhibernate

Cet article détaille certains points noirs à propos d’Entity Framework.

CodeFluent Entities ne présente aucune de ces faiblesses :

• Il dispose d’une prise en charge complète des énumérations. Vous pouvez modéliser et générer une énumération ou en réutiliser une existante à partir d’une Assembly déjà compilée• Il définit la notion de convention de nommage, et est livré avec quelques-unes d’entre elles. Vous pouvez bien sûr développer les vôtres• Il génère du code humainement lisible• Il prend en charge les traitements par lots de suppressions (batchs)• Il supporte les évolutions du modèle et les compilations continues• Il possède de nombreux points d’extension à tous les niveaux

“Stack trace apparemment infinie dans EF 4.0 et performances moyennes des requêtes lors de la mon-tée en charge“, “LINQ to SQL remonte une StackOverflowException”

http://stackoverflow.com/questions/6978207/seemingly-infinite-stack-trace-in-ef-4-0-and-poor-query-perfor-mance-under-load


41

43

http://stackoverflow.com/questions/5744764/linq-to-sql-throwing-a-stackoverflowexception

Ces articles démontrent à quels points il peut être difficile de déboguer du code d’accès aux données qui a été généré à l’exécution et de manière dynamique. C’est pourquoi CodeFluent Entities génère des procédures stockées claires, prédictibles et humainement lisibles, que l’on appelle tout simplement via des méthodes .NET.

“Comment stocker des images en utilisant Entity Framework Code-First de la CTP 5 ?“

“Enregistrer un fichier dans une base de données SQL Server 2008 avec Entity Framework”

http://stackoverflow.com/questions/4653095/how-to-store-images-using-entity-framework-code-first-ctp-5

http://stackoverflow.com/questions/5370351/save-a-file-in-sql-server-2008-database-with-entity-framework

Les Blobs (par exemple les images, les vidéos, les documents, l’audio) sont des types natifs dans CodeFluent Entities, la manipulation des propriétés de type Blob est totalement transparente à travers toutes les couches de l’application. En outre, les blobs sont manipulés à l’aide de « streams » à travers toutes les couches de votre application (et non des tableaux d’octets).

“Comment puis-je ajouter des contraintes à une entité ADO.NET ?”

http://stackoverflow.com/questions/1963829/how-can-i-add-constraints-to-an-ado-net-entity

CodeFluent Entities supporte ces caractéristiques depuis le premier jour.

“EF avec Azure – Mixé SQL Server et Windows Azure Storage”

http://stackoverflow.com/questions/7580649/ef-with-azure-mixing-sql-server-and-windows-azure-storage

Une autre caractéristique fournie par défaut dans CodeFluent Entities et qui ne nécessite aucune ligne de code supplémentaire à fournir par le développeur. Les développeurs peuvent choisir de stocker leurs blobs dans la base de données (par défaut), dans Windows Azure Blob Storage, ou dans un répertoire NTFS sur un serveur.

“Ajouter une documentation XML, des commentaires aux propriétés et aux champs dans les classes générées par EF“

http://stackoverflow.com/questions/7672627/add-xml-documentation-comments-to-properties-fields-in-ef-gene-rated-classes

En utilisant CodeFluent Entities vous pouvez documenter le code généré, sans avoir à utiliser d’autre outil, ni à devoir créer des modèles personnalisés.

“Comment faire pour ajouter des lignes dans l’ordre avec EntityFramework”

http://stackoverflow.com/questions/5159824/how-to-make-entityframework-add-rows-in-order

L’enregistrement dans des champs de type auto-incrémental est entièrement pris en charge dans CodeFluent Entities.


42

44

“Comment dois-je faire pour gérer les colonnes CreatedOn et ModifiedOn avec EF 4.1 ?”

http://stackoverflow.com/questions/5543639/how-should-i-annotate-createdon-and-modifiedon-columns-with-ef-4-1

Le suivi des colonnes est automatiquement généré (par défaut) et intégralement pris en charge dans Code-Fluent Entities.

“Internationnalisation du contenu dans Entity Framework”

http://stackoverflow.com/questions/11085205/internationalization-of-content-in-entity-framework

L’aspect de Localisation fournit en standard dans CodeFluent Entities permet de mettre en place un système linguistique simplement et de manière relativement transparente au niveau du modèle de données.

“Horodatage généré automatiquement dans le gestionnaire de l’entité“

http://stackoverflow.com/questions/6087083/autogenerated-timestamp-in-entity-manager

CodeFluent Entities génère automatiquement une colonne timestamp (ou rowversion) qui est disponible sur toutes les plateformes (exemple Oracle, SQL Server, SQL Azure) et qui ne nécessite aucune ligne de code pour être implémenté.

“Traiter avec DateTime à l’aide de méthodes Linq”

http://stackoverflow.com/questions/6253905/dealing-with-datetime-using-linq-methods

Avec CodeFluent Entities, les valeurs dans la base de données sont automatiquement converties en valeurs du modèle objet et vice versa, et toutes ces conversions utilisent des valeurs par défaut afin que les développeurs n’aient jamais à lutter avec les nulls ou DbNulls.

“LINQ – Exécuter une requête avec une clause WHERE sur environ 6000 enregistrements”

http://stackoverflow.com/questions/8730879/linq-querying-about-6000-unique-records-by-where-clause

Les requêtes de ce type sont parfaitement prises en charge par CodeFluent Entities et ne nécessitent aucune ligne de code supplémentaire.

“LINQ to Entities ne reconnaît pas la méthode Parse(System.String) du type Double, et cette méthode ne peut pas être traduite en une expression de base de données“, “problème lors de la suppression en cascade avec Entity Framework”

http://stackoverflow.com/questions/5971521/linq-to-entities-does-not-recognize-the-method-double-parsesys-tem-string-met

http://stackoverflow.com/questions/6297657/ef4-1-fluent-api-sqlquery-configuration-mappings-when-calling-sproc-data


43

45

CodeFluent Entities, pour sa part est conçu pour être apprécié des DBAs grâce au code clair qu’il génère, ces sujets étant tous gérés nativement et sans nécessité de code supplémentaire.

“Entity Framework T4 objets POCO remonte une exception dans WCF”

http://stackoverflow.com/questions/7073147/entity-framework-t4-poco-objects-raising-exception-in-wcf

En utilisant CodeFluent Entities, les classes .NET générées peuvent être utilisées sur toutes les plates-formes côté client et serveur (comme par exemple Windows Forms, WPF, ASP.NET, ASP.NET MVC, WCF, WF, Silver-light, SharePoint).

“Mise à jour vers la dernière version de EF (4.1) à partir de la CTP - Comment faire pour remplacer les Under scores généré dans les clés étrangères”

http://stackoverflow.com/questions/7487746/upgraded-to-the-latest-ef-4-1-from-ctp-how-do-we-override-under-scores-genera

CodeFluent Entities permet aux développeurs de personnaliser comme ils le souhaitent les conventions de nommage, ce qui leur permet de changer la manière dont tous les objets sont nommés (comme par exemple les tables, les procédures stockées, les colonnes, les vues, les contraintes).


44

46

VIRessources

45

47

VI. RessourcesPage d’accueil du produit : http://www.softfluent.com/products/codefluent-entities

Obtenez une version d’essai (complète et gratuite pour un usage personnel) :http://www.softfluent.com/trials/codefluent-entities/

Pourquoi CodeFluent Entities (avec des exemples) ?http://www.softfluent.com/products/codefluent-entities/why/examples

Démarrez avec CodeFluent Entities (Utilisez les assistants, Importez des modèles existants) : http://www.softfluent.com/products/codefluent-entities/get-started

Le Blog CodeFluent Entities (plus de 350 articles !) :http://blog.codefluententities.com/

Forums:http://forums.softfluent.com/

Documentation de référence :http://www.softfluent.com/community-support/codefluent-entities/documentation

Les questions/réponses de la plateforme StackOverflow :http://stackoverflow.com/search?q=codefluent+entities


4446

48

EUROPE3 rue de la Renaissance

92160 AntonyFrance

[email protected]

AMERICA2018 156th Avenue NE

Bellevue, WA 98007USA

Technology

CodeFluent Entities et l'ADO.NET : comprendre le positionnement relatif