Как сделать паузу в процедуре и после нее вернуть значение?

Используйте функцию асинхронного ожидания:

Отметьте свой метод как асинхронный.

Добавьте Task.Delay(2000) в качестве ожидаемой задачи.

 public async CSPFEnumration.ProcedureResult GenerateFaxFile(string Daftar_No, string Channelno, string NationalCode)
        {
                -----
                // I want to make a pause in here without locking UI
              await Task.Delay(2000);
                -----
        }

Просьба о минусах:

DoEvents

Предупреждение: тотальное, полное и непростительно вопиющее программирование скотного двора:

// before call (disable the UI element that called this so it can't re-enter)
DateTime st = DateTime.Now();
while(DateTime.Now.Subtract(st).TotalSeconds<3)
    System.Windows.Forms.DoEvents();
// after call (re-enable UI element)

Это казалось бы работать. Никакой ответственности, если люди указывают пальцем и смеются.

Эй, ты спросил!

Вы можете посмотреть вокруг Task.Delay(), он не будет блокировать текущий поток и продолжит выполнение через несколько миллисекунд.

Пример использования из msdn:

Stopwatch sw = Stopwatch.StartNew();
var delay = Task.Delay(1000).ContinueWith(_ =>
                           { sw.Stop();
                             return sw.ElapsedMilliseconds; } );

Console.WriteLine("Elapsed milliseconds: {0}", delay.Result);
// The example displays output like the following:
//        Elapsed milliseconds: 1013

Или, возможно, просмотрите Таймер класс.

Я вижу, как он работает с событиями или задачами (если вы не можете использовать async/await). Вот как создать событие. Мы можем использовать отдельный Thread, чтобы проверить, создан ли файл, и запустить событие, если это так:

public class FileGenEventArgs : EventArgs
{
    public string ProcedureResult { get; set; }
}

public class GenerateFile
{
    public event EventHandler<FileGenEventArgs > fileCreated;

    public GenerateFile()
    {
        // subscribe for this event somewhere in your code.
        fileCreated += GenerateFile_fileCreated;
    }

    void GenerateFile_fileCreated(object sender, FileGenEventArgs args)
    {            
        // .. do something with  args.ProcedureResult
    }

    private void FileCheck()
    {
        Thread.Sleep(2000); // delay

        fileCreated(this, new FileGenEventArgs()
        {
            ProcedureResult = File.Exists(FaxFilePath) ?
              CSPFEnumration.ProcedureResult.Success :
                 CSPFEnumration.ProcedureResult.Error
        });            
    }

    public void GenerateFaxFile(string Daftar_No, string Channelno, string NationalCode)
    {
        try
        {
            // this .Sleep() represents your sql operation so change it
            Thread.Sleep(1000);

            new Thread(FileCheck).Start();
        }
        catch (Exception ex)
        {
            InternalDatabase.GetInstance.InsertToPensionOrganizationException(ex);  
        }
    }
}

Плюсы:

• Пауза, которую вы хотели
• Не блокирует поток пользовательского интерфейса.
• Подход, основанный на событиях (который является правильным способом решения проблем такого рода)

Минусы:

• Требуется рефакторинг вашего кода

Самый простой способ подождать, сохраняя отзывчивость пользовательского интерфейса, — это использовать async-await.

Для этого вы должны объявить свою функцию асинхронной и вернуть Task вместо void и Task<TResult> вместо TResult:

public async Task<CSPFEnumration.ProcedureResult> GenerateFaxFile(
    string Daftar_No,
    string Channelno,
    string NationalCode)
{
    // do your stuff,
}

Теперь всякий раз, когда вы делаете что-то, что требует некоторого времени, используйте асинхронную версию функции для запуска процесса. Пока идет этот процесс, вы можете заниматься другими делами. Когда вам нужен результат await для задачи, и вы получаете пустоту, если асинхронность возвращает Task, или TResult, если асинхронность возвращает Task<TResult>

public async Task<CSPFEnumration.ProcedureResult> GenerateFaxFile(
    string Daftar_No,
    string Channelno,
    string NationalCode)
{
    IEnumerable<string> commandStrings = Regex.Split(
        script, @"^\s*GO\s*$", RegexOptions.Multiline | RegexOptions.IgnoreCase);

    Connect();
    foreach (var commandString in commandStrings)
     {
        if (commandString.Trim() != "")
        {
            using (var command = new SqlCommand(commandString, Connection))
                {
                    Task<int> task = command.ExecuteNonQueryAsync();
                    // while the command is being executed
                    // you can do other things.
                    // when you need the result: await
                    int result = await task;
                    // if useful: interpret result;
                }
            }
        }

        DisConnect();
        ... etc.
}

• Каждая функция, которая вызывает асинхронную функцию, должна быть объявлена ​​асинхронной.
• every async function returns Task instead of void and Task<TResult> instead of TResult
  • There is only one exception: the event handler may return void.

Пример обработчика асинхронного события:

private async void OnButton1_Clicked(object sender, ...)
{
    var task = GenerateFaxFile(...);
    // while the fax file is generated do some other stuff
    // when you need the result:
    var procedureResult = await task;
    Process(procedureResult);
}

