Design & Architecture

Απ: Scriptable business logic

Panagiotis Kefalidis — Tue, 17 Mar 2009 19:09:48 GMT

Παναγιώτης Καναβός:

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

...

Αν και με πολύ καθυστέρηση.. Ναι έχει και μάλιστα προσφέρει και έτοιμο assembly για να "μιλήσεις" με το engine. Απο εκεί και πέρα, φτιάχνεις κάποια "functions" τα οποία τα δηλώνεις και σαν functions που φαίνονται και στο Scripting engine και φυσικά τι τύπο επιστρέφει αυτό και τελείωσες όσο αφορά το κομμάτι του integration/intepretation των script. Απο εκεί και πέρα το πως θα τα σώσεις κλπ στην βάση, θα μπορούσε να είναι απλό κείμενο καθώς το scripting engine διαβάζει τα script σαν απλό κείμενο και στην συνέχεια τα τρέχει.

Απ: Scriptable business logic

Markos — Tue, 17 Mar 2009 18:09:29 GMT

Καλημέρα,

Κι εγώ δεν μπορώ να πω πως έχω σκεφτεί όλα τα πιθανά σενάρια. Απλά σκέφτηκα πάνω σε μια εναλλακτική πρόταση η οποία έχει το πλεονέκτημα στο ότι μπορεί κανείς να βασιστεί πάνω της και να φτιάξει ένα εύχρηστο interface. Για της ανάγκες δικής μου εφαρμογής έχω ήδη φτιάξει έναν equation editor ο οποίος χρησιμοποιεί πεδία από tables της βάσης σα μεταβλητές και ο χρήστης μπορεί να εισάγει την εξίσωση. Το επόμενο βήμα είναι αυτό, αλλά δεν είχα μέχρι τώρα αφιερώσει χρόνο για να βρω μια λύση. Έτσι όπως το σκέφτομαι είναι όλα να μπορούν να λειτουργήσουν σα μεταβλητές. Για παράδειγμα, το αποτέλεσμα μιας εξίσωσης να μπορεί να συμμετέχει σε μία σύγκριση και αντίθετα, το αποτέλεμα μιας σύγκρισης (αν είναι αριθμός) να μπορεί να χρησιμοποιηθεί σα μεταβλητή σε μία εξίσωση. Η αλήθεια είναι ότι θέλει πολύ δουλειά. Σκέφτομαι να το προχωρήσω μόλις ξεμπερδέψω μ' αυτό που ασχολούμαι τώρα (κι αν δεν προκύψει κάτι άλλο στην πορεία βέβαια). Μου αρέσει το ότι έτσι μπορώ να δώσω στο χρήστη κάτι πολύ εύχρηστο. Το αν θα δουλέψει σε όλα τα σενάρια δεν το γνωρίζω. Αυτό, όμως, είναι το περιεχόμενο και ο ορισμός του R and D. Έτσι, δεν είναι;

Απ: Scriptable business logic

KelMan — Tue, 17 Mar 2009 15:36:12 GMT

Μου είναι λίγο δύσκολο να φανταστώ πώς θα δουλέψει η λύση σου στην πράξη (μου φαίνεται ότι είναι κάτι σαν rule engine). Βασικά με βρίσκει λίγο διστακτικό η γενική ιδέα του να φτιάξω κάτι δικό μου από την αρχή γιατί συνήθως σε τέτοιες περιπτώσεις ισχύει ο κανόνας του 80-20. Μπορείς να καλύψεις εύκολα το 80% των περιπτώσεων αλλά για το υπόλοιπο 20% - που συνήθως δεν το έχεις σκεφτεί ή σου βγαίνει στην πορεια - χρειάζεται πολύυυυ δουλειά ή μεγάλο re-engineering.

Από την άλλη έφτιαξα ένα working protorype με την τεχνική του κώδικά μέσω CodeDOM και παίζει μια χαρά. Αυτό που θέλω να κάνω είναι να βάλω κάτω (μόλις τα έχω) όλα τα business rules και να προσπαθήσω να τα εκφράσω με κάπως τυποποιημένη μορφή ώστε να εξετάσω κατά πόσο μπορεί να εφαρμοσθεί κάποιο έτοιμο rule engine ή όπως μου πρότεινε ο Παναγιώτης, κάποια λύση τύπου fluent interface.

Απ: Scriptable business logic

Markos — Mon, 16 Mar 2009 21:11:39 GMT

Το Σαββατοκύριακο είχα την ευκαιρία να σκεφτώ πάνω σ' αυτό το πρόβλημα πιο χαλαρά και κατέληξα σε ορισμένα συμπεράσματα που θέλω να μοιραστώ μαζί σας, μιας και άρχισε κι εμένα να με ενδιαφέρει αυτό το topic. Για να τα πάρουμε, όμως, τα πράγματα με τη σειρά.

