Add article, snippets, toc, and redirects (#1233)

.openpublishing.redirection.json

@@ -564,6 +564,14 @@
         {
             "source_path": "dotnet-desktop-guide/framework/wpf/properties/read-only-dependency-properties.md",
             "redirect_url": "/dotnet/desktop/wpf/advanced/read-only-dependency-properties?view=netframeworkdesktop-4.8"
+        },
+        {
+            "source_path": "dotnet-desktop-guide/net/wpf/advanced/dependency-property-security.md",
+            "redirect_url": "/dotnet/desktop/wpf/properties/dependency-property-security?view=netdesktop-6.0"
+        },
+        {
+            "source_path": "dotnet-desktop-guide/framework/wpf/properties/dependency-property-security.md",
+            "redirect_url": "/dotnet/desktop/wpf/advanced/dependency-property-security?view=netframeworkdesktop-4.8"
         }
     ]
 }

dotnet-desktop-guide/net/wpf/properties/dependency-property-security.md

@@ -0,0 +1,61 @@
+---
+title: "Dependency property security"
+description: Learn about the dependency property accessibility and security in Windows Presentation Foundation (WPF).
+ms.date: "12/03/2021"
+dev_langs:
+  - "csharp"
+  - "vb"
+helpviewer_keywords:
+  - "wrappers [WPF], access"
+  - "wrappers [WPF], security"
+  - "dependency properties [WPF], security"
+  - "security [WPF], wrappers"
+  - "validation [WPF], dependency properties"
+  - "dependency properties [WPF], access"
+  - "security [WPF], dependency properties"
+---
+<!-- The acrolinx score was 92 on 12/03/2021-->
+
+# Dependency property security (WPF .NET)
+
+The accessibility of read-write dependency properties through the Windows Presentation Foundation (WPF) property system effectively makes them public properties. As a result, it's not possible to make security guarantees about read-write dependency property values. The WPF property system provides more security for read-only dependency properties so that you can restrict write access.
+
+[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
+
+## Access and security of property wrappers
+
+A common language runtime (CLR) property wrapper is usually included in read-write dependency property implementations to simplify getting or setting property values. If included, the CLR property wrapper is a convenience method that implements the <xref:System.Windows.DependencyObject.GetValue%2A> and <xref:System.Windows.DependencyObject.SetValue%2A> static calls that interact with the underlying dependency property. Essentially, a CLR property wrapper exposes a dependency property as a CLR property backed by a dependency property rather than a private field.
+
+Applying security mechanisms and restricting access to the CLR property wrapper might prevent usage of the convenience method, but those techniques won't prevent direct calls to `GetValue` or `SetValue`. In other words, a read-write dependency property is always accessible through the WPF property system. If you're implementing a read-write dependency property, avoid restricting access to the CLR property wrapper. Instead, declare the CLR property wrapper as a public member so callers are aware of the true access level of the dependency property.
+
+## Property system exposure of dependency properties
+
+The WPF property system provides access to a read-write dependency property through its <xref:System.Windows.DependencyProperty> identifier. The identifier is usable in <xref:System.Windows.DependencyObject.GetValue%2A> and <xref:System.Windows.DependencyObject.SetValue%2A> calls. Even if the static identifier field is non-public, several aspects of the property system will return a `DependencyProperty` as it exists on an instance of a class or derived class. For example, the <xref:System.Windows.DependencyObject.GetLocalValueEnumerator%2A> method returns identifiers for dependency property instances with a locally set value. Also, you can override the <xref:System.Windows.DependencyObject.OnPropertyChanged%2A> virtual method to receive event data that will report the `DependencyProperty` identifier for dependency properties that have changed value. To make callers aware of the true access level of a read-write dependency property, declare its identifier field as a public member.
+
+> [!NOTE]
+> Although declaring a dependency property identifier field as `private` reduces the number of ways that a read-write dependency property is accessible, the property won't be [private](/dotnet/csharp/language-reference/keywords/private) according to the CLR language definition.
+
+### Validation security
+
+Applying a <xref:System.Security.IStackWalk.Demand%2A> to a <xref:System.Windows.DependencyProperty.ValidateValueCallback%2A> and expecting validation to fail on `Demand` failure, isn't an adequate security mechanism for restricting property value changes. Also, new value invalidation enforced through `ValidateValueCallback` can be suppressed by malicious callers, if those callers are operating within the application domain.
+
+## Access to read-only dependency properties
+
+To restrict access, register your property as a read-only dependency property by calling the <xref:System.Windows.DependencyProperty.RegisterReadOnly%2A> method. The `RegisterReadOnly` method returns a <xref:System.Windows.DependencyPropertyKey>, which you can assign to a non-public class field. For read-only dependency properties, the WPF property system will only provide write access to those who have a reference to the `DependencyPropertyKey`. To illustrate this behavior, the following test code:
+
+- Instantiates a class that implements both read-write and read-only dependency properties.
+- Assigns a `private` access modifier to each identifier.
+- Only implements `get` accessors.
+- Uses the <xref:System.Windows.DependencyObject.GetLocalValueEnumerator%2A> method to access the underlying dependency properties through the WPF property system.
+- Calls <xref:System.Windows.DependencyObject.GetValue%2A> and <xref:System.Windows.DependencyObject.SetValue%2A> to test access to each dependency property value.
+
+:::code language="csharp" source="./snippets/dependency-property-security/csharp/MainWindow.xaml.cs" id="DependencyPropertyAccessTests":::
+:::code language="vb" source="./snippets/dependency-property-security/vb/MainWindow.xaml.vb" id="DependencyPropertyAccessTests":::
+
+## See also
+
+- <xref:System.Windows.DependencyProperty>
+- <xref:System.Windows.DependencyObject.GetLocalValueEnumerator%2A>
+- <xref:System.Windows.DependencyObject.OnPropertyChanged%2A>
+- [Custom dependency properties](custom-dependency-properties.md)
+- [Implement a Dependency property](how-to-implement-a-dependency-property.md)

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/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
+{
+    /// <summary>
+    /// Interaction logic for App.xaml
+    /// </summary>
+    public partial class App : Application
+    {
+    }
+}

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/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)
+)]

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/csharp/CodeSampleCsharp.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net6.0-windows</TargetFramework>
+    <UseWPF>true</UseWPF>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Update="Properties\Resources.Designer.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Update="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+
+</Project>

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/csharp/MainWindow.xaml

