Laden...

Remote-Event Fehlermeldung

Letzter Beitrag vor 17 Jahren 25 Posts 12.375 Views
Remote-Event Fehlermeldung

Hallo nochmal,

ich bin immer noch am Remoting drann, jetzt beschäftige ich mich mit Events die über .NET Remoting gehandelt werden sollen.

Hier ist mal mein RemoteObject:


namespace RemoteObjects
{
	public delegate void NameChangedEventHandler(object sender, NameChangedEventArgs e);

	public class RemoteObject: MarshalByRefObject 
	{
		public event NameChangedEventHandler NameChanged;

		private string _name;

		public string Name
		{
			get{return _name;}
			set
			{
				string oldName = _name;
				string newName = value;
				_name = value;
				Console.WriteLine("Change Name from " + oldName + " to " + newName);
				if(NameChanged != null)
				{
					NameChanged(this, new NameChangedEventArgs(oldName, newName));
				}
			}
		}

		public RemoteObject()
		{
			_name = "";
			Console.WriteLine("Create RemoteObject at " + DateTime.Now.ToShortTimeString());
		}

		public String GetGreeting() 
		{
			return ("Hallo " + _name);
		}
	}
}

Und hier ein ClientObject welches das RemoteObject Aggregiert:


namespace WindowsClient
{
	[Serializable]
	public class DataClass
	{
		private RemoteObject _remoteObject;

		public string Name
		{
			get{return _remoteObject.Name;}
			set{_remoteObject.Name = value;}
		}

		public DataClass()
		{
			_remoteObject = new RemoteObject();
			_remoteObject.NameChanged += new NameChangedEventHandler(_remoteObject_NameChanged);
		}

		 ~DataClass()
		{
			_remoteObject.NameChanged -= new NameChangedEventHandler(_remoteObject_NameChanged);
			_remoteObject = null;
		 }

		private void _remoteObject_NameChanged(object sender, NameChangedEventArgs e)
		{
			// Do something...
		}
	}
}

Sobald versucht wird dem Ereignis eine Methode anzuhängen kommt die Fehlermeldung:

"Eine nicht behandelte Ausnahme des Typs 'System.Security.SecurityException' ist in mscorlib.dll aufgetreten.

Zusätzliche Informationen: Typ 'System.DelegateSerializationHolder' und die davon abgeleiteten Typen (z.B. 'System.DelegateSerializationHolder') dürfen in dieser Sicherheitsebene nicht deserialisiert werden."

Was muss ich tun damit die Events auch über Remoting funktionieren?

Viele Grüße

Roland

Hast du TypeFilterLevel.FullTrust eingestellt?

// TcpChannel für Server registrieren.
BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();
BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
serverProvider.TypeFilterLevel = TypeFilterLevel.Full;
IDictionary p = new Hashtable();
p["port"] = 1234;
p["name"] = "server";
TcpChannel ch = new TcpChannel(p, clientProvider, serverProvider);
ChannelServices.RegisterChannel(ch);

Beim Client ist FullTrust nicht erforderlich. Für Events ist es nur wichtig, dass der Client einen Port zugewiesen bekommt. Das erreicht man indem man beim Registrieren des TcpChannels als Port 0 angibt.

Gerade mit Remoting und Events wird aber noch ein anderes Problem auftreten. Und zwar muss auf Serverseite jegliche Client-Klasse verfügbar sein, die sich für Events registrieren könnte. Für eine Server-Anwendung ist das eigentlich nicht zumutbar. Es soll ja gerade möglich sein, dass sich beliebige Clients verbinden können.

Am besten wäre es deshalb bei Remoting auf Events zu verzichten. Dem Server reichen dann Interfaces für die Clients und die Client-Klassen können auf Clientseite bleiben.

Eine andere Möglichkeit ist, eine spezielle Klasse zu definieren und diese zum Abonnieren von Server-Events zu verwenden. Die Klasse ist auf Client- und auf Server-Seite verfügbar. Der Server braucht dann nur noch diese eine Klasse und es können sich trotzdem beliebige Clients für die Events anmelden.

Gruss
Pulpapex

Hi, erstmal vielen Dank für deine Antwort.

Ich wusste nicht wie Fulltrust angegeben werden soll, deshalb hilft mir dein Beispiel schon sehr viel weiter.

Es ist schade das die Serveranwendung die Klassen kennen muss die auf ein Server-Event reagieren sollen, das bringt mein ganzes Konzept durcheinander. Natürlich ist es nicht zumutbar alle Klassen der Serveranwendung mitzugeben, schliesslich weiss man ja jetzt noch nicht welche Client-Klassen auf Events reagieren sollen und die Serveranwendung soll deswegen bestimmt nicht am laufenden Bande geändert bzw. um die neuen Klassen erweitert werden. Dann kann man auch direkt auf Remoting verzichten.

Eigentlich wollte ich folgendes erreichen:

Es gibt eine Server-Klasse die Daten bereithält. Auf diese Daten können mehrere Clientanwendungen per Remoting zugreifen. Eigentlich wollte ich dann gerne die Eigenschaften der Server-Klasse an Controls binden. Dann wollte ich erreichen das wenn ein User in einem Client eine Eigenschaft der Server-Klasse ändert das das sofort alle anderen Clients mitbekommen und die geänderten Daten anzeigen ohne das ständig eine Abfrage der Server-Klasse in einem bestimmten Intervall stattfindet. Deshalb wollte ich ja auch Events einsetzen, denn dann hätte jeder Client sich bei der Server-Klasse registriert und wäre automatisch benachrichtigt worden sobald sich eine Eigenschaft ändert und dann hätten die Controls aktualisiert werden können.

Hat jemand eine Idee wie dieses Szenario zu realisieren wäre?

Viele Grüße

Roland

Hallo roland!

Grob hätte ich da ein Lösungsvorschlag, wenn ich auch nicht der perfekte Umsetzer von IdealLösungen bin 😉

Der Server merkt sich welcher Client welche Objekte benutzt. (Oder lässt sich das irgendwie anders herausfinden) -> Ich dachte da an eine Liste, die Serverseitig gehalten wird.

Deine Daten werden mittels Get/Set Properties geholt, bsw. gesetzt. Nach dem Setzen beliebiger Daten, springst Du in eine Unterfunktion, so was wie UpdateClients.

Diese Unterfunktion arbeitet oben genannte Liste ab, und löst bei jedem Client ein Event aus, worauf er aufgefordert wird das Objekt neu vom Server zu holen.

So hast Du dein Event auf die clients umgelegt, was dann aber realisierbar sein sollte, meiner Meinung nach.

Dafür habe ich leider keinen Code, und ich weiß auch nicht, ob diese Lösung mit viel oder wenig Aufwand realisierbar ist, aber ich denke es ist ein Lösungsansatz.

Ciao
Norman-Timo

A: “Wie ist denn das Wetter bei euch?”
B: “Caps Lock.”
A: “Hä?”
B: “Na ja, Shift ohne Ende!”

Hallo zusammen,

naja, ein Server kann ja vom Grundsatz her nicht von sich aus aktiv werden, sondern nur auf Anfragen des Clients reagieren. Es könnte also eine Lösung sein, eine Rückverbindung zu allen Clients aufzubauen, statt Events zu verwenden. Das ist aber nur ein unreflektierter Gedanke.

herbivore

@norman_timo: Ich kann dir im Forum keine PMs schicken (du hast wohl die Funktion gesperrt). Habe stattdessen gestern eine E-Mail geschickt.

Statt Events kann das Observer-Pattern eingesetzt werden. Vielleicht kennst du die Listeners in Java, in der Art in etwa. Der Server hat Methoden zum Hinzufügen und Entfernen von Client-Interfaces und das Client-Interface hat Methoden, die der Server aufruft. (So wird es auch im MSDN empfohlen, allerdings finde ich die Seite nicht mehr)

// Observer-Pattern: Subjekt
public class Server {

  public IList Clients { get; set; }

  public void ClientConnect(IClient client) { }
  public void ClientDisconnect(IClient client) { }
}

// Observer-Pattern: Observer
public interface IClient {

  void ClientConnect(string clientName);
  void ClientDisconnect(string clientName);
  void ReceiveMessage(string clientName, string message);

  // usw.
}

Eine Client-Implementierung definiert dann die Events, über die die Controls aktuell gehalten werden. Somit kann auf Clientseite weiterhin wie gewohnt mit Events programmiert werden.

// Observer-Pattern: Konkreter Observer
public class ConcreteClient : IClient {

  public void ClientConnect(string clientName) {}
  public void ClientDisconnect(string clientName) {}
  public void ReceiveMessage(string clientName, string message) {}

  protected void OnClientConnected(string c) {}
  protected void OnClientDisconnected(string c) {}
  protected void OnMessageReceived(string c, string m) {}

  public event ClientConnectedEventHandler ClientConnected;
  public event ClientDisconnectedEventHandler ClientDisconnected;
  public event MessageReceivedEventHandler MessageReceived;
}

So wie du es vorgehabt hast, dass sich Windows-Controls direkt für Server-Events registrieren, ist es meines Erachtens ohnehin nicht machbar. Das würde nämlich bedeuten, dass der Server ein Event mehrmals übers Netz senden muss - für jedes registrierte Control einmal - wäre nur unnötige Netzlast.

Gruss
Pulpapex

Hallo,

vielen Dank für eure Antworten. Das mit dem ObserverPattern werde ich mal ausprobieren. Schade nur das keine Events übers Netz verschickt werden. Ich finde das dies eine praktische Sache wäre.

Viele Grüße

Roland

Vielleicht darf ich auch noch eine Lösungsmöglichkeit vorschlagen welche auch die Veröffentlichung der Clientimplementierung umgeht.
Das ganze geht Richtung Event-Channel-Pattern.

Server will Client eine Event, Nachricht oder was auch immer schicken.
Dazu muss der Server irgendwas kennen wo er die Nachricht schicken kann.
Dazu erstellst du eine neue Klasse. Diese bietet ein Ereignis an welche vom Client aboniert werden kann. Damit Rechnergrenzen überwunden werden können muss diese Klasse von MarshalByRefObject erben. Damit alle Teilnehmer (Client u. Server) dieses Objekt kennen wird's in eine Bibliothek gepackt und steht beiden zu Verfügung.

Klasse könnte so aussehen:


public class CNameChangedListener : MarshalByRefObject 
{
	//hier registriert sich ein Client
	public event NameChangedEventHandler NameChanged;
		
	//das ruft der Server auf
	public void OnNameChangedEvent(object sender, NameChangedEventArgs e)
	{			
		if(NameChanged != null)
			NameChanged(sender,e);
	}
}

So schaut dann der Code auf Clientseite aus, hab mich mal auf deinen Code bezogen:


//der Einfachheit haben die EventHandler dieselbe Signatur, Namespace muss evtl. auch angepasst werden

//Object anlgen welches auch der Server kennt (Metainformationen)
nameChangedListener  = new CNameChangedListener ();
			
//lokale Funktion registrieren
nameChangedListener.NameChanged += new RemoteObjects.NameChangedEventHandler(this.MethodeBeiClient);

//Object beim Server registrieren				
iServer.NameChanged += new RemoteObjects.NameChangedEventHandler(nameChangedListener.OnNameChangedEvent);

Hallo AlfameisterT,

so wie ich deine Lösung verstehe schleust du das Event noch zusätzlich über eine weitere Klasse. Allerdings verstehe ich nicht ganz wie das mein Problem lösen soll, denn hier ist ja wieder ein Client-Objekt an ein Event des Server-Objektes genknüpft, damit ist ist doch die selbe Situation wie vorher. Anscheinend bin ich aber auch einfach nur zu blöde um deine Code zu verstehen! 😉

Ich versuche mich gerade mal an dem Observer-Pattern. Hierzu habe ich mir was bei CodeProject runtergeladen. Wen es interessiert, hier der Link zum Artikel: http://www.codeproject.com/csharp/c_sharp_remoting.asp.

Hierbei habe ich aber wieder ein Problem, sobald ein Client-Objekt sich bei dem Server-Objekt registrieren will, kommt eine Security-Exception vom Remoting-System. Ich habe auch versucht das Observer-Pattern selber zu lösen, aber leider auch nur mit dem selbigen Erfolg der auftretenden Security-Exception. Was für Sicherheitseinstellungen müssen bei dem Framework 1.1 denn vorgenommen werden? Kennt sich jemand damit aus? Hat jemand sich schon mal das Projekt angeschaut?

Liebe Grüße

Roland

Hallo,

Schade nur das keine Events übers Netz verschickt werden. Ich finde das dies eine praktische Sache wäre.

Ich wollte eigentlich nur nochmal dafür ein Beispiel geben. Das ist ja das was Pulpapex in seinem Post erwähnte.
Also es kann sehrwohl die Event-Klasse benutzt werden. Die nimmt ja einem viel Arbeit ab (An- u. Abmelden, sich alle Clients merken, dann in ner Schleife alle benachrichtigen usw)

denn hier ist ja wieder ein Client-Objekt an ein Event des Server-Objektes genknüpft

Versteh ich jetzt nicht 😉

Der Server muss in diesem Fall über keine Client-Informationen verfügen. Es ist wurscht welcher Client sich für das Ereignis interessiert.

Aber hast das Bsp. schon richtig verstanden. Ist so ne Art Repeater. Der fängt das Ereignis und gibt es wieder.

Wegen der Sicherheitseinstellungen einfach das vom 2. Post übernehmen.

Hallo Leuts,

das mit der Security-Exception hatte sich gelegt sobald im Server wie im 2 Posting der Tcp-Channel geöffnet wurde. =)

Jetzt habe ich mal eine kleine Observer-Pattern App geschrieben um das ganze zu testen. Leider läuft da immer noch was falsch! 🙁 Die Clients können sich jetzt beim Server registrieren, die Notify-Methode des Servers wird auch ausgeführt, aber bei den Clients wird die Update-Methode nicht aufgerufen. Vielleicht sieht ja einer was hier noch nicht richtig ist. 🙂


namespace RemoteObjects
{
	public interface IServer
	{
		void Add(IClient client);
		void Remove(IClient client);
		void Notify();
	}
}

namespace RemoteObjects
{
	public interface IClient
	{
		void Update(IServer sender);
	}
}

namespace RemoteServer
{
	public class ServerObject : MarshalByRefObject, IServer
	{
		private ArrayList _clients;

		public ServerObject()
		{
			_clients = new ArrayList();
			Console.WriteLine("ServerObject created");
		}

		public void Add(IClient client)
		{
			Console.WriteLine("Add Client to ServerObject");
			_clients.Remove(client);
		}

		public void Remove(IClient client)
		{
			Console.WriteLine("Remove Client from ServerObject");
			_clients.Add(client);
		}

		public void Notify()
		{
			Console.WriteLine("ServerObject Notify-Method called");
			for (int i = 0; i < _clients.Count; i++)
			{
				IClient client = (IClient)_clients[i];
				client.Update(this);
			}
		}
	}
}

namespace RemoteServer
{
	class RemoteServer
	{
		/// <summary>
		/// Der Haupteinstiegspunkt für die Anwendung.
		/// </summary>
		[STAThread]
		static void Main(string[] args)
		{
			BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();
			BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
			serverProvider.TypeFilterLevel = TypeFilterLevel.Full;
			IDictionary p = new Hashtable();
			p["port"] = 12345;
			p["name"] = "RemoteServer";
			ChannelServices.RegisterChannel(new TcpChannel(p, clientProvider, serverProvider)); 
			RemotingConfiguration.RegisterWellKnownServiceType (typeof(ServerObject), "Server", WellKnownObjectMode.Singleton);
			Console.WriteLine("Hit Enter to exit");
			Console.ReadLine();
		}
	}
}

namespace RemoteClient
{
	public class ClientObject : MarshalByRefObject, IClient
	{
		public ClientObject()
		{
			Console.WriteLine("ClientObject created");
		}

		public void Update(IServer sender)
		{
			Console.WriteLine("Update by Server-Object");
		}
	}
}

namespace RemoteClient
{
	class RemoteClient
	{
		/// <summary>
		/// Der Haupteinstiegspunkt für die Anwendung.
		/// </summary>
		[STAThread]
		static void Main(string[] args)
		{
			ChannelServices.RegisterChannel(new TcpChannel(0));
			IServer server = (IServer)Activator.GetObject(typeof(IServer),"tcp://localhost:12345/Server");
			IClient client = new ClientObject();
			server.Add(client);
			Console.WriteLine("Type Q for exit");
			string strAnswer = Console.ReadLine();
			while (strAnswer != "Q")
			{
				server.Notify();
				strAnswer = Console.ReadLine();
			}
		}
	}
}


Ich danke euch auf jedenfall sehr für eure Hilfe! Durch dieses Forum fällt einem schon mal leichter was zu verstehen. 😁

Viele liebe Grüße

Roland

Na auf jeden Fall sind da Fehler in den Methoden ServerObject.Add und ServerObject.Remove.

Hallo Pulpapex,

würdest du mir auch sagen was an den Methoden falsch ist? Es handelt sich hier auch nur um eine Beispielapplikation zu Übungszwecken. Hier wird natürlich nichts abgefangen oder grossartig überprüft um den Code so schmal wie möglich zu halten.

Viele Grüße

Roland

Moin roland,

hast du dir die Methoden mal angeschaut? Für mich sieht es so aus als wenn
da was vertauscht wäre. Eigentlich sticht es doch ins Auge:


public void Add(IClient client)
{
    Console.WriteLine("Add Client to ServerObject");
    _clients.Remove(client);
}

public void Remove(IClient client)
{
    Console.WriteLine("Remove Client from ServerObject");
    _clients.Add(client);
}

Du meinst das mit Console.WriteLine...?

Das ist Absicht, denn ich möchte zum Protokoll die Meldungen in der Konsole der Server-Anwendung ausgeben. 😉

Mittlerweile habe ich auch herausgefunden wie Events super über Remoting funktionieren. Ich habe das ganze mal in eine kleine einfache Chat-Anwendung gepackt. Hier ist der Code:


namespace RemoteObjects
{
	[Serializable]
	public class NotifyEventArgs : EventArgs
	{
		private string _message;

		public string Message
		{
			get{return _message;}
		}

		public NotifyEventArgs(string message)
		{
			_message = message;
		}
	}
}

namespace RemoteObjects
{
	public interface IClient
	{
		void NotifyEventMethod(object sender, NotifyEventArgs e);
	}
}

namespace RemoteObjects
{
	public delegate void NotifyEventHandler(object sender, NotifyEventArgs e);

	public interface IServer
	{
		event NotifyEventHandler NotifyEvent;
		void Notify(string message);
	}
}

namespace RemoteObjects
{
	public class ClientObject : MarshalByRefObject, IClient
	{
		private IServer _server;

		public ClientObject(IServer server)
		{
			_server = server;
			_server.NotifyEvent += new NotifyEventHandler(NotifyEventMethod);
		}

		~ClientObject()
		{
			_server.NotifyEvent -= new NotifyEventHandler(NotifyEventMethod);
		}

		public void NotifyEventMethod(object sender, NotifyEventArgs e)
		{
			Console.WriteLine(e.Message);
		}
	}
}

namespace RemoteObjects
{
	public class ServerObject : MarshalByRefObject, IServer
	{
		public event NotifyEventHandler NotifyEvent;

		public void Notify(string message)
		{
			if (NotifyEvent != null)
				NotifyEvent(this, new NotifyEventArgs(message));
		}
	}
}

namespace RemoteClient
{
	class RemoteClient
	{
		/// <summary>
		/// Der Haupteinstiegspunkt für die Anwendung.
		/// </summary>
		[STAThread]
		static void Main(string[] args)
		{
			BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();
			BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
			serverProvider.TypeFilterLevel = TypeFilterLevel.Full;
			IDictionary p = new Hashtable();
			p["port"] = 0;
			p["name"] = "RemoteClient";
			ChannelServices.RegisterChannel(new TcpChannel(p, clientProvider, serverProvider)); 
			IServer server = (IServer)Activator.GetObject(typeof(IServer),"tcp://192.168.123.190:12345/Server");
			IClient client = new ClientObject(server);
			Console.WriteLine("Type Quit to Exit!");
			string message = Console.ReadLine();
			while (message != "Quit")
			{
				server.Notify(message);
				message = Console.ReadLine();
			}
		}
	}
}

namespace RemoteServer
{
	class RemoteServer
	{
		/// <summary>
		/// Der Haupteinstiegspunkt für die Anwendung.
		/// </summary>
		[STAThread]
		static void Main(string[] args)
		{
			BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();
			BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
			serverProvider.TypeFilterLevel = TypeFilterLevel.Full;
			IDictionary p = new Hashtable();
			p["port"] = 12345;
			p["name"] = "RemoteServer";
			ChannelServices.RegisterChannel(new TcpChannel(p, clientProvider, serverProvider)); 
			RemotingConfiguration.RegisterWellKnownServiceType (typeof(ServerObject), "Server", WellKnownObjectMode.Singleton);
			Console.WriteLine("Hit Enter to exit");
			Console.ReadLine();
		}
	}
}

Das ganze besteht aus zwei Konsolenanwendungen

  • RemoteServer.exe
  • RemoteClient.exe

und einer DLL

  • RemoteObjects.dll

Damit brauch man das Oberver-Pattern nicht mehr direkt umzusetzen da es in dem Event ja enthalten ist. Der einzige Nachteil ist, das die Klasse mit der NotifyEventMethod-Methode in der DLL enthalten sein muss.

Viele Grüße

Roland

Ich meinte eigentlich, dass in der Add-Methode _clients.Remove drin steht
und in Remove _clients.Add.

Ups... 😁

Das habe ich völlig übersehen!!!

Danke!

Windows-Anwendung

Hallo!

Ich habe leider nicht viel Erfahrung mit C# (arbeite normalerweise mit Java).
Ich habe als Beispiel deine Chat-Anwendung verwendet, aber ich habe versucht, das alles als Windows-Anwendung aufzubauen.


namespace prog
{

    public partial class HauptForm : Form, IHauptForm
    {
        private IServer server;
        private IClient client;
        private string nik;

        public HauptForm(string nik, string adresse)
        {
                this.nik = nik;
                InitializeComponent();
                BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();
                BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
                serverProvider.TypeFilterLevel = TypeFilterLevel.Full;
                IDictionary p = new Hashtable();
                p["port"] = 0;
                p["name"] = "RemoteClient";
                ChannelServices.RegisterChannel(new TcpChannel(p, clientProvider, serverProvider));
                server = (IServer)Activator.GetObject(typeof(IServer), adresse);
                client = new ClientObject(spiel, this);
        }

        private void MyMouseClick(object sender, MouseEventArgs e)
        {
             this.server.Notify(this.nik + " hat angeklickt!!!");

        }
        public void setStatus(string messege)
        {
            this.toolStripStatusLabel1.Text = messege;
        }

    }
}



namespace prog
{
    public interface IHauptForm
    {
        void setStatus(string messedge);
    }
}


namespace prog
{
    public class ClientObject : MarshalByRefObject, IClient
    {
        private IServer _server;
        private IHauptForm _hp;


        public ClientObject(IServer server, HauptForm form)
        //public ClientObject(IServer server)
        {
            _server = server;
            _hp = form;
            _server.NotifyEvent += new NotifyEventHandler(NotifyEventMethod);
        }

        ~ClientObject()
        {
            _server.NotifyEvent -= new NotifyEventHandler(NotifyEventMethod);
        }

        public void NotifyEventMethod(object sender, NotifyEventArgs e)
        {
            Console.WriteLine(e.Message);
            this._hp.setStatus(e.Message);
         }
    }
}

Folgendes Problem habe ich dabei:
Beim Ausführen der Methode NotifyEventMethod(object sender, NotifyEventArgs e) in der Klasse ClientObject stürzt das Programm ab, und zwar hier: this._hp.setStatus(e.Message);

Vielleicht kann mir jemand helfen?

Danke im Voraus.

Hallo Camel,

[Hinweis] Wie poste ich richtig? Punkt 5.

herbivore

Hi,
bez. [Hinweis] Wie poste ich richtig? Punkt 5.
es gibt keine Fehler- bzw. Exceptionmeldung 🙁

Hallo Camel,

ein Absturz unter .NET ohne Fehlermeldung ist sehr unwahrscheinlich. Ohne Fehlermeldung endet ein Programm normalerweise nur, wenn es normal beendet wird.

Fange im Main mal alle evtl. auftretenden Exceptions und gib sie aus. Kommt da was?

herbivore

wenn keine Fehlermeldung kommt, könnte es vielleicht sein, dass du in einer Endlosschleife drin bist?

greetz..

I cna tpye 300 wrods pre mnuite!

Hi,
ich habe das versucht, aber es kommt nichts...
Im Windows Task-Manager steht "Form1 Keine Rückmeldung"
X(

Hallo Camel,

ok, dann stützt die Anwendung also gar nicht ab. Siehe [FAQ] Warum blockiert mein GUI?.

herbivore

Lass das ganze mal ein paar Minuten laufen - hatte ein ähnliches Problem vor einiger Zeit. Irgendwann kam dann eine Exception. Gelöst hab ich das Problem bisher noch nicht, hab mich damit aber auch nicht mehr damit beschäftigt.
Ich konnte keine Methoden von (an den Server) übergebenen Klassen aufrufen - dann ist das ganze gestanden.