WPF-动态加载

1. 添加一个UserControl，命名为BusyIndicator，view为空，在其.cs文件中定义一个类

           /// <summary>
           /// 动态实体
           /// </summary>
          public class AnimationObject
          {
              public DoubleAnimation DoubleAnimation { get; set; }
   
              public TranslateTransform TranslateTransform { get; set; }
          }

2. 定义属性

   1.    #region Properties
      
              /// <summary>
              /// 系统是否后台运行
              /// </summary>
              public bool IsBusy
              {
                  get
                  {
                      return (bool)GetValue(IsBusyProperty);
                  }
                  set
                  {
                      SetValue(IsBusyProperty, value);
                      IsWorking = value;
                      if (value)
                      {
                          BeginAnimation();
                          //显示
                          base.Visibility = System.Windows.Visibility.Visible;
                      }
                      else
                      {
                          //隐藏
                          base.Visibility = System.Windows.Visibility.Collapsed;
                      }
                  }
              }
      
              /// <summary>
              /// 是否在运行
              /// </summary>
              private bool IsWorking { get; set; }
      
              /// <summary>
              /// 圆点的宽
              /// </summary>
              public new double? Width { get; set; }
      
              /// <summary>
              /// 圆点的高
              /// </summary>
              public new double? Height { get; set; }
      
              /// <summary>
              /// 圆点移动的间隔时间，秒
              /// </summary>
              public double? WaitTimeSpan { get; set; }
      
              /// <summary>
              /// 圆点的数量
              /// </summary>
              public int? EllipseCount { get; set; }
      
              /// <summary>
              /// 
              /// </summary>
              public List<AnimationObject> Ellipses { get; set; }
      
              /// <summary>
              /// 填充画刷
              /// </summary>
              public Brush Fill { get; set; }
      
              /// <summary>
              /// 轮廓画刷
              /// </summary>
              public Brush Stroke { get; set; }
      
              /// <summary>
              /// 圆点的间隔
              /// </summary>
              public int? Space { get; set; }
      
              /// <summary>
              /// 圆点的播放时长
              /// </summary>
              public double? Duration { get; set; }
      
              #endregion

3. 添加事件

   1.  #region Methods
      
              
      
              /// <summary>
              /// 加载完毕事件
              /// </summary>
              /// <param name="sender"></param>
              /// <param name="e"></param>
              private void WinViewLoaded(object sender, RoutedEventArgs e)
              {
                  InitializateData();
              }
      
              /// <summary>
              /// 初始化数据
              /// </summary>
              private void InitializateData()
              {
                  if (!Width.HasValue)
                  {
                      Width = 10;
                  }
                  if (!Height.HasValue)
                  {
                      Height = 10;
                  }
                  if (!EllipseCount.HasValue)
                  {
                      EllipseCount = 10;
                  }
                  if (!WaitTimeSpan.HasValue)
                  {
                      WaitTimeSpan = 0.3;
                  }
                  if (!Space.HasValue)
                  {
                      Space = 10;
                  }
                  if (!this.Duration.HasValue)
                  {
                      this.Duration = 0.5;
                  }
      
                  Ellipses = new List<AnimationObject>();
                  TopGrid.Children.Clear();
                  for (int i = 0; i < EllipseCount; i++)
                  {
                      Ellipses.Add(SetEllipse(i));
                  }
              }
      
              /// <summary>
              /// 设置圆点
              /// </summary>
              /// <param name="_index"></param>
              /// <returns></returns>
              private AnimationObject SetEllipse(int _index)
              {
                  //绘制一个椭圆
                  Ellipse e = new Ellipse();
      
                  e.HorizontalAlignment = System.Windows.HorizontalAlignment.Left;
                  e.VerticalAlignment = System.Windows.VerticalAlignment.Bottom;
                  e.Width = Width.Value;
                  e.Height = Height.Value;
                  e.Fill = Fill;
                  e.Stroke = Stroke;
                  e.StrokeThickness = 2;
                  TransformGroup tg = new TransformGroup();
                  e.RenderTransform = tg;
                  TranslateTransform tt = new TranslateTransform();
                  tg.Children.Add(tt);
                  DoubleAnimation da = new DoubleAnimation();
                  da.Name = "DA" + _index.ToString();
                  da.From = 0;
                  da.To = TopGrid.ActualWidth / 2 + (EllipseCount * Space) / 2 - _index * Space;
                  da.Duration = new Duration(TimeSpan.FromSeconds(this.Duration.Value));
                  da.BeginTime = TimeSpan.FromSeconds(_index * WaitTimeSpan.Value);
                  da.Completed += (s, x) =>
                  {
                      DoubleAnimation thisDa = (s as AnimationClock).Timeline as DoubleAnimation;
                      int DaIndex = int.Parse(thisDa.Name.Replace("DA", ""));
                      DoubleAnimation da2 = new DoubleAnimation();
                      da2.From = thisDa.To;
                      da2.BeginTime = thisDa.BeginTime.Value.Add(TimeSpan.FromSeconds((EllipseCount.Value - 1) * WaitTimeSpan.Value - DaIndex * WaitTimeSpan.Value));
                      da2.To = TopGrid.ActualWidth + Space * EllipseCount - Space - DaIndex * Space;
                      da2.Duration = new Duration(TimeSpan.FromSeconds(this.Duration.Value));
                      if (_index == EllipseCount - 1) //最后一个点二阶段的动画都已结束
                      {
                          da2.Completed += (ss, ee) =>
                          {
                              if (IsBusy) BeginAnimation();
                              else IsWorking = false;
                          };
                      }
                      tt.BeginAnimation(TranslateTransform.XProperty, da2);
                  };
                  TopGrid.Children.Add(e);
      
                  return new AnimationObject() { DoubleAnimation = da,TranslateTransform = tt };
              }
      
              /// <summary>
              /// 开始变动
              /// </summary>
              private void BeginAnimation()
              {
                  IsWorking = true;
                  foreach (var ell in Ellipses)
                  {
                      ell.TranslateTransform.BeginAnimation(TranslateTransform.XProperty, ell.DoubleAnimation);
                  }
              }
      
              #endregion

4. 最后运行

5.  /// <summary>
           /// 
           /// </summary>
           public BusyIndicator()
           {
               InitializeComponent();
   
               Fill = new SolidColorBrush(Colors.DarkBlue);
               Stroke = new SolidColorBrush(Colors.White);
               InitializateData();
               this.Loaded += WinViewLoaded;
           }
   
   
           public static DependencyProperty IsBusyProperty =
               DependencyProperty.RegisterAttached("IsBusy",
                               typeof(bool), 
                               typeof(BusyIndicator),
                               new FrameworkPropertyMetadata((bool)false, IsBusyChanged));
   
           /// <summary>
           /// 是否后台运行的变化事件
           /// </summary>
           /// <param name="sender"></param>
           /// <param name="e"></param>
           private static void IsBusyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
           {
               BusyIndicator waiting = sender as BusyIndicator;
               if (waiting == null)
               {
                   return;
               }
               else
               {
                   waiting.IsBusy = (bool)e.NewValue;
               }
           }