Un requisito diverso per una schermata iniziale in App WinForms

Question

Ok, so che questo è stato chiesto un milione di volte prima (e la gente anche iniziare la domanda StackOverflow nello stesso modo XD), ma mi piacerebbe sapere come raggiungere il seguente:

1. L'applicazione prima lancia una scatola di inizio
2. Se l'accesso riesce, allora la schermata iniziale deve dimostrare (in un thread separato).
3. Mentre la schermata iniziale mostra, un oggetto di classe devono essere riempiti (che aderisce al pattern Singleton) con abbondanti quantità di dati specifici dell'utente dal DB, mentre la visualizzazione torna all'utente che cosa sta facendo (ad es. L'inizializzazione. ..loading preferenze dei dati ... loading ... rendendo spazio di lavoro ... fatto!)
4. La schermata iniziale deve attendere il modulo principale per terminare inizializzazione sul filo principale, prima di essere smaltiti.

Questo è il flusso di volontà per l'applicazione. Alla chiusura del modulo principale, l'utente deve essere restituito alla casella di accesso.

Devo dire in anticipo che non sono tutto ciò che chiarirmi su un sacco di roba WinForms, ma attraverso chiedendo questo tipo di domande, sto lentamente imparando. Ho fatto un po 'di lettura su threading, e ho imparato che la schermata iniziale dovrebbe essere deposto le uova nel proprio thread, e dei mangimi aggiornamenti di stato utilizzando i delegati (per soddisfare gli aggiornamenti cross-thread per l'interfaccia utente) dal thread principale, e che questo dovrebbe essere fatto nel Program.cs "Main ()" subroutine.

Sto raggiungendo fuori qui, come io non so nemmeno da dove cominciare, a causa del requisito aggiuntivo di avere il modulo di login spettacolo prima (e poi la scorsa quando la forma principale è chiuso). Io certamente valorizzare qualsiasi tipo di assistenza in questo senso.

Molto grazie! sha

Answer 1

Ecco un semplice esempio di come fare questo. Il trucco è quello di rendere la casella di login modulo principale dal momento che è quello che si apre e si chiude prima scorso.

In questo esempio, il modulo di loginscreen ha un tasto, un pulsante OK che richiama il metodo OnOK () quando si fa clic.

public partial class LoginScreen : System.Windows.Forms.Form
{
    ApplicationWindow window;

    public LoginScreen()
    {
        InitializeComponent();
    }
    private void OnFormClosed( object sender, FormClosedEventArgs e )
    {
        this.Show();
    }
    private void OnOK( object sender, EventArgs e )
    {
        this.Hide();

        window = new ApplicationWindow();
        window.FormClosed += OnFormClosed;
        window.Show();
    }
}

La forma ApplicationWindow sarebbe pari a quello che lei ha fatto riferimento a come forma "principale". E 'quello che lancia lo SplashForm.

public partial class ApplicationWindow : System.Windows.Forms.Form
{
    public ApplicationWindow()
    {
        SplashForm.Show( 500 );

        InitializeComponent();
    }

    private void OnLoad( object sender, EventArgs e )
    {
        // Simulate doing a lot of work here.
        System.Threading.Thread.Sleep( 1000 );

        SplashForm.Hide();

        Show();
        Activate();
    }
}

Ed ecco una copia del SplashForm che uso. Sarà fade in e fade out in base al numero di millisecondi specificati nel statico Show () metodo.

public partial class SplashForm : Form
{
    #region Public Methods

    /// <summary>
    /// Shows the splash screen with no fading effects.
    /// </summary>
    public new static void Show()
    {
        Show( 0 );
    }

