Hej!

Jag blev lite inspirerad av Weblocks (för LISP) som Niklas tipsade om i en helt annat tråd, och jag köper konceptet rakt av; att kunna lägga upp webbprogrammeringen som om man skrev ett enkel console-program tilltalar mig :P

Hur som haver: Enkel beskrivning av vad man kan göra med Weblocks: I stället för att lägga upp en site som ett gäng olika sidor med mer eller mindre invecklade konstruktioner för att på något sätt försöka efterlikna ett tänkt flöde (Vara -> Kundvagn, Kundvagn -> Kassan, som i sin tur är uppdelad på fem sidor som man kör igenom i turordning á la "wizard") så skriver man sitt program enligt:

var kontaktuppgifter = FrågaEfterKontaktuppgifter();
var betalningssätt = FrågaEfterBetalningssätt();
if(betalningssätt == "med kort")
{
var kortnummer = FrågaEfterKortnummer();
}
var bekräftat = FrågaEfterBekräftelse();
var köpgenomfört = KontaktaBetalningsföretag();
VisaKundenKvittot();
GåTillStartsidan();

I LISP är det ganska enkelt då det inte finns någon klar distinktion mellan programkod och informationen som programkoden behandlar: att modifiera programkoden lite grann och peta in lämpliga saker för att "dela upp" programmet på ett gäng "sidor" är inga större problem.

Nu är dock frågan: kan man göra samma sak i ASP.NET? Tanken är lite MVC-stuk ("sidan" styr ingenting, logiken bakom gör det), men tillskillnad från MVC så ska koden mer eller mindre se ut som mitt exempel här ovan.

Att göra exemplet här ovan är rätt simpelt om man skriver en console-app, men på webben? HTTP är ju tillståndslöst.. :)

Jag har klurat lite, och kommit fram till en liten prototyp idag på en variant som ser ut att fungera, och löser just det här problemet; att kunna skriva ett "workflow" utan en tanke på webbens begränsningar. Jag har alltså ett fungerande exempel som påminner om exemplet här ovan.

Exempel:
--------------

Logiken som styr

            //Fråga efter förnamnet
            string firstName;
            firstName = CR<string>(delegate()
            {
                this.QueueResponseRedirect("~/StepOne.aspx?syncId=" + this.SyncId.ToString());
                this.WaitForPostedResult();
                return null; //This is dummy
            });
            //Fråga efter mellannamn ända tills man lämnar rutan tom
            string middleNames = "";
            while (true)
            {
                string middleName;
                middleName = CR<string>(delegate()
                {
                    if(HttpContext.Current.Request.UrlReferrer.PathAndQuery.Contains("/StepOne.aspx"))
                        this.QueueResponseRedirect("~/StepTwo.aspx?syncId=" + this.SyncId.ToString());
                    else
                        this.QueueServerTransfer("~/StepTwo.aspx?syncId=" + this.SyncId.ToString());
                    this.WaitForPostedResult();
                    return null; //This is dummy
                });
                if (middleName != "")
                {
                    if (middleNames.Length > 0)
                        middleNames += " ";
                    middleNames += middleName;
                }
                else
                {
                    break;
                }
            }
            //Skriv ut alla namnen, och när man trycker ok så hamnar man på startsidan igen
            string names;
            names = firstName + " " + middleNames;
            CR<object>(delegate()
            {
                this.QueueResponseRedirect("~/StepThree.aspx?syncId=" + this.SyncId.ToString());
                this.WaitForPostedResult(new KeyValuePair<string, object>("names", names));
                return null; //This is dummy
            });
            this.QueueResponseRedirect("~/Default.aspx");
            return null;

"Fortsätt"-knappen på första sidan (där man fyller i förnamnet):

        protected void Continue_Click(object sender, EventArgs e)
        {
            SyncManager sm = new SyncManager();
            sm.TryPostSyncStepResult(this.FirstName.Text);
            sm.TryContinueRunSync();
        }

Koden för att dra igång hela kedjan:

            SyncManager sm = new SyncManager();
            sm.StartSync(typeof(TestSync));

Och till sist koden för att skriva ut alla namnen på sidan:

        protected void Page_Load(object sender, EventArgs e)
        {
            Dictionary<string, object> arguments;
            SyncManager sm = new SyncManager();
            arguments = sm.GetPostSyncStepArguments();
            string names = arguments["names"] as string;
            this.Names.Text = names;
        }

