protected virtual void Dispose(bool disposing)
{
if (disposing)
{
WorkerCommands?.Dispose();
}
}
public void Destroy()
{
if (_destroyed)
{
return;
}
_destroyed = true;
foreach (var disposable in _disposables)
{
disposable.Dispose();
}
_disposables.Clear();
Ticker.UnregisterTicked(this);
Ticker.UnregisterTicked(EntityManager);
Ticker.UnregisterTicked(PhysicsEngine);
Ticker.UnregisterTicked(ChunkManager);
BackgroundWorker?.Dispose();
EntityManager.Dispose();
EntityManager = null;
ChunkManager.Dispose();
ChunkManager = null;
Player.Dispose();
Ticker.Dispose();
}
protected virtual void Dispose(bool disposing)
{
Worker?.Dispose();
Worker = null;
PurgeWorker?.Dispose();
PurgeWorker = null;
}
/// ------------------------------------------------------------------------------------
public void Dispose()
{
m_worker?.Dispose();
m_project = null;
m_dataSource = null;
m_fwDsInfo = null;
}
public void Stop()
{
timer.Stop();
Dock = DockStyle.None;
Visible = false;
bgWorker?.Dispose();
}
private void FormMain_FormClosing(object sender, FormClosingEventArgs e)
{
_backgroundWorker?.CancelAsync();
_backgroundWorker?.Dispose();
_logBuilder.AppendLine();
File.AppendAllText(Path.Combine(Path.GetTempPath(), $"ZipExtractor-{startTime.ToString("yyyy-dd-M--HH-mm-ss")}.log"), _logBuilder.ToString());
}
private void Window_Closed(object sender, EventArgs e)
{
Logger?.Info("Application closing");
_detectionWorker?.Dispose();
_patchWorker?.Dispose();
_packageWorker?.Dispose();
_updateWorker?.Dispose();
_snapshotWorker?.Dispose();
}
private void InitWorker()
{
_worker?.Dispose();
_worker = new BackgroundWorker {
WorkerSupportsCancellation = true
};
_worker.DoWork += DoWork;
_worker.RunWorkerAsync();
}
private void InitializeSeekWorker()
{
_seekBackgroundWorker?.Dispose();
_seekBackgroundWorker = new BackgroundWorker
{
WorkerReportsProgress = true,
WorkerSupportsCancellation = true
};
_seekBackgroundWorker.DoWork += (s, e) =>
{
this.Invoke(() => MessageStatusLabel.Text = "Seeking...");
this.Invoke(() => SavingProgressBar.Visible = true);
for (;;)
{
if (_seekBackgroundWorker.CancellationPending || !IsHandleCreated || !MainForm.PauseOnFrame.HasValue)
{
e.Cancel = true;
break;
}
int diff = Emulator.Frame - _seekStartFrame.Value;
int unit = MainForm.PauseOnFrame.Value - _seekStartFrame.Value;
double progress = 0;
if (diff != 0 && unit != 0)
{
progress = (double)100d / unit * diff;
}
if (progress < 0)
{
progress = 0;
}
else if (progress > 100)
{
progress = 100;
}
_seekBackgroundWorker.ReportProgress((int)progress);
System.Threading.Thread.Sleep(1);
}
};
_seekBackgroundWorker.ProgressChanged += (s, e) =>
{
this.Invoke(() => SavingProgressBar.Value = e.ProgressPercentage);
};
_seekBackgroundWorker.RunWorkerCompleted += (s, e) =>
{
this.Invoke(() => SavingProgressBar.Visible = false);
this.Invoke(() => MessageStatusLabel.Text = "");
};
}
public void TaskStop(BackgroundWorker worker, frmATLTask frm)
{
try
{
frm.bExit = true;
frm.Close();
worker?.Dispose();
}
catch (Exception err)
{
MessageBox.Show(err.Message);
}
}
private bool _disposedValue; // Для определения избыточных вызовов
private void Dispose(bool disposing)
{
if (!_disposedValue)
{
if (disposing)
{
BackgroundWorkerReadRz?.Dispose();
_radToggleButtonElementRec.Dispose();
}
// TODO: освободить неуправляемые ресурсы (неуправляемые объекты) и переопределить ниже метод завершения.
// TODO: задать большим полям значение NULL.
_disposedValue = true;
}
}
private void CleanCacheWithWorker()
{
if (_currentWorker != null && _currentWorker.IsBusy || SelectedItems == null || SelectedItems.Count == 0)
{
return;
}
_currentWorker?.Dispose();
_currentWorker = new BackgroundWorker()
{
WorkerReportsProgress = true, WorkerSupportsCancellation = true
};
_currentWorker.ProgressChanged += CleanCleanBackgroundWorker_ProgressChanged;
_currentWorker.DoWork += CleanCleanBackgroundWorker_DoWork;
_currentWorker.RunWorkerCompleted += CleanCleanBackgroundWorker_RunWorkerCompleted;
_currentWorker.RunWorkerAsync();
ExecuteDelayCommands();
}
private void ResetForm()
{
productCodeLabel.Text = "";
gameTitleLabel.Text = "";
irdMatchLabel.Text = "";
discSizeLabel.Text = "";
step1StatusLabel.Text = "▶";
step2StatusLabel.Text = "";
step3StatusLabel.Text = "";
step4StatusLabel.Text = "";
step1Label.Text = "Insert PS3 game disc";
step2Label.Text = "Select disc key file";
step3Label.Text = "Decrypt and copy files";
step4Label.Text = "Validate integrity";
step2Label.Enabled = false;
step3Label.Enabled = false;
step4Label.Enabled = false;
currentDumper = null;
discBackgroundWorker?.Dispose();
discBackgroundWorker = new BackgroundWorker {
WorkerSupportsCancellation = true, WorkerReportsProgress = true
};
discBackgroundWorker.DoWork += DetectPs3DiscGame;
discBackgroundWorker.RunWorkerCompleted += DetectPs3DiscGameFinished;
settingsButton.Enabled = true;
rescanDiscsButton.Enabled = true;
rescanDiscsButton.Visible = true;
selectIrdButton.Visible = false;
selectIrdButton.Enabled = false;
startDumpingButton.Visible = false;
startDumpingButton.Enabled = false;
cancelDiscDumpButton.Visible = false;
cancelDiscDumpButton.Enabled = false;
dumpingProgressLabel.Visible = false;
dumpingProgressLabel.Text = "";
dumpingProgressBar.Visible = false;
dumpingProgressBar.Value = 0;
taskbarItemInfo.ProgressState = TaskbarItemProgressState.None;
taskbarItemInfo.ProgressValue = 0;
}
public void Destroy()
{
if (_destroyed)
{
return;
}
_destroyed = true;
Ticker.UnregisterTicked(this);
Ticker.UnregisterTicked(EntityManager);
Ticker.UnregisterTicked(PhysicsEngine);
Ticker.UnregisterTicked(ChunkManager);
BackgroundWorker?.Dispose();
EntityManager.Dispose();
ChunkManager.Dispose();
Player.Dispose();
Ticker.Dispose();
}
//加载关键词
void Rp23KeyWords_Loaded(object sender, RoutedEventArgs e)
{
CTKeyWord.ItemsSource = mRootItem1.Children;
//this.CBDepartBasic.SelectedIndex = 0;
mRootItem1.Children.Clear();
itemRootKW.Children.Clear();
mWorker = new BackgroundWorker();
mWorker.DoWork += (s, de) =>
{
InitKeyWords();
};
mWorker.RunWorkerCompleted += (s, re) =>
{
mWorker.Dispose();
mRootItem1.IsChecked = false;
if (mRootItem1.Children.Count > 0)
{
mRootItem1.Children[0].IsExpanded = true;
}
};
mWorker.RunWorkerAsync();
}
private void Init()
{
try
{
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += (s, de) =>
{
SetKwContentEnable();
SetRbEnable();
SetRbDelete();
};
worker.RunWorkerCompleted += (s, re) =>
{
worker.Dispose();
};
worker.RunWorkerAsync();
}
catch (Exception ex)
{
ShowException(ex.Message);
}
}
/// <summary>
/// Does the work.
/// </summary>
/// <param name="workAction">The work action.</param>
/// <param name="workCompleteAction">The work complete action.</param>
/// <param name="workProgressAction">The work progress action.</param>
public static void DoWork(Action <object, DoWorkEventArgs> workAction,
Action <object, RunWorkerCompletedEventArgs> workCompleteAction,
Action <object, ProgressChangedEventArgs> workProgressAction)
{
if (workAction == null)
{
throw new ArgumentNullException("workAction", "The work Action is null.");
}
if (workCompleteAction == null)
{
throw new ArgumentNullException("workCompleteAction", "The work complete Action is null.");
}
var worker = new BackgroundWorker();
worker.DoWork += (o, args) => workAction.Invoke(o, args);
worker.WorkerReportsProgress = (workProgressAction != null);
if (workProgressAction != null)
{
worker.ProgressChanged += (o, args) =>
workProgressAction.Invoke(o, args);
}
worker.RunWorkerCompleted += (o, args) =>
{
try
{
workCompleteAction.Invoke(o, args);
}
finally
{
worker.Dispose();
}
};
worker.RunWorkerAsync();
}
public static void Show(string WindowTitle, string ProgressText, Action WorkerFunction, LogPage logWindow)
{
var progressWindow = new formProgress();
progressWindow.StatusText.Text = ProgressText;
logWindow.Text = ProgressText;
var progressWorker = new BackgroundWorker();
progressWorker.DoWork += (obj, var) =>
{
WorkerFunction();
};
progressWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(
delegate(object sender, RunWorkerCompletedEventArgs e) {
if (e.Error != null)
{
Debug.LogLine(String.Format("[Error] Exception message '{0}'", e.Error.ToString()));
Debug.LogLine(String.Format("[Error] Exception StackTrace '{0}'", e.Error.StackTrace));
logWindow.Invoke((MethodInvoker) delegate { logWindow.Text = String.Format("Error during process :'{0}'", ProgressText); });
MessageBox.Show(String.Format("Exception :'{0}'\r\nCheck SnakeBites log for more info.", e.Error.ToString()), String.Format("Error during process :'{0}'", ProgressText), MessageBoxButtons.OK, MessageBoxIcon.Error);
progressWindow.Invoke((MethodInvoker) delegate { progressWindow.Close(); });
}
else if (e.Cancelled)
{
}
else
{
progressWindow.Invoke((MethodInvoker) delegate { progressWindow.Close(); });
}
progressWorker.Dispose();
}
);
progressWorker.RunWorkerAsync();
progressWindow.ShowDialog();
}
/// <summary>
/// FileStatsReader Worker Competion task. Updates the UI with the newly acquired values.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FileStatsWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Error != null)
{
ShowErrorBox("Error while retreiving log file stats!" + Environment.NewLine + e.Error.Message);
}
else if (e.Cancelled)
{
// Cancelled
}
else
{
// Success
lbl_TotalRowsValue.Text = totalRows.ToString();
lbl_FileSizeValue.Text = (fileSize / 1024 / 1024).ToString();
SetOutputUIElements(true);
}
StartWaiting(false);
fileStatsWorker.Dispose();
}
//加载质检员
void InspectorList_Loaded(object sender, RoutedEventArgs e)
{
BtnConfirm.Content = CurrentApp.GetLanguageInfo("31020", "Confirm");
BtnClose.Content = CurrentApp.GetLanguageInfo("31021", "Close");
InspectorTree.ItemsSource = mRootItem_Inspector.Children;
mRootItem_Inspector.Children.Clear();
mWorker = new BackgroundWorker();
mWorker.DoWork += (s, de) =>
{
InitInspectorParents();
};
mWorker.RunWorkerCompleted += (s, re) =>
{
mWorker.Dispose();
mRootItem_Inspector.IsChecked = false;
if (mRootItem_Inspector.Children.Count > 0)
{
mRootItem_Inspector.Children[0].IsExpanded = true;
}
};
mWorker.RunWorkerAsync();
}
private void InfoWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
try
{
if (e.Error != null)
{
SccmExceptionDialog.ShowDialog(this, e.Error, "Error");
}
}
finally
{
if (sender as BackgroundWorker == backgroundWorker)
{
backgroundWorker.Dispose();
backgroundWorker = null;
UseWaitCursor = false;
listViewClientHealth.IsLoading = false;
listViewClientHealth.UpdateColumnWidth(columnHeaderDescription);
buttonRefresh.Enabled = true;
}
}
}
void UCLDAPLinkPage_Loaded(object sender, RoutedEventArgs e)
{
this.ComboxDomain.ItemsSource = IListDomainInfo;
this.BtnConfirm.Click += BtnConfirm_Click;
this.BtnClose.Click += BtnClose_Click;
ChangeLanguage();
//this.ComboxDomain.SelectedIndex = 0;
IListDomainInfo.Clear();
ParenntPage.SetBusy(true, string.Empty);
mWorker = new BackgroundWorker();
mWorker.DoWork += (s, de) =>
{
InitDomainInfo();
};
mWorker.RunWorkerCompleted += (s, re) =>
{
ParenntPage.SetBusy(false, string.Empty);
mWorker.Dispose();
};
mWorker.RunWorkerAsync();
}
void QueryConditionPage_Loaded(object sender, RoutedEventArgs e)
{
SetBusy(true, CurrentApp.GetMessageLanguageInfo("001", string.Format("Loading data, please wait...")));
mWorker = new BackgroundWorker();
mWorker.DoWork += (s, de) =>
{
GetKeyWord();
};
mWorker.RunWorkerCompleted += (s, re) =>
{
mWorker.Dispose();
SetBusy(false, string.Empty);
InitQueryDetailColumns();
InitQueryDetail();
InitTaskDetailColumns();
InitTaskDetail();
CreatoptButtons();
};
mWorker.RunWorkerAsync();
LvTaskDetail.ItemsSource = ListTaskItems;
LvQueryCondition.ItemsSource = ListQueryItems;
}
public static void ExecuteBackup(object parameter)
{
BackupParameters parameters = parameter as BackupParameters;
if (parameters != null)
{
Context = parameters.Context;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += async(sender, args) =>
{
await Context.Dispatcher.InvokeAsync(async() =>
{
_adb = new AdbTools(Context);
if (parameters.Context2.SelectedIndex == 0)
{
await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.All, parameters.Bool, parameters.Target);
}
if (parameters.Context2.SelectedIndex == 1)
{
await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.Apps, parameters.Bool, parameters.Target);
}
if (parameters.Context2.SelectedIndex == 2)
{
await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.SystemApps, parameters.Bool, parameters.Target);
}
if (parameters.Context2.SelectedIndex == 3)
{
await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.AppsWithoutSystemApps, parameters.Bool, parameters.Target);
}
if (parameters.Context2.SelectedIndex == 4)
{
await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.SDCard, parameters.Bool, parameters.Target);
}
});
};
worker.RunWorkerCompleted += (sender, args) => worker.Dispose();
worker.RunWorkerAsync();
}
}
private void SendFriendRequestTo(Consumer consumer, Label addButtonLabel, Panel singleUserPanel)
{
BackgroundWorker backgroundWorker = new BackgroundWorker();
backgroundWorker.DoWork += (s, e) =>
{
bool?success = ServerConnections.ServerRequest.SendFriendRequest(Consumer.LoggedIn.Id, consumer.Id);
if (success == true)
{
this.SetAddFriendButton(consumer, singleUserPanel, "r_receiver");
}
else
{
if (success == null)
{
MessageBox.Show("Database access denied!");
}
}
};
backgroundWorker.RunWorkerCompleted += (s, e) => { backgroundWorker.Dispose(); };
backgroundWorker.RunWorkerAsync();
}
protected override void OnStop()
{
if (bw != null)
{
bw.CancelAsync();
while (bw.IsBusy)
{
Thread.Sleep(1000);
}
bw.Dispose();
}
if (BOM != null)
{
BOM.Dispose();
}
if (IPCServer != null)
{
IPCServer.Dispose();
}
}
private void btnRead_Click(object sender, EventArgs e)
{
RecordsRead = 0;
//clear the form
dgvData.DataSource = null;
dgvData.Visible = false;
tableLayoutPanel1.Visible = false;
dgvData.Hide();
this.textConsole.Text = String.Empty;
this.lblReadTime.Text = String.Empty;
this.lblSerialNumber.Text = String.Empty;
this.lblNumSamplesOnMeter.Text = String.Empty;
//show wait message
Point startLocationOfWaitWindow = this.Location;
startLocationOfWaitWindow.X += (this.Width / 2) - (wm.Width / 2);
startLocationOfWaitWindow.Y += (this.Height / 2) - (wm.Height / 2);
wm.Location = startLocationOfWaitWindow;
wm.ProgressValue = 0;
if (!wm.Visible)
{
wm.Show(this);
}
wm.Update();
//record the start time
startDateTime = DateTime.Now;
bgw.Dispose();
bgw = new BackgroundWorker();
bgw.WorkerSupportsCancellation = true;
bgw.DoWork += new DoWorkEventHandler(bgw_DoWork);
bgw.RunWorkerAsync(new string [] { this.cbComports.SelectedItem.ToString(), cbMeterType.SelectedValue.ToString().Trim() });
bgw.RunWorkerCompleted += bgw_RunWorkerCompleted;
}
/// <summary>
/// Gets all file references associated with main project file
/// </summary>
internal void GetReferences()
{
References = new List <ProjectFile>();
var w = new BackgroundWorker();
w.DoWork += new DoWorkEventHandler((s, e) => {
GetReferences(Roles.Include, new ScnSyntax.IncludeSimple());
GetReferences(Roles.Timetable, new ScnSyntax.Timetable(), new[] { "none", "rozklad" }, null, ".txt");
GetReferences(Roles.Description, new ScnSyntax.CommandInclude(), null, new[] { ".txt", ".html" });
});
if (Role == Roles.Main)
{
w.RunWorkerCompleted += new RunWorkerCompletedEventHandler((s, e) => {
if (ReferencesResolved != null)
{
ReferencesResolved.Invoke(this, EventArgs.Empty);
}
});
}
w.RunWorkerAsync();
w.Dispose();
}
public void ReloadData()
{
try
{
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += (s, de) =>
{
LoadAlarmMessageInfos();
};
worker.RunWorkerCompleted += (s, re) =>
{
worker.Dispose();
CreateAlarmMessageItems();
};
worker.RunWorkerAsync();
}
catch (Exception ex)
{
ShowException(ex.Message);
}
}
private void dataTableTest()
{
//Data Set for each System Library
//Gets program directory
DirectoryInfo d = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory);
//Gets only .dat files from directory
FileInfo[] Files = d.GetFiles("*.dat");
//Runs work for each .dat file collected
foreach (FileInfo file in Files)
{
BackgroundWorker xDocWorker = new BackgroundWorker();
xDocWorker.WorkerReportsProgress = true;
xDocWorker.DoWork += new DoWorkEventHandler(xDocWorker_DoWork);
xDocWorker.ProgressChanged += new ProgressChangedEventHandler(xDocWorker_ProgressChanged);
xDocWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(xDocWorker_RunWorkerCompleted);
xDocWorker.RunWorkerAsync(file);
xDocWorker.Dispose();
}
}
public void DisposeTwiceShouldNotThrow()
{
var bw = new BackgroundWorker();
bw.Dispose();
bw.Dispose();
}
