Auslesen einer DLL mit Reflection: Property einer Kindklasse wird falsch ausgewertet

[Saheeda]

Hallo,

ich habe folgende Hierarchie:

IModule

--- abstract ModuleForm

--------BasicCalculationForm

--------GeometryCalculationForm

In ModuleForm gibt es ein protected property Identifier.

BasicCalculation und GeometryCalculation werden aus einer gemeinsamen .dll ausgelesen:

            IList<ModuleForm> modules = new List<ModuleForm>();

            foreach (Assembly a in assemblies)

            {

                Type[] types = a.GetTypes();

                foreach (Type t in types)

                {

                    Type moduleClass = a.GetType(t.FullName);


                    Type[] interfaces = moduleClass.GetInterfaces();


                    if (interfaces.Contains(typeof(IModule)))

                    {


                        ModuleForm mod = Activator.CreateInstance(moduleClass) as ModuleForm;

                        modules.Add(mod);

                    }

                }

            }

Wenn ich mir hier alle Identifier der modules-Liste ausgeben lasse, erhalte ich immer "ModuleForm" Lasse ich allerding Basic... und Geometry... direkt IModule implementieren und die Definition von Identifier ins IModule-Interface verschiebe, bekomme ich die Ausgabe "Basic...", "Geometry...".

IList<IModule> modules = new List<IModule>();

            foreach (Assembly a in assemblies)

            {

                Type[] types = a.GetTypes();

                foreach (Type t in types)

                {

                    Type moduleClass = a.GetType(t.FullName);


                    Type[] interfaces = moduleClass.GetInterfaces();


                    if (interfaces.Contains(typeof(IModule)))

                    {


                        IModule mod = Activator.CreateInstance(moduleClass) as IModule;

                        modules.Add(mod);

                    }

                }

            }

 public interface IModule

    {

        string Identifier { get; }


        void Load();

    }

public abstract class ModuleForm : IModule

    {  

         ...

        public string Identifier

        {

            get {return "ModuleForm"; }

        }

    }

//geht

 public class BaseCalculationForm : ModuleForm, IModule

//geht nicht

 public class BaseCalculationForm : ModuleForm

    {

        private string _identifier;


        public string Identifier

        {

            get { return this._identifier; }

        }  


        public BaseCalculationForm()

        {

            this.options = new string[] { "Add", "Sub", "Multi", "Div" };

            this._identifier = "Grundrechenarten";

        }     

    }

Ich kann jetzt nicht so ganz nachvollziehen, warum ich mit dem Interface als oberster Klasse die richtigen Werte bekomme, mit der Abstrakten Klasse aber nicht :confused:

Ich dachte ja zunächst, dass vielleicht die Vererbung über 2 Generationen nicht so funktioniert, wie ich das will und habe mir testweise ne Grandpa-Parent-Child-Konstruktion gebastelt und in eine List<Grandpa> gepackt, aber auch hier bekomme ich alle richtigen Werte zurück.

[SilentDemise]

public abstract class ModuleForm : IModule

    {  

         ...

        public string Identifier

        {

            get {return "ModuleForm"; }

        }

    }

naja, hier sagst du ihm ja auch, er soll dir das zurückgeben? O.o

Ganz davon ab: ich verstehe deine Strategie hier aber auch nicht. Warum brauchst du ein Interface, eine abstract class und 2 weitere classes in einer Vererbungsstruktur? Das sieht schon nach nem code smell aus.

(=> composition over inheritance)

Zu deinem ersten Codeschnippsel:

Du prüfst hier auf: if (interfaces.Contains(typeof(IModule)))

wo vererbst du denn, wenn nicht in der abstract class? Was steht dann im Interface drin?

[Saheeda]

Hallo,

naja, ich würde erwarten das Property der Kindklasse zurück zu bekommen, nicht der abstrakten Elternklasse.

Ich weiß, dass das ganze nicht zoll ist, habe im Moment aber keine bessere Idee.

Ich brauche das Interface, um gewisse Methoden in jedem Modul garantieren zu können, deren Implementierung aber je nach Modul anders sein kann.

Die abstrakte Klasse ist mehr n Helper. Es gib ein-zwei Methoden, welche alle Module mit gleicher Implementierung haben.

Hintergrund ist ne Hausaufgabe. Wir sollen x Module auf einen gemeinsamen Nenner bringen / eine Schnittstelle schaffen, die eigentlich nix gemeinsam haben. Außer dass sie mal im selben Programm laufen werden.

Ich setz mich heut nochmal dran und versuch was hübscheres zu finden.