RoutedEventArgs.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Core / CSharp / System / Windows / RoutedEventArgs.cs / 1305600 / RoutedEventArgs.cs
                        

                        
                            using System; 
using System.Security;

using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID; 
using MS.Internal.PresentationCore;
using System.Collections.Specialized ; 
using System.Windows.Input; 
using System.Diagnostics;
using MS.Internal; 

namespace System.Windows
{
    /// 
 
    ///     The container for all state associated
    ///     with a RoutedEvent 
    /// 
 
    /// 
    ///      
    ///     constitutes the 
    ///     , 
    ///     , 
    ///      and  
    ///      
    ///      
    /// 
    ///     Different 
    ///     can be used with a single   
    ///     
    ///
    ///     The  is responsible
    ///     for packaging the , 
    ///     providing extra event state info, and invoking the
    ///     handler associated with the RoutedEvent 
    ///  
    public class RoutedEventArgs : EventArgs
    { 
        #region Construction

        /// 

        ///     Constructor for  
        /// 
        ///  
        ///     All members take default values  
        ///     
        /// 
        ///     
        ///     defaults to null 
        ///      defaults to
        ///     false  
        ///      defaults to null 
        ///      also defaults to null 
        ///      
        /// 
        public RoutedEventArgs() 
        {
        }

        /// 
 
        ///     Constructor for 
        /// 
 
        /// The new value that the RoutedEvent Property is being set to  
        public RoutedEventArgs(RoutedEvent routedEvent) : this( routedEvent, null)
        { 
        }

        /// 

        ///     Constructor for  
        /// 
        /// The new value that the SourceProperty is being set to  
        /// The new value that the RoutedEvent Property is being set to  
        public RoutedEventArgs(RoutedEvent routedEvent, object source)
        { 
            _routedEvent = routedEvent;
            _source = _originalSource = source;
        }
 
        #endregion Construction
 
        #region External API 
        /// 

        ///     Returns the  associated 
        ///     with this 
        /// 
        /// 
        ///     The  cannot be null 
        ///     at any time
        ///  
        public RoutedEvent RoutedEvent 
        {
            get {return _routedEvent;} 
            set
            {
                if (UserInitiated && InvokingHandler)
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventCannotChangeWhileRouting)); 

                _routedEvent = value; 
            } 
        }
 
        /// 

        ///     Changes the RoutedEvent assocatied with these RoutedEventArgs
        /// 
        ///  
        ///     Only used internally.  Added to support cracking generic MouseButtonDown/Up events
        ///     into MouseLeft/RightButtonDown/Up events. 
        ///  
        /// 
        ///     The new RoutedEvent to associate with these RoutedEventArgs 
        /// 
        internal void OverrideRoutedEvent( RoutedEvent newRoutedEvent )
        {
            _routedEvent = newRoutedEvent; 
        }
 
        /// 
 
        ///     Returns a boolean flag indicating if or not this
        ///     RoutedEvent has been handled this far in the route 
        /// 
        /// 
        ///     Initially starts with a false value before routing
        ///     has begun 
        /// 
        /// 
        /// Critical - _flags is critical due to UserInitiated value. 
        /// PublicOK - in this function we're not setting UserInitiated - we're setting Handled.
        /// 
        public bool Handled
        {
            [SecurityCritical ]
            get 
            {
                return _flags[ HandledIndex ] ; 
            } 

            [SecurityCritical ] 
            set
            {
                if (_routedEvent == null)
                { 
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventArgsMustHaveRoutedEvent));
                } 
 

                if( TraceRoutedEvent.IsEnabled ) 
                {
                    TraceRoutedEvent.TraceActivityItem(
                                            TraceRoutedEvent.HandleEvent,
                                            value, 
                                            RoutedEvent.OwnerType.Name,
                                            RoutedEvent.Name, 
                                            this ); 
                }
 

                // Note: We need to allow the caller to change the handled value
                // from true to false.
                // 
                // We are concerned about scenarios where a child element
                // listens to a high-level event (such as TextInput) while a 
                // parent element listens tp a low-level event such as KeyDown. 
                // In these scenarios, we want the parent to not respond to the
                // KeyDown event, in deference to the child. 
                //
                // Internally we implement this by asking the parent to only
                // respond to KeyDown events if they have focus.  This works
                // around the problem and is an example of an unofficial 
                // protocol coordinating the two elements.
                // 
                // But we imagine that there will be some cases we miss or 
                // that third parties introduce.  For these cases, we expect
                // that the application author may need to mark the KeyDown 
                // as handled in the child, and then reset the event to
                // being unhandled after the parent, so that default processing
                // and promotion still occur.
                // 
                // For more information see the following task:
                // 20284: Input promotion breaks down when lower level input is intercepted 
 
                _flags[ HandledIndex ] = value;
 
            }
        }

        /// 
 
        ///     Returns Source object that raised the RoutedEvent
        /// 
 
        public object Source 
        {
            get {return _source;} 
            set
            {

                if (InvokingHandler && UserInitiated) 
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventCannotChangeWhileRouting));
 
                if (_routedEvent == null) 
                {
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventArgsMustHaveRoutedEvent)); 
                }


                object source = value ; 
                if (_source == null && _originalSource == null)
                { 
                    // Gets here when it is the first time that the source is set. 
                    // This implies that this is also the original source of the event
                    _source = _originalSource = source; 
                    OnSetSource(source);
                }
                else if (_source != source)
                { 
                    // This is the actiaon taken at all other times when the
                    // source is being set to a different value from what it was 
                    _source = source; 
                    OnSetSource(source);
                } 
            }
        }

        /// 
 
        ///     Changes the Source assocatied with these RoutedEventArgs
        /// 
 
        ///  
        ///     Only used internally.  Added to support cracking generic MouseButtonDown/Up events
        ///     into MouseLeft/RightButtonDown/Up events. 
        /// 
        /// 
        ///     The new object to associate as the source of these RoutedEventArgs
        ///  
        internal void OverrideSource( object source )
        { 
            _source = source; 
        }
 
        /// 

        ///     Returns OriginalSource object that raised the RoutedEvent
        /// 
        ///  
        ///     Always returns the OriginalSource object that raised the
        ///     RoutedEvent unlike  
        ///     that may vary under specific scenarios  
        ///     This property acquires its value once before the event
        ///     handlers are invoked and never changes then on 
        /// 
        public object OriginalSource
        {
            get {return _originalSource;} 
        }
 
        /// 
 
        ///     Invoked when the source of the event is set
        /// 
 
        /// 
        ///     Changing the source of an event can often
        ///     require updating the data within the event.
        ///     For this reason, the OnSource=  method is 
        ///     protected virtual and is meant to be
        ///     overridden by sub-classes of 
        ///       
        ///     Also see 
        ///  
        /// 
        ///     The new value that the SourceProperty is being set to
        /// 
        protected virtual void OnSetSource(object source) 
        {
        } 
 
        /// 

        ///     Invokes the generic handler with the 
        ///     appropriate arguments
        /// 
        /// 
        ///     Is meant to be overridden by sub-classes of 
        ///      to provide
        ///     more efficient invocation of their delegate 
        ///  
        /// 
        ///     Generic Handler to be invoked 
        /// 
        /// 
        ///     Target on whom the Handler will be invoked
        ///  
        protected virtual void InvokeEventHandler(Delegate genericHandler, object genericTarget)
        { 
            if (genericHandler == null) 
            {
                throw new ArgumentNullException("genericHandler"); 
            }

            if (genericTarget == null)
            { 
                throw new ArgumentNullException("genericTarget");
            } 
 
            if (_routedEvent == null)
            { 
                throw new InvalidOperationException(SR.Get(SRID.RoutedEventArgsMustHaveRoutedEvent));
            }

            InvokingHandler = true; 
            try
            { 
                if (genericHandler is RoutedEventHandler) 
                {
                    ((RoutedEventHandler)genericHandler)(genericTarget, this); 
                }
                else
                {
                    // Restricted Action - reflection permission required 
                    genericHandler.DynamicInvoke(new object[] {genericTarget, this});
                } 
            } 
            finally
            { 
                InvokingHandler = false;
            }

        } 

        #endregion External API 
 
        #region Operations
 
        // Calls the InvokeEventHandler protected
        // virtual method
        //
        // This method is needed because 
        // delegates are invoked from
        // RoutedEventHandler which is not a 
        // sub-class of RoutedEventArgs 
        // and hence cannot invoke protected
        // method RoutedEventArgs.FireEventHandler 
        internal void InvokeHandler(Delegate handler, object target)
        {
            InvokingHandler = true;
 
            try
            { 
                InvokeEventHandler(handler, target); 
            }
            finally 
            {
                InvokingHandler = false;
            }
        } 

        /// 
        ///     Critical - access critical information, if this is a user initiated command 
        ///     TreatAsSafe - checking user initiated bit considered safe.
        /// 
        internal bool UserInitiated
        {
            [SecurityCritical, SecurityTreatAsSafe ]
            [FriendAccessAllowed] // Also used by Framework. 
            get
            { 
                if (_flags [UserInitiatedIndex]) 
                {
                    return SecurityHelper.CallerHasUserInitiatedRoutedEventPermission(); 
                }
                return false;
            }
        } 

        ///  
        ///     Critical - access critical information, if this is a user initiated command 
        /// 
        [SecurityCritical] 
        internal void MarkAsUserInitiated()
        {
            _flags [ UserInitiatedIndex ] = true;
        } 

        ///  
        ///     Critical - access critical information, if this is a user initiated command 
        ///     TreatAsSafe - clearing user initiated bit considered safe.
        ///  
        [SecurityCritical, SecurityTreatAsSafe ]
        internal void ClearUserInitiated()
        {
            _flags [ UserInitiatedIndex ] = false ; 
        }
 
        /// 
        /// Critical - _flags is critical due to UserInitiated value.
        /// TreatAsSafe - in this function we're not setting UserInitiated - we're setting InvokingHandler. 
        ///
        private bool InvokingHandler
        {
            [SecurityCritical, SecurityTreatAsSafe ] 
            get
            { 
                return _flags[InvokingHandlerIndex]; 
            }
            [SecurityCritical, SecurityTreatAsSafe ] 
            set
            {
                _flags[InvokingHandlerIndex] = value;
            } 
        }
        #endregion Operations 
 

 
        #region Data

        private RoutedEvent _routedEvent;
        private object _source; 
        private object _originalSource;
 
        /// 
        /// Critical - the UserInitiated flag value is critical.
        /// 
        [SecurityCritical]
        private BitVector32          _flags;

        private const int HandledIndex                          = 1; 
        private const int UserInitiatedIndex                    = 2;
        private const int InvokingHandlerIndex                  = 4; 
 

        #endregion Data 
    }

    /// 

    ///     RoutedEventHandler Definition 
    /// 
    ///  
    public delegate void RoutedEventHandler(object sender, RoutedEventArgs e); 
}
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
using System; 
using System.Security;

using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID; 
using MS.Internal.PresentationCore;
using System.Collections.Specialized ; 
using System.Windows.Input; 
using System.Diagnostics;
using MS.Internal; 

namespace System.Windows
{
    /// 
 
    ///     The container for all state associated
    ///     with a RoutedEvent 
    /// 
 
    /// 
    ///      
    ///     constitutes the 
    ///     , 
    ///     , 
    ///      and  
    ///      
    ///      
    /// 
    ///     Different 
    ///     can be used with a single   
    ///     
    ///
    ///     The  is responsible
    ///     for packaging the , 
    ///     providing extra event state info, and invoking the
    ///     handler associated with the RoutedEvent 
    ///  
    public class RoutedEventArgs : EventArgs
    { 
        #region Construction

        /// 

        ///     Constructor for  
        /// 
        ///  
        ///     All members take default values  
        ///     
        /// 
        ///     
        ///     defaults to null 
        ///      defaults to
        ///     false  
        ///      defaults to null 
        ///      also defaults to null 
        ///      
        /// 
        public RoutedEventArgs() 
        {
        }

        /// 
 
        ///     Constructor for 
        /// 
 
        /// The new value that the RoutedEvent Property is being set to  
        public RoutedEventArgs(RoutedEvent routedEvent) : this( routedEvent, null)
        { 
        }

        /// 

        ///     Constructor for  
        /// 
        /// The new value that the SourceProperty is being set to  
        /// The new value that the RoutedEvent Property is being set to  
        public RoutedEventArgs(RoutedEvent routedEvent, object source)
        { 
            _routedEvent = routedEvent;
            _source = _originalSource = source;
        }
 
