Develop Reference

.net C# - Winform getting Deactivated after "Not responding" message on title bar

I have a ClientForm (opened from MainWindow) which has a search button which on click takes around 12 seconds to process.
During search if user has clicked on that form multiple times "Not Responding" text get appears on its title bar which is ok, but after search completes ClientForm will lose focus or will get deactivate and MainWindow will get the focus - which is an issue.
Below is the code snippet.
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
// this is a wpf window
public MainWindow()
{
InitializeComponent();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
var cf= new ClientForm();
cf.Show();
}
}
// This is a winform
public partial class ClientForm : Form
{
public ClientForm()
{
InitializeComponent();
}
private void Search_Click(object sender, EventArgs e)
{
Cursor.Current = Cursors.WaitCursor;
// Do some processing
Thread.Sleep(12000);
Cursor.Current = Cursors.Default;
}
}
Is this a .net framework issue?
I am not using background thread for search or have not used ShowDialog to display form. Would like to know how else this can be fixed and why this issue is occurring.
Thanks!!!

Using background threads, my own example
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace WindowsFormsApp2
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
backgroundWorker1.WorkerReportsProgress = true;
backgroundWorker1.WorkerSupportsCancellation = true;
button2.Enabled = false;
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
for (int i = 0; i < 100; i++)
{
if (worker.CancellationPending == true)
{
e.Cancel = true;
break;
}
else
{
backgroundWorker1.ReportProgress(i);
Thread.Sleep(100);
}
}
}
private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
progressBar1.Value = e.ProgressPercentage;
}
private void button1_Click(object sender, EventArgs e)
{
if (backgroundWorker1.IsBusy != true)
{
button1.Enabled = false;
button2.Enabled = true;
label1.Text = "Runing...";
// Start the asynchronous operation.
backgroundWorker1.RunWorkerAsync();
}
}
private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
button1.Enabled = true;
button2.Enabled = false;
label1.Text = "Complete";
}
private void button2_Click(object sender, EventArgs e)
{
if (backgroundWorker1.WorkerSupportsCancellation == true)
{
// Cancel the asynchronous operation.
backgroundWorker1.CancelAsync();
button1.Enabled = true;
button2.Enabled = false;
label1.Text = "Cancel";
}
}
}
}

Thanks for your help but I have got the answer to this weird behavior in below link.
https://learn.microsoft.com/en-us/windows/win32/win7appqual/preventing-hangs-in-windows-applications?redirectedfrom=MSDN
Window with "Not Responding" is not the actual window as actual one is set to hidden and thus deactivated. To resolve this, I have remove the GhostWindowFunctionality and now there is no loss of focus.
Only cons is user can not move, minimize, and close the unresponsive application but we have task manager to close/kill such app.
// This is a winform
public partial class ClientForm : Form
{
[DllImport("user32.dll")]
public static extern void DisableProcessWindowsGhosting();
public ClientForm()
{
InitializeComponent();
DisableProcessWindowsGhosting(); // This will disable it
}
private void Search_Click(object sender, EventArgs e)
{
Cursor.Current = Cursors.WaitCursor;
// Do some processing
Thread.Sleep(12000);
Cursor.Current = Cursors.Default;
}
}

Show Main Form after splash screen completes the background process

Is it possible to show just splash screen (without showing main form)?
SplashScreen splash;
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
splash = new SplashScreen();
splash.Show();
BackgroundWorker backgroundWorker = new BackgroundWorker();
backgroundWorker.DoWork += BackgroundWorker_DoWork;
backgroundWorker.RunWorkerCompleted += BackgroundWorker_RunWorkerCompleted;
backgroundWorker.RunWorkerAsync();
// var mainForm = MainForm();
// Application.Run(layoutForm); // I don't want to call this from here
}
private static void BackgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
splash.Close();
// This never gets called, coz application ended
}
private static void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
for (int i = 0; i <= 100; i++)
{
Thread.Sleep(100);
}
}

