public static void ParseRecommends(string html, Action<List<Recommend>> finished)
{
BackgroundWorker bw = new BackgroundWorker();
bw.DoWork += new DoWorkEventHandler((sender, e) =>
{
List<Recommend> allRecommends = new List<Recommend>();
HtmlDocument hDoc = new HtmlDocument();
hDoc.LoadHtml(html);
var tableRows = hDoc.DocumentNode.SelectNodes(Constants.Instance.XPATH_GAME_SHOW_RESULT);
foreach (var node in tableRows)
{
var results = ChildElementsInTableRow(node);
if (results.Count == Constants.Instance.COUNT_GAME_SHOW_RESULT_COLUMNS)
{
var rec = RecommendFromStrings(results);
if (IsValidRecommend(rec))
{
allRecommends.Add(rec);
}
}
}
finished(allRecommends);
});
bw.RunWorkerAsync();
}
public static void ParseTopPerson(string html, Action<List<Person>> finished)
{
BackgroundWorker bw = new BackgroundWorker();
bw.DoWork += new DoWorkEventHandler((sender, e) =>
{
List<Person> TopPerson = new List<Person>();
HtmlDocument hDoc = new HtmlDocument();
hDoc.LoadHtml(html);
var tableRows = hDoc.DocumentNode.SelectNodes(Constants.Instance.XPATH_GAME_TOP_RESULT);
foreach (var node in tableRows)
{
var results = ChildElementsInTableRow(node);
if (results.Count == Constants.Instance.COUNT_GAME_TOP_RESULT_COLUMNS)
{
var person = TopPersonFromStrings(results);
if (person.Total != 0)
{
TopPerson.Add(person);
}
}
}
finished(TopPerson);
});
bw.RunWorkerAsync();
}
private void btVolDoc_Click(object sender, EventArgs e)
{
worker = new BackgroundWorker();
worker.DoWork += new DoWorkEventHandler(VolDocAsync);
worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(VolDocAsyncCompleta);
btVolDoc.Text = "Pesquisando";
btVolDoc.Enabled = false;
if (radioMatriz.Checked) // Matriz
{
query = "SELECT trim(trf_ref) || trf_ser as serie from transferido where trf_vol = '"+ numericDoc.Value+ "' and trf_dtc is null and ROWNUM <= 500 order by trf_ser";
//Console.WriteLine(query);
worker.RunWorkerAsync();
}
else // Filial
{
if(intFilial.Value != 0) // Não é filial 0
{
// query = "SELECT mov_ser as serie from movimento where mov_doc = '" + numericDoc.Value + "' and mov_sed ='" +intFilial.Value + "' and ROWNUM <= 500";
query = "SELECT trim(mov_ref) || mov_ser as mercadoria from movimento where mov_doc = '" + numericDoc.Value + "' and mov_sed ='" + intFilial.Value + "'";
worker.RunWorkerAsync();
}
else
{
MessageBox.Show("Precisa selecionar uma filial");
btVolDoc.Text = "Pesquisar";
btVolDoc.Enabled = true;
}
}
}
public MainWindow()
{
string[] args = Environment.GetCommandLineArgs();
InitializeComponent();
string[] validUsers = { "usernames" };//update to run
string strUserName = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
int indDomain = strUserName.LastIndexOf("\\")+1;
string user = strUserName.Substring(indDomain, strUserName.Length - indDomain);
int i = args.Count();
if (true) { //update for validuser check
BackgroundWorker bw1 = new BackgroundWorker();
if (args.Count() > 1) {
string fileName = args[1];
bw1.DoWork += new DoWorkEventHandler(updateFromFile);
bw1.RunWorkerAsync(fileName);
initBtn.IsEnabled = false;
updateBtn.IsEnabled = false;
pBar.Visibility = Visibility.Hidden;
} else {
bw1.DoWork += new DoWorkEventHandler(getPList);
bw1.RunWorkerAsync();
initBtn.IsEnabled = false;
updateBtn.IsEnabled = false;
pBar.Visibility = Visibility.Hidden;
}
} else {
initBtn.IsEnabled = false;
updateBtn.IsEnabled = false;
status.Content = "Not an allowed user, contact SCT.";
pBar.Visibility = Visibility.Hidden;
}
//status.Content = strUserName;
}
public NetworkClient(System.Net.IPAddress serverAddress, int port)
{
TcpClient client = new TcpClient();
client.Connect(serverAddress, port);
_stream = client.GetStream();
_connected = true;
BackgroundWorker streamWorker = new BackgroundWorker();
streamWorker.WorkerSupportsCancellation = true;
streamWorker.DoWork += ReadFromStream;
streamWorker.RunWorkerCompleted += (s, a) =>
{
if (_connected)
{
streamWorker.RunWorkerAsync(_stream);
}
};
streamWorker.RunWorkerAsync(_stream);
StreamError += (ex, stream) =>
{
if (ex is IOException || ex is InvalidOperationException || ex is ObjectDisposedException)
{
_connected = false;
Console.WriteLine("Lost connection: {0}", ex.Message);
Console.Write("> ");
}
else
{
throw ex;
}
};
}
private void Form1_Load(object sender, EventArgs e)
{
_serverProcessor = new ServerProcessor();
_serverProcessor.MessageReceived += _serverProcessor_MessageReceived;
BackgroundWorker bg = new BackgroundWorker();
bg.DoWork += delegate { _serverProcessor.RunServer(); };
bg.RunWorkerCompleted += delegate { bg.RunWorkerAsync(); };
bg.RunWorkerAsync();
}
private void ServerForm_Load(object sender, EventArgs e)
{
_bg = new BackgroundWorker();
_bg.DoWork += delegate { _processor.Initialize(); };
_bg.RunWorkerCompleted += delegate { _bg.RunWorkerAsync(); };
_bg.RunWorkerAsync();
this.Text += " " + _processor.ServerDetails;
NotifyIconServer.Text = _processor.ServerDetails;
WindowState = FormWindowState.Minimized;
}
public override void Start(SUAppcastItem item, string path) {
BackgroundWorker unzipper = new BackgroundWorker();
unzipper.DoWork += UnzipFile;
unzipper.RunWorkerCompleted += UnzipCompleted;
unzipper.RunWorkerAsync(path);
}
/// <summary>
/// Lance une tache dans un background worker.
/// </summary>
/// <param name="taskFunc">Tache à exécuter.</param>
/// <param name="completionAction">Action à réaliser après l'exécution. Recoit l'exception si une exception a eu lieu.</param>
public static void Start(Action taskFunc, Action<Exception> completionAction)
{
if (taskFunc == null)
{
throw new ArgumentNullException("taskFunc");
}
var backgroundWorker = new BackgroundWorker();
backgroundWorker.DoWork += new DoWorkEventHandler(
delegate
{
taskFunc();
});
backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(
delegate(object sender, RunWorkerCompletedEventArgs e)
{
if (completionAction != null)
{
completionAction(e.Error);
}
});
backgroundWorker.RunWorkerAsync();
}
public void CreateDictionaryHash()
{
var prefixTreeThread = new BackgroundWorker();
prefixTreeThread.DoWork += ReadPrefixTree;
prefixTreeThread.RunWorkerCompleted += ReadPrefixTreeComplete;
prefixTreeThread.RunWorkerAsync();
}
// Konstruktor
public MainPage()
{
InitializeComponent();
// prepare Photo Chooser Task for the open button
photoChooserTask = new PhotoChooserTask();
photoChooserTask.Completed += (s, e) => { if (e.TaskResult == TaskResult.OK) ProcessImage(e); };
// prepare the backround worker thread for the image processing
scannerWorker = new BackgroundWorker();
scannerWorker.DoWork += scannerWorker_DoWork;
scannerWorker.RunWorkerCompleted += scannerWorker_RunWorkerCompleted;
foreach (var x in typeof(BarcodeFormat).GetFields())
{
if (x.IsLiteral)
{
BarcodeType.Items.Add(x.GetValue(null));
}
}
// open the default barcode which should be displayed when the app starts
var uri = new Uri("/images/35.png", UriKind.Relative);
var imgSource = new BitmapImage(uri);
BarcodeImage.Source = imgSource;
imgSource.ImageOpened += (s, e) => scannerWorker.RunWorkerAsync(new WriteableBitmap((BitmapImage)s));
}
public void Run()
{
BackgroundWorker transferTablesWorker = new BackgroundWorker();
transferTablesWorker.DoWork += new DoWorkEventHandler(TransferTablesWorker_DoWork);
transferTablesWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(TransferTablesWorker_RunWorkerCompleted);
transferTablesWorker.RunWorkerAsync();
}
public TemperatureSequenceEditor(ENUM_Window_Mode Mode)
{
InitializeComponent();
_vm = new ViewModel_TemperatureSequenceEditor();
/* 加载Sequence Names */
bgw_Init = new BackgroundWorker();
bgw_Init.WorkerReportsProgress = true;
bgw_Init.DoWork += bgw_Init_DoWork;
bgw_Init.ProgressChanged += bgw_Init_ProgressChanged;
bgw_Init.RunWorkerAsync();
/* 根据模式设置界面 */
if (Mode == ENUM_Window_Mode.Load)
{
btn_New.Visibility = Visibility.Hidden;
btn_Save.Visibility = System.Windows.Visibility.Hidden;
btn_Delete.Visibility = System.Windows.Visibility.Hidden;
btn_Load.Visibility = System.Windows.Visibility.Visible;
grid_SequenceEdit.IsEnabled = false;
}
else
{
btn_New.Visibility = Visibility.Visible;
btn_Save.Visibility = System.Windows.Visibility.Visible;
btn_Delete.Visibility = System.Windows.Visibility.Visible;
btn_Load.Visibility = System.Windows.Visibility.Hidden;
grid_SequenceEdit.IsEnabled = true;
}
}
private static void UpdateCheck()
{
Game.PrintChat("<font color='#33FFFF'>>>LeagueSharp.Common loaded <<");
var bgw = new BackgroundWorker();
bgw.DoWork += bgw_DoWork;
bgw.RunWorkerAsync();
}
public Twitch(string channel, string ircAdress, int port) {
smiles = new Dictionary<string, TwitchSmile>();
channelName = channel.Trim().ToLower();
ircUrl = ircAdress;
this.port = port;
BackgroundWorker bg = new BackgroundWorker();
bg.DoWork += bg_DoWork;
bg.RunWorkerAsync();
regexSignsEmotions = new string[]{"B-?\\)",
"\\:-?[z|Z|\\|]",
"\\:-?\\)",
"\\:-?\\(",
"\\:-?(p|P)",
"\\;-?(p|P)",
"\\<\\;3",
"\\:-?(?:\\/|\\\\)(?!\\/)",
"\\;-?\\)",
"R-?\\)",
"[o|O](_|\\.)[o|O]",
"\\:-?D",
"\\:-?(o|O)",
"\\>\\;\\(",
"\\:\\>\\;",
"\\:-?(S|s)",
"#-?[\\\\/]",
"\\<\\;\\]",
":-?(?:7|L)"};
}
public MovieVideo(string magnetUri)
{
InitializeComponent();
//AxWMPLib.AxWindowsMediaPlayer player = new AxWindowsMediaPlayer();
//Host.Child = player;
if (magnetUri != string.Empty)
{
if (File.Exists("hash.txt"))
File.Delete("hash.txt");
NodeServerManager.StartServer(magnetUri);
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += (sender, e) =>
{
while (true)
{
if (File.Exists("hash.txt"))
break;
}
};
worker.RunWorkerCompleted += (sender, e) =>
{
File.Delete("hash.txt");
//this.Player.closedCaption.SAMIFileName=
this.Player.URL = "http://localhost:1337";
};
worker.RunWorkerAsync();
//this.Player.URL = "http://localhost:1337";
//axWmp.URL = "http://localhost:1337";
}
}
public FrmMain()
{
InitializeComponent();
var v = Assembly.GetEntryAssembly().GetName().Version;
this.Version = string.Format("v{0}.{1}", v.Major, v.Minor);
string title = string.Format("编程辅助工具{0}", this.Version);
this.Text = title;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += new DoWorkEventHandler(worker_DoWork);
worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
worker.RunWorkerAsync();
this.IsMdiContainer = true;
this.dockPanel.DocumentStyle = DocumentStyle.DockingMdi;
//详细信息
DockContent dc = new DockContent();
dc.CloseButtonVisible = false;
dc.Text = "详细信息";
DetailTabPage dtpage = new DetailTabPage();
dtpage.Dock = DockStyle.Fill;
dc.Controls.Add(dtpage);
dc.Show(this.dockPanel, DockState.Document);
//数据
DockContent dc2 = new DockContent();
dc2.CloseButtonVisible = false;
dc2.Text = "数据";
SchemaTreeView stpage = new SchemaTreeView();
stpage.Dock = DockStyle.Fill;
dc2.Controls.Add(stpage);
dc2.Show(this.dockPanel, DockState.DockLeft);
}
public void CopyFolder(string origin, string destination)
{
if (!Directory.Exists(origin))
{
UpdateHistory("Unable to copy. The origin folder isn't accessible.");
return;
}
else if(!Directory.Exists(destination))
{
UpdateHistory("Error opening Folder in which to copy.");
return;
}
this.TotalFileSize = this.GetDirectorySize(origin);
BackgroundWorker bw = new BackgroundWorker();
bw.DoWork += this.bw_DoWork;
bw.RunWorkerCompleted += this.bw_RunWorkerCompleted;
CopyArgs args = new CopyArgs()
{
Origin = origin,
Destination = destination
};
bw.WorkerReportsProgress = true;
bw.ProgressChanged += this.bw_ReportProgess;
bw.RunWorkerAsync(args);
}
public void _timer_Elapsed(object sender, ElapsedEventArgs e)
{
Classes.CustomSnapshotRoot root = null;
Classes.KeeperAPI keeper = new Classes.KeeperAPI();
Action workAction = delegate
{
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += delegate
{
root = keeper.getKeeperInfo(guid);
};
worker.RunWorkerCompleted += delegate
{
try {
//image.Source = null;
Classes.ScoreboardRenderer render = new Classes.ScoreboardRenderer(this, root.snapshot.mapId, root);
}catch(Exception ex)
{
Classes.Logger.addLog(ex.ToString(), 1);
}
//Update code in here
};
worker.RunWorkerAsync();
};
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, workAction);
}
/// <summary>
/// Run the layout algorithm on this control
/// </summary>
public void RunLayoutAlgorithm()
{
if (!_isRunning)
{
_isRunning = true;
_layout = new ForceLayout(GetKeyFromNode,
GetSourceNodeKeyFromEdge,
GetDestinationNodeKeyFromEdge,
SetNodeCoordinates);
_layout.MaximumScaledX = this.ActualWidth * .95;
_layout.MaximumScaledY = this.ActualHeight * .95;
_layout.MaximumSeconds = 120;
IEnumerable nodes = this.Children.Where(ch => !(ch is IEdge)).ToList();
IEnumerable edges = this.Children.Where(ch => ch is IEdge).ToList();
_worker = new BackgroundWorker();
_worker.WorkerReportsProgress = true;
_worker.DoWork += (w, data) =>
{
// Run the layout algorithm
// every child that is not an edge is considered a node
_layout.Layout(nodes,
edges);
};
_worker.ProgressChanged += new ProgressChangedEventHandler(_worker_ProgressChanged);
_worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(_worker_RunWorkerCompleted);
_worker.RunWorkerAsync();
}
}
/// <summary>
/// Starts execution of a background operation.
/// </summary>
/// <param name="action">The operation to be invoked by a <see cref="System.ComponentModel.BackgroundWorker"/>.</param>
public static void RunWorkerAsync(Action<object, DoWorkEventArgs> action)
{
var w = new BackgroundWorker();
w.DoWork += (s, e) => action(s, e);
w.RunWorkerCompleted += (s, e) => w.Dispose();
w.RunWorkerAsync();
}
private static void UpdateCheck()
{
Game.PrintChat("<font color='#33FFFF'> .: Orianna by trelli loaded :.");
var bgw = new BackgroundWorker();
bgw.DoWork += bgw_DoWork;
bgw.RunWorkerAsync();
}
public void Execute(ActionExecutionContext context)
{
Exception error = null;
var worker = new BackgroundWorker();
worker.DoWork += (s, e) =>
{
try
{
_work();
}
catch (Exception ex)
{
error = ex;
}
};
worker.RunWorkerCompleted += (s, e) =>
{
if (error == null && _onSuccess != null)
_onSuccess.OnUIThread();
if (error != null && _onFail != null)
{
Caliburn.Micro.Execute.OnUIThread(() => _onFail(error));
}
Completed(this, new ResultCompletionEventArgs { Error = error });
};
worker.RunWorkerAsync();
}
private void b_open_Click(object sender_, RoutedEventArgs e_)
{
p_progress.Visibility = Visibility.Visible;
p_label.Visibility = Visibility.Visible;
bw_LoadFile = new BackgroundWorker();
bw_LoadFile.DoWork += (sender, e) =>
{
LCIO.OpenFile(bw_LoadFile);
};
bw_LoadFile.ProgressChanged += (sender, e) =>
{
p_label.Content = e.UserState;
};
bw_LoadFile.RunWorkerCompleted += (sender, e) =>
{
if (e.Error != null)
{
new TextMessage("Ошибка", e.Error.Message).ShowDialog();
}
p_progress.Visibility = Visibility.Hidden;
p_label.Visibility = Visibility.Hidden;
FLYOUT_OpenFile.IsOpen = false;
UpdateList();
};
bw_LoadFile.WorkerReportsProgress = true;
bw_LoadFile.RunWorkerAsync();
}
public void RunAsync()
{
worker = new BackgroundWorker();
worker.DoWork += OnMethodStarted;
worker.RunWorkerCompleted += OnMethodFinished;
worker.RunWorkerAsync();
}
public void ReformTermsAsynchronously(IEnumerable<String> terms, ImprovedQueryReady callback)
{
var worker = new BackgroundWorker { WorkerReportsProgress = false,
WorkerSupportsCancellation = false };
worker.DoWork += (sender, args) => callback.Invoke(ReformTermsSynchronously(terms));
worker.RunWorkerAsync();
}
internal void SpashScreen_Shown(object sender, RoutedEventArgs e)
{
BackgroundWorker loadapp = new BackgroundWorker();
loadapp.DoWork += new DoWorkEventHandler(load_splash);
loadapp.RunWorkerCompleted += new RunWorkerCompletedEventHandler(load_done);
loadapp.RunWorkerAsync();
}
public override void RefreshAllAsync()
{
BackgroundWorker refreshAllWorker = new BackgroundWorker();
refreshAllWorker.DoWork += new DoWorkEventHandler(RefreshWorker_DoWork);
refreshAllWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(RefreshWorker_RunWorkerCompleted);
refreshAllWorker.RunWorkerAsync();
}
public UpdateRecordItem()
{
InitializeComponent();
Group = "異動資料";
BGWorker = new BackgroundWorker();
BGWorker.DoWork += new DoWorkEventHandler(BGWorker_DoWork);
BGWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(BGWorker_RunWorkerCompleted);
SHUpdateRecord.AfterChange += new EventHandler<K12.Data.DataChangedEventArgs>(SHUpdateRecord_AfterChange);
if (!string.IsNullOrEmpty(_StudentID))
BGWorker.RunWorkerAsync();
#region 權限判斷程式碼。
//取得此 Class 定議的 FeatureCode。
FeatureCode = FeatureCodeAttribute.GetCode(this.GetType());
_permission = FISCA.Permission.UserAcl.Current[FeatureCode];
btnAdd.Visible = _permission.Editable;
btnRemove.Visible = _permission.Editable;
bthUpdate.Visible = _permission.Editable;
btnView.Visible = !_permission.Editable;
#endregion
Disposed += new EventHandler(UpdateRecordItem_Disposed);
}
private void btnLoadData_Click(object sender, EventArgs e)
{
using (FolderBrowserDialog dlgFolder = new FolderBrowserDialog())
{
if (dlgFolder.ShowDialog() == DialogResult.OK)
{
for (int i = 0; i < this.feretDataSet.faces.Rows.Count; i++)
{
this.feretDataSet.faces.Rows[i].Delete();
}
updateDatabase();
BackgroundWorker worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.DoWork += new DoWorkEventHandler(worker_DoWork);
worker.ProgressChanged += new ProgressChangedEventHandler(worker_ProgressChanged);
worker.RunWorkerAsync(dlgFolder.SelectedPath);
lstInfo.Enabled = false;
//lstSelect.Enabled = false;
btnLoadData.Enabled = false;
btnSaveSetList.Enabled = false;
dataGridView1.Enabled = false;
}
}
}
protected override void Execute(IRuleContext context)
{
var bw = new System.ComponentModel.BackgroundWorker();
bw.DoWork += (o, e) =>
{
throw new InvalidOperationException();
};
bw.RunWorkerCompleted += (o, e) =>
{
if (e.Error != null)
{
context.AddErrorResult(e.Error.Message);
}
context.Complete();
};
bw.RunWorkerAsync();
}
protected override void Execute(IRuleContext context)
{
var cn = (string)context.InputPropertyValues[PrimaryProperty];
var bw = new System.ComponentModel.BackgroundWorker();
bw.RunWorkerCompleted += (o, e) =>
{
context.AddOutValue(_nameProperty, string.Format("customer name {0}", cn));
context.Complete();
};
bw.DoWork += (o, e) =>
{
Thread.Sleep(50);
};
bw.RunWorkerAsync();
}
protected override void mergePdfToolStripMenuItem_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog openFileDialog1 = new OpenFileDialog();
openFileDialog1.InitialDirectory = imageFolder;
openFileDialog1.Title = Properties.Resources.Select_Input_PDFs;
openFileDialog1.Filter = "PDF Files (*.pdf)|*.pdf";
openFileDialog1.FilterIndex = filterIndex;
openFileDialog1.RestoreDirectory = true;
openFileDialog1.Multiselect = true;
Nullable <bool> result = openFileDialog1.ShowDialog();
if (result.HasValue && result.Value)
{
filterIndex = openFileDialog1.FilterIndex;
imageFolder = Path.GetDirectoryName(openFileDialog1.FileName);
SaveFileDialog saveFileDialog1 = new SaveFileDialog();
saveFileDialog1.InitialDirectory = imageFolder;
saveFileDialog1.Title = Properties.Resources.Save_Merged_PDF;
saveFileDialog1.Filter = "PDF Files (*.pdf)|*.pdf";
saveFileDialog1.RestoreDirectory = true;
result = saveFileDialog1.ShowDialog();
if (result.HasValue && result.Value)
{
ArrayList args = new ArrayList();
args.Add(openFileDialog1.FileNames);
args.Add(saveFileDialog1.FileName);
this.Cursor = Cursors.Wait;
this.statusLabel.Content = Properties.Resources.MergePDF_running;
this.textBox1.Cursor = Cursors.Wait;
this.toolStripProgressBar1.IsEnabled = true;
this.toolStripProgressBar1.Visibility = Visibility.Visible;
//this.toolStripProgressBar1.Style = ProgressBarStyle.Marquee;
// Start the asynchronous operation.
backgroundWorkerMergePdf.RunWorkerAsync(args);
}
}
}
void Button1Click(object sender, EventArgs e)
{
picwidth = pictureBox1.Width;
picheight = pictureBox1.Height;
resultLabel.Text = String.Empty;
this.button1.Enabled = false;
this.cancelAsyncButton.Enabled = true;
pictureBox1.Image = new Bitmap(pictureBox1.Width, pictureBox1.Height);
//panel1.Pa
var fileContent = string.Empty;
var filePath = string.Empty;
using (OpenFileDialog openFileDialog = new OpenFileDialog())
{
openFileDialog.InitialDirectory = "C:\\";
openFileDialog.Filter = "obj files (*.obj)|*.obj|All files (*.*)|*.*";
openFileDialog.FilterIndex = 2;
openFileDialog.RestoreDirectory = true;
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
//Get the path of specified file
filePath = openFileDialog.FileName;
//Read the contents of the file into a stream
var fileStream = openFileDialog.OpenFile();
Obj model = new Obj();
object[] casting = { model, filePath };
// backgroundWorker1.RunWorkerAsync(model);// Start the asynchronous operation.
backgroundWorker1.RunWorkerAsync((object)casting); // Start the asynchronous operation.
//using (StreamReader reader = new StreamReader(fileStream)) { fileContent = reader.ReadToEnd(); }
fileContent = Encoding.Default.GetString(File.ReadAllBytes(filePath));
textoutput showmodelstuff = new textoutput(fileContent);
//showmodelstuff.Location.X = 900;
//showmodelstuff.Location.Y = 900;
showmodelstuff.Activate();
showmodelstuff.Show();
}
}
}
public void StartRequery()
{
SessionLog.Debug(string.Format("*** StartRequery: {0}", period));
//App.PeriodVM = this;
Navigate.selectedDate = date;
#if WINDOWS_PHONE
Navigate.selectedPeriod = period;
#endif
var syncID = new System.Random().NextDouble().ToString();
querySyncID = syncID;
try
{
SyncPeriod();
if (NewStyleWithoutItems)
{
return;
}
Requery(syncID, false);
}
catch (Exception ex) { LittleWatson.ReportException(ex); }
var bw = new System.ComponentModel.BackgroundWorker();
bw.DoWork += (s, a) =>
{
System.Threading.Thread.Sleep(300);
try
{
if (querySyncID == syncID)
{
#if DEBUG && WINDOWS_PHONE
FoodJournal.WinPhone.App.SetThreadCulture(); // only needed for screenshots
#endif
Requery(syncID, true);
}
}
catch (Exception ex) { LittleWatson.ReportException(ex); }
};
bw.RunWorkerAsync();
}
private void button1_Click(object sender, EventArgs e)
{
using (var worker = new System.ComponentModel.BackgroundWorker())
{
worker.WorkerReportsProgress = true;
worker.DoWork += DoWork;
worker.ProgressChanged += (o, args) =>
{
txtCount.Text = args.UserState.ToString();
};
worker.RunWorkerCompleted += (o, args) =>
{
txtTotalTime.Text = args.Result.ToString();
};
worker.RunWorkerAsync();
}
}
/// <summary>
/// 下载文件
/// </summary>
/// <param name="RemoteAddress">远程服务地址，需要从client中获取</param>
/// <param name="filePath">本地保存路径，不带文件名</param>
/// <param name="fileName">需要下载的文件名（远程）</param>
public void DownloadFile(string RemoteAddress, string localPath, string serverFilePath, string downloadFileName)
{
this.backgroundDownloadWorker = new System.ComponentModel.BackgroundWorker();
backgroundDownloadWorker.WorkerReportsProgress = true;
backgroundDownloadWorker.WorkerSupportsCancellation = true;
backgroundDownloadWorker.DoWork += new DoWorkEventHandler(backgroundDownloadWorker_DoWork);
backgroundDownloadWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
backgroundDownloadWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker_RunWorkerCompleted);
FileTransferInfo fileTranserInfo = new FileTransferInfo();
fileTranserInfo.fileTransferType = FileTransferType.downloadFile;
fileTranserInfo.remoteAddress = RemoteAddress;
fileTranserInfo.localPath = localPath;
fileTranserInfo.serverPath = serverFilePath;
fileTranserInfo.fileName = downloadFileName;
backgroundDownloadWorker.RunWorkerAsync(fileTranserInfo);
}
private void startAsyncButton_Click(System.Object sender,
System.EventArgs e)
{
// Reset the text in the result label.
resultLabel.Text = String.Empty;
// Disable the Start button until
// the asynchronous operation is done.
this.startAsyncButton.Enabled = false;
// Enable the Cancel button while
// the asynchronous operation runs.
this.cancelAsyncButton.Enabled = true;
// Reset the variable for percentage tracking.
highestPercentageReached = 0;
// Start the asynchronous operation.
backgroundWorker1.RunWorkerAsync();
}
private void startButton_Click(object sender, EventArgs e)
{
try
{
// Open a new session and configure a grab
_session = new ImaqdxSession(cameraComboBox.Text);
_session.ConfigureGrab();
// Update UI state
startButton.Enabled = false;
stopButton.Enabled = true;
// Start up background worker to acquire images
acquisitionWorker.RunWorkerAsync();
}
catch (ImaqdxException ex)
{
MessageBox.Show(ex.Message, "NI-IMAQdx Error");
}
}
protected override void OnGotFocus(EventArgs e)
{
try
{
if (this.parentWin != null)
{
bool bSetNewSelection = (bool)parentWin.GetType().InvokeMember("bSetNewSelection", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetField | System.Reflection.BindingFlags.ExactBinding | System.Reflection.BindingFlags.Instance, null, parentWin, null);
if (!bSetNewSelection)
{
//we've turned off that flag temporarily to skip some Microsoft code that causes an exception message box
//fire up a background thread to flip this flag back in a few seconds (after the Microsoft code has been skipped)
System.ComponentModel.BackgroundWorker backgroundThreadSetNewSelection = new System.ComponentModel.BackgroundWorker();
backgroundThreadSetNewSelection.DoWork += new DoWorkEventHandler(backgroundThreadSetNewSelection_DoWork);
backgroundThreadSetNewSelection.RunWorkerAsync();
}
}
}
catch { }
base.OnGotFocus(e);
}
private void refreshToolStripMenuItem_Click(object sender, EventArgs e)
{
string userName = txtUsername.Text;
string password = txtPassword.Text;
bool product = chkProdName.Checked;
bool version = chkProdVer.Checked;
bool serial = chkSerialNum.Checked;
bool model = chkModelName.Checked;
Interlocked.Increment(ref running);
Task.Run(() =>
{
TreeNode node;
node = getSoftware(new WMIC(lastSelectedNode.Text, userName, password, version, serial, model));
while (backWorker.IsBusy)
{
;
}
backWorker.RunWorkerAsync(node);
});
}
static void Main(string[] args)
{
#if _LOCAL_PERF
long ellapsed = LocalTimer.Instance.ElapsedMilliseconds;
#elif _SPY
Performance.StartEvent(1, "Calibrate.Main");
#endif
System.ComponentModel.BackgroundWorker backgroundWorker1 = new System.ComponentModel.BackgroundWorker();
backgroundWorker1.DoWork += new System.ComponentModel.DoWorkEventHandler(backgroundWorker1_DoWork);
backgroundWorker1.RunWorkerAsync();
RunConsoleProcess();
#if _LOCAL_PERF
ellapsed = LocalTimer.Instance.ElapsedMilliseconds - ellapsed;
LocalLogger.Instance.Log("Calibrate.Main;" + ellapsed.ToString());
#elif _SPY
Performance.EndEvent();
#endif
}
private void ThemeBuilder_Load(object sender, EventArgs e)
{
objectTreeView.ExpandAll();
treeBackgroundVideo.ExpandAll();
DirectoryInfo[] themeList = p_theme.getThemeList();
themeComboBox.Items.Add("Default");
foreach (DirectoryInfo theme in themeList)
{
themeComboBox.Items.Add(theme);
}
themeComboBox.SelectedIndex = 0;
bgwCode = new BackgroundWorker();
bgwCode.WorkerReportsProgress = true;
bgwCode.WorkerSupportsCancellation = true;
bgwCode.DoWork += new DoWorkEventHandler(bgwCode_DoWork);
bgwCode.RunWorkerAsync();
}
private void downloadButton_Click(object sender, EventArgs e)
{
// Assign the result of the computation
// to the Result property of the DoWorkEventArgs
// object. This is will be available to the
// RunWorkerCompleted eventhandler.
CredentialsGetter credential = new CredentialsGetter();
if (!credential.HasValidCredentials())
{
PickCredentialForm form = new PickCredentialForm();
form.Show();
return;
}
downloadButton.Enabled = false;
resultTextBox.Text = "Downloading...";
DateTime date = dateTimePicker.Value.Date;
backgroundWorker.RunWorkerAsync(date);
}
//Location
public List <Tester> getTestersWithinDistance(Address addr, int kilometers)
{
myDAL md = new myDAL();
/*
* bool anonymousFunc(tester){
* if(tester.addr-addr < 40){
* return true;
* }
* }
*/
backgroundWorker1.DoWork += new DoWorkEventHandler(backgroundWorker1_DoWork);
backgroundWorker1.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker1_RunWorkerCompleted);
Func <Tester, bool> anon = (Tester tstr) => (Distance(tstr.Address, addr) < kilometers);
backgroundWorker1.RunWorkerAsync(anon);
//List<Tester> ListOfTestersInProximity = md.GetTesters(anon);
return(ListOfTestersInProximity);
// for(i,j):
// schedule[i,j] = (CheckBox)"Checkbox{i}{j}".ischecked
}
/// <summary>
/// Access scanner and scan documents via WIA.
/// </summary>
void performScan()
{
try
{
this.statusLabel.Content = Properties.Resources.Scanning;
this.Cursor = Cursors.Wait;
this.textBox1.Cursor = Cursors.Wait;
this.buttonScan.IsEnabled = false;
this.scanToolStripMenuItem.IsEnabled = false;
this.toolStripProgressBar1.IsEnabled = true;
this.toolStripProgressBar1.Visibility = Visibility.Visible;
//this.toolStripProgressBar1.Style = ProgressBarStyle.Marquee;
// Start the asynchronous operation.
backgroundWorkerScan.RunWorkerAsync();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
protected override void splitPdfToolStripMenuItem_Click(object sender, RoutedEventArgs e)
{
SplitPdfDialog dialog = new SplitPdfDialog();
dialog.Owner = this;
Nullable <bool> dialogResult = dialog.ShowDialog();
if (dialogResult.HasValue && dialogResult.Value)
{
this.Cursor = Cursors.Wait;
this.statusLabel.Content = Properties.Resources.SplitPDF_running;
this.textBox1.Cursor = Cursors.Wait;
this.toolStripProgressBar1.IsEnabled = true;
this.toolStripProgressBar1.Visibility = Visibility.Visible;
//this.toolStripProgressBar1.Style = ProgressBarStyle.Marquee;
// Start the asynchronous operation.
backgroundWorkerSplitPdf.RunWorkerAsync(dialog.Args);
}
}
private void dataGridView_CellClick(object sender, System.Windows.Forms.DataGridViewCellEventArgs e)
{
DataGridViewButtonCell dgbtn = null;
if (dataGridView.Columns[e.ColumnIndex].Name == "Status")
{
dgbtn = (DataGridViewButtonCell)(dataGridView.Rows[e.RowIndex].Cells["Status"]);
if (dgbtn.Value.ToString() == "Status")
{
dgbtn.UseColumnTextForButtonValue = false;
dataGridView.CurrentCell = dataGridView.Rows[e.RowIndex].Cells["Status"];
dataGridView.CurrentCell.ReadOnly = false;
dgbtn.Value = "Running";
dataGridView.CurrentCell.ReadOnly = true;
DataGridViewRow selectedRow = dataGridView.Rows[e.RowIndex];
SelectedModelName = selectedRow.Cells["ModelName"].Value.ToString();
m_backgroundworker = new BackgroundWorker();
InitializeBackgroundWorker();
m_backgroundworker.WorkerReportsProgress = true;
m_backgroundworker.WorkerSupportsCancellation = true;
m_backgroundworker.RunWorkerAsync();
}
else if (dgbtn.Value.ToString() == "Running")
{
// stop model
DataGridViewRow selectedRow = dataGridView.Rows[e.RowIndex];
SelectedModelName = selectedRow.Cells["ModelName"].Value.ToString();
m_currentsession.StopModel(SelectedModelName, dgbtn);
}
}
}
/// <summary>
/// Handles the Click event of the Start control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
private void Start_Click(object sender, RoutedEventArgs e)
{
if (Step2.IsEnabled == true || Step3.IsEnabled == true)
{
WriteToConsole("Cannot do this operation");
return;
}
MessageBoxResult result = MessageBox.Show("Would you like to start ETL process? \nThis operation can't be undone", "Choose one option", MessageBoxButton.YesNo, MessageBoxImage.Question);
switch (result)
{
case MessageBoxResult.Yes:
{
if (!(Step2.IsEnabled == false && Step3.IsEnabled == false))
{
return;
}
Start.IsEnabled = false;
Step1.IsEnabled = false;
Step2.IsEnabled = false;
Step3.IsEnabled = false;
// BACKGROUNDWORKER POZWALA NA WYKONYWANIE OPERACJI W TLE
// POZWALA NA WYKONYWANIE ZLOZONYCH OPERACJI BEZ ZAWIESZANIA GUI
BackgroundWorker backgroundWorker1 = new System.ComponentModel.BackgroundWorker();
backgroundWorker1.DoWork += new DoWorkEventHandler(backgroundWorker1_DoWork);
backgroundWorker1.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker1_RunWorkerCompleted);
backgroundWorker1.RunWorkerAsync();
break;
}
case MessageBoxResult.No:
break;
}
}
private void btnImport_Click(object sender, RoutedEventArgs e)
{
System.Windows.Forms.OpenFileDialog openFileDialog1 = new System.Windows.Forms.OpenFileDialog();
openFileDialog1.Filter = "Excel Files|*.xls;*.xlsx;*.xlsm";
openFileDialog1.FilterIndex = 1;
ErrorGrid.DataContext = null;
openFileDialog1.Multiselect = false;
System.Windows.Forms.DialogResult result = openFileDialog1.ShowDialog();
if (result == System.Windows.Forms.DialogResult.OK)
{
string filename = openFileDialog1.FileName;
if (filename != "")
{
imagebox.Visibility = Visibility.Visible;
this.loadingimage.Image = global::SQSAdmin_WpfCustomControlLibrary.Properties.Resources.processingImage;
try
{
CallParameter cp = new CallParameter();
cp.State = stateid.ToString();
cp.UserCode = usercode;
cp.FileName = filename;
if (!backgroundWorker1.IsBusy)
{
backgroundWorker1.RunWorkerAsync(cp);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="winParent"></param>
public void Invoke(IWin32Window winParent)
{
_WorkThread.RunWorkerAsync();
Thread.Sleep(100);
if (winParent == null && Application.OpenForms.Count > 0)
{
var parent = Application.OpenForms[Application.OpenForms.Count - 1];
if (!parent.Equals(_WaitDialog))
{
winParent = parent;
}
}
if (winParent != null)
{
_WaitDialog.ShowDialog(winParent);
}
else
{
_WaitDialog.ShowDialog();
}
}
public static System.ComponentModel.BackgroundWorker Launch(DoWorkEventHandler doWork, ProgressChangedEventHandler progressChange)
{
var bw = new System.ComponentModel.BackgroundWorker
{
WorkerReportsProgress = true,
WorkerSupportsCancellation = true
};
bw.DoWork += doWork;
bw.ProgressChanged += progressChange;
bw.RunWorkerCompleted += (s, args) =>
{
if (args.Error != null) // if an exception occurred during DoWork,
{
MessageBox.Show(args.Error.ToString()); // do your error handling here
}
};
bw.RunWorkerAsync();
return(bw);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
mainWindow = Application.Current.Windows.OfType <MainWindow>().FirstOrDefault();
if (mainWindow != null)
{
driver_lbl.Text = mainWindow.username;
}
//get list of connected users from the data base.
// when a new player joins add him to the list.
// Start the asynchronous operation.
backgroundWorker1.RunWorkerAsync();
mainWindow.backgroundWorker1.CancelAsync();
//getPlayers();
//mainWindow.Client.socket.ReceiveAll(); // wait for a messge from the server (the messge will be that a new client has join the room and this client should update the )
}
private void bCrear_Click(object sender, EventArgs e)
{
if (tNombreActividad.Text.Length == 0)
{
MessageBox.Show("El nombre de la actividad es obligatorio");
return;
}
if (tDescripcion.Text.Length == 0)
{
MessageBox.Show("La descripción es obligatoria");
return;
}
if (dInicio.Value > dFin.Value)
{
MessageBox.Show("La actividad no puede tener duración negativa");
return;
}
if (dInicio.Value < System.DateTime.Now || dFin.Value < System.DateTime.Now)
{
MessageBox.Show("No puedes iniciar una actividad en el pasado");
return;
}
BD.Insert(new ActividadBD(-1, tNombreActividad.Text, tDescripcion.Text, dInicio.Value, dFin.Value, Usuario.getInstance().usuario));
var personas = BD.Select("SELECT * FROM Usuario WHERE admin = 0");
var worker = new System.ComponentModel.BackgroundWorker();
worker.DoWork += (sender, e) => mandarCorreos(personas);
worker.RunWorkerAsync();
this.Close();
}
private void scan_Click(object sender, EventArgs e)
{
string folderpath = folderName.Text;
if (!Directory.Exists(folderpath))
{
MessageBox.Show(folderpath + " doesn'this exist");
return;
}
scanButton.Enabled = false;
scanButton.Text = "Running";
saveButton.Enabled = false;
openViewerButton.Enabled = false;
long used = 0;
DriveInfo[] drives = DriveInfo.GetDrives();
foreach (DriveInfo drive in drives)
{
//There are more attributes you can use.
//Check the MSDN link for a complete example.
if (folderName.Text.Contains(drive.RootDirectory.FullName))
{
used = drive.TotalSize - drive.AvailableFreeSpace;
}
if (drive.IsReady)
{
Console.WriteLine(drive.TotalSize);
}
}
progressBar1.Maximum = (int)(used / 1000);
backgroundWorker.RunWorkerAsync();
}
private void irrlichtPanel_MouseClick(object sender, MouseEventArgs e)
{
// need to have a click plus the ctrl key down
if (pickKeyDown)
{
ViewFrustum f = smgr.ActiveCamera.ViewFrustum;
Vector3Df farLeftUp = f.FarLeftUp;
Vector3Df lefttoright = f.FarRightUp - farLeftUp;
Vector3Df uptodown = f.FarLeftDown - farLeftUp;
float dx = e.X / (float)viewPort.Width;
float dy = e.Y / (float)viewPort.Height;
Line3Df ray = new Line3Df(f.CameraPosition, farLeftUp + (lefttoright * dx) + (uptodown * dy));
SceneNode pickedNode = smgr.SceneCollisionManager.GetSceneNodeFromRayBB(ray);
if (pickedNode != null)
{
RenderMessage message = new RenderMessage(MessageType.HIGHLIGHT_NODE, pickedNode);
commandQueue.Enqueue(message);
propertiesDlg.SetProperties(pickedNode);
if (!propertiesDlg.Visible)
{
propertiesDlg.Show(this);
}
if (backgroundSearcher.IsBusy)
{
backgroundSearcher.CancelAsync();
}
backgroundSearcher.RunWorkerAsync(pickedNode.ID);
}
}
}
private void bCrear_Click(object sender, EventArgs e)
{
if (tAsunto.Text.Length == 0)
{
MessageBox.Show("El asunto del correo es obligatorio");
return;
}
if (tCuerpo.Text.Length == 0)
{
MessageBox.Show("El cuerpo del correo es obligatorio");
return;
}
string asunto = tAsunto.Text;
string cuerpo = tCuerpo.Text;
var worker = new System.ComponentModel.BackgroundWorker();
worker.DoWork += (sender, e) => mandarCorreos(asunto, cuerpo);
worker.RunWorkerAsync();
this.Close();
}
/// <summary>
/// 上传文件
/// </summary>
/// <param name="RemoteAddress"></param>
/// <param name="localFileFullPath"></param>
/// <param name="serverUploadPath"></param>
public void UploadFile(string RemoteAddress, string localFileFullPath, string serverUploadPath)
{
this.backgroundUploadWorker = new System.ComponentModel.BackgroundWorker();
backgroundUploadWorker.WorkerReportsProgress = true;
backgroundUploadWorker.WorkerSupportsCancellation = true;
backgroundUploadWorker.DoWork += new DoWorkEventHandler(backgroundUploadWorker_DoWork);
backgroundUploadWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
backgroundUploadWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker_RunWorkerCompleted);
FileTransferInfo fileTranserInfo = new FileTransferInfo();
fileTranserInfo.fileTransferType = FileTransferType.uploadFile;
fileTranserInfo.remoteAddress = RemoteAddress;
int nPos = localFileFullPath.LastIndexOf('\\');
string localPath = localFileFullPath.Substring(0, nPos);
string fileName = localFileFullPath.Substring(nPos + 1);
fileTranserInfo.localPath = localPath;
fileTranserInfo.serverPath = serverUploadPath;
fileTranserInfo.fileName = fileName;
backgroundUploadWorker.RunWorkerAsync(fileTranserInfo);
}
private void generateButton_Click(object sender, EventArgs e)
{
DateTime startDateTime;
TimeSpan timeSpan;
generateButton.Visible = false;
cancelButton.Visible = true;
Initialize();
patternLengthDisplay.Text = patternLength.ToString();
ulong possibleCalls = (ulong)(Math.Pow(n, patternLength + 1) - 1) / (n - 1);
possibleCallsDisplay.Text = possibleCalls.ToString("n0");
elapsedTime = 0.0;
elapsedTimeDisplay.Text = elapsedTime.ToString("n3");
startDateTime = DateTime.Now;
timer.Enabled = true;
bgWorker.RunWorkerAsync();
while (bgWorker.IsBusy)
{
Application.DoEvents();
}
timer.Enabled = false;
timeSpan = DateTime.Now - startDateTime;
elapsedTime = timeSpan.Hours * 3600.0 + timeSpan.Minutes * 60.0 + timeSpan.Seconds * 1.0 +
timeSpan.Milliseconds / 1000.0;
if (!bgWorkerCancelled)
{
DisplayResults();
}
else
{
dgv.Rows.Clear();
}
generateButton.Visible = true;
cancelButton.Visible = false;
}
private void button8_Click(object sender, EventArgs e)
{
if (backgroundWorker2.IsBusy != true)
{
// Start the asynchronous operation.
if (imeituanCheck.Checked == true)
{
this.imeituanCheck.Enabled = false;
this.ilashouCheck.Enabled = false;
this.inuomiCheck.Enabled = false;
this.button8.Enabled = false;
filepath = customSection.Meituanpath;
type = 1;
statusLabel.Text = "正在索引meituan.xml ...";
backgroundWorker2.RunWorkerAsync();
}
if (ilashouCheck.Checked == true)
{
this.imeituanCheck.Enabled = false;
this.ilashouCheck.Enabled = false;
this.inuomiCheck.Enabled = false;
this.button8.Enabled = false;
filepath = customSection.Lashoupath;
type = 2;
statusLabel.Text = "正在索引lashou.xml ...";
backgroundWorker2.RunWorkerAsync();
}
if (inuomiCheck.Checked == true)
{
this.imeituanCheck.Enabled = false;
this.ilashouCheck.Enabled = false;
this.inuomiCheck.Enabled = false;
this.button8.Enabled = false;
type = 3;
filepath = customSection.Nuomipath;
statusLabel.Text = "正在索引nuomi.xml ...";
backgroundWorker2.RunWorkerAsync();
}
}
}
