netcore/System.Private.CoreLib/shared/System/WeakReference.T.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Runtime.Serialization;
   6 using System.Runtime.CompilerServices;
   7 using System.Diagnostics.CodeAnalysis;
   8
   9 namespace System
  10 {
  11     [Serializable]
  12     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
  13     // This class is sealed to mitigate security issues caused by Object::MemberwiseClone.
  14     public sealed partial class WeakReference<T> : ISerializable
  15         where T : class?
  16     {
  17         // If you fix bugs here, please fix them in WeakReference at the same time.
  18
  19         // Creates a new WeakReference that keeps track of target.
  20         // Assumes a Short Weak Reference (ie TrackResurrection is false.)
  21         //
  22         public WeakReference(T target)
  23             : this(target, false)
  24         {
  25         }
  26
  27         // Creates a new WeakReference that keeps track of target.
  28         //
  29         public WeakReference(T target, bool trackResurrection)
  30         {
  31             Create(target, trackResurrection);
  32         }
  33
  34         private WeakReference(SerializationInfo info, StreamingContext context)
  35         {
  36             if (info == null)
  37             {
  38                 throw new ArgumentNullException(nameof(info));
  39             }
  40
  41             T target = (T)info.GetValue("TrackedObject", typeof(T))!; // Do not rename (binary serialization)
  42             bool trackResurrection = info.GetBoolean("TrackResurrection"); // Do not rename (binary serialization)
  43
  44             Create(target, trackResurrection);
  45         }
  46
  47         //
  48         // We are exposing TryGetTarget instead of a simple getter to avoid a common problem where people write incorrect code like:
  49         //
  50         //      WeakReference ref = ...;
  51         //      if (ref.Target != null)
  52         //          DoSomething(ref.Target)
  53         //
  54         [MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
  55         public bool TryGetTarget([MaybeNullWhen(false), NotNullWhen(true)] out T target)
  56         {
  57             // Call the worker method that has more performant but less user friendly signature.
  58             T o = this.Target;
  59             target = o;
  60             return o != null;
  61         }
  62
  63         public void GetObjectData(SerializationInfo info, StreamingContext context)
  64         {
  65             if (info == null)
  66             {
  67                 throw new ArgumentNullException(nameof(info));
  68             }
  69
  70             info.AddValue("TrackedObject", this.Target, typeof(T)); // Do not rename (binary serialization)
  71             info.AddValue("TrackResurrection", IsTrackResurrection()); // Do not rename (binary serialization)
  72         }
  73     }
  74 }