Wie animiere ich eine Strichzeichnung über eine WPF-Leinwand mit C#?

Wie animiere ich eine Linie auf einer Leinwand in C?

Frage: Wie kann ich eine Linie langsam über den Bildschirm ziehen lassen? Ich möchte C#-Code in einem WPF-Projekt verwenden.

Antwort:

Um eine Linie auf einer Leinwand in C# zu animieren, befolgen Sie diese Schritte:

1. Erstellen Sie ein Canvas-Steuerelement in Ihrem WPF-Formular.
2. Erstellen Sie eine LineViewModel-Klasse, die die Linie darstellt Sie animieren möchten.
3. Binden Sie das LineViewModel an das Canvas-Steuerelement.
4. Definieren Sie in der LineViewModel-Klasse einen Timer, der zum Animieren der Linie verwendet wird.
5. In der Timer_Tick-Ereignishandler, aktualisiert die Koordinaten der Linie, um den Animationseffekt zu erstellen.
6. Setzen Sie die Animate-Eigenschaft auf true, um den zu starten Animation.

Hier ist ein Beispiel-Codeausschnitt, der zeigt, wie man mit den bereitgestellten Schritten eine Linie auf einer Leinwand erstellt und animiert:

XAML:

<Canvas x:Name="MyCanvas" Height="500" Width="500">
  <Line x:Name="MyLine" X1="0" Y1="0" X2="100" Y2="100" Stroke="Black" StrokeThickness="2"/>
</Canvas>

C# Code:

public partial class MainWindow : Window
{
    private LineViewModel _lineViewModel;

    public MainWindow()
    {
        InitializeComponent();

        // Create the LineViewModel.
        _lineViewModel = new LineViewModel();

        // Bind the LineViewModel to the Line control.
        MyLine.SetBinding(Line.X1Property, new Binding("X1") { Source = _lineViewModel });
        MyLine.SetBinding(Line.Y1Property, new Binding("Y1") { Source = _lineViewModel });
        MyLine.SetBinding(Line.X2Property, new Binding("X2") { Source = _lineViewModel });
        MyLine.SetBinding(Line.Y2Property, new Binding("Y2") { Source = _lineViewModel });

        // Start the animation.
        _lineViewModel.Animate = true;
    }
}

public class LineViewModel : INotifyPropertyChanged
{
    #region Timer-based Animation

    private System.Threading.Timer Timer;
    private static Random Rnd = new Random();

    private bool _animate;
    public bool Animate
    {
        get { return _animate; }
        set
        {
            _animate = value;
            NotifyPropertyChanged("Animate");
            if (value)
                StartTimer();
            else
                StopTimer();
        }
    }

    private int _animationSpeed = 1;
    public int AnimationSpeed
    {
        get { return _animationSpeed; }
        set
        {
            _animationSpeed = value;
            NotifyPropertyChanged("AnimationSpeed");
            if (Timer != null)
                Timer.Change(0, 100 / value);
        }
    }

    private static readonly List<int> _animationSpeeds = new List<int> { 1, 2, 3, 4, 5 };
    public List<int> AnimationSpeeds
    {
        get { return _animationSpeeds; }
    }

    public void StartTimer()
    {
        StopTimer();
        Timer = new Timer(x => Timer_Tick(), null, 0, 100 / AnimationSpeed);
    }

    public void StopTimer()
    {
        if (Timer != null)
        {
            Timer.Dispose();
            Timer = null;
        }
    }

    private void Timer_Tick()
    {
        X1 = X1 + Rnd.Next(-2, 3);
        Y1 = Y1 + Rnd.Next(-2, 3);
        X2 = X2 + Rnd.Next(-2, 3);
        Y2 = Y2 + Rnd.Next(-2, 3);
    }

    #endregion

    #region Coordinates

    private double _x1;
    public double X1
    {
        get { return _x1; }
        set
        {
            _x1 = value;
            NotifyPropertyChanged("X1");
        }
    }

    private double _y1;
    public double Y1
    {
        get { return _y1; }
        set
        {
            _y1 = value;
            NotifyPropertyChanged("Y1");
        }
    }

    private double _x2;
    public double X2
    {
        get { return _x2; }
        set
        {
            _x2 = value;
            NotifyPropertyChanged("X2");
        }
    }

    private double _y2;
    public double Y2
    {
        get { return _y2; }
        set
        {
            _y2 = value;
            NotifyPropertyChanged("Y2");
        }
    }

    #endregion

    #region Other Properties

    private string _name;
    public string Name
    {
        get { return _name; }
        set
        {
            _name = value;
            NotifyPropertyChanged("Name");
        }
    }

    private double _thickness;
    public double Thickness
    {
        get { return _thickness; }
        set
        {
            _thickness = value;
            NotifyPropertyChanged("Thickness");
        }
    }

    public Color Color1 { get; set; }
    public Color Color2 { get; set; }

    private double _opacity = 1;
    public double Opacity
    {
        get { return _opacity; }
        set
        {
            _opacity = value;
            NotifyPropertyChanged("Opacity");
        }
    }

    #endregion

    #region INotifyPropertyChanged

    public event PropertyChangedEventHandler PropertyChanged;

    private void NotifyPropertyChanged(string propertyName)
    {
        Application.Current.Dispatcher.BeginInvoke((Action)(() =>
        {
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }));
    }

    #endregion
}

Mit diesem Ansatz können Sie eine Linie erstellen, die langsam und mit anpassbarer Geschwindigkeit über die Leinwand neu gezeichnet wird.

Das obige ist der detaillierte Inhalt vonWie animiere ich eine Strichzeichnung über eine WPF-Leinwand mit C#?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!