You would call your Splash screen from your main form.
public partial class mainform : Form
{
public mainform()
{
InitializeComponent();
}
public mainform_Load(object sender, EventArgs e)
{
this.Visible = false;
using (SplashScreen ss = new SplashScreen())
{
ss.ShowDialog();
SetTheme(ss.LoadedTheme);
this.Visible = true;
}
}
private void SetTheme(Theme theme)
{
//Put your theme setting code here.
}
}
Here's how your SplashScreen code will look:
public partial class SplashScreen : Form
{
public Theme LoadedTheme { get; private set; }
public SplashScreen()
{
InitializeComponent();
}
public void SplashScreen_Load(object sender, EventArgs e)
{
bwSplashScreenWorker.RunWorkerAsync();
}
public void bwSplashScreenWorker_DoWork(object sender, DoWorkEventArgs e)
{
// Load in your data here
LoadedTheme = LoadTheme();
}
public void bwSplashScreenWorker_Completed(object sender, RunWorkerCompletedEventArgs e)
{
DialogResult = DialogResult.OK;
}
}
Now, your application will start, when the mainform is loaded it will hide itself, open the SplashScreen in a blocking manner. The splashscreen will load in your theme data in a background thread and save it into the LoadedTheme property. When the background worker completes it will set the DialogResult to OK which closes the SplashScreen and returns control to mainform_Loaded. At this point you call your SetTheme method passing in the public property LoadedTheme from your SplashScreen. Your SetTheme method sets up your theme and returns back to mainform_Loaded where it sets the mainform to visible.

C# Timer not stopping?

Here's what I have, why is my timer(s) not stopping?
I'm not sure what I'm doing wrong.
I'm fairly new to C# and I'm trying to make it so my splash screen Hides(form1) and my program starts(samptool) however my program starts but the splash screen stays and the timers reset instead of stopping. Every 6.5 seconds the application opens in a new window.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Timers;
namespace SplashScreen.cs
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
timer1.Interval = 250;
timer2.Interval = 6500;
timer1.Start();
timer2.Start();
}
private void pictureBox1_Click(object sender, EventArgs e)
{
}
private void timer1_Tick(object sender, EventArgs e)
{
this.progressBar1.Increment(5);
}
private void timer2_Tick(object sender, EventArgs e)
{
SampTool w = new SampTool();
Form1 m = new Form1();
timer1.Enabled = false;
timer1.Stop();
timer2.Enabled = false;
timer2.Stop();
m.Hide();
w.Show();
}
}
}

When you use the new keyword, you create a new instance of a class:
Form1 m = new Form1();
When you create a new instance, the constructor is invoked (the constructor is the method that is named the same as the class).
This will run all the code in the constructor again, hence creating new timers.
To close the current form, you should just run the forms Hide method:
private void timer2_Tick(object sender, EventArgs e)
{
timer1.Stop();
timer2.Stop();
SampTool sampTool = new SampTool();
sampTool.Show();
Hide(); // call the Forms Hide function.
}

C# Singleton form not opening correctly from Timer, opening correctly from button press

I have a singletone form that can be opened from a ribbon button or that will check every minute whether it should be open after passing a few conditional checks.
When opening the form from the ribbon button, it works correctly every time.
When opening on the timer, the form does not get rendered correctly, any place a control should be is just displayed as a white rectangle. Screenshots below.
ThisAddIn.cs
using Timer = System.Timers.Timer;
public partial class ThisAddIn
{
private Timer ticker;
private void ThisAddIn_Startup(object sender, System.EventArgs e) {
ticker = new Timer(5 * 60 * 1000);
ticker.AutoReset = true;
ticker.Elapsed += new System.Timers.ElapsedEventHandler(checkForOverdue);
ticker.Start();
}
private void checkForOverdue(object sender, System.Timers.ElapsedEventArgs e)
{
bool overdue = false;
foreach (Reminder reminder in reminders)
{
DateTime now = DateTime.Now;
if (reminder.time <= now)
{
overdue = true;
break;
}
}
if (overdue)
{
RemindersList form = RemindersList.CreateInstance();
if (form != null)
{
form.Show();
}
}
}
}
Ribbon.cs
public partial class Ribbon
{
private void reminderListButton_Click(object sender, RibbonControlEventArgs e)
{
RemindersList form = RemindersList.CreateInstance();
if (form != null)
{
form.Show();
}
}
}
RemindersList.cs
public partial class RemindersList : Form
{
private static RemindersList _singleton;
private RemindersList()
{
InitializeComponent();
this.FormClosed += new FormClosedEventHandler(f_formClosed);
}
private static void f_formClosed(object sender, FormClosedEventArgs e)
{
_singleton = null;
}
public static RemindersList CreateInstance(List<Reminder> rs)
{
if (_singleton == null)
{
_singleton = new RemindersList(rs);
_singleton.Activate();
// Flash in taskbar if not active window
FlashWindow.Flash(_singleton);
return _singleton;
}
else
{
return null;
}
}
}
EDIT - SOLUTION
Per sa_ddam213's answer, I changed out the System.Timers.Timer for a Windows.Forms.Timer and it's now working just how I wanted.
Code changes:
ThisAddIn.cs
using Timer = System.Windows.Forms.Timer;
public partial class ThisAddIn {
private void ThisAddIn_Startup(object sender, System.EventArgs e) {
ticker = new Timer();
ticker.Interval = 5 * 60 * 1000;
ticker.Tick += new EventHandler(checkForOverdue);
ticker.Start();
}
// Also needed to change the checkForOverdue prototype as follows:
private void checkForOverdue(object sender, EventArgs e)
}

