少一分浮躁，多一分执著

在 c++ 或者 c 的源代码中，经常看到 extern "C"这样的写法，主要原因是各个编译器的名字改编方式不同，下面是来自:
http://blog.csdn.net/vinep/archive/2009/02/17/3899780.aspx 一篇原文，粘贴一下，已备查看。
 

以int func(int, int)为例，C的编译器会将名字改编为_func, 而C++的编译器会改编为_func_int_int 或_funcii（各编译器不同）。如果这个函数在C中编译成库，目标文件中函数名为_func,当这个函数中C++中被调用时，C++的编译器就会到目标文件中寻找_funcii，结果找不到，出错。所以为了防止这种问题，在C++调用时，将函数声明前加个extern "C" 告诉C++的编译器，不要对名字再进修饰，而直接去找_func。因为C、C++的编译器对函数名的修饰不同，为了保证在C、C++中编写的函数能够被互相调用，所以采用这个

链接指示符

同样在C++中编译的函数，如果想让C来使用，通常也加上extern "C"在编译时将函数名按C的风格进行修饰。通常C中编写的函数如果有在其它语言中使用的可能，通常会有下面形式的声明：#ifdef  __cplusplusextern "C" {#endif/**** some declaration or so *****/#ifdef  __cplusplus    }#endif  /* end of __cplusplus */即在声明时已经加上extern "C" 而不需要调用时麻烦。例如在VC++中调用C的库函数就不用作特别的声明。extern "C"的使用要点

1. 可以是单一语句
    extern "C" double sqrt(double);
2. 可以是复合语句, 相当于复合语句中的声明都加了extern "C"
    extern "C"
   {
      double sqrt(double);
      int min(int, int);
  }
3.可以包含头文件，相当于头文件中的声明都加了extern "C"
   extern "C"
  {
    ＃i nclude <cmath>
  }
4. 不可以将extern "C" 添加在函数内部
5. 如果函数有多个声明，可以都加extern "C", 也可以只出现在第一次声明中，后面的声明会接受第一个链接指示符的规则。
6. 除extern "C", 还有extern "FORTRAN" 等。

用户交互操作最好描述为控件创建和响应的各种事件。一些比较常见的事件有Click、DoubleClick、KeyDown、KeyPress、Validating和Paint。

鼠标事件Click、DoubleClick、MouseDown、MouseUp、MouseEnter、MouseLeave和 MouseHover处理鼠标和控件的交互操作。如果处理Click和DoubleClick事件，每次捕获一个DoubleClick事件时，也会引发 Click事件。如果处理不正确，就会出现我们不希望的结果。Click和DoubleClick事件都把EventArgs作为其参数，而 MouseDown和MouseUp事件把MouseEventArgs作为其参数。MouseEventArgs包含几个有用的信息，例如单击的按钮、 按钮被单击的次数、鼠标轮制动器(鼠标轮上的凹槽)的数目和鼠标的当前XY坐标。如果可以访问这些信息，就必须处理MouseDown或MouseUp事 件，而不是Click或DoubleClick事件。

键盘事件的工作方式与此类似：需要一些信息来确定处理什么事件。对于简单的情况，KeyPress事件接收一个 KeyPressEventArgs，它包含表示被按键的字符值KeyChar。Handled属性用于确定事件是否已处理。把Handled属性设置为 true，事件就不会由操作系统进行默认处理。如果需要被按的键的更多信息，则处理KeyDown或KeyUp事件会比较合适。它们都接收 KeyEventArgs。KeyEventArgs中的属性包括Ctrl、Alt或Shift键是否被按下。KeyCode属性返回一个Keys枚举 值，表示被按下的键。与KeyPressEventArgs.KeyChar不同，KeyCode属性指定键盘上的每个键，而不仅仅是字母数字键。 KeyData属性返回一个Key值，还设置修饰符。修饰符与值进行OR运算，指定是否同时按下了Shift或Ctrl键。KeyValue属性是 Keys枚举的整数值。Modifiers属性包含一个Keys值，它表示被按下的修饰符键。如果选择了多个修饰符键，这些值就进行OR运算。键盘事件以 下述顺序来引发：

(1) KeyDown

(2) KeyPress

(3) KeyUp

Validating、Validated、Enter、Leave、GotFocus和LostFocus事件都处理获得焦点(或被激活)和失去 焦点的控件。在用户用tab键选择一个控件或用鼠标选择该控件时，该控件就获得了焦点。Enter、Leave、GotFocus和LostFocus事 件的功能似乎非常类似。GotFocus和LostFocus事件是低级事件，与Windows消息WM_SETFOCUS和WM_KILLFOCUS相 关。一般应尽可能使用Enter和Leave事件。Validating和Validated事件在验证控件时发生。这些事件接收一个 CancelEventArgs，利用该参数，把Cancel属性设置为true，就可以取消以后的事件。如果定制了验证代码，而且验证失败，就可以把 Cancel属性设置为true，且控件也不会失去焦点。Validating事件在验证过程中发生，Validated事件在验证过程后发生。这些事件 的引发顺序如下：