Το πρώτο θέμα που πρέπει να επιλυθεί είναι η έκφραση των conditions. Με λίγη σκέψη εύκολα φτάνει κανείς στο συμπέρασμα ότι όλα τα conditions μπορούν να εκφραστούν σε στήλες και σειρές. Οι σειρές μπορεί να είναι AND συνθήκες και οι στήλες OR. Για παράδειγμα, το condition (A OR B) AND (C OR D) μετασχηματίζεται σε:

A AND C OR
A AND D OR
B AND C OR
B AND D

Ομοίως, το condition (A AND B) OR ((C AND D) OR E) μετασχηματίζεται ακόμα πιο εύκολα σε:

A AND B OR
C AND D OR
E

Από τα παραπάνω βγαίνει το συμπέρασμα, ότι το μόνο που χρειάζεται είναι ένας table editor εισαγωγής συνθηκών ο οποίος θα δέχεται τα AND σε σειρές και τα OR σε στήλες. Κάθε σειρά είναι true εάν και μόνο εάν όλες οι συνθήκες είναι true, ενώ η OR στήλη είναι true εάν και μόνο εάν μία σειρά είναι true. Με χρήση generics, αυτό μπορεί να γραφτεί ως εξής:

    public enum Condition
    {
        EQ,NotEQ,LT,LTorEQ,GT,GTorEQ
    }
    
    //
    // Σύγκριση μεταξύ δύο μεταβλητών...
    //
    public class Comparison<T> where T : IComparable<T>
    {
        private T lhs; // Left hand side
        private T rhs; // Right hand side
        private Condition cond;
        private bool result;

        public bool Result
        {
            get
            {
                this.result = this.ComparisonResult();
                return result;
            }
        }

        public Comparison(T lhs, T rhs, Condition cond)
        {
            this.lhs = lhs;
            this.rhs = rhs;
            this.cond = cond;
        }

        private bool ComparisonResult()
        {
            bool result = false;
            //
            switch (cond)
            {
                case Condition.EQ:
                    if (lhs.CompareTo(rhs) == 0) { result = true; }
                    break;
                case Condition.NotEQ:
                    if (lhs.CompareTo(rhs) != 0) { result = true; }
                    break;
                case Condition.GT:
                    if (lhs.CompareTo(rhs) > 0) { result = true; }
                    break;
                case Condition.GTorEQ:
                    if (lhs.CompareTo(rhs) >= 0) { result = true; }
                    break;
                case Condition.LT:
                    if (lhs.CompareTo(rhs) < 0) { result = true; }
                    break;
                case Condition.LTorEQ:
                    if (lhs.CompareTo(rhs) <= 0) { result = true; }
                    break;
            }
            //
            return result;
        }
    }

    //
    // Στο ComparisonRow όλα τα conditions είναι AND
    //
    public class ComparisonRow
    {
        private List<bool> rowResults = new List<bool>();
        private bool result;

        public bool Result
        {
            get
            {
                this.result = this.RowResult();
                return result;
            }
        }

        public void AddRowResult(bool comparisonResult)
        {
            this.rowResults.Add(comparisonResult);
        }

        private bool RowResult()
        {
            bool rowResult = true;
            //
            if (this.rowResults.Count == 0)
            {
                throw new Exception("No results entered in the comparison row...");
            }
            else
            {
                if (this.rowResults.Contains(false))
                {
                    rowResult = false;
                }
            }
            //
            return rowResult;
        }
    }

    //
    // Στο ComparisonColumn όλα τα conditions είναι OR
    //
    public class ComparisonColumn
    {
        private List<bool> columnResults = new List<bool>();
        private bool result;

        public bool Result
        {
            get
            {
                this.result = this.ColumnResult();
                return result;
            }
        }

        public void AddColumnResult(bool rowResult)
        {
            this.columnResults.Add(rowResult);
        }

        private bool ColumnResult()
        {
            bool columnResult = false;
            //
            if (this.columnResults.Count == 0)
            {
                throw new Exception("No results entered in the comparison column...");
            }
            else
            {
                if (this.columnResults.Contains(true))
                {
                    columnResult = true;
                }
            }
            //
            return columnResult;
        }
    }

Το επόμενο θέμα είναι η δομή IF THEN ELSE. Νομίζω ότι και αυτό μπορεί να λυθεί με την ισοδύναμη έκφραση του Immediate IF. Δηλαδή, IF (Condition, True part, False part). Από πλευράς editing ο χρήστης θα εισάγει τους περιορισμούς με τη μορφή ενός branching tree:

Όπου RV: Return Value, Condition(i): Οι συνθήκες που εισάγονται με μορφή πίνακα από τον προηγούμενο editor

Τέλος, απαιτείται η χρήση ενός equation editor ο οποίος θα κάνει evaluation σε expressions. Μάλιστα, οι τιμές των εξισώσεων μπορεί να είναι return values των conditions. Μια γενική μορφή του μπορεί να είναι η εξής:

Y variable: (ορίζεται από το χρήστη)

