Come faccio a generare dinamicamente colonne in un DataGrid di WPF?

Question

Sto tentando di visualizzare i risultati di una query in un datagrid WPF. Il tipo di elemento Items cui mi sto legando è IEnumerable<dynamic>. Poiché i campi restituiti non sono determinati fino al runtime, non conosco il tipo di dati fino a quando la query non viene valutata. Ogni "riga" viene restituita come ExpandoObject con proprietà dinamiche che rappresentano i campi.

Era mia speranza che AutoGenerateColumns (come di seguito) sarebbe in grado di generare colonne da un ExpandoObject come fa con un tipo statico ma non sembra.

<DataGrid AutoGenerateColumns="True" ItemsSource="{Binding Results}"/> 

Esiste comunque la possibilità di farlo in modo dichiarativo o devo agganciare imperativamente con qualche C#?

EDIT

Ok questo mi otterrà le colonne corrette:

// ExpandoObject implements IDictionary<string,object> 
IEnumerable<IDictionary<string, object>> rows = dataGrid1.ItemsSource.OfType<IDictionary<string, object>>(); 
IEnumerable<string> columns = rows.SelectMany(d => d.Keys).Distinct(StringComparer.OrdinalIgnoreCase); 
foreach (string s in columns) 
    dataGrid1.Columns.Add(new DataGridTextColumn { Header = s }); 

Così ora solo bisogno di capire come associare le colonne ai valori IDictionary.

Answer 1

definitiva avevo bisogno di fare due cose:

1. Generare il colonne manualmente dall'elenco di proprietà restituite dalla query
2. Impostazione di un oggetto DataBinding

Dopo che l'associazione dati incorporata è entrata in azione e ha funzionato correttamente e non sembra avere alcun problema a ottenere i valori delle proprietà fuori dallo ExpandoObject.

<DataGrid AutoGenerateColumns="False" ItemsSource="{Binding Results}" /> 

e

// Since there is no guarantee that all the ExpandoObjects have the 
// same set of properties, get the complete list of distinct property names 
// - this represents the list of columns 
var rows = dataGrid1.ItemsSource.OfType<IDictionary<string, object>>(); 
var columns = rows.SelectMany(d => d.Keys).Distinct(StringComparer.OrdinalIgnoreCase); 

foreach (string text in columns) 
{ 
    // now set up a column and binding for each property 
    var column = new DataGridTextColumn 
    { 
     Header = text, 
     Binding = new Binding(text) 
    }; 

    dataGrid1.Columns.Add(column); 
} 

Answer 2

Il problema è che il clr creerà colonne per ExpandoObject stesso, ma non è garantito che un gruppo di ExpandoObjects condivida le stesse proprietà tra loro, nessuna regola per il motore per sapere quali colonne devono essere create .

Forse qualcosa come i tipi anonimi di Linq funzionerebbe meglio per voi. Non so che tipo di datagrid stai usando, ma il binding dovrebbe essere identico per tutti loro. Ecco un semplice esempio per il datagrid telerik.
link to telerik forums

Questo non è in realtà veramente dinamico, i tipi devono essere noti al momento della compilazione - ma questo è un modo facile di impostare qualcosa di simile in fase di esecuzione.

Se davvero non hai idea di quale tipo di campi mostrerai il problema diventa un po 'più peloso. Le soluzioni possibili sono:

• Creazione di un mapping dei tipi in fase di esecuzione utilizzando Reflection.Emit, penso che sia possibile creare un convertitore di valore generico che avrebbe accettato i risultati della query, creare un nuovo tipo (e mantenere una lista memorizzata nella cache) e restituisce un elenco di oggetti. Creazione di un nuovo tipo dinamico seguirebbe lo stesso algoritmo già utilizzata per la creazione dei ExpandoObjects
  
  MSDN on Reflection.Emit
  An old but useful article on codeproject
  
  
• tramite il Dynamic LINQ - questo è probabilmente il modo più semplice più veloce per farlo.
  Using Dynamic Linq
  Getting around anonymous type headaches with dynamic linq

Con LINQ dinamica è possibile creare tipi anonimi utilizzando una stringa in fase di esecuzione - che è possibile assemblare dai risultati della query. Esempio di utilizzo dal secondo link:

var orders = db.Orders.Where("OrderDate > @0", DateTime.Now.AddDays(-30)).Select("new(OrderID, OrderDate)"); 

In ogni caso, l'idea di base è quella di impostare in qualche modo l'itemgrid a una collezione di oggetti la cui condiviso proprietà pubbliche può essere trovato dalla riflessione.

Answer 3

la mia risposta da Dynamic column binding in Xaml

ho usato un approccio che segue il modello di questo pseudocodice

columns = New DynamicTypeColumnList() 
columns.Add(New DynamicTypeColumn("Name", GetType(String))) 
dynamicType = DynamicTypeHelper.GetDynamicType(columns) 

