[C#] socket.SendPacketsAsync

[roy-t]

Ik probeer 2 test programma's async via sockets met elkaar te laten praten. Over asynchroon data ontvangen is veel te vinden en ik denk ook dat die code goed is, maar over async verzenden kan ik geen goede documentatie vinden, op dit moment krijg ik een nullrefexception in de app die de data stuurt en een socketclosedexception in de app die de data ontvangt op het moment dat ik ze met elkaar probeer te laten communiceren.

Het listen/accept/connected gedeelte gaat wel goed, de code van de 'server' komt zonder fouten in de "OnDataReceived" methode die ik gedefinieerd heb, maar de 'client' faalt op dat moment.

De client ziet er zo uit:

C#:

sender = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint address = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1440);
sender.Connect(address);
if (sender.Connected) //code komt netjes hier in
{
      Packet p = new Packet();
      p.msg = "Hello Webs";
      sender.SendPacketsAsync(p); //bij het aanroepen van deze methode gaat het fout!
      Console.Out.WriteLine("Message send!!");
}

De server lijkt alles goed te doen maar voor de zekerheid wil ik daar ook de relevante code even van posten

C#:

public void StartServer()
        {
            IPEndPoint address = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1440);
            listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            listener.Bind(address);            
            listener.Listen(1000);
            while (true)
            {
                allDone.Reset(); //ManualResetEvent dat er voor zorgt dat het thread halt totdat iemand connect
                Console.Out.WriteLine("Waiting for a connection...");
                listener.BeginAccept(OnConnect, null);
                allDone.WaitOne();
            }
        }
private void OnConnect(IAsyncResult result)
        {
            try
            {                
                Socket socket = listener.EndAccept(result);                
                Packet packet = new Packet();
                packet.socket = socket;
                socket.BeginReceive(packet.dataBuffer, 0, packet.dataBuffer.Length, SocketFlags.None, OnReceive, packet);
            }
//snip catches
       }
private void OnReceive(IAsyncResult result)
        {
            Packet packet = result.AsyncState as Packet;
            int status = packet.socket.EndReceive(result);
            Console.Out.WriteLine(packet.msg);                           
        }

Op MSDN staat helaas geen voorbeeld code http://msdn.microsoft.com...ket.sendpacketsasync.aspx en ik wil dit graag allemaal non-blocking hebben en dus echt Async senden, hier kan ik ook geen goede voorbeelden van vinden. Ik heb zowel SendAysync als SendPacketsAsync geprobeerd (ik denk dat ik de laatste moet hebben). Maar dit maakt geen verschil in foutmeldingen.

Wie o wie weet welk stukje code de fout in gaat waardoor ik geen data kan verzenden/ontvangen.

(oh het classje Packet dat je af en toe ziet heeft de volgende signature)

C#:

public class Packet : SocketAsyncEventArgs
    {
        public string msg;
        public Socket socket;
        public byte[] dataBuffer = new byte[1];
   }

[Sebazzz]

Waar geeft hij deze NullReference op?
edit: nvm

[ Voor 12% gewijzigd door Sebazzz op 26-05-2009 15:10 ]

[pjvandesande]

Verander de OnReceive method eens in het volgende:

code:

private void OnReceive(IAsyncResult result) 
{ 
    int status = packet.socket.EndReceive(result); 
    Packet packet = result.AsyncState as Packet; 
    Console.Out.WriteLine(packet.msg);                            
}

[ Voor 6% gewijzigd door pjvandesande op 26-05-2009 14:59 . Reden: code reformat ]

[Woy]

pjvandesande schreef op dinsdag 26 mei 2009 @ 14:58:
Verander de OnReceive method eens in het volgende:

code:

private void OnReceive(IAsyncResult result) 
{ 
    int status = packet.socket.EndReceive(result); 
    Packet packet = result.AsyncState as Packet; 
    Console.Out.WriteLine(packet.msg);                            
}

Hoe kun je in regel 3 packet gebruiken als packet nog niet gedeclareerd is