@@ -0,0 +1,5 @@
+<Window x:Class="CodeSampleCsharp.MainWindow"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="Dependency property security" Height="100" Width="400">
+</Window>

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/csharp/MainWindow.xaml.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Diagnostics;
+using System.Windows;
+
+namespace CodeSampleCsharp
+{
+    /// <summary>
+    /// Interaction logic for MainWindow.xaml.
+    /// </summary>
+    public partial class MainWindow : Window
+    {
+        public MainWindow()
+        {
+            InitializeComponent();
+
+            DependencyPropertyAccessTests();
+        }
+
+        //<DependencyPropertyAccessTests>
+        /// <summary>
+        ///  Test get/set access to dependency properties exposed through the WPF property system.
+        /// </summary>
+        public static void DependencyPropertyAccessTests()
+        {
+            // Instantiate a class that implements read-write and read-only dependency properties.
+            Aquarium _aquarium = new();
+            // Access each dependency property using the LocalValueEnumerator method.
+            LocalValueEnumerator localValueEnumerator = _aquarium.GetLocalValueEnumerator();
+            while (localValueEnumerator.MoveNext())
+            {
+                DependencyProperty dp = localValueEnumerator.Current.Property;
+                string dpType = dp.ReadOnly ? "read-only" : "read-write";
+                // Test read access.
+                Debug.WriteLine($"Attempting to get a {dpType} dependency property value...");
+                Debug.WriteLine($"Value ({dpType}): {(int)_aquarium.GetValue(dp)}");
+                // Test write access.
+                try
+                {
+                    Debug.WriteLine($"Attempting to set a {dpType} dependency property value to 2...");
+                    _aquarium.SetValue(dp, 2);
+                }
+                catch (InvalidOperationException e)
+                {
+                    Debug.WriteLine(e.Message);
+                }
+                finally
+                {
+                    Debug.WriteLine($"Value ({dpType}): {(int)_aquarium.GetValue(dp)}");
+                }
+            }
+
+            // Test output:
+
+            // Attempting to get a read-write dependency property value...
+            // Value (read-write): 1
+            // Attempting to set a read-write dependency property value to 2...
+            // Value (read-write): 2
+
+            // Attempting to get a read-only dependency property value...
+            // Value (read-only): 1
+            // Attempting to set a read-only dependency property value to 2...
+            // 'FishCountReadOnly' property was registered as read-only
+            // and cannot be modified without an authorization key.
+            // Value (read-only): 1
+        }
+    }
+
+    public class Aquarium : DependencyObject
+    {
+        public Aquarium()
+        {
+            // Assign locally-set values.
+            SetValue(FishCountProperty, 1);
+            SetValue(FishCountReadOnlyPropertyKey, 1);
+        }
+
+        // Failed attempt to restrict write-access by assigning the
+        // DependencyProperty identifier to a non-public field.
+        private static readonly DependencyProperty FishCountProperty =
+            DependencyProperty.Register(
+              name: "FishCount",
+              propertyType: typeof(int),
+              ownerType: typeof(Aquarium),
+              typeMetadata: new PropertyMetadata());
+
+        // Successful attempt to restrict write-access by assigning the
+        // DependencyPropertyKey to a non-public field.
+        private static readonly DependencyPropertyKey FishCountReadOnlyPropertyKey =
+            DependencyProperty.RegisterReadOnly(
+              name: "FishCountReadOnly",
+              propertyType: typeof(int),
+              ownerType: typeof(Aquarium),
+              typeMetadata: new PropertyMetadata());
+
+        // Declare public get accessors.
+        public int FishCount => (int)GetValue(FishCountProperty);
+        public int FishCountReadOnly => (int)GetValue(FishCountReadOnlyPropertyKey.DependencyProperty);
+    }
+    //</DependencyPropertyAccessTests>
+}

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/csharp/Properties/Resources.Designer.cs

