changement C# cible action/délégué: appels hiérarchiques

Question

Supposons que j'ai

public IList<Entity> Children { get; set; } 

public NotifyChildren(Func<object, bool> action, object data) 
{ 
    foreach (var child in Children) 
     if (action(data)) 
      /// <-- !!!! need action to work on child this time, not on the original target 
      //child.NofifyChildren(action, data); <- this doesn't work because of the above requirement 
      child.NotifyChildren(action.ChangeTargetTo(child), data); // << pseudocode! 
} 

public void SomeChangeOccured() 
{ 
    var changedChild; 
    NotifyChildren(x => x.SomeHandler(), "somedata"); 
} 

Comment puis-je changer la cible de l'action? Je suis OK pour passer un délégué au lieu de l'action mais son .Target est en lecture seule, aussi. Je pense actuellement en train de faire

public NotifyChildren(Expression<Func<Entity, bool>> action, object data) 
{ 
    // so that I can do method.Invoke(newtarget, new object[]{data}); 
    NotifyChildren(((MethodCallExpression)action).Method, data); 
} 

qui est, passer de l'action à l'appel de la méthode réfléchie ... mais il est un peu laid, est-ce pas?

J'ai le sentiment que la solution est très simple et je la connaissais ... juste oublié. Hm, une solution serait d'avoir un délégué statique qui accepte Entity comme premier paramètre, mais je ne voudrais pas aller de cette façon.

Answer 1

Qu'est-ce que vous êtes spécifiquement demandant n'est pas possible. Un délégué représente une méthode liée statiquement, alors que vous cherchez quelque chose de dynamique. Pour ce faire, vous avez besoin de réflexion.

Cependant, votre code apparaît pour être structuré de la manière correcte pour accomplir ce que vous voulez, mais le code n'a pas l'air d'être appelé correctement.

Vous définir action comme Func<Entity, bool>, mais vous passez data (ce qui est un object) plutôt que child (ce qui est un Entity). Il semble que vous devriez effectivement déclarer comme Func<Entity, object, bool> et le faire comme ceci:

public IList<Entity> Children { get; set; } 

public NotifyChildren(Func<Entity, object, bool> action, object data) 
{ 
    foreach (var child in Children) 
    { 
     if (action(child, data)) 
     { 
      child.NofifyChildren(action, data); 
     } 
    } 
} 

public void SomeChangeOccured() 
{ 
    NotifyChildren((x, data) => x.SomeHandler(data), "somedata"); 
} 

public bool SomeHandler(object data) 
{ 
    return true; // obviously need more robust logic 
} 

Answer 2

foreach (var child in Children) 
    if (action(data)) 
     /// <-- !!!! need action to work on child this time, not on the original target 
     child.NofifyChildren(action, data); 

Pourquoi appelez-vous une action dans cette boucle? Je pense que vous pouvez l'appeler une seule fois avant.