Export (0) Print
Expand All
1 out of 3 rated this helpful - Rate this topic

WeakReference Class

Represents a weak reference, which references an object while still allowing that object to be reclaimed by garbage collection.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public class WeakReference : ISerializable
/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public class WeakReference implements ISerializable
SerializableAttribute 
ComVisibleAttribute(true) 
public class WeakReference implements ISerializable
Not applicable.

A weak reference allows the garbage collector to collect an object while still allowing an application to access the object. If you need the object, you can still obtain a strong reference to it and prevent it from being collected. For more information about how to use short and long weak references, see Using Weak References.

The following example demonstrates how you can use weak references to maintain a cache of objects as a resource for an application. The cache is constructed using an IDictionary of WeakReference objects keyed by an index value. The Target property for the WeakReference objects is an object in a byte array that represents data.

The example randomly accesses objects in the cache. If an object is reclaimed for garbage collection, a new data object is regenerated; otherwise, the object is available to access because of the weak reference.

using System;
using System.Timers;

class Program
{

    static void Main(string[] args)
    {

        // Creating an instance
        // of an object creates
        // a strong reference.
        ClassA objA1 = new ClassA();

        // Create a short weak reference to the object.
        // Specify true for a long weak reference.
        WeakReference wr = new WeakReference(objA1, false);

        // Set the target of the
        // weak reference to the object.
        wr.Target = objA1;

        // Remove the strong reference
        // the application has to the object.
        objA1 = null;
        if (objA1 == null)
        {
            Console.WriteLine("After setting objA1 to null: objA1 is null.");
        }

        // Set a timer to set a strong reference
        // and to force garbage collection.
        System.Timers.Timer aTimer = new System.Timers.Timer();

        // Set interval to 5 seconds.
        aTimer.Interval = 5000;
        aTimer.Enabled = true;

        // Counter for tracking.
        int count = 1;

        // Anonymous method.
        aTimer.Elapsed += delegate(object sender,
            System.Timers.ElapsedEventArgs e)
        {
            if (objA1 == null)
            {
                Console.WriteLine("objA1 is null");

                // Adjust the count higher if
                // you want to allow more time
                // for automatic garbage collection.
                if (count == 5)
                {
                    // Uncomment next line to set a strong reference.
                    //objA1 = (ClassA)wr.Target;
                    GC.Collect();
                }

                if (count == 8)
                {
                    // This code is only reached if
                    // the weak reference is long.
                    objA1 = (ClassA)wr.Target;

                }
                if (wr.IsAlive == false)
                {
                    // Object is collected and
                    // all references terminated.
                    Console.WriteLine("Object collected");
                    aTimer.Stop();
                }
                else
                {
                    Console.WriteLine("count {0}, still alive. long weak reference: {1}",
                        count.ToString(),
                        wr.TrackResurrection.ToString());
                    count++;
                }
            }
            else
            {
                // A strong reference is established
                // and prevents it being collected.
                Console.WriteLine("Strong reference applied");
                aTimer.Stop();
            }
        };
    }

}
public class ClassA
{
    public ClassA()
    {

    }

    ~ClassA()
    {
        Console.WriteLine("Finalized.");
    }

    void MakeSomeGarbage()
    {
        // Create objects and release them
        // to fill up memory with unused objects.
        Version vt;

        for (int i = 0; i < 10000; i++)
        {
            vt = new Version();
        }
    }
}


// -------- Code example output --------
//
// A short weak reference creates
// the following output:
// ------------------------------------
// After setting objA1 to null: objA1 is null.
// objA1 is null
// count 1, still alive. long weak reference: False
// objA1 is null
// count 2, still alive. long weak reference: False
// objA1 is null
// count 3, still alive. long weak reference: False
// objA1 is null
// count 4, still alive. long weak reference: False
// objA1 is null
// Object collected
// Finalized.
// ------------------------------------
//
//
// A long weak reference creates
// the following output, being
// ressurected at count 5.
// ------------------------------------
// After setting objA1 to null: objA1 is null.
// objA1 is null
// count 1, still alive. long weak reference: True
// objA1 is null
// count 2, still alive. long weak reference: True
// objA1 is null
// count 3, still alive. long weak reference: True
// objA1 is null
// count 4, still alive. long weak reference: True
// objA1 is null
// count 5, still alive. long weak reference: True
// Finalized.
// objA1 is null
// count 6, still alive. long weak reference: True
// objA1 is null
// count 7, still alive. long weak reference: True
// objA1 is null
// count 8, still alive. long weak reference: True
// Strong reference applied
// ----------------------------------
//
//
// A weak reference creates
// the following output with a
// strong reference applied
// at count 5.
// ----------------------------------
// After setting objA1 to null: objA1 is null.
// objA1 is null
// count 1, still alive. long weak reference: False
// objA1 is null
// count 2, still alive. long weak reference: False
// objA1 is null
// count 3, still alive. long weak reference: False
// objA1 is null
// count 4, still alive. long weak reference: False
// objA1 is null
// count 5, still alive. long weak reference: False
// Strong reference applied
// ------------------------------------
//

System.Object
  System.WeakReference
Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 2.0, 1.0

XNA Framework

Supported in: 1.0
Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback

Community Additions

ADD
Show:
© 2014 Microsoft. All rights reserved.