WPF: comment utiliser les 2 convertisseurs 1 liaison?

J'ai un contrôle que je veux afficher/masquer, en fonction de la valeur d'un booléen.

J'ai un NegatedBooleanConverter (commutateurs de true à false, et vice-versa) et j'ai besoin d'exécuter ce convertisseur en premier.
J'ai un BooleanToVisibilityConverter et j'ai besoin d'exécuter ce convertisseur après le NegatedBoolConverter.

Comment puis-je résoudre ce problème? Je veux le faire en XAML.

edit: c'est une solution possible.

Qui ne semble pas fonctionner. Il convertit la valeur avec le séparer les convertisseurs et puis quelque chose avec les valeurs converties.

Ce dont j'ai besoin est:

  • Convertir la valeur avec le premier convertisseur (ce qui donne convertedValue).
  • Convertir convertedValue avec le deuxième convertisseur et c'est ce résultat que j'ai besoin.
  • oui, la solution est lié à est probablement le meilleur...
  • Voir aussi le Chaînage de plusieurs convertisseurs en XAML
  • La ville dit mieux que ici, sa solution permet de chaîne autant que vous le souhaitez, semblable à jberger réponse, mais celle-ci est encore plus élégant et court dans la mise en œuvre
InformationsquelleAutor Natrium | 2009-10-20
  1. 59

    C'est ce que j'ai fait:

    public class CombiningConverter : IValueConverter
    {
        public IValueConverter Converter1 { get; set; }
        public IValueConverter Converter2 { get; set; }

        #region IValueConverter Members

        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            object convertedValue = Converter1.Convert(value, targetType, parameter, culture);
            return Converter2.Convert(convertedValue, targetType, parameter, culture);
        }

        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            throw new NotImplementedException();
        }

        #endregion
    }

    et je l'appelle comme ceci:

    <converters:CombiningConverter x:Key="negatedBoolToVisibilityConverter" Converter1="{StaticResource NegatedBooleanConverter}" Converter2="{StaticResource BoolToVisibilityConverter}" />

    Un MultiValueConverter pourrait également être possible je pense. Peut-être que je vais essayer plus tard.

    • C'est gentil...
    InformationsquelleAutor Natrium
  2. 28

    Expansion sur de Sodium, la grande réponse...

    XAML 

    <conv:ConverterChain x:Key="convBoolToInverseToVisibility">
    <conv:BoolToInverseConverter />
    <BooleanToVisibilityConverter />
</conv:ConverterChain>

    Classe

    ///<summary>Represents a chain of <see cref="IValueConverter"/>s to be executed in succession.</summary>
[ContentProperty("Converters")]
[ContentWrapper(typeof(ValueConverterCollection))]
public class ConverterChain : IValueConverter
{
    private readonly ValueConverterCollection _converters= new ValueConverterCollection();

    ///<summary>Gets the converters to execute.</summary>
    public ValueConverterCollection Converters
    {
        get { return _converters; }
    }

    #region IValueConverter Members

    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return Converters
            .Aggregate(value, (current, converter) => converter.Convert(current, targetType, parameter, culture));
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return Converters
            .Reverse()
            .Aggregate(value, (current, converter) => converter.Convert(current, targetType, parameter, culture));
    }

    #endregion
}

///<summary>Represents a collection of <see cref="IValueConverter"/>s.</summary>
public sealed class ValueConverterCollection : Collection<IValueConverter> { }
    • Cette article's solution offre au moment de l'exécution de la vérification de type.
    • Cela passe du mauvais targetType de convertisseurs. Il va passer la destination targetType à tous les convertisseurs, qui, même dans l'ouverture de la question scénario est incorrect. Le type de "Visibilité" est passée au premier convertisseur, lorsque le targetType est en fait "bool".
    InformationsquelleAutor Jake Berger
  3. 3

    Ce que nous faisons dans notre projet, c'est de faire régulièrement BooleanToVisibilityConverter, dit convertisseur prend un paramètre (de rien du tout, un string, int, bool, peu importe). Si le paramètre est défini, il inverse le résultat, si pas, il crache de l'ordinaire résultat.

    public class BooleanToVisibilityConverter : IValueConverter
{
    #region IValueConverter Members

