Autor Beitrag
marcel04
Hält's aus hier
Beiträge: 3



BeitragVerfasst: Mi 08.07.15 15:05 
hallo com,


ich sende einen Broadcost an meine Slaves die darauf hin zum Broadcost etwas zurück senden,

ich will nun Abfangen was und wer das schickt?
mit meinem Code bekomm ich das nicht hin bzw was passt nicht?

ausblenden C#-Quelltext
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:
private void StartListening()
{
    //udp.Client.Bind();
    ar_ = udp.BeginReceive(Receive, new object());
    udp.Client.ReceiveTimeout = 50000;
    if (IPback.Length > 1)
        SendtoTable();
}

private void Receive(IAsyncResult ar)
{
    UdpClient client = new UdpClient();
    Messageback = "";
    IPback = "";

    IPEndPoint ip = new IPEndPoint(IPAddress.Broadcast, PORT_NUMBERReceive);

    byte[] bytes = udp.EndReceive(ar, ref ip);
    string message = Encoding.ASCII.GetString(bytes);
    Console.WriteLine("From {0} received: {1} ", ip.Address.ToString(), message);

    Messageback = message;
    IPback = ip.Address.ToString();

    StartListening();
}

?

mfg

Moderiert von user profile iconTh69: C#-Tags hinzugefügt
Moderiert von user profile iconTh69: Topic aus C# - Die Sprache verschoben am Mi 08.07.2015 um 17:12
Th69
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Moderator
Beiträge: 3951
Erhaltene Danke: 812

Win7
C++, C# (VS 2015/17)
BeitragVerfasst: Mi 08.07.15 16:04 
Hallo und :welcome:

schau dir mal das Beispiel zu UdpClient.EndReceive an.
Du verwendest anscheinend zwei verschiedene IPEndPoint-Objekte, einmal beim UdpClient-Konstruktor und einmal beim EndReceive.
marcel04 Threadstarter
Hält's aus hier
Beiträge: 3



BeitragVerfasst: Do 09.07.15 06:19 
Danke ;),

Ich werd daraus nicht schlau...


erhalte dabei einen Fehler wegen Udp.state, wäre es nicht einfacher wenn ich meinen Code umschreibe? oder ist dieser komplett falsch?


Hier einmal mein ganzer Code vlt traut sich jemand :P


ausblenden volle Höhe C#-Quelltext
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:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
520:
521:
522:
523:
524:
525:
526:
527:
528:
529:
530:
531:
532:
533:
534:
535:
536:
537:
538:
539:
540:
541:
542:
543:
544:
545:
546:
547:
548:
549:
550:
551:
552:
553:
554:
555:
556:
557:
558:
559:
560:
561:
562:
563:
564:
565:
566:
567:
568:
569:
570:
571:
572:
573:
574:
575:
576:
577:
578:
579:
580:
581:
582:
583:
584:
585:
586:
587:
588:
589:
590:
591:
592:
593:
594:
595:
596:
597:
598:
599:
600:
601:
602:
603:
604:
605:
606:
607:
608:
609:
610:
611:
612:
613:
614:
615:
616:
617:
618:
619:
620:
621:
622:
623:
624:
625:
626:
627:
628:
629:
630:
631:
632:
633:
634:
635:
636:
637:
638:
639:
640:
641:
642:
643:
644:
645:
646:
647:
648:
649:
650:
651:
652:
653:
654:
655:
656:
657:
658:
659:
660:
661:
662:
663:
664:
665:
666:
667:
668:
669:
670:
671:
672:
673:
674:
675:
676:
677:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Collections;
using System.Net;
using System.Net.Sockets;
using System.Threading;


namespace SchneidConfigTool
{
    public partial class Form1 : Form
    {

