Problem bei C#: Wert aus einem List-Funktion in anderem List-Funktion

A

Aydogan61

Grünschnabel
Kurze Problem Beschreibung:

Hallo Leute, es tut mir leid das ich mit solchen Kleinigkeit gekommen bin. Eigentlich ist Parameterübergabe ganz einfaches aber ich bekomme das irgendwie nicht. Wie Sie bemerkt haben, bin ich noch ein Anfänger. Deswegen bitte ich euch in ständisch um ihre Hilfe.

In der Code habe ich die Parameterübergabe kommentiert, da versuche ich die Wert von der Liste IPFaktoren raus zu holen und in der Liste Parameter ein kleine mathematische Funktion durchzuführen.

Aber es funktioniert nicht, Wert wechselt sich nicht, wenn ich eine IPFaktor aus dem Liste wähle.

Bitte******

Programm:



Code: 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Automation;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Markup;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Media.Effects;
using System.Windows.Media.Imaging;
using System.Windows.Media.Media3D;
using System.Windows.Media.TextFormatting;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Shell;

namespace WpfApplication4
{
    /// <summary>
    /// Interaktionslogik für MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
      
        public MainWindow()
        {
            InitializeComponent();
            VS_Serie.ItemsSource = GetParameters();
            VS_Serie.DisplayMemberPath = "Name";
            VS_Serie.SelectedIndex = 0;
            VS_Serie.Focus();

            Einheiten.ItemsSource = GetEinheitens();
            Einheiten.DisplayMemberPath = "Unit";
            Einheiten.SelectedIndex = 0;
            Einheiten.Focus();

            Interpolationsfaktor.ItemsSource = GetIPFaktors();
            Interpolationsfaktor.DisplayMemberPath = "IPFaktor";
            Interpolationsfaktor.SelectedIndex = 0;
            Interpolationsfaktor.Focus();
        }

        
        public List<Parameter> GetParameters()
        {
            IPFaktoren Dert = new IPFaktoren();  // Parameterübergabe
            double Nert;
            Dert.Wert = 1.0;
            Nert = Dert.Wert;
            

            List<Parameter> liste = new List<Parameter>();
            liste.Add(new Parameter { Name = "VS0.02", Pulse = 0.02, Factor = 500.0 * Nert});
            liste.Add(new Parameter { Name = "VS0.04", Pulse = 0.04, Factor = 250.0 * Nert});
            liste.Add(new Parameter { Name = "VS0.1", Pulse = 0.1, Factor = 10.0 * Nert});
            liste.Add(new Parameter { Name = "VS0.2", Pulse = 0.2, Factor = 5.0 * Nert});
            liste.Add(new Parameter { Name = "VS0.4", Pulse = 0.4, Factor = 25.0 * Nert});
            liste.Add(new Parameter { Name = "VS1", Pulse = 1.0, Factor = 1000.0 * Nert});
            liste.Add(new Parameter { Name = "VS2", Pulse = 2.0, Factor = 500.0 * Nert});
            liste.Add(new Parameter { Name = "VS4", Pulse = 4.0, Factor = 250.0 * Nert});
            liste.Add(new Parameter { Name = "VS10", Pulse = 10.0, Factor = 300.0 * Nert});
            return liste;           
            }

        public List<Einheiten> GetEinheitens()
        {
            List<Einheiten> liste = new List<Einheiten>();
            liste.Add(new Einheiten { Unit = "ml/sec", EFactor = 1 });
            liste.Add(new Einheiten { Unit = "l/sec", EFactor = 0.001 });
            liste.Add(new Einheiten { Unit = "ml/min", EFactor = 60 });
            liste.Add(new Einheiten { Unit = "l/min", EFactor = 0.06 });
            liste.Add(new Einheiten { Unit = "m³/min", EFactor = 0.0006 });
            liste.Add(new Einheiten { Unit = "ml/h", EFactor = 3600 });
            liste.Add(new Einheiten { Unit = "l/h", EFactor = 3.6 });
            liste.Add(new Einheiten { Unit = "m³/h", EFactor = 0.0036 });
            liste.Add(new Einheiten { Unit = "gpm", EFactor = 22 });
            return liste;
        }

