Fix resolving types with primary constructors using in parameters

src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/CallSiteFactory.cs

@@ -575,6 +575,17 @@ private ConstructorCallSite CreateConstructorCallSite(
             {
                 ServiceCallSite? callSite = null;
                 Type parameterType = parameters[index].ParameterType;
+
+                // reference types cannot be resolved directly, but can be resolved via their underlying type
+                if (parameterType.IsByRef)
+                {
+                    Type? elementType = parameterType.GetElementType();
+                    if (elementType != null)
+                    {
+                        parameterType = elementType;
+                    }
+                }
+
                 foreach (var attribute in parameters[index].GetCustomAttributes(true))
                 {
                     if (serviceIdentifier.ServiceKey != null && attribute is ServiceKeyAttribute)

src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceLookup/CallSiteFactoryTest.cs

@@ -78,6 +78,7 @@ public void CreateCallSite_CreatesInstanceCallSite_IfTypeHasDefaultOrPublicParam
         [InlineData(typeof(TypeWithParameterizedAndNullaryConstructor))]
         [InlineData(typeof(TypeWithMultipleParameterizedConstructors))]
         [InlineData(typeof(TypeWithSupersetConstructors))]
+        [InlineData(typeof(TypeWithPrimaryConstructorWithInDependency))]
         public void CreateCallSite_CreatesConstructorCallSite_IfTypeHasConstructorWithInjectableParameters(Type type)
         {
             // Arrange
@@ -1008,7 +1009,15 @@ private static IEnumerable<Type> GetParameters(ConstructorCallSite constructorCa
             constructorCallSite
                 .ConstructorInfo
                 .GetParameters()
-                .Select(p => p.ParameterType);
+                .Select(p => {
+                    var type = p.ParameterType;
+                    if (type.IsByRef)
+                    {
+                        var refType = type.GetElementType();
+                        return refType ?? type;
+                    }
+                    return type;
+                });
 
         private static ConstructorInfo GetConstructor(Type type, Type[] parameterTypes) =>
             type.GetTypeInfo().DeclaredConstructors.First(

src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceLookup/Types/TypeWithPrimaryConstructorWithInDependency.cs

@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.DependencyInjection.Specification.Fakes;
+
+namespace Microsoft.Extensions.DependencyInjection.ServiceLookup
+{
+    public class TypeWithPrimaryConstructorWithInDependency(in IFakeService fakeService)
+    {
+        private readonly IFakeService _fakeService = fakeService;
+    }
+}

src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderValidationTests.cs

@@ -239,6 +239,20 @@ public void GetService_DoesNotThrow_WhenGetServiceForNonScopedImplementationWith
             Assert.NotNull(result);
         }
 
+        [Fact]
+        public void GetService_DoesNotThrow_WhenGetServiceForNonScopedImplementationWithPrimaryConstructorUsingInParameter()
+        {
+            // Arrange
+            var serviceCollection = new ServiceCollection();
+            serviceCollection.AddSingleton<IBar, Bar>();
+            serviceCollection.AddSingleton<IFoo, FooWithInDependency>();
+            var serviceProvider = serviceCollection.BuildServiceProvider(true);
+
+            // Act + Assert
+            var foo = serviceProvider.GetService(typeof(IFoo));
+            Assert.NotNull(foo);
+        }
+
         [Fact]
         public void BuildServiceProvider_ValidateOnBuild_Throws_WhenScopedIsInjectedIntoSingleton()
         {
@@ -412,6 +426,11 @@ public Foo2(IBar bar)
             }
         }
 
+        private class FooWithInDependency(in IBar bar) : IFoo
+        {
+            private readonly IBar bar = bar;
+        }
+
         private interface IBar
         {
         }