(1) Enter

(2) GotFocus

(3) Leave

(4) Validating

(5) Validated

(6) LostFocus

理解这些事件的引发顺序是很重要的，可以避免不小心创建递归事件。例如，在控件的LostFocus事件中设置控件的焦点，就会创建一个消息死锁，且应用程序会停止响应。

((((留存 )))))))

一个端口扫描程序就是对一段区域内的端口进行连接测试，如果能够连接上则标识这个端口是开放的。为了简化程序，我只是TCP连接方式的 端口进行扫描。为了加快扫描速度，我需要使用多线程，用ThreadPool对线程进行维护。

首先，定义一个端口扫描的类，该类实现对指定地址、指定端口进行扫描，并将扫描的结果（能、不能连接）保存 ，代码如下：（注意，为了加快端口扫描的速度，我对 Socket 的Connect采用异步方式，而信号灯等待1秒仍然没有得到结果，就认为没有连接到对方主机）

Code
using System;
using System.Collections.Generic;
using System.Text;

using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace PortScaner
{
    public class PortScaner
    {
        private ManualResetEvent manualEvent;
        private string hostName;
        private bool connected;
        private int port;

        public bool Connected {
            get { return connected; }
        }

        public string HostName {
            get { return hostName; }
            set { hostName = value; }
        }
        

        public int Port {
            get { return port; }
            set { port = value; }
        }

        public PortScaner(string hostName, int port) {
            this.hostName = hostName;
            this.port = port;
            this.connected = false;
            manualEvent = new ManualResetEvent(false);
        }


        /// <summary>
        /// 扫描指定主机的指定端口
        /// </summary>
        /// <returns></returns>
        public void  Scan( ) {

            Socket s = null;
            manualEvent.Reset();
            try {
                s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                s.BeginConnect(this.hostName, this.port, new AsyncCallback(EndConnected), s);
                if (manualEvent.WaitOne(1000, false) == true) {
                    connected = s.Connected;
                }
                else {
                    connected = false;
                }
            }
            catch (Exception ) {
                connected = false;
            }
            finally {
                if (s != null) {
                    s.Close();
                    s = null;
                }
            }
        }

        public void  EndConnected(IAsyncResult ar) {
            try {
                Socket sk = (Socket)ar.AsyncState;
                sk.EndConnect(ar);
            }
            catch (Exception) {
                connected = false;
            }
            finally {
                manualEvent.Set();
            }
        }
    }
}

 接下来就是，在多线程的环境中执行Scan了，代码如下：

Code
using System;
using System.Collections.Generic;
using System.Text;

using System.Threading;

namespace PortScaner
{
    public class MyThreadState
    {
        private PortScaner portScaner;
        private AutoResetEvent autoEvent;

        public PortScaner PortScaner {
            get { return portScaner; }
            set { portScaner = value; }
        }        

        public AutoResetEvent AutoEvent {
            get { return autoEvent; }
            set { autoEvent = value; }
        }

        public MyThreadState(PortScaner portScaner, AutoResetEvent autoEvent) {
            this.portScaner = portScaner;
            this.autoEvent = autoEvent;
        }


    }

    public class PortScanerManager
    {
        private string hostName;
        private int startPort;
        private int endPort;
        private int maxThread;        

        #region 属性和构造函数

        public string HostName {
            get { return hostName; }
            set { hostName = value; }
        }        

        public int StartPort {
            get { return startPort; }
            set { startPort = value; }
        }        

        public int EndPort {
            get { return endPort; }
            set { endPort = value; }
        }        

        public int MaxThread {
            get { return maxThread; }
            set {
                if (value > 25)
                    maxThread = 25;
                else 
                    maxThread = value; 
            }
        }
        
        public PortScanerManager(string hostName) {
            this.hostName = hostName;
            this.startPort = 100;
            this.endPort = 2000;
            this.maxThread = 25;
        }

        public PortScanerManager(string hostName, int startPort, int endPort) {
            this.hostName = hostName;
            this.startPort = startPort;
            this.endPort = endPort;
            this.maxThread = 25;
        }
        #endregion

