Multi Task với WPF trong C#

using System;
using System.Collections.Generic;
using System.Linq;
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 WPF_Multi_Task.ViewModel;

namespace WPF_Multi_Task
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        MainViewModel ViewModel;
        public MainWindow()
        {
            InitializeComponent();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            this.DataContext = ViewModel = new MainViewModel();
        }

        private void Window_Closed(object sender, EventArgs e)
        {
            ViewModel.SaveData();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

<Window x:Class="WPF_Multi_Task.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WPF_Multi_Task"
        mc:Ignorable="d"
        Closed="Window_Closed"
        Loaded="Window_Loaded"
        Title="WPF Multi Task - K9 from Kteam" Height="450" Width="600">
    <Window.Resources>
        <Style TargetType="Button">
            <Setter Property="Margin" Value="5"></Setter>
            <Setter Property="Width" Value="75"></Setter>
            <Setter Property="Height" Value="25"></Setter>
        </Style>
        <Style TargetType="TextBox">
            <Setter Property="Margin" Value="5"></Setter>
            <Setter Property="Width" Value="75"></Setter>
            <Setter Property="Height" Value="25"></Setter>
        </Style>
    </Window.Resources>
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="auto"></RowDefinition>
            <RowDefinition></RowDefinition>
        </Grid.RowDefinitions>

        <StackPanel Orientation="Horizontal">
            <Button Content="Close All" Command="{Binding CloseAll_CMD}"></Button>
            <Button Content="Add data" Command="{Binding AddData_CMD}"></Button>
            <TextBox Text="{Binding SettingData.TotalData, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"></TextBox>
            <Button Content="Start all" Command="{Binding StartAll_CMD}"></Button>
            <Button Content="Stop all" Command="{Binding StopAll_CMD}"></Button>
            <Button Content="Delete all" Command="{Binding DeleteAll_CMD}"></Button>
        </StackPanel>

        <Grid Grid.Row="1">
            <ListView ItemsSource="{Binding Profiles}" Margin="5">
                <ListView.View>
                    <GridView>
                        <!--<GridViewColumn Header="STT" Width="40"
                                        DisplayMemberBinding="{Binding RelativeSource={RelativeSource FindAncestor, 
                                         AncestorType={x:Type ListViewItem}}, 
                                         Converter={StaticResource IndexConverter}}" >                            
                        </GridViewColumn>-->
                        <GridViewColumn Header="STT" Width="30" DisplayMemberBinding="{Binding Index}"></GridViewColumn>
                        <GridViewColumn Header="Name" Width="100" DisplayMemberBinding="{Binding Name}">
                            <GridViewColumn.CellTemplate>
                                <DataTemplate>
                                    <TextBox Text="{Binding BindingGroupName, Mode=OneWay}" IsReadOnly="True"></TextBox>
                                </DataTemplate>
                            </GridViewColumn.CellTemplate>
                        </GridViewColumn>
                        <GridViewColumn Header="Status" Width="150" DisplayMemberBinding="{Binding Status}"></GridViewColumn>
                        <!--<GridViewColumn Header="User name" Width="150" DisplayMemberBinding="{Binding UserName}"></GridViewColumn>

                        <GridViewColumn Header="Password" Width="150" DisplayMemberBinding="{Binding Password}"></GridViewColumn>-->
                        <GridViewColumn >
                            <GridViewColumn.CellTemplate>
                                <DataTemplate>
                                    <Button Content="Open"
                                            Command="{Binding RelativeSource={RelativeSource FindAncestor, 
                                         AncestorType={x:Type Window}},Path=DataContext.OpenDriver_CMD}"
                                            CommandParameter="{Binding}"></Button>
                                </DataTemplate>
                            </GridViewColumn.CellTemplate>
                        </GridViewColumn>
                        <GridViewColumn >
                            <GridViewColumn.CellTemplate>
                                <DataTemplate>
                                    <Button Content="Close"
                                            Command="{Binding RelativeSource={RelativeSource FindAncestor, 
                                         AncestorType={x:Type Window}},Path=DataContext.CloseDriver_CMD}"
                                            CommandParameter="{Binding}"></Button>
                                </DataTemplate>
                            </GridViewColumn.CellTemplate>
                        </GridViewColumn>
                        <GridViewColumn >
                            <GridViewColumn.CellTemplate>
                                <DataTemplate>
                                    <Button Content="Stop"
                                            Command="{Binding RelativeSource={RelativeSource FindAncestor, 
                                         AncestorType={x:Type Window}},Path=DataContext.StopProfile_CMD}"
                                            CommandParameter="{Binding}"></Button>
                                </DataTemplate>
                            </GridViewColumn.CellTemplate>
                        </GridViewColumn>
                        <GridViewColumn >
                            <GridViewColumn.CellTemplate>
                                <DataTemplate>
                                    <Button Content="Start"
                                            Command="{Binding RelativeSource={RelativeSource FindAncestor, 
                                         AncestorType={x:Type Window}},Path=DataContext.StartProfile_CMD}"
                                            CommandParameter="{Binding}"></Button>
                                </DataTemplate>
                            </GridViewColumn.CellTemplate>
                        </GridViewColumn>
                        <GridViewColumn >
                            <GridViewColumn.CellTemplate>
                                <DataTemplate>
                                    <Button Content="Delete"
                                            Command="{Binding RelativeSource={RelativeSource FindAncestor, 
                                         AncestorType={x:Type Window}},Path=DataContext.DeleteProfile_CMD}"
                                            CommandParameter="{Binding}"></Button>
                                </DataTemplate>
                            </GridViewColumn.CellTemplate>
                        </GridViewColumn>                       
                        <GridViewColumn >
                            <GridViewColumn.CellTemplate>
                                <DataTemplate>
                                    <Button Content="Pause"
                                            Command="{Binding RelativeSource={RelativeSource FindAncestor, 
                                         AncestorType={x:Type Window}},Path=DataContext.PauseProfile_CMD}"
                                            CommandParameter="{Binding}"></Button>
                                </DataTemplate>
                            </GridViewColumn.CellTemplate>
                        </GridViewColumn>
                        <GridViewColumn >
                            <GridViewColumn.CellTemplate>
                                <DataTemplate>
                                    <Button Content="Resume"
                                            Command="{Binding RelativeSource={RelativeSource FindAncestor, 
                                         AncestorType={x:Type Window}},Path=DataContext.ResumeProfile_CMD}"
                                            CommandParameter="{Binding}"></Button>
                                </DataTemplate>
                            </GridViewColumn.CellTemplate>
                        </GridViewColumn>
                    </GridView>
                </ListView.View>
            </ListView>
        </Grid>
    </Grid>
