当它不在绑定列表中时，阻止ComboBox将selectedValue设置为null

Question

我不太确定如何处理这个问题。我正在使用一组带有下拉列表值的组合框，我们也允许用户设置属性。 （即货币=“美元，加元，欧元”）。

当我们加载数据时，我们会发现货币不在我们的列表中，例如“AUD”。在这种情况下，我们仍然希望组合框显示加载的值，并且当前选择的货币应保持“AUD”，除非用户选择更改它，在这种情况下，他们唯一的选项仍然是“USD，CAD，EUR”。

我的问题是，一旦控件变得可见，ComboBox就会在我的SelectedCurrency属性上调用setter并将其设置为null，大概是因为当前值“AUD”不在它的列表中。如何在不使用户可以在Currency字段中键入任何内容的情况下禁用此行为？

Answer 1

设置IsEditable="True"，IsReadOnly="True"和您的SelectedItem等于您要保留所选项目的任何对象

<ComboBox ItemsSource="{Binding SomeCollection}"
          Text="{Binding CurrentValue}"
          SelectedItem="{Binding SelectedItem}"
          IsEditable="True"
          IsReadOnly="True">

IsEditable允许Text属性显示不在列表中的值

IsReadOnly使得Text属性无法编辑

SelectedItem存储所选项目。在用户选择列表中的项目之前，它将为null，因此在SaveCommand中，如果SelectedItem == null，则在保存到CurrentValue时使用SelectedItem代替{{1}}数据库

Answer 2

这似乎是一个相当普遍的问题。想象一下，您在数据库中有一个查找列表，可能是一个员工列表。 employee表有一个'works here'标志。另一个表引用了员工查找列表。当一个人离开公司时，您希望您的视图显示旧员工的姓名，但不允许将来分配旧员工。

以下是我对类似货币问题的解决方案：

的Xaml

<Page.DataContext>
    <Samples:ComboBoxWithObsoleteItemsViewModel/>
</Page.DataContext>
<Grid>
    <ComboBox Height="23" ItemsSource="{Binding Items}" 
              SelectedItem="{Binding SelectedItem}"/>
</Grid>

C＃

// ViewModelBase and Set() are from MVVM Light Toolkit
public class ComboBoxWithObsoleteItemsViewModel : ViewModelBase
{
    private readonly string _originalCurrency;
    private ObservableCollection<string> _items;
    private readonly bool _removeOriginalWhenNotSelected;
    private string _selectedItem;

    public ComboBoxWithObsoleteItemsViewModel()
    {
        // This value might be passed in to the VM as a parameter
        // or obtained from a data service
        _originalCurrency = "AUD";

        // This list is hard-coded or obtained from your data service
        var collection = new ObservableCollection<string> {"USD", "CAD", "EUR"};

        // If the value to display isn't in the list, then add it
        if (!collection.Contains(_originalCurrency))
        {
            // Record the fact that we may need to remove this
            // value from the list later.
            _removeOriginalWhenNotSelected = true;
            collection.Add(_originalCurrency);
        }

        Items = collection;

        SelectedItem = _originalCurrency;
    }

    public string SelectedItem
    {
        get { return _selectedItem; }
        set
        {
            // Remove the original value from the list if necessary
            if(_removeOriginalWhenNotSelected && value != _originalCurrency)
            {
                Items.Remove(_originalCurrency);
            }

            Set(()=>SelectedItem, ref _selectedItem, value);
        }
    }

    public ObservableCollection<string> Items
    {
        get { return _items; }
        private set { Set(()=>Items, ref _items, value); }
    }
}

Answer 3

您应该将ComboBox的IsEditable设置为true并绑定Text属性而不是SelectedValue属性。

Answer 4

如果IsEditable = false，则ComboBox不支持列表中不存在的值。

如果您希望用户操作添加值但不编辑该值或任何现有值，则一种方法可能是将新值放入TextBlock（不可编辑），使用Button来让它们添加该值。如果他们从组合框中选择任何值，则隐藏TextBlock和Button。

另一种方法是将值添加到列表中，后面有更复杂的逻辑，如果选择了任何其他值，则删除该临时值。并且暂定值在被选中之前不会持久存在。

Answer 5

他不想让用户能够输入，所以IsEditable似乎不在桌面上。

我要做的只是将新值AUD添加到项目列表中

 ComboBoxItem Content="AUD" Visibility="Collapsed"

然后Text =“AUD”将在代码中工作，但不会从下拉列表中工作。 为了花哨，可以为ItemsSource制作一个绑定到TEXT框的转换器并添加它自动折叠

