请问如何在嵌套类里面访问外部类的非静态成员？谢谢

Question

我在一个Form1类里面定义了一个线程类
大概结构如下：namespace autologin
{
    public partial class Form1 : Form
    {
         public Form1()
        {
            InitializeComponent();
            Label1.Text = "想要被线程调用";
        }
        //下面是一个线程类
        public class checkFlowThread
        {
            public checkFlowThread()
            {
            }
            public void checkFlow()
            {
                 Form1.Label.Text = "想访问外部类的非静态成员";
            }                    
        } 
    }
}
由于Label1是设计器自动生成的，改为静态会产生一些问题，
那么如果不把Label1改为静态的话，我应该怎么在内部类访问它呢？
也就是如何在内部类访问外部类的非静态成员？
或者应该怎么设计线程类，使得它可以更改外部类的成员？
谢谢！
编译时出现这种错误：非静态的字段、方法或属性“autologin.Form1.Label1”要求对象引用。

Answer 1

namespace autologin
{
    public partial class Form1 : Form
    {
         public Form1()
        {
            InitializeComponent();
            Label1.Text = "想要被线程调用";
        }public string LabelText
{
get
{
retrun Label.Text;
}
set
{
Label.Text = value;
}
}
        //下面是一个线程类
        public class checkFlowThread
        {
            public checkFlowThread()
            {
            }
            public void checkFlow()
            {
                 LabelText = "想访问外部类的非静态成员";
            }                    
        } 
    }
}

Answer 2

这样还是提示：
无法通过嵌套类型“autologin.Form1.checkFlowThread”来访问外部类型“autologin.Form1”的非静态成员.

Answer 3

delegate void ADelegate();
event ADelegate AEvent;
private void Form1_Load(object sender, EventArgs e)
        {
            AEvent += new ADelegate(A);
            Thread myThread = new Thread(new ThreadStart(this.ListenPort));
            myThread.Start();
        }        private void A()
        {
            Label1.Text="";      
        }
        private void ListenPort()
        {
            if (this.InvokeRequired)
            {
                this.Invoke(AEvent);
            }
            else
            {
                Label1.Text="";                
            }
        }http://topic.csdn.net/u/20100118/16/f2e535d6-0ff6-4025-9220-34b02739662a.html

Answer 4

Msdn上说:
嵌套类型（或内部类型）可访问包含类型（或外部类型）。若要访问包含类型，请将其作为构造函数传递给嵌套类型。例如：public class Container
{
    public class Nested
    {
        private Container m_parent;        public Nested()
        {
        }
        public Nested(Container parent)
        {
            m_parent = parent;
        }
    }
}据此,你的代码更改如下:
public class checkFlowThread
        {
            Form1 form1;
            public checkFlowThread(Form1 f)
            {
               this.form1=f;
            }
            public void checkFlow()
            {
            form1.Label.Text = "想访问外部类的非静态成员";
            }                    
        } 
 嵌套类型可访问包含类型的私有成员和受保护的成员（包括所有继承的保护的成员)  

Answer 5

这样的话，出现以下异常：
线程间操作无效: 从不是创建控件“Label1”的线程访问它。

Answer 6

我照着这种方法使用了以下的委托，但是还是提示错误: 无法通过嵌套类型“autologin.Form1.checkFlowThread”来访问外部类型“autologin.Form1”的非静态成员。
我的代码如下，不知道有什么问题呢？namespace autologin
{
    public delegate void ChangeLabel(string lbinfo);//代理
    public partial class Form1 : Form
    {
         Thread checkflowthread = null;//检测流量的线程 
         ChangeLabel changelabel = null;//创建一个代理（委托)
        public Form1()
        {
            InitializeComponent();
        }
        private void Form1_Load(object sender, EventArgs e)
        {
            changelabel = new ChangeLabel(ChangeLabelText);
        }
        //让代理（委托）调用此方法修改lbinfo的值，实现跨线程访问控件成员
        private void ChangeLabelText(string lbinfo)
        {
            if (this.lbinfo.InvokeRequired)
            { //调用方在另外一个线程中
                //在拥有此控件的线程上执行委托指向的方法
                this.Label1.Invoke(changelabel, lbinfo);
            }
            else
            {//调用方在当前线程中
                this.Label1.Text = lbinfo;
            }
        }
        //下面是一个线程类
         public class checkFlowThread
        {
            public checkFlowThread()
            {
            }
            public void checkFlow()
            {
                 ChangeLabelText("想访问外部类的非静态成员");//提示错误：无法通过嵌套类型“autologin.Form1.checkFlowThread”来访问外部类型“autologin.Form1”的非静态成员
            }                    
        } 
}

Answer 7

我这边实现了，你看看这样行不？
public delegate void DoEvent();    public partial class Form1 : Form
    {
        checkFlowThread td;
        DoEvent toDo;        public Form1()
        {
            InitializeComponent();
            toDo = new DoEvent(checkFlow);
            if (td == null)
                td = new checkFlowThread(this);
            this.Load += (sender, e) =>
                {
                    checkFlow();
                };
        }        private void checkFlow()
        {
            if (this.InvokeRequired)
            {
                this.Invoke(toDo);
            }
            else
            {
                td.checkFlow();
            }
        }        //下面是一个线程类
        public class checkFlowThread
        {
            Form1 from;
            public checkFlowThread(Form1 f)
            {
                from = f;
                DoEvent todo = new DoEvent(checkFlow);
            }            public void checkFlow()
            {                from.label1.Text = "想访问外部类的非静态成员";
            }
        }
    }