一次回答多个问题：带有窗体的交互式动画图形

namespace BouncingBall.Thread {
    using System;
    using System.Drawing;
    using System.Threading;

    partial class ThreadWrapper {

        internal class MotionEventArgs : EventArgs {
            internal MotionEventArgs(PointF coordinates) { Coordinates = coordinates; }
            internal PointF Coordinates { get; set; }
        } //class MotionEventArgs
        internal class ExceptionEventArgs : EventArgs {
            internal ExceptionEventArgs(Exception exception) { Exception = exception; }
            internal Exception Exception { get; set; }
        } //class ExceptionEventArgs

        internal ThreadWrapper() {
            Thread = new Thread(Body);
        } //ThreadWrapper

        internal void Start(bool letGo) {
            Thread.Start();
            if (!letGo) return;
            InnerLoopEvent.Set();
            OuterLoopEvent.Set();
        } //Start
        internal void Abort() {
            Thread.Abort();
        } //Abort
        internal void Pause() {
            InnerLoopEvent.Reset();
            OuterLoopEvent.Reset();
        } //Pause
        internal void Resume() {
            InnerLoopEvent.Set();
            OuterLoopEvent.Set();
        } //Resume

        internal event EventHandler<MotionEventArgs> CoordinatesChanged;
        internal event EventHandler<ExceptionEventArgs> ExceptionThrown;
        internal event EventHandler Paused;

        void Body() {
            while (true) {
                OuterLoopEvent.WaitOne();
                try {
                    InnerLoop();
                } catch (ThreadAbortException) {
                } catch (Exception exception) {
                    if (ExceptionThrown != null)
                        ExceptionThrown.Invoke(this, new ExceptionEventArgs(exception));
                } //exception
            } //do
        } //Body

        void SelfPause() {
            Pause();
            if (Paused != null)
                Paused.Invoke(this, new EventArgs());
        } //SelfPause

        ThreadExchangeData exchangeData;
        internal ThreadExchangeData ExchangeData {
            get { lock (SyncObject) return exchangeData; }
            set { lock (SyncObject) exchangeData = value; }
        } //ExchangeData

        PointF ballPosition;
        internal PointF BallPosition {
            get { lock (PositionSyncObject) return ballPosition; }
            set {
                lock (PositionSyncObject) {
                    isBallPositionDirty = true;
                    ballPosition = value;
                } //lock
            } //set BallPosition
        } //BallPosition

        Thread Thread;
        ManualResetEvent InnerLoopEvent = new ManualResetEvent(false);
        ManualResetEvent OuterLoopEvent = new ManualResetEvent(false);
        object SyncObject = new object();
        object PositionSyncObject = new object();
        bool isBallPositionDirty;

    } //class ThreadWrapper

} //namespace BouncingBall.Thread

请注意，该类是部分的，因此这里未显示某些成员（CurrentState、State、InnerLoop 和 InvertAndDampVelocity；请参阅提供的完整源代码，“ThreadWrapper.InnerLoop.cs”文件）。

线程包装器最重要的方面是它提供了数据交换和事件调用的封装，因此也提供了线程同步。

一个关键概念是使用带有虚拟方法 Body 的 System.Threading.Thread 构造函数。想法是这样的：传递给线程构造函数的方法本身可以有一个参数。这可以通过使用 ParameterizedThreadStart类型的参数的构造函数来完成。好还是坏？这很糟糕！问题在于：此委托类型接受一个非类型化参数，更确切地说，是 System.Object 类型。这种类型丢失在实践中需要类型转换，这是危险、容易出错且不易维护的事情。同时，重要的是要注意，线程构造函数接受委托实例，这意味着静态和非静态（实例）方法。当我们传递包装器实例本身的实例方法时，它的所有成员都作为一个（隐式）调用参数传递给委托：this。它全面解决了在线程实例构造期间传递参数的问题。ParameterizedThreadStart 将变得毫无意义。

