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

Aydogan61 · 6. November 2013

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();
            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 = 50.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 = 1.0 * Nert});
            liste.Add(new Parameter { Name = "VS2", Pulse = 2.0, Factor = 5.0 * Nert});
            liste.Add(new Parameter { Name = "VS4", Pulse = 4.0, Factor = 2.0 * Nert});
            liste.Add(new Parameter { Name = "VS10", Pulse = 10.0, Factor = 3.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"));
            }
        }
    }
}

Krik · 6. November 2013

Ich habe nicht ganz verstanden, was du sagen willst.

Was für eine List-Funktion? Ich sehe ein paar Methoden, die Listen zurückgeben, aber eine List-Funktion selber habe ich nicht entdeckt.
Die Grün- und Rotmarkierung hat nicht funktioniert. Das Forum hat die Formatierung vermutlich gefressen.

Schreib mal in Pseudocode auf, was du machen willst.

Aydogan61 · 6. November 2013

1.private List<Parameter> GetParameters()
2.{
3.IPFaktoren Dert = new IPFaktoren();
4.double Nert = 1.0;
5.Nert = Convert.ToDouble(Dert.Wert);
6.
7.List<Parameter> liste = new List<Parameter>();
8.liste.Add(new Parameter { Name = "VS0.02", Range = "0.002 - 2", Pulse = 0.02, Factor = 500000.0 * Nert });
9.liste.Add(new Parameter { Name = "VS0.04", Range = "0.004 - 4", Pulse = 0.04, Factor = 25000.0 * Nert });
10.liste.Add(new Parameter { Name = "VS0.1", Range = "0.01 - 10", Pulse = 0.1, Factor = 10000.0 * Nert });
11.liste.Add(new Parameter { Name = "VS0.2", Range = "0.02 - 18", Pulse = 0.2, Factor = 5000.0 * Nert });
12.liste.Add(new Parameter { Name = "VS0.4", Range = "0.03 - 40", Pulse = 0.4, Factor = 2500.0 * Nert });
13.liste.Add(new Parameter { Name = "VS1", Range = "0.05 - 80", Pulse = 1.0, Factor = 1000.0 * Nert });
14.liste.Add(new Parameter { Name = "VS2", Range = "0.1 - 120", Pulse = 2.0, Factor = 500.0 * Nert });
15.liste.Add(new Parameter { Name = "VS4", Range = "1 - 250", Pulse = 4.0, Factor = 250.0 * Nert });
16.liste.Add(new Parameter { Name = "VS10", Range = "1.5 - 525", Pulse = 10.0, Factor = 300.0 * Nert });
17.return liste;
18.}

Von Zeile 3 bis 6, habe ich versucht ein Wert zu übergeben und in der Liste versuchte ich die übergebene Wert mit einem Variable zu multiplizieren.
1.private List<IPFaktoren> GetIPFaktors()
2.{
3.List<IPFaktoren> liste = new List<IPFaktoren>();
4.liste.Add(new IPFaktoren { IPFaktor = "1", Wert = 1.0 });
5.liste.Add(new IPFaktoren { IPFaktor = "2", Wert = 2.0 });
6.liste.Add(new IPFaktoren { IPFaktor = "3", Wert = 3.0 });
7.liste.Add(new IPFaktoren { IPFaktor = "4", Wert = 4.0 });
8.liste.Add(new IPFaktoren { IPFaktor = "5", Wert = 5.0 });
9.liste.Add(new IPFaktoren { IPFaktor = "8", Wert = 8.0 });
10.liste.Add(new IPFaktoren { IPFaktor = "10", Wert = 10.0 });
11.liste.Add(new IPFaktoren { IPFaktor = "12", Wert = 12.0 });
12.liste.Add(new IPFaktoren { IPFaktor = "16", Wert = 16.0 });
13.return liste;
14.}

Hier wird die Variable Wert ein Wert zugewiesen.
1.private double _Wert;
2.public double Wert
3.{
4.get { return _Wert; }
5.set
6.{
7._Wert = value;
8.OnPropertyChanged(new PropertyChangedEventArgs("Wert"));
9.}
10.}
Und hier versuchte ich die Variable Wert zu veröffentlichen.

Als Ergebnis bekomme ich immer einen NULL, das verstehe ich nicht so ganz.

Krik · 6. November 2013

Code:

IPFaktoren Dert = new IPFaktoren();
double Nert = 1.0;
Nert = Convert.ToDouble(Dert.Wert);

Du erzeugst ein Objekt vom Typ IPFaktoren und willst anschließend den Inhalt der Property "Wert" verwenden. Allerdings steht bis da noch gar nichts in "Wert" drin (Konstruktor gibt es keinen und bei der Deklaration erfolgt auch keine Initialisierung). Das bedeutet, dass er hier NULL oder 0.0d zurück gibt (bin mir gerade nicht sicher, was da jetzt eintritt). In der Folge jedenfalls rechnet er dann "Factor" falsch aus.

