Move lengthy remarks for DynamicMethod to conceptual docs repo

docs/fundamentals/runtime-libraries/includes/context.md

@@ -1 +1,2 @@
-This article provides supplementary remarks to the reference documentation for this API.
+> [!NOTE]
+> This article provides supplementary remarks to the reference documentation for this API.

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/Project.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source.cs

@@ -0,0 +1,145 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+// These classes are for demonstration purposes.
+//
+public class Example
+{
+ private int id = 0;
+ public Example(int id)
+ {
+ this.id = id;
+ }
+ public int ID { get { return id; }}
+}
+
+public class DerivedFromExample : Example
+{
+ public DerivedFromExample(int id) : base(id) {}
+}
+
+// Two delegates are declared: UseLikeInstance treats the dynamic
+// method as if it were an instance method, and UseLikeStatic
+// treats the dynamic method in the ordinary fashion.
+//
+public delegate int UseLikeInstance(int newID);
+public delegate int UseLikeStatic(Example ex, int newID);
+
+public class Demo
+{
+ public static void Main()
+ {
+ // This dynamic method changes the private id field. It has
+ // no name; it returns the old id value (return type int);
+ // it takes two parameters, an instance of Example and
+ // an int that is the new value of id; and it is declared
+ // with Example as the owner type, so it can access all
+ // members, public and private.
+ //
+ DynamicMethod changeID = new DynamicMethod(
+ "",
+ typeof(int),
+ new Type[] { typeof(Example), typeof(int) },
+ typeof(Example)
+ );
+
+ // Get a FieldInfo for the private field 'id'.
+ FieldInfo fid = typeof(Example).GetField(
+ "id",
+ BindingFlags.NonPublic | BindingFlags.Instance
+ );
+
+ ILGenerator ilg = changeID.GetILGenerator();
+
+ // Push the current value of the id field onto the
+ // evaluation stack. It's an instance field, so load the
+ // instance of Example before accessing the field.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldfld, fid);
+
+ // Load the instance of Example again, load the new value
+ // of id, and store the new field value.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldarg_1);
+ ilg.Emit(OpCodes.Stfld, fid);
+
+ // The original value of the id field is now the only
+ // thing on the stack, so return from the call.
+ ilg.Emit(OpCodes.Ret);
+
+ // Create a delegate that uses changeID in the ordinary
+ // way, as a static method that takes an instance of
+ // Example and an int.
+ //
+ UseLikeStatic uls =
+ (UseLikeStatic) changeID.CreateDelegate(
+ typeof(UseLikeStatic)
+ );
+
+ // Create an instance of Example with an id of 42.
+ //
+ Example ex = new Example(42);
+
+ // Create a delegate that is bound to the instance of
+ // of Example. This is possible because the first
+ // parameter of changeID is of type Example. The
+ // delegate has all the parameters of changeID except
+ // the first.
+ UseLikeInstance uli =
+ (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ ex
+ );
+
+ // First, change the value of id by calling changeID as
+ // a static method, passing in the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(ex, 1492)
+ );
+
+ // Change the value of id again using the delegate bound
+ // to the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(2700)
+ );
+
+ Console.WriteLine("Final value of id: {0}", ex.ID);
+
+ // Now repeat the process with a class that derives
+ // from Example.
+ //
+ DerivedFromExample dfex = new DerivedFromExample(71);
+
+ uli = (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ dfex
+ );
+
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(dfex, 73)
+ );
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(79)
+ );
+ Console.WriteLine("Final value of id: {0}", dfex.ID);
+ }
+}
+
+/* This code example produces the following output:
+
+Change the value of id; previous value: 42
+Change the value of id; previous value: 1492
+Final value of id: 2700
+Change the value of id; previous value: 71
+Change the value of id; previous value: 73
+Final value of id: 79
+ */
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source1.cs

@@ -0,0 +1,80 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+public class Test
+{
+ // Declare a delegate that will be used to execute the completed
+ // dynamic method.
+ private delegate int HelloInvoker(string msg, int ret);
+
+ public static void Main()
+ {
+ // Create an array that specifies the types of the parameters
+ // of the dynamic method. This method has a string parameter
+ // and an int parameter.
+ Type[] helloArgs = {typeof(string), typeof(int)};
+
+ // Create a dynamic method with the name "Hello", a return type
+ // of int, and two parameters whose types are specified by the
+ // array helloArgs. Create the method in the module that
+ // defines the Test class.
+ DynamicMethod hello = new DynamicMethod("Hello",
+ typeof(int),
+ helloArgs,
+ typeof(Test).Module);
+
+ // <Snippet2>
+ // Create an array that specifies the parameter types of the
+ // overload of Console.WriteLine to be used in Hello.
+ Type[] writeStringArgs = {typeof(string)};
+ // Get the overload of Console.WriteLine that has one
+ // String parameter.
+ MethodInfo writeString =
+ typeof(Console).GetMethod("WriteLine", writeStringArgs);
+
+ // Get an ILGenerator and emit a body for the dynamic method.
+ ILGenerator il = hello.GetILGenerator();
+ // Load the first argument, which is a string, onto the stack.
+ il.Emit(OpCodes.Ldarg_0);
+ // Call the overload of Console.WriteLine that prints a string.
+ il.EmitCall(OpCodes.Call, writeString, null);
+ // The Hello method returns the value of the second argument;
+ // to do this, load the second argument onto the stack and return.
+ il.Emit(OpCodes.Ldarg_1);
+ il.Emit(OpCodes.Ret);
+ // </Snippet2>
+
+ // <Snippet3>
+ // Create a delegate that represents the dynamic method. This
+ // action completes the method. Further attempts to change the
+ // method are ignored and no exception is thrown.
+ HelloInvoker hi =
+ (HelloInvoker) hello.CreateDelegate(typeof(HelloInvoker));
+ // </Snippet3>
+
+ // Use the delegate to execute the dynamic method. Save and
+ // print the return value.
+ int retval = hi("\r\nHello, World!", 42);
+ Console.WriteLine("Executing delegate hi(\"Hello, World!\", 42) returned {0}",
+ retval);
+
+ // Do it again, with different arguments.
+ retval = hi("\r\nHi, Mom!", 5280);
+ Console.WriteLine("Executing delegate hi(\"Hi, Mom!\", 5280) returned {0}",
+ retval);
+
+ // <Snippet4>
+ // Create an array of arguments to use with the Invoke method.
+ object[] invokeArgs = {"\r\nHello, World!", 42};
+ // Invoke the dynamic method using the arguments. This is much
+ // slower than using the delegate, because you must create an
+ // array to contain the arguments, and ValueType arguments
+ // must be boxed.
+ object objRet = hello.Invoke(null, invokeArgs);
+ Console.WriteLine("hello.Invoke returned {0}", objRet);
+ // </Snippet4>
+ }
+}
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/vb/Project.vbproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/includes/context.md

