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
- ConfigXmlDocument.cs
- Helper.cs
- SchemaElement.cs
- SafeRightsManagementSessionHandle.cs
- MemberHolder.cs
- BamlLocalizer.cs
- FrameworkReadOnlyPropertyMetadata.cs
- BindingList.cs
- FixedSOMLineRanges.cs
- DoubleCollectionConverter.cs
- DirectionalLight.cs
- ColumnWidthChangingEvent.cs
- CompositeFontParser.cs
- ReferentialConstraint.cs
- DrawingVisual.cs
- MenuBindingsEditor.cs
- DataGridComponentEditor.cs
- objectresult_tresulttype.cs
- CommonXSendMessage.cs
- SqlDeflator.cs
- ActivityTypeCodeDomSerializer.cs
- ServiceTimeoutsBehavior.cs
- PTConverter.cs
- StreamGeometry.cs
- SynchronizedDispatch.cs
- CompiledQuery.cs
- TimeSpanValidatorAttribute.cs
- Model3DGroup.cs
- GcSettings.cs
- DynamicMethod.cs
- MatrixAnimationUsingPath.cs
- ECDiffieHellmanPublicKey.cs
- CodeParameterDeclarationExpressionCollection.cs
- Size3DValueSerializer.cs
- EventLogger.cs
- MenuItemAutomationPeer.cs
- XhtmlBasicValidationSummaryAdapter.cs
- StateItem.cs
- SimpleWorkerRequest.cs
- LocatorPartList.cs
- ScrollEvent.cs
- XmlAtomicValue.cs
- TextFormatter.cs
- EncoderParameter.cs
- WebPartDisplayModeCollection.cs
- DataGridHeaderBorder.cs
- File.cs
- ScrollProviderWrapper.cs
- GridViewRow.cs
- AuthenticationModulesSection.cs
- SecurityElement.cs
- BamlLocalizableResource.cs
- CaseInsensitiveOrdinalStringComparer.cs
- SafeRightsManagementEnvironmentHandle.cs
- ExceptionHandler.cs
- DecimalStorage.cs
- DesignerActionVerbItem.cs
- Clipboard.cs
- CompressionTransform.cs
- BindingMemberInfo.cs
- DocumentAutomationPeer.cs
- MsmqOutputSessionChannel.cs
- MessageEncodingBindingElement.cs
- DbSetClause.cs
- WebMessageBodyStyleHelper.cs
- ObjectQueryState.cs
- PngBitmapDecoder.cs
- OutputCacheSettingsSection.cs
- ImageDrawing.cs
- TraceHandlerErrorFormatter.cs
- XpsFixedPageReaderWriter.cs
- TypographyProperties.cs
- RoleManagerModule.cs
- CollectionContainer.cs
- ResourceKey.cs
- DesignerVerbCollection.cs
- MediaPlayerState.cs
- NavigationPropertyEmitter.cs
- columnmapkeybuilder.cs
- Compiler.cs
- WCFModelStrings.Designer.cs
- Camera.cs
- CodeSnippetTypeMember.cs
- PlacementWorkspace.cs
- HandlerWithFactory.cs
- RegexGroupCollection.cs
- UniformGrid.cs
- MatrixStack.cs
- SqlServices.cs
- RootProfilePropertySettingsCollection.cs
- TemplateAction.cs
- XsltOutput.cs
- DecimalStorage.cs
- ApplicationHost.cs
- SqlServer2KCompatibilityAnnotation.cs
- TreeIterator.cs
- _SSPISessionCache.cs
- SecUtil.cs
- SecurityRuntime.cs
- SHA1.cs