Ich fahre einen Audi A6 Baujahr 2005, 2.4Liter Benziner mit 177PS.
Sparsam ist was anderes, aber solange ich noch keine Kinder und kein Haus habe, kann ichs mir leisten.
Daher lieber jetzt sowas schickes fahren, als gar nicht mehr 😃

Sehe das wie mein Vorposter.
Würde wenn dann die Tanzschule bei Facebook einrichten.
Da kann man genauso Einladungen und News versenden und heutzutage haben dort wirklich sehr sehr viele Leute ein Konto.
Eventuell weckt man dadurch, dass manche Leute deine Tanzschule gut finden und das auch in ihren Status schreiben, sogar das Interesse anderer und gewinnt neue Kunden.
Dieser Aspekt ist in der heutigen Zeit keines falls zu unterschätzen. Was besseres als konstenlose Werbung gibts doch nicht, oder?

Hier gibts je nach Stockwerk: versch. Vollautomaten, Kaffefiltermaschinen.
Die Vollautomaten wollen 20 Cent pro Kaffee, Zucker und Milch steht umsonst dabei.
Wasser gibts in 3 versch. Kohlensäurestufen umsonst.

Ich trinke 2-4 Kaffeetassen pro Tag.

Ich hatte ähnliche Probleme, als mein Projekt auf einem Netzlaufwerk lag.

Glaube nicht, dass es an dir liegt, dass du keine Antwort bekommen hast.
Ich kenn mich leider nicht mit WebProxys aus, daher habe ich bisher nicht geantwortet.

Aber wenn du dir mal die anderen Themen anguckst, siehst du das eh nur mit Verzögerung oder gar nicht geantwortet wird.

Formulier deine Frage in englisch und stell sie bei c-sharpcorner.com oder stackoverflow.com rein, da hast du weit aus bessere Chancen 😉

Ja so habe ich das zumindest gemacht:

host = new ServiceHost(DataService, new Uri[] { new Uri("http://localhost:XXX/[B]ServiceÜberbegriff1[/B]/"), });

Und dadrunter dann z.B. :

host.AddServiceEndpoint(typeof(GetData), CreateJob, "CreateJob");
host.AddServiceEndpoint(typeof(GetData), GetStatus, "GetStatus");
host.AddServiceEndpoint(typeof(GetData), GetFinJobList, "GetFinJobList");
host.AddServiceEndpoint(typeof(GetData), GetRunJobList, "GetRunJobList");
host.AddServiceEndpoint(typeof(GetData), CancelJob, "CancelJob");

Und für den nächsten Service genauso einen Überbegriff.

Aber hab ich dann nicht folgendes Problem:
Client fragt (per Timer alle 2 Sekunden) z.B. die GetRunnningJoblist ab und die Anfrage kommt beim Dienst an, genau in dem Augenblick schließe ich den Client.
Dann kann der Dienst es ja nicht zurücksenden und läuft in einen Timeout oder?

Meine Idee dabei war, den Client ohne jegliche Probleme zu jeder Zeit schließen zu können.
Vielleicht geht das aber auch so, wie du es geschrieben hast und ich machs mir zu kompliziert.

Threads brauch ich da nicht drum bauen, da die Responsetime auf maximal eine Sekunde kommt.

Also generell schon mal super, dass ich eventuell kein Callbacks brauche, aber mein Problem würde ich damit ja nicht lösen.
Denn wenn ich jetzt keine Callbacks hätte, würde der Client beim Aufruf von GetRunningJobList() ja ewig warten(bis zum Timeout), da der Dienst am nächsten Tag ja nicht mehr antwortet.

Am Besten ich gucke am Montag(lasse den Dienst übers Wochenende laufen) erst mal ob die WCF "Anrufe" überhaupt noch beim Dienst ankommen.
Sollten ja im Tracing-Log auftauchen.
Und wenn ich das Problem gelöst habe, könnte ich die Callbacks auch rausnehmen.

Edit: Update:

Habe das Tracelog angeguckt und die Clientanfragen kommen noch beim Server an, aber werden nicht mehr weiter verarbeitet.
Screen vom TraceViewer ist im Anhang.

Ich kann die ganze Geschichte mit Sicherheit durch Exceptionhandling mit IErrorHandler lösen, aber wodurch wird die Exception ausgelöst?
Bleibt mir leider immer noch ein Rätsel

Dürfte eigentlich nicht relevant sein, da die Verbindung ja geschlossen wird(hoffentlich richtig).

Scheint wirklich eine Art InactivityTimeout zu sein, der nach mehreren Stunden ohne Aktivität greift.
Dachte erst, dass der ReliableSession InactivityTimeout der Grund sein könnte, aber ich habs nirgends explizit auf true gesetzt. Außerdem antwortet der Server nach 10 Minuten(defaultWert) Inaktivität noch ohne Probleme.

Habe jetzt Tracing und erweitertes Loggen eingeschaltet.
Spätestens Montag weiß ich mehr.

Also so ist es aufgebaut(Dienst):

[ServiceContract(SessionMode = SessionMode.Required, CallbackContract = typeof(ICallback))]
	public interface IGetData
	{
		[OperationContract(IsOneWay = true)]
		void CreateJob(List<object> argList);

		[OperationContract(IsOneWay = true)]
		void GetFinishedJobList();

		[OperationContract(IsOneWay = true)]
		void GetRunningJobList();

		[OperationContract(IsOneWay = true)]
		void GetStatus(string sessionstring);

		[OperationContract(IsOneWay = true)]
		void CancelJob(string sessionstring, string username);
	}
	

	interface ICallback
	{
		[OperationContract (IsOneWay = true, IsTerminating = true)]
		void SendSession(string sessionstring);

		[OperationContract(IsOneWay = true, IsTerminating = true)]
		void SendStatus(string sessionstring, double value, string content, string state);

		[OperationContract(IsOneWay = true, IsTerminating = true)]
		void SendFinishedJobList(List<JobDb> joblist);

		[OperationContract(IsOneWay = true, IsTerminating = true)]
		void SendRunningJobList(List<JobDb> joblist);

		[OperationContract(IsOneWay = true, IsTerminating = true)]
		void SendCancelOk(string message);
	}

Und wenn der Client z.B. den Endpoint GetRunningJobList vom Dienst aufruft passiert auf dem Dienst folgendes:

public void GetRunningJobList()
			{
				ICallback cb = OperationContext.Current.GetCallbackChannel<ICallback>();
				List<JobDb> tmplist = new List<JobDb>();

//tmplist wird gefüllt
				foreach (JobStructure.Job job in JobListRunning)
				{
					if (job.Status == "Running" || job.Status == "Queued")
					{
						tmplist.Add(job.Convert());
					}
				}
//tmplist wird zurückgesendet
				cb.SendRunningJobList(tmplist);
			}

Mach ich da grundlegend was falsch? Bin absoluter Neuling was WCF angeht.

Das könnte ich versuchen um das Problem einzugrenzen, wäre aber keine Dauerlösung für mich.

Das Ganze ist so gedacht:
Dienst läuft und nimmt Jobs von Clients entgegen, arbeitet sie ab.
Client holt sich alle paar Sekunden die Jobübersicht von Dienst.
Client kann und SOLL nach starten der Jobs wieder geschlossen werden.
Das heißt ein Client läuft nur wenn nötig.
Die Verbindung zwischen Dienst und Client wird sofort beendet, so in etwa:
Client schickt CreateJob an Dienst, Dienst sendet nur kurz einen string "job created" + sessionid. Verbindung wird geschlossen.

Genauso wie beim Status abholen. Client schickt GetStatus, Server sendet eine List<>. Verbindung wird geschlossen.

Gibts denn derartige Timeouts? Wo kann ich die sehen/einstellen?
Mein WCF-Dienst soll keine "Ablaufzeit" haben 😄

Hallo,

ich habe einen WCF Dienst, der verschiedene zeitaufwendige Arbeiten erledigt, auf einem Server laufen und frage per Clientanwendung, die im Intranet verfügbar ist, den Status des Dienstes ab und kann auch neue Jobs starten, die der Dienst dann abarbeitet.

Das klappt auch alles wunderbar, doch wenn ich am nächsten Morgen wieder ins Büro komme krieg ich mit der Clientanwendung keine Antwort mehr.
Der Server läuft, der Port ist offen, er arbeitet auch noch die Jobs ab, aber ich krieg keine Callback response mehr vom Dienst zum Client.

Ich kann den Dienst pausieren und wieder fortführen, klappt alles.
Aber wie gesagt, null WCF response.
Wenn ich den Dienst neustarte klappt alles bis zum nächsten Morgen wieder wunderbar.