        public List<int> Start() {

            List<PortScaner > scaners = new List<PortScaner >();
            WaitCallback callBack = new WaitCallback(ThreadWork);

            if (maxThread > endPort - startPort) {
                maxThread = endPort - startPort;
            }           
            ThreadPool.SetMaxThreads(maxThread, maxThread + 10);

            int runingThread = 0;
            int curPort = startPort;

            while (runingThread < endPort - startPort) {
                int needThread = (endPort - curPort) > maxThread ? maxThread : (endPort - curPort);

                AutoResetEvent[] autoEvents = new AutoResetEvent[needThread];
                for (int i = 0; i < needThread; i++) {
                    PortScaner scaner = new PortScaner(this.hostName, curPort);
                    scaners.Add(scaner);

                    autoEvents[i] = new AutoResetEvent(false);
                    MyThreadState state = new MyThreadState(scaner, autoEvents[i]);
                    ThreadPool.QueueUserWorkItem(callBack, state);

                    curPort++;
                    runingThread++;
                }

                WaitHandle.WaitAll (autoEvents);
            }       
    
            List<int> result = new List<int> ();
            for (int i = 0; i < scaners.Count; i++) {
                if (scaners[i].Connected == true)
                    result.Add(scaners[i].Port);
            }
            return result;
        }


        private void ThreadWork(object state) {

            ((MyThreadState )state).PortScaner .Scan();
            ((MyThreadState)state).AutoEvent.Set();
        }
    }
}

呵呵，这里用了比较 bt 的办法， WaitHandle.WaitAll (autoEvents);这是为了前面讲的原理写的，而为了不那么bt可以采用推拉窗技术。

好了，就说了这么多，一则希望能对大家有所帮助，二则希望自己将来写程序的时候，能够很快的进入状态。

   很久没有接着写这个系列的东西了，自己拿起来，还有些恍惚，因为有二年多的时间没有进行代码的编写了。

 上次解决了如何象线程传入参数，但是没有解决在主线程中获取发生了变化的参数的问题，引起这个问题的原因有两个：

1、线程池中的线程的启动、终止不是由我们设计的程序来控制的；

2、线程池中的线程执行完成后是没有返回值的。（这实际上与操作系统的线程调度和内存分配策略有关）

所以要想取得返回值，就需要解决这两个问题。

对于第一个问题，我们很容易想到操作系统提供的一种机制 “信号灯”（也有叫“信号量”、“信号”的），操作系统提供的这种机制允许进程之间进行通讯，呵呵，这样我们就可以让子线程与主线程进行通讯了。

对于第二个问题，由于线程没有返回值，我们可以传递给线程的参数中设置一个字段用于存储返回值，也可以通过通过获取 WaitCallBack 方法所在类的属性来获取（当然，在线程中这个属性是对其进行了改变的）。

现在，简单的说一下“信号灯”机制，打一个跟厕所有关的比喻，（不是很雅^_^），在火车上，当A上厕所的时候，他会将厕所的门锁上，对外标识一个“有人”的表示，当他解决完以后，他会打开门，“有人”的标识就会变成“无人”的标识，这样B就可以进去了，而如果A不把这个标识改变，B就算憋死也进不去的。（当然暴力方式排除在外）。C# 提供的 AutoResetEvent就是这样一种“信号灯”，定义这个类的变量，并传递到子线程，在子线程将结束时，将该“信号灯”设置为 true(“无人”）状态，这样主线程就可以进入了（开始执行）。

同样，我们还有上公共厕所的经历，在公共厕所了有很多个便池，当然还有一个厕所管理员，这时，A1,A2,A3……就可以在厕所管理员这里领取一个牌匾，同时进去解决“问题”， 如果，厕所管理员不是很bt，当A1出来的时候，他会放B1进去，但是也有Bt的，非得等到A1,A2,A3……都解决问题了，才让B1,B2,……进去，这就是WaitHandle.WaitAll()和WaitHandle.WaitAny(),WaitHandle.WaitOne()的区别，这是可以使用ManualResetEvent的“信号灯”

当然，还有一些线程之间也会争用资源，要达到同步的话，可以使用Monitor,Mutex的“信号灯”。

总之，信号灯机制提供了一个对子线程与主线程，子线程与子线程之间进行通讯的机制，这些通讯机制的共同特点是某个线程释放了资源（给出一个信号），其他的线程（主线程）才开始执行。

接着，我用一个端口扫描的程序来具体说明一下。

在VS2005中希望Label标签实现换行的功能：

直接在修改代码，Label.Text ="www\r\nyyyyyy",这样Label中就会显示成如下样式：

www

yyyyyy

切忌不能在设计器中输入"\r\n"这样的字符，它会直接显示成 如下样式：

 www\r\nyyyyyy，也就是在设计器中不对转义字符进行处理。

在VS2005中希望 .resx 文件中的字符串分行显示，采用"shift+回车”对字符串进行分行。

同样，在.resx文件中不会对转义字符进行处理。