UnsafeAccessorAttribute.xml

<Type Name="UnsafeAccessorAttribute" FullName="System.Runtime.CompilerServices.UnsafeAccessorAttribute">
  <TypeSignature Language="C#" Value="public sealed class UnsafeAccessorAttribute : Attribute" />
  <TypeSignature Language="ILAsm" Value=".class public auto ansi sealed beforefieldinit UnsafeAccessorAttribute extends System.Attribute" />
  <TypeSignature Language="DocId" Value="T:System.Runtime.CompilerServices.UnsafeAccessorAttribute" />
  <TypeSignature Language="VB.NET" Value="Public NotInheritable Class UnsafeAccessorAttribute&#xA;Inherits Attribute" />
  <TypeSignature Language="F#" Value="type UnsafeAccessorAttribute = class&#xA;    inherit Attribute" />
  <TypeSignature Language="C++ CLI" Value="public ref class UnsafeAccessorAttribute sealed : Attribute" />
  <AssemblyInfo>
    <AssemblyName>System.Runtime</AssemblyName>
    <AssemblyVersion>8.0.0.0</AssemblyVersion>
    <AssemblyVersion>9.0.0.0</AssemblyVersion>
  </AssemblyInfo>
  <Base>
    <BaseTypeName>System.Attribute</BaseTypeName>
  </Base>
  <Interfaces />
  <Attributes>
    <Attribute>
      <AttributeName Language="C#">[System.AttributeUsage(System.AttributeTargets.Method, AllowMultiple=false, Inherited=false)]</AttributeName>
      <AttributeName Language="F#">[&lt;System.AttributeUsage(System.AttributeTargets.Method, AllowMultiple=false, Inherited=false)&gt;]</AttributeName>
    </Attribute>
    <Attribute>
      <AttributeName Language="C#">[System.Runtime.CompilerServices.Nullable(0)]</AttributeName>
      <AttributeName Language="F#">[&lt;System.Runtime.CompilerServices.Nullable(0)&gt;]</AttributeName>
    </Attribute>
    <Attribute>
      <AttributeName Language="C#">[System.Runtime.CompilerServices.NullableContext(2)]</AttributeName>
      <AttributeName Language="F#">[&lt;System.Runtime.CompilerServices.NullableContext(2)&gt;]</AttributeName>
    </Attribute>
  </Attributes>
  <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>.

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 must be passed as `ref`.

Constructors can be accessed using <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.Constructor> or <xref:System.Runtime.CompilerServices.UnsafeAccessorKind.Method>.

A match is determined by comparing metadata signatures as defined in section II.23.2 of [ECMA-335](https://ecma-international.org/publications-and-standards/standards/ecma-335/). 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);
      }

      // 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>
  <Members>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public UnsafeAccessorAttribute (System.Runtime.CompilerServices.UnsafeAccessorKind kind);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(valuetype System.Runtime.CompilerServices.UnsafeAccessorKind kind) cil managed" />
      <MemberSignature Language="DocId" Value="M:System.Runtime.CompilerServices.UnsafeAccessorAttribute.#ctor(System.Runtime.CompilerServices.UnsafeAccessorKind)" />
      <MemberSignature Language="VB.NET" Value="Public Sub New (kind As UnsafeAccessorKind)" />
      <MemberSignature Language="F#" Value="new System.Runtime.CompilerServices.UnsafeAccessorAttribute : System.Runtime.CompilerServices.UnsafeAccessorKind -&gt; System.Runtime.CompilerServices.UnsafeAccessorAttribute" Usage="new System.Runtime.CompilerServices.UnsafeAccessorAttribute kind" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; UnsafeAccessorAttribute(System::Runtime::CompilerServices::UnsafeAccessorKind kind);" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyName>System.Runtime</AssemblyName>
        <AssemblyVersion>8.0.0.0</AssemblyVersion>
        <AssemblyVersion>9.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Parameters>
        <Parameter Name="kind" Type="System.Runtime.CompilerServices.UnsafeAccessorKind" />
      </Parameters>
      <Docs>
        <param name="kind">The kind of the target to which access is provided.</param>
        <summary>Instantiates an <see cref="T:System.Runtime.CompilerServices.UnsafeAccessorAttribute" /> providing access to a member of kind <see cref="T:System.Runtime.CompilerServices.UnsafeAccessorKind" />.</summary>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Kind">
      <MemberSignature Language="C#" Value="public System.Runtime.CompilerServices.UnsafeAccessorKind Kind { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance valuetype System.Runtime.CompilerServices.UnsafeAccessorKind Kind" />
      <MemberSignature Language="DocId" Value="P:System.Runtime.CompilerServices.UnsafeAccessorAttribute.Kind" />
      <MemberSignature Language="VB.NET" Value="Public ReadOnly Property Kind As UnsafeAccessorKind" />
      <MemberSignature Language="F#" Value="member this.Kind : System.Runtime.CompilerServices.UnsafeAccessorKind" Usage="System.Runtime.CompilerServices.UnsafeAccessorAttribute.Kind" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property System::Runtime::CompilerServices::UnsafeAccessorKind Kind { System::Runtime::CompilerServices::UnsafeAccessorKind get(); };" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>System.Runtime</AssemblyName>
        <AssemblyVersion>8.0.0.0</AssemblyVersion>
        <AssemblyVersion>9.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Runtime.CompilerServices.UnsafeAccessorKind</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Gets the kind of member to which access is provided.</summary>
        <value>To be added.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Name">
      <MemberSignature Language="C#" Value="public string? Name { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance string Name" />
      <MemberSignature Language="DocId" Value="P:System.Runtime.CompilerServices.UnsafeAccessorAttribute.Name" />
      <MemberSignature Language="VB.NET" Value="Public Property Name As String" />
      <MemberSignature Language="F#" Value="member this.Name : string with get, set" Usage="System.Runtime.CompilerServices.UnsafeAccessorAttribute.Name" />
      <MemberSignature Language="C++ CLI" Value="public:&#xA; property System::String ^ Name { System::String ^ get(); void set(System::String ^ value); };" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>System.Runtime</AssemblyName>
        <AssemblyVersion>8.0.0.0</AssemblyVersion>
        <AssemblyVersion>9.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <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.
            The name must be unset/<code>null</code> for <see cref="F:System.Runtime.CompilerServices.UnsafeAccessorKind.Constructor" />.</remarks>
      </Docs>
    </Member>
  </Members>
</Type>