Serialisieren von Objekt zum senden bereit über TCPClient-Stream

Vorausgesetzt, Sie haben eine Klasse House (auf beiden Seiten der Verbindung) wie folgt suchen:

[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; }
}

Können Sie serialisieren, wird die Klasse in eine MemoryStream. Sie können dann in Ihrem TcpClient Zusammenhang wie diesem:

//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);
}

Natürlich haben Sie ein wenig mehr zu tun Untersuchung zu machen, das Programm läuft ohne Ausnahme. (z.B. Überprüfen memoryStream.Length nicht größer als ein int, ein.s.o.), aber ich hoffe, ich gab Ihnen die richtigen Anregungen, um Sie auf Ihrem Weg helfen 😉

InformationsquelleAutor Fischermaen

Können Sie einfach dekorieren Sie Ihr House Klasse mit der [Serializable] Attribut. (Sie brauchen nicht zu definieren, alle anderen Sachen wie gepostet in der anderen Antwort)

Senden Sie dieses Objekt auf den Draht durch serialisieren es mit der BinaryFormatter Klasse.

Haben Sie sich überlegt die Einrichtung eines WCF-Diensts, anstatt TcpListener und TcpClient ? Macht das Leben viel einfacher.

Beispielsweise könnten Sie einen service definieren, dass wieder ein Haus

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

Sehen diese realen Welt Beispiel.

InformationsquelleAutor wal

Erstellen Sie zuerst eine leere ServerApplication und ClientApplication als Konsolen-Anwendung zur Vereinfachung der Beispiel.

Dann legt man die definition für die serializable-Objekt in einer separaten assembly, und fügen Sie dann einen Verweis auf die gemeinsam genutzte assembly zu jedem Projekt (server und client). Ist notwendig, teilen die gleiche Objekt, nicht nur eine identische Klasse kopieren.

Zu Generieren DLL >
Recht clic in Lösung 'ServerApplication' in der Lösung Explorer - > Add New Project... -> wählen Sie " Class Library
(z.B. name dieses Projekts MySharedHouse)
Benennen Sie das standardmäßige Class1 Haus und füllen Sie es

[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; }
}

Recht clic in MySharedHouse und Bauen.

Nun die dll bauen, und wir müssen hinzufügen, dass es im Server-Projekt-und-Client-Projekt.
Recht clic in ServerApplication > Verweis Hinzufügen > Durchsuchen und finden Sie die dll, die für dieses Beispiel

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

Wiederholen Sie den Vorgang in ClientApplication mit der gleichen dll (gleicher Pfad).

Nun können Sie Instanzen von Haus-Klasse in ServerApplication und ClientApplication als ein einzelnes Objekt, einfaches hinzufügen der Satz "mit MySharedHouse" an der Spitze.

SERVER-CODE

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!");
            }
        }
    }
}

CLIENT-CODE

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! das erste Haus, das für das senden über TCP/IP

InformationsquelleAutor Musculaa