TeamAAS-VP-HeShuo/TeamAAS-VM/Controls/VibrationPara.xaml.cs

using Prism.Commands;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Data.SqlTypes;
using System.Globalization;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.Remoting.Channels;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using Team.FFFeederService.Enums;
using Team.FFFeederService.Interfaces;
using Team.FFFeederService.Models;
using TeamAAS_VP;
using TouchSocket.Core;

namespace TeamAAS_VP.Controls
{
    /// <summary>
    /// VibrationPara.xaml 的交互逻辑
    /// </summary>
    public partial class VibrationPara : UserControl, INotifyPropertyChanged
    {
        private bool IsLoading = false;
        public VibrationPara()
        {
            InitializeComponent();
            this.DataContext = this;
            this.Loaded += VibrationPara_Loaded;
            ProgramCollection.Clear();
            for (int i = 1; i <= 26; i++)
            {
                ProgramCollection.Add(i);
                char chn = (char)('A' + i);
            }
        }



        #region 属性
        public IVoiceCoilMotorFeeder Feeder { get; set; }

        private ObservableCollection<int> _ProgramCollection=new ObservableCollection<int>();
        /// <summary>
        /// 振动集
        /// </summary>
        public ObservableCollection<int> ProgramCollection
        {
            get { return _ProgramCollection; }
            set { SetProperty(ref _ProgramCollection,value); }
        }

        private int _SelectProgram=-1;

        /// <summary>
        /// 当前选择的振动集编号
        /// </summary>
        public int SelectProgram
        {
            get { return _SelectProgram; }
            set { SetProperty(ref _SelectProgram, value); }
        }

        private int _SelectedShakeMotionIndex=-1;

        /// <summary>
        /// 当前选择的动作
        /// </summary>
        public int SelectedShakeMotionIndex
        {
            get { return _SelectedShakeMotionIndex; }
            set { SetProperty(ref _SelectedShakeMotionIndex, value); }
        }

        private double _Duration;
        /// <summary>
        /// 持续时间
        /// </summary>
        public double Duration
        {
            get { return _Duration; }
            set { SetProperty(ref _Duration, value); }
        }

        private VoiceMotorParam _Motor1;

        /// <summary>
        /// 音圈电机1
        /// </summary>
        public VoiceMotorParam Motor1
        {
            get { return _Motor1; }
            set { SetProperty(ref _Motor1, value); }
        }

        private VoiceMotorParam _Motor2;

        /// <summary>
        /// 音圈电机2
        /// </summary>
        public VoiceMotorParam Motor2
        {
            get { return _Motor2; }
            set { SetProperty(ref _Motor2, value); }
        }

        private VoiceMotorParam _Motor3;

        /// <summary>
        /// 音圈电机3
        /// </summary>
        public VoiceMotorParam Motor3
        {
            get { return _Motor3; }
            set { SetProperty(ref _Motor3, value); }
        }

        private VoiceMotorParam _Motor4;

        /// <summary>
        /// 音圈电机4
        /// </summary>
        public VoiceMotorParam Motor4
        {
            get { return _Motor4; }
            set { SetProperty(ref _Motor4, value); }
        }

        private bool _IsSyncChanging;

        /// <summary>
        /// 同步
        /// </summary>
        public bool IsSyncChanging
        {
            get { return _IsSyncChanging; }
            set { SetProperty(ref _IsSyncChanging, value); }
        }

        private ushort _CurrentAmplitude;
        /// <summary>
        /// 当前的振幅
        /// </summary>
        public ushort CurrentAmplitude
        {
            get { return _CurrentAmplitude; }
            set { SetProperty(ref _CurrentAmplitude, value); }
        }

        private ushort _CurrentFrequency;
        /// <summary>
        /// 当前的频率
        /// </summary>
        public ushort CurrentFrequency
        {
            get { return _CurrentFrequency; }
            set { SetProperty(ref _CurrentFrequency, value); }
        }

        private ushort _CurrentPhase;

        /// <summary>
        /// 当前相位
        /// </summary>
        public ushort CurrentPhase
        {
            get { return _CurrentPhase; }
            set { _CurrentPhase = value; }
        }

        private WaveShape _CurrentWaveShape;

        /// <summary>
        /// 当前波形
        /// </summary>
        public WaveShape CurrentWaveShape
        {
            get { return _CurrentWaveShape; }
            set { _CurrentWaveShape = value; }
        }

        #endregion