@@ -1 +1,2 @@
-This article provides supplementary remarks to the reference documentation for this API.
+> [!NOTE]
+> This article provides supplementary remarks to the reference documentation for this API.

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/Project.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source.cs

@@ -0,0 +1,145 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+// These classes are for demonstration purposes.
+//
+public class Example
+{
+ private int id = 0;
+ public Example(int id)
+ {
+ this.id = id;
+ }
+ public int ID { get { return id; }}
+}
+
+public class DerivedFromExample : Example
+{
+ public DerivedFromExample(int id) : base(id) {}
+}
+
+// Two delegates are declared: UseLikeInstance treats the dynamic
+// method as if it were an instance method, and UseLikeStatic
+// treats the dynamic method in the ordinary fashion.
+//
+public delegate int UseLikeInstance(int newID);
+public delegate int UseLikeStatic(Example ex, int newID);
+
+public class Demo
+{
+ public static void Main()
+ {
+ // This dynamic method changes the private id field. It has
+ // no name; it returns the old id value (return type int);
+ // it takes two parameters, an instance of Example and
+ // an int that is the new value of id; and it is declared
+ // with Example as the owner type, so it can access all
+ // members, public and private.
+ //
+ DynamicMethod changeID = new DynamicMethod(
+ "",
+ typeof(int),
+ new Type[] { typeof(Example), typeof(int) },
+ typeof(Example)
+ );
+
+ // Get a FieldInfo for the private field 'id'.
+ FieldInfo fid = typeof(Example).GetField(
+ "id",
+ BindingFlags.NonPublic | BindingFlags.Instance
+ );
+
+ ILGenerator ilg = changeID.GetILGenerator();
+
+ // Push the current value of the id field onto the
+ // evaluation stack. It's an instance field, so load the
+ // instance of Example before accessing the field.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldfld, fid);
+
+ // Load the instance of Example again, load the new value
+ // of id, and store the new field value.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldarg_1);
+ ilg.Emit(OpCodes.Stfld, fid);
+
+ // The original value of the id field is now the only
+ // thing on the stack, so return from the call.
+ ilg.Emit(OpCodes.Ret);
+
+ // Create a delegate that uses changeID in the ordinary
+ // way, as a static method that takes an instance of
+ // Example and an int.
+ //
+ UseLikeStatic uls =
+ (UseLikeStatic) changeID.CreateDelegate(
+ typeof(UseLikeStatic)
+ );
+
+ // Create an instance of Example with an id of 42.
+ //
+ Example ex = new Example(42);
+
+ // Create a delegate that is bound to the instance of
+ // of Example. This is possible because the first
+ // parameter of changeID is of type Example. The
+ // delegate has all the parameters of changeID except
+ // the first.
+ UseLikeInstance uli =
+ (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ ex
+ );
+
+ // First, change the value of id by calling changeID as
+ // a static method, passing in the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(ex, 1492)
+ );
+
+ // Change the value of id again using the delegate bound
+ // to the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(2700)
+ );
+
+ Console.WriteLine("Final value of id: {0}", ex.ID);
+
+ // Now repeat the process with a class that derives
+ // from Example.
+ //
+ DerivedFromExample dfex = new DerivedFromExample(71);
+
+ uli = (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ dfex
+ );
+
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(dfex, 73)
+ );
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(79)
+ );
+ Console.WriteLine("Final value of id: {0}", dfex.ID);
+ }
+}
+
+/* This code example produces the following output:
+
+Change the value of id; previous value: 42
+Change the value of id; previous value: 1492
+Final value of id: 2700
+Change the value of id; previous value: 71
+Change the value of id; previous value: 73
+Final value of id: 79
+ */
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source1.cs

@@ -0,0 +1,80 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+public class Test
+{
+ // Declare a delegate that will be used to execute the completed
+ // dynamic method.
+ private delegate int HelloInvoker(string msg, int ret);
+
+ public static void Main()
+ {
+ // Create an array that specifies the types of the parameters
+ // of the dynamic method. This method has a string parameter
+ // and an int parameter.
+ Type[] helloArgs = {typeof(string), typeof(int)};
+
+ // Create a dynamic method with the name "Hello", a return type
+ // of int, and two parameters whose types are specified by the
+ // array helloArgs. Create the method in the module that
+ // defines the Test class.
+ DynamicMethod hello = new DynamicMethod("Hello",
+ typeof(int),
+ helloArgs,
+ typeof(Test).Module);
+
+ // <Snippet2>
+ // Create an array that specifies the parameter types of the
+ // overload of Console.WriteLine to be used in Hello.
+ Type[] writeStringArgs = {typeof(string)};
+ // Get the overload of Console.WriteLine that has one
+ // String parameter.
+ MethodInfo writeString =
+ typeof(Console).GetMethod("WriteLine", writeStringArgs);
+
+ // Get an ILGenerator and emit a body for the dynamic method.
+ ILGenerator il = hello.GetILGenerator();
+ // Load the first argument, which is a string, onto the stack.
+ il.Emit(OpCodes.Ldarg_0);
+ // Call the overload of Console.WriteLine that prints a string.
+ il.EmitCall(OpCodes.Call, writeString, null);
+ // The Hello method returns the value of the second argument;
+ // to do this, load the second argument onto the stack and return.
+ il.Emit(OpCodes.Ldarg_1);
+ il.Emit(OpCodes.Ret);
+ // </Snippet2>
+
+ // <Snippet3>
+ // Create a delegate that represents the dynamic method. This
+ // action completes the method. Further attempts to change the
+ // method are ignored and no exception is thrown.
+ HelloInvoker hi =
+ (HelloInvoker) hello.CreateDelegate(typeof(HelloInvoker));
+ // </Snippet3>
+
+ // Use the delegate to execute the dynamic method. Save and
+ // print the return value.
+ int retval = hi("\r\nHello, World!", 42);
+ Console.WriteLine("Executing delegate hi(\"Hello, World!\", 42) returned {0}",
+ retval);
+
+ // Do it again, with different arguments.
+ retval = hi("\r\nHi, Mom!", 5280);
+ Console.WriteLine("Executing delegate hi(\"Hi, Mom!\", 5280) returned {0}",
+ retval);
+
+ // <Snippet4>
+ // Create an array of arguments to use with the Invoke method.
+ object[] invokeArgs = {"\r\nHello, World!", 42};
+ // Invoke the dynamic method using the arguments. This is much
+ // slower than using the delegate, because you must create an
+ // array to contain the arguments, and ValueType arguments
+ // must be boxed.
+ object objRet = hello.Invoke(null, invokeArgs);
+ Console.WriteLine("hello.Invoke returned {0}", objRet);
+ // </Snippet4>
+ }
+}
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/vb/Project.vbproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/includes/context.md

