标签: asyncsocket

我正在尝试在模拟器上运行iPhone程序.我的问题是接收UDP数据.我使用asyncUdpSocket.如果我做一个插座并使用sendData:(NSData) toHost:,......好吧它工作正常.

想想我可能无法弄清楚接收功能是如何工作的.

我假设这样的事情:

socket = [[AsyncUdpSocket alloc] initWithDelegate:self];
[socket bindToPort:8000] error:nil] //returns YES
[socket receiveWithTimeout:-1 tag:1];  

我相信它应该调用该方法 -(BOOL)onUdpSocket:(AsyncUdpSocket *)sock didReceiveData:(NSData *)data withTag:(long) fromHost:(NSString *)host port:(UInt16)port

好吧,我在该方法中放置了一个NSLog,它永远不会被调用.那么[socket receive,..]是唯一的接收方法,所以我想它应该是那个...或者是否有另一种方法我必须使用？或者我必须为我的代表或其他任何东西做一些补充......我只是无法弄清楚我是如何做到的

我搜索了asyncUdpSocket示例,教程,如何('s)等等,但我找不到一个例子.因此,如果有人想解释它或知道坐在一个很好的解释,将非常感激.

如果您还不知道答案,那么无论如何都要阅读!

通常,在附加调试器时,即使"异常"对话框在"已抛出"列中没有异常类型的勾号,Visual Studio 2010也会在未处理的异常处停止.这里的关键字未处理; 所述对话框仅指处理的异常.

但是,在下面的最小示例中,Visual Studio 2010不会停止在我的异常,即使它作为第一次机会异常出现在立即窗口中:

编辑:我发布的第一个最小的例子是我收到的第一个答案修复,但不幸的是下面的例子仍然显示问题:

using System;
using System.Net.Sockets;

namespace SocketTest
{
    class Program
    {
        static void Main(string[] args)
        {
            var listener = new TcpListener(8080);
            listener.Start();
            AsyncCallback accepter = null;
            accepter = ar =>
            {
                var socket = listener.EndAcceptSocket(ar);
                var buffer = new byte[65536];
                AsyncCallback receiver = null;
                receiver = ar2 =>
                {
                    var bytesRead = socket.EndReceive(ar2);
                    throw new InvalidOperationException();
                    socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, receiver, null);
                };
                socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, receiver, null);
                listener.BeginAcceptSocket(accepter, null); …

我一直在寻找有关如何处理TCP消息框架的示例.我看到许多示例,其中NetworkStreams被传递到StreamReader或StreamWriter对象,然后使用ReadLine或WriteLine方法来处理'\n'分隔的消息.我的应用程序协议包含以'\n'结尾的消息,因此NetworkStream似乎是最佳选择.但是,我找不到任何关于正确处理所有这些与异步套接字相结合的方法的具体示例.当下面调用ReceiveCallback()时,如何实现NetworkStream和StreamReader类来处理消息框架？根据我所读到的内容,我可以在一次接收中获取一条消息的一部分,并在下一次接收时获取剩余的消息(包括'\n').这是否意味着我可以得到一条消息的结尾和下一条消息的一部分？当然,必须有一种更简单的方法来处理这个问题.

我有以下代码:

    private void StartRead(Socket socket)
    {
        try
        {
            StateObject state = new StateObject();
            state.AsyncSocket = socket;

            socket.BeginReceive(state.Buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
        }
        catch (SocketException)
        {
            m_Socket.Shutdown(SocketShutdown.Both);
            Disconnect();
        }
    }

    private void ReceiveCallback(IAsyncResult ar)
    {
        try
        {
            StateObject state = (StateObject)ar.AsyncState;

            int bytes_read = state.AsyncSocket.EndReceive(ar);

            char[] chars = new char[bytes_read + 1];
            System.Text.Decoder decoder = System.Text.Encoding.UTF8.GetDecoder();
            int charLength = decoder.GetChars(state.Buffer, 0, bytes_read, chars, 0);

            String data = new String(chars);

            ParseMessage(data);

            StartRead(state.AsyncSocket);
        }
        catch (SocketException)
        {
            m_Socket.Shutdown(SocketShutdown.Both);
            Disconnect();
        } …

我正在用c/c ++编写兼容POSIX的多线程服务器,它必须能够异步地接受,读取和写入大量连接.服务器有几个工作线程,它们执行任务,偶尔(和不可预测)队列数据写入套接字.客户端偶尔(并且不可预测地)将数据写入套接字,因此服务器也必须异步读取.一种显而易见的方法是为每个连接提供一个从其套接字读取和写入的线程; 但这很丑陋,因为每个连接可能会持续很长时间,因此服务器可能必须保持数百或数千个线程才能跟踪连接.

更好的方法是使用select()/ pselect()函数处理所有通信的单个线程.即,单个线程在任何套接字上等待可读,然后生成一个作业来处理输入,当输入可用时,该输入将由其他线程池处理.只要其他工作线程为连接生成输出,它就会排队,并且通信线程在写入之前等待该套接字可写.

这个问题是当输出由服务器的工作线程排队时,通信线程可能在select()或pselect()函数中等待.有可能的是,如果几秒钟或几分钟没有输入,则排队的输出块将等待通信线程完成select()ing.但这不应该发生 - 数据应该尽快写入.

现在我看到一些线程安全的解决方案.一种是使通信线程忙 - 等待输入并更新它每隔十分之一秒左右写入的套接字列表.这不是最佳的,因为它涉及忙碌等待,但它会起作用.另一个选择是使用pselect()并在新输出排队时发送USR1信号(或等效的东西),允许通信线程立即更新它正在等待可写状态的套接字列表.我更喜欢后者,但仍然不喜欢使用信号作为条件(pthread_cond_t).另一种选择是在select()等待的文件描述符列表中包含一个虚拟文件,只要需要将套接字添加到select()的可写fd_set中,我们就会写入单个字节; 这会唤醒通信服务器,因为那个特定的虚拟文件可以读取,从而允许通信线程立即更新它的可写fd_set.

我觉得直觉上,第二种方法(使用信号)是对服务器进行编程的"最正确"方式,但我很好奇是否有人知道上述哪一种最有效,一般来说,无论是否以上将导致我不知道的竞争条件,或者是否有人知道这个问题的更一般的解决方案.我真正想要的是一个pthread_cond_wait_and_select()函数,它允许comm线程等待套接字的更改或来自条件的信号.

提前致谢.

据我了解,可以在PHP 5.x中创建一个非阻塞网络套接字.

但是如果脚本使用相同的非阻塞套接字发送几条长消息,会发生什么？

socket_write($socket, $string1, $length);
socket_write($socket, $string2, $length);
socket_write($socket, $string3, $length);
socket_write($socket, $string4, $length);

这些消息是否排队(在发送方/接收方？)或接收方是否可能因为发送"并行"而获取不同消息的一部分？

例如:接收器是否有可能获得10个字节的$ string1,然后30个字节的$ string2,然后是另外25个字节的$ string1 ......依此类推......

我正在使用NetworkStream.BeginRead异步读取Socket.

但是,如果你真的用一个网络流包裹网络流,它会快得多BufferedStream.

我的问题:NetworkStream.BeginRead内部调用Socket.BeginReceive和整个堆栈的异步IO(Windows上的CompletionPorts等).BufferedStream在中间是否会发生同样的事情？

我试图了解asyncio库,特别是使用套接字.我写了一些代码以试图获得理解,

我想异步运行发送器和接收器套接字.我到了最后一个发送所有数据的地步,但是我必须再运行一个循环.看看如何做到这一点,我从stackoverflow找到了这个链接,我在下面实现了 - 但是这里发生了什么？是否有更好/更理智的方式来做到这一点,而不是打电话stop跟随run_forever？

stop()事件循环中的文档是:

停止运行事件循环.

调用stop()之前安排的每个回调都将运行.调用stop()后调度的回调将不会运行.但是,如果稍后再次调用run_forever(),那些回调将会运行.

而且run_forever()的文件是:

运行直到调用stop().

问题:

• 为什么世界上run_forever唯一的出路run_once？这甚至没有意义
• 有一个更好的方法吗？
• 我的代码看起来像是使用asyncio库编程的合理方式吗？
• 是否有更好的方法将事件添加到事件循环中asyncio.async()？loop.create_task在我的Linux系统上出错.

https://gist.github.com/cloudformdesign/b30e0860497f19bd6596

与使用(双向)NetworkStream的异步IO相关,MSDN表示"每次调用BeginRead都必须调用一次EndRead".

即使在EndRead()将抛出异常的情况下也是如此,例如在发布BeginRead()之后NetworkStream已关闭的情况下？

我不想要抛出异常的开销,但我也不想泄漏BeginRead()保留的OS宝贵资源.

我也知道流可以在流的状态测试和条件EndRead()之间关闭,但是如果我们知道流被关闭时可以省略EndRead(),那么将节省大多数情况下的异常处理.

我做错了吗？

谢谢!

我已经看到很多关于处理套接字而没有对象处理异常的问题,所以我决定对它进行一次破解,看看是否可以完成.以下是我的发现.

问题？

您有一段代码使用来自System.Net.Sockets的Socket作为服务器套接字.问题是你想要关闭套接字,每次尝试时都会遇到ObjectDisposedException.

您的代码可能如下所示:

    private static ManualResetEvent allDone = new ManualResetEvent(false);
    private Socket ear;
    public void Start()
    {
        new Thread(() => StartListening()).Start();
    }

    private void StartListening()
    {
        IP = Dns.GetHostAddresses(Dns.GetHostName()).Where(address => address.AddressFamily == AddressFamily.InterNetwork).First();
        port = 11221;
        IPEndPoint localEndPoint = new IPEndPoint(IP, Port);
        ear = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        ear.Bind(localEndPoint);
        ear.Listen(100);
        try
        {

            while (true)
            {
                allDone.Reset();
                ear.BeginAccept(new AsyncCallback(AcceptCallback), ear);
                allDone.WaitOne();
            }
        }
        catch (ObjectDisposedException e)
        {
            Console.WriteLine("Socket Closed");
        }
    }

    private void AcceptCallback(IAsyncResult ar)
    {
        allDone.Set();
        Socket listener = …

我习惯于同步套接字，并且在达到现在的水平时遇到了一些头痛，尤其是Socket.Receive(..)并不总是接收所有字节

这是我以前使用的代码

    public byte[] Receive(int size)
    {
        var buffer = new byte[size];
        var r = 0;
        do
        {
            // ReSharper disable once InconsistentlySynchronizedField
            var c = _clientSocket.Receive(buffer, r, size - r, SocketFlags.None);
            if (c == 0)
            {
                throw new SocketExtendedException();
            }
            r += c;
        } while (r != buffer.Length);
        return buffer;
    }

现在我开始在 Windows Phone 中使用套接字，但.Receive(..)不可用，我设法开始工作Socket.ReceiveAsync(..)，但我担心（到目前为止没有发生问题）这是我的新代码，我还没有实现检查是否已收到所有字节我也不知道是否必须使用以下代码

    private byte[] ReadBySize(int size = 4)
    {
        var readEvent = new AutoResetEvent(false);
        var buffer = new byte[size];
        var …