异常处理其实很强大的 
catch(SocketException x){

if(x.ErrorCode == 10004){
}
}
 还有写自已的异常处理类

#region public enum ReadReplyCode

/// <summary>
/// Reply reading return codes.
/// </summary>
public enum ReadReplyCode
{
/// <summary>
/// Read completed successfully.
/// </summary>
Ok             = 0,

/// <summary>
/// Read timed out.
/// </summary>
TimeOut        = 1,

/// <summary>
/// Maximum allowed Length exceeded.
/// </summary>
LengthExceeded = 2,

/// <summary>
/// Connected client closed connection.
/// </summary>
SocketClosed = 3,

/// <summary>
/// UnKnown error, eception raised.
/// </summary>
UnKnownError   = 4,
}

#endregion

/// <summary>
/// Summary description for ReadException.
/// </summary>
public class ReadException : System.Exception
{
private ReadReplyCode m_ReadReplyCode;

/// <summary>
/// 
/// </summary>
/// <param name="code"></param>
/// <param name="message"></param>
public ReadException(ReadReplyCode code,string message) : base(message)
{
m_ReadReplyCode = code;
}

#region Properties Implementation

/// <summary>
/// Gets read error.
/// </summary>
public ReadReplyCode ReadReplyCode
{
get{ return m_ReadReplyCode; }
}

#endregion
ReadReplyCode replyCode = ReadReplyCode.Ok;

try{
_FixedStack stack = new _FixedStack(terminator);
long readedCount      = 0;
int  nextReadWriteLen = 1;
while(nextReadWriteLen > 0){
//Read byte(s)
byte[] b = new byte[nextReadWriteLen];
int countRecieved = this.Receive(b);
if(countRecieved > 0){
readedCount += countRecieved;

// Write byte(s) to buffer, if length isn't exceeded.
if(readedCount <= maxLength){
storeStream.Write(b,0,countRecieved);
}

// Write to stack(terminator checker)
nextReadWriteLen = stack.Push(b,countRecieved);
}
// Client disconnected
else{
return ReadReplyCode.SocketClosed;
}

OnActivity();
}
                
// Check if length is exceeded
if(readedCount > maxLength){
return ReadReplyCode.LengthExceeded;
}

// If reply is ok then remove chars if any specified by 'removeFromEnd'.
if(replyCode == ReadReplyCode.Ok && removeFromEnd.Length > 0){
storeStream.SetLength(storeStream.Length - removeFromEnd.Length);
}

// Logging stuff
if(m_pLogger != null){
if(storeStream is MemoryStream && storeStream.Length < 200){
MemoryStream ms = (MemoryStream)storeStream;
m_pLogger.AddReadEntry(m_pEncoding.GetString(ms.ToArray()));
}
else{
m_pLogger.AddReadEntry("Big binary, readed " + readedCount.ToString() + " bytes.");
}
}
}
catch(Exception x){
replyCode = ReadReplyCode.UnKnownError;

if(x is SocketException){
SocketException xS = (SocketException)x;
if(xS.ErrorCode == 10060){
return ReadReplyCode.TimeOut;
}
}
}

return replyCode;

这些问题全解决了 呵呵

老大是不是写得有点乱
_FixedStack是什么
你这段代码不好调试啊？再全一点好吗，老大

晕的_FixedStack是一个封装的byte位操作类，不用管他 
  只是一种处理思路，不是拿来调试的，不然又要一堆代码

up

LG

帮你顶

顶

帮你顶：）

帮我顶哈

up

顶起不放

帮你顶

这个代码写的确实有点乱。没空细心看的阿。

帮你顶

有两种方法：
   1：用try catch捕捉
   2：设置好要接收数据的总长度，当数据接收完后。数据是否达到要求，如未达到要求，则可知道对方，半路中断

catch(SocketException x){

if(x.ErrorCode == 10004){
}
}

我觉得这种方式最好，或者用个SWITCH，这样扩充性好，如果要扑捉新的错误，加个CASE很容易的

楼上两位朋友，你们用socket编程传输文件没有？

用try catch捕捉，发送端没有问题的，对方主动终止或线路断开都会抛出错误的!可以很好的处理。
关键是接收端：当只接收了部分数据时，对方主动终止或线路断开，                iNumByte=rBinarySocket.Receive(pBuf);不会抛出任何错误
如果这时线路断开它只有不停的循环接收。

while(uiTotal < uilength)
{
  ......
  iNumByte=rBinarySocket.Receive(pBuf);
  ......
  uiTotal+=iNumByte;
  Thread.Sleep(1);
}

UP

up

up

mark

up

up

帮你顶

mark

up

up

up

错误代码在:请参见 MSDN 中的 Windows Socket 2 版 API 错误代码文档。
我怎么找不到呢?