implab/ImplabNet Files · Implab/Components/LazyAndWeak.cs

minor fixes

cin - - Load All Authors

File last commit:

r182:76e8f2ba12b8 ref20160224


                r260:547a2fc0d93e

v3.0.6 v3

Download file

             LazyAndWeak.cs
        
                    64 lines
            
             | 2.1 KiB
            
                | text/x-csharp
            
             |
                CSharpLexer
            
             / Implab / Components / LazyAndWeak.cs
          
                    History
                
                 |
                  Annotation
                 | Raw
                 |Copy content
                 |Copy permalink

      using System;

      using System.Threading;

      namespace Implab.Components {

          /// <summary>

          /// Creates an instace on-demand and allows it to be garbage collected.

          /// </summary>

          /// <remarks>

          /// Usefull when dealing with memory-intensive objects which are frequently used.

          /// This class is similar to <see cref="ObjectPool{T}"/> except it is a singleton.

          /// </remarks>

          public class LazyAndWeak<T> where T : class {

              readonly Func<T> m_factory;

              readonly object m_lock;

              WeakReference m_reference;

              public LazyAndWeak(Func<T> factory, bool useLock) {

                  Safe.ArgumentNotNull(factory, "factory");

                  m_factory = factory;

                  m_lock = useLock ? new object() : null;

              }

              public LazyAndWeak(Func<T> factory) : this(factory, false) {

              }

              public T Value {

                  get {

                      while (true) {

                          var weak = m_reference;

                          T value;

                          if (weak != null) {

                              value = weak.Target as T;

                              if (value != null)

                                  return value;

                          }

                          if (m_lock == null) {

                              value = m_factory();

                              if (Interlocked.CompareExchange(ref m_reference, new WeakReference(value), weak) == weak)

                                  return value;

                          } else {

                              lock (m_lock) {

                                  // double check

                                  weak = m_reference;

                                  if (weak != null) {

                                      value = weak.Target as T;

                                      if (value != null)

                                          return value;

                                  }

                                  // we are safe to write

                                  value = m_factory();

                                  m_reference = new WeakReference(value);

                                  return value;

                              }

                          }

                      }

                  }

              }

          }

      }

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

				using System;
				using System.Threading;

				namespace Implab.Components {
				/// <summary>
				/// Creates an instace on-demand and allows it to be garbage collected.
				/// </summary>
				/// <remarks>
				/// Usefull when dealing with memory-intensive objects which are frequently used.
				/// This class is similar to <see cref="ObjectPool{T}"/> except it is a singleton.
				/// </remarks>
				public class LazyAndWeak<T> where T : class {

				readonly Func<T> m_factory;
				readonly object m_lock;
				WeakReference m_reference;


				public LazyAndWeak(Func<T> factory, bool useLock) {
				Safe.ArgumentNotNull(factory, "factory");
				m_factory = factory;
				m_lock = useLock ? new object() : null;
				}

				public LazyAndWeak(Func<T> factory) : this(factory, false) {
				}

				public T Value {
				get {
				while (true) {
				var weak = m_reference;
				T value;
				if (weak != null) {
				value = weak.Target as T;
				if (value != null)
				return value;
				}

				if (m_lock == null) {
				value = m_factory();

				if (Interlocked.CompareExchange(ref m_reference, new WeakReference(value), weak) == weak)
				return value;
				} else {
				lock (m_lock) {
				// double check
				weak = m_reference;
				if (weak != null) {
				value = weak.Target as T;
				if (value != null)
				return value;
				}
				// we are safe to write
				value = m_factory();
				m_reference = new WeakReference(value);
				return value;
				}
				}
				}
				}
				}
				}
				}