Comment lire type d'objet hébergé par BindingSource

Question

EDIT: J'ai changé libellé, ajoutée à long exemple de code pour être plus descriptif

Je dois lire le nom du type de liaison objet via BindingSource.
Ma méthode accepte BindingSource comme paramètre et ignore le type d'objet 'hébergé' par BindingSource. Mais je dois lire ce type d'objet

Pour mieux expliquer ce que je voulais dire, suppose que j'ai 2 classes

class Person { 
    public string Name { get; set; } 
    public List<Parent> Parents { get; set; } 

} 
class Parent { 
    public string Name { get; set; } 
    public int ChildrenCount { get; set; } 
} 

Que je les utiliser dans le scénario de liaison Windows Forms:

 // Create Person List 
     List<Person> Persons = new List<Person>(); 

     // add Sample data 
     Persons.Add(new Person() { Name = "Person_1" }); 
     Persons.Add(new Person() { Name = "Person_2" }); 
     Persons[0].Parents = new List<Parent>(); 
     Persons[0].Parents.Add(new Parent() { Name = "Father_1", ChildrenCount = 2 }); 
     Persons[0].Parents.Add(new Parent() { Name = "Mother_1", ChildrenCount = 2 }); 
     Persons[1].Parents = new List<Parent>(); 
     Persons[1].Parents.Add(new Parent() { Name = "Father_2", ChildrenCount = 1 }); 
     Persons[1].Parents.Add(new Parent() { Name = "Mother_2", ChildrenCount = 1 }); 


     // create binding sources 
     BindingSource bs1 = new BindingSource(Persons, null); 
     BindingSource bs2 = new BindingSource(bs1, "Parents"); 

     // bind to grid 
     dataGridView1.DataSource = bs1; 
     dataGridView2.DataSource = bs2; 


     // **************************************** 
     // ****** Read type 'hosted' by BS ******** 
     // **************************************** 
     // BS1 - Expected: System.Collections.Generic.List`1[Person] 
     // That's easy... 
     Console.WriteLine("type bind to BS1=" + bs1.DataSource.GetType()); 

     // BS2 - Expected: System.Collections.Generic.List`1[Person] 
     // HOW TO READ THAT ??!! 

     // this returns BindingSource type 
     Console.WriteLine("type bind to BS2=" + bs2.DataSource.GetType()); 
     // this returns: System.Collections.Generic.List`1[Person] (I need List<Parents> or Person.List<Parents>" 
     Console.WriteLine("type bind to BS2=" + (bs2.DataSource as BindingSource).DataSource.GetType()); 

Donc, comme vous l'avez remarqué, il s'agit de la liaison maître-détail (bs1 est lié à une grille, bs2 à la seconde) *

Donc, je voudrais lire en quelque sorte le type «hébergé» via bindingSou rce BS2 (Type attendu est Liste < Parent>)

Méthode que je dois écrire Shall regarde comme suit:

Type GetBSType (BindingSource bs) 

apprécierais toute aide ...

Answer 1

Dans .NET chaque objet hérite de System.Object, qui a une méthode nommée GetType() qui renverra le type de l'objet - qui peut résoudre votre première question des tests BS1

Type bs1DataType = bs1.DataSource.GetType(); 
string bs1DataTypeName = bs1DataType.Name; 

La deuxième question est un peu floue; vous pouvez utiliser la même méthode pour déterminer le type de bs2.DataSource == BindingSource (puisque vous l'avez défini sur bs1). Vous pouvez ensuite le convertir depuis Object vers BindingSource et interroger sa propriété DataSource pour déterminer le type sous-jacent (Essentiellement, faire la même chose que l'exemple ci-dessus pour déterminer le type de source de données sous-jacente de bs1). Tout est compliqué car vous explorez deux sources de liaison pour trouver le type sous-jacent.

---

Pouvez-vous retirer éventuellement BS2, et il suffit d'utiliser BS1 comme il est reçu de la source externe? Si vous recevez déjà un BindingSource, l'emballer dans un autre BindingSource semble très étrange.

Une autre option serait de mettre DataSource BS2 à DataSource BS1, plutôt que de se bs`:

// This is essentially binding bs2 to the underlying List<Person> 
bs2.DataSource = bs1.DataSource; 

Answer 2

Vous pouvez également être à la recherche d'un moyen d'identifier précisément le type.Pour déterminer qu'un BindingSource bs a une DataSource qui est un List<Parent>, vous procédez comme suit:

if (bs.DataSource.GetType() == typeof(List<Parent>)) 
{ 
    //Do something useful 
} 

De plus, pour trouver si quelque chose est dérivé d'un type (ou que quelque chose implémente une interface spécifique), utilisez:

if (typeof(MyFancyType).IsAssignableFrom(bs.DataSource.GetType())) 
{ 
    //Do something useful 
} 

IsAssignableFrom renvoie true si une variable du type passé peut être stocké dans une variable de type MyFancyType. Par exemple:

if (typeof(object).IsAssignableFrom(typeof(string))) 
{ 
    //Do something useful 
} 

Retourne toujours vrai et fait "quelque chose d'utile". (Parce que vous pouvez coller une référence d'objet string dans une variable object)

Où:

if (typeof(string).IsAssignableFrom(typeof(object))) 
{ 
    //Do something useful 
} 

ne ferait jamais rien "utile". (vous ne pouvez pas coller une référence d'objet générique object dans une variable string ... (au moment de la compilation ou sans lancer)