Θέλω να φτιάξω μια εφαρμογή και μαζεύω γνώμες πάνω σε ένα θέμα σχεδιασμού που με απασχολεί. Θα το περιγράψω σε γενικευμένο επίπεδο ώστε να μην οδηγήσω τη σκέψη σας πουθενά.

Το κύριο ζητούμενο είναι να μπορώ να αλλάζω το business logic εύκολα, χωρίς να χρειάζεται update η εφαρμογή.

Ας υποθέσουμε ότι υπάρχει κάποιο βασικό entity (ας το πούμε widget) και αυτό έχει κάποια attributes. Το business logic είναι ουσιαστικά ο καθορισμός νέων attributes που βασίζονται πάνω στα υπάρχοντα ή lookup τιμές από πινακάκια που θα καθορίζονται και αυτά δυναμικά.

Παράδειγμα:

Το Widget έχει attributes τα Αlpha (numeric), Beta (string) και Gama (date). Μερικά νέα attributes είναι τα:

Delta: αν Gama < 1/1/1980 τοτε Delta = 20%
       αν Gama >= 1/1/1980 και Gama < 1/1/1990 τοτε Delta = 30%
       αν Gama >= 1/1/1990 τοτε Delta = 40%

Epsilon: Epsilon = Alpa * Delta

Theta: αν Beta = "Χ" και Gama τότε Theta = Epsilon / 2
       αν Beta = "Υ" και Gama τότε Theta = Epsilon / 3
       αν Beta = "Ζ" και Gama τότε Theta = Epsilon / 4

 

Ουσιαστικά μιλάμε για script engine. Μέχρι στιγμής έχω υπό σκέψη και έρευνα το παλιό καλό (αλλά COM) Microsoft Script Control καθώς και την υποστήριξη scripting μέσω του Microsoft.Vsa namespace.

Αν κάποιος άλλος έχει εμπειρία πάνω στο συγκεκριμένο θέμα ή έχει κάποια πρόταση θα χαρώ να την ακούσω.

(Θα εκτιμούσα αν δεν μου απαντήσετε με links από googling. Έχω κάνει το homework μου )

---

Vir prudens non contra ventum mingit

Αν η λογική έχει τέτοια μορφή, μήπως σε βολεύει ένα rules engine αντί για script engine? Οπότε παίζουν WF και NxBRE, αν και μπορεί να κάνεις τη δουλειά σου και με κάτι πολύ απλούστερο. Ουσιαστικά, τα νέα attributes γίνονται νέα Rules. Θα πρέπει να βρεις ένα rule engine το οποίο να καλύπτει αυτά που θες αλλά θα έχει αρκετά απλή σύνταξη για να το χρησιμοποιήσει όποιος ορίζει τους κανόνες.

Αλήθεια, ποιός και πόσο συχνά θα αλλάζει τους ορισμούς?

---

Παναγιώτης Καναβός, Freelancer
Twitter: http://www.twitter.com/pkanavos

Οι ορισμοί δεν θα αλλάζουν πολύ συχνά... Μερικές φορές το χρόνο. Το ποιός είναι ένα θέμα. Το ιδανικά θα ήταν να μπορούσε (μέσω ενός intuitive interface) να τους αλλάξει ένας χρήστης που δουλεύει άνετα με excel formulas.

Ως προς το rule engine αρχικά το σκέφτηκα αλλά μου φάνηκε πιο περίπλοκο συν επίσης ότι έχω την εντύπωση ότι τα scripts μπορεί να ταγράψει κάποιος Javascript oriented αλλά και VBScript oriented. Δεν το έχω αποκλείσει πάντως ως λύση.

---

Vir prudens non contra ventum mingit

Rule engine, βασισμένο σε anonymous methods?

Γιατί σε anonymous methods? Πώς το σκέφτεσαι?

---

Vir prudens non contra ventum mingit