Weiterhin konvertierst du "Wert" zu Double, obwohl das eigentlich schon den Datentyp Double hat. Das ist überflüssig.
Siehe auch hier: http://msdn.microsoft.com/de-de/library/1tfb1115(v=vs.110).aspx
"Gibt die angegebene Gleitkommazahl mit doppelter Genauigkeit zurück. Es wird keine wirkliche Konvertierung durchgeführt."

Aydogan61 · 6. November 2013

Und wie kann ich das am besten realisieren. Wie du gesehen hast bin ich ein Anfänger. Seit drei Tagen Versuche ich das zu lösen aber irgendwie komme ich nicht auf dem Lösung. Das Buch "Visual C# 2012" von Andreas Kühl hat mir auch nicht weiter geholfen. Ich wäre sehr dankbar wenn du mir dabei helfen kannst.

mfg

Krik · 6. November 2013

Du bist Anfänger, ok.

Das mit den Variablen verhält sich so:

1. Deklaration, zB int var;
Das bedeutet für den Rechner: Reserviere einen Speicherbereich passend für eine Integerzahl, und benenne den Zeiger auf diesen Speicherbereich mit "var".
Beachte, dass im Speicherbereich, auf den var zeigt, noch gar nichts reingeschrieben wurde. Per Definition ist der Inhalt unbekannt und theoretisch könnte da Datenmüll drin stehen. Praktisch wird der Speicher zwar immer vor der neuen Verwendung genullt, aber darauf sollte man sich nie verlassen.

2. Initialisierung, zB var = 2;
Das bedeutet für den Rechner: Suche den Speicherbereich, auf den "var" zeigt, heraus und schreibe die Integerzahl 2 dort rein.
Erst jetzt gibt es eine Zahl, mit der du arbeiten kannst.

Beide Schritte kann man auch in einem Rutsch machen, zB int var = 2;

In deinem Fall musst du bei _Wert vor der ersten Verwendung irgendeine Zahl reinschreiben.
zB hier

Code:

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

oder hier

Code:

IPFaktoren Dert = new IPFaktoren();
Dert.Wert = 1.0;
Nert = Dert.Wert; // Diese Zeile macht nur Sinn, wenn Nert anschließend noch verändert wird. Ansonsten stattdessen Dert.Wert verwenden.

oder anders. Es gibt da viele Möglichkeiten.

Aydogan61 · 7. November 2013

Irgendwie wird der Wert von der Liste IPFaktor nicht in die Parameter - Liste übertragen. Wieso funktioniert das nicht. Ich bitte um hilfe...

Krik · 7. November 2013

Es gibt keine Listen namens IPFaktor und Parameter. Und bei was funktioniert es nicht? Und was genau funktioniert nicht? Zeig den Code und markiere die Stelle, wo etwas passieren sollte, aber nicht passiert.

Du musst dich klarer ausdrücken und dein Problem so exakt wie möglich beschreiben. Verwende auch die Fachbegriffe, wo bekannt, damit es keine Missverständnisse gibt, sonst reden wir aneinander vorbei.

PapstRatze · 7. November 2013

Ich habe mich jetzt mal versucht da rein zu fuchsen, aber bin mir nicht sicher ob ich das Problem korrekt erkannt habe. Aber ich schließe im Moment, das die Berechnung immer die gleichen Ergebnisse liefert, bzw. Nert in Zeile 60 immer null ist.

Was ja auch logisch ist, da du zwei Zeilen zuvor eine Neue Instanz der Klasse IPFaktoren einrichtest. Wie e-Laurin ja schon gesagt hat. Da der constructor leer ist wird Wert nicht initialisiert und null. Funktionieren würde es wenn du den Wert vorher festlegst. Ich vermute aber das du eher den Wert aus der Liste verwenden möchtest, der in der anderen ?Listbox? ausgewählt wurde.

Code:

IPFaktoren dert = Interpolationsfaktor.SelectedItem as IPFaktoren;

Geht allerdings nur wenn in Interpolationsfaktor bereits was drin steht. Wenn nicht durfte das Programm hier wohl abstürzen. Eine andere statische Möglichkeit wäre:

Code:

IPFaktoren der = new IPFaktoren{IPFaktor = "1", Wert = 1.0 };

Fraglich ob IPFaktor wirklich als Klasse erstellt werden muss, es scheint ja, dass die Zeichenkette einfach die Zahl ist, meine dass eine Listbox damit umgehen kann.

Ich weiß nicht wie das jetzt nun grundsätzlich gesehen wird, ich finde es aber eleganter die Klassen mit Konstruktoren zu versehen und dann gescheit zu initialisieren.

#Edit: Handelt es sich eigentlich um c#5? Also arbeitest du in VS12?

Aydogan61 · 8. November 2013

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.

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.

PapstRatze · 8. November 2013

Okay zuerst dann mal eine Neuerung, die OnPropertyChanged Methode kann man ab c#5 mit CallerMemberName aufrufen, das führt in der Regel zu weniger Fehlern und erleichtert Schreibarbeit

:

Code:

protected void RaisePropertyChanged([CallerMemberName] string member = "")
        {
            var copy = PropertyChanged;
            if (copy != null)
            {
                copy(this, new PropertyChangedEventArgs(member));
            }
        }

