Classe WeakReference (System)

Imports System
Imports System.Collections.Generic
Public Class Module1

    Public Shared Sub Main()

        ' Create the cache.
        Dim cacheSize As Integer = 50
        Dim r As Random = New Random
        Dim c As Cache = New Cache(cacheSize)

        Dim DataName As String = ""

        ' Randomly access objects in the cache.
        Dim i As Integer
        Do While i < c.Count
            Dim index As Integer = r.Next(c.Count)

            ' Access the object by
            ' getting a property value.
            DataName = c(index).Name

            i += 1
        Loop

        'Show results.
        Dim regenPercent As Double = c.RegenerationCount * 100 / c.Count
        Console.WriteLine("Cache size: {0}, Regenerated: {1}%", c.Count.ToString(), regenPercent.ToString())

    End Sub
End Class
Public Class Cache

    ' Dictionary to contain the cache.
    Private Shared _cache As Dictionary(Of Integer, WeakReference)

    ' Track the number of times an
    ' object is regenerated.
    Dim regenCount As Integer = 0

    Public Sub New(ByVal count As Integer)
        MyBase.New()
        _cache = New Dictionary(Of Integer, WeakReference)

        ' Add data objects with a short
        ' weak reference to the cache.
        Dim i As Integer = 0
        Do While (i < count)
            _cache.Add(i, New WeakReference(New Data(i)))
            i = (i + 1)
        Loop
    End Sub

    ' Number of items in the cache.
    Public ReadOnly Property Count() As Integer
        Get
            Return _cache.Count
        End Get
    End Property

    ' Number of times an
    ' object needs to be regenerated.
    Public ReadOnly Property RegenerationCount() As Integer
        Get
            Return regenCount
        End Get
    End Property

    ' Access a data object from the cache.
    ' If the object was reclaimed for garbage collection,
    ' create a new data object at that index location.
    Default Public ReadOnly Property Item(ByVal index As Integer) As Data
        Get
            ' Obtain an instance of a data
            ' object from the cache of
            ' of weak reference objects.
            Dim d As Data = CType(_cache(index).Target, Data)
            If (d Is Nothing) Then
                ' Object was reclaimed, so generate a new one.
                Console.WriteLine("Regenerate object at {0}: Yes", index.ToString())
                d = New Data(index)
                regenCount += 1
           Else
                 ' Object was obtained with the weak reference.
                Console.WriteLine("Regenerate object at {0}: No", index.ToString())
            End If
            Return d
        End Get

    End Property
End Class

' Class that creates byte arrays to simulate data.
Public Class Data

    Private _data() As Byte

    Private _name As String

    Public Sub New(ByVal size As Integer)
        MyBase.New()
        _data = New Byte(((size * 1024)) - 1) {}
        _name = size.ToString
    End Sub

    ' Simple property for
    ' accessing the object.
    Public ReadOnly Property Name() As String
        Get
            Return _name
        End Get
    End Property
End Class

' Example of the last lines of the output:
' ...
' Regenerate object at 36: Yes
' Regenerate object at 8: Yes
' Regenerate object at 21: Yes
' Regenerate object at 4: Yes
' Regenerate object at 38: No
' Regenerate object at 7: Yes
' Regenerate object at 2: Yes
' Regenerate object at 43: Yes
' Regenerate object at 38: No
' Cache size: 50, Regenerated: 94%
'

using System;
using System.Collections.Generic;

public class Program
{

    public static void Main()
    {

        // Create the cache.
        int cacheSize = 50;
        Random r = new Random();
        Cache c = new Cache(cacheSize);

        string DataName = "";

        // Randomly access objects in the cache.
        for (int i = 0; i < c.Count; i++)
        {
            int index = r.Next(c.Count);

            // Access the object by
            // getting a property value.
            DataName = c[index].Name;
        }
        // Show results.
        double regenPercent = c.RegenerationCount * 100 / c.Count;
        Console.WriteLine("Cache size: {0}, Regenerated: {1}%", c.Count.ToString(), regenPercent.ToString());

    }
}


public class Cache
{
    // Dictionary to contain the cache.
    static Dictionary<int, WeakReference> _cache;

    // Track the number of times an 
    // object is regenerated.
    int regenCount = 0;   

    public Cache(int count)
    {

        _cache = new Dictionary<int, WeakReference>();

        // Add data objects with a 
        // short weak reference to the cache.
       for (int i = 0; i < count; i++)
        {
            _cache.Add(i, new WeakReference(new Data(i), false));
        }

    }

    // Returns the number of items in the cache.
    public int Count
    {
        get
        {
            return _cache.Count;
        }
    }

    // Returns the number of times an 
    // object had to be regenerated.
    public int RegenerationCount
    {
        get
        {
            return regenCount;
        }
    }

    // Accesses a data object from the cache.
    // If the object was reclaimed for garbage collection,
    // create a new data object at that index location.
    public Data this[int index]
    {
        get
        {
            // Obtain an instance of a data
            // object from the cache of
            // of weak reference objects.
            Data d = _cache[index].Target as Data;
            if (d == null)
            {
                // Object was reclaimed, so generate a new one.
                Console.WriteLine("Regenerate object at {0}: Yes", index.ToString());
                d = new Data(index);
                regenCount++;
            }
            else
            {
                // Object was obtained with the weak reference.
                Console.WriteLine("Regenerate object at {0}: No", index.ToString());
            }

            return d;
       }

    }

}


// This class creates byte arrays to simulate data.
public class Data
{
    private byte[] _data;
    private string _name;

    public Data(int size)
    {
        _data = new byte[size * 1024];
        _name = size.ToString();
    }

    // Simple property.
    public string Name
    {
        get
        {
            return _name;
        }
    }

}

// Example of the last lines of the output:
//
// ...
// Regenerate object at 36: Yes
// Regenerate object at 8: Yes
// Regenerate object at 21: Yes
// Regenerate object at 4: Yes
// Regenerate object at 38: No
// Regenerate object at 7: Yes
// Regenerate object at 2: Yes
// Regenerate object at 43: Yes
// Regenerate object at 38: No
// Cache size: 50, Regenerated: 94%
//