[转载]海量数据处理专题（七）——数据库索引及优化 – 码农1946 – 博客园.

索引是对数据库表中一列或多列的值进行排序的一种结构，使用索引可快速访问数据库表中的特定信息。

数据库索引

什么是索引

数据库索引好比是一本书前面的目录，能加快数据库的查询速度。
例如这样一个查询：select * from table1 where id=44。如果没有索引，必须遍历整个表，直到ID等于44的这一行被找到为止；有了索引之后(必须是在ID这一列上建立的索引)，直接在索引里面找 44（也就是在ID这一列找），就可以得知这一行的位置，也就是找到了这一行。可见，索引是用来定位的。
索引分为聚簇索引和非聚簇索引两种，聚簇索引 是按照数据存放的物理位置为顺序的，而非聚簇索引就不一样了；聚簇索引能提高多行检索的速度，而非聚簇索引对于单行的检索很快。

概述

建立索引的目的是加快对表中记录的查找或排序。
为表设置索引要付出代价的：一是增加了数据库的存储空间，二是在插入和修改数据时要花费较多的时间(因为索引也要随之变动)。

B树索引-SQL Server索引方式

为什么要创建索引

创建索引可以大大提高系统的性能。
第一，通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
第二，可以大大加快数据的检索速度，这也是创建索引的最主要的原因。
第三，可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
第四，在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
第五，通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。
也许会有人要问：增加索引有如此多的优点，为什么不对表中的每一个列创建一个索引呢？因为，增加索引也有许多不利的方面。
第一，创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
第二，索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。
第三，当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。

在哪建索引

索引是建立在数据库表中的某些列的上面。在创建索引的时候，应该考虑在哪些列上可以创建索引，在哪些列上不能创建索引。一般来说，应该在这些列上创建索引：
在经常需要搜索的列上，可以加快搜索的速度；
在作为主键的列上，强制该列的唯一性和组织表中数据的排列结构；
在经常用在连接的列上，这些列主要是一些外键，可以加快连接的速度；在经常需要根据范围进行搜索的列上创建索引，因为索引已经排序，其指定的范围是连续的；
在经常需要排序的列上创建索引，因为索引已经排序，这样查询可以利用索引的排序，加快排序查询时间；
在经常使用在WHERE子句中的列上面创建索引，加快条件的判断速度。
同样，对于有些列不应该创建索引。一般来说，不应该创建索引的的这些列具有下列特点：
第一，对于那些在查询中很少使用或者参考的列不应该创建索引。这是因为，既然这些列很少使用到，因此有索引或者无索引，并不能提高查询速度。相反，由于增加了索引，反而降低了系统的维护速度和增大了空间需求。
第二，对于那些只有很少数据值的列也不应该增加索引。这是因为，由于这些列的取值很少，例如人事表的性别列，在查询的结果中，结果集的数据行占了表中数据行的很大比例，即需要在表中搜索的数据行的比例很大。增加索引，并不能明显加快检索速度。
第三，对于那些定义为text, image和bit数据类型的列不应该增加索引。这是因为，这些列的数据量要么相当大，要么取值很少,不利于使用索引。
第四，当修改性能远远大于检索性能时，不应该创建索引。这是因为，修改性能和检索性能是互相矛盾的。当增加索引时，会提高检索性能，但是会降低修改性能。当减少索引时，会提高修改性能，降低检索性能。因此，当修改操作远远多于检索操作时，不应该创建索引。

数据库优化

此外，除了数据库索引之外，在LAMP结果如此流行的今天，数据库（尤其是MySQL）性能优化也是海量数据处理的一个热点。下面就结合自己的经验，聊一聊MySQL数据库优化的几个方面。
首先，在数据库设计的时候，要能够充分的利用索引带来的性能提升，至于如何建立索引，建立什么样的索引，在哪些字段上建立索引，上面已经讲的很清楚了， 这里不在赘述。另外就是设计数据库的原则就是尽可能少的进行数据库写操作（插入，更新，删除等），查询越简单越好。如下：

数据库设计