另一个重要方面是使用事件处理对象进行线程节流：System.Threading.EventWaitHandle 或其两个专用形式，System.Threading.AutoResetEvent 和 System.Threading.ManualResetEvent。请注意，现代线程类没有 Pause 或 Resume 等方法；它们已被弃用并删除，因为它们极其危险。它们的危险性显而易见，但解释这一点将超出本文的主题。与这些方法相反，EventWaitHandle 的 wait 方法仅在代码中一些精确选择的点将调用线程置于等待状态，这些点非常适合这样做。在等待状态下，调用线程不花费任何 CPU 时间。当它调用非信号事件句柄对象上的 wait 方法时，调用线程会被其他线程抢占，并且不会安排执行，直到它被某些事件（由任何其他线程调用的 Abort、Interrupt 方法，超时，以及重要的是，相应 EventWaitHandle 实例的信号事件）唤醒。

“实时”

我已经解释了主要思想：我们实际上不需要严格周期性的动画帧之间的时间间隔。

最适合动画的计时工具是 System.Diagnostics.Stopwatch 类。它提供了最佳精度。请注意，我们只需要相对时间，而不是绝对日历时间。

现在，我将提出一个不那么常用甚至不那么显而易见的想法，该想法适用于我们的特定问题：使用该类的两个独立实例：一个用于 X 运动，另一个用于 Y 运动。是的，我有单独的“X 时间”和“Y 时间”。关键是：在均匀引力场（在我们的情况下是 Y 方向）中的机械运动，以及在许多其他简单情况下，对于两个方向是完全独立的，所以整个运动是两个独立任务。

这是使用 Stopwatch 的基本场景。

using Stopwatch = System.Diagnostics.Stopwatch;

// ...

partial class ThreadWrapper {

// ...

    void InnerLoop() {
        Stopwatch watchX = new Stopwatch();
        Stopwatch watchY = new Stopwatch();
        while (true) {
            InnerLoopEvent.WaitOne();
            ThreadExchangeData data = ExchangeData;
            lock (SyncObject) {
                // ...
                watchX.Stop(); watchY.Stop();
                // ...
            } 
            lock (PositionSyncObject)
                // ...
                        watchX.Reset(); watchY.Reset();
                        watchX.Start(); watchY.Start();
                // ...
                double timeX = watchX.Elapsed.TotalSeconds;
                double timeY = watchY.Elapsed.TotalSeconds;
                // ...
        // use timeX to calculate new X coordinate
        // use timeY to calculate new Y coordinate
                watchX.Reset(); watchX.Start();     
    } //InnerLoop

} //class ThreadWrapper

using Dispatcher = System.Windows.Threading.Dispatcher;

// ...

Dispatcher Dispatcher;

// ...

Dispatcher = Dispatcher.CurrentDispatcher;

// ...

Thread.ThreadWrapper Thread = new Thread.ThreadWrapper();

// ...
// in some forms initialization method ImplementSetup,
// which is called after the form's InitializeComponent() is called:

Thread.CoordinatesChanged += (sender, eventArgs) => {
    System.Action action = () => {
        Scene.Position =
            new System.Drawing.PointF(eventArgs.Coordinates.X, eventArgs.Coordinates.Y);
    };
    //with System.Windows.Forms.Control.Invoke:
    //Invoke(action);
    //with System.Windows.Threading.Dispatcher:
    Dispatcher.Invoke(action);
}; //Thread.CoordinatesChanged

partial class BallScene : Control {

    // ...
    
    public PointF Position {
        get { return position; }
        set {
            if (position == value) return;
            position = FixPosition(value);
            Invalidate();
        } //set Position
    } //Position

} //class BallScene

initialY = 2d * physicsMaxY - y;
y = initialY;
double potential = localData.Gravity * (physicsMaxY - y);
yEnergy *= 1d - localData.Damping;
double kinetic = (yEnergy - potential);
if (kinetic < 0 && localData.Friction > 0) {
    kinetic = 0;
    frictionMode = true;
    // ...
} //if

protected override void OnFormClosing(FormClosingEventArgs e) {
    Thread.Abort();
    base.OnFormClosing(e);
} //OnFormClosing

// first, entry point: 
static void Main() {
    Application.EnableVisualStyles();
    // this is how the mechanism is enabled:
    Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
    Application.SetCompatibleTextRenderingDefault(false);
    Application.Run(new FormMain());
} //Main

public partial class FormMain {

    // ...

    void ImplementSetup() {

        // ...

        Thread.ExceptionThrown += (sender, eventArgs) => {
            Invoke(new Action(() => {
                Pause();
                ShowException(Resources.UiText.FormatAnimationException, eventArgs.Exception);
            }));
        }; //Thread.ExceptionThrown

    } //ImplementSetup

    // very simplified type-agnostic exception handler: 
    void ShowException(string titleFormat, Exception exception) {
        if (exception == null) return;
        MessageBox.Show(
            string.Format(
                Resources.UiText.FormatException,
                exception.GetType().Name, exception.Message),
            string.Format(titleFormat, Application.ProductName),
            MessageBoxButtons.OK,
            MessageBoxIcon.Error);
     } //ShowException

    // ...

} //class FormMain

partial class MyForm : Form {

    // ...

    void DoSomething() {
        if (DesignMode) return;
        // now really do something :-)
    } // DoSomething

} // class MyForm

static string PersistentConfigurationFileName {
    get {
        string applicationDataDirectory =
            System.Environment.GetFolderPath(
                System.Environment.SpecialFolder.LocalApplicationData);
        return string.Format(Configuration.DefinitionSet.FmtUniqueFileName,
            applicationDataDirectory,
            System.IO.Path.DirectorySeparatorChar,
            Configuration.DefinitionSet.UniqueFileNameGuid);
    } //PersistentConfigurationFileName
} //PersistentConfigurationFileName

internal static MetadataSchema Load(string fileName) {
    DataContractSerializer serializer = new DataContractSerializer(typeof(MetadataSchema));
    using (XmlReader reader = XmlReader.Create(fileName, FastestXmlReaderSettings)) {
        return (MetadataSchema)serializer.ReadObject(reader);
    } //using
} //Load

internal void Store(string fileName) {
    DataContractSerializer serializer = new DataContractSerializer(GetType());
    using (XmlWriter writer = XmlWriter.Create(fileName, HumanReadableXmlWriterSettings)) {
        serializer.WriteObject(writer, this);
    } //using
} //Store

[assembly: AssemblyDocumentation(
    Uri = "https://www.codeproject... Many-Questions-Answered-At-Once-Graphics-WinForms")]
[assembly: ApplicationDocumentation(
    Uri = "https://www.codeproject... Many-Questions-Answered-At-Once-Graphics-WinForms")]

namespace System {

    [AttributeUsage(AttributeTargets.Assembly)]
    public class AssemblyDocumentationAttribute : System.Attribute {
        public string Uri { get { return uri; } set { this.uri = value; } }
        internal Uri Value { get { return new Uri(uri); } }
        string uri;
    } //class AssemblyDocumentationAttribute

