Accès aux données et contrôle des données

Bonjour,

Étant nouveau sur l'environnement dot.net, j'ai beaucoup de mal à savoir par ou commencer !!

Je dois coder une application de gestion, qui donc d'une part accède à une base de données (surement MsSQL), mais j'aimerais que le contrôle de validité des données soit dans une couche séparée et donc indépendant de l'interface (modèle x tiers). Mais d'autres part j'aimerais que les erreurs que rencontre la couche de contrôle remonte à mon interface par la classe ErrorProvider qui me semble adapté.

Malgré un nombre de classe assez impressionnant fourni par le framework, je n'arrive pas à visualiser le principe que je dois adopter. J'ai fais différents essais qui ne sont pas concluants.

L'accès aux données se fera par ADO à priori, l'interface sera du Winforms dans un premier temps mais au milieu je mets quoi ?

-> Dataset, mais ou dois je placer les contrôles
-> Trigger, très dépendant de la base de données
-> Linq for entities, pareil : ou dois je placer les contrôles
-> J'ai fais le choix par ailleurs la bibliothèque de composants devexpress qui propose aussi un ORM -> XPO

Si possible, j'aimerais utiliser au maximum les classes existantes, vu que de nos jours, les petits projets doivent être rapide à développer et que les budgets sont de plus en plus réduits.

Quelqu'un pourrais me donner une piste, ou l'adresse d'un document traitant de ce genre de sujet, ou mieux même si quelqu'un avais un projet de base avec 2 tables en relations 1-N et les formulaires qui les gèrent, ca serais parfait comme exemple.

Désolé si la question à déjà été posé, mais pas trouvé de trace malgré mes recherches.

Merci.

Vu le peu de réponses, j'ai 2 possibilités :

- Soit ma demande n'est pas claire, mais dites moi le ;)
- soit personne n'a la réponse.


J'essaye tout de même de préciser à nouveau, j'aimerais avoir, au niveau d'un composant, des évènements correspondant aux actions qu'effectuent l'utilisateur.

Avant édition d'un champ/d'un enregistrement
Après édition
Avant suppression
Après suppression
Annulation de la modification

Etc.

Dans ces événements, je pourrais contrôler les incohérences et soit renvoyer une erreur par le mécanisme que fourni ErrorProvider, soit lever une exception.


Pour prendre un exemple simple sur lequel je bloque : Sur le dataset et sur l'évènement columnchanging, je peut vérifier les données saisies et renvoyer comme voulu les erreurs, mais là ou le bas blesse par exemple, c'est que si ces évènements proviennent d'une dbgrid et que l'utilisateur appui sur Echap pour annuler ces modification, mon dataset n'en est pas informé et du coup je ne peut pas effacer les erreurs que j'ai fourni par le mécanisme ErrorProvider.

Depuis que j'ai poser la question, j'ai trouvé une suite de composants qui semblent fourni ce que je cherche, mais le problème, c'est que c'est pas gratuit (ça encore ça peut passer), mais d'autre part c'est closed source :/

L'addresse du composant : http://www.componentone.com/SuperPro...ataObjectsNET/

Cette bibliothèque propose différents composants et parmi eux : C1DataSetLogic, C1TableLogic qui me fournissent l'ensemble des évènements suivants :

AfterAddNew
AfterBeginEdit
AfterCancelEdit
AfterChanges
AfterDelete
AfterEndAddNew
AfterEndEdit
AfterFieldChange
AfterUpdateRow

et leurs corrolaires en Before.

Connaissez vous une autre solution pour obtenir un comportement similaire ?

- si tu utilises des DataSets :
Dans la classe DataTable, tu as les évènements suivants qui devraient correspondre à peu près à ton besoin :

ColumnChanging
ColumnChanged
RowChanging
RowChanged
RowDeleting
RowDeleted
TableClearing
TableCleared
TableNewRow

