Wert von Combobox2 via SelectedIndex aus Combobox1 auslesen
Hallo!
ich hoffe vorab im richtigen Forum gepostet zu haben...
Ich stehe seit gestern Abend völlig auf dem Schlauch.
Was will ich machen?
Ich habe zwei Comboboxen. In der erste stehen je nachdem welche Rubrik aufgerufen wird, Gegenstände. In der zweiten die Gewichte der Gegenstände aus der ComboBox1. Beide werden über die Rubrik und eine Klasse gefüttert. Die IndexIDs der Comboboxen gehören immer zusammen. Was bedeutet der Gegenstand1 (ID1) hat in Combobox2 (ID1) sein Gewicht stehen.
Was ich nun machen wollte...
Ich würde gerne die SelectedIndex aus Combobox1 auslesen, was ja kein Problem da stellt. Nun wollte ich mit dieser IndexID den Wert aus Combobox2 auslesen... nur weiß ich grad überhaupt nicht wie?!
Ich arbeite mit VS 2015 und erstelle gerade eine UWP App mit C# und XAML.
Befinde mich noch in den Anfängen meiner Programmierzeit 😉
Habt vielen Dank!
lg
littlerocky
Wieso eine zweite Combobox, wenn es dort für jeden Gegenstand der ersten Combobox nur einen Eintrag gibt, also nichts zu wählen? Warum nicht einfach so:
<Combobox ItemsSource={Binding Gegenstandsliste}
SelectedItem={Binding AktuellerGegenstand} />
<TextBox Text={Binding AktuellerGegenstand.Gewicht} />
Wenn das Gewicht nicht verändert werden soll, tut's auch ein TextBlock statt der TextBox.
Oder entspricht der "Gegenstand" in der ersten Combobox genau genommen einer Gruppe von Gegenständen mit verschiedenem Gewicht? Das könnte dann zum Beispiel so gehen:
<ComboBox ItemsSource={Binding Gegenstandsgruppenliste}
SelectedItem={Binding AktuelleGegenstandsgruppe} />
<ComboBox ItemsSource={Binding AktuelleGegenstandsgruppe}
DisplayMemberPath="Gewicht"
SelectedItem={Binding AktuellerGegenstand} />
AktuellerGegenstand enthält in diesem zweiten Fall den Gegenstand mit dem gewählten Gewicht.
Nabend bb1898,
Die Comboboxen werden bereits über Bindings gefüttert:
<ComboBox
Name="comboBaustoffe"
ItemsSource="{x:Bind BaustoffItem}"
SelectedValuePath="BaustoffItem"
DisplayMemberPath="Baustoffe"
</ComboBox>
<ComboBox
Name="comboBaustoffeGewicht"
ItemsSource="{x:Bind BaustoffItem}"
SelectedValuePath="BaustoffItem"
DisplayMemberPath="Gewicht"
Visibility="Collapsed">
</ComboBox>
Die Daten kommen daher:
private static List<BaustoffItem> getBaustoffItems()
{
var items = new List<BaustoffItem>();
items.Add(new BaustoffItem() { BaustoffArt = "Sand", Baustoffe = "Beachvolley-Sand 0-1mm", Gewicht = 1200 });
items.Add(new BaustoffItem() { BaustoffArt = "Sand", Baustoffe = "Brechersand 0-2mm", Gewicht = 1530 });
items.Add(new BaustoffItem() { BaustoffArt = "Sand", Baustoffe = "Brechsand aus Kalkstein 0-2mm", Gewicht = 1600 });
items.Add(new BaustoffItem() { BaustoffArt = "Sand", Baustoffe = "Estrichsand 0-8mm", Gewicht = 1590 });
...
So nun gibt es verschiedene BaustoffArt(en) die ich filter und je nach gewählter Rubrik an die Comboboxen schicke.
Mein Problem ist:
Ich möchte gern die m³ berechnen, daher muss ich wissen welcher Stoff und welches Gewicht. Das Material zu bekommen ist ja kein Thema, jedoch soll das Combo mit dem Gewicht erstmal versteckt sein und somit nicht anwählbar. Daher möchte ich gerne das Gewicht über die IndexID herausfiltern und verwenden, ohne das die zweite Combobox ausgewählt werden muss.
Verstanden was ich erreichen will oder ist der Ansatz völlig daneben?
Filtern tu ich so:
public static void HoleInhalt(string baustoffe, ObservableCollection<BaustoffItem> baustoffItems)
{
var allItems = getBaustoffItems();
var filteredBaustoffItems = allItems.Where(p => p.BaustoffArt == baustoffe).ToList();
baustoffItems.Clear();
filteredBaustoffItems.ForEach(p => baustoffItems.Add(p));
}
Dein Problem kann man leichter lösen. =)
Die zweite ComboBox benötigst du nicht.
Schaue dir einmal das SelectedItem der ComboBox an - es ist in deinem Fall ein BaustoffItem. Dort bekommst du alles, was du brauchst.
Da du mit UWP arbeitest, sind die Angaben ohne Gewähr - kann es nicht testen. Laut Doku gibt es aber ein SelectedItem. :rtfm:
Dein Problem kann man leichter lösen. =)
Die zweite ComboBox benötigst du nicht.
Schaue dir einmal dasSelectedItemder ComboBox an - es ist in deinem Fall einBaustoffItem. Dort bekommst du alles, was du brauchst.Da du mit UWP arbeitest, sind die Angaben ohne Gewähr - kann es nicht testen. Laut Doku gibt es aber ein SelectedItem. :rtfm:
Danke für den Tipp, bin die Doku mal durch, sie hilft mir jetzt leider nicht.
Bin mit meinem Latein am Ende... ich habe ehrlich gesagt keine Ahnung wie ich jetzt an das Gewicht komme wenn ich einen Baustoff auswähle.
Danke trotzdem für deine Antwort 😃
Ja, das habe ich. Ich hab bisher nicht rausgefunden wie ich das Object so zerlegen kann, dass ich die verschiedene Inhalte einzeln abrufen kann. Mein Buch vom Rheinwerk bzw. MSDN hat mir da jetzt noch nicht ganz so weitergeholfen wie gedacht.
Als Output kriege ich nur das:
Baustoff_Kalkulator.Inhalt.BaustoffItem
lg
Mal Zwischenfrage: Wie sieht denn das Datenmodell aus?
Weil wenn das Datenmodel schon vom Konzept her es nicht hergibt, was du vorhast, dann werden alle Features der Combobox dir da auch nicht weiterhelfen können.
Weisst du, was ein Datenmodell ist?
Hast du ein hierarchisches oder ein relationales?
Welche Entitäten treten da auf, und wie hängen die miteinander zusammen?
Der frühe Apfel fängt den Wurm.
Du hast 2 Möglichkeiten:
Wenn du direkt auf das SelectedItem der ComboBox zugreifst:
Da das SelectedItem vom Typobjectist, muss du es in deinBaustoffItemcasten - hast du das getan, dann kannst du auf alle Properties des BaustoffItem zugreifen.
Tipp: [FAQ] Casten aber richtig: () / is / asEine Property vom Typ BaustoffItem in deinem ViewModel anlegen und in der View das SelectedItem daran binden - im ViewModel kannst du dann diese Property nutzen.
@ErfinderDesRades:
new BaustoffItem() { BaustoffArt = "Sand", Baustoffe = "Beachvolley-Sand 0-1mm", Gewicht = 1200 }
Er bindet an eine Liste von BaustoffItems, ergo hat er in der ComboBox das gewählte BaustoffItem zur Verfügung.
8o 🤔 X(
Bin völlig überfordert... ich lass das glaube und begrabe erstmal mein kleines Projekt. Wird in Zukunft wieder Stift und Papier herhalten müssen.
Danke trotzdem für eure Geduld 🙂
new BaustoffItem() { BaustoffArt = "Sand", Baustoffe = "Beachvolley-Sand 0-1mm", Gewicht = 1200 }
Und das ist das ganze Datenmodell?
Nur BaustoffItems?
Ich hätte erwartet, es gäbe noch Kategorien von Baustoffen, und offsichtlich sind auch die Mengen in bestimmten Stufen quantifiziert.
Wenn ich sein Xaml angucke, eine Combo soll wohl Baustoffe präsentieren (was in meiner Welt eher den Kategorien entspräche, im Gegensatz zu den BaustoffItems, dies ja auch noch gibt), die andere Combo soll iwie Mengen zur Auswahl anbieten
Beide Combos haben aber scheints dieselbe Auflistung als ItemsSource - das passt ja vorne und hinten nicht.
Der frühe Apfel fängt den Wurm.
So ich will nun nochmal ganz genau versuchen zu erklären, was meine Gedankengänge waren:
Ich komme ursprünglich aus dem PHP Lager und habe auch mit diesem Ansatz mal angefangen. Um mich in C# aber einzuarbeiten liegen die Bücher:
"Einstieg in C# mit Visual Studio 2015", "C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken" und "Windows Presentation Foundation: Das umfassende Handbuch zur WPF, aktuell zu .NET 4.6 und Visual Studio 2015".
So nun zum Thema zurück.
@ErfinderDesRades, dein Fachjargon finde ich gut, man merkt du hast Ahnung. Ich habe oben aber bewusst angemerkt, dass ich in den Kinderschuhen stecke und dich einfach auch leider überhaupt nicht verstanden habe.
Ich benötige verschiedene Sand, Schotter, Splitt und Kiessorten, da ich gerade ein Haus baue, allesamt sind dies Baustoffe-Arten - und ja man kann das als Kategorie bezeichnen. Weiter geht es dann mit den Baustoffen selber, den unterschiedlichen Materialien. Diese Materialien haben ein festes Gewicht pro m³ und Tonne. Dieser Wert ändert sich nicht.
Nun wollte ich, wie in einer MySQL-Tabelle die Werte aus einer Tabelle holen.
Mein Ansatz war also, ich Filter nach der BaustoffArt: "Sand", "Erde"... und hole mir so den Baustoff und das Gewicht aus der Liste und Packe das erstmal in eine Combobox, denn den Baustoff soll man ja auswählen können, das Gewicht nicht, denn das ist fest und wird nur zum errechnen der m³ (cbm) benötigt. Die Idee mit der zweiten Combobox war vielleicht unsinnig, für mich jetzt als Laie aber erstmal der schnellste Ansatz.
So, dadurch hätten theoretisch die Baustoff- und Gewicht-Combobox die identische ItemID.
Ich bekomme auch ohne weiteres die ItemID. Bei Auswahl des Baustoffs, selektiert er dank der ID auch automatisch das Gewicht entsprechende an und wählt es aus.
Mein Problem ist nur, dass ich weder auf das Item der Baustoff- noch auf die der Gewicht-Combobox zugreifen kann bzw. kein Wert erhalte.
Ich versuch es zB. so:
int BIndex;
BIndex = comboBaustoffe.SelectedIndex;
...
comboBaustoffeGewicht.Items[BIndex].ToString();
oder so
comboBaustoffeGewicht.SelectionBoxItem.ToString();
Ich kriege nur als Rückgabewert immer:
Baustoff_Kalkulator.Inhalt.BaustoffItem
Ich weiß, dass der Ansatz mit den zwei Comboboxen nicht schön ist, jedoch war es für mich jetzt am schnellsten zu lösen. Das ich das noch irgendwann mal ändern werde, ist für mich klar - jedoch bin ich noch nicht so weit mit dem Lesen und Einarbeiten in Visual C# und XAML um es anders hinzukriegen.
Wieso ich dann sowas überhaupt erstmal bastel?
Ich habe mein Smartphone immer an meiner Seite und wenn es schnell gehen muss und der Baustofflieferant eine Liefermenge haben möchte, starte ich nur kurz die App, berechne Tonnen und m³ und alles ist schick - vorerst.
lg
Jo - ich bin Fachjargon-Freak, also ich halte Fachsprache für unumgänglich (werde dafür gelegentlich als arrogant betrachtet - naja - mussich mit leben).
Ich finde, programmieren kann man auch als einen Prozess betrachten, Ideen und Gedanken immer weiter zu konkretisieren, bis man sie schließlich in der Computersprache formuliert, was ja ist ein Fachjargon mit 0-Toleranz an Mehrdeutigkeit und "du verstehst schon was ich meine".
Also ein Prozess von vollkommen schwammig, unbestimmt hin zu einer vollkommen definierten Formulierung.
Und hier hat sich ein son typisches Missverständnis natürlicher Sprache soeben geklärt: Wenn du sagst "Gewicht" dann meinst du nicht, was ich unter Gewicht verstehe (eine Masseinheit, mit der man Mengen angeben kann, also viel oder wenig), sondern du meinst das spezifische Gewicht eines Baustoffes.
Das Fachwort dafür ist SchüttDichte, und ich empfehle, dieses Fachwort auch zu verwenden, um genau solche Missverständnisse zu vermeiden.
Da stimme ich dann p!lle zu, das ist eiglich ganz einfach. SchüttDichte ist ja eine Eigenschaft des Baustoffes, ebenso wie Name eine Eigenschaft ist.
Also wenn du mit der Combo einen Baustoff gewählt hast, dann hast du damit alle 3 Eigenschaften gewählt und direkt verfügbar: Name, Schüttdichte, und auch die ID (die brauchst du aber garnet).
Allerdings eine Combo kann nur eine Eigenschaft anzeigen, zB den Namen. Trotzdem wählt sie das gesamte Item, mit wie gesagt allen seinen Eigenschaften.
Und da weiß ich nu nicht, was du mit der ID, oder ItemId, oder wie immer du es nennst, nun noch willst, und was du noch von iwo holen willst.
Dein SelectedItem hat bereits die Eigenschaft Schüttdichte, da musst du nix weiteres holen, du musst es höchstens anzeigen.
Etwa indem du eine Textbox an Combobox.SelectedItem bindest mit Path="SchuettDichte" würdest du jederzeit die Dichte des aktuell angewählten Baustoffes sehen - extra irgendwo herholen musst du das nicht.
Der frühe Apfel fängt den Wurm.
<TextBlock x:Name="inputCBM" Text="{Binding ElementName=comboBaustoffe, Path=SelectedItem.Gewicht}"/>
Ha! Hab es verstanden was ihr die ganze Zeit meintet... So... super! Ich krieg das Item wirklich korrekt angezeigt. Vielen Dank, ich spare mir nun wirklich die zweite Combobox! 🙂
Und wie lade ich das jetzt in eine Variable, damit ich damit rechnen kann? Das will mir mit der Methode nämlich nicht gelingen 🤔
Jo, jetzt wirds erst schwierig, und du musst den MVVM-Pattern erlernen.
Also ein Viewmodel coden (ein(e Art) Datenmodell, spezialisiert darauf, dass Xaml daran bindet), und Xaml dran binden.
Dann wirkt das, was der User eingibt, über die Bindings direkt ins Viewmodel hinein, und im Viewmodel kannst du dann auch deine Rechnungen ansiedeln.
Und auch andersrum: Was das Viewmodel ausrechnet, kann via Bindings auch direkt in der Oberfläche präsentiert sein - das ist dann alles ein Kinderspiel, wenn mans erst geschnackelt hat.
Downloadable Beispiel-Anwendungen kannste hier finden: VBParadise-Wpf-Tuts.
Insbesondere bei was mit "Grundlagen" überschrieben ist sollteste nützliche Hinweise und Vorlagen finden.
Und besonders wichtig ist das "BindingPicking"-Video, weil viele Wpf-Progger wissen garnet, wie das Designen mittm Wpf-Designer eiglich konzipiert ist.
Es tickt nämlich wesentlich anders als in WinForms - zum einen schwieriger, zum anderen aber auch mächtiger, also im WinForms-Designer kann man sich keine Beispiel-Test-Daten verfügbar machen, die man bereits inne Designer-Vorschau sieht - in Wpf geht das.
Und leider kann man da auch extrem viel falsch machen, und dann ist Wysiwig und Intellisense nicht verfügbar, und man lernt's nie, dasses das ühaupt gibt, und proggen ist viel mühsamer und fehleranfälliger.
Der frühe Apfel fängt den Wurm.
Danke, ich werde mir das mal genauer angucken und hoffen, dass ich das ein wenig verstehe.
Eine andere Grundsatzfrage, wieso ist es nicht möglich dann z.B. sowas zu machen:
string schuettdichte = comboBaustoffe.SelectedItem.Gewicht.ToString();
Also das es nicht geht, weiß ich. Nur so vom Prinzip, es wäre doch so einfach 😁
Hallo,
das geht schon, aber wie p!lle schon oben geschrieben hat, mußt du erst SelectedItem casten: [FAQ] Casten aber richtig: () / is / as.
Hallo,
das geht schon, aber wie p!lle schon oben geschrieben hat, mußt du erst SelectedItem casten:
> .
Ich habe mir das auch angeguckt, ich verstehe es nur derzeit noch nicht. 🙁
liegt wohl am Fachjargon - was ein Cast eiglich ist, weisste nicht (und das steht da auch nicht, sondern da steht nur, wie's geht).
Also ein Cast weist den Compiler an, ein Objekt des einen Datentyps als ein Objekt eines anderen Datentyps zu betrachten.
Klingt wie Blödfug, ergibt aber Sinn im Zusammenhang mit der "Vererbungslehre" objektorientierter Sprachen.
Also zB Button erbt von Control, d.h.: ein Button ist immer auch ein Control.
Textbox erbt auch von Control, also auch Textboxen sind Controls (wer hätte das gedacht? 😉)
Sowas geht also:
Control ctr = checkbox1;
//...
ctr = listbox1;
Dieselbe Variable kann Objekte unterschiedlichen Datentyps aufnehmen.
Die Variable weiss von ihrem Inhalt aber nur den Teil, den ein Control "kann".
Also die Variable "weiss", dass .Enabled = false; gesetzt werden kann.
Sie weiß aber nicht den Checkstate zu setzen, weil das geht ja nur, solange sie die Checkbox enthält.
Aber der Programmierer weiss es (hofflich), wann die variable eine Checkbox enthält, und dann kann er mit einem Cast den Compiler anweisen, diese Variable an eine explizite Checkbox-Variable zuzuweisen - damit der Checkstate dann auch gesetzt wern kann:
Checkbox ckb = (Checkbox)ctr;
Das mit den runden Klammern ist ein Cast, ein "harter" - im Jargon des verlinkten Tuts.
Dasselbe mit deim SelectedItem - das ist vom Datentyp Object - der Basisklasse aller Klassen. Datentyp Object kann sogutwie garnix, muss man immer casten, wenn man was mit tun will, in deim Fall musste auf BaustoffItem casten, wenn du die BaustoffItem-Properties benutzen möchtest.
Aber das ist jetzt absolutes Basis-Grundlagen-Wissen - dazu sollteste dir ein gscheites Grundlagenbuch zu durcharbeiten - sich auf ForenPosts zu stützen hinterlässt Wissenslücken wie Scheunentore.
Der frühe Apfel fängt den Wurm.
Ich habe die Bücher hier liegen und werde mir sie nun auch intensiv vornehmen. Ich dachte so für mich halt, die App die ich da selber auf der Baustelle benutze schnell zusammensetzen und dann ins eingemachte der Bücher vordringen.
Danke für deine Geduld, ich werde dann erstmal studieren... schade, dass es nun so kompliziert doch ist 😭
Schönes Wochenende =)
Keine Full-Quotes [Hinweis] Wie poste ich richtig?
Eigentlich ist es gar nicht so schwer, wenn man das mit dem ViewModel (das VM in MVVM)verstanden hat.
So könnte das ViewModel aussehen
public class MainPageViewModel : BindableBase
{
public MainPageViewModel()
{
SelectableBaustoffarten = new ObservableCollection<string>(
Data.SampleData.Baustoffe
.GroupBy( b => b.Art )
.Select( b => b.Key )
.OrderBy( b => b.ToLowerInvariant() ) );
}
#region Baustoffart
private ObservableCollection<string> _SelectableBaustoffarten;
public ObservableCollection<string> SelectableBaustoffarten
{
get { return _SelectableBaustoffarten; }
private set
{
if ( SetProperty( ref _SelectableBaustoffarten, value ) )
{
SelectedBaustoffart = _SelectableBaustoffarten.FirstOrDefault();
}
}
}
private string _SelectedBaustoffart;
public string SelectedBaustoffart
{
get { return _SelectedBaustoffart; }
set
{
if ( SetProperty( ref _SelectedBaustoffart, value ) )
{
SelectableBaustoffe = new ObservableCollection<Data.Baustoff>( Data.SampleData.Baustoffe.Where( b => b.Art == value ) );
SelectedBaustoff = SelectableBaustoffe.FirstOrDefault();
}
}
}
#endregion Baustoffart
#region Baustoff
private ObservableCollection<Data.Baustoff> _SelectableBaustoffe;
public ObservableCollection<Data.Baustoff> SelectableBaustoffe
{
get { return _SelectableBaustoffe; }
private set { SetProperty( ref _SelectableBaustoffe, value ); }
}
private Data.Baustoff _SelectedBaustoff;
public Data.Baustoff SelectedBaustoff
{
get { return _SelectedBaustoff; }
set
{
if ( SetProperty( ref _SelectedBaustoff, value ) )
OnPropertyChanged( nameof( Ergebnis ) );
}
}
#endregion Baustoff
#region Faktor
private decimal _Faktor;
public decimal Faktor
{
get { return _Faktor; }
set
{
if ( SetProperty( ref _Faktor, value ) )
OnPropertyChanged( nameof( Ergebnis ) );
}
}
#endregion Factor
#region Ergebnis
public decimal? Ergebnis
{
get
{
if ( SelectedBaustoff == null ) return null;
return Faktor * SelectedBaustoff.Gewicht;
}
}
#endregion Result
}
und so die zugehörige View
<Page
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:App1"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:vm="using:App1.ViewModels"
xmlns:ConverterLib="using:ConverterLib"
x:Class="App1.MainPage"
d:DataContext="{d:DesignInstance IsDesignTimeCreatable=True, Type=vm:MainPageViewModel}"
mc:Ignorable="d">
<Page.Resources>
<ConverterLib:DecimalStringConverter x:Key="DecimalStringConverter"/>
</Page.Resources>
<Page.DataContext>
<vm:MainPageViewModel/>
</Page.DataContext>
<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
<StackPanel>
<TextBlock Text="Art:"/>
<ComboBox
ItemsSource="{Binding SelectableBaustoffarten}"
SelectedValue="{Binding SelectedBaustoffart, Mode=TwoWay}"
HorizontalAlignment="Stretch"/>
<TextBlock Text="Bezeichnung:"/>
<ComboBox
ItemsSource="{Binding SelectableBaustoffe}"
SelectedValue="{Binding SelectedBaustoff, Mode=TwoWay}"
DisplayMemberPath="Bezeichnung"
HorizontalAlignment="Stretch" />
<TextBlock Text="Gewicht:"/>
<TextBlock Text="{Binding Baustoff.Gewicht}"/>
<TextBlock Text="Faktor:"/>
<TextBox Text="{Binding Faktor, Converter={StaticResource DecimalStringConverter}, Mode=TwoWay}" />
<TextBlock Text="Ergebnis:"/>
<TextBlock Text="{Binding Ergebnis}"/>
</StackPanel>
</Grid>
</Page>
Für jede ComboBox gibt es zwei Eigenschaften im ViewModel:1.Eine Collection der wählbaren Elemente 1.Das ausgewählte Element
Durch das Binding spart man sich den Cast, denn das passiert schon automatisch durch das Binding. Wie man sieht, die View selber berechnet rein gar nichts, sondern stellt einfach nur Daten dar, bzw. leitet die Eingaben des Benutzers an das ViewModel weiter.
PS:
Hier noch die BindableBase-Klasse (als Basis für ein jedes VM)
public class BindableBase : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
protected void OnPropertyChanged( string propertyName = "" )
{
var handler = PropertyChanged;
handler?.Invoke( this, new PropertyChangedEventArgs( propertyName ) );
}
protected bool SetProperty<T>( ref T field, T value, [CallerMemberName]string propertyName = "" )
{
return SetProperty( ref field, value, EqualityComparer<T>.Default, propertyName );
}
protected bool SetProperty<T>( ref T field, T value, IEqualityComparer<T> comparer, [CallerMemberName]string propertyName = "" )
{
if ( comparer.Equals( field, value ) )
return false;
field = value;
OnPropertyChanged( propertyName );
return true;
}
protected bool SetProperty<T>( ref T field, T value, IComparer<T> comparer, [CallerMemberName]string propertyName = "" )
{
if ( comparer.Compare( field, value ) == 0 )
return false;
field = value;
OnPropertyChanged( propertyName );
return true;
}
}
Eigentlich ist es gar nicht so schwer, wenn man das mit dem ViewModel (das VM in MVVM)verstanden hat....
Vielen Dank für die Einblicke in MVVM, ich habe mir das mal alles kopiert und werde Anhand der Bücher versuchen es in den nächsten Tagen "zu verstehen".
Die zweite Combobox habe ich bereits entfernt 😉
Was mir auf den Nägeln brennt, ist jedoch - wie Caste ich das SelectItem so, dass ich es benutzen kann?
Baustoff ist ein String, BaustoffArt auch und Gewicht ist ein double. Möchte gerne, dass zumindest das jetzt ein Ende findet um mich ein wenig zu motivieren. Heute habe ich mich durch meine Bücher gewühlt und angefangen zu lesen. Da ist das Thema Casten mal kurz angesprochen worden, jedoch noch nicht vertieft (kommt noch später).
Habe meine App praktisch fertig, nur den Wert von den SelectItem ist für mich unerreichbar... 😦
Ich weiß, dass das hier kein Anfängerforum ist... aber könnt ihr mir da evtl. unter die Arme greifen? Der Motivation wegen?
BaustoffItem item = comboBaustoffe.SelectedItem as BaustoffItem;
if (item != null)
{
string schuettdichte = item.Gewicht.ToString();
}
8o
Da waren meine Ansätze ja richtig, bis auf das
BaustoffItem item
hatte ich das genauso...
Vielen Dank! 👍