diff --git a/xml/System.Runtime.CompilerServices/UnsafeAccessorAttribute.xml b/xml/System.Runtime.CompilerServices/UnsafeAccessorAttribute.xml
index f4bad7e63f9..00d0aa77313 100644
--- a/xml/System.Runtime.CompilerServices/UnsafeAccessorAttribute.xml
+++ b/xml/System.Runtime.CompilerServices/UnsafeAccessorAttribute.xml
@@ -31,94 +31,131 @@
   <Docs>
     <summary>Provides access to an inaccessible member of a specific type.</summary>
     <remarks>
-      <format type="text/markdown"><![CDATA[
-
-## Remarks
-
-You can apply this attribute to an `extern static` method. The implementation of the `extern static` method annotated with this attribute will be provided by the runtime based on the information in the attribute and the signature of the method that the attribute is applied to. The runtime will try to find the matching method or field and forward the call to it. If the matching method or field is not found, the body of the `extern static` method will throw <xref:System.MissingFieldException> or <xref:System.MissingMethodException>.
-
-For <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.Method>, <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.StaticMethod>, <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.Field>, and <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.StaticField>, the type of the first argument of the annotated `extern static` method identifies the owning type. Only the specific type defined will be examined for inaccessible members. The type hierarchy is not walked looking for a match.
-
-The value of the first argument is treated as `this` pointer for instance fields and methods.
-
-The first argument must be passed as `ref` for instance fields and methods on structs.
-
-The value of the first argument is not used by the implementation for `static` fields and methods.
-
-The return value for an accessor to a field can be `ref` if setting of the field is desired.
-
-
-Constructors can be accessed using <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.Constructor> or <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.Method>.
-
-
-The return type is considered for the signature match. Modreqs and modopts are initially not considered for the signature match. However, if an ambiguity exists ignoring modreqs and modopts, a precise match is attempted. If an ambiguity still exists, <xref:System.Reflection.AmbiguousMatchException> is thrown.
-
-By default, the attributed method's name dictates the name of the method/field. This can cause confusion in some cases since language abstractions, like C# local functions, generate mangled IL names. The solution to this is to use the `nameof` mechanism and define the <xref:System.Runtime.CompilerServices.UnsafeAccessorAttribute.Name> property.
-
+      <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+You can apply this attribute to an `extern static` method. The implementation of the `extern static` method annotated with this attribute will be provided by the runtime based on the information in the attribute and the signature of the method that the attribute is applied to. The runtime will try to find the matching method or field and forward the call to it. If the matching method or field is not found, the body of the `extern static` method will throw <xref:System.MissingFieldException> or <xref:System.MissingMethodException>.
+
+Generic parameters are supported since .NET 9. Generic parameters must match the target in form and index (that is, type parameters must be type parameters and method parameters must be method parameters). The `extern static` method's generic parameters must also exactly match any constraints reflected on the target. If constraints don't match, the method throws <xref:System.InvalidProgramException>.
+
+For <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.Method>, <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.StaticMethod>, <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.Field>, and <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.StaticField>, the type of the first argument of the annotated `extern static` method identifies the owning type. Only the specific type defined will be examined for inaccessible members. The type hierarchy is not walked looking for a match.
+
+The value of the first argument is treated as `this` pointer for instance fields and methods.
+
+The first argument must be passed as `ref` for instance fields and methods on structs.
+
+The value of the first argument is not used by the implementation for `static` fields and methods and can be `null`.
+
+The return value for an accessor to a field can be `ref` if setting of the field is desired.
+
+
+Constructors can be accessed using <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.Constructor> or <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.Method>.
+
+
+The return type is considered for the signature match. Modreqs and modopts are initially not considered for the signature match. However, if an ambiguity exists ignoring modreqs and modopts, a precise match is attempted. If an ambiguity still exists, <xref:System.Reflection.AmbiguousMatchException> is thrown.
+
+By default, the attributed method's name dictates the name of the method/field. This can cause confusion in some cases since language abstractions, like C# local functions, generate mangled IL names. The solution to this is to use the `nameof` mechanism and define the <xref:System.Runtime.CompilerServices.UnsafeAccessorAttribute.Name> property.
+
       ]]></format>
     </remarks>
     <example>
