Oxite 是微软近期发布了一个开源CMS或博客平台，关于Oxite 系统的基本介绍，请参考文章 – 微软发布Oxite开源CMS博客平台。

 

这里，EntLib.com 开源论坛小组一步一步详细介绍如何编译、调试和部署 Oxite 系统。假设你的系统已经有SQL Server 2005 和 Visual Studio 2008。

 

ASP.NET MVC下载地址：

 

如果你之前有安装 ASP.NET MVC 的前期版本，则你需要先下载早期的版本。ASP.NET MVC 的安装过程很简单，这里就不具体介绍了。

关于ASP.NET MVC 的介绍，推荐你阅读如下文章：

 

下载地址：http://www.codeplex.com/oxite/

展开压缩文件，通过 Visual Studio 2008 打开Oxite.sln 项目文件。先看看项目文件：
 

 

接下来，设置 OxiteSite 项目为启动项目（Set as Startup Project）。编译整个Oxite 项目，整个项目编译通过。到现在，一切都很顺利。

 

但是，当你运行OxiteSite 项目时，Visual Studio 2008 会提示你Deploy Failed-发布失败。仔细看看，这是Oxite.Database 项目产生的。

 

最简单的解决办法是，右键单击Oxite.Database项目，选择 Unload Project 或者 Remove 菜单项，如下图所示。
 

 

现在，你再次运行Oxite 项目，发现可以正常运行了，并且显示如下运行界面。
 

 

Oxite.Database 项目到底有什么用呢？这里，Oxite.Database 项目用来创建Oxite 数据库，由于OxiteSite Web项目采用的是SQL Server Express进行 Oxite 数据库连接。数据库连接字符串Connection String 如下：

 

默认，数据库文件存放在\OxiteSite\App_Data 目录下。所以，上面的Oxite.Database 项目可以直接Unload 或者 Remove。

 

如果你想通过Oxite.Database 直接在SQL Server 2005 创建一个Oxite 的数据库，你也可以按照如下的步骤，轻松创建Oxite数据库。

首先，需要修改Oxite.Database 项目的一些设置，如下图所示：

(1) 设置Default collation 属性为 Chinese_PRC_CI_AS，采用中文字符集。
 

 

(2) 正确设置Oxite.Database 项目的Target database name 属性为：Oxite。同时，设置Default location for target database files – 默认数据库文件存放位置属性为：c:\Program Files\Microsoft SQL Server\MSSQL.1\MSSQL\DATA\。这一属性根据实际情况，可以设置为其他路径。
具体设置信息如下图所示：
 

 

现在，编译、部署Oxite.Database 项目就可以正确通过了。此时，你可以进一步修改OxiteSite 项目中的web.config 配置文件，修改其中的数据库连接字符串 Connection String。如下所示：

 

现在，重新编译、运行OxiteSite 项目，数据库连接到 SQL Server 2005 中的Oxite 数据库了，而不是先前的SQL Server express 的Oxite.Database.mdf 数据库文件。

 

本文由http://forum.entlib.com 开源论坛小组提供，欢迎交流、讨论、分享。

 

1. 微软发布Oxite开源CMS博客平台

 

2. Oxite 配置入门文章

 

3. Microsoft ASP.NET MVC Preview 5 及LINQ TO SQL最新版开发示例演示（提供源码下载）

源码下载：http://www.tracefact.net/SourceCode/CSharp-Chat.rar

C#编写简单的聊天程序

引言

这是一篇基于Socket进行网络编程的入门文章，我对于网络编程的学习并不够深入，这篇文章是对于自己知识的一个巩固，同时希望能为初学的朋友提供一点参考。文章大体分为四个部分：程序的分析与设计、C#网络编程基础(篇外篇)、聊天程序的实现模式、程序实现。

程序的分析与设计

1.明确程序功能

如 果大家现在已经参加了工作，你的经理或者老板告诉你，“小王，我需要你开发一个聊天程序”。那么接下来该怎么做呢？你是不是在脑子里有个雏形，然后就直接 打开VS2005开始设计窗体，编写代码了呢？在开始之前，我们首先需要进行软件的分析与设计。就拿本例来说，如果只有这么一句话“一个聊天程序”，恐怕 现在大家对这个“聊天程序”的概念就很模糊，它可以是像QQ那样的非常复杂的一个程序，也可以是很简单的聊天程序；它可能只有在对方在线的时候才可以进行 聊天，也可能进行留言；它可能每次将消息只能发往一个人，也可能允许发往多个人。它还可能有一些高级功能，比如向对方传送文件等。所以我们首先需要进行分 析，而不是一上手就开始做，而分析的第一步，就是搞清楚程序的功能是什么，它能够做些什么。在这一步，我们的任务是了解程序需要做什么，而不是如何去做。

了解程序需要做什么，我们可以从两方面入手，接下来我们分别讨论。

1.1请求客户提供更详细信息

我 们可以做的第一件事就是请求客户提供更加详细的信息。尽管你的经理或老板是你的上司，但在这个例子中，他就是你的客户（当然通常情况下，客户是公司外部委 托公司开发软件的人或单位）。当遇到上面这种情况，我们只有少得可怜的一条信息“一个聊天程序”，首先可以做的，就是请求客户提供更加确切的信息。比如， 你问经理“对这个程序的功能能不能提供一些更具体的信息？”。他可能会像这样回答：“哦，很简单，可以登录聊天程序，登录的时候能够通知其他在线用户，然 后与在线的用户进行对话，如果不想对话了，就注销或者直接关闭，就这些吧。”

有了上面这段话，我们就又可以得出下面几个需求：

1. 程序可以进行登录。
2. 登录后可以通知其他在线用户。
3. 可以与其他用户进行对话。
4. 可以注销或者关闭。

1.2对于用户需求进行提问，并进行总结

经常会有这样的情况：可能客户给出的需求仍然不够细致，或者客户自己本身对于需求就很模糊，此时我们需要做的就是针对用户上面给出的信息进行提问。接下来我就看看如何对上面的需求进行提问，我们至少可以向经理提出以下问题：

NOTE：这里我穿插一个我在见到的一个印象比较深刻的例子：客户往往向你表达了强烈的意愿他多么多么想拥有一个属于自己的网站，但是，他却没有告诉你网站都有哪些内容、栏目，可以做什么。而作为开发者，我们显然关心的是后者。

1. 登录时需要提供哪些内容？需不需要提供密码？
2. 允许多少人同时在线聊天？
3. 与在线用户聊天时，可以将一条消息发给一个用户，还是可以一次将消息发给多个用户？
4. 聊天时发送的消息包括哪些内容？
5. 注销和关闭有什么区别？
6. 注销和关闭对对方需不需要给对方提示？

由于这是一个范例程序，而我在为大家讲述，所以我只能再充当一下客户的角色，来回答上面的问题：

1. 登录时只需要提供用户名称就可以了，不需要输入密码。
2. 允许两个人在线聊天。（这里我们只讲述这种简单情况，允许多人聊天需要使用多线程）
3. 因为只有两个人，那么自然是只能发给一个用户了。
4. 聊天发送的消息包括：用户名称、发送时间还有正文。
5. 注销并不关闭程序，只是离开了对话，可以再次进行连接。关闭则是退出整个应用程序。
6. 注销和关闭均需要给对方提示。

好了，有了上面这些信息我们基本上就掌握了程序需要完成的功能，那么接下来做什么？开始编码了么？上面的这些属于业务流程，除非你对它已经非常熟悉，或者程序非常的小，那么可以对它进行编码，但是实际中，我们最好再编写一些用例，这样会使程序的流程更加的清楚。

1.3编写用例

通常一个用例对应一个功能或者叫需求，它是程序的一个执行路径或者执行流程。编 写用例的思路是：假设你已经有了这样一个聊天程序，那么你应该如何使用它？我们的使用步骤，就是一个用例。用例的特点就每次只针对程序的一个功能编写，最 后根据用例编写代码，最终完成程序的开发。我们这里的需求只有简单的几个：登录，发送消息，接收消息，注销或关闭，上面的分析是对这几点功能的一个明确。 接下来我们首先编写第一个用例：登录。

在开始之前，我们先明确一个概念：客户端，服务端。因为这个程序只是在两个人（机器）之间聊天，那么我们大致可以绘出这样一个图来：

我们期望用户A和用户B进行对话，那么我们就需要在它们之间建立起连接。尽管“用户A”和“用户B”的地位是对等的，但按照约定俗称的说法：我们将发起连接请求的一方称为客户端（或叫本地），另一端称为服务端（或叫远程）。所以我们的登录过程，就是“用户A”连接到“用户B”的过程，或者说客户端（本地）连接到服务端（远程）的过程。在分析这个程序的过程中，我们总是将其分为两部分，一部分为发起连接、发送消息的一方（本地），一方为接受连接、接收消息的一方（远程）。

登录和连接（本地）
主路径	可选路径
1.打开应用程序，显示登录窗口
2.输入用户名
3.点击“登录”按钮，登录成功	3.“登录”失败 如果用户名为空，重新进入第2步。
4.显示主窗口，显示登录的用户名称
5.点击“连接”，连接至远程
6.连接成功 6.1提示用户，连接已经成功。	6.连接失败 6.1 提示用户，连接不成功
5.在用户界面变更控件状态 5.2连接为灰色，表示已经连接 5.3注销为亮色，表示可以注销 5.4发送为亮色，表示可以发消息

这里我们的用例名称为登录和连接，但是后面我们又打了一个括号，写着“本地”，它的意思是说，登录和连接是客户端，也就是发起连接的一方采取的动作。同样，我们需要写下当客户端连接至服务端时，服务端采取的动作。

登录和连接（远程）
主路径	可选路径
1-4 同客户端
5.等待连接
6.如果有连接，自动在用户界面显示“远程主机连接成功”

接下来我们来看发送消息。在发送消息时，已经是登录了的，也就是“用户A”、“用户B”已经做好了连接，所以我们现在就可以只关注发送这一过程：

发送消息（本地）
主路径	可选路径
1.输入消息
2.点击发送按钮	2.没有输入消息，重新回到第1步
3.在用户界面上显示发出的消息	3.服务端已经断开连接或者关闭 3.1在客户端用户界面上显示错误消息

然后我们看一下接收消息，此时我们只关心接收消息这一部分。

接收消息（远程）
主路径	可选路径
1.侦听到客户端发来的消息，自动显示在用户界面上。

注意到这样一点：当远程主机向本地返回消息时，它的用例又变为了上面的用例“发送消息（本地）”。因为它们的角色已经互换了。

最后看一下注销，我们这里研究的是当我们在本地机器点击“注销”后，双方采取的动作：

注销（本地主动）
主路径	可选路径
1.点击注销按钮，断开与远程的连接
2.在用户界面显示已经注销
3.更改控件状态 3.1注销为灰色，表示已经注销 3.2连接为亮色，表示可以连接 3.3发送为灰色，表示无法发送

与此对应，服务端应该作出反应：

注销（远程被动）
主路径	可选路径
1.自动显示远程用户已经断开连接。

注意到一点：当远程主动注销时，它采取的动作为上面的“本地主动”，本地采取的动作则为这里的“远程被动”。

至 此，应用程序的功能分析和用例编写就告一段落了，通过上面这些表格，之后再继续编写程序变得容易了许多。另外还需要记得，用例只能为你提供一个操作步骤的 指导，在实现的过程中，因为技术等方面的原因，可能还会有少量的修改。如果修改量很大，可以重新修改用例；如果修改量不大，那么就可以直接编码。这是一个 迭代的过程，也没有一定的标准，总之是以高效和合适为标准。

2.分析与设计

我们已经很清楚地知道了程序需要做些什么，尽 管现在还不知道该如何去做。我们甚至可以编写出这个程序所需要的接口，以后编写代码的时候，我们只要去实现这些接口就可以了。这也符合面向接口编程的原 则。另外我们注意到，尽管这是一个聊天程序，但是却可以明确地划分为两部分，一部分发送消息，一部分接收消息。另外注意上面标识为自动的语句，它们暗示这个操作需要通过事件的通知机制来完成。关于委托和事件，可以参考这两篇文章：

• C#中的委托和事件 – 委托和事件的入门文章，同时捎带讲述了Observer设计模式和.NET的事件模型
• C#中的委托和事件(续) – 委托和事件更深入的一些问题，包括异常、超时的处理，以及使用委托来异步调用方法。

2.1消息Message

首先我们可以定义消息，前面我们已经明确了消息包含三个部分：用户名、时间、内容，所以我们可以定义一个结构来表示这个消息：

public struct Message {
    private readonly string userName;
    private readonly string content;
    private readonly DateTime postDate;
    public Message(string userName, string content) {
        this.userName = userName;
        this.content = content;
        this.postDate = DateTime.Now;
    }
    public Message(string content) : this("System", content) { }
    public string UserName {
        get { return userName; }
    }
    public string Content {
        get { return content; }
    }
    public DateTime PostDate {
        get { return postDate; }
    }
    public override string ToString() {
        return String.Format("{0}[{1}]： {2} ", userName, postDate, content);
    }
}

2.2消息发送方IMessageSender

从上面我们可以看出，消息发送方主要包含这样几个功能：登录、连接、发送消息、注销。 另外在连接成功或失败时还要通知用户界面，发送消息成功或失败时也需要通知用户界面，因此，我们可以让连接和发送消息返回一个布尔类型的值，当它为真时表 示连接或发送成功，反之则为失败。因为登录没有任何的业务逻辑，仅仅是记录控件的值并进行显示，所以我不打算将它写到接口中。因此我们可以得出它的接口大 致如下：

public interface IMessageSender {
    bool Connect(IPAddress ip, int port);       // 连接到服务端
    bool SendMessage(Message msg);              // 发送用户
    void SignOut();                                 // 注销系统
}

2.3消息接收方IMessageReceiver

而对于消息接收方，从上面我们可以看出，它的操作全是被动的：客户端连接时自动提示，客户端连接丢失时显示自动提示，侦听到消息时自动提 示。注意到上面三个词都用了“自动”来修饰，在C#中，可以定义委托和事件，用于当程序中某种情况发生时，通知另外一个对象。在这里，程序即是我们的 IMessageReceiver，某种情况就是上面的三种情况，而另外一个对象则为我们的用户界面。因此，我们现在首先需要定义三个委托：