其次，配置缓存是必不可少的，配置缓存可以有效的降低数据库查询读取次数，从而缓解数据库服务器压力，达到优化的目的，一定程度上来讲，这算是一个“围 魏救赵”的办法。可配置的缓存包括索引缓存(key_buffer)，排序缓存(sort_buffer)，查询缓存(query_buffer)，表描 述符缓存(table_cache)，如下图：

配置缓存

第三，切表，切表也是一种比较流行的数据库优化方法。分表包括两种方式：横向分表和纵向分表，其中，纵向分表比较有使用意义，但是分表会造成查询的负担，因此在数据库设计之初，要想好：

分表

第四，日志分析，在数据库运行了较长一段时间以后，会积累大量的LOG日志，其实这里面的蕴涵的有用的信息量还是很大的。通过分析日志，可以找到系统性能的瓶颈，从而进一步寻找优化方案。

性能分析

以上讲的都是单机MySQL的性能优化的一些经验，但是随着信息大爆炸，单机的数据库服务器已经不能满足我们的需求，于是，多多节点，分布式数据库网络出现了，其一般的结构如下：

分布式数据库结构

这种分布式集群的技术关键就是“同步复制”。。。未完待续~~~

[转载]Android与IIS身份验证——基本验证 – 刘冬.NET – 博客园.

内容摘要

前言

1.服务器端

2.Android客户端

3.IIS部署

4.运行效果

在Android移动项目开发中，访问服务器时,为了简洁方便，我们经常使用http协议来传递JSON格式的数据。然而有些项目需要有一定的 安全性，如使用Android客户端登陆到MIS系统。虽然我们是通过Android手机客户端的登陆Activity中登陆到系统的，但是略懂电脑的黑 客是能够跳过登陆Activity，从而直接进入系统的。这样，会造成一些由于系统的不安全所带来的麻烦。建立一种防止黑客强行登录的身份验证模式尤为重 要。此时，系统的身份验证成为阻挡黑客登陆的一道屏障。那么，怎样实现一个身份验证呢？让我们以IIS为宿主，一步一步的实现身份验证吧。

一、ASP.NET服务器端

首先，我们使用VS2010创建一个web项目(可以是WebForms，也可以是MVC，我这里使用的是ASP.NET MVC项目)。图1.1所示

图1.1

然后，在HomeController的Index Action中输入：登陆成功。

二、Android客户端

首先，创建一个Android项目，并新建一个MainActivity类。

接着，编写一个访问IIS服务器的类。

注意的是，我这里用户名和密码分别是：liudong和123。

然后，修改layout文件：main.xml

最后，修改MainActivity。

设置访问权限为：<uses-permission android:name=”android.permission.INTERNET” />

运行模拟器的效果如图2.1所示。

图2.1

三、IIS部署

首先、添加一个网站，如图3.1所示。

如图3.1

接着，在进入计算机管理–>本地用户和组–>用户，新建一个用户，如图3.2所示。

图3.2

然后，设置IIS的身份验证(图3.3所示)。

图3.3

设置其身份验证模式为：基本验证或Window身份s验证(图3.4所示)。

图3.4

最后，我们在浏览器中输入网址进行验证，验证结果见图3.5和图3.6。

图3.5

图3.6

从图中我们可以发现，浏览该网页时需要用户名和密码。我们输入了正确的用户名和密码后就可以登录这个页面了。

四，运行效果。

见图4.1和图4.2所示。

图4.1

图4.2

代码下载

出处：http://www.cnblogs.com/GoodHelper/archive/2011/08/17/android_iis_01.html

作者：刘冬.NET

欢迎转载，但须保留版权。

[转载]Android通过摇晃手机的频率来控制声音的频率 – stay – 博客园.

通过晃动手机的频率来修改播放声音的频率。效果很给力的说。主要通过sensor来算手机摇晃的频率，摇晃的频率越高，播放声音的速度越快。

/**
* @author Stay
* 通过摇晃手机的频率来改变声音的速度
*/
public class ShakeSound extends Activity implements SensorEventListener,OnClickListener {
private static final float SHAKE_THRESHOLD = 50;
private static final String TAG = “ActivityTest”;
private SensorManager manager;
private SoundManager sm;
private long curTime, lastUpdate;
private float last_x, last_y, last_z;
private float x,y,z;
private boolean isPlaying;
private int count = -2;
private float force;
private int audioCount = 0;
private float audioForce;
private Button btn;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btn = (Button) this.findViewById(R.id.hello);
btn.setOnClickListener(this);
manager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sm = new SoundManager(this);
sm.addSound(1, “heixiu.ogg”);
}

