小编rem*_*dao的帖子

delegate void DelegateTest();

DelegateTest delTest;

电话delTest.Invoke()和delTest()？之间的区别是什么？两者都会在当前线程上执行委托,对吧？

http://msdn.microsoft.com/en-us/library/system.net.sockets.socketasynceventargs.aspx

从上面的msdn示例开始,我正在尝试编写一个超时检查,它将关闭非活动的客户端套接字并释放资源.

这就是我想出的.但我不确定它是否完全是线程安全的,如果有更好的方法可以做到这一点.我希望有人可以给出一些建议.

void IO_Completed(object sender, SocketAsyncEventArgs e)
{
    if (e.SocketError != SocketError.Success)
    {
        CloseClientSocket(e);
        return;
    }

    if (1 < Interlocked.CompareExchange(ref token.Status, 1, 0))
        return;

    switch (e.LastOperation)
    {
        case SocketAsyncOperation.Receive:
            ProcessReceive(e);
            break;
        ...
    }

    token.LastActive = Environment.TickCount;
    Interlocked.CompareExchange(ref token.Status, 0, 1);
}

void ProcessReceive(SocketAsyncEventArgs e)
{
    AsyncUserToken token = (AsyncUserToken)e.UserToken;
    if (e.BytesTransferred > 0)
        if (!token.Socket.SendAsync(e))
            ProcessSend(e);
    else
        CloseClientSocket(e);
}

void ProcessSend(SocketAsyncEventArgs e)
{
    AsyncUserToken token = (AsyncUserToken)e.UserToken;
    if (!token.Socket.ReceiveAsync(e))
        ProcessReceive(e);
}

TimeoutCheck将每20秒执行一次.allReadWriteArgs是一个包含所有SocketAsyncEventArgs的数组.关闭套接字后,将使用SocketError.OperationAborted调用IO_Completed.

void TimeoutCheck(object state)
{
    AsyncUserToken token;
    int …

我正在编写一个只使用一个套接字的简单套接字客户端.所以我想我可以为所有接收操作重用一个SocketAsyncEventArgs.只要连接插座,它就能正常工作.当服务器断开连接时,客户端将在控制台中输入无限接收循环垃圾邮件"接收成功".

当套接字断开连接时,e.SocketError!= SocketError.Success是不是真的？

以下是代码的一部分:

private void Completed(object sender, SocketAsyncEventArgs e)
{
   if (e.SocketError != SocketError.Success)
      status = 0;

   System.Console.WriteLine(e.LastOperation + " " + e.SocketError);

   if (status == 1)
   {
      switch (e.LastOperation)
      {
         case SocketAsyncOperation.Connect:
            ProcessConnect(e);
            break;
         case SocketAsyncOperation.Receive:
            ProcessReceive(e);
            break;
         case SocketAsyncOperation.Send:
            ProcessSend(e);
            break;
         default:
            status = 0;
            break;
      }
   }

   if (status != 1)
      CloseSocket();
}

private void ProcessReceive(SocketAsyncEventArgs e)
{
   if (!socket.ReceiveAsync(e))
      Completed(null, e);
}

我正在编写一个通用类,我需要使用Interlocked.

T test1, test2;
Interlocked.Exchange<T>(ref test1, test2);

这不会编译.所以我被迫使用Exchange(对象,对象)而不是MSDN建议不要那样使用它？

我需要一种方法将对象强制转换为在编译时不知道的类型.

这样的事情:

object obj;

public (type of obj) Obj
{
    get
    {
        return obj
    }
    set
    {
        obj = (type of obj)value;
    }
}

唯一知道的是obj是一种值类型.

我怀疑这样的事情是可能的.只是检查一下是否有人聪明地做这件事.

我正在编写一个与本地sql server通信的服务器应用程序.

每个客户端都需要读取或写入数据库.

拥有一个可以在单个sql连接上排队并执行sql命令的线程安全类会更好吗？或者我应该为每个命令打开一个新连接？性能是否重要？

有谁知道这段代码是否是线程安全的,或者在调用timer2.Change时是否必须使用锁？

Timer timer1 = new Timer(timerCallback1);
Timer timer2 = new Timer(timerCallback2);
timer1.Change(5000, 5000);
timer2.Change(3000, 3000);

public void timerCallback1(object state)
{
    timer1.Change(Timeout.Infinite, Timeout.Infinite);
    timer2.Change(Timeout.Infinite, Timeout.Infinite);

    DoStuff();

    timer1.Change(5000, 5000);
    timer2.Change(3000, 3000);
}

对32位字段的读操作是原子的.因此,如果队列持有对象引用,Queue.Peek方法应该是线程安全的,对吧？

在接收操作中应该期望的最大数据大小是多少？必须发送的数据非常大,但在某些时候我会猜到数据包碎片？