AddObject() sans SaveChanges() ?

Version imprimable

28/05/2010, 14h47
rarazor

AddObject() sans SaveChanges() ?
Bonjour,

Je programme actuellement un outil utilisant Entity Framework et SQL Server Compact.

J'ai constaté que lors de l'ajout d'un objet sans ensuite faire appel à la fonction SaveChanges(), l'objet ajouté est ignoré par les requêtes Linq !

J'ajoute mon objet dans la table CV_Folder:
Code:

1 2 _Entities.CV_Folders.AddObject(Folder.GetEntity());
Je réalise ma requete Linq:
Code:

1 2 3 var Folders = (from F in _Entities.CV_Folders select F);
La variable Folders contient tous les Folders déjà présent dans la base de données mais pas l'élément que je viens d'ajouter !

Si après la fonction AddObject(), j'exécute la fonction SaveChanges():
Code:

1 2 _Entities.SaveChanges();
... dans ce cas, la requête Linq renvoit ce que j'attend.

N'y a-t-il pas une solution pour que ma requête Linq travail également avec les objets qui viennent d'être ajoutés sans sauvegarder forcément ?

Merci de votre aide !
Raoul
28/05/2010, 15h06
anthyme

Ta requête linq c'est du sql qui ramènent des objets qui viennent de la base donc c'est normal qu'il n'y ai pas encore tes objets en mémoire dans le résultat.

Le plus simple c'est donc de faire le save changes sinon à toi d'ajouter tes objets en mémoire à la main dans le résultats mais je pense pas qu'il y ait de bonne approche pour faire ça ...

Ca te dérange tant que ca de faire un savechanges() ?
28/05/2010, 15h35
rarazor
Merci pour ta réponse!

Je pense que la requête Linq ne ramène pas directement les objets se trouvant en base de données.

Par exemple si j'exécute le code suivant:
Code:

1 2 3 4 5 6 7 8 Entity = (from F in _Entities.CV_Folders select F).First(); Entity.Name = "Toto"; Entity = (from F in _Entities.CV_Folders select F).First();
La requete Linq me renvoit bien à la fin Entity.Name = "Toto" alors que je n'ai pas réalisé de SaveChanges()... Les données sont donc en cache ?

Pourquoi j'arrive à obtenir les objets modifiés mais pas les nouveaux ?

La fonction SaveChanges() est en effet problématique: dans le programme, l'utilisateur ajoute/modifie/supprime des objets.... Mais il me faut apporter les modifications à la base de données uniquement lorsqu'il décide d'entregistrer ses modifications...
28/05/2010, 15h41
anthyme

c'est un peu plus compliqué que cela ...

Déjà il n'y a pas d'objets dans la base de données, les objet sont créé par EF dans l'application

Quand tu fait une requête linq cela génère bien une requete SQL qui va ramener des lignes de la table en question en provenance de la base de données.

Ensuite EF parcours ces ligne et les transforme en objet ...
Mais pour éviter d'avoir une duplication d'objets identiques en mémoire il va vérifier si il n'a pas déjà un objet lié au contexte avec le même Id et renvoyer ce dernier si il est présent au lieu d'en créer un nouveau.

Mais cela ne change pas le fait que la requête renverra uniquement des objets ayant une existence en base.

La solution pour toi est de mettre en place un système de transaction.

Si l'utilisateur valide ses modifications tu fais un commit de la transaction, sinon tu fais un rollback
31/05/2010, 11h54
rarazor

Merci pour les explications !
J'ai suivi ton conseil et j'ai mis en place un BeginTransaction() !
31/05/2010, 12h13
anthyme

De rien ;)

Salut,

Désolé de réveiller ce vieux post, mais j'ai une petite question à ce sujet.

Je fais un projet web et j'aimerais aussi que les utilisateurs confirment leurs changements. J'ai donc suivi ton conseil et ça marche assez bien tant que je suis seul sur mon serveur SQL. Une fois qu'on est plusieurs, ma transaction bloque celle de mon collègue et inversement.