        public Form1()
        {
            InitializeComponent();


            this.listView1.View = View.Details;

            // Anzeigeheader im listview1 Spalten 
            listView1.Columns.Add(new ColHeader("Quelle"110, HorizontalAlignment.Left, true));
            listView1.Columns.Add(new ColHeader("Name"110, HorizontalAlignment.Left, true));
            listView1.Columns.Add(new ColHeader("Type"70, HorizontalAlignment.Left, true));

            // Add the data.
            /*listView1.Items.Add(new ListViewItem(new string[] { "192.168.0.1", "MeinModul1", "Tibbo" }));
            listView1.Items.Add(new ListViewItem(new string[] { "192.168.0.2", "MeinModul2", "TCP09" }));
            listView1.Items.Add(new ListViewItem(new string[] { "192.168.0.3", "MeinModul3", "TCP09" }));
            listView1.Items.Add(new ListViewItem(new string[] { "192.168.0.11", "2", "TCP09" }));
            listView1.Items.Add(new ListViewItem(new string[] { "192.168.0.13", "6", "Tibbo" }));
            listView1.Items.Add(new ListViewItem(new string[] { "192.168.0.12", "7", "RF-LP" }));
            listView1.Items.Add(new ListViewItem(new string[] { "192.168.0.111", "1", "RF-LP" }));
            listView1.Items.Add(new ListViewItem(new string[] { "192.168.0.114", "5", "RF-HP" }));
            */

            // Connect the ListView.ColumnClick event to the ColumnClick event handler.
            this.listView1.ColumnClick += new ColumnClickEventHandler(listView1_ColumnClick);
        }
        public class TCP08VALUE
        {
            private string name; // This is the so-called "backing field"
            public string Name // This is your property
            {
                get { return name; }
                set { name = value; }
            }
        }
        TCP08VALUE MA = new TCP08VALUE();
        TCP08VALUE MC = new TCP08VALUE();
        TCP08VALUE VR = new TCP08VALUE();
        TCP08VALUE ST = new TCP08VALUE();
        TCP08VALUE MN = new TCP08VALUE();

        public class SortWrapper
        {
            internal ListViewItem sortItem;
            internal int sortColumn;


            // A SortWrapper requires the item and the index of the clicked column.
            public SortWrapper(ListViewItem Item, int iColumn)
            {
                sortItem = Item;
                sortColumn = iColumn;
            }

            // Text property for getting the text of an item.
            public string Text
            {
                get
                {
                    return sortItem.SubItems[sortColumn].Text;
                }
            }

            // Implementation of the IComparer
            // interface for sorting ArrayList items.
            public class SortComparer : IComparer
            {
                bool ascending;

                // Constructor requires the sort order;
                // true if ascending, otherwise descending.
                public SortComparer(bool asc)
                {
                    this.ascending = asc;
                }

                // Implemnentation of the IComparer:Compare
                // method for comparing two objects.
                public int Compare(object x, object y)
                {
                    SortWrapper xItem = (SortWrapper)x;
                    SortWrapper yItem = (SortWrapper)y;

                    string xText = xItem.sortItem.SubItems[xItem.sortColumn].Text;
                    string yText = yItem.sortItem.SubItems[yItem.sortColumn].Text;
                    return xText.CompareTo(yText) * (this.ascending ? 1 : -1);
                }
            }
        }

        public class ColHeader : ColumnHeader
        {
            public bool ascending;
            public ColHeader(string text, int width, HorizontalAlignment align, bool asc)
            {
                this.Text = text;
                this.Width = width;
                this.TextAlign = align;
                this.ascending = asc;
            }
        }

        private void listView1_ColumnClick(object sender, ColumnClickEventArgs e)
        {

            // Create an instance of the ColHeader class.
            ColHeader clickedCol = (ColHeader)this.listView1.Columns[e.Column];

            // Set the ascending property to sort in the opposite order.
            clickedCol.ascending = !clickedCol.ascending;

            // Get the number of items in the list.
            int numItems = this.listView1.Items.Count;

            // Turn off display while data is repoplulated.
            this.listView1.BeginUpdate();

            // Populate an ArrayList with a SortWrapper of each list item.
            ArrayList SortArray = new ArrayList();
            for (int i = 0; i < numItems; i++)
            {
                SortArray.Add(new SortWrapper(this.listView1.Items[i], e.Column));
            }

            SortArray.Sort(0, SortArray.Count, new SortWrapper.SortComparer(clickedCol.ascending));

            // Clear the list, and repopulate with the sorted items.
            this.listView1.Items.Clear();
            for (int i = 0; i < numItems; i++)
                this.listView1.Items.Add(((SortWrapper)SortArray[i]).sortItem);

            // Turn display back on.
            this.listView1.EndUpdate();
        }


        //GM UDP Broadcastreciver
        /// <summary>
        /// ////////////////////////////////////////UDP//////////////
        /// </summary>


        String[] TCP08COMANDS = { "MC""VR""MN""UN""ST""IM""OP""DD""CP""PO""DG""KA""KI""KE""RI""LI""SM""GW""DS""PI""PP""DX""DP""DI""DW""DH""LP""RP""RH""BR""DB""PR""SB""FL""IT""PT""PS""PD""TE""SS""NP""SP" };

