Comment avoir des transactions sur des objets

Question

Comment imiter des transactions sur des objets. Par exemple, je souhaite supprimer l'élément d'une collection, puis ajouter le même élément à une autre collection en tant qu'action atomique. Il est possible de faire beaucoup de vérifications quand quelque chose a échoué et de tout reculer mais c'est ennuyeux. Y at-il une technique (pas de différence quelle langue (Java/C++/C#)) pour réaliser cela.

Answer 1

Pour les petits objets simples, vous pouvez utiliser un idiome copy-modify-swap. Copiez l'objet original. Faites les changements. Si tous les changements ont réussi, échangez la copie avec l'original. (En C++, swap est généralement efficace et sans échec.) Le destructeur nettoie alors l'original, au lieu de la copie.

Dans votre cas, vous copiez les deux collections. Supprimez l'objet de la première, ajoutez-le à la seconde, puis échangez les collections d'origine avec les copies. Cependant, cela peut ne pas être pratique si vous avez des objets volumineux ou difficiles à copier. Dans ces cas, vous devez généralement faire plus de travail manuellement.

Answer 2

Oui, modèle Memento http://en.wikipedia.org/wiki/Memento_pattern

Answer 3

Software transactional memory est une approche. Il n'y a pas de technologie agnostique pour cela que je connaisse.

Answer 4

Vous pouvez utiliser la méthode de Herb Sutters

Comme

class EmployeeDatabase 
    { 
     public void TerminateEmployee(int index) 
     { 
      // Clone sensitive objects. 
      ArrayList tempActiveEmployees = 
      (ArrayList) activeEmployees.Clone(); 
      ArrayList tempTerminatedEmployees = 
      (ArrayList) terminatedEmployees.Clone(); 

      // Perform actions on temp objects. 
      object employee = tempActiveEmployees[index]; 
      tempActiveEmployees.RemoveAt(index); 
      tempTerminatedEmployees.Add(employee); 

      // Now commit the changes. 
      ArrayList tempSpace = null; 

      ListSwap(ref activeEmployees, 
       ref tempActiveEmployees, 
       ref tempSpace); 

      ListSwap(ref terminatedEmployees, 
       ref tempTerminatedEmployees, 
       ref tempSpace); 
     } 

     void ListSwap(ref ArrayList first, 
      ref ArrayList second, 
      ref ArrayList temp) 
     { 
      temp = first; 
      first = second; 
      second = temp; 
      temp = null; 
     } 

     private ArrayList activeEmployees; 
     private ArrayList terminatedEmployees; 
} 

Principalement, cela signifie diviser le code en 2 parties:

void ExceptionNeutralMethod() 
    { 
     //—————————— 
     // All code that could possibly throw exceptions is in this 
     // first section. In this section, no changes in state are 
     // applied to any objects in the system including this. 
     //—————————— 


     //—————————— 
     // All changes are committed at this point using operations 
     // strictly guaranteed not to throw exceptions. 
     //—————————— 
    } 

Bien sûr, il est juste de montrer la méthode I signifie concernant ArrayList :). Il vaut mieux utiliser les médicaments génériques si possible, etc ...

EDIT

En outre, si vous avez une extrême fiabilité des exigences s'il vous plaît jeter un oeil à Régions d'exécution avec contraintes aussi.

Answer 5

Ce genre de chose devient plus facile lorsque vous utilisez des collections immuables. Dans une collection immutable, l'ajout ou la suppression d'un membre ne modifie pas la collection, elle renvoie une collection nouvelle. (La mise en œuvre de collections immuables qui peuvent le faire en utilisant peu de temps et d'espace est un problème délicat.)

Mais si vous avez des collections immuables, la logique devient beaucoup plus facile. Supposons que vous souhaitiez déplacer un élément de la collection de gauche vers la collection de droite:

newLeft = left.Remove(item); 
newRight = right.Add(item); 

gauche et droite n'ont pas changé; ils sont immuables. Maintenant, le problème que vous devez résoudre est un ensemble atomique de left = newLeft et right = newRight, ce qui n'est pas si difficile à résoudre.