none
WPF Chart Control ( Line Chart ) bind to DataSet / DataTable RRS feed

  • Frage

  • Hallo,

     

    Ich benutze das Chart Control aus dem DataVisualization Toolkit. Meine Frage hierzu, wie binde ich bspw. ein "Line Chart" an ein DataSet oder DataTable.

    Ich möchte die Werte aus dem DataTable auslesen und im Chart veranschaulichen.

     

    XAML:

     

    <Window x:Class="MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:DVC="clr-namespace:System.Windows.Controls.DataVisualization.Charting;assembly=System.Windows.Controls.DataVisualization.Toolkit"
        Title="MainWindow" Height="auto" Width="auto">
        <Grid>
            <DVC:Chart Canvas.Top="80" Canvas.Left="10" Name="mcChart" Background="#FFC72D40" Margin="0">
                <DVC:Chart.Series>
                    <DVC:LineSeries Title="Line"
                    IndependentValueBinding="{Binding Path=Key}"
                    DependentValueBinding="{Binding Path=Value}">
                    </DVC:LineSeries>
                </DVC:Chart.Series>
            </DVC:Chart>         
        </Grid>
    </Window>

    VB.NET:

    Imports System.Windows.Controls.DataVisualization.Charting


    Class MainWindow
        Private Sub LoadColumnChartData()
            DirectCast(mcChart.Series(0), LineSeries).ItemsSource = New KeyValuePair(Of StringInteger)() {New KeyValuePair(Of StringInteger)("Jan", 150),
                                                                                                              New KeyValuePair(Of StringInteger)("Feb", 160),
                                                                                                              New KeyValuePair(Of StringInteger)("Mär", 120),
                                                                                                              New KeyValuePair(Of StringInteger)("Apr", 160),
                                                                                                              New KeyValuePair(Of StringInteger)("Mai", 190),
                                                                                                              New KeyValuePair(Of StringInteger)("Jun", 180),
                                                                                                              New KeyValuePair(Of StringInteger)("Jul", 150),
                                                                                                              New KeyValuePair(Of StringInteger)("Aug", 140),
                                                                                                              New KeyValuePair(Of StringInteger)("Sep", 135),
                                                                                                              New KeyValuePair(Of StringInteger)("Okt", 145),
                                                                                                              New KeyValuePair(Of StringInteger)("Nov", 160),
                                                                                                              New KeyValuePair(Of StringInteger)("Dez", 190)}

        End Sub
    End Class

    Im Moment zeigt mein Chart Control mir die oben händisch eingefügten Werte.

    Jeder Tipp der "Binding" betrifft ist hilfreich.

    Vielen Dank im Voraus!


    Edit: .NET 4.0 ; Microsoft Visual Studio 2010
    Freitag, 25. März 2011 08:59