------------

Är det någon som tycker det här är intressant? Ser det vettigt ut? (De ska göras mer på, jag har bara knackat lite idag när jag har haft tid)

Nu har jag filat lite mer på det hela; exempelkoden igen :)

        public override object Start()
        {
            string firstName;
            firstName = CR<string>("~/StepOne.aspx"); //Hämta resultatet från sidan StepOne.aspx, dvs. förnamnet
            string middleNames = "";
            middleNames = CR<string>(delegate() //Visar på att man kan cacha lite, exempelvis resultatet från den här loopen
            {
                string mntemp = "";
                while (true)
                {
                    string middleName;
                    //Hämta mellannamnen, som man ser av den här loopen så frågar den ända tills man fyller i ett tomt namn
                    middleName = CR<string>("~/StepTwo.aspx");
                    if (middleName != "")
                    {
                        if (mntemp.Length > 0)
                            mntemp += " ";
                        mntemp += middleName;
                    }
                    else
                    {
                        break;
                    }
                }
                return mntemp;
            });
            string names;
            //Exempel för att visa att man kan cacha en uträkning, om man t.ex. ska använda Random så kan det vara bra att cacha
            names = CR<string>(delegate() { return firstName + " " + middleNames; });
            //Presentera resultatet på sidan StepThree.aspx
            CR<object>("~/StepThree.aspx", new KeyValuePair<string, object>("names", names));
            this.QueueResponseRedirect("~/Default.aspx"); //Återgå till startsidan och skrota all state som hör till den här "sekvensen"
            return null; //Har lite "komponenttänk", tänker mig att man i framtiden ska kunna nästla sekvenser
        }

Koden ovan körs alltså "varje" gång man laddar en sida, men CR-anropen som tar url:er avbryter exekveringen där om resultat saknas från den sidan, om resultat finns så spottar den bara tillbaka det resultatet. Verkar fungera ganska stabilt :)

Grymt, men man skulle ju också vilja slippa just "~/StepOne.aspx", det känns lite obehagligt och icke-typsäkert.

Och annars finns det ett stort problem: du utgår ifrån en LISP-lösning, och skapar sen en replika i ett underlägset språk istället för i LISP. ;-) :evil:


Frågan är hur man borde lägga upp det för att kunna göra det så pass snyggt som Weblocks är. Man måste ju åtminstone spotta ur sig element i "realtid". Det meckiga är att alla varianter känns som att man måste göra en kopia på typ hela ASP.NET, anpassad så att det funkar.

En F#-lösning hade varit intressant. Fast då kan man ju lika gärna ge sig på Haskell istället.

Great, kommentarer :)

> Grymt, men man skulle ju också vilja slippa just "~/StepOne.aspx", det känns lite obehagligt och icke-typsäkert.

Det är en prototyp, det där tillhör en av sakerna som jag ska göra någonting åt, håller på att skissa lite på hur man skulle kunna göra

> Och annars finns det ett stort problem: du utgår ifrån en LISP-lösning, och skapar sen en replika i ett underlägset språk istället för i LISP. ;-) :evil:

Haha, jo, jag vet, LISP äger på sådana här saker, men, men. LISP har andra nackdelar, så det kan nog jämna ut sig :P

> Frågan är hur man borde lägga upp det för att kunna göra det så pass snyggt som Weblocks är. Man måste ju åtminstone spotta ur sig element i "realtid".

Jag har faktiskt inte detaljstuderat Weblocks, mest läst igenom lite på länken du postade i andra tråden, och tittat lite på exemplen, så jag är inte riktigt med på hur du menar nu. Kan du utveckla lite?

> En F#-lösning hade varit intressant. Fast då kan man ju lika gärna ge sig på Haskell istället.

F# är okänd mark för mig ;)

Har gjort det lite mer typsäkert nu :)

        public override object Start()
        {
            string firstName;
            firstName = this.StepOne();
            string middleNames = "";
            middleNames = CR<string>(delegate()
            {
                string mntemp = "";
                while (true)
                {
                    string middleName;
                    middleName = this.StepTwo();
                    if (middleName != "")
                    {
                        if (mntemp.Length > 0)
                            mntemp += " ";
                        mntemp += middleName;
                    }
                    else
                    {
                        break;
                    }
                }
                return mntemp;
            });
            string names;
            names = CR<string>(delegate() { return firstName + " " + middleNames; });
            this.StepThree(names);
            this.GoHome();
            return null;
        }

