En el desarrollo de aplicaciones C#, las operaciones de transferencia de valor entre formularios son operaciones inevitables y frecuentes.
Por ejemplo, ¿cuáles son los métodos comunes para llamar a otro formulario en un formulario, pasar un valor y obtener el valor de retorno?
Generalmente, esto se logra a través de variables públicas del proyecto, variables públicas del formulario (campos más propiedades de acceso), constructores de formularios, delegados y eventos, etc. A continuación se dan ejemplos.
1. A través de variables públicas
En el desarrollo inicial se pueden hacer muchas cosas a través de variables públicas, parece haber sido probado y cierto, y también es un pensamiento habitual, siempre que se puedan evitar efectivamente los conflictos de acceso.
Definir clases de acceso público:
internal class GlobalVar
{
private static string _StrPsp = "";// 私有静态字段
public static string StrPsp // 公有静态属性
{
get { return _StrPsp; }
set { _StrPsp = value; }
}
}Cambie su valor en form2:
GlobalVar.StrPsp = "这是改变后的值";
DialogResult = DialogResult.OK;
Close();Llame al formulario form2 y obtenga el valor de retorno:
//可以处理GlobalVar.StrPsp
//......
Form2 form = new Form2();
DialogResult FrmSelect = form.ShowDialog();
if (FrmSelect == DialogResult.OK)
{
// 获取返回值
MessageBox.Show( GlobalVar.StrPsp);
// 处理返回值
}
else
{
//不取值
MessageBox.Show("没有改变值");
}No es necesario utilizar el método ShowDialog, esto es sólo para centrar el acceso y evitar conflictos de acceso.
2. Usando el método ShowDialog
Use el método ShowDialog para abrir un formulario y configurarlo como un cuadro de diálogo modal. Después de esperar a que se cierre el formulario, puede obtener el valor de retorno accediendo a sus propiedades o métodos públicos.
La diferencia entre este y el anterior es que el anterior accede a las variables públicas de todo el proyecto, mientras que este método accede a las variables públicas del formulario. Aquí, el formulario se abre y se le asigna un valor, y el valor de retorno se obtiene una vez completado el acceso, todo esto se logra accediendo a las variables públicas del formulario.
Por ejemplo:
Defina variables de acceso en el formulario form3:
public string StrReturn { get; private set; }Cambie el valor de retorno cuando necesite devolver un resultado:
StrReturn = "这是改变后的返回值";
DialogResult = DialogResult.OK;
Close();transferir:
Form3 form = new Form3();
MessageBox.Show(form.ReturnValue,"改变前的值");
DialogResult result = form.ShowDialog();
if (result == DialogResult.OK)
{
// 获取返回值
MessageBox.Show(form.StrReturn);
}Si hay muchas variables complejas a las que es necesario acceder, esto se puede lograr definiendo una clase, por ejemplo:
public static class NetInfo
{
private static string _IpAddress;
public static string IpAddress
{
get { return _IpAddress; }
set { _IpAddress = value; }
}
}Devolución del formulario 3:
NetInfo.IpAddress = "1.2.3.4";
DialogResult = DialogResult.OK;
Close();Extraiga el valor de retorno:
Form3 form = new Form3();
MessageBox.Show(Form3.NetInfo.IpAddress,"改变前的值");
DialogResult result = form.ShowDialog();
if (result == DialogResult.OK)
{
// 获取返回值
string value = Form3.NetInfo.IpAddress;
MessageBox.Show(value);
}Los dos métodos anteriores realizan la transferencia de valor y obtienen el valor de retorno a través de las variables públicas del proyecto y las variables públicas del formulario, que son simples, prácticas, rápidas y convenientes.
En muchas herramientas de desarrollo de aplicaciones, hay un objeto público pasado de forma predeterminada, que equivale a un pasador intermedio y desempeña el papel de una estación de transferencia de datos.
3. Pasar eventos
Los parámetros se pasan a través del constructor del formulario y los valores de retorno se obtienen mediante devoluciones de llamada de eventos.
Definir clases de acceso público:
public class Student
{
public int Id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
}Defínalo en el formulario form4 al que se debe acceder:
public event EventHandler<Student> ReturnValueEvent;//回调事件
private Student MyStudent;Constructor de forma4:
public Form4(Student student)
{
InitializeComponent();
MyStudent = student;
}
valor de retorno:
MyStudent.Id = 2;
MyStudent.Name = "Java";
MyStudent.Age = 3;
//MessageBox.Show(MyStudent.Name);
// 触发事件，传递返回值
ReturnValueEvent?.Invoke(this, MyStudent);
Close();Llame al formulario form4, pase el valor y obtenga el valor de retorno:
Student student = new Student();
student.Name = "C#";
student.Id = 1;
student.Age = 2;
Form4 targetForm = new Form4(student);
targetForm.ReturnValueEvent += targetForm_ReturnValueEvent;//订阅事件
targetForm.ShowDialog();Manejo de eventos:
private void targetForm_ReturnValueEvent(object sender, Student student)
{
// 处理返回值
MessageBox.Show(student.Name);
}4. Por delegación
La persona que llama está preparada para definir una clase de acceso:
public class Student
{
public int Id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
}Método de procesamiento de declaraciones:
private void Form_ReturnValueCallback(Student MyStudent)
{
// 处理返回值
MessageBox.Show(MyStudent.Name);
}Formulario de llamada4:
Form4 frm4= new Form4();
frm4.ReturnValueCallback = Form_ReturnValueCallback;
frm4.Show();Defina un delegado en el formulario llamado:
public Action<Student> ReturnValueCallback { get; set; }valor de retorno:
Student student1 = new Student();
student1.Id = 2;
student1.Name = "C#";
student1.Age = 3;
// 调用委托，传递返回值
ReturnValueCallback?.Invoke(student1);
Close(); Lo anterior resume las cuatro operaciones comunes para transferir valores entre formularios, que se pueden seleccionar de acuerdo con la situación real durante el desarrollo del proyecto.