C # Sql Server "окно загрузки"

Question

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

Теперь мой вопрос: Я занимаюсь разработкой своего первого программного приложения, которое обменивается данными между сервером SQL и самим приложением. Это разрабатывается в C #. Сохранение или получение данных из базы данных сервера SQL не является проблемой. То, что я хочу, это способ информировать пользователя о задержке между локальной машиной (где установлено приложение) и сервером. Я могу сделать некоторые анимации или просто отобразить несколько текстовых сообщений. Мне нужна помощь в том, как создать код, который активирует / запускает / запускает, когда время взаимодействия с этим сервером работает.

Если вы не можете понять идею, представьте себе видеоигру. Когда он загружается (в некоторых играх), вы можете видеть экран загрузки перед началом игры. Мне нужен код, который отображает это «окно загрузки», когда приложение загружает или загружает данные с / на сервер.

Буду признателен за любой пример кода или рекомендацию веб-сайта.

PS: Извините за обширный текст, но я хочу убедиться, что все понимают, поэтому мне не нужно повторять это снова: P

Answer 1

• Как реализовать индикатор выполнения в C #?

• Каксоздать плавный индикатор выполнения в Visual C #

• Класс ProgressBar

Answer 2

Сначала позвольте мне поблагодарить вас за ваши ответы.

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

С.Амани ответил, что это было не совсем то, что я хочу, но благодаря этому я нашел более легкий путь. Я создал форму (может быть что угодно), разместил метку с надписью: «Сохранение в базе данных», вынул верхнюю панель, определил местоположение и определил, что ее родитель должен быть отключен, когда отображается, и включается при закрытии. Следующий код - это то, что я поместил в свой DataBaseInteractionClass

private Wait myCustomWaitDialog = new Wait(); // My Waiting form

private void SaveToDatabase(myObjectToSave obj) // Method called to save data do DB
{
    // Create the connections and queries
    (...)
    // This is what I did
    // Show Waiting Form
    myCustomWaitDialog.Show();
    // Instanciate the command that will carry the query and to DB
    SqlCommand command = new SqlCommand(Queries.GetData(code), conn);
    // This is important
    //Create event that will fire when the command completes
    command.StatementCompleted += new StatementCompletedEventHandler(command_StatementCompleted);
    // Execute the transaction
    SqlDataReader reader = command.ExecuteReader();
    // Rest of the code (validations, close connections, try/catch, etc
    (...)
}

void command_StatementCompleted(object sender, StatementCompletedEventArgs e)
{
    // This is the method that closes my Waiting Dialog 
    myCustomWaitDialog.CloseDialog();
    myCustomWaitDialog.Dispose();
}

Это не совсем то, чего я хочу, но это лучшее решение, которое я нашел до сих пор. На данный момент это будет делать :) В любом случае, спасибо за ответы, и я надеюсь, что это поможет кому-то еще.

Answer 3

Я разработал простой PleaseWait класс 2 года назад, но я не обновлял этот класс, он работает очень хорошо, надеюсь, это даст вам идею реализовать вашу логику.

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

    bool _isMoving = false;
    int _moveStart_x = 0;
    int _moveStart_y = 0;


    private void tmrProgress_Tick(object sender, EventArgs e)
    {
        if (barProgress.Value == barProgress.Maximum)
            barProgress.Value = barProgress.Minimum;
        else
            barProgress.Value += 1;
    }

    private void btnCancel_Click(object sender, EventArgs e)
    {
        Close();
        PleaseWait.Abort();
    }
    protected override CreateParams CreateParams
    {
        get
        {
            System.Windows.Forms.CreateParams p = base.CreateParams;
            p.ClassStyle += 0x20000;
            p.ExStyle += 0x8000000;
            return p;
        }
    }

    protected override void WndProc(ref Message m)
    {
        const int WM_NCHITTEST = 132;

        base.WndProc(ref m);

        switch (m.Msg)
        {
            case WM_NCHITTEST:
                if (m.Result.ToInt32() == 1)
                    m.Result = new IntPtr(2);
                break;
        }
    }

    private void panelEx1_MouseDown(object sender, MouseEventArgs e)
    {
        if (e.Button == MouseButtons.Left)
        {
            _isMoving = true;
            _moveStart_x = e.X;
            _moveStart_y = e.Y;
        }
    }

    private void panelEx1_MouseUp(object sender, MouseEventArgs e)
    {
        _isMoving = false;
    }

    private void pnlContainer_MouseMove(object sender, MouseEventArgs e)
    {
        if (_isMoving)
            this.Location = new Point(Location.X + e.X - _moveStart_x, Location.Y + e.Y - _moveStart_y);
    }
}

public class PleaseWait
{
    #region Static Operations
    private static Boolean _isAborted = false;
    private static Boolean _isVisible = false;
    private static frmWait _waitForm;
    private static String _waitingState = "";
    private static Boolean _autoClose = false;
    private static Boolean _cancelable = false;
    private static System.Threading.Thread _waiterThred;

    public delegate void CancelButtonPressed();

    public static event CancelButtonPressed OnCancel;

    public static Boolean AutoClose
    {
        get { return PleaseWait._autoClose; }
        set { PleaseWait._autoClose = value; }
    }
    public static string WaitingState
    {
        get { return PleaseWait._waitingState; }
        set { PleaseWait._waitingState = value; }
    }
    public static bool IsVisible
    {
        get { return _isVisible; }
        internal set { _isVisible = value; }
    }

    public static void ShowPleaseWait()
    {
        ShowPleaseWait("", _autoClose, false);
    }

    public static void ShowPleaseWait(string waitingState)
    {
        ShowPleaseWait(waitingState, _autoClose, false);
    }

    public static void ShowPleaseWait(bool autoClose)
    {
        ShowPleaseWait("", autoClose, false);
    }

    public static void ShowPleaseWait(string waitingState, bool autoClose, bool cancelable)
    {
        if (_waiterThred != null)
        {
            if (_isVisible)
            {
                // the please wait it woking, just continue and apply the changes
                _waitingState = waitingState;
                _autoClose = autoClose;
                _cancelable = cancelable;
                return;
            }
            else
            {
                _waiterThred.Abort();
                _waiterThred = null;
            }
        }

        _waitingState = waitingState;
        _autoClose = autoClose;
        _cancelable = cancelable;
        _isAborted = false;
        _isVisible = false;

        if (_autoClose)
            Application.Idle += new EventHandler(Application_Idle);



        _waiterThred = new System.Threading.Thread(DisplayWaitingForm);
        _waiterThred.IsBackground = true;
        _waiterThred.Name = "Please Wait....";
        _waiterThred.Start();
        Application.DoEvents();
    }

    public static void Abort()
    {
        _isAborted = true;
    }

    private static void Application_Idle(object sender, EventArgs e)
    {
        if (_autoClose)
            _isAborted = true;
    }


    private static void DisplayWaitingForm()
    {
        if (_waitForm != null)
        {
            if (!_waitForm.IsDisposed)
                _waitForm.Dispose();
            _waitForm = null;
            _isVisible = false;
        }
        try
        {
            if (_isAborted)
                return;

            _waitForm = new frmWait();
            if (_cancelable)
            {
                _waitForm.btnCancel.Enabled = true;
                _waitForm.btnCancel.Click += new EventHandler(btnCancel_Click);
            }
            try
            {
                _isVisible = true;
                _waitForm.Show();
                _waitForm.Focus();
                while (!_isAborted)
                {
                    System.Threading.Thread.Sleep(15);
                    _waitForm.lblMessage.Text = _waitingState;
                    Application.DoEvents();
                    _waitForm.lblMessage.Text = _waitingState;
                }
                _isVisible = false;
            }
            finally
            {
                FreeWaitingForm();
            }
        }
        finally
        {
            _isVisible = false;
        }
    }

    static void btnCancel_Click(object sender, EventArgs e)
    {
        if (_waitForm.InvokeRequired)
        {
            _waitForm.BeginInvoke(new EventHandler(btnCancel_Click), new object[] { e });
        }
        else
        {
            if (OnCancel != null)
                OnCancel.Invoke();
        }
    }

    private static void FreeWaitingForm()
    {
        _waitingState = "";
        _isVisible = false;
        if (_waitForm == null)
        {
            return;
        }
        _waitForm.Hide();
        if (!_waitForm.IsDisposed)
            _waitForm.Dispose();
        _waitForm = null;
    }

    #endregion
}

используйте как следующий код:

PleaseWait.ShowPleaseWait("Please wait", true, false);
// If second param is true then it will close the form automatically.
// If third param is true the it will expose a cancel button, so you can cancel your Asynchronous operations.

Я не вставил код дизайна, вы можете понять, посмотрев код.

надеюсь, что это поможет.