円弧アニメーションによるカウントダウン制御

もっと一貫性のあるものがいくつかあります。

  public static readonly DependencyProperty StartAngleProperty =
        DependencyProperty.Register（ "StartAngle"、typeof（double）、typeof（Arc）、
            new FrameworkPropertyMetadata（0.0、FrameworkPropertyMetadataOptions.AffectsRender））;
 

  public static readonly DependencyProperty SecondsProperty =
        DependencyProperty.Register（nameof（Seconds）、typeof（int）、typeof（Countdown）、新しいPropertyMetadata（0））;
 

Countdown.xaml.cs の依存関係プロパティは nameof を使用しますが、 Arc.cs のものは使用しません。 IMOは彼らがすべきです。

   //Using a DependencyProperty as the backing store for SmallAngle.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty SmallAngleProperty =
        DependencyProperty.Register("SmallAngle", typeof(bool), typeof(Arc),
            new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.AffectsRender));

    static Arc() => DefaultStyleKeyProperty.OverrideMetadata(typeof(Arc), new FrameworkPropertyMetadata(typeof(Arc)));

Arc.cs の依存関係プロパティにはすべてコメントがありますが、コンストラクタにはありません。 IMOのコンストラクタは理解するのが難しいです。コメントなしでそれを理解するのに十分なWPFを誰かが知っている場合、依存関係プロパティに関するコメントは必要ありません。

            double startAngleRadians = StartAngle * Math.PI/180;
            double endAngleRadians = EndAngle * Math.PI/180;

            double a0 = StartAngle < 0 ? startAngleRadians + 2 * Math.PI : startAngleRadians;
            double a1 = EndAngle < 0 ? endAngleRadians + 2 * Math.PI : endAngleRadians;

            if (a1 < a0)
                a1 += Math.PI * 2;

            SweepDirection d = SweepDirection.Counterclockwise;
            bool large;

            if (SmallAngle)
            {
                large = false;
                double t = a1;
                d = (a1 - a0) > Math.PI ? SweepDirection.Counterclockwise : SweepDirection.Clockwise;
            }
            else
                large = (Math.Abs(a1 - a0) < Math.PI);

ここで何が起こっているのかを説明するために私は間違いなくいくつかのコメントを使用することができます。特に最後の行は非常に直感に反するように見えます。

デッドラインもあります。 t はどこにも使用されていません。

ローカライズできません...

  _timer.Start（）;
            _timer.Tick + = Timer_Tick;
 

実際には起こりそうもないが、技術的には 競合状態になっている。 2行の順番を入れ替えることには利点があるだけです。

...タイムアウトを設定するためにSeconds依存プロパティを追加しました。秒を表示するためにbinding Content = "{Binding Seconds}" を使用しています。アニメーションの長さは   背後にあるコードで設定

  Animation.Duration = new Duration（TimeSpan.FromSeconds（Seconds））;
 

     

何も書かずにXAMLでそれが可能かどうかわからないので   カスタムコンバータカスタムコンバータを作成することはできないと思います   ここで正当化した。

バインディングプロパティを TimeSpan （ Seconds からのようなものに変更する）にすることで、カスタムコンバータなしでそれができると思います 。 TimeRemaining ）とラベルコンテンツのバインディングでの StringFormat の使用私はこれをテストしていません。

これを行うならば、あなたはセッターの最も近い秒に丸めることによって非整数の TimeSpan.TotalSeconds 値を処理したいかもしれません。

1） DispatcherTimer は定期的なUIの更新には適していますが、正確さが不十分なため、時間の測定には使用しないでください。正確な時間を測定するには、タイマーコールバック内で Stopwatch クラスを使用する必要があります。

2） Seconds プロパティは明らかに2つのことをします：それは "countdown duration"として始まりますが、コントロールがロードされた後は "残り時間"として振舞います。ここでは2つのプロパティを使用して、必要に応じてそれらを別々にデータバインドできるようにします。

3） DataContext = this; - 再利用可能な公開型に DataContext を設定しないでください。誰かが（あなた自身を含めて）MVVM環境でこのクラスを使うことを最終的に決めることができますが、あなたのクラスの DataContext を変更することはそれを壊すでしょう。内部では、 Binding クラスの RelativeSource または ElementName プロパティ、または DependencyProperty コールバックを使用して入札を行います DataContext が空です。

これが ElementName の使用例です。

 ...
         
         
 ...
 

2つのタイマー/タイムラインを同時に実行しているのは嫌いです。代わりに、コードビハインドからアニメーションを実行することができます。それはまたあなたにload以外の場所からそれを引き起こす機会を与えます：

private void StartAnimation()
{
  double from = -90;
  double to = 270;
  int seconds = Seconds;
  TimeSpan duration = TimeSpan.FromSeconds(Seconds);

  DoubleAnimation animation = new DoubleAnimation(from, to, new Duration(duration));

  Storyboard.SetTarget(animation, Arc);
  Storyboard.SetTargetProperty(animation, new PropertyPath("EndAngle"));

  Storyboard storyboard = new Storyboard();
  storyboard.CurrentTimeInvalidated += (s, e) =>
  {
    int diff = (int)((s as ClockGroup).CurrentTime.Value.TotalSeconds); 
    Seconds = seconds - diff;
  };

  storyboard.Children.Add(animation);
  storyboard.Begin();
}

private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
  StartAnimation();
  //Animation.Duration = new Duration(TimeSpan.FromSeconds(Seconds));
  //if (Seconds > 0)
  //{
 // _timer.Tick += Timer_Tick;
 // _timer.Start();
  //}
}

私のソリューションに対するほぼすべての推奨事項を取り入れましたが、最も過激なものは承認された回答です。どんなフィードバックでも大歓迎です！

Start と Stop のパブリックメソッドと Elapsed イベントも追加しました。

結果：

Arc.cs

public class Arc : Shape
{
    public Point Center
    {
        get => (Point)GetValue(CenterProperty);
        set => SetValue(CenterProperty, value);
    }

    public static readonly DependencyProperty CenterProperty =
        DependencyProperty.Register(nameof(Center), typeof(Point), typeof(Arc),
            new FrameworkPropertyMetadata(new Point(), FrameworkPropertyMetadataOptions.AffectsRender));

    public double StartAngle
    {
        get => (double)GetValue(StartAngleProperty);
        set => SetValue(StartAngleProperty, value);
    }

    public static readonly DependencyProperty StartAngleProperty =
        DependencyProperty.Register(nameof(StartAngle), typeof(double), typeof(Arc),
            new FrameworkPropertyMetadata(0.0, FrameworkPropertyMetadataOptions.AffectsRender));

    public double EndAngle
    {
        get => (double)GetValue(EndAngleProperty);
        set => SetValue(EndAngleProperty, value);
    }

    public static readonly DependencyProperty EndAngleProperty =
        DependencyProperty.Register(nameof(EndAngle), typeof(double), typeof(Arc),
            new FrameworkPropertyMetadata(90.0, FrameworkPropertyMetadataOptions.AffectsRender));

    public double Radius
    {
        get => (double)GetValue(RadiusProperty);
        set => SetValue(RadiusProperty, value);
    }

    public static readonly DependencyProperty RadiusProperty =
        DependencyProperty.Register(nameof(Radius), typeof(double), typeof(Arc),
            new FrameworkPropertyMetadata(10.0, FrameworkPropertyMetadataOptions.AffectsRender));

    public bool SmallAngle
    {
        get => (bool)GetValue(SmallAngleProperty);
        set => SetValue(SmallAngleProperty, value);
    }

