C＃是对象有效的

Question

You can check if an object is null but can you check if an object is valid?

Assert.IsValid(object_name);

For example, the object has been deleted by the garbage collector or someone has done dispose on it. But the pointer is still pointing to that object.

Answer 1

If the object has been freed by the garbage collector, you won't have a reference to it, by definition.

If it's been disposed and that's important to the object's validity, the type ought to provide a way of determining that. (In some cases Dispose can just mean "reset", for example.)

It's rarely appropriate to even allow the possibility of having a reference to a disposed object though - if you use:

using (Foo foo = new Foo())
{
    ...
}

then the object will be disposed at the same time that foo goes out of scope, so this isn't an issue.

Answer 2

If the object has been disposed, there isn't any "live" reference of it, so you can't access it (it's guaranteed that there is no reachable code that can read/write the object) (this in "safe" code... In "unsafe" code there isn't any guarantee of anything. But it's "unsafe" for a reason :-) )

For the IDisposable objects, classes "correctly done" keep a flag that they check ( bool isDisposed = false at the beginning, isDisposed = true; in the Dispose() ) in every method/property and if the object is already disposed they throw new ObjectDisposedException() .

Note that there isn't anything in the C# language/.NET runtime that forbids for a "disposed" object to be "reignited", reused and "re-disposed" again, but it is bad code writing (and to support this "anti-pattern" there is even a GC.ReRegisterForFinalize to balance the GC.SuppressFinalize often done in Dispose() )

If you have a WeakReference and you want to check "only for statistical purpose" if the object is still reachable, you use WeakReference.IsValid . If you want a reference to the object to use it, you use WeakReference.Target and check if the return value is null . This is very important!!

var wr = new WeakReference(new List<int>());

// Right!!
var target = (List<int>)wr.Target;
if (target != null)
{
    target.Clear();
}

// Wrong!! The GC could kick in after the if and before the target = 
if (wr.IsAlive)
{
    target = (List<int>)wr.Target;
    target.Clear();
}

Answer 3

but how would object_name get garbage collected if its not nulled first?

If a pointer is still pointing to the object (per your question) then there is no way the object will get garbage collected

Answer 4

Store your objects in a list of WeakReference 's.

Use the IsAlive property to check if the object has been garbage collected.

Answer 5

The garbage collector does by definition not delete objects that are "not garbage", that includes objects to which your code holds a reference.

There is no general way to see if an object has been disposed, as the IDisposable contract does not contain such a method. But many classes have a way of determining their state, eg the SqlConnection class has a State property which will return ConnectionState.Closed on a disposed object.

Answer 6

In terms of GC and a custom object state you can only check whether object has been moved across the generations using

int objectGeneration = GC.GetGeneration(objectInstance)

but you can not access GCed object or check whether object was Disposed because Dispose() is a custom implementation of the each particular IDisposable type and in very rare cases those types exposed something like IsDisposed flag because it does not make any sense for object's consumer in most cases.

When you know a generation number you can do some assumptions based on:

Fundamentals of Garbage Collection: Generations

Generation 0. This is the youngest generation and contains short-lived objects. An example of a short-lived object is a temporary variable. Garbage collection occurs most frequently in this generation. Newly allocated objects form a new generation of objects and are implicitly generation 0 collections, unless they are large objects, in which case they go on the large object heap in a generation 2 collection. Most objects are reclaimed for garbage collection in generation 0 and do not survive to the next generation.

Generation 1. This generation contains short-lived objects and serves as a buffer between short-lived objects and long-lived objects.

Generation 2. This generation contains long-lived objects. An example of a long-lived object is an object in a server application that contains static data that is live for the duration of the process