Comment mettre en œuvre efficace de l'undo/redo fonctionnalités pour une zone de texte

L' .NET System.ComponentModel espace de noms est livré avec un IEditableObject interface, vous pouvez également utiliser INotifyPropertyChanging et INotifyPropertyChanged. Modèle MVC serait aussi que votre interface répond à des changements dans le modèle par le biais d'événements mettant ainsi à jour ou la restauration de la valeur de votre zone de texte.

Efficacement la Memento Modèle.

Avez-vous eu un coup d'oeil dans ces? Ici est un comment.

Façon rapide et simple de la version pour stocker l'état de la zone de texte OnTextChanged. Chaque annuler serait de retour le dernier événement dans un Tableau. Le C# Type de Pile peut être utile ici. Vous pourriez claire de l'état une fois que vous êtes hors de l'interface ou après Apply.

Une bonne solution peut être trouvée ici:

Ajouter Annuler/Rétablir ou à l'Arrière/vers l'Avant de la Fonctionnalité de votre Application

Undo/Redo Capable de zone de texte (winforms)

Le code est dans VB.NET mais vous pouvez facilement les convertir en C# sans trop d'efforts. En ligne convertisseurs sont également disponibles.

J'ai besoin de réinitialisation de la sélection, aussi, dans sa position d'origine lorsque défaire /refaire. Regarder "les Extensions de la classe", au bas de ma juste de base et bien-code de travail, pour un formulaire avec une seule zone de texte "textBox1" à essayer:

public partial class Form1 : Form
{
Stack<Func<object>> undoStack = new Stack<Func<object>>();
Stack<Func<object>> redoStack = new Stack<Func<object>>();
public Form1()
{
InitializeComponent();
textBox1.KeyDown += TextBox1_KeyDown;
}
private void TextBox1_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.ControlKey && ModifierKeys == Keys.Control) { }
else if (e.KeyCode == Keys.U && ModifierKeys == Keys.Control)
{
if(undoStack.Count > 0)
{
StackPush(sender, redoStack);
undoStack.Pop()();
}
}
else if (e.KeyCode == Keys.R && ModifierKeys == Keys.Control)
{
if(redoStack.Count > 0)
{
StackPush(sender, undoStack);
redoStack.Pop()();
}
}
else
{
redoStack.Clear();
StackPush(sender, undoStack);
}
}
private void StackPush(object sender, Stack<Func<object>> stack)
{
TextBox textBox = (TextBox)sender;
var tBT = textBox.Text(textBox.Text, textBox.SelectionStart);
stack.Push(tBT);
}
}
public static class Extensions
{
public static Func<TextBox> Text(this TextBox textBox, string text, int sel)
{
return () => 
{
textBox.Text = text;
textBox.SelectionStart = sel;
return textBox;
};
}
}

La façon la plus intelligente est avec immuables des objets persistants. Ne jamais modifier un objet seulement faire de nouveaux objets qui changent un peu de l'ancienne version. Cela peut être fait assez efficacement que par le clonage des parties de l'arbre sur le hot chemin.

J'ai un exemple d'une pile d'annulation écrite avec un minimum de code

 [Fact]
public void UndoStackSpec()
{
var stack = new UndoStack<A>(new A(10, null));
stack.Current().B.Should().Be(null);
stack.Set(x => x.B, new B(20, null));
stack.Current().B.Should().NotBe(null);
stack.Current().B.P.Should().Be(20);
stack.Undo();
stack.Current().B.Should().Be(null);
}

où A et B comme des classes avec private setters sur toutes les propriétés ie
immutable

class A : Immutable
{
public int P { get; private set; }
public B B { get; private set; }
public A(int p, B b)
{
P = p;
B = b;
}
}
class B : Immutable
{
public int P { get; private set; }
public C C { get; private set; }
public B(int p, C c)
{
P = p;
C = c;
}
}
class C : Immutable
{
public int P { get; private set; }
public C(int p)
{
P = p;
}
}

vous pouvez trouver la source ici https://gist.github.com/bradphelan/5395652