@@ -1 +1,2 @@
-This article provides supplementary remarks to the reference documentation for this API.
+> [!NOTE]
+> This article provides supplementary remarks to the reference documentation for this API.

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/Project.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source.cs

@@ -0,0 +1,145 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+// These classes are for demonstration purposes.
+//
+public class Example
+{
+ private int id = 0;
+ public Example(int id)
+ {
+ this.id = id;
+ }
+ public int ID { get { return id; }}
+}
+
+public class DerivedFromExample : Example
+{
+ public DerivedFromExample(int id) : base(id) {}
+}
+
+// Two delegates are declared: UseLikeInstance treats the dynamic
+// method as if it were an instance method, and UseLikeStatic
+// treats the dynamic method in the ordinary fashion.
+//
+public delegate int UseLikeInstance(int newID);
+public delegate int UseLikeStatic(Example ex, int newID);
+
+public class Demo
+{
+ public static void Main()
+ {
+ // This dynamic method changes the private id field. It has
+ // no name; it returns the old id value (return type int);
+ // it takes two parameters, an instance of Example and
+ // an int that is the new value of id; and it is declared
+ // with Example as the owner type, so it can access all
+ // members, public and private.
+ //
+ DynamicMethod changeID = new DynamicMethod(
+ "",
+ typeof(int),
+ new Type[] { typeof(Example), typeof(int) },
+ typeof(Example)
+ );
+
+ // Get a FieldInfo for the private field 'id'.
+ FieldInfo fid = typeof(Example).GetField(
+ "id",
+ BindingFlags.NonPublic | BindingFlags.Instance
+ );
+
+ ILGenerator ilg = changeID.GetILGenerator();
+
+ // Push the current value of the id field onto the
+ // evaluation stack. It's an instance field, so load the
+ // instance of Example before accessing the field.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldfld, fid);
+
+ // Load the instance of Example again, load the new value
+ // of id, and store the new field value.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldarg_1);
+ ilg.Emit(OpCodes.Stfld, fid);
+
+ // The original value of the id field is now the only
+ // thing on the stack, so return from the call.
+ ilg.Emit(OpCodes.Ret);
+
+ // Create a delegate that uses changeID in the ordinary
+ // way, as a static method that takes an instance of
+ // Example and an int.
+ //
+ UseLikeStatic uls =
+ (UseLikeStatic) changeID.CreateDelegate(
+ typeof(UseLikeStatic)
+ );
+
+ // Create an instance of Example with an id of 42.
+ //
+ Example ex = new Example(42);
+
+ // Create a delegate that is bound to the instance of
+ // of Example. This is possible because the first
+ // parameter of changeID is of type Example. The
+ // delegate has all the parameters of changeID except
+ // the first.
+ UseLikeInstance uli =
+ (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ ex
+ );
+
+ // First, change the value of id by calling changeID as
+ // a static method, passing in the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(ex, 1492)
+ );
+
+ // Change the value of id again using the delegate bound
+ // to the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(2700)
+ );
+
+ Console.WriteLine("Final value of id: {0}", ex.ID);
+
+ // Now repeat the process with a class that derives
+ // from Example.
+ //
+ DerivedFromExample dfex = new DerivedFromExample(71);
+
+ uli = (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ dfex
+ );
+
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(dfex, 73)
+ );
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(79)
+ );
+ Console.WriteLine("Final value of id: {0}", dfex.ID);
+ }
+}
+
+/* This code example produces the following output:
+
+Change the value of id; previous value: 42
+Change the value of id; previous value: 1492
+Final value of id: 2700
+Change the value of id; previous value: 71
+Change the value of id; previous value: 73
+Final value of id: 79
+ */
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source1.cs

@@ -0,0 +1,80 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+public class Test
+{
+ // Declare a delegate that will be used to execute the completed
+ // dynamic method.
+ private delegate int HelloInvoker(string msg, int ret);
+
+ public static void Main()
+ {
+ // Create an array that specifies the types of the parameters
+ // of the dynamic method. This method has a string parameter
+ // and an int parameter.
+ Type[] helloArgs = {typeof(string), typeof(int)};
+
+ // Create a dynamic method with the name "Hello", a return type
+ // of int, and two parameters whose types are specified by the
+ // array helloArgs. Create the method in the module that
+ // defines the Test class.
+ DynamicMethod hello = new DynamicMethod("Hello",
+ typeof(int),
+ helloArgs,
+ typeof(Test).Module);
+
+ // <Snippet2>
+ // Create an array that specifies the parameter types of the
+ // overload of Console.WriteLine to be used in Hello.
+ Type[] writeStringArgs = {typeof(string)};
+ // Get the overload of Console.WriteLine that has one
+ // String parameter.
+ MethodInfo writeString =
+ typeof(Console).GetMethod("WriteLine", writeStringArgs);
+
+ // Get an ILGenerator and emit a body for the dynamic method.
+ ILGenerator il = hello.GetILGenerator();
+ // Load the first argument, which is a string, onto the stack.
+ il.Emit(OpCodes.Ldarg_0);
+ // Call the overload of Console.WriteLine that prints a string.
+ il.EmitCall(OpCodes.Call, writeString, null);
+ // The Hello method returns the value of the second argument;
+ // to do this, load the second argument onto the stack and return.
+ il.Emit(OpCodes.Ldarg_1);
+ il.Emit(OpCodes.Ret);
+ // </Snippet2>
+
+ // <Snippet3>
+ // Create a delegate that represents the dynamic method. This
+ // action completes the method. Further attempts to change the
+ // method are ignored and no exception is thrown.
+ HelloInvoker hi =
+ (HelloInvoker) hello.CreateDelegate(typeof(HelloInvoker));
+ // </Snippet3>
+
+ // Use the delegate to execute the dynamic method. Save and
+ // print the return value.
+ int retval = hi("\r\nHello, World!", 42);
+ Console.WriteLine("Executing delegate hi(\"Hello, World!\", 42) returned {0}",
+ retval);
+
+ // Do it again, with different arguments.
+ retval = hi("\r\nHi, Mom!", 5280);
+ Console.WriteLine("Executing delegate hi(\"Hi, Mom!\", 5280) returned {0}",
+ retval);
+
+ // <Snippet4>
+ // Create an array of arguments to use with the Invoke method.
+ object[] invokeArgs = {"\r\nHello, World!", 42};
+ // Invoke the dynamic method using the arguments. This is much
+ // slower than using the delegate, because you must create an
+ // array to contain the arguments, and ValueType arguments
+ // must be boxed.
+ object objRet = hello.Invoke(null, invokeArgs);
+ Console.WriteLine("hello.Invoke returned {0}", objRet);
+ // </Snippet4>
+ }
+}
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/vb/Project.vbproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/includes/context.md

@@ -1 +1,2 @@
-This article provides supplementary remarks to the reference documentation for this API.
+> [!NOTE]
+> This article provides supplementary remarks to the reference documentation for this API.

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/Project.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source.cs

