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

Kurze Problem Beschreibung:

Ich habe mehrere Klassen und in der Hauptklasse lasse ich die Ereignisse auf meinen Bildschirm anzeigen, gleichzeitig habe ich auch meine List-Funktion da drin. Jeder dieser List Funktion hat seine eigene Klasse für die Variable Deklaration. In der List Funktion weise ich auch bei einigen Variablen einen Wert zu. Diesen Wert möchte ich bei der anderen List-Funktion für Berechnungen nutzen. Irgendwie kann ich den Wert nicht übergeben. Um besser zu verstehen habe ich das Programm unten dargestellt.

Bei einigen Foren habe ich um Hilfe gebeten aber leider war es nicht Hilfreich. Ist es so einfach, dass ich das überhaupt nicht sehen kann oder muss man etwas um die Ecke denken.

Programm:

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();

            this.DataContext = IMP;   

        }

 
        private List<Parameter> GetParameters()
        {
            List<Parameter> liste = new List<Parameter>();
            liste.Add(new Parameter { Name = "VS0.02", Range = "0.002 - 2", Pulse = 0.02, Factor = 500000 * Wert});
            liste.Add(new Parameter { Name = "VS0.04", Range = "0.004 - 4", Pulse = 0.04, Factor = 25000 * Wert});
            liste.Add(new Parameter { Name = "VS0.1", Range = "0.01 - 10", Pulse = 0.1, Factor = 10000 * Wert});
            liste.Add(new Parameter { Name = "VS0.2", Range = "0.02 - 18", Pulse = 0.2, Factor = 5000 * Wert});
            liste.Add(new Parameter { Name = "VS0.4", Range = "0.03 - 40", Pulse = 0.4, Factor = 2500 * Wert});
            liste.Add(new Parameter { Name = "VS1", Range = "0.05 - 80", Pulse = 1.0, Factor = 100 * Wert});
            liste.Add(new Parameter { Name = "VS2", Range = "0.1 - 120", Pulse = 2.0, Factor = 500 * Wert});
            liste.Add(new Parameter { Name = "VS4", Range = "1 - 250", Pulse = 4.0, Factor = 250 * Wert});
            liste.Add(new Parameter { Name = "VS10", Range = "1.5 - 525", Pulse = 10.0, Factor = 300 * Wert});
            return liste;
            }
        private List<IPFaktoren> GetIPFaktors()
        {
            List<IPFaktoren> liste = new List<IPFaktoren>();
            liste.Add(new IPFaktoren { IPFaktor = "1", Wert = 1 });      // Diese Werte möchte ich oben für Berechnungen verwenden.
            liste.Add(new IPFaktoren { IPFaktor = "2", Wert = 2 });      // Hier weise ich den Variable Wert ein Wert zu und ob möchte
            liste.Add(new IPFaktoren { IPFaktor = "3", Wert = 3 });      // ich die zugewiesene Wert für Faktor-Berechnung nutzen.
            liste.Add(new IPFaktoren { IPFaktor = "4", Wert = 4 });      // Bis jetzt konnte ich die Werte nicht übergeben.
            liste.Add(new IPFaktoren { IPFaktor = "5", Wert = 5 });
            liste.Add(new IPFaktoren { IPFaktor = "8", Wert = 8 });
            liste.Add(new IPFaktoren { IPFaktor = "10", Wert = 10 });
            liste.Add(new IPFaktoren { IPFaktor = "12", Wert = 12 });
            liste.Add(new IPFaktoren { IPFaktor = "16", Wert = 16 });
            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"));
            }
        }
}

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

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

Dir fehlt eben die Verbindung zwischen den Klassen Parameter und IPFaktor.

Eine Möglichkeit wäre der Klasse Parameter ein Feld vom Typ IPFaktor zu geben. Dann kann das Parameter Objekt zum Berechnen des Faktors auf den Wert eine IPFaktor Objekts zugreifen.

Aber ansonsten, wären ein paar weitere Informationen hilfreich.
Wie hängen Parameter und IPFaktor zusammen? Woher weißt du welcher IPFaktor.Wert bei welchen Parameter zu Berechnung gebraucht wird? Bleibt es bei diesen neun Parametern (bzw. IPFaktoren) oder wird diese Liste später dynamisch aus einer DB gelesen oä?

EDIT: Der Wert des IPFaktors darf null sein, ist dies so richtig? Eine Multiplikation mit einem nullable Type ist nicht möglich.

Die Verbindung habe ich bewusst bei diesem Thread nicht angezeigt. Nämlich ich habe das auch mit Feld, Objekt, Vererbung, Property versucht aber es hat nicht funktioniert.

Nein, es ist nicht Null, fängt mit EINS an.

Jaein, vor erst bleibt es bei diesem neun Parameter.

Die Verbindung habe ich bewusst bei diesem Thread nicht angezeigt. Nämlich ich habe das auch mit Feld, Objekt, Vererbung, Property versucht aber es hat nicht funktioniert.

Wie gesagt eine Möglichkeit wäre die Klasse Parameter zu erweitern.
Eine andere wäre der Klasse Parameter einen Konstruktor zu geben

	public Parameter(string name, string range, double pulse, double factor, IPFaktor ipfaktor)
	{
		Name = name;
		Range = range;
		Pulse = pulse;
		Factor = factor * (double)ipfaktor.Wert;
	}

Nein, es ist nicht Null, fängt mit EINS an.

Ich habe auch nicht behauptet das es null IST. Aber der Typ des Feldes "wert" in der Klasse IPFaktor ist ein nullable.
Somit muss man bei Berechnungen diesen Wert zuerst casten. Nachdem aber jeder IPFaktor einen Wert != null hat, wollte ich nur nachfragen ob dies so gewollt ist bzw. ob die Liste noch erweitert wird etc.

Das wird bei mir angezeigt: > Fehlermeldung:

Für das nicht statische Feld, die Methode oder die Eigenschaft "WpfApplication4.IPFaktoren.Wert.get" ist ein Objektverweis erforderlich.

Ich weiß es nicht ob es an meinen Visual Studio liegt aber Fehler angezeigt. Objektverweise habe ich.

Mit etwas Code zu der Fehlermeldung könnte man besser helfen.
Ansonsten kann ich nur auf diesen Thread verweisen => [FAQ] Für das nicht statische Feld, die Methode oder die Eigenschaft "X" ist ein Objektverweis erf.

Somit muss man bei Berechnungen diesen Wert zuerst casten.

Nun man muss nicht casten, man kann auch einfach Nullable.GetValueOrDefault() aufrufen.

was deine Verlinkung angeht, du kannst ja in deiner Klasse IPFaktor eine Eigenschaft von Typ
Parameter definieren (oder umgekehrt) und schon sind die beiden verlinkt.

das hatte aber Pippl schon gesagt.

Diesen Weg bin ich auch gegangen aber dann bekomme ich dann dieses Fehler:

Fehlermeldung:
Das statische Feld oder die statische Eigenschaft "Wert" kann nicht in einem Objektinitialisierer zugewiesen werden.

Bei dem List<IPFaktoren>