[AOT] Fix RuntimeContext warnings

src/OpenTelemetry.Api/Context/RuntimeContext.cs

@@ -27,10 +27,52 @@ public static class RuntimeContext
     {
         private static readonly ConcurrentDictionary<string, object> Slots = new();
 
+        private static Type contextSlotType;
+
+        private static RuntimeContextSlotFactory runtimeContextSlotFactory;
+
+        static RuntimeContext()
+        {
+            ContextSlotType = typeof(AsyncLocalRuntimeContextSlot<>);
+        }
+
         /// <summary>
         /// Gets or sets the actual context carrier implementation.
         /// </summary>
-        public static Type ContextSlotType { get; set; } = typeof(AsyncLocalRuntimeContextSlot<>);
+        public static Type ContextSlotType
+        {
+            get => contextSlotType;
+            set
+            {
+                Guard.ThrowIfNull(value, nameof(value));
+
+                if (!value.IsGenericType || !value.IsGenericTypeDefinition || value.GetGenericArguments().Length != 1)
+                {
+                    throw new NotSupportedException($"Type '{value}' must be generic with a single generic type argument");
+                }
+
+                if (value == typeof(AsyncLocalRuntimeContextSlot<>))
+                {
+                    runtimeContextSlotFactory = new RuntimeContextSlotFactory.AsyncLocalRuntimeContextSlotFactory();
+                }
+                else if (value == typeof(ThreadLocalRuntimeContextSlot<>))
+                {
+                    runtimeContextSlotFactory = new RuntimeContextSlotFactory.ThreadLocalRuntimeContextSlotFactory();
+                }
+#if NETFRAMEWORK
+                else if (value == typeof(RemotingRuntimeContextSlot<>))
+                {
+                    runtimeContextSlotFactory = new RuntimeContextSlotFactory.RemotingRuntimeContextSlotFactory();
+                }
+#endif
+                else
+                {
+                    throw new NotSupportedException("${value} is not supported.");
+                }
+
+                contextSlotType = value;
+            }
+        }
 
         /// <summary>
         /// Register a named context slot.
@@ -49,9 +91,8 @@ public static RuntimeContextSlot<T> RegisterSlot<T>(string slotName)
                     throw new InvalidOperationException($"Context slot already registered: '{slotName}'");
                 }
 
-                var type = ContextSlotType.MakeGenericType(typeof(T));
-                var ctor = type.GetConstructor(new Type[] { typeof(string) });
-                var slot = (RuntimeContextSlot<T>)ctor.Invoke(new object[] { slotName });
+                var slot = runtimeContextSlotFactory.Create<T>(slotName);
+
                 Slots[slotName] = slot;
                 return slot;
             }

src/OpenTelemetry.Api/Context/RuntimeContextSlotFactory.cs

@@ -0,0 +1,45 @@
+// <copyright file="RuntimeContextSlotFactory.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+#nullable enable
+
+namespace OpenTelemetry.Context
+{
+    internal abstract class RuntimeContextSlotFactory
+    {
+        public abstract RuntimeContextSlot<T> Create<T>(string name);
+
+        public sealed class AsyncLocalRuntimeContextSlotFactory : RuntimeContextSlotFactory
+        {
+            public override RuntimeContextSlot<T> Create<T>(string name)
+                => new AsyncLocalRuntimeContextSlot<T>(name);
+        }
+
+#if NETFRAMEWORK
+        public sealed class RemotingRuntimeContextSlotFactory : RuntimeContextSlotFactory
+        {
+            public override RuntimeContextSlot<T> Create<T>(string name)
+                => new RemotingRuntimeContextSlot<T>(name);
+        }
+#endif
+
+        public sealed class ThreadLocalRuntimeContextSlotFactory : RuntimeContextSlotFactory
+        {
+            public override RuntimeContextSlot<T> Create<T>(string name)
+                => new ThreadLocalRuntimeContextSlot<T>(name);
+        }
+    }
+}

test/OpenTelemetry.AotCompatibility.Tests/AotCompatibilityTests.cs

@@ -85,7 +85,7 @@ public void EnsureAotCompatibility()
             Assert.True(process.ExitCode == 0, "Publishing the AotCompatibility app failed. See test output for more details.");
 
             var warnings = expectedOutput.ToString().Split('\n', '\r').Where(line => line.Contains("warning IL"));
-            Assert.Equal(58, warnings.Count());
+            Assert.Equal(55, warnings.Count());
         }
     }
 }