Waar krijg je overigens exact de null-refference exception?

Om data asynchroon te verzende gebruik ik zelf overigen altijd de BeginSend ( Of BeginWrite van de NetworkStream class ) methode, met deze manier van async data versturen ben ik niet bekend.

Hier lijkt er overigens wel gewoon een voorbeeld te staan: http://msdn.microsoft.com...socketasynceventargs.aspx

Zo te zien zal je bijvoorbeeld een buffer op je SocketAsyncEventArgs moeten zetten met de SetBuffer methode.

[ Voor 35% gewijzigd door Woy op 26-05-2009 15:09 ]

[Sebazzz]

Woy schreef op dinsdag 26 mei 2009 @ 15:03:
[...]

Waar krijg je overigens exact de null-refference exception?

Op "sender.SendPacketsAsync(p)" in de client.

[Woy]

Sebazzz schreef op dinsdag 26 mei 2009 @ 15:12:
[...]
Op "sender.SendPacketsAsync(p)" in de client.

Ja maar je kan natuurlijk nog preciezer zien waar het mis gaat, en in de source van die methodes kijken waarop je een null-refference krijgt.

Ik denk dat het mis gaat omdat er geen buffer gezet is op de SocketAsyncEventArgs

[Niemand_Anders]

Als je met async sockets werk in de scope van de socket instantie beperkt tot de verbinding tot stand is gebracht. Daarna neemt SocketAsync(EventArgs) bijna alles van de socket over.

Een voorbeeld kun je vinden op: http://www.codeproject.co...ssampl.aspx?display=Print

offtopic:
was vergeten op submit te klikken

[ Voor 9% gewijzigd door Niemand_Anders op 26-05-2009 15:24 . Reden: moet leren om eerst punt 1 af te maken voordat ik met puntje 2 begin... ]

[Matis]

zoiets?

C#:

  private void tcpClientReadCallback(IAsyncResult ar)
        {
            NetworkStream netStream = (NetworkStream)ar.AsyncState;
            try
            {
                int receivedBytesCounter = netStream.EndRead(ar);

                while (netStream.DataAvailable)
                {
                    byte[] receivedBytes = new byte[receivedBytesCounter];
                    netStream.Read(receivedBytes, 0, receivedBytesCounter);
                    commandBuffer += Encoding.ASCII.GetString(receivedBytes);
                }
                if (commandBuffer != "")
                {
                    processCommand();
                    commandBuffer = "";
                }

                netStream.BeginRead(bf, 0, 1, new AsyncCallback(tcpClientReadCallback), netStream);
            }
            catch (Exception)
            {
            }
        }

pm me maar als je de hele klasse wilt

[roy-t]

pjvandesande schreef op dinsdag 26 mei 2009 @ 14:58:
Verander de OnReceive method eens in het volgende:

code:

private void OnReceive(IAsyncResult result) 
{ 
    int status = packet.socket.EndReceive(result); 
    Packet packet = result.AsyncState as Packet; 
    Console.Out.WriteLine(packet.msg);                            
}

