blocks|key|5196370|text|您可以使用.net框架中提供的各种类创建自己的解决方案。您可能想要签出WCF或套接字命名空间，特别是TcpClient和TcpListener类，请参阅MSDN。如果你做一个与使用这些相关的搜索，你会发现有很多很棒的教程。您还需要考虑如何将类型化的对象转换为字节数组，类似于下面的question。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5196371|另一种方法是使用网络库。有低级库和高级库。考虑到你的编程经验和特定的最终目标，我建议你使用一个高级的库。这样的网络库的一个例子是lidgren。我是另一个网络库networkComms.net的开发人员，下面是如何使用该库发送类型化对象的快速示例：|5196372|共享库(定义播放器对象)：|5196373|[ProtoContract]
class+Player
{
++++[ProtoMember(1)]
++++public+string+Name+{+get;+private+set;+}
++++[ProtoMember(2)]
++++public+int+Ammo+{+get;+private+set;+}
++++[ProtoMember(3)]
++++public+string+Position+{+get;+private+set;+}

++++private+Player()+{+}

++++public+Player(string+name,+int+ammo,+string+position)
++++{
++++++++this.Name+=+name;
++++++++this.Ammo+=+ammo;
++++++++this.Position+=+position;
++++}
}|code-block|syntax|javascript|5196374|客户端(发送一个播放器对象)：|5196375|using+System;
using+System.Collections.Generic;
using+System.Linq;
using+System.Text;
using+System.IO;

using+NetworkCommsDotNet;
using+ProtoBuf;

namespace+Client
{
++++class+Program
++++{
++++++++static+void+Main(string[]+args)
++++++++{
++++++++++++Player+player+=+new+Player("MarcF",+100,+"09.09N,21.12W");

++++++++++++//Could+also+use+UDPConnection.GetConnection...
++++++++++++TCPConnection.GetConnection(new+ConnectionInfo("127.0.0.1",+10000)).SendObject("PlayerData",+player);

++++++++++++Console.WriteLine("Send+completed.+Press+any+key+to+exit+client.");
++++++++++++Console.ReadKey(true);
++++++++++++NetworkComms.Shutdown();
++++++++}
++++}
}|5196376|服务器：|5196377|using+System;
using+System.Collections.Generic;
using+System.Linq;
using+System.Text;
using+System.IO;

using+NetworkCommsDotNet;
using+ProtoBuf;

namespace+Server
{
++++class+Program
++++{
++++++++static+void+Main(string[]+args)
++++++++{
++++++++++++//+Convert+incoming+data+to+a+<Player>+object+and+run+this+method+when+an+incoming+packet+is+received.
++++++++++++NetworkComms.AppendGlobalIncomingPacketHandler<Player>("PlayerData",+(packetHeader,+connection,+incomingPlayer)+=>
++++++++++++{
++++++++++++++++Console.WriteLine("Received+player+data.+Player+name+was+"+%2B+incomingPlayer.Name);
++++++++++++++++//Do+anything+else+with+the+player+object+here
++++++++++++++++//e.g.+UpdatePlayerPosition(incomingPlayer);
++++++++++++});

++++++++++++//Listen+for+incoming+connections
++++++++++++TCPConnection.StartListening(true);

++++++++++++Console.WriteLine("Server+ready.+Press+any+key+to+shutdown+server.");
++++++++++++Console.ReadKey(true);
++++++++++++NetworkComms.Shutdown();
++++++++}
++++}
}|5196378|以上是此tutorial的修改版本。您显然需要从网站下载NetworkCommsDotNet动态链接库，以便可以将其添加到“使用NetworkCommsDotNet”参考中。另请参见客户端示例中的服务器IP地址当前为"127.0.0.1"，如果您在同一台计算机上同时运行服务器和客户端，则应该可以这样做。|5196379|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/sb27wehh.aspx|1|https://stackoverflow.com/questions/10390356/c-sharp-serializing-deserializing-with-memory-stream|2|http://code.google.com/p/lidgren-network-gen3/|3|http://www.networkcomms.net/|4|http://www.networkcomms.net/how-to-create-a-client-server-application-in-minutes/^0|24|4|0|3W|8|1|0|1S|7|2|28|G|3|0|0|0|0|0|0|0|4|8|4|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@$A|1D|B|1E|1|1F]|$A|1G|B|1H|1|1I]]|C|$]]|$1|D|3|E|5|6|7|1J|8|@]|9|@$A|1K|B|1L|1|1M]|$A|1N|B|1O|1|1P]]|C|$]]|$1|F|3|G|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1R|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1S|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|1T|8|@]|9|@]|C|$K|L]]|$1|Q|3|R|5|6|7|1U|8|@]|9|@]|C|$]]|$1|S|3|T|5|J|7|1V|8|@]|9|@]|C|$K|L]]|$1|U|3|V|5|6|7|1W|8|@]|9|@$A|1X|B|1Y|1|1Z]]|C|$]]|$1|W|3|-4|5|6|7|20|8|@]|9|@]|C|$]]]|X|$Y|$5|Z|10|11|C|$12|13]]|14|$5|Z|10|11|C|$12|15]]|16|$5|Z|10|11|C|$12|17]]|18|$5|Z|10|11|C|$12|19]]|1A|$5|Z|10|11|C|$12|1B]]]]