        public List<IPFaktoren> GetIPFaktors()
        {
            List<IPFaktoren> liste = new List<IPFaktoren>();
            liste.Add(new IPFaktoren { IPFaktor = "1", Wert = 1.0 });
            liste.Add(new IPFaktoren { IPFaktor = "2", Wert = 2.0 });
            liste.Add(new IPFaktoren { IPFaktor = "3", Wert = 3.0 });
            liste.Add(new IPFaktoren { IPFaktor = "4", Wert = 4.0 });
            liste.Add(new IPFaktoren { IPFaktor = "5", Wert = 5.0 });
            liste.Add(new IPFaktoren { IPFaktor = "8", Wert = 8.0 });
            liste.Add(new IPFaktoren { IPFaktor = "10", Wert = 10.0 });
            liste.Add(new IPFaktoren { IPFaktor = "12", Wert = 12.0 });
            liste.Add(new IPFaktoren { IPFaktor = "16", Wert = 16.0 });
            return liste;
        }
    }

    public class Parameter  : INotifyPropertyChanged
    {
        // Ereignis
        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            if (PropertyChanged != null)
                PropertyChanged(this, e);
        }

        // Eigenschaften
        private string _Name;
        public string Name
        {
            get { return _Name; }
            set
            {
                _Name = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Name"));
            }
        }

        private string _Range;
        public string Range
        {
            get { return _Range; }
            set
            {
                _Range = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Range"));
            }
        }

            private double _Pulse;
            public double Pulse
            {
                get { return _Pulse; }
                set
                {
                     _Pulse = value;
                     OnPropertyChanged(new PropertyChangedEventArgs("Pulse"));
                }        
            }

        private double _Factor;
        public double Factor
        {
            get { return _Factor; }
            set
            {
                _Factor = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Factor"));
            }
        }

        private double _Nert;
        public double Nert
        {
            get { return _Nert; }
            set
            {
                _Nert = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Factor"));
            }
        }

        private string _USRange;
        public string USRange
        {
            get { return _USRange; }
            set
            {
                _USRange = value;
                OnPropertyChanged(new PropertyChangedEventArgs("USRange"));
            }
        }

        private string _USPulse;
        public string USPulse
        {
            get { return _USPulse; }
            set
            {
                _USPulse = value;
                OnPropertyChanged(new PropertyChangedEventArgs("USPulse"));
            }
        }

        private double? _USFactor;
        public double? USFactor
        {
            get { return _USFactor; }
            set
            {
                _USFactor = value;
                OnPropertyChanged(new PropertyChangedEventArgs("USFactor"));
            }
        }
    }

    public class Einheiten : INotifyPropertyChanged
    {
        // Ereignis
        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            if (PropertyChanged != null)
                PropertyChanged(this, e);
        }

        // Eigenschaften
        private string _Unit;
        public string Unit
        {
            get { return _Unit; }
            set
            {
                _Unit = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Unit"));
            }
        }

        private double _EFactor;
        public double EFactor
        {
            get { return _EFactor; }
            set
            {
                _EFactor = value;
                OnPropertyChanged(new PropertyChangedEventArgs("EFactor"));
            }
        }
    }

    public class IPFaktoren : INotifyPropertyChanged
    {
        // Ereignis
        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            if (PropertyChanged != null)
                PropertyChanged(this, e);
        }

        // Eigenschaften
        private string _IPFaktor;
        public string IPFaktor
        {
            get { return _IPFaktor; }
            set
            {
                _IPFaktor = value;
                OnPropertyChanged(new PropertyChangedEventArgs("IPFaktor"));
            }
        }

        public double _Wert = 1.0;
        public double Wert
        {
            get { return _Wert; }
            set 
            {
                _Wert = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Wert"));
            }
        }
    }
}
 
Zuletzt bearbeitet:
OK, ich versuche es noch mal. Ich versuche einen Kalkulator zu programmieren, wo man einige Parameter wählen muss. Zu erst wird der VS - Komponente gewählt. Das ist als Parameter - Liste dargestellt. Und jede Komponente kann aufgerüstet werden, die Aufrüstung wird als Interpolationsfaktor - Liste dargestellt.

