[C#] door lijst lopen met breakpoints

[Kayshin]

Ik heb in mijn applicatie een lijst met events, welke door een statemachine geproccessed wordt. Ik wil graag een soort van step/breakpoint functie hebben binnen deze lijst. Nu ben ik me af aan het vragen hoe ik dit het beste kan implementeren. Ik heb een eigen klasse in mijn applicatie die de statemachine bevat, die een lijst met events bevat (waar ik breakpoints in kan zetten dmv een boolean in het object van type event op true te zetten).

Wat er moet gebeuren is dat als ik het eventlog process hij het hele eventlog in principe gaat doorlopen, met pauzes bij de aangegeven breakpoints, en dat ik (op een zelfde soort manier als bij het debuggen van een stuk code) met een f9 commando (of knopje) doorga naar de volgende breakpoint. Met een eventueel ander knopje zou ik graag 1 step willen zetten.

Ik heb op google gezocht naar een implementatie hiervoor maar helaas krijg ik met mijn searches alleen maar resultaten die te maken hebben met de debugger van VS zelf, ik ben juist op zoek naar een implementatie of soort van uitleg hoe ik dit zelf kan implementeren Zijn hier standaardmanieren voor of zal ik dan toch zelf iets moeten gaan verzinnen?

[giMoz]

Het is een console applicatie? In dat geval zou Console.ReadKey() de oplossing zijn denk ik

[Kayshin]

Nee het is een Windows Forms applicatie. Ik vraag me af of er eventueel een standaardmanier is om dit te doen of dat ik zelf iets moet gaan bedenken, wat, naar mijn idee, neerkomt op het dupliceren van de lijst en deze gebruiken, waarna hij uit deze lijst steeds de events die al afgehandeld zijn verwijdert. Maar er zal hier toch een betere manier voor moeten zijn?

Eventlist is zo opgebouwd:
timestamp, trigger, breakpoint
timestamp is een datetime, trigger is de daadwerkelijke ID van de trigger die losgelaten wordt op de statemachine en breakpoint is een bool met daarin true als dit een breakpoint is. Het setten van de breakpoints is al geimplementeerd en dus geen probleem, het gaat mij puur om de gedachtengang van het breakpoint idee

[Steefph]

Misschien te simpel gedacht maar, kun je niet simpel in je functie loop een key-event inbouwen?

Als in While(!Key);

[ Voor 10% gewijzigd door Steefph op 25-02-2013 11:21 ]

[SaphuA]

.

[ Voor 100% gewijzigd door SaphuA op 31-01-2022 15:04 ]

[Kayshin]

Niet zozeer dat ik mijn code wil pauzeren maar dat ik als het ware een soort van subsets van de event list doorloop elke keer dat ik op run to next breakpoint duw. Als dit met threading opgelost kan worden, prima, maar het gaat mij even om de gedachtengang die ik aan moet houden. Kan ik dit het beste doen door in mijn object een tellertje te setten welke weet waar ik gebleven ben of zijn hier andere oplossingen voor?

Het idee waar ik mee zit is dat zogauw ik de eerste keer op run duw, hij ervan uit moet gaan dat de hele event list uiteindelijk doorlopen wordt, dus niet dat ik tot de volgende breakpoint run en dat ik daarna als het ware "opnieuw" begin met het processen van deze log maar dan met een aangepaste inhoud oid.

[ Voor 27% gewijzigd door Kayshin op 25-02-2013 12:00 ]

[pedorus]

De state bijhouden en een "single step" implementeren lijkt me inderdaad de meest logische oplossing. Alternatief zou je met DoEvents() kunnen wachten tot er op doorgaan/stoppen wordt gedrukt, maar dit lijkt me vrij lelijk.

[Kayshin]

Dus dan is de verstandigste oplossing neem ik aan ook niet om de eventlist aan te passen in mijn custom object maar gewoon steeds een subset verwerken gebaseerd op de laatste event die ik afgehandeld heb en de next breakpoint/last event.

[Rotterdammertje]

Als ik het goed begrijp bevat je state machine nu de lijst met events die hij afhandelt. Ik zou dit loskoppelen. De enige verantwoordelijkheid die de state machine heeft, is om, aan de hand van de huidige state en een trigger, bepaalde handelingen uit te voeren en een nieuwe state te bepalen. De state machine hoeft niets te weten over events en breakpoints, maar is alleen geinteresseerd in de trigger.

De lijst met events kan je buiten de state machine aflopen. Is het een event met een breakpoint, dan pauzeer je, anders voer je de trigger van het event direct in de state machine en ga je naar het volgende event. Volgens mij is het dan niet moeilijker dan dat..

[Kayshin]

Mijn state machine bevat geen lijst met events, mijn state machine controller bevate een statemachine en eventueel een lijst met events als deze ingeladen is. De reden dat dit binnen 1 klasse zit is dat ik dadelijk met verschillende statemachines moet gaan werken en dat ik alle functies ook alleen op zijn eigen state machine moet laten uitvoeren.

Ik heb het probleem al opgelost door in mijn controller class een lastevent op te slaan, welke steeds wordt geset naar het laatste event dat ik heb afgevuurd. Aan de hand hiervan maak ik een subset van mijn eventlist welke ik dan kan processen:

C#:

 /// <summary>
        /// Run the event list in the state machine to the next set breakpoint
        /// </summary>
        /// <returns>List containing the output for storage</returns>
        public Tuple<List<string>, Event> RunToBreakpoint()
        {
            List<string> tmpObj = new List<string>();
            List<Event> tmpList;
            int lastIndex, i;

            if (this.lastEvent == null)
            {
                lastIndex = 0;
            }
            else
            {
                lastIndex = this.eventList.IndexOf(this.lastEvent) + 1;
            }

            List<Event> subList = this.eventList.Skip(lastIndex).ToList();

            if ((i = subList.FindIndex(1, x => x.Breakpoint == true)) == -1)
            {
                tmpList = subList;
            }
            else
            {
                List<Event> bla = subList.SkipWhile(x => x.Breakpoint == true).ToList().GetRange(lastIndex, i);
                tmpList = subList.GetRange(0, i);
            }

            tmpObj = this.ProcessEventSet(tmpList).Item1;

            return new Tuple<List<string>, Event>(tmpObj, this.lastEvent);
        }

Dit is een Tuple omdat ik een lijst terug moet sturen naar mijn main form welke opgeslagen wordt in een bestand en ik het laatste event eventueel in mijn main form ook nog zou willen gebruiken

[ Voor 5% gewijzigd door Kayshin op 26-02-2013 14:59 ]