- si tu utilises Linq to Entities :
La classe EntityObject (dont héritent toutes les entités générées par le designer) implémente INotifyPropertyChanging et INotifyPropertyChanged, et a donc des évènements PropertyChanging et PropertyChanged.
Pour surveiller l'ajout et la suppression d'entités tu peux utiliser l'évènement ObjectStateManagerChanged de l'ObjectStateManager de ton ObjectContext.

Merci pour ta réponse, mais pour reprendre l'exemple du DataSet. Si sur ColumnChanging je fais un test sur la valeur et que je retourne une erreur via SetError, l'interface récupère bien l'erreur et m'affiche un icône rouge, mais si à partir de ce moment, l'utilisateur décide d'annuler ces modifications et appuie sur Esc, je n'ai plus aucun évènement au niveau du DataSet. L'interface se retrouve donc avec les anciennes valeurs, mais l'icône rouge reste comme s'il y avait une erreur.

En fait il faudrait déclencher la validation sur un évènement au niveau de l'UI, plutôt qu'au niveau du DataSet
Par exemple si tu utilises un DataGridView, tu peux utiliser l'évènement CellValidating
Avec la XtraGrid de DevExpress, ça doit être les évènements ValidateRow (pour valider la ligne entière) et ValidatingEditor (pour valider une cellule)

Je n'arrive pas à comprendre pourquoi je n'ai pas au niveau du DataSet tout les évènements concernant les données.

Si on commence à partir du principe que l'on doit coder des déclenchements de vérification de données au niveau de l'UI, ca veut dire qu'il faut gérer plein de petit bout de code dans plein d'évènements. Surtout que pour le même champ de données, il peut être saisi de différentes manières, grid, textbox, etc...

Je trouve ca lourd alors que le but de la BLL c'est d'être autonome concernant les données.

1) Quelqu'un connais la raison de cette limitation du DataSet ?

Je dis limitation parce que à priori au moins un éditeur propose un DataSet qui comporte tout les évènements (cf 2ième post, ComponentOne C1DataObjects).

2) Existe-t-il d'autres alternatives que celle de microsoft, simple et complète, concernant les données ?

Dataset est un conteneur, il va te permettre de gérer une collection de Datatable en mémoire plus d'autres objets comme les DataRelation.

J'ai l'impression que tu confonds le TDataset de la VCL Delphi avec le Dataset de ADO.NET. L'équivalent si j'ose dire est le DataTable.

Oui, il est vrai que j'utilise DataSet comme un terme générique et que le DataTable correspond plus à la notion de TDataSet, mais cela ne change en rien ma question ;)

Le DataTable ne propose pas tout les évènements concernant la mise à jour des données.

Mais quand tu parles de BLL ( Business Logical Layer ), il s'agit d'une architecture en couche. Dans ce contexte, je ne pense pas qu'il faille utiliser Dataset.

Oui BLL c'est une couche au sens strict du terme, mais c'est aussi une fonctionnalité, la logique métier.

A priori je n'ai pas été clair dans ma demande. Je cherche un outil (classe a priori) qui me permettent de contrôler les données saisies par l'utilisateur.

Je parle par ailleurs de DataSet, vu que le DataSet propose quelques évènements (ColumnChanging, ColumnChanged, Row..., ) pour cette tâche, mais n'est pas complet.

La structure de l'application que je vois, c'est une couche d'accès et de contrôle des données, une couche interface et bien sûr la BDD. La DAL et la BLL serait donc confondu même si je sais que dans l'absolu ce n'est pas parfait.

Le but de cette recherche est d'avoir un ensemble d'outil me permettant de développer rapidement et proprement des "petites" applications de gestion.

Je travaille dans une petite société et n'ai pas les moyens (les clients non plus) de passer trop de temps à développer/tester des classes complémentaires.

Soit une solution existe avec les composants/classes de base et/ou avec DevExpress, mais je n'ai pas trouvé, soit une autre solution que je ne connais donc pas (peut être ComponentOne avec le C1DataObjects).