La sérialisation d'objet prêt à envoyer plus de TCPClient Flux

En supposant que vous avez une classe House (disponible sur les deux côtés de votre connexion) qui ressemble à ceci:

[Serializable]
public class House
{
    public string Street { get; set; }
    public string ZipCode { get; set; }
    public int Number { get; set; }
    public int Id { get; set; }
    public string Town { get; set; }
}

Vous pouvez sérialiser la classe dans une MemoryStream. Vous pouvez ensuite utiliser dans votre TcpClient connexion comme ceci:

//Create a new house to send house and set values.
var newHouse = new House
    {
        Street = "Mill Lane", 
        ZipCode = "LO1 BT5", 
        Number = 11, 
        Id = 1, 
        Town = "London"
    };  

var xmlSerializer = new XmlSerializer(typeof(House));
var networkStream = tcpClient.GetStream();
if (networkStream.CanWrite)
{
    xmlSerializer.Serialize(networkStream, newHouse);
}

Bien sûr, vous avez à faire un peu plus d'enquête afin de faire le programme en cours d'exécution, sans exception. (par exemple, Vérifier memoryStream.Length pas être plus grand qu'un int, un.s.o.), mais j'espère que je vous ai donné le droit des suggestions pour vous aider sur votre chemin 😉

OriginalL'auteur Fischermaen

Vous pouvez tout simplement décorer votre House de classe avec le [Serializable] attribut. (Vous n'avez pas besoin de définir tous les autres trucs que posté dans l'autre réponse)

Vous pouvez ensuite envoyer cet objet sur le fil par sérialisation à l'aide de la BinaryFormatter classe.

Avez-vous envisagé de mettre en place un service WCF au lieu d'utiliser TcpListener et TcpClient ? Rend la vie beaucoup plus facile.

Par exemple, vous pourriez définir un service qui a retourné une maison

[ServiceContract]
public interface IService
{
[OperationContract]
House GetHouse(int houseId);
}

Voir cette l'exemple du monde réel.

OriginalL'auteur wal

D'abord créer un vide ServerApplication et ClientApplication que l'Application de la Console afin de simplifier l'exemple.

Ensuite, mettre la définition de la sérialisation d'un objet dans un ensemble distinct et ensuite d'ajouter une référence à l'assembly partagé à chaque projet (client et serveur). Est nécessaire de partager le même objet, pas seulement un cours identique copie.

Pour Générer DLL >
Clic droit dans Solution "ServerApplication' dans l'Explorateur de solutions > Ajouter un Nouveau Projet... -> sélectionnez la Bibliothèque de classes
(par exemple, le nom de ce projet MySharedHouse)
Renommez le Class1 par défaut pour la Maison et de le compléter

[Serializable]
public class House
{
    public string Street { get; set; }
    public string ZipCode { get; set; }
    public int Number { get; set; }
    public int Id { get; set; }
    public string Town { get; set; }
}

Clic droit dans MySharedHouse et Construire.

Maintenant la dll est en construction et nous avons besoin de l'ajouter dans le Projet de Serveur et de Client du Projet.
Clic droit dans ServerApplication > Ajouter une Référence > Parcourir et de trouver la dll, pour cet exemple

Projects\ServerApplication\MySharedHouse\bin\Debug\MySharedHouse.dll

Répétez le processus de l'ClientApplication à l'aide de la même dll (même chemin).

Maintenant, vous pouvez utiliser des instances de la classe de Maison en ServerApplication et ClientApplication comme un seul objet, il suffit d'ajouter la phrase "à l'aide de MySharedHouse" en haut.

CODE SERVEUR

using System;
using System.Net;
using System.Net.Sockets;
using System.Runtime.Serialization.Formatters.Binary;
using System.Threading;
using MySharedHouse;
namespace ServerApplication
{
class Program
{
static void Main(string[] args)
{
MessageServer s = new MessageServer(515);
s.Start();
}
}
public class MessageServer
{
private int _port;
private TcpListener _tcpListener;
private bool _running;
private TcpClient connectedTcpClient;
private BinaryFormatter _bFormatter;
private Thread _connectionThread;
public MessageServer(int port)
{
this._port = port;
this._tcpListener = new TcpListener(IPAddress.Loopback, port);
this._bFormatter = new BinaryFormatter();
}
public void Start()
{
if (!_running)
{
this._tcpListener.Start();
Console.WriteLine("Waiting for a connection... ");
this._running = true;
this._connectionThread = new Thread
(new ThreadStart(ListenForClientConnections));
this._connectionThread.Start();
}
}
public void Stop()
{
if (this._running)
{
this._tcpListener.Stop();
this._running = false;
}
}
private void ListenForClientConnections()
{
while (this._running)
{
this.connectedTcpClient = this._tcpListener.AcceptTcpClient();
Console.WriteLine("Connected!");
House house = new House();
house.Street = "Evergreen Terrace";
house.ZipCode = "71474";
house.Number = 742;
house.Id = 34527;
house.Town = "Springfield";
_bFormatter.Serialize(this.connectedTcpClient.GetStream(), house);
Console.WriteLine("send House!");
}
}
}
}

CODE CLIENT

using System;
using System.Net.Sockets;
using System.Runtime.Serialization.Formatters.Binary;
using System.Threading;
using MySharedHouse;
namespace ClientApplication
{
class Program
{
static void Main(string[] args)
{
MessageClient client = new MessageClient(515);
client.StartListening();
}
}
public class MessageClient
{
private int _port;
private TcpClient _tcpClient;
private BinaryFormatter _bFormatter;
private Thread _listenThread;
private bool _running;
private House house;
public MessageClient(int port)
{
this._port = port;
this._tcpClient = new TcpClient("127.0.0.1", port);
this._bFormatter = new BinaryFormatter();
this._running = false;
}
public void StartListening()
{
lock (this)
{
if (!_running)
{
this._running = true;
this._listenThread = new Thread
(new ThreadStart(ListenForMessage));
this._listenThread.Start();
}
else
{
this._running = true;
this._listenThread = new Thread
(new ThreadStart(ListenForMessage));
this._listenThread.Start();
}
}
}
private void ListenForMessage()
{
Console.WriteLine("Reading...");
try
{
while (this._running)
{
this.house = (House)this._bFormatter.Deserialize(this._tcpClient.GetStream());
Console.WriteLine(this.house.Street);
Console.WriteLine(this.house.ZipCode);
Console.WriteLine(this.house.Number);
Console.WriteLine(this.house.Id);
Console.WriteLine(this.house.Town);
}
}
catch (Exception e)
{
Console.WriteLine(e);
Console.ReadLine();
}
}
}
}

Wooala! la première maison à être envoyés sur TCP/IP

OriginalL'auteur Musculaa