        #endregion Construction
 
        #region External API 
        /// 

        ///     Returns the  associated 
        ///     with this 
        /// 
        /// 
        ///     The  cannot be null 
        ///     at any time
        ///  
        public RoutedEvent RoutedEvent 
        {
            get {return _routedEvent;} 
            set
            {
                if (UserInitiated && InvokingHandler)
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventCannotChangeWhileRouting)); 

                _routedEvent = value; 
            } 
        }
 
        /// 

        ///     Changes the RoutedEvent assocatied with these RoutedEventArgs
        /// 
        ///  
        ///     Only used internally.  Added to support cracking generic MouseButtonDown/Up events
        ///     into MouseLeft/RightButtonDown/Up events. 
        ///  
        /// 
        ///     The new RoutedEvent to associate with these RoutedEventArgs 
        /// 
        internal void OverrideRoutedEvent( RoutedEvent newRoutedEvent )
        {
            _routedEvent = newRoutedEvent; 
        }
 
        /// 
 
        ///     Returns a boolean flag indicating if or not this
        ///     RoutedEvent has been handled this far in the route 
        /// 
        /// 
        ///     Initially starts with a false value before routing
        ///     has begun 
        /// 
        /// 
        /// Critical - _flags is critical due to UserInitiated value. 
        /// PublicOK - in this function we're not setting UserInitiated - we're setting Handled.
        /// 
        public bool Handled
        {
            [SecurityCritical ]
            get 
            {
                return _flags[ HandledIndex ] ; 
            } 

            [SecurityCritical ] 
            set
            {
                if (_routedEvent == null)
                { 
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventArgsMustHaveRoutedEvent));
                } 
 

                if( TraceRoutedEvent.IsEnabled ) 
                {
                    TraceRoutedEvent.TraceActivityItem(
                                            TraceRoutedEvent.HandleEvent,
                                            value, 
                                            RoutedEvent.OwnerType.Name,
                                            RoutedEvent.Name, 
                                            this ); 
                }
 

                // Note: We need to allow the caller to change the handled value
                // from true to false.
                // 
                // We are concerned about scenarios where a child element
                // listens to a high-level event (such as TextInput) while a 
                // parent element listens tp a low-level event such as KeyDown. 
                // In these scenarios, we want the parent to not respond to the
                // KeyDown event, in deference to the child. 
                //
                // Internally we implement this by asking the parent to only
                // respond to KeyDown events if they have focus.  This works
                // around the problem and is an example of an unofficial 
                // protocol coordinating the two elements.
                // 
                // But we imagine that there will be some cases we miss or 
                // that third parties introduce.  For these cases, we expect
                // that the application author may need to mark the KeyDown 
                // as handled in the child, and then reset the event to
                // being unhandled after the parent, so that default processing
                // and promotion still occur.
                // 
                // For more information see the following task:
                // 20284: Input promotion breaks down when lower level input is intercepted 
 
                _flags[ HandledIndex ] = value;
 
            }
        }

        /// 
 
        ///     Returns Source object that raised the RoutedEvent
        /// 
 
        public object Source 
        {
            get {return _source;} 
            set
            {

                if (InvokingHandler && UserInitiated) 
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventCannotChangeWhileRouting));
 
                if (_routedEvent == null) 
                {
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventArgsMustHaveRoutedEvent)); 
                }


                object source = value ; 
                if (_source == null && _originalSource == null)
                { 
                    // Gets here when it is the first time that the source is set. 
                    // This implies that this is also the original source of the event
                    _source = _originalSource = source; 
                    OnSetSource(source);
                }
                else if (_source != source)
                { 
                    // This is the actiaon taken at all other times when the
                    // source is being set to a different value from what it was 
                    _source = source; 
                    OnSetSource(source);
                } 
            }
        }

        /// 
 
        ///     Changes the Source assocatied with these RoutedEventArgs
        /// 
 
        ///  
        ///     Only used internally.  Added to support cracking generic MouseButtonDown/Up events
        ///     into MouseLeft/RightButtonDown/Up events. 
        /// 
        /// 
        ///     The new object to associate as the source of these RoutedEventArgs
        ///  
        internal void OverrideSource( object source )
        { 
            _source = source; 
        }
 
        /// 

        ///     Returns OriginalSource object that raised the RoutedEvent
        /// 
        ///  
        ///     Always returns the OriginalSource object that raised the
        ///     RoutedEvent unlike  
        ///     that may vary under specific scenarios  
        ///     This property acquires its value once before the event
        ///     handlers are invoked and never changes then on 
        /// 
        public object OriginalSource
        {
            get {return _originalSource;} 
        }
 
        /// 
 
        ///     Invoked when the source of the event is set
        /// 
 
        /// 
        ///     Changing the source of an event can often
        ///     require updating the data within the event.
        ///     For this reason, the OnSource=  method is 
        ///     protected virtual and is meant to be
        ///     overridden by sub-classes of 
        ///       
        ///     Also see 
        ///  
        /// 
        ///     The new value that the SourceProperty is being set to
        /// 
        protected virtual void OnSetSource(object source) 
        {
        } 
 
        /// 

        ///     Invokes the generic handler with the 
        ///     appropriate arguments
        /// 
        /// 
        ///     Is meant to be overridden by sub-classes of 
        ///      to provide
        ///     more efficient invocation of their delegate 
        ///  
        /// 
        ///     Generic Handler to be invoked 
        /// 
        /// 
        ///     Target on whom the Handler will be invoked
        ///  
        protected virtual void InvokeEventHandler(Delegate genericHandler, object genericTarget)
        { 
            if (genericHandler == null) 
            {
                throw new ArgumentNullException("genericHandler"); 
            }

            if (genericTarget == null)
            { 
                throw new ArgumentNullException("genericTarget");
            } 
 
            if (_routedEvent == null)
            { 
                throw new InvalidOperationException(SR.Get(SRID.RoutedEventArgsMustHaveRoutedEvent));
            }

            InvokingHandler = true; 
            try
            { 
                if (genericHandler is RoutedEventHandler) 
                {
                    ((RoutedEventHandler)genericHandler)(genericTarget, this); 
                }
                else
                {
                    // Restricted Action - reflection permission required 
                    genericHandler.DynamicInvoke(new object[] {genericTarget, this});
                } 
            } 
            finally
            { 
                InvokingHandler = false;
            }

        } 

        #endregion External API 
 
        #region Operations
 
        // Calls the InvokeEventHandler protected
        // virtual method
        //
        // This method is needed because 
        // delegates are invoked from
        // RoutedEventHandler which is not a 
        // sub-class of RoutedEventArgs 
        // and hence cannot invoke protected
        // method RoutedEventArgs.FireEventHandler 
        internal void InvokeHandler(Delegate handler, object target)
        {
            InvokingHandler = true;
 
            try
            { 
                InvokeEventHandler(handler, target); 
            }
            finally 
            {
                InvokingHandler = false;
            }
        } 

        /// 
        ///     Critical - access critical information, if this is a user initiated command 
        ///     TreatAsSafe - checking user initiated bit considered safe.
        /// 
        internal bool UserInitiated
        {
            [SecurityCritical, SecurityTreatAsSafe ]
            [FriendAccessAllowed] // Also used by Framework. 
            get
            { 
                if (_flags [UserInitiatedIndex]) 
                {
                    return SecurityHelper.CallerHasUserInitiatedRoutedEventPermission(); 
                }
                return false;
            }
        } 

        ///  
        ///     Critical - access critical information, if this is a user initiated command 
        /// 
        [SecurityCritical] 
        internal void MarkAsUserInitiated()
        {
            _flags [ UserInitiatedIndex ] = true;
        } 

        ///  
        ///     Critical - access critical information, if this is a user initiated command 
        ///     TreatAsSafe - clearing user initiated bit considered safe.
        ///  
        [SecurityCritical, SecurityTreatAsSafe ]
        internal void ClearUserInitiated()
        {
            _flags [ UserInitiatedIndex ] = false ; 
        }
 
        /// 
        /// Critical - _flags is critical due to UserInitiated value.
        /// TreatAsSafe - in this function we're not setting UserInitiated - we're setting InvokingHandler. 
        ///
        private bool InvokingHandler
        {
            [SecurityCritical, SecurityTreatAsSafe ] 
            get
            { 
                return _flags[InvokingHandlerIndex]; 
            }
            [SecurityCritical, SecurityTreatAsSafe ] 
            set
            {
                _flags[InvokingHandlerIndex] = value;
            } 
        }
        #endregion Operations 
 

 
        #region Data

        private RoutedEvent _routedEvent;
        private object _source; 
        private object _originalSource;
 
        /// 
        /// Critical - the UserInitiated flag value is critical.
        /// 
        [SecurityCritical]
        private BitVector32          _flags;

        private const int HandledIndex                          = 1; 
        private const int UserInitiatedIndex                    = 2;
        private const int InvokingHandlerIndex                  = 4; 
 

        #endregion Data 
    }

    /// 

    ///     RoutedEventHandler Definition 
    /// 
    ///  
    public delegate void RoutedEventHandler(object sender, RoutedEventArgs e); 
}
 

