Added ResolveWith overload that takes a Delegate

src/HotChocolate/Core/src/Types/Types/Descriptors/Contracts/IObjectFieldDescriptor.cs

@@ -233,6 +233,37 @@ IObjectFieldDescriptor ResolveWith<TResolver>(
     /// <returns></returns>
     IObjectFieldDescriptor ResolveWith(MemberInfo propertyOrMethod);
 
+    /// <summary>
+    /// Adds a resolver based on a delegate to the field.
+    /// A resolver is a method that resolves the value for a
+    /// field. The resolver can access parent object, arguments, services and more through the
+    /// <see cref="IResolverContext"/>.
+    /// </summary>
+    /// <param name="delegate">The resolver of the field</param>
+    /// <example>
+    /// Given the following resolvers class
+    /// <code>
+    /// <![CDATA[
+    /// private static class Resolvers
+    /// {
+    ///    public static ValueTask<string> GetFoo(
+    ///        [Service] IFooService service,
+    ///        CancellationToken cancellationToken) =>
+    ///        service.GetFooAsync(cancellationToken);
+    /// }
+    /// ]]>
+    /// </code>
+    /// The GetFoo method can be mapped like:
+    /// <code>
+    /// <![CDATA[
+    /// descriptor
+    ///     .Field(x => x.Foo)
+    ///     .ResolveWith(Resolvers.GetFoo);
+    /// ]]>
+    /// </code>
+    /// </example>
+    IObjectFieldDescriptor ResolveWith(Delegate @delegate);
+
     /// <summary>
     /// Adds a subscription resolver to to the field
     /// </summary>

src/HotChocolate/Core/src/Types/Types/Descriptors/ObjectFieldDescriptor.cs

@@ -390,6 +390,17 @@ public IObjectFieldDescriptor ResolveWith(MemberInfo propertyOrMethod)
         return ResolveWithInternal(propertyOrMethod, propertyOrMethod.DeclaringType);
     }
 
+    /// <inheritdoc />
+    public IObjectFieldDescriptor ResolveWith(Delegate @delegate)
+    {
+        if (@delegate is null)
+        {
+            throw new ArgumentNullException(nameof(@delegate));
+        }
+
+        return ResolveWithInternal(@delegate.Method, resolverType: null);
+    }
+
     private IObjectFieldDescriptor ResolveWithInternal(
         MemberInfo propertyOrMethod,
         Type? resolverType)

src/HotChocolate/Core/test/Types.Tests/Types/ObjectTypeTests.cs

@@ -1733,6 +1733,30 @@ public void ResolveWithAsync()
             .MatchSnapshot();
     }
 
+    [Fact]
+    public void ResolveWithStatic()
+    {
+        SchemaBuilder.New()
+            .AddQueryType<ResolveWithStaticQueryType>()
+            .Create()
+            .MakeExecutable()
+            .Execute("{ foo baz }")
+            .ToJson()
+            .MatchSnapshot();
+    }
+
+    [Fact]
+    public void ResolveWithStaticAsync()
+    {
+        SchemaBuilder.New()
+            .AddQueryType<ResolveWithStaticQueryTypeAsync>()
+            .Create()
+            .MakeExecutable()
+            .Execute("{ foo baz qux }")
+            .ToJson()
+            .MatchSnapshot();
+    }
+
     [Fact]
     public void ResolveWith_NonGeneric()
     {
@@ -2316,6 +2340,16 @@ public Task<bool> BarAsync(IResolverContext context)
             => Task.FromResult(context is not null);
     }
 
+    public static class ResolveWithStaticQueryResolver
+    {
+        public static string Bar() => "Bar";
+
+        public static Task<string> FooAsync() => Task.FromResult("Foo");
+
+        public static Task<bool> BarAsync(IResolverContext context)
+            => Task.FromResult(context is not null);
+    }
+
     public class ResolveWithQueryType : ObjectType<ResolveWithQuery>
     {
         protected override void Configure(IObjectTypeDescriptor<ResolveWithQuery> descriptor)
@@ -2341,6 +2375,25 @@ protected override void Configure(IObjectTypeDescriptor<ResolveWithQuery> descri
         }
     }
 
+    public class ResolveWithStaticQueryType : ObjectType<ResolveWithQuery>
+    {
+        protected override void Configure(IObjectTypeDescriptor<ResolveWithQuery> descriptor)
+        {
+            descriptor.Field(t => t.Foo).ResolveWith(ResolveWithStaticQueryResolver.Bar);
+            descriptor.Field("baz").ResolveWith(ResolveWithStaticQueryResolver.Bar);
+        }
+    }
+
+    public class ResolveWithStaticQueryTypeAsync : ObjectType<ResolveWithQuery>
+    {
+        protected override void Configure(IObjectTypeDescriptor<ResolveWithQuery> descriptor)
+        {
+            descriptor.Field(t => t.Foo).ResolveWith(ResolveWithStaticQueryResolver.FooAsync);
+            descriptor.Field("baz").ResolveWith(ResolveWithStaticQueryResolver.FooAsync);
+            descriptor.Field("qux").ResolveWith(ResolveWithStaticQueryResolver.BarAsync);
+        }
+    }
+
     public class ResolveWithNonGenericObjectType : ObjectType
     {
         protected override void Configure(IObjectTypeDescriptor descriptor)

src/HotChocolate/Core/test/Types.Tests/Types/__snapshots__/ObjectTypeTests.ResolveWithStatic.snap

@@ -0,0 +1,6 @@
+{
+  "data": {
+    "foo": "Bar",
+    "baz": "Bar"
+  }
+}

src/HotChocolate/Core/test/Types.Tests/Types/__snapshots__/ObjectTypeTests.ResolveWithStaticAsync.snap

@@ -0,0 +1,7 @@
+{
+  "data": {
+    "foo": "Foo",
+    "baz": "Foo",
+    "qux": true
+  }
+}