    public static readonly DependencyProperty SmallAngleProperty =
        DependencyProperty.Register(nameof(SmallAngle), typeof(bool), typeof(Arc),
            new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.AffectsRender));

    static Arc() => DefaultStyleKeyProperty.OverrideMetadata(typeof(Arc), new FrameworkPropertyMetadata(typeof(Arc)));

    protected override Geometry DefiningGeometry
    {
        get
        {
            double startAngleRadians = StartAngle * Math.PI/180;
            double endAngleRadians = EndAngle * Math.PI/180;

            double a0 = StartAngle < 0 ? startAngleRadians + 2 * Math.PI : startAngleRadians;
            double a1 = EndAngle < 0 ? endAngleRadians + 2 * Math.PI : endAngleRadians;

            if (a1 < a0)
                a1 += Math.PI * 2;

            SweepDirection d = SweepDirection.Counterclockwise;
            bool large;

            if (SmallAngle)
            {
                large = false;
                d = (a1 - a0) > Math.PI ? SweepDirection.Counterclockwise : SweepDirection.Clockwise;
            }
            else
                large = (Math.Abs(a1 - a0) < Math.PI);

            Point p0 = Center + new Vector(Math.Cos(a0), Math.Sin(a0)) * Radius;
            Point p1 = Center + new Vector(Math.Cos(a1), Math.Sin(a1)) * Radius;

            List<pathSegment> segments = new List<pathSegment>
            {
                new ArcSegment(p1, new Size(Radius, Radius), 0.0, large, d, true)
            };

            List<pathFigure> figures = new List<pathFigure>
            {
                new PathFigure(p0, segments, true)
                {
                    IsClosed = false
                }
            };

            return new PathGeometry(figures, FillRule.EvenOdd, null);
        }
    }
}

Countdown.xaml

Countdown.xaml.cs

public partial class Countdown : UserControl
{
    public Duration Duration
    {
        get => (Duration)GetValue(DurationProperty);
        set => SetValue(DurationProperty, value);
    }

    public static readonly DependencyProperty DurationProperty =
        DependencyProperty.Register(nameof(Duration), typeof(Duration), typeof(Countdown), new PropertyMetadata(new Duration()));

    public int SecondsRemaining
    {
        get => (int)GetValue(SecondsRemainingProperty);
        set => SetValue(SecondsRemainingProperty, value);
    }

    public static readonly DependencyProperty SecondsRemainingProperty =
        DependencyProperty.Register(nameof(SecondsRemaining), typeof(int), typeof(Countdown), new PropertyMetadata(0));

    public event EventHandler Elapsed;

    private readonly Storyboard _storyboard = new Storyboard();

    public Countdown()
    {
        InitializeComponent();

        DoubleAnimation animation = new DoubleAnimation(-90, 270, Duration);
        Storyboard.SetTarget(animation, Arc);
        Storyboard.SetTargetProperty(animation, new PropertyPath(nameof(Arc.EndAngle)));
        _storyboard.Children.Add(animation);

        DataContext = this;
    }

    private void Countdown_Loaded(object sender, EventArgs e)
    {
        if (IsVisible)
            Start();
    }

    public void Start()
    {
        Stop();

        _storyboard.CurrentTimeInvalidated += Storyboard_CurrentTimeInvalidated;
        _storyboard.Completed += Storyboard_Completed;

        _storyboard.Begin();
    }

    public void Stop()
    {
        _storyboard.CurrentTimeInvalidated -= Storyboard_CurrentTimeInvalidated;
        _storyboard.Completed -= Storyboard_Completed;

        _storyboard.Stop();
    }

    private void Storyboard_CurrentTimeInvalidated(object sender, EventArgs e)
    {
        ClockGroup cg = (ClockGroup)sender;
        if (cg.CurrentTime == null) return;
        TimeSpan elapsedTime = cg.CurrentTime.Value;
        SecondsRemaining = (int)Math.Ceiling((Duration.TimeSpan - elapsedTime).TotalSeconds);
    }

    private void Storyboard_Completed(object sender, EventArgs e)
    {
        if (IsVisible)
            Elapsed?.Invoke(this, EventArgs.Empty);
    }
}

使用例