Wie Objekttyp von Binding

Question

EDIT gehostet zu lesen: Ich Wortlaut geändert, hinzugefügt Code lange Probe mehr beschreibend sein

Ich brauche Typnamen des Objekts binden über Binding zu lesen.
Meine Methode akzeptiert BindingSource als Parameter und es weiß nicht über Objekttyp "gehostet" von BindingSource. Aber ich brauche diesen Objekttyp lesen

besser zu erklären, was ich meinte, nehme ich habe 2 Klassen

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; } 
} 

, als ich sie in Windows Forms bin mit Bindungsszenario:

 // 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()); 

Also, wie Sie bemerkt haben, ist dies Master-Detail-Bindung (bs1 ist an ein Gitter binden, bs2 an zweites) *

Also würde ich gerne lesen irgendwie Typ "gehostet" über BindingSou rce BS2 (Erwarteter Typ ist Liste < Parent>)

Methode muss ich werde sieht wie folgt schreiben:

Type GetBSType (BindingSource bs) 

Jede mögliche Hilfe schätzen ...

Answer 1

In .NET jedes Objekt erbt von System.Object, die eine Methode namens GetType() hat, der den Typ des Objekts zurückkehren wird - was Ihre erste Frage der Prüfung BS1

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

lösen

Die zweite Frage ist ein wenig unklar; Sie können dieselbe Methode verwenden, um den Typ == BindingSource von bs2.DataSource zu ermitteln (seit Sie ihn auf bs1 gesetzt haben). Sie können es dann von Object zurück in BindingSource umwandeln und dessen DataSource-Eigenschaft abfragen, um den zugrunde liegenden Typ zu ermitteln (im Wesentlichen dasselbe tun wie im obigen Beispiel, um den zugrunde liegenden Datenquellentyp von bs1 zu ermitteln).

Es ist alles verwickelt, weil Sie durch zwei Bindungsquellen graben, um den zugrunde liegenden Typ zu finden.

Konnte Sie möglicherweise bs2 entfernen, und nur bs1 verwenden, wie es von der externen Quelle erhalten wird? Wenn Sie bereits eine BindingSource empfangen, dann scheint es sehr merkwürdig, es in eine andere BindingSource zu verpacken.

Eine andere Möglichkeit wäre BS2 die Datasource BS1 Datasource zu setzen, anstatt sich bs`:

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

Answer 2

Sie auch nach einem Weg suchen kann, um genau die Art zu identifizieren.Um festzustellen, dass ein BindingSource bs ein DataSource hat, dass ein List<Parent> ist, würden Sie wie folgt vor:

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

Außerdem zu finden, wenn etwas von einer Art abgeleitet wird (oder dass etwas implementiert eine bestimmte Schnittstelle), Verwendung:

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

IsAssignableFrom gibt true zurück, wenn eine Variable mit dem übergebenen Typ kann MyFancyType in einer variablen vom Typ gespeichert werden. Zum Beispiel:

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

Würde immer wieder wahr und tun "etwas Nützliches". (Da Sie einen string Objektverweis in eine object Variable haften können)

Wo:

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

tun würde nie etwas "nützlich". (Sie können nicht eine generische object Objektreferenz in eine string Variable ... (zur Kompilierzeit oder ohne Besetzung) stick