c#子窗体操作父窗体传值_c#父窗体传值给子窗体,子窗体返回父窗体时值没了 - CSDN
  • 简介 在很多场景下,我们的程序需要完成窗体间的传值功能,有时候是窗体→窗体单向传值、窗体→父窗体传值甚至是,也有时候我们需要窗体⇆窗体双向传值。  在本文中主要介绍一些能够实现双向传值的方法...

    简介

      在很多场景下,我们的程序需要完成窗体间的传值功能,有时候是父窗体→子窗体单向传值、子窗体→父窗体传值甚至是,也有时候我们需要父窗体⇆子窗体双向传值。
      在本文中主要介绍一些能够实现双向传值的方法,能够双向传值的方法也能够实现单向传值。
      本文的所有源码都可以在GitHub上下载
      
      本文介绍的方法仅限于我自己知道并且实现过的,我相信还有很多我并不知道的方法,因此也许在很多朋友眼中本文的内容是浅显甚至可笑的,希望路过的各方朋友不吝赐教,我也希望不断地进步!

    方法1:Public字段+ShowDialog

    原理

      这个方法的原理就是:
      1.父窗体在实例化子窗体对象(假定名为childWindow)的时候,通过对子窗体Public字段进行赋值的方法,完成父窗体→子窗体的传值;
      2.父窗体实例化子窗体后,调用子窗体的childWindow.ShowDialog()方法;
      3.随后在父窗体中对childWindow.DialogResult的值进行判断,当会话结束的时候,将childWindow的字段值传给父窗体,实现子窗体→父窗体的传值。

    代码

      示例代码:
      父窗体为MainWindow,子窗体为ChildWindow,我们将两个窗体间Title字段值进行互传。逻辑代码我们都放在了窗体的按钮点击事件中,用按钮来触发。
      
      父窗体代码:

    /// <summary>
    /// 给子窗体传值
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void btn_ShowChild_Click(object sender, RoutedEventArgs e)
    {
        ChildWindow child = new ChildWindow() {  Title="我的名字是父窗体给的!" };//第1步,给子窗体传值了
        child.ShowDialog();//第2步,调用ShowDialog
    
        if (child.DialogResult==true)//第3步,然后对DialogResult进行判断
        {
            this.Title = child.Title;//子窗体给父窗体传值
        }
    }

      子窗体代码  

    /// <summary>
    /// 给父窗体传值
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void btn_ShowFather_Click(object sender, RoutedEventArgs e)
    {
        this.Title = "我要给父窗体传值";
        this.DialogResult = true;//第3步,首先会话结束
    }

    效果截图

      截图为证:
      父窗体→子窗体
      点击“给子窗体传值”
      这里写图片描述
      子窗体→父窗体
      点击“给父窗体传值”
      这里写图片描述

    总结

      优点:这种方法简单方便,可以实现子窗体和父窗体间互相传值;
      缺点:不够灵活,子窗体和父窗体都需要承载中间值的对象,而且需要借助ShowDialog()和DialogResult。

    方法2:公共类的静态字段

    原理

      这个方法的原理就是:父窗体和子窗体分别对同一公共类的静态字段(可以是同一个字段也可以是不同的字段)进行赋值,然后父窗体和子窗体各自获取这些字段的值,就能够实现窗体间的传值。
      该方法同样需要借助到ShowDialog()和DialogResult。

    代码

      公共类代码  

    /// <summary>
    /// 公共类
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    public class InfoClass
    {
        public static string Title { get; set; }
        public static string Message { get; set; }
    }

      父窗体代码 

    /// <summary>
    /// 实例化子窗体,为公用类静态字段赋值
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void btn_ShowChild_Click(object sender, RoutedEventArgs e)
    {
        InfoClass.Title = "我的名字来自公共类!";
        ChildWindow child = new ChildWindow();
        child.ShowDialog();
    
        if (child.DialogResult==true)
        {
            this.Title=InfoClass.Title;
            MessageBox.Show(InfoClass.Message);
        }
    }

      子窗体代码 

    /// <summary>
    /// 加载事件
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        this.Title = InfoClass.Title;
    }
    
    /// <summary>
    /// 修改公共类的静态字段,变相为父窗体赋值
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void btn_ShowFather_Click(object sender, RoutedEventArgs e)
    {
        InfoClass.Title = "我的名字也是来自公共类!";
        InfoClass.Message = "这是子窗体留下的信息!";
        this.DialogResult = true;
    }

    效果截图

      截图为证:
      父窗体→子窗体
      点击“给子窗体传值”
      这里写图片描述
      子窗体→父窗体
      点击“给父窗体传值”
      这里写图片描述
      

    总结

    方法3:构造函数+委托(我认为最好的方法)

    原理

      这个方法的原理就是:
      1.父窗体利用子窗体的构造函数向子窗体传值;
      2.自定义子窗体的构造函数,函数签名包含一个委托函数;
      3.在子窗体中调用来自父窗体传递的委托函数,对对父窗体进行传值。

    代码

      委托代码
      这个方法需要用到委托函数,我们将委托函数单独定义在公共类文件里面。
      代码如下:

    public delegate void ShowMessage(string value);

      父窗体代码
      

    /// <summary>
    /// 通过自定义构造函数,给子窗体传值
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void btn_ShowChild_Click(object sender, RoutedEventArgs e)
    {
        ChildWindow child = new ChildWindow(ShowErrorMessage,"这是来自父窗体的信息");
        child.Show();
    }
    
    /// <summary>
    /// 符合委托函数ShowMessage返回类型和签名的函数实例
    /// </summary>
    /// <param name="value"></param>
    private void ShowErrorMessage(string value)
    {
        MessageBox.Show(value,"父窗体提示框");
    }

      子窗体代码

    ShowMessage sm;
    string value="";
    public ChildWindow(ShowMessage _sm,string _value)
    {
        InitializeComponent();
        sm = _sm;
        value = _value;
    }
    
    /// <summary>
    /// 加载事件,显示父窗体传递来的值
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        MessageBox.Show(value, "子窗体提示框");
    }
    
    
    /// <summary>
    /// 调用父窗体传来的委托函数,给父窗体传值
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void btn_ShowFather_Click(object sender, RoutedEventArgs e)
    {
        sm.Invoke("这是来自子窗体的信息!");
    }

    效果截图

      截图为证:
      
      父窗体→子窗体
      点击“给子窗体传值”
      这里写图片描述
      子窗体→父窗体
      点击“给父窗体传值”
      这里写图片描述
      

    总结

      优点:能够在不关闭子窗体的情况下实现两个窗体间的传值(而且不仅限于传值),灵活方便,功能强大;
      缺点:需要对委托有一定的了解,使用起来需要对这个方法有一定的理解;

    展开全文
  • 利用委托进行窗体传值。  窗体:Form1  窗体:Form2  点击Form1,弹出Form2,点击按钮返回值给Form1 首先在Form2中定义委托和事件: //声明委托 和 事件 public delegate void ...

    利用委托进行窗体传值。

        父窗体:Form1

      子窗体:Form2

      点击Form1,弹出Form2,点击按钮返回值给Form1


    首先在Form2中定义委托和事件:


     //声明委托 和 事件
        public delegate void TransfDelegate(String value);
        public partial class Form2 : Form
        {
            public Form2()
            {
                InitializeComponent();
            }
    
            public event TransfDelegate TransfEvent; 
            private void button1_Click(object sender, EventArgs e)
            {
                //触发事件
                TransfEvent(textBox1.Text);
                this.Close();
            }
        }
    
    然后在Form1中进行调用:
    
    
    
    public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
                
            }
    
            private void button1_Click(object sender, EventArgs e)
            {
                Form2 frm = new Form2();
                //注册事件
                frm.TransfEvent += frm_TransfEvent;
                frm.ShowDialog();
            }
    
            //事件处理方法
            void frm_TransfEvent(string value)
            {
                textBox1.Text = value;
            }
        }







    展开全文
  • 【1】窗体与父窗体传值,见:http://www.cnblogs.com/xugang/archive/2010/06/29/1767465.html 【2】窗体与子窗体传值: 前提:Form1座位窗体,然后它new出来了两个个子窗体分别为Form2与Form3; 要求:可以...

    【1】子窗体与父窗体传值

    见:http://www.cnblogs.com/xugang/archive/2010/06/29/1767465.html

    【2】子窗体与子窗体传值:

    前提:Form1座位父窗体,然后它new出来了两个个子窗体分别为Form2与Form3;

    要求:可以及时把Form2中产生的数据,传递给Form3,更新Form3;如果Form3没有被打开,则不传递。

    窗体设计:


    Form1代码:

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    
    namespace Test
    {
        public partial class Form1 : Form
        {
            Form3 f3;
            Form2 f2 = new Form2();
            int i = 0;
            public Form1()
            {
                InitializeComponent();
            }
    
            private void button1_Click(object sender, EventArgs e)
            {
                f2.TitleChanged += f2_TitleChanged;
                f2.Show();
            }
    
            void f2_TitleChanged(object sender, Form2.TitleChangedEventArgs e)
            {
                if (f3 != null)
                {
                    f3.setText(e.Title);
                }
            }
    
            private void button2_Click(object sender, EventArgs e)
            {
                f3 = new Form3();
                f3.Disposed += f3_Disposed;
                f3.Show();
            }
    
            void f3_Disposed(object sender, EventArgs e)
            {
                f3 = null;
            }
        }
    }

    Form2代码:

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    
    namespace Test
    {
        public partial class Form2 : Form
        {
            public class TitleChangedEventArgs : EventArgs // 事件参数类
            {
                private string title = "";
                public string Title
                {
                    get { return title; }
                    set { title = value; }
                }
            }
            // 声明委托
            public delegate void TitleChangedEventHandler(object sender, TitleChangedEventArgs e);
            // 定义事件
            public event TitleChangedEventHandler TitleChanged;
           
            public Form2()
            {
                InitializeComponent();
            }
    
            private void Form2_Load(object sender, EventArgs e)
            {
    
            }
    
            private void button2_Click(object sender, EventArgs e)
            {
                TitleChangedEventArgs e1 = new TitleChangedEventArgs();
                e1.Title = textBox1.Text;
                OnTitleChanged(e1);// 触发事件
            }
            // 触发事件的方法
            protected virtual void OnTitleChanged(TitleChangedEventArgs e)
            {
                if (TitleChanged != null)
                    TitleChanged(this, e);
            }
        }
    }
    


    Form3代码:

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    
    namespace Test
    {
        public partial class Form3 : Form
        {
            public Form3()
            {
                InitializeComponent();
            }
    
            private void Form3_Load(object sender, EventArgs e)
            {
    
            }
            public  void  setText(string s)
            {
                label1.Text = s;
            }
        }
    }
    
    
    


    总结:
    Form2与Form3不能直接传值。 必须先将值传到Form1中,然后Form1把值传递给Form3

    By:Jim


    展开全文
  • C# 子窗体传值窗体
  • C# 窗体与窗体之间几种传值的方式 ... C# 委托和事件,简单示例说明问题 https://www.cnblogs.com/hjsstudio/p/9816126.html C#简单实现窗体向父窗体传值的方法 委托方法=>窗体 public event A...

    C# 子窗体与父窗体之间几种传值的方式

    https://blog.csdn.net/yuekunge/article/details/9171301

    C# 委托和事件,简单示例说明问题

    https://www.cnblogs.com/hjsstudio/p/9816126.html

    C#简单实现子窗体向父窗体传值的方法

     

    委托方法=>子窗体
       public event Action<List<DataGridViewRow>> myEvent;
       myEvent(List);  子窗体调用
    
    父窗体
    创建对象
               frm.myEvent += Set物料;
      private void Set物料(List<DataGridViewRow> list)()
    {
    }

    方式一: 使用公共静态变量传值

    主窗体frmMain中代码

    ?

    1

    2

    3

    4

    5

    6

    7

    public partial class frmMain : Form

    {

     //声明工位ID 为公共静态变量

     public static string terminalID = "";

     //给静态变量赋值

     terminalID = "q13bh01-bh12";

     }

    子窗体frmGroup中代码

    ?

    1

    2

    3

    4

    5

    6

    private void frmGroup_Load(object sender, EventArgs e)

    {

      this.txtTerminalID.Text= frmMain.terminalID.Trim();

      //可以再赋值给静态成员,方便其他窗体调用

      frmMain.terminalID = "q13bh01-bh11";

    }

    特点 : 双向传值,实现简单
    缺点: 静态变量在类加载的时候分配内存,存储于方法区,一般不会被销毁,在系统不够内存情况下会自动回收静态内存,这样就会引起访问全局静态错误。

    方式二: 使用公共变量传值

    主窗体frmMain中代码

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    public partial class frmMain : Form

    {

     //声明工位ID 为公共变量

     public string terminalID = "";

     //给变量赋值

     terminalID = "q13bh01-bh12";

     //单击‘行为'按钮的时候会给窗体传值

     private void btnGroup_Click(object sender, EventArgs e)

        {

          frmGroup frmGro = new frmGroup();

          //变量传值 ,注意顺序写在ShowDialog()方法之前

          frmGro .stationID = this.terminalID;

          frmGro .ShowDialog();

        }

     }

    子窗体frmGroup中代码

    ?

    1

    2

    3

    4

    5

    public partial class frmGroup : Form

    {

     //定义公共属性

     public string stationID = "";

    }

    特点 : 单向传值,只能主窗体给子窗体传值,实现简单

    方式三: 使用委托传值

    先来看子窗体frmGroup中代码

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    namespace Siemens.Simatic.GUIClient.MESClient

    {

      //1、声明一个委托

      public delegate void setTextValue(string textValue,bool flag);

      public partial class frmGroup : Form

      {

        //2、声明一个委托类型的事件

         public event setTextValue setFormTextValue;

         public string groupName = "";

         public bool flagBtnGroup = false;

         public frmGroup()

         {

          InitializeComponent();

         }

         //轮询‘行为'按钮(相当于按钮单击事件)

         private void tmrBtn_Tick(object sender, EventArgs e)

         {

          if (sender is ButtonX) {

            ButtonX butX = (ButtonX)sender;//判断触发事件的是不是Button

            groupName = butX.Text.Trim();

            flagBtnGroup = true;

            //3、准备要回传的数据。

            setFormTextValue(this.groupName.Replace(" ", ""), this.flagBtnGroup );

            this.Close();

            return;

          }

        }

    主窗体frmMain中代码

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    private void btnGroup_Click(object sender, EventArgs e)

       {

         frmGroup frmGro = new frmGroup();

          //4、初始化事件

         frmGro .setFormTextValue += new setTextValue(frmGro _setFormTextValue);

         //变量传值 ,注意顺序写在ShowDialog()方法之前

         frmGro .stationID = this.terminalID;

         frmGro .ShowDialog();

       }

       //5、事件具体实现

        public void frmGro _setFormTextValue(string textValue,bool flag)

       {

         this.newGroupName = textValue;

         this.flagBtnGroup = flag;

         if (!string.IsNullOrEmpty(newGroupName))

         {

            ……

         }

        }

    特点 :适合子窗体数据实时回传父窗体。

    方式四:使用构造函数传递一个数值

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    class FormB

    {

     int orgId;

     public FormB(int orgId)

     {

       this.orgId=orgId;

     }

    }

     

    class FormA

    {

    public void ShowB()

    {

      FormB fb=new FormB(5); // 5是要传递过去的值

      fb.Show();

    }

    }

    方式五:把A窗体整个传递给B窗体

    有些时候需要在B窗体里对A窗体的某个控件值做修改,并且需要立即改变A窗体的控件显示,本方法适合这种情况。

    修改FormA,把要在B里处理的控件的可访问性(Modifiers)设为public,然后按下面的方式处理

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    class FormA

    {

    public void ShowB()

    {

      FormB fb=new FormB(this); // 在构造函数里把A窗体本身传过去

      fb.Show();

    }

    }

     

    class FormB

    {

    FormA fm; //B窗体增加一个FormA类型的成员

    public FormB(FormA fm) //添加一个带参数的构造方法,参数类型是FormA

    {

      this.fm=fm;

    }

    protected void Method1()

    {

      fm.txtName.Text="Haha!"; //在这儿可以直接操作A窗体里的控件了!

    }

    }

    叨叨两句

    项目中父窗体向子窗体传值传的是固定值,用的是第一种方式,子窗体向父窗体传值传的是变化的值,用的是第三种方式,第三种方式为我解决了一个大麻烦。

    总结

    感谢您的阅读,窗体传值有好多种方法,构造参数参数传值、公共属性传值等,各种场景下找到适合需求的最好,希望为小编提出宝贵意见!

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

     

    本文实例讲述了WinForm窗体间传值的方法。分享给大家供大家参考。具体实现方法如下:

    窗体间传递数据,无论是父窗体操作子窗体,还是子窗体操作符窗体,有以下几种方式:
     
    1.公共静态变量;
    2.使用共有属性;
    3.使用委托与事件;
    4.通过构造函数把主窗体传递到从窗体中;

    一、通过静态变量

    特点:传值是双向的,实现简单
     
    实现代码如下:
    在一个app类中定义一个静态成员value

    复制代码代码如下:

    public class app
    {
    public static string value;
    }


    在窗体Form1中这样调用

    复制代码代码如下:

    app.value = "f2"; //给静态成员赋值
    new Form2 ( ).Show ( ); //显示Form2


    在窗体Form2中

    复制代码代码如下:

    this.Text = app.value; //取回app.value的值
    app.value = "Form2"; //给app.value赋值,以便其他窗体调用


     
    二、公共变量传值

     

    这种方法就是利用一个公共变量,先把需要的值存放到这个公共变量,然后需要的时候再通过读取该变量的值来使用
    例子
    Form1:

    复制代码代码如下:

    public static string Form1Value; // 注意,必须申明为static变量
    private void button1_Click(object sender, EventArgs e)
    {
    Form1Value = "来自Form1";
    new Form2().Show();
    }


    Form2:

    复制代码代码如下:

    private void Form_Load(object sender, EventArgs e)
    {
    MessageBox.Show(Form1.Form1Value);
    }


    这种方式传值,理解和使用上都相对的简单,但是容易让变量串值,比如第一次修改为“a”,而第二次修改为“b”,则有可能本来需要“a”值的结果变成了“b”。
     
    三、静态方法方式访问

     

    这种方法与传值方法的第一种有些类似,就是将需要被其他窗体访问的方法用static定义,以便其他传递可以直接访问到
    例子:
    Form1:

    复制代码代码如下:

    private void button1_Click(object sender, EventArgs e)
    {
    new Form2().Show();
    }
    public static void FF()
    {
    MessageBox.Show("Form1方法");
    }


    Form2:

    复制代码代码如下:

    private void Form_Load(object sender, EventArgs e)
    {
    Form1.FF();
    }


    使用这种方法访问其他窗体的方法,在跨窗体上实现方便,但是需要需要访问到控件值则不能直接访问,需要将值先传递给其他窗体,再有窗体传递回来,或者存储在其他变量后对这变量进行访问。
     
    四、通过窗体的公有属性值

     

    特点:实现简单
     
    实现代码如下:
    在窗体Form2中定义一个公有属性Form2Value,获取和设置textBox1的文本值

    复制代码代码如下:

    public string Form2Value
    {
    get
    {
    return this.textBox1.Text;
    }
    set
    {
    this.textBox1.Text = value;
    }
    }


    在窗体Form1中这样调用

    复制代码代码如下:

    Form2 f2 = new Form2 ( );
    f2.Form2Value = "Ok"; //给Form2的textBox1赋值Ok
    f2.ShowDialog ( );


     
    五、通过窗体的公有属性值和Owner属性

     

    特点:实现简单,灵活
     
    实现代码如下:
    在窗体Form1中

    复制代码代码如下:

    public int Form1Value = 1;
    Form2 f2 = new Form2 ( );
    f2.ShowDialog ( this ); //把Form1作为Form2的所有者传递给Form2


    在窗体Form2中

    复制代码代码如下:

    //Form2的所有者是Form1
    Form1 f1 = ( Form1 ) this.Owner;
    //取到Form1的值是1
    MessageBox.Show ( f1.Form1Value .ToString ( ) );
    //给Form1的Form1Value赋值222
    f1.Form1Value = 222;


     
    六、通过窗体的公有属性值和Application.OpenForms属性

     

    说明:Application.OpenForms属性:获取属于应用程序的打开窗体的集合。(此属性在 .NET Framework2.0版中)
     
    实现代码如下:
    在窗体Form1中

    复制代码代码如下:

    public int Form1Value = 1;
    Form2 f2 = new Form2 ( );
    f2.Show ( );


    在窗体Form2中

    复制代码代码如下:

    string formName = "Form1";
    Form fr = Application.OpenForms [ formName ];
    if ( fr != null )
    {
    Form1 f1 = ( Form1 ) fr;
    //取到Form1的值是1
    MessageBox.Show ( f1.Form1Value.ToString ( ) );
    //给Form1的Form1Value赋值222
    f1.Form1Value = 222;
    }


     
    七、传参式传值

     

    此方法顾名思义就是将需要的值一参数形式传递给需要值的窗体
    例子:
    Form1:

    复制代码代码如下:

    private void button1_Click(object sender, EventArgs e)
    {
    new Form2("来自Form1").Show();
    }


    Form2:

    复制代码代码如下:

    public Form2(string value)
    {
    InitializeComponent();
    MessageBox.Show(vaue);
    }


    此种窗体间传值方法明显优与第一种的传值参数,也不会出现串数据现象,但是需要注意修改Form2的构造函数,每个窗体的默认构造函数默认都是无参数的,因此需要去修改构造函数。
     
    八、通过构造函数

     

    特点:传值是单向的(不可以互相传值),实现简单
     
    实现代码如下:
    在窗体Form2中

    复制代码代码如下:

    int value1;
    string value2;
    public Form2 ( int value1 , string value2 )
    {
    InitializeComponent ( );
    this.value1 = value1;
    this.value2 = value2;
    }


    在窗体Form1中这样调用

    复制代码代码如下:

    new Form2 ( 111 , "222" ).Show ( ); //这样就把111,"222",这2个值传送给了Form2


     
    九、用委托来实现。

     

    委托可以把一个方法作为参数带入另一个方法,在窗体传值中,子窗体需要执行一个方法来改变父窗体的值,
    而这个方法,则可以用委托从父窗体传递过来。在父窗体中,声明修改文本框的方法AfterChildChange,在new一个子窗体的时候,将这个方法传递给子窗体。那么当子窗体点击同步按钮时,会执行父窗体的AfterChildChange方法,已达到修改文本框值的目的。
     
    例子
    1、在子窗体中设置一个委托类型的属性:

    复制代码代码如下:

    public Action<string> AfterChangeTextDel { get; set; }


    2、在子窗体同步按钮中:

    复制代码代码如下:

    if (AfterChangeTextDel != null)
    {
    AfterChangeTextDel(this.textBox1.Text);//执行委托
    }


    3、在父窗体中添加方法:

    复制代码代码如下:

    public void AfterChildChange(string text)
    {
    txtName.Text = text;
    }


    4、在父窗体启动子窗体按钮:

    复制代码代码如下:

    ChildFrm frm =new ChildFrm();
    frm.AfterChangeTextDel = new Action<string>(this.AfterChildChange);
    frm.Show();


    5、这样也能实现窗体传值,子窗体的委托可以在父窗体 其他地方可以进行直接执行。:解决此问题。微软引入了事件。
     
    十、用事件来实现

     

    事件是委托类型的对象。它内部是用委托来实现的,对于事件来说,外部只能注册自己+=,注销自己-=,外界不可以注销其他的注册者,也不能主动触发事件。而委托则无法实现这些控制,因此诞生了事件这话总语法。
     
    实现代码如下
    在窗体Form2中定义公有属性Form2Value,获取和设置textBox1的文本值
    并且还定义一个accept事件

    复制代码代码如下:

    public string Form2Value
    {
    get
    {
    return this.textBox1.Text;
    }
    set
    {
    this.textBox1.Text = value;
    }
    }
    public event EventHandler accept;
     
    private void button1_Click ( object sender , EventArgs e )
    {
    if ( accept != null )
    {
    accept ( this , EventArgs.Empty ); //当窗体触发事件,传递自身引用
    }
    }


    在窗体Form1中

    复制代码代码如下:

    Form2 f2 = new Form2 ( );
    f2.accept += new EventHandler ( f2_accept );
    f2.Show ( );
    void f2_accept ( object sender , EventArgs e )
    {
    //事件的接收者通过一个简单的类型转换得到Form2的引用
    Form2 f2 = (Form2) sender;
    //接收到Form2的textBox1.Text
    this.textBox1.Text = f2.Form2Value;
    }

     

    希望本文所述对大家的C#程序设计有所帮助

    展开全文
  • c#窗体传值 1. 窗体向子窗体传值 窗体Form1程序 //使其成为主窗体Form1的一个属性, private string text; public string Text { get { return text; } set { text = value; } } ...
  • C#通过委托从窗体向父窗体传值 1.Form1中: 1 using System; 2 using System.Windows.Forms; 3 4 namespace WindowsForms跨窗体传值大全 5 { 6 public partial class Form1 : Form 7 { 8 public...
  • C#中实现窗体向子窗体传值窗体向父窗体传值 感谢这篇博文!
  • //父类代码 Form2 frm2 = new Form2(); frm2.Owner = this; frm2.Show(); //或 frm2.Show(this); //或 frm2.ShowDialog(this); //子类代码 Form1 frm1 = (Form1)this.Owner; frm1.textBox1.Text = "aaa";
  • 在写程序的时候用到了由子窗体确定参数后返回给父窗体。这就涉及到窗体传值的问题。C#是不提供窗体间变量和控件的直接相互调用(就是说即使Form1的变量和控件属性都设为Public或者Internal,在Form2种也不能通过 ...
  • 做了很多项目,很多项目都用到子父窗体之间的传值。。 父窗体传入子窗体都比较简单,而子窗体传入父窗体因为有很多不通道的需求,所以·搞起来有点头大。 先说父窗体传入子窗体: 将父窗体控件上的值传入...
  • 如果是父窗体传值窗体,这个很简单,利用属性字段传值即可。那么窗体如何传值给窗体呢?其实也很简单,用委托就可以。下面看一个案例:现有一个窗体(MainForm)和一个窗体(ChildForm),点击窗体的...
  • 本例子: 在子窗体中定义:委托与事件, 在父窗体中实现定义的事件。 实现子窗体,修改父窗体中的内容,及窗体之间的传值,都可以参考此例子。
  • 击Form1的button1 打开Form2  再点击Form2的button...  在button2_Click事件中 通过this.Owner将Form2的textBox2的值设置给Form1的textBox1  并关闭Form2 ... public partial class Form1 : Form ... public Form1
  • c# 委托,父窗体传值窗体、调用方法,DEMO,完整代码,visual studio2010
  • 子窗体childForm,利用事件进行传值子窗体中的操作: public event EventHandler accept; public string value; private void btnStart_Click(object sender, EventArgs e) {  value=txtName.text; ...
  • C#,winform,ShowDialog,窗体向父窗体传值
  • 子窗体: public partial class ChildForm : Form { public ChildForm() { InitializeComponent(); } //声明一个委托 public delegate void DisplayUpdateDelegate(string...
  • //父窗体 private void btnAdd_Click(object sender, EventArgs e) { FormAddHotKey m_FormAddKey = new MyAutomaticTextInput.FormAddHotKey(); m_FormAddKey.Owner = this; ...
1 2 3 4 5 ... 20
收藏数 3,276
精华内容 1,310
关键字:

c#子窗体操作父窗体传值