        const int PORT_NUMBERSend = 50001;
        public int PORT_NUMBERReceive;
        public int Port { get; set; }
        public String Messageback = "";
        public String IPback = "";

        Thread t = null;
        public void Start()
        {
            if (t != null)
            {
                throw new Exception("Already started, stop first");
            }
            Console.WriteLine("Started listening");
            StartListening();

        }
        public void Stop()
        {
            try
            {
                udp.Close();
                Console.WriteLine("Stopped listening");
            }
            catch { /* don't care */ }
        }

        /*private readonly*/

        UdpClient udp = new UdpClient(50001);
        Socket sck = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
        IPEndPoint ip = new IPEndPoint(IPAddress.Parse("255.255.255.255"), PORT_NUMBERSend);

        IAsyncResult ar_ = null;

        private void StartListening()
        {
            //udp.Client.Bind();
            ar_ = udp.BeginReceive(Receive, new object());
            udp.Client.ReceiveTimeout = 50000;
            if (IPback.Length > 1)
                SendtoTable();
        }
        private void Receive(IAsyncResult ar)
        {
            UdpClient client = new UdpClient();
            Messageback = "";
            IPback = "";

            IPEndPoint ip = new IPEndPoint(IPAddress.Broadcast, PORT_NUMBERReceive);

            byte[] bytes = udp.EndReceive(ar, ref ip);
            string message = Encoding.ASCII.GetString(bytes);
            Console.WriteLine("From {0} received: {1} ", ip.Address.ToString(), message);

            Messageback = message;
            IPback = ip.Address.ToString();


            StartListening();
        }

      
      
        public void Sendbyte(byte[] message)
        {

            UdpClient client = new UdpClient();
            IPEndPoint ip = new IPEndPoint(IPAddress.Parse("255.255.255.255"), PORT_NUMBERSend);

            byte[] bytes = message;



            
            client.Send(bytes, bytes.Length, ip);

            PORT_NUMBERReceive = ((System.Net.IPEndPoint)(client.Client.LocalEndPoint)).Port;
            StartListening();
            Console.WriteLine("Source Port: {0}", PORT_NUMBERReceive.ToString());
            Console.WriteLine("Destination Port: {0}", PORT_NUMBERSend.ToString());
            
        }



        private void SendtoTable()
        {

            this.Invoke((MethodInvoker)delegate
            {

                //GM Test
                textBox2.Text = ("VON " + IPback + " MSG " + Messageback);

                //Erzeuge Einträge
                listView1.Items.Add(new ListViewItem(new string[] { IPback, Messageback, "TCP08" }));

            });
        }
        //public static bool messageReceived = false;

        //public static void ReceiveCallback(IAsyncResult ar)
        //{
        //    UdpClient u = (UdpClient)((UdpState)(ar.AsyncState)).u;
        //    IPEndPoint e = (IPEndPoint)((UdpState)(ar.AsyncState)).e;

        //    Byte[] receiveBytes = u.EndReceive(ar, ref e);
        //    string receiveString = Encoding.ASCII.GetString(receiveBytes);

        //    Console.WriteLine("Received: {0}", receiveString);
        //    messageReceived = true;
        //}

        //public static void ReceiveMessages()
        //{
        //    // Receive a message and write it to the console.
        //    IPEndPoint e = new IPEndPoint(IPAddress.Any, PORT_NUMBERReceive);
        //    UdpClient u = new UdpClient(e);

        //    UdpState s = new UdpState();
        //    s.e = e;
        //    s.u = u;

        //    Console.WriteLine("listening for messages");
        //    u.BeginReceive(new AsyncCallback(ReceiveCallback), s);

        //    // Do some work while we wait for a message. For this example,
        //    // we'll just sleep
        //    while (!messageReceived)
        //    {
        //        Thread.Sleep(100);
        //    }
        //}



        public String SearchMSG08()
        {
            String ret = "";
            int lengmsg = TCP08COMANDS.Length;


            for (int i = 0; i < lengmsg; i++)
                ret += TCP08COMANDS[i] + "\r\n";

            return ret;

        }

        public byte[] prefix_MA(string mac)
        {

            byte[] ret = new byte[10];
            ret[0] = 0x4d//M
            ret[1] = 0x41//A
            char[] delimiterChars = { ':' };

            string[] s = mac.Split(delimiterChars);

            if (s.Length == 6)
            {
                for (Int16 i = 0; i <= 5; i++)
                {
                    ret[2 + i] = (byte)Convert.ToInt32(s[i], 16);
                }
            }
            else
            {
                for (Int16 i = 0; i <= 5; i++)
                {
                    ret[2 + i] = 0xff;
                }
            }
            ret[8] = 0xd;
            ret[9] = 0xa;

            return ret;


        }