    [AttributeUsage(AttributeTargets.Assembly)]
    public class ApplicationDocumentationAttribute : System.Attribute {
        public string Uri { get { return uri; } set { this.uri = value; } }
        internal Uri Value { get { return new Uri(uri); } }
        string uri;
    } //class ApplicationDocumentationAttribute

} //System

internal static Uri ApplicationDocumentationUri {
    get {
        object[] attributes = Assembly.GetExecutingAssembly()
            .GetCustomAttributes(
                typeof(ApplicationDocumentationAttribute), false);
        if (attributes.Length == 0) {
            return default(Uri);
        }
        return ((ApplicationDocumentationAttribute)attributes[0]).Value;
    }
} //ApplicationDocumentationUri

void Setup() {
    this.Text = String.Format(
        Resources.UiText.FormatTitleAbout, Application.ProductName);
    pictureBox.Image = Resources.Files.Logo;
    textBoxMainText.Text =
        string.Format(Resources.UiText.FormatAboutMain,
                      Application.ProductName,
                      AssemblyVersion.Major,
                      AssemblyVersion.Minor,
                      AssemblyCopyright);
    textBoxDescription.Text = AssemblyDescription;
    linkLabelArticle.Text = AssemblyDocumentationUri.ToString();
    linkLabelArticle.Click += (sender, eventArgs) => {
        System.Diagnostics.Process.Start(linkLabelArticle.Text);
    }; //linkLabelArticle.Click
} //Setup

internal void Draw(Graphics graphics, PrintPageEventArgs printPage) {
    int radius = Radius;
    graphics.SmoothingMode = SmoothingMode.HighQuality;
    graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
    graphics.TextRenderingHint = TextRenderingHint.AntiAlias;
    bool printing = printPage != null;
    Matrix textPrintTransform = default(Matrix);
    if (printing) { //indicate printer
        SetPrintPageLayout(graphics, printPage.MarginBounds);
        textPrintTransform = graphics.Transform;
        PrintFrame(graphics);
    } //if
    if (printPreview)
        PrintFrame(graphics);
    graphics.TranslateTransform(position.X + radius, position.Y + radius);
    BallRenderer.DrawBall(graphics, radius, ballColor);
    if (showVelocity) {
        float baseR = radius * 4;
        float x = velocity.X * baseR;
        float y = velocity.Y * baseR;
        float length = (float)Math.Sqrt(x * x + y * y);
        float angle;
        if (length > 0) {
            angle = (float)Math.Atan2(y, x);
            angle = (float)(angle * 180d / Math.PI);
            graphics.RotateTransform(angle);
            //graphics, vectorModule, arrowLength, arrowNotch, arrowRadius:
            BallRenderer.DrawVelocity(
                graphics, length,
                DefinitionSet.ArrowLength, DefinitionSet.ArrowNotch, DefinitionSet.ArrowRadius);
        } //if
    } //if showVelocity
    if (printing) {
        graphics.Transform = textPrintTransform;
        PrintText(graphics, false);
        return;
    } //if
    graphics.ResetTransform();
    if (PrintPreview)
        PrintText(graphics, true);
    Pen penFrame = SystemPens.ControlDark;
    if (Focused)
        penFrame = SystemPens.ControlText;
    graphics.DrawRectangle(penFrame, new Rectangle(
        ClientRectangle.Left, ClientRectangle.Top,
        ClientRectangle.Width - 1, ClientRectangle.Height - 1));
} //Draw

void PrintToImage() {
    this.Scene.PrintPreview = true;
    try {
        if (PrintToImageDialog.ShowDialog() != DialogResult.OK) return;
        using (Bitmap bitmap =
            new Bitmap(Scene.ClientRectangle.Width, Scene.ClientRectangle.Height)) {
            using (Graphics graphics = Graphics.FromImage(bitmap))
                Scene.Draw(graphics, null);
            bitmap.Save(PrintToImageDialog.FileName);
        } //using bitmap
    } finally {
        this.Scene.PrintPreview = false;
    } //exception
} //PrintToImage

void Print() {
    using (PrintDocument pd = new PrintDocument()) {
        this.Scene.PrintPreview = true;
        try {
            if (PrinterSettings != null) 
                PrintDialog.PrinterSettings = PrinterSettings;
            pd.PrintPage += (sender, eventArgs) => {
                this.Scene.Draw(eventArgs.Graphics, eventArgs);
            }; // pd.PrintPage
            DialogResult result = PrintDialog.ShowDialog();
            if (result != DialogResult.OK) return;
            PrinterSettings = PrintDialog.PrinterSettings;
            PrintDialog.Document = pd;
            pd.PrinterSettings = PrinterSettings;
            pd.Print();
        } finally {
            this.Scene.PrintPreview = false;
        } //exception
    } //using
} //Print

string location = System.Reflection.Assembly.GetEntryAssembly().Location;
string executableDirectory = System.IO.Path.GetDirectoryName(location);