Y a-t-il moyen d'avoir des transactions non bloquantes ? ou juste au niveau du cache ?

Voici mon code actuel :
Extensions des Entity Object :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    public static class EntityObjectExtensions
    {
        public static void addToContext(this EntityObject aObject)
        {
            aObject.addToContext(aObject.GetType().Name + "s");
        }
 
        public static void addToContext(this EntityObject aObject, string EntitySetName)
        {
            CTMSModelContainer.DataContext.AddObject(EntitySetName, aObject);
            CTMSModelContainer.DataContext.SaveChanges();
        }
 
        public static void removeFromContext(this EntityObject aObject)
        {
            CTMSModelContainer.DataContext.DeleteObject(aObject);
            CTMSModelContainer.DataContext.SaveChanges();
        }
 
        public static void reloadFromDb(this EntityObject aObject)
        {
            CTMSModelContainer.DataContext.Refresh(System.Data.Objects.RefreshMode.StoreWins, aObject);
        }
    }

Mon context :

Code:

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
public partial class CTMSModelContainer : ObjectContext
    {
        private static Dictionary<string, CTMSModelContainer> DataContextList { get; set; }
 
        static CTMSModelContainer()
        {
            CTMSModelContainer.DataContextList = new Dictionary<string, CTMSModelContainer>();
        }
        private DbTransaction transaction;
 
        private static CTMSModelContainer CreateDataContext()
        {
            CTMSModelContainer oNewContext = new CTMSModelContainer(ConfigurationManager.ConnectionStrings["CTMSModelContainer"].ConnectionString);
            return oNewContext;
        }
 
        public static CTMSModelContainer DataContext
        {
            get 
            {
                CTMSModelContainer oDataContext = null;
                string SessionID = "CTMSSession"; // todo : HttpContext.Current.Session.SessionID;
                // Web
                if (HttpContext.Current != null && HttpContext.Current != null)
                {
                    if (DataContextList.ContainsKey(SessionID))
                        oDataContext = DataContextList[SessionID];
                    else 
                    {
                        oDataContext = CTMSModelContainer.CreateDataContext();
                        DataContextList.Add(SessionID, oDataContext);
                    }
                }
                // Win
                else
                {
                    if (DataContextList.ContainsKey("AppliWin"))
                        oDataContext = DataContextList["AppliWin"];
                    else
                    {
                        oDataContext = CTMSModelContainer.CreateDataContext();
                        DataContextList.Add("AppliWin", oDataContext);
                    }
                }
                return oDataContext;
            }
        }
 
        private static void RemoveContext(string aDataContextId)
        {
            if (DataContextList.ContainsKey(aDataContextId))
                DataContextList.Remove(aDataContextId);
        }
 
        private static void RemoveCurrentContext()
        {
            string SessionID = "CTMSSession"; // todo : HttpContext.Current.Session.SessionID;
            CTMSModelContainer.RemoveContext(SessionID);
        }
 
        public static void BeginTransaction(bool IsPostBack)
        {
            if (!IsPostBack)
            {
                DbConnection aConnection = CTMSModelContainer.DataContext.Connection;
                aConnection.Close();
                aConnection.Open();
                CTMSModelContainer.DataContext.Transaction = aConnection.BeginTransaction();
            }
        }
 
        public static void Save()
        {
            if (CTMSModelContainer.DataContext.Transaction != null)
            {
                CTMSModelContainer.DataContext.Transaction.Commit();
                CTMSModelContainer.DataContext.Transaction = null;
            }
        }
 
        public static void Cancel()
        {
            if (CTMSModelContainer.DataContext.Transaction != null)
            {
                CTMSModelContainer.DataContext.Transaction.Rollback();
                CTMSModelContainer.DataContext.Transaction = null;
            }
        }
 
        public DbTransaction Transaction {
            get {
                return transaction;
            }
            set {
                if (transaction != value) {
                    transaction = value;
                }
            }
        }
 
    }

J'appel le BeginTransaction() du context à chaque début de page.

Merci pour votre aide :)