@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     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.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace CodeSampleCsharp.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // 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() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [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;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+    }
+}

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/csharp/Properties/Resources.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/csharp/app.xaml

@@ -0,0 +1,9 @@
+<Application x:Class="CodeSampleCsharp.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="clr-namespace:CodeSampleCsharp"
+             StartupUri="MainWindow.xaml">
+    <Application.Resources>
+         
+    </Application.Resources>
+</Application>

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/vb/Application.xaml

@@ -0,0 +1,9 @@
+<Application x:Class="Application"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="clr-namespace:CodeSampleVb"
+             StartupUri="MainWindow.xaml">
+    <Application.Resources>
+         
+    </Application.Resources>
+</Application>

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/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

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/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)
+<Assembly: ThemeInfo(ResourceDictionaryLocation.None, ResourceDictionaryLocation.SourceAssembly)>

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/vb/CodeSampleVb.vbproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net6.0-windows</TargetFramework>
+    <RootNamespace>CodeSampleVb</RootNamespace>
+    <UseWPF>true</UseWPF>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Import Include="System.Windows" />
+    <Import Include="System.Windows.Controls" />
+    <Import Include="System.Windows.Data" />
+    <Import Include="System.Windows.Documents" />
+    <Import Include="System.Windows.Input" />
+    <Import Include="System.Windows.Media" />
+    <Import Include="System.Windows.Media.Imaging" />
+    <Import Include="System.Windows.Navigation" />
+    <Import Include="System.Windows.Shapes" />
+  </ItemGroup>
+
+</Project>

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/vb/MainWindow.xaml

@@ -0,0 +1,5 @@
+<Window x:Class="CodeSampleVb.MainWindow"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="Dependency property security" Height="100" Width="400">
+</Window>

dotnet-desktop-guide/net/wpf/properties/snippets/dependency-property-security/vb/MainWindow.xaml.vb