    /// <summary>
    /// Shows the splash screen.
    /// </summary>
    /// <param name="fadeTimeInMilliseconds">The time to fade
    /// in the splash screen in milliseconds.</param>
    public static void Show( int fadeTimeInMilliseconds )
    {
        // Only show the splash screen once.
        if ( _instance == null ) {
            _fadeTime = fadeTimeInMilliseconds;
            _instance = new SplashForm();

            // Hide the form initially to avoid any pre-paint flicker.
            _instance.Opacity = 0;
            ( ( Form ) _instance ).Show();

            // Process the initial paint events.
            Application.DoEvents();

            if ( _fadeTime > 0 ) {
                // Calculate the time interval that will be used to
                // provide a smooth fading effect.
                int fadeStep = ( int ) Math.Round( ( double ) _fadeTime / 20 );
                _instance.fadeTimer.Interval = fadeStep;

                // Perform the fade in.
                for ( int ii = 0; ii <= _fadeTime; ii += fadeStep ) {
                    Thread.Sleep( fadeStep );
                    _instance.Opacity += 0.05;
                }
            } else {
                // Use the Tag property as a flag to indicate that the
                // form is to be closed immediately when the user calls
                // Hide();
                _instance.fadeTimer.Tag = new object();
            }

            _instance.Opacity = 1;
        }
    }

    /// <summary>
    /// Closes the splash screen.
    /// </summary>
    public new static void Hide()
    {
        if ( _instance != null ) {
            // Invoke the Close() method on the form's thread.
            _instance.BeginInvoke( new MethodInvoker( _instance.Close ) );

            // Process the Close message on the form's thread.
            Application.DoEvents();
        }
    }

    #endregion Public Methods

    #region Constructors

    /// <summary>
    /// Initializes a new instance of the SplashForm class.
    /// </summary>
    public SplashForm()
    {
        InitializeComponent();

        Size = BackgroundImage.Size;

        // If transparency is ever needed, set the color of the desired
        // transparent portions of the bitmap to fuschia and then
        // uncomment this code.
        //Bitmap bitmap = new Bitmap(this.BackgroundImage);
        //bitmap.MakeTransparent( System.Drawing.Color.Fuchsia );
        //this.BackgroundImage = bitmap;
    }

    #endregion Constructors

    #region Protected Methods

    protected override void OnClosing( CancelEventArgs e )
    {
        base.OnClosing( e );

        // Check to see if the form should be closed immediately.
        if ( fadeTimer.Tag != null ) {
            e.Cancel = false;
            _instance = null;
            return;
        }

        // Only use the timer to fade if the form is running.
        // Otherwise, there will be no message pump.
        if ( Application.OpenForms.Count > 1 ) {
            if ( Opacity > 0 ) {
                e.Cancel = true; // prevent the form from closing
                Opacity -= 0.05;

                // Use the timer to iteratively call the Close method.
                fadeTimer.Start();
            } else {
                fadeTimer.Stop();

                e.Cancel = false;
                _instance = null;
            }
        } else {
            if ( Opacity > 0 ) {
                Thread.Sleep( fadeTimer.Interval );
                Opacity -= 0.05;
                Close();
            } else {
                e.Cancel = false;
                _instance = null;
            }
        }
    }

    #endregion Protected Methods

    #region Private Methods

    private void OnTick( object sender, EventArgs e )
    {
        Close();
    }

    #endregion Private Methods

    #region Private Fields

    private static SplashForm _instance = null;
    private static int _fadeTime = 0;

    #endregion Private Fields
}

Lo SplashForm è solo una forma vuota con i seguenti valori di proprietà:

• BackgroundImage = (l'immagine della vostra scelta)
• BackgroundImageLayout = Centro
• DoubleBuffered = true
• FormBorderStyle = Nessuno
• ShowInTaskbar = False
• StartPosition = CenterScreen
• TopMost = true

Esso contiene anche un controllo System.Windows.Forms.Timer chiamato fadeTimer con le proprietà predefinite. L'evento Tick è configurato per richiamare il metodo onTick ().

Quello che non fa è aggiornare lo stato del processo di caricamento. Forse qualcun altro può riempire in quella porzione per te.