@@ -0,0 +1,145 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+// These classes are for demonstration purposes.
+//
+public class Example
+{
+ private int id = 0;
+ public Example(int id)
+ {
+ this.id = id;
+ }
+ public int ID { get { return id; }}
+}
+
+public class DerivedFromExample : Example
+{
+ public DerivedFromExample(int id) : base(id) {}
+}
+
+// Two delegates are declared: UseLikeInstance treats the dynamic
+// method as if it were an instance method, and UseLikeStatic
+// treats the dynamic method in the ordinary fashion.
+//
+public delegate int UseLikeInstance(int newID);
+public delegate int UseLikeStatic(Example ex, int newID);
+
+public class Demo
+{
+ public static void Main()
+ {
+ // This dynamic method changes the private id field. It has
+ // no name; it returns the old id value (return type int);
+ // it takes two parameters, an instance of Example and
+ // an int that is the new value of id; and it is declared
+ // with Example as the owner type, so it can access all
+ // members, public and private.
+ //
+ DynamicMethod changeID = new DynamicMethod(
+ "",
+ typeof(int),
+ new Type[] { typeof(Example), typeof(int) },
+ typeof(Example)
+ );
+
+ // Get a FieldInfo for the private field 'id'.
+ FieldInfo fid = typeof(Example).GetField(
+ "id",
+ BindingFlags.NonPublic | BindingFlags.Instance
+ );
+
+ ILGenerator ilg = changeID.GetILGenerator();
+
+ // Push the current value of the id field onto the
+ // evaluation stack. It's an instance field, so load the
+ // instance of Example before accessing the field.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldfld, fid);
+
+ // Load the instance of Example again, load the new value
+ // of id, and store the new field value.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldarg_1);
+ ilg.Emit(OpCodes.Stfld, fid);
+
+ // The original value of the id field is now the only
+ // thing on the stack, so return from the call.
+ ilg.Emit(OpCodes.Ret);
+
+ // Create a delegate that uses changeID in the ordinary
+ // way, as a static method that takes an instance of
+ // Example and an int.
+ //
+ UseLikeStatic uls =
+ (UseLikeStatic) changeID.CreateDelegate(
+ typeof(UseLikeStatic)
+ );
+
+ // Create an instance of Example with an id of 42.
+ //
+ Example ex = new Example(42);
+
+ // Create a delegate that is bound to the instance of
+ // of Example. This is possible because the first
+ // parameter of changeID is of type Example. The
+ // delegate has all the parameters of changeID except
+ // the first.
+ UseLikeInstance uli =
+ (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ ex
+ );
+
+ // First, change the value of id by calling changeID as
+ // a static method, passing in the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(ex, 1492)
+ );
+
+ // Change the value of id again using the delegate bound
+ // to the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(2700)
+ );
+
+ Console.WriteLine("Final value of id: {0}", ex.ID);
+
+ // Now repeat the process with a class that derives
+ // from Example.
+ //
+ DerivedFromExample dfex = new DerivedFromExample(71);
+
+ uli = (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ dfex
+ );
+
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(dfex, 73)
+ );
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(79)
+ );
+ Console.WriteLine("Final value of id: {0}", dfex.ID);
+ }
+}
+
+/* This code example produces the following output:
+
+Change the value of id; previous value: 42
+Change the value of id; previous value: 1492
+Final value of id: 2700
+Change the value of id; previous value: 71
+Change the value of id; previous value: 73
+Final value of id: 79
+ */
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source1.cs

@@ -0,0 +1,80 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+public class Test
+{
+ // Declare a delegate that will be used to execute the completed
+ // dynamic method.
+ private delegate int HelloInvoker(string msg, int ret);
+
+ public static void Main()
+ {
+ // Create an array that specifies the types of the parameters
+ // of the dynamic method. This method has a string parameter
+ // and an int parameter.
+ Type[] helloArgs = {typeof(string), typeof(int)};
+
+ // Create a dynamic method with the name "Hello", a return type
+ // of int, and two parameters whose types are specified by the
+ // array helloArgs. Create the method in the module that
+ // defines the Test class.
+ DynamicMethod hello = new DynamicMethod("Hello",
+ typeof(int),
+ helloArgs,
+ typeof(Test).Module);
+
+ // <Snippet2>
+ // Create an array that specifies the parameter types of the
+ // overload of Console.WriteLine to be used in Hello.
+ Type[] writeStringArgs = {typeof(string)};
+ // Get the overload of Console.WriteLine that has one
+ // String parameter.
+ MethodInfo writeString =
+ typeof(Console).GetMethod("WriteLine", writeStringArgs);
+
+ // Get an ILGenerator and emit a body for the dynamic method.
+ ILGenerator il = hello.GetILGenerator();
+ // Load the first argument, which is a string, onto the stack.
+ il.Emit(OpCodes.Ldarg_0);
+ // Call the overload of Console.WriteLine that prints a string.
+ il.EmitCall(OpCodes.Call, writeString, null);
+ // The Hello method returns the value of the second argument;
+ // to do this, load the second argument onto the stack and return.
+ il.Emit(OpCodes.Ldarg_1);
+ il.Emit(OpCodes.Ret);
+ // </Snippet2>
+
+ // <Snippet3>
+ // Create a delegate that represents the dynamic method. This
+ // action completes the method. Further attempts to change the
+ // method are ignored and no exception is thrown.
+ HelloInvoker hi =
+ (HelloInvoker) hello.CreateDelegate(typeof(HelloInvoker));
+ // </Snippet3>
+
+ // Use the delegate to execute the dynamic method. Save and
+ // print the return value.
+ int retval = hi("\r\nHello, World!", 42);
+ Console.WriteLine("Executing delegate hi(\"Hello, World!\", 42) returned {0}",
+ retval);
+
+ // Do it again, with different arguments.
+ retval = hi("\r\nHi, Mom!", 5280);
+ Console.WriteLine("Executing delegate hi(\"Hi, Mom!\", 5280) returned {0}",
+ retval);
+
+ // <Snippet4>
+ // Create an array of arguments to use with the Invoke method.
+ object[] invokeArgs = {"\r\nHello, World!", 42};
+ // Invoke the dynamic method using the arguments. This is much
+ // slower than using the delegate, because you must create an
+ // array to contain the arguments, and ValueType arguments
+ // must be boxed.
+ object objRet = hello.Invoke(null, invokeArgs);
+ Console.WriteLine("hello.Invoke returned {0}", objRet);
+ // </Snippet4>
+ }
+}
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/vb/Project.vbproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/includes/context.md

@@ -1 +1,2 @@
-This article provides supplementary remarks to the reference documentation for this API.
+> [!NOTE]
+> This article provides supplementary remarks to the reference documentation for this API.

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/Project.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source.cs

