精华内容
下载资源
问答
  • 窗体间传递数据

    2015-06-10 11:40:02
    窗体间传递数据窗体间传递值,頟种传值方式
  • 主要介绍了C#实现窗体间传递数据实例,需要的朋友可以参考下
  • 解决初学者学习Qt窗体间传递数据的问题http://blog.csdn.net/shihoongbo/article/details/48681979
  • 总结 C#中窗体间传递数据的几 种方法 总结 C# 中窗体间传递数据的几种方法 由别人的方法整理 编写 C#windows 应用程序的时候我们经常会遇到这种问题怎么样两个窗体间传递数 据呢以下是我整理的网上的各种方法...
  • C#委托窗体间传递数据

    千次阅读 2019-03-26 18:43:55
    委托窗体间窗体数据的价值 窗体间可以共享对象(比如工控上位机实例PLC连接时只需一个) 主从窗体运行状态可以实时更新(工控上位机主要运用) 窗口运行界面 主窗体点击可以同时给从窗体加1 主窗体点击复位...

    什么是委托?

    一句话:委托是一个可以代理方法的特殊数据类型

    1. 首先委托是一种特殊数据类型
    2. 其次委托代理的数据不是普通数据而是方法

    委托窗体间窗体数据的价值

    • 窗体间可以共享对象(比如工控上位机实例PLC连接时只需一个)
    • 主从窗体运行状态可以实时更新(工控上位机主要运用)

    窗口运行界面

    在这里插入图片描述

    • 主窗体点击可以同时给从窗体加1
    • 主窗体点击复位可以将加的值请空
    • 从窗体点击回让主窗体加1

    主窗体代码

    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 DelegateDemo
    {
    
        public delegate void SendCount(int m); // 不在类外面 从窗体无法使用
        public partial class frmMain : Form
        {   
            // <一>.主窗体向从窗体发数据。。。。。。
            // [1].主窗体向从窗体发送时委托定义在主窗体中方便
            // [2].从窗体中写具体实现的方法
            // [3].打开从窗体时绑定委托与方法
            // [4].主窗体中写触发委托方法
            SendCount send;
            public frmMain()
            {
                InitializeComponent();
                FrmOther1 frm1 = new FrmOther1();
                send = frm1.ReceiveDate;
                frm1.frm1Send = ReceiveData;
                frm1.Show();
                FrmOther2 frm2 = new FrmOther2();
                frm2.frm2Send = ReceiveData;
                send += frm2.ReceiveData;
                frm2.Show();
            }
    
            int myCount = 1;
            private void button1_Click(object sender, EventArgs e)
            {
                myCount++;
                send?.Invoke(myCount);
            }
    
            private void button2_Click(object sender, EventArgs e)
            {
                send?.Invoke(0);
                myCount = 1;
            }
    
            public void ReceiveData(int count)
            {
                labCount.Text = count.ToString();
            }
        }
    }
    
    

    从窗体1的代码如下

    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 DelegateDemo
    {
    
     
        public partial class FrmOther1 : Form
        {
            public SendCount frm1Send; // 不声明为public主窗体无法使用
            public FrmOther1()
            {
                InitializeComponent();
            }
    
            public void ReceiveDate(int count)
            {
                labCount.Text = count.ToString();
            }
    
            int count = 0;
            private void button1_Click(object sender, EventArgs e)
            {
                count++;
                frm1Send?.Invoke(count);
               
            }
        }
    }
    
    

    从窗体2的代码

    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 DelegateDemo
    {
        public partial class FrmOther2 : Form
        {
            public FrmOther2()
            {
                InitializeComponent();
            }
            public SendCount frm2Send;
            public void ReceiveData(int count)
            {
                labCount.Text = count.ToString();
            }
    
            int count = 0;
            private void button1_Click(object sender, EventArgs e)
            {
                count++;
                frm2Send?.Invoke(count);
            }
        }
    }
    
    
    展开全文
  • 总结 总结C#中窗体间传递数据的几种方法 (由别人的方法整理) 编写C#windows应用程序的时候我们经常会遇到这种问题怎么样两个窗体间传递数据呢 以下是我整理的网上的各种方法 遇到一个实际问题forml中打开一...
  • C#中窗体间传递数据的几种方法

    千次阅读 2018-12-27 09:02:54
    编写C#windows应用程序的时候我们经常会遇到这种问题,怎么样两个窗体间传递数据呢?以下是我整理的网上的各种方法,遇到一个实际问题:form1中打开一个form2窗口作为录入界面,将录入的值经转换后form1中...

    C#中窗体间传递数据的几种方法

    在编写C#windows应用程序的时候我们经常会遇到这种问题,怎么样在两个窗体间传递数据呢?以下是我整理的网上的各种方法,在遇到一个实际问题:在form1中打开一个form2窗口作为录入界面,将录入的值经转换后在form1中显示。 采用了委托的方法,可以实现。(与VC的回调的应用相似)
    1.可以通过委托的方法来解决
    问题:通过form1做一个录入界面,将里边通过文本框录入的数值复值给 form2中的listview各列,用3个textbox1.text举例吧,分别对应listview的3个列。
    可以这么做,如果两个窗体是在同一个命名空间下
    定义一个代理,注意这个代理是全局的:(即同一命名空间下,与Form1,Form2平级的)
    public delegate void MyInvoke(string Item1,string Item2,string Item3);

    //在窗体From2中有这么一个回调函数,用于在ListView里添加一个新项的:
    private void UpdateListView(string Item1,string Item2,string Item3)
    {
    ListView1.Items.Add(Item1);
    ListView1.Items[ListView1.Items.Count - 1].SubItems.Add(Item2);
    ListView1.Items[ListView1.Items.Count - 1].SubItems.Add(Item3);
    }

    //比如说点击Form2的一个按钮弹出Form1进行录入,在点击按钮的事件下:
    //把委托传过去
    Form1 frmEdit=new Form1(new MyInvoke(UpdateListView));
    frmEdit.ShowDialog(this);

    //在Form1里定义一个属性
    private MyInvoke mi=null;

    在构造函数中接收这个委托:
    public Form1(MyInvoke myInvoke)
    {
    this.mi=myInvoke;
    }

    //录入数据后,点击OK按钮,在点击事件下:
    //回调
    this.mi(this.TextBox1.Text,this.TextBox3.Text,this.TextBox3.Text);
    this.Close();//关闭Form1
    补充:如果我要是想再把form2的值给form1,
    Form1 frmEdit=new Form1(new MyInvoke(UpdateListView),string para1,string para2…);
    frmEdit.ShowDialog(this);
    然后将Form1的构造函数改成可以接收几个参数的就行了。

    2.假如主框架为Form1,打开的搜索对话框是Form2.直接在Form2类中申明一个Form1实例:Form1 f1=new Form1();然后就可以通过f1来调用Form1中的域和函数了。其实不是这样的,你申明的新的Form1实例不是原来的那个Form1对象了,这样操作的是新的Form1中的域和函数,和最先打开的Form1是没有关系的。
    我们要做的是把当前的Form1实例传递给Form2,如果是这样的话,问题就很好解决了。
    方法1:首先,我们在Form2中定义:
    private Form1 mF_Form
    我们更改Form2的构造函数为有参数的
    public Form2 ( Form1 myForm )
    {
    //
    // Windows 窗体设计器支持所必需的
    //
    InitializeComponent ( ) ;
    this.mF_Form = myForm ; /这样在Form1中申明Form2的时候就把Form1的实例传递过来了
    //
    // TODO: 在 InitializeComponent 调用后添加任何构造函数代码
    //
    }
    在Form1中,我在 要用到Form2的地方申明如下:
    Form2 f2=new Form2(this);这里的this指的就是Form1当前的实例,也就是把当前Form1的实例通过Form2的构造函数传递给Form2类(其实在网上看到过比较蠢的方式,就是在构造函数里面传递要传递的信息如:字符串或是数字等,这样做很有局限性,不能传递其他的,所有我们可以直接传递实例,来完成传递更多的信息。)
    这样在Form2中使用myForm 就可以对原来的Form1窗口进行操作了。但是你要把要操作的Form1中的域和函数定义成public形式的(这样可能不安全),此时的myForm就是真正的最开始打开的Form1了,你可以用这个实例来进行两个窗体的通讯了。 ()
    3.其实C#中提供了窗体间进行通讯的现成的属性,呵呵,我们能想到的,微软也想到了,他们创造的语言其实确实可以说是人性化了。
    在Form1类中申明Form2时用如下代码:
    Form2 f2=new Form2();//类Form2中的构造函数不改,还是无参的
    f2.owner=this;这里的this指的是类Form1当前的实例。
    //也可以使用函数的方法,给当前实例添加一个附属窗口 代码:this.AddOwnedForm(f2);
    在Form2类的定义中写如下代码:
    Form1 f1=this.owner;
    这样f1对应的就是原来的Form1的实例了,也就可以用这个进行通讯了。但是还是要把不同类之间访问的域和函数定义成public,哎,安全确实是一个问题!!

    4.使用静态类
    这个也是我们经常要用到的一种数据交互方法。
    下面是定义的一个类:
    using System;
    using System.Collections;
    namespace ZZ
    {
    public class AppDatas
    {
    private static ArrayList listData;
    static AppDatas()
    {
    listData = new ArrayList();
    listData.Add(“DotNet”);
    listData.Add(“C#”);
    listData.Add(“Asp.net”);
    listData.Add(“WebService”);
    listData.Add(“XML”);
    }
    public static ArrayList ListData
    {
    get{return listData;}
    }
    public static ArrayList GetListData()
    {
    return listData;
    }
    }
    }
    上面包含了一个静态类成员,listData,一个静态构造函数static AppDatas(),用来初始化listData的数据。还有一个静态属性ListData和一个静态GetListData()方法,他们实现了同样的功能就是返回listData。
    由于前面两篇文章已经讲了很多,这里不细说了,下面是完整的代码:
    Form1.cs文件
    using System;
    using System.Drawing;
    using System.Collections;
    using System.ComponentModel;
    using System.Windows.Forms;
    namespace ZZ
    {
    public class Form1 : System.Windows.Forms.Form
    {
    private System.Windows.Forms.Button buttonEdit;
    private System.Windows.Forms.ListBox listBoxFrm1;
    private System.ComponentModel.Container components = null;
    public Form1()
    {
    InitializeComponent();
    this.listBoxFrm1.DataSource = AppDatas.ListData;

         }
         protected override void Dispose( bool disposing )
         {
              if( disposing )
                   if(components != null)
                       components.Dispose();
              base.Dispose( disposing );
         }
         [STAThread]
         static void Main() 
         {
              Application.Run(new Form1());
         }
         private void InitializeComponent()
         {
              this.buttonEdit = new System.Windows.Forms.Button();
              this.listBoxFrm1 = new System.Windows.Forms.ListBox();
              this.SuspendLayout();
              this.buttonEdit.Location = new System.Drawing.Point(128, 108);
              this.buttonEdit.Name = "buttonEdit";
              this.buttonEdit.TabIndex = 1;
              this.buttonEdit.Text = "修改";
              this.buttonEdit.Click += new System.EventHandler(this.buttonEdit_Click);
              this.listBoxFrm1.ItemHeight = 12;
              this.listBoxFrm1.Location = new System.Drawing.Point(12, 8);
              this.listBoxFrm1.Name = "listBoxFrm1";
              this.listBoxFrm1.Size = new System.Drawing.Size(108, 124);
              this.listBoxFrm1.TabIndex = 2;
              this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
              this.ClientSize = new System.Drawing.Size(208, 141);
              this.Controls.Add(this.listBoxFrm1);
              this.Controls.Add(this.buttonEdit);
              this.Name = "Form1";
              this.Text = "Form1";
              this.ResumeLayout(false);
         }
         private void buttonEdit_Click(object sender, System.EventArgs e)
         {
              Form2 formChild = new Form2();
              formChild.ShowDialog();
              this.listBoxFrm1.DataSource = null;
              this.listBoxFrm1.DataSource = AppDatas.ListData;
         }
     }
    

    }

    Form2.cs文件
    using System.Drawing;
    using System.Collections;
    using System.ComponentModel;
    using System.Windows.Forms;
    namespace ZZ
    {
    public class Form2 : System.Windows.Forms.Form
    {
    private System.Windows.Forms.Button buttonOK;
    private System.ComponentModel.Container components = null;
    private System.Windows.Forms.ListBox listBoxFrm2;
    private System.Windows.Forms.Button buttonAdd;
    private System.Windows.Forms.Button buttonDel;
    private System.Windows.Forms.TextBox textBoxAdd;
    public Form2()
    {
    InitializeComponent();
    foreach(object o in AppDatas.ListData)
    this.listBoxFrm2.Items.Add(o);
    }
    protected override void Dispose( bool disposing )
    {
    if( disposing )
    if(components != null)
    components.Dispose();
    base.Dispose( disposing );
    }
    private void InitializeComponent()
    {
    this.buttonOK = new System.Windows.Forms.Button();
    this.listBoxFrm2 = new System.Windows.Forms.ListBox();
    this.buttonAdd = new System.Windows.Forms.Button();
    this.buttonDel = new System.Windows.Forms.Button();
    this.textBoxAdd = new System.Windows.Forms.TextBox();
    this.SuspendLayout();
    this.buttonOK.Location = new System.Drawing.Point(188, 108);
    this.buttonOK.Name = “buttonOK”;
    this.buttonOK.TabIndex = 0;
    this.buttonOK.Text = “确定”;
    this.buttonOK.Click += new System.EventHandler(this.buttonOK_Click);
    this.listBoxFrm2.ItemHeight = 12;
    this.listBoxFrm2.Location = new System.Drawing.Point(8, 8);
    this.listBoxFrm2.Name = “listBoxFrm2”;
    this.listBoxFrm2.Size = new System.Drawing.Size(168, 124);
    this.listBoxFrm2.TabIndex = 2;
    this.buttonAdd.Location = new System.Drawing.Point(188, 44);
    this.buttonAdd.Name = “buttonAdd”;
    this.buttonAdd.TabIndex = 3;
    this.buttonAdd.Text = “增加”;
    this.buttonAdd.Click += new System.EventHandler(this.buttonAdd_Click);
    this.buttonDel.Location = new System.Drawing.Point(188, 76);
    this.buttonDel.Name = “buttonDel”;
    this.buttonDel.TabIndex = 4;
    this.buttonDel.Text = “删除”;
    this.buttonDel.Click += new System.EventHandler(this.buttonDel_Click);
    this.textBoxAdd.Location = new System.Drawing.Point(188, 12);
    this.textBoxAdd.Name = “textBoxAdd”;
    this.textBoxAdd.Size = new System.Drawing.Size(76, 21);
    this.textBoxAdd.TabIndex = 5;
    this.textBoxAdd.Text = “”;
    this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
    this.ClientSize = new System.Drawing.Size(272, 141);
    this.Controls.Add(this.textBoxAdd);
    this.Controls.Add(this.buttonDel);
    this.Controls.Add(this.buttonAdd);
    this.Controls.Add(this.listBoxFrm2);
    this.Controls.Add(this.buttonOK);
    this.Name = “Form2”;
    this.Text = “Form2”;
    this.ResumeLayout(false);
    }
    private void buttonOK_Click(object sender, System.EventArgs e)
    {
    this.Close();
    }
    private void buttonAdd_Click(object sender, System.EventArgs e)
    {
    if(this.textBoxAdd.Text.Trim().Length>0)
    {
    AppDatas.ListData.Add(this.textBoxAdd.Text.Trim());
    this.listBoxFrm2.Items.Add(this.textBoxAdd.Text.Trim());
    }
    else
    MessageBox.Show(“请输入添加的内容!”);

         }
         private void buttonDel_Click(object sender, System.EventArgs e)
         {
              int index = this.listBoxFrm2.SelectedIndex;
              if(index!=-1)
              {
                    AppDatas.ListData.RemoveAt(index);
                   this.listBoxFrm2.Items.RemoveAt(index);
              }
              else
                   MessageBox.Show("请选择删除项!");
         }
     }
    

    }
    总结,我认为使用静态类比较多的地方就是把应用程序的配置文件装载到一个静态类里面,让所有的窗体和其他实例都可以通过静态属性以及静态方法使用这些数据,比如三层结构或多层结构都可以访问它,而不是在多个实例间传来传去。在这里我们讨论的是Windows窗体,其实在两个不同的实例间交互数据,都可以采用三篇文章中的方案实现,除非是这个类特有的属性或着方法。现在都讲完了,虽然不是什么高深的东西,但是希望能对一些初学者有所帮助,同时也欢迎各位朋友进行技术交流,共同提高。

    分析上面几种方法:
    1. 采用了委托的方法,可以实现。:很好的实现了数据处理与数据显示的分离,即FORM2(主)显示与FORM1数据处理,(不需要将FORM2的显示放在FORM1中)与VC的回调的应用有延续性。并且确保了FORM1中要修改的属性的私有性。

    2. 方法2、3都是传递主窗口的引用,比较简单易用。可以实现FORM2(主)与FORM1所有数据的传递(不过需要将要FORM1传递和要修改的数据设为PUBLIC),而这样会存在安全问题。

    委托方法可以很好地实现数据的保护

    总结C#中窗体间传递数据的几种方法 (由别人的方法整理)

    在编写C#windows应用程序的时候我们经常会遇到这种问题,怎么样在两个窗体间传递数据呢?以下是我整理的网上的各种方法,在遇到一个实际问题:在form1中打开一个form2窗口作为录入界面,将录入的值经转换后在form1中显示。 采用了委托的方法,可以实现。(与VC的回调的应用相似)
    1.可以通过委托的方法来解决
    问题:通过form1做一个录入界面,将里边通过文本框录入的数值复值给 form2中的listview各列,用3个textbox1.text举例吧,分别对应listview的3个列。
    可以这么做,如果两个窗体是在同一个命名空间下
    定义一个代理,注意这个代理是全局的:(即同一命名空间下,与Form1,Form2平级的)
    public delegate void MyInvoke(string Item1,string Item2,string Item3);

    //在窗体From2中有这么一个回调函数,用于在ListView里添加一个新项的:
    private void UpdateListView(string Item1,string Item2,string Item3)
    {
    ListView1.Items.Add(Item1);
    ListView1.Items[ListView1.Items.Count - 1].SubItems.Add(Item2);
    ListView1.Items[ListView1.Items.Count - 1].SubItems.Add(Item3);
    }

    //比如说点击Form2的一个按钮弹出Form1进行录入,在点击按钮的事件下:
    //把委托传过去
    Form1 frmEdit=new Form1(new MyInvoke(UpdateListView));
    frmEdit.ShowDialog(this);

    //在Form1里定义一个属性
    private MyInvoke mi=null;

    在构造函数中接收这个委托:
    public Form1(MyInvoke myInvoke)
    {
    this.mi=myInvoke;
    }

    //录入数据后,点击OK按钮,在点击事件下:
    //回调
    this.mi(this.TextBox1.Text,this.TextBox3.Text,this.TextBox3.Text);
    this.Close();//关闭Form1
    补充:如果我要是想再把form2的值给form1,
    Form1 frmEdit=new Form1(new MyInvoke(UpdateListView),string para1,string para2…);
    frmEdit.ShowDialog(this);
    然后将Form1的构造函数改成可以接收几个参数的就行了。

    2.假如主框架为Form1,打开的搜索对话框是Form2.直接在Form2类中申明一个Form1实例:Form1 f1=new Form1();然后就可以通过f1来调用Form1中的域和函数了。其实不是这样的,你申明的新的Form1实例不是原来的那个Form1对象了,这样操作的是新的Form1中的域和函数,和最先打开的Form1是没有关系的。
    我们要做的是把当前的Form1实例传递给Form2,如果是这样的话,问题就很好解决了。
    方法1:首先,我们在Form2中定义:
    private Form1 mF_Form
    我们更改Form2的构造函数为有参数的
    public Form2 ( Form1 myForm )
    {
    //
    // Windows 窗体设计器支持所必需的
    //
    InitializeComponent ( ) ;
    this.mF_Form = myForm ; /这样在Form1中申明Form2的时候就把Form1的实例传递过来了
    //
    // TODO: 在 InitializeComponent 调用后添加任何构造函数代码
    //
    }
    在Form1中,我在 要用到Form2的地方申明如下:
    Form2 f2=new Form2(this);这里的this指的就是Form1当前的实例,也就是把当前Form1的实例通过Form2的构造函数传递给Form2类(其实在网上看到过比较蠢的方式,就是在构造函数里面传递要传递的信息如:字符串或是数字等,这样做很有局限性,不能传递其他的,所有我们可以直接传递实例,来完成传递更多的信息。)
    这样在Form2中使用myForm 就可以对原来的Form1窗口进行操作了。但是你要把要操作的Form1中的域和函数定义成public形式的(这样可能不安全),此时的myForm就是真正的最开始打开的Form1了,你可以用这个实例来进行两个窗体的通讯了。 ()
    3.其实C#中提供了窗体间进行通讯的现成的属性,呵呵,我们能想到的,微软也想到了,他们创造的语言其实确实可以说是人性化了。
    在Form1类中申明Form2时用如下代码:
    Form2 f2=new Form2();//类Form2中的构造函数不改,还是无参的
    f2.owner=this;这里的this指的是类Form1当前的实例。
    //也可以使用函数的方法,给当前实例添加一个附属窗口 代码:this.AddOwnedForm(f2);
    在Form2类的定义中写如下代码:
    Form1 f1=this.owner;
    这样f1对应的就是原来的Form1的实例了,也就可以用这个进行通讯了。但是还是要把不同类之间访问的域和函数定义成public,哎,安全确实是一个问题!!

    4.使用静态类
    这个也是我们经常要用到的一种数据交互方法。
    下面是定义的一个类:
    using System;
    using System.Collections;
    namespace ZZ
    {
    public class AppDatas
    {
    private static ArrayList listData;
    static AppDatas()
    {
    listData = new ArrayList();
    listData.Add(“DotNet”);
    listData.Add(“C#”);
    listData.Add(“Asp.net”);
    listData.Add(“WebService”);
    listData.Add(“XML”);
    }
    public static ArrayList ListData
    {
    get{return listData;}
    }
    public static ArrayList GetListData()
    {
    return listData;
    }
    }
    }
    上面包含了一个静态类成员,listData,一个静态构造函数static AppDatas(),用来初始化listData的数据。还有一个静态属性ListData和一个静态GetListData()方法,他们实现了同样的功能就是返回listData。
    由于前面两篇文章已经讲了很多,这里不细说了,下面是完整的代码:
    Form1.cs文件
    using System;
    using System.Drawing;
    using System.Collections;
    using System.ComponentModel;
    using System.Windows.Forms;
    namespace ZZ
    {
    public class Form1 : System.Windows.Forms.Form
    {
    private System.Windows.Forms.Button buttonEdit;
    private System.Windows.Forms.ListBox listBoxFrm1;
    private System.ComponentModel.Container components = null;
    public Form1()
    {
    InitializeComponent();
    this.listBoxFrm1.DataSource = AppDatas.ListData;

         }
         protected override void Dispose( bool disposing )
         {
              if( disposing )
                   if(components != null)
                       components.Dispose();
              base.Dispose( disposing );
         }
         [STAThread]
         static void Main() 
         {
              Application.Run(new Form1());
         }
         private void InitializeComponent()
         {
              this.buttonEdit = new System.Windows.Forms.Button();
              this.listBoxFrm1 = new System.Windows.Forms.ListBox();
              this.SuspendLayout();
              this.buttonEdit.Location = new System.Drawing.Point(128, 108);
              this.buttonEdit.Name = "buttonEdit";
              this.buttonEdit.TabIndex = 1;
              this.buttonEdit.Text = "修改";
              this.buttonEdit.Click += new System.EventHandler(this.buttonEdit_Click);
              this.listBoxFrm1.ItemHeight = 12;
              this.listBoxFrm1.Location = new System.Drawing.Point(12, 8);
              this.listBoxFrm1.Name = "listBoxFrm1";
              this.listBoxFrm1.Size = new System.Drawing.Size(108, 124);
              this.listBoxFrm1.TabIndex = 2;
              this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
              this.ClientSize = new System.Drawing.Size(208, 141);
              this.Controls.Add(this.listBoxFrm1);
              this.Controls.Add(this.buttonEdit);
              this.Name = "Form1";
              this.Text = "Form1";
              this.ResumeLayout(false);
         }
         private void buttonEdit_Click(object sender, System.EventArgs e)
         {
              Form2 formChild = new Form2();
              formChild.ShowDialog();
              this.listBoxFrm1.DataSource = null;
              this.listBoxFrm1.DataSource = AppDatas.ListData;
         }
     }
    

    }

    Form2.cs文件
    using System.Drawing;
    using System.Collections;
    using System.ComponentModel;
    using System.Windows.Forms;
    namespace ZZ
    {
    public class Form2 : System.Windows.Forms.Form
    {
    private System.Windows.Forms.Button buttonOK;
    private System.ComponentModel.Container components = null;
    private System.Windows.Forms.ListBox listBoxFrm2;
    private System.Windows.Forms.Button buttonAdd;
    private System.Windows.Forms.Button buttonDel;
    private System.Windows.Forms.TextBox textBoxAdd;
    public Form2()
    {
    InitializeComponent();
    foreach(object o in AppDatas.ListData)
    this.listBoxFrm2.Items.Add(o);
    }
    protected override void Dispose( bool disposing )
    {
    if( disposing )
    if(components != null)
    components.Dispose();
    base.Dispose( disposing );
    }
    private void InitializeComponent()
    {
    this.buttonOK = new System.Windows.Forms.Button();
    this.listBoxFrm2 = new System.Windows.Forms.ListBox();
    this.buttonAdd = new System.Windows.Forms.Button();
    this.buttonDel = new System.Windows.Forms.Button();
    this.textBoxAdd = new System.Windows.Forms.TextBox();
    this.SuspendLayout();
    this.buttonOK.Location = new System.Drawing.Point(188, 108);
    this.buttonOK.Name = “buttonOK”;
    this.buttonOK.TabIndex = 0;
    this.buttonOK.Text = “确定”;
    this.buttonOK.Click += new System.EventHandler(this.buttonOK_Click);
    this.listBoxFrm2.ItemHeight = 12;
    this.listBoxFrm2.Location = new System.Drawing.Point(8, 8);
    this.listBoxFrm2.Name = “listBoxFrm2”;
    this.listBoxFrm2.Size = new System.Drawing.Size(168, 124);
    this.listBoxFrm2.TabIndex = 2;
    this.buttonAdd.Location = new System.Drawing.Point(188, 44);
    this.buttonAdd.Name = “buttonAdd”;
    this.buttonAdd.TabIndex = 3;
    this.buttonAdd.Text = “增加”;
    this.buttonAdd.Click += new System.EventHandler(this.buttonAdd_Click);
    this.buttonDel.Location = new System.Drawing.Point(188, 76);
    this.buttonDel.Name = “buttonDel”;
    this.buttonDel.TabIndex = 4;
    this.buttonDel.Text = “删除”;
    this.buttonDel.Click += new System.EventHandler(this.buttonDel_Click);
    this.textBoxAdd.Location = new System.Drawing.Point(188, 12);
    this.textBoxAdd.Name = “textBoxAdd”;
    this.textBoxAdd.Size = new System.Drawing.Size(76, 21);
    this.textBoxAdd.TabIndex = 5;
    this.textBoxAdd.Text = “”;
    this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
    this.ClientSize = new System.Drawing.Size(272, 141);
    this.Controls.Add(this.textBoxAdd);
    this.Controls.Add(this.buttonDel);
    this.Controls.Add(this.buttonAdd);
    this.Controls.Add(this.listBoxFrm2);
    this.Controls.Add(this.buttonOK);
    this.Name = “Form2”;
    this.Text = “Form2”;
    this.ResumeLayout(false);
    }
    private void buttonOK_Click(object sender, System.EventArgs e)
    {
    this.Close();
    }
    private void buttonAdd_Click(object sender, System.EventArgs e)
    {
    if(this.textBoxAdd.Text.Trim().Length>0)
    {
    AppDatas.ListData.Add(this.textBoxAdd.Text.Trim());
    this.listBoxFrm2.Items.Add(this.textBoxAdd.Text.Trim());
    }
    else
    MessageBox.Show(“请输入添加的内容!”);

         }
         private void buttonDel_Click(object sender, System.EventArgs e)
         {
              int index = this.listBoxFrm2.SelectedIndex;
              if(index!=-1)
              {
                    AppDatas.ListData.RemoveAt(index);
                   this.listBoxFrm2.Items.RemoveAt(index);
              }
              else
                   MessageBox.Show("请选择删除项!");
         }
     }
    

    }
    总结,我认为使用静态类比较多的地方就是把应用程序的配置文件装载到一个静态类里面,让所有的窗体和其他实例都可以通过静态属性以及静态方法使用这些数据,比如三层结构或多层结构都可以访问它,而不是在多个实例间传来传去。在这里我们讨论的是Windows窗体,其实在两个不同的实例间交互数据,都可以采用三篇文章中的方案实现,除非是这个类特有的属性或着方法。现在都讲完了,虽然不是什么高深的东西,但是希望能对一些初学者有所帮助,同时也欢迎各位朋友进行技术交流,共同提高。

    分析上面几种方法:
    1. 采用了委托的方法,可以实现。:很好的实现了数据处理与数据显示的分离,即FORM2(主)显示与FORM1数据处理,(不需要将FORM2的显示放在FORM1中)与VC的回调的应用有延续性。并且确保了FORM1中要修改的属性的私有性。

    2. 方法2、3都是传递主窗口的引用,比较简单易用。可以实现FORM2(主)与FORM1所有数据的传递(不过需要将要FORM1传递和要修改的数据设为PUBLIC),而这样会存在安全问题。

    委托方法可以很好地实现数据的保护

    展开全文
  • 在窗体间传递数据的方法比较多: 1,窗体中自定义一个构造函数,参数类型是主窗体,当要显示子窗体的时候,就用这个构造函数来实例化子窗体,然后把this指针传进去,说起来太抽象了,我大概一写大家应该就明白了...
  • C#窗体间传递数据

    2012-02-04 22:29:48
    一、从Form1(主窗体)把数据传递给Form2(新窗体) 举例: 比如要将Form1中的一个TextBox(frm1_txt)中的值传给Form2 方法:通过重载Form2的构造函数 public Form2() { InitializeComponent(); } private ...


    一、从Form1(主窗体)把数据传递给Form2(新窗体)

    举例: 比如要将Form1中的一个TextBox(frm1_txt)中的值传给Form2

    方法:通过重载Form2的构造函数

            public Form2()
            {
                InitializeComponent();
            }
            private string msg;
    
            /*重写Form2构造函数来接收Form1传来的数据*/
            public Form2(TextBox txt) 
            {
                InitializeComponent();
                msg = txt.Text;
            }


    二、把Form2(新窗体)中的数据传回给Form1(主窗体)

    举例:比如要将Form2中一个TextBox(frm2_txt)中的值传回给Form1

    方法:使用自定义事件

    [ Form2中的代码 ]

    //Form2.cs
    
    /*声明委托*/
    public delegate void ReturnDateEventHandler(object sender, TextBox e);
    
    /*声明事件*/
    public event ReturnDateEventHandler OnReturnDateEventHandler;
    
    /*将Form2的textBox中的数据传回给Form1*/
    private void frm2_btn2_Click(object sender, EventArgs e)
    {
    	//当事件不为空时触发事件
    	if (OnReturnDateEventHandler != null)
    	{
    		OnReturnDateEventHandler(this, frm2_txt);
    	}
    }

    [ Form1中的代码 ]

    //From1.cs
    
    private string msg;
    
    /*用于新建Form2,并把frm1_txt的数据传给新建的Form2实例*/
    private void frm1_btn1_Click(object sender, EventArgs e)
    {
    	//新建Form2实例
    	Form2 myfrm2 = new Form2(frm1_txt);
    	//订阅事件
    	myfrm2.OnReturnDateEventHandler += new Form2.ReturnDateEventHandler(Handletheevent);
    	myfrm2.Show();
    }
    
    /*显示Form2传来的数据*/
    private void frm1_btn2_Click(object sender, EventArgs e)
    {
    	frm1_txt.Text = msg;
    }
    
    /*事件处理程序:结束From2传过来的textBox数据*/
    public void Handletheevent(object sender, TextBox e)
    {
    	msg = e.Text;
    }


    展开全文
  • 我们经常遇到程序设计中,数据可以同一个窗体传递,也可能在窗体间传递。这里将要阐述窗体之间的数值传递。例如需要通过调用子窗体来修改父窗体的内容。 【注意】窗体间传值要弄清楚到底是哪个对象的问题,...

      我们经常遇到在程序设计中,数据可以在同一个窗体中传递,也可能在窗体间传递。这里将要阐述窗体之间的数值传递。例如需要通过调用子窗体来修改父窗体的内容。

    【注意】窗体间传值要弄清楚到底是哪个对象的问题,否则容易传错值。

    例如,我们要实现,在登陆窗体中,把当前的登陆用户信息传递给主窗体,但是却实例了一个新的对象loginFrm把里头的信息传递给了mainFrm,得到了的却是空值,为什么??

       窗体传值的前提是,要传的字段,在类里面的访问修饰符必须是public(如果在源窗体内传值则例外,参见下列常用方法2)

    《方法》这里先阐述一下常用的几种方法:

    【以下转载于博客】cnblogs.com/tomin/archive/2009/02/25/1397677.html
    【1】
    静态变量,在窗体里中,写入一个静态变量A,可以给其赋值,那么在这个项目中,就可以通过Form1.A来调用。不推荐此种方法,不太安全。

    【2】比较稳妥的方法,就是在传值的过程中,首先在被传值窗体form2中,建立一个公有属性B,做为接收者。

         在form1里实例form2时,把需要传递的值A赋给新实例form2.B,或者是通过Form2类的构造函数传递,方法很多,此种传值较为安全(推荐)。

    【3】若是要得到一组固定的数据,那么可以写成一个公有的带返回值的方法,在源窗体中。然后在目标窗体中实例源窗体对象,调用此方法获得数据,此方法虽不同于静态变量,但有异曲同工之妙,可以不必强调对象。其缺点是,方法体内传递数据为固定的,不能变通。

    【4】查询对话框,大家都用过记事本,里头有个查询功能,就是当选中一段文字时,打开查询对话框,就会在查询对话框中显示选中的那段文字,其代码实现为:
          在Form1中:我们要把一个文本传递给Form2窗体,假定为passText
                  public string passText
                  {
                       get{ return textBox1.Text;}
                  }      

                  Form1
    中还有个按钮button1在其点击事件中有:
                                 private void button1_Click(object sender,EventArgs e)
                  {
                          Form2 f2 = new Form2();   //
    呃。。这个就不用说了
                          f2.Owner = this;  //
    设置附属,好搭关系~
                         f2.Show();   //
    看得出来撒
                  }

    /********************************************************************************/
    Form2的对象中:
                
    假设有个文本框txtBox1,
                 private void form2_Load(object sender,EventArgs e)
                 {
                                        //
    通过目标窗体,找到拥有它的源窗体,得到的是一个object
                                        
    对象,要转换成Form1这个类型,就可以得到它的公有属性passText拉。
                     textBox1.Text = ((Form1)this.Owner).passText;
                                 }
    这样当我们打开Form2时,就会在其文本框中,显示Form1的文本框信息了

    想要做到查询对话框显示选中文本的效果,只需要在把passText的属性改成textBox.SelectedText即可.
    这种方法的主要好处是在于,我们能在目标窗体的对象中,找到源窗体的对象。而有别与上面两种情况。

    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    --------------------------------------------------------------------------------------------------------------------------------------------------------
    实例一《构造传值方式》】
    在Form1和Form2中,将Form1中的输入值传递给Form2并显示于Form2:
    例如Form1中添加一个TextBox和Button控件,Form2中添加一个Textbox显示Form1的文本和Button控件点击关闭:
     
     
    Form1中添加【添加信息】的代码如 下:
     private void button1_Click(object sender, EventArgs e)
            {
                if (textBox1.Text.Trim()!="")
                {
                     Form2 form = new Form2( textBox1.Text.Trim());
                     form.ShowDialog();
                }
                else
                {
                    MessageBox.Show("请填写完整信息!");
                }
              
            }
    Form2中添加代码:
    namespace WindowsFormsApplication1
    {
        public partial class Form2 : Form
        {
            public Form2()
            {
                InitializeComponent();
            }
            /// <summary>
            /// 重构函数
            /// </summary>
            /// <param name="message">传递给Form2的TextBox文本编辑框中</param>
            public Form2(string message)
            {
                InitializeComponent();
                txtNumber.Text = message;
            }
            /// <summary>
            /// 公共字段
            /// </summary>
            private void btnOK_Click(object sender, EventArgs e)
            {
                this.Close();//关闭这个窗体
            }
    }
     
    实例2《公有字段传值方式》】

    和【实例1】一样,但是本例采用的是公有字段进行传值:

    在Form1中添加如下代码:

    (1)将private System.Windows.Forms.TextBox textBox2; 改为public。

    (2)

            /// <summary>
            /// 公有变量传递
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void button3_Click(object sender, EventArgs e)
            {
                Form2 f2 = new Form2(this);
                f2.ShowDialog();
            }
            /// <summary>
            /// 公共字段
            /// </summary>
            public string Msg
            {
                get
                {
                    return textBox2.Text.Trim();
                }
            }

    *************************************************************

    Form2 代码添加       

          public string Msg
            {
                get
                {
                    return txtNumber.Text.Trim();
                }
                set
                {
                    txtNumber.Text= value;
                }
            }
            public Form2(Form1 f1)
            {
                InitializeComponent();
                txtNumber.Text = f1.Msg;
            }

    【实例3】委托与事件传递 

    功能描述:与前面实例1和实例2不同的是,本实例实现在子窗体中改变父窗体的内容,通过委托和事件来传值给父窗体

     

    如上图所示,调用Form3中的按钮【启动调用Form4】,弹出Form4的窗体,修改Form4的窗体内容,点击【确认】则实现了修改父窗体Form3的内容。

    实现过程如下所示:

    在【Form3】中代码

    (1)定义一个结果对象,用来存放子窗体返回的结果,同时定义一个事件,可以让子窗体修改父窗体的状态。代码如下

        //声明delegate对象
        public delegate void TextChangedHandler(string s);

        public class CallObject
        {
            //用来存放子窗体返回的结果
            public string ResultValue = "";

            //定义事件对象,可以让子窗体修改父窗体的状态
            public event TextChangedHandler SelTextChanged;

            //以调用delegate的方式写事件触发函数
            public void ChangeSelText(string s)
            {
                if (SelTextChanged != null)
                {
                    //调用delegate
                    SelTextChanged(s);
                }
            }
        }

    (2)双击按钮【启动调用Form4】,激活事件

          private void btnCallF4_Click(object sender, EventArgs e)
            {
                CallObject co = new CallObject();

                //用+=操作符将事件添加到队列中
                co.SelTextChanged += new TextChangedHandler(EventResultChanged);
                Form4 f4 = new Form4(co);
                f4.ShowDialog();
                txtF4EventResult.Text = "Form4的返回值是:\r\n" + co.ResultValue;
            }
            //事件方法
            private void EventResultChanged(string s)
            {
                txtF4Select.Text = s;
            }
        }

    在【Form4】中的代码:

    (3)在子窗体添加一个构造函数,以便接收结果对象

    private CallObject co;
            public Form4(CallObject cov)
                : this()
            {
                this.co = cov;
            }

    (4)在子窗体改变选择,

      private void radbtn_A_CheckedChanged(object sender, EventArgs e)
            {
                co.ChangeSelText("A");
            }

            private void radbtn_B_CheckedChanged(object sender, EventArgs e)
            {
                co.ChangeSelText("B");
            }

            private void radbtn_C_CheckedChanged(object sender, EventArgs e)
            {
                co.ChangeSelText("C");
            }
            private void btnSend_Click(object sender, EventArgs e)
            {
                co.ResultValue = textBox1.Text;
                Close();
            }

     

    -------------------------------------------------------------------------------------------------


    【5】窗体间同步传值的实现,就是实时更新两个窗体间的信息,有心的朋友可能发现,既然能在目标窗体中,找到源窗体,那么我们还可以通过源窗体来控制目标窗体,从这里面突破,就能达到此效果了。代码如下还是依照4例:在Form1中:
    程序代码:

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

            public string passText
            {
                get {
                    return textBox1.SelectedText.Text;
                }
            }

            private void button1_Click(object sender, EventArgs e)
            {
                Form2 f2 = new Form2();
                f2.Owner = this;
                f2.Show();
            }

            private void Form1_Load(object sender, EventArgs e)
            {

            }

            private void textBox1_TextChanged(object sender, EventArgs e)
            {
                if(this.OwnedForms.Length != 0)
                (this.OwnedForms[0] as Form2).selectText = textBox1.Text;

    /*OwnedForms是一个数组,表示当前对象拥有的子窗体数组,同样要把通过下标得到的元素转换为Form2类型。*/
            }
        }
    }

    namespace WindowsApplication1
    {
        public partial class Form2 : Form
        {
            public string selectText
            {
                set
                {
                    textBox1.Text = value;   //
    设置一个属性,让form1操作
                }
            }

            public Form2()
            {
                InitializeComponent();
            }

            private void Form2_Load(object sender, EventArgs e)
            {
                textBox1.Text = ((Form1)this.Owner).passText;
            }
        }
    }

    最后,要说一下的是,在传值的时候,不光可以传变量属性,还有个很好的东西,每个窗体都有个 Tag 属性,是一个标记, object 类型的,我们可以把一个类赋给它。这样就为我们的代码,提供了极大的便利,大家可以依据上面 4 种传值方式,进行使用。
     
    部分参考《项目中的.NET》
    展开全文
  • c#中如何两个窗体间传递数据? 2011-06-04 12:54天若星尘 | 分类:C#/.NET | 浏览2397次 窗体A、B,A中有listbox1,B中有listbox2和按钮1。 首先打开窗体A,通过A上的另外一个按钮打开窗体B,窗体A不关闭...
  • Winform窗体间传递数据

    2014-03-26 13:02:59
    public string passText { get { return textBox1.Text; } } //Form1中还有个按钮button1其点击事件中有: private void button1_Click(object sender, EventArgs e) {
  • 窗体间传递复杂数据

    2011-07-01 10:40:00
    设计窗体程序时往往需要相互调用的窗体间传递复杂的数据,有时候甚至需要子窗体修改父窗体的内容。前一阵博客园中看到很多人讨论这个问题,海天一鸥《窗体间传值和窗体间互操作》的评论中,我看到有这么几种...
  • 上面描述的例子,就涉及到了一个父子窗体间数据传递。如何实现这一数据传递,当然有很多方法。这里只是记录一下这个例子中我使用的方法。我的方法是窗体点击“确定”按钮时,将操作结果构造成json格式的...
  • C# 窗体间数据传递

    2009-09-08 12:21:41
    C# 窗体间数据传递 有两个例子 初学者常常碰到这个问题
  • WinForm 窗体间传递数据的一些方法[转] 方法一 窗体中自定义一个构造函数,参数类型是主窗体,当要显示子窗体的时候,就用这个构造函数来实例化子窗体,然后把this指针传进去。代码如下: 主窗体....
  • C#中实现窗体间数据传递
  • C#中窗体间传递数据的几种方法

    千次阅读 2007-04-22 09:58:00
    经常会遇到C#中窗体间传递数据,搜了一下网上的资料,做一下汇总http://blog.donews.com/coolbo/archive/2005/05/29/403132.aspx一个稍微复杂一点的程序一般都有两个或者更多的窗体。有时程序设计中,数据不仅要...
  • 窗体间传递复杂数据

    千次阅读 2004-10-22 09:40:00
    窗体间传递复杂数据 源代码下载请点这里设计窗体程序时往往需要相互调用的窗体间传递复杂的数据,有时候甚至需要子窗体修改父窗体的内容。前一阵博客园中看到很多人讨论这个问题,海天一鸥《窗体间传值和窗体...
  • Microsoft Visual_C#_实现窗体间数据传递

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,367
精华内容 18,146
关键字:

如何在窗体间传递数据