Dat kan helaas niet omdat je in het packet de socket opslaat die je gebruikt om het packet te ontvangen (dit staat ook in meerdere code voorbeelden zo.

Verder over waar de fout zit:
ik krijg

code:

{"De objectverwijzing is niet op een exemplaar van een object ingesteld."}

op sender.SendPacketsAsync(p)
Geen inner exception en ik krijg hem exact als ik die regel uitvoer, ook is er geen extra exception data. Kan ik misschien nog "skip over non-user code" uitzetten ergens? (Eigenlijk nooit gedaan?)

Edit:

Niemand_Anders schreef op dinsdag 26 mei 2009 @ 15:22:
Als je met async sockets werk in de scope van de socket instantie beperkt tot de verbinding tot stand is gebracht. Daarna neemt SocketAsync(EventArgs) bijna alles van de socket over.

Een voorbeeld kun je vinden op: http://www.codeproject.co...ssampl.aspx?display=Print

offtopic:
was vergeten op submit te klikken

Maar dat is toch exact wat ik doe, al bij de eerste accept gebruik ik de SocketAsyncEventArgs om alles te gebruiken.

@ Toaomatis, bedankt voor dit stukje voorbeeld code maar je maakt van een heel ander soort verbinding gebruik dan ik en hierbij mist juist het verzenden stukje
@Tomatis

[ Voor 29% gewijzigd door roy-t op 26-05-2009 15:33 ]

[Sebazzz]

Woy schreef op dinsdag 26 mei 2009 @ 15:14:
[...]

Ja maar je kan natuurlijk nog preciezer zien waar het mis gaat, en in de source van die methodes kijken waarop je een null-refference krijgt.

Hmm, bij een interne methode gaat het hier fout:

C#:

foreach (SendPacketsElement spe in m_SendPacketsElements)

m_SendPacketsElements is null. Kan alleen in VS niet herleiden waar deze gedefineerd is en geassigned zou moeten worden.

roy-t schreef op dinsdag 26 mei 2009 @ 15:27:
[...]

Geen inner exception en ik krijg hem exact als ik die regel uitvoer, ook is er geen extra exception data. Kan ik misschien nog "skip over non-user code" uitzetten ergens? (Eigenlijk nooit gedaan?)

Als het goed is moet je wel eerst de publieke symbols (reference source) hebben geladen.

[ Voor 29% gewijzigd door Sebazzz op 26-05-2009 15:38 ]

[Woy]

Maar heb je nu al geprobeerd om een buffer te zetten met http://msdn.microsoft.com/en-us/library/bb517542.aspx

[roy-t]

@Woy, ik heb even niet aan de buffer gezeten omdat ik die nu niet meer nodig lijk te hebben / de buffer zit in de constructor van de sendpacketselements en in de constructor maak ik een arbritair grote aan.
@Sebazzz ik heb de code nu aangepast dat er 2 onderdelen zijn in dingen die verstuurd worden:

C#:

public class Element : SendPacketsElement
    {
        public string msg;
        public Element() :
            base(new byte[1000],0, 1000,false)

        {
            msg = "";                                    
        }
    }

    public class Packet : SocketAsyncEventArgs
    {
        public Socket socket;
    }

Die heb ik nu aangepast zodat er ook assynchroon op een connectie wordt gewacht en zodat de elements geset worden:

C#:

anualResetEvent allDone = new ManualResetEvent(false);        
        Socket sender;
        public void Start()
        {
            try
            {
                sender = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IPEndPoint address = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1440);
                Packet p = new Packet();                
                p.socket = sender;
                sender.BeginConnect(address, OnConnect, p);
                allDone.WaitOne();
                Console.Out.WriteLine("Done Waiting, bye bye");                
            }
            catch (Exception e)
            {
                Console.Out.WriteLine(e.Message);
            }
        }

        private void OnConnect(IAsyncResult result)
        {
            allDone.Set();
            Console.Out.WriteLine("Connected to server");
            Packet p = result.AsyncState as Packet;
            Element m = new Element();
            m.msg = "Hai World!";
            p.SendPacketsElements = new SendPacketsElement[] { m };            
            p.SetBuffer(p.SendPacketsElements[0].Buffer, 0, p.SendPacketsElements[0].Buffer.Length);            
            Socket s = p.socket;
            
            s.EndConnect(result);
            if (s.Connected)
            {                                
                s.SendPacketsAsync(p);                
                Console.Out.WriteLine("Message send!!");
            }
            else
            {
                Console.Out.WriteLine("Not connected :(");
            }
            Console.ReadLine();
        }
    }

Daarvoor heb ik de ontvang code ook ietsjes aangepast:

C#:

ocket socket = listener.EndAccept(result);                
                Packet packet = new Packet();
                packet.socket = socket;
                packet.SendPacketsElements = new SendPacketsElement[] { new Element() };
                socket.BeginReceive(packet.SendPacketsElements[0].Buffer, 0, packet.SendPacketsElements[0].Buffer.Length, SocketFlags.None, OnReceive, packet);
            }