Kör med extension methods, har en klass som ser ut såhär:

    public static class SyncSteps
    {
        public static string StepOne(this SyncBase sync)
        {
            return sync.CR<string>("~/StepOne.aspx");
        }

        public static string StepTwo(this SyncBase sync)
        {
            return sync.CR<string>("~/StepTwo.aspx");
        }

        public static string StepThree(this SyncBase sync, string names)
        {
            return sync.CR<string>("~/StepThree.aspx", new KeyValuePair<string, object>("names", names));
        }

        public static void GoHome(this SyncBase sync)
        {
            sync.QueueResponseRedirect("~/Default.aspx");
        }
    }

Just nu funderar jag på några saker:

1) Jag måste lösa så att man kan använda bakåtknappen, har ingen jättegenomtänkt lösning på det än. Till viss del har jag lite stöd, två saker måste nämligen alltid skickas med en förfrågan; "syncId" samt "syncHash". Den första är ett id för hela sekvensen (är tänkt att kunna stödja nästling i ett senare skede), den andra är ett SHA-hash på den "path" som bildas av alla CR-anrop.

Om jag lägger till syncId i pathen för varje CR-anrop, samt sparar ner hashet i den tillhörande cachen, samt lägger till en räknare i cachen för varje CR-anrop, så borde man kunna hantera att man går bakåt i kedjan? (Just nu har jag nämligen bara sparat hashet ihop med syncId i cachen, och det är bara det hashet för vilket anrop man nu väntar svar ifrån. Finns alltså inget sätt att kunna "backa" kedjan)

2) En kul sak vore om man kunde hantera flera variabler i ett CR-anrop, utöver vad man returnerar via return. En fundering är att köra med byref-parametrar, en annan är att göra någon variant med en hashtable eller liknande. Jag har dock inte fått någon ordning på hur det ska lyckas fungera än.. :) Förslag?

Kom på några andra saker jag också funderar på:

1) Det mindre problemet är att man vill kunna gå bakåt. Det större är att man säkert vill kunna gå bakåt, korrigera en uppgift, och sedan fortsätta "framåt" igen. Hur bygger man lättast ett sådant stöd? Tänkbara problem är att koden "framåt" kan tänkas ta olika vägar baserat på vad man matat in, funderar lite på om man skulle kunna tänka sig att man på något sätt "markerar" i koden olika beroenden som finns om man vill utnyttja möjligheten att "gå framåt".

Ett konkret exempel skulle kunna vara utcheckningen på en webbshop: beroende på betalningsalternativ så kommer man få olika frågor i nästa steg, för att sedan gå till bekräftelsesidan. Förslag?

<b>>beroende på betalningsalternativ så kommer man få olika frågor i nästa steg, för att sedan gå till bekräftelsesidan. Förslag?</b>
Det enklaste vore ju ett väldigt konkret exempel:

En webbshop har tre produkter:
1 Bomull
2 Bensin
3 Dynamit

Om man köper bomull behöver man först välja färg, och sen bara kryssa i "bekräfta".
Om man köper bensin har man inga val, men man måste klicka i en kryssruta där det står "Ska ej användas till bombkonstruktion" före "bekräfta"
Och om man köper dynamit måste man skriva fritext där man beskriver vad man ska använda det till före "bekräfta".

Frågan är då - om man först tar 123 och sen går tillbaks och bockar ur 2, gäller då fortfarande fritexten när man går framåt igen?
eller 12, och bockar ur 1, gäller krysset?

om man tar 13, och bockar ur 3, ska man då varna för att man tappar ett tidigare val, för det är ju det man gör?

Om man tar 13, går tillbaks, byter färg på bomullen och bockar ur dynamiten, vad ska hända?



Eftersom de faktiska svaren kan variera väldigt, tror jag på en generell variant där man kan styra det på en högre nivå, kanske en sån här lösning:

