diff --git a/xml/System.ComponentModel.Design/IDesignerOptionService.xml b/xml/System.ComponentModel.Design/IDesignerOptionService.xml index 7f4e389ca96..3b994e40f63 100644 --- a/xml/System.ComponentModel.Design/IDesignerOptionService.xml +++ b/xml/System.ComponentModel.Design/IDesignerOptionService.xml @@ -163,7 +163,7 @@ [!NOTE] > The page and value names are always expected in English. Therefore, the following table is provided to help you access the options you want. diff --git a/xml/System.Globalization/IdnMapping.xml b/xml/System.Globalization/IdnMapping.xml index 57174bfc0c6..0176d16f136 100644 --- a/xml/System.Globalization/IdnMapping.xml +++ b/xml/System.Globalization/IdnMapping.xml @@ -43,8 +43,8 @@ > [!IMPORTANT] > In the [!INCLUDE[net_v45](~/includes/net-v45-md.md)], the class supports different versions of the IDNA standard, depending on the operating system in use: > -> - When run on [!INCLUDE[win8](~/includes/win8-md.md)], it supports the 2008 version of the IDNA standard outlined by [RFC 5891: Internationalized Domain Names in Applications (IDNA): Protocol](https://go.microsoft.com/fwlink/?LinkId=231875). -> - When run on earlier versions of the Windows operating system, it supports the 2003 version of the standard outlined by [RFC 3490: Internationalizing Domain Names in Applications (IDNA)](https://go.microsoft.com/fwlink/?LinkId=158110). +> - When run on [!INCLUDE[win8](~/includes/win8-md.md)], it supports the 2008 version of the IDNA standard outlined by [RFC 5891: Internationalized Domain Names in Applications (IDNA): Protocol](https://go.microsoft.com/fwlink/?LinkId=231875). +> - When run on earlier versions of the Windows operating system, it supports the 2003 version of the standard outlined by [RFC 3490: Internationalizing Domain Names in Applications (IDNA)](https://go.microsoft.com/fwlink/?LinkId=158110). > > See [Unicode Technical Standard #46: IDNA Compatibility Processing](https://go.microsoft.com/fwlink/?LinkId=232459) for the differences in the way these standards handle particular sets of characters. diff --git a/xml/System.Net.Configuration/ProxyElement.xml b/xml/System.Net.Configuration/ProxyElement.xml index 32e7e38b527..aea62500441 100644 --- a/xml/System.Net.Configuration/ProxyElement.xml +++ b/xml/System.Net.Configuration/ProxyElement.xml @@ -53,15 +53,7 @@ Initializes a new instance of the class. - - - + To be added. Network Settings Schema diff --git a/xml/System.Web.Services.Protocols/SoapExtension.xml b/xml/System.Web.Services.Protocols/SoapExtension.xml index 3a3c30c315f..bcb6c3088a6 100644 --- a/xml/System.Web.Services.Protocols/SoapExtension.xml +++ b/xml/System.Web.Services.Protocols/SoapExtension.xml @@ -258,19 +258,13 @@ - Class constructor - The class constructor is called every time a SOAP extension is instantiated and is typically used to initialize member variables. -- - , however, is called just once, the first time a SOAP request is made to an XML Web services method. If a custom attribute is applied to the XML Web service method, the method is invoked. This allows the SOAP extension to interrogate the of an XML Web service method for prototype information or to access extension-specific data passed by a class deriving from . The return value is cached by ASP.NET and passed into subsequent methods. Therefore, initialization done in is encapsulated essentially into a one-time performance hit. - -- - is called every time a SOAP request is made to an XML Web service method, but has an advantage over the class constructor, in that the initialized in is passed to it. +- - This method is called just once, the first time a SOAP request is made to an XML Web services method. If a custom attribute is applied to the XML Web service method, the method is invoked. This allows the SOAP extension to interrogate the of an XML Web service method for prototype information or to access extension-specific data passed by a class deriving from . The return value is cached by ASP.NET and passed into subsequent methods. Therefore, initialization done in is encapsulated essentially into a one-time performance hit. -- +- - This method is called every time a SOAP request is made to an XML Web service method, but has an advantage over the class constructor, in that the initialized in is passed to it. > [!NOTE] > You can also add a SOAP extension without deriving from by using the [\ Element](https://msdn.microsoft.com/library/7a373a98-6d82-4f8d-a6fc-2996da3fd54c) in a configuration file. For details, see [\ Element](https://msdn.microsoft.com/library/7a373a98-6d82-4f8d-a6fc-2996da3fd54c) and [SOAP Message Modification Using SOAP Extensions](https://msdn.microsoft.com/library/97d81ace-95e7-4acc-ae39-9692a0021e95). -- - - - ## Examples The following example demonstrates how you can use the data cached during the method. @@ -324,4 +318,4 @@ - \ No newline at end of file + diff --git a/xml/System.Windows.Documents/FixedPage.xml b/xml/System.Windows.Documents/FixedPage.xml index bfe0a886868..a2a0ce5df1a 100644 --- a/xml/System.Windows.Documents/FixedPage.xml +++ b/xml/System.Windows.Documents/FixedPage.xml @@ -364,18 +364,14 @@ - . must be greater than or equal to (.+1). - For rules about the relative sizes of the and the , see the topic . - -- - + ## Dependency Property Information ||| |-|-| -|- Identifier field|| -|Metadata properties set to `true`|- None| - -- +|Identifier field|| +|Metadata properties set to `true`|None| ]]> diff --git a/xml/System.Windows.Documents/Hyperlink.xml b/xml/System.Windows.Documents/Hyperlink.xml index 62288833cea..80cc02c1602 100644 --- a/xml/System.Windows.Documents/Hyperlink.xml +++ b/xml/System.Windows.Documents/Hyperlink.xml @@ -32,7 +32,7 @@ implements the property that you set with the of the content that should be navigated to when the Hyperlink is clicked. navigation can only occur, however, if either the direct or indirect parent of a is a navigation host, including , , or any browser that can host [!INCLUDE[TLA2#tla_xbap#plural](~/includes/tla2sharptla-xbapsharpplural-md.md)] (which includes [!INCLUDE[TLA2#tla_ie7](~/includes/tla2sharptla-ie7-md.md)], [!INCLUDE[TLA2#tla_ie6](~/includes/tla2sharptla-ie6-md.md)], and Firefox 2.0+). For more information, see the **Navigation Hosts** topic in [Navigation Overview](~/docs/framework/wpf/app-development/navigation-overview.md). + implements the property that you set with the of the content that should be navigated to when the Hyperlink is clicked. navigation can only occur, however, if either the direct or indirect parent of a is a navigation host, including , , or any browser that can host XBAPs (which includes Internet Explorer 6 and later versions, and Firefox 2.0+). For more information, see the **Navigation Hosts** topic in [Navigation Overview](~/docs/framework/wpf/app-development/navigation-overview.md). enforces a strong content model for child content. See [TextElement Content Model Overview](~/docs/framework/wpf/advanced/textelement-content-model-overview.md) for more information about the content model. @@ -569,10 +569,10 @@ System.Uri - Gets or sets a [!INCLUDE[TLA2#tla_uri](~/includes/tla2sharptla-uri-md.md)] to navigate to when the is activated. - The to navigate to when the is activated. The default is . + Gets or sets a URI to navigate to when the is activated. + The URI to navigate to when the is activated. The default is . - can navigate to the value of the property only if either the direct or indirect parent of a is a navigation host, including , , or any browser that can host [!INCLUDE[TLA2#tla_xbap#plural](~/includes/tla2sharptla-xbapsharpplural-md.md)] (which includes [!INCLUDE[TLA2#tla_ie7](~/includes/tla2sharptla-ie7-md.md)], [!INCLUDE[TLA2#tla_ie6](~/includes/tla2sharptla-ie6-md.md)], and Firefox 2.0+). For more information, see the **Navigation Hosts** section in [Navigation Overview](~/docs/framework/wpf/app-development/navigation-overview.md). + can navigate to the value of the property only if either the direct or indirect parent of a is a navigation host, including , , or any browser that can host XBAPs (which includes Internet Explorer 6 and later versions, and Firefox 2.0+). For more information, see the Navigation Hosts section in Navigation Overview. @@ -960,4 +960,4 @@ - \ No newline at end of file + diff --git a/xml/System.Windows.Documents/Typography.xml b/xml/System.Windows.Documents/Typography.xml index 4c9ec2c6f19..d09fbca3a50 100644 --- a/xml/System.Windows.Documents/Typography.xml +++ b/xml/System.Windows.Documents/Typography.xml @@ -85,7 +85,10 @@ Text using OpenType capitals |||`false`| || | | | | | |.| - All dependency properties of this class also have an attached property usage in [!INCLUDE[TLA2#tla_xaml](~/includes/tla2sharptla-xaml-md.md)]. For instance, you can set the property through this syntax: `<`*object*``**Typography.AnnotationAlternates**`="`*value*`".../>` + All dependency properties of this class also have an attached property usage in [!INCLUDE[TLA2#tla_xaml](~/includes/tla2sharptla-xaml-md.md)]. + For instance, you can set the property through this syntax: + + <*object* **Typography.AnnotationAlternates**="*`value`*" .../> @@ -5705,4 +5708,4 @@ Example of subscripts - \ No newline at end of file + diff --git a/xml/System.Windows.Media/PointCollection.xml b/xml/System.Windows.Media/PointCollection.xml index 0727bc445a5..61d06f16b4d 100644 --- a/xml/System.Windows.Media/PointCollection.xml +++ b/xml/System.Windows.Media/PointCollection.xml @@ -83,7 +83,7 @@ *oneOrMorePoints* One or more values, with each pair delimited by a single comma and/or one or more spaces. - *[delimiter* *]\** + _[delimiter__]\*_ For example, `"0,0 100,100 200,100"` and `"0,0,100,100,200,100"` are both valid. diff --git a/xml/System.Windows/ContentElement.xml b/xml/System.Windows/ContentElement.xml index f9896715749..658a0766e1a 100644 --- a/xml/System.Windows/ContentElement.xml +++ b/xml/System.Windows/ContentElement.xml @@ -4381,14 +4381,14 @@ The default implementation of this property caches the value and also calculates - Returns class-specific implementations for the [!INCLUDE[TLA#tla_winclient](~/includes/tlasharptla-winclient-md.md)] infrastructure. + Returns class-specific implementations for the Windows Presentation Foundation (WPF) infrastructure. The type-specific implementation. implementation, and return it as the return value. +The implementation of this method is typically to call the constructor of a specific implementation, and return it as the return value. All derived classes should implement this method in order to provide their own specific implementations to the WPF infrastructure. For details on implementing this pattern, see . @@ -4424,7 +4424,7 @@ The implementation of this method is typically to call the constructor of a spec ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -4461,7 +4461,7 @@ The implementation of this method is typically to call the constructor of a spec ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -4498,7 +4498,7 @@ The implementation of this method is typically to call the constructor of a spec ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -4535,7 +4535,7 @@ The implementation of this method is typically to call the constructor of a spec ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -4572,7 +4572,7 @@ The implementation of this method is typically to call the constructor of a spec ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -4614,7 +4614,7 @@ The implementation of this method is typically to call the constructor of a spec ## Remarks This method, although virtual, does have a default implementation that raises the event. - This On* method implementation is intended to raise the event, and this same method implementation is invoked internally to raise the event when the property value changes. The implementation differs from some other [!INCLUDE[TLA#tla_winclient](~/includes/tlasharptla-winclient-md.md)] On* implementations, which only provide a convenient way to add class handling for that event. + This On\* method implementation is intended to raise the event, and this same method implementation is invoked internally to raise the event when the property value changes. The implementation differs from some other Windows Presentation Foundation (WPF) On\* implementations, which only provide a convenient way to add class handling for that event. ## Notes to inheritors @@ -4655,7 +4655,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -4692,7 +4692,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -4729,7 +4729,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -5067,7 +5067,7 @@ Note that by default a is not foc This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -5106,7 +5106,7 @@ Note that by default a is not foc This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -5148,7 +5148,7 @@ Note that by default a is not foc ## Remarks This method, although virtual, does have a default implementation that raises the event. - This On* method implementation is intended to raise the event, and this same method implementation is invoked internally to raise the event when the property value changes. This implementation differs from some other [!INCLUDE[TLA#tla_winclient](~/includes/tlasharptla-winclient-md.md)] On* implementations, which only provide a convenient way to add class handling for that event. + This On\* method implementation is intended to raise the event, and this same method implementation is invoked internally to raise the event when the property value changes. This implementation differs from some other Windows Presentation Foundation (WPF) On\* implementations, which only provide a convenient way to add class handling for that event. ]]> @@ -5185,7 +5185,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -5222,7 +5222,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -5259,7 +5259,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -5331,11 +5331,11 @@ Note that by default a is not foc If you mark this event as handled in class handling, subevents are still raised; however, they pass the handled state in the event data. If the event is handled in class handling, instance handlers for the subevents are not invoked unless you explicitly use with `handledEventsToo` `true` in order to attach handlers. Class handlers also are not invoked unless those class handlers were registered with the signature with `handledEventsToo` `true`. By handling , you are implying that your class handling accounted for all possible mouse button down actions. This behavior might be unwanted; therefore, use caution when you use this virtual method to mark events as handled. - Each of the button-specific direct events also has a virtual On* method; consider whether overriding these button-specific class handlers might be more appropriate. + Each of the button-specific direct events also has a virtual On\* method; consider whether overriding these button-specific class handlers might be more appropriate. This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -5372,7 +5372,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. You may call base either before or after your special handling, depending on your requirements. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event, with a direct routing strategy. Marking the event as handled is still useful for preventing the typical instance handlers (those that do not specify `handledEventsToo`) from being invoked. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event, with a direct routing strategy. Marking the event as handled is still useful for preventing the typical instance handlers (those that do not specify `handledEventsToo`) from being invoked. ]]> @@ -5407,7 +5407,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. You may call base either before or after your special handling, depending on your requirements. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event, with a direct routing strategy. Marking the event as handled is still useful for preventing the typical instance handlers (those that do not specify `handledEventsToo`) from being invoked. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event, with a direct routing strategy. Marking the event as handled is still useful for preventing the typical instance handlers (those that do not specify `handledEventsToo`) from being invoked. ]]> @@ -5512,7 +5512,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -5623,11 +5623,11 @@ Note that by default a is not foc If you mark this event as handled in class handling, subevents are still raised; however, they pass the handled state in the event data. If the event is handled in class handling, instance handlers for the subevents are not invoked unless you explicitly use with `handledEventsToo` `true` in order to attach handlers. Class handlers also are not invoked unless those class handlers were registered with the signature with `handledEventsToo` `true`. By handling , you are implying that your class handling accounted for all possible mouse button up actions. This behavior might be unwanted; Therefore, use caution when you use this virtual method to mark events as handled. - Each of the button-specific direct events also has a virtual On* method; consider whether overriding these button-specific class handlers might be more appropriate. + Each of the button-specific direct events also has a virtual On\* method; consider whether overriding these button-specific class handlers might be more appropriate. This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -5663,7 +5663,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -5700,7 +5700,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -5737,7 +5737,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -5774,7 +5774,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -5811,7 +5811,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -5848,7 +5848,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -5885,7 +5885,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -5922,7 +5922,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -5959,7 +5959,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -5996,7 +5996,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6037,11 +6037,11 @@ Note that by default a is not foc If you mark this event as handled in class handling, subevents are still raised; however, they pass the handled state in the event data. If the event is handled in class handling, instance handlers for the subevents are not invoked unless you explicitly use with `handledEventsToo` `true` in order to attach handlers. Class handlers also are not invoked unless those class handlers were registered with the signature with `handledEventsToo` `true`. By handling , you are implying that your class handling accounted for all possible mouse button down actions. This behavior might be unwanted; Therefore, use caution when you use this virtual method to mark events as handled. - Each of the button-specific direct events also has a virtual On* method; consider whether overriding these button-specific class handlers might be more appropriate. + Each of the button-specific direct events also has a virtual On\* method; consider whether overriding these button-specific class handlers might be more appropriate. This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6148,7 +6148,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6259,11 +6259,11 @@ Note that by default a is not foc If you mark this event as handled in class handling, subevents are still raised; however, they pass the handled state in the event data. If the event is handled in class handling, instance handlers for the subevents are not invoked unless you explicitly use with `handledEventsToo` `true` in order to attach handlers. Class handlers also are not invoked unless those class handlers were registered with the signature with `handledEventsToo` `true`. By handling , you are implying that your class handling accounted for all possible mouse button up actions. This behavior might be unwanted; Therefore, use caution when you use this virtual method to mark events as handled. - Each of the button-specific direct events also has a virtual On* method; consider whether overriding these button-specific class handlers might be more appropriate. + Each of the button-specific direct events also has a virtual On\* method; consider whether overriding these button-specific class handlers might be more appropriate. This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -6300,7 +6300,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6337,7 +6337,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6374,7 +6374,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6411,7 +6411,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6448,7 +6448,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6485,7 +6485,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6522,7 +6522,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6559,7 +6559,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6596,7 +6596,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6633,7 +6633,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6670,7 +6670,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6707,7 +6707,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. Another scenario that is specifically for Preview events is to mark them handled so that the matching bubbling class handlers are not invoked. @@ -6838,7 +6838,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -6875,7 +6875,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -6912,7 +6912,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -6949,7 +6949,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -6986,7 +6986,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -7023,7 +7023,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. You may call base either before or after your special handling, depending on your requirements. - The purpose of this method is similar to [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. Marking the event as handled is still useful for preventing typical instance handlers (those that do not specify `handledEventsToo`) from being invoked. + The purpose of this method is similar to [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. Marking the event as handled is still useful for preventing typical instance handlers (those that do not specify `handledEventsToo`) from being invoked. ]]> @@ -7058,7 +7058,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -7095,7 +7095,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -7132,7 +7132,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. You may call base either before or after your special handling, depending on your requirements. - The purpose of this method is similar to [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. Marking the event as handled is still useful for preventing typical instance handlers (those that do not specify `handledEventsToo`) from being invoked. + The purpose of this method is similar to [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. Marking the event as handled is still useful for preventing typical instance handlers (those that do not specify `handledEventsToo`) from being invoked. ]]> @@ -7167,7 +7167,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -7204,7 +7204,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -7241,7 +7241,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -7278,7 +7278,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. @@ -7315,7 +7315,7 @@ Note that by default a is not foc ## Remarks This method has no default implementation. Because an intermediate class in the inheritance might implement this method, we recommend that you call the base implementation in your implementation. - The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. + The purpose of this method is similar to the [!INCLUDE[TLA#tla_clr](~/includes/tlasharptla-clr-md.md)] event pattern On\* methods: this method provides the means to handle the matching event from derived classes by establishing a class handler instead of an instance handler. In this case the matching event is a routed event. The implementation pattern of the On\* methods is different for routed events because a routed event can be raised by a child element, which is not necessarily the element that will invoke handlers. Therefore, your implementation needs to examine the source properties of the event data. It should not try to reraise the event in most cases. Either by overriding this method or by registering class handlers with , derived classes of can call private class handler methods when the event is received along the event route. One scenario where class handling is appropriate is to manipulate the event data and mark the routed event as handled. diff --git a/xml/System.Xml/XmlNodeChangedEventArgs.xml b/xml/System.Xml/XmlNodeChangedEventArgs.xml index 1cd0ec672ca..6c49bbea7a7 100644 --- a/xml/System.Xml/XmlNodeChangedEventArgs.xml +++ b/xml/System.Xml/XmlNodeChangedEventArgs.xml @@ -152,28 +152,7 @@ void NodeInsertedHandler(Object src, XmlNodeChangedEventArgs args) Gets a value indicating what type of node change event is occurring. - An value describing the node change event. - - XmlNodeChangedAction Value - - Description - - Insert - - A node has been or will be inserted. - - Remove - - A node has been or will be removed. - - Change - - A node has been or will be changed. - - - The value does not differentiate between when the event occurred (before or after). You can create separate event handlers to handle both instances. - - + One of the enumeration values that describes the node change event. The value does not differentiate between when the event occurred (before or after). You can create separate event handlers to handle both instances. To be added.