        #region 命令
        private DelegateCommand _SelectProgramCommand;
        public DelegateCommand SelectProgramCommand =>
            _SelectProgramCommand ?? (_SelectProgramCommand = new DelegateCommand(ExecuteSelectProgramCommand));

        private DelegateCommand<int?> _SelectActionCommand;
        public DelegateCommand<int?> SelectActionCommand =>
            _SelectActionCommand ?? (_SelectActionCommand = new DelegateCommand<int?>(ExecuteSelectActionCommand));

        private DelegateCommand<double?> _DurationChangedCommand;
        public DelegateCommand<double?> DurationChangedCommand =>
            _DurationChangedCommand ?? (_DurationChangedCommand = new DelegateCommand<double?>(ExecuteDurationChangedCommand));

        private DelegateCommand _ExecuteFromSelected;
        public DelegateCommand ExecuteFromSelected =>
            _ExecuteFromSelected ?? (_ExecuteFromSelected = new DelegateCommand(ExecuteExecuteFromSelected));

        private DelegateCommand _ExecuteStopCommand;
        public DelegateCommand ExecuteStopCommand =>
            _ExecuteStopCommand ?? (_ExecuteStopCommand = new DelegateCommand(ExecuteExecuteStopCommand));

        private DelegateCommand _SaveParamCommand;
        public DelegateCommand SaveParamCommand =>
            _SaveParamCommand ?? (_SaveParamCommand = new DelegateCommand(ExecuteSaveParamCommand));

        private DelegateCommand<string> _VoiceMotorParamChangedCommand;
        public DelegateCommand<string> VoiceMotorParamChangedCommand =>
            _VoiceMotorParamChangedCommand ?? (_VoiceMotorParamChangedCommand = new DelegateCommand<string>(MotorParamChangedCommand));

        private DelegateCommand<string> _WaveShapeChangedCommand;
        public DelegateCommand<string> WaveShapeChangedCommand =>
            _WaveShapeChangedCommand ?? (_WaveShapeChangedCommand = new DelegateCommand<string>(ExecuteWaveShapeChangedCommand));

        private DelegateCommand _AmplitudeChangedCommand;
        public DelegateCommand AmplitudeChangedCommand =>
            _AmplitudeChangedCommand ?? (_AmplitudeChangedCommand = new DelegateCommand(ExecuteAmplitudeChangedCommand));

        private DelegateCommand _FrequencyChangedCommand;
        public DelegateCommand FrequencyChangedCommand =>
            _FrequencyChangedCommand ?? (_FrequencyChangedCommand = new DelegateCommand(ExecuteFrequencyChangedCommand));

        #endregion

        #region 事件

        #endregion

        #region 方法

        private async void VibrationPara_Loaded(object sender, RoutedEventArgs e)
        {
            if (Feeder == null || !Feeder.IsConnected) return;
            if (SelectProgram==-1)
            {
                try
                {
                    SelectProgram = 0;
                    IsLoading = true;
                    //选择振动集
                    await Feeder.SelectShakeParamAsync(1);
                    SelectedShakeMotionIndex = 0;

                    //获取当前动作的4个电机的参数
                    var paramCollection = await Feeder.GetShakeGroupValueAsync(0);
                    Motor1 = paramCollection.Motor1;
                    Motor2 = paramCollection.Motor2;
                    Motor3 = paramCollection.Motor3;
                    Motor4 = paramCollection.Motor4;
                    Duration = (double)paramCollection.DurationValue;
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogError("Feeder参数加载时出错！", ex);
                }
                IsLoading = false;
            }
        }

        /// <summary>
        /// 选择振动集时触发
        /// </summary>
        async void ExecuteSelectProgramCommand()
        {
            if (SelectProgram == -1)
            {
                return;
            }

            if (Feeder == null)
            {
                SelectProgram = -1;
                return;
            }

            var id = SelectProgram+1;
            try
            {
                //选择振动集
                await Feeder.SelectShakeParamAsync(id);
                if (SelectedShakeMotionIndex == -1)
                {
                    SelectedShakeMotionIndex = await Feeder.GetSelectedSequenceAsync() - 1;
                    if (SelectedShakeMotionIndex < 0 || SelectedShakeMotionIndex > 25)
                    {
                        SelectedShakeMotionIndex = 0;
                    }
                }

                await Task.Delay(100);
                var selectedActionId = SelectedShakeMotionIndex;
                IsLoading = true;
                //获取当前动作的4个电机的参数
                var paramCollection = await Feeder.GetShakeGroupValueAsync(selectedActionId);
                Motor1 = paramCollection.Motor1;
                Motor2 = paramCollection.Motor2;
                Motor3 = paramCollection.Motor3;
                Motor4 = paramCollection.Motor4;
                Duration= (double)paramCollection.DurationValue;
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("Feeder选择振动集时触发时出错！", ex);
            }
            IsLoading = false;
        }

