garbage collection

[André]

Hello,

I have a c# application that creates a timer to fire every minute using
multithreading. On every minute it calls a Ping class that I made using
sockets.
It creates a new ping class then sets it to null when it’s done.

I noticed every time this class gets created I see the memory keeps getting
larger.
I think I should add Idisposable to my ping class and dispose of the memory
after the class is set to null.

Can someone give me their thoughts on this and maybe an example on how to
use the Idisposable class?
Thanks

[Kevin Spencer]

Hi Andre,

You might want to take a look at the following SDK topic:

http://msdn.microsoft.com/library/de...classtopic.asp

IDisposable is not a class; it's an Interface. And if your class employs any
Disposable classes, or interacts with any unmanged or marshalled resources,
setting it to null doesn't do much of anything. Read the article for
details.

--
HTH,

Kevin Spencer
Microsoft MVP
..Net Developer
Ambiguity has a certain quality to it.

"André" <An**@discussio ns.microsoft.co m> wrote in message
news:DD******** *************** ***********@mic rosoft.com...

Hello,

I have a c# application that creates a timer to fire every minute using
multithreading. On every minute it calls a Ping class that I made using
sockets.
It creates a new ping class then sets it to null when it's done.

I noticed every time this class gets created I see the memory keeps
getting
larger.
I think I should add Idisposable to my ping class and dispose of the
memory
after the class is set to null.

Can someone give me their thoughts on this and maybe an example on how to
use the Idisposable class?
Thanks

[André]

Thanks Kevin,

I only use managed code. I am using the sockets class in C#

Does this mean I should not use the Idiposable interaface?

"Kevin Spencer" wrote:

Hi Andre,

You might want to take a look at the following SDK topic:

http://msdn.microsoft.com/library/de...classtopic.asp

IDisposable is not a class; it's an Interface. And if your class employs any
Disposable classes, or interacts with any unmanged or marshalled resources,
setting it to null doesn't do much of anything. Read the article for
details.

--
HTH,

Kevin Spencer
Microsoft MVP
..Net Developer
Ambiguity has a certain quality to it.

"André" <An**@discussio ns.microsoft.co m> wrote in message
news:DD******** *************** ***********@mic rosoft.com...

Hello,

I have a c# application that creates a timer to fire every minute using
multithreading. On every minute it calls a Ping class that I made using
sockets.
It creates a new ping class then sets it to null when it's done.

I noticed every time this class gets created I see the memory keeps
getting
larger.
I think I should add Idisposable to my ping class and dispose of the
memory
after the class is set to null.

Can someone give me their thoughts on this and maybe an example on how to
use the Idisposable class?
Thanks

[Kevin Spencer]

The System.Net.Sock ets.Socket class implements IDisposable. This indicates
that a Socket should be disposed when you're through with it. Since your
class implements at least one Socket, it should ensure that the Socket(s) is
disposed when your class is finished with it.

This means that your class should employ structured exception handling and
other techniques to ensure that this happens. If the Socket is a publicly
exposed member of your class, implementing IDisposable could be a very good
idea, to ensure that any developer implementing your class does not forget
to Dispose the Socket. Your Dispose method would Dispose the Socket.

Classes that implement IDisposable are eventually Garbage-collected even if
they are not Disposed, but there is a significant delay in the release of
the unmanaged resources they use, which can cause the type of memory
build-up you observed.

--
HTH,

Kevin Spencer
Microsoft MVP
..Net Developer
Ambiguity has a certain quality to it.

"André" <An**@discussio ns.microsoft.co m> wrote in message
news:E4******** *************** ***********@mic rosoft.com...

Thanks Kevin,

I only use managed code. I am using the sockets class in C#

Does this mean I should not use the Idiposable interaface?

"Kevin Spencer" wrote:

Hi Andre,

You might want to take a look at the following SDK topic:

http://msdn.microsoft.com/library/de...classtopic.asp

IDisposable is not a class; it's an Interface. And if your class employs
any
Disposable classes, or interacts with any unmanged or marshalled
resources,
setting it to null doesn't do much of anything. Read the article for
details.

--
HTH,

Kevin Spencer
Microsoft MVP
..Net Developer
Ambiguity has a certain quality to it.

"André" <An**@discussio ns.microsoft.co m> wrote in message
news:DD******** *************** ***********@mic rosoft.com...

> Hello,
>
> I have a c# application that creates a timer to fire every minute using
> multithreading. On every minute it calls a Ping class that I made
> using
> sockets.
> It creates a new ping class then sets it to null when it's done.
>
> I noticed every time this class gets created I see the memory keeps
> getting
> larger.
> I think I should add Idisposable to my ping class and dispose of the
> memory
> after the class is set to null.
>
> Can someone give me their thoughts on this and maybe an example on how
> to
> use the Idisposable class?
> Thanks
>

[André]

Thanks Kevin,

Can you help me add the dispose interface?

This is my simple ping class. I looked at the example on Microsoft’s web
page, but not sure how to clean up the resources.

I have one class calling the ping (keepalive) class that calls it like this
every minute.

private void timer_Elapsed(o bject sender, System.Timers.E lapsedEventArgs e)
{

KeepAlive keep = new KeepAlive(Conve rt.ToInt32(Loca lPort));
keep.ping();
keep = null;
}
//*************** *************** *************

//Calls this class.

using System;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sock ets;

namespace SSH2
{
public class KeepAlive
{
int _port;
internal KeepAlive(int port)
{
_port = port;
}

internal void ping()
{
try
{
Encoding ASCII = Encoding.ASCII;
IPEndPoint hostEndPoint;
IPAddress hostAddress = System.Net.IPAd dress.Loopback;
int conPort = port;
string Get = "GET / HTTP/1.1\r\nHost: 127.0.0.1\r\nCo nnection:
Close\r\n\r\n";

Byte[] ByteGet = ASCII.GetBytes( Get);
byte[] RecvBytes = new byte[256];
hostEndPoint = new IPEndPoint(host Address, conPort);
Socket s= new Socket(AddressF amily.InterNetw ork, SocketType.Stre am,
ProtocolType.Tc p);
s.Connect(hostE ndPoint);
s.Send(ByteGet, ByteGet.Length, 0);

s.Close();
}
catch
{
}

}

internal int port
{
get
{
return _port;
}
set
{
_port = value;
}
}
}
}

[Brian Gideon]

André,

In this particular case KeepAlive does not need to implement
IDisposable. This is because Socket is only used in the ping method.
With structured exception handling you can be sure that the Socket
always gets disposed inside that method. To make things easier use the
Socket inside a using block. This guarentees that Dispose will be
called on the Socket even if an exception occurs.

using (Socket s = new Socket(...))
{
s.Connect(...);
s.Send(...);
}
Brian

André wrote:

Thanks Kevin,

Can you help me add the dispose interface?

This is my simple ping class. I looked at the example on Microsoft's web
page, but not sure how to clean up the resources.

I have one class calling the ping (keepalive) class that calls it like this
every minute.

private void timer_Elapsed(o bject sender, System.Timers.E lapsedEventArgs e)
{

KeepAlive keep = new KeepAlive(Conve rt.ToInt32(Loca lPort));
keep.ping();
keep = null;
}
//*************** *************** *************

//Calls this class.

using System;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sock ets;

namespace SSH2
{
public class KeepAlive
{
int _port;
internal KeepAlive(int port)
{
_port = port;
}

internal void ping()
{
try
{
Encoding ASCII = Encoding.ASCII;
IPEndPoint hostEndPoint;
IPAddress hostAddress = System.Net.IPAd dress.Loopback;
int conPort = port;
string Get = "GET / HTTP/1.1\r\nHost: 127.0.0.1\r\nCo nnection:
Close\r\n\r\n";

Byte[] ByteGet = ASCII.GetBytes( Get);
byte[] RecvBytes = new byte[256];
hostEndPoint = new IPEndPoint(host Address, conPort);
Socket s= new Socket(AddressF amily.InterNetw ork, SocketType.Stre am,
ProtocolType.Tc p);
s.Connect(hostE ndPoint);
s.Send(ByteGet, ByteGet.Length, 0);

s.Close();
}
catch
{
}

}

internal int port
{
get
{
return _port;
}
set
{
_port = value;
}
}
}


}

[Marcus Andrén]

On Tue, 18 Oct 2005 08:39:04 -0700, André
<An**@discussio ns.microsoft.co m> wrote:

Thanks Kevin,

Can you help me add the dispose interface?

The code you posted wouldn't be helped by the IDisposable interface
since the socket isn't a persistant resource.

I do have a couple of remarks about your code, including an unmanaged
resource leak. I made some changes to your code to make it cleaner.
Comments are inline:

internal void ping()
{
// Declaration need to be before try block since
// variable is used in finally block
Socket s = null;

try
{
Encoding ASCII = Encoding.ASCII;
IPEndPoint hostEndPoint;
IPAddress hostAddress = System.Net.IPAd dress.Loopback;
int conPort = port;
string Get = "GET / HTTP/1.1\r\nHost: 127.0.0.1\r\nCo nnection:
Close\r\n\r\n";
Byte[] ByteGet = ASCII.GetBytes( Get);
byte[] RecvBytes = new byte[256];
hostEndPoint = new IPEndPoint(host Address, conPort);
Socket s= new Socket(AddressF amily.InterNetw ork,
SocketType.Stre am, ProtocolType.Tc p);
s.Connect(hostE ndPoint);
s.Send(ByteGet, ByteGet.Length, 0);
}
catch(SocketExc eption) // Catch specific exceptions. Swallowing
// all exceptions are bad.
{

}
finally
{
// Everything in finally is called even if an exception has been
// thrown.

// The previous version would leak an unmanaged socket
// resource if an exception was thrown before s.Close() was
// called.

// Call s.Close() or s.Dispose() to release the socket.
// I personally prefer Dispose since it is more generic to the
// framework.
if(s!=null)
s.Dispose();
}
}

--
Marcus Andrén

[André]

ok, i've made the change. Do i just leave this code as it stands?

private void timer_Elapsed(o bject sender, System.Timers.E lapsedEventArgs e)
{

KeepAlive keep = new KeepAlive(Conve rt.ToInt32(Loca lPort));
keep.ping();
keep = null;
}
"Brian Gideon" wrote:

André,

In this particular case KeepAlive does not need to implement
IDisposable. This is because Socket is only used in the ping method.
With structured exception handling you can be sure that the Socket
always gets disposed inside that method. To make things easier use the
Socket inside a using block. This guarentees that Dispose will be
called on the Socket even if an exception occurs.

using (Socket s = new Socket(...))
{
s.Connect(...);
s.Send(...);
}
Brian

André wrote:

Thanks Kevin,

Can you help me add the dispose interface?

This is my simple ping class. I looked at the example on Microsoft's web
page, but not sure how to clean up the resources.

I have one class calling the ping (keepalive) class that calls it like this
every minute.

private void timer_Elapsed(o bject sender, System.Timers.E lapsedEventArgs e)
{

KeepAlive keep = new KeepAlive(Conve rt.ToInt32(Loca lPort));
keep.ping();
keep = null;
}
//*************** *************** *************

//Calls this class.

using System;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sock ets;

namespace SSH2
{
public class KeepAlive
{
int _port;
internal KeepAlive(int port)
{
_port = port;
}

internal void ping()
{
try
{
Encoding ASCII = Encoding.ASCII;
IPEndPoint hostEndPoint;
IPAddress hostAddress = System.Net.IPAd dress.Loopback;
int conPort = port;
string Get = "GET / HTTP/1.1\r\nHost: 127.0.0.1\r\nCo nnection:
Close\r\n\r\n";

Byte[] ByteGet = ASCII.GetBytes( Get);
byte[] RecvBytes = new byte[256];
hostEndPoint = new IPEndPoint(host Address, conPort);
Socket s= new Socket(AddressF amily.InterNetw ork, SocketType.Stre am,
ProtocolType.Tc p);
s.Connect(hostE ndPoint);
s.Send(ByteGet, ByteGet.Length, 0);

s.Close();
}
catch
{
}

}

internal int port
{
get
{
return _port;
}
set
{
_port = value;
}
}
}
}

[Brian Gideon]

Yes, that's fine. Except, you really don't need to set the object
reference to null.

André wrote:

ok, i've made the change. Do i just leave this code as it stands?

private void timer_Elapsed(o bject sender, System.Timers.E lapsedEventArgs e)
{

KeepAlive keep = new KeepAlive(Conve rt.ToInt32(Loca lPort));
keep.ping();
keep = null;
}

[André]

I still notice that the memory usage is getting higher each time the ping is
created. I know that the Garbage collection will get to it when it does.
Should I call the GC.collect? or just let it be?

Also, when is a time that I should use the IDisposable interface? I’m still
new to GC

Thanks
"Brian Gideon" wrote:

Yes, that's fine. Except, you really don't need to set the object
reference to null.

André wrote:

ok, i've made the change. Do i just leave this code as it stands?

private void timer_Elapsed(o bject sender, System.Timers.E lapsedEventArgs e)
{

KeepAlive keep = new KeepAlive(Conve rt.ToInt32(Loca lPort));
keep.ping();
keep = null;
}