how to dispose a closed connection in wcf

Question

1.00/5 (1 vote)

See more:

I'm trying some samples with wcf where i start the host and some clients. Inside the Service I log construction and destruction of the service objects.

I can see, whenever I connect a new client, a new Service-object is created. But whenever I close the client, the Service-object is NOT destructed.

Is there a way to dispose unused Service-instances ?

my Host:

C#

namespace wcf_Test.Host
{
	public class Params
	{
		public string conn="net.pipe://localhost/myPipe";
		public NetNamedPipeBinding binding=new NetNamedPipeBinding();
	}

	class Program
	{
		public static void Main(string[] args)
		{
			Params cPar=new Params();
 			using (var host = new ServiceHost(typeof (MyService), new Uri(cPar.conn)))
            {
           
           		host.AddServiceEndpoint(typeof (Itest), cPar.binding,"");
          		host.Open();
          		Console.WriteLine("Service running. Press ENTER to stop.");
                        Console.ReadLine();
                ((IDisposable)host).Dispose();
            }
 			 Console.ReadLine();
 			 Console.WriteLine("This is the end");
            }
		}
	}
}

here is my Service:

C#

namespace wcf_Test.Service
{
	[ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Reentrant)]
	public class MyService: Itest
	{
		public IMyCallback callback;
		public Timer timer;

		private int a=1;
		private static int sID=0;
		private int ID=0;

		
		
		public MyService()
		{
			ID=++sID;
			Console.WriteLine("Contructor ID=  {0}",ID);
			callback = OperationContext.Current.GetCallbackChannel<IMyCallback>();	
			
			timer = new Timer(1000);
            timer.Elapsed += OnTimerElapsed;
            timer.Enabled = true;
        }
		~MyService()
		{
			Console.WriteLine("Destructor ID= {0}",ID);	
		}
 
        void OnTimerElapsed(object sender, ElapsedEventArgs e)
        {
            callback.OnCallback();
        }
			
		
		public string getText()
		{		
			return string.Format("Hello from {0}, call number: {1}",ID, a++);
		}
		public void write (string text)
		{
			Console.WriteLine(text);
		}
		public void init()
		{}
	}
}

I tried to insert a screenshot but there's no option to do so, so here is the Output of the Host application after i added your code:

Service running. Press ENTER to stop.
Contructor ID= 1
Contructor ID= 2

//I started and closed two clients here...

This is the end
Destructor ID= 2
Destructor ID= 1

as you can see the instances of the service-object remain active till the application is closed. I closed both clients before pressing the key!

Posted 13-Apr-15 22:13pm

Florian Braun

Updated 13-Apr-15 23:41pm

v3

Add a Solution

Comments

Afzaal Ahmad Zeeshan 14-Apr-15 4:31am

First of all, your connection is not closed; there is no host.Close() in your code. Secondly, you do not overload the destructors but you can somehow do add the logic to destruct the objects. But I do not find your question enough logical, please see Solution 1 for more.

Florian Braun 14-Apr-15 4:54am

Well I want to keep the host running for other clients. So I guess a call of host.close would close every connection to still running clients.

The question is:
* each clients gets a new instance of the service-object. The constructor runs everytime i open a connection. (reading this article: http://www.codeproject.com/Articles/566448/WCF-Instance-Management it seems i am using the perSession mode, with fits perfectly).
* Everytime a client is closed, the deconstructor of the service-instance isn't called, so it seems it remains in memory.

My question is: how can these zombie-instances be disposed without closing the host? I want to keep it running for other clients.

Afzaal Ahmad Zeeshan 14-Apr-15 5:04am

That is because you explicitly open the connection by using host.Open(), but you do not close the connection... Just the way connection is opened for every client, it should be closed for every client. Makes sense?

Also, I have added the solution, in which it is stated that Dispose function is called automatically. Please read the Solution 1.

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Afzaal Ahmad Zeeshan · Answer 1 · 2015-04-13T22:30:00

When you are using the using statement, all of the objects that can be used here (inside the using block) must implement the IDisposable[^] interface. So when you create the block, .NET framework automatically calls the Dispose() function and releases any resource attached to the variables and objects created (specially the one used in the using statement).

So in your code, host variable would get Dispose() called automatically, once the control hits the closing braces (}) of the code block. To give you an overview, your code is similar to this code,

C#

// Create new instance
var host = new ServiceHost(typeof (MyService), new Uri(cPar.conn));

// Use it as connection
host.AddServiceEndpoint(typeof (Itest), cPar.binding,"");
host.Open();
Console.WriteLine("Service running. Press ENTER to stop.");
Console.ReadLine();

// Cast to IDisposable and dispose
((IDisposable)host).Dispose();

The one thing that doesn't get performed is Close() automatically, which you have to call yourself to close the connection. Also, Dispose() does not call the destructor, it just releases the resources for other objects and methods to use; once object is disposed .NET framework would call the destructor[^] automatically, you should not call destructors. For more on this please read this MSDN resource about using statement[^] and all other resources attached.