        /// <summary>
        /// 选择动作时触发
        /// </summary>
        /// <param name="index"></param>
        async void ExecuteSelectActionCommand(int? index)
        {
            if (SelectedShakeMotionIndex == -1)
            {
                return;
            }
            if (Feeder == null)
            {
                SelectedShakeMotionIndex = -1;
                return;
            }
            if (!Feeder.IsConnected)
            {
                SelectedShakeMotionIndex = -1;
                return;
            }
            try
            {
                var selectedActionId = SelectedShakeMotionIndex;
                //获取当前动作的4个电机的参数
                IsLoading=true;
                var paramCollection = await Feeder.GetShakeGroupValueAsync(selectedActionId);
                Motor1 = paramCollection.Motor1;
                Motor2 = paramCollection.Motor2;
                Motor3 = paramCollection.Motor3;
                Motor4 = paramCollection.Motor4;
                Duration = (double)paramCollection.DurationValue;
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("Feeder选择动作时触发时出错！", ex);
            }
            IsLoading = false;
        }

        /// <summary>
        /// 持续时间更改时
        /// </summary>
        /// <param name="duration"></param>
        async void ExecuteDurationChangedCommand(double? duration)
        {
            try
            {
                if (SelectedShakeMotionIndex >= 0 && Feeder != null && Feeder.IsConnected && !IsLoading)
                {
                    await Feeder.SetShakeParametersAsync(SelectedShakeMotionIndex, 16, ((int)Duration).ToString());
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("Feeder持续时间更改时出错！", ex);
            }
        }

        /// <summary>
        /// 执行动作
        /// </summary>
        async void ExecuteExecuteFromSelected()
        {
            if (SelectedShakeMotionIndex == -1)
            {
                return;
            }
            if (Feeder == null)
            {
                return;
            }

            if (!Feeder.IsConnected)
            {
                return;
            }
            try
            {
                //加载平台振动参数
                await Feeder.GetShakeParametersAsync(SelectedShakeMotionIndex);
                //执行平台动作
                await Feeder.StartAction(SelectedShakeMotionIndex, (int)Duration);
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("Feeder执行动作时出错！", ex);
            }
        }

        /// <summary>
        /// 停止动作
        /// </summary>
        async void ExecuteExecuteStopCommand()
        {
            if (Feeder == null)
            {
                return;
            }
            if (!Feeder.IsConnected)
            {
                return;
            }
            try
            {
                await Feeder.StopAsync();
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("Feeder停止动作时出错！", ex);
            }
        }

        /// <summary>
        /// 保存参数
        /// </summary>
        async void ExecuteSaveParamCommand()
        {
            try
            {
                if (Motor1 == null || Motor2 == null || Motor3 == null || Motor4 == null) return;
                var motionId = SelectedShakeMotionIndex;
                SingleActionParam singleActionParam = new SingleActionParam()
                {
                    Motor1=Motor1,
                    Motor2=Motor2,
                    Motor3=Motor3,
                    Motor4=Motor4,
                    DurationValue=(int)Duration,
                };

                await Feeder.SetShakeParametersAsync(motionId, singleActionParam);
                await Feeder.SaveShakeSetAsync();
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("Feeder保存参数时出错！", ex);
            }
        }

        /// <summary>
        /// 电机参数变更
        /// </summary>
        /// <param name="param"></param>
        async void MotorParamChangedCommand(string param)
        {
            try
            {
                if (Motor1 == null || Motor2 == null || Motor3 == null || Motor4 == null) return;
                if (IsSyncChanging)     //同步时
                {
                    if (IsLoading)
                        return;
                    IsLoading = true;
                    string[] item = param.Split('-');
                    if (Convert.ToInt16(item[1]) == 1)
                    {
                        //振幅
                        if (Convert.ToInt16(item[0]) == 1)
                        {
                            CurrentAmplitude = Motor1.Amplitude;
                            Motor2.Amplitude = CurrentAmplitude;
                            Motor3.Amplitude = CurrentAmplitude;
                            Motor4.Amplitude = CurrentAmplitude;
                        }
                        else if (Convert.ToInt16(item[0]) == 2)
                        {
                            CurrentAmplitude = Motor2.Amplitude;
                            Motor1.Amplitude = CurrentAmplitude;
                            Motor3.Amplitude = CurrentAmplitude;
                            Motor4.Amplitude = CurrentAmplitude;
                        }
                        else if (Convert.ToInt16(item[0]) == 3)
                        {
                            CurrentAmplitude = Motor3.Amplitude;
                            Motor1.Amplitude = CurrentAmplitude;
                            Motor2.Amplitude = CurrentAmplitude;
                            Motor4.Amplitude = CurrentAmplitude;
                            
                        }
                        else if (Convert.ToInt16(item[0]) == 4)
                        {
                            CurrentAmplitude = Motor4.Amplitude;
                            Motor2.Amplitude = CurrentAmplitude;
                            Motor3.Amplitude = CurrentAmplitude;
                            Motor1.Amplitude = CurrentAmplitude;
                        }
                    }
                    else if (Convert.ToInt16(item[1]) == 2)
                    {
                        //频率
                        if (Convert.ToInt16(item[0]) == 1)
                        {
                            CurrentFrequency = Motor1.Frequency;
                            Motor2.Frequency = CurrentFrequency;
                            Motor3.Frequency = CurrentFrequency;
                            Motor4.Frequency = CurrentFrequency;
                        }
                        else if (Convert.ToInt16(item[0]) == 2)
                        {
                            CurrentFrequency = Motor2.Frequency;
                            Motor1.Frequency = CurrentFrequency;
                            Motor3.Frequency = CurrentFrequency;
                            Motor4.Frequency = CurrentFrequency;
                        }
                        else if (Convert.ToInt16(item[0]) == 3)
                        {
                            CurrentFrequency = Motor3.Frequency;
                            Motor2.Frequency = CurrentFrequency;
                            Motor1.Frequency = CurrentFrequency;
                            Motor4.Frequency = CurrentFrequency;
                        }
                        else if (Convert.ToInt16(item[0]) == 4)
                        {
                            CurrentFrequency = Motor4.Frequency;
                            Motor2.Frequency = CurrentFrequency;
                            Motor3.Frequency = CurrentFrequency;
                            Motor1.Frequency = CurrentFrequency;
                        }
                    }
                    IsLoading = false;
                    var motionId = SelectedShakeMotionIndex;
                    SingleActionParam singleActionParam = new SingleActionParam()
                    {
                        Motor1 = Motor1,
                        Motor2 = Motor2,
                        Motor3 = Motor3,
                        Motor4 = Motor4,
                        DurationValue = (int)Duration,
                    };
                    await Feeder.SetShakeParametersAsync(motionId, singleActionParam);
                }
                else    //不同步时
                {
                    if (SelectedShakeMotionIndex == -1)
                    {
                        return;
                    }
                    if (Feeder == null || !Feeder.IsConnected)
                    {
                        return;
                    }
                    if (IsLoading)
                        return;
                    var motionId = SelectedShakeMotionIndex;

                    string[] item = param.Split('-');
                    if (Convert.ToInt16(item[1]) == 1)
                    {
                        //振幅
                        if (Convert.ToInt16(item[0]) == 1)
                        {
                            await Feeder.SetShakeParametersAsync(motionId, 0, Motor1.Amplitude.ToString());
                        }
                        else if (Convert.ToInt16(item[0]) == 2)
                        {
                            await Feeder.SetShakeParametersAsync(motionId, 4, Motor2.Amplitude.ToString());
                        }
                        else if (Convert.ToInt16(item[0]) == 3)
                        {
                            await Feeder.SetShakeParametersAsync(motionId, 8, Motor3.Amplitude.ToString());
                        }
                        else if (Convert.ToInt16(item[0]) == 4)
                        {
                            await Feeder.SetShakeParametersAsync(motionId, 12, Motor4.Amplitude.ToString());
                        }
                    }
                    else if (Convert.ToInt16(item[1]) == 2)
                    {
                        //频率
                        if (Convert.ToInt16(item[0]) == 1)
                        {
                            await Feeder.SetShakeParametersAsync(motionId, 1, Motor1.Frequency.ToString());
                        }
                        else if (Convert.ToInt16(item[0]) == 2)
                        {
                            await Feeder.SetShakeParametersAsync(motionId, 5, Motor2.Frequency.ToString());
                        }
                        else if (Convert.ToInt16(item[0]) == 3)
                        {
                            await Feeder.SetShakeParametersAsync(motionId, 9, Motor3.Frequency.ToString());
                        }
                        else if (Convert.ToInt16(item[0]) == 4)
                        {
                            await Feeder.SetShakeParametersAsync(motionId, 13, Motor4.Frequency.ToString());
                        }
                    }
                    else if (Convert.ToInt16(item[1]) == 3)
                    {
                        //相位
                        if (Convert.ToInt16(item[0]) == 1)
                        {
                            await Feeder.SetShakeParametersAsync(motionId, 2, Motor1.Phase.ToString());
                        }
                        else if (Convert.ToInt16(item[0]) == 2)
                        {
                            await Feeder.SetShakeParametersAsync(motionId, 6, Motor2.Phase.ToString());
                        }
                        else if (Convert.ToInt16(item[0]) == 3)
                        {
                            await Feeder.SetShakeParametersAsync(motionId, 10, Motor3.Phase.ToString());
                        }
                        else if (Convert.ToInt16(item[0]) == 4)
                        {
                            await Feeder.SetShakeParametersAsync(motionId, 14, Motor4.Phase.ToString());
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("Feeder电机参数变更时出错！", ex);
            }
        }

        /// <summary>
        /// 电机波形变更
        /// </summary>
        /// <param name="param"></param>
        async void ExecuteWaveShapeChangedCommand(string param)
        {
            if (Motor1 == null || Motor2 == null || Motor3 == null || Motor4 == null) return;
            if (SelectedShakeMotionIndex == -1)
            {
                return;
            }
            if (Feeder == null || !Feeder.IsConnected)
            {
                return;
            }
            if (IsLoading)
                return;
            IsLoading = true;
            try
            {
                string[] item = param.Split('-');
                switch (Convert.ToInt16(item[0]))
                {
                    case 1:
                        if (Motor1 != null)
                        {
                            Motor1.WaveShape = (WaveShape)(Convert.ToInt16(item[1]) - 1);
                            if (Motor1.WaveShape == WaveShape.None)
                            {
                                Motor1.Amplitude = 0;
                                Motor1.Frequency = 0;
                                Motor1.Phase = 0;
                            }
                        }
                        break;
                    case 2:
                        if (Motor2 != null)
                        {
                            Motor2.WaveShape = (WaveShape)(Convert.ToInt16(item[1]) - 1);
                            if (Motor2.WaveShape == WaveShape.None)
                            {
                                Motor2.Amplitude = 0;
                                Motor2.Frequency = 0;
                                Motor2.Phase = 0;
                            }
                        }
                        break;
                    case 3:
                        if (Motor3 != null)
                        {
                            Motor3.WaveShape = (WaveShape)(Convert.ToInt16(item[1]) - 1);
                            if (Motor3.WaveShape == WaveShape.None)
                            {
                                Motor3.Amplitude = 0;
                                Motor3.Frequency = 0;
                                Motor3.Phase = 0;
                            }
                        }
                        break;
                    case 4:
                        if (Motor4 != null)
                        {
                            Motor4.WaveShape = (WaveShape)(Convert.ToInt16(item[1]) - 1);
                            if (Motor4.WaveShape == WaveShape.None)
                            {
                                Motor4.Amplitude = 0;
                                Motor4.Frequency = 0;
                                Motor4.Phase = 0;
                            }
                        }
                        break;
                    default:
                        break;
                }
                var motionId = SelectedShakeMotionIndex;
                SingleActionParam singleActionParam = new SingleActionParam()
                {
                    Motor1 = Motor1,
                    Motor2 = Motor2,
                    Motor3 = Motor3,
                    Motor4 = Motor4,
                    DurationValue = (int)Duration,
                };
                await Feeder.SetShakeParametersAsync(motionId, singleActionParam);
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("Feeder电机波形变更时出错！", ex);
            }
            IsLoading = false;
        }

        /// <summary>
        /// 同步栏振幅更改事件
        /// </summary>
        async void ExecuteAmplitudeChangedCommand()
        {
            try
            {
                if (!IsSyncChanging) return;
                if (IsLoading) return;
                if (Motor1 == null || Motor2 == null || Motor3 == null || Motor4 == null) return;

                IsLoading = true;
                if (Motor1.WaveShape != WaveShape.None)
                {
                    Motor1.Amplitude = CurrentAmplitude;
                }
                if (Motor2.WaveShape != WaveShape.None)
                {
                    Motor2.Amplitude = CurrentAmplitude;
                }
                if (Motor3.WaveShape != WaveShape.None)
                {
                    Motor3.Amplitude = CurrentAmplitude;
                }
                if (Motor4.WaveShape != WaveShape.None)
                {
                    Motor4.Amplitude = CurrentAmplitude;
                }
                IsLoading = false;
                var motionId = SelectedShakeMotionIndex;
                SingleActionParam singleActionParam = new SingleActionParam()
                {
                    Motor1 = Motor1,
                    Motor2 = Motor2,
                    Motor3 = Motor3,
                    Motor4 = Motor4,
                    DurationValue = (int)Duration,
                };

                await Feeder.SetShakeParametersAsync(motionId, singleActionParam);
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("Feeder同步栏振幅更改事件时出错！", ex);
            }
        }

        /// <summary>
        /// 同步栏频率更改事件
        /// </summary>
        async void ExecuteFrequencyChangedCommand()
        {
            try
            {
                if (!IsSyncChanging) return;
                if (IsLoading) return;
                if (Motor1 == null || Motor2 == null || Motor3 == null || Motor4 == null) return;

                IsLoading = true;
                if (Motor1.WaveShape != WaveShape.None)
                {
                    Motor1.Frequency = CurrentFrequency;
                }
                if (Motor2.WaveShape != WaveShape.None)
                {
                    Motor2.Frequency = CurrentFrequency;
                }
                if (Motor3.WaveShape != WaveShape.None)
                {
                    Motor3.Frequency = CurrentFrequency;
                }
                if (Motor4.WaveShape != WaveShape.None)
                {
                    Motor4.Frequency = CurrentFrequency;
                }
                IsLoading = false;
                var motionId = SelectedShakeMotionIndex;
                SingleActionParam singleActionParam = new SingleActionParam()
                {
                    Motor1 = Motor1,
                    Motor2 = Motor2,
                    Motor3 = Motor3,
                    Motor4 = Motor4,
                    DurationValue = (int)Duration,
                };

                await Feeder.SetShakeParametersAsync(motionId, singleActionParam);
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("Feeder同步栏频率更改事件时出错！", ex);
            }
        }
        #endregion

        #region 属性更改通知
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Checks if a property already matches a desired value. Sets the property and
        /// notifies listeners only when necessary.
        /// </summary>
        /// <typeparam name="T">Type of the property.</typeparam>
        /// <param name="storage">Reference to a property with both getter and setter.</param>
        /// <param name="value">Desired value for the property.</param>
        /// <param name="propertyName">Name of the property used to notify listeners. This
        /// value is optional and can be provided automatically when invoked from compilers that
        /// support CallerMemberName.</param>
        /// <returns>True if the value was changed, false if the existing value matched the
        /// desired value.</returns>
        protected virtual bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string propertyName = null)
        {
            if (EqualityComparer<T>.Default.Equals(storage, value)) return false;

            storage = value;
            RaisePropertyChanged(propertyName);

            return true;
        }

        /// <summary>
        /// Checks if a property already matches a desired value. Sets the property and
        /// notifies listeners only when necessary.
        /// </summary>
        /// <typeparam name="T">Type of the property.</typeparam>
        /// <param name="storage">Reference to a property with both getter and setter.</param>
        /// <param name="value">Desired value for the property.</param>
        /// <param name="propertyName">Name of the property used to notify listeners. This
        /// value is optional and can be provided automatically when invoked from compilers that
        /// support CallerMemberName.</param>
        /// <param name="onChanged">Action that is called after the property value has been changed.</param>
        /// <returns>True if the value was changed, false if the existing value matched the
        /// desired value.</returns>
        protected virtual bool SetProperty<T>(ref T storage, T value, Action onChanged, [CallerMemberName] string propertyName = null)
        {
            if (EqualityComparer<T>.Default.Equals(storage, value)) return false;

            storage = value;
            onChanged?.Invoke();
            RaisePropertyChanged(propertyName);

            return true;
        }

        /// <summary>
        /// Raises this object's PropertyChanged event.
        /// </summary>
        /// <param name="propertyName">Name of the property used to notify listeners. This
        /// value is optional and can be provided automatically when invoked from compilers
        /// that support <see cref="CallerMemberNameAttribute"/>.</param>
        protected void RaisePropertyChanged([CallerMemberName] string propertyName = null)
        {
            OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
        }

        /// <summary>
        /// Raises this object's PropertyChanged event.
        /// </summary>
        /// <param name="args">The PropertyChangedEventArgs</param>
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs args)
        {
            PropertyChanged?.Invoke(this, args);
        }
        #endregion
    }
}