Ένα rule engine θα είναι ευκολότερο, όχι δυσκολότερο από ένα script engine, ειδικά αν το ζητούμενο είναι "κάποιος που ξέρει Excel" αντί για "κάποιος που ξέρει javascript". Εννοείται έτοιμο, γιατί αν πρέπει να το φτιάξεις από το μηδέν, έχει δουλίτσα. Αποκλείοντας καταρχήν το WF λόγω .... XMLίτιδας, υπάρχουν διάφορα Rule engines για .NET με αρκετά απλή γλώσσα. Έτσι κι αλλιώς,  χρειάζεται ένα απλό rule engine, το οποίο απλά θα καταλαβαίνει το "Αν χ, ψ, ω τότε α, β, γ".

Όσον αφορά το καθαρό parsing, μπορείς να χρησιμοποιήσεις τη μέθοδο CodeDomProvider.Parse για να κάνεις parse ένα text stream και να δημιουργήσεις μετά από αυτό executable κώδικα. Το .NET έρχεται πακέτο με VB, C#, JScript compilers οπότε μπορείς να χρησιμοποιήσεις κάποια από αυτές τις γλώσσες. Και πάλι όμως, θα έπρεπε να χρησιμοποιήσεις διαφορετική γλώσσα για τον τελικό χρήστη, εκτός και αν θεωρείς ότι ξέρει ήδη κάποια από αυτές τις γλώσσες. Ακόμα και αν έχεις έτοιμο το σκελετό του κώδικα, και απλά προσθέτεις τους κανόνες που σου δίνει ο χρήστης, αυτός θα πρέπει να καταλαβαίνει τη σύνταξη της γλώσσας.

Μπορείς να χρησιμοποιήσεις και μία απλή μορφή Decision Table αντί για rule engine. Ουσιαστικά, έχεις ένα πίνακα όπου στις ν-1 στήλες έχεις διάφορες συνθήκες που πρέπει να ισχύουν και στην τελευταία το αποτέλεσμα που θα εκτελέσεις. Για το χρήστη είναι εύκολη η εισαγωγή των κανόνων, αλλά κάπως θα πρέπει να κάνεις .... parse  τις συνθήκες του πίνακα και το αποτέλεσμα!
Αν όμως οι κανόνες αλλάζουν σπάνια, δεν σε εμποδίζει τίποτε να πάρεις τον πίνακα, να δημιουργήσεις με CodeDom ή string manipulation τον κώδικα με μορφή if - then , να κάνεις compile σε Dll με τον CodeDomProvider και να έχεις έτσι έτοιμο το rule dll που θέλεις.

Πάντα βέβαια με την προϋπόθεση ότι δεν θα βρεις κάτι έτοιμο, γιατί τότε, τα παραπάνω γίνονται σχεδόν αυτόματα.

---

Παναγιώτης Καναβός, Freelancer
Twitter: http://www.twitter.com/pkanavos

KelMan:

Γιατί σε anonymous methods? Πώς το σκέφτεσαι?

΄

Μάλλον lamda εννοεί. Κάτι τέτοιο έχει νόημα καθώς ο χρήστης εισάγει τη συνθήκη και εσύ τη μετατρέπεις σε executable κώδικα. Θα μπορούσες έτσι να φτιάξεις ένα απλό decision table όπου η μία στήλη θα έχει το lamda της συνθήκης και η άλλη το lamda του αποτελέσματος. Αυτό που μένει, είναι να μετατρέψεις τα string που θα σου δώσει ο χρήστης σε lamdas.

Βρήκα και ένα άρθρο του Martin Fowler για τη χρήση Decision Tables για τέτοιες περιπτώσεις, το οποίο περιέχει και ένα decision table engine. Αν και προτείνει "για περίπλοκες συνθήκες του στυλ χ>=50 καλύτερα να αφήσεις το χρήστη να βάζει ranges στις συνθήκες", δεν δίνει ένα τέτοιο δείγμα.

---

Παναγιώτης Καναβός, Freelancer
Twitter: http://www.twitter.com/pkanavos

Επίσης εάν θες μπορείς να ρίξεις και μία ματιά στην LuA που είναι scriptable language με απλό syntax και μπορεί να κάνει τα πάντα. Την έχω συναντήσει σε πολλά games αλλά και σε προγράμματα για την δημιουργεία macros. Βέβαια προφανώς ένα decision table engine ίσως είνια καλύτερη σαν λύση (ειδικά άμα υπάρχει κώδικας έτοιμος) αλλά και το LuA αξίζει να το δει κάποιος.