@@ -0,0 +1,100 @@
+Namespace CodeSampleVb
+
+    ' <summary>
+    ' Interaction logic for MainWindow.xaml.
+    ' </summary>
+    Partial Public Class MainWindow
+        Inherits Window
+
+        Public Sub New()
+            InitializeComponent()
+            DependencyPropertyAccessTests()
+        End Sub
+
+        '<DependencyPropertyAccessTests>
+        ''' <summary>
+        ''' ' Test get/set access to dependency properties exposed through the WPF property system.
+        ''' </summary>
+        Public Shared Sub DependencyPropertyAccessTests()
+            ' Instantiate a class that implements read-write and read-only dependency properties.
+            Dim _aquarium As New Aquarium()
+            ' Access each dependency property using the LocalValueEnumerator method.
+            Dim localValueEnumerator As LocalValueEnumerator = _aquarium.GetLocalValueEnumerator()
+            While localValueEnumerator.MoveNext()
+                Dim dp As DependencyProperty = localValueEnumerator.Current.[Property]
+                Dim dpType As String = If(dp.[ReadOnly], "read-only", "read-write")
+                ' Test read access.
+                Debug.WriteLine($"Attempting to get a {dpType} dependency property value...")
+                Debug.WriteLine($"Value ({dpType}): {CInt(_aquarium.GetValue(dp))}")
+                ' Test write access.
+                Try
+                    Debug.WriteLine($"Attempting to set a {dpType} dependency property value to 2...")
+                    _aquarium.SetValue(dp, 2)
+                Catch e As InvalidOperationException
+                    Debug.WriteLine(e.Message)
+                Finally
+                    Debug.WriteLine($"Value ({dpType}): {CInt(_aquarium.GetValue(dp))}")
+                End Try
+            End While
+
+            ' Test output
+
+            ' Attempting to get a read-write dependency property value...
+            ' Value (read-write): 1
+            ' Attempting to set a read-write dependency property value to 2...
+            ' Value (read-write): 2
+
+            ' Attempting to get a read-only dependency property value...
+            ' Value (read-only): 1
+            ' Attempting to set a read-only dependency property value to 2...
+            ' 'FishCountReadOnly' property was registered as read-only
+            ' and cannot be modified without an authorization key.
+            ' Value (read-only): 1
+        End Sub
+
+    End Class
+
+    Public Class Aquarium
+        Inherits DependencyObject
+
+        Public Sub New()
+            ' Assign locally-set values.
+            SetValue(FishCountProperty, 1)
+            SetValue(FishCountReadOnlyPropertyKey, 1)
+        End Sub
+
+        ' Failed attempt to restrict write-access by assigning the
+        ' DependencyProperty identifier to a non-public field.
+        Private Shared ReadOnly FishCountProperty As DependencyProperty =
+            DependencyProperty.Register(
+                name:="FishCount",
+                propertyType:=GetType(Integer),
+                ownerType:=GetType(Aquarium),
+                typeMetadata:=New PropertyMetadata())
+
+        ' Successful attempt to restrict write-access by assigning the
+        ' DependencyPropertyKey to a non-public field.
+        Private Shared ReadOnly FishCountReadOnlyPropertyKey As DependencyPropertyKey =
+            DependencyProperty.RegisterReadOnly(
+                name:="FishCountReadOnly",
+                propertyType:=GetType(Integer),
+                ownerType:=GetType(Aquarium),
+                typeMetadata:=New PropertyMetadata())
+
+        ' Declare public get accessors.
+        Public ReadOnly Property FishCount As Integer
+            Get
+                Return GetValue(FishCountProperty)
+            End Get
+        End Property
+
+        Public ReadOnly Property FishCountReadOnly As Integer
+            Get
+                Return GetValue(FishCountReadOnlyPropertyKey.DependencyProperty)
+            End Get
+        End Property
+
+    End Class
+    '</DependencyPropertyAccessTests>
+
+End Namespace

dotnet-desktop-guide/net/wpf/toc.yml

@@ -96,6 +96,8 @@ items:
       href: properties/dependency-property-callbacks-and-validation.md
     - name: Read-only dependency properties
       href: properties/read-only-dependency-properties.md
+    - name: Dependency property security
+      href: properties/dependency-property-security.md
     - name: Common tasks
       items:
       - name: Implement a dependency property

redirects_generator/definitions.json

@@ -383,6 +383,10 @@
             "SourceUrl": "/dotnet/desktop/wpf/advanced/read-only-dependency-properties?view=netframeworkdesktop-4.8",
             "TargetUrl": "/dotnet/desktop/wpf/properties/read-only-dependency-properties?view=netdesktop-6.0"
         },
+        {
+            "SourceUrl": "/dotnet/desktop/wpf/advanced/dependency-property-security?view=netframeworkdesktop-4.8",
+            "TargetUrl": "/dotnet/desktop/wpf/properties/dependency-property-security?view=netdesktop-6.0"
+        },
 
         // Systems - XAML
         {