Generic weak reference

I'm sure I'm not the first person who's found that there is no generic version of the System.WeakReference class. I searched and did find some implementation, but I found it not good enough. First of all it didn't inherit from WeakReference which is a major drawback since it can't be passed where a WeakReference is expected as an argument.

Also I thought it would be nice to be able to implicitly cast between a WeakReference<T> and a T as follows:

WeakReference<string> r = new WeakReference<string>("doh!");  
string s = r; // The variable s now holds the value "doh!".

(To be honest a weak reference to a string-object would in most cases be quite useless but this is just an example).

I'm not sure how well known the cast operators of .Net are, but they sure are handy, especially for this kind of generic classes, check out the implementation of Nullable<T> for examples of both the implicit and the explicit cast operator.

The implementation is simple enough as follows:

/// <summary> 
/// Represents a weak reference, which references an object while still allowing   
/// that object to be reclaimed by garbage collection.    
/// </summary>    
/// <typeparam name="T">The type of the object that is referenced.</typeparam>    
[Serializable]    
public class WeakReference<T>        
    : WeakReference where T : class    
{       
    /// <summary>        
    /// Initializes a new instance of the Minimal.WeakReference{T} class, referencing        
    /// the specified object.        
    /// </summary>        
    /// <param name="target">The object to reference.</param>        
    public WeakReference(T target)            
        : base(target) { } 
    /// <summary>        
    /// Initializes a new instance of the WeakReference{T} class, referencing 
    /// the specified object and using the specified resurrection tracking. 
    /// </summary>        
    /// <param name="target">An object to track.</param> 
    /// <param name="trackResurrection">Indicates when to stop tracking the object. If true, the object is tracked 
    /// after finalization; if false, the object is only tracked until finalization.</param> 
    public WeakReference(T target, bool trackResurrection) 
        : base(target, trackResurrection) { } 
    protected WeakReference(SerializationInfo info, StreamingContext context) 
        : base(info, context) { } 
    /// <summary> 
    /// Gets or sets the object (the target) referenced by the current WeakReference{T} 
    /// object. 
    /// </summary> 
    public new T Target 
    { 
        get 
        { 
            return (T)base.Target; 
        } 
        set 
        { 
            base.Target = value; 
        } 
    } 
    /// <summary> 
    /// Casts an object of the type T to a weak reference 
    /// of T. 
    /// </summary> 
    public static implicit operator WeakReference<T>(T target)        
    { 
        if (target == null)            
        { 
            throw new ArgumentNullException("target"); 
        } 
        return new WeakReference<T>(target); 
    } 
    /// <summary> 
    /// Casts a weak reference to an object of the type the 
    /// reference represents. 
    /// </summary> 
    public static implicit operator T(WeakReference<T> reference) 
    { 
        if (reference != null) 
        { 
            return reference.Target; 
        } 
        else 
        { 
            return null; 
        } 
    } 
}

Technorati-taggar: csharp,c#,.net,dotnet,weak reference,weakreference