Lier à une méthode dans WPF?

Comment liez-vous à une méthode d'objets dans ce scénario dans WPF?

public class RootObject
{
    public string Name { get; }

    public ObservableCollection<ChildObject> GetChildren() {...}
}

public class ChildObject
{
    public string Name { get; }
}

XAML:

<TreeView ItemsSource="some list of RootObjects">
    <TreeView.Resources>
        <HierarchicalDataTemplate DataType="{x:Type data:RootObject}" 
                                  ItemsSource="???">
            <TextBlock Text="{Binding Path=Name}" />
        </HierarchicalDataTemplate>
        <HierarchicalDataTemplate DataType="{x:Type data:ChildObject}">
            <TextBlock Text="{Binding Path=Name}" />
        </HierarchicalDataTemplate>
    </TreeView.Resources>
</TreeView>

Ici, je veux me lier à la GetChildrenméthode sur chacun RootObjectdes arbres.

EDIT La liaison à un ObjectDataProviderne semble pas fonctionner parce que je me lie à une liste d'éléments et que les ObjectDataProviderbesoins soit une méthode statique, soit elle crée sa propre instance et l'utilise.

Par exemple, en utilisant la réponse de Matt, j'obtiens:

Erreur System.Windows.Data: 33: ObjectDataProvider ne peut pas créer d'objet; Type = 'objet racine'; Error = 'Mauvais paramètres pour le constructeur.'

Erreur System.Windows.Data: 34: ObjectDataProvider: échec de la tentative d'appel de la méthode sur le type; Méthode = 'GetChildren'; Type = 'objet racine'; Error = 'Le membre spécifié ne peut pas être appelé sur la cible.' TargetException: 'System.Reflection.TargetException: La méthode non statique nécessite une cible.

Une autre approche qui pourrait fonctionner pour vous est de créer une personnalisation IValueConverterqui prend un nom de méthode en tant que paramètre, afin qu'elle soit utilisée comme ceci:

ItemsSource="{Binding 
    Converter={StaticResource MethodToValueConverter},
    ConverterParameter='GetChildren'}"

Ce convertisseur trouverait et invoquerait la méthode en utilisant la réflexion. Cela nécessite que la méthode n'ait aucun argument.

Voici un exemple de la source d'un tel convertisseur:

public sealed class MethodToValueConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        var methodName = parameter as string;
        if (value==null || methodName==null)
            return value;
        var methodInfo = value.GetType().GetMethod(methodName, new Type[0]);
        if (methodInfo==null)
            return value;
        return methodInfo.Invoke(value, new object[0]);
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotSupportedException("MethodToValueConverter can only be used for one way conversion.");
    }
}

Et un test unitaire correspondant:

[Test]
public void Convert()
{
    var converter = new MethodToValueConverter();
    Assert.AreEqual("1234", converter.Convert(1234, typeof(string), "ToString", null));
    Assert.AreEqual("ABCD", converter.Convert(" ABCD ", typeof(string), "Trim", null));

    Assert.IsNull(converter.Convert(null, typeof(string), "ToString", null));

    Assert.AreEqual("Pineapple", converter.Convert("Pineapple", typeof(string), "InvalidMethodName", null));
}

Notez que ce convertisseur n'applique pas le targetTypeparamètre.

Vous ne savez pas comment cela fonctionnera dans votre scénario, mais vous pouvez utiliser la MethodNamepropriété sur ObjectDataProviderpour lui faire appeler une méthode spécifique (avec des paramètres spécifiques de votre MethodParameterspropriété) pour récupérer ses données.

Voici un extrait de code extrait directement de la page MSDN:

<Window.Resources>
    <ObjectDataProvider ObjectType="{x:Type local:TemperatureScale}"
        MethodName="ConvertTemp" x:Key="convertTemp">
        <ObjectDataProvider.MethodParameters>
            <system:Double>0</system:Double>
            <local:TempType>Celsius</local:TempType>
        </ObjectDataProvider.MethodParameters>
    </ObjectDataProvider>
</Window.Resources>

C'est donc ObjectDataProviderune ConvertTempméthode qui appelle une méthode sur une instance d'une TemperatureScaleclasse, en passant deux paramètres ( 0et TempType.Celsius).

Devez-vous vous lier à la méthode?

Pouvez-vous vous lier à une propriété dont le getter est la méthode?

public ObservableCollection<ChildObject> Children
{
   get
   {
      return GetChildren();
   }
}

À moins que vous ne puissiez ajouter une propriété pour appeler la méthode (ou créer une classe wrapper qui ajoute cette propriété), le seul moyen que je connaisse est d'utiliser un ValueConverter.

ObjectDataProvider a également une propriété ObjectInstance qui peut être utilisée à la place de ObjectType

Vous pouvez utiliser System.ComponentModelpour définir dynamiquement les propriétés d'un type (elles ne font pas partie des métadonnées compilées). J'ai utilisé cette approche dans WPF pour activer la liaison à un type qui stockait ses valeurs dans des champs, car la liaison aux champs n'est pas possible.

Les types ICustomTypeDescriptoret TypeDescriptionProviderpeuvent vous permettre d'obtenir ce que vous voulez. D'après cet article :

TypeDescriptionProvidervous permet d'écrire une classe distincte qui implémente ICustomTypeDescriptor, puis d'enregistrer cette classe en tant que fournisseur de descriptions pour d'autres types.

Je n'ai pas essayé cette approche moi-même, mais j'espère qu'elle vous sera utile dans votre cas.

Pour lier à la méthode d'un objet dans votre scénario WPF, vous pouvez lier à une propriété qui retourne un délégué.