DynamicTypeHelper.GetDynamicType() genera un tipo con proprietà semplici. Vedere this post per i dettagli su come generare un tale tipo

Quindi utilizzare effettivamente il tipo, fare qualcosa di simile

Dim rows as List(Of DynamicItem) 
Dim row As DynamicItem = CType(Activator.CreateInstance(dynamicType), DynamicItem) 
row("Name") = "Foo" 
rows.Add(row) 
dataGrid.DataContext = rows 

Answer 4

Anche se v'è una risposta accettata dal PO, utilizza AutoGenerateColumns="False" che non è esattamente quello che la domanda iniziale chiesto. Fortunatamente, può essere risolto anche con colonne generate automaticamente. La chiave per la soluzione è la DynamicObject che può avere proprietà statiche e dinamiche:

public class MyObject : DynamicObject, ICustomTypeDescriptor { 
    // The object can have "normal", usual properties if you need them: 
    public string Property1 { get; set; } 
    public int Property2 { get; set; } 

    public MyObject() { 
    } 

    public override IEnumerable<string> GetDynamicMemberNames() { 
    // in addition to the "normal" properties above, 
    // the object can have some dynamically generated properties 
    // whose list we return here: 
    return list_of_dynamic_property_names; 
    } 

    public override bool TryGetMember(GetMemberBinder binder, out object result) { 
    // for each dynamic property, we need to look up the actual value when asked: 
    if (<binder.Name is a correct name for your dynamic property>) { 
     result = <whatever data binder.Name means> 
     return true; 
    } 
    else { 
     result = null; 
     return false; 
    } 
    } 

    public override bool TrySetMember(SetMemberBinder binder, object value) { 
    // for each dynamic property, we need to store the actual value when asked: 
    if (<binder.Name is a correct name for your dynamic property>) { 
     <whatever storage binder.Name means> = value; 
     return true; 
    } 
    else 
     return false; 
    } 

    public PropertyDescriptorCollection GetProperties() { 
    // This is where we assemble *all* properties: 
    var collection = new List<PropertyDescriptor>(); 
    // here, we list all "standard" properties first: 
    foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(this, true)) 
     collection.Add(property); 
    // and dynamic ones second: 
    foreach (string name in GetDynamicMemberNames()) 
     collection.Add(new CustomPropertyDescriptor(name, typeof(property_type), typeof(MyObject))); 
    return new PropertyDescriptorCollection(collection.ToArray()); 
    } 

    public PropertyDescriptorCollection GetProperties(Attribute[] attributes) => TypeDescriptor.GetProperties(this, attributes, true); 
    public AttributeCollection GetAttributes() => TypeDescriptor.GetAttributes(this, true); 
    public string GetClassName() => TypeDescriptor.GetClassName(this, true); 
    public string GetComponentName() => TypeDescriptor.GetComponentName(this, true); 
    public TypeConverter GetConverter() => TypeDescriptor.GetConverter(this, true); 
    public EventDescriptor GetDefaultEvent() => TypeDescriptor.GetDefaultEvent(this, true); 
    public PropertyDescriptor GetDefaultProperty() => TypeDescriptor.GetDefaultProperty(this, true); 
    public object GetEditor(Type editorBaseType) => TypeDescriptor.GetEditor(this, editorBaseType, true); 
    public EventDescriptorCollection GetEvents() => TypeDescriptor.GetEvents(this, true); 
    public EventDescriptorCollection GetEvents(Attribute[] attributes) => TypeDescriptor.GetEvents(this, attributes, true); 
    public object GetPropertyOwner(PropertyDescriptor pd) => this; 
} 

Per l'ICustomTypeDescriptor implementazione, è possibile per lo più utilizzare le funzioni statiche di TypeDescriptor in modo banale. GetProperties() è quello che richiede un'implementazione reale: la lettura delle proprietà esistenti e l'aggiunta di quelle dinamiche.

Come PropertyDescriptor è astratta, si ha in possesso di questo:

public class CustomPropertyDescriptor : PropertyDescriptor { 
    private Type componentType; 

    public CustomPropertyDescriptor(string propertyName, Type componentType) 
    : base(propertyName, new Attribute[] { }) { 
    this.componentType = componentType; 
    } 

    public CustomPropertyDescriptor(string propertyName, Type componentType, Attribute[] attrs) 
    : base(propertyName, attrs) { 
    this.componentType = componentType; 
    } 

    public override bool IsReadOnly => false; 

    public override Type ComponentType => componentType; 
    public override Type PropertyType => typeof(property_type); 

    public override bool CanResetValue(object component) => true; 
    public override void ResetValue(object component) => SetValue(component, null); 

    public override bool ShouldSerializeValue(object component) => true; 

    public override object GetValue(object component) { 
    return ...; 
    } 

    public override void SetValue(object component, object value) { 
    ... 
    }