Databinding an Chart mit mehreren Graphen

  • VB.NET

Es gibt 114 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

    Databinding an Chart mit mehreren Graphen

    Hallo,
    nachdem ich die Videos "vier Views auf Video" von ErfinderDesRades durchgearbeitet und nachprogrammiert habe, habe ich nun versucht einen eigenes kleines Testprogramm zu schreiben.
    Ich schaffe es aber nicht eine Ausgabe über einen Chart zu ermöglichen.
    Es werden fünf verschiedene Geradengleichungen berechnet und die XY-Werte in der Datenbank abgelegt. Die Auswahl der einzelnen Werte funktioniert über das DataGrid.
    Nur bei der Anbindung an einen Chart klappt nicht richtig.

    Kann man das über die Eigenschaften den Charts so einstellen, dass alle Graphen gleichzeitig angezeigt werden?

    Das mein Weg zur Anzeige nicht alle Graphen gleichzeitig nicht funktionieren kann, da mir die Auswahlmöglichkeiten fehlen ist mir klar. Ich habe nur keine Idee wie ich es anders machen kann.
    Vielleicht könnt ihr mir einen Tipp geben.

    Bilder vom Programm und auch das Programm (als Zip-File) habe ich angehängt.
    Bilder

    • Bild01.png

      32,21 kB, 1.006×658, 403 mal angesehen

    • Bild02.png

      9,27 kB, 683×231, 343 mal angesehen

    • Bild03.png

      40,94 kB, 1.289×774, 380 mal angesehen

    • Bild04.png

      64,09 kB, 1.463×767, 426 mal angesehen
    Dateien

    • xy_Werte_002.zip

      (136,22 kB, 226 mal heruntergeladen, zuletzt: )

    Leider hilft es mir nicht weiter, da bei mir die Werte für die Graphen über eine Abfrage abgefragt werden werden und ich keine Ahnung habe, wie ich das im Chart einstellen kann und ob dies überhaupt möglich ist.

    Wenn die direkte Bindung nicht geht, muss ich vielleicht auch ein Extra-DataTable entwerfen, welches ich dann wie in dem Beispiel von EDR dann einbinden kann. Ich habe aber keine Ahnung ob ein solches Vorgehen sinnvoll ist.
    Kann ein solches Vorgehen über den Designer zusammengestellt werden oder muss dies per Hand programmiert werden?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „egon“ ()

    egon schrieb:

    Kann man das über die Eigenschaften den Charts so einstellen, dass alle Graphen gleichzeitig angezeigt werden?
    Alle Graphen benutzen ja genau ein Koordinatensystem. Du musst Min und Max für x und y über alle Graphen bestimmen oder Du machst das dynamisch:

    VB.NET-Quellcode

    1. ' uninitialisiert => dynamische xy-Skalierung
    2. Me.Chart1.ChartAreas(0).AxisX.Maximum = Double.NaN
    3. Me.Chart1.ChartAreas(0).AxisX.Minimum = Double.NaN
    4. Me.Chart1.ChartAreas(0).AxisY.Maximum = Double.NaN
    5. Me.Chart1.ChartAreas(0).AxisY.Minimum = Double.NaN
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Erstmal kompliment: Bin schwer beeindruckt, dass du in < 3 Tagen wohl das meiste der "Databinding-Welt" geschnackelt hast - vor allem die Denkweise - so weit, dass du das auf deine Belange umsetzen kannst :thumbsup:

    Jo, dann im Chart-Tut ist auch auf die Microsoft-Chart-Samples verlinkt - kannste auch downloaden, laufen lassen, und mal durchgucken.
    So spontan würde ich sagen, wenn du 4 Kurven auf dem Chart willst, dann brauchst du eine DataTable mit mindestens 5 Spalten: Eine für die X-Achse, und dazu halt 4 Spalten der verschiedenen Y-Wert. Dann kann jede Kurve an ihre Y-Werte binden.
    Jedenfalls so ists in meim Chart-Tut gemacht: Für 2 Kurven brauchte ich 3 Spalten.
    Ist blöd, denn normal werden die anderen Kurven sowohl in X als auch Y Wert unterschiedlich sen, und wenn Messreihen verschieden viele Punkte haben, geht das garnimmer mehr in eine Tabelle.
    Wie gesagt: Die MS-Samples downloaden - vlt. gibts ja was von Rationpharm.

    Ach nochwas: Du programmierst zwar typisiert, und auch ohne den Deppen-Namespace, aber dringend empfehle ich dir, dein VisualStudio auch entsprechend einzurichten:
    Visual Studio - Empfohlene Einstellungen

    Und noch was: Guck dir mal Layout in Windows.Forms an - mit 2 SplitContainern könntest du in 5 min auch deiner Testanwendung ein dynamisches Layout verpassen.

    Mir scheint mal wieder: Was ich in dieses Paket gepackt habe, davon bleibt einem nix erspart: Datenverarbeitungs-Vorraussetzungen
    Nur dass du nach nur 3 Tagen eiglich zum großen Teil schon durch bist :thumbsup: (aber guck nochmal zumindest auch punkt #3 von dort - nicht, dass am Ende doch noch was vergessen wird)

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „ErfinderDesRades“ ()

    @RodFromGermany: Das hat noch nicht zum Erfolg geführt. Eigentlich bin ich mir sicher, dass ich dem Chart nicht richtig mitteile, dass er für jeden Graph anders auf die Abfrage zurückgreifen muss. Woher soll der Chart wissen, dass er für den ersten Graphen andere Werte nehmen soll als für den zweiten Graphen usw.. Er nimmt immer die gleichen Werte.
    Ich habe versucht dies in diesem Anhang deutlich zu machen. Weiterhin habe ich den Chart auf "Balken" umgestellt, damit man leichter erkennen kann, dass alle Graphen nur von einem Member versorgt werden.


    @ErfinderDesRades: "... dass du in < 3 Tagen wohl das meiste der "Databinding-Welt" geschnackelt hast"
    Danke für die Blumen. Ich fühle mich aber immer noch sehr unsicher. Gestern hatte ich einen kurzen lichten Moment wo ich das Gefühl hatte das System verstanden zu haben. Das ist heute wieder vorbei ;-). Es steht wohl ein erneutes Durcharbeiten an...

    @ErfinderDesRades: Deine Einschätzung deckt sich mit meiner Vermutung. Das ist schon mal sehr beruhigend...
    Die sonstigen Anmekungen habe ich abgespeichert und auf die todo-Liste verschoben, da ich mich erst einmal auf das Chart-Problem stürzen möchte. Auch die MS-Samples werde ich mir mal durchsehen.

    Meine Idee ist, dass eine Abfrage ein neues Table erstellt, mit den Spalten
    x_Wert_Kurve1
    y_Wert_Kurve1
    x_Wert_Kurve2
    y_Wert_Kurve2
    x_Wert_Kurve3
    y_Wert_Kurve3
    x_Wert_Kurve4
    y_Wert_Kurve4
    x_Wert_Kurve5
    y_Wert_Kurve5

    Ich glaube irgendwo gelesen zu haben, dass leere Punkte einfach nicht gezeichnet werden. Dann sollte es auch egal sein, wenn die Kurven nicht die gleiche Anzahl an Datenpunkten haben und auch unterschiedliche x_Werte (im XY-Diagramm).
    Um dies auszuprobieren scheitere ich aber an der automatischen Erstellung einer neue Table, die genau diese Spalten erhält.
    Könntet ihr mir hier weiterhelfen?
    Bilder

    • Fehler03.png

      53,19 kB, 952×650, 322 mal angesehen

    • Fehler02.png

      69,67 kB, 1.025×1.076, 323 mal angesehen

    also wenns geht, mach das nicht automatisch, sondern mach dir eine typisierte Tabelle ins Dataset, mit diese 10 Spalten.
    Dann wüsste ich eiglich nicht, was noch schief gehen sollte.

    Vlt. im 2. Schritt - wenns wirklich so dynamisch sein soll (variabel viele Kurven auffm Chart) - kannste versuchen, codeseitig eine dafür geeignete DataTable zu erstellen, und codeseitig das Chart entsprechend einzurichten, und anzubinden.
    Dabei musste aber genau die richtigen Einstellungen treffen - da wirds eine Hilfe sein, es im Designer schonmal hinbekommen zu haben.
    Du kannst dir übrigens auch den Designer-Code angucken - zumindest was das Chart betrifft, kann man davon lernen.
    Der DesignerCode des Datasets hingegen ist wohl schwieriger - weil das ist enorm viel.
    Naja - wenn man von Dataset.InitClass ausgeht, kann man sich vlt. sogar durchhangeln - man muss ja nur eine Tabelle schnackeln.

    EDR:..sondern mach dir eine typisierte Tabelle ins Dataset

    Verstehe ich dich richtig, dass du vorschlägst nicht diese automatische Abfrage zu programmieren, sondern "einfach nur" eine typisierte Tabelle mit diesen Spalten und dann die Spalten zu füllen. Eigentlich müsste dass doch reichen.
    Ich muss mit dann nur noch Unterlagen suchen, die mir den Umgang mit diesen typisierten Tabelle richtig zeigen, um den Pfaden in die Hand zu bekommen, an dem ich mich durch Thema hangeln kann:
    Zugriff aus einzelne Spalten, an den Anfang/Ende der Zeilen einer jeden Spalte springen können, kopieren einzelner Spalten (als Erweiterung)
    ... und dass alles in der typisierten Form, die ich noch nicht vollständig begriffen habe

    egon schrieb:

    Verstehe ich dich richtig, dass du vorschlägst nicht diese automatische Abfrage zu programmieren, sondern "einfach nur" eine typisierte Tabelle mit diesen Spalten und dann die Spalten zu füllen. Eigentlich müsste dass doch reichen.
    Ja.
    Und vor allem schlage ich ein schrittweises Vorgehen vor - Entwicklung eben.
    Ich weiß nicht genau, was du mit "dieser automatischen Abfrage" meinst (Datenbank? Linq?), aber mir scheint sehr unwahrscheinlich, dass das gut geht, wenn du damit gleich anfängst.

    egon schrieb:

    Zugriff aus einzelne Spalten, an den Anfang/Ende der Zeilen einer jeden Spalte springen können, kopieren einzelner Spalten (als Erweiterung)
    Wenn du damit meinst, dass du eine Spalte einer DataTable kopierst, und dadurch der DataTable eine zusätzliche Spalte anfügst, dann verlässt du damit den Kontext des typisierten Dataset.
    Die Werte dieser neuen Spalte haben keinen eigenen Namen mehr, keinen compiler-überprüften Datentyp, und Databinding an diese Spalte musst du dann codeseitig frickeln - weil auch der Designer kennt natürlich keine DataColumn, wenn sie erst zur Laufzeit zugefügt wird.
    Ach - und die typisierten AddDataRow-Methoden kennen diese neue Spalte ja auch nicht - also das wird ziemlich unübersichtlich werden.
    Aber die anderen Sachen: Zugriff, "Springen" - das ist im typisierten Ansatz mit drin.

    Oder ist es vielleicht in diesem Fall ein leichterer Weg, wenn man die Berechnungen in einem Array ablegt, bei der die Größe variabel ist und für die Anzeige den Inhalt des Array in ein Tablet kopiert?
    Bei 5 Graphen wären das 10 Spalten (jeweils x und y-Werte) und die Anzahl der Datenpunkte würde die Anzahl der Reihen bestimmen.
    Wenn man mein Beispiel weiterdenkt, würden selbst bei komplizierten Funktionen 500 Punkte pro Kurve reichen, da der Bildschirm nicht viel mehr anzeigen kann.
    Wenn ein Graph weniger punkte hat als die anderen müssten diese Zellen eben auf "leer" stehen.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „egon“ ()

    Ich habe nun ein kleines Testprogramm geschrieben, welches mehrere Graphen ausgeben kann. Leider stellt sich nun heraus, dass es langsam auf Benutzereingaben reagiert.
    Es wird bei diesem Versuch ohne Datenbank und nur mit einem Array gearbeitet. Nur so konnte ich für die einzelnen Graphen eine unterschiedliche Punkteanzahl realisieren.
    Mich stört nun das träge Verhalten des Programms. Kann man da etwas machen?

    In dem Testprogramm kann mit zwei Trackbars eine Gerade verändert werden. Da ist schon deutlich die Verzögerung zu erkennen. Bei mir eigentlich bei jedem Verschieben des Trackbars.
    Der obere Trackbar beeinflusst die Anzahl der Punkte und der untere Trackbar die Verschiebung auf der Y-Achse.
    Wenn man auf den Button drückt, wird der veränderbare Graph nach Graph1 kopiert. Im Direktfenster (Debug) ist dann eine Zeitmessung zu sehen. Gemessen wird zuerst das Kopieren des Arrays (dauert manchmal sehr lange) und dann die Aktualisierung des Charts (geht sehr schnell). Ich habe extra die Größe des Array auf 1000 Punkte gesetzt, damit die Effekte deutlich werden.

    Das irritiert mich, da der Zugriff auf Arrays doch sehr schnell geht. Kann es sein, dass die Routine insgesamt so langsam ist, dass in der Zwischenzeit erneut ein Events ausgelöst (schnelles verschieben des Trackbars) wird und dann irgendetwas blockiert wird?
    Mich irritiert auch, dass das Kopieren des Array manchmal sehr schnell geht und manchmal 2 Sekunden dauert.

    Wie könnte man diese Verzögerung in den Griff bekommen. Bei dem Beispiel muss nicht jeder Event verarbeitet werden. Wenn man den Schieber schnell verschiebt und sich mehrere Events anhäufen, reicht es aus, wenn immer nur der letzte Event verarbeitet wird. So könnte man doch einen flüssigen Ablauf hinbekommen - oder?

    Im Anhang findet ihr in dem ZIP-File den Programmordner.

    VB.NET-Quellcode

    1. Option Strict On
    2. Imports System.IO
    3. 'Imports xy_Werte_001.DataSet_xyWerte
    5. Imports System.Text.RegularExpressions
    6. Imports System.Windows.Forms.DataVisualization.Charting
    7. 'Imports System.IO
    9. Public Class FormXY_Werte
    10. Private array_Kurve0(1000, 1) As Double
    11. Private array_Kurve1(1000, 1) As Double
    12. Private array_Kurve2(1000, 1) As Double
    13. Private array_Kurve3(1000, 1) As Double
    14. Private array_Kurve4(1000, 1) As Double
    16. Const Kurve0 As Int16 = 0
    17. Const Kurve1 As Int16 = 1
    18. Const Kurve2 As Int16 = 2
    19. Const Kurve3 As Int16 = 3
    20. Const Kurve4 As Int16 = 4
    21. Const A_x_Wert As Int16 = 0
    22. Const A_y_Wert As Int16 = 1
    23. Private A_Lengh_0 As Int32
    24. Private A_Lengh_1 As Int32
    25. Private A_Lengh_2 As Int32
    26. Private A_Lengh_3 As Int32
    27. Private A_Lengh_4 As Int32
    29. Private Sub FormXY_Werte_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    30. Me.Chart1.DataSource = Nothing
    31. TrackBar2.TickFrequency = 50
    32. TrackBar2.SmallChange = 100
    33. TrackBar2.LargeChange = 100
    34. ComboBox1.Text = "Kurve 1"
    35. Generate_neu()
    36. anzeige()
    37. End Sub
    39. Private Sub Generate_neu()
    40. A_Lengh_0 = 639
    41. For i = 0 To A_Lengh_0
    42. array_Kurve0(i, A_x_Wert) = i
    43. array_Kurve0(i, A_y_Wert) = i * 2 + 25
    44. Next
    46. A_Lengh_1 = 629
    47. For i = 0 To A_Lengh_1
    48. array_Kurve1(i, A_x_Wert) = i
    49. array_Kurve1(i, A_y_Wert) = i * 2 + 10
    50. Next
    52. A_Lengh_2 = 619
    53. For i = 0 To A_Lengh_2
    54. array_Kurve2(i, A_x_Wert) = i
    55. array_Kurve2(i, A_y_Wert) = i * 2
    56. Next
    58. A_Lengh_3 = 69
    59. For i = 0 To A_Lengh_3
    60. array_Kurve3(i, A_x_Wert) = i
    61. array_Kurve3(i, A_y_Wert) = i * 2 - 10
    62. Next
    64. A_Lengh_4 = 66
    65. For i = 0 To A_Lengh_4
    66. array_Kurve4(i, A_x_Wert) = i
    67. array_Kurve4(i, A_y_Wert) = i * 2 - 20
    68. Next
    69. End Sub
    71. Private Sub anzeige()
    72. Chart1.Series(0).Color = Color.Blue
    73. Chart1.Series(0).BorderWidth = 3
    74. Chart1.Series(0).ChartType = SeriesChartType.Line
    75. For i = 0 To A_Lengh_0
    76. Chart1.Series(0).Points.AddXY(array_Kurve0(i, A_x_Wert), array_Kurve0(i, A_y_Wert))
    77. Next
    79. Chart1.Series(1).Color = Color.Brown
    80. Chart1.Series(1).BorderWidth = 3
    81. Chart1.Series(1).ChartType = SeriesChartType.Line
    82. For i = 0 To A_Lengh_1
    83. Chart1.Series(1).Points.AddXY(array_Kurve1(i, A_x_Wert), array_Kurve1(i, A_y_Wert))
    84. Next
    86. Chart1.Series(2).Color = Color.DarkCyan
    87. Chart1.Series(2).BorderWidth = 3
    88. Chart1.Series(2).ChartType = SeriesChartType.Line
    89. For i = 0 To A_Lengh_2
    90. Chart1.Series(2).Points.AddXY(array_Kurve2(i, A_x_Wert), array_Kurve2(i, A_y_Wert))
    91. Next
    93. Chart1.Series(3).Color = Color.Orange
    94. Chart1.Series(3).BorderWidth = 3
    95. Chart1.Series(3).ChartType = SeriesChartType.Line
    96. For i = 0 To A_Lengh_3
    97. Chart1.Series(3).Points.AddXY(array_Kurve3(i, A_x_Wert), array_Kurve3(i, A_y_Wert))
    98. Next
    100. Chart1.Series(4).Color = Color.Thistle
    101. Chart1.Series(4).BorderWidth = 3
    102. Chart1.Series(4).ChartType = SeriesChartType.Line
    103. For i = 0 To A_Lengh_4
    104. Chart1.Series(4).Points.AddXY(array_Kurve4(i, A_x_Wert), array_Kurve4(i, A_y_Wert))
    105. Next
    106. End Sub
    108. Private Sub TrackBar1_Scroll(sender As Object, e As EventArgs) Handles TrackBar1.ValueChanged, TrackBar2.ValueChanged
    109. Dim track_x As Integer
    110. track_x = TrackBar1.Value
    111. Label1.Text = track_x.ToString
    112. Chart1.Series(0).Points.Clear()
    114. For i = 0 To A_Lengh_0
    115. array_Kurve0(i, A_x_Wert) = i
    116. array_Kurve0(i, A_y_Wert) = i * 2 + track_x
    117. Next
    118. anzeige()
    119. End Sub
    121. Private Sub TrackBar1_Scroll_1(sender As Object, e As EventArgs) Handles TrackBar1.Scroll, TrackBar2.ValueChanged
    122. Dim track_x As Integer
    123. track_x = TrackBar2.Value
    124. Label3.Text = track_x.ToString
    126. 'Chart1.SuspendLayout()
    128. A_Lengh_0 = track_x
    130. For i = 0 To A_Lengh_0
    131. array_Kurve0(i, A_x_Wert) = i
    132. array_Kurve0(i, A_y_Wert) = i * 2 + TrackBar1.Value
    133. Next
    134. anzeige()
    135. 'Chart1.ResumeLayout()
    136. 'Debug.WriteLine("xxxx")
    137. End Sub
    139. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    140. Dim StartZeit As Date = System.DateTime.Now
    141. Dim Text As String
    142. Text = ComboBox1.Text
    143. Chart1.Series(1).Points.Clear()
    145. Select Case Text
    146. Case "Kurve 1"
    147. ' Debug.WriteLine("nach Kurve1 wird kopiert")
    148. ' Array.Copy(array_Kurve0, array_Kurve1, Lengh_0) funktioniert nicht Grund unbekannt
    149. A_Lengh_1 = A_Lengh_0
    150. ' ReDim array_Kurve1(A_Lengh_0, 1)
    151. For i = 0 To A_Lengh_1
    152. array_Kurve1(i, A_x_Wert) = array_Kurve0(i, A_x_Wert)
    153. array_Kurve1(i, A_y_Wert) = array_Kurve0(i, A_y_Wert)
    154. Next
    155. Case Else
    157. End Select
    158. Debug.WriteLine("Array kopieren " & CInt(System.DateTime.Now.Subtract(StartZeit).TotalMilliseconds))
    159. StartZeit = System.DateTime.Now
    160. anzeige()
    161. Debug.WriteLine("Bildausgabe " & CInt(System.DateTime.Now.Subtract(StartZeit).TotalMilliseconds))
    162. End Sub
    164. End Class
    Dateien

    • xy_Werte_003.zip

      (160,3 kB, 269 mal heruntergeladen, zuletzt: )

    >>> Das lagt v.a., weil du die Series-Punkte nicht vorher löschst, bevor du neue Punkte rein machst.

    Wenn ich Punkte zeichne werden mit "Chart1.Series(0).Points.Clear()" die Punkte von einem Graphen gelöscht. So habe ich es jedenfalls verstanden.
    Bei einem Array kann ich mir es nicht vorstellen, dass es wichtig ist, wenn vorher die einzelnen Elemente gelöscht werden.

    Edit: Wenn ich die Zeitmessungen richtig interpretiere, wird das kopieren des Array sehr langsam.
    Was passiert eigentlich, wenn im Eingabefenster eingaben gemacht sind und das Programm noch mit der Abarbeitung der alten Events (Benutzereingaben) beschäftigt sind. Wird dann alles in eine Art Warteschleife geschrieben?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „egon“ ()

    Achso - hattest du das bereits gemacht? Mir war so, als ob nicht.
    Nochmal geguckt - also in meim Download hast du keine Series-Punkte gelöscht.
    Bei mir ist das Zeile#6:

    VB.NET-Quellcode

    1. Private Sub anzeige()
    2. Chart1.Series.Cast(Of Series).Zip({array_Kurve0, array_Kurve1, array_Kurve2, array_Kurve3, array_Kurve4}).ForEach( _
    3. Sub(tpl)
    4. Dim ser As Series = tpl.Item1
    5. Dim arr As Double(,) = tpl.Item2
    6. ser.Points.Clear()
    7. For i = 0 To arr.GetUpperBound(0)
    8. ser.Points.AddXY(arr(i, 0), arr(i, 1))
    9. Next
    10. End Sub)
    11. End Sub
    Kannste auch mal auskommentieren, dann siehste, wie sich da ein erhebliches Laggen entwickelt

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „ErfinderDesRades“ ()

    Deine Routine kann ich nicht testen, da ich den Fehler nicht wegbekomme. Kannst du mir bitte erklären was das "Zip" macht. Kann man damit alle aufgezählten Array in einem Rutsch übergeben?

    "Chart1.Series(0).Points.Clear()" findest du bei mir in den Zeilen 112 und 143.

    Dann hätte ich noch die Frage, wie man richtig das Array array_Kurve0 nach array_Kurve1 kopiert. Irgendwie hat das bei mir nicht geklappt. Deshalb habe ich bei mir eine For-Schleife, die alle Elemente durchläuft. Das ist bestimmt unnötig und geht viel einfacher.
    Bilder

    • Fehler04.png

      24,33 kB, 1.167×377, 280 mal angesehen

    Jo, ich hab meine Helpers eingebunden, um gscheit debuggen zu können.
    Weil du über die Zeit-Messungen redetest, nahm ich an, ich hätte das geuploadet.
    Nun weiß ich aber garnimmer, von welchen ZeitMessungen du redest, weil von meinen Messungen kanns ja nicht sein.

    Naja - egal:
    Dateien

    Die Veränderungen von dir muss ich mir in Ruhe ansehen und mein ganzes Programm überarbeiten. Die Darstellung ist auch noch nicht richtig in deinem File aus Beitrag #16, da ich meine Array nicht richtig vollgeschrieben habe. Ich hatte immer die Länge in den Variablen A_Lengh_0 bis A_Lengh_4 zu übergeben. Ab das so schlau ist, bin ich mir nicht so sicher. Vielleicht ist es besser ganz sauber die Array immer richtig zu dimensionieren.
    Du hast immer die ganzen Array verarbeitet. (Woher sollst du auch wissen, was ich da so komisches gemacht habe ;) )

    Deine Helpers habe ich vorher noch nicht so richtig wahrgenommen. Was können sie alles leisten und wie binde ich sie in eine neues Projekt ein?

    egon schrieb:

    Vielleicht ist es besser ganz sauber die Array immer richtig zu dimensionieren.
    Auf jeden Fall :thumbsup:

    Und mein Code ist auch bischen Vorgriff darauf, aber nur bischen.

    Anders gesehen auch wieder nicht, denn nachwievor bin ich der Ansicht, man sollte das über DataTables abhandeln, und die Aktualisierung mittels Chart.Databind abwickeln.
    Dadurch ist das Bereitstellen der Daten, und die Aktualisierung des Guis optimal voneinander getrennt, wobei letzterer ein interner Vorgang ist, der evtl. auch noch wesentlich schneller ist, als jeden Punkt selbst hinzumachen.
    Aber vlt. auch nicht, das weiß ich erst, wenn ichs gemacht hab.

    Hast du eiglich die MS-Samples mal durchgeguckt? Ich hab das in Erinnerung, dasses fast 100 Varianten anzugugge gab.

Facebook
Telefonspende