wpf
Konwertery wartości i wielowartościowe

Parametry

Uwagi

Wbudowany BooleanToVisibilityConverter [IValueConverter]

Konwerter między wartością logiczną a widocznością. Uzyskaj wartość bool na wejściu i zwraca wartość Visibility .

UWAGA: Ten konwerter już istnieje w przestrzeni nazw System.Windows.Controls .

public sealed class BooleanToVisibilityConverter : IValueConverter
{
    /// <summary>
    /// Convert bool or Nullable bool to Visibility
    /// </summary>
    /// <param name="value">bool or Nullable bool</param>
    /// <param name="targetType">Visibility</param>
    /// <param name="parameter">null</param>
    /// <param name="culture">null</param>
    /// <returns>Visible or Collapsed</returns>
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        bool bValue = false;
        if (value is bool)
        {
            bValue = (bool)value;
        }
        else if (value is Nullable<bool>)
        {
            Nullable<bool> tmp = (Nullable<bool>)value;
            bValue = tmp.HasValue ? tmp.Value : false;
        }
        return (bValue) ? Visibility.Visible : Visibility.Collapsed;
    }

    /// <summary>
    /// Convert Visibility to boolean
    /// </summary>
    /// <param name="value"></param>
    /// <param name="targetType"></param>
    /// <param name="parameter"></param>
    /// <param name="culture"></param>
    /// <returns></returns>
    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is Visibility)
        {
            return (Visibility)value == Visibility.Visible;
        }
        else
        {
            return false;
        }
    }
}

Korzystanie z konwertera

1. Zdefiniuj zasób

<BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter"/>

3. Użyj go w oprawie

<Button Visibility="{Binding AllowEditing, 
                             Converter={StaticResource BooleanToVisibilityConverter}}"/>

Konwerter z właściwością [IValueConverter]

Pokaż, jak utworzyć prosty konwerter z parametrem poprzez właściwość, a następnie przekaż go w deklaracji. Konwertuj wartość bool na Visibility . Zezwól na odwrócenie wartości wyniku, ustawiając Inverted właściwość na True .

public class BooleanToVisibilityConverter : IValueConverter
{
    public bool Inverted { get; set; }

    /// <summary>
    /// Convert bool or Nullable bool to Visibility
    /// </summary>
    /// <param name="value">bool or Nullable bool</param>
    /// <param name="targetType">Visibility</param>
    /// <param name="parameter">null</param>
    /// <param name="culture">null</param>
    /// <returns>Visible or Collapsed</returns>
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        bool bValue = false;
        if (value is bool)
        {
            bValue = (bool)value;
        }
        else if (value is Nullable<bool>)
        {
            Nullable<bool> tmp = (Nullable<bool>)value;
            bValue = tmp ?? false;
        }

        if (Inverted)
            bValue = !bValue;
        return (bValue) ? Visibility.Visible : Visibility.Collapsed;
    }

    /// <summary>
    /// Convert Visibility to boolean
    /// </summary>
    /// <param name="value"></param>
    /// <param name="targetType"></param>
    /// <param name="parameter"></param>
    /// <param name="culture"></param>
    /// <returns>True or False</returns>
    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is Visibility)
        {
            return ((Visibility) value == Visibility.Visible) && !Inverted;
        }

        return false;
    }
}

Korzystanie z konwertera

1. Zdefiniuj przestrzeń nazw

xmlns:converters="clr-namespace:MyProject.Converters;assembly=MyProject"

2. Zdefiniuj zasób

<converters:BooleanToVisibilityConverter x:Key="BoolToVisibilityInvertedConverter"
                                         Inverted="False"/>

3. Użyj go w oprawie

<Button Visibility="{Binding AllowEditing, Converter={StaticResource BoolToVisibilityConverter}}"/>

Prosty konwerter dodawania [IMultiValueConverter]

Pokaż, jak utworzyć prosty konwerter IMultiValueConverter i korzystać z MultiBinding w MultiBinding . Uzyskaj podsumowanie wszystkich wartości przekazanych przez tablicę values .

public class AddConverter : IMultiValueConverter
{
    public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
    {
        decimal sum = 0M;

        foreach (string value in values)
        {
            decimal parseResult;
            if (decimal.TryParse(value, out parseResult))
            {
                sum += parseResult;
            }
        }

        return sum.ToString(culture);
    }

    public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
    {
        throw new NotSupportedException();
    }
}

Korzystanie z konwertera

1. Zdefiniuj przestrzeń nazw

xmlns:converters="clr-namespace:MyProject.Converters;assembly=MyProject"

2. Zdefiniuj zasób

<converters:AddConverter x:Key="AddConverter"/>

3. Użyj go w oprawie

<StackPanel Orientation="Vertical">
    <TextBox x:Name="TextBox" />
    <TextBox x:Name="TextBox1" />
    <TextBlock >
        <TextBlock.Text>
            <MultiBinding Converter="{StaticResource AddConverter}">
                <Binding Path="Text" ElementName="TextBox"/>
                <Binding Path="Text" ElementName="TextBox1"/>
            </MultiBinding>
         </TextBlock.Text>
    </TextBlock>
</StackPanel>

Konwertery użytkowania z ConverterParameter

Pokaż, jak utworzyć prosty konwerter i użyj ConverterParameter aby przekazać parametr do konwertera. Pomnóż wartość przez współczynnik przekazany w ConverterParameter.

public class MultiplyConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value == null)
            return 0;

        if (parameter == null)
            parameter = 1;

        double number;
        double coefficient;

        if (double.TryParse(value.ToString(), out number) && double.TryParse(parameter.ToString(), out coefficient))
        {
            return number * coefficient;
        }

        return 0;
    }

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

Korzystanie z konwertera

1. Zdefiniuj przestrzeń nazw

xmlns:converters="clr-namespace:MyProject.Converters;assembly=MyProject"

2. Zdefiniuj zasób

<converters:MultiplyConverter x:Key="MultiplyConverter"/>

3. Użyj go w oprawie

<StackPanel Orientation="Vertical">
    <TextBox x:Name="TextBox" />
    <TextBlock Text="{Binding Path=Text, 
                              ElementName=TextBox, 
                              Converter={StaticResource MultiplyConverter},
                              ConverterParameter=10}"/>
</StackPanel>

Grupowanie wielu konwerterów [IValueConverter]

Ten konwerter będzie łączyć wiele konwerterów razem.

public class ValueConverterGroup : List<IValueConverter>, IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return this.Aggregate(value, (current, converter) => converter.Convert(current, targetType, parameter, culture));
    }

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

W tym przykładzie wynik logiczny z EnumToBooleanConverter jest używany jako dane wejściowe w BooleanToVisibilityConverter .

<local:ValueConverterGroup x:Key="EnumToVisibilityConverter">
    <local:EnumToBooleanConverter/>
    <local:BooleanToVisibilityConverter/>
</local:ValueConverterGroup>

Przycisk będzie widoczny tylko wtedy, gdy właściwość CurrentMode jest ustawiona na Ready .

<Button Content="Ok" Visibility="{Binding Path=CurrentMode, Converter={StaticResource EnumToVisibilityConverter}, ConverterParameter={x:Static local:Mode.Ready}"/>

Użycie MarkupExtension z konwerterami do pominięcia deklaracji zasobów

Zwykle, aby użyć konwertera, musimy zdefiniować go jako zasób w następujący sposób:

<converters:SomeConverter x:Key="SomeConverter"/>

Można pominąć ten krok, definiując konwerter jako MarkupExtension i implementując metodę ProvideValue . Poniższy przykład konwertuje wartość na jej wartość ujemną:

namespace MyProject.Converters
{
public class Converter_Negative : MarkupExtension, IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return this.ReturnNegative(value);
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return this.ReturnNegative(value);
    }

    private object ReturnNegative(object value)
    {
        object result = null;
        var @switch = new Dictionary<Type, Action> {
            { typeof(bool), () => result=!(bool)value },
            { typeof(byte), () => result=-1*(byte)value },
            { typeof(short), () => result=-1*(short)value },
            { typeof(int), () => result=-1*(int)value },
            { typeof(long), () => result=-1*(long)value },
            { typeof(float), () => result=-1f*(float)value },
            { typeof(double), () => result=-1d*(double)value },
            { typeof(decimal), () => result=-1m*(decimal)value }
        };

        @switch[value.GetType()]();
        if (result == null) throw new NotImplementedException();
        return result;
    }

    public Converter_Negative()
        : base()
    {
    }

    private static Converter_Negative _converter = null;

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        if (_converter == null) _converter = new Converter_Negative();
        return _converter;
    }
}
}

Za pomocą konwertera:

1. Zdefiniuj przestrzeń nazw

   xmlns: converters = "clr-namespace: MyProject.Converters; assembly = MyProject"

2. Przykładowe użycie tego konwertera w powiązaniu

   <RichTextBox IsReadOnly="{Binding Path=IsChecked, ElementName=toggleIsEnabled, Converter={converters:Converter_Negative}}"/>
   

Użyj IMultiValueConverter, aby przekazać wiele parametrów do polecenia

Możliwe jest przekazanie wielu powiązanych wartości jako parametru CommandParameter za pomocą MultiBinding za pomocą bardzo prostego IMultiValueConverter :

namespace MyProject.Converters
{
    public class Converter_MultipleCommandParameters : MarkupExtension, IMultiValueConverter
    {
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            return values.ToArray();
        }
        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
        {
            throw new NotSupportedException();
        }

        private static Converter_MultipleCommandParameters _converter = null;

        public override object ProvideValue(IServiceProvider serviceProvider)
        {
            if (_converter == null) _converter = new Converter_MultipleCommandParameters();
            return _converter;
        }

        public Converter_MultipleCommandParameters()
            : base()
        {
        }
    }
}

Za pomocą konwertera:

1. Przykładowa implementacja - metoda wywoływana podczas wykonywania SomeCommand ( uwaga: DelegateCommand to implementacja ICommand która nie jest podana w tym przykładzie ):

    private ICommand _SomeCommand;
    public ICommand SomeCommand
    {
        get { return _SomeCommand ?? (_SomeCommand = new DelegateCommand(a => OnSomeCommand(a))); }
    }
   
    private void OnSomeCommand(object item)
    {
        object[] parameters = item as object[];
   
        MessageBox.Show(
            string.Format("Execute command: {0}\nParameter 1: {1}\nParamter 2: {2}\nParamter 3: {3}",
            "SomeCommand", parameters[0], parameters[1], parameters[2]));
    }
   

2. Zdefiniuj przestrzeń nazw

xmlns: converters = "clr-namespace: MyProject.Converters; assembly = MyProject"

3. Przykładowe użycie tego konwertera w powiązaniu

   <Button Width="150" Height="23" Content="Execute some command" Name="btnTestSomeCommand"
        Command="{Binding Path=SomeCommand}" >
        <Button.CommandParameter>
            <MultiBinding Converter="{converters:Converter_MultipleCommandParameters}">
                <Binding RelativeSource="{RelativeSource Self}" Path="IsFocused"/>
                <Binding RelativeSource="{RelativeSource Self}" Path="Name"/>
                <Binding RelativeSource="{RelativeSource Self}" Path="ActualWidth"/>
            </MultiBinding>
        </Button.CommandParameter>
    </Button>