@Override
public void onSensorChanged(SensorEvent event) {
curTime = System.currentTimeMillis();
if ((curTime – lastUpdate) > 100) {
count ++ ;
if (count < 0) { return; } if (count == 0) { if (!isPlaying) { Log.i(TAG, "sm.play(1, 0, 1.0f);"); sm.play(1, 0, 1.0f); } last_x = event.values[SensorManager.DATA_X]; last_y = event.values[SensorManager.DATA_Y]; last_z = event.values[SensorManager.DATA_Z]; return; } lastUpdate = curTime; x = event.values[SensorManager.DATA_X]; y = event.values[SensorManager.DATA_Y]; z = event.values[SensorManager.DATA_Z]; curTime = System.currentTimeMillis(); // 每100毫秒检测一次 float deltaForce = Math.abs(x + y + z - last_x - last_y - last_z); force = force + deltaForce; updateAudioRate(deltaForce); if (count >= SHAKE_THRESHOLD) {
Log.i(TAG, “unSensorListener”);
// onShakeCallBack(force / count); get the score
unSensorListener();
if (isPlaying) {
sm.stop();
isPlaying = false;
}
count = – 2;
force = 0;
return;
}
last_x = x;
last_y = y;
last_z = z;
}
}

@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}

private void updateAudioRate(float force) {
float rate=0;
float prvAudioRate = 1;
audioCount =audioCount+1;
audioForce=audioForce+force;
if(audioCount>3){
//from 0-50 maps to 0.6 to 2
//rate=audioForce/audioCount*0.03+0.5;
//from 0-50 maps to 1 to 1.8
rate=(float) (audioForce/audioCount*0.012+1.0);
//myAlert(rate);
prvAudioRate=prvAudioRate+(rate-prvAudioRate)/3;
sm.setRate(prvAudioRate);
Log.i(TAG, “sm.setRate=” + prvAudioRate);
audioForce=0;
audioCount=0;
//prvAudioRate=rate;
}
}

private void setSensorListener() {
Log.i(TAG, “setSensorListener”);
Sensor sensor = manager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
manager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_GAME);
}

private void unSensorListener() {
Log.i(TAG, “unregisterListener”);
manager.unregisterListener(this);
}

@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.hello:
setSensorListener();
break;
default:
break;
}
}

/**
* @author Stay
* 声音管理类
*/
public class SoundManager {
public SoundPool mSoundPool;
private HashMap mSoundPoolMap;
private AudioManager mAudioManager;
private Context mContext;
private int mStreamID;
static final String LOG_TAG = “SoundManager”;
private boolean mSoundEnable = true;
private float mRate = 1f;
private boolean playing = false;
private int loopMode = 0;
private int mPlayIndex = -1;

public SoundManager(Context mContext) {
this.mContext = mContext;
mSoundPool = new SoundPool(4, AudioManager.STREAM_MUSIC, 0);
mSoundPoolMap = new HashMap();
mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
}

public void addSound(int index, String audioName) {
// mSoundPoolMap.put(1, mSoundPool.load(mContext, SoundID, 1));
try {
mSoundPoolMap.put(index, mSoundPool.load(mContext.getAssets().openFd(audioName), 1));
} catch (IOException e) {
e.printStackTrace();
}
}

// loopMode=0:play once; loopMode=-1:loop mode;
public void play(int index, int loopMode, float rate) {
if (mSoundEnable) {
this.loopMode = loopMode;
mRate = checkRate(rate);

int streamVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
// float streamVolume = 0.1f;
// notes: for loop mode, the priority should be set to 0, else it can’t be stopped
// mStreamID=mSoundPool.play(mSoundPoolMap.get(index), streamVolume, streamVolume, 1, loopMode, mRate);
if (mPlayIndex < 0) { mStreamID = mSoundPool.play(mSoundPoolMap.get(index), streamVolume, streamVolume, 0, loopMode, mRate); } else { mStreamID = mSoundPool.play(mSoundPoolMap.get(mPlayIndex), streamVolume, streamVolume, 0, loopMode, mRate); } playing = true; } } // added for v 1.0.1, enable changing the audio remotely public void setPlayIndex(int index) { mPlayIndex = index; } public void setRate(float rate) { if (mSoundEnable) { mRate = checkRate(rate); mSoundPool.setRate(mStreamID, mRate); } } private float checkRate(float rate) { if (rate > 2f) {
return 2f;
} else if (rate < 0.5f) { return 0.5f; } else { return rate; } } public void stepRate(float step) { if (mSoundEnable) { mRate = mRate + step; mRate = checkRate(mRate); mSoundPool.setRate(mStreamID, mRate); } } public void pause() { if (mSoundEnable) { mSoundPool.pause(mStreamID); // mSoundPool.autoPause(); } } public void resume() { if (mSoundEnable) { if (false == playing) { play(1, loopMode, mRate); } else { mSoundPool.resume(mStreamID); } } // mSoundPool.autoResume(); } public void stop() { if (mSoundEnable) { playing = false; mSoundPool.stop(mStreamID); } } public void setSound(boolean soundEnable) { mSoundEnable = soundEnable; } public void release() { if (mSoundEnable) { playing = false; mSoundPool.release(); } mSoundPool.release(); mSoundPool = null; mSoundPoolMap.clear(); mSoundPoolMap = null; } } [/java]

[转载]重构代码的7个阶段 | 酷壳 – CoolShell.cn.

你曾去想重构一个很老的模块，但是你只看了一眼你就恶心极了。文档，奇怪的函数和类的命名，等等，整个模块就像一个带着脚镣的衣衫褴褛的人，虽然能 走，但是其已经让人感到很不舒服。面对这种情况，真正的程序员会是不会认输的，他们会接受挑战认真分析，那怕重写也在所不惜。最终那个模块会被他们重构， 就像以前和大家介绍过的那些令人销魂的编程方式中的屠宰式编程一样。下面是重构代码的几个阶段，文章来自：The 7 stages of refactoring，下面的翻译只是意译。

第一阶段 – 绝望

在你开始去查看你想要重构的模块的，你会觉得好像很简单，这里需要改一个类，那里需要改两到三个函数，重写几个 函数，看上去没什么大不了的，一两天就搞定了。于是你着手开始重构，然后当你调整重构了一些代码，比如改了一些命名，修理了一些逻辑，渐渐地，你会发现这 个怪物原来体型这么大，你会看到与代码不符甚至含糊不清的注释，完全摸不着头脑的数据结构，还有一些看似不需要方法被调了几次，你还会发现无法搞清一个函 数调用链上的逻辑。你感到这个事可能一周都搞不定，你开始绝望了。

第二阶段 – 找最简单的做

你承认你要重构的这个模块就是一个可怕的怪物，不是一两下就可以搞定的，于是你开始着干一些简单的事，比如重新命名一下几个函数，移除一些代码的阻碍，产生几个常量来消除magic number，等等，你知道这样做至少不会让代码变得更糟糕。

第三阶段 – 再次绝望

但是接下来的事会让你再次撞墙。你会发现那些代码的瑕疵是些不痛不痒的事，改正这些事完全于事无补，你应该要做 的事就是重写所有的东西。但是你却没有时间这么干，而这些代码剪不乱理还乱，耦合得太多，让你再一次绝望。所以，你只能部分重写那些不会花太多时间的部 分，这样至少可以让这些老的代码能被更多的重用。虽然不完美，但是至少可以试试。

第四阶段 – 开始乐观

在你试着部分重构这个模块几天之后，随着重构了几个单元后，虽然你发现改善代码的进度太慢了，但此时，你已知道代码应该要被改成什么样，你在痛苦之 后也锁定了那些那修改的类。是的，虽然你的时间预算已经超支，虽然要干的事比较多，但你还是充满希望，觉得那是值得的。你胸中的那团火又被点燃了。

第五阶段  – 快速了结

在这个时候，你发现你已花了太多的时间，而情况越来越复杂，你感到你所面对的情况越来越让你越到不安，你明白你自己已经陷入了困境。你原本以为只需 要一次简单的重构，然而现在你要面对的是重写所有的东西。你开始意识到原因是因为你是一个完美主义者，你想让代码变得完美。于是你开始在怠慢你文档，并想 找到一个捷径来重写老的代码，你开始采用一些简单而粗暴，快速而有点肮脏的方法。虽然不是很完美，但你就是这样去做了。然后，你开始运行测试做UT，发现 UT报告上全是红色，几乎全都失败了，你恐慌了，于是快速地fix代码，然后让UT 能工作。此时，你拍拍自己胸口，说到，没问题 ，于是就把代码提交了。

第六阶段 – 修改大量的Bug

你的重写并不完美，虽然其过了测试，但是那些UT测试对于你的新的代码有点不太合适，虽然他们都没有报错，但是他们测试得范围太小了，没有覆盖到所 有的情况和边界。所以，在这以后，你还需要几周或是更长的时间不得不来修正越来越多的bug，这使得你的设计和代码在每一次quick-fix后就变得越 来越难看。此时，代码已经不像你所期望的那样完美了，但你依然觉得他还是比一开始要好一些。这个阶段可能历经几个月。

第七阶段  – 觉悟

经过了6个月，你重写的模块又出了一个比较严重的bug。这让你重构的那个模块变得更难堪。你发现出的这个问题是和当初的设计不一致，你还发现被你 重构掉的那段老的代码并不是当初看上去的那么坏，那段老的代码确实考虑到了一些你未曾考虑到的事情。这个时候，你团队里有人站出来说这个模块应该被重构或 是重写，而你却不动声色地一言不发，并希望那个站出来的人能在几个月后能觉悟起来。

——————

不知道这是不是你的经历，我经历过很多次这样的事。对于很多维护性质的项目，我犯过的错误让我成了一个实实在在的保守派，我几乎不敢动，那怕看到代 码很不合口味。当然，那些从来没有写过代码的敏捷咨询师一定会说用TDD或是UT可以让你的重构更有效也更容易，因为这样会让他们显得更我价值，但我想告 诉你，这种脱离实际的说法很不负责任，这就好比说—— 我在杀猪的时候遇到了一些麻烦，因为我对猪的生理结构不清楚，或是这本来就是一头畸形的猪，导致我杀的猪很难看，而伟大的敏捷咨询师却告诉我，要用一把更快更漂亮的刀。软件开发永远不是那么简单的事，杀猪也一样。

[转载]Repository模式.

interface IRepository<T> where T : class
{
    IEnumerable<T> FindAll(Func<T, bool> exp);
    void Add(T entity);
    void Delete(T entity);
    void Save();
}

public class Repository<T> : IRepository<T> where T : class
{
    public DataContext context;
    public Repository(DataContext context)
    {
        this.context = context;
    }
    public IEnumerable<T> FindAll(Func<T, bool> exp)
    {
        return context.GetTable<T>().Where(exp);
    }
    public void Add(T entity)
    {
        context.GetTable<T>().InsertOnSubmit(entity);
    }
    public void Delete(T entity)
    {
        context.GetTable<T>().DeleteOnSubmit(entity);
    }
    public void Save()
    {
        context.SubmitChanges();
    }
}

interface IBookRepository : IRepository<Book>
{
    IList<Book> GetAllByBookId(int id);
}

public class BookRepository : Repository<Book>, IBookRepository
{
    public BookRepository(DataContext dc)
        : base(dc)
    { }
    public IList<Book> GetAllByBookId(int id)
    {
        var listbook = from c in context.GetTable<Book>()
                       where c.BookId == id
                       select c;
        return listbook.ToList();
    }
}

大早晨打开电脑就弹出窗口“谷歌125亿美元收购摩托罗拉移动”，好消息啊！

新闻内容：

北京时间8月15日消息，据国外媒体报道，谷歌和摩托罗拉移动今天宣布，两家公司已经达成一致协议，谷歌将以每股40美元现金的价格收购摩托罗拉移动。这 笔交易的总价值达到约125亿美元，按照上周五的收盘价计算，该收购价比摩托罗拉移动的股价溢价63%。这笔交易已经分别获得谷歌和摩托罗拉移动董事会的 一致通过。

不知道google又要有什么大动作，下面是谷歌CEO拉里-佩奇(Larry Page)说是为了巩固Android的地位?!看来Google从微软和苹果的专利联合攻击中发现“搞硬件才能拳头硬”

以下为佩奇声明全文：

自2007年11月推出以来，Android不仅极大地丰富了用户的选择空间，而且还改善了用户的整个移动使用体验。目前，全球累计激活的Android设备超过1.5亿部，每天激活的设备数量高达55万部，这些来自全球39家硬件设备厂商的Android设备登陆了123个国家的231家运营商的网络。鉴于Android所取得的巨大成功，我们一直在寻求新的方式来进一步巩固Android的市场地位。这就是我今天如此高兴地宣布收购摩托罗拉移动的原因所在。

在通信技术、移动产品和知识产权开发三大领域，摩托罗拉有着80多年的创新历史，正是这些创新推动着我们今天的移动计算领域不断向前发展。摩托罗拉的里程碑主要包括：约30年前推出全球首款便携式手机，当时全球最小、最轻的手机StarTAC。 2007年，摩托罗拉率先参与组建了“开放手机联盟”(Open Handset Alliance)，共同推广Android平台。我个人一直非常欣赏摩托罗拉手机手机，从当时的StarTAC到现在的DROID系列。

2008年，摩托罗拉就把全部的赌注都压在了Android系统身上，将Android作为其全部智能手机的唯一操作系统。这是一个明智的选择，我们为摩托罗拉今天所取得的成功感到无比兴奋。我们相信摩托罗拉的移动业务将继续呈现上行趋势，并获得爆炸式增长。

摩托罗拉同时还是家庭设备和视频解决方案市场的领跑者。由于整个市场向互联网领域转移，我们非常乐于与摩托罗拉和整个行业合作来为我们的伙伴提供支持，推动市场创新。

摩托罗拉全身心地投入到Android平台的发展是我们收购摩托罗拉的原因之一。除此之外，两家公司还有很多共同之处。合并后，我们将为用户提供更出色的用户体验，从而进一步巩固整个Android生态系统，这对用户、合作伙伴和开发人员来说都是十分有利的。而且收购摩托罗拉还会进一步增强谷歌的专利实力，以更好地保护Android系统免受微软、苹果和其他公司的侵权诉讼纠纷。

该交易不仅会进一步巩固Android的市场地位，而且还将提升移动操作系统市场的竞争激烈程度，并为消费者提供持续的创新产品、丰富的选择空间以及完美的使用体验。我坚信，这些体验将会为我们的股东创造出更多的价值。

我非常欢迎摩托罗拉员工成为谷歌大家庭中的一员。

[转载]用TCP/IP实现自己简单的应用程序协议:其余部分 – 浪雪 – 博客园.

    public class VoteClientTCP {

      public static int CANDIDATEID = 888;//随便写了一个      

      public static void Main(String[] args) {

        int port = 5555;
        IPEndPoint ipep = new IPEndPoint(GetLocalhostIPv4Addresses().First(), port);

        Socket sock = new Socket(AddressFamily.InterNetwork,
                    SocketType.Stream, ProtocolType.Tcp);
        try
        {
            sock.Connect(ipep);
        }
        catch (SocketException e)
        {
            Console.WriteLine("Can not connect {0} ,reason：{1}，NativeErrorCode：{2},SocketErrorCode:{3}", ipep.Address, e.Message, e.NativeErrorCode, e.SocketErrorCode);
            Console.ReadKey();
            return;
        }

        IVoteMsgCoder coder = new VoteMsgTextCoder();

        IFramer framer = new LengthFramer(sock);

        VoteMsg msg = new VoteMsg(true, false, CANDIDATEID, 1);
        byte[] encodedMsg = coder.toWire(msg);

        // 发送查询
        Console.WriteLine("Sending Inquiry (" + encodedMsg.Length + " bytes): ");
        framer.frameMsg(encodedMsg);

        // 投第一票给候选人888
        msg.IsInquiry = false;
        encodedMsg = coder.toWire(msg);
        Console.WriteLine("Sending Vote (" + encodedMsg.Length + " bytes): ");
        framer.frameMsg(encodedMsg);

        // 投第二票给候选人888
        msg.IsInquiry = false;
        encodedMsg = coder.toWire(msg);
        Console.WriteLine("Sending Vote (" + encodedMsg.Length + " bytes): ");
        framer.frameMsg(encodedMsg);

        // 再次查询
        msg.IsInquiry = true;
        encodedMsg = coder.toWire(msg);
        Console.WriteLine("Sending Inquiry (" + encodedMsg.Length + " bytes): ");
        framer.frameMsg(encodedMsg);
        
        encodedMsg = framer.nextMsg();
        msg = coder.fromWire(encodedMsg);
        Console.WriteLine("Received Response (" + encodedMsg.Length
                   + " bytes): ");
        Console.WriteLine(msg);


        msg = coder.fromWire(framer.nextMsg());
        Console.WriteLine("Received Response (" + encodedMsg.Length
               + " bytes): ");
        Console.WriteLine(msg);

        msg = coder.fromWire(framer.nextMsg());
        Console.WriteLine("Received Response (" + encodedMsg.Length
               + " bytes): ");
        Console.WriteLine(msg);

        msg = coder.fromWire(framer.nextMsg());
        Console.WriteLine("Received Response (" + encodedMsg.Length
               + " bytes): ");
        Console.WriteLine(msg);

        sock.Shutdown(SocketShutdown.Both);
        sock.Close();
        Console.ReadLine();
      }

　　　　//辅助方法
      public static IPAddress[] GetLocalhostIPv4Addresses()
      {
          IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());
          List<IPAddress> list = new List<IPAddress>();
          foreach (IPAddress address in hostEntry.AddressList)
          {
              if (address.AddressFamily == AddressFamily.InterNetwork)
              {
                  list.Add(address);
              }
          }
          return list.ToArray();
      }

    }

    public class VoteServerTCP {

      public static void Main(String[] args){

        int port = 5555;

        Socket servSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp );;
        //编码对象
        IVoteMsgCoder coder = new VoteMsgTextCoder();
          //服务对象
        VoteService service = new VoteService();
        //创建IP终结点
        IPAddress localAddress = AddressHelper.GetLocalhostIPv4Addresses().First();        
        IPEndPoint ipep = new IPEndPoint(localAddress, port);

        servSock.Bind(ipep);
        servSock.Listen(1);

        while (true) {
          Socket clntSock = servSock.Accept();
          Console.WriteLine("Handling client at " + clntSock.AddressFamily);

          IFramer framer = new LengthFramer(clntSock);
          try {
            byte[] req;
            while ((req = framer.nextMsg()) != null) { 
              Console.WriteLine("Received message (" + req.Length + " bytes)");
              VoteMsg responseMsg = service.handleRequest(coder.fromWire(req));
                //发回反馈消息
              framer.frameMsg(coder.toWire(responseMsg));
            }
          } catch (SocketException soe) {
              //比如说客户端提发送多条消息，又在全部接收前关闭socket时就会引发此类异常。
            Console.WriteLine("Error handling client: " + soe.Message);
          } finally {
            Console.WriteLine("Closing connection");
            clntSock.Close();
          }
        }
      }
    }

    public class VoteMsgTextCoder : IVoteMsgCoder
    {
        // 下面是需要进行编码的字段
        public static readonly String MAGIC = "Voting";
        public static readonly String VOTESTR = "v";
        public static readonly String INQSTR = "i";
        public static readonly String RESPONSESTR = "R";

        public static readonly String DELIMSTR = " ";
        UTF8Encoding encoder = null;


        public static readonly int MAX_WIRE_LENGTH = 2000;


        public VoteMsgTextCoder()
        {
            encoder = new UTF8Encoding();
        }



        public byte[] toWire(VoteMsg msg)
        {
            String msgString = MAGIC + DELIMSTR + (msg.IsInquiry ? INQSTR : VOTESTR)
                + DELIMSTR + (msg.IsResponse ? RESPONSESTR + DELIMSTR : "")
                + msg.CandidateID.ToString() + DELIMSTR
                + msg.VoteCount.ToString();
            byte[] data = encoder.GetBytes(msgString);
            return data;
        }

        public VoteMsg fromWire(byte[] message)
        {

            bool isInquiry;
            bool isResponse;
            int candidateID;
            long voteCount;
            string token;

            string StringSentByClient = Encoding.UTF8.GetString(message);
            string[] fields = StringSentByClient.Split(new char[] { ' ' });

            try
            {
                token = fields[0];
                if (!token.Equals(MAGIC))
                {
                    throw new IOException("Bad magic string: " + token);
                }
                token = fields[1];
                if (token.Equals(VOTESTR))
                {
                    isInquiry = false;
                }
                else if (!token.Equals(INQSTR))
                {
                    throw new IOException("Bad vote/inq indicator: " + token);
                }
                else
                {
                    isInquiry = true;
                }

                token = fields[2];
                if (token.Equals(RESPONSESTR))
                {
                    isResponse = true;
                    token = fields[3];
                }
                else
                {
                    isResponse = false;
                }

                candidateID = int.Parse(token);
                if (isResponse)
                {
                    token = fields[4];
                    voteCount = long.Parse(token);
                }
                else
                {
                    voteCount = 0;
                }
            }
            catch (IOException ioe)
            {
                throw new IOException("Parse error...");
            }

            return new VoteMsg(isInquiry, isResponse, candidateID, voteCount);

        }
    }

[转载]用TCP/IP实现自己简单的应用程序协议:成帧器部分 – 浪雪 – 博客园.

IFramer接口的定义:

namespace VoteForMyProtocol
{
    public interface IFramer
    {
        void frameMsg(byte[] message);
        byte[] nextMsg();
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.IO;

namespace VoteForMyProtocol
{

    public class LengthFramer : IFramer {
        public static readonly int MAXMESSAGELENGTH = 65535;
        Socket s = null;

        public LengthFramer(Socket s)
        {
            this.s = s;
        }

        //把消息成帧并发送
        public void frameMsg(byte[] message){
            if (message.Length > MAXMESSAGELENGTH) {
              throw new IOException ("message too long");
            }

            int totalSent = 0;
            int dataLeft = message.Length;     //剩余的消息
            int thisTimeSent;
            //保存消息长度
            byte[] datasize = new byte[4];
            datasize = BitConverter.GetBytes(message.Length);
            //将消息长度发送出去
            thisTimeSent = s.Send(datasize);
            //发送消息剩余的部分
            while (totalSent < message.Length)
            {
                thisTimeSent = s.Send(message, totalSent, dataLeft, SocketFlags.None);
                totalSent += thisTimeSent;
                dataLeft -= thisTimeSent;
            }
        }

        //按帧来解析消息
        public byte[] nextMsg(){
            if (s == null)
                throw new ArgumentNullException("socket null");
            int total = 0;  //已接收的字节数
            int recv;
            //接收4个字节，得到“消息长度”
            byte[] datasize = new byte[4];

            //如果当前使用的是面向连接的 Socket，则 Receive 方法将读取所有可用的数据，直到达到 size 参数指定的字节数。
            //如果远程主机使用 Shutdown 方法关闭了 Socket 连接，并且所有可用数据均已收到，则 Receive 方法将立即完成并返回零字节。 
            recv = s.Receive(datasize, 0, 4, 0);
            if (recv < 4)
                return null;

            int size = BitConverter.ToInt32(datasize, 0);

            //按消息长度接收数据
            int dataleft = size;
            //容器装满了就证明收集到了一条完整的消息。
            byte[] data = new byte[size];
            //直到容器填满再返回
            while (total < size)
            {
                recv = s.Receive(data, total, dataleft, 0);
                total += recv;
                dataleft -= recv;
                if (dataleft == 0)
                {
                    break;
                }
            }
            return data;
        }

    }
}

[转载]Socket=>流，TCP连接,TCP可靠性概述 – 浪雪 – 博客园.

[转载]分组报文，协议和Socket的概念 – 浪雪 – 博客园.