(de onrecieve en overige code is hetzelfde gebleven, sorry voor de toch grote hoeveelheid c/p hier). Anyway ik krijg nu gewoon geen foutmelding meer als ik de code laat lopen of er door heen debug maar het packet.SendPacketsElements[0] wordt niet overschreven/ontvangen en string in Elements houd de standaard waarde van "". Dat komt mogelijk omdat ik die code al nodig heb in

code:

socket.BeginReceive(packet.SendPacketsElements[0].Buffer, 0, packet.SendPacketsElements[0].Buffer.Length, SocketFlags.None, OnReceive, packet);

Want daarvoor maak ik in de ontvang functies dus al een SendPacketsElement aan, maar hoe zorg ik ervoor dat dit de goede wordt (de code wordt ook steeds ingewikkelder ik denk dat ik de verkeerde weg op zit).


Edit: na veel gekloot kom ik er op deze manier niet uit, misschien zit ik ook wel helemaal verkeerd te kijken, alles wat ik wil is een object serializen, dat versturen via TCP of UDP en dat aan de andere kant weer in elkaar zetten, asynchroon aan de applicatie, in Java ging dat via Sockets, maar ik zie oa van Toaomatis dat je ook networkstreams hebt, het gaat om realtime data die ik er uiteindelijk mee wil versturen (voor een zelf gemaakt spelletje, maar vooral om te leren). Dus het liefst de snelle manier om dit te doen, ik heb nu het idee dat ik compleet de verkeerde kant op ga.

[ Voor 9% gewijzigd door roy-t op 26-05-2009 18:49 ]

[Sebazzz]

Kan je niet gewoon een Thread starten waarin je dat doet? Ik heb ook nog wat geprobeerd maar ik blijf die NullRefException ook houden Op Google vindt ik er ook niets over. Misschien een bug in .NET?

[user109731]

Google geeft sowieso erg weinig resultaten voor SendPacketsAsync. Mono heeft 'm zelfs nog niet geimplementeerd. Het lijkt me dus een wat obscure functie waar eenvoudigere alternatieven voor moeten zijn?

Van SendAsync is bijvoorbeeld wel code te vinden die volgens mij precies doet wat je nodig hebt (even kijken hoe zij het doen kan geen kwaad)

[Woy]

Zoals ik al eerder hier aangaf gebruik zelf gewoon de Begin.... functies om asynchroon data te versturen. Meestal gewrapt in een Network stream.

Dat werkt IMHO gewoon het makkelijkst, en ik zie het nut van deze toevoeging ook niet zo heel erg, maar ik heb me er eerlijk gezegd ook, bij gebrek aan noodzaak, nog niet echt in verdiept.

[Sebazzz]

JanDM schreef op dinsdag 26 mei 2009 @ 23:34:
Van SendAsync is bijvoorbeeld wel code te vinden die volgens mij precies doet wat je nodig hebt (even kijken hoe zij het doen kan geen kwaad)

Ik kan wel zeggen dat Async in zijn huidige vorm niets doet. Geen exception, maar het bericht komt ook niet aan. Er moet dus meer aan de code aangepast worden.

[Woy]

Sebazzz schreef op woensdag 27 mei 2009 @ 01:27:
[...]

Ik kan wel zeggen dat Async in zijn huidige vorm niets doet. Geen exception, maar het bericht komt ook niet aan. Er moet dus meer aan de code aangepast worden.

Maar heb je bijvoorbeeld ook met wireshark gekeken of er wel wat over de lijn gaat? Dan weet je of het in de versturende code of de ontvangende code zit.

[roy-t]

Woy schreef op dinsdag 26 mei 2009 @ 23:40:
Zoals ik al eerder hier aangaf gebruik zelf gewoon de Begin.... functies om asynchroon data te versturen. Meestal gewrapt in een Network stream.

Dat werkt IMHO gewoon het makkelijkst, en ik zie het nut van deze toevoeging ook niet zo heel erg, maar ik heb me er eerlijk gezegd ook, bij gebrek aan noodzaak, nog niet echt in verdiept.

Ik ben nu aan het controleren hoe de begin functies e.d. gaan, maar wat me dwars zit is dat dit niet netjes serialization ondersteund zover ik zie en dus niet gewoon een object kan toevoegen aan een pakketje zodat ik deze stuur, alle voorbeeld code die ik zie sturen bit voor bit een string, maar met serialisation moet dat toch beter te doen zijn, anyway gister niet meer veel kunnen uitzoeken naar laatste post dus ik ga is kijken of ik wat goede hits op serialisation+C#+socket kan vinden.

[user109731]

Je kunt een object toch gewoon serializen naar een string en die sturen? Volgens mij wordt het meestal zo gedaan...

[Sebazzz]

JanDM schreef op woensdag 27 mei 2009 @ 12:26:
Je kunt een object toch gewoon serializen naar een string en die sturen? Volgens mij wordt het meestal zo gedaan...

Of je gebruikt een BinarySerializer. Meestal moet je die functies toch een byte array voeden.

[roy-t]

Ik geloof dat ik er nu helemaal uit ben en via een binaryformatter en memory stream werkt dit allemaal, ik zal later de volledige gedocumenteerde code even posten (als ik die netjes heb gemaakt) maar hier alvast de serialisatie code (voor referentie).

C#:

[Serializable]
    public class Status
    {
        [NonSerialized]    
        public Socket Socket;
        [NonSerialized]
        public List<byte> TransmissionBuffer = new List<byte>();
        [NonSerialized]
        public byte[] buffer = new byte[1024];

        public string msg;        
        

        public byte[] Serialize()
        {
            BinaryFormatter bin = new BinaryFormatter();            
            MemoryStream mem = new MemoryStream();
            bin.Serialize(mem, this);            
            return mem.GetBuffer();            
        }

        public Status DeSerialize()
        {
            byte[] dataBuffer = TransmissionBuffer.ToArray();
            BinaryFormatter bin = new BinaryFormatter();
            MemoryStream mem = new MemoryStream();
            mem.Write(dataBuffer,0, dataBuffer.Length);
            mem.Seek(0, 0);            
            return (Status)bin.Deserialize(mem);
        }

(Zoals jullie zien heb ik een heel fancy object waarin nu slechts een string zit, maar het werkt allemaal prima en nu kan ik er natuurlijk allemaal spul inproppen, of de klasse aanpassen waardoor ik hiervan kan inheritten.

[ Voor 8% gewijzigd door roy-t op 27-05-2009 13:34 ]

[Woy]

Ik zou de Serializatie/Deserializatie niet aan het object zelf over laten, maar dat bijvoorbeeld gewoon in de server of in een apart object doen

C#:

public class Server : IDisposable
{
    private NetworkStream stream;
    private BinaryFormatter formatter;

    public Server(Socket socket)
    {
        stream = new NetworkStream(socket);
        formatter = new BinaryFormatter();
    }

    public void Dispose()
    {
        stream.Dispose();
    }

    public IAsyncResult BeginWrite(object o, AsyncCallback callback, object state)
    {
        MemoryStream memStream = new MemoryStream();
        formatter.Serialize(memStream, o);
        byte[] data = memStream.ToArray();

        return stream.BeginWrite(data, 0, data.Length, callback, state);
    }

    public void EndWrite(IAsyncResult asyncResult)
    {
        stream.EndWrite(asyncResult);
    }
}

En dan voor de client iets soortgelijks.

[roy-t]

Woy schreef op woensdag 27 mei 2009 @ 13:47:
Ik zou de Serializatie/Deserializatie niet aan het object zelf over laten, maar dat bijvoorbeeld gewoon in de server of in een apart object doen

C#:

En dan voor de client iets soortgelijks.

Ja dat klinkt inderdaad netter, ik moet idd nog opruimen eerst had ik iets andere functies waardoor het wel iets logischer was dat het daar zat .