Der Aufruft ist dann zum Beispiel:

Code:

{
            get { return _IPFaktor; }
            set
            {
                _IPFaktor = value;
                RaisePropertyChanged();
            }
        }

Dafür muss der Namespace System.Runtime.CompilerServices inkludiert werden. Da könnte man mal aufräumen, meines erachtens wurde da eine ganze Menge unnötig eingeführt. Einfach Rechtsklick drauf -> Using-Direktiven Organisieren -> Nicht verwendete Using-Direktiven entfernen.

Nun zum Problem: Ich bin mir immer noch nicht ganz sicher ob ich das Verstanden habe, denke jetzt es geht darum das sich bei Auswahl eines Interpolationsfaktors keine Änderung einstellt.

Am einfachsten sollte es gehen, wenn du der ComboBox für die Interpolationsfaktoren das Event "SelectionChanged" zuweißt. Dort kannst du dann mit verweis auf das ausgewählte Item der ComboBox die Berechnung durchführen lassen.

Aydogan61 · 8. November 2013

Wie du gesagt hast habe ich die Änderungen durchgeführt.

Zu dem Problem: Es ist ganz einfach ich möchte die Werte in dem IPFaktor - Liste in dem Parameter - Liste aufrufen. Also die Zahlen in den "Wert" sollen zu den "Nert" übergeben werden.

Wert ----> Nert

PapstRatze · 8. November 2013

Das ist echt schwer zu lesen, es muss ja keiner perfekt deutsch können, aber es macht die Ganze Sache nicht einfacher

.

Aber es scheint mir, das du eine Verbindung der Variablen voraussetzt die so nicht vorhanden sein kann. Die Variable Nert der Klasse Parameter wird ja nie Gesetzt. In dem codeblock wird eine neue Variable Nert eingeführt, die aber hat keinen Bezug zu der in der Klasse Parameter. Wenn du dort Nert der Klasse Parameter festelgen wolltest müsstest du das natürlich auch angeben.

Code:

IPFaktoren Dert = new IPFaktoren { IPFaktor = "1", Wert = 1.0 };
            double Nert = 1.0; // neue Variable Nert die hat nichts mit new Parameter().Nert zu tuen!
            Nert = Dert.Wert;

Wenn du einen ordentlichen Konstruktor der Klasse hättest könntest du das dort festlegen, du kannst es aber genauso wie die anderen Klassen-Instanzen, beim erstellen erledigen.

Code:

public Parameter(string name, double factor, double nert)
{
	Nert = nert;
	Factor = factor * nert;
	Name = name;
}

Im Programm dann aufzurufen als:

Code:

liste.Add(new Parameter("VS0.02",500000.0,Dert.Wert));

Aydogan61 · 8. November 2013

Entschuldigung, war nicht böse gemeint. Ich habe damit vor ein Monat angefangen und bin hier stehen geblieben. Vor drei Tagen wollte ich damit weiter machen, aber wie du sehen kannst bin ich nicht so weit gekommen. Kannst du mir das noch mal erklären, wie muss ich dann die Liste aufbauen .

PapstRatze · 8. November 2013

Wenn das ganze in WPF ist, könntest du mal posten was du in der xaml so geschrieben hast, bin mir noch nicht so ganz sicher wie die Boxen zusammenhängen.

Die Listen kannst du genau so füllen wie vorher, nur wenn du einen Konstruktor verwendest, dann eben wie in meinem letzten Post. Weiter ändert sich erstmal nichts daran.

Aydogan61 · 8. November 2013

Ich werde mich morgen melden, ich muss die Struktur des Code ändern, wird bisschen zeit nehmen. Vielen Dank.

Nicht weg gehen :-) morgen bin ich wieder da...

Aydogan61 · 11. November 2013

Leider konnte ich am Wochenende nicht online sein. Ich habe die ganzen Änderungen durchgeführt aber die Wert aus dem IPFaktor - Liste konnte ich immer noch nicht raus holen...

PapstRatze · 11. November 2013

Wenn es wirklich darum geht, einen Wert mit dem Faktor zu verrechnen, der in der Combobox namens "Interpolationsfaktor" ausgewählt ist, wurde die Lösung schon genannt. Post #11 letzter Absatz!

Suche

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

Aydogan61

Cadet 2nd Year

Krik

Fleet Admiral Pro

Aydogan61

Cadet 2nd Year

Krik

Fleet Admiral Pro

Aydogan61

Cadet 2nd Year

Krik

Fleet Admiral Pro

Aydogan61

Cadet 2nd Year

Krik

Fleet Admiral Pro

PapstRatze

Lt. Junior Grade

Aydogan61

Cadet 2nd Year

PapstRatze

Lt. Junior Grade

Aydogan61

Cadet 2nd Year

PapstRatze

Lt. Junior Grade

Aydogan61

Cadet 2nd Year

PapstRatze

Lt. Junior Grade

Aydogan61

Cadet 2nd Year

Aydogan61

Cadet 2nd Year

PapstRatze

Lt. Junior Grade

Ähnliche Themen