</Window>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

using OpenQA.Selenium.Chrome;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WPF_Multi_Task.ViewModel;

namespace WPF_Multi_Task.Model
{
    public class ProfileDetail : BaseViewModel
    {
        private int _Index;
        public int Index { get => _Index; set { _Index = value; OnPropertyChanged(); } }

        private string _Name;
        public string Name { get => _Name; set { _Name = value; OnPropertyChanged(); } }

        private string _Status;
        public string Status { get => _Status; set { _Status = value; OnPropertyChanged(); } }

        private string _UserName;
        public string UserName { get => _UserName; set { _UserName = value; OnPropertyChanged(); } }

        private string _Password;
        public string Password { get => _Password; set { _Password = value; OnPropertyChanged(); } }

        public ChromeDriver Driver { get; set; }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WPF_Multi_Task.ViewModel;

namespace WPF_Multi_Task.Model
{
    public class SettingData : BaseViewModel
    {
        private int _TotalData;
        public int TotalData
        {
            get => _TotalData;
            set
            {

                _TotalData = value;
                OnPropertyChanged();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Input;

namespace WPF_Multi_Task.ViewModel
{
    public class BaseViewModel : ThreadController, INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
                handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }
    public class ThreadController
    {
        public delegate void ThreadAction();
        public Task _Task;
        CancellationTokenSource src;
        PauseTokenSource pauseSource;
        public bool StopTask()
        {
            if (_Task == null)
                return true;
            try
            {
                if (src == null)
                    return true;
                src.Cancel();
                return true;
            }
            catch
            {
                return false;
            }
        }

        public void TaskWait(CancellationTokenSource TokenSrouce, PauseTokenSource PauseSource)
        {
            var ct = StartTask(async () =>
            {

                while (true)
                {
                    try
                    {
                        TokenSrouce.Token.ThrowIfCancellationRequested();
                    }
                    catch
                    {
                        return;
                    }
                    await PauseSource.Token.PauseIfRequestedAsync();

                    await Task.Delay(TimeSpan.FromSeconds(1));
                }
            }, TokenSrouce, PauseSource);
        }

        public bool StartTask(ThreadAction action, CancellationTokenSource TokenSrouce, PauseTokenSource PauseSource)
        {
            if (_Task != null)
            {
                StopTask();
                _Task = null;
            }
            try
            {
                src = TokenSrouce;
                pauseSource = PauseSource;

                if (TokenSrouce == null)
                {
                    _Task = Task.Run(() => { action(); });
                }
                else
                {
                    _Task = Task.Run(() => { action(); }, TokenSrouce.Token);
                }



                return true;
            }
            catch
            {
                return false;
            }
        }

        public async Task<bool> PauseTask()
        {
            if (_Task == null)
                return true;

            try
            {
                await pauseSource.PauseAsync();
                return true;
            }
            catch
            {
                return false;
            }
        }

        public async Task<bool> ResumeTask()
        {
            if (_Task == null)
                return true;

            try
            {
                await pauseSource.ResumeAsync();
                return true;
            }
            catch
            {
                return false;
            }
        }
    }
    public class PauseTokenSource
    {
        bool _paused = false;
        bool _pauseRequested = false;

        TaskCompletionSource<bool> _resumeRequestTcs;
        TaskCompletionSource<bool> _pauseConfirmationTcs;

        readonly SemaphoreSlim _stateAsyncLock = new SemaphoreSlim(1);
        readonly SemaphoreSlim _pauseRequestAsyncLock = new SemaphoreSlim(1);

        public PauseToken Token { get { return new PauseToken(this); } }

        public async Task<bool> IsPaused(CancellationToken token = default(CancellationToken))
        {
            await _stateAsyncLock.WaitAsync(token);
            try
            {
                return _paused;
            }
            finally
            {
                _stateAsyncLock.Release();
            }
        }

        public async Task ResumeAsync(CancellationToken token = default(CancellationToken))
        {
            await _stateAsyncLock.WaitAsync(token);
            try
            {
                if (!_paused)
                {
                    return;
                }

                await _pauseRequestAsyncLock.WaitAsync(token);
                try
                {
                    var resumeRequestTcs = _resumeRequestTcs;
                    _paused = false;
                    _pauseRequested = false;
                    _resumeRequestTcs = null;
                    _pauseConfirmationTcs = null;
                    resumeRequestTcs.TrySetResult(true);
                }
                finally
                {
                    _pauseRequestAsyncLock.Release();
                }
            }
            finally
            {
                _stateAsyncLock.Release();
            }
        }

        public async Task PauseAsync(CancellationToken token = default(CancellationToken))
        {
            await _stateAsyncLock.WaitAsync(token);
            try
            {
                if (_paused)
                {
                    return;
                }

                Task pauseConfirmationTask = null;

                await _pauseRequestAsyncLock.WaitAsync(token);
                try
                {
                    _pauseRequested = true;
                    _resumeRequestTcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
                    _pauseConfirmationTcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
                    pauseConfirmationTask = WaitForPauseConfirmationAsync(token);
                }
                finally
                {
                    _pauseRequestAsyncLock.Release();
                }

                await pauseConfirmationTask;

                _paused = true;
            }
            finally
            {
                _stateAsyncLock.Release();
            }
        }

        private async Task WaitForResumeRequestAsync(CancellationToken token)
        {
            using (token.Register(() => _resumeRequestTcs.TrySetCanceled(), useSynchronizationContext: false))
            {
                await _resumeRequestTcs.Task;
            }
        }

        private async Task WaitForPauseConfirmationAsync(CancellationToken token)
        {
            using (token.Register(() => _pauseConfirmationTcs.TrySetCanceled(), useSynchronizationContext: false))
            {
                await _pauseConfirmationTcs.Task;
            }
        }

        internal async Task PauseIfRequestedAsync(CancellationToken token = default(CancellationToken))
        {
            Task resumeRequestTask = null;

            await _pauseRequestAsyncLock.WaitAsync(token);
            try
            {
                if (!_pauseRequested)
                {
                    return;
                }
                resumeRequestTask = WaitForResumeRequestAsync(token);
                _pauseConfirmationTcs.TrySetResult(true);
            }
            finally
            {
                _pauseRequestAsyncLock.Release();
            }

            await resumeRequestTask;
        }
    }

    // PauseToken - consumer side
    public struct PauseToken
    {
        readonly PauseTokenSource _source;

        public PauseToken(PauseTokenSource source) { _source = source; }

        public Task<bool> IsPaused() { return _source.IsPaused(); }

        public Task PauseIfRequestedAsync(CancellationToken token = default(CancellationToken))
        {
            return _source.PauseIfRequestedAsync(token);
        }
    }
    class RelayCommand<T> : ICommand
    {
        private readonly Predicate<T> _canExecute;
        private readonly Action<T> _execute;

        public RelayCommand(Predicate<T> canExecute, Action<T> execute)
        {
            if (execute == null)
                throw new ArgumentNullException("execute");
            _canExecute = canExecute;
            _execute = execute;
        }

        public bool CanExecute(object parameter)
        {
            return _canExecute == null ? true : _canExecute((T)parameter);
        }

        public void Execute(object parameter)
        {
            _execute((T)parameter);
        }

        public event EventHandler CanExecuteChanged
        {
            add { CommandManager.RequerySuggested += value; }
            remove { CommandManager.RequerySuggested -= value; }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307

using Newtonsoft.Json;
using OpenQA.Selenium.Chrome;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using WPF_Multi_Task.Model;

namespace WPF_Multi_Task.ViewModel
{
    public class MainViewModel : BaseViewModel
    {
        #region Properties
        private SettingData _SettingData;
        public SettingData SettingData { get => _SettingData; set { _SettingData = value; OnPropertyChanged(); } }

        private ObservableCollection<ProfileDetail> _Profiles;
        public ObservableCollection<ProfileDetail> Profiles
        {
            get => _Profiles;
            set
            {

                _Profiles = value;
                OnPropertyChanged();
            }
        }
        
        #endregion

        public MainViewModel() 
        {
            FirstLoad();
            LoadCommand();
        }

        #region CMD
        public ICommand AddData_CMD { get; set; }
        public ICommand PauseProfile_CMD { get; set; }
        public ICommand ResumeProfile_CMD { get; set; }
        public ICommand StartProfile_CMD { get; set; }
        public ICommand DeleteProfile_CMD { get; set; }
        public ICommand CreateProfile_CMD { get; set; }
        public ICommand StartAll_CMD { get; set; }
        public ICommand StopAll_CMD { get; set; }
        public ICommand StopProfile_CMD { get; set; }
        public ICommand DeleteAll_CMD { get; set; }
        public ICommand CloseAll_CMD { get; set; }
        public ICommand OpenDriver_CMD { get; set; }
        public ICommand CloseDriver_CMD { get; set; }
        #endregion

        #region Method
        void FirstLoad()
        {
            LoadSavedData();
        }

        void LoadCommand()
        {
            StopProfile_CMD = new RelayCommand<ProfileDetail>((p) => { return p != null && Profiles != null && Profiles.Contains(p); }, (p) => { StopProfile(p); });
            AddData_CMD = new RelayCommand<ProfileDetail>((p) => { return true; }, (p) => { Add500Row(); });
            PauseProfile_CMD = new RelayCommand<ProfileDetail>((p) => { return p != null && Profiles != null && Profiles.Contains(p); }, (p) => { PauseProfile(p); });
            ResumeProfile_CMD = new RelayCommand<ProfileDetail>((p) => { return p != null && Profiles != null && Profiles.Contains(p); }, (p) => { ResumeProfile(p); });
            StartProfile_CMD = new RelayCommand<ProfileDetail>((p) => { return p != null && Profiles != null && Profiles.Contains(p); }, (p) => { StartProfile(p); });
            DeleteProfile_CMD = new RelayCommand<ProfileDetail>((p) => { return p != null && Profiles != null && Profiles.Contains(p); }, async (p) =>{ StopProfile(p); await DeleteProfile(p);});
            CreateProfile_CMD = new RelayCommand<object>((p) => { return true; }, (p) => { CreateProfile(); });
            StartAll_CMD = new RelayCommand<ProfileDetail>((p) => { return Profiles != null; }, (p) => { StartAll(); });
            StopAll_CMD = new RelayCommand<ProfileDetail>((p) => { return Profiles != null; }, (p) => { StopAll(); });
            DeleteAll_CMD = new RelayCommand<ProfileDetail>((p) => { return Profiles != null; }, (p) => { DeleteAll(); });
            CloseAll_CMD = new RelayCommand<ProfileDetail>((p) => { return true; }, (p) => { CloseAllDriver(); });
            OpenDriver_CMD = new RelayCommand<ProfileDetail>((p) => { return p != null; }, (p) => { p.StartTask(() => { OpenDriver(p); }, null,null);  });
            CloseDriver_CMD = new RelayCommand<ProfileDetail>((p) => { return p != null; }, (p) => { p.StartTask(() => { CloseDriver(p); }, null, null);  });
        }
        void Demo()
        {
            MessageBox.Show("DDDDD");
        }

        void StopProfile(ProfileDetail p)
        {
            p.Status = "Being stop";
            p.StopTask();
            p.Status = "Stop";
        }

        async void PauseProfile(ProfileDetail p)
        {
            if (await p.PauseTask())
            {
                p.Status = "Paused";
            }
        }

        async void ResumeProfile(ProfileDetail p)
        {
            if (await p.ResumeTask())
            {
                p.Status = "Resumed";
            }
        }

        void StartAll()
        {
            StartTask(() => {
                foreach (var item in Profiles)
                {
                    StartProfile(item);
                }
            }, null, null);
        }

        void CloseAllDriver()
        {
            StartTask(() => {
                foreach (var item in Profiles)
                {
                    StopProfile(item);
                    CloseDriver(item);
                }
            }, null, null);
        }
        void DeleteAll()
        {
            StartTask(async() => {
                while (Profiles.Count > 0)
                {
                    var item = Profiles.First();
                    StopProfile(item);
                    await DeleteProfile(item);
                }
              
            }, null, null);
        }

        void StopAll()
        {
            StartTask(() => {
                foreach (var item in Profiles)
                {
                    StopProfile(item);
                }
            }, null, null);
        }

        void Add500Row()
        {
            StartTask(() => {
                for (int i = 0; i < SettingData.TotalData; i++)
                {
                    CreateProfile(i + "");
                }
            }, null, null);
        }

        void OpenDriver(ProfileDetail p)
        {
            CloseDriver(p);
            p.Driver = new ChromeDriver();
        }

        void CloseDriver(ProfileDetail p)
        {
            if (p.Driver != null)
            {
                try
                {
                    p.Driver.Quit();
                }
                catch
                {

                }
            }
        }

        void StartProfile(ProfileDetail p)
        {
            CancellationTokenSource sourceToken = new CancellationTokenSource();
            PauseTokenSource pauseToken = new PauseTokenSource();
            var ct = p.StartTask(async () =>
            {
                OpenDriver(p);
                p.Driver.Navigate().GoToUrl("https://howkteam.vn/");

                while (true)
                {
                    p.Status = $"Working...{DateTime.Now.Second}";
                    p.Driver.Navigate().GoToUrl("https://howkteam.vn/learn");
                    await Task.Delay(TimeSpan.FromSeconds(5));
                    try
                    {
                        sourceToken.Token.ThrowIfCancellationRequested();
                    }
                    catch
                    {
                        return;
                    }
                    await pauseToken.Token.PauseIfRequestedAsync();


                    p.Driver.Navigate().GoToUrl("https://howkteam.vn/question");
                    await Task.Delay(TimeSpan.FromSeconds(5));
                    try
                    {
                        sourceToken.Token.ThrowIfCancellationRequested();
                    }
                    catch
                    {
                        return;
                    }
                    await pauseToken.Token.PauseIfRequestedAsync();
                }              

            }, sourceToken, pauseToken);
        }

        async Task DeleteProfile(ProfileDetail p)
        {
            p.Status = $"Deleting Profile";
            await Application.Current.Dispatcher.InvokeAsync(new Action(() =>
            {
                p.Status = $"Removing";
                Profiles.Remove(p);
                UpdateProfileIndex();
            }));
        }

        void UpdateProfileIndex()
        {
            if (Profiles == null || Profiles.Count == 0)
            {
                return;
            }
            int i = 0;
            foreach (var item in Profiles)
            {
                item.Index = ++i;
            }
        }

        ProfileDetail CreateProfile(string profileName = null)
        {
            if(Profiles == null)
            {
                Profiles = new ObservableCollection<ProfileDetail>();
            }
            var profile = new ProfileDetail() { Name = profileName, Status = "Created" };
            Application.Current.Dispatcher.InvokeAsync(new Action(() =>
            {
                Profiles.Add(profile);
                UpdateProfileIndex();
            }));

            return profile;
        }

        void LoadSavedData()
        {
            try
            {
                var text = File.ReadAllText("Saved.txt");
                SettingData = JsonConvert.DeserializeObject<SettingData>(text);

            }
            catch
            {

            }

            if (SettingData == null)
            {
                SettingData = new SettingData();
                SettingData.TotalData = 100;
            }
        }

        public void SaveData()
        {
            try
            {
                File.WriteAllText("Saved.txt", JsonConvert.SerializeObject(SettingData));
            }
            catch { }
        }
        #endregion
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296