Discussion :

[flzox]

Bonjour,
je développe une application de gestion de comptes bancaire, qui nécessite donc la sauvegarde et l'accès aux données dans une base.

1. Lors d'une session l'utilisateur peut insérer/supprimer des données en base et les requêtes à venir doivent prendre en compte ces modifications.

2. A la fin de la session (quand on quitte l'appli) il doit être possible d'annuler toutes les modifications effectuées en base par l'utilisateur (ajout, suppression, mise à jour etc).

Pour le moment j'utilise Linq To Sql, qui fait bien le boulot pour le point 1, mais je bloque au point 2.

Quelle solution me conseillez vous ?
- Méthode bourrin : Faire une copie de la BDD en début de session et travailler sur une BDD temporaire. Si l'utilisateur annule on supprime la BDD temporaire, sinon on remplace la BDD par la BDD temporaire ?
- Utiliser un TransactionScope (testé mais je n'ai pas réussi à l'utiliser pour le point 2).
- Changer de techno ? Si oui avez vous un exemple illustrant le point 2 ?
- Autre proposition ?

Merci de votre aide.

[bizet]

Salut

A priori je pense que l'utilisation des transactions est suffisante.

Pour annuler, il suffit de faire un rollback sur ta transaction pour annuler toutes les modifications de l'utilisateur qui n'ont pas été "commit".

[morgand]

Pouvons nous avoir un peu plus de détail (web / winform) ? Version du Framework (3.5) ?

Si les données sont unique pour chaque client, c'est à dire qu'il n'existe pas de données transversale (utilisé par plusieurs clients en même temps) alors tu peux faire un contexte générale par connexion. Si je ne me trompe pas, tu dois faire "context.SaveChanging()" pour valider tes changements ? et bien ton contexte peut rester ouvert tout le long de ta manipulation des données et tu fais la sauvegarde que quand tu as besoin de la faire.

Sinon les transaction avec Commit et RollBack fonction très bien pour ça, ce qui revient aux même que de faire ce que je t'ai dis.

Sinon tu structures ta base de données autrement. Dans le cas par exemple où tu aurais besoin de sauvegarder tes manipulations et pouvoir les manipuler plus tard sans qu'elles aient été enregistré dans les données principales. Et bien tu crées des tables tampons, qui permettent de stockés les pré-modifications.

[flzox]

L'application est du type Winform avec le Fw 3.5.

Je ne dois pas avoir bien saisi l'utilisation des transactions. J'ai vu un peu partout ce type de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
using (TransactionScope scope = new TransactionScope()) 
{ 
   MaTable.InsertOnSubmit(UneNouvelleLigne);
   MaTable.SubmitChanges();
   scope.complete();
}

En procédant ainsi, les données sont sauvées en base si tout se passe bien, (pas de rollback possible), et le rollback est automatique si SubmiChanges plante par exemple, ou si on enlève scope.Complete(). C'est bien pour une opération ponctuelle mais pas pour une session entière, à moins d'avoir un seul TransactionScope global à l'application, j'ai donc tenté ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
public class MaClasse:Form
    {
        ...
        //Déclaration d'un TransactionScope global à l'application
        TransactionScope ts;
        ...
 
        public MaClasse()
        {
            InitializeComponent();
 
            ts = new TransactionScope();
            ...
        }
 
        //Tout enregistrer
        private void buttonEnregistrer_Click(object sender, EventArgs e)
        {
            ts.Complete();
            ts = new TransactionScope();
        }
 
        //Tout annuler
        private void buttonAnnuler_Click(object sender, EventArgs e)
        {
            ts.Dispose();
            ts = new TransactionScope();
        }
    }

Ça marche, c'est à dire que les points 1 et 2 de mon premier message sont satisfait, sauf que du moment ou ts.Complete() ou ts.Dispose() sont appelés, j'ai beau détruire et reinstancier ts, je ne peux plus insérer de ligne dans la table.

[bizet]

Regarde le dernier paragraphe de cet article.
Il explique comment mettre en place des transactions sans TransactionScope

[iberserk]

Méthode bourrin : Faire une copie de la BDD en début de session et travailler sur une BDD temporaire. Si l'utilisateur annule on supprime la BDD temporaire, sinon on remplace la BDD par la BDD temporaire ?

Pourquoi pas monter une VM pour chaque utilisateur aussi!!!

Je rêve...

Pendant la session, insérez vos données dans des tables 'sessions'.

S'il annule à la sortie... purgez vos tables, sinon lancez un batch (Procédure stockée) mettant à jour la base de données à partir des tables sessions puis purgez les.

Mais le fonctionnement que vous recherchez me semble bien etrange...

[flzox]

Un peu condescendante cette réponse iberserk. Si je pose des question c'est que justement je ne sais pas comment m'y prendre ...

D'ailleurs, qu'y a-t-il d'étrange dans ce fonctionnement que je cherche ?

Je cherche à faire ce que n'importe quelle application de gestion de compte bancaire propose, c'est à dire charger des données, les utiliser, les modifier, et avoir la possibilité sauvegarder ou annuler les modifications en quittant la session.

Je suis prêt à changer de méthode ou de techno mais j'ai besoin d'indications plus précises que "purger vos tables".

[iberserk]

Un peu condescendante cette réponse iberserk. Si je pose des question c'est que justement je ne sais pas comment m'y prendre ...

Passons , j'aurais pu tout aussi bien vous citer:

Méthode bourrin :

Le fonctionnement que je proposerais:
Créez des tables de vos données avec dans chacune une notion de session ( GUID par exemple...).

Quand un utilisateur se connecte vous lui affectez un numéro de session...

pour toutes les modifications qu'il apportent aux données vous modifiez les données de la session...

Lors de la confirmation, lancez une procédure en base qui insère/update les données dans les tables définitives et purgez (videz) les données de la session.
Si l'utilisateur annule vous avez juste à purger (vider) les données de la session.

[flzox]

Merci,

En tant qu'architecte de base de données vous devez avoir une bonne raison de penser que le fonctionnement que je recherche est étrange.
Pourquoi ? J'ai pourtant l'impression que nombre d'applications proposent d'abandonner toute modif en quittant une session.

Je vais étudier votre proposition de notion de session.

[iberserk]

En tant qu'architecte de base de données vous devez avoir une bonne raison de penser que le fonctionnement que je recherche est étrange.
Pourquoi ? J'ai pourtant l'impression que nombre d'applications proposent d'abandonner toute modif en quittant une session.

Je vais étudier votre proposition de notion de session.

C'est le principe de session complète qui me semblait étrange... rien de plus
Mais si c'est votre besoin...

[morgand]

La méthode de la copie de base de données est utilisée dans les mode déconnecté, mais c'est très très très ... compliqué à mettre en place pour l'architecte BDD, parce qu'il y a tout un système de date à mettre en place et d'algo de comparaison de date et de priorité ... enfin je passe les détails, un CRM qui marche avec ce système est : SalesLogix de Sage en web et en Win.

Mais sinon, je pense que le mieux pour toi est de voir les transactions

[flzox]

J'ai en effet trouvé une méthode avec les transations.

En gros :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
private void button_Rollback_Click(object sender, EventArgs e)
{
            MyDataContext.Transaction.Rollback();
            MyDataContext.Connection.Close();
 
            MyDataContext = new DataBase(connectionString);
            MyDataContext.Connection.Open();
            DbTransaction transaction = MyDataContext.Connection.BeginTransaction();
            MyDataContext.Transaction = transaction;
}

Je ne sais pas si c'est très propre mais pour le moment ça semble fonctionner.