Answer 6

以下是我解决这个问题的方法：

XAML看起来像这样：

<DataTemplate>
    <local:CCYDictionary Key="{TemplateBinding Content}">
        <local:CCYDictionary.ContentTemplate>
            <DataTemplate>
                <ComboBox Style="{StaticResource ComboBoxCellStyle}"
                          SelectedValuePath="CCYName" 
                          DisplayMemberPath="CCYName"
                          TextSearch.TextPath="CCYName"
                          ItemsSource="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:CCYDictionary}}, Path=ListItems}"
                          SelectedValue="{Binding}" />
            </DataTemplate>
        </local:CCYDictionary.ContentTemplate>
    </local:CCYDictionary>
</DataTemplate>

<!-- For Completion's sake, here's the style and the datacolumn using it -->
<Style x:Key="ComboBoxCellStyle" TargetType="ComboBox">
    <Setter Property="IsEditable" Value="False"/>
    <Setter Property="IsTextSearchEnabled" Value="True"/>
    <!-- ...other unrelated stuff (this combobox was was a cell template for a datagrid) -->
</Style>
<Column FieldName="CCYcode" Title="Currency" DataTemplate="{StaticResource CCYEditor}" />

字典可能有一种更好的方式来公开ItemsSource，这样Binding就不那么难看了，但是一旦我开始工作，我就厌倦了这个问题来进一步完善它。

个人词典如此声明：

public class CCYDictionary : DataTableDictionary<CCYDictionary>
{
    protected override DataTable table { get { return ((App)App.Current).ApplicationData.CCY; } }
    protected override string indexKeyField { get { return "CCY"; } }
    public CCYDictionary() { }
}
public class BCPerilDictionary : DataTableDictionary<BCPerilDictionary>
{
    protected override DataTable table { get { return ((App)App.Current).ApplicationData.PerilCrossReference; } }
    protected override string indexKeyField { get { return "BCEventGroupID"; } }
    public BCPerilDictionary() { }
}
//etc...

基类如下：

public abstract class DataTableDictionary<T> : ContentPresenter where T : DataTableDictionary<T>
{
    #region Dependency Properties
    public static readonly DependencyProperty KeyProperty = DependencyProperty.Register("Key", typeof(object), typeof(DataTableDictionary<T>), new PropertyMetadata(null, new PropertyChangedCallback(OnKeyChanged)));
    public static readonly DependencyProperty RowProperty = DependencyProperty.Register("Row", typeof(DataRowView), typeof(DataTableDictionary<T>), new PropertyMetadata(null, new PropertyChangedCallback(OnRowChanged)));
    public static readonly DependencyProperty ListItemsProperty = DependencyProperty.Register("ListItems", typeof(DataView), typeof(DataTableDictionary<T>), new PropertyMetadata(null));
    public static readonly DependencyProperty IndexedViewProperty = DependencyProperty.Register("IndexedView", typeof(DataView), typeof(DataTableDictionary<T>), new PropertyMetadata(null));
    #endregion Dependency Properties

    #region Private Members
    private static DataTable _SourceList = null;
    private static DataView _ListItems = null;
    private static DataView _IndexedView = null;
    private static readonly Binding BindingToRow;
    private static bool cachedViews = false;
    private bool m_isBeingChanged;
    #endregion Private Members

    #region Virtual Properties
    protected abstract DataTable table { get; }
    protected abstract string indexKeyField { get; }
    #endregion Virtual Properties

    #region Public Properties
    public DataView ListItems
    {
        get { return this.GetValue(ListItemsProperty) as DataView; }
        set { this.SetValue(ListItemsProperty, value); }
    }
    public DataView IndexedView
    {
        get { return this.GetValue(IndexedViewProperty) as DataView; }
        set { this.SetValue(IndexedViewProperty, value); }
    }
    public DataRowView Row
    {
        get { return this.GetValue(RowProperty) as DataRowView; }
        set { this.SetValue(RowProperty, value); }
    }
    public object Key
    {
        get { return this.GetValue(KeyProperty); }
        set { this.SetValue(KeyProperty, value); }
    }
    #endregion Public Properties

    #region Constructors
    static DataTableDictionary()
    {
        DataTableDictionary<T>.BindingToRow = new Binding();
        DataTableDictionary<T>.BindingToRow.Mode = BindingMode.OneWay;
        DataTableDictionary<T>.BindingToRow.Path = new PropertyPath(DataTableDictionary<T>.RowProperty);
        DataTableDictionary<T>.BindingToRow.RelativeSource = new RelativeSource(RelativeSourceMode.Self);
    }

