Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Classe WeakReference

 

Data di pubblicazione: ottobre 2016

Rappresenta un riferimento debole, ovvero un riferimento a un oggetto che può ancora essere recuperato dalla procedura di Garbage Collection.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.WeakReference

[SerializableAttribute]
[ComVisibleAttribute(true)]
[SecurityPermissionAttribute(SecurityAction.InheritanceDemand, 
	Flags = SecurityPermissionFlag.UnmanagedCode)]
public class WeakReference : ISerializable

NomeDescrizione
System_CAPS_pubmethodWeakReference(Object)

Inizializza una nuova istanza della classe WeakReference che fa riferimento all'oggetto specificato.

System_CAPS_pubmethodWeakReference(Object, Boolean)

Inizializza una nuova istanza della classe WeakReference, che fa riferimento all'oggetto specificato e usa l'opzione di rilevamento specificata per il ripristino.

System_CAPS_protmethodWeakReference(SerializationInfo, StreamingContext)

Inizializza una nuova istanza della classe WeakReference, usando dati deserializzati dalla serializzazione e dagli oggetti del flusso specificati.

NomeDescrizione
System_CAPS_pubpropertyIsAlive

Ottiene un valore che indica se l'oggetto cui fa riferimento l'oggetto WeakReference corrente è stato sottoposto alla procedura di Garbage Collection.

System_CAPS_pubpropertyTarget

Ottiene o imposta l'oggetto o la destinazione a cui fa riferimento l'oggetto WeakReference corrente.

System_CAPS_pubpropertyTrackResurrection

Ottiene un valore che indica se l'oggetto cui fa riferimento l'oggetto WeakReference corrente viene controllato dopo essere stato finalizzato.

NomeDescrizione
System_CAPS_pubmethodEquals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object.)

System_CAPS_protmethodFinalize()

Elimina il riferimento alla destinazione rappresentata dall'oggetto WeakReference corrente.(Esegue l'override di Object.Finalize().)

System_CAPS_pubmethodGetHashCode()

Funge da funzione hash predefinita.(Ereditato da Object.)

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Popola un oggetto SerializationInfo con tutti i dati necessari per serializzare l'oggetto WeakReference corrente.

System_CAPS_pubmethodGetType()

Ottiene l'oggetto Type dell'istanza corrente.(Ereditato da Object.)

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.(Ereditato da Object.)

System_CAPS_pubmethodToString()

Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object.)

Un riferimento debole consente al garbage collector di raccogliere un oggetto consentendo comunque un'applicazione accedere all'oggetto. Se l'oggetto è necessario, è possibile ottenere un riferimento forte ad esso e impedire venga raccolto. Per ulteriori informazioni sull'utilizzo di brevi e riferimenti deboli lunghi, vedere Weak References.

Nell'esempio seguente viene illustrato come è possibile utilizzare riferimenti deboli per mantenere una cache di oggetti come una risorsa per un'applicazione. La cache viene costruita utilizzando un IDictionary<TKey, TValue> di WeakReference oggetti con chiave forniti da un valore di indice. Il Target proprietà per il WeakReference oggetti è un oggetto in una matrice di byte che rappresenta i dati.

Nell'esempio si accede in modo casuale gli oggetti nella cache. Se un oggetto viene recuperato per garbage collection, un nuovo oggetto dati viene rigenerato. in caso contrario, l'oggetto è disponibile per l'accesso a causa di riferimento debole.

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 = "";
        GC.Collect(0);

        // 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/(double)c.Count;
        Console.WriteLine("Cache size: {0}, Regenerated: {1:P2}%", c.Count, regenPercent);
    }
}

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 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));
        }
    }

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

    // Number of times an object needs to be regenerated.
    public int RegenerationCount
    {
        get { return regenCount; }
    }

    // Retrieve a data object from the cache.
    public Data this[int index]
    {
        get {
            Data d = _cache[index].Target as Data;
            if (d == null) {
                // If the object was reclaimed, generate a new one.
                Console.WriteLine("Regenerate object at {0}: Yes", index);
                d = new Data(index);
                _cache[index].Target = d;
                regenCount++;
            }
            else {
                // Object was obtained with the weak reference.
                Console.WriteLine("Regenerate object at {0}: No", index);
            }

            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%

SecurityPermission

for the ability to call unmanaged code. Demand value: F:System.Security.Permissions.SecurityAction.InheritanceDemand; Permission value: F:System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1

I membri statici pubblici ( Condiviso in Visual Basic) di questo tipo è thread safe. Non tutti i membri di istanza sono garantiti come thread safe.

Torna all'inizio
Mostra: