remoting (objekt senden)

[e86]

ich habe mich über das wochende mit dem remoting unter c# beschäftigt. dazu habe ich sehr viele tutorials consultiert. einige waren von codeproject.com.

bei einem habe ich dann mal ein bein in die tür bekommen, nur leider versucht mich ein kleiner bug, wieder heraus zudrengeln.

meine ausgangssituation:

3 Dateien:

Projekt: Server
- Server.cs
- ServerClass.cs

Projekt: Client
- Client.cs
-ServerClass.cs

Inhalt ServerClass.cs:

using System;

 namespace NServiceClass
 {
  public class ServiceClass : MarshalByRefObject
  {
   private string text;

   public string Text
   {
    get
    {
     return this.text;
    }
    set
    {
     this.text = value;
    }
   }

  }
 }

Inhalt Server.cs:

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;

using NServiceClass;

namespace DefaultNamespace
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			HttpChannel channel = new HttpChannel(8080);
			ChannelServices.RegisterChannel(channel);

			ServiceClass remoteObject = new ServiceClass();
			remoteObject.Text = "Hello Remote-World!";

			ObjRef reference = RemotingServices.Marshal( remoteObject,
			"remoteObjectURI");

			Console.WriteLine ("Server laeuft...");

			Console.ReadLine();

		}
	}
}

Und die 3. Datei, Client.cs:

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;

using NServiceClass;

namespace DefaultNamespace
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			HttpChannel channel = new HttpChannel(0);
			ChannelServices.RegisterChannel(channel);

			RemotingConfiguration.RegisterWellKnownClientType(typeof(ServiceClass),
			"http://localhost:8080/remoteObjectURI");

			ServiceClass remote = new ServiceClass();

			Console.WriteLine(remote.Text);

			Console.ReadLine ();
		}
	}
}

mein problem:

ich habe statt http://localhost:8080/remoteObjectURI, http://111.111.111.112:8080/remoteObjectURI geschrieben. diese 1sen und die 2 sind die ip für meinen server-rechner.

ich habe nun auf dem o.g. serverrechner das Programm Server (Server.cs) laufen.
alles bestens.

nun starte ich auf einem 2. rechner im netzwerk das Clientprogramm (Client.cs). Hier wartet er eine kurze zeit (3sek.) und bricht dann ab.

Er sagt mir, dass er nicht auf den Socket etc. zugreifen kann.

was ich will:

das er mir im client programm 'hello remote-world' ausgibt.

kOOni

[AndreasW]

Hallo,

auf einem Port kann immer nur eine Anwendung lauern. Von daher ist port 8080 ungünstig, da dies Port gern von Webservern verwendet wird. Nimm lieber einen anderen Port.

Du solltest deiner URI eine Endung geben, damit man weiss, um welchen typ es sich handelt: "remoteObjectURI.SOAP" wäre später auch zum IIS kompatible, da er die SOAP-Endung toll findet.

HttpChannel channel = new HttpChannel(0); // ist 0 kein Port ?
   ChannelServices.RegisterChannel(channel);

Auf Clientseite muss man kein Channel regristrieren, da ein Client kein Channel belegt (es sei denn er gibt nen Port an, um Callbacks/Events mit den Server zu ermöglichen ).
Beispiel:

(ServiceClass) service=(ServiceClass) Activator.GetObject(typeof(ServiceClass),
            "http://localhost:3001/remoteObjectURI.SOAP");
        // hier service verwenden. Man muss (darf/soll) keine Instance danach erzeugen.

Service ist nun ein Proxi-Objekt der Klasse ServiceClass, welche auf dem Server ausgeführt wird. Vorausetzung dafür ist natürlich SAO.
Wo wir bei Server-Teil wären, welchen du eigentlich richtig hast. Nur solltest du auf ein anderen Port gehen (ich hab im Beispiel mal 3001 genommen).

hier mal ein komplettes Hello Remote-Beipspiel:

eine Projektmappe mit 4 Projekten
2 Consolen-Anwendungen (Client/Server)
2 Dll-Projekte (Global/ Interfaces)

Ich mach das immer über Interfaces, weil man dann die Server implementierung ändern kann, ohne den Client neu kompilieren zu müssen.

So, hier quellcode:

// Interfaces.cs
using System;

namespace Interfaces
{
	public interface IHelloService
	{
		string GetHallo();
	}
}

// Global.cs
using System;
using Interfaces;
namespace Global
{
	public class HelloService:MarshalByRefObject,IHelloService
	{
		public string GetHallo()
		{
			Console.WriteLine("Server: Hallo");
			return "Hallo";
		}
	}
}

// Server.cs
using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Remoting.Channels;
using Interfaces;
using Global;
namespace Server
{

	class Start
	{

		[STAThread]
		static void Main(string[] args)
		{
			Console.WriteLine("Server gestartet");
			ChannelServices.RegisterChannel(new HttpChannel(3001));
			RemotingConfiguration.RegisterWellKnownServiceType(typeof(HelloService),
				"HelloService.soap",
				WellKnownObjectMode.Singleton); // hier ein SAO- Singelton. Bei Fragen, einfach Fragen ;)
			Console.ReadLine();
		}
	}
}

// CLient.cs
using System;
using Interfaces;
namespace Client
{
	/// <summary>
	/// Zusammenfassung für Class1.
	/// </summary>
	class Class1
	{
		/// <summary>
		/// Der Haupteinstiegspunkt für die Anwendung.
		/// </summary>
		[STAThread]
		static void Main(string[] args)
		{
				Console.WriteLine("Client gestartet");
			IHelloService t=(IHelloService)Activator.GetObject(typeof(IHelloService),"http://localhost:3001/HelloService.soap");
				Console.WriteLine("Verbindung hergestellt");
			Console.WriteLine("Achte darauf, wo swelcher Text ausgegeben wird!");
			Console.WriteLine("Client " +t.GetHallo());
			Console.ReadLine();
		}
	}
}

man beachte, das der Client weder die Global.dll oder Server-Implementierung kennt. Er kennt nur das Interface.

Bei Fragen helfe ich auch gern weiter...

[e86]

ich danke dir. mir war es erstmal nicht möglich zu antworten, da ich nen grippalen infekt hatte und ne weile das bett hüten musste. werds mir am wochenende mal anschauen.

nice weekend.
kOOni

[e86]

nabend. ich habs getestet und es läuft. aber nur, wenn man client und server auf dem gleichen rechner hat.

was ich will:

rechner 1: hier führe ich server.exe aus
rechner 2: hier führe ich client.exe aus

diese sind mit dem netzwerkkabel verbunden. nun soll auf client eben "hallo" oder sonst was ausgegeben werden.

wie müsste ich den code da modifizieren ?

was ist sao ?

kennt jemand noch gute tutorials zu dem thema ?

kOOni

[AndreasW]

Hi,

SAO ist ein "Server Activated Object".
Was das bedeutet kannst du hier nachlesen:

http://www.codeproject.com/vb/net/RemotingTech.asp
http://www.codeproject.com/csharp/DotNetRemotingBasicTutor.asp
http://www.glacialcomponents.com/ArticleDetail.aspx?articleID=CAOGuide

http://www.awprofessional.com/articles/article.asp?p=102172&seqNum=3
http://www.awprofessional.com/articles/article.asp?p=102172&seqNum=6
http://www.devx.com/vb2themax/Article/19895/1763
http://www.csharphelp.com/archives2/archive422.html
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnpatterns/html/ImpBrokerClient.asp

[e86]

habs nach langer probiererei hinbekommen. ich hatte wohl ein paar logische fehler beim abtippen von deinem quelltext in meinen eingebaut. jedenfalls lief er bei mir nicht übers netzwerk.

da hätte ich aber mal wieder ne frage:

ich will einen kleinen chatclient mache. auf beiden rechner, im lokalen network oder internet, sollen beide user normal texte schreiben können und sich schicken können. wie stelle ich das am dümmsten an ?

mache ich das ambesten über einen stream (system.Io), über einen tcpclient und listener (system.net) oder über eben remoting (siehe die oberen quelltexte) mit objekt übergabe etc.?

kOOni

[AndreasW]

Hi,

ich will einen kleinen chatclient mache. auf beiden rechner, im lokalen network oder internet, sollen beide user normal texte schreiben können und sich schicken können. wie stelle ich das am dümmsten an ?

nun, ein Chat zu programmieren, indem ein Clientrechner eine Verbindung zu einem anderen Clientrechner aufbaut ist ziemlich ineffektiv. Stell dir vor, es gibt 100 Chat-User. Dann muss jeder Rechner mit jeden verbunden sein. Das geht gar nicht.
Bei so was macht man eine zentralisierte Lösung: Man baut sich ein Chat-Server. IRC und Co machen das auch so.

mache ich das ambesten über einen stream (system.Io), über einen tcpclient und listener (system.net) oder über eben remoting (siehe die oberen quelltexte) mit objekt übergabe etc.?

Eine dateibasierte Lösung stelle ich mir kaum als umsetzbar vor. Ein TCPClient und Listener wären da schon denkbar. Wirklich Komfortable ist jedoch erst Remoting.

wie stelle ich das am dümmsten an ?

hm, ist eigentlich ganz einfach. Du könntest das obrige Beispiel so umbauen, dass der Client über eine Methode des Servers nachrichten schickt und über eine Zeitgesteuerten Aufruf den Server über eine Andere Methode nach neuen Nachrichten fragt. Das verursacht aber natürlich enorm Traffic. Deshalb schlage ich eine eventbasierte Lösung vor.

Hier mal ein Beispiel:

Es gibt 3 Projekte in einer Projektmappe:
- Server ? Die Implementation des ChatServers
- Client ? Die Implementaion des ChatClients
- Global ? Schnittstellen und globale Klassen

// Global.cs
using System;
using System.Runtime.Remoting.Messaging;
namespace RemotingTest
{
	[Serializable]
	public class ChatEventArgs
	{
		private string _Message;
		private string _User;
		public ChatEventArgs(string AMessage,string AUser)
		{
			_Message = AMessage;
			_User=AUser;
		}

		public string Message
		{
			get{return _Message;}
		}
		public string User
		{
			get{return _User;}
		}
	}
	public delegate void ChatEventDelegate(object sender, ChatEventArgs e);

	public interface IChatServer
	{
		event ChatEventDelegate OnMessage;
		void SendMessage(string AMessage, string AUser);
	}

	public class RemoteChatEventHandler: MarshalByRefObject
	{
		public ChatEventDelegate OnMessageEvent;
		public RemoteChatEventHandler()
		{

		}

            // Dieses Methode wird vom Server über ein Delegate remote aufgerufen. 
		[OneWay]
		public void OnMessage(object sender, ChatEventArgs e)
		{
                  // Das dieses Objekt im Client instanziert wird, kann man hier ein Delegate der Clientanwendung ohne Probleme aufrufen.                   
			if(OnMessageEvent!=null) 
				OnMessageEvent(sender,e);
		}
	}
}

// CLient.cs
using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
using System.Runtime.Serialization.Formatters;
using System.Collections;

namespace RemotingTest
{
	class ChatClient
	{
		private IChatServer _Server;
		public ChatClient()
		{
			// Verbindung zum ChatServer herstellen
			_Server = (IChatServer)Activator.GetObject(typeof(IChatServer),"tcp://localhost:3001/Chat.tcp");	
			Console.WriteLine("Verbindung zum Server hergestellt");

			// nun die Verbindung des Servers zum Client ermöglichen
                  // Damit der Server ein Event aufrufen kann, muss er eine verbindung zum Clint haben.
                  // Hier wird hier ein freier Port belegt und ein Socket aufgemacht, mit den der Server agieren kann.
                  // Dazu wird en Remoteobjekt auf dem Client erstellt, welches über durch Proxies auf den Server dupliziert werden. 
                  // Dieses Objekt ist hier im Beispiel ein Objekt der Klasse RemoteChatEventHandler und dient als Eventverwalter.  
                  // Das Event wird nun vom Server aufgerufen und im Client ausgeführt.
                  // So wird RemoteChatEventHandler verwendet um rechnerübergreifende Events durchzuführen, da ein Server normalerweise nicht auf ein Client zugreifen kann.

			BinaryServerFormatterSinkProvider provider = new BinaryServerFormatterSinkProvider();
			provider.TypeFilterLevel = TypeFilterLevel.Full;
			IDictionary props = new Hashtable();
			props["port"] =0; // es soll ein Port gesucht werden, der frei ist
			props["name"] = "ClientChatConnection"; 
			TcpChannel tcpChannel = new TcpChannel(props, null,	provider);
			ChannelServices.RegisterChannel(tcpChannel);

			// Die RemoteEvents erstellen.
			RemoteChatEventHandler h=new RemoteChatEventHandler();
			_Server.OnMessage+=  new ChatEventDelegate(h.OnMessage); // Dieses wird Remote im Server aufgerufen und hier im Client ausgeführt
			h.OnMessageEvent+= new ChatEventDelegate(OnChatMessage); // Dieses wird hier im CLient aufgerufen und ausgeführt, wenn das Remote-Event "h.OnMessage" ausgeführt wird. Es wird also das Event durchgereicht.

		}
		public void StartChat(string AUserName)
		{
			Console.WriteLine("Sie sind als :"+ AUserName+" angemeldet. geben sie 'exit' ein um die Chatverbindung zu beenden.");
			string message;
			while(true)
			{
				message=Console.ReadLine().Trim();
				if(message.ToLower()=="exit")
					return;
				_Server.SendMessage(message,AUserName);
			}

		}

		void OnChatMessage(object sender, ChatEventArgs e)
		{
			Console.WriteLine(e.User+ "\t:"+ e.Message);
		}

		[STAThread]
		static void Main(string[] args)
		{
			try
			{
				string name="";
				Console.WriteLine("Geben Sie Ihren Namen ein:");
				name=Console.ReadLine();			
				ChatClient c =new ChatClient();
				c.StartChat(name);
			}
			catch(Exception E)
			{
				Console.WriteLine(E.Message);

			}
Console.ReadLine();
		}
	}
}

// Server.cs
using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
using System.Runtime.Serialization.Formatters;
using System.Collections;

namespace RemotingTest
{

	class ChatServer: MarshalByRefObject,IChatServer
	{
		public event ChatEventDelegate OnMessage;
		public void SendMessage(string AMessage, string AUser)
		{
			if(OnMessage!=null)
				OnMessage(this,new ChatEventArgs(AMessage,AUser));
			Console.WriteLine(AUser+ "\t:"+ AMessage);
		} 

		[STAThread]
		static void Main(string[] args)
		{
			BinaryServerFormatterSinkProvider provider = new BinaryServerFormatterSinkProvider();
			provider.TypeFilterLevel = TypeFilterLevel.Full; // alles serialisieren was den Formatter so vor die Füße geschmissen wird

			IDictionary conf= new Hashtable();
			conf.Add("port",3001);  // den Prot für den Server festlegen
			ChannelServices.RegisterChannel( new TcpChannel(conf, null, provider));
			RemotingConfiguration.RegisterWellKnownServiceType(typeof(ChatServer),
																"Chat.tcp", 
																WellKnownObjectMode.Singleton);
			Console.WriteLine("Chat-Server gestartet...");
			Console.ReadLine();		

		}
	}
}

[AndreasW]

Hi,

der Vollständigkeithalber hier eine Version mit TcpClient und TcpListener.

Ist aber ein wenig komplexer:

//Global.cs
using System;
using System.Net;
using System.Net.Sockets;
using System.Text.RegularExpressions;
using System.Runtime.Serialization.Formatters;
using System.IO;

using System.Runtime.Serialization.Formatters.Binary;

namespace TCPChat
{

	[Serializable]
	public class ChatConnection
	{
		private char[] _ClientHost;
		private uint _ClientPort;
		public string ClientHost
		{
			get{return new string (_ClientHost);}
		}
		public uint ClientPort
		{
			get{return _ClientPort;}
		}
		public ChatConnection(string AClientHost,uint AClientPort)
		{
			_ClientHost=AClientHost.ToCharArray();
			_ClientPort=AClientPort;

		}

		public static ChatConnection FromByteArray(byte[] ABuffer)
		{
			try
			{
				MemoryStream m=new MemoryStream(ABuffer);
				BinaryFormatter f=new BinaryFormatter();
				ChatConnection c= (ChatConnection)f.Deserialize(m);
				return c;
			}
			catch(Exception E)
			{
				Console.WriteLine("Fehler in ChatConnection::FromByteArray:"+E.Message);
				return null;
			}
		}
		public byte[] ToByteArray()
		{
			try
			{
				MemoryStream m=new MemoryStream();
				BinaryFormatter f=new BinaryFormatter();
				f.Serialize(m,this);
				return m.ToArray();
			}
			catch(Exception E)
			{
				Console.WriteLine("Fehler in ChatConnection::ToByteArray:"+E.Message);
				return null;
			}

		}
		public static int Size()
		{
			return 215;
		}
	}

	[Serializable]
	public class ChatMessage
	{
		private char[] _User, _Message;
		public string Message
		{
			get{return new string (_Message);}
		}
		public string User
		{
			get{return new string (_User);}
		}
		public ChatMessage(string AMessage,string AUser)
		{
			_Message=AMessage.ToCharArray(0,Math.Min(AMessage.Length, 1000));
			_User=AUser.ToCharArray(0,Math.Min(AUser.Length, 100));
		}

		public static ChatMessage FromByteArray(byte[] ABuffer)
		{
			try
			{
				MemoryStream m=new MemoryStream(ABuffer);
				BinaryFormatter f=new BinaryFormatter();
				ChatMessage msg= (ChatMessage)f.Deserialize(m);
				return msg;
			}
			catch(Exception E)
			{
				Console.WriteLine("ChatMessage::FromByteArray"+E.Message);
				return null;
			}
		}
		public byte[] ToByteArray()
		{
			try
			{
				MemoryStream m=new MemoryStream();
				BinaryFormatter f=new BinaryFormatter();
				f.Serialize(m,this);

				return m.ToArray();
			}
			catch(Exception E)
			{
				Console.WriteLine("ChatMessage::ToByteArray"+E.Message);
				return null;
			}

		}
		public static int Size()
		{
			return 1100;
		}

	}
}

// ChatClient.cs
using System;
using System.Net;
using System.Net.Sockets;
using System.Text.RegularExpressions;
using System.Runtime.Serialization.Formatters;
using System.IO;
using System.Threading;
namespace TCPChat
{
	public class Client
	{
		private TcpListener _MessageListener;
		private static string host="127.0.0.1";
		public Client()
		{
			try
			{
				// Listenenr zum Mitschreiben der nachrichten starten
				IPAddress IP = IPAddress.Parse(host);
				_MessageListener=new TcpListener(IP,0);
				_MessageListener.Start();
				IPEndPoint p=(IPEndPoint ) _MessageListener.LocalEndpoint;
				uint port=(uint)p.Port;				
				Thread t=new Thread(new ThreadStart(ClientMessageListenerProc));
				t.Start();
				// Verbindung zum Server herstellen
				TcpClient conserver = new TcpClient();
				Console.WriteLine("Verbindung wird hergestellt.....");
				conserver.Connect(IP,3001); 				
				Console.WriteLine("Verbindung zum Server hergestellt");
				// Server den Listener bekanntmachen
				ChatConnection c =new ChatConnection(host,port);
				byte[] b= c.ToByteArray();			   
				conserver.GetStream().Write(b,0,b.Length);
				conserver.Close();
				Console.WriteLine("erfolgreich am Server angemeldet"); 
			}
			catch(Exception E)
			{
				Console.WriteLine(E.Message);
			}
		}
		public void ClientMessageListenerProc()
		{
			while(true)
			{
				try
				{
					Socket socket=_MessageListener.AcceptSocket();	
					byte[] buffer=new byte[ChatMessage.Size()];
					int count=socket.Receive(buffer);
					ChatMessage m= ChatMessage.FromByteArray(buffer);
					if(m !=null)
					{
						Console.WriteLine( m.User +"\t:"+ m.Message);
					}
					Thread.Sleep(200);
				}
				catch(Exception E)
				{
					Console.WriteLine(E.Message);
				}
			}
		}

		public void StartChat(string AUser)
		{
			Console.WriteLine("Sie sind als "+AUser+ " angemeldet. Beenden Sie die Chat-Verbindung mit 'exit'");
			while(true)
			{
				string text= Console.ReadLine();
				if(text=="exit")
					return;
				SendToServer(text,AUser);

			}
		}
		private void SendToServer(string AMessage,string AUser)
		{
			IPAddress IP = IPAddress.Parse(host);
			ChatMessage m=new ChatMessage(AMessage,AUser);
			byte[] b=m.ToByteArray();

			TcpClient messageserver= new TcpClient();
			messageserver.Connect(IP,3002);
			messageserver.GetStream().Write(b,0,b.Length);
			messageserver.Close();	

		}
		[STAThread]
		static void Main()
		{
			Console.WriteLine("Geben Sie Ihren Namen an:");
			string Name=Console.ReadLine();
			Client c=new Client();
			c.StartChat(Name);
		}
	}
}

// ChatServer.cs
using System;
using System.Net;
using System.Net.Sockets;
using System.Text.RegularExpressions;
using System.Threading;
using System.Collections;

namespace TCPChat
{
	public class Server
	{
		private TcpListener _ConnectionListener;
		private TcpListener _MessageListener;
		private ArrayList _Connections;
		private Thread _ConnectionListenerThread;
		private Thread _MessageListenerThread;
		public Server()
		{
			try
			{
				Console.WriteLine("Server wird gestartet");
				_Connections=new ArrayList();
				IPAddress IP = IPAddress.Parse("127.0.0.1");
				_ConnectionListener=new TcpListener(IP,3001);
				_MessageListener=new TcpListener(IP,3002);
				_ConnectionListener.Start();
				_MessageListener.Start();
				_ConnectionListenerThread=new Thread(new ThreadStart(ConnectionListenerProc));
				_ConnectionListenerThread.Start();
				_MessageListenerThread=new Thread(new ThreadStart(MessageListenerProc));
				_MessageListenerThread.Start();
				Console.WriteLine("Server läuft");

			}
			catch(Exception E)
			{
				Console.WriteLine(E.Message);
			}

		}

		private void ConnectionListenerProc()
		{
			while(true)
			{
				Socket socket=_ConnectionListener.AcceptSocket();
				Thread .Sleep(1000);
				byte[] buffer=new byte[ChatConnection.Size()];
				Console.WriteLine("ConnectionListenerProc: buffersize"+buffer.Length.ToString());
				int count=socket.Receive(buffer);
				Console.WriteLine("Anmeldung erfolgt...");
				Console.WriteLine("ConnectionListenerProc:count"+count.ToString());
				lock(_Connections)
					{					
						try
						{							
							ChatConnection c= ChatConnection.FromByteArray(buffer);
							if(c!=null)
							{
								IPAddress IP= IPAddress.Parse(c.ClientHost);
								_Connections.Add(c);
								Console.WriteLine("ChatConnection hinzugefügt");
							}
						}
						catch(Exception E)
						{
							Console.WriteLine(E.Message);
						}
					}				
			}
		}
		private void MessageListenerProc()
		{

			while(true)
			{
				Socket socket=_MessageListener.AcceptSocket();			
				Thread.Sleep(400);
				byte[] buffer=new byte[ChatMessage.Size()];
				int count=socket.Receive(buffer);
				ChatMessage m= ChatMessage.FromByteArray(buffer);
				if(m !=null)
				{
					lock(_Connections)
					{
						try
						{
							foreach(ChatConnection c in _Connections)
							{
								TcpClient Client=new TcpClient();
								IPAddress IP= IPAddress.Parse(c.ClientHost);								
								Client.Connect(IP,(int)c.ClientPort);
								Client.GetStream().Write(buffer,0,count);
								Client.Close();
								Console.WriteLine( m.User+"\t:"+ m.Message);
							}
						}
						catch(Exception E)
						{
							Console.WriteLine(E.Message);
						}
					}
				}
				else
				{
					Console.WriteLine("Message is null");
				}
			}
		}

		[STAThread]
		static void Main()
		{
			Server s=new Server();
			while(true)
			{
				Thread.Sleep(300);
			}

		}
	}
}

schon bei solch ein kleines Projekt zeigt sich, dass Remoting besser geignet ist.

[e86]

Ohh man, das ist mehr als ich erwartet habe. Danke.

das mit dem chat, was ich oben erwähnte, war eher als testbeispiel gedacht. ich möchte eigentlich eine art programm schreiben das wie sub seven funktioniert.
[bitte nicht gleich rumschreien.]

man hat 2 programm versionen, den client und den server. dazu folgendes bsp.:

eine firma administriert die server ihrer kunden. die kunden bekommen die client version. die firma hat die server version und loggt sich in die clients ein. die kunden müssten beständigen ob sie es wollen.

nun kann die firma versch. aktionen durchführen. das soll der hauptgedanke dazu sein.

ich wollte fragen, ob es tutorials gibt, in dennen beschrieben wird, wie man übers netzwerk einen anderen pc auf eine gewisse art steuern kann. dh. software installieren, deinstall., vlt. windows neustarten etc. wenn ihr programmbeispiele habt, bitte nur kurze codeschnipsel posten, möchte es dann selbst weiterversuchen.

ich danke euch schonmal.
kOOni

[AndreasW]

die firma hat die server version und loggt sich in die clients ein. die kunden müssten beständigen ob sie es wollen.

ähm, verwechselst du da nicht was ? Eine Server-Anwendung ist eine Anlaufstelle. Ein Client-Anwendung ist eine Anwendung, die mit einer Server-Anwendung kommuniziert.

bitte nur kurze codeschnipsel posten, möchte es dann selbst weiterversuchen.

ok

Die grundsätzliche Kommunikation ist ja hier in Beispielen beschrieben.

Softwareinstallationen sind einfache exe-Dateien, welche ausgeführt werden. Es gibt für die meisten großen Programmen auch stille Setup-Anwendungen, in denen keine Anwenderabfragen notwendig sind, da werden die Install-Optionen halt in den Startparametern abgefragt. Solen Setup-Anwendungen kannst du ja auch selber erzeugen. Beachte dabei aber auch die rechtlichen Aspekte und das Urheberrecht der Hersteller der zu installierenden Anwendung.
Für die ganzen Installgeschichten gibt es ein recht gutes Buch:

http://www.amazon.de/exec/obidos/ASIN/3860630997/028-2976514-1155744

[/quote] vlt. windows neustarten etc. wenn ihr programmbeispiele habt, bitte nur kurze codeschnipsel posten[quote]

naja, vielleicht sowas:

http://www.dotnet247.com/247reference/msgs/18/92889.aspx