Ich füge mal die Oberfläche noch zu um besser zu verstehen.

VSbild01.jpg

Links habe ich die Parameter - Liste und rechts habe ich die Interpolationsfaktor und unten werden die Parameter dargestellt. Wie sie sehen könnt ist eine Stelle Null und da liegt das Problem. Wenn ich ein VS - Serie gewählt habe werden die Parameters angezeigt. Mit der Interpolationsfaktor - Liste möchte ich die Parameter - Liste ein bisschen beeinflussen, also wenn ich ein Interpolationsfaktor gewählt habe, soll die K - Faktor neu berechnet wird. Diese Berechnungsaufgabe habe ich in dem Parameter - Liste eingebaut. Aber irgendwie schaffe ich nicht die Wert in der Interpolationsfaktor - Liste steht in die Parameter - Liste zu übergeben, das die Berechnung dort statt finden kann.

Die Parameter - Liste sieht so aus:

Code: 
        public List<Parameter> GetParameters()
        {
            IPFaktoren Dert = new IPFaktoren { IPFaktor = "1", Wert = 1.0 };      // Parameterübergabe versuche
            double Nert = 1.0;
            Nert = Dert.Wert;

            List<Parameter> liste = new List<Parameter>();
            liste.Add(new Parameter { Name = "VS0.02", Factor = 500000.0 * Dert.Wert});
            liste.Add(new Parameter { Name = "VS0.04", Factor = 25000.0 * Nert});
            liste.Add(new Parameter { Name = "VS0.1", Factor = 10000.0 * Nert});
            liste.Add(new Parameter { Name = "VS0.2", Factor = 5000.0 * Nert});
            liste.Add(new Parameter { Name = "VS0.4", Factor = 2500.0 * Nert});
            return liste;            
            }

Diese Liste möchte ich beeinflussen durch diese Liste (IPFaktoren):

Code: 
        public List<IPFaktoren> GetIPFaktors()
        {
            List<IPFaktoren> liste = new List<IPFaktoren>();
            liste.Add(new IPFaktoren { IPFaktor = "1", Wert = 1.0 });
            liste.Add(new IPFaktoren { IPFaktor = "2", Wert = 2.0 });
            liste.Add(new IPFaktoren { IPFaktor = "3", Wert = 3.0 });
            liste.Add(new IPFaktoren { IPFaktor = "4", Wert = 4.0 });
            liste.Add(new IPFaktoren { IPFaktor = "5", Wert = 5.0 });
            liste.Add(new IPFaktoren { IPFaktor = "8", Wert = 8.0 });
            liste.Add(new IPFaktoren { IPFaktor = "10", Wert = 10.0 });
            liste.Add(new IPFaktoren { IPFaktor = "12", Wert = 12.0 });
            liste.Add(new IPFaktoren { IPFaktor = "16", Wert = 16.0 });
            return liste;
        }

Wenn ich ein Interpolationsfaktor gewählt habe möchte ich die zugehörige Wert in die Parameter - Liste übertragen wird, wo dort die Berechnung durchgeführt werden kann.

Das Wert habe ich so definiert:

Code: 
    public class IPFaktoren : INotifyPropertyChanged
    {
        // Ereignis
        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            if (PropertyChanged != null)
                PropertyChanged(this, e);
        }
        // Eigenschaften
        private string _IPFaktor;
        public string IPFaktor
        {
            get { return _IPFaktor; }
            set
            {
                _IPFaktor = value;
                OnPropertyChanged(new PropertyChangedEventArgs("IPFaktor"));
            }
        }
        public double _Wert;
        public double Wert
        {
            get { return _Wert; }
            set 
            {
                _Wert = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Wert"));
            }
        }
    }

Und die Variablen in der Parameter - Liste habe ich identisch so gemacht.

Code: 
    public class Parameter  : INotifyPropertyChanged
    {
        // Ereignis
        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            if (PropertyChanged != null)
                PropertyChanged(this, e);
        }
        // Eigenschaften
        private string _Name;
        public string Name
        {
            get { return _Name; }
            set
            {
                _Name = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Name"));
            }
        }
        private double _Factor;
        public double Factor
        {
            get { return _Factor; }
            set
            {
                _Factor = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Factor"));
            }
        }
    }