@@ -0,0 +1,145 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+// These classes are for demonstration purposes.
+//
+public class Example
+{
+ private int id = 0;
+ public Example(int id)
+ {
+ this.id = id;
+ }
+ public int ID { get { return id; }}
+}
+
+public class DerivedFromExample : Example
+{
+ public DerivedFromExample(int id) : base(id) {}
+}
+
+// Two delegates are declared: UseLikeInstance treats the dynamic
+// method as if it were an instance method, and UseLikeStatic
+// treats the dynamic method in the ordinary fashion.
+//
+public delegate int UseLikeInstance(int newID);
+public delegate int UseLikeStatic(Example ex, int newID);
+
+public class Demo
+{
+ public static void Main()
+ {
+ // This dynamic method changes the private id field. It has
+ // no name; it returns the old id value (return type int);
+ // it takes two parameters, an instance of Example and
+ // an int that is the new value of id; and it is declared
+ // with Example as the owner type, so it can access all
+ // members, public and private.
+ //
+ DynamicMethod changeID = new DynamicMethod(
+ "",
+ typeof(int),
+ new Type[] { typeof(Example), typeof(int) },
+ typeof(Example)
+ );
+
+ // Get a FieldInfo for the private field 'id'.
+ FieldInfo fid = typeof(Example).GetField(
+ "id",
+ BindingFlags.NonPublic | BindingFlags.Instance
+ );
+
+ ILGenerator ilg = changeID.GetILGenerator();
+
+ // Push the current value of the id field onto the
+ // evaluation stack. It's an instance field, so load the
+ // instance of Example before accessing the field.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldfld, fid);
+
+ // Load the instance of Example again, load the new value
+ // of id, and store the new field value.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldarg_1);
+ ilg.Emit(OpCodes.Stfld, fid);
+
+ // The original value of the id field is now the only
+ // thing on the stack, so return from the call.
+ ilg.Emit(OpCodes.Ret);
+
+ // Create a delegate that uses changeID in the ordinary
+ // way, as a static method that takes an instance of
+ // Example and an int.
+ //
+ UseLikeStatic uls =
+ (UseLikeStatic) changeID.CreateDelegate(
+ typeof(UseLikeStatic)
+ );
+
+ // Create an instance of Example with an id of 42.
+ //
+ Example ex = new Example(42);
+
+ // Create a delegate that is bound to the instance of
+ // of Example. This is possible because the first
+ // parameter of changeID is of type Example. The
+ // delegate has all the parameters of changeID except
+ // the first.
+ UseLikeInstance uli =
+ (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ ex
+ );
+
+ // First, change the value of id by calling changeID as
+ // a static method, passing in the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(ex, 1492)
+ );
+
+ // Change the value of id again using the delegate bound
+ // to the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(2700)
+ );
+
+ Console.WriteLine("Final value of id: {0}", ex.ID);
+
+ // Now repeat the process with a class that derives
+ // from Example.
+ //
+ DerivedFromExample dfex = new DerivedFromExample(71);
+
+ uli = (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ dfex
+ );
+
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(dfex, 73)
+ );
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(79)
+ );
+ Console.WriteLine("Final value of id: {0}", dfex.ID);
+ }
+}
+
+/* This code example produces the following output:
+
+Change the value of id; previous value: 42
+Change the value of id; previous value: 1492
+Final value of id: 2700
+Change the value of id; previous value: 71
+Change the value of id; previous value: 73
+Final value of id: 79
+ */
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source1.cs

@@ -0,0 +1,80 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+public class Test
+{
+ // Declare a delegate that will be used to execute the completed
+ // dynamic method.
+ private delegate int HelloInvoker(string msg, int ret);
+
+ public static void Main()
+ {
+ // Create an array that specifies the types of the parameters
+ // of the dynamic method. This method has a string parameter
+ // and an int parameter.
+ Type[] helloArgs = {typeof(string), typeof(int)};
+
+ // Create a dynamic method with the name "Hello", a return type
+ // of int, and two parameters whose types are specified by the
+ // array helloArgs. Create the method in the module that
+ // defines the Test class.
+ DynamicMethod hello = new DynamicMethod("Hello",
+ typeof(int),
+ helloArgs,
+ typeof(Test).Module);
+
+ // <Snippet2>
+ // Create an array that specifies the parameter types of the
+ // overload of Console.WriteLine to be used in Hello.
+ Type[] writeStringArgs = {typeof(string)};
+ // Get the overload of Console.WriteLine that has one
+ // String parameter.
+ MethodInfo writeString =
+ typeof(Console).GetMethod("WriteLine", writeStringArgs);
+
+ // Get an ILGenerator and emit a body for the dynamic method.
+ ILGenerator il = hello.GetILGenerator();
+ // Load the first argument, which is a string, onto the stack.
+ il.Emit(OpCodes.Ldarg_0);
+ // Call the overload of Console.WriteLine that prints a string.
+ il.EmitCall(OpCodes.Call, writeString, null);
+ // The Hello method returns the value of the second argument;
+ // to do this, load the second argument onto the stack and return.
+ il.Emit(OpCodes.Ldarg_1);
+ il.Emit(OpCodes.Ret);
+ // </Snippet2>
+
+ // <Snippet3>
+ // Create a delegate that represents the dynamic method. This
+ // action completes the method. Further attempts to change the
+ // method are ignored and no exception is thrown.
+ HelloInvoker hi =
+ (HelloInvoker) hello.CreateDelegate(typeof(HelloInvoker));
+ // </Snippet3>
+
+ // Use the delegate to execute the dynamic method. Save and
+ // print the return value.
+ int retval = hi("\r\nHello, World!", 42);
+ Console.WriteLine("Executing delegate hi(\"Hello, World!\", 42) returned {0}",
+ retval);
+
+ // Do it again, with different arguments.
+ retval = hi("\r\nHi, Mom!", 5280);
+ Console.WriteLine("Executing delegate hi(\"Hi, Mom!\", 5280) returned {0}",
+ retval);
+
+ // <Snippet4>
+ // Create an array of arguments to use with the Invoke method.
+ object[] invokeArgs = {"\r\nHello, World!", 42};
+ // Invoke the dynamic method using the arguments. This is much
+ // slower than using the delegate, because you must create an
+ // array to contain the arguments, and ValueType arguments
+ // must be boxed.
+ object objRet = hello.Invoke(null, invokeArgs);
+ Console.WriteLine("hello.Invoke returned {0}", objRet);
+ // </Snippet4>
+ }
+}
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/vb/Project.vbproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/includes/context.md

@@ -1 +1,2 @@
-This article provides supplementary remarks to the reference documentation for this API.
+> [!NOTE]
+> This article provides supplementary remarks to the reference documentation for this API.

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/Project.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source.cs

