WPF DataGrid - Enlace a la colección de 'celdas'

Estoy tratando de descubrir cómo vincular la fuente de datos de un DataGrid a una ObservableCollection de 'celdas'. En particular, tengo un ObservableCollection que contiene instancias de la siguiente clase:

public class Option : INotifyPropertyChanged
{
    public Option()
    {
    }

    // +-+- Static Information +-+-
    public double spread = 0;        
    public double strike = 0;        
    public int daysToExpiry = 0;
    public int put_call; // 0 = Call, 1 = Put

    // Ticker References
    public string fullTicker = "";
    public string underlyingTicker = "";

    //+-+-Properties used in Event Handlers+-+-//
    private double price = 0;
    public double Price
    {
        get { return price; }
        set
        {
            price = value; 
            NotifyPropertyChanged("Price");
        }
    }

    //+-+-+-+- Propoerty Changed Event & Hander +-+-+-+-+-//
    public event PropertyChangedEventHandler PropertyChanged;

    private void NotifyPropertyChanged(string info)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(info));
        }
    }
}

En mi DataGrid, quiero mostrar estas clases (estoy usando TemplateColumns, el precio y las variables 'tachar' en cada celda) de modo que estén agrupadas por "subyacenteTicker" [que es una cadena de 4 caracteres] y por "spread" [que toma 1 de 6 valores posibles definidos en la codificación de fondo].

Actualmente, cuando vinculo el DataContext de DataGrid a ObservableCollection, muestra cada 'Opción' como una fila, y no puedo averiguar cómo especificar en qué agrupar los pares...

Así es como se ve mi cuadrícula de datos ahora: enter image description here

¡Muchas gracias, kcross!

preguntado el 02 de mayo de 12 a las 19:05

¿Cómo se ve el ItemSource={Binding ...} de su DataGrid, así como al menos una muestra de código de su columna y es vinculante? Además, ¿qué quiere decir exactamente con: "y no puedo averiguar cómo especificar en qué agrupar los pares" -

1 Respuestas

Al igual que Dtex, no entiendo del todo lo que quieres hacer. Pero traté de hacer una simplificación que, con suerte, lo ayudará a comenzar. Tienes que pasar el DataGridan IEnumerable(preferiblemente un ObserrvableCollection) de objetos. Los objetos individuales se traducirán a filas, las propiedades de estos objetos se traducirán a los encabezados de columna.

Entonces, si desea que los encabezados de las columnas representen múltiplos de la desviación estándar (¿no?), tendrá que crear un objeto que tenga estos múltiplos como propiedades. Las celdas resultantes contendrán el Option clases Para representarlos, deberá definir un DataTemplate o anular la función ToString(). Creo que hiciste lo primero a juzgar por tu ejemplo.

El código detrás:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.ComponentModel;
using System.Collections.ObjectModel;
namespace DataGridSpike
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        private List<Option> _unsortedOptions;
        private ObservableCollection<OptionRow> _groupedOptions;

        public ObservableCollection<OptionRow> GroupedOptions
        {
            get { return _groupedOptions; }
            set { _groupedOptions = value; }
        }

        public MainWindow()
        {
            var rnd=new Random();
            InitializeComponent();

            //Generate some random data
            _unsortedOptions=new List<Option>();
            for(int element=0;element<50;element++)
            {
                double column=rnd.Next(-2,3);
                int row=rnd.Next(0,9);

                _unsortedOptions.Add(new Option { ColumnDefiningValue = column, RowDefiningValue = row });
            }

            //Prepare the data for the DataGrid
            //group and sort
            var rows = from option in _unsortedOptions
                       orderby option.ColumnDefiningValue
                       group option by option.RowDefiningValue into optionRow
                       orderby optionRow.Key ascending
                       select optionRow;

            //convert to ObservableCollection
            _groupedOptions = new ObservableCollection<OptionRow>();
            foreach (var groupedOptionRow in rows)
            {
                var groupedRow = new OptionRow(groupedOptionRow);
                _groupedOptions.Add(groupedRow);
            }

            //bind the ObservableCollection to the DataGrid
            DataContext = GroupedOptions;
        }
    }

    public class OptionRow
    {
        private List<Option> _options;

        public OptionRow(IEnumerable<Option> options)
        {
            _options = options.ToList();
        }

        public Option Minus2
        {
            get
            {
                return (from option in _options
                       where option.ColumnDefiningValue == -2
                       select option).FirstOrDefault();
            }
        }
        public Option Minus1
        {
            get
            {
                return (from option in _options
                        where option.ColumnDefiningValue == -1
                        select option).FirstOrDefault();
            }
        }
        public Option Zero
        {
            get
            {
                return (from option in _options
                        where option.ColumnDefiningValue == 0
                        select option).FirstOrDefault();
            }
        }
        public Option Plus1
        {
            get
            {
                return (from option in _options
                        where option.ColumnDefiningValue == 1
                        select option).FirstOrDefault();
            }
        }
        public Option Plus2
        {
            get
            {
                return (from option in _options
                        where option.ColumnDefiningValue == 2
                        select option).FirstOrDefault();
            }
        }
    }

    public class Option:INotifyPropertyChanged
    {

        public override string ToString()
        {
            return string.Format("{0}-{1}", RowDefiningValue.ToString(),ColumnDefiningValue.ToString());
        }

        private double _columnDefiningValue;
        public double ColumnDefiningValue
        {
            get{return _columnDefiningValue;}
            set{_columnDefiningValue = value;
                OnPropertyChanged("ColumndDefiningValue");
            }
        }

        private int _rowDefiningValue;
        public int RowDefiningValue
        {
            get{return _rowDefiningValue;}
            set{_rowDefiningValue = value;
                OnPropertyChanged("RowDefiningValue");
            }
        }

        private void OnPropertyChanged(string propertyName)
        {
            if (PropertyChanged!=null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;
    }
}

El XAML:

<Window x:Class="DataGridSpike.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <DataGrid ItemsSource="{Binding}"/>
    </Grid>
</Window>

contestado el 05 de mayo de 12 a las 07:05

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.