    public object Convert(object value, System.Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        bool? isVisible = value as bool?;
        if (parameter != null && isVisible.HasValue)
            isVisible = !isVisible;
        if (isVisible.HasValue && isVisible.Value == true)
            return Visibility.Visible;
        else
            return Visibility.Collapsed;
    }

    public object ConvertBack(object value, System.Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        throw new System.NotImplementedException();
    }

    #endregion
}
    • comment appeler ce convertisseur en xaml?
    InformationsquelleAutor Carlo
  4. 3

    Dans ce cas, vous n'avez pas besoin d'un convertisseur de chaîne. Vous avez juste besoin d'un configurable convertisseur. Ceci est similaire à Carlo réponse ci-dessus, mais définit explicitement les valeurs vrai et faux (ce qui signifie que vous pouvez utiliser les mêmes convertisseurs Caché, Visible ou l'effondrement des conversions).

    [ValueConversion(typeof(bool), typeof(Visibility))]
public class BoolToVisibilityConverter : IValueConverter
{
    public Visibility TrueValue { get; set; }
    public Visibility FalseValue { get; set; }

    public BoolToVisibilityConverter()
    {
        //set defaults
        FalseValue = Visibility.Hidden;
        TrueValue = Visibility.Visible;
    }

    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return (bool)value ? TrueValue : FalseValue;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

    Puis en XAML:

        <BoolToVisibilityConverter x:Key="BoolToVisibleConverter"
                               FalseValue="Hidden"
                               TrueValue="Visible" />
    • Si vous pouvez utiliser XAML 2009, vous pouvez aussi faire de ce générique. La syntaxe d'attribut: Converter={c:BooleanConverter(Visibility) True=Visible, False=Collapsed} élément de syntaxe: <c:BooleanConverter x:TypeArguments="FontWeight" True="Bold" False="Normal" /> Si vous ne pouvez pas utiliser XAML 2009, vous pouvez toujours faire la classe de base générique, mais vous avez besoin de béton les classes dérivées pour chaque type générique.
    InformationsquelleAutor metao
  5. 1

    Pour répondre à ma propre question: j'utilise cette solution depuis des années maintenant: http://www.codeproject.com/Articles/15061/Piping-Value-Converters-in-WPF

    Il fait un nouveau convertisseur de 2 convertisseurs, d'appeler le premier un premier, puis le second, etc, etc.

    Je suis assez heureux avec cette solution.

    InformationsquelleAutor Natrium
  6. 0

    Je viens de créer ce que j'ai appelé ReversedBooleanToVisibilityConverter pour l'essentiel à faire ce que ces 2 permettrait de le faire pour vous, mais en une seule étape.

    • Oui, ce serait une solution possible, mais je préfère une solution où je peux réutiliser mon convertisseurs sans avoir à réinventer la roue. Si cette solution existe...
    InformationsquelleAutor Alan Mendelevich
  7. 0

    Pour répondre à ce problème spécifique, au lieu d'utiliser deux convertisseurs de votre pouvez écrire votre propre BoolToVisibilityConverter qui utilise le ConverterParameter (comme un bool) afin de déterminer si ou de ne pas nier l'origine Booléenne.

    • Oui, ce serait une solution possible, mais je préfère une solution où je peux réutiliser mon convertisseurs sans avoir à réinventer la roue. Si cette solution existe...
    InformationsquelleAutor John Myczek
  8. 0

    Personnellement, je voudrais juste faire 1 seul convertisseur qui fait la conversion totale. Sauf si vous avez désespérément besoin les convertisseurs (comme la négation) dans d'autres endroits, il sera plus facile à maintenir (omi) si la conversion est effectuée à la fois, en un seul endroit.

    • Oui, ce serait une solution possible, mais je préfère une solution où je peux réutiliser mon convertisseurs sans avoir à réinventer la roue. Si cette solution existe...
    InformationsquelleAutor Alastair Pitts
  9. 0

    Je pense que vous souhaiterez peut-être utiliser un Multiconverter ici au lieu de deux convertisseurs. Vous devriez être en mesure de réutiliser la logique de vos convertisseurs. Découvrez cette discussion pour commencer.

    InformationsquelleAutor Scott Lawrence