        public byte[] SearchMSG08Byte(String PW)
        {

            String msg = "";

            if (PW.Length == 0) PW = " ";


            int lengmsg = TCP08COMANDS.Length;


            for (int i = 0; i < lengmsg; i++)
                msg += TCP08COMANDS[i] + "\r\n";


            msg = "PW" + PW + "\r\n" + msg;


            byte[] bMsg = System.Text.Encoding.ASCII.GetBytes(msg);
            byte[] ret = new byte[10 + bMsg.Length];
            byte[] tmp = prefix_MA("FF:FF:FF:FF:FF:FF");
            //byte[] tmp = prefix_MA("00:08:DC:1E:C7:A9");

            Array.ConstrainedCopy(tmp, 0, ret, 010);
            Array.ConstrainedCopy(bMsg, 0, ret, 10, bMsg.Length);

            return ret;

        }

        public void TCP08CON(string ipdest)
        {
            //listView1.Items.Clear();

            IPEndPoint ep = new IPEndPoint(IPAddress.Parse(ipdest), 50001);
            Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            sock.SendTimeout = 50;
            sock.ReceiveTimeout = 50;
            if (null != sock)
            {
                try
                {
                    sock.Connect(ep);
                    if (sock.Connected)
                    {

                        // Blocks until send returns.
                        int bytesSent = sock.Send(SearchMSG08Byte(""));
                        Console.WriteLine("Sent {0} bytes.", bytesSent);
                        //get the first 4 bytes, should be the lenngth of the rest of the response.
                        byte[] response = new byte[4];
                        int bytesRec = sock.Receive(response);
                        int totalBytesRec = 0;
                        if (4 == bytesRec)
                        {
                            int len = BitConverter.ToInt32(response, 0);
                            response = new byte[len];
                            Console.WriteLine("Trying to get {0} bytes.", len);
                            bytesRec = 0;

                            do
                            {
                                bytesRec = sock.Receive(response);
                                totalBytesRec += bytesRec;
                                //forecast += Encoding.ASCII.GetString(response, 0, bytesRec);

                                string message = Encoding.ASCII.GetString(response, 0, bytesRec);
                                Console.WriteLine("Data {0}  ", message);
                                parsingMsg(message);

                            } while (totalBytesRec < len && bytesRec > 0);

                            if (totalBytesRec != len)
                                throw new Exception("The total bytes recieved from manager did not equal the expected bytes");
                        }
                        else
                            throw new Exception("Unable to get the response size from the manager");


                        Console.WriteLine("Received {0} bytes.", totalBytesRec);
                    }

                }
                catch (SocketException ex)
                {
                    Console.WriteLine("{0} Error code: {1}.", ex.Message, ex.ErrorCode);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
                finally
                {
                    sock.Shutdown(SocketShutdown.Both);
                    sock.Close();
                }
            }
        }


        private void parsingMsg(string msg)
        {


            if (msg.Length > 0)
            {
                char[] delimiterChars = { '\r''\n' };
                string[] s = msg.Split(delimiterChars);
                for (int i = 0; i <= s.Length - 1; i++)
                {
                    if (s[i].Length > 2)
                    {
                        string sData = s[i].Substring(2, s[i].Length - 2);
                        switch (s[i].Substring(02))
                        {

                            case "MC":
                                //ret.MC.name = "MC";
                                MC.Name = sData;
                                break;
                            case "VR":
                                VR.Name = sData;
                                break;
                            case "MN":
                                MN.Name = sData;
                                break;
                            case "ST":
                                ST.Name = sData;
                                break;
                            /* case "IM":
                                 ret.IM.name = "IM";
                                 ret.IM.data = sData;
                                 break;
                             case "OP":
                                 ret.OP.name = "OP";
                                 ret.OP.data = sData;
                                 break;
                             case "DD":
                                 ret.DD.name = "DD";
                                 ret.DD.data = sData;
                                 break;
                             case "CP":
                                 ret.CP.name = "CP";
                                 ret.CP.data = sData;
                                 break;
                             case "PO":
                                 ret.PO.name = "PO";
                                 ret.PO.data = sData;
                                 break;
                             case "DG":
                                 ret.DG.name = "DG";
                                 ret.DG.data = sData;
                                 break;
                             case "KA":
                                 ret.KA.name = "KA";
                                 ret.KA.data = sData;
                                 break;
                             case "KI":
                                 ret.KI.name = "KI";
                                 ret.KI.data = sData;
                                 break;
                             case "KE":
                                 ret.KE.name = "KE";
                                 ret.KE.data = sData;
                                 break;
                             case "RI":
                                 ret.RI.name = "RI";
                                 ret.RI.data = sData;
                                 break;
                             case "LI":
                                 ret.LI.name = "LI";
                                 ret.LI.data = sData;
                                 break;
                             case "SM":
                                 ret.SM.name = "SM";
                                 ret.SM.data = sData;
                                 break;
                             case "GW":
                                 ret.GW.name = "GW";
                                 ret.GW.data = sData;
                                 break;
                             case "DS":
                                 ret.DS.name = "DS";
                                 ret.DS.data = sData;
                                 break;
                             case "PI":
                                 ret.PI.name = "PI";
                                 ret.PI.data = sData;
                                 break;
                             case "PP":
                                 ret.PP.name = "PP";
                                 ret.PP.data = sData;
                                 break;
                             case "DP":
                                 ret.DP.name = "DP";
                                 ret.DP.data = sData;
                                 break;
                             case "DI":
                                 ret.DI.name = "DI";
                                 ret.DI.data = sData;
                                 break;
                             case "DW":
                                 ret.DW.name = "DW";
                                 ret.DW.data = sData;
                                 break;
                             case "DH":
                                 ret.DH.name = "DH";
                                 string help = "";
                                 help = sData.Replace("WIZ", "TCP");
                                 ret.DH.data = help;
                                 break;
                             case "LP":
                                 ret.LP.name = "LP";
                                 ret.LP.data = sData;
                                 break;
                             case "RP":
                                 ret.RP.name = "RP";
                                 ret.RP.data = sData;
                                 break;
                             case "RH":
                                 ret.RH.name = "RH";
                                 ret.RH.data = sData;
                                 break;
                             case "BR":
                                 ret.BR.name = "BR";
                                 ret.BR.data = sData;
                                 break;
                             case "DB":
                                 ret.DB.name = "DB";
                                 ret.DB.data = sData;
                                 break;
                             case "PR":
                                 ret.PR.name = "PR";
                                 ret.PR.data = sData;
                                 break;
                             case "SB":
                                 ret.SB.name = "SB";
                                 ret.SB.data = sData;
                                 break;
                             case "FL":
                                 ret.FL.name = "FL";
                                 ret.FL.data = sData;
                                 break;
                             case "IT":
                                 ret.IT.name = "IT";
                                 ret.IT.data = sData;
                                 break;
                             case "PT":
                                 ret.PT.name = "PT";
                                 ret.PT.data = sData;
                                 break;
                             case "PS":
                                 ret.PS.name = "PS";
                                 ret.PS.data = sData;
                                 break;
                             case "PD":
                                 ret.PD.name = "PD";
                                 ret.PD.data = sData;
                                 break;
                             case "TE":
                                 ret.TE.name = "TE";
                                 ret.TE.data = sData;
                                 break;
                             case "SS":
                                 ret.SS.name = "SS";
                                 ret.SS.data = sData;
                                 break;
                             case "NP":
                                 ret.NP.name = "NP";
                                 ret.NP.data = sData;
                                 break;
                             case "SP":
                                 ret.SP.name = "SP";
                                 ret.SP.data = sData;
                                 break;
                             case "LG":
                                 ret.LG.name = "LG";
                                 ret.LG.data = sData;
                                 break;
                             case "ER":
                                 ret.ER.name = "ER";
                                 ret.ER.data = sData;
                                 break;
                             case "UN":
                                 ret.UN.name = "UN";
                                 ret.UN.data = sData;
                                 
                                 break;*/

                        }
                    }
                }
            }
            //return ret;
            listView1.Items.Add(new ListViewItem(new string[] { MC.Name, VR.Name, MN.Name }));
        }




        //Button 1 geklickt
        private void button1_Click(object sender, EventArgs e)
        {



            Start();

            //Send(textBox1.Text);

            //Send(SearchMSG08());
            Sendbyte(SearchMSG08Byte(""));

            //Thread.Sleep(10);
            //Stop();


        }

        private void button2_Click(object sender, EventArgs e)
        {

            TCP08CON(textBox1.Text);


        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

    }
}



problem erledigt danke.

mfg