Change timer at runtime c#

Question

Iv'e created a timer using dispatcher time :

time = new DispatcherTimer();
time.Interval = new TimeSpan(0, 0, 0, 0, 80);

and I use it for the speed of an object.Each tick the objects moves 10 pixels. I would like to know how to increase the speed of the object without changing the pixels it moves each tick, meaning I want to make the timer itself faster during run time every 10 seconds or so. Is there a way I can do it?Ive tried making a variable speed=0 and increasing it each time I count 10 and then

time.Interval = new TimeSpan(0, 0, 0, 0, 80-speed); 

but The object stayed in the same speed.So do I have to make my own timer class instead of using the built in dispatcher time, if so how do I do that?or is there another solution for this?

Answer 1

I think that DispatcherTimer is not your best ally for this task. The class is by no means designed to execute actions at precise intervals.

I'll try to better explain myself: even if the DispatcherTimer, as its name suggests, dispatches actions timely and with a great precision, the dispatched actions will be queued and then executed when the underlying GUI thread decides to process them.

Normally, a GUI thread has a resolution of around 8ms (it's an approximation, but I don't think we need to measure this right now)... and you are using a starting Interval of 80ms that is going to decrease over time until it probably goes beyond that tolerance limit of 8ms or so. In the meanwhile, you are also repainting your interface (or part of it) over and over and this impacts the performance and the responsiveness of the GUI even more: if the GUI thread is busy repainting and that requires more than the Interval value to be accomplished, the next dispatched action will be processed only once the GUI thread completes the undergoing task.

If you need a more precise scheduling, avoiding hangings / losses of responsiveness / delayed actions, you need to use a timer class that runs in background like System.Threading.Timer (google for SyncronizationContext, that would be helpful) or System.Timers.Timer.

On the top of that, never play with intervals when showing a change in speed. Work with a fixed interval and increase/decrease the movement "size" in pixels. You should be able to calculate the delta without problems. Just to make things clearer: if I want to slow that the speed of an object doubled, I don't half the timer interval that draws the object, but I double the amount of pixels my object traverses at each step.

Answer 2

using System;
using System.Collections.Generic;
using System.Linq;

namespace CQRS_and_EventSourcing
{
    internal class Program
    {
        //CQRS = command query responsibility segregation
        //CQS= command query separation

        //COMMAND

        public class PersonStroge
        {
            Dictionary<int, Person> people;
        }

        public class Person
        {
            public int UniqueId;
            public int age;
            EventBroker broker;

            public Person(EventBroker broker)
            {
                this.broker = broker;
                broker.Commands += BrokerOnCommands;
                broker.Queries += BrokeronQueries;
            }

            private void BrokeronQueries(object sender, Query query)
            {
                var ac = query as AgeQuery;
                if (ac != null && ac.Target == this)
                {
                    ac.Result = age;
                }
            }

            private void BrokerOnCommands(object sender, Command command)
            {
                var cac = command as ChangeAgeCommand;
                if (cac != null && cac.Target == this)
                {
                    if (cac.Register)
                        broker.AllEvents.Add(new AgeChangedEvent(this, age, cac.Age));
                    age = cac.Age;
                }
            }
            public bool CanVote => age >= 16;
        }
        public class EventBroker
        {
            //1. All events that happened.
            public IList<Event> AllEvents = new List<Event>();
            //2. Commands
            public event EventHandler<Command> Commands;
            //3. Query
            public event EventHandler<Query> Queries;

            public void Command(Command c)
            {
                Commands?.Invoke(this, c);
            }

            public T Query<T>(Query q)
            {
                Queries?.Invoke(this, q);
                return (T)q.Result;
            }

            public void UndoLast()
            {
                var e = AllEvents.LastOrDefault();
                var ac = e as AgeChangedEvent;
                if (ac != null)
                {
                    Command(new ChangeAgeCommand(ac.Target, ac.OldValue) { Register = false });
                    AllEvents.Remove(e);
                }
            }
        }
        public class Query
        {
            public object Result;
        }
        public class AgeQuery : Query
        {
            public Person Target;
        }
        public class Command : EventArgs
        {
            public bool Register = true;
        }
        public class ChangeAgeCommand : Command
        {
            public Person Target;
            //public int TargetId;
            public int Age;

            public ChangeAgeCommand(Person target, int age)
            {
                Target = target;
                Age = age;
            }
        }

        public class Event
        {
            //backtrack
        }
        public class AgeChangedEvent : Event
        {
            public Person Target;
            public int OldValue, NewValue;

            public AgeChangedEvent(Person target, int oldValue, int newValue)
            {
                Target = target;
                OldValue = oldValue;
                NewValue = newValue;
            }
            public override string ToString()
            {
                return $"Age changed from {OldValue} to {NewValue}";
            }
        }

        static void Main(string[] args)
        {
            var eb = new EventBroker();
            var p = new Person(eb);

            eb.Command(new ChangeAgeCommand(p, 123));

            foreach (var e in eb.AllEvents)
            {
                Console.WriteLine(e);
            }
            //int age;

            //age = eb.Query<int>(new AgeQuery { Target = p });
            //Console.WriteLine(age);

            //eb.UndoLast();
            //foreach (var e in eb.AllEvents)
            //{
            //    Console.WriteLine(e);
            //}

            //age = eb.Query<int>(new AgeQuery { Target = p });
            //Console.WriteLine(age);

            Console.ReadKey();
        }
    }
}

?f you couldnt make look at this repository; [1]:https://github.com/kYasinAblay/DNesteruk.Additional.Lectures/blob/master/CQRS_and_EventSourcing/Program.cs