像Web应用程序一样以windows形式实现加载器

Question

I'm trying displaying Loader while any long running process being executing in windows forms . I have implemented code for that, but loader being displayed but not in CenterParent location, it will be displayed on Center of the screen.

Code:

CPLoader is form that I want to display while any process executing.

public class CommonLoader
{
    CPLoader cploader = new CPLoader();
    readonly Form form = null;

    public CommonLoader(Form frm)
    {
        form = frm;
    }

    public void ShowLoader()
    {
        try
        {
            if (form.InvokeRequired)
            {
                try
                {
                    cploader = new CPLoader();
                    cploader.ShowDialog();
                }
                catch 
                {
                    Console.WriteLine("Cp loader exception");
                }
            }
            else
            {
                Thread th = new Thread(ShowLoader);
                th.IsBackground = false;
                th.Start();
            }
        }
        catch
        {
            Console.WriteLine("Cp loader exception");
        }
    }

    /// <summary>
    /// this method will used for hide loader while process stop
    /// </summary>
    public void HideLoader()
    {
        try
        {
            if (cploader != null)
            {
                Thread.Sleep(200);
                cploader.Invoke(new Action(cploader.Close));
            }
        }
        catch
        {
            Console.WriteLine("Cp loader exception");
        }
    }
}

I have also try cploader.ShowDialog() with frm.BeginInvoke(new MethodInvoker(delegate(){cploader.ShowDialog(form); })) .

If I use BeginInvoke() then I'm unable to close the loader.

Answer 1

Splash screens, progress screens etc appeared in Visual Basic or Delphi desktop applications long before web applications. They are just modeless forms/windows displayed on top of their application. They don't need threads either - back then applications were mostly single threaded.

Background threads can't modify the UI anyway, which means that the entire ShowLoader method does nothing more than try to call :

cploader = new CPLoader();
cploader.ShowDialog();

All of this can be replaced with

public void ShowLoader()
{
    cploader.ShowDialog();
}

public void HideLoader()
{
    cploader.Hide(); 
    //or Close if we don't intend to reuse the loader
}

Specifying the parent

Calling ShowDialog without any parameters creates a window whose parent is the desktop. That's why the window appears centered on the screen, not the application.

To specify an owner/parent, just pass it as the owner parameter to ShowDialog or Show .

The following code can be used to display a dialog box centered on the current form :

var myDialog=new MyDialogForm();
myDialog.ShowDialog(this);

This means that ShowLoader probably has to accept the owner as a parameter :

public void ShowLoader(Form frm)
{
    cploader.ShowDialog(frm);
}

Modeless windows

ShowDialog() is used to display a modal form - a form that retains the focus until it's closed, just like a dialog box. That's why the method is called ShowDialog() instead of ShowModal() .

A loader needs to be modeless, so Show should be used instead :

public void ShowLoader(Form frm)
{
    cploader.Show(frm);
}

Another difference is that ShowDialog returns a result with the user's choice (OK, Cancel etc) while Show returns nothing.

Modal Loader with notification

If you want to create a modal loader with ShowDialog but still perform some work in the background, you need a way to notify that loader from the background thread. You can do that using the Progress class.

The loader can expose IProgress<T> as a property. The T parameter can be a simple string or integer showing progress, or a complex entity with progress, a string message and a status indicator. For laziness' sake, let's use string and close the dialog if the value is empty :

public IProgress<string> Progress{get;private set;}

public CPLoader()
{
    this.Progress=new Progress<string>(UpdateUI);
}

private void UpdateUI(string msg)
{
    if(String.IsNullOrWhitespace(msg))
    {       
        this.DialogResult=DialogResult.Cancel;
        this.Close(); 
    }
    else
    {
        this.SomeLabel.Text=msg;
    }
}

The code that works in the background needs access to that IProgress<string> property. Let's say the code that needs to work in the background is :

void Work(IProgress<string> progress)
{
    for(int i=0;i<1000000;i++)
    {
        //Do something CPU intensive
        //Report every 1000 items
        if(i%1000==0)
        {
            progress.Report($"{i} out of 1000000");
        }
    }
    //This tells the loader to close.
    progress.Report("");
}

This code can run in the background and use the loader this way :

var loader=new CPLoader();
var task=Task.Run(()=>DoWork(loader.Progress));
loader.ShowDialog();
await task;

The loader is initialized first, giving us access to the IProgress<T> instance. The job gets started in the background after that with Task.Run . When it finishes, it sends an empty progress string and the loader's UpdateUI method closed the dialog in response

The code that needs to perform work while loading can access that IProgress<string> interface and use it to signal pro