Combobox selected Item leeren

Hallo,

ich nutze eine Kombobox die eine Aktion auführt (also nicht nur eine Eigenschaft ändert). wenn die Aktion ausgeführt wurde, soll die Combobox wieder auf null gesetzt werden, genau der erste Eintrag, der nichts anzeigt. Es wird ein MVVM Pattern verwendet.

Mein Problem ist, wenn ich durch meine Funktion den Wert der Eigenschaft ändere, kommt dieser an der Oberfläche scheinbar nicht an. Die Wert wird scheinbar gemeldet, aber die Listbox ändert sich nicht.

Ich weiß echt nicht, was ich noch einstellen soll/kann/muss.

   <ComboBox Grid.Column="1" x:Name="Input" 
                          Visibility="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.WorkingTable, Mode=TwoWay, Converter={StaticResource enumToVisibility}, ConverterParameter=Input}" 
                          ItemsSource="{Binding PossibleInputRules}"
                          DisplayMemberPath="Value"
                          SelectedValuePath="Key"
                          SelectedIndex="{Binding InputRuleIndex, Mode=TwoWay, NotifyOnTargetUpdated=True, NotifyOnSourceUpdated=True}"
                          >
                </ComboBox>

Hi Taladan,

Die Wert wird scheinbar gemeldet

Was bedeuted scheinbar? Hast du den Debugger verwendet? Gibt es Binding-Fehlermeldungen im Ausgabefenster? Magst du uns den Code zeigen, von dem du sprichst?

Christian

Ist nur eine ganz normale Eigenschaft

        private int _selectedInputRuleIndex;
        /// <summary>
        /// Gibt den Index der ausgewählten Regel an.
        /// </summary>
        public int SelectedInputRuleIndex
        {
            get { return _selectedInputRuleIndex; }
            set { _selectedInputRuleIndex = value; NotifyPropertyChanged(); SetRuletype(value, 1);}
        }

Die Funktion SetRuletype ändert dann Diverses ab und setzt zum Schluss die Eigenschaft SelectedInputRuleIndex auf 0 (Schleife wird verhindert).

So wie's aussieht ist es die SetRuletype-Methode, die das Problem verursacht. Warum, kann man nur vermuten, weil du ja den Code für dich behältst. Wie verhinderst du denn eine Schleife, und warum rufst du NotifyPropertyChanged auf, bevor SetRuletype den Wert ändert? Oder anders gefragt, ruft SetRuleType auch die NotifyPropertyChanged-Methode auf?

Hi,

die Operation macht nichts wildes, daher habe ich sie nicht gepostet. Die Operation setzt wieder die Methode und ruft die PropertyChanged auf. Auch wenn wenn ich alles dazwischen weg lasse, passiert nichts (korrektes). Der getter wird aufgerufen, aber die UI ändert die ansicht nicht.

  private void SetRuletype(int value, int table)
{
    if (value != 0)
            {
                // Tabelle ermitteln
                List<KeyValuePair<int, string>> tmpTable = null;
                switch (table)
                {
                    case 1:
                        tmpTable = PossibleInputRules; 
                        break;
                    case 2:
                        tmpTable = PossibleTempRules;
                        break;
                    case 3:
                        tmpTable = PossibleOutputRules;
                        break;
                }

                 //Regel mit internerID ermitteln und erzeugen
                string type = ((KeyValuePair<int, string>)tmpTable[value]).Value;
                Rule rule = null;
                switch (type)
                {
                    case "ErsteZeilenIgnorieren":
                        rule = new ErsteZeilenIgnorieren();
                        break;
                    case "LetzteZeilenIgnorieren":
                        rule = new LetzteZeilenIgnorieren();
                        break;
                    case "AnredeZuPersonenart":
                        rule = new AnredeZuPersonenart();
                        break;
                    case "BereitsImportiert":
                        rule = new BereitsImportiert();
                        break;
                    case "Dateiname":
                        rule = new Dateiname();
                        break;
                    case "ErzeugeString":
                        rule = new ErzeugeString();
                        break;
                    case "FestesZeilenfeld":
                        rule = new FestesZeilenfeld();
                        break;
                    case "PersonenartZuIkarosAnrede":
                        rule = new PersonenartZuIkarosAnrede();
                        break;
                    case "SQLFeld":
                        rule = new SQLFeld();
                        break;
                    case "Trennzeichen":
                        rule = new Trennzeichen();
                        break;
                    case "Validate":
                        rule = new Validate();
                        break;
                    case "Wenn":
                        rule = new Wenn();
                        break;
                    case "WennGefuellt":
                        rule = new WennGefuellt();
                        break;
                    case "ErstellePostSQL":
                        rule = new ErstellePostSQL();
                        break;
                    case "ErstellePreSQL":
                        rule = new ErstellePreSQL();
                        break;
                    case "Accumio":
                        rule = new Accumio();
                        break;
                    case "BarpayZahlungen":
                        rule = new BarpayZahlungen();
                        break;
                    case "InternetportalAdressermittlung":
                        rule = new InternetportalAdressermittlung();
                        break;
                    default:
                        System.Windows.MessageBox.Show(string.Format("Die Regel {0} ist noch nicht implementiert", type));
                        break;
                }

                // Wenn eine Regel erstellt wurde, dann diese austauschen.
                if (rule != null)
                {
                    bool change = true;
                   

                    if (change)
                    {
                        int index = this.SelectedIndex;
                        this.WorkingRules.RemoveAt(this.SelectedIndex);
                        this.WorkingRules.Insert(index, rule);
                        this.SelectedIndex = index;
                    }
                }

                switch (table)
                {
                    case 1:
                        this._selectedInputRuleIndex = 0;
                        NotifyPropertyChanged("SelectedInputRuleIndex");
                        break;
                    case 2:
                        this._selectedTempRuleIndex = 0;
                        NotifyPropertyChanged("SelectedTempRuleIndex");
                        break;
                    case 3:
                        this._selectedOutputRuleIndex = 0;
                        NotifyPropertyChanged("SelectedOutputRuleIndex");
                        break;
                }
            }