简体   繁体   中英

Waiting for messages on a StreamSocket in C#/Win8

I'm trying as a side project to build an IRC client in Windows 8 as a way to learn Network programming. However, I can't find the best way to structure the listener.

I have a class that creates a StreamSocket and connects to the server. Now I need to have my class listen for incoming messages from the server, and call back to a delegate when a message comes in. As far as I can tell, StreamSocket only gives me a way to pull whatever is currently waiting on the Socket, but not have some sort of a callback on an incoming message. What is the best way to do this?

I imagine you will implement this as a Windows Service, so your code will look a lot like the below. Much of this is infrastructure to let you debug a service easily. I know it pollutes the example but not having it is far too much work.

The service implementation is in a library rather than directly in the service host because I often write services that publish interfaces via WCF and it's less hassle to always separate host from service.

Service host

using IrcServiceLibrary;
using System.Collections.Generic;
using System.ServiceProcess;
using System.Threading;
using System.Xml;

namespace IrcServiceHost
{
  internal static class Program
  {
    /// <summary>
    /// Launches as an application when an argument "app" is supplied.
    /// Otherwise launches as a Windows Service.
    /// </summary>
    private static void Main(string[] arg)
    {
      var args = new List<string>(arg);
      ServiceBase[] ServicesToRun = new ServiceBase[]
      {
        new IrcServiceLibrary.Irc(
            Properties.Settings.Default.IrcTcpPort)
          };
      if (args.Contains("app"))
      {
        foreach (IExecutableService es in ServicesToRun)
          es.StartService();
        Thread.Sleep(Timeout.Infinite);
      }
      else
      {
        ServiceBase.Run(ServicesToRun);
      }
    }
  }
}

Session establishment

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.ServiceModel;
using System.ServiceProcess;
using System.Threading;

namespace IrcServiceLibrary
{
  /// <summary>
  /// Listens for TCP connection establishment and creates an 
  /// IrcSession object to handle the test session.
  /// </summary>
  [ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple, InstanceContextMode = InstanceContextMode.Single)]
  public partial class Irc : ServiceBase, IExecutableService
  {
    AutoResetEvent _autoResetEvent = new AutoResetEvent(false);
    TcpListener _tcpListener;
    List<IrcSession> _sessions = new List<IrcSession>();

    /// <summary>
    /// Creates Irc and applies configuration supplied by the service host.
    /// </summary>
    /// <param name="tcpPort">Port on which the session is established.</param>
    public Irc(int tcpPort)
    {
      Trace.TraceInformation("NetReady service created {0}", GetHashCode());
      InitializeComponent();
      _tcpListener = new TcpListener(IPAddress.Any, tcpPort); 
      NetReadySession.Sessions = _sessions;
    }

    void AcceptTcpClient(IAsyncResult asyncResult)
    {
      var listener = asyncResult.AsyncState as TcpListener;
      var tcpClient = listener.EndAcceptTcpClient(asyncResult);
      try
      {
        new NetReadySession(tcpClient);
      }
      catch (IndexOutOfRangeException)
      {
        //no free session - NetReadySession ctor already informed client, no action here
      } 
      _tcpListener.BeginAcceptTcpClient(AcceptTcpClient, _tcpListener);
    }

    /// <summary>
    /// <see cref="StartService">ServiceStart</see> 
    /// </summary>
    /// <param name="args">Arguments passed by the service control manager</param>
    protected override void OnStart(string[] args)
    {
      StartService();
    }

    /// <summary>
    /// <see cref="StopService">ServiceStop</see> 
    /// </summary>
    protected override void OnStop()
    {
      StopService();
    }

    void Execute(object state)
    {
      Trace.TraceInformation("IRC service started");
      _tcpListener.Start();
      _tcpListener.BeginAcceptTcpClient(AcceptTcpClient, _tcpListener);
      _autoResetEvent.WaitOne();
      _tcpListener.Stop();
    }

    internal static int UdpPortLow { get; set; }

    internal static int UdpPortHigh { get; set; }

    /// <summary>
    /// Starts the service. OnStart uses this method to implement startup behaviour.
    /// This guarantees identical behaviour across application and service modes.
    /// </summary>
    public void StartService()
    {
      ThreadPool.QueueUserWorkItem(Execute);
    }

    /// <summary>
    /// Stops the service. OnStop uses this method to implement shutdown behaviour.
    /// This guarantees identical behaviour across application and service modes.
    /// </summary>
    public void StopService()
    {
      _autoResetEvent.Set();
    }
  }
}

Session behaviour

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace IrcServiceLibrary
{
  public class IrcSession
  {    
    /// <summary>
    /// Exists to anchor sessions to prevent premature garbage collection
    /// </summary>
    public static List<IrcSession> Sessions;
    TcpClient _tcpClient;
    NetworkStream _stream;
    byte[] _buf; //remain in scope while awaiting data

    /// <summary>
    /// Created dynamically to manage an Irc session. 
    /// </summary>
    /// <param name="tcpClient">The local end of the TCP connection established by a test client 
    /// to request and administer a test session.</param>
    public IrcSession(TcpClient tcpClient)
    {
      Sessions.Add(this);
      _tcpClient = tcpClient;
      _stream = _tcpClient.GetStream();
      _buf = new byte[1];
      _stream.BeginRead(_buf, 0, 1, IncomingByteHandler, _buf);
    }

    void IncomingByteHandler(IAsyncResult ar)
    {
      byte[] buf = ar.AsyncState as byte[];
      try
      {
        byte[] buf = ar.AsyncState as byte[];
        int cbRead = _stream.EndRead(ar);
        //do something with the incoming byte which is in buf
        //probably feed it to a state machine
      }
      finally
      {
        //restart listening AFTER digesting byte to ensure in-order delivery to this code
        _stream.BeginRead(buf, 0, 1, IncomingByteHandler, buf);
      }
    }

  }
}

The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM