Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / Lazy.cs / 1305376 / Lazy.cs
#pragma warning disable 0420
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
//
// Lazy.cs
//
// [....]
//
// A class that provides a simple, lightweight implementation of lazy initialization,
// obviating the need for a developer to implement a custom, thread-safe lazy initialization
// solution.
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
using System.Runtime;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Diagnostics;
using System.Runtime.Serialization;
using System.Threading;
using System.Diagnostics.Contracts;
namespace System
{
///
/// Provides support for lazy initialization.
///
/// Specifies the type of element being laziliy initialized.
///
///
/// By default, all public and protected members of
///
[Serializable]
[ComVisible(false)]
[HostProtection(Synchronization = true, ExternalThreading = true)]
[DebuggerTypeProxy(typeof(System_LazyDebugView<>))]
[DebuggerDisplay("ThreadSafetyMode={Mode}, IsValueCreated={IsValueCreated}, IsValueFaulted={IsValueFaulted}, Value={ValueForDebugDisplay}")]
public class Lazy
{
#region Inner classes
///
/// wrapper class to box the initialized value, this is mainly created to avoid boxing/unboxing the value each time the value is called in case T is
/// a value type
///
[Serializable]
class Boxed
{
internal Boxed(T value)
{
m_value = value;
}
internal T m_value;
}
///
/// Wrapper class to wrap the excpetion thrown by the value factory
///
class LazyInternalExceptionHolder
{
internal Exception m_exception;
internal LazyInternalExceptionHolder(Exception ex)
{
m_exception = ex;
}
}
#endregion
// A dummy delegate used as a :
// 1- Flag to avoid recursive call to Value in None and ExecutionAndPublication modes in m_valueFactory
// 2- Flag to PublicationOnly mode in m_threadSafeObj
static Func PUBLICATION_ONLY_OR_ALREADY_INITIALIZED = delegate { return default(T); };
//null --> value is not created
//m_value is Boxed --> the value is created, and m_value holds the value
//m_value is LazyExceptionHolder --> it holds an exception
private volatile object m_boxed;
// The factory delegate that returns the value.
// In None and ExecutionAndPublication modes, this will be set to PUBLICATION_ONLY_OR_ALREADY_INITIALIZED as a flag to avoid recursive calls
[NonSerialized]
private Func m_valueFactory;
// null if it is not thread safe mode
// PUBLICATION_ONLY_OR_ALREADY_INITIALIZED if PublicationOnly mode
// object if ExecutionAndPublication mode
[NonSerialized]
private readonly object m_threadSafeObj;
///
/// Initializes a new instance of the
///
/// An instance created with this constructor may be used concurrently from multiple threads.
///
public Lazy()
: this(LazyThreadSafetyMode.ExecutionAndPublication)
{
}
///
/// Initializes a new instance of the
///
/// The
/// An instance created with this constructor may be used concurrently from multiple threads.
///
public Lazy(Func valueFactory)
: this(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication)
{
}
///
/// Initializes a new instance of the
/// true if this instance should be usable by multiple threads concurrently; false if the instance will only be used by one thread at a time.
///
public Lazy(bool isThreadSafe) :
this(isThreadSafe? LazyThreadSafetyMode.ExecutionAndPublication : LazyThreadSafetyMode.None)
{
}
///
/// Initializes a new instance of the
/// The lazy thread-safety mode mode
///
/// Initializes a new instance of the
///
/// The valueFactory, bool isThreadSafe)
: this(valueFactory, isThreadSafe ? LazyThreadSafetyMode.ExecutionAndPublication : LazyThreadSafetyMode.None)
{
}
///
/// Initializes a new instance of the
///
/// The valueFactory, LazyThreadSafetyMode mode)
{
if (valueFactory == null)
throw new ArgumentNullException("valueFactory");
m_threadSafeObj = GetObjectFromMode(mode);
m_valueFactory = valueFactory;
}
///
/// Static helper function that returns an object based on the given mode. it also throws an exception if the mode is invalid
///
private static object GetObjectFromMode(LazyThreadSafetyMode mode)
{
if (mode == LazyThreadSafetyMode.ExecutionAndPublication)
return new object();
else if (mode == LazyThreadSafetyMode.PublicationOnly)
return PUBLICATION_ONLY_OR_ALREADY_INITIALIZED;
else if (mode != LazyThreadSafetyMode.None)
throw new ArgumentOutOfRangeException("mode", Environment.GetResourceString("Lazy_ctor_ModeInvalid"));
return null; // None mode
}
/// Forces initialization during serialization.
/// The StreamingContext for the serialization operation.
[OnSerializing]
private void OnSerializing(StreamingContext context)
{
// Force initialization
T dummy = Value;
}
/// Creates and returns a string representation of this instance.
/// The result of calling
///
/// The
public override string ToString()
{
return IsValueCreated ? Value.ToString() : Environment.GetResourceString("Lazy_ToString_ValueNotCreated");
}
/// Gets the value of the Lazy<T> for debugging display purposes.
internal T ValueForDebugDisplay
{
get
{
if (!IsValueCreated)
{
return default(T);
}
return ((Boxed)m_boxed).m_value;
}
}
///
/// Gets a value indicating whether this instance may be used concurrently from multiple threads.
///
internal LazyThreadSafetyMode Mode
{
get
{
if (m_threadSafeObj == null) return LazyThreadSafetyMode.None;
if (m_threadSafeObj == (object)PUBLICATION_ONLY_OR_ALREADY_INITIALIZED) return LazyThreadSafetyMode.PublicationOnly;
return LazyThreadSafetyMode.ExecutionAndPublication;
}
}
///
/// Gets whether the value creation is faulted or not
///
internal bool IsValueFaulted
{
get { return m_boxed is LazyInternalExceptionHolder; }
}
/// Gets a value indicating whether the
/// true if the
///
/// The initialization of a
public bool IsValueCreated
{
#if !FEATURE_CORECLR && !PFX_LEGACY_3_5
[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
#endif
get
{
return m_boxed != null && m_boxed is Boxed;
}
}
/// Gets the lazily initialized value of the current
/// The lazily initialized value of the current
///
/// The
///
/// The
///
/// The
///
/// If for more information on how
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public T Value
{
get
{
Boxed boxed = null;
if (m_boxed != null )
{
// Do a quick check up front for the fast path.
boxed = m_boxed as Boxed;
if (boxed != null)
{
return boxed.m_value;
}
LazyInternalExceptionHolder exc = m_boxed as LazyInternalExceptionHolder;
Contract.Assert(m_boxed != null);
throw exc.m_exception;
}
// Fall through to the slow path.
// We call NOCTD to abort attempts by the debugger to funceval this property (e.g. on mouseover)
// (the debugger proxy is the correct way to look at state/value of this object)
#if !PFX_LEGACY_3_5
Debugger.NotifyOfCrossThreadDependency();
#endif
return LazyInitValue();
}
}
///
/// local helper method to initialize the value
///
/// The inititialized T value
private T LazyInitValue()
{
Boxed boxed = null;
LazyThreadSafetyMode mode = Mode;
if (mode == LazyThreadSafetyMode.None)
{
boxed = CreateValue();
m_boxed = boxed;
}
else if (mode == LazyThreadSafetyMode.PublicationOnly)
{
boxed = CreateValue();
if (Interlocked.CompareExchange(ref m_boxed, boxed, null) != null)
boxed = (Boxed)m_boxed; // set the boxed value to the succeeded thread value
}
else
{
lock (m_threadSafeObj)
{
if (m_boxed == null)
{
boxed = CreateValue();
m_boxed = boxed;
}
else // got the lock but the value is not null anymore, check if it is created by another thread or faulted and throw if so
{
boxed = m_boxed as Boxed;
if (boxed == null) // it is not Boxed, so it is a LazyInternalExceptionHolder
{
LazyInternalExceptionHolder exHolder = m_boxed as LazyInternalExceptionHolder;
Contract.Assert(exHolder != null);
throw exHolder.m_exception;
}
}
}
}
Contract.Assert(boxed != null);
return boxed.m_value;
}
/// Creates an instance of T using m_valueFactory in case its not null or use reflection to create a new T()
/// An instance of Boxed.
private Boxed CreateValue()
{
Boxed boxed = null;
LazyThreadSafetyMode mode = Mode;
if (m_valueFactory != null)
{
try
{
// check for recursion
if (mode != LazyThreadSafetyMode.PublicationOnly && m_valueFactory == PUBLICATION_ONLY_OR_ALREADY_INITIALIZED)
throw new InvalidOperationException(Environment.GetResourceString("Lazy_Value_RecursiveCallsToValue"));
Func factory = m_valueFactory;
if (mode != LazyThreadSafetyMode.PublicationOnly) // only detect recursion on None and ExecutionAndPublication modes
m_valueFactory = PUBLICATION_ONLY_OR_ALREADY_INITIALIZED;
boxed = new Boxed(factory());
}
catch (Exception ex)
{
if (mode != LazyThreadSafetyMode.PublicationOnly) // don't cache the exception for PublicationOnly mode
{
#if PFX_LEGACY_3_5
m_boxed = new LazyInternalExceptionHolder(ex);
#else
m_boxed = new LazyInternalExceptionHolder(ex.PrepForRemoting());// copy the call stack by calling the internal method PrepForRemoting
#endif
}
throw;
}
}
else
{
try
{
boxed = new Boxed((T)Activator.CreateInstance(typeof(T)));
}
catch (System.MissingMethodException)
{
Exception ex = new System.MissingMemberException(Environment.GetResourceString("Lazy_CreateValue_NoParameterlessCtorForT"));
if (mode != LazyThreadSafetyMode.PublicationOnly) // don't cache the exception for PublicationOnly mode
m_boxed = new LazyInternalExceptionHolder(ex);
throw ex;
}
}
return boxed;
}
}
/// A debugger view of the Lazy<T> to surface additional debugging properties and
/// to ensure that the Lazy<T> does not become initialized if it was not already.
internal sealed class System_LazyDebugView
{
//The Lazy object being viewed.
private readonly Lazy m_lazy;
/// Constructs a new debugger view object for the provided Lazy object.
/// A Lazy object to browse in the debugger.
public System_LazyDebugView(Lazy lazy)
{
m_lazy = lazy;
}
/// Returns whether the Lazy object is initialized or not.
public bool IsValueCreated
{
get { return m_lazy.IsValueCreated; }
}
/// Returns the value of the Lazy object.
public T Value
{
get
{ return m_lazy.ValueForDebugDisplay; }
}
/// Returns the execution mode of the Lazy object
public LazyThreadSafetyMode Mode
{
get { return m_lazy.Mode; }
}
/// Returns the execution mode of the Lazy object
public bool IsValueFaulted
{
get { return m_lazy.IsValueFaulted; }
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
#pragma warning disable 0420
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
//
// Lazy.cs
//
// [....]
//
// A class that provides a simple, lightweight implementation of lazy initialization,
// obviating the need for a developer to implement a custom, thread-safe lazy initialization
// solution.
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
using System.Runtime;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Diagnostics;
using System.Runtime.Serialization;
using System.Threading;
using System.Diagnostics.Contracts;
namespace System
{
///
/// Provides support for lazy initialization.
///
/// Specifies the type of element being laziliy initialized.
///
///
/// By default, all public and protected members of
///
[Serializable]
[ComVisible(false)]
[HostProtection(Synchronization = true, ExternalThreading = true)]
[DebuggerTypeProxy(typeof(System_LazyDebugView<>))]
[DebuggerDisplay("ThreadSafetyMode={Mode}, IsValueCreated={IsValueCreated}, IsValueFaulted={IsValueFaulted}, Value={ValueForDebugDisplay}")]
public class Lazy
{
#region Inner classes
///
/// wrapper class to box the initialized value, this is mainly created to avoid boxing/unboxing the value each time the value is called in case T is
/// a value type
///
[Serializable]
class Boxed
{
internal Boxed(T value)
{
m_value = value;
}
internal T m_value;
}
///
/// Wrapper class to wrap the excpetion thrown by the value factory
///
class LazyInternalExceptionHolder
{
internal Exception m_exception;
internal LazyInternalExceptionHolder(Exception ex)
{
m_exception = ex;
}
}
#endregion
// A dummy delegate used as a :
// 1- Flag to avoid recursive call to Value in None and ExecutionAndPublication modes in m_valueFactory
// 2- Flag to PublicationOnly mode in m_threadSafeObj
static Func PUBLICATION_ONLY_OR_ALREADY_INITIALIZED = delegate { return default(T); };
//null --> value is not created
//m_value is Boxed --> the value is created, and m_value holds the value
//m_value is LazyExceptionHolder --> it holds an exception
private volatile object m_boxed;
// The factory delegate that returns the value.
// In None and ExecutionAndPublication modes, this will be set to PUBLICATION_ONLY_OR_ALREADY_INITIALIZED as a flag to avoid recursive calls
[NonSerialized]
private Func m_valueFactory;
// null if it is not thread safe mode
// PUBLICATION_ONLY_OR_ALREADY_INITIALIZED if PublicationOnly mode
// object if ExecutionAndPublication mode
[NonSerialized]
private readonly object m_threadSafeObj;
///
/// Initializes a new instance of the
///
/// An instance created with this constructor may be used concurrently from multiple threads.
///
public Lazy()
: this(LazyThreadSafetyMode.ExecutionAndPublication)
{
}
///
/// Initializes a new instance of the
///
/// The
/// An instance created with this constructor may be used concurrently from multiple threads.
///
public Lazy(Func valueFactory)
: this(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication)
{
}
///
/// Initializes a new instance of the
/// true if this instance should be usable by multiple threads concurrently; false if the instance will only be used by one thread at a time.
///
public Lazy(bool isThreadSafe) :
this(isThreadSafe? LazyThreadSafetyMode.ExecutionAndPublication : LazyThreadSafetyMode.None)
{
}
///
/// Initializes a new instance of the
/// The lazy thread-safety mode mode
///
/// Initializes a new instance of the
///
/// The valueFactory, bool isThreadSafe)
: this(valueFactory, isThreadSafe ? LazyThreadSafetyMode.ExecutionAndPublication : LazyThreadSafetyMode.None)
{
}
///
/// Initializes a new instance of the
///
/// The valueFactory, LazyThreadSafetyMode mode)
{
if (valueFactory == null)
throw new ArgumentNullException("valueFactory");
m_threadSafeObj = GetObjectFromMode(mode);
m_valueFactory = valueFactory;
}
///
/// Static helper function that returns an object based on the given mode. it also throws an exception if the mode is invalid
///
private static object GetObjectFromMode(LazyThreadSafetyMode mode)
{
if (mode == LazyThreadSafetyMode.ExecutionAndPublication)
return new object();
else if (mode == LazyThreadSafetyMode.PublicationOnly)
return PUBLICATION_ONLY_OR_ALREADY_INITIALIZED;
else if (mode != LazyThreadSafetyMode.None)
throw new ArgumentOutOfRangeException("mode", Environment.GetResourceString("Lazy_ctor_ModeInvalid"));
return null; // None mode
}
/// Forces initialization during serialization.
/// The StreamingContext for the serialization operation.
[OnSerializing]
private void OnSerializing(StreamingContext context)
{
// Force initialization
T dummy = Value;
}
/// Creates and returns a string representation of this instance.
/// The result of calling
///
/// The
public override string ToString()
{
return IsValueCreated ? Value.ToString() : Environment.GetResourceString("Lazy_ToString_ValueNotCreated");
}
/// Gets the value of the Lazy<T> for debugging display purposes.
internal T ValueForDebugDisplay
{
get
{
if (!IsValueCreated)
{
return default(T);
}
return ((Boxed)m_boxed).m_value;
}
}
///
/// Gets a value indicating whether this instance may be used concurrently from multiple threads.
///
internal LazyThreadSafetyMode Mode
{
get
{
if (m_threadSafeObj == null) return LazyThreadSafetyMode.None;
if (m_threadSafeObj == (object)PUBLICATION_ONLY_OR_ALREADY_INITIALIZED) return LazyThreadSafetyMode.PublicationOnly;
return LazyThreadSafetyMode.ExecutionAndPublication;
}
}
///
/// Gets whether the value creation is faulted or not
///
internal bool IsValueFaulted
{
get { return m_boxed is LazyInternalExceptionHolder; }
}
/// Gets a value indicating whether the
/// true if the
///
/// The initialization of a
public bool IsValueCreated
{
#if !FEATURE_CORECLR && !PFX_LEGACY_3_5
[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
#endif
get
{
return m_boxed != null && m_boxed is Boxed;
}
}
/// Gets the lazily initialized value of the current
/// The lazily initialized value of the current
///
/// The
///
/// The
///
/// The
///
/// If for more information on how
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public T Value
{
get
{
Boxed boxed = null;
if (m_boxed != null )
{
// Do a quick check up front for the fast path.
boxed = m_boxed as Boxed;
if (boxed != null)
{
return boxed.m_value;
}
LazyInternalExceptionHolder exc = m_boxed as LazyInternalExceptionHolder;
Contract.Assert(m_boxed != null);
throw exc.m_exception;
}
// Fall through to the slow path.
// We call NOCTD to abort attempts by the debugger to funceval this property (e.g. on mouseover)
// (the debugger proxy is the correct way to look at state/value of this object)
#if !PFX_LEGACY_3_5
Debugger.NotifyOfCrossThreadDependency();
#endif
return LazyInitValue();
}
}
///
/// local helper method to initialize the value
///
/// The inititialized T value
private T LazyInitValue()
{
Boxed boxed = null;
LazyThreadSafetyMode mode = Mode;
if (mode == LazyThreadSafetyMode.None)
{
boxed = CreateValue();
m_boxed = boxed;
}
else if (mode == LazyThreadSafetyMode.PublicationOnly)
{
boxed = CreateValue();
if (Interlocked.CompareExchange(ref m_boxed, boxed, null) != null)
boxed = (Boxed)m_boxed; // set the boxed value to the succeeded thread value
}
else
{
lock (m_threadSafeObj)
{
if (m_boxed == null)
{
boxed = CreateValue();
m_boxed = boxed;
}
else // got the lock but the value is not null anymore, check if it is created by another thread or faulted and throw if so
{
boxed = m_boxed as Boxed;
if (boxed == null) // it is not Boxed, so it is a LazyInternalExceptionHolder
{
LazyInternalExceptionHolder exHolder = m_boxed as LazyInternalExceptionHolder;
Contract.Assert(exHolder != null);
throw exHolder.m_exception;
}
}
}
}
Contract.Assert(boxed != null);
return boxed.m_value;
}
/// Creates an instance of T using m_valueFactory in case its not null or use reflection to create a new T()
/// An instance of Boxed.
private Boxed CreateValue()
{
Boxed boxed = null;
LazyThreadSafetyMode mode = Mode;
if (m_valueFactory != null)
{
try
{
// check for recursion
if (mode != LazyThreadSafetyMode.PublicationOnly && m_valueFactory == PUBLICATION_ONLY_OR_ALREADY_INITIALIZED)
throw new InvalidOperationException(Environment.GetResourceString("Lazy_Value_RecursiveCallsToValue"));
Func factory = m_valueFactory;
if (mode != LazyThreadSafetyMode.PublicationOnly) // only detect recursion on None and ExecutionAndPublication modes
m_valueFactory = PUBLICATION_ONLY_OR_ALREADY_INITIALIZED;
boxed = new Boxed(factory());
}
catch (Exception ex)
{
if (mode != LazyThreadSafetyMode.PublicationOnly) // don't cache the exception for PublicationOnly mode
{
#if PFX_LEGACY_3_5
m_boxed = new LazyInternalExceptionHolder(ex);
#else
m_boxed = new LazyInternalExceptionHolder(ex.PrepForRemoting());// copy the call stack by calling the internal method PrepForRemoting
#endif
}
throw;
}
}
else
{
try
{
boxed = new Boxed((T)Activator.CreateInstance(typeof(T)));
}
catch (System.MissingMethodException)
{
Exception ex = new System.MissingMemberException(Environment.GetResourceString("Lazy_CreateValue_NoParameterlessCtorForT"));
if (mode != LazyThreadSafetyMode.PublicationOnly) // don't cache the exception for PublicationOnly mode
m_boxed = new LazyInternalExceptionHolder(ex);
throw ex;
}
}
return boxed;
}
}
/// A debugger view of the Lazy<T> to surface additional debugging properties and
/// to ensure that the Lazy<T> does not become initialized if it was not already.
internal sealed class System_LazyDebugView
{
//The Lazy object being viewed.
private readonly Lazy m_lazy;
/// Constructs a new debugger view object for the provided Lazy object.
/// A Lazy object to browse in the debugger.
public System_LazyDebugView(Lazy lazy)
{
m_lazy = lazy;
}
/// Returns whether the Lazy object is initialized or not.
public bool IsValueCreated
{
get { return m_lazy.IsValueCreated; }
}
/// Returns the value of the Lazy object.
public T Value
{
get
{ return m_lazy.ValueForDebugDisplay; }
}
/// Returns the execution mode of the Lazy object
public LazyThreadSafetyMode Mode
{
get { return m_lazy.Mode; }
}
/// Returns the execution mode of the Lazy object
public bool IsValueFaulted
{
get { return m_lazy.IsValueFaulted; }
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- InvalidateEvent.cs
- CssTextWriter.cs
- DescendentsWalkerBase.cs
- SizeFConverter.cs
- ArcSegment.cs
- OledbConnectionStringbuilder.cs
- GridView.cs
- SecureUICommand.cs
- ComPlusDiagnosticTraceRecords.cs
- NamespaceMapping.cs
- Composition.cs
- SR.cs
- SafeSecurityHandles.cs
- EmbeddedObject.cs
- ServiceDebugElement.cs
- DispatchChannelSink.cs
- ValueOfAction.cs
- Typography.cs
- DesignerCalendarAdapter.cs
- CapabilitiesSection.cs
- Keyboard.cs
- SoapRpcMethodAttribute.cs
- FileSystemEventArgs.cs
- SqlDataSourceView.cs
- GetWorkflowTree.cs
- HtmlInputControl.cs
- ILGenerator.cs
- ParameterBuilder.cs
- NameValuePermission.cs
- WeakEventManager.cs
- OneOf.cs
- RegexTree.cs
- WinFormsUtils.cs
- RegularExpressionValidator.cs
- MatrixAnimationBase.cs
- XmlStringTable.cs
- TreeViewImageKeyConverter.cs
- CopyNodeSetAction.cs
- ProxySimple.cs
- NavigationPropertyEmitter.cs
- SevenBitStream.cs
- RegexGroup.cs
- BooleanSwitch.cs
- DataServiceRequestOfT.cs
- ReturnEventArgs.cs
- IteratorFilter.cs
- HostExecutionContextManager.cs
- MexHttpBindingElement.cs
- ExecutionContext.cs
- FileBasedResourceGroveler.cs
- PropertySegmentSerializer.cs
- Convert.cs
- DockPanel.cs
- MarkupProperty.cs
- RelationalExpressions.cs
- RequestSecurityTokenForRemoteTokenFactory.cs
- TagPrefixInfo.cs
- EditCommandColumn.cs
- Action.cs
- NotCondition.cs
- ClientUtils.cs
- NumericExpr.cs
- CharConverter.cs
- FrameworkPropertyMetadata.cs
- UmAlQuraCalendar.cs
- MenuAutomationPeer.cs
- KeyedHashAlgorithm.cs
- DeviceContexts.cs
- XmlTextReader.cs
- IDQuery.cs
- Set.cs
- TreeViewDesigner.cs
- DetailsViewUpdatedEventArgs.cs
- IncrementalCompileAnalyzer.cs
- DataGridTableCollection.cs
- ControlAdapter.cs
- DataGridViewCheckBoxColumn.cs
- AdapterUtil.cs
- UpdateTracker.cs
- ZipIOLocalFileHeader.cs
- ObjectDataProvider.cs
- BrowserCapabilitiesCodeGenerator.cs
- ColorAnimation.cs
- Size.cs
- TypedColumnHandler.cs
- HashMembershipCondition.cs
- TypeBrowserDialog.cs
- SqlAliaser.cs
- WS2007HttpBindingElement.cs
- ScrollItemProviderWrapper.cs
- CompModSwitches.cs
- SmtpAuthenticationManager.cs
- DBPropSet.cs
- InputScopeAttribute.cs
- PropertyChange.cs
- ControlBuilderAttribute.cs
- SizeIndependentAnimationStorage.cs
- HtmlTable.cs
- EdmComplexPropertyAttribute.cs
- ContentTextAutomationPeer.cs