Back to: Design Patterns in C# With Real-Time Examples
Real-Time Examples of Memento Design Pattern in C#
In this article, I will discuss the Real-Time Examples of the Memento Design Pattern in C#. Please read our previous article discussing the basic concepts of Memento Design Patterns in C# with Examples. At the end of this article, you will understand the following Real-time Examples using Memento Design Pattern in C#.
- Content Management System (CMS)
- Settings in a Software Application
- Banking System
- Game Character’s State Management
- Drawing Board
- Text Editors
- Shopping Cart System
- Game Save Mechanism
- Graphic Design Tool
- Thermostat Temperature Control
Real-Time Example of Memento Design Pattern in C#: Content Management System (CMS)
Let’s illustrate the Memento pattern with a real-time example using a simple versioning system for articles in a content management system (CMS). This way, authors can save drafts and restore previous versions of their articles. Let us see how we can implement the above example using the Memento Design Pattern in C#:
using System;
using System.Collections.Generic;
namespace MementoDesignPattern
{
//ArticleMemento - This will store the state of the article.
public class ArticleMemento
{
public string Title { get; }
public string Content { get; }
public DateTime Timestamp { get; }
public ArticleMemento(string title, string content, DateTime timestamp)
{
this.Title = title;
this.Content = content;
this.Timestamp = timestamp;
}
}
//Article - This represents our main entity.
//It creates a memento and can restore its state from a memento.
public class Article
{
public string Title { get; set; }
public string Content { get; set; }
// Saves the current state
public ArticleMemento Save()
{
return new ArticleMemento(Title, Content, DateTime.Now);
}
// Restores the state from a memento
public void Restore(ArticleMemento memento)
{
this.Title = memento.Title;
this.Content = memento.Content;
}
}
//History - This will manage the saved versions of the article.
public class ArticleHistory
{
private Stack<ArticleMemento> _history = new Stack<ArticleMemento>();
public void Save(Article article)
{
_history.Push(article.Save());
}
public ArticleMemento GetLatestVersion()
{
return _history.Pop();
}
}
// Testing the Memento Design Pattern
// Client Code
public class Client
{
public static void Main()
{
Article article = new Article();
ArticleHistory history = new ArticleHistory();
article.Title = "Memento Pattern in C#";
article.Content = "The Memento Pattern is...";
history.Save(article); // Save the initial version
article.Content += " It's useful for implementing undo functionality.";
history.Save(article); // Save after adding more content
article.Content += " However, care must be taken about memory usage.";
// Oops! The last sentence was not needed. Let's restore the previous version.
var previousVersion = history.GetLatestVersion();
article.Restore(previousVersion);
Console.WriteLine(article.Content);
// Outputs: "The Memento Pattern is... It's useful for implementing undo functionality."
Console.ReadKey();
}
}
}
In this real-time example, authors can keep saving different versions of their articles, and if they make a mistake or change their mind about a change, they can restore a previous version. When you run the above code, you will get the following output.
The Memento Pattern is… It’s useful for implementing undo functionality.
Real-Time Example of Memento Design Pattern in C#: Settings in a Software Application
Consider a real-time example of dealing with user settings in a software application. Users can modify their settings and preview them. If they don’t like the changes, they’d want to restore the previous settings. Let us see how we can implement the above example using the Memento Design Pattern in C#:
using System;
using System.Collections.Generic;
namespace MementoDesignPattern
{
//SettingsMemento - This stores a snapshot of user settings.
public class SettingsMemento
{
public string ThemeColor { get; }
public string FontSize { get; }
public string Layout { get; }
public SettingsMemento(string themeColor, string fontSize, string layout)
{
ThemeColor = themeColor;
FontSize = fontSize;
Layout = layout;
}
}
//UserSettings - This is the actual settings object which users modify.
public class UserSettings
{
public string ThemeColor { get; set; }
public string FontSize { get; set; }
public string Layout { get; set; }
public SettingsMemento CreateSnapshot()
{
return new SettingsMemento(ThemeColor, FontSize, Layout);
}
public void RestoreFromSnapshot(SettingsMemento snapshot)
{
ThemeColor = snapshot.ThemeColor;
FontSize = snapshot.FontSize;
Layout = snapshot.Layout;
}
}
//SettingsHistory - This maintains a history of user settings.
public class SettingsHistory
{
private Stack<SettingsMemento> _history = new Stack<SettingsMemento>();
public void SaveSnapshot(SettingsMemento memento)
{
_history.Push(memento);
}
public SettingsMemento GetLastSnapshot()
{
return _history.Pop();
}
}
// Testing the Memento Design Pattern
// Client Code
public class Client
{
public static void Main()
{
UserSettings settings = new UserSettings();
SettingsHistory history = new SettingsHistory();
// Set initial settings
settings.ThemeColor = "Blue";
settings.FontSize = "Medium";
settings.Layout = "Grid";
// Save initial state
history.SaveSnapshot(settings.CreateSnapshot());
// User modifies settings to see how they look
settings.ThemeColor = "Dark Mode";
settings.Layout = "List";
// User doesn't like the Dark Mode. Wants to revert.
settings.RestoreFromSnapshot(history.GetLastSnapshot());
Console.WriteLine($"Theme: {settings.ThemeColor}, Layout: {settings.Layout}");
// Outputs: Theme: Blue, Layout: Grid
Console.ReadKey();
}
}
}
This example depicts a common scenario in software applications where users can tweak settings. Before they commit to changes, they might want to preview them. If they aren’t satisfied, they can revert to the previous settings using the Memento pattern. When you run the above code, you will get the following output.
Theme: Blue, Layout: Grid
Real-Time Example of Memento Design Pattern in C#: Banking System
Let’s explore a real-time example using a banking system scenario. Consider a scenario where a customer uses online banking to make various transactions. To enhance the user experience, the bank wants to provide a feature that allows users to undo their recent transactions. Let us see how we can implement the above example using the Memento Design Pattern in C#:
using System;
using System.Collections.Generic;
namespace MementoDesignPattern
{
//TransactionMemento - This will store the state of the account.
public class TransactionMemento
{
public decimal Balance { get; }
public TransactionMemento(decimal balance)
{
this.Balance = balance;
}
}
//BankAccount - Represents a bank account.
//It can create a memento and restore its state from a memento.
public class BankAccount
{
public decimal Balance { get; private set; }
public BankAccount(decimal initialBalance)
{
Balance = initialBalance;
}
public void Deposit(decimal amount)
{
Balance += amount;
}
public void Withdraw(decimal amount)
{
Balance -= amount;
}
public TransactionMemento CreateMemento()
{
return new TransactionMemento(Balance);
}
public void RestoreFromMemento(TransactionMemento memento)
{
this.Balance = memento.Balance;
}
}
//TransactionHistory - Manages the saved states of the account.
public class TransactionHistory
{
private Stack<TransactionMemento> _history = new Stack<TransactionMemento>();
public void SaveState(BankAccount account)
{
_history.Push(account.CreateMemento());
}
public TransactionMemento UndoTransaction()
{
return _history.Pop();
}
}
// Testing the Memento Design Pattern
// Client Code
public class Client
{
public static void Main()
{
BankAccount account = new BankAccount(1000.00M);
TransactionHistory history = new TransactionHistory();
account.Deposit(200);
history.SaveState(account); // Balance: 1200
account.Withdraw(100);
history.SaveState(account); // Balance: 1100
account.Withdraw(50);
history.SaveState(account); // Balance: 1050
// Oops! That last withdrawal was a mistake. Let's undo it.
account.RestoreFromMemento(history.UndoTransaction());
Console.WriteLine($"Current Balance: ${account.Balance}");
// Outputs: Current Balance: $1100.00
Console.ReadKey();
}
}
}
In this real-time example, the bank provides an “undo” feature for transactions. Each time a transaction is made (deposit or withdrawal), a memento of the account’s state is saved. If users realize they made an error or want to revert a transaction, they can use the undo feature to restore the account to a previous state. When you run the above code, you will get the following output.
Current Balance: $1050.00
Real-Time Example of Memento Design Pattern in C#: Game Character’s State Management.
implementing the Memento design pattern for a simple game character’s state management. This will allow players to save and load the character’s state. A character has health, attack, and defense attributes in a game. The player can save the character’s state before attempting a challenging level. If the character is defeated, the player can restore the saved state instead of accepting the weaker state. Let us see how we can implement the above example using the Memento Design Pattern in C#:
using System;
using System.Collections.Generic;
namespace MementoDesignPattern
{
//CharacterMemento - Represents the memento storing the character's attributes.
public class CharacterMemento
{
public int Health { get; }
public int Attack { get; }
public int Defense { get; }
public CharacterMemento(int health, int attack, int defense)
{
Health = health;
Attack = attack;
Defense = defense;
}
}
//GameCharacter - Represents the game character.
//It can create a memento and restore its attributes from a memento.
public class GameCharacter
{
public int Health { get; set; }
public int Attack { get; set; }
public int Defense { get; set; }
public GameCharacter(int health, int attack, int defense)
{
Health = health;
Attack = attack;
Defense = defense;
}
public CharacterMemento SaveState()
{
return new CharacterMemento(Health, Attack, Defense);
}
public void RestoreState(CharacterMemento memento)
{
Health = memento.Health;
Attack = memento.Attack;
Defense = memento.Defense;
}
}
//CharacterStateCaretaker - Manages the saved character states.
public class CharacterStateCaretaker
{
private Stack<CharacterMemento> _states = new Stack<CharacterMemento>();
public void SaveCharacterState(CharacterMemento memento)
{
_states.Push(memento);
}
public CharacterMemento GetLastSavedState()
{
return _states.Pop();
}
}
// Testing the Memento Design Pattern
// Client Code
public class Client
{
public static void Main()
{
GameCharacter hero = new GameCharacter(100, 50, 30); // Health, Attack, Defense
CharacterStateCaretaker caretaker = new CharacterStateCaretaker();
Console.WriteLine($"Initial State: Health={hero.Health}, Attack={hero.Attack}, Defense={hero.Defense}");
// Player decides to save the current state before facing a boss.
caretaker.SaveCharacterState(hero.SaveState());
// The character is defeated by the boss and loses health and attack power.
hero.Health -= 50;
hero.Attack -= 20;
Console.WriteLine($"After Boss Fight: Health={hero.Health}, Attack={hero.Attack}, Defense={hero.Defense}");
// Player decides to restore the saved state.
hero.RestoreState(caretaker.GetLastSavedState());
Console.WriteLine($"Restored State: Health={hero.Health}, Attack={hero.Attack}, Defense={hero.Defense}");
Console.ReadKey();
}
}
}
In this game example, the Memento pattern allows the player to store a character’s state before a challenging event and restore it later if desired. This is similar to saving a game before a hard level and reloading the save file if things don’t go as planned. When you run the above code, you will get the following output.
Real-Time Example of Memento Design Pattern in C#: Drawing Board
Let’s consider an application that provides a drawing board where a user can make various drawings, and the application provides undo functionality to undo the user’s last action. You are developing a drawing application. The user can draw various shapes on the board. After each draw, the current state of the drawing board is saved. If the user doesn’t like the latest drawing or makes a mistake, they can undo their last action. Let us see how we can implement the above example using the Memento Design Pattern in C#:
using System;
using System.Collections.Generic;
namespace MementoDesignPattern
{
//DrawingMemento - Captures a snapshot of the drawing board.
public class DrawingMemento
{
public List<string> Shapes { get; }
public DrawingMemento(List<string> shapes)
{
// Create a deep copy of shapes to store in the memento
this.Shapes = new List<string>(shapes);
}
}
//DrawingBoard - Represents our drawing board.
public class DrawingBoard
{
public List<string> Shapes { get; } = new List<string>();
public void Draw(string shape)
{
Shapes.Add(shape);
}
public DrawingMemento SaveState()
{
return new DrawingMemento(Shapes);
}
public void RestoreState(DrawingMemento memento)
{
Shapes.Clear();
Shapes.AddRange(memento.Shapes);
}
}
//History - Maintains a list of saved drawing board states.
public class DrawingHistory
{
private Stack<DrawingMemento> _history = new Stack<DrawingMemento>();
public void Save(DrawingBoard board)
{
_history.Push(board.SaveState());
}
public DrawingMemento Undo()
{
return _history.Pop();
}
}
// Testing the Memento Design Pattern
// Client Code
public class Client
{
public static void Main()
{
DrawingBoard board = new DrawingBoard();
DrawingHistory history = new DrawingHistory();
board.Draw("Circle");
board.Draw("Square");
history.Save(board); // Save current state
board.Draw("Triangle");
history.Save(board); // Save current state
board.Draw("Rectangle");
Console.WriteLine(string.Join(", ", board.Shapes));
// Outputs: Circle, Square, Triangle, Rectangle
// Undo the last action
board.RestoreState(history.Undo());
Console.WriteLine(string.Join(", ", board.Shapes));
// Outputs: Circle, Square, Triangle
Console.ReadKey();
}
}
}
In this drawing application example, the Memento pattern allows users to undo their actions. Every time a shape is drawn, the application saves the state of the drawing board, allowing users to revert to a previous state if they make an error or want to undo a particular drawing action. When you run the above code, you will get the following output.
Real-Time Example of Memento Design Pattern in C#: Text Editors
Imagine a simple text editor (like Notepad). Users can create a snapshot at various intervals as they type text. If they make an error or want to go back to a previous version of the document, they can restore from one of the saved snapshots. Let us see how we can implement the above example using the Memento Design Pattern in C#:
using System;
using System.Collections.Generic;
namespace MementoDesignPattern
{
//EditorMemento - Captures a snapshot of the editor's content.
public class EditorMemento
{
public string Content { get; }
public EditorMemento(string content)
{
this.Content = content;
}
}
//TextEditor - Represents our editor.
public class TextEditor
{
public string Content { get; set; }
public EditorMemento SaveState()
{
return new EditorMemento(Content);
}
public void RestoreState(EditorMemento memento)
{
Content = memento.Content;
}
}
//EditorHistory - Maintains a list of saved editor states.
public class EditorHistory
{
private Stack<EditorMemento> _history = new Stack<EditorMemento>();
public void Save(TextEditor editor)
{
_history.Push(editor.SaveState());
}
public EditorMemento Undo()
{
return _history.Pop();
}
}
// Testing the Memento Design Pattern
// Client Code
public class Client
{
public static void Main()
{
TextEditor editor = new TextEditor();
EditorHistory history = new EditorHistory();
editor.Content = "Hello, World!";
history.Save(editor); // Save current state
editor.Content = "Hello, Memento!";
history.Save(editor); // Save current state
editor.Content = "Hello, Design Patterns!";
Console.WriteLine(editor.Content);
// Outputs: Hello, Design Patterns!
// Undo to the last saved state
editor.RestoreState(history.Undo());
Console.WriteLine(editor.Content);
// Outputs: Hello, Memento!
// Undo to the previous saved state
editor.RestoreState(history.Undo());
Console.WriteLine(editor.Content);
// Outputs: Hello, World!
Console.ReadKey();
}
}
}
In this example, the Memento pattern enables the TextEditor to have an “undo” functionality. The user can save different versions of their document and revert back to any saved state, allowing them to discard unwanted changes. This emulates the behavior of many text editors or word processors where users can undo and redo actions. When you run the above code, you will get the following output.
Real-Time Example of Memento Design Pattern in C#: Shopping Cart System
In an e-commerce application, users can add items to their shopping cart. They might want to see a snapshot of their cart at various stages. For instance, before they add a promotional code, they might save a snapshot to compare prices later. If they find that the promotional code didn’t give a good discount or added unwanted items, they can revert to a previous snapshot. Let us see how we can implement the above example using the Memento Design Pattern in C#:
using System;
using System.Collections.Generic;
namespace MementoDesignPattern
{
//CartMemento - Captures the current state of the cart.
public class CartMemento
{
public List<string> Items { get; private set; }
public CartMemento(List<string> items)
{
this.Items = new List<string>(items);
}
}
//ShoppingCart - Represents the current cart and its items.
public class ShoppingCart
{
public List<string> Items { get; private set; } = new List<string>();
public void AddItem(string item)
{
Items.Add(item);
}
public CartMemento Save()
{
return new CartMemento(Items);
}
public void Restore(CartMemento memento)
{
Items = new List<string>(memento.Items);
}
}
//CartHistory - Manages and keeps track of saved states of the cart.
public class CartHistory
{
private Stack<CartMemento> _history = new Stack<CartMemento>();
public void Save(ShoppingCart cart)
{
_history.Push(cart.Save());
}
public CartMemento GetLastSavedState()
{
return _history.Pop();
}
}
// Testing the Memento Design Pattern
// Client Code
public class Client
{
public static void Main()
{
ShoppingCart cart = new ShoppingCart();
CartHistory history = new CartHistory();
cart.AddItem("Laptop");
cart.AddItem("Mouse");
// User saves the current cart state before applying a promo code
history.Save(cart);
// A promo code automatically adds a free "USB stick"
cart.AddItem("USB stick");
Console.WriteLine($"Current Cart Items: {string.Join(", ", cart.Items)}");
// Outputs: Current Cart Items: Laptop, Mouse, USB stick
// User doesn't want the free USB stick and decides to revert to the previous state
cart.Restore(history.GetLastSavedState());
Console.WriteLine($"Restored Cart Items: {string.Join(", ", cart.Items)}");
// Outputs: Restored Cart Items: Laptop, Mouse
Console.ReadKey();
}
}
}
This e-commerce example leverages the Memento pattern to allow users to revert their cart to a previous state. It is especially useful if promotions or other changes make unwanted modifications to their cart. When you run the above code, you will get the following output.
Real-Time Example of Memento Design Pattern in C#: Game Save Mechanism
Imagine a simple computer game where a player navigates through different levels, collects points, and can find power-ups. The player should have the option to save their game progress. If they find themselves in an unfavorable situation in the game (e.g., low health), they might want to load a previously saved state. Let us see how we can implement the above example using the Memento Design Pattern in C#:
using System;
using System.Collections.Generic;
namespace MementoDesignPattern
{
//GameMemento - Captures the current state of the game.
public class GameMemento
{
public int Level { get; }
public int Points { get; }
public List<string> PowerUps { get; }
public GameMemento(int level, int points, List<string> powerUps)
{
Level = level;
Points = points;
PowerUps = new List<string>(powerUps);
}
}
//GameSession - Represents the current game state.
public class GameSession
{
public int Level { get; set; }
public int Points { get; set; }
public List<string> PowerUps { get; } = new List<string>();
public GameMemento Save()
{
return new GameMemento(Level, Points, PowerUps);
}
public void Restore(GameMemento memento)
{
Level = memento.Level;
Points = memento.Points;
PowerUps.Clear();
PowerUps.AddRange(memento.PowerUps);
}
}
//GameHistory - Keeps track of saved game states.
public class GameHistory
{
private Stack<GameMemento> _savedStates = new Stack<GameMemento>();
public void SaveState(GameSession game)
{
_savedStates.Push(game.Save());
}
public GameMemento LoadLastSavedState()
{
return _savedStates.Pop();
}
}
// Testing the Memento Design Pattern
// Client Code
public class Client
{
public static void Main()
{
GameSession game = new GameSession();
GameHistory gameHistory = new GameHistory();
game.Level = 5;
game.Points = 3000;
game.PowerUps.Add("Shield");
game.PowerUps.Add("Speed boost");
// Player saves the game state
gameHistory.SaveState(game);
// Player progresses but then finds themselves in trouble
game.Level = 6;
game.Points = 3200;
game.PowerUps.Remove("Shield");
Console.WriteLine($"Current Game State: Level={game.Level}, Points={game.Points}, PowerUps={string.Join(", ", game.PowerUps)}");
// Outputs: Current Game State: Level=6, Points=3200, PowerUps=Speed boost
// Player decides to load the previously saved state
game.Restore(gameHistory.LoadLastSavedState());
Console.WriteLine($"Restored Game State: Level={game.Level}, Points={game.Points}, PowerUps={string.Join(", ", game.PowerUps)}");
// Outputs: Restored Game State: Level=5, Points=3000, PowerUps=Shield, Speed boost
Console.ReadKey();
}
}
}
In this game example, the Memento pattern allows players to save and load their game progress, ensuring they can revert to a more favorable game state if required. This mimics the behavior of many video games that offer save and load functionalities to players. When you run the above code, you will get the following output.
Real-Time Example of Memento Design Pattern in C#: Graphic Design Tool
In graphic design software, users can draw shapes on a canvas. After performing various actions like moving shapes, coloring, resizing, etc., a user might want to revert some changes. The Memento pattern can facilitate this “undo” functionality. Let us see how we can implement the above example using the Memento Design Pattern in C#:
using System;
using System.Collections.Generic;
using System.Linq;
namespace MementoDesignPattern
{
public class Circle : Shape
{
public int Radius { get; set; }
public override Shape Clone()
{
return new Circle { X = this.X, Y = this.Y, Radius = this.Radius };
}
}
public class Rectangle : Shape
{
public int Width { get; set; }
public int Height { get; set; }
public override Shape Clone()
{
return new Rectangle { X = this.X, Y = this.Y, Width = this.Width, Height = this.Height };
}
}
//CanvasMemento - Captures the current state of the canvas.
public class CanvasMemento
{
public List<Shape> Shapes { get; }
public CanvasMemento(List<Shape> shapes)
{
// Deep clone the list of shapes for true snapshot
this.Shapes = shapes.Select(s => s.Clone()).ToList();
}
}
public abstract class Shape
{
public int X { get; set; }
public int Y { get; set; }
// Other shape-specific properties and methods...
public abstract Shape Clone();
}
//DesignCanvas - Represents the current state of the canvas and its drawn shapes.
public class DesignCanvas
{
public List<Shape> Shapes { get; } = new List<Shape>();
public CanvasMemento Save()
{
return new CanvasMemento(Shapes);
}
public void Restore(CanvasMemento memento)
{
Shapes.Clear();
Shapes.AddRange(memento.Shapes.Select(s => s.Clone()));
}
}
//CanvasHistory - Manages and keeps track of saved states of the canvas.
public class CanvasHistory
{
private Stack<CanvasMemento> _history = new Stack<CanvasMemento>();
public void Save(DesignCanvas canvas)
{
_history.Push(canvas.Save());
}
public CanvasMemento Undo()
{
return _history.Pop();
}
}
// Testing the Memento Design Pattern
// Client Code
public class Client
{
public static void Main()
{
DesignCanvas canvas = new DesignCanvas();
CanvasHistory history = new CanvasHistory();
// Draw a shape on the canvas
canvas.Shapes.Add(new Circle { X = 10, Y = 10, Radius = 5 });
history.Save(canvas);
// Modify the canvas by adding another shape
canvas.Shapes.Add(new Rectangle { X = 20, Y = 20, Width = 10, Height = 5 });
Console.WriteLine($"Shapes count after adding rectangle: {canvas.Shapes.Count}");
// Outputs: Shapes count after adding rectangle: 2
// User decides to undo the last change
canvas.Restore(history.Undo());
Console.WriteLine($"Shapes count after undo: {canvas.Shapes.Count}");
// Outputs: Shapes count after undo: 1
Console.ReadKey();
}
}
}
In this graphic design tool example, the Memento pattern allows designers to undo their actions and revert to a previous state of the canvas. This functionality is essential in design software, where users often experiment with various designs and want the flexibility to backtrack. When you run the above code, you will get the following output.
Real-Time Example of Memento Design Pattern in C#: Thermostat Temperature Control
Imagine a smart thermostat where users can set the desired temperature. As they adjust it throughout the day, they might want to quickly revert to a previously set temperature if they feel uncomfortable. The Memento pattern can facilitate this functionality. Let us see how we can implement the above example using the Memento Design Pattern in C#:
using System;
using System.Collections.Generic;
namespace MementoDesignPattern
{
//TemperatureMemento - Captures the current state of the thermostat.
public class TemperatureMemento
{
public double Temperature { get; }
public TemperatureMemento(double temperature)
{
this.Temperature = temperature;
}
}
//Thermostat - Represents the current state of the thermostat.
public class Thermostat
{
public double Temperature { get; private set; }
public void SetTemperature(double temperature)
{
this.Temperature = temperature;
}
public TemperatureMemento Save()
{
return new TemperatureMemento(Temperature);
}
public void Restore(TemperatureMemento memento)
{
Temperature = memento.Temperature;
}
}
//ThermostatHistory - Manages and keeps track of saved temperature states.
public class ThermostatHistory
{
private Stack<TemperatureMemento> _history = new Stack<TemperatureMemento>();
public void SaveState(Thermostat thermostat)
{
_history.Push(thermostat.Save());
}
public TemperatureMemento Undo()
{
return _history.Count > 0 ? _history.Pop() : null;
}
}
// Testing the Memento Design Pattern
// Client Code
public class Client
{
public static void Main()
{
Thermostat thermostat = new Thermostat();
ThermostatHistory history = new ThermostatHistory();
thermostat.SetTemperature(72.0);
history.SaveState(thermostat);
thermostat.SetTemperature(75.5);
Console.WriteLine($"Current Temperature: {thermostat.Temperature}°F");
// Outputs: Current Temperature: 75.5°F
// User feels it's too warm and decides to revert to the previous temperature
TemperatureMemento previousSetting = history.Undo();
if (previousSetting != null)
thermostat.Restore(previousSetting);
Console.WriteLine($"After undo: {thermostat.Temperature}°F");
// Outputs: After undo: 72.0°F
Console.ReadKey();
}
}
}
In this thermostat example, the Memento pattern lets users quickly revert to a previously set temperature. This is handy when users try to find the most comfortable temperature setting and want the flexibility to revert changes quickly. When you run the above code, you will get the following output.
When to Use the Memento Design Pattern in Real-Time Applications?
The Memento Design Pattern is useful when restoring an object to one of its previous states. It’s essentially an “undo” mechanism for object states. Here are some scenarios in real-time applications where the Memento pattern can be useful:
- Editor Applications: Text editors, image editing software, or any software that offers undo functionality can utilize the Memento pattern to save content states for every change. When a user presses “Undo”, the software retrieves the last saved state from the memento.
- Gaming: Many games allow players to save their progress. The saved game state is a memento. When you load a saved game, you’re restoring the game to its state when you saved it.
- Database Transactions: When performing complex transactions, sometimes you must roll back to a previous state if an error occurs. Memento can help capture the database’s state before performing operations.
- Serialization: Serializing an object to store or send over a network can be seen as creating a memento. The serialized state can be used to restore the object if needed.
- VM Snapshots: Virtualization software allows administrators to take snapshots (or mementos) of a virtual machine’s state. They can restore the VM to a previous snapshot if something goes wrong.
- State Management: Some applications have complex state management needs. For instance, web apps with complicated client-side interactivity might use a state management library or system to manage and navigate between states. Memento patterns can help in storing and restoring these states.
- Browser History: Each webpage visit can be thought of as a state. The browser’s back and forward buttons can be seen as restoring to a previous or next memento.
- Caretaker Operations: Operations like configuration management tools where you want to keep a history of configurations and be able to roll back to a previous configuration if needed.
When considering the use of the Memento pattern, keep the following in mind:
- Memory Implications: Depending on the size of the object’s state and how often mementos are created, the pattern can consume a significant amount of memory.
- Encapsulation: The memento should not expose the internal state details of the originator. Ensure that you’re not breaking encapsulation when implementing the pattern.
So, any situation where you anticipate the need to revert to an earlier state or where maintaining a history of states is beneficial is a potential candidate for the Memento pattern.
Advantages and Disadvantages of Memento Design Pattern
The Memento Design Pattern offers a structured way to capture and restore the internal state of an object without violating its encapsulation. However, as with any design pattern, it has advantages and disadvantages.
Advantages of Memento Design Pattern:
- Preserve Encapsulation: The Memento pattern enables you to save and restore the state of an object without exposing its internal structure.
- Simplifies Originator: By offloading the responsibility of preserving the object’s state to the separate Memento object, the Originator class becomes less complicated.
- Undo Capabilities: The pattern naturally provides an undo mechanism, which can be useful in applications like text editors, graphic editors, and game states.
- History Management: It can maintain a history of states useful in features like branching or version histories.
Disadvantages of Memento Design Pattern:
- Memory Consumption: If not managed properly, keeping too many mementos can lead to high memory usage, especially if the mementos store a lot of state information or are saved frequently.
- Overhead: Creating mementos might introduce runtime overhead, especially if the state is complex or is done frequently.
- Maintenance Complexity: If the internal state of the Originator changes (like when new fields are added), you’ll need to ensure the Memento class is updated appropriately, which can lead to maintenance issues.
- Tight Coupling: Even though the Memento pattern preserves encapsulation from the client’s perspective, the Memento class often has to be tightly coupled with the Originator to access its internal state. This can be a problem if you need to change the structure of the Originator or make it work with mementos created from a different version of the Originator.
- State Integrity: Care must be taken to ensure the integrity of the saved state. If, for some reason, a memento gets corrupted or is not in sync with the originator’s structure, restoring from such a memento can lead to undefined behavior.
In conclusion, while the Memento pattern provides a structured mechanism to implement state-saving features like undo and history management, it’s important to be aware of its downsides and employ it judiciously. Like any design pattern, it’s a tool, and its suitability depends on the specific requirements and constraints of the application.
In the next article, I will discuss the Dependency Injection Design Pattern in C# with Examples. Here, in this article, I try to explain Real-Time Examples of Memento Design Patterns in C#. I hope you enjoy this article.
About the Author: Pranaya Rout
Pranaya Rout has published more than 3,000 articles in his 11-year career. Pranaya Rout has very good experience with Microsoft Technologies, Including C#, VB, ASP.NET MVC, ASP.NET Web API, EF, EF Core, ADO.NET, LINQ, SQL Server, MYSQL, Oracle, ASP.NET Core, Cloud Computing, Microservices, Design Patterns and still learning new technologies.