    public DataTableDictionary()
    {
        ConstructDictionary();
        this.SetBinding(DataTableDictionary<T>.ContentProperty, DataTableDictionary<T>.BindingToRow);
    }
    #endregion Constructors

    #region Private Methods
    private bool ConstructDictionary()
    {            
        if( cachedViews == false )
        {
            _SourceList = table;
            if( _SourceList == null )
            {   //The application isn't loaded yet, we'll have to defer constructing this dictionary until it's used.
                return false;
            }
            _SourceList = _SourceList.Copy(); //Copy the table so if the base table is modified externally we aren't affected.
            _ListItems = _SourceList.DefaultView;
            _IndexedView = CreateIndexedView(_SourceList, indexKeyField);
            cachedViews = true;
        }
        ListItems = _ListItems;
        IndexedView = _IndexedView;
        return true;
    }

    private DataView CreateIndexedView(DataTable table, string indexKey)
    {
        // Create a data view sorted by ID ( keyField ) to quickly find a row.
        DataView dataView = new DataView(table);
        dataView.Sort = indexKey;
        dataView.ApplyDefaultSort = true;
        return dataView;
    }
    #endregion Private Methods

    #region Static Event Handlers
    private static void OnKeyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
    {
        // When the Key changes, try to find the data row that has the new key.
        // If it is not found, return null.
        DataTableDictionary<T> dataTableDictionary = sender as DataTableDictionary<T>;

        if( dataTableDictionary.m_isBeingChanged ) return; //Avoid Reentry
        dataTableDictionary.m_isBeingChanged = true;

        try
        {
            if( dataTableDictionary.IndexedView == null ) //We had to defer loading.
                if( !dataTableDictionary.ConstructDictionary() )
                    return; //throw new Exception("Dataview is null. Check to make sure that all Reference tables are loaded.");

            DataRowView[] result = _IndexedView.FindRows(dataTableDictionary.Key);
            DataRowView dataRow = result.Length > 0 ? result[0] : null;

            //Sometimes a null key is valid - but sometimes it's just xceed being dumb - so we only skip the following step if it wasn't xceed.
            if( dataRow == null && dataTableDictionary.Key != null )
            {
                //The entry was not in the DataView, so we will add it to the underlying table so that it is not nullified. Treaty validation will take care of notifying the user.
                DataRow newRow = _SourceList.NewRow();
                //DataRowView newRow = _IndexedView.AddNew();
                int keyIndex = _SourceList.Columns.IndexOf(dataTableDictionary.indexKeyField);
                for( int i = 0; i < _SourceList.Columns.Count; i++ )
                {
                    if( i == keyIndex )
                    {
                        newRow[i] = dataTableDictionary.Key;
                    }
                    else if( _SourceList.Columns[i].DataType == typeof(String) )
                    {
                        newRow[i] = "(Unrecognized Code: '" + (dataTableDictionary.Key == null ? "NULL" : dataTableDictionary.Key) + "')";
                    }
                }
                newRow.EndEdit();
                _SourceList.Rows.InsertAt(newRow, 0);
                dataRow = _IndexedView.FindRows(dataTableDictionary.Key)[0];
            }

            dataTableDictionary.Row = dataRow;
        }
        catch (Exception ex)
        {
            throw new Exception("Unknow error in DataTableDictionary.OnKeyChanged.", ex);
        }
        finally
        {
            dataTableDictionary.m_isBeingChanged = false;
        }
    }

    private static void OnRowChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
    {
        // When the Key changes, try to find the data row that has the new key.
        // If it is not found, return null.
        DataTableDictionary<T> dataTableDictionary = sender as DataTableDictionary<T>;

        if( dataTableDictionary.m_isBeingChanged ) return; //Avoid Reentry
        dataTableDictionary.m_isBeingChanged = true;

        try
        {
            if( dataTableDictionary.Row == null )
            {
                dataTableDictionary.Key = null;
            }
            else
            {
                dataTableDictionary.Key = dataTableDictionary.Row[dataTableDictionary.indexKeyField];
            }
        }
        catch (Exception ex)
        {
            throw new Exception("Unknow error in DataTableDictionary.OnRowChanged.", ex);
        }
        finally
        {
            dataTableDictionary.m_isBeingChanged = false;
        }
    }
    #endregion Static Event Handlers
}