Última actualización: 31.10.2015

Para agregar otro formulario al proyecto, haga clic derecho en el nombre del proyecto en la ventana del Explorador de soluciones y seleccione Agregar->Formulario de Windows...

vamos a dar nueva forma algún nombre, por ejemplo, Formulario2.cs:

Entonces, hemos agregado un segundo formulario a nuestro proyecto. Ahora intentemos implementar la interacción entre dos formas. Digamos que el primer formulario llamará al segundo formulario cuando se haga clic en el botón. Primero, agreguemos un botón al primer formulario, Form1, y hagamos doble clic en el botón para ir al archivo de código. Entonces, seremos llevados al controlador de eventos de clic del botón, que se crea de forma predeterminada después de hacer doble clic en el botón:

Botón de anulación privada1_Click(remitente del objeto, EventArgs e) ( )

Ahora agreguemos el código para llamar al segundo formulario. Nuestro segundo formulario se llama Form2, así que primero creamos un objeto de esta clase, y luego para mostrarlo en pantalla llamamos al método Show:

Botón de anulación privado1_Click (remitente del objeto, EventArgs e) ( Form2 newForm = new Form2(); newForm.Show(); )

Ahora hagamos lo contrario: para que la segunda forma afecte a la primera. Mientras que la segunda forma desconoce la existencia de la primera. Para solucionar este problema, debe transferir de alguna manera información sobre el primer formulario al segundo formulario. Para hacer esto, usaremos pasar un enlace al formulario en el constructor.

Entonces, pasemos al segundo formulario y vayamos a su código: haga clic derecho en el formulario y seleccione Ver código. Por ahora está vacío y contiene sólo un constructor. Dado que C# admite la sobrecarga de métodos, podemos crear varios métodos y constructores con diferentes parámetros y llamar a uno de ellos según la situación. Entonces, cambiemos el archivo de código del segundo formulario a lo siguiente:

Usando el Sistema; usando System.Collections.Generic; usando System.ComponentModel; usando System.Data; usando System.Drawing; usando System.Linq; usando System.Text; usando System.Threading.Tasks; usando System.Windows.Forms; espacio de nombres HelloApp (clase parcial pública Form2: Formulario (Form2 público() (InitializeComponent(); ) Form2 público(Form1 f) (InitializeComponent(); f.BackColor = Color.Yellow; ) ) )

De hecho, acabamos de agregar aquí nuevo constructor public Form2(Form1 f) , en el que obtenemos el primer formulario y configuramos su fondo en amarillo. Ahora pasemos al código del primer formulario, donde llamamos al segundo formulario y lo cambiamos a lo siguiente:

Botón de anulación privado1_Click(remitente del objeto, EventArgs e) ( Form2 newForm = new Form2(this); newForm.Show(); )

Desde en en este caso la palabra clave this representa una referencia al objeto actual: el objeto Form1, luego, al crear un segundo formulario, lo recibirá (el enlace) y controlará el primer formulario a través de él.

Ahora, después de hacer clic en el botón, se creará un segundo formulario, que inmediatamente cambiará el color del primer formulario.

También podemos crear objetos de la forma actual:

Botón de anulación privado1_Click(remitente del objeto, EventArgs e) ( Form1 newForm1 = new Form1(); newForm1.Show(); Form2 newForm2 = new Form2(newForm1); newForm2.Show(); )

Cuando trabaje con varios formularios, debe tener en cuenta que uno de ellos es el principal, que se inicia primero en el archivo Program.cs. Si tenemos varios formularios abiertos al mismo tiempo, cuando cerramos el principal, se cierra toda la aplicación y con ella todos los demás formularios.

En ocasiones es necesario acceder a los elementos de un formulario desde otro durante la ejecución del programa. Por ejemplo, hay un formulario Form1, desde él abrimos otro Form2 y ahora, trabajando en Form2, necesitamos acceder a los elementos del formulario padre Form1. Encontré varias formas de hacer esto.

1er método. Pasar una referencia a una variable pública.