Equation:                                                   Panel αριθμών, τελεστών και συναρτήσεων:
+-----------------------------------------------+ +-----------------------+
|(3*x1+log(x2))*x3.....                            | |                              |
|                                                            | |                              |
|                                                            | |                              |
|                                                            | |                              |
|                                                            | |                              |
|                                                            | |                              |
|                                                            | |                              |
|                                                            | |                              |
|                                                            | |                              |
|                                                            | |                              |
+-----------------------------------------------+ +-----------------------+

Επιλογή μεταβλητών (μπορεί να είναι πεδία πινάκων):
+-----------------------------------------------+
|x1 x2 x3...                                             |
|                                                            |
|                                                            |
|                                                            |
+-----------------------------------------------+

Σίγουρα μια τέτοια υλοποίηση είναι αρκετά πιο δύσκολο να επιτευχθεί σε σύγκριση με έναν απλό script editor τύπου notepad, αλλά αρκεί να γίνει μια φορά. Τα components είναι reusable και μπορούν να ενσωματωθούν εύκολα σε οποιαδήποτε μελλοντική εφαρμογή. Το evaluation δε των εκφράσεων με τον τρόπο αυτό γίνεται εύκολα. Όσο για expression evaluators έχει πήξει ο τόπος (βλπ. εδώ κι εδώ). Ο κώδικας του RangeEvaluator που έκανα post πιο πριν μπορεί να χρησιμοποιηθεί σαν μια ειδική περίπτωση του IF THEN ELSE. Πιστεύω ότι μια τέτοια υλοποίηση θα δουλέψει. Εσείς τι λέτε;

Απ: Scriptable business logic

Markos — Sat, 14 Mar 2009 09:03:00 GMT

Άκυρο. Όταν έγραφα το προηγούμενο post μου είχε φανεί πιο απλό. Τώρα και να γίνεται, δεν ξέρω αν αξίζει τον κόπο τη στιγμή που υπάρχουν ήδη έτοιμες λύσεις.

Απ: Scriptable business logic

Markos — Sat, 14 Mar 2009 04:57:33 GMT

Μια τελευταία ερώτηση:

Ρϊχνοντας μια δεύτερη ματιά, κατάλαβα ότι το μεγαλύτερο πρόβλημα είναι το conditional nesting. Γιατί το ReturnValue του Point<T> να προέρχεται μόνο από εξίσωση ή από explicit assignment; Τα rule objects επιστρέφουν ReturnValue (double). Συνεπώς, μπορούμε να ορίσουμε με oveloading στον constructor του point όσα rule objects θέλουμε, αντί μόνο για μια εξίσωση ή μια προκαθορισμένη τιμή. Με αυτό τον τρόπο, με δύο ή τρεις το πολύ generic classes οι οποίες θα καλύπτουν conditional περιπτώσεις για discrete ή range values (συμπεριλαμβανομένων των strings), μπορούμε να έχουμε όσο conditional nesting θέλουμε. Μου φαίνεται ότι κάτι τέτοιο θα δουλέψει καλά για πάρα πολλές περιπτώσεις. Μήπως χρειάζεσαι και looping;

Απ: Scriptable business logic

Dimitris Papadimitriou — Fri, 13 Mar 2009 17:54:14 GMT

Μια άλλη εκδοχή έρχεται από το "Oslo" project. Εδώ υπάρχει μια σύντομη περιγραφή. Στο παράδειγμα μπορεί κανείς να γράψει κανόνες με φυσική γλώσσα ή μια domain specific language.

Απ: Scriptable business logic

Markos — Fri, 13 Mar 2009 17:22:35 GMT

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

Απ: Scriptable business logic

KelMan — Fri, 13 Mar 2009 15:58:00 GMT

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

Απ: Scriptable business logic

Markos — Fri, 13 Mar 2009 08:07:12 GMT

Νομίζω ότι με απλή χρήση 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.

Απ: Scriptable business logic

m6s — Fri, 13 Mar 2009 04:03:54 GMT

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

Απ: Scriptable business logic

Dimitris Papadimitriou — Fri, 13 Mar 2009 00:49:41 GMT

Χρησιμοποιώ εδώ και πολύ καιρό τον 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 τον κώδικα όσο νωρίτερα γίνεται, π.χ. όταν ξεκινά η εφαρμογή και όχι όταν θα χρησιμοποιηθεί ο κώδικας. Έτσι αυτός που γράφει τον κώδικα θα μπορεί γρήγορα να βρει συντακτικά λάθη.
Η λύση αυτή παρέχετε με την εγγύηση "Δουλεύει για μένα".

Απ: Scriptable business logic

KelMan — Thu, 12 Mar 2009 22:54:06 GMT

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

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

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

Απ: Scriptable business logic

Παναγιώτης Καναβός — Thu, 12 Mar 2009 22:06:10 GMT

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 και να περάσει τις συνθήκες και το αποτέλεσμα απευθείας σε κώδικα ...

Απ: Scriptable business logic

Panagiotis Kefalidis — Thu, 12 Mar 2009 19:21:04 GMT

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