Modularisierung eine C # Compact Framework 2.0 Anwendung

Question

Wir haben zur Zeit ein neues Stück von Handheld-Software zu entwickeln. Ich kann nicht die Art der Anwendung diskutieren, also werde ich ein Beispiel stattdessen verwenden.

Wir entwerfen Handheld-Software eine Schule für die Verwaltung. Wir wollen jeden Aspekt des Systems modularisieren, so dass verschiedene Schulen unterschiedliche Funktionen verwenden können.

Unser System wird mit einem Hauptmenü und einem Login-Bildschirm starten. Ich möchte das die Basis des Systems sein und geben, in denen die Module hinzugefügt werden wird. D. h Ich werde ein Projekt namens SchoolPda.

Ich möchte dann verschiedene Module haben. Das heißt, ich möchte ein Registrierungsmodul, das Schüler-Registrierungen behandelt. Ich möchte ein Klassenmodul Klassenzimmer Sauberkeit für die Verwaltung, etc.

So wie ich möglicherweise diese Arbeits sehen würde ist mit / ohne verschiedene DLLs ist und das Hauptmenü des Basissystems Tasten aussetzen, um diese Module zugreifen, wenn die DLLs vorhanden sind. Das ist genau die Art von Dingen, die wir suchen.

Hat jemand eine Erfahrung hat so etwas wie dies zu tun? Was wäre der beste Weg, es zu tun? Wir brauchen nicht über die Datenbank zur Sorge, da die Datenbank immer die vollständige Datenbank sein wird, aber Aspekte werden nicht aufgefüllt bekommen, wenn die zugehörigen Module sind nicht vorhanden.

Answer 1

Ich habe in Projekten, dass es zwei Möglichkeiten haben:

• In einem Projekt, das wir bereitstellen nicht bestimmten DLLs, wenn die Kunden nicht genehmigt wurden. Das ist, was Sie vorschlagen. Es hat gut funktioniert. Natürlich gab es keine Möglichkeit, diese Module ohne zusätzliche installieren zu können, aber es machte durchaus Sinn für diese App.

• In einem anderen Projekt haben wir alles im Einsatz und nur zu den Endnutzern die Menüs ausgesetzt, Knöpfe, usw., für die der Kunde lizenziert wurde. Wir taten das, weil dann könnte der Benutzer leicht Add-on ein zusätzliches Modul durch eine Lizenz für sie hinzufügen. Wenn die Lizenz hinzugefügt wurde, zeigte das Material auf magische Weise bei der nächsten Anmeldung auf.

Also in meiner Erfahrung, ich würde Blick auf Ihrem Lizenzmodell sagt als ein großes Stück Ihrer Entscheidung. Denken Sie darüber nach, ob Sie jemals diese zusätzlichen Module im laufenden Betrieb hinzufügen möchten.

Answer 2

Ich bin derzeit auch die Entwicklung eine Anwendung, die sowohl auf Compact und Full Rahmen verläuft und modular aufgebaut.

So wie ich es implementiert ist, dass es einen Ort für DLL durchsucht und enummerates über jeden Typ und sieht, wenn sie eine „ScreenInfoAttribute“ oder „WidgetInfoAttribute“ definiert haben, die nützliche Informationen über die Klasse enthält.

Hier ist ein Ausschnitt, es enthält 3,5-Code, aber das ist, weil wir vor kurzem den Schalter von 2,0 gemacht, aber das Prinzip funktioniert in 2.0

public void Analyze(FileInfo file) {
        Assembly asm = Assembly.LoadFrom(file.FullName);
        List<Data.AnyPlugin> types = GetPluginTypes(asm.GetTypes());

        if (types.Count > 0) {
            types.ForEach(x => x.AssemblyPath = file.FullName);
            if (_plugins.ContainsKey(file.FullName)) {
                _plugins[file.FullName].Plugins.AddRange(types);
            } else {
                AssemblyPlugin asp = new AssemblyPlugin();
                asp.Ass = asm;
                asp.Plugins = types;
                _plugins.Add(file.FullName, asp);
            }
        }
    }

    private List<Data.AnyPlugin> GetPluginTypes(Type[] types) {
        List<Data.AnyPlugin> returnTypes = new List<AnyPlugin>();
        foreach (Type t in types) {
            Data.AnyPlugin st = GetPluginType(t);
            if (st != null) returnTypes.Add(st);
        }
        return returnTypes;
    }

    private Data.AnyPlugin GetPluginType(Type type) {
        if (type.IsSubclassOf(typeof(Screens.bScreen<T>))) {
            Screens.ScreenInfoAttribute s = GetScreenAttrib(type);
            if (s != null) {
                return new Data.ScreenPlugin("", type, s);
            }
        } else if (type.IsSubclassOf(typeof(Widgets.bWidget<T>))) {
            Widgets.WidgetInfoAttribute w = GetWidgetAttrib(type);
            if (w != null) return new Data.WidgetPlugin("", type, w);
        }
        return null;
    }

    private Screens.ScreenInfoAttribute GetScreenAttrib(Type t) {
        Attribute a = Attribute.GetCustomAttribute(t, typeof(Screens.ScreenInfoAttribute));
        return (Screens.ScreenInfoAttribute)a;
    }

Answer 3

Ich weiß nicht, ob es auf der CLR arbeiten werde aber einen Blick auf MEF , für eine Art und Weise zu entdecken und laden Sie Ihre dlls / Module zu schaffen. Sie könnten auch haben Ihre Module eine GetMenuItem Methode (oder etwas so vom Schlage), die die Informationen, damit Ihr Hauptmenü erforderlich wird eine Schaltfläche hinzufügen kann.

Offensichtlich ein anderes Design für das Hauptmenü, wenn es sinnvoll ist, aber Sie wollen es wirklich beide, modularisierten und ausfahrbar sein, so dass Sie Ihren Kern schreiben können, und in der Zukunft weiterhin neue Komponenten schreiben, ohne dass Sie Kern ändern.

Es tut mir leid, wenn dies nicht die größte Menge an Sinn macht. Nur hoffte man eine Idee in eine Richtung zu geben.

Answer 4

Lassen Sie einfach jedes Modul eine gemeinsame Schnittstelle implementieren. In Methoden wie GetButtons () oder GetActions ().

Sie können dann legen Infomationen über die Assembly und den Klassennamen in einem Config - Datei. Nun ist es einfach, die angegebenen Assembly und erstellen Sie eine Instanz der Klasse mit Activator.CreateInstance, warf es zu Ihrer Schnittstelle und rufen Sie die GetButtons () usw. Methoden zu laden.