Ich hoffe, dass ich das diesmal übersichtlich dargestellt habe.

Ich benutze das Software Visual C# 2012.
 

Anhänge

  • VSbild01.jpg
    VSbild01.jpg
    66,7 KB · Aufrufe: 8
Das ist WPF und nicht WinForms => falsches Forum.
Aber egal...Wenn ich dieses furchtbare durcheinander richtig verstehe willst du in GetParameters() auf den jeweils ausgewählten Wert der Interpolationsfaktor Combobox zugreifen.

Also entweder du sprichst einfach Interpolationsfaktor.SelectedItem an,
oder du machst ein TwoWay Binding auf Interpolationsfaktor.SelectedItem auf eine Property und sprichst dann diese an.

XML: 
<ComboBox Name="Interpolationsfaktor"
            SelectedItem="{Binding MySelectedItemProperty, Mode=TwoWay}" />

Letzteres wäre zu bevorzugen da du dann auch besser reagieren kannst wenn sich die Auswahl ändert.
Im ersten Fall müsstest du dann noch extra ein SelectionChanged Eventhandler verwenden.

Btw. das ist alles nich sonderlich schön was du da machst.
Man setzt Eigenschaften wie ItemsSource nicht im CodeBehind sondern in XAML.
Man Bindet Eigenschaften wie ItemsSource nicht an Methoden sondern an Properties.
Wieso rufst du mehrere male Focus() für unterschiedliche Elemente auf? Es kann sowieso nur ein Element den Focus besitzen.
Du Implementierst min. 3 mal INotifyPropertyChanged. Mach dir doch einfach eine Basis Klasse von der du erben kannst dann musst du es nur 1 mal implementieren.
 
Zuletzt bearbeitet von einem Moderator:
Erst mal vielen Dank, du hast mich richtig verstanden. Ich weiß, dass meine Ausdrücke nicht so verständlich ist. Nochmals vielen Dank. Ich arbeite seit 3 Monaten mit dem C#, bin noch Anfänger. Als Hilfsmittel nutze ich das Buch Visual C# 2012 von Andreas Kühl, schon 3 mal durchgelesen aber irgendwie verstehe ich die Parameterübergabe/Zugriff auf einen Parameter nicht.

Kannst du mir dabei behilflich sein, wie kann ich das optimal aufbauen.
 
Ich hab dir mal schnell ein Beispiel zusammen gekritzelt.

MainWindow.xaml
XML: 
<Window x:Class="WpfPlayground.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525"
        DataContext="{Binding RelativeSource={RelativeSource Self}}">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>

        <StackPanel Orientation="Horizontal">
            <ComboBox Name="Combobox1" SelectedIndex="0" ItemsSource="{Binding Parameters}" SelectedItem="{Binding SelectedParameter, Mode=TwoWay}" DisplayMemberPath="Name"/>
            <ComboBox Name="Combobox2" SelectedIndex="0" ItemsSource="{Binding IPFaktoren}" SelectedItem="{Binding SelectedIPFaktor, Mode=TwoWay}" DisplayMemberPath="IPFaktor"/>
        </StackPanel>

        <TextBlock Grid.Row="1" Text="{Binding KFactor}" />
    </Grid>
    
</Window>

MainWindow.xaml.cs
C#: 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.ComponentModel;
using System.Collections.ObjectModel;