You can't touch UI controls/elements with any other thread than the UI thread, in your case the System.Timer is running on another thread and the window will never open
Try switching to a Windows.Forms.Timer
Or invoke the call back to the UI thread.
private void checkForOverdue(object sender, System.Timers.ElapsedEventArgs e)
{
base.Invoke(new Action(() =>
{
/// all your code here
}));
}

I suspect that the timer event handler is not launched on the UI thread, which could cause all sorts of problems. I would check that first and ensure that the UI stuff is actually done on the UI thread.

Form is not visible on taskbar

I created a default form in Visual Studio 2010 and on the form design I have not changed anything. I only added following code in Form1.cs:
using System;
using System.Windows.Forms;
namespace WinFormTest1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
this.TopMost = true;
this.ShowInTaskbar = true;
this.Load += new EventHandler(Form1_Load);
this.Shown += new EventHandler(Form1_Shown);
}
void Form1_Load(object sender, EventArgs e)
{
this.Opacity = 0;
}
void Form1_Shown(object sender, EventArgs e)
{
this.Opacity = 1;
}
}
}
Starting this program the form does not appear on the taskbar. It only appears on the task bar when made ​​active any other window, and then activating this form.
What is the reason of such behavior?
Edited:
Why do I need to set the opacity of it in handler Form1_Load?
I created class FormAppearingEffect whose code below:
using System;
using System.Diagnostics;
using System.Threading;
using System.Windows.Forms;
namespace AG.FormAdditions
{
public class FormAppearingEffect
{
private Form form;
double originalOpacity;
public FormAppearingEffect(Form form)
{
this.form = form;
form.Load += form_Load;
form.Shown += form_Shown;
}
void form_Load(object sender, EventArgs e)
{
originalOpacity = form.Opacity;
form.Opacity = 0;
}
private void form_Shown(object sender, EventArgs e)
{
try
{
double currentOpacity = 0;
form.Opacity = currentOpacity;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 1; currentOpacity < originalOpacity; i++)
{
currentOpacity = 0.1 * i;
form.Opacity = currentOpacity;
Application.DoEvents();
//if processor loaded and does not have enough time for drawing form, then skip certain count of steps
int waitMiliseconds = (int)(50 * i - stopwatch.ElapsedMilliseconds);
if (waitMiliseconds >= 0)
Thread.Sleep(waitMiliseconds);
else
i -= waitMiliseconds / 50 - 1;
}
stopwatch.Stop();
form.Opacity = originalOpacity;
}
catch (ObjectDisposedException) { }
}
}
}
In any form of program I use this class like this:
using System;
using System.Windows.Forms;
using AG.FormAdditions;
namespace WinFormTest1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
FormAppearingEffect frmEffects = new FormAppearingEffect(this);
}
}
}
Thus my form appears on the screen "gradually".
This is where I found a bug, which we are in this topic.
And that's it for this reason I need to set the opacity in the event handlers.