如何为IValueConverter类的属性绑定列表类型数据及编写绑定表达式？

Great question! Yes, you absolutely can bind an IValueConverter's property to a list—you just need to adjust how you declare and reference your converter in XAML. The inline markup extension syntax you used (Converter={converter:ValueConverterWithProperties TrueValue=5}) only works for static values, so we’ll need to refactor things to support data binding.

Here’s how to do it step by step: #

1. Update your Converter class to support a collection property

First, modify your ValueConverterWithProperties to include a collection-type property (replacing the single TrueValue). Use an IList<T> or ObservableCollection<T> if you need dynamic updates when the list changes:

using System.Collections.Generic;
using System.Globalization;
using System.Windows;
using System.Windows.Data;
using System.Windows.Markup;

public class ValueConverterWithProperties : MarkupExtension, IValueConverter
{
    // Replace single value property with collection
    public IList<int> TrueValues { get; set; }

    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        // Check if the bound value exists in the TrueValues collection
        if (value is int itemValue && TrueValues != null)
        {
            return TrueValues.Contains(itemValue);
        }
        return false;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        // Reverse conversion logic (adjust based on your needs)
        if ((bool)value && TrueValues?.Count > 0)
        {
            return TrueValues[0]; // Example: return first item in the list
        }
        return Binding.DoNothing;
    }

    // Keep this for markup extension support (optional if only using as a resource)
    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        return this;
    }
}

If you need the converter to react when the list’s contents change (e.g., items added/removed), use ObservableCollection<int> and implement INotifyPropertyChanged to handle changes to the list reference itself:

using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.CompilerServices;

public class ValueConverterWithProperties : MarkupExtension, IValueConverter, INotifyPropertyChanged
{
    private ObservableCollection<int> _trueValues;
    public ObservableCollection<int> TrueValues
    {
        get => _trueValues;
        set
        {
            _trueValues = value;
            OnPropertyChanged();
        }
    }

    // INotifyPropertyChanged implementation
    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    // Convert/ConvertBack methods remain the same
}

2. Declare the converter as a XAML resource and bind its property

Instead of using the inline markup extension, declare your converter as a resource in your XAML (e.g., in Window.Resources or UserControl.Resources). This lets you use data binding for the converter’s TrueValues property:

<Window x:Class="YourNamespace.YourWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:converter="clr-namespace:YourNamespace.Converters"
        DataContext="{Binding YourViewModelInstance}">

    <Window.Resources>
        <!-- Declare converter as resource and bind its TrueValues property -->
        <converter:ValueConverterWithProperties x:Key="MultiValueConverter"
                                               TrueValues="{Binding TrueValuesList}" />
    </Window.Resources>

    <!-- Use the converter resource in your binding -->
    <CheckBox IsChecked="{Binding Item, Converter={StaticResource MultiValueConverter}}" />
</Window>

3. Ensure your ViewModel exposes the list property

Make sure your ViewModel has the list you want to bind to. Use ObservableCollection<int> if you need dynamic updates:

public class YourViewModel : INotifyPropertyChanged
{
    private ObservableCollection<int> _trueValuesList;
    public ObservableCollection<int> TrueValuesList
    {
        get => _trueValuesList;
        set
        {
            _trueValuesList = value;
            OnPropertyChanged();
        }
    }

    // Example initialization
    public YourViewModel()
    {
        TrueValuesList = new ObservableCollection<int> { 5, 10, 15 };
    }

    // INotifyPropertyChanged implementation (omitted for brevity)
    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

Key Notes: #

• Why not inline markup? The inline {converter:ValueConverterWithProperties ...} syntax uses a markup extension, which doesn’t support direct {Binding} expressions for its properties—only static values. Declaring the converter as a resource bypasses this limitation.
• DataContext Scope: Ensure the converter’s binding can resolve to your ViewModel. If the converter is in a resource with a different DataContext, use RelativeSource or Source to target the correct context (e.g., TrueValues="{Binding DataContext.TrueValuesList, RelativeSource={RelativeSource AncestorType=Window}}").
• Dynamic Updates: Using ObservableCollection<T> and INotifyPropertyChanged ensures the converter reacts to changes in the list’s contents or reference.

内容的提问来源于stack exchange，提问作者Joe M. Doe