11 Antworten in diesem Thema

[juPP]

Moin Jungs... ich hab ne socket connection über die ich objekte schicken möchte ... dafür hab ich mir ne Wrapperklasse "Packet" angelegt...

die sieht so aus:

class Packet
{
	 private string PacketObjType;
	 private Object PacketObj;


	 public Packet(Object PacketObj)
	 {
		 this.PacketObjType = PacketObj.GetType().ToString();
		 this.PacketObj = PacketObj;

		 TestObj t = (TestObj) this.PacketObj;
		 Console.WriteLine(t.test);
	 }

}

In PacketObj soll das eigentlich zu übertragende Objekt liegen ... da ich aber nie genau weiss von welchem Typ das ist brauche ich sowas wie dynamisches Typcasting zur runtime....

Ich weiss könnte es auch mit einem größen switch lösen wo ich alle typen die übertragen werden aufnehme ... das möchte ich aber nicht...


Wer kann mir zeigen wie es geht?

EDIT: < .NET 4 ...

Bearbeitet von juPP, 18 June 2014 - 13:15 Uhr.

[easysurfer]

Kommt drauf an was das für Objekte sind. Eine ultimative Lösung gibt es dazu leider nicht, aber ein paar Konzepte:

• Du hast ein Basisinterface/Klasse, welche die gewünschten Funktionen und Objekte bereitstellt. Dann überschreibst Du diese Methoden der Basisklasse und kannst sie direkt aufrufen => wird wird die überschriebene Funktion aufgerufen
• Du arbeitest mit Invoke() und Reflection, um die gewünschten Methoden und Objekte abzurufen. Verlangt allerdings, dass Du die eine Liste von solchen Methoden basierend auf dem Type bereitstellst, also läuft auch auf Hardcoding der Typen raus.

Daher: Mehr Infos sind benötigt was diese Packete enthalten und wie genau Du sie weiterverarbeiten willst.

Greez

[juPP]

Hi easysurfer,

Ich dachte mir das ich in das Paket-Objekt noch ein Feld für eine Id anlege, anhand dieser würde ich dann entscheiden wie das Paket verarbeitet wird...
Ich hatte mir das so vorgestellt, dass ich einfach ein beliebiges Objekt (zb. TreeNode, Image oder Objekte von selbst definierten Klassen (Diese Objekte enthalten Daten die auf Clientseite erzeugt und befüllt werden) ) in meinem Wrapperobjekt unterbringe, die Wrapperklasse serialisiere, verschicke, deserialisie und das enthaltende Objekt zum richtigen Typ caste und damit weiter arbeiten kann. ( Vielleicht etwas zu bequem gedacht ... )

Bearbeitet von juPP, 18 June 2014 - 19:47 Uhr.

[mr3ee]

Ich hab hier mal ein Beispiel schnell runter getippt. (ungetestet)
So würde ich das ca machen.

[Serializable]
public interface ISendableObject
{
  string Id { get; set; }
}
// Sender Class
public class Packet
{
  private string PacketObjType;
  private Object PacketObj;

  public static string SendPackage(ISendableObject o)
  {
   XmlSerializer s = null;
   StringWriter sw = new StringWriter();
   s = new XmlSerializer(o.GetType());
   s.Serialize(sw, o);
   Console.WriteLine(o.Id); // mach was mit der Id
   Console.WriteLine(sw.ToString()); //TODO: sende das Object als XML
   return sw.ToString(); // zurück zum Testen
  }
  public static T ReceivePackage<T>(string xml) where T : ISendableObject
  {
   T o = default(T);
   XmlSerializer s = null;
   s = new XmlSerializer(o.GetType());
   using (TextReader reader = new StringReader(xml))
   {
    o = (T)s.Deserialize(reader);
   }
   return o;
  }
  public static ISendableObject ReceivePackage(string xml)
  {
   return ReceivePackage<ISendableObject>(xml);
  }
}
/* Example Call */
public class Example
{
  public class ExampleObject : ISendableObject
  {
   public string Id
   {
    get;
    set;
   }
   public string Name
   {
    get;
    set;
   }
  }
  public void Example()
  {
   ExampleObject e = new ExampleObject();
   e.Id = Guid.NewGuid().ToString();
   e.Name = "Max Muster";
   var xml = Packet.SendPackage(e);
   // Wenn du weißt welches Package genau zurück kommt.
   var e2 = Packet.ReceivePackage<ExampleObject>(xml);
   if (e2 == null || !e.Name.Equals(e2.Name))
   {
    throw new Exception("Dumm gelaufen.");
   }
   // Wenn du keinen Plan hast..
   var eUnknown = Packet.ReceivePackage(xml);
  }
}

[juPP]

Hi mr3ee,

so wie ich dein Codebeispiel verstehe müssen alle Objekte die versendet werden sollen das Interface "ISendableObject" implementiert haben... das heisst ich müsste mir eine Wrapper klasse für alle zu sendenden Objekte (z.B TreeNode) anlegen und das Interface mitgeben ... genau das wollte ich eben nicht tun. Gibts da nicht noch eine generischere Lösung?

[mr3ee]

Nein, gibt es nicht!
.Net arbeitet nunmal mit Typen du kannst zwar jedes Beliebige Objekt (wie in meinen Beispiel) in ein XML Serialisieren jedoch muss der Receiver-Code irgendwie wissen welches Objekt das ist um damit weiter Arbeiten zu können.

Natürlich kannst du mit Reflection dieses "unbekannte" Objekt wieder verarbeiten aber Best Practice ist was anderes.

Wenn du willst schreib ich dir schnell ein Beispiel wie das mit Reflection funktionieren würde.
Aber ich bin mir ganz sicher das es einen Eleganteren weg dafür gibt.

Normalerweise würde man hier ein DTO (Data Transfer Objekt) verwenden.

Aber das ist natürlich hier alles nur ins Blaue geraten solange du uns nicht erzählst was du damit genau bezwecken willst.

[juPP]

Ok, dann will ich mal versuchen ins detail zu gehen.

Ich habe eine Server sowie eine Client Anwendung. Nachdem der Client eine Verbindung zum Server aufgebaut hat schickt der Server ein Paket Objekt an den Client, in diesem Paket steckt ein Befehl für eine Aktion (diese könnte zum Beispiel sein, indiziere das gesamte C Laufwerk und nehme diese Struktur in ein TreeNode Objekt auf
______________
Bis hierher kein Problem, da ich den Typen des Befehlsobjekt auf der Clientseite ja kenne und damit weiterarbeiten kann.

.....
jetzt dachte ich mir das der Client einfach das erzeugte TreeNode Objekt in meiner Wrapperklasse (Packet) verpackt, serialisiert, an den Server schickt, deserialisiert und ich dort Anhand von dem eigentlichen Typ des Objekts ( PacketObj.GetType() ), in dem Fall dann TreeNode, das Objekt was in this.PacketObj liegt einfach zum richtigen Typ Casten kann. und dann auf Serverseite ich dieses Treenode Objekt der gui übergebe....

Jetzt soll dies aber nicht nur mit TreeNode Objekten funktionieren, sondern möglichst mit jedem Typ der auf Client und Serverseite bekannt ist

Bearbeitet von juPP, 19 June 2014 - 19:57 Uhr.

[mr3ee]

Du hast ein Objekt welches TreeNodeDto heißt dieses wird befüllt mit den Daten deiner TreeNode.
Die Klasse TreeNodeDto kennen beide Seiten (also Client und Server).

Und schon hast du einen fertigen Workflow:

• Client erstellt und befüllt TreeNodeDto
• Client wandelt TreeNodeDto um in XML
• Client sendet zum Server
• Server empfängt XML
• Server weiß durch den Endpoint für welches Objekt die Daten im XML sind und wandelt das XML wieder zurück in ein TreeNodeDto
• Server verarbeitet und macht was immer du willst mit diesen Objekt

Klingt doch gut, oder?

[juPP]

Jaein... Denn dann müsste ich ja für alle Objekte die über die Verbindung gehen entsprechende DTO Objekte anlegen, richtig? Dachte sowas könnte man generalisieren

[mr3ee]

Ja, genau so wird das überall auf der Welt auch gemacht.
Für alle Objekt die sich ähneln kannst du natürlich den kleinsten gemeinsamen Nenner suchen.

Wieviele Objekt hast du den?
Ich bin mir sicher wenn du mal durchzählst wirst du selbst merken das du weniger Typen brauchst als du denkst:

TreeNode -> KeyValuePair<string, string>
Passwörter auslesen -> KeyValuePair<string, string>
Datei lesen -> byte[]
Status von irgendwas -> string

Bei einen Trojaner (denk mal das du sowas bauen willst) komme ich jetzt auf 3 Dto's mit welchen ich ziemlich alles abdecken kann.

[juPP]

Ok, danke für die äußerst hilfreichen Antworten. Ich wusste schlicht nicht, das dies halt so gemacht werden muss. Und es sind in der Tat nicht soviele Typen wie ich dachte

Vielen dank!

[mr3ee]

Freut mich das ich dir helfen konnte!
Viel Erfolg.