Manipulador de eventos padrão (com operador+ =) é um dosvazamento de memória causa (se não for registrado / descartado (com- = operador)).
E a Microsoft resolveu comWeakEventManager e sua herança como:PropertyChangedEventManager, CollectionChangedEventManager, CurrentChangedEventManager, ErrorsChangedEventManager e assim por diante.

O exemplo de código simples com vazamento de memória é:

public class EventCaller
{
    public static event EventHandler MyEvent;

    public static void Call()
    {
        var handler = MyEvent;
        if (handler != null)
        {
            handler(null, EventArgs.Empty);
            Debug.WriteLine("=============");
        }
    }
}

public class A
{
    string myText;

    public A(string text)
    {
        myText = text;
        EventCaller.MyEvent += OnCall;

        // Use code below and comment out code above to avoid memory leakage.
        // System.Windows.WeakEventManager<EventCaller, EventArgs>.AddHandler(null, "MyEvent", OnCall);  
    }

    void OnCall(object sender, EventArgs e)
    {
        Debug.WriteLine(myText);
    }

    ~A()
    {
        Debug.WriteLine(myText + " destructor");
    }
}

void Main()
{
    var a = new A("A");
    var b = new A("B");
    EventCaller.Call();
    a = null;
    GC.Collect();
    EventCaller.Call();
}

A saída é:

A
B
+++++++
A
B
+++++++

Podemos ver que o destruidor não será chamado. Mas se mudarmos (comentando o código não utilizado) de:

    EventCaller.MyEvent += OnCall;

para

    System.Windows.WeakEventManager<EventCaller, EventArgs>.AddHandler(null, "MyEvent", OnCall);  

E a saída é:

A
B
+++++++
B
+++++++
Um destruidor
Destruidor B

Depois que a é nulo, seu manipulador de eventos não será mais chamado.
A e B serão descartados depois de não serem mais usados sem o operador - =.

1. Posso substituir com segurança todo o operador + = pelo System.Windows.WeakEventManager para evitar vazamento de memória devido à falta de registro no evento e ao salvar código, não deve implementar IDisposable?

2. Se não for realmente seguro, o que devo considerar ou observar?