[C#] Plugins en data

[st0p]

Ik zit met het volgende probleem: In mijn applicatie maak ik gebruik van plugins. Een plugin is gewoon een klasse die erft van een klasse Plugin. Bij het opstarten loop ik alle plugins in de plugin-folder af om te kijken welke plugins er aanwezig zijn. Deze worden door middel van reflection bekeken om te kijken welke public variabelen ze hebben. Deze informatie gebruik ik voor het automatisch genereren van een Form waarmee je de variabelen kan beinvloeden en voor (de nog te implementeren) scripting engine.

Aangezien ik bepaalde metadata nodig heb (minimum waarde, maximum waarde bijvoorbeeld) gebruik ik hiervoor geen standaard .Net datatypen, maar zelf gebakken klasses. Hieronder een deel van de huidige implementatie:

code:

    public class ARFloat : ARBaseVar, IVarFloat {
        private float min = -500;
        private float max = 500;
        private float inc = 1;
        private float val = 0;
        public bool Loop = false;

        public ARFloat() { }
        public ARFloat(float v) { Value = v; }

        public void SetAttributes(string n, float mi, float ma, float i) {
            name = n;
            min = mi;
            max = ma;
            inc = i;
        }

        public float Value {
            get { return val; }
            set {
                if (value >= min && value <= max)
                    val = value;
                else if (Loop) {
                    if (value < min) {
                        val = max;
                    } else {
                        val = min;
                    }
                }
            }
        }

        public override System.Windows.Forms.UserControl GetControl() {
            return ARVarGuiFactory.GetUserControl(this);
        }

        public float Min { get { return min; } }
        public float Max { get { return max; } }
        public float Inc { get { return inc; } }

        public override string ToXml(bool enclose) {
            return "<ARFloat loop=\"" + Loop + "\">" + val.ToString() + "</ARFloat>\r\n";
            
        }

        public override void FromXml(XmlReader reader) {
            PresetLoader.LoadARVar(this, reader);
        }
    }

    public class ARFloat2 : ARBaseVar, IVarFloat {
        protected ARFloat x;
        protected ARFloat y;

        public ARFloat2() {
            x = new ARFloat();
            y = new ARFloat();
        }

        public ARFloat2(float xx, float yy) {
            x = new ARFloat(xx);
            y = new ARFloat(yy);
        }

        public void Set(float xx, float yy) {
            this.x.Value = xx;
            this.y.Value = yy;
        }

        public virtual void SetAttributes(string n, float mi, float ma, float i) {
            this.name = n;
            x.SetAttributes(name, mi, ma, i);
            y.SetAttributes(name, mi, ma, i);
        }

        public ARFloat X { get { return x; } set { x = value; } }
        public ARFloat Y { get { return y; } set { y = value; } }

        public override System.Windows.Forms.UserControl GetControl() {
            return ARVarGuiFactory.GetUserControl(this);
        }

        public float Min { get { return x.Min; } }
        public float Max { get { return x.Max; } }
        public float Inc { get { return x.Inc; } }

        public override string ToXml(bool enclose) {
            string ret = x.ToXml(false) + y.ToXml(false);
            if (enclose)
                return "<ARFloat2>\r\n" + ret + "</ARFloat2>\r\n";
            else
                return ret;
        }

        public virtual bool Loop {
            set {
                x.Loop = value;
                y.Loop = value;
            }
        }

        public override void FromXml(XmlReader reader) {
            PresetLoader.LoadARVar(this, reader);
        }
    }

    public class ARFloat3 : ARFloat2, IVarFloat {
        protected ARFloat z;
        public ARFloat3()
            : base() {
            z = new ARFloat();
        }
        public ARFloat3(float xx, float yy, float zz)
            : base(xx, yy) {
            z = new ARFloat(zz);
        }

        public void Set(float xx, float yy, float zz) {
            base.Set(xx, yy);
            this.z.Value = zz;
        }

        public override void SetAttributes(string n, float mi, float ma, float i) {
            base.SetAttributes(n, mi, ma, i);
            z.SetAttributes(n, mi, ma, i);
        }

        public ARFloat Z { get { return z; } set { z = value; } }

        public Vector3 ToVector3() {
            return new Vector3(this.x.Value, this.y.Value, this.Z.Value);
        }

        public override System.Windows.Forms.UserControl GetControl() {
            return ARVarGuiFactory.GetUserControl(this);
        }

        public override string ToXml(bool enclose) {
            string ret = base.ToXml(false) + z.ToXml(false);
            if (enclose)
                return "<ARFloat3>\r\n" + ret + "</ARFloat3>\r\n";
            else
                return ret;
        }

        public override void FromXml(XmlReader reader) {
            PresetLoader.LoadARVar(this, reader);
        }

        public override bool Loop {
            set {
                base.Loop = value;
                z.Loop = value;
            }
        }
    }

om vervolgens deze klassen te gebruiken in de plugin gebruik je de volgende code:

code:

class PluginDing : Plugin {
        //[ARFloatAttribute("Naam in Form", min, max, increment)]
        [ARFloatAttribute("Size", -1000f, 1000f, 0.2f)]
        public ARFloat2 size;
        [ARIntAttribute("Texture", 0, 63, 1)]
        public ARInt Texture;

        public PluginDing() {
             //initialiseer shit...
        }

       public void DoeIets() {
            //doe nuttige shit
       }
}

Op zich werkt dit, maar er zitten wel wat scherpe kantjes aan. Ten eerste heb ik ook nog ARFloat4 en ARFloat5 klassen, daarnaast heb ik ook nog integers. Oftewel ik heb nog 5 klassen waarin ik dmv zoeken en vervangen alle floats door ints vervang. Dat is niet volgens de regel Do Not Repeat Yourself. Ook moet ik dus om nieuwe functionaliteit toe te voegen 10 klassen aanpassen.

Het eerste idee was om generics te gebruiken (dan zou ik iig de helft van het aantal klasses overhouden), maar dat kan omdat het niet mogelijk is om met Generics te rekenen. Het toevoegen van een IArithmetic interface aan het .net framework zou dit oplossen (zie bijvoorbeeld dit artikel) en het schijnt dat in op dit moment hiernaar gekeken wordt voor de 4.0 release. Maar daar ga ik natuurlijk niet op wachten.

Heeft iemand suggesties over hoe ik dit beter zou kunnen implementeren?

[Haan]

st0p schreef op zondag 01 juni 2008 @ 17:18:
Aangezien ik bepaalde metadata nodig heb (minimum waarde, maximum waarde bijvoorbeeld) gebruik ik hiervoor geen standaard .Net datatypen, maar zelf gebakken klasses.

Heeft iemand suggesties over hoe ik dit beter zou kunnen implementeren?

Zijn hiervoor geen structures uitgevonden?

[st0p]

Je hebt op zich gelijk dat deze klasses misschien beter structs zouden kunnen zijn, maar dat doet toch niets af aan de explosie van verschillende klasses/structs?

[whoami]

Kan je niet zelf een interface schrijven, waarin je het 'contract' vastlegt waaraan jouw eigen classes moeten voldoen ?
Dan kan je met generics werken, en afdwingen dat het generic type jouw interface moet implementeren.

Haan schreef op zondag 01 juni 2008 @ 17:40:
[...]

Zijn hiervoor geen structures uitgevonden?

Hoe is dit een oplossing voor het probleem ?

[Haan]

whoami schreef op zondag 01 juni 2008 @ 17:48:

Hoe is dit een oplossing voor het probleem ?

Ik had niet helemaal goed gelezen wat het werkelijke probleem was, ik zat alleen naar de voorbeeld code te kijken..

[st0p]

Bedoel je iets als:

code:

interface ICalculate<T> {
    T Add(T t1, T t2);
    T Sub(T t1, T t2);
    T Div(T t1, T t2);
    T Mul(T t1, T t2);
}

Nadeel hiervan vind ik zelf dat je de gewone operatoren (+, -, *, /) niet meer kan gebruiken, aangezien ik het gebruik ervan zo transparant mogelijk wil houden. Ik heb ook nog gekeken of ik operator overloading in een interface kon opnemen maar aangezien deze overloads static zijn kan ik ze niet in een interface knallen.

[whoami]

Dat is idd een (klein) nadeel , maar het zorgt er wellicht wel voor dat je veel code kunt weggooien ....
't Is aan jou om de voor- en nadelen tov elkaar af te wegen ...

[st0p]

yep, ik zit er zelf ook al even over te filosoferen maar waarschijnlijk is het de beste oplossing. Volgens mij zou ik als ik de classes ook nog static operator overloads geef binnen de plugins zelf ook nog gewoon +, -, / en * kunnen gebruiken. Dat betekend dat ik alleen in de generieke klassen zelf gebruik hoef te maken van de interface.

[compufreak88]

Wat je kan doen is een basisklasse maken die de interface implementeert, inclusief de operatoroverloads. De rest van de classes erven hiervan dan over. Als je de operatoroverloads dan MustInherrit maakt, dan krijg je hetzelfde idee.

[whoami]

Volgens mij kan je geen abstract operators definieren.
Indien het wel zou kunnen, dan kan je natuurlijk gewoon een abstract class maken, met daarin abstract operator overloads, en dan kan je die interface meteen weglaten.
Maar, ik ben 99% zeker dat je geen abstract operators kunt definieren ...

[Verwijderd]

Kan je niet van Linq's expression tree's gebruik maken.
http://www.google.nl/sear...on+tree&btnG=Zoeken&meta=

[D-Raven]

Op zich voegt het volgende niks toe aan de discussie, en zal zeker niet je probleem oplossen (of wel, hangt af van hoe je er tegen aan kijken).
Maar heb je al eens gekeken naar het Managed AddIn framework? Het is geen eenvoudige materie maar misschien verschaft het je met nieuwe inzichten. Wat altijd goed is natuurlijk
Link naar blogpost:
http://www.danielmoth.com/Blog/2008/02/maf-screencasts.html

Overigens is dit geen verkapte flame naar je plugin implementatie. Zie het gewoon als ter informatie.

[st0p]

@Compufreak88: Ik heb het geprobeerd maar de compiler vindt dat idd niet goed...

@Menno_bakker: Ik zie zeker wel voordelen van je methode (en er is een stuk in mijn applicatie waar functioneel programeren denk ik zeker voordeel heeft, los daarvan is het iets waar ik me sowieso wat meer in wil verdiepen), dus ik ga daar zeker nog verder naar kijken, maar ik heb het gevoel dat het in dit geval geen toegevoegde waarde heeft (correct me if i'm wrong)

@Deathraven: Ik ga die screencasts bekijken (gisteravond werkten ze niet) en als je verkapte flames op mijn oplossing hebt, dan hoor ik het graag!

edit:

Ik heb de 1e screencast zojuist bekeken maar ik ben weinig onder de indruk. Er zitten maar 2 dingen in waarvan ik denk "ja, dat biedt voordeel ten opzichte van wat ik nu heb!"
1) Garbage collection als je dingen in een ander AppDomain laad (maar ik laad niks in een ander AppDomain)
2) Een iets striktere scheiding tussen host en plugin, vanwege de 2 interfaces (architectureel wel een klein voordeel maar ik vind de wildgroei aan klassen die dat oplevert (ook al zijn ze gegenereerd) minder fraai)

@whoami: Ik ben aan het kijken naar de oplossing zoals jij hebt hem aangedragen maar ik heb hem nog niet werkend. Als dat gelukt is zal ik hem hier posten.

[ Voor 36% gewijzigd door st0p op 03-06-2008 20:33 ]

[H!GHGuY]

C#:

public class MyPlugin : Plugin
{
   [MaxValue(500)]
   [MinValue(0)]
   public int Property { get; set; }
}

of [Bounds(0,500)]

of
public int Property
{
   get {return property; }
   set { if (value < 0 || value > 500) throw new ArgumentException(); property = value;
}

[whoami]

Euh ..... En wat wil je hiermee zeggen H!GHGuy ?

[H!GHGuY]

Je kan toch gewoon MaxValue en MinValue of Bounds attributen gebruiken ?
Gebruik dan ook meteen het feit dat bepaalde conversies impliciet gebeuren en gebruik meteen het meest geschikte type.

Of gebruik gewoon excepties en vang die op.
Het gaat over een at runtime gegenereerde GUI, dan is een SetXXX functie die die exceptie opvangt en een mooie error returned niet meer dan normaal.

[DrDelete]

H!GHGuY schreef op dinsdag 03 juni 2008 @ 22:20:

C#:

public class MyPlugin : Plugin
{
   [MaxValue(500)]
   [MinValue(0)]
   public int Property { get; set; }
}

of [Bounds(0,500)]

of
public int Property
{
   get {return property; }
   set { if (value < 0 || value > 500) throw new ArgumentException(); property = value;
}

dat laatste zou ik niet zo snel doen : als programmeur verwacht je geen exceptions bij getters en setters, veelal zou ik de waarde van "value" laten controleren door een constructor initializer en alleen getter overhouden (geen setter meer).

[st0p]

@Highguy: Dat is toch de implementatie zoals ik hem nu heb? Ik gebruik al attributes om min/max te bepalen. In mijn geval is een datatype geen plugin, maar stelt de plugin datatypes zoals jij beschrijft beschikbaar.

[Sebazzz]

DrDelete schreef op woensdag 04 juni 2008 @ 07:49:
[...]


dat laatste zou ik niet zo snel doen : als programmeur verwacht je geen exceptions bij getters en setters

Waarom niet? Het is iets wat je constant ziet in het .NET framework.

[DrDelete]

Sebazzz schreef op woensdag 04 juni 2008 @ 08:22:
[...]

Waarom niet? Het is iets wat je constant ziet in het .NET framework.

De guideline betreft vooral getters, bij setters zou het wel mogen hoor, maar persoonlijk doe ik dit niet

[H!GHGuY]

st0p schreef op woensdag 04 juni 2008 @ 08:18:
@Highguy: Dat is toch de implementatie zoals ik hem nu heb? Ik gebruik al attributes om min/max te bepalen. In mijn geval is een datatype geen plugin, maar stelt de plugin datatypes zoals jij beschrijft beschikbaar.

Bespaar jezelf het typwerk door impliciet aangeboden conversies te gebruiken.

C#:

double d = 100.0;
int i = 90;
Debug.Assert(i < d);

bovendien zijn excepties tijdens setters, helemaal niet uit den boze. Zeker niet in een plugin-structuur waarbij je de implementatie en dus "wat mag en wat niet mag" niet kent.
Je interface van je plugin moet enkel beschrijven wie wat mag opgooien (of maw wat je in het host programma opvangt en wat niet)

[ Voor 24% gewijzigd door H!GHGuY op 04-06-2008 13:00 ]