diff --git a/.openpublishing.redirection.json b/.openpublishing.redirection.json
index 2ea2fcc..a208fdb 100644
--- a/.openpublishing.redirection.json
+++ b/.openpublishing.redirection.json
@@ -604,6 +604,14 @@
{
"source_path": "dotnet-desktop-guide/framework/wpf/properties/xaml-loading-and-dependency-properties.md",
"redirect_url": "/dotnet/desktop/wpf/advanced/xaml-loading-and-dependency-properties?view=netframeworkdesktop-4.8"
+ },
+ {
+ "source_path": "dotnet-desktop-guide/net/wpf/advanced/how-to-add-an-event-handler-using-code.md",
+ "redirect_url": "/dotnet/desktop/wpf/events/how-to-add-an-event-handler-using-code?view=netdesktop-6.0"
+ },
+ {
+ "source_path": "dotnet-desktop-guide/framework/wpf/events/how-to-add-an-event-handler-using-code.md",
+ "redirect_url": "/dotnet/desktop/wpf/advanced/how-to-add-an-event-handler-using-code?view=netframeworkdesktop-4.8"
}
]
}
diff --git a/dotnet-desktop-guide/framework/wpf/advanced/xaml-syntax-in-detail.md b/dotnet-desktop-guide/framework/wpf/advanced/xaml-syntax-in-detail.md
index 7bc0475..3d30cea 100644
--- a/dotnet-desktop-guide/framework/wpf/advanced/xaml-syntax-in-detail.md
+++ b/dotnet-desktop-guide/framework/wpf/advanced/xaml-syntax-in-detail.md
@@ -36,39 +36,9 @@ ms.assetid: 67cce290-ca26-4c41-a797-b68aabc45479
This topic defines the terms that are used to describe the elements of XAML syntax. These terms are used frequently throughout the remainder of this documentation, both for WPF documentation specifically and for the other frameworks that use XAML or the basic XAML concepts enabled by the XAML language support at the System.Xaml level. This topic expands on the basic terminology introduced in the topic [XAML in WPF](xaml-in-wpf.md).
-This topic defines the terms that are used to describe the elements of XAML syntax. These terms are used frequently throughout the remainder of this documentation, both for WPF documentation specifically and for the other frameworks that use XAML or the basic XAML concepts enabled by the XAML language support at the System.Xaml level. This topic expands on the basic terminology introduced in the topic [XAML Overview (WPF)](/dotnet/desktop-wpf/fundamentals/xaml).
-
-## The XAML Language Specification
-
-The XAML syntax terminology defined here is also defined or referenced within the XAML language specification. XAML is a language based on XML and follows or expands upon XML structural rules. Some of the terminology is shared from or is based on the terminology commonly used when describing the XML language or the XML document object model.
-
-For more information about the XAML language specification, download [\[MS-XAML\]](https://download.microsoft.com/download/0/A/6/0A6F7755-9AF5-448B-907D-13985ACCF53E/[MS-XAML].pdf) from the Microsoft Download Center.
-
-## XAML and CLR
-
-XAML is a markup language. The common language runtime (CLR), as implied by its name, enables runtime execution. XAML is not by itself one of the common languages that is directly consumed by the CLR runtime. Instead, you can think of XAML as supporting its own type system. The particular XAML parsing system that is used by WPF is built on the CLR and the CLR type system. XAML types are mapped to CLR types to instantiate a run time representation when the XAML for WPF is parsed. For this reason, the remainder of discussion of syntax in this document will include references to the CLR type system, even though the equivalent syntax discussions in the XAML language specification do not. (Per the XAML language specification level, XAML types could be mapped to any other type system, which does not have to be the CLR, but that would require the creation and use of a different XAML parser.)
-
-### Members of Types and Class Inheritance
-
-Properties and events as they appear as XAML members of a [!INCLUDE[TLA2#tla_winclient](../../../includes/tla2sharptla-winclient-md.md)] type are often inherited from base types. For example, consider this example: ``. The property is not an immediately declared property on the class, if you were to look at the class definition, reflection results, or the documentation. Instead, is inherited from the base class.
-
-The class inheritance behavior of [!INCLUDE[TLA2#tla_winclient](../../../includes/tla2sharptla-winclient-md.md)] XAML elements is a significant departure from a schema-enforced interpretation of XML markup. Class inheritance can become complex, particularly when intermediate base classes are abstract, or when interfaces are involved. This is one reason that the set of XAML elements and their permissible attributes is difficult to represent accurately and completely using the schema types that are typically used for XML programming, such as DTD or XSD format. Another reason is that extensibility and type-mapping features of the XAML language itself preclude completeness of any fixed representation of the permissible types and members.
-
-## Object Element Syntax
-
-*Object element syntax* is the XAML markup syntax that instantiates a CLR class or structure by declaring an XML element. This syntax resembles the element syntax of other markup languages such as HTML. Object element syntax begins with a left angle bracket (\<), followed immediately by the type name of the class or structure being instantiated. Zero or more spaces can follow the type name, and zero or more attributes may also be declared on the object element, with one or more spaces separating each attribute name="value" pair. Finally, one of the following must be true:
-
-- The element and tag must be closed by a forward slash (/) followed immediately by a right angle bracket (>).
-
-- The opening tag must be completed by a right angle bracket (>). Other object elements, property elements, or inner text, can follow the opening tag. Exactly what content may be contained here is typically constrained by the object model of the element. The equivalent closing tag for the object element must also exist, in proper nesting and balance with other opening and closing tag pairs.
-
-XAML as implemented by .NET has a set of rules that map object elements into types, attributes into properties or events, and XAML namespaces to CLR namespaces plus assembly. For WPF and .NET, XAML object elements map to .NET types as defined in referenced assemblies, and the attributes map to members of those types. When you reference a CLR type in XAML, you have access to the inherited members of that type as well.
-
-For example, the following example is object element syntax that instantiates a new instance of the class, and also specifies a attribute and a value for that attribute:
-
-[!code-xaml[XAMLOvwSupport#SyntaxOE](~/samples/snippets/csharp/VS_Snippets_Wpf/XAMLOvwSupport/CSharp/Page1.xaml#syntaxoe)]
-
-The following example is object element syntax that also includes XAML content property syntax. The inner text contained within will be used to set the XAML content property, .
+
+## The XAML Language Specification
+ The XAML syntax terminology defined here is also defined or referenced within the XAML language specification. XAML is a language based on XML and follows or expands upon XML structural rules. Some of the terminology is shared from or is based on the terminology commonly used when describing the XML language or the XML document object model.
For more information about the XAML language specification, download [\[MS-XAML\]](https://download.microsoft.com/download/0/A/6/0A6F7755-9AF5-448B-907D-13985ACCF53E/[MS-XAML].pdf) from the Microsoft Download Center.
@@ -112,20 +82,6 @@ The following example is object element syntax that also includes XAML content p
## Attribute Syntax (Properties)
Attribute syntax is the XAML markup syntax that sets a value for a property by declaring an attribute on an existing object element. The attribute name must match the CLR member name of the property of the class that backs the relevant object element. The attribute name is followed by an assignment operator (=). The attribute value must be a string enclosed within quotes.
-### Content Models
-
-A class might support a usage as a XAML object element in terms of the syntax, but that element will only function properly in an application or page when it is placed in an expected position of an overall content model or element tree. For example, a should typically only be placed as a child of a derived class such as . Content models for specific elements are documented as part of the remarks on the class pages for controls and other [!INCLUDE[TLA2#tla_winclient](../../../includes/tla2sharptla-winclient-md.md)] classes that can be used as XAML elements.
-
-## Properties of Object Elements
-
-Properties in XAML are set by a variety of possible syntaxes. Which syntax can be used for a particular property will vary, based on the underlying type system characteristics of the property that you are setting.
-
-By setting values of properties, you add features or characteristics to objects as they exist in the run time object graph. The initial state of the created object from a object element is based on the parameterless constructor behavior. Typically, your application will use something other than a completely default instance of any given object.
-
-## Attribute Syntax (Properties)
-
-Attribute syntax is the XAML markup syntax that sets a value for a property by declaring an attribute on an existing object element. The attribute name must match the CLR member name of the property of the class that backs the relevant object element. The attribute name is followed by an assignment operator (=). The attribute value must be a string enclosed within quotes.
-
> [!NOTE]
> You can use alternating quotes to place a literal quotation mark within an attribute. For instance you can use single quotes as a means to declare a string that contains a double quote character within it. Whether you use single or double quotes, you should use a matching pair for opening and closing the attribute value string. There are also escape sequences or other techniques available for working around character restrictions imposed by any particular XAML syntax. See [XML Character Entities and XAML](/dotnet/desktop/xaml-services/xml-character-entities).
@@ -210,36 +166,35 @@ Attribute syntax is the XAML markup syntax that sets a value for a property by d
An implicit collection element creates a member in the logical tree representation, even though it does not appear in the markup as an element. Usually the constructor of the parent type performs the instantiation for the collection that is one of its properties, and the initially empty collection becomes part of the object tree.
> [!NOTE]
-> The generic list and dictionary interfaces ( and ) are not supported for collection detection. However, you can use the class as a base class, because it implements directly, or as a base class, because it implements directly.
-
-In the .NET Reference pages for collection types, this syntax with the deliberate omission of the object element for a collection is occasionally noted in the XAML syntax sections as Implicit Collection Syntax.
-
-With the exception of the root element, every object element in a XAML file that is nested as a child element of another element is really an element that is one or both of the following cases: a member of an implicit collection property of its parent element, or an element that specifies the value of the XAML content property for the parent element (XAML content properties will be discussed in an upcoming section). In other words, the relationship of parent elements and child elements in a markup page is really a single object at the root, and every object element beneath the root is either a single instance that provides a property value of the parent, or one of the items within a collection that is also a collection-type property value of the parent. This single-root concept is common with XML, and is frequently reinforced in the behavior of APIs that load XAML such as .
-
-The following example is a syntax with the object element for a collection () specified explicitly.
-
-```xaml
-
-
-
-
-
-
-
-
-```
-
-Note that it is not always possible to explicitly declare the collection. For instance, attempting to declare explicitly in the previously shown example would fail. Explicitly declaring the collection requires that the collection class must support a parameterless constructor, and does not have a parameterless constructor.
-
-## XAML Content Properties
-
-XAML content syntax is a syntax that is only enabled on classes that specify the as part of their class declaration. The references the property name that is the content property for that type of element (including derived classes). When processed by a XAML processor, any child elements or inner text that are found between the opening and closing tags of the object element will be assigned to be the value of the XAML content property for that object. You are permitted to specify explicit property elements for the content property, but this usage is not generally shown in the XAML syntax sections in the .NET reference. The explicit/verbose technique has occasional value for markup clarity or as a matter of markup style, but usually the intent of a content property is to streamline the markup so that elements that are intuitively related as parent-child can be nested directly. Property element tags for other properties on an element are not assigned as "content" per a strict XAML language definition; they are processed previously in the XAML parser's processing order and are not considered to be "content".
-
-### XAML Content Property Values Must Be Contiguous
-
-The value of a XAML content property must be given either entirely before or entirely after any other property elements on that object element. This is true whether the value of a XAML content property is specified as a string, or as one or more objects. For example, the following markup does not parse:
-
-```xaml
+> The generic list and dictionary interfaces ( and ) are not supported for collection detection. However, you can use the class as a base class, because it implements directly, or as a base class, because it implements directly.
+
+ In the .NET Reference pages for collection types, this syntax with the deliberate omission of the object element for a collection is occasionally noted in the XAML syntax sections as Implicit Collection Syntax.
+
+ With the exception of the root element, every object element in a XAML file that is nested as a child element of another element is really an element that is one or both of the following cases: a member of an implicit collection property of its parent element, or an element that specifies the value of the XAML content property for the parent element (XAML content properties will be discussed in an upcoming section). In other words, the relationship of parent elements and child elements in a markup page is really a single object at the root, and every object element beneath the root is either a single instance that provides a property value of the parent, or one of the items within a collection that is also a collection-type property value of the parent. This single-root concept is common with XML, and is frequently reinforced in the behavior of APIs that load XAML such as .
+
+ The following example is a syntax with the object element for a collection () specified explicitly.
+
+```xaml
+
+
+
+
+
+
+
+
+```
+
+ Note that it is not always possible to explicitly declare the collection. For instance, attempting to declare explicitly in the previously shown example would fail. Explicitly declaring the collection requires that the collection class must support a parameterless constructor, and does not have a parameterless constructor.
+
+
+## XAML Content Properties
+ XAML content syntax is a syntax that is only enabled on classes that specify the as part of their class declaration. The references the property name that is the content property for that type of element (including derived classes). When processed by a XAML processor, any child elements or inner text that are found between the opening and closing tags of the object element will be assigned to be the value of the XAML content property for that object. You are permitted to specify explicit property elements for the content property, but this usage is not generally shown in the XAML syntax sections in the .NET reference. The explicit/verbose technique has occasional value for markup clarity or as a matter of markup style, but usually the intent of a content property is to streamline the markup so that elements that are intuitively related as parent-child can be nested directly. Property element tags for other properties on an element are not assigned as "content" per a strict XAML language definition; they are processed previously in the XAML parser's processing order and are not considered to be "content".
+
+### XAML Content Property Values Must Be Contiguous
+ The value of a XAML content property must be given either entirely before or entirely after any other property elements on that object element. This is true whether the value of a XAML content property is specified as a string, or as one or more objects. For example, the following markup does not parse:
+
+```xaml
diff --git a/dotnet-desktop-guide/net/wpf/events/how-to-add-an-event-handler-using-code.md b/dotnet-desktop-guide/net/wpf/events/how-to-add-an-event-handler-using-code.md
new file mode 100644
index 0000000..4bc9094
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/how-to-add-an-event-handler-using-code.md
@@ -0,0 +1,76 @@
+---
+title: "How to add an event handler using code"
+description: Learn how to add an event handler in code-behind for an element in Windows Presentation Foundation (WPF).
+ms.date: "02/01/2021"
+dev_langs:
+ - "csharp"
+ - "vb"
+helpviewer_keywords:
+ - "event handlers [WPF], adding"
+ - "XAML [WPF], adding event handlers"
+---
+
+
+# How to add an event handler using code (WPF .NET)
+
+You can assign an event handler to an element in Windows Presentation Foundation (WPF) using markup or code-behind. Although it's customary to assign an event handler in Extensible Application Markup Language (XAML), sometimes you might have to assign an event handler in code-behind. For instance, use code when:
+
+- You assign an event handler to an element after the markup page that contains the element loads.
+- You add an element and assign its event handler after the markup page that will contain the element loads.
+- You define the element tree for your application entirely in code.
+
+[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
+
+## Syntax for event handler assignment
+
+C# supports event handler assignment using:
+
+- The `+=` operator, which is also used in the common language runtime (CLR) event handling model.
+- The method.
+
+VB supports event handler assignment using:
+
+- The [AddHandler](/dotnet/visual-basic/language-reference/statements/addhandler-statement) statement with the [AddressOf](/dotnet/visual-basic/language-reference/operators/addressof-operator) operator, which is also used in the CLR event handling model.
+- The [Handles](/dotnet/visual-basic/language-reference/statements/handles-clause) keyword in the event handler definition. For more information, see [Visual Basic and WPF event handling](/dotnet/desktop/wpf/advanced/visual-basic-and-wpf-event-handling?view=netframeworkdesktop-4.8&preserve-view=true).
+- The method, together with the `AddressOf` operator to reference the event handler.
+
+## Example
+
+The following example uses XAML to define a named `ButtonCreatedByXaml` and to assign the `ButtonCreatedByXaml_Click` method as its event handler. `Click` is a built-in routed event for buttons that derive from .
+
+:::code language="xaml" source="./snippets/how-to-add-an-event-handler-using-code/csharp/MainWindow.xaml" id="ButtonCreatedByXaml":::
+
+The example uses code-behind to implement the `ButtonCreatedByXaml_Click` and `ButtonCreatedByCode_Click` handlers, and to assign the `ButtonCreatedByCode_Click` handler to the `ButtonCreatedByCode` and `StackPanel1` elements. Event handler methods can only be implemented in code-behind.
+
+:::code language="csharp" source="./snippets/how-to-add-an-event-handler-using-code/csharp/MainWindow.xaml.cs" id="ButtonEventHandlers":::
+:::code language="vb" source="./snippets/how-to-add-an-event-handler-using-code/vb/MainWindow.xaml.vb" id="ButtonEventHandlers":::
+
+When `ButtonCreatedByXaml` is clicked and its event handler runs, `ButtonCreatedByXaml_Click` programmatically:
+
+1. Adds a new button named `ButtonCreatedByCode` to the already constructed XAML element tree.
+1. Specifies properties for the new button, such as the name, content, and background color.
+1. Assigns the `ButtonCreatedByCode_Click` event handler to `ButtonCreatedByCode`.
+1. Assigns the same `ButtonCreatedByCode_Click` event handler to `StackPanel1`.
+
+When `ButtonCreatedByCode` is clicked:
+
+1. The routed event is raised on `ButtonCreatedByCode`.
+1. The `ButtonCreatedByCode_Click` event handler assigned to `ButtonCreatedByCode` is triggered.
+1. The `Click` routed event traverses up the element tree to `StackPanel1`.
+1. The `ButtonCreatedByCode_Click` event handler assigned to `StackPanel1` is triggered.
+1. The `Click` routed event continues up the element tree potentially triggering other `Click` event handlers assigned to other traversed elements.
+
+The `ButtonCreatedByCode_Click` event handler obtains the following information about the event that triggered it:
+
+- The [sender](xref:System.Windows.RoutedEventHandler) object, which is the element that the event handler is assigned to. The `sender` will be `ButtonCreatedByCode` the first time the handler runs, and `StackPanel1` the second time.
+- The object, which is the element that originally raised the event. In this example, the `Source` is always `ButtonCreatedByCode`.
+
+> [!NOTE]
+> A key difference between a routed event and a CLR event is that a routed event traverses the element tree, whereas a CLR event occurs only on the `sender`. As a result, a routed event `sender` can be any traversed element in the element tree.
+
+For more information on how to create and handle routed events, see [How to create a custom routed event](/dotnet/desktop/wpf/advanced/how-to-create-a-custom-routed-event?view=netframeworkdesktop-4.8&preserve-view=true) and [Handle a routed event](/dotnet/desktop/wpf/advanced/how-to-handle-a-routed-event?view=netframeworkdesktop-4.8&preserve-view=true).
+
+## See also
+
+- [Routed events overview](/dotnet/desktop/wpf/advanced/routed-events-overview?view=netframeworkdesktop-4.8&preserve-view=true)
+- [XAML in WPF](/dotnet/desktop/wpf/advanced/xaml-in-wpf?view=netframeworkdesktop-4.8&preserve-view=true)
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/App.xaml.cs b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/App.xaml.cs
new file mode 100644
index 0000000..3128552
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/App.xaml.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+
+namespace CodeSampleCsharp
+{
+ ///
+ /// Interaction logic for App.xaml
+ ///
+ public partial class App : Application
+ {
+ }
+}
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/AssemblyInfo.cs b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/AssemblyInfo.cs
new file mode 100644
index 0000000..8b5504e
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/AssemblyInfo.cs
@@ -0,0 +1,10 @@
+using System.Windows;
+
+[assembly: ThemeInfo(
+ ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
+ //(used if a resource is not found in the page,
+ // or application resource dictionaries)
+ ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
+ //(used if a resource is not found in the page,
+ // app, or any theme specific resource dictionaries)
+)]
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/CodeSampleCsharp.csproj b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/CodeSampleCsharp.csproj
new file mode 100644
index 0000000..5621ca9
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/CodeSampleCsharp.csproj
@@ -0,0 +1,25 @@
+
+
+
+ WinExe
+ net6.0-windows
+ true
+ en-us
+
+
+
+
+ True
+ True
+ Resources.resx
+
+
+
+
+
+ ResXFileCodeGenerator
+ Resources.Designer.cs
+
+
+
+
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/MainWindow.xaml b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/MainWindow.xaml
new file mode 100644
index 0000000..0b1f7b6
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/MainWindow.xaml
@@ -0,0 +1,16 @@
+
+
+
+
+
+
+
+
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/MainWindow.xaml.cs b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/MainWindow.xaml.cs
new file mode 100644
index 0000000..2b96682
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/MainWindow.xaml.cs
@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Media;
+
+namespace CodeSampleCsharp
+{
+ ///
+ /// Interaction logic for MainWindow.xaml.
+ ///
+ public partial class MainWindow : Window
+ {
+ public MainWindow()
+ {
+ InitializeComponent();
+ }
+
+ //
+ // The click event handler for the existing button 'ButtonCreatedByXaml'.
+ private void ButtonCreatedByXaml_Click(object sender, RoutedEventArgs e)
+ {
+ // Create a new button.
+ Button ButtonCreatedByCode = new();
+
+ // Specify button properties.
+ ButtonCreatedByCode.Name = "ButtonCreatedByCode";
+ ButtonCreatedByCode.Content = "New button and event handler created in code";
+ ButtonCreatedByCode.Background = Brushes.Yellow;
+
+ // Add the new button to the StackPanel.
+ StackPanel1.Children.Add(ButtonCreatedByCode);
+
+ // Assign an event handler to the new button using the '+=' operator.
+ ButtonCreatedByCode.Click += new RoutedEventHandler(ButtonCreatedByCode_Click);
+
+ // Assign an event handler to the new button using the AddHandler method.
+ // AddHandler(ButtonBase.ClickEvent, new RoutedEventHandler(ButtonCreatedByCode_Click);
+
+ // Assign an event handler to the StackPanel using the AddHandler method.
+ StackPanel1.AddHandler(ButtonBase.ClickEvent, new RoutedEventHandler(ButtonCreatedByCode_Click));
+ }
+
+ // The Click event handler for the new button 'ButtonCreatedByCode'.
+ private void ButtonCreatedByCode_Click(object sender, RoutedEventArgs e)
+ {
+ string sourceName = ((FrameworkElement)e.Source).Name;
+ string senderName = ((FrameworkElement)sender).Name;
+
+ Debug.WriteLine($"Routed event handler attached to {senderName}, " +
+ $"triggered by the Click routed event raised by {sourceName}.");
+ }
+ //
+
+ // Debug output when ButtonCreatedByCode is clicked:
+ // Routed event handler attached to ButtonCreatedByCode, triggered by the Click routed event raised by ButtonCreatedByCode.
+ // Routed event handler attached to StackPanel1, triggered by the Click routed event raised by ButtonCreatedByCode.
+ }
+}
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/Properties/Resources.Designer.cs b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/Properties/Resources.Designer.cs
new file mode 100644
index 0000000..64552f9
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/Properties/Resources.Designer.cs
@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by a tool.
+// Runtime Version:4.0.30319.42000
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+//------------------------------------------------------------------------------
+
+namespace CodeSampleCsharp.Properties {
+ using System;
+
+
+ ///
+ /// A strongly-typed resource class, for looking up localized strings, etc.
+ ///
+ // This class was auto-generated by the StronglyTypedResourceBuilder
+ // class via a tool like ResGen or Visual Studio.
+ // To add or remove a member, edit your .ResX file then rerun ResGen
+ // with the /str option, or rebuild your VS project.
+ [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+ internal class Resources {
+
+ private static global::System.Resources.ResourceManager resourceMan;
+
+ private static global::System.Globalization.CultureInfo resourceCulture;
+
+ [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+ internal Resources() {
+ }
+
+ ///
+ /// Returns the cached ResourceManager instance used by this class.
+ ///
+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+ internal static global::System.Resources.ResourceManager ResourceManager {
+ get {
+ if (object.ReferenceEquals(resourceMan, null)) {
+ global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("CodeSampleCsharp.Properties.Resources", typeof(Resources).Assembly);
+ resourceMan = temp;
+ }
+ return resourceMan;
+ }
+ }
+
+ ///
+ /// Overrides the current thread's CurrentUICulture property for all
+ /// resource lookups using this strongly typed resource class.
+ ///
+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+ internal static global::System.Globalization.CultureInfo Culture {
+ get {
+ return resourceCulture;
+ }
+ set {
+ resourceCulture = value;
+ }
+ }
+ }
+}
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/Properties/Resources.resx b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/Properties/Resources.resx
new file mode 100644
index 0000000..1af7de1
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/Properties/Resources.resx
@@ -0,0 +1,120 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
\ No newline at end of file
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/app.xaml b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/app.xaml
new file mode 100644
index 0000000..867d2f0
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/csharp/app.xaml
@@ -0,0 +1,9 @@
+
+
+
+
+
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/Application.xaml b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/Application.xaml
new file mode 100644
index 0000000..f225972
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/Application.xaml
@@ -0,0 +1,9 @@
+
+
+
+
+
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/Application.xaml.vb b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/Application.xaml.vb
new file mode 100644
index 0000000..084cbe9
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/Application.xaml.vb
@@ -0,0 +1,6 @@
+Class Application
+
+ ' Application-level events, such as Startup, Exit, and DispatcherUnhandledException
+ ' can be handled in this file.
+
+End Class
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/AssemblyInfo.vb b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/AssemblyInfo.vb
new file mode 100644
index 0000000..025ee72
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/AssemblyInfo.vb
@@ -0,0 +1,11 @@
+Imports System.Windows
+
+'The ThemeInfo attribute describes where any theme specific and generic resource dictionaries can be found.
+'1st parameter: where theme specific resource dictionaries are located
+'(used if a resource is not found in the page,
+' or application resource dictionaries)
+
+'2nd parameter: where the generic resource dictionary is located
+'(used if a resource is not found in the page,
+'app, and any theme specific resource dictionaries)
+
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/CodeSampleVb.vbproj b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/CodeSampleVb.vbproj
new file mode 100644
index 0000000..90d032b
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/CodeSampleVb.vbproj
@@ -0,0 +1,23 @@
+
+
+
+ WinExe
+ net6.0-windows
+ CodeSampleVb
+ en-us
+ true
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/MainWindow.xaml b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/MainWindow.xaml
new file mode 100644
index 0000000..f125d1b
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/MainWindow.xaml
@@ -0,0 +1,16 @@
+
+
+
+
+
+
+
+
diff --git a/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/MainWindow.xaml.vb b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/MainWindow.xaml.vb
new file mode 100644
index 0000000..0fccfa5
--- /dev/null
+++ b/dotnet-desktop-guide/net/wpf/events/snippets/how-to-add-an-event-handler-using-code/vb/MainWindow.xaml.vb
@@ -0,0 +1,57 @@
+Imports System.Windows.Controls.Primitives
+
+Namespace CodeSampleVb
+
+ '
+ ' Interaction logic for MainWindow.xaml.
+ '
+ Partial Public Class MainWindow
+ Inherits Window
+
+ Public Sub New()
+ InitializeComponent()
+ End Sub
+
+ '
+ ' The click event handler for the existing button 'ButtonCreatedByXaml'.
+ Private Sub ButtonCreatedByXaml_Click(sender As Object, e As RoutedEventArgs)
+
+ ' Create a new button and specify button properties.
+ Dim ButtonCreatedByCode As New Button With {
+ .Name = "ButtonCreatedByCode",
+ .Content = "New button and event handler created in code",
+ .Background = Brushes.Yellow
+ }
+
+ ' Add the new button to the StackPanel.
+ StackPanel1.Children.Add(ButtonCreatedByCode)
+
+ ' Assign an event handler to the new button using the AddHandler statement.
+ AddHandler ButtonCreatedByCode.Click, AddressOf ButtonCreatedByCode_Click
+
+ ' Assign an event handler to the new button using the AddHandler method.
+ ' ButtonCreatedByCode.AddHandler(ButtonBase.ClickEvent, New RoutedEventHandler(AddressOf ButtonCreatedByCode_Click))
+
+ ' Assign an event handler to the StackPanel using the AddHandler method.
+ StackPanel1.AddHandler(ButtonBase.ClickEvent, New RoutedEventHandler(AddressOf ButtonCreatedByCode_Click))
+
+ End Sub
+
+ ' The Click event handler for the new button 'ButtonCreatedByCode'.
+ Private Sub ButtonCreatedByCode_Click(sender As Object, e As RoutedEventArgs)
+
+ Dim sourceName As String = CType(e.Source, FrameworkElement).Name
+ Dim senderName As String = CType(sender, FrameworkElement).Name
+
+ Debug.WriteLine($"Routed event handler attached to {senderName}, " +
+ $"triggered by the Click routed event raised by {sourceName}.")
+
+ End Sub
+ '
+
+ ' Debug output when ButtonCreatedByCode is clicked:
+ ' Routed event handler attached to ButtonCreatedByCode, triggered by the Click routed event raised by ButtonCreatedByCode.
+ ' Routed event handler attached to StackPanel1, triggered by the Click routed event raised by ButtonCreatedByCode.
+ End Class
+
+End Namespace
diff --git a/dotnet-desktop-guide/net/wpf/toc.yml b/dotnet-desktop-guide/net/wpf/toc.yml
index 9e69465..d6e19dc 100644
--- a/dotnet-desktop-guide/net/wpf/toc.yml
+++ b/dotnet-desktop-guide/net/wpf/toc.yml
@@ -78,6 +78,12 @@ items:
- name: Systems
expanded: true
items:
+ - name: Events
+ items:
+ - name: Common tasks
+ items:
+ - name: Add an event handler using code
+ href: events/how-to-add-an-event-handler-using-code.md
- name: Properties
items:
- name: Dependency properties
diff --git a/redirects_generator/definitions.json b/redirects_generator/definitions.json
index df0732d..031c6aa 100644
--- a/redirects_generator/definitions.json
+++ b/redirects_generator/definitions.json
@@ -327,6 +327,13 @@
"TargetUrl": "/dotnet/desktop/wpf/documents/how-to-print-xps-files?view=netdesktop-6.0"
},
+ // Systems - Events
+ {
+ "Redirect": "TwoWay",
+ "SourceUrl": "/dotnet/desktop/wpf/advanced/how-to-add-an-event-handler-using-code?view=netframeworkdesktop-4.8",
+ "TargetUrl": "/dotnet/desktop/wpf/events/how-to-add-an-event-handler-using-code?view=netdesktop-6.0"
+ },
+
// Systems - Properties
{
"Redirect": "TwoWay",