none
Liste mit voneinander abhängigen Einträgen

    Frage

  • Hallo,

    ich brauche eine Liste von einen MyType mit einem Integer-Property z.b. Position.

    BindingList<MyType>

    Dabei müssen alle Einträge der Position aufsteigend sein (nicht sortieren).  Also muss der Listeneintrag vom Vorgänger beachtet werden.

    Ausserdem gibt es noch einen Minimum-Wert, der in der Klasse darüber als Property gehalten wird. Der Anfangswert des Integers aus der Liste mit MyType muss größer sein als diese Min-Wert.

    Sollte sich der Min-Wert ändern, müssen die Werte der Liste angepasst werden, abhängig von einen anderen Property Differenzwert aus MyType.

    Wird irgendein Property Differenzwert der Liste geändert müssen sic hauch alle Werte darüber ändern.

    Die Liste muss in einen Datagridview dargestellt werden und serialisierbar sein (was nat. schon geht - nur als Hinweis).

    Wie macht man das geschickt?

    Vielen Dank

    MfG

    Dienstag, 6. November 2018 16:08

Alle Antworten

  • Hi,

    könntest Du das bitte mal mit Beispieldaten garniert übersichtlich darstellen?


    Gruß, Stefan
    Microsoft MVP - Visual Developer ASP/ASP.NET (2001-2018)
    https://www.asp-solutions.de/ - IT Beratung, Softwareentwicklung, Remotesupport

    Dienstag, 6. November 2018 18:07
    Moderator
  • Altitude wird aus Höhe und Gradient berechnet und aus Höhe

    Allerdings kann der User auch ein Altitute eingeben und und daraus werden Höhe und alle vorhergehenden Altitude  zurück berechnet (die genaue Formel soll hier unwichtig sein)

    Ich möchte die Berechnung an die Liste anbinden, nicht ans Gridview.

    Zur Berechnung muss ich den Vorgänger der Klasse kennen.

    Alles muss im Gridview editierbar bleiben, dh. Werte ändern und neue Zeilen hinzufügen plus Zeilen bzw. Listeneinträge löschen.

    • Bearbeitet UMorgenw Mittwoch, 7. November 2018 08:47
    Mittwoch, 7. November 2018 08:39
  • Hi,
    wenn Du GridView schreibst, dann meinst Du vermutlich eine ASP.NET Anwendung mit WebForms?

    Hier mal eine Demo eines möglichen Lösungsweges in einer Windows Forms Anwendung.

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Windows.Forms;
    
    namespace WindowsFormsApp1
    {
      public partial class Form40 : Form
      {
        public Form40()
        {
          InitializeComponent();
        }
    
        DataGridView dgv = new DataGridView();
        private void Form40_Load(object sender, EventArgs e)
        {
          Liste l = new Liste();
          l.PropertyChanged += L_PropertyChanged;
          dgv.DataSource = new BindingSource() { DataSource =l};
          this.Controls.Add(dgv);
        }
    
        private void L_PropertyChanged(object sender, PropertyChangedEventArgs e) =>      dgv.Refresh();
    
        class Liste : List<Data>, INotifyPropertyChanged
        {
          // Demo-Anfangswerte im ctor setzen
          public Liste()
          {
            for (int i = 1; i < 10; i++)
            {
              Data d = new Data() { Wert = i };
              d.PropertyChanged += D_PropertyChanged;
              this.Add(d);
            }
          }
    
          private void D_PropertyChanged(object sender, DataChangedEventArgs e)
          {
            foreach (var item in this) if (item != sender) item._wert += e.Diff;
            OnPropertyChanged();
          }
    
          public event PropertyChangedEventHandler PropertyChanged;
          internal void OnPropertyChanged() => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Liste)));
        }
        public class Data
        {
          public double _wert = 0;
          public double Wert
          {
            get { return this._wert; }
            set
            {
              double oldValue = this._wert;
              this._wert = value;
              OnPropertyChanged(nameof(Wert), value -oldValue);
            }
          }
    
          public event EventHandler<DataChangedEventArgs> PropertyChanged;
          internal void OnPropertyChanged(string propName, double diff) =>
            PropertyChanged?.Invoke(this, new DataChangedEventArgs()
            { Diff = diff });
        }
    
        public class DataChangedEventArgs : EventArgs
        {
          public double Diff { get; set; }
        }
    
      }
    }


    --
    Viele Grüsse
    Peter Fleischer (ehem. MVP für Developer Technologies)
    Meine Homepage mit Tipps und Tricks

    Mittwoch, 7. November 2018 10:14