Espacio de nombres WindowsApplication1 (clase pública parcial Form1: Form (form1 público() (InitializeComponent(); ) botón vacío privado1_Click(remitente del objeto, EventArgs e) ( Form2 frm = new Form2(); frm.but1 = this.button1; // enviar enlace al botón en el formulario Form2 frm.ShowDialog() ) ) )

En Form2, la variable a la que se pasó el enlace ahora corresponderá al botón1 de Form1

Espacio de nombres WindowsApplication1 (clase pública parcial Form2: Form (botón público pero1; // esta variable contendrá un enlace al botón1 desde Form1 public Form2() (InitializeComponent(); ) private void button1_Click(remitente del objeto, EventArgs e) (pero1. Texto = "prueba"; // cambia el texto en el botón botón1 del Formulario1 ) ) )

2do método. Pasando el enlace al formulario secundario.

La esencia es aproximadamente la misma en el primer método. Al abrir Form2, le pasamos un enlace al elemento que planeamos cambiar más adelante.

Espacio de nombres WindowsApplication1 (clase pública parcial Form1: Form (form1 público() (InitializeComponent(); ) botón vacío privado1_Click(remitente del objeto, EventArgs e) ( Form2 frm = new Form2(this.button1); // pasa un enlace al botón al formulario Form2 frm.ShowDialog();

Ahora en Form2 necesitamos crear una variable que contendrá un enlace a este botón y a través de él accederemos al botón de Form1 (líneas 5,7,9 y 15).

Espacio de nombres WindowsApplication1 ( clase parcial pública Form2: Formulario ( botón privado pero1; // esta variable contendrá un enlace al botón botón1 del formulario Form1 public Form2(Botón pero) // obtener un enlace al botón en la variable pero ( pero1 = pero; // ahora pero1 será un enlace al botón botón1 InitializeComponent(); ) private void button1_Click(remitente del objeto, EventArgs e) (but1.Text = "prueba"; // cambia el texto en el botón botón1 de Form1) )

3er método. Acceso a todo el formulario para padres.

Para hacer esto, necesita realizar cambios en varios archivos, pero al mismo tiempo tendremos acceso a todos los elementos del formulario principal y no necesitaremos pasar un enlace a cada elemento, como en el método 1.

Paso 1. en archivo Programa.cs cree una variable pública f1 (línea 5).

Espacio de nombres WindowsApplication1 ( clase estática Programa ( public static Form1 f1; // variable que contendrá un enlace al formulario Form1 static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1( ) );

Paso 2. Apertura Formulario1.Designer.cs y en él, para elementos a los que será necesario acceder desde otro formulario, cambiamos privado en público. Por ejemplo, hagamos que el botón1 en Form1 esté disponible para cambios.

Sistema público.Windows.Forms.Botón botón1; // reemplazado privado por público

Paso 3. Al crear Form1, asignamos a la variable f1 un enlace a este formulario (línea 7)

Espacio de nombres WindowsApplication1 ( clase parcial pública Form1: Form ( public Form1() ( Program.f1 = this; // ahora f1 será un enlace al formulario Form1 InitializeComponent(); ) private void button1_Click(remitente del objeto, EventArgs e) ( Form2 frm = nuevo Formulario2(); frm.ShowDialog();

Paso 4. Ahora desde absolutamente cualquier formulario o desde cualquier clase puedes acceder al elemento botón1 ubicado en Formulario1 así: Programa.f1.botón1. Por ejemplo, deje que el botón de Form2 cambie el texto del botón en Form1:

Espacio de nombres WindowsApplication1 (clase parcial pública Form2: Formulario (formulario público2() (InitializeComponent();) botón vacío privado1_Click(remitente del objeto, EventArgs e) (Program.f1.button1.Text = "prueba"; // Cambia el texto en el botón de formulario Form1 ) ) )

A pesar de que mi opinión sobre Visual Studio de Microsoft sigue siendo la misma, a veces hay que hacer algo al respecto. Si aceptamos el hecho de que, de hecho, no escribimos en C++, sino en el llamado C++/CLI, trabajar con componentes visuales familiares no será tan diferente de los mismos entornos de Borland. Pero puede crear problemas, en comparación con Builder. Consideremos 3 situaciones típicas de trabajar con una aplicación que contiene más de un formulario. El entorno de ejemplo es Visual C++ 2010 Express gratuito, se supone que el formulario principal tiene el nombre predeterminado Form1.

Un ejemplo de construcción y llamada programática a un formulario.

Este código se puede ejecutar, por ejemplo, haciendo clic en un botón en el formulario principal Form1.

Formulario^form2 = gcnew Formulario(); Botón^ botón2 = gcnew Botón(); botón2->Texto = L"OK"; botón2->Ubicación = Punto(10,10); form2->Texto = L"Mi ventana"; formulario2->BotónAyuda = verdadero; form2->FormBorderStyle = System::Windows::Forms::FormBorderStyle::FixedDialog; form2->PosiciónInicio = PosiciónInicioForm::PantallaCentro; form2->Controles->Agregar(botón2); formulario2->MostrarDialog();

Para agregar un controlador de clic para un botón generado mediante programación button2, simplemente escriba antes de la última línea de código:

Botón2->Hacer clic += gcnew System::EventHandler(this, &Form1::button2_Click);

Antes de llamar al método form2->ShowDialog() o form2->Show();

En este caso, el código del controlador se encuentra en el módulo actual Form1.h:

Privado: Sistema::Botón vacío2_Click(Sistema::Objeto^ remitente, Sistema::EventArgs^ e) ( MessageBox::Show("Aquí"); )

Llamar a otro formulario desde el formulario principal

En el menú, seleccione Proyecto - Agregar un nuevo elemento - Formulario - nombre Form2

Agreguemos un operador

#incluir "Form2.h"

antes del primer espacio de nombres en Form1.h (es decir, al principio del archivo).

Incluyamos un puntero a la instancia de clase en la sección pública de la clase Form1:

Formulario2^F2;

Agreguemos el código donde necesitamos crear y llamar al segundo formulario:

F2=gcnewForm2(); F2->Mostrar();

Para eliminar mediante programación el segundo formulario, el siguiente código es adecuado:

Eliminar F2;

Cabe señalar que el puntero almacena la dirección de un solo formulario, el que se creó en último lugar. Si creamos secuencialmente varios formularios usando este código, solo se eliminará el último. Alternativamente, pruebe la matriz de formas que se describe a continuación.

Describamos los datos necesarios en la clase de formulario Form1 (aquí el nombre y el espacio de nombres del proyecto Tabulator, si es necesario, reemplácelo por el suyo):

Constante estática int MAX_FORMS = 100; //Número máximo de formularios int FormCount; //Formulario de matriz de contadores ^F2; //Puntero a una serie de formularios

Luego inicializamos los datos usando el evento Load del formulario principal:

FormCount=0; F2 = gcnueva matriz (MAX_FORMAS);

Luego implementamos el código para crear el siguiente formulario.

Si (Conteo de formularios Espectáculo(); ) else MessageBox::Show("¡Demasiados formularios!");

y su eliminación:

Si (FormCount) ( eliminar F2; FormCount--; )

Si queremos crear formularios secundarios no por separado, sino dentro del formulario principal, entonces en las propiedades de Form1 debemos indicar que es un "antepasado" (establezca la propiedad IsMdiParent = true), y antes de mostrar el formulario secundario usando el Operador F2->Show(), márquelo como hijo de Form1:

F2->MdiParent = esto;

Llamar a un método de formulario principal desde un formulario secundario

Difícilmente podemos prescindir del uso de archivos .cpp, lo cual no está nada mal: escribir código en archivos .h generalmente rompe el sistema C correcto :)

Describamos el proceso paso a paso.

1) Hay 2 formularios: Formulario1 y Formulario2, en Formulario1 hay un Botón (botón1, abrirá el segundo formulario) y una Etiqueta (etiqueta1, aquí cambiaremos el texto). En Form2 - botón1, al hacer clic, el texto en la etiqueta1 cambiará.

2) Como necesitamos tener acceso del primer formulario al segundo, y del segundo al primero, surgirá el problema de las referencias cruzadas (cuando Form1.h se refiere a Form2.h, que, a su vez, nuevamente se refiere a Form1.h). Para evitar esto, moveremos el código del primer formulario (Form1), que tendrá acceso al segundo formulario (Form2), del archivo .h al archivo .cpp. Por lo tanto, necesita crear un archivo Form1.cpp.

3) anunciar método público Establezca en Form1.h para que pueda cambiar el texto de label1 (el código se puede escribir al final del archivo, después de #pragma endregion):

Público: conjunto vacío (cadena ^ texto) (etiqueta1->Texto = texto;)

4) En el archivo Form2.h incluimos Form1.h (al principio):

#incluir "Formulario1.h"

y cree un constructor que acepte y guarde un enlace al primer formulario para su uso posterior:

Form2(Form1^ parent) ( InitializeComponent(); parentForm = parent; ) //puedes escribir un enlace inmediatamente debajo: privado: Form1^ parentForm;

5) Al hacer clic en el botón en Form2, llamaremos al método Set del formulario principal:

Privado: Sistema::Void botón1_Click(Sistema::Objeto^ remitente, Sistema::EventArgs^ e) ( parentForm->Set("hola desde formulario2"); parentForm->Mostrar(); esto->Ocultar(); )

6) Queda por abrir el segundo formulario en el primer formulario. Para hacer esto, transferimos el controlador de clic del botón de Form1.h a Form1.cpp, y en el archivo .h dejamos solo su declaración.

Por administrador.

Aprender C# es lento. pero continúa fielmente. Hace poco yo
dio un ejemplo de cómo abrir otro desde un formulario en Visual C#. En principio, todo es sencillo.

Hoy apareció la siguiente tarea: iniciar un formulario modal desde el formulario principal de la aplicación; cuando se cierra, este formulario debe pasar algunos datos (texto, valores de propiedad, etc.) a los controles del formulario principal. No es posible solucionar este problema utilizando el método descrito en el post anterior sobre formularios, porque en este caso simplemente creamos un nuevo objeto de formulario con nuevos valores para todas las propiedades. Afortunadamente, C# tiene un recolector de basura maravilloso... Pero el punto no es el recolector, sino ¿cómo abrir un formulario secundario en C# y luego volver al formulario principal desde él?

Para empezar, configuremos los datos iniciales (iniciales).

Entonces. Tenemos el formulario de solicitud principal:

En este formulario también hay un TextBox llamado TBDialog y un botón Button sobre el cual debemos hacer clic:

1. Pase el valor de la propiedad Texto de TBDialog a TBMain;
2. Cerrar fDialog;

Ahora veamos todo el proceso en orden.

Primero, siempre vale la pena recordar que, de forma predeterminada, a todas las propiedades, variables y métodos en C# se les asigna un modificador. privado– por lo tanto, para pasar del segundo formulario al control del primero, necesitamos establecer un modificador para TBMain público por cuenta propia. Para hacer esto, seleccione el elemento TBMain en el diseñador de formularios, vaya a la ventana de propiedades y cambiar el valor de la propiedad Modificadores Con privado en público

Ahora TBMain será visible en otros objetos. Sigamos adelante. Para abrir el formulario en modo modal, necesitamos usar una de dos opciones para el método ShowDialog():

público DialogResult ShowDialog (propietario de IWin32Window);

En el primer caso, el método muestra el formulario como un cuadro de diálogo modal con la ventana activa actual configurada como propietaria, y en el segundo, podemos especificar de forma independiente qué formulario se convertirá en el propietario de nuestra ventana modal.

Por ejemplo, usemos la segunda versión del método ShowDialog() y mostremos el segundo formulario de forma modal. Para ello escribiremos lo siguiente: Aquí usé la palabra clave nuevamente. este , que apunta al objeto actual, es decir. establecer el formulario principal como propietario ( fPrincipal ). Ahora pasemos directamente a resolver nuestro problema y respondamos la pregunta:¿Cómo pasar valor de una forma a otra? Cada control tiene una propiedad destacable. Dueño

– que apunta al padre:

Ahora puede ejecutar el proyecto y asegurarse de que el texto del cuadro de texto del formulario secundario se transfiera perfectamente al cuadro de texto del primero. Por las dudas, publico el código fuente del proyecto comentado en el ejemplo.
Es más probable que la pregunta abordada en este artículo se relacione con el tema de la construcción de una arquitectura de aplicación y no específicamente con el problema en consideración. Transferir datos de un formulario a otro no es nada difícil. Para ello basta con hacer abierto el control cuyos datos queremos obtener, es decir marcarlo con el modificador público. Además, es posible otra opción. Por ejemplo, en la primera forma creamos un objeto de la segunda forma pasando una referencia a nosotros mismos al constructor, es decir, pasando una referencia al primero de la primera forma a la segunda.
SegundoForm segundoForm = nuevo SegundoForm(este);

Naturalmente, antes de hacer esto, debes encargarte de crear una sobrecarga para el constructor del segundo formulario.

Y este método es bastante común. Sin embargo, su simplicidad conlleva muchos problemas potenciales, el principal de los cuales es una violación del principio de encapsulación. En una palabra, la segunda forma no debería saber nada sobre la existencia de la primera y, más aún, no debería poder influir en ella. La solución a este problema es bastante sencilla. Miremos directamente el código. En el diseñador, creamos el formulario principal (se iniciará cuando se inicie la aplicación). pongamos uno, Cuadro de texto Etiqueta Y.

Al hacer clic en el botón, se abrirá el segundo formulario y el texto del campo de texto del formulario principal se transferirá al campo de texto del segundo formulario. Inicialmente, el segundo formulario se ve así:

Similar al primero, tiene los mismos controles. No necesitamos más. El punto de entrada de la aplicación inicia el formulario principal:

Usando el Sistema; usando System.Collections.Generic; usando System.Linq; usando System.Windows.Forms; espacio de nombres From1FormTo2 ( clase estática Programa ( // El punto de entrada principal para la aplicación. static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); ) ) )

El código del formulario principal se ve así:

Usando el Sistema; usando System.Collections.Generic; usando System.ComponentModel; usando System.Data; usando System.Drawing; usando System.Linq; usando System.Text; usando System.Windows.Forms; espacio de nombres From1FormTo2 ( clase parcial pública MainForm: Form ( //segundo formulario SecondForm secondForm; //constructor public MainForm() ( InitializeComponent(); ) //controlador de eventos de transferencia de datos //desde el formulario principal al segundo vacío privado btn_mainForm_Click(objeto remitente, EventArgs e) ( secondForm = new SecondForm(tb_mainForm.Text.Trim()); secondForm.ShowDialog(); if ( secondForm.DialogResult == DialogResult.OK) tb_mainForm.Text = secondForm.ReturnData(); ) ) )

En consecuencia, no olvides conectar el botón al evento. Hacer clic. Aquí en la clase de formulario principal hay un campo segundo formulario segundo formulario, que representa el objeto del segundo formulario. Cuando hace clic en el botón "Enviar", se crea un segundo formulario (se llama al constructor sobrecargado, lo crearemos más adelante) y se inicia usando el método Mostrar cuadro de diálogo(). En este caso, este método nos conviene. Además, después de esto nos aseguramos de verificar si el segundo formulario se cerró, pero se hizo clic en su botón. Si se hizo clic en un botón en el segundo formulario, entonces el primer formulario debería aceptar datos del segundo. Esto sucede llamando al método Datos de retorno() en la segunda forma.

Ahora la parte más interesante es el código de la segunda forma:

Usando el Sistema; usando System.Collections.Generic; usando System.ComponentModel; usando System.Data; usando System.Drawing; usando System.Linq; usando System.Text; usando System.Windows.Forms; espacio de nombres From1FormTo2 (clase pública parcial SecondForm: Form ( //constructor sobrecargado public SecondForm(string data) (InitializeComponent(); tb_ secondForm.Text = data; ) //controlador de eventos de transferencia de datos //del segundo formulario al principal private void btn_ secondForm_Click (remitente del objeto, EventArgs e) ( this.DialogResult = DialogResult.OK; ) //método público para acceder //al campo de texto de este formulario public string ReturnData() ( return (tb_ secondForm.Text.Trim()); ) ) )

Como puede ver, hay una sobrecarga de constructor única que acepta un tipo de cadena. Recuerde que estamos intentando transferir texto desde un TextBox. En el constructor, los componentes están programados para inicializarse y el texto del campo de texto se establece en el valor transmitido desde el primer formulario. A continuación, suscribiéndote al evento. Hacer clic Para el botón del segundo formulario, creamos un controlador. btn_segundoForm_Click, que simula el funcionamiento del botón “Ok” de cualquier cuadro de diálogo. Así, al hacer clic en el botón “Enviar” (del segundo formulario), ejecutamos la condición

(segundo formulario .DialogResult == DialogResult .OK)

La primera forma, por lo tanto, llama al método. segundoForm.ReturnData(), configuramos el campo de texto del primer formulario al valor del campo de texto del segundo formulario.

Creo que el funcionamiento de este método ya no requiere explicación. Simplemente devuelve el texto de un único campo de texto, manteniéndolo privado.

Como resultado, transferimos datos al segundo formulario desde el primero y del segundo al primero sin violar los principios de encapsulación.

Intente ingresar el texto "aaa" en el campo de texto del primer formulario y haga clic en el botón. Verá este texto en el campo de texto del segundo formulario que se abre. Intente cambiar el texto a "aaa ppp" y haga clic en el botón. Verás como, tras cerrar el segundo formulario, aparecerá este texto en el campo de texto del formulario principal.

Ahora creo que podrás transferir datos entre formularios de forma más correcta. En el próximo artículo hablaremos de cómo hacerlo en aplicaciones ASP.NET.