Mediatore come Singleton - design-patterns, singleton, mediator

Sto lavorando a un progetto scolastico su GRAPS eModelli di progettazione. È fondamentalmente un gioco con una griglia su cui gli oggetti e i giocatori possono muoversi. Stavo pensando di usare un mediatore per determinare la posizione esatta su cui un oggetto dovrebbe atterrare.

Ogni collega (in questo caso ogni articolo e ilgriglia) dovrebbe essere consapevole del suo "oggetto Mediatore" (Design Patterns, Gamma et al.) Per questo motivo, mi chiedevo se rendere questo mediatore un singleton sarebbe stato considerato una buona scelta progettuale. Il mediatore è completamente apolide ed è identico per ciascun oggetto, soddisfacendo così i requisiti di applicabilità stabiliti dal modello Singleton.

risposte:

So che è tardi, ma ti preghiamo di controllare la seguente implementazione del mediatore ...

public sealed class Mediator
{
private static Mediator instance = null;
private volatile object locker = new object();
private MultiDictionary<ViewModelMessages, Action<Object>> internalList =
new MultiDictionary<ViewModelMessages, Action<object>>();

#region Constructors.
/// <summary>
/// Internal constructor.
/// </summary>
private Mediator() { }

/// <summary>
/// Static constructor.
/// </summary>
static Mediator() { }
#endregion

#region Properties.
/// <summary>
/// Instantiate the singleton.
/// </summary>
public static Mediator Instance
{
get
{
if (instance == null)
instance = new Mediator();
return instance;
}
}
#endregion

#region Public Methods.
/// <summary>
/// Registers a Colleague to a specific message.
/// </summary>
/// <param name="callback">The callback to use
/// when the message it seen.</param>
/// <param name="message">The message to
/// register to.</param>
public void Register(Action<Object> callback, ViewModelMessages message)
{
internalList.AddValue(message, callback);
}

/// <summary>
/// Notify all colleagues that are registed to the
/// specific message.
/// </summary>
/// <param name="message">The message for the notify by.</param>
/// <param name="args">The arguments for the message.</param>
public void NotifyColleagues(ViewModelMessages message, object args)
{
if (internalList.ContainsKey(message))
{
// forward the message to all listeners.
foreach (Action<object> callback in internalList[message])
callback(args);
}
}
#endregion
}

Questa classe utilizza a Dictionary<[enum], Action<T>> mediare. Questa classe è stata ammessa da me, ma è stata originariamente presa da Qui. Dice MVVM, ma non c'è motivo per cui non possa funzionare in altre implementazioni.

Questo è un mediatore singleton e può essere usato come mostrato nell'articolo collegato.

Spero che questo aiuti e mi scusi per la risposta in ritardo.