Antworten

  • Hier mal eine Demo, wqie ich das machen würde:

    XAML:

    <Window x:Class="Window3"
     xmlns:dvc="clr-namespace:System.Windows.Controls.DataVisualization.Charting;assembly=System.Windows.Controls.DataVisualization.Toolkit" 
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      Title="Window3" Height="300" Width="300"
        xmlns:local="clr-namespace:WpfApplication1">
     <Window.Resources>
      <local:Window3VM x:Key="vm"/>
     </Window.Resources>
     <Grid DataContext="{Binding Source={StaticResource vm}}">
      <dvc:Chart>
       <dvc:Chart.Series>
        <dvc:LineSeries Title="Line" 
                ItemsSource="{Binding Data}"
                 DependentValueBinding="{Binding Value}" 
                 IndependentValueBinding="{Binding Key}">
        </dvc:LineSeries>
       </dvc:Chart.Series>
      </dvc:Chart>
     </Grid>
    </Window>
    

    Dazu die ViewModel-Klasse:

    Imports System.Data
    Imports System.Data.SqlClient
    Imports System.ComponentModel
    
    Public Class Window3VM
    
     Public ReadOnly Property Data As ICollectionView
      Get
       Dim cvs As New CollectionViewSource
       cvs.Source = LoadData()
       Return cvs.View
      End Get
     End Property
    
     Private Function LoadData() As DataTable
      Dim dt As New DataTable
      Using da As New SqlDataAdapter("SELECT keyvalue as [Key], datavalue1 as Value FROM chart_data", My.Settings.cn)
       da.Fill(dt)
      End Using
      Return dt
     End Function
    
    End Class
    
    --
    Peter
    Sonntag, 27. März 2011 09:26
  • Das geht auch mit Deinem Code:
     
    XAML:
     
    <Window x:Class="Window5"
       xmlns:dvc="clr-namespace:System.Windows.Controls.DataVisualization.Charting;assembly=System.Windows.Controls.DataVisualization.Toolkit" 
        Title="Window5" Height="300" Width="300"
            xmlns:local="clr-namespace:WpfApplication1">
      <Window.Resources>
        <local:Window5VM x:Key="vm"/>
      </Window.Resources>
      <Grid DataContext="{Binding Source={StaticResource vm}}">
        <dvc:Chart>
          <dvc:Chart.Series>
            <dvc:LineSeries Title="Line"
                            ItemsSource="{Binding Data}"
                              DependentValueBinding="{Binding Tore}"
                              IndependentValueBinding="{Binding Month}">
            </dvc:LineSeries>
          </dvc:Chart.Series>
        </dvc:Chart>
      </Grid>
    </Window>
     
    Und der Code dazu:
     
    Imports System.Data
    Imports System.ComponentModel
     
    Public Class Window5VM
     
      Public ReadOnly Property Data As ICollectionView
        Get
          Dim cvs As New CollectionViewSource
          cvs.Source = GetData()
          Return cvs.View
        End Get
      End Property
     
      Private Function GetData() As DataTable
        Dim dt As New DataTable
        With dt
          .TableName = "results"
          With .Columns
            .Add("Month", GetType(String))
            .Add("Tore", GetType(Integer))
          End With
          For i As Integer = 1 To 12
            Dim dr As DataRow = dt.NewRow
            dr.Item("Month") = "Monat " & i.ToString
            Select Case i
              Case 1, 3, 7, 9
                dr.Item("Tore") = 4
              Case 2, 4, 6, 10
                dr.Item("Tore") = 7
              Case Else
                dr.Item("Tore") = 8
            End Select
            dt.Rows.Add(dr)
          Next
        End With
        Return dt
      End Function
     
    End Class
     
    --
    Viele Grüße
    Peter
    Montag, 28. März 2011 16:08
  • Da Ihr Euch so die Zuweisung im CodeBehind wünscht, hier mal ein Beispiel:
     
    XAML:
     
    <Window x:Class="Window6"
        Title="Window6" Height="500" Width="1000"
        xmlns:chart="clr-namespace:System.Windows.Controls.DataVisualization.Charting;assembly=System.Windows.Controls.DataVisualization.Toolkit">
      <Grid>
        <TabControl >
          <TabControl.Items>
            <TabItem Name="tab_Results" FontSize="14" Header="Ergebnisse">
              <Grid Name="subgrid_Auswertung_Ergebnisse">
                <chart:Chart Name="Chart_1" Margin="109,61,245,30">
                  <chart:Chart.Series>
                    <chart:LineSeries Name="Serie1" Title="Erster Test"
                                  IndependentValueBinding="{Binding Month}"
                                  DependentValueBinding="{Binding Path=Tore}"/>
                  </chart:Chart.Series>
                </chart:Chart>
              </Grid>
            </TabItem>
          </TabControl.Items>
        </TabControl>
      </Grid>
    </Window>
     
    Dazu der CodeBehind:
     
    Imports System.Data
     
    Public Class Window6
     
      Private Sub Window6_Loaded(ByVal sender As Object, ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded
        BindData()
      End Sub
     
      Private Sub BindData()
        Dim dt As New DataTable
        With dt
          .TableName = "results"
          With .Columns
            .Add("Month", GetType(String))
            .Add("Tore", GetType(Integer))
          End With
          For i As Integer = 1 To 12
            Dim dr As DataRow = dt.NewRow
            dr.Item("Month") = "Monat " & i.ToString
            Select Case i
              Case 1, 3, 7, 9
                dr.Item("Tore") = 4
              Case 2, 4, 6, 10
                dr.Item("Tore") = 7
              Case Else
                dr.Item("Tore") = 8
            End Select
            dt.Rows.Add(dr)
          Next
        End With
        Me.Serie1.ItemsSource = (New CollectionViewSource With {.Source = dt}).View
      End Sub
     
    End Class
     
    --
    Viele Grüße
    Peter
    Freitag, 1. April 2011 17:41
  • Ich vermute, dass das Formular "frm_Kundenakte" heißt und der Code im
    Codebehind des Formulars steht. Mit der Instanziierung eines Objektes vom
    Typ des Formulars als Ressource wird dieser Prozess unendlich wiederholt und
    führt letztendlich zum Pufferüberlauf.
     
    Ich empfehle, die Anwendung sauber zu strukturieren und die Instanzen
    hierarchisch aufzubauen. Das bedeutet:
     
    1. Formular als XAML und, wenn wirklich Bedienlogik zu unterstützen ist,
    dann auch Code im CodeBehind.
     
    2. Klasse mit der Geschäftslogik, die von der Oberfläche instanziiert wird,
    z.B. als Ressource. Die Klasse stellt alle Eigenschaften bereit, die in der
    Oberfläche im XAML für Bindungen genutzt werden. Dabei ist zwischen
    Dateneigenschaften (für die Datenanzeige), Befehlseigenschaften (für
    Befehlsschaltflächen) und angehängten Eigenschaften (für Ereignisse der
    Steuerelemente der Oberfläche) zu unterscheiden.
     
    3. Klasse mit Code für die Datenbereitstellung, die von der Geschäftslogik
    instanziiert wird.
     
    --
    Viele Grüße
    Peter
     
     
    Freitag, 1. April 2011 03:55

Alle Antworten

  • Hier mal eine Demo, wqie ich das machen würde:

    XAML:

    <Window x:Class="Window3"
     xmlns:dvc="clr-namespace:System.Windows.Controls.DataVisualization.Charting;assembly=System.Windows.Controls.DataVisualization.Toolkit" 
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      Title="Window3" Height="300" Width="300"
        xmlns:local="clr-namespace:WpfApplication1">
     <Window.Resources>
      <local:Window3VM x:Key="vm"/>
     </Window.Resources>
     <Grid DataContext="{Binding Source={StaticResource vm}}">
      <dvc:Chart>
       <dvc:Chart.Series>
        <dvc:LineSeries Title="Line" 
                ItemsSource="{Binding Data}"
                 DependentValueBinding="{Binding Value}" 
                 IndependentValueBinding="{Binding Key}">
        </dvc:LineSeries>
       </dvc:Chart.Series>
      </dvc:Chart>
     </Grid>
    </Window>
    

    Dazu die ViewModel-Klasse:

    Imports System.Data
    Imports System.Data.SqlClient
    Imports System.ComponentModel
    
    Public Class Window3VM
    
     Public ReadOnly Property Data As ICollectionView
      Get
       Dim cvs As New CollectionViewSource
       cvs.Source = LoadData()
       Return cvs.View
      End Get
     End Property
    
     Private Function LoadData() As DataTable
      Dim dt As New DataTable
      Using da As New SqlDataAdapter("SELECT keyvalue as [Key], datavalue1 as Value FROM chart_data", My.Settings.cn)
       da.Fill(dt)
      End Using
      Return dt
     End Function
    
    End Class
    
    --
    Peter
    Sonntag, 27. März 2011 09:26
  • hallo Herr Fleischer

    Ich übernehme an dieser Stelle kurz für meinen Kollegen Timm Schröder und bedanke mich erstmal für Ihre Hilfestellung. Wir nutzen aktuell in unserem Projekt kein MVVM Pattern und auch keinen SQL-Server. Wir können Ihr Beispiel abstrahieren aber wir möchten nur die notwendigsten Einstellungen in XAML abbilden. U. a. soll über den Code-Behind in einem einzigen Control je nach Programmsituation auch andere Charttypen gezeigt werden. Daher suchen wir (ziemlich erfolglos) nach Dokumentation bzw. Beispiele, wie ich ein DataTable verwenden kann. Zwar kann ich das DataTable in KeyValuePair umwandeln aber nach unserem Verständnis spricht nichts dagegen, als Itemsource ein DataTable DefaultView zu verwenden. Nachstehend ein Beispiel für unseren DataTable:

    Dim dt As New DataTable
    
        With dt
          .TableName = "results"
          With .Columns
            .Add("Month", GetType(String))
            .Add("Tore", GetType(Integer))
          End With
          For i As Integer = 1 To 12
            Dim dr As DataRow = dt.NewRow
            dr.Item("Month") = "Monat " & i.ToString
            Select Case i
              Case 1, 3, 7, 9
                dr.Item("Tore") = 4
              Case 2, 4, 6, 10
                dr.Item("Tore") = 7
              Case Else
                dr.Item("Tore") = 8
            End Select
            dt.Rows.Add(dr)
          Next
        End With
    

    Unser bislang erfolgloser Versuch (immerhin keine Fehlermeldung!) ist nachstehend abgebildet:

    If Not IsNothing(dt) Then
            With Me.chart_line
              .ItemsSource = dt.DefaultView
              .IndependentValuePath = "Month"
              .DependentValuePath = "Tore"
            End With
          End If
    

    Vielen Dank für jeden Tipp!

    Michael Lutz

    BITsoft


    Michael Lutz, BITsoft
    Montag, 28. März 2011 15:29
  • Das geht auch mit Deinem Code:
     
    XAML:
     
    <Window x:Class="Window5"
       xmlns:dvc="clr-namespace:System.Windows.Controls.DataVisualization.Charting;assembly=System.Windows.Controls.DataVisualization.Toolkit" 
        Title="Window5" Height="300" Width="300"
            xmlns:local="clr-namespace:WpfApplication1">
      <Window.Resources>
        <local:Window5VM x:Key="vm"/>
      </Window.Resources>
      <Grid DataContext="{Binding Source={StaticResource vm}}">
        <dvc:Chart>
          <dvc:Chart.Series>
            <dvc:LineSeries Title="Line"
                            ItemsSource="{Binding Data}"
                              DependentValueBinding="{Binding Tore}"
                              IndependentValueBinding="{Binding Month}">
            </dvc:LineSeries>
          </dvc:Chart.Series>
        </dvc:Chart>
      </Grid>
    </Window>
     
    Und der Code dazu:
     
    Imports System.Data
    Imports System.ComponentModel
     
    Public Class Window5VM
     
      Public ReadOnly Property Data As ICollectionView
        Get
          Dim cvs As New CollectionViewSource
          cvs.Source = GetData()
          Return cvs.View
        End Get
      End Property
     
      Private Function GetData() As DataTable
        Dim dt As New DataTable
        With dt
          .TableName = "results"
          With .Columns
            .Add("Month", GetType(String))
            .Add("Tore", GetType(Integer))
          End With
          For i As Integer = 1 To 12
            Dim dr As DataRow = dt.NewRow
            dr.Item("Month") = "Monat " & i.ToString
            Select Case i
              Case 1, 3, 7, 9
                dr.Item("Tore") = 4
              Case 2, 4, 6, 10
                dr.Item("Tore") = 7
              Case Else
                dr.Item("Tore") = 8
            End Select
            dt.Rows.Add(dr)
          Next
        End With
        Return dt
      End Function
     
    End Class
     
    --
    Viele Grüße
    Peter
    Montag, 28. März 2011 16:08
  • Guten Morgen Peter

    Vielen Dank für die sehr hilfreiche Unterstützung. Mit deinem Beispiel bekommen wir das Chart angezeigt. Aber wir möchten das Chart komplett über Codebehind und ohne Databinding aufbauen. Gibt es dazu keine Möglichkeit? Die ICollectionView generieren wir aus dem DataTable und hängen ihn an die ItemsSource Eigenschaft. Nach meinem Verständnis müssten doch dann die die Eigenschaften IndependentValuePath (= "Month") und DependentValuePath (= "Tore") bestückbar sein.

    Bislang habe ich nur Beispiele gefunden die (meist Silverlight und C#) ausschließlich die meiste Gestaltungsarbeit in XAML machen. Dieses sicherlich begründete Vorgehen ist aber für unsere Applikation umständlich und unflexibel. Das Charting muss situativ über Codebehind zu managen sein. Gibt es irgendein Dokument welches die Struktur der sicherlich sehr mächtigen Charting-Komponente verdeutlicht?

    Vielen Dank für deine weitere Unterstützung.

     


    Michael Lutz, BITsoft
    Dienstag, 29. März 2011 07:26
  • Das verstehe ich nicht. Wenn das Chart Control ohne Datenbindung genutzt werden soll, wie soll das Chart dann seine Daten für die Anzeige bekommen? In diesem Fall wäre es einfach möglich, ohne das Chart Control zu arbeiten und anhand der Daten die Anzeigeelemente selbst per Code zu zeichnen. Das wird dann aber ein Vielfaches des Aufwandes gegenüber der Nutzung des Chart Controls, welches sich die Daten für die Anzeige aus der Datenquelle holt.

    --
    Peter

    Dienstag, 29. März 2011 07:32
  • hallo Peter

    Wahrscheinlich habe ich unsere Intension ungeschickt formuliert. Ich orientierte mich am Vorgehen beim Füllen eines DataGrid, bei dem ich zwar im XAML-Code die Bindings der einzelnen Columns festlege, aber die Itemssource erst zur Laufzeit einbringe. So wie ich das jetzt verstanden habe, muss ich bereits in XAML festlegen, welchen Typ von Charting ist einsetze (Line, Bar etc.).

    Aber das prinzipielle Vorgehen für das Charting ist verstanden. Vielen Dank. Dennoch möchte ich nochmal die Frage aufwerfen, ob es irgendwo eine Klassenübersicht der Charting-Name-Spaces gibt?

    Danke

     


    Michael Lutz, BITsoft
    Dienstag, 29. März 2011 08:03
  • Die ItemsSource kann beim Chart Steuerelement auch per Code festgelegt
    werden. Es bleibt da aber die Frage, warum man das machen will/muss. Mit
    solcher engen Bindung von Oberfläche und Code verbaut man sich effektive
    Wege für das Testen, für die Fehlersuche, für die Gewährleistung einer
    Übersichtlichkeit, für nachträgliche Änderungen und Anpassungen.
     
    Wenn Du Dir einen Überblick über die Klassen, Interfaces usw. verschaffen
    willst, dann schau dir mit einem Reflector die
    System.Windows.Controls.DataVisualization.Toolkit.dll an. Da ist nicht wenig
    drin: äußeres Panel, Chart Bereich, Legende, X- und Y-Achsen,
    Beschriftungen, ChartTypen, Serien, Punkte usw.
     
    --
    Viele Grüße
    Peter
     
     
    Dienstag, 29. März 2011 12:05
  • Danke Peter, das werden wir machen.

    viele Grüße


    Michael Lutz, BITsoft
    Dienstag, 29. März 2011 13:28
  • Hallo Peter

    Wir haben im Nachgang noch eine Frage. Gibt es irgendeine Möglichkeit, ein DataTable (Month ist der String (Key) und Tore ist ein Integer (Value) direkt als ItemSource zu nutzen?

    danke schon im Voraus

     


    Michael Lutz, BITsoft
    Donnerstag, 31. März 2011 15:34
  • Wie meinst Du das? Was gefällt Dir an meinem Beispiel nicht?
     
    --
    Viele Grüße
    Peter
     
     
    Donnerstag, 31. März 2011 19:07
  • hallo Peter, danke für die Antwort zu später Stunde!

    ich habe leider zu voreilig gesagt, dass dein zweites Beispiel ("das funktioniert auch mit deinem Code") bei uns funktioniert. Irrtümlich hatten wir wieder unser erstes beispielhaftes Vorgehen am Start. Ich poste morgen früh ganz zeitig den von uns verwendeten XAML und VB.NET Code. Ist mir ja peinlich zu fragen aber hast du dein Beispiel tatsächlich so ans Laufen gebracht? Die einzige Variation die wir haben ist, dass wir den DataContext des Grids nicht verwenden. Wir vermuteten, dass dieser noch aus vorherigen Beispielen stammt.

    Puh - irgendwie stehen wir auf dem Schlauch.

    lg


    Michael Lutz, BITsoft
    Donnerstag, 31. März 2011 19:36
  • Hier exakt der Code:

    <Window.Resources>
    <local:frm_Kundenakte x:Key="vm" /> 
    </Window.Resources>
    <TabItem Name="tab_Results" FontSize="14" Header="Ergebnisse">
    <Grid Name="subgrid_Auswertung_Ergebnisse" DataContext="{Binding Source={StaticResource vm}}">
      <chart:Chart Name="Chart_1" Margin="109,61,245,30">
       <chart:Chart.Series>
         <chart:LineSeries Title="Erster Test" ItemsSource="{Binding Data}" IndependentValueBinding="{Binding Month}" DependentValueBinding="{Binding Path=Tore}"/>
         </chart:Chart.Series>
      </chart:Chart>
    </Grid>
    </TabItem>
    Public ReadOnly Property Data As ICollectionView
     Get
     Dim cvs As New CollectionViewSource
    	 cvs.Source = GetData()
     Return cvs.View
     End Get
     End Property
    
    Private Function GetData() As DataTable
    
     Dim dt As New DataTable
    
     With dt
     .TableName = "results"
     With .Columns
     .Add("Month", GetType(String))
     .Add("Tore", GetType(Integer))
     End With
    
     For i As Integer = 1 To 12
     Dim dr As DataRow = dt.NewRow
     dr.Item("Month") = "Monat " & i.ToString
    
     Select Case i
      Case 1, 3, 7, 9
      dr.Item("Tore") = 4
      Case 2, 4, 6, 10
      dr.Item("Tore") = 7
      Case Else
      dr.Item("Tore") = 8
     End Select
    
     dt.Rows.Add(dr)
     Next
    
     End With
    
     If Not IsNothing(dt) Then
     GetData = dt
     Else
     GetData = Nothing
     End If
    
    End Function

     


    Das Resultat ist ernüchternd. Beim Aufruf der Form bekomme ich nach ca. 10 Sekunden die Meldung im Debugger: "Eine nicht behandelte Ausnahme des Typs "System.StackOverflowException" ist in mscorlib.dll aufgetreten." Geschieht in InitializeComponent().

    Dann haben wir auch die ItemSource per Button_Click Event zugewiesen mit dem Resultat, dass die Meldung kam, dass das Objekt (?) nicht existiert.

    Wenn der Code bei dir läuft, sind wir ziemlich ratlos.

    Danke


    Michael Lutz, BITsoft


    Donnerstag, 31. März 2011 20:20
  • Ich vermute, dass das Formular "frm_Kundenakte" heißt und der Code im
    Codebehind des Formulars steht. Mit der Instanziierung eines Objektes vom
    Typ des Formulars als Ressource wird dieser Prozess unendlich wiederholt und
    führt letztendlich zum Pufferüberlauf.
     
    Ich empfehle, die Anwendung sauber zu strukturieren und die Instanzen
    hierarchisch aufzubauen. Das bedeutet:
     
    1. Formular als XAML und, wenn wirklich Bedienlogik zu unterstützen ist,
    dann auch Code im CodeBehind.
     
    2. Klasse mit der Geschäftslogik, die von der Oberfläche instanziiert wird,
    z.B. als Ressource. Die Klasse stellt alle Eigenschaften bereit, die in der
    Oberfläche im XAML für Bindungen genutzt werden. Dabei ist zwischen
    Dateneigenschaften (für die Datenanzeige), Befehlseigenschaften (für
    Befehlsschaltflächen) und angehängten Eigenschaften (für Ereignisse der
    Steuerelemente der Oberfläche) zu unterscheiden.
     
    3. Klasse mit Code für die Datenbereitstellung, die von der Geschäftslogik
    instanziiert wird.
     
    --
    Viele Grüße
    Peter
     
     
    Freitag, 1. April 2011 03:55
  • Guten Morgen Peter

    >>Ich vermute, dass das Formular "frm_Kundenakte" heißt und der Code im
    Codebehind des Formulars steht. Mit der Instanziierung eines Objektes vom
    Typ des Formulars als Ressource wird dieser Prozess unendlich wiederholt und
    führt letztendlich zum Pufferüberlauf.<<
    Danke - ich hab das überprüft und das Formular wird von einem anderen Formular als Formvariable aufgerufen. Die Referenzierung im XAML-Code erfolgte erst, als wir das Beispiel ausprobieren wollten. Und das war auch eher eine Verzweifelungstat, da wir zunächst das Beispiel so umformten, dass wir die Zuweisung von Itemssource über einen Button oder bspw. über einen SelectedItemChanged Event eines verwendeten Tabcontrols umsetzen konnten.
    Zu Punkt 2: Ansonsten ist alles sauber strukturiert. Sämtliche Businesslogik und auch die Bedienerführung (Zustand von Buttons und Tabcontrols) wird strikt durch Databbinding geregelt. Die Anwendung ist schon sehr komplex und funktioniert auch sehr stabil. Punkt 3 ist ebenfalls penibel vom eigentlichen Formular getrennt. Insgesamt ist der Anteil des Codebehind minimal und enthält vor allem den Teil, um auf Bedienereingaben im DataGrid DetailRowView zu reagieren.
    Ich danke dir für deine Unterstützung. Vielleicht ist es dem Umstand geschuldet, dass uns noch wichtige Kenntnisse im Bezug auf WPF fehlen und wir dadurch die Funktionalitäten der löblichen WPF-Toolkit Initiativen nicht erschließen. Als VB.NET / WPF Nutzer stellt die Nutzung der vorhanden Beispiele erst mal eine große Einstiergshürde dar. 
    Sicherlich kann man es sehr kontrovers diskutieren was alles mit XAML und was mit Codebehind realisiert werden kann. Aber letztendlich waren wir nur auf der Suche nach einem simplen Beispiel, in dem ein Chartcontrol über Itemssource Balken oder Linien anzeigen soll. Als Datenquelle soll ein aus der Datenklasse übergebenes DataTable, respektive eine daraus gewandelte Collection fungieren. Eigentlich doch eine einfache Anforderung. Wie auch immer - aus Zeitdruck steigen wir hier aus dieser Sache aus. Die Kaufkomponente von Visifire kommt mit guter Dokumentation und auf Anhieb nachvollziehbaren Beispielen. Die Nutzung von ItemsSource, respektive DataSource über Codebehind funktionierte auf Anhieb.
    Nochmals vielen Dank für deine immanente Unterstützung!!! Gerne kommen wir an anderer Stelle darauf zurück. Auch versuchen wir mit unseren bescheidenen Kenntnissen hier im Forum den ein oder anderen Newbie zu unterstützen, der wie wir am Anfang steht und dem sich WPF und Dot.Net erst mal erschließen muss.
    viele Grüße

    Michael Lutz, BITsoft
    Freitag, 1. April 2011 05:44
  • Da Ihr Euch so die Zuweisung im CodeBehind wünscht, hier mal ein Beispiel:
     
    XAML:
     
    <Window x:Class="Window6"
        Title="Window6" Height="500" Width="1000"
        xmlns:chart="clr-namespace:System.Windows.Controls.DataVisualization.Charting;assembly=System.Windows.Controls.DataVisualization.Toolkit">
      <Grid>
        <TabControl >
          <TabControl.Items>
            <TabItem Name="tab_Results" FontSize="14" Header="Ergebnisse">
              <Grid Name="subgrid_Auswertung_Ergebnisse">
                <chart:Chart Name="Chart_1" Margin="109,61,245,30">
                  <chart:Chart.Series>
                    <chart:LineSeries Name="Serie1" Title="Erster Test"
                                  IndependentValueBinding="{Binding Month}"
                                  DependentValueBinding="{Binding Path=Tore}"/>
                  </chart:Chart.Series>
                </chart:Chart>
              </Grid>
            </TabItem>
          </TabControl.Items>
        </TabControl>
      </Grid>
    </Window>
     
    Dazu der CodeBehind:
     
    Imports System.Data
     
    Public Class Window6
     
      Private Sub Window6_Loaded(ByVal sender As Object, ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded
        BindData()
      End Sub
     
      Private Sub BindData()
        Dim dt As New DataTable
        With dt
          .TableName = "results"
          With .Columns
            .Add("Month", GetType(String))
            .Add("Tore", GetType(Integer))
          End With
          For i As Integer = 1 To 12
            Dim dr As DataRow = dt.NewRow
            dr.Item("Month") = "Monat " & i.ToString
            Select Case i
              Case 1, 3, 7, 9
                dr.Item("Tore") = 4
              Case 2, 4, 6, 10
                dr.Item("Tore") = 7
              Case Else
                dr.Item("Tore") = 8
            End Select
            dt.Rows.Add(dr)
          Next
        End With
        Me.Serie1.ItemsSource = (New CollectionViewSource With {.Source = dt}).View
      End Sub
     
    End Class
     
    --
    Viele Grüße
    Peter
    Freitag, 1. April 2011 17:41
  • hallo Peter - das hat jetzt super funktioniert! Vielen Dank und gute Woche.

     


    Michael Lutz, BITsoft
    Montag, 4. April 2011 11:42