Обратите внимание, что все обрабатывается потоком пользовательского интерфейса. Единственная разница в том, что как только происходит что-то, требующее много времени, процесс не ждет, а обрабатывает ввод пользовательского интерфейса.

Вышеупомянутого достаточно, чтобы ваш пользовательский интерфейс оставался отзывчивым. Вы сказали, что хотите знать, как подождать какое-то время. Из остальной части вашего вопроса я понимаю, что вы имели в виду: как прервать процедуру, пока она чего-то ждет, чтобы пользовательский интерфейс мог делать что-то другое. Если вам действительно нужно подождать некоторое время, сохраняя отзывчивость пользовательского интерфейса, используйте Task.Delay(TimeSpan).

Эрик Липперт (спасибо, Эрик!) объяснил асинхронное ожидание следующим образом в ">Stackoverflow - async/await - правильно ли это понимание?

Предположим, на завтрак вам нужно поджарить хлеб и сварить яйца. Для этого есть несколько сценариев:

1. Начните поджаривать хлеб. Подождите, пока это не закончится. Начинайте варить яйца, дождитесь окончания. Синхронная обработка. Пока вы ждете, пока поджарится хлеб, вы больше ничего не можете делать.
2. Начните поджаривать хлеб, пока хлеб поджаривается, начните готовить яйца. когда яйца будут приготовлены, подождите, пока хлеб не поджарится. Это называется асинхронным, но не одновременным. Это делается основным потоком, и пока этот поток что-то делает, основной поток не может делать ничего другого. Но пока он ждет, у него есть время заняться другими делами (например, заварить чай)
3. Наймите поваров, чтобы поджарить хлеб и приготовить яйца. Подождите, пока оба не закончатся. Асинхронный и параллельный: работа выполняется разными потоками. Это самое дорогое, потому что вам нужно начинать новые потоки.

Наконец, примечание об обработке исключений

Вы заметили, что если возникает исключение, вы не отключаетесь? Правильный способ убедиться, что разъединение всегда вызывается, заключается в следующем:

try
{
    Connect();
    ... do other stuff
}
catch (Exception exc)
{
     ... process exception
}
finally
{
    Disconnect();
}

Наконец, часть всегда выполняется, независимо от того, было ли выброшено какое-либо исключение или нет.

Вы можете использовать простой пул потоков для архивирования этого. Однако ваш возврат должен выполняться асинхронно, чтобы он не блокировал графический интерфейс.

public void GenerateFaxFile(string Daftar_No, string Channelno,
            string NationalCode, Action<CSPFEnumration.ProcedureResult> result)
        {
            ThreadPool.QueueUserWorkItem(o =>
            {
                string script = "your script";
                try
                {
                    // more of your script

                    // I want to make a pause in here without locking UI
                    while (true)
                    {
                        // do your check here to unpause
                        if (stopMe == true)
                        {
                            break;
                        }

                        Thread.Sleep(500);
                    }


                    if (File.Exists(FaxFilePath))
                    {
                        result(CSPFEnumration.ProcedureResult.Success);
                        return;
                    }
                    else
                    {
                        result(CSPFEnumration.ProcedureResult.Error);
                    }


                }
                catch (Exception ex)
                {
                    InternalDatabase.GetInstance.InsertToPensionOrganizationException(ex);
                    result(CSPFEnumration.ProcedureResult.Error);
                    return;
                }

            });

        }

        public void HowToUseMe()
        {
            GenerateFaxFile("", "", "", result => {

                if (result == CSPFEnumration.ProcedureResult.Error)
                {
                    // no good
                }
                else
                {
                    // bonus time
                }
            });
        }

Вы должны использовать старый добрый фоновый поток (см. ответ, написанный FabJan), или вы можете использовать async и await с контекстом синхронизации:

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private async void buttonStart_Click(object sender, EventArgs e)
    {
        await progressBar1.DoProgress(2000);
        Trace.WriteLine("Done");          
        MessageBox.Show("Done");
    }

    private void buttonMoveButton1_Click(object sender, EventArgs e)
    {
        //to prove UI click several times buttonMove while the task is ruunning
        buttonStart.Top += 10;
    }
}

public static class WaitExtensions
{
    public static async Task DoProgress(this ProgressBar progressBar, int sleepTimeMiliseconds)
    {
        int sleepInterval = 50;
        int progressSteps = sleepTimeMiliseconds / sleepInterval; //every 50ms feedback
        progressBar.Maximum = progressSteps;

        SynchronizationContext synchronizationContext = SynchronizationContext.Current;
        await Task.Run(() =>
        {
            synchronizationContext.OperationStarted();

            for (int i = 0; i <= progressSteps; i++)
            {
                Thread.Sleep(sleepInterval);
                synchronizationContext.Post(new SendOrPostCallback(o =>
                {
                    Trace.WriteLine((int)o + "%");

                    progressBar.Value = (int)o;
                }), i);
            }

            synchronizationContext.OperationCompleted();
        });
    }
}    

Может показаться, что MessageBox сделал шоу до того, как ProgressBar достигнет своего максимума. Я виню в этом волшебную анимацию progressBar в Windows 8. Пожалуйста, поправьте меня, если я ошибаюсь.