C# tcp stream - is it possible to run stream without listener?

Question

I want to write a part of code in which I start sending packages using tcp stream, but without any part that receives it over the internet. In the meantime I would also like to have another method that can connect to that particular stream at any time and starts receiving bytes from the moment it connects. I wanted to use multicasting, but I see it's impossible to do it over the Internet Is there a way to do it? I only found some info so far, that the tcp connection in C# uses point to point way, so my case sounds impossible to implement, because the listener has to be always active to even initialize the streamer, how can I bypass that?

Answer 1

Edit Added an example of a simply "broker" who republishes all messages it receives.

Either use UDP and broadcast your packets to an endpoint that may or maynot be listening at any point in time.

Or use a message queue such as MSMQ, RabbitMQ or 0MQ.

MSMQ may become a problem if the listening service is offline for to long as the messages queue on your dispatch system resulting in a backlog that may fill.

If you would like to create something using UDP here is some code.

Listener (server):

using System;
using System.Text;
using System.Net;
using System.Net.Sockets;

namespace UDPLISTENER
{
    class Program
    {
        static void Main(string[] args)
        {
            var port = 8750;
            var listener = new UdpClient(port);
            var group = new IPEndPoint(IPAddress.Any, port);

            Console.WriteLine("Listening for datagrams on port {0}", port);
            while(true)
            {
                var data = listener.Receive(ref group);
                Console.WriteLine("{0}: {1}", group.ToString(), Encoding.Default.GetString(data, 0, data.Length));
            }
        }
    }
}

Broker (Server&Client):

sing System;
using System.Text;
using System.Net;
using System.Net.Sockets;

namespace UDPCLIENT
{
    class Program
    {
        static void Main(string[] args)
        {
            int listeningPort = 8749, dispatchPort = 8750;
            var listener = new UdpClient(listeningPort);
            var group = new IPEndPoint(IPAddress.Any, listeningPort);

            // Republish client
            var sender = new UdpClient("127.0.0.1", dispatchPort);

            Console.WriteLine("Listening for datagrams on port {0}", listeningPort);
            while (true)
            {
                var data = listener.Receive(ref group);
                Console.WriteLine("{0}: {1}", group.ToString(), Encoding.Default.GetString(data, 0, data.Length));
                sender.Send(data, data.Length);
            }
        }
    }
}

Sender (Client):

using System;
using System.Text;
using System.Net;
using System.Net.Sockets;

namespace UDPSENDER
{
    class Program
    {
        static void Main(string[] args)
        {
            var sender = new UdpClient("127.0.0.1", 8749);

            while (true)
            {
                Console.WriteLine("Message: ");
                var data = Encoding.Default.GetBytes(Console.ReadLine());
                sender.Send(data, data.Length);
            }
        }
    }
}

Depending what you wish to archive I recommend message queues they give to the most flexibility.

But as you can see UDP works a bit differently to TCP. You don't need a handshake like TCP does, this means if no one is listening to your messages they vanish with no cost to the sender (there is still cost to the network). But if a listener pops up then they start consuming the messages right away. Remember no UDP packet is guaranteed delivery, this is both a blessing and a curse.

If you want messages to be guaranteed you need to implement your own solution, one method is a counter on the datagrams that the listener watches if there is a message missing then it request that message be resent.

Answer 2

You can create a new class derived from Stream, override the Write method, and manage the writing to the tcp clients here. You will be able to write to this stream from your code whether a client is connected or not. When no client is connected, the data will simply be ignored.