@@ -0,0 +1,145 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+// These classes are for demonstration purposes.
+//
+public class Example
+{
+ private int id = 0;
+ public Example(int id)
+ {
+ this.id = id;
+ }
+ public int ID { get { return id; }}
+}
+
+public class DerivedFromExample : Example
+{
+ public DerivedFromExample(int id) : base(id) {}
+}
+
+// Two delegates are declared: UseLikeInstance treats the dynamic
+// method as if it were an instance method, and UseLikeStatic
+// treats the dynamic method in the ordinary fashion.
+//
+public delegate int UseLikeInstance(int newID);
+public delegate int UseLikeStatic(Example ex, int newID);
+
+public class Demo
+{
+ public static void Main()
+ {
+ // This dynamic method changes the private id field. It has
+ // no name; it returns the old id value (return type int);
+ // it takes two parameters, an instance of Example and
+ // an int that is the new value of id; and it is declared
+ // with Example as the owner type, so it can access all
+ // members, public and private.
+ //
+ DynamicMethod changeID = new DynamicMethod(
+ "",
+ typeof(int),
+ new Type[] { typeof(Example), typeof(int) },
+ typeof(Example)
+ );
+
+ // Get a FieldInfo for the private field 'id'.
+ FieldInfo fid = typeof(Example).GetField(
+ "id",
+ BindingFlags.NonPublic | BindingFlags.Instance
+ );
+
+ ILGenerator ilg = changeID.GetILGenerator();
+
+ // Push the current value of the id field onto the
+ // evaluation stack. It's an instance field, so load the
+ // instance of Example before accessing the field.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldfld, fid);
+
+ // Load the instance of Example again, load the new value
+ // of id, and store the new field value.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldarg_1);
+ ilg.Emit(OpCodes.Stfld, fid);
+
+ // The original value of the id field is now the only
+ // thing on the stack, so return from the call.
+ ilg.Emit(OpCodes.Ret);
+
+ // Create a delegate that uses changeID in the ordinary
+ // way, as a static method that takes an instance of
+ // Example and an int.
+ //
+ UseLikeStatic uls =
+ (UseLikeStatic) changeID.CreateDelegate(
+ typeof(UseLikeStatic)
+ );
+
+ // Create an instance of Example with an id of 42.
+ //
+ Example ex = new Example(42);
+
+ // Create a delegate that is bound to the instance of
+ // of Example. This is possible because the first
+ // parameter of changeID is of type Example. The
+ // delegate has all the parameters of changeID except
+ // the first.
+ UseLikeInstance uli =
+ (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ ex
+ );
+
+ // First, change the value of id by calling changeID as
+ // a static method, passing in the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(ex, 1492)
+ );
+
+ // Change the value of id again using the delegate bound
+ // to the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(2700)
+ );
+
+ Console.WriteLine("Final value of id: {0}", ex.ID);
+
+ // Now repeat the process with a class that derives
+ // from Example.
+ //
+ DerivedFromExample dfex = new DerivedFromExample(71);
+
+ uli = (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ dfex
+ );
+
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(dfex, 73)
+ );
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(79)
+ );
+ Console.WriteLine("Final value of id: {0}", dfex.ID);
+ }
+}
+
+/* This code example produces the following output:
+
+Change the value of id; previous value: 42
+Change the value of id; previous value: 1492
+Final value of id: 2700
+Change the value of id; previous value: 71
+Change the value of id; previous value: 73
+Final value of id: 79
+ */
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source1.cs

@@ -0,0 +1,80 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+public class Test
+{
+ // Declare a delegate that will be used to execute the completed
+ // dynamic method.
+ private delegate int HelloInvoker(string msg, int ret);
+
+ public static void Main()
+ {
+ // Create an array that specifies the types of the parameters
+ // of the dynamic method. This method has a string parameter
+ // and an int parameter.
+ Type[] helloArgs = {typeof(string), typeof(int)};
+
+ // Create a dynamic method with the name "Hello", a return type
+ // of int, and two parameters whose types are specified by the
+ // array helloArgs. Create the method in the module that
+ // defines the Test class.
+ DynamicMethod hello = new DynamicMethod("Hello",
+ typeof(int),
+ helloArgs,
+ typeof(Test).Module);
+
+ // <Snippet2>
+ // Create an array that specifies the parameter types of the
+ // overload of Console.WriteLine to be used in Hello.
+ Type[] writeStringArgs = {typeof(string)};
+ // Get the overload of Console.WriteLine that has one
+ // String parameter.
+ MethodInfo writeString =
+ typeof(Console).GetMethod("WriteLine", writeStringArgs);
+
+ // Get an ILGenerator and emit a body for the dynamic method.
+ ILGenerator il = hello.GetILGenerator();
+ // Load the first argument, which is a string, onto the stack.
+ il.Emit(OpCodes.Ldarg_0);
+ // Call the overload of Console.WriteLine that prints a string.
+ il.EmitCall(OpCodes.Call, writeString, null);
+ // The Hello method returns the value of the second argument;
+ // to do this, load the second argument onto the stack and return.
+ il.Emit(OpCodes.Ldarg_1);
+ il.Emit(OpCodes.Ret);
+ // </Snippet2>
+
+ // <Snippet3>
+ // Create a delegate that represents the dynamic method. This
+ // action completes the method. Further attempts to change the
+ // method are ignored and no exception is thrown.
+ HelloInvoker hi =
+ (HelloInvoker) hello.CreateDelegate(typeof(HelloInvoker));
+ // </Snippet3>
+
+ // Use the delegate to execute the dynamic method. Save and
+ // print the return value.
+ int retval = hi("\r\nHello, World!", 42);
+ Console.WriteLine("Executing delegate hi(\"Hello, World!\", 42) returned {0}",
+ retval);
+
+ // Do it again, with different arguments.
+ retval = hi("\r\nHi, Mom!", 5280);
+ Console.WriteLine("Executing delegate hi(\"Hi, Mom!\", 5280) returned {0}",
+ retval);
+
+ // <Snippet4>
+ // Create an array of arguments to use with the Invoke method.
+ object[] invokeArgs = {"\r\nHello, World!", 42};
+ // Invoke the dynamic method using the arguments. This is much
+ // slower than using the delegate, because you must create an
+ // array to contain the arguments, and ValueType arguments
+ // must be boxed.
+ object objRet = hello.Invoke(null, invokeArgs);
+ Console.WriteLine("hello.Invoke returned {0}", objRet);
+ // </Snippet4>
+ }
+}
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/vb/Project.vbproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/includes/context.md

@@ -1 +1,2 @@
-This article provides supplementary remarks to the reference documentation for this API.
+> [!NOTE]
+> This article provides supplementary remarks to the reference documentation for this API.

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/Project.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source.cs