namespace WpfPlayground
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window, INotifyPropertyChanged
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private ObservableCollection<IPFaktoren> ipFaktoren;
        public ObservableCollection<IPFaktoren> IPFaktoren
        {
            get
            {
                if (this.ipFaktoren == null)
                    this.ipFaktoren = new ObservableCollection<IPFaktoren>(this.GetIPFaktors());
                return ipFaktoren;
            }
            set
            {
                ipFaktoren = value;
                OnPropertyChanged("IPFaktoren");
            }
        }

        private ObservableCollection<Parameter> parameters;
        public ObservableCollection<Parameter> Parameters
        {
            get
            {
                if (this.parameters == null)
                    this.parameters = new ObservableCollection<Parameter>(this.GetParameters());
                return parameters;
            }
            set
            {
                parameters = value;
                OnPropertyChanged("Parameters");
            }
        }

        private IPFaktoren selectedIPFaktor;
        public IPFaktoren SelectedIPFaktor
        {
            get
            {
                if (this.selectedIPFaktor == null)
                    this.selectedIPFaktor = this.IPFaktoren.FirstOrDefault();
                return selectedIPFaktor;
            }
            set
            {
                selectedIPFaktor = value;
                OnPropertyChanged("SelectedIPFaktor");

                this.SetKFactor();
            }
        }

        private Parameter selectedParameter;
        public Parameter SelectedParameter
        {
            get { return selectedParameter; }
            set
            {
                selectedParameter = value;
                OnPropertyChanged("SelectedParameter");

                this.SetKFactor();
            }
        }
        
        public List<IPFaktoren> GetIPFaktors()
        {
            List<IPFaktoren> liste = new List<IPFaktoren>(){
                                                                new IPFaktoren { IPFaktor = "1", Wert = 1.0 },
                                                                new IPFaktoren { IPFaktor = "2", Wert = 2.0 },
                                                                new IPFaktoren { IPFaktor = "3", Wert = 3.0 },
                                                                new IPFaktoren { IPFaktor = "4", Wert = 4.0 },
                                                                new IPFaktoren { IPFaktor = "5", Wert = 5.0 },
                                                                new IPFaktoren { IPFaktor = "8", Wert = 8.0 },
                                                                new IPFaktoren { IPFaktor = "10", Wert = 10.0 },
                                                                new IPFaktoren { IPFaktor = "12", Wert = 12.0 },
                                                                new IPFaktoren { IPFaktor = "16", Wert = 16.0 }
                                                            };
            return liste;
        }

        public List<Parameter> GetParameters()
        {
            List<Parameter> liste = new List<Parameter>(){
                                                            new Parameter { Name = "VS0.02", Factor = 500000.0 },
                                                            new Parameter { Name = "VS0.04", Factor = 25000.0 },
                                                            new Parameter { Name = "VS0.1", Factor = 10000.0 },
                                                            new Parameter { Name = "VS0.2", Factor = 5000.0 },
                                                            new Parameter { Name = "VS0.4", Factor = 2500.0 }
                                                        };
            return liste;
        }

        private double kFactor;
        public double KFactor
        {
            get { return kFactor; }
            set
            {
                kFactor = value;
                OnPropertyChanged("KFactor");
            }
        }

        private void SetKFactor()
        {
            if (this.SelectedIPFaktor == null || this.SelectedParameter == null)
                this.KFactor = 0;
            else
                this.KFactor = this.SelectedParameter.Factor * this.SelectedIPFaktor.Wert;
        }
        
        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }

    }

    public class Parameter : NotifyBase
    {       
        private string _Name;
        public string Name
        {
            get { return _Name; }
            set
            {
                _Name = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Name"));
            }
        }
        private double _Factor;
        public double Factor
        {
            get { return _Factor; }
            set
            {
                _Factor = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Factor"));
            }
        }
    }

    public class IPFaktoren : NotifyBase
    {        
        private string _IPFaktor;
        public string IPFaktor
        {
            get { return _IPFaktor; }
            set
            {
                _IPFaktor = value;
                OnPropertyChanged(new PropertyChangedEventArgs("IPFaktor"));
            }
        }
        public double _Wert;
        public double Wert
        {
            get { return _Wert; }
            set
            {
                _Wert = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Wert"));
            }
        }
    }

    public class Einheiten : NotifyBase
    {        
        private string _Unit;
        public string Unit
        {
            get { return _Unit; }
            set
            {
                _Unit = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Unit"));
            }
        }

        private double _EFactor;
        public double EFactor
        {
            get { return _EFactor; }
            set
            {
                _EFactor = value;
                OnPropertyChanged(new PropertyChangedEventArgs("EFactor"));
            }
        }
    }

    public class NotifyBase : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            if (PropertyChanged != null)
                PropertyChanged(this, e);
        }
    }
}
 
Zuletzt bearbeitet von einem Moderator:
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück