Machen Sie diese Reflexion Methodenaufruf typsicher

Question

class CustomerMessage
{
    private string name;
    private Dictionary<MethodBase, object> changeTrackingMethods = 
        new Dictionary<MethodBase, object>();

    public int Id { get; set; }

    public string Name {
        get { return this.name; }
        set
        {
            this.name = value;
            this.PropertyChanged("SetName", value);
        }
    }

    private void PropertyChanged(string behaviorMethod, object value)
    {
        var method = typeof(Customer).GetMethod(behaviorMethod);
        this.changeTrackingMethods.Add(method, value);
    }

    public void ApplyChanges(Customer c)
    {
        foreach (var changedProperty in this.changeTrackingMethods)
            changedProperty.Key.Invoke(c, new object[] { 
                changedProperty.Value 
            });
    }
}

Wie man sehen kann ich die Änderungen auf dieser eingehenden Nachricht am Tracking, um die Änderungen auf einem anderen Objekt laufen. Das Verfahren zur Lauf wird als String Propertygeben. Hat jemand einen Tipp, wie ich diese Art sicher machen?

Answer 1

So etwas wie das?

class CustomerMessage
{
    private string name;
    private List<Action<Customer>> changeTrackingMethods =
        new List<Action<Customer>>();

    public int Id { get; set; }

    public string Name {
        get { return this.name; }
        set
        {
            this.name = value;
            this.changeTrackingMethods.Add(c => { c.SetName(value) });
        }
    }

    public void ApplyChanges(Customer c)
    {
        foreach (var action in this.changeTrackingMethods)
        {
            action(c);
        }
    }
}

Answer 2

Sie wollen also als String übergeben den Namen der Methode zu vermeiden? Warum nicht das Objekt Method erhält in den Setter?

public string Name {
    get { return this.name; }
    set
    {
        this.name = value;
        this.PropertyChanged(typeof(Customer).GetMethod(behaviorMethod), value);
    }
}

private void PropertyChanged(MethodBase method, object value)
{
    this.changeTrackingMethods.Add(method, value);
}

Answer 3

Anstelle das Speichern der „Operation, die getan werden muss“ als ein Paar von Verfahren und ein Argument, das es mit Reflexion übergeben werden, sollten Sie einen Delegaten speichern können, die ausgeführt werden sollen. Der einfachste Weg, dies zu tun ist, eine Liste vom Typ List<Action<Customer>> speichern - dann in der ApplyChanges Methode können Sie die Liste durchlaufen und alle Aktionen ausgeführt werden.

Falls Sie sich nicht mit .NET 3.5 und C # 3.0 (das ist eine generische Delegaten Action und unterstützt Lambda-Ausdrücke definiert), können Sie diese Zeilen schreibe in C # 2.0:

// you can define a delegate like this
delegate void UpdateCustomer(Customer c);

// and you could use anonymous methods 
// (instead of more recent lambda expressions)
list.Add(delegate (Customer c) { c.SetName("test"); });

EDIT:. Es sieht aus wie ich war langsamer mit dem Code zu schreiben, aber ich werde das hier hält als Erklärung - die Lösung von ‚dtb‘ ist genau das, was ich beschrieben