Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / wpf / src / Framework / System / Windows / ResourceReferenceExpression.cs / 5 / ResourceReferenceExpression.cs
//----------------------------------------------------------------------------
//
// File: ResourceReferenceExpression.cs
//
// Description:
// Expression to evaluate a ResourceReference.
//
// Copyright (C) 2003 by Microsoft Corporation. All rights reserved.
//
//---------------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Markup;
using MS.Internal;
namespace System.Windows
{
///
/// Expression to evaluate a ResourceReference
///
[TypeConverter(typeof(ResourceReferenceExpressionConverter))]
internal class ResourceReferenceExpression : Expression
{
///
/// Constructor for ResourceReferenceExpression
///
///
/// Name of the resource being referenced
///
public ResourceReferenceExpression(object resourceKey)
{
_resourceKey = resourceKey;
}
///
/// List of sources of the ResourceReferenceExpression
///
/// Sources list
internal override DependencySource[] GetSources()
{
return null;
}
///
/// Called to evaluate the ResourceReferenceExpression value
///
/// DependencyObject being queried
/// Property being queried
/// Computed value. Unset if unavailable.
internal override object GetValue(DependencyObject d, DependencyProperty dp)
{
if (d == null)
{
throw new ArgumentNullException("d");
}
if (dp == null)
{
throw new ArgumentNullException("dp");
}
// If the cached value is valid then return it
if (ReadInternalState(InternalState.HasCachedResourceValue) == true)
return _cachedResourceValue;
object source;
return GetRawValue(d, out source, dp);
}
// Clone a copy of this expression (this is used by Freezable.Copy)
internal override Expression Copy( DependencyObject targetObject, DependencyProperty targetDP )
{
return new ResourceReferenceExpression( ResourceKey );
}
///
/// Called to evaluate the ResourceReferenceExpression value
///
/// DependencyObject being queried
/// Source object that the resource is found on
/// DependencyProperty
/// Computed value. Unset if unavailable.
///
/// This routine has been separated from the above GetValue call because it is
/// invoked by the ResourceReferenceExpressionConverter during serialization.
///
internal object GetRawValue(DependencyObject d, out object source, DependencyProperty dp)
{
// Find the mentor node to invoke FindResource on. For example
//
/// Allows ResourceReferenceExpression to store set values
///
/// DependencyObject being set
/// Property being set
/// Value being set
/// true if ResourceReferenceExpression handled storing of the value
internal override bool SetValue(DependencyObject d, DependencyProperty dp, object value)
{
return false;
}
///
/// Notification that the ResourceReferenceExpression has been set as a property's value
///
/// DependencyObject being set
/// Property being set
internal override void OnAttach(DependencyObject d, DependencyProperty dp)
{
_targetObject = d;
_targetProperty = dp;
FrameworkObject fo = new FrameworkObject(_targetObject);
fo.HasResourceReference = true;
if (!fo.IsValid)
{
// Listen for the InheritanceContextChanged event on the target node,
// so that if this context hierarchy changes we can re-evaluate this expression.
_targetObject.InheritanceContextChanged += new EventHandler(InvalidateExpressionValue);
}
}
///
/// Notification that the ResourceReferenceExpression has been removed as a property's value
///
/// DependencyObject being cleared
/// Property being cleared
internal override void OnDetach(DependencyObject d, DependencyProperty dp)
{
// Invalidate all the caches
InvalidateMentorCache();
if (!(_targetObject is FrameworkElement) && !(_targetObject is FrameworkContentElement))
{
// Stop listening for the InheritanceContextChanged event on the target node
_targetObject.InheritanceContextChanged -= new EventHandler(InvalidateExpressionValue);
}
_targetObject = null;
_targetProperty = null;
}
///
/// Key used to lookup the resource
///
public object ResourceKey
{
get { return _resourceKey; }
}
///
/// This method is called when the cached value of the resource has
/// been invalidated. E.g. after a new Resources property is set somewhere
/// in the ancestory.
///
private void InvalidateCacheValue()
{
object resource = _cachedResourceValue;
// If the old value was a DeferredResourceReference, it should be
// removed from its Dictionary's list to avoid a leak (bug 1624666).
DeferredResourceReference deferredResourceReference = _cachedResourceValue as DeferredResourceReference;
if (deferredResourceReference != null)
{
if (deferredResourceReference.IsInflated)
{
// use the inflated value for the Freezable test below
resource = deferredResourceReference.Value;
}
else
{
// stop listening for the Inflated event
if (ReadInternalState(InternalState.IsListeningForInflated))
{
deferredResourceReference.RemoveInflatedListener(this);
WriteInternalState(InternalState.IsListeningForInflated, false);
}
}
deferredResourceReference.RemoveFromDictionary();
}
StopListeningForFreezableChanges(resource);
_cachedResourceValue = null;
WriteInternalState(InternalState.HasCachedResourceValue, false);
}
///
/// This method is called to invalidate all the cached values held in
/// this expression. This is called under the following 3 scenarios
/// 1. InheritanceContext changes
/// 2. Logical tree changes
/// 3. ResourceDictionary changes
/// This call is more pervasive than the InvalidateCacheValue method
///
private void InvalidateMentorCache()
{
if (ReadInternalState(InternalState.IsMentorCacheValid) == true)
{
if (_mentorCache != null)
{
if (_mentorCache != _targetObject)
{
FrameworkElement mentorFE;
FrameworkContentElement mentorFCE;
Helper.DowncastToFEorFCE(_mentorCache, out mentorFE, out mentorFCE, true);
// Your mentor is about to change, make sure you detach handlers for
// the events that you were listening on the old mentor
if (mentorFE != null)
{
mentorFE.ResourcesChanged -= new EventHandler(InvalidateExpressionValue);
}
else
{
mentorFCE.ResourcesChanged -= new EventHandler(InvalidateExpressionValue);
}
}
// Drop the mentor cache
_mentorCache = null;
}
// Mark the cache invalid
WriteInternalState(InternalState.IsMentorCacheValid, false);
}
// Invalidate the cached value of the expression
InvalidateCacheValue();
}
///
/// This event handler is called to invalidate the cached value held in
/// this expression. This is called under the following 3 scenarios
/// 1. InheritanceContext changes
/// 2. Logical tree changes
/// 3. ResourceDictionary changes
///
internal void InvalidateExpressionValue(object sender, EventArgs e)
{
ResourcesChangedEventArgs args = e as ResourcesChangedEventArgs;
if (args != null)
{
ResourcesChangeInfo info = args.Info;
if (!info.IsTreeChange)
{
// This will happen when
// 1. Theme changes
// 2. Entire ResourceDictionary in the ancestry changes
// 3. Single entry in a ResourceDictionary in the ancestry is changed
// In all of the above cases it is sufficient to re-evaluate the cache
// value alone. The mentor relation ships stay the same.
InvalidateCacheValue();
}
else
{
// This is the case of a logical tree change and hence we need to
// re-evaluate both the mentor and the cached value.
InvalidateMentorCache();
}
}
else
{
// There is no information provided by the EventArgs. Hence we
// pessimistically invalidate both the mentor and the cached value.
// This code path will execute when the InheritanceContext changes.
InvalidateMentorCache();
}
InvalidateTargetProperty(sender, e);
}
private void InvalidateTargetProperty(object sender, EventArgs e)
{
_targetObject.InvalidateProperty(_targetProperty);
}
private void InvalidateTargetSubProperty(object sender, EventArgs e)
{
_targetObject.NotifySubPropertyChange(_targetProperty);
}
private void ListenForFreezableChanges(object resource)
{
if (!ReadInternalState(InternalState.IsListeningForFreezableChanges))
{
// If this value is an unfrozen Freezable object, we need
// to listen to its changed event in order to properly update
// the cache.
Freezable resourceAsFreezable = resource as Freezable;
if( resourceAsFreezable != null && !resourceAsFreezable.IsFrozen )
{
resourceAsFreezable.Changed += new EventHandler(InvalidateTargetSubProperty);
WriteInternalState(InternalState.IsListeningForFreezableChanges, true);
}
}
}
private void StopListeningForFreezableChanges(object resource)
{
if (ReadInternalState(InternalState.IsListeningForFreezableChanges))
{
// If the old value was an unfrozen Freezable object, we need
// to stop listening to its changed event. If the old value wasn't
// frozen (hence we attached an listener) but has been frozen
// since then, the change handler we had attached was already
// discarded during the freeze so we don't care here.
Freezable resourceAsFreezable = resource as Freezable;
if( resourceAsFreezable != null && !resourceAsFreezable.IsFrozen )
{
resourceAsFreezable.Changed -= new EventHandler(InvalidateTargetSubProperty);
}
// It is possible that a freezable was unfrozen during the call to ListForFreezableChanges
// but was frozen before the call to StopListeningForFreezableChanges
WriteInternalState(InternalState.IsListeningForFreezableChanges, false);
}
}
// when a deferred resource reference is inflated, the value may need extra
// work
internal void OnDeferredResourceInflated(DeferredResourceReference deferredResourceReference)
{
if (ReadInternalState(InternalState.IsListeningForInflated))
{
// once the value is inflated, stop listening for the event
deferredResourceReference.RemoveInflatedListener(this);
WriteInternalState(InternalState.IsListeningForInflated, false);
}
ListenForFreezableChanges(deferredResourceReference.Value);
}
// Extracts the required flag and returns
// bool to indicate if it is set or unset
private bool ReadInternalState(InternalState reqFlag)
{
return (_state & reqFlag) != 0;
}
// Sets or Unsets the required flag based on
// the bool argument
private void WriteInternalState(InternalState reqFlag, bool set)
{
if (set)
{
_state |= reqFlag;
}
else
{
_state &= (~reqFlag);
}
}
private object _resourceKey; // Name of the resource being referenced by this expression
// Cached value and a dirty bit. See GetValue.
private object _cachedResourceValue;
// Used to find the value for this expression when it is set on a non-FE/FCE.
// The mentor is the FE/FCE that the FindResource method is invoked on.
private DependencyObject _mentorCache;
// Used by the change listener to fire invalidation.
private DependencyObject _targetObject;
private DependencyProperty _targetProperty;
// Bit Fields used to store boolean flags
private InternalState _state = InternalState.Default; // this is a byte (see def'n)
///
/// This enum represents the internal state of the RRE.
/// Additional bools should be coalesced into this enum.
///
[Flags]
private enum InternalState : byte
{
Default = 0x00,
HasCachedResourceValue = 0x01,
IsMentorCacheValid = 0x02,
DisableThrowOnResourceFailure = 0x04,
IsListeningForFreezableChanges= 0x08,
IsListeningForInflated = 0x10,
}
}
///
/// These EventArgs are used to pass additional
/// information during a ResourcesChanged event
///
internal class ResourcesChangedEventArgs : EventArgs
{
internal ResourcesChangedEventArgs(ResourcesChangeInfo info)
{
_info = info;
}
internal ResourcesChangeInfo Info
{
get { return _info; }
}
private ResourcesChangeInfo _info;
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
//
// File: ResourceReferenceExpression.cs
//
// Description:
// Expression to evaluate a ResourceReference.
//
// Copyright (C) 2003 by Microsoft Corporation. All rights reserved.
//
//---------------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Markup;
using MS.Internal;
namespace System.Windows
{
///
/// Expression to evaluate a ResourceReference
///
[TypeConverter(typeof(ResourceReferenceExpressionConverter))]
internal class ResourceReferenceExpression : Expression
{
///
/// Constructor for ResourceReferenceExpression
///
///
/// Name of the resource being referenced
///
public ResourceReferenceExpression(object resourceKey)
{
_resourceKey = resourceKey;
}
///
/// List of sources of the ResourceReferenceExpression
///
/// Sources list
internal override DependencySource[] GetSources()
{
return null;
}
///
/// Called to evaluate the ResourceReferenceExpression value
///
/// DependencyObject being queried
/// Property being queried
/// Computed value. Unset if unavailable.
internal override object GetValue(DependencyObject d, DependencyProperty dp)
{
if (d == null)
{
throw new ArgumentNullException("d");
}
if (dp == null)
{
throw new ArgumentNullException("dp");
}
// If the cached value is valid then return it
if (ReadInternalState(InternalState.HasCachedResourceValue) == true)
return _cachedResourceValue;
object source;
return GetRawValue(d, out source, dp);
}
// Clone a copy of this expression (this is used by Freezable.Copy)
internal override Expression Copy( DependencyObject targetObject, DependencyProperty targetDP )
{
return new ResourceReferenceExpression( ResourceKey );
}
///
/// Called to evaluate the ResourceReferenceExpression value
///
/// DependencyObject being queried
/// Source object that the resource is found on
/// DependencyProperty
/// Computed value. Unset if unavailable.
///
/// This routine has been separated from the above GetValue call because it is
/// invoked by the ResourceReferenceExpressionConverter during serialization.
///
internal object GetRawValue(DependencyObject d, out object source, DependencyProperty dp)
{
// Find the mentor node to invoke FindResource on. For example
//
/// Allows ResourceReferenceExpression to store set values
///
/// DependencyObject being set
/// Property being set
/// Value being set
/// true if ResourceReferenceExpression handled storing of the value
internal override bool SetValue(DependencyObject d, DependencyProperty dp, object value)
{
return false;
}
///
/// Notification that the ResourceReferenceExpression has been set as a property's value
///
/// DependencyObject being set
/// Property being set
internal override void OnAttach(DependencyObject d, DependencyProperty dp)
{
_targetObject = d;
_targetProperty = dp;
FrameworkObject fo = new FrameworkObject(_targetObject);
fo.HasResourceReference = true;
if (!fo.IsValid)
{
// Listen for the InheritanceContextChanged event on the target node,
// so that if this context hierarchy changes we can re-evaluate this expression.
_targetObject.InheritanceContextChanged += new EventHandler(InvalidateExpressionValue);
}
}
///
/// Notification that the ResourceReferenceExpression has been removed as a property's value
///
/// DependencyObject being cleared
/// Property being cleared
internal override void OnDetach(DependencyObject d, DependencyProperty dp)
{
// Invalidate all the caches
InvalidateMentorCache();
if (!(_targetObject is FrameworkElement) && !(_targetObject is FrameworkContentElement))
{
// Stop listening for the InheritanceContextChanged event on the target node
_targetObject.InheritanceContextChanged -= new EventHandler(InvalidateExpressionValue);
}
_targetObject = null;
_targetProperty = null;
}
///
/// Key used to lookup the resource
///
public object ResourceKey
{
get { return _resourceKey; }
}
///
/// This method is called when the cached value of the resource has
/// been invalidated. E.g. after a new Resources property is set somewhere
/// in the ancestory.
///
private void InvalidateCacheValue()
{
object resource = _cachedResourceValue;
// If the old value was a DeferredResourceReference, it should be
// removed from its Dictionary's list to avoid a leak (bug 1624666).
DeferredResourceReference deferredResourceReference = _cachedResourceValue as DeferredResourceReference;
if (deferredResourceReference != null)
{
if (deferredResourceReference.IsInflated)
{
// use the inflated value for the Freezable test below
resource = deferredResourceReference.Value;
}
else
{
// stop listening for the Inflated event
if (ReadInternalState(InternalState.IsListeningForInflated))
{
deferredResourceReference.RemoveInflatedListener(this);
WriteInternalState(InternalState.IsListeningForInflated, false);
}
}
deferredResourceReference.RemoveFromDictionary();
}
StopListeningForFreezableChanges(resource);
_cachedResourceValue = null;
WriteInternalState(InternalState.HasCachedResourceValue, false);
}
///
/// This method is called to invalidate all the cached values held in
/// this expression. This is called under the following 3 scenarios
/// 1. InheritanceContext changes
/// 2. Logical tree changes
/// 3. ResourceDictionary changes
/// This call is more pervasive than the InvalidateCacheValue method
///
private void InvalidateMentorCache()
{
if (ReadInternalState(InternalState.IsMentorCacheValid) == true)
{
if (_mentorCache != null)
{
if (_mentorCache != _targetObject)
{
FrameworkElement mentorFE;
FrameworkContentElement mentorFCE;
Helper.DowncastToFEorFCE(_mentorCache, out mentorFE, out mentorFCE, true);
// Your mentor is about to change, make sure you detach handlers for
// the events that you were listening on the old mentor
if (mentorFE != null)
{
mentorFE.ResourcesChanged -= new EventHandler(InvalidateExpressionValue);
}
else
{
mentorFCE.ResourcesChanged -= new EventHandler(InvalidateExpressionValue);
}
}
// Drop the mentor cache
_mentorCache = null;
}
// Mark the cache invalid
WriteInternalState(InternalState.IsMentorCacheValid, false);
}
// Invalidate the cached value of the expression
InvalidateCacheValue();
}
///
/// This event handler is called to invalidate the cached value held in
/// this expression. This is called under the following 3 scenarios
/// 1. InheritanceContext changes
/// 2. Logical tree changes
/// 3. ResourceDictionary changes
///
internal void InvalidateExpressionValue(object sender, EventArgs e)
{
ResourcesChangedEventArgs args = e as ResourcesChangedEventArgs;
if (args != null)
{
ResourcesChangeInfo info = args.Info;
if (!info.IsTreeChange)
{
// This will happen when
// 1. Theme changes
// 2. Entire ResourceDictionary in the ancestry changes
// 3. Single entry in a ResourceDictionary in the ancestry is changed
// In all of the above cases it is sufficient to re-evaluate the cache
// value alone. The mentor relation ships stay the same.
InvalidateCacheValue();
}
else
{
// This is the case of a logical tree change and hence we need to
// re-evaluate both the mentor and the cached value.
InvalidateMentorCache();
}
}
else
{
// There is no information provided by the EventArgs. Hence we
// pessimistically invalidate both the mentor and the cached value.
// This code path will execute when the InheritanceContext changes.
InvalidateMentorCache();
}
InvalidateTargetProperty(sender, e);
}
private void InvalidateTargetProperty(object sender, EventArgs e)
{
_targetObject.InvalidateProperty(_targetProperty);
}
private void InvalidateTargetSubProperty(object sender, EventArgs e)
{
_targetObject.NotifySubPropertyChange(_targetProperty);
}
private void ListenForFreezableChanges(object resource)
{
if (!ReadInternalState(InternalState.IsListeningForFreezableChanges))
{
// If this value is an unfrozen Freezable object, we need
// to listen to its changed event in order to properly update
// the cache.
Freezable resourceAsFreezable = resource as Freezable;
if( resourceAsFreezable != null && !resourceAsFreezable.IsFrozen )
{
resourceAsFreezable.Changed += new EventHandler(InvalidateTargetSubProperty);
WriteInternalState(InternalState.IsListeningForFreezableChanges, true);
}
}
}
private void StopListeningForFreezableChanges(object resource)
{
if (ReadInternalState(InternalState.IsListeningForFreezableChanges))
{
// If the old value was an unfrozen Freezable object, we need
// to stop listening to its changed event. If the old value wasn't
// frozen (hence we attached an listener) but has been frozen
// since then, the change handler we had attached was already
// discarded during the freeze so we don't care here.
Freezable resourceAsFreezable = resource as Freezable;
if( resourceAsFreezable != null && !resourceAsFreezable.IsFrozen )
{
resourceAsFreezable.Changed -= new EventHandler(InvalidateTargetSubProperty);
}
// It is possible that a freezable was unfrozen during the call to ListForFreezableChanges
// but was frozen before the call to StopListeningForFreezableChanges
WriteInternalState(InternalState.IsListeningForFreezableChanges, false);
}
}
// when a deferred resource reference is inflated, the value may need extra
// work
internal void OnDeferredResourceInflated(DeferredResourceReference deferredResourceReference)
{
if (ReadInternalState(InternalState.IsListeningForInflated))
{
// once the value is inflated, stop listening for the event
deferredResourceReference.RemoveInflatedListener(this);
WriteInternalState(InternalState.IsListeningForInflated, false);
}
ListenForFreezableChanges(deferredResourceReference.Value);
}
// Extracts the required flag and returns
// bool to indicate if it is set or unset
private bool ReadInternalState(InternalState reqFlag)
{
return (_state & reqFlag) != 0;
}
// Sets or Unsets the required flag based on
// the bool argument
private void WriteInternalState(InternalState reqFlag, bool set)
{
if (set)
{
_state |= reqFlag;
}
else
{
_state &= (~reqFlag);
}
}
private object _resourceKey; // Name of the resource being referenced by this expression
// Cached value and a dirty bit. See GetValue.
private object _cachedResourceValue;
// Used to find the value for this expression when it is set on a non-FE/FCE.
// The mentor is the FE/FCE that the FindResource method is invoked on.
private DependencyObject _mentorCache;
// Used by the change listener to fire invalidation.
private DependencyObject _targetObject;
private DependencyProperty _targetProperty;
// Bit Fields used to store boolean flags
private InternalState _state = InternalState.Default; // this is a byte (see def'n)
///
/// This enum represents the internal state of the RRE.
/// Additional bools should be coalesced into this enum.
///
[Flags]
private enum InternalState : byte
{
Default = 0x00,
HasCachedResourceValue = 0x01,
IsMentorCacheValid = 0x02,
DisableThrowOnResourceFailure = 0x04,
IsListeningForFreezableChanges= 0x08,
IsListeningForInflated = 0x10,
}
}
///
/// These EventArgs are used to pass additional
/// information during a ResourcesChanged event
///
internal class ResourcesChangedEventArgs : EventArgs
{
internal ResourcesChangedEventArgs(ResourcesChangeInfo info)
{
_info = info;
}
internal ResourcesChangeInfo Info
{
get { return _info; }
}
private ResourcesChangeInfo _info;
}
}
// 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
- InvokePatternIdentifiers.cs
- WhereaboutsReader.cs
- SweepDirectionValidation.cs
- WindowsFormsSynchronizationContext.cs
- ImageCollectionCodeDomSerializer.cs
- DataGridViewCellEventArgs.cs
- DispatcherExceptionEventArgs.cs
- DataServiceProviderMethods.cs
- Permission.cs
- HeaderPanel.cs
- ClientUrlResolverWrapper.cs
- XmlNodeChangedEventArgs.cs
- HashHelper.cs
- SizeLimitedCache.cs
- BinHexEncoder.cs
- AnnotationResourceCollection.cs
- RelationshipDetailsRow.cs
- MdbDataFileEditor.cs
- HtmlLink.cs
- DrawingVisualDrawingContext.cs
- GeometryValueSerializer.cs
- COM2TypeInfoProcessor.cs
- MaterialCollection.cs
- ReliabilityContractAttribute.cs
- UrlParameterReader.cs
- OptimizedTemplateContent.cs
- DesigntimeLicenseContextSerializer.cs
- RegistrationServices.cs
- SqlRowUpdatingEvent.cs
- XPathDocument.cs
- SecureConversationDriver.cs
- MarshalByValueComponent.cs
- XmlLoader.cs
- CharStorage.cs
- AutomationFocusChangedEventArgs.cs
- WindowsMenu.cs
- InternalResources.cs
- GZipDecoder.cs
- ListManagerBindingsCollection.cs
- FullTextState.cs
- SiteMapSection.cs
- InvalidPropValue.cs
- RenamedEventArgs.cs
- CqlQuery.cs
- MarkupProperty.cs
- HttpCapabilitiesEvaluator.cs
- DataSourceView.cs
- WebPartCollection.cs
- ResourceContainer.cs
- UserControlCodeDomTreeGenerator.cs
- FileVersion.cs
- CryptoKeySecurity.cs
- EventMemberCodeDomSerializer.cs
- CodeTypeDeclarationCollection.cs
- DoubleAnimationUsingKeyFrames.cs
- ClosableStream.cs
- TextElement.cs
- CapacityStreamGeometryContext.cs
- UserMapPath.cs
- X509CertificateCollection.cs
- Win32.cs
- NotifyIcon.cs
- Pair.cs
- StreamSecurityUpgradeProvider.cs
- OrderingQueryOperator.cs
- ScrollProperties.cs
- FocusChangedEventArgs.cs
- GenericUriParser.cs
- AnnotationAdorner.cs
- securitycriticaldataformultiplegetandset.cs
- LongPath.cs
- Comparer.cs
- MemberInfoSerializationHolder.cs
- TraceContext.cs
- InitiatorSessionSymmetricMessageSecurityProtocol.cs
- MachineKeySection.cs
- XPathNodeHelper.cs
- SHA256.cs
- OrderedDictionary.cs
- SchemaInfo.cs
- VectorCollectionConverter.cs
- SwitchAttribute.cs
- RoutedEventArgs.cs
- SqlCacheDependencySection.cs
- ToolStripLocationCancelEventArgs.cs
- SqlInternalConnection.cs
- TouchesCapturedWithinProperty.cs
- KeyTime.cs
- TailCallAnalyzer.cs
- LocatorPart.cs
- SiteMapNode.cs
- DispatcherHookEventArgs.cs
- WebServiceParameterData.cs
- DataGridTextBox.cs
- DocumentCollection.cs
- TextMarkerSource.cs
- Char.cs
- ResourceBinder.cs
- UIElementParagraph.cs
- XMLSchema.cs