在一个控件中修改另一个控件的属性.docx

在一个窗体中设置另一个窗体的控件属性
分类： c#2008-10-13 20:05 1016人阅读 评论(0) 收藏 举报
textboxbuttonstringnull
 最经有学生问我怎么样在一个窗体中设置另一个窗体的控件属性，问题如下：
有两个form. 
一个form1,一个form2. 
怎么样在form2中用代码设置form1的textbox的属性
我考虑了有如下两种方法：

一、
1、在form1类中定义一个静态数据成员，来保存当前窗体对象， 
如下：  public static Form1 f1 = null; 
2、  然后在form1窗体构造函数中，给上述静态成员初始化，如下：      
public Form1() 
        { 
            InitializeComponent(); 
            p1 = this; 
        } 
3、  在form2中调用form1，可以通过如下方式： 
”Form1.f1”， 
例如：  Form1.f1.textBox1.Text="你想设置的值"; 
以上所做的，只是让你能够访问当前form1对象或form2窗体对象，如果想操作控件，可以直接修改控件的成员访问符，即可以把”private”修改成”public”。当然最好的还是可以用增加公有属性的做法，这样不会破坏类本身的封装。 
如下： 
public string Text_Box 
        { 
            get { return textBox1.Text; } 
            set { textBox1.Text = value; } 
        }    

在form2的button_click事件中添加 
Form1.p1.Text_Box = "你想设置的值"; 
这样就ok了！

源代码如下
Form1的代码：
1. using System;
2. using System.Collections.Generic;
3. using System.ComponentModel;
4. using System.Data;
5. using System.Drawing;
6. using System.Linq;
7. using System.Text;
8. using System.Windows.Forms;
9.
10. namespace WindowsFormsApplication1
11. {
12.     public partial class Form1 : Form
13.     {
14.         public static Form1 p1 = null;
15.         public Form1()
16.         {
17.             InitializeComponent();
18.             p1 = this;
19.         }
20.
21.         private void button1_Click(object sender, EventArgs e)
22.         {
23.             Form2 fr2 = new Form2();
24.             fr2.Show();
25.         }
26.
27.         public void setvalue(string a)
28.         {
29.             textBox2.Text = a;
30.         }
31.
32.         public string Text_Box 
33.         { 
34.             get { return textBox2.Text; }
35.             set { textBox2.Text = value; }
36.         }
37.     }
38. }
39.
Form2的代码：

15. using System;
16. using System.Collections.Generic;
17. using System.ComponentModel;
18. using System.Data;
19. using System.Drawing;
20. using System.Linq;
21. using System.Text;
22. using System.Windows.Forms;
23.
24. namespace WindowsFormsApplication1
25. {
26.     public partial class Form2 : Form
27.     {
28.         public Form2()
29.         {
30.             InitializeComponent();
31.         }
32.
33.         private void button1_Click(object sender, EventArgs e)
34.         {
35.             Form1.p1.Text_Box = "aaaa";
36.         }
37.     }
38. }
 二、在Form1中定一个public方法和一个按钮事件（打开Form2）
40. //public方法用于修改TextBox的值
41. public void SetTextBox(string strValue)
42. {
43.     this.textBox1.Text = strValue;
44. }
45.
46. //按钮事件
47. private void button1_Click(object sender, System.EventArgs e)
48. {
49.     Form2 f = new Form2();
50.     f.Tag = this; //把Form1的实例传给Form2实例f的Tag属性
51.     f.Show();
52. }
53.
Form2中的按钮事件
60. private void button1_Click(object sender, System.EventArgs e)
61. {
62.     Form1 f = (Form1)this.Tag;//获取Form1实例
63.     f.SetTextBox("去修改Form1中的TextBox的值");//调用Form1的public方法修改Form1中TextBox的值
64. }
65.
以上仅供参考，可能还有别的办法。
C# 操作内存是如何实现的呢？让我们开始讲解吧：
我们先来看看C#中如何操作内存，也就是非托管的数据。这需要引用System.Runtime.InteropServices命名空间。该命名空间下的Marshal的一些静态方法提供了这样的功能：
1. Marshal.ReadInt32()  
2. //从指定内存地址读取4位 C#操作内存  
3. Marshal.PtrToStringAnsi()  
4. //从指定内存地址读取字符串C#操作内存   
5. Marshal.WriteInt32()  
6. //将整数写到指定内存地址 C#操作内存  
7. Marshal.WriteByte()  
8. //将字符串写到指定内存地址我们来看看具体的代码：   
9. using System;   
10. using System.Text;   
11. using System.Runtime.InteropServices;   
12.  
13. internal sealed class RCEvent {   
14. public int Event;   
15. public int Flag;   
16. public string User;   
17. };   
18.  //C#操作内存
19. internal sealed class RCEventAgent {   
20. internal static RCEvent Read(IntPtr ptr){   
21. RCEvent Event = new RCEvent();   
22.    
23. Event.Event = ReadEvent(ptr);   
24. Event.Flag = ReadFlag(ptr);   
25. Event.User = ReadUser(ptr);   
26.  
27. return Event;   
28. }   
29.  //C#操作内存
30. internal static int ReadEvent(IntPtr basePtr) {   
31. return Marshal.ReadInt32(basePtr);   
32. }   
33. internal static int ReadFlag(IntPtr basePtr) {   
34. return Marshal.ReadInt32(basePtr,4);   
35. }   
36. internal static string ReadUser(IntPtr basePtr) {   
37. return Marshal.PtrToStringAnsi(  
38. new IntPtr(basePtr.ToInt32() + 8));   
39. }   
40.  
41. internal static void Write(ClientEvent Event,IntPtr ptr) {   
42. WriteEvent(ptr,Event.Event);   
43. WriteFlag(ptr,Event.Flag);   
44. WriteUser(ptr,Event.User);   
45. }   
46.  //C#操作内存
47. internal static void WriteEvent(  
48. IntPtr basePtr,int value) {   
49. Marshal.WriteInt32(basePtr,value);   
50. }   
51. internal static void WriteFlag(  
52. IntPtr basePtr,int flag) {   
53. Marshal.WriteInt32(basePtr,4,flag);   
54. }   
55. internal static void WriteUser(  
56. IntPtr basePtr,string user) {   
57. WriteString(basePtr,user,8,40);   
58. }   
59. private static void WriteString(  
60. IntPtr basePtr,string value,int offset,int length) {   
61. int pos = 0;   
62. byte[] bytes = Encoding.Default.GetBytes(value);   
63. while(pos ﹤ length) {   
64. if (pos ﹤ bytes.Length)   
65. Marshal.WriteByte(basePtr,offset,bytes[pos]);   
66. else   
67. Marshal.WriteByte(basePtr,offset,0);   
68.  
69. pos ++;   
70. offset ++;   
71. }   
72. }   //C#操作内存
73. } 
这样我们就可以通过ReadEvent和WriteEvent直接在c#中处理该结构体。或者通过 ReadXXX() 和 WriteXXX() 直接修改其字段。
74. public void DoSomething(IntPtr ptr){   
75. RCEvent Event = RCEventAgent.Read(ptr);   
76. Event.Flag ++;   
77. RCEventAgent.Write(ptr, Event);   
78.  
79. // 或者以下代码   
80. // RCEventAgent.WriteFlag( ptr, RCEventAgent.ReadFlag(ptr) + 1 );   
81. } 
C++中则可以直接将结构体地址传给C#：
82. #using   ﹤mscorlib.dll﹥   
83. #using   ﹤CuteSuProc.dll﹥   
84.  
85. void SomeMethod(RCEStruct* pEventStruc){   
86. MyCSharpDll::DoSomething(pEventStruc);   
87. } 

C#操作内存读写方法是什么呢？让我们来看看具体的实例实现：
1. using System.Runtime.InteropServices;  
2. using System.Text;  
3. public class Function  
4. {  
5.  //C#操作内存读写方法
6. public static byte PtrToByte( int Ptr )  
7. {  
8. byte b = Marshal.ReadByte( ( IntPtr ) Ptr );  
9.  
10. return b;  
11. }  
12.  
13. public static char PtrToChar( int Ptr )  
14. {  
15. byte b = Marshal.ReadByte( ( IntPtr ) Ptr );  
16.  
17. return ( char ) b;  
18. }  
19.  
20. public static short PtrToShort( int Ptr )  
21. {  
22. short b = Marshal.ReadInt16( ( IntPtr ) Ptr );  
23.  
24. return b;  
25. }  
26.  //C#操作内存读写方法
27. public static ushort PtrToUShort( int Ptr )  
28. {  
29. ushort b = ( ushort ) Marshal.ReadInt16( ( IntPtr ) Ptr );  
30.  
31. return b;  
32. }  
33.  
34. public static int PtrToInt( int Ptr )  
35. {  
36. int b = Marshal.ReadInt32( ( IntPtr ) Ptr );  
37.  
38. return b;  
39. }  
40.  
41. public static uint PtrToUInt( int Ptr )  
42. {  
43. uint b = ( uint ) Marshal.ReadInt32( ( IntPtr ) Ptr );  
44.  
45. return b;  
46. }  
47.  
48. public static long PtrToLong( int Ptr )  
49. {  
50. long b = Marshal.ReadInt64( ( IntPtr ) Ptr );  
51.  
52. return b;  
53. }  //C#操作内存读写方法
54.  
55. public static ulong PtrToULong( int Ptr )  
56. {  
57. ulong b = ( ulong ) Marshal.ReadInt64( ( IntPtr ) Ptr );  
58.  
59. return b;  
60. }  
61.  
62.  
63. // Convert an ip address stored an address to equivalent string value  
64. public static string GetPtrToIpAddr(int intPtr, int varlen)  
65. {  
66. int i = 0;  
67. StringBuilder sb = new StringBuilder(0,varlen*4);  
68. byte[] byx = new byte[varlen];  
69.  
70. // ip address cann't have zero value C#操作内存读写方法  
71. // ip address cann't have zero length C#操作内存读写方法
72. if( ( intPtr == 0 ) || ( varlen == 0 ) ) return "";  
73. Marshal.Copy( ( IntPtr ) intPtr , byx , 0 , varlen );  
74. for( i = 0; i < varlen - 1; i ++ )  
75. {  
76. sb.Append(byx[i]);  
77. sb.Append('.');  
78.  
79. }  
80. sb.Append(byx[varlen - 1]);  
81.  
82. return sb.ToString();  
83.  
84. }  
85.  
86. }