-      <code language="csharp">
-      public class Class
-      {
-          static void StaticPrivateMethod() { }
-          static int StaticPrivateField;
-          Class(int i) { PrivateField = i; }
-          void PrivateMethod() { }
-          int PrivateField;
-          int PrivateProperty { get =&gt; PrivateField; }
-      }
-
-      public void CallStaticPrivateMethod()
-      {
-          StaticPrivateMethod(null);
-          
-          [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = nameof(StaticPrivateMethod))]
-          extern static void StaticPrivateMethod(Class c);
-      }
-      public void GetSetStaticPrivateField()
-      {
-          ref int f = ref GetSetStaticPrivateField(null);
-
-          [UnsafeAccessor(UnsafeAccessorKind.StaticField, Name = "StaticPrivateField")]
-          extern static ref int GetSetStaticPrivateField(Class c);
-      }
-      public void CallPrivateConstructor()
-      {
-          Class c1 = PrivateCtor(1);
-          
-          Class c2 = (Class)RuntimeHelpers.GetUninitializedObject(typeof(Class));
-
-          PrivateCtorAsMethod(c2, 2);
-
-          [UnsafeAccessor(UnsafeAccessorKind.Constructor)]
-          extern static Class PrivateCtor(int i);
-          
-          [UnsafeAccessor(UnsafeAccessorKind.Method, Name = ".ctor")]
-          extern static void PrivateCtorAsMethod(Class c, int i);
-
-      }
-      public void CallPrivateMethod(Class c)
-      {
-          PrivateMethod(c);
-          
-          [UnsafeAccessor(UnsafeAccessorKind.Method, Name = nameof(PrivateMethod))]
-          extern static void PrivateMethod(Class c);
-      }
-      public void GetPrivateProperty(Class c)
-      {
-          int f = GetPrivateProperty(c);
-
-          [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_PrivateProperty")]
-          extern static int GetPrivateProperty(Class c);
-      }
-      public void GetSetPrivateField(Class c)
-      {
-          ref int f = ref GetSetPrivateField(c);
-
-          [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "PrivateField")]
-          extern static ref int GetSetPrivateField(Class c);
-      }
+      <code language="csharp">
+      public class Class
+      {
+          static void StaticPrivateMethod() { }
+          static int StaticPrivateField;
+          Class(int i) { PrivateField = i; }
+          void PrivateMethod() { }
+          int PrivateField;
+          int PrivateProperty { get =&gt; PrivateField; }
+      }
+
+      public void CallStaticPrivateMethod()
+      {
+          StaticPrivateMethod(null);
+
+          [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = nameof(StaticPrivateMethod))]
+          extern static void StaticPrivateMethod(Class c);
+      }
+      public void GetSetStaticPrivateField()
+      {
+          ref int f = ref GetSetStaticPrivateField(null);
+
+          [UnsafeAccessor(UnsafeAccessorKind.StaticField, Name = "StaticPrivateField")]
+          extern static ref int GetSetStaticPrivateField(Class c);
+      }
+      public void CallPrivateConstructor()
+      {
+          Class c1 = PrivateCtor(1);
+
+          Class c2 = (Class)RuntimeHelpers.GetUninitializedObject(typeof(Class));
+
+          PrivateCtorAsMethod(c2, 2);
+
+          [UnsafeAccessor(UnsafeAccessorKind.Constructor)]
+          extern static Class PrivateCtor(int i);
+
+          [UnsafeAccessor(UnsafeAccessorKind.Method, Name = ".ctor")]
+          extern static void PrivateCtorAsMethod(Class c, int i);
+
+      }
+      public void CallPrivateMethod(Class c)
+      {
+          PrivateMethod(c);
+
+          [UnsafeAccessor(UnsafeAccessorKind.Method, Name = nameof(PrivateMethod))]
+          extern static void PrivateMethod(Class c);
+      }
+      public void GetPrivateProperty(Class c)
+      {
+          int f = GetPrivateProperty(c);
+
+          [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_PrivateProperty")]
+          extern static int GetPrivateProperty(Class c);
+      }
+      public void GetSetPrivateField(Class c)
+      {
+          ref int f = ref GetSetPrivateField(c);
+
+          [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "PrivateField")]
+          extern static ref int GetSetPrivateField(Class c);
+      }
+
+      // Generic example
+      public class Class&lt;T&gt;
+      {
+          private T _field;
+          private void M(T t) { }
+          private void GM&lt;U&gt;(U u) { }
+          private void GMWithConstraints&lt;U, V&gt;(U u, V v) where U : V, IEquatable&lt;U&gt; { }
+      }
+
+      class Accessors&lt;V&gt;
+      {
+          [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_field")]
+          public extern static ref V GetSetPrivateField(Class&lt;V&gt; c);
+
+          [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "M")]
+          public extern static void CallM(Class&lt;V&gt; c, V v);
+
+          [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "GM")]
+          public extern static void CallGM&lt;X&gt;(Class&lt;V&gt; c, X x);
+
+          [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "GMWithConstraints")]
+          public extern static void CallGMWithConstraints&lt;X, Y&gt;(Class&lt;V&gt; c, X x, Y y) where X : Y, IEquatable&lt;X&gt;;
+      }
+
+      public void AccessGenericType(Class&lt;int&gt; c)
+      {
+          ref int f = ref Accessors&lt;int&gt;.GetSetPrivateField(c);
+
+          Accessors&lt;int&gt;.CallM(c, 1);
+
+          Accessors&lt;int&gt;.CallGM&lt;string&gt;(c, string.Empty);
+
+          Accessors&lt;int&gt;.CallGMWithConstraints&lt;string, object&gt;(c, string.Empty, new object());
+      }
       </code>
     </example>
   </Docs>
@@ -186,7 +223,7 @@ By default, the attributed method's name dictates the name of the method/field.
       <Docs>
         <summary>Gets or sets the name of the member to which access is provided.</summary>
         <value>To be added.</value>
-        <remarks>The name defaults to the annotated method name if not specified.
+        <remarks>The name defaults to the annotated method name if not specified.
             The name must be unset/<code>null</code> for <see cref="F:System.Runtime.CompilerServices.UnsafeAccessorKind.Constructor" />.</remarks>
       </Docs>
     </Member>