it-swarm.com.de

c # ein neues Formular öffnen, dann das aktuelle Formular schließen?

Angenommen, ich bin in Formular 1, dann möchte ich:

  1. Formular 2 öffnen (über eine Schaltfläche in Formular 1)
  2. Formular 1 schließen
  3. Konzentrieren Sie sich auf Formular 2
61
tnhan07

Steves Lösung funktioniert nicht. Beim Aufruf von this.Close () wird das aktuelle Formular zusammen mit form2 angezeigt. Daher müssen Sie es ausblenden und das form2.Closed -Ereignis festlegen, um this.Close () aufzurufen.

private void OnButton1Click(object sender, EventArgs e)
{
    this.Hide();
    var form2 = new Form2();
    form2.Closed += (s, args) => this.Close(); 
    form2.Show();
}
150
nihique

Versuchen Sie das zu tun ...

{
    this.Hide();
    Form1 sistema = new Form1();
    sistema.ShowDialog();
    this.Close();
}
18
MontDeska

Das Problem liegt bei dieser Linie:

Application.Run(new Form1()); Was sich wahrscheinlich in Ihrer program.cs-Datei befindet.

Diese Zeile zeigt an, dass form1 die Nachrichtenschleife verarbeiten soll. Mit anderen Worten, form1 ist für die weitere Ausführung Ihrer Anwendung verantwortlich. Die Anwendung wird geschlossen, wenn form1 geschlossen wird.

Es gibt mehrere Möglichkeiten, um damit umzugehen, aber alle werden auf die eine oder andere Weise form1 nicht schließen.
(Sofern wir den Projekttyp nicht in eine Windows Forms-Anwendung ändern)

Ich denke, dass es für Ihre Situation am einfachsten ist, 3 Formulare zu erstellen:

  • form1 - bleibt unsichtbar und fungiert als Manager. Sie können es zuweisen, wenn Sie möchten, mit einem Tray-Symbol.

  • form2 - hat die Schaltfläche, die, wenn Sie darauf klicken, form2 schließt und form3 öffnet

  • form3 - hat die Rolle des anderen Formulars, das geöffnet werden muss.

Und hier ist ein Beispielcode, um das zu erreichen:
(Ich habe auch ein Beispiel hinzugefügt, um die App aus dem 3. Formular zu schließen.)

static class Program
{
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1()); //set the only message pump to form1.
    }
}


public partial class Form1 : Form
{
    public static Form1 Form1Instance;

    public Form1()
    {
        //Everyone eveywhere in the app should know me as Form1.Form1Instance
        Form1Instance = this;

        //Make sure I am kept hidden
        WindowState = FormWindowState.Minimized;
        ShowInTaskbar = false;
        Visible = false;

        InitializeComponent();

        //Open a managed form - the one the user sees..
        var form2 = new Form2();
        form2.Show();
    }

}

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

    private void button1_Click(object sender, EventArgs e)
    {
        var form3 = new Form3(); //create an instance of form 3
        Hide();             //hide me (form2)
        form3.Show();       //show form3
        Close();            //close me (form2), since form1 is the message loop - no problem.
    }
}

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

    private void button1_Click(object sender, EventArgs e)
    {
        Form1.Form1Instance.Close(); //the user want to exit the app - let's close form1.
    }
}


Hinweis: Die Arbeit mit Panels oder das dynamische Laden von Benutzersteuerelementen ist eher wissenschaftlich und als Produktionsstandards der Industrie vorzuziehen - aber ich glaube, Sie versuchen nur zu überlegen, wie die Dinge funktionieren - dafür ist dieses Beispiel besser.

Und jetzt, wo die Prinzipien verstanden werden, versuchen wir es mit zwei Formen:

  • Das erste Formular übernimmt die Rolle des Managers wie im vorherigen Beispiel, zeigt jedoch auch den ersten Bildschirm an, damit es nicht einfach nur ausgeblendet wird.

  • Das zweite Formular übernimmt die Aufgabe, den nächsten Bildschirm anzuzeigen, und durch Klicken auf eine Schaltfläche wird die Anwendung geschlossen. 


    public partial class Form1 : Form
    {
        public static Form1 Form1Instance;

        public Form1()
        {
            //Everyone eveywhere in the app show know me as Form1.Form1Instance
            Form1Instance = this;
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //Make sure I am kept hidden
            WindowState = FormWindowState.Minimized;
            ShowInTaskbar = false;
            Visible = false;

            //Open another form 
            var form2 = new Form2
            {
                //since we open it from a minimezed window - it will not be focused unless we put it as TopMost.
                TopMost = true
            };
            form2.Show();
            //now that that it is topmost and shown - we want to set its behavior to be normal window again.
            form2.TopMost = false; 
        }
    }

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

        private void button1_Click(object sender, EventArgs e)
        {
            Form1.Form1Instance.Close();
        }
    }

Wenn Sie das vorige Beispiel ändern, löschen Sie form3 aus dem Projekt.

Viel Glück.

9
G.Y

Viele andere Wege wurden bereits in den anderen Antworten beschrieben. Viele von ihnen sind jedoch entweder ShowDialog() betroffen oder form1 bleibt offen, bleibt jedoch verborgen. Der beste und intuitivste Weg ist meiner Meinung nach, einfach form1 zu schließen und dann form2 von außerhalb (dh nicht in einem dieser Formulare) zu erstellen. In dem Fall, in dem form1 in Main erstellt wurde, kann form2 einfach mit Application.Run wie zuvor form1 erstellt werden. Hier ist ein Beispielszenario:

Ich brauche den Benutzer, um seine Zugangsdaten einzugeben, damit ich sie irgendwie authentifizieren kann. Wenn die Authentifizierung erfolgreich war, möchte ich dem Benutzer die Hauptanwendung zeigen. Um dies zu erreichen, verwende ich zwei Formen: LogingForm und MainForm. Die Variable LoginForm verfügt über ein Flag, das bestimmt, ob die Authentifizierung erfolgreich war oder nicht. Dieses Flag wird dann verwendet, um zu entscheiden, ob die MainForm-Instanz erstellt werden soll oder nicht. Keine dieser Formen muss über die andere Form Bescheid wissen, und beide Formen können elegant geöffnet und geschlossen werden. Hier ist der Code dafür:

class LoginForm : Form
{
    bool UserSuccessfullyAuthenticated { get; private set; }

    void LoginButton_Click(object s, EventArgs e)
    {
        if(AuthenticateUser(/* ... */))
        {
            UserSuccessfullyAuthenticated = true;
            Close();
        }
    }
}

static class Program
{
    [STAThread]
    static void Main()
    {
        LoginForm loginForm = new LoginForm();
        Application.Run(loginForm);

        if(loginForm.UserSuccessfullyAuthenticated)
        {
            // MainForm is defined elsewhere
            Application.Run(new MainForm());
        }
    }
}
9
Manuzor

Sie waren nicht spezifisch, aber es sieht so aus, als hätten Sie versucht, das zu tun, was ich in meinen Win Forms-Apps getan habe: Beginnen Sie mit einem Anmeldeformular, schließen Sie nach erfolgreichem Login dieses Formular und legen Sie den Fokus auf ein Hauptformular. So mache ich es:

  1. machen Sie frmMain zum Startformular; So sieht mein Program.cs aus: 

    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new frmMain());
    }
    
  2. erstellen Sie in meinem FrmLogin eine öffentliche Eigenschaft, die nur bei einer erfolgreichen Anmeldung mit "false" initialisiert wird und auf "true" gesetzt wird: 

    public bool IsLoggedIn { get; set; }
    
  3. mein frmMain sieht so aus: 

    private void frmMain_Load(object sender, EventArgs e)
    {
        frmLogin frm = new frmLogin();
        frm.IsLoggedIn = false;
        frm.ShowDialog();
    
        if (!frm.IsLoggedIn)
        {
            this.Close();
            Application.Exit();
            return;
        }
    

Kein erfolgreiches Login Beenden Sie die Anwendung. Ansonsten fahren Sie mit frmMain fort. Da es sich um das Startformular handelt, wird die Anwendung beim Schließen geschlossen.

6
Barry Novak

verwenden Sie dieses Code-Snippet in Ihrem form1.

public static void ThreadProc()
{
Application.Run(new Form());
}

private void button1_Click(object sender, EventArgs e)
{
System.Threading.Thread t = new System.Threading.Thread(new System.Threading.ThreadStart(ThreadProc));
t.Start();
this.Close();
}

Ich habe das von hier

1
lakshman

Dieser Code kann Ihnen helfen:

Master frm = new Master();

this.Hide();

frm.ShowDialog();

this.Close();
                     this.Visible = false;
                        //or                         // will make LOgin Form invisivble
                        //this.Enabled = false;
                         //  or
                       // this.Hide(); 



                        Form1 form1 = new Form1();
                        form1.ShowDialog();

                        this.Dispose();
0
Aamir Zargar

Angenommen, Sie haben zwei Formulare. Der erste Formularname ist Form1 und der zweite Formularname ist Form2. Schreibe den Code wie folgt: 

Auf Form1 habe ich eine Schaltfläche mit dem Namen Button1, und auf deren Klickoption schreiben Sie den Code:

protected void Button1_Click(Object sender,EventArgs e)
{
    Form frm=new Form2();// I have created object of Form2
    frm.Show();
    this.Visible=false;
    this.Hide();
    this.Close();
    this.Dispose();
}

Ich hoffe, dieser Code wird Ihnen helfen

0
Shahnawaz

Ich denke das ist viel einfacher :)

    private void btnLogin_Click(object sender, EventArgs e)
    {
        //this.Hide();
        //var mm = new MainMenu();
        //mm.FormClosed += (s, args) => this.Close();
        //mm.Show();

        this.Hide();
        MainMenu mm = new MainMenu();
        mm.Show();

    }
0
Sachith
private void buttonNextForm(object sender, EventArgs e)
{
    NextForm nf = new NextForm();//Object of the form that you want to open
    this.hide();//Hide cirrent form.
    nf.ShowModel();//Display the next form window
    this.Close();//While closing the NextForm, control will come again and will close this form as well
}
0
Prateek Shukla

Wenn Sie zwei Formulare haben: frm_form1 und frm_form2. Mit dem folgenden Code können Sie frm_form2 öffnen und frm_form1 schließen. (Für Windows-Formularanwendung)

        this.Hide();//Hide the 'current' form, i.e frm_form1 
        //show another form ( frm_form2 )   
        frm_form2 frm = new frm_form2();
        frm.ShowDialog();
        //Close the form.(frm_form1)
        this.Close();
0
maneesh
//if Form1 is old form and Form2 is the current form which we want to open, then
{
Form2 f2 = new Form1();

this.Hide();// To hide old form i.e Form1
f2.Show();
}
0
user2186819