client.SendFile("1");
client.SendFile("2");
client.SendFile("3");

   private void ConnectionCallback(IAsyncResult ar)
    {
      TcpListener listener = (TcpListener)ar.AsyncState;
      try
      {
        Socket s = listener.EndAcceptSocket(ar);
        new Func<Socket, byte[]>(HandleSocketComms).BeginInvoke(
          s,
          new AsyncCallback(HandleSocketCommsCallback),
          s);
      }
      catch
      {
        //You should handle this but this should be a _rare_ error
        throw;
      }
      finally
      {
        //Prime up the listener to accept another inbound request
        listener.BeginAcceptSocket(new AsyncCallback(ConnectionCallback), listener);
      }
    }

      using (MemoryStream ms = new MemoryStream()) //This may be a bad idea for big files :)

public class OnFileReceivedArgs : EventArgs
  {
    private byte[] _buffer;
    public byte[] Buffer { get { return _buffer; } }
 
    private string _FilePath;
    public string FilePath { get { return _FilePath; } }
 
    private OnFileReceivedArgs()
      : base()
    {
    }
    public OnFileReceivedArgs(byte[] buffer)
      : this()
    {
      this._buffer = buffer;
    }
 
    public OnFileReceivedArgs(string filePath)
        : this()
    {
        this._FilePath = filePath;
    }
  }

  private void ConnectionCallback(IAsyncResult ar)
    {
      TcpListener listener = (TcpListener)ar.AsyncState;
      try
      {
        Socket s = listener.EndAcceptSocket(ar);
        new Func<Socket, string>(HandleSocketComms).BeginInvoke(
          s,
          new AsyncCallback(HandleSocketCommsCallback),
          s);
 
 
      }
      catch
      {
        //You should handle this but this should be a _rare_ error
        throw;
      }
      finally
      {
        //Prime up the listener to accept another inbound request
        listener.BeginAcceptSocket(new AsyncCallback(ConnectionCallback), listener);
      }
    }

private string HandleSocketComms(Socket s)
    {
      //Dont do any exception handling here
      TrackThread();
      string tempfileloc = Path.GetTempFileName();
      using (FileStream ms = new FileStream(tempfileloc, FileMode.Create, FileAccess.Write)) //This may be a bad idea for big files :)
      {
        do
        {
          int szToRead = s.Available;
          byte[] buffer = new byte[szToRead];
 
          int szRead = s.Receive(buffer, szToRead, SocketFlags.None);
          if (szRead > 0)
          {
            ms.Write(buffer, 0, szRead);
            Console.WriteLine("Read " + szRead.ToString());
          }
        }
        while (SocketConnected(s));
 
        return tempfileloc;
      }
      //return result;
    }

 private void HandleSocketCommsCallback(IAsyncResult ar)
    {
      byte[] file = null;
      string filepath = "";
      bool error = false;
 
      try
      {
        AsyncResult result = (AsyncResult)ar;
        var del = (Func<Socket, string>)result.AsyncDelegate;
        filepath = del.EndInvoke(ar);
 
        Socket s = (ar.AsyncState as Socket);
        if (s != null)
        {
          //Sockets throw exceptions++ when disposed
          try
          {
            s.Close(0);
            ((IDisposable)s).Dispose();
          }
          catch { }
        }
      }
      catch (ThreadAbortException) //When we stop our server
      {
        //We were killed! Just let it die out
        error = true;
      }
      catch
      {
        //Might want to handle this
        error = true;
      }
      finally
      {
        RemoveThread(); //conn is closed at this point
        //if (!error && (file != null) && (file.Length > 0))
        if (!error)
        {
          var del = this.OnFileReceived;
          if (del != null)
            del(this, new OnFileReceivedArgs(filepath));
        }
      }
    }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Xml.Serialization;
 
namespace ClientServer.Common
{
  public enum CommandType
  {
    SendFile
  }
  public class Command
  {
 
    /// <summary>
    /// When this byte collection is hit you know you have received a command
    /// </summary>
    public static readonly byte[] COMMAND_DELIM = new byte[] { 7, 9, 13, 10, 10, 13 }; //This is invalid inside an XML document so its "good-enough"
 
 
    public CommandType CommandCode { get; set; }
    /// <summary>
    /// File size in bytes
    /// </summary>
    public int FileSize { get; set; }
    public string FileName { get; set; }
    public Command()
    {
    }
 
    public byte[] Serialize()
    {
      using (MemoryStream ms = new MemoryStream())
      {
        XmlSerializer ser = new XmlSerializer(typeof(Command));
        ser.Serialize(ms, this);
        return ms.ToArray();
      }
    }
 
    public static Command FromBuffer(byte[] buffer)
    {
      using (MemoryStream ms = new MemoryStream(buffer))
      {
        return FromStream(ms);
      }
    }
    public static Command FromStream(Stream s)
    {
      s.Seek(0, SeekOrigin.Begin);
      s.Position = 0;
      XmlSerializer ser = new XmlSerializer(typeof(Command));
      return (Command)ser.Deserialize(s);
    }
  }
}