@@ -0,0 +1,145 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+// These classes are for demonstration purposes.
+//
+public class Example
+{
+ private int id = 0;
+ public Example(int id)
+ {
+ this.id = id;
+ }
+ public int ID { get { return id; }}
+}
+
+public class DerivedFromExample : Example
+{
+ public DerivedFromExample(int id) : base(id) {}
+}
+
+// Two delegates are declared: UseLikeInstance treats the dynamic
+// method as if it were an instance method, and UseLikeStatic
+// treats the dynamic method in the ordinary fashion.
+//
+public delegate int UseLikeInstance(int newID);
+public delegate int UseLikeStatic(Example ex, int newID);
+
+public class Demo
+{
+ public static void Main()
+ {
+ // This dynamic method changes the private id field. It has
+ // no name; it returns the old id value (return type int);
+ // it takes two parameters, an instance of Example and
+ // an int that is the new value of id; and it is declared
+ // with Example as the owner type, so it can access all
+ // members, public and private.
+ //
+ DynamicMethod changeID = new DynamicMethod(
+ "",
+ typeof(int),
+ new Type[] { typeof(Example), typeof(int) },
+ typeof(Example)
+ );
+
+ // Get a FieldInfo for the private field 'id'.
+ FieldInfo fid = typeof(Example).GetField(
+ "id",
+ BindingFlags.NonPublic | BindingFlags.Instance
+ );
+
+ ILGenerator ilg = changeID.GetILGenerator();
+
+ // Push the current value of the id field onto the
+ // evaluation stack. It's an instance field, so load the
+ // instance of Example before accessing the field.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldfld, fid);
+
+ // Load the instance of Example again, load the new value
+ // of id, and store the new field value.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldarg_1);
+ ilg.Emit(OpCodes.Stfld, fid);
+
+ // The original value of the id field is now the only
+ // thing on the stack, so return from the call.
+ ilg.Emit(OpCodes.Ret);
+
+ // Create a delegate that uses changeID in the ordinary
+ // way, as a static method that takes an instance of
+ // Example and an int.
+ //
+ UseLikeStatic uls =
+ (UseLikeStatic) changeID.CreateDelegate(
+ typeof(UseLikeStatic)
+ );
+
+ // Create an instance of Example with an id of 42.
+ //
+ Example ex = new Example(42);
+
+ // Create a delegate that is bound to the instance of
+ // of Example. This is possible because the first
+ // parameter of changeID is of type Example. The
+ // delegate has all the parameters of changeID except
+ // the first.
+ UseLikeInstance uli =
+ (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ ex
+ );
+
+ // First, change the value of id by calling changeID as
+ // a static method, passing in the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(ex, 1492)
+ );
+
+ // Change the value of id again using the delegate bound
+ // to the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(2700)
+ );
+
+ Console.WriteLine("Final value of id: {0}", ex.ID);
+
+ // Now repeat the process with a class that derives
+ // from Example.
+ //
+ DerivedFromExample dfex = new DerivedFromExample(71);
+
+ uli = (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ dfex
+ );
+
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(dfex, 73)
+ );
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(79)
+ );
+ Console.WriteLine("Final value of id: {0}", dfex.ID);
+ }
+}
+
+/* This code example produces the following output:
+
+Change the value of id; previous value: 42
+Change the value of id; previous value: 1492
+Final value of id: 2700
+Change the value of id; previous value: 71
+Change the value of id; previous value: 73
+Final value of id: 79
+ */
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source1.cs

@@ -0,0 +1,80 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+public class Test
+{
+ // Declare a delegate that will be used to execute the completed
+ // dynamic method.
+ private delegate int HelloInvoker(string msg, int ret);
+
+ public static void Main()
+ {
+ // Create an array that specifies the types of the parameters
+ // of the dynamic method. This method has a string parameter
+ // and an int parameter.
+ Type[] helloArgs = {typeof(string), typeof(int)};
+
+ // Create a dynamic method with the name "Hello", a return type
+ // of int, and two parameters whose types are specified by the
+ // array helloArgs. Create the method in the module that
+ // defines the Test class.
+ DynamicMethod hello = new DynamicMethod("Hello",
+ typeof(int),
+ helloArgs,
+ typeof(Test).Module);
+
+ // <Snippet2>
+ // Create an array that specifies the parameter types of the
+ // overload of Console.WriteLine to be used in Hello.
+ Type[] writeStringArgs = {typeof(string)};
+ // Get the overload of Console.WriteLine that has one
+ // String parameter.
+ MethodInfo writeString =
+ typeof(Console).GetMethod("WriteLine", writeStringArgs);
+
+ // Get an ILGenerator and emit a body for the dynamic method.
+ ILGenerator il = hello.GetILGenerator();
+ // Load the first argument, which is a string, onto the stack.
+ il.Emit(OpCodes.Ldarg_0);
+ // Call the overload of Console.WriteLine that prints a string.
+ il.EmitCall(OpCodes.Call, writeString, null);
+ // The Hello method returns the value of the second argument;
+ // to do this, load the second argument onto the stack and return.
+ il.Emit(OpCodes.Ldarg_1);
+ il.Emit(OpCodes.Ret);
+ // </Snippet2>
+
+ // <Snippet3>
+ // Create a delegate that represents the dynamic method. This
+ // action completes the method. Further attempts to change the
+ // method are ignored and no exception is thrown.
+ HelloInvoker hi =
+ (HelloInvoker) hello.CreateDelegate(typeof(HelloInvoker));
+ // </Snippet3>
+
+ // Use the delegate to execute the dynamic method. Save and
+ // print the return value.
+ int retval = hi("\r\nHello, World!", 42);
+ Console.WriteLine("Executing delegate hi(\"Hello, World!\", 42) returned {0}",
+ retval);
+
+ // Do it again, with different arguments.
+ retval = hi("\r\nHi, Mom!", 5280);
+ Console.WriteLine("Executing delegate hi(\"Hi, Mom!\", 5280) returned {0}",
+ retval);
+
+ // <Snippet4>
+ // Create an array of arguments to use with the Invoke method.
+ object[] invokeArgs = {"\r\nHello, World!", 42};
+ // Invoke the dynamic method using the arguments. This is much
+ // slower than using the delegate, because you must create an
+ // array to contain the arguments, and ValueType arguments
+ // must be boxed.
+ object objRet = hello.Invoke(null, invokeArgs);
+ Console.WriteLine("hello.Invoke returned {0}", objRet);
+ // </Snippet4>
+ }
+}
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/vb/Project.vbproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/includes/context.md

@@ -1 +1,2 @@
-This article provides supplementary remarks to the reference documentation for this API.
+> [!NOTE]
+> This article provides supplementary remarks to the reference documentation for this API.

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/Project.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source.cs

@@ -0,0 +1,145 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+// These classes are for demonstration purposes.
+//
+public class Example
+{
+ private int id = 0;
+ public Example(int id)
+ {
+ this.id = id;
+ }
+ public int ID { get { return id; }}
+}
+
+public class DerivedFromExample : Example
+{
+ public DerivedFromExample(int id) : base(id) {}
+}
+
+// Two delegates are declared: UseLikeInstance treats the dynamic
+// method as if it were an instance method, and UseLikeStatic
+// treats the dynamic method in the ordinary fashion.
+//
+public delegate int UseLikeInstance(int newID);
+public delegate int UseLikeStatic(Example ex, int newID);
+
+public class Demo
+{
+ public static void Main()
+ {
+ // This dynamic method changes the private id field. It has
+ // no name; it returns the old id value (return type int);
+ // it takes two parameters, an instance of Example and
+ // an int that is the new value of id; and it is declared
+ // with Example as the owner type, so it can access all
+ // members, public and private.
+ //
+ DynamicMethod changeID = new DynamicMethod(
+ "",
+ typeof(int),
+ new Type[] { typeof(Example), typeof(int) },
+ typeof(Example)
+ );
+
+ // Get a FieldInfo for the private field 'id'.
+ FieldInfo fid = typeof(Example).GetField(
+ "id",
+ BindingFlags.NonPublic | BindingFlags.Instance
+ );
+
+ ILGenerator ilg = changeID.GetILGenerator();
+
+ // Push the current value of the id field onto the
+ // evaluation stack. It's an instance field, so load the
+ // instance of Example before accessing the field.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldfld, fid);
+
+ // Load the instance of Example again, load the new value
+ // of id, and store the new field value.
+ ilg.Emit(OpCodes.Ldarg_0);
+ ilg.Emit(OpCodes.Ldarg_1);
+ ilg.Emit(OpCodes.Stfld, fid);
+
+ // The original value of the id field is now the only
+ // thing on the stack, so return from the call.
+ ilg.Emit(OpCodes.Ret);
+
+ // Create a delegate that uses changeID in the ordinary
+ // way, as a static method that takes an instance of
+ // Example and an int.
+ //
+ UseLikeStatic uls =
+ (UseLikeStatic) changeID.CreateDelegate(
+ typeof(UseLikeStatic)
+ );
+
+ // Create an instance of Example with an id of 42.
+ //
+ Example ex = new Example(42);
+
+ // Create a delegate that is bound to the instance of
+ // of Example. This is possible because the first
+ // parameter of changeID is of type Example. The
+ // delegate has all the parameters of changeID except
+ // the first.
+ UseLikeInstance uli =
+ (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ ex
+ );
+
+ // First, change the value of id by calling changeID as
+ // a static method, passing in the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(ex, 1492)
+ );
+
+ // Change the value of id again using the delegate bound
+ // to the instance of Example.
+ //
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(2700)
+ );
+
+ Console.WriteLine("Final value of id: {0}", ex.ID);
+
+ // Now repeat the process with a class that derives
+ // from Example.
+ //
+ DerivedFromExample dfex = new DerivedFromExample(71);
+
+ uli = (UseLikeInstance) changeID.CreateDelegate(
+ typeof(UseLikeInstance),
+ dfex
+ );
+
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uls(dfex, 73)
+ );
+ Console.WriteLine(
+ "Change the value of id; previous value: {0}",
+ uli(79)
+ );
+ Console.WriteLine("Final value of id: {0}", dfex.ID);
+ }
+}
+
+/* This code example produces the following output:
+
+Change the value of id; previous value: 42
+Change the value of id; previous value: 1492
+Final value of id: 2700
+Change the value of id; previous value: 71
+Change the value of id; previous value: 73
+Final value of id: 79
+ */
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/csharp/source1.cs

@@ -0,0 +1,80 @@
+//<Snippet1>
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+public class Test
+{
+ // Declare a delegate that will be used to execute the completed
+ // dynamic method.
+ private delegate int HelloInvoker(string msg, int ret);
+
+ public static void Main()
+ {
+ // Create an array that specifies the types of the parameters
+ // of the dynamic method. This method has a string parameter
+ // and an int parameter.
+ Type[] helloArgs = {typeof(string), typeof(int)};
+
+ // Create a dynamic method with the name "Hello", a return type
+ // of int, and two parameters whose types are specified by the
+ // array helloArgs. Create the method in the module that
+ // defines the Test class.
+ DynamicMethod hello = new DynamicMethod("Hello",
+ typeof(int),
+ helloArgs,
+ typeof(Test).Module);
+
+ // <Snippet2>
+ // Create an array that specifies the parameter types of the
+ // overload of Console.WriteLine to be used in Hello.
+ Type[] writeStringArgs = {typeof(string)};
+ // Get the overload of Console.WriteLine that has one
+ // String parameter.
+ MethodInfo writeString =
+ typeof(Console).GetMethod("WriteLine", writeStringArgs);
+
+ // Get an ILGenerator and emit a body for the dynamic method.
+ ILGenerator il = hello.GetILGenerator();
+ // Load the first argument, which is a string, onto the stack.
+ il.Emit(OpCodes.Ldarg_0);
+ // Call the overload of Console.WriteLine that prints a string.
+ il.EmitCall(OpCodes.Call, writeString, null);
+ // The Hello method returns the value of the second argument;
+ // to do this, load the second argument onto the stack and return.
+ il.Emit(OpCodes.Ldarg_1);
+ il.Emit(OpCodes.Ret);
+ // </Snippet2>
+
+ // <Snippet3>
+ // Create a delegate that represents the dynamic method. This
+ // action completes the method. Further attempts to change the
+ // method are ignored and no exception is thrown.
+ HelloInvoker hi =
+ (HelloInvoker) hello.CreateDelegate(typeof(HelloInvoker));
+ // </Snippet3>
+
+ // Use the delegate to execute the dynamic method. Save and
+ // print the return value.
+ int retval = hi("\r\nHello, World!", 42);
+ Console.WriteLine("Executing delegate hi(\"Hello, World!\", 42) returned {0}",
+ retval);
+
+ // Do it again, with different arguments.
+ retval = hi("\r\nHi, Mom!", 5280);
+ Console.WriteLine("Executing delegate hi(\"Hi, Mom!\", 5280) returned {0}",
+ retval);
+
+ // <Snippet4>
+ // Create an array of arguments to use with the Invoke method.
+ object[] invokeArgs = {"\r\nHello, World!", 42};
+ // Invoke the dynamic method using the arguments. This is much
+ // slower than using the delegate, because you must create an
+ // array to contain the arguments, and ValueType arguments
+ // must be boxed.
+ object objRet = hello.Invoke(null, invokeArgs);
+ Console.WriteLine("hello.Invoke returned {0}", objRet);
+ // </Snippet4>
+ }
+}
+//</Snippet1>

docs/fundamentals/runtime-libraries/snippets/System.Reflection.Emit/DynamicMethod/.ctor/vb/Project.vbproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Library</OutputType>
+ <TargetFramework>net10.0</TargetFramework>
+ </PropertyGroup>
+
+</Project>