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

A

Aydogan61

Neuling
Thread Starter
Mitglied seit
06.11.2013
Beiträge
3
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();
        }

        
[B]        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 = 50.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 = 100.0 * Nert });
            liste.Add(new Parameter { Name = "VS0.2", Pulse = 0.2, Factor = 500.0 * Nert});
            liste.Add(new Parameter { Name = "VS0.4", Pulse = 0.4, Factor = 250.0 * Nert });
            liste.Add(new Parameter { Name = "VS1", Pulse = 1.0, Factor = 100.0 * Nert });
            liste.Add(new Parameter { Name = "VS2", Pulse = 2.0, Factor = 50.0 * Nert });
            liste.Add(new Parameter { Name = "VS4", Pulse = 4.0, Factor = 25.0 * Nert });
            liste.Add(new Parameter { Name = "VS10", Pulse = 10.0, Factor = 30.0 * Nert});
            return liste;           
            }[/B]

        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;
        }

[B]        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;
        }[/B]
    }

    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"));
            }
        }

[B]        public double _Wert = 1.0;
        public double Wert
        {
            get { return _Wert; }
            set 
            {
                _Wert = value;
                OnPropertyChanged(new PropertyChangedEventArgs("Wert"));
            }
        }[/B]
    }
}
 
Zuletzt bearbeitet:
Wenn Du diese Anzeige nicht sehen willst, registriere Dich und/oder logge Dich ein.
Ich will nicht Faul klingen aber ich habe wenig Lust den kompletten Code durch zu gehen.
Hast du ein Minimalbeispiel, das dein Problem gleich beschreibt?
 
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.

Das Problem wurde gelöst. Die Thread kann gelöscht werden.
 
Zuletzt bearbeitet:
Anmelden, um zu antworten.
Hardwareluxx setzt keine externen Werbe- und Tracking-Cookies ein. Auf unserer Webseite finden Sie nur noch Cookies nach berechtigtem Interesse (Art. 6 Abs. 1 Satz 1 lit. f DSGVO) oder eigene funktionelle Cookies. Durch die Nutzung unserer Webseite erklären Sie sich damit einverstanden, dass wir diese Cookies setzen. Mehr Informationen und Möglichkeiten zur Einstellung unserer Cookies finden Sie in unserer Datenschutzerklärung.


Zurück
Oben Unten refresh