---

Παναγιώτης Κεφαλίδης

"Για να επιτύχεις, θα πρέπει το πάθος σου για την επιτυχία να είναι μεγαλύτερο απο τον φόβο σου για την αποτυχία"

Οι απαντήσεις παρέχονται για συγκεκριμένες ερωτήσεις και χωρίς καμιά εγγύηση. Παρακαλώ διαβάστε τους όρους χρήσης.

Integration με .NET έχει? Εδώ μιλάμε για business λογική και όχι γενικό scripting. Αυτό σημαίνει ότι υπάρχουν κάποιοι ουσιαστικοί περιορισμοί για να πεις ότι αξίζει τον κόπο:

• Το engine πρέπει να ενσωματώνεται εύκολα στην εφαρμογή
• Το engine πρέπει να βλέπει εύκολα τα structures της εφαρμογής ή/και η εφαρμογή να παρέχει API για scripting
• Η γλώσσα ή το interface προγραμματισμού πρέπει να είναι εύκολο για όποιον τη χρησιμοποιεί και όχι για τον προγραμματιστή που κάνει το integration

Οι κανόνες που ζητάει ο Μάνος είναι πολύ απλοί, που σημαίνει ότι μία γλώσσα γενικού σκοπού είναι overkill. Μία μικρή γλώσσα γι αυτό το σκοπό θα ήταν καλύτερη (πως λέμε DSL ?). Αν η γλώσσα έχει τη μορφή κειμένου όμως, θα πρέπει να γίνει parse, έστω και το ( A>40 AND B=30) => X=A*B/0.45. Αν όμως η επιθυμητή διάλεκτος είναι τόσο απλή όσο αυτό που περιέγραψε ο Μάνος, ο κώδικας για το parsing μπορεί να γραφτεί εύκολα.

Ίσως όμως να μπορείς να χρησιμοποιήσει και την eval της JScript και να περάσει τις συνθήκες και το αποτέλεσμα απευθείας σε κώδικα  ...

---

Παναγιώτης Καναβός, Freelancer
Twitter: http://www.twitter.com/pkanavos

Βασικά, θα ήθελα να είχα στη διάθεσή μου διάφορες δομές όπως If/Then/Else, Case/Switch, κλπ. Γι αυτό και σκεφτόμουν για scripting.

Ξεκίνησα να κοιτάω το Drools.NET ωστόσο έχει (για το δυνητικό χρήστη) κάποιο learning curve αφού έχει το δικό του τρόπο έκφρασης στα rules. Το NxBRE που λες Παναγιώτη είναι XMLbased και χρησιμοποιεί το Visio για ασφαλή σύνταξη rules (απ' όσο είδα) πράγμα που το καθιστά ακατάλληλο.

To θέμα είναι ότι αυτά τα rules/scripts θα πρέπει να αποθηκεύονται στη βάση μαζί με ημερολογιακά διαστήματα που εφαρμόζονται, ώστε να μπορεί να συγκρίνει ο χρήστης εικόνες από τις τιμές των attributes μεταξύ δύο ημερομηνιών (πχ σήμερα και πριν δύο χρόνια).

---

Vir prudens non contra ventum mingit

Χρησιμοποιώ εδώ και πολύ καιρό τον CodeProvider του .NET για να κάνω compile κώδικα σε runtime (δες εδώ για ένα proof of concept: http://www.codeproject.com/KB/dotnet/dynacodgen.aspx). Δουλεύει πολύ καλά, ιδιαίτερα αν μπορείς να κασάρεις στη μνήμη το αποτέλεσμά του compilation για να μην κάνεις κάθε φορά compile τον κώδικα πριν τον τρέξεις. Ουσιαστικά λοιπόν ο "χρήστης" μου πρέπει να γράψει .net γλώσσα (C# ή VB). Χρησιμοποιώ εισαγωγικά στο "χρήστης" γιατί δεν θα είναι απαραίτητα ο τελικός χρήστης, ίσως ούτε καν ο διαχειριστής του συστήματος του πελάτη. Μπορεί να είναι το τμήμα υποστήριξης της εταιρείας μου. Θεωρώ (δική μου υποκειμενική παραδοχή) ότι σχεδόν οποιοσδήποτε έχει τις γνώσεις για να π.χ. εγκαταστήσει τα Windows, μπορεί να γράψει μερικά if statements για να εκφράσει απλό logic. Ειδικά αν έχει και κάποια templates/βοηθήματα.
Έχω τεστάρει αυτή τη λύση σε αρκετά περιβάλλοντα παραγωγής εκτελώντας κώδικα που έχει γραφτεί αρκετές χιλιάδες φορές την ώρα και δεν έχω προβλήματα.
Γενικά η λύση δουλεύει περίπου όπως το παλιό παραδοσιακό script εργαλείο που είχαμε στην vb6 αλλά ο κώδικας είναι .net και είναι compiled, οπότε πιο γρήγορος. Ίσως όσο γρήγορος θα ήταν αν είχε γίνει build μαζί με την εφαρμογή.
Σημαντικό είναι να κάνεις compile τον κώδικα όσο νωρίτερα γίνεται, π.χ. όταν ξεκινά η εφαρμογή και όχι όταν θα χρησιμοποιηθεί ο κώδικας. Έτσι αυτός που γράφει τον κώδικα θα μπορεί γρήγορα να βρει συντακτικά λάθη.
Η λύση αυτή παρέχετε με την εγγύηση "Δουλεύει για μένα".

---

Dimitris Papadimitriou Software Development Professional

Οι απαντήσεις παρέχονται για συγκεκριμένες ερωτήσεις και χωρίς καμιά εγγύηση. Διαβάστε επίσης τους όρους χρήσης.

Είχα παίξει με τις ανώνυμες μεθόδους, φτιάχνωντας ένα μηχανισμό (οκ..της πλάκας ισως) για τον υπολογισμό ΦΠΑ, που έχεις 3 συνθήκες με διαφορετικό ΦΠΑ, που μπορεί να μην είναι σε όλα τις κατηγορίες ΦΠΑ, ένα προϊόν τελικά δεμένο, οπότε αντί να κάνεις if-cases, λειτουργεί μέσω delegates...( http://dmexis.wordpress.com, αν θέλετε να δείτε ) δεν ξέρω αν θα βοήθαγε σε αυτό που θές να κάνεις πραγματικά, γιατί απο ότι βλέπω και απο την απάντηση που πήρες πιο μετά, υπάρχουν και πιο προχωρημένες και πιθανώς ποιο ολοκληρωμένες λύσεις. Και αυτό που πρότεινε, ο Παναγιώτης...φαίνεται...way too good.... :-)

Νομίζω ότι με απλή χρήση generics μπορούμε να έχουμε το ίδιο αποτέλεσμα. Συγκρίσεις τις μορφής α <= β < γ, μπορούν να γίνουν με χρήση λίστας που θα κρατούν τα compare points κατ' αύξουσα σειρά, είτε πρόκειται για ημερομηνίες είτε για νούμερα, και να επιστρέφουν τις καθορισμένες τιμές για τη σύγκριση. Αυτές οι τιμές μπορούν ή να εισαχθούν άμεσα ή να υπολογιστούν από εξίσωση. Equation parsers υπάρχουν πάρα πολλοί. Σα μεταβλητές των εξισώσεων μπορούν να οριστούν τα πεδία που μας ενδιαφέρουν από τη βάση δεδομένων.

Παίζοντας λίγο με κώδικα σε c# κατέληξα σ' αυτό:

    public class Point<T> where T:IComparable<T>
    {
        private T point; // Το σημείο
        private bool rightInclusive; // true αν θέλουμε να ισχύει '<=', false αν θέλουμε να ισχύει '<'
        private double returnValue; // Η τιμή που θα επιστραφεί αν το input point είναι μεταξύ του προηγούμενου point και αυτού του point
        private Equation mathEquation; // Η συνάρτηση βάσει της οποίας θα υπολογιστεί το returnValue, εκτός αν οριστεί explicitly

        public Equation MathEquation
        {
            get { return mathEquation; }
        }

        public double ReturnValue
        {
            get { return returnValue; }
        }

        public bool RightInclusive
        {
            get { return rightInclusive; }
        }

        public T Value
        {
            get { return point; }
        }

        //
        // Ο constructor είναι overloaded ανάλογα με το αν η τιμή που θα επιστραφεί καθορίζεται
        // από εξίσωση ή όχι
        //
        public Point(T point, bool rightInclusive, double returnValue)
        {
            this.point = point;
            this.rightInclusive = rightInclusive;
            this.returnValue = returnValue;
        }

        public Point(T point, bool rightInclusive, Equation mathEquation)
        {
            this.point = point;
            this.rightInclusive = rightInclusive;
            this.mathEquation = mathEquation;
            this.returnValue = this.mathEquation.EquationValue;
        }
    }

Με την κλάση Point ορίζουμε το κάθε ένα σημείο που θα αποτελέσει compare point. Η επόμενη κλάση είναι η RangeRule:

public class RangeRule<T> where T:IComparable<T>
    {
        private string ruleName; // Το όνομα του Rule
        private T bottomPoint; // Η μικρότερη δυνατή τιμή για το point π.χ. int.MinValue
        private T ceilingPoint; // Η μεγαλύτερη δυνατή τιμή για το point π.χ. int.MaxValue
        private List<Point<T>> listOfPoints=new List<Point<T>>();
        private double? rangeRuleValue = null; // Η τιμή που επιστρέφει το Rule
        private double ceilingValue = double.NaN; // Η τιμή που θα επιστραφεί αν το testPoint είναι μεταξύ του τελευταίου point και του ceilingPoint
        private Equation ceilingEquation = null; // Ομοίως, αν η τιμή καθορίζεται από εξίσωση.
        private T testPoint;

        public T TestPoint
        {
            get { return testPoint; }
            set { testPoint = value; }
        }

        public Equation CeilingEquation
        {
            get { return ceilingEquation; }
        }

        public double CeilingValue
        {
            get { return ceilingValue; }
        }

        public double? RangeRuleValue
        {
            get
            {
                this.rangeRuleValue = this.RuleValue();
                return rangeRuleValue;
            }
        }

        public T CeilingPoint
        {
            get { return ceilingPoint; }
            set { ceilingPoint = value; }
        }

        public T BottomPoint
        {
            get { return bottomPoint; }
            set { bottomPoint = value; }
        }

        public string RuleName
        {
            get { return ruleName; }
            set { ruleName = value; }
        }

        public RangeRule(string ruleName, double ceilingValue, T testPoint)
        {
            this.ruleName = ruleName;
            this.ceilingValue = ceilingValue;
            this.testPoint = testPoint;
        }

        public RangeRule(string ruleName, Equation ceilingEquation, T testPoint)
        {
            this.ruleName = ruleName;
            this.ceilingEquation = ceilingEquation;
            this.ceilingValue = this.ceilingEquation.EquationValue;
            this.testPoint = testPoint;
        }

        public void AddPoint(Point<T> point)
        {
            if (this.listOfPoints.Count == 0)
            {
                if ((point.Value.CompareTo(this.BottomPoint)>0) && (point.Value.CompareTo(this.CeilingPoint)<0))
                {
                    this.listOfPoints.Add(point);
                }
                else
                {
                    throw new Exception("point either <= than BottomPoint or >= than CeilingPoint");
                }
            }
            else
            {
                if ((point.Value.CompareTo(listOfPoints[listOfPoints.Count - 1].Value)>0) && (point.Value.CompareTo(this.CeilingPoint))<0)
                {
                    this.listOfPoints.Add(point);
                }
                else
                {
                    throw new Exception("point either <= than Previous point Value or >= than CeilingPoint");
                }
            }
        }

        private double? RuleValue()
        {
            double? ruleValue = null;
            if (this.listOfPoints.Count == 0)
            {
                throw new Exception("The rule has no intermediate points");
            }
            else
            {
                for (int i = 0; i < this.listOfPoints.Count; i++)
                {
                    T minPoint;
                    bool minInclusive = true;
                    T maxPoint;
                    bool maxInclusive = true;
                    //
                    if (i == this.listOfPoints.Count - 1)
                    {
                        maxPoint = this.CeilingPoint;
                        ruleValue = this.CeilingValue;
                    }
                    else
                    {
                        maxPoint = this.listOfPoints[i + 1].Value;
                        maxInclusive = this.listOfPoints[i + 1].RightInclusive;
                        ruleValue = this.listOfPoints[i + 1].ReturnValue;
                    }
                    //
                    if (i == 0)
                    {
                        minPoint = this.BottomPoint;
                        ruleValue = this.listOfPoints.ReturnValue;
                    }
                    else
                    {
                        minPoint = this.listOfPoints.Value;
                        minInclusive = !this.listOfPoints.RightInclusive; // Θυμήσου, το RightInclusive αφορά μόνο στο '<='
                    }
                    //
                    if ((minInclusive) && (maxInclusive))
                    {
                        if ((this.TestPoint.CompareTo(minPoint) >= 0) && (this.TestPoint.CompareTo(maxPoint) <= 0)) { break; }
                    }
                    if ((!minInclusive) && (maxInclusive))
                    {
                        if ((this.TestPoint.CompareTo(minPoint) > 0) && (this.TestPoint.CompareTo(maxPoint) <= 0)) { break; }
                    }
                    if ((minInclusive) && (!maxInclusive))
                    {
                        if ((this.TestPoint.CompareTo(minPoint) >= 0) && (this.TestPoint.CompareTo(maxPoint) < 0)) { break; }
                    }
                    if ((!minInclusive) && (!maxInclusive))
                    {
                        if ((this.TestPoint.CompareTo(minPoint) > 0) && (this.TestPoint.CompareTo(maxPoint) < 0)) { break; }
                    }
                }
            }
            return ruleValue;
        }
    }

Εδώ δίνουμε τα compare point με Add και το test point. Ανάλογα με το αποτέλεσμα της σύγκρισης επιστρέφει την τιμή που έχουμε καθορίσει.

Δεν έχω τεστάρει διεξοδικά τον παραπάνω κώδικα και μπορεί να έχει bugs. Αλλά, νομίζω πως η ιδέα είναι εμφανής. Αν τα υπόλοιπα business rules ακολουθούν απλά patterns νομίζω ότι με αυτόν τον τρόπο και ένα λειτουργικό editor οι χρήστες θα μπορέσουν να αλλάζουν μόνοι τους τα rules.

---

Ακόμα κι ένας άνθρωπος μπορεί ν' αλλάξει τον κόσμο. Μη θέλεις να κυβερνήσεις. Απλά δείξε το μονοπάτι κι ο κόσμος θ' ακολουθήσει!!

Σ' ευχαριστώ για όλα αυτά που έγραψες αλλά στη συγκεκριμένη περίπτωση αυτή η λύση έχει το μειονέκτημα ότι θα πρέπει εκ των προτέρων να ξέρω όλα τα πιθανά expressions που θα απαιτηθούν. Το συγκεκριμένο expression είναι απλά ένα παράδειγμα... Έχοντας ένα rules engine ή τη δυνατότητα να εισάγεις script δεν υπάρχει κανένας περιορισμός.

---

Vir prudens non contra ventum mingit

OK. Νόμισα ότι οι μορφές των rules είναι εκείνες του αρχικού παραδείγματος και ότι δεν υπάρχουν άλλες για τη συγκεκριμένη εφαρμογή. Γι' αυτό και το έκανα έτσι, ώστε να μην απαιτείται να γράψει το script ο χρήστης. Αν η μορφή του rule είναι τελείως αυθαίρετη, τότε σίγουρα η λύση αυτή είναι περιοριστική. Αν και ακόμα και με τις κλάσεις, εφόσον οριστούν input και output παράμετροι, το ένα rule μπορεί να καλέσει είτε το άλλο είτε μια συνάρτηση, προσφέροντας κάποιας μορφής ευελιξία. Το πλεονέκτημα μ' αυτό τον τρόπο είναι ότι ο χρήστης μπορεί να χρησιμοποιήσει ένα table και έναν equation editor για την εισαγωγή των περιορισμών, χωρίς να χρειαστεί να ορίσει δομές if then else, ή switch case.

---

Ακόμα κι ένας άνθρωπος μπορεί ν' αλλάξει τον κόσμο. Μη θέλεις να κυβερνήσεις. Απλά δείξε το μονοπάτι κι ο κόσμος θ' ακολουθήσει!!