You could create your own solution using the various classes provided in the .net framework. You would want to checkout WCF or the Sockets namepsace, specifically the TcpClient and TcpListener classes, see <a href="http://msdn.microsoft.com/en-us/library/sb27wehh.aspx" rel="nofollow noreferrer">MSDN</a>. There are loads of great tutorials if you do a search related to using these. You would also need to consider how to turn your typed objects into byte arrays, similar to this <a href="https://stackoverflow.com/questions/10390356/c-sharp-serializing-deserializing-with-memory-stream">question</a>.

An alternative approach would be to use a network library. There are low-level libraries and high-level libraries. Given your level of programming experience and specific end goal I would suggest a high-level library. An example of such a network library would be <a href="http://code.google.com/p/lidgren-network-gen3/" rel="nofollow noreferrer">lidgren</a>. I'm the developer of another network library <a href="http://www.networkcomms.net" rel="nofollow noreferrer">networkComms.net</a> and a quick example of how you can send typed objects using this library follows:

Shared Base (defines Player object):

<pre><code>[ProtoContract]
class Player
{
 [ProtoMember(1)]
 public string Name { get; private set; }
 [ProtoMember(2)]
 public int Ammo { get; private set; }
 [ProtoMember(3)]
 public string Position { get; private set; }

 private Player() { }

 public Player(string name, int ammo, string position)
 {
 this.Name = name;
 this.Ammo = ammo;
 this.Position = position;
 }
}
</code></pre>

Client (sends a single Player object):

<pre><code>using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

using NetworkCommsDotNet;
using ProtoBuf;

namespace Client
{
 class Program
 {
 static void Main(string[] args)
 {
 Player player = new Player("MarcF", 100, "09.09N,21.12W");

 //Could also use UDPConnection.GetConnection...
 TCPConnection.GetConnection(new ConnectionInfo("127.0.0.1", 10000)).SendObject("PlayerData", player);

 Console.WriteLine("Send completed. Press any key to exit client.");
 Console.ReadKey(true);
 NetworkComms.Shutdown();
 }
 }
}
</code></pre>

Server:

<pre><code>using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

using NetworkCommsDotNet;
using ProtoBuf;

namespace Server
{
 class Program
 {
 static void Main(string[] args)
 {
 // Convert incoming data to a &lt;Player&gt; object and run this method when an incoming packet is received.
 NetworkComms.AppendGlobalIncomingPacketHandler&lt;Player&gt;("PlayerData", (packetHeader, connection, incomingPlayer) =&gt;
 {
 Console.WriteLine("Received player data. Player name was " + incomingPlayer.Name);
 //Do anything else with the player object here
 //e.g. UpdatePlayerPosition(incomingPlayer);
 });

 //Listen for incoming connections
 TCPConnection.StartListening(true);

 Console.WriteLine("Server ready. Press any key to shutdown server.");
 Console.ReadKey(true);
 NetworkComms.Shutdown();
 }
 }
}
</code></pre>

The above is a modified version of this <a href="http://www.networkcomms.net/how-to-create-a-client-server-application-in-minutes/" rel="nofollow noreferrer">tutorial</a>. You will obviously need to download the NetworkCommsDotNet DLL from the website so that you can add it in the 'using NetworkCommsDotNet' reference. Also see the server IP address in the client example is currently "127.0.0.1", this should work if you run both the server and client on the same machine.

blocks|key|1845696|text|我推荐一种方法和两种较小的方法，这两种方法依赖于许多因素。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1845697|第一个意味着您已经知道如何使用Socket类，但是需要通过它发送大量的类。|1845698|从传输的角度来看，您应该只创建/考虑一个非常简单的类。让我们将这个类称为MyMessage：|1845699|public+class+MyMessage+{
++public+byte[]+Data+{+get;+set;+}
}|code-block|syntax|javascript|1845700|好的。从TCP的角度来看，您需要做的就是确保能够传递此类的实例(从客户端到服务器，再从客户端传递到服务器)。我不会深入讨论这样做的细节，但我会指出，如果您设法做到这一点，您就将TCP/IP连接的性质从“字节流”转换为“消息流”。这意味着，通常情况下，TCP/IP不能保证通过连接发送的数据块以相同的形式到达目的地(它们可能连接在一起，也可能被拆分)。它唯一保证的是所有块的字节最终将以相同的顺序到达连接的另一端(总是)。|1845701|现在已经启动并运行了消息流，可以使用.NET良好的旧序列化将任何类实例封装在数据属性中。它所做的是将对象图序列化为字节，反之亦然。|1845702|(最常见的)方法是使用标准库类:+System.Runtime.Serialization.Formatters.Binary.BinaryFormatter，它可以在mscorlib.dll中找到，如下所示：|1845703|public+static+class+Foo+{

++public+static+Message+Serialize(object+anySerializableObject)+{
++++using+(var+memoryStream+=+new+MemoryStream())+{
++++++(new+BinaryFormatter()).Serialize(memoryStream,+anySerializableObject);
++++++return+new+Message+{+Data+=+memoryStream.ToArray()+};
++++}
++}

++public+static+object+Deserialize(Message+message)+{
++++using+(var+memoryStream+=+new+MemoryStream(message.Data))
++++++return+(new+BinaryFormatter()).Deserialize(memoryStream);
++}

}|1845704|BinaryFormatter类能够从作为Serialize+(+stream，object)方法的第二个参数提供的根/前哨开始遍历对象的树/图，并将所有原始值加上类型信息和相对位置信息写入所提供的流。它还能够进行完全相反的操作，并对整个对象图进行反序列化，只要所提供的流对应于以前的对象图序列化的位置即可。|1845705|但是这里有一些问题:您需要用SerializableAttribute注释所有的类。如果您的类包含您编写的其他类的字段，而您说它们确实是这样的：|1845706|[SerializableAttribute]
public+class+Player+{
++public+PlayerInfo+Info;+
++//...+etc+|1845707|然后你也需要用SerializableAttribute对它们进行注释：|1845708|[SerializableAttribute]
public+class+PlayerInfo+{+//...+etc|1845709|如果您的类包含由其他人(例如Microsoft)编写的类型的字段，那么这些字段最好已经使用属性进行了注释。大多数可以序列化的已经是序列化了。原始类型自然是可序列化的。不应该序列化的东西有:+FileStreams、线程、套接字等。|1845710|在确保你有了可序列化的类之后，你需要做的就是序列化它们的实例，发送它们，接收它们，并反序列化它们：|1845711|class+Client+{

++public+static+void+SendMovement(Movement+movement)+{
++++Message+message+=+Foo.Serialize(movement);

++++socketHelper.SendMessage(message);
++}
++public+static+void+SendPlayer(Player+player)+{
++++Message+message+=+Foo.Serialize(player);

++++socketHelper.SendMessage(message);
++}
++//+..+etc

++public+static+void+OnMessageReceivedFromServer(Message+message)+{
++++object+obj+=+Foo.Deserialize(message);
++++if+(obj+is+Movement)
++++++Client.ProcessOtherPlayersMovement(obj+as+Movement);
++++else+if+(obj+is+Player)
++++++Client.ProcessOtherPlayersStatusUpdates(obj+as+Player);
++++//+..+etc
++}

++public+static+void+ProcessOtherPlayersMovement(Movement+movement)+{
++++//...
++}
++//+..+etc

}|1845712|而在服务器端：|1845713|class+Server+{

++public+static+void+OnMessageReceived(Message+message,+SocketHelper+from,+SocketHelper[]+all)+{
++++object+obj+=+Foo.Deserialize(+message+);
++++if+(obj+is+Movement)
++++++Server.ProcessMovement(+obj+as+Movement+);
++++else+if+(obj+is+Player)
++++++Server.ProcessPlayer(+obj+as+Player+);
++++//+..+etc

++++foreach+(var+socketHelper+in+all)
++++++if+(socketHelper+!=+from)
++++++++socketHelper.SendMessage(+message+);
++}
}|1845714|您将需要一个公共程序集项目(类库)，以供两个可执行项目(客户端和服务器)引用。|1845715|所有需要传递的类都必须在该程序集中编写，以便服务器和客户端都知道如何在这个非常详细的级别上相互理解。|1845716|如果服务器不需要理解客户端之间正在说什么，而只是传递消息(向其他N-1个客户端广播一条消息)，那么忘记我所说的关于公共程序集的内容。在这种情况下，服务器只能看到字节，而客户端对来回发送的实际消息有更深的理解。|1845717|我说过我有三种方法。|1845718|第二个涉及.NET远程处理，它可以减轻您的工作负担，但如果您不完全理解它，就很难接受它。你可以在MSDN上读到，这里是：http://msdn.microsoft.com/en-us/library/kwdt6w2k(v=vs.100).aspx|offset|length|1845719|只有当(现在或将来)你所说的XNA指的是Windows+Phone或其他不支持BinaryFormatter类的XNA实现(带有MonoTouch的ExEn，或其他)时，第三种方法会更好。在这种情况下，如果您需要您的服务器(一个成熟的、优秀的老式.NET应用程序)引用我提到的公共程序集，并且让游戏项目(它不是一个很好的老式.NET应用程序，但具有相当异国情调的性质)引用完全相同的程序集，那么您将很难做到这一点。|1845720|在这种情况下，我们需要使用另一种形式的序列化和反序列化对象。您还需要在两个世界(.NET和WP7或WP8)中相同地实现两组类。您可以使用某种形式的XML序列化程序，您需要显式地将其映射到您的类(功能不如BinaryFormatter类强大，但在承载您的类的运行时的性质方面更具通用性)。|1845721|您可以在MSDN上阅读有关XmlSerializer类的内容，请访问：http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlserializer.aspx|1845722|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/kwdt6w2k(v=vs.100).aspx|1|http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlserializer.aspx^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1O|1R|0|0|0|0|Z|2B|1|0^^$0|@$1|2|3|4|5|6|7|24|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|25|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|26|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|27|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|28|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|29|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|2A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|2B|8|@]|9|@]|A|$I|J]]|$1|S|3|T|5|6|7|2C|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|2D|8|@]|9|@]|A|$]]|$1|W|3|X|5|H|7|2E|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|2F|8|@]|9|@]|A|$]]|$1|10|3|11|5|H|7|2G|8|@]|9|@]|A|$I|J]]|$1|12|3|13|5|6|7|2H|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|2I|8|@]|9|@]|A|$]]|$1|16|3|17|5|H|7|2J|8|@]|9|@]|A|$I|J]]|$1|18|3|19|5|6|7|2K|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|H|7|2L|8|@]|9|@]|A|$I|J]]|$1|1C|3|1D|5|6|7|2M|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2N|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|2O|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|2P|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|2Q|8|@]|9|@$1M|2R|1N|2S|1|2T]]|A|$]]|$1|1O|3|1P|5|6|7|2U|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|6|7|2V|8|@]|9|@]|A|$]]|$1|1S|3|1T|5|6|7|2W|8|@]|9|@$1M|2X|1N|2Y|1|2Z]]|A|$]]|$1|1U|3|-4|5|6|7|30|8|@]|9|@]|A|$]]]|1V|$1W|$5|1X|1Y|1Z|A|$20|21]]|22|$5|1X|1Y|1Z|A|$20|23]]]]

I have one approach I would recommend and two lesser ones which are dependent on many things.

The first one implies you already know how to use the Socket class but have a lot of classes that you need to send through it.

From a transport point of view you should create / take into consideration just one very simple class. Let's call this class MyMessage:

<pre><code>public class MyMessage {
 public byte[] Data { get; set; }
}
</code></pre>

Ok. From a TCP point of view all you need to do is make sure you're able to pass instances of this class around (from clients to the server and back). I will not dive into the details of doing that but I will point out that if you manage to do this you transform the nature of the TCP/IP connection from "byte-stream" to "message-stream". What that means is that normally, TCP/IP does not guarantee that chunks of data you send through a connection arrive at the destination in the same formations (they might get joined together or be split apart). The only thing it guarantees is that the bytes of all the chunks will eventually arrive in the same order at the other end of the connection (always).

Now that you have a message-stream up and running you could use .NET good old serialization to encapsulate any class instance inside the Data property. What that does is it serializes object graphs into bytes and vice-versa.

The way you do that (most commonly) is to use the standard library class:
 System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
which can be found in mscorlib.dll like so:

<pre><code>public static class Foo {

 public static Message Serialize(object anySerializableObject) {
 using (var memoryStream = new MemoryStream()) {
 (new BinaryFormatter()).Serialize(memoryStream, anySerializableObject);
 return new Message { Data = memoryStream.ToArray() };
 }
 }

 public static object Deserialize(Message message) {
 using (var memoryStream = new MemoryStream(message.Data))
 return (new BinaryFormatter()).Deserialize(memoryStream);
 }

}
</code></pre>

The BinaryFormatter class is able to traverse the tree/graph of objects starting from the root / sentinel provided as the second argument of the Serialize (Stream, object) method and write all of the primitive values plus type information and relative position information to the provided stream.
It is also able to do the exact reverse and deserialize an entire object graph as long as the provided stream is positioned accordingly to the place of a former object graph serialization.

There are a few catches here though: you will need to annotate all of your classes with [SerializableAttribute]. If your classes contain fields that are of other classes written by you, and you said they do:

<pre><code>[SerializableAttribute]
public class Player {
 public PlayerInfo Info; 
 //... etc 
</code></pre>

then you need to annotate those with [SerializableAttribute] too:

<pre><code>[SerializableAttribute]
public class PlayerInfo { //... etc
</code></pre>

If your classes contain fields that are of types written by others (say Microsoft) then those would better be already annotated with the attribute. Most of those which could be serialized already are. Primitive types are naturally serializable. Things that shouldn't be serialized are: FileStreams, Threads, Sockets, etc.

After making sure you have serializable classes all you need to do is serialize their instances, send them, receive them and deserialize them:

<pre><code>class Client {

 public static void SendMovement(Movement movement) {
 Message message = Foo.Serialize(movement);

 socketHelper.SendMessage(message);
 }
 public static void SendPlayer(Player player) {
 Message message = Foo.Serialize(player);

 socketHelper.SendMessage(message);
 }
 // .. etc

 public static void OnMessageReceivedFromServer(Message message) {
 object obj = Foo.Deserialize(message);
 if (obj is Movement)
 Client.ProcessOtherPlayersMovement(obj as Movement);
 else if (obj is Player)
 Client.ProcessOtherPlayersStatusUpdates(obj as Player);
 // .. etc
 }

 public static void ProcessOtherPlayersMovement(Movement movement) {
 //...
 }
 // .. etc

}
</code></pre>

While on the server side:

<pre><code>class Server {

 public static void OnMessageReceived(Message message, SocketHelper from, SocketHelper[] all) {
 object obj = Foo.Deserialize( message );
 if (obj is Movement)
 Server.ProcessMovement( obj as Movement );
 else if (obj is Player)
 Server.ProcessPlayer( obj as Player );
 // .. etc

 foreach (var socketHelper in all)
 if (socketHelper != from)
 socketHelper.SendMessage( message );
 }
}
</code></pre>

You will need a common assembly project (class library) to be referenced by both executable projects (client and server).

All your classes that need to be passed around will have to be written in that assembly so as that both the server and the client know how to understand each other at this very detailed level.

If the server needs not understand what is being said between the clients and only pass around messages (broadcasting one message to the other N-1 clients) then forget what I said about the common assembly. In that particular case, the server sees only bytes, while the clients have a deeper understanding of the actual messages being sent back and forth.

I said I had three approaches.

The second one involves .NET Remoting which can take a lot of work off your shoulders but which is hard to live with if you don't fully understand it. You can read about it on MSDN, here: <a href="http://msdn.microsoft.com/en-us/library/kwdt6w2k(v=vs.100).aspx">http://msdn.microsoft.com/en-us/library/kwdt6w2k(v=vs.100).aspx</a>

The third one would be better only if (now, or in the future) by XNA you mean Windows Phone or another implementation of XNA which does not support the BinaryFormatter class (ExEn with MonoTouch, or others).
In that case you would have a hard time if you needed your server (a full blown, good old fashioned .NET application) to reference the common assembly I talked about and also have the game project (which would not be a good old fashioned .NET app but have a rather exotic nature) reference the exact same assembly.

In that case we would need to use and alternate form of serializing and deserializing your objects. You would also need to identically implement two sets of classes in the two worlds (.NET and WP7 or WP8). You could use some form of XML serializers which you would need to map to your classes explicitly (not as powerful as the BinaryFormatter class but more versatile in what the nature of the runtime that host your classes could be).

You can read about the XmlSerializer class on MSDN, here: <a href="http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlserializer.aspx">http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlserializer.aspx</a>

blocks|key|5196493|text|我个人的快速清理解决方案，使用JSON.NET：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5196494|class+JMessage
{
++++public+Type+Type+{+get;+set;+}
++++public+JToken+Value+{+get;+set;+}

++++public+static+JMessage+FromValue<T>(T+value)
++++{
++++++++return+new+JMessage+{+Type+=+typeof(T),+Value+=+JToken.FromObject(value)+};
++++}

++++public+static+string+Serialize(JMessage+message)
++++{
++++++++return+JToken.FromObject(message).ToString();
++++}

++++public+static+JMessage+Deserialize(string+data)
++++{
++++++++return+JToken.Parse(data).ToObject<JMessage>();
++++}
}|code-block|syntax|javascript|5196495|现在你可以像这样序列化你的对象：|5196496|Player+player+=+...;
Enemy+enemy+=+...;
string+data1+=+JMessage.Serialize(JMessage.FromValue(player));
string+data2+=+JMessage.Serialize(JMessage.FromValue(enemy));|5196497|通过线路发送数据，然后在另一端，您可以执行以下操作：|5196498|string+data+=+...;
JMessage+message+=+JMessage.Deserialize(data);
if+(message.Type+==+typeof(Player))
{
++++Player+player+=+message.Value.ToObject<Player>();
}
else+if+(message.Type+==+typeof(Enemy))
{
++++Enemy+enemy+=+message.Value.ToObject<Enemy>();
}
//etc...|5196499|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

My personal quick-and-clean solution, using JSON.NET:

<pre><code>class JMessage
{
 public Type Type { get; set; }
 public JToken Value { get; set; }

 public static JMessage FromValue&lt;T&gt;(T value)
 {
 return new JMessage { Type = typeof(T), Value = JToken.FromObject(value) };
 }

 public static string Serialize(JMessage message)
 {
 return JToken.FromObject(message).ToString();
 }

 public static JMessage Deserialize(string data)
 {
 return JToken.Parse(data).ToObject&lt;JMessage&gt;();
 }
}
</code></pre>

Now you can serialize your objects like so:

<pre><code>Player player = ...;
Enemy enemy = ...;
string data1 = JMessage.Serialize(JMessage.FromValue(player));
string data2 = JMessage.Serialize(JMessage.FromValue(enemy));
</code></pre>

Send that data across the wire and then on the other end you can do something like:

<pre><code>string data = ...;
JMessage message = JMessage.Deserialize(data);
if (message.Type == typeof(Player))
{
 Player player = message.Value.ToObject&lt;Player&gt;();
}
else if (message.Type == typeof(Enemy))
{
 Enemy enemy = message.Value.ToObject&lt;Enemy&gt;();
}
//etc...
</code></pre>

blocks|key|1845844|text|经过两年多的时间，我找到了解决这个问题的新方法，我认为分享它可能对某些人有用。请注意，接受的答案仍然有效。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1845845|我能找到的序列化类型化对象的最简单的方法是使用Json.NET中的json转换器，它有一个设置对象，允许您在json中将类型存储为一个名为$type的值。下面是如何执行此操作以及生成的json：|offset|length|style|CODE|1845846|JsonSerializerSettings+settings+=+new+JsonSerializerSettings
{
++++TypeNameHandling+=+TypeNameHandling.All
};

JsonConvert.SerializeObject(myObject,+settings);|code-block|syntax|javascript|1845847|Json结果：|1845848|{
++++"$type"+:+"Testing.MyType,+Testing",
++++"ExampleProperty"+:+"Hello+world!"
}|1845849|反序列化时，如果使用相同的设置，则将反序列化正确类型的对象。正是我要的!希望这能有所帮助。|1845850|entityMap^0|0|1X|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

After more than 2 years, I've found new ways of solving this issue, and I thought sharing it might be useful to someone. Please note the accepted answer is still valid.

A simplest way to serialize typed objects I could find is by using the json converter in Json.NET. There's a settings object that allow you to store the type in the json as a value named <code>$type</code>. Here's how to do it and the resulting json:

<pre><code>JsonSerializerSettings settings = new JsonSerializerSettings
{
 TypeNameHandling = TypeNameHandling.All
};

JsonConvert.SerializeObject(myObject, settings);
</code></pre>

Json result:

<pre><code>{
 "$type" : "Testing.MyType, Testing",
 "ExampleProperty" : "Hello world!"
}
</code></pre>

When deserializing, if the same setting is used, an object of the correct type will be deserialized. Exactly what I needed! Hope this helps.

I’m having trouble creating a network interface for a very simple game I’ve made in Xna. I would simply need to send objects through a TCP client / Socket. Ex:
I have a class named “Player”.
In every Player, there’s a field name “Info”, of type “PlayerInfo”. In the client / server, I would need to send every players’ info to every client except the one who sent it (obviously).
This is a simple example, but I would need to do that with around 5 – 10 objects, plus sending the player updates (positions, actions …)
Is there a simple way to do that with TCP / Sock?
Note : I would rate my knowledge in C# and programming as 6/10, so you don’t need to explain everything if you have a solution (Ex : what’s the difference between a variable and a field). I also know about interfaces, libraries and so on…
Thanks in advance!

Send typed objects through tcp or sockets

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我在为我用Xna制作的一个非常简单的游戏创建网络界面时遇到了问题。我只需要通过TCP客户端/套接字发送对象。我有一个叫“Player”的类。在每个播放器中，都有一个字段名为“Info”，类型为“PlayerInfo”。在客户端/服务器端，我需要将每个玩家的信息发送给除了发送它的那个客户端之外的每个客户端(显然)。这是一...

问通过tcp或套接字发送类型化对象
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问通过tcp或套接字发送类型化对象EN