// 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

• WebServiceHostFactory.cs
• CollectionViewGroup.cs
• DataTableClearEvent.cs
• UpdatePanelControlTrigger.cs
• HtmlToClrEventProxy.cs
• ProbeMatches11.cs
• DataGridViewComboBoxCell.cs
• BaseUriHelper.cs
• XmlElement.cs
• DataBinding.cs
• IconConverter.cs
• OracleBinary.cs
• XmlComment.cs
• HoistedLocals.cs
• DynamicActivityProperty.cs
• EventMap.cs
• XpsThumbnail.cs
• Fonts.cs
• EmptyImpersonationContext.cs
• DetailsViewPageEventArgs.cs
• EntityClientCacheKey.cs
• RealProxy.cs
• PixelShader.cs
• WindowsIdentity.cs
• NativeWrapper.cs
• RowCache.cs
• RelationshipEndCollection.cs
• SchemaLookupTable.cs
• EntryIndex.cs
• UserMapPath.cs
• ObjectPropertyMapping.cs
• UTF8Encoding.cs
• RayMeshGeometry3DHitTestResult.cs
• IISMapPath.cs
• ParseHttpDate.cs
• StaticTextPointer.cs
• Rule.cs
• DataSetMappper.cs
• DelegatingConfigHost.cs
• EllipticalNodeOperations.cs
• TrackingMemoryStreamFactory.cs
• EDesignUtil.cs
• CacheVirtualItemsEvent.cs
• DiscoveryInnerClientAdhoc11.cs
• FunctionNode.cs
• ConfigurationManagerInternal.cs
• DefaultTextStoreTextComposition.cs
• ControlCachePolicy.cs
• SByteConverter.cs
• EmptyWithCancelationCheckWorkItem.cs
• ReferenceSchema.cs
• _PooledStream.cs
• ImageClickEventArgs.cs
• MenuAdapter.cs
• MaskedTextProvider.cs
• CommandPlan.cs
• SoapAttributeAttribute.cs
• MetadataLocation.cs
• HostProtectionException.cs
• HtmlInputCheckBox.cs
• COM2ExtendedUITypeEditor.cs
• KnowledgeBase.cs
• ShapingEngine.cs
• Icon.cs
• QuotedStringWriteStateInfo.cs
• LocatorPart.cs
• XmlReaderDelegator.cs
• CodeEventReferenceExpression.cs
• TempFiles.cs
• EpmContentSerializerBase.cs
• SecurityValidationBehavior.cs
• Transform.cs
• Condition.cs
• XmlIncludeAttribute.cs
• BlockCollection.cs
• DataSourceView.cs
• PackageRelationship.cs
• DebugHandleTracker.cs
• XmlSchemaImport.cs
• CfgRule.cs
• _RequestCacheProtocol.cs
• TargetInvocationException.cs
• EditCommandColumn.cs
• PropertyChangingEventArgs.cs
• CLSCompliantAttribute.cs
• PagerSettings.cs
• EntityTemplateFactory.cs
• Confirm.cs
• GlyphRunDrawing.cs
• XmlAnyElementAttributes.cs
• XmlSortKey.cs
• Geometry3D.cs
• SourceFileInfo.cs
• SQLDecimal.cs
• KnownTypeDataContractResolver.cs
• Rotation3DKeyFrameCollection.cs
• serverconfig.cs
• SchemaImporter.cs
• ProcessRequestArgs.cs
• DoubleMinMaxAggregationOperator.cs