C#: come trasformare classi in byte da inviare su udp?

[Abdujaparov]

Salve a tutti sto scrivendo un client ed un server udp che si scambiano dei dati.
Girando su internet ho trovato esempi di come fare in modo che due host si scambino stringhe:
1)la stringa viene convertita in array di byte
2)la stringa viene inviata sul socket.

Ora la conversione in array di byte la faccio in questo modo:

string daInviare = "Messaggio da inviare";
                    Byte[] sendBytes = Encoding.ASCII.GetBytes(daInviare);

e i dati li riconverto da byte a string in quest'altro modo:

int recv;
byte[] data = new byte[1024];
recv = newsock.ReceiveFrom(data, ref Remote);
                    Console.WriteLine(Encoding.ASCII.GetString(data));

Ora se io volessi inviare una classe o una struct per implementare un mio protocollo che mi garantisca affidabilità su udp (non voglio il tcp, devo implementare un protocollo simile su udp per esercizio) come convertirei le classi (o le strutture) in un array di byte?
Grazie a tutti, ciao ciao.

[okay]

Originariamente inviato da Abdujaparov

Salve a tutti sto scrivendo un client ed un server udp che si scambiano dei dati.
Girando su internet ho trovato esempi di come fare in modo che due host si scambino stringhe:
1)la stringa viene convertita in array di byte
2)la stringa viene inviata sul socket.

Ora la conversione in array di byte la faccio in questo modo:

string daInviare = "Messaggio da inviare";
                    Byte[] sendBytes = Encoding.ASCII.GetBytes(daInviare);

e i dati li riconverto da byte a string in quest'altro modo:

int recv;
byte[] data = new byte[1024];
recv = newsock.ReceiveFrom(data, ref Remote);
                    Console.WriteLine(Encoding.ASCII.GetString(data));

Ora se io volessi inviare una classe o una struct per implementare un mio protocollo che mi garantisca affidabilità su udp (non voglio il tcp, devo implementare un protocollo simile su udp per esercizio) come convertirei le classi (o le strutture) in un array di byte?
Grazie a tutti, ciao ciao.

che fai... l'encoding? ... ma dai!!

fai un &cast:

(const char*) &Dati //dati della struttura

N.B.
sul client e il server devi avere le stesse strutture di sizeoff()
//uguali! se no cosa comunicano...

esempio:

//invio
send (socket, (const char*) &Dati, sizeof(MiaStruct), 0);
//ricezione
char rec(1024);
bytes = recv(socket, rec, sizeof(MiaStruct), 0);

[Abdujaparov]

Ciao, grazie mille, le stesse strutture di sizeof in che senso?
Invece mi chiedo un'altra cosa se comunicano due computer diversi non ci possono essere problemi differenti per quanto riguarda la dimensione della struct, l'ordinamento di byte (little o big endian)?
Questi problemi se li gestisce in automatico il CLR oppure devo fare tutto a mano come capitava in C (ho programmato qualche socket in C tempo fa e ricordo cose simili)?
Grazie, ciao ciao.

[okay]

Originariamente inviato da Abdujaparov

Ciao, grazie mille, le stesse strutture di sizeof in che senso?.

//client
struct miastruct
int a
char b
;

//server
struct miastruct
int a
char b//se commenti char b la dimensione della struttura cambia
// e avrai un crash al prg se tenti di prendere b che non c'è
;

Originariamente inviato da Abdujaparov

Invece mi chiedo un'altra cosa se comunicano due computer diversi non ci possono essere problemi differenti per quanto riguarda la dimensione della struct, l'ordinamento di byte (little o big endian)?
.

Il formato di memorizazione dei byte nei processori Intel è diverso dal formato utilizzato da Internet. Intel utilizza un formato little endian mentre le Winsock richiedono in ingresso un formato big endian.

winsock big endian
bit alto 7 + significativo 0 bit basso meno significativo
7 | 0 | 0 | 0

target.sin_port = htons (wPort);

La funzione htons (Host to Network) converte un numero nel formato del computer locale in quello della rete (è stato scelto il Big-Endian per internet vedi sopra). Anche se si sa che il computer locale è Big-Endian è ottima cosa usare lo stesso questa funzione, che in tal caso sarà solo una macro vuota.

ciao

[Abdujaparov]

Ecco io mi riferivo proprio a queste operazioni. In C ricordo che dovevo farle per forza dato che lavoravo a basso livello, in C# cercando di lavorare ad un livello più alto, utilizzando le sue librerie questi controlli li posso evitare?
Ricordo, anche se in modo non preciso, che controlli simili in java non erano necessari, ci pensava la JVM. In C# non ci pensa il CLR?
Grazie, ciao ciao.

[U-Boat]

Il modo più semplice per inviare oggetti sulla rete è quello di ricorrere alla serializzazione.

Ti riporto un esempio molto semplice, dove l'oggetto che si invia contiene una stringa

Crea la classe in questo modo:

[Serializable]
public class ClassToSend
{
	private string message;

	public ClassToSend(string message)
	{
		this.message = message;
	}

	public override string ToString()
	{
		return "Message: " + this.message;
	}
}

Il client (ho usato TCPListener, tu puoi usare UDPListener che funziona nello stesso modo)

public class Client
{
	public void SendMessage(string message, int port)
	{
		ClassToSend messageContainer = new ClassToSend(message);

		TcpClient tcpClient = new TcpClient("localhost", port);
		NetworkStream stream = tcpClient.GetStream();

		BinaryFormatter binaryFormatter = new BinaryFormatter();
		binaryFormatter.Serialize(stream, messageContainer);

		stream.Close();
	}
}

e il server così (se lo lanci come processo separato puoi evitare di ricorrere ai thread)

public class Server
{
	TcpListener listener;

	public Server(int port)
	{
		listener = new TcpListener(port);
	}

	public void Start()
	{
		Thread listenThread = new Thread(Listen);
		listenThread.Start();
	}

	private void Listen()
	{
		Console.WriteLine("In attesa...");
		listener.Start();
		TcpClient client = listener.AcceptTcpClient();
		Stream stream = client.GetStream();
		BinaryFormatter binaryFormatter = new BinaryFormatter();
		ClassToSend message = (ClassToSend)binaryFormatter.Deserialize(stream);

		Console.WriteLine(message.ToString());
	}
}

infine il programma principale:

static void Main(string[] args)
{
	Server server = new Server(1234);
	server.Start();

	Client client = new Client();
	client.SendMessage("ciao", 1234);

	Console.ReadLine();
}

[abe.flagg]

mi riaggancio a questo thread per una questione che mi sta assillando da qualche giorno:

ho una libreria scritta in C++ con la quale scambio da un applicativo all'altro dei pacchetti di dimensione variabile.
precisamente invio su un socket il numero di byte che trasmetterò, e successivamente il buffer di char che codifica la mia struttura.
questo tramite una funzione write(void *pcMem, int iSize)...

se io volessi replicare lo stesso concetto sotto c#(per comunicare con gli applicativi scritti in c++!), dovrei fare il marshalling della struttura che voglio inviare prima di serializzarla...in modo da assicurarmi che l'allineamento dei dati replichi quello implementato dal compilatore c.
però una struttura a dimensione variabile tipo questa:

[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct T_MY_DATA
{
public uint uiSize;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)];
public byte[] pcMem; //
};

mi permette di inviare SOLAMENTE strutture con array di 32 byte(o in generale il numero di byte specificati in SizeConst...)...e questo non è buono...

in attesa di illuminazione...

thk