Utöver "skriva in förnamn", "skriva in mellannamn", "skriva in efternamn", som ju sker i sekvenser, typ:
F -> M -> E
F -> M -> M -> M -> E
så finns det också en händelse "gå bakåt". Vad den gör är att hakas på sist:
F -> M -> E -> B

Vad "Gå bakåt" gör beror på tidigare steg i kedjan, och är implementationsspecifik, men kan till exempel innebära att man måste svara "ja" på en fråga om huruvida man verkligen vill backa. Sen ändras tillståndet, så att det ser ut som:

F -> M
Men som under ytan fortfarande håller hela sekvensen. När man sen fortsätter så fylls det då på, typ:

F -> M -> E -> B -> E

men det ser ut som:

F -> M -> E

För då borde du aldrig behöva gå bakåt, utan kan ständigt bara lägga på nya steg. Problem om någon går fram och tillbaka hundra gånger, men annars borde det vara ok?

Är du med på mitt vansinniga lösryckta pladder? =)

<b>>2) En kul sak vore om man kunde hantera flera variabler i ett CR-anrop, utöver vad man returnerar via return. En fundering är att köra med byref-parametrar, en annan är att göra någon variant med en hashtable eller liknande. Jag har dock inte fått någon ordning på hur det ska lyckas fungera än.. :) Förslag?</b>
Det är här LISP, Haskell och hela funktionella-språk-ligan (tillsammans med C++ och några till på ett litet hörn) fullkomligt bankar skiten ur C#. Där hade man lagt upp någon sorts anonyma typer, i C++ någon sorts tuple, och fått det både typsäkert, enkelt och smidigt.

Mina personliga åsikt är nog hashtabell/directory tillsammans med någon sorts typindikator, eller en serialiserad sträng. Jag gissar att systemet inte blir så där överdrivet effektivt ändå?
Iofs måste man ju inte ens ha en hashtabell, man skulle ju kunna köra med en sträng-/objektarray, och bestämma en viss ordning.


byref-parametrar kan du ju i så fall ändå bara sätta upp ett specifikt antal?
Och generics hjälper ju knappast heller, du lär ju få typomvandla ändå.

> Mina personliga åsikt är nog hashtabell/directory tillsammans med någon sorts typindikator, eller en serialiserad sträng. Jag gissar att systemet inte blir så där överdrivet effektivt ändå?

Utveckla "typindikator" lite :)

Det är en lagringen som är det stora problemet, det är snarare att "markera" vilka variabler man vill "behålla", samt att "fylla" variablerna när värdena ska hämtas ifrån cachen, som är det stora problemet.

> byref-parametrar kan du ju i så fall ändå bara sätta upp ett specifikt antal?

Mjo, tanken var väl att det skulle kunna vara en lightweight-variant om man bara har två-tre variabler allt-som-allt att hålla reda på. Det borde trots allt bli mer "säkert" med den varianten eftersom att man inte kan glömma att markera vilka variabler man vill behålla.

Min idé är att man på något sätt skulle ha typ:

string s;
float f;
DateTime d;
int kaka = CR<int>(delegate()
{
  s = "häst";
  f = 4.5;
  Keep(s, f);
  Keep(d);
  return 5;
});

Keep() skulle då vara en funktion som på något sätt skulle plocka fram referensen till den/de variabler man stoppade in, fick reda på vad variablerna hade för "adresser" och sparade sedan både "adresser" och innehåll i cachen. Hur det nu skulle gå till.. Det känns lite som att det här är gråzon för vad man kan hitta på i .NET?

> Eftersom de faktiska svaren kan variera väldigt, tror jag på en generell variant där man kan styra det på en högre nivå, kanske en sån här lösning:

Hm, efter att jag suttit och funderat igenom några gånger på hur du tänker så tror jag att jag börjar fastna på samma våglängd lite grann..

Det som skulle lösas är man kan hoppa bakåt och ändra, och fortfarande ha kvar gamla resultat utifall att man vill återskapa resultatet senare (dvs. låta gamla värden vara förifyllda t.ex.) Men jag är fortfarande inte säker på att det är riktigt vattentätt än.. Det känns som att jag måste missat något/några scenarion där "vägval" i koden beslutas av tidigare input, men sedan ändras? Funderingar?

Om jag funderar vidare på ett annat spår så.. Behöver man egentligen spara mer än en version av resultat ifrån en sida? Har man någonsin nytta av att veta mer än vad man fyllde i sist man var på ett visst steg?

Och på ytterligare ett annat spår: Om man tar min exempelkod som exempel: Vad händer och hur bör man hantera scenariot att man backar några steg och ersätter det första mellannamnet med en tom ruta ( => loopen slutar => mellannamnen som man tidigare hade fyllt i efter det första försvinner.) Visserligen kanske ett specialfall, men ett sådant specialfall skulle kunna kräva någon form av "specialhantering", som man då får hacka ihop själv? Skulle man kunna göra en konstruktion som säger att vissa delar kan man inte backa, utan att man i så fall får ha ett steg där man kan filtrera bort felaktiga inmatningar senare i programmet?

Damn you web!

Hur ska man lägga upp allting, och vilka begränsningar ska gälla? Vilka krav från non-web-världen ska man trycka in på webben för att det inte ska bli helt rörigt? Hela grejjen är ju trots allt lite att komma ifrån "webbtänket" och få lite mer "sekvenstänket". Jag känner att frågan nästan är lite ideologisk?

Vid lite närmare fundering så kan jag komma på en lösning på det där med variablerna:

Man får köra Keep() på alla variabler som är aktuella

string s;
float f;
DateTime d;
int kaka = CR<int>(delegate()
{
  s = "häst";
  f = 4.5;
  return 5;
});
Keep(ref f);
Keep(ref s);

Keep skulle sedan själv hålla koll på vilken CR som föregått anropet till Keep, och beroende på om CR har kört ifrån cache eller inte så hämtar respektive sparar anropet till Keep variabeln. Eftersom att variablerna alltid står i samma ordning så petar den tillbaka i samma ordning som den sparade.

Jag har fått en idé på (delvis) lösning på det där med hur man ska hantera framåt/bakåt:

1) Man sparar bara en enda version av allting, dvs. man ändrar istället för att lägga till i cachen
2) Man kan sätta beroenden på saker. CR-anropen ska inte längre returnera saker rakt av utan istället returnera en wrapper, ResultWrapper<T>, med egenskapen "T Result", samt en metod Depend() som returnerar en av typen SyncDepend (eller något liknande)

Man skulle då kunna ha någonting i stil med:

ResultWrapper<string> rwFirstName;
string firstName;
int age, length;
rwFirstName = CR<string>(/*någonting*/); //Frågar efter förnamn, ålder och längd
Keep(age);
Keep(length);
firstName = rwFirstName.Result;

ResultWrapper<string> rwLastName;
string lastName;
//Beroende på ålder så visar sidan olika informationstext för när man fyller i efternamn
//Exakt konstruktion vet jag inte
rwLastName = CR<string>(
  rwFirstName.Depend().On(age).On(length).ClearChildren().And().OnAll().ClearThis(),
  /*någonting*/);
lastName = rwLastName.Result;

Tanken är lite jQuery-stuk på de anropen. I exemplet skulle man då kunna kräva att om age eller length ändras så kommer den aktuella CR, inklusive ev. nästlade CR, att rensa sin cache. Oavsett vad som ändras, bara att man kört om frågan efter förnamnet (och postat sidan), så kommer den rensa den här aktuella CR, dock inte nästlade CR. Sedan skulle man kunna ha två versioner på And(), en som bara lägger till en ny gren, utan parametrar, och en som tar ytterligare en ny "SyncDepend" från ett annat CR.Depend()-anrop.

Man skulle då enkelt kunna sätta villkor på saker så att om man behåller "kort" som betalform (vilket alltid visar "betala_med_kort.aspx") men ändrar korttyp (t.ex. från "visa" till "mastercard") så måste steget där man fyller i kortnummer göras om, likaså skulle man kunna sätta som villkor att oavsett vad man ändrat i checkout-processen så måste man göra om den näst sista sidan där man accepterar villkoren)

Täcker den här lösningen alla behov?

Nu har jag knackat ihop en rätt vettig lösning på det där med att kunna komma ihåg variabler. Dessutom har jag utfört ganska övergripande kladd på all kod som går att hitta.. :)

Returnerar ett SyncResult<T>, som i sin tur har egenskapen T Result samt metoderna SyncDepend Depend() och void Keep<K>(ref K variable).

string s = null;
int a=2;
sr = CR<int>(delegate()
{
  a = 3;
  s = "kossa";
  return 4;
});
sr.Keep<int>(ref a);
sr.Keep<string>(ref s);
//sr.Result == 4
//a == 3
//s == "kossa"

Ser ut att fungera prima :)

Nu är det dags att fundera på hur man kan göra en snygg lösning för att kunna "flytta över" variabler från en sida..

Nu har jag hackat lite mer, och nu verkar det fungera ganska vettigt :)

Har gjort så att man kan lägga beroenden, som jag beskrev ovan; man kan göra beroenden på om resultat ändras, om någon variabel ändras eller om någonting inte hämtats från cache, oavsett om allting är oförändrat. Om ett beroende "triggas" så kan man välja "action" till att behålla, tömma, ta bort, tömma inkl. alla underliggande samt ta bort inkl. alla underliggande.

Skillnaden mellan att tömma resp. ta bort är väl i princip att jag har tänkt lägga till så man kan få tag på gamla värden för att t.ex. kunna fylla i ett formulär med de gamla värdena, eller liknande. Tömma skulle då behålla de värdena, men ta bort skulle rensa bort alla sådana spår. I det fallet att beroendet visar på att man kommer ta en annan väg så skulle man även kunna spara minne på det hela.

En grej till jag ändrat är att allting man vill leka med i "processen" måste kunna serializeras, sparar "processen" som en byte-array.

Nu har jag nog en hyffsat vettigt framåt/bakåt-grunka fungerande.

Har byggt en "TimeMachine" (omg!) som gör att man kan få tillgång till värden som är skapade "senare" i koden (en liten enkel Dictionary<string, object> helt enkelt) =) Har bland annat ett nytt argument till CR-funktionerna, en sträng som fungerar som nyckel till dictionaryt. Har man med den parametern så sparas en url som låter en hoppa tillbaka till det steget i dictionaryt under den keyen, dictionaryt kan sedan t.ex. användas för att generera en lista med länkar för att hoppa framåt/bakåt. Har byggt om mitt exempel med en masterpage som listar länkarna.

Den där TimeMachine-grunkan kan väl säkert användas till annat också, men, men.

Dessutom har jag lagt till en metod .GetStepUrl() på result-objekten, ifall man nu skulle behöva en url för att komma åt sidan senare

Är det någon som är intresserad av att testa grunkan? Funderar på att lägga upp en tidig alpha så man kan testa själv?

---

Funderingar på tillägg: lägga till stöd för masterpages och lite annat. (Med stöd menar jag att man kan skapa "plugins" så att man kan "lägga till" rätt masterpage på rätt sidor i processen, t.ex. en masterpage för kassan inkl. länkar framåt och bakåt i processen på "kassasidorna", men inte den masterpagen när man visar en popup för att skriva ut kvittot..)

Sitter "tyvärr" (beroende på hur man ser det) i stort sett ingenting med webapplikationer, vilket gör att jag inte har något direkt att testa med. Men lägg upp det ändå för fan!

Om inte annat är det nog intressant att lära sig från (om det är OS vill säga).

> Sitter "tyvärr" (beroende på hur man ser det) i stort sett ingenting med webapplikationer, vilket gör att jag inte har något direkt att testa med. Men lägg upp det ändå för fan!

Haha :P

> Om inte annat är det nog intressant att lära sig från (om det är OS vill säga).

Mjo, jag tänkte lägga upp inkl. kod, även om den ser ut som stryk :)

Har lagt upp hela projektet inkl. lite skräp som jag inte orkade rensa bort ur solutionen.

http://onkelborg.com/files/SyncWeb.0.0.1.0.rar

Det är mappen SyncWeb däri som innehåller exemplet, och Onkelborg.Sync som innehåller libraryt.

Är det någon som vågat sig på att titta/testa det hela?

Jepp, jag gav mig på det en kort vända, men har haft för mycket att göra för att sätta mig in i det ordentligt. Jag skulle behöva ett faktiskt problem att använda det på för att komma in i det.

Det verkar som att det bara är det vi två som är intresserade - but fear not, de andra kommer kanske snart ikapp. ;-)

Haha, jo, man kan ju hoppas :p tycker dock fortfarande att idén är rätt cool :) har haft lite svårt att få tid att knacka kod bara...