public delegate void MessageReceivedEventHandler(string msg);  
public delegate void ClientConnectedEventHandler(IPEndPoint endPoint);
public delegate void ConnectionLostEventHandler(string info);

接下来，我们注意到接收方需要侦听消息，因此我们需要在接口中定义的方法是StartListen()和StopListen()方法，这两个方法是典型的技术相关，而不是业务相关，所以从用例中是看不出来的，可能大家现在对这两个方法是做什么的还不清楚，没有关系，我们现在并不写实现，而定义接口并不需要什么成本，我们写下IMessageReceiver的接口定义：

public interface IMessageReceiver {
    event MessageReceivedEventHandler MessageReceived; // 接收到发来的消息
    event ConnectionLostEventHandler ClientLost;            // 远程主动断开连接
    event ClientConnectedEventHandler ClientConnected;  // 远程连接到了本地
    void StartListen();         // 开始侦听端口
    void StopListen();          // 停止侦听端口
}

我记得曾经看过有篇文章说过，最好不要在接口中定义事件，但是我忘了他的理由了，所以本文还是将事件定义在了接口中。

2.4主程序Talker

而 我们的主程序是既可以发送，又可以接收，一般来说，如果一个类像获得其他类的能力，以采用两种方法：继承和复合。因为C#中没有多重继承，所以我们无法同 时继承实现了IMessageReceiver和IMessageSender的类。那么我们可以采用复合，将它们作为类成员包含在Talker内部：

public class Talker {
    private IMessageReceiver receiver;
    private IMessageSender sender;
    public Talker(IMessageReceiver receiver, IMessageSender sender) {
        this.receiver = receiver;
        this.sender = sender;
    }
}

现在，我们的程序大体框架已经完成，接下来要关注的就是如何实现它，现在让我们由设计走入实现，看看实现一个网络聊天程序，我们需要掌握的技术吧。

C#网络编程基础(篇外篇)

这部分的内容请参考 C#网络编程 系列文章，共5个部分较为详细的讲述了基于Socket的网络编程的初步内容。

编写程序代码

如 果你已经看完了上面一节C#网络编程，那么本章完全没有讲解的必要了，所以我只列出代码，对个别值得注意的地方稍微地讲述一下。首先需要了解的就是，我们 采用的是三个模式中开发起来难度较大的一种，无服务器参与的模式。还有就是我们没有使用广播消息，所以需要提前知道连接到的远程主机的地址和端口号。

1.实现IMessageSender接口

public class MessageSender : IMessageSender {
    TcpClient client;
    Stream streamToServer;
    // 连接至远程
    public bool Connect(IPAddress ip, int port) {
        try {
            client = new TcpClient();
            client.Connect(ip, port);
            streamToServer = client.GetStream();    // 获取连接至远程的流
            return true;
        } catch {
            return false;
        }
    }
    // 发送消息
    public bool SendMessage(Message msg) {
        try {
            lock (streamToServer) {
                byte[] buffer = Encoding.Unicode.GetBytes(msg.ToString());
                streamToServer.Write(buffer, 0, buffer.Length);
                return true;
            }
        } catch {
            return false;
        }
    }
    // 注销
    public void SignOut() {
        if (streamToServer != null)
            streamToServer.Dispose();
        if (client != null)
            client.Close();
    }
}

这段代码可以用朴实无华来形容，所以我们直接看下一段。

2.实现IMessageReceiver接口

public delegate void PortNumberReadyEventHandler(int portNumber);
public class MessageReceiver : IMessageReceiver {
    public event MessageReceivedEventHandler MessageReceived;
    public event ConnectionLostEventHandler ClientLost;
    public event ClientConnectedEventHandler ClientConnected;
    // 当端口号Ok的时候调用 — 需要告诉用户界面使用了哪个端口号在侦听
    // 这里是业务上体现不出来，在实现中才能体现出来的
    public event PortNumberReadyEventHandler PortNumberReady;
    private Thread workerThread;
    private TcpListener listener;
    public MessageReceiver() {
        ((IMessageReceiver)this).StartListen();
    }
    // 开始侦听：显示实现接口
    void IMessageReceiver.StartListen() {
        ThreadStart start = new ThreadStart(ListenThreadMethod);
        workerThread = new Thread(start);
        workerThread.IsBackground = true;
        workerThread.Start();
    }
    // 线程入口方法
    private void ListenThreadMethod() {
        IPAddress localIp = IPAddress.Parse("127.0.0.1");
        listener = new TcpListener(localIp, 0);
        listener.Start();
        // 获取端口号
        IPEndPoint endPoint = listener.LocalEndpoint as IPEndPoint;
        int portNumber = endPoint.Port;
        if (PortNumberReady != null) {
            PortNumberReady(portNumber);        // 端口号已经OK，通知用户界面
        }
        while (true) {
            TcpClient remoteClient;
            try {
                remoteClient = listener.AcceptTcpClient();
            } catch {
                break;
            }
            if (ClientConnected != null) {
                // 连接至本机的远程端口
                endPoint = remoteClient.Client.RemoteEndPoint as IPEndPoint;
                ClientConnected(endPoint);      // 通知用户界面远程客户连接
            }
            Stream streamToClient = remoteClient.GetStream();
            byte[] buffer = new byte[8192];
            while (true) {
                try {
                    int bytesRead = streamToClient.Read(buffer, 0, 8192);
                    if (bytesRead == 0) {
                        throw new Exception("客户端已断开连接");
                    }
                    string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);
                    if (MessageReceived != null) {
                        MessageReceived(msg);       // 已经收到消息
                    }
                } catch (Exception ex) {
                    if (ClientLost != null) {
                        ClientLost(ex.Message);     // 客户连接丢失
                        break;                      // 退出循环
                    }
                }
            }
        }
    }
    // 停止侦听端口
    public void StopListen() {
        try {
            listener.Stop();
            listener = null;
            workerThread.Abort();
        } catch { }
    }
}

这里需要注意的有这样几点：我们StartListen()为显式实现接口， 因为只能通过接口才能调用此方法，接口的实现类看不到此方法；这通常是对于一个接口采用两种实现方式时使用的，但这里我只是不希望 MessageReceiver类型的客户调用它，因为在MessageReceiver的构造函数中它已经调用了StartListen。意思是说，我 们希望这个类型一旦创建，就立即开始工作。我们使用了两个嵌套的while循环，这个它可以为多个客户端的多次请求服务，但是因为是同步操作，只要有一个 客户端连接着，我们的后台线程就会陷入第二个循环中无法自拔。所以结果是：如果有一个客户端已经连接上了，其它客户端即使连接了也无法对它应答。最后需要注意的就是四个事件的使用，为了向用户提供侦听的端口号以进行连接，我又定义了一个PortNumberReadyEventHandler委托。

3.实现Talker类

Talker 类是最平庸的一个类，它的全部功能就是将操作委托给实际的IMessageReceiver和IMessageSender。定义这两个接口的好处也从这 里可以看出来：如果日后想重新实现这个程序，所有Windows窗体的代码和Talker的代码都不需要修改，只需要针对这两个接口编程就可以了。

public class Talker {
    private IMessageReceiver receiver;
    private IMessageSender sender;
    public Talker(IMessageReceiver receiver, IMessageSender sender) {
        this.receiver = receiver;
        this.sender = sender;
    }
    public Talker() {
        this.receiver = new MessageReceiver();
        this.sender = new MessageSender();
    }
    public event MessageReceivedEventHandler MessageReceived {
        add {
            receiver.MessageReceived += value;
        }
        remove {
            receiver.MessageReceived -= value;
        }
    }
    public event ClientConnectedEventHandler ClientConnected {
        add {
            receiver.ClientConnected += value;
        }
        remove {
            receiver.ClientConnected -= value;
        }
    }
    public event ConnectionLostEventHandler ClientLost {
        add {
            receiver.ClientLost += value;
        }
        remove {
            receiver.ClientLost -= value;
        }
    }
    // 注意这个事件
    public event PortNumberReadyEventHandler PortNumberReady {
        add {
            ((MessageReceiver)receiver).PortNumberReady += value;
        }
        remove {
            ((MessageReceiver)receiver).PortNumberReady -= value;
        }
    }
           
    // 连接远程 – 使用主机名
    public bool ConnectByHost(string hostName, int port) {
        IPAddress[] ips = Dns.GetHostAddresses(hostName);
        return sender.Connect(ips[0], port);
    }
    // 连接远程 – 使用IP
    public bool ConnectByIp(string ip, int port) {
        IPAddress ipAddress;
        try {
            ipAddress = IPAddress.Parse(ip);
        } catch {
            return false;
        }
        return sender.Connect(ipAddress, port);
    }
    // 发送消息
    public bool SendMessage(Message msg) {
        return sender.SendMessage(msg);
    }
    // 释放资源，停止侦听
    public void Dispose() {
        try {
            sender.SignOut();
            receiver.StopListen();
        } catch {
        }
    }
    // 注销
    public void SignOut() {
        try {
            sender.SignOut();
        } catch {
        }
    }
}

4.设计窗体，编写窗体事件代码

现在我们开始设计窗体，我已经设计好了，现在可以先进行一下预览：

这 里需要注意的就是上面的侦听端口，是程序接收消息时的侦听端口，也就是IMessageReceiver所使用的。其他的没有什么好说的，下来我们直接看 一下代码，控件的命名是自解释的，我就不多说什么了。唯一要稍微说明下的是txtMessage指的是下面发送消息的文本框，txtContent指上面 的消息记录文本框：

public partial class PrimaryForm : Form {
    private Talker talker;
    private string userName;
    public PrimaryForm(string name) {
        InitializeComponent();
        userName = lbName.Text = name;
        this.talker = new Talker();
        this.Text = userName + " Talking …";
        talker.ClientLost +=
            new ConnectionLostEventHandler(talker_ClientLost);
        talker.ClientConnected +=
            new ClientConnectedEventHandler(talker_ClientConnected);
        talker.MessageReceived +=
            new MessageReceivedEventHandler(talker_MessageReceived);
        talker.PortNumberReady +=
            new PortNumberReadyEventHandler(PrimaryForm_PortNumberReady);
    }
    void ConnectStatus() {  }
    void DisconnectStatus() { }
    // 端口号OK
    void PrimaryForm_PortNumberReady(int portNumber) {         
        PortNumberReadyEventHandler del = delegate(int port) {
            lbPort.Text = port.ToString();
        };
        lbPort.Invoke(del, portNumber);
    }
    // 接收到消息
    void talker_MessageReceived(string msg) {
        MessageReceivedEventHandler del = delegate(string m) {
            txtContent.Text += m;
        };
        txtContent.Invoke(del, msg);
    }
    // 有客户端连接到本机
    void talker_ClientConnected(IPEndPoint endPoint) {
        ClientConnectedEventHandler del = delegate(IPEndPoint end) {
            IPHostEntry host = Dns.GetHostEntry(end.Address);
            txtContent.Text +=
                String.Format("System[{0}]： 远程主机{1}连接至本地。 ", DateTime.Now, end);
        };
        txtContent.Invoke(del, endPoint);
    }
    // 客户端连接断开
    void talker_ClientLost(string info) {
        ConnectionLostEventHandler del = delegate(string information) {
            txtContent.Text +=
                String.Format("System[{0}]： {1} ", DateTime.Now, information);
        };
        txtContent.Invoke(del, info);
    }
    // 发送消息
    private void btnSend_Click(object sender, EventArgs e) {
        if (String.IsNullOrEmpty(txtMessage.Text)) {
            MessageBox.Show("请输入内容！");
            txtMessage.Clear();
            txtMessage.Focus();
            return;
        }
        Message msg = new Message(userName, txtMessage.Text);
        if (talker.SendMessage(msg)) {
            txtContent.Text += msg.ToString();
            txtMessage.Clear();
        } else {
            txtContent.Text +=
                String.Format("System[{0}]： 远程主机已断开连接 ", DateTime.Now);
            DisconnectStatus();
        }
    }
    // 点击连接
    private void btnConnect_Click(object sender, EventArgs e) {
        string host = txtHost.Text;
        string ip = txtHost.Text;
        int port;
        if (String.IsNullOrEmpty(txtHost.Text)) {
            MessageBox.Show("主机名称或地址不能为空");
        }          
        try{
            port = Convert.ToInt32(txtPort.Text);
        }catch{
            MessageBox.Show("端口号不能为空，且必须为数字");
            return;
        }
       
        if (talker.ConnectByHost(host, port)) {
            ConnectStatus();
            txtContent.Text +=
                String.Format("System[{0}]： 已成功连接至远程 ", DateTime.Now);
            return;
        }
           
        if(talker.ConnectByIp(ip, port)){
            ConnectStatus();
            txtContent.Text +=
                String.Format("System[{0}]： 已成功连接至远程 ", DateTime.Now);
        }else{
            MessageBox.Show("远程主机不存在，或者拒绝连接！");
        }          
        txtMessage.Focus();
    }
    // 关闭按钮点按
    private void btnClose_Click(object sender, EventArgs e) {
        try {
            talker.Dispose();
            Application.Exit();
        } catch {
        }
    }
    // 直接点击右上角的叉
    private void PrimaryForm_FormClosing(object sender, FormClosingEventArgs e) {
        try {
            talker.Dispose();
            Application.Exit();
        } catch {
        }
    }
    // 点击注销
    private void btnSignout_Click(object sender, EventArgs e) {
        talker.SignOut();
        DisconnectStatus();
        txtContent.Text +=
            String.Format("System[{0}]： 已经注销 ",DateTime.Now);
    }
    private void btnClear_Click(object sender, EventArgs e) {
        txtContent.Clear();
    }
}

在上面代码中，分别通过四个方法订阅了四个事件，以实现自动通知的机制。最后需要注意的就是SignOut()和Dispose()的区分。SignOut()只是断开连接，Dispose()则是离开应用程序。

总结

这 篇文章简单地分析、设计及实现了一个聊天程序。这个程序只是对无服务器模式实现聊天的一个尝试。我们分析了需求，随后编写了几个用例，并对本地、远程的概 念做了定义，接着编写了程序接口并最终实现了它。这个程序还有很严重的不足：它无法实现自动上线通知，而必须要事先知道端口号并进行手动连接。为了实现一 个功能强大且开发容易的程序，更好的办法是使用集中型服务器模式。

感谢阅读，希望这篇文章能对你有所帮助。

源码下载：http://www.tracefact.net/SourceCode/Network-Part5.rar

C#网络编程(接收文件) – Part.5

这篇文章将完成Part.4中剩余的部分，它们本来是一篇完整的文章，但是因为上一篇比较长，合并起来页数太多，浏览起来可能会比较不方便，我就将它拆为两篇了，本文便是它的后半部分。我们继续进行上一篇没有完成的步骤：客户端接收来自服务端的文件。

4.客户端接收文件

4.1服务端的实现

对 于服务端，我们只需要实现上一章遗留的sendFile()方法就可以了，它起初在handleProtocol中是注释掉的。另外，由于创建连接、获取 流等操作与receiveFile()是没有区别的，所以我们将它提出来作为一个公共方法getStreamToClient()。下面是服务端的代码， 只包含新增改过的代码，对于原有方法我只给出了签名：

class Server {
    static void Main(string[] args) {
        Console.WriteLine("Server is running … ");
        IPAddress ip = IPAddress.Parse("127.0.0.1");
        TcpListener listener = new TcpListener(ip, 8500);
        listener.Start();           // 开启对控制端口 8500 的侦听
        Console.WriteLine("Start Listening …");
        while (true) {
            // 获取一个连接，同步方法，在此处中断
            TcpClient client = listener.AcceptTcpClient(); 
            RemoteClient wapper = new RemoteClient(client);
            wapper.BeginRead();
        }
    }
}
public class RemoteClient {
    // 字段 略

    public RemoteClient(TcpClient client) {}
    // 开始进行读取
    public void BeginRead() { }
    // 再读取完成时进行回调
    private void OnReadComplete(IAsyncResult ar) { }
    // 处理protocol
    private void handleProtocol(object obj) {
        string pro = obj as string;
        ProtocolHelper helper = new ProtocolHelper(pro);
        FileProtocol protocol = helper.GetProtocol();
        if (protocol.Mode == FileRequestMode.Send) {
            // 客户端发送文件，对服务端来说则是接收文件
            receiveFile(protocol);
        } else if (protocol.Mode == FileRequestMode.Receive) {
            // 客户端接收文件，对服务端来说则是发送文件
            sendFile(protocol);
        }
    }
    // 发送文件
    private void sendFile(FileProtocol protocol) {
        TcpClient localClient;
        NetworkStream streamToClient = getStreamToClient(protocol, out localClient);
        // 获得文件的路径
        string filePath = Environment.CurrentDirectory + "/" + protocol.FileName;
        // 创建文件流
        FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
        byte[] fileBuffer = new byte[1024];     // 每次传1KB
        int bytesRead;
        int totalBytes = 0;
        // 创建获取文件发送状态的类
        SendStatus status = new SendStatus(filePath);
        // 将文件流转写入网络流
        try {
            do {
                Thread.Sleep(10);           // 为了更好的视觉效果，暂停10毫秒:-)
                bytesRead = fs.Read(fileBuffer, 0, fileBuffer.Length);
                streamToClient.Write(fileBuffer, 0, bytesRead);
                totalBytes += bytesRead;            // 发送了的字节数
                status.PrintStatus(totalBytes); // 打印发送状态
            } while (bytesRead > 0);
            Console.WriteLine("Total {0} bytes sent, Done!", totalBytes);
        } catch {
            Console.WriteLine("Server has lost…");
        }
        streamToClient.Dispose();
        fs.Dispose();
        localClient.Close();
    }
    // 接收文件
    private void receiveFile(FileProtocol protocol) { }
    // 获取连接到远程的流 — 公共方法
    private NetworkStream getStreamToClient(FileProtocol protocol, out TcpClient localClient) {
        // 获取远程客户端的位置
        IPEndPoint endpoint = client.Client.RemoteEndPoint as IPEndPoint;
        IPAddress ip = endpoint.Address;
        // 使用新端口号，获得远程用于接收文件的端口
        endpoint = new IPEndPoint(ip, protocol.Port);
        // 连接到远程客户端
        try {
            localClient = new TcpClient();
            localClient.Connect(endpoint);
        } catch {
            Console.WriteLine("无法连接到客户端 –> {0}", endpoint);
            localClient = null;
            return null;
        }
        // 获取发送文件的流
        NetworkStream streamToClient = localClient.GetStream();
        return streamToClient;
    }
    // 随机获取一个图片名称
    private string generateFileName(string fileName) {}
}

服务端的sendFile方法和客户端的SendFile()方法完全类似，上面的代码几乎是一次编写成功的。另外注意我将客户端使用的SendStatus类也拷贝到了服务端。接下来我们看下客户端。

4.2客户端的实现

首先要注意的是客户端的SendFile()接收的参数是文件全路径，但是在写入到协议时只获取了路径中的文件名称。这是因为服务端不需要知道文件在客户端的路径，所以协议中只写文件名；而为了使客户端的SendFile()方法更通用，所以它接收本地文件的全路径。

客户端的ReceiveFile()的实现也和服务端的receiveFile()方法类似，同样，由于要保存到本地，为了避免文件名重复，我将服务端的generateFileName()方法复制了过来。

public class ServerClient :IDisposable {
    // 字段略

    public ServerClient() {}
    // 发送消息到服务端
    public void SendMessage(string msg) {}
    // 发送文件 – 异步方法
    public void BeginSendFile(string filePath) {    }
    private void SendFile(object obj) { }
   
    // 发送文件 — 同步方法
    public void SendFile(string filePath) {}
   
    // 接收文件 — 异步方法
    public void BeginReceiveFile(string fileName) {
        ParameterizedThreadStart start =
            new ParameterizedThreadStart(ReceiveFile);
        start.BeginInvoke(fileName, null, null);
    }
    public void ReceiveFile(object obj) {
        string fileName = obj as string;
        ReceiveFile(fileName);
    }
    // 接收文件 — 同步方法
    public void ReceiveFile(string fileName) {
        IPAddress ip = IPAddress.Parse("127.0.0.1");
        TcpListener listener = new TcpListener(ip, 0);
        listener.Start();
        // 获取本地侦听的端口号
        IPEndPoint endPoint = listener.LocalEndpoint as IPEndPoint;
        int listeningPort = endPoint.Port;
        // 获取发送的协议字符串
        FileProtocol protocol =
            new FileProtocol(FileRequestMode.Receive, listeningPort, fileName);
        string pro = protocol.ToString();
        SendMessage(pro);       // 发送协议到服务端

        // 中断，等待远程连接
        TcpClient localClient = listener.AcceptTcpClient();
        Console.WriteLine("Start sending file…");
        NetworkStream stream = localClient.GetStream();
        // 获取文件保存的路劲
        string filePath =
            Environment.CurrentDirectory + "/" + generateFileName(fileName);
        // 创建文件流
        FileStream fs = new FileStream(filePath, FileMode.CreateNew, FileAccess.Write);
        byte[] fileBuffer = new byte[1024];     // 每次传1KB
        int bytesRead;
        int totalBytes = 0;
        // 从缓存buffer中读入到文件流中
        do {
            bytesRead = stream.Read(buffer, 0, BufferSize);
            fs.Write(buffer, 0, bytesRead);
            totalBytes += bytesRead;
            Console.WriteLine("Receiving {0} bytes …", totalBytes);
        } while (bytesRead > 0);
        Console.WriteLine("Total {0} bytes received, Done!", totalBytes);
        fs.Dispose();          
        stream.Dispose();
        localClient.Close();
        listener.Stop();
    }
    // 随机获取一个图片名称
    private string generateFileName(string fileName) {}
    public void Dispose() {
        if (streamToServer != null)
            streamToServer.Dispose();
        if (client != null)
            client.Close();
    }
}

上面关键的一句就是创建协议那句，注意到将mode由Send改为了Receive，同时传去了想要接收的服务端的文件名称。

4.3程序测试

现在我们已经完成了所有收发文件的步骤，可以看到服务端的所有操作都是被动的，接下来我们修改客户端的Main()程序，创建一个菜单，然后根据用户输入发送或者接收文件。

class Program {
    static void Main(string[] args) {
        ServerClient client = new ServerClient();
        string input;
        string path = Environment.CurrentDirectory + "/";
        do {
            Console.WriteLine("Send File:    S1 – Client01.jpg, S2 – Client02.jpg, S3 – Client03.jpg");
            Console.WriteLine("Receive File: R1 – Server01.jpg, R1 – Server02.jpg, R3- Server03.jpg");
            Console.WriteLine("Press 'Q' to exit. ");
            Console.Write("Enter your choice: ");
            input = Console.ReadLine();
            switch(input.ToUpper()){
                case "S1":
                    client.BeginSendFile(path + "Client01.jpg");
                    break;
                case "S2":
                    client.BeginSendFile(path + "Client02.jpg");
                    break;
                case "S3":
                    client.BeginSendFile(path + "Client02.jpg");
                    break;
                case "R1":
                    client.BeginReceiveFile("Server01.jpg");
                    break;
                case "R2":
                    client.BeginReceiveFile("Server01.jpg");
                    break;
                case "R3":
                    client.BeginReceiveFile("Server01.jpg");
                    break;
            }              
        } while (input.ToUpper() != "Q");
        client.Dispose();
    }
}

由于这是一个控制台应用程序，并且采用了异步操作，所以这个菜单的出现顺序有点混乱。我这里描述起来比较困难，你将代码下载下来后运行一下就知道了:-)

程序的运行结果和上一节类似，这里我就不再贴图了。接下来是本系列的最后一篇，将发送字符串与传输文件的功能结合起来，创建一个可以发送消息并能收发文件的聊天程序，至于语音聊天嘛…等我学习了再告诉你 >_<、