Als ob der Dienst über Nacht nicht mehr auf seine WCF-Contracts lauscht.

Hat Jemand eine Idee woran es liegen könnte?

Das Einzige das mir jetzt einfällt um das Problem einzugrenzen ist:
Tracing anschalten und ein paar Logausgaben meiner Logging-Klasse benutzen um zu gucken, ob die WCF-Contracts überhaupt noch beim Dienst verarbeitet werden.

Ich verwende WSDualHttpBinding.

Hab meinen Fehler gefunden.
Wenn ich IGetData sämtliche OperationContracts auch IsOneWay auf true setze klappts.
hat sich erledigt

public interface IGetData
	{
		[OperationContract(IsOneWay = true)]
		void GetData(string user, int landid, string landcode, int layer, int provider);

		[OperationContract(IsOneWay = true)]
		void GetOverview();

		[OperationContract(IsOneWay = true)]
		void GetStatus(string sessionstring);

		[OperationContract(IsOneWay = true)]
		void CancelJob(string sessionstring);
	}

Ok ich habe mein WCF Dienst nun so umgebaut, dass der Client den Job an den Host sendet und dann auf die SessionId wartet.
Irgendwie kommt nur nichts zurück und er läuft dort in den Timeout.
Ich versteh momentan nicht wirklich warum, da das generelle zurücksenden an den Client ja vorher auch ohne Probleme ging. Das ist mein ServiceContract.

• GetData hat als Callback SendSession
• GetOverview hat als Callback SendOverview
• GetStatus " " SendStatus
• CancelJob " " SendCancelOk

Jede Get-Methode soll direkt die zugehörige Send-Methode aufrufen und danach soll die Verbindung wieder geschlossen werden.
Vielleicht ist ja auch mein kompletter ServiceContract falsch?
Muss ich für jede Get-methode einen neuen machen?

[ServiceContract(SessionMode = SessionMode.Required, CallbackContract = typeof(ICallbackGetData))]
	public interface IGetData
	{
		[OperationContract]
		void GetData(string user, int landid, string landcode, int layer, int provider);
		
		[OperationContract]
		void GetOverview();

		[OperationContract]
		void GetStatus(string sessionstring);

		[OperationContract]
		void CancelJob(string sessionstring);
	}


	interface ICallbackGetData
	{
		[OperationContract(IsOneWay = true)]
		void SendSession(string sessionstring);
		
		[OperationContract(IsOneWay = true)]
		void SendStatus(double value, string content);

		[OperationContract(IsOneWay = true)]
		void SendOverview(List<JobStructure.Job> joblist);

		[OperationContract(IsOneWay = true)]
		void SendCancelOk();

	}

Also mein Host kriegt den Job, packt ihn auch in meine Jobliste.
Ruft auch SendSession auf, der Client kriegt aber nie was.
Folgendes ist mir noch aufgefallen, wenn der Host den Job gekriegt hat gibt er auf der Console "State: Open" aus, obwohl ich das nirgends in meinem Projekt ausgebe.

Weiß Jemand wo das herkommt?
Ich weiß nicht warum es gerade nicht funktioniert.
Wie gesagt, den Status zurücksenden oder Ähnliches hat vor dem Umbau ohne probleme geklappt.

Vielleicht liegt das Problem auch hier unten begraben:
Ich würde gerne bei ServiceBehavior, InstanceContextMode komplett weglassen (auf default). Wenn ich das mache krieg ich folgende Fehlermeldung beim host.open()

Um einen der ServiceHost-Konstruktoren zu verwenden, der eine Dienstinstanz annimmt, muss der InstanceContextMode des Diensts auf InstanceContextMode.Single festgelegt sein. Dies kann über das ServiceBehaviorAttribute konfiguriert werden. Andernfalls sollten Sie erwägen, die ServiceHost-Konstruktoren zu verwenden, die ein Type-Argument annehmen.

public class JobAdministration
	{

		[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
		public class GetDataService : IGetData
		{
			public void GetData(string user, int landid, string landcode, int layer, int provider)
			{
                         .....
			}


			public void GetStatus(string sessionstring)
			{
			....
			}

			public void GetOverview()
			{
                        ....
			}

			public void CancelJob(string sessionstring)
			{
			...
			}
		}
	}

Darf ich hier dem ServieHost Konstruktor nicht getDataService mitgeben? Liegt da der Fehler?

JobAdministration.GetDataService getDataService = new JobAdministration.GetDataService();
			jobList = getDataService.JobList;


			ListChecker listChecker = new ListChecker(jobList);
			TimerCallback delegateTimer = new TimerCallback(listChecker.StatusChecker);
			AutoResetEvent autoEvent = new AutoResetEvent(false);

			jobTimer = new Timer(delegateTimer, autoEvent, 2000, 4000);	

			using (ServiceHost host = new ServiceHost(getDataService, new Uri[] {new Uri("http://localhost:8080"),}))
			{

				host.AddServiceEndpoint(typeof (IGetData), new WSDualHttpBinding(), "GetData");
				host.AddServiceEndpoint(typeof (IGetData), new WSDualHttpBinding(), "GetStatus");
				host.AddServiceEndpoint(typeof (IGetData), new WSDualHttpBinding(), "GetOverview");
				host.AddServiceEndpoint(typeof (IGetData), new WSDualHttpBinding(), "CancelJob");

				host.Open();
				
				
				
				Console.WriteLine("Service is available. " + "Press <ENTER> to exit.");


				Console.ReadLine();
				host.Close();
				jobTimer.Dispose();
			}

Was mache ich falsch? Wahrscheinlich viel, aber warum kommt nichts an den Client zurück?

Ah ok, dann ist das damit schon erledigt.

Ja das läuft alles nach Plan. Es sind Jobs die bis zu 10 Millionen Datensätze aus versch. Tabellen abruft und diese mit einander verknüpft und wieder in eine andere Datenbank schreibt. Das Problem ist, dass je Datensatz auch Geography Daten enthalten sind, die teilweise bis zu 4GB groß sind( ein einzelner Datensatz) und noch durch komplexe Vergleiche und Manipulationen läuft.

Vielen Dank für die Hilfe 😃

Nein, es soll kein Job parallel laufen, daher ja Singleton.
Die Idee, dass der Client den Status abfragt ist gut, das löst schon mal ein Problem, danke.

Und ja die Jobs sollen warten. Das Problem ist, dass ein einzelner Job mal locker 1 Tag dauern kann. Wie krieg ich es hin, dass die anderen Jobs trotzdem solange warten, bis sie dran sind? Timeout hochsetzen kann ja nicht die Lösung sein.

Mit Jobtabelle ist folgendes gemeint:
Eine Tabelle auf einem SQL Server, wo sich der Client seine Jobs einträgt und der Host Job für Job da abholt und abarbeitet.
Z.B. Ganz simple:

JobName JobParameter1 JobParameter2

Job1 string1 integer1
Job2 string2 integer2
Jobn....

Hallo,

ich bin ein absoluter Anfänger was WCF angeht.

So sieht mein WCF Host/Client momentan aus:

Der Host läuft auf einem Server, der seine Dienste dem kompletten Intranet bereitstellt.
Client wird (momentan) noch von mehreren Arbeitsplätzen gestartet.

• Client stößt einen Job auf dem Host an, dieser führt dann eine zeitintensive Arbeit durch (Sql Abfragen etc.).
• Host sendet regelmäßig seinen Status (in %) an Client(Callbackcontract) und an eine Jobtabelle auf einem SQL Server zurück.
  Als InstanceContextMode ist Single gesetzt, weil Job für Job abgearbeitet werden soll und nicht mehrere auf einmal.

Problem1:
Wenn mehrere Clients einen Job starten, reihen sich diese in die Warteschleife ein, wenn bereits ein Job aktiv ist. Wenn dieser Job zu lange dauert, brechen die anderen Jobs mit Timeouts ab.

Problem2:
Schließe ich den Client, bricht der gestartete Job beim Host ab, weil er den Status nicht mehr zurücksenden kann(Timeout).

Ich benötige also eine echte Warteschleife, die unabhängig von Timeouts die Jobs aufnimmt und einen nach dem anderen abarbeitet. Geht das überhaupt ohne zusätzliche SQL-Jobtabelle?
Und der Client soll nach Anstoß des Jobs geschlossen werden können, ohne dass der Job vom Host unterbrochen wird.

Wie kann ich das am Besten umsetzen?

Vielen Dank im Voraus für die Antworten