1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:

using System;
using System.Threading;
using System.Net;
using System.IO;
using System.Net.Sockets;
using System.Text;

//EventArgs-Ableitung
public class SpesenThreadArgs : EventArgs
{
    private string FMessage;
    
    public SpesenThreadArgs(string AMsg)
    {
        FMessage = AMsg;
    }

    public string Message
    {
        get
        {
            return FMessage;
        }
    }
}

public class SpesenThread
{
    private TcpClient TL;
    private byte[] ReceiveBuffer;
    private Stream TcpStream;

    private string FTargetIP;
    private int FTargetPort;
    private volatile bool IsTerminated;

    private string Message;
    //Unser Eventhandler, damit wir Empfangsdaten hochbubblen können
    public delegate void SpesenEventHandler(SpesenThreadArgs e);
    public event SpesenEventHandler OnReceiveData;

    public SpesenThread(string TargetIP, int TargetPort)
    {
        FTargetIP=TargetIP;
        FTargetPort=TargetPort;
        ReceiveBuffer = new byte[100];
        TL = new TcpClient();
        TL.ReceiveTimeout = 250;
        IsTerminated = false;
    }

    //Eventhandler
    public void OnReceived(SpesenThreadArgs e)
    {
        if (OnReceiveData != null)
            OnReceiveData(e);
    }

    public void Terminate()
    {
        IsTerminated = true;
    }

    public void WorkerMethod()
    {
        int RcvCount;
        ASCIIEncoding enc;

        enc = new ASCIIEncoding();

        while (!IsTerminated)
        {
            if (!TL.Connected)
            {
                //Is this blocking ? We will find out...
                //It is blocking. And throws an Exception when connection can't be established
                try
                {
                    TL.Connect(FTargetIP, FTargetPort);
                    TcpStream = TL.GetStream();
                }
                catch
                {
                    //Just eat the Exception, so we can try again to connect
                }
            }
            else
            {
                //We are connected, so lets handle incoming Data
                //is this blocking, too ? We will find out...
                try
                {
                    RcvCount = TcpStream.Read(this.ReceiveBuffer, 0, 100);
                }
                catch(IOException)
                {
                    //Receive-Timeout: No data available
                    RcvCount = 0;
                    //Alle anderen Exceptions gehen nach oben
                }
                if (RcvCount > 0)
                {
                    //Wie cool ist denn dieses ASCIIEncoding ?!? Brauch ma in Delphi !!!
                    Message = enc.GetString(ReceiveBuffer, 0, RcvCount);
                    //PostMessage ?!? Statt dessen nehmen wir unseren Eventhandler
                    OnReceived(new SpesenThreadArgs(Message));
                }
            }
        }
    }

}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

        private void button1_Click(object sender, RoutedEventArgs e)
        {
            ST = new SpesenThread("10.0.0.1", 28416);
            ST.OnReceiveData += OnReceiveData;
            ts = new ThreadStart(ST.WorkerMethod);
            TCPThread = new Thread(ts);
            TCPThread.Start();
        }
        public void OnReceiveData(SpesenThreadArgs e)
        {
            MessageBox.Show("Received: " + e.Message);
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            if (ST != null)
            {
                ST.Terminate();
                if (!TCPThread.Join(1000))
                    TCPThread.Abort();
            }
        }					

1:
2:
3:
4:
5:
6:

public void OnReceived(SpesenThreadArgs e)
{
   var tmp = OnReceiveData;
   if (tmp != null)
       tmp (this, e);
}					

1:
2:
3:
4:
5:

        public void OnReceiveData(Object sender, SpesenThreadArgs e)
        {
            //this.BeginInvoke, this.InvokeRequired, this.Invoke - alles unbekannt
            MessageBox.Show("Received: " + e.Message);
        }					

1:
2:
3:
4:
5:
6:
7:

    //Eventhandler
    public void OnReceived(SpesenThreadArgs e)
    {
        //Ebenfalls alles unbekannt, wie in OnReceiveData des Hauptformulars auch
        if (OnReceiveData != null)
            OnReceiveData(e);
    }					

1:

 this.Dispatcher.Invoke(() => this.MeinLiebesLabel.Text = "Received: " + e.Message);					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:

using System;
using System.Threading;
using System.Net;
using System.IO;
using System.Net.Sockets;
using System.Text;
using System.Collections.Concurrent;

//EventArgs-Ableitung
public class RDLHandlerArgs : EventArgs
{
    private string Msg;
    
    public RDLHandlerArgs(string AMsg) { Msg = AMsg; }
    public string Message { get { return Msg; } }
}

public class RDLHandler
{
    private TcpClient TL;
    private byte[] ReceiveBuffer;
    private Stream TcpStream;
    public ConcurrentQueue<string> Queue;
    public Object RDLLock;

    private string TargetIP;
    private int TargetPort;
    private volatile bool IsTerminated;

    private string Message;
    //Unser Eventhandler, damit wir Empfangsdaten hochbubblen können
    public event EventHandler<RDLHandlerArgs> OnReceiveData;

    public RDLHandler(string IP, int Port)
    {
        TargetIP=IP;
        TargetPort=Port;
        ReceiveBuffer = new byte[100];
        IsTerminated = false;
    }

    //Eventhandler
    public void OnReceived(RDLHandlerArgs e)
    {
        var tmp = OnReceiveData;
        if (tmp != null)
            tmp(this, e);
    }

    public void Terminate()
    {
        IsTerminated = true;
    }

    public void DoRDLHandling()
    {
        int RcvCount;
        ASCIIEncoding enc = new ASCIIEncoding();

        RDLLock = new Object();
        Queue = new ConcurrentQueue<string>();

        using (TL = new TcpClient())
        {
            TL.ReceiveTimeout = 250;
            while (!IsTerminated)
            {
                if (!TL.Connected)
                {
                    try
                    {
                        TL.Connect(TargetIP, TargetPort);
                        TcpStream = TL.GetStream();
                    }
                    catch (SocketException)
                    {
                        //Just eat the SocketException, so we can try again to connect
                    }
                }
                else
                {
                    //We are connected, so lets handle incoming Data
                    try
                    {
                        RcvCount = TcpStream.Read(this.ReceiveBuffer, 0, 100);
                    }
                    catch (IOException)
                    {
                        //Receive-Timeout: No data available
                        RcvCount = 0;
                    }
                    if (RcvCount > 0)
                    {
                        Message = enc.GetString(ReceiveBuffer, 0, RcvCount);
                        lock (RDLLock)
                        {
                            Queue.Enqueue(Message);
                        }
                        OnReceived(new RDLHandlerArgs(Message));
                    }
                }
            }
            //Stream has to be closed manually
            if (TL.Connected)
                TcpStream.Close();
        }
    }

}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:

    public partial class MainWindow : Window
    {
        RDLHandler RDH;
        ThreadStart ts;
        Thread TCPThread;

        public MainWindow()
        {
            InitializeComponent();
        }

        public void OnReceiveData(Object sender, RDLHandlerArgs e)
        {
            this.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal, new Action( delegate() 
            {
                MessageBox.Show("Received: " + e.Message);
               
            }
            ));
        }

        private void button1_Click(object sender, RoutedEventArgs e)
        {
            RDH = new RDLHandler("192.168.0.19", 4226);
            RDH.OnReceiveData += OnReceiveData;

            ts = new ThreadStart(RDH.DoRDLHandling);
            TCPThread = new Thread(ts);
            TCPThread.Start();
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            if (RDH != null)
            {
                RDH.Terminate();
                if (!TCPThread.Join(1000))
                    TCPThread.Abort();
            }
        }
    }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:

public class RDLHandlerEventArgs : EventArgs
{
    private string _message;

    public string Message
    {
        get { return _message; }
    }

    public RDLHandlerEventArgs(string message)
    {
        _message = message;
    }
}

public class RDLHandler
{
    private readonly string _targetIp;
    private readonly int _targetPort;
    private volatile bool _isTerminated;

    public ConcurrentQueue<string> Queue { get; set; }
    public bool IsTerminated
    {
        get { return _isTerminated; }
    }

    public event EventHandler<RDLHandlerEventArgs> ReceiveDataEvent;

    public RDLHandler(string ip, int port)
    {
        _targetIp = ip;
        _targetPort = port;
    }

    public void Terminate()
    {
        _isTerminated = true;
    }

    public void DoRDLHandling()
    {
        Queue = new ConcurrentQueue<string>();

        using (var tcpCLient = new TcpClient() { ReceiveTimeout = 250 })
        {
            NetworkStream tcpStream = null;

            while (!IsTerminated)
            {
                if (!tcpCLient.Connected)
                    tcpStream = GetNetworkStream(tcpCLient);
                else
                    ReadMessage(tcpStream);
            }
        }
    }

    private NetworkStream GetNetworkStream(TcpClient tcpCLient)
    {
        NetworkStream resultStream = null;

        try
        {
            tcpCLient.Connect(_targetIp, _targetPort);
            resultStream = tcpCLient.GetStream();
        }
        catch (SocketException) { }

        return resultStream;
    }

    private void ReadMessage(Stream stream)
    {
        var receiveBuffer = new byte[100];
        var receivedBytesCount = 0;

        try
        {
            receivedBytesCount = stream.Read(receiveBuffer, 0, 100);
        }
        catch (IOException) { }

        if (receivedBytesCount > 0)
        {
            var message = new ASCIIEncoding().GetString(receiveBuffer, 0, receivedBytesCount);
            Queue.Enqueue(message);
            OnReceiveDataEvent(message);
        }
    }

    protected void OnReceiveDataEvent(string message)
    {
        var handler = ReceiveDataEvent;
        if (handler != null)
            handler(this, new RDLHandlerEventArgs(message));
    }
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:

public class RelayCommand : ICommand
{
    private readonly Action _execute;
    private readonly Func<bool> _checkCanExecute;

    public event EventHandler CanExecuteChanged
    {
        add { CommandManager.RequerySuggested += value; }
        remove { CommandManager.RequerySuggested -= value; }
    }

    public RelayCommand(Action execute)
        : this(execute, null)
    {
    }
    public RelayCommand(Action execute, Func<bool> checkCanExecute)
    {
        _execute = execute;
        _checkCanExecute = checkCanExecute;
    }

    public bool CanExecute(object parameter)
    {
        var result = true;

        if (_checkCanExecute != null)
            result = _checkCanExecute();

        return result;
    }
    public void Execute(object parameter)
    {
        _execute.Invoke();
    }
}

public class MainWindowViewModel
{
    private readonly Dispatcher _mainWindowDispatcher;
    private readonly ICommand _runCommand;
    private readonly ICommand _stopCommand;
    private RDLHandler _rdhHandler;
    private Thread _tcpThread;

    public ICommand RunCommand
    {
        get { return _runCommand; }
    }
    public ICommand StopCommand
    {
        get { return _stopCommand; }
    }

    public MainWindowViewModel(Dispatcher mainWindowDispatcher)
    {
        if (mainWindowDispatcher == null)
            throw new ArgumentNullException("mainWindowDispatcher");

        _mainWindowDispatcher = mainWindowDispatcher;

        _runCommand = new RelayCommand(Run);
        _stopCommand = new RelayCommand(Stop, () => _rdhHandler != null && _tcpThread != null);
    }

    private void ReceiveData(object sender, RDLHandlerEventArgs e)
    {
        Action method = () => MessageBox.Show("Received: " + e.Message);
        _mainWindowDispatcher.BeginInvoke(DispatcherPriority.Normal, method);
    }
    public void Run()
    {
        _rdhHandler = new RDLHandler("192.168.0.19", 4226);
        _rdhHandler.ReceiveDataEvent += ReceiveData;

        _tcpThread = new Thread(_rdhHandler.DoRDLHandling);
        _tcpThread.Start();
    }
    public void Stop()
    {
        _rdhHandler.Terminate();

        if (!_tcpThread.Join(1000))
            _tcpThread.Abort();
    }
}

public partial class MainWindow : Window
{
    public MainWindowViewModel ViewModel
    {
        get { return (MainWindowViewModel)DataContext; }
        set { DataContext = value; }
    }

    public MainWindow()
    {
        InitializeComponent();
    }

    private void button1_Click(object sender, RoutedEventArgs e)
    {
        ViewModel.RunCommand.Execute(null);
    }
    private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
    {
        ViewModel.StopCommand.Execute(null);
    }
    // Die Event-Methoden könnten weg fallen, wenn die Commands in WPF gebunden werden.
}					

1:
2:
3:
4:

var mainWindow = new MainWindow();
var mainViewModel = new MainWindowViewModel(mainWindow.Dispatcher);
mainViewModel.ViewModel = mainViewModel;
mainWindow.Show();					

1:
2:
3:

var message = ReadMessageFromStream(stream);
Queue.Enqueue(message);
OnReceiveDataEvent(message);