diff --git a/src/MagicOnion.Abstractions/Internal/RawBytesBox.cs b/src/MagicOnion.Abstractions/Internal/RawBytesBox.cs
new file mode 100644
index 000000000..00b4a2e5f
--- /dev/null
+++ b/src/MagicOnion.Abstractions/Internal/RawBytesBox.cs
@@ -0,0 +1,17 @@
+using System;
+using System.ComponentModel;
+
+namespace MagicOnion.Internal
+{
+    // Pubternal API
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public sealed class RawBytesBox
+    {
+        public ReadOnlyMemory<byte> Bytes { get; }
+
+        public RawBytesBox(ReadOnlyMemory<byte> bytes)
+        {
+            Bytes = bytes;
+        }
+    }
+}
diff --git a/src/MagicOnion.Client.Unity/Assets/Scripts/MagicOnion/MagicOnion.Abstractions/Internal/RawBytesBox.cs b/src/MagicOnion.Client.Unity/Assets/Scripts/MagicOnion/MagicOnion.Abstractions/Internal/RawBytesBox.cs
new file mode 100644
index 000000000..00b4a2e5f
--- /dev/null
+++ b/src/MagicOnion.Client.Unity/Assets/Scripts/MagicOnion/MagicOnion.Abstractions/Internal/RawBytesBox.cs
@@ -0,0 +1,17 @@
+using System;
+using System.ComponentModel;
+
+namespace MagicOnion.Internal
+{
+    // Pubternal API
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public sealed class RawBytesBox
+    {
+        public ReadOnlyMemory<byte> Bytes { get; }
+
+        public RawBytesBox(ReadOnlyMemory<byte> bytes)
+        {
+            Bytes = bytes;
+        }
+    }
+}
diff --git a/src/MagicOnion.Client.Unity/Assets/Scripts/MagicOnion/MagicOnion.Abstractions/Internal/RawBytesBox.cs.meta b/src/MagicOnion.Client.Unity/Assets/Scripts/MagicOnion/MagicOnion.Abstractions/Internal/RawBytesBox.cs.meta
new file mode 100644
index 000000000..0fb354b7b
--- /dev/null
+++ b/src/MagicOnion.Client.Unity/Assets/Scripts/MagicOnion/MagicOnion.Abstractions/Internal/RawBytesBox.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e38ae70e650f974458dc1814576f4747
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/src/MagicOnion.Client.Unity/Assets/Scripts/MagicOnion/MagicOnion.Client/MagicOnion.Shared/GrpcMethodHelper.cs b/src/MagicOnion.Client.Unity/Assets/Scripts/MagicOnion/MagicOnion.Client/MagicOnion.Shared/GrpcMethodHelper.cs
index 32595d973..7ac93817c 100644
--- a/src/MagicOnion.Client.Unity/Assets/Scripts/MagicOnion/MagicOnion.Client/MagicOnion.Shared/GrpcMethodHelper.cs
+++ b/src/MagicOnion.Client.Unity/Assets/Scripts/MagicOnion/MagicOnion.Client/MagicOnion.Shared/GrpcMethodHelper.cs
@@ -1,7 +1,6 @@
 using System;
-using System.Collections.Generic;
 using System.Reflection;
-using System.Text;
+using System.Runtime.CompilerServices;
 using Grpc.Core;
 using MagicOnion.Internal;
 using MagicOnion.Serialization;
@@ -14,18 +13,39 @@ public static class GrpcMethodHelper
         public sealed class MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse>
         {
             public Method<TRawRequest, TRawResponse> Method { get; }
-            public Func<TRequest, TRawRequest> ToRawRequest { get; }
-            public Func<TResponse, TRawResponse> ToRawResponse { get; }
-            public Func<TRawRequest, TRequest> FromRawRequest { get; }
-            public Func<TRawResponse, TResponse> FromRawResponse { get; }
 
             public MagicOnionMethod(Method<TRawRequest, TRawResponse> method)
             {
                 Method = method;
-                ToRawRequest = ((typeof(TRawRequest) == typeof(Box<TRequest>)) ? (Func<TRequest, TRawRequest>)(x => (TRawRequest)(object)Box.Create(x)) : x => DangerousDummyNull.GetObjectOrDummyNull((TRawRequest)(object)x));
-                ToRawResponse = ((typeof(TRawResponse) == typeof(Box<TResponse>)) ? (Func<TResponse, TRawResponse>)(x => (TRawResponse)(object)Box.Create(x)) : x => DangerousDummyNull.GetObjectOrDummyNull((TRawResponse)(object)x));
-                FromRawRequest = ((typeof(TRawRequest) == typeof(Box<TRequest>)) ? (Func<TRawRequest, TRequest>)(x => ((Box<TRequest>)(object)x).Value) : x => DangerousDummyNull.GetObjectOrDefault<TRequest>(x));
-                FromRawResponse = ((typeof(TRawResponse) == typeof(Box<TResponse>)) ? (Func<TRawResponse, TResponse>)(x => ((Box<TResponse>)(object)x).Value) : x => DangerousDummyNull.GetObjectOrDefault<TResponse>(x));
+            }
+
+            public TRawRequest ToRawRequest(TRequest obj) => ToRaw<TRequest, TRawRequest>(obj);
+            public TRawResponse ToRawResponse(TResponse obj) => ToRaw<TResponse, TRawResponse>(obj);
+            public TRequest FromRawRequest(TRawRequest obj) => FromRaw<TRawRequest, TRequest>(obj);
+            public TResponse FromRawResponse(TRawResponse obj) => FromRaw<TRawResponse, TResponse>(obj);
+
+            static TRaw ToRaw<T, TRaw>(T obj)
+            {
+                if (typeof(TRaw) == typeof(Box<T>))
+                {
+                    return (TRaw)(object)Box.Create(obj);
+                }
+                else
+                {
+                    return DangerousDummyNull.GetObjectOrDummyNull(Unsafe.As<T, TRaw>(ref obj));
+                }
+            }
+
+            static T FromRaw<TRaw, T>(TRaw obj)
+            {
+                if (typeof(TRaw) == typeof(Box<T>))
+                {
+                    return ((Box<T>)(object)obj).Value;
+                }
+                else
+                {
+                    return DangerousDummyNull.GetObjectOrDefault<T>(obj);
+                }
             }
         }
 
@@ -39,27 +59,17 @@ public static MagicOnionMethod<Nil, TResponse, Box<Nil>, TRawResponse> CreateMet
             //             DynamicClient sends byte[], but GeneratedClient sends Nil, which is incompatible,
             //             so as a special case we do not serialize/deserialize and always convert to a fixed values.
             var isMethodResponseTypeBoxed = typeof(TResponse).IsValueType;
+            var responseMarshaller = isMethodResponseTypeBoxed
+                ? (object)CreateBoxedMarshaller<TResponse>(messageSerializer)
+                : (object)CreateMarshaller<TResponse>(messageSerializer);
 
-            if (isMethodResponseTypeBoxed)
-            {
-                return new MagicOnionMethod<Nil, TResponse, Box<Nil>, TRawResponse>(new Method<Box<Nil>, TRawResponse>(
-                    methodType,
-                    serviceName,
-                    name,
-                    IgnoreNilMarshaller,
-                    (Marshaller<TRawResponse>)(object)CreateBoxedMarshaller<TResponse>(messageSerializer, methodType, methodInfo)
-                ));
-            }
-            else
-            {
-                return new MagicOnionMethod<Nil, TResponse, Box<Nil>, TRawResponse>(new Method<Box<Nil>, TRawResponse>(
-                    methodType,
-                    serviceName,
-                    name,
-                    IgnoreNilMarshaller,
-                    (Marshaller<TRawResponse>)(object)CreateMarshaller<TResponse>(messageSerializer, methodType, methodInfo)
-                ));
-            }
+            return new MagicOnionMethod<Nil, TResponse, Box<Nil>, TRawResponse>(new Method<Box<Nil>, TRawResponse>(
+                methodType,
+                serviceName,
+                name,
+                IgnoreNilMarshaller,
+                (Marshaller<TRawResponse>)responseMarshaller
+            ));
         }
 
         public static MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse> CreateMethod<TRequest, TResponse, TRawRequest, TRawResponse>(MethodType methodType, string serviceName, string name, IMagicOnionSerializer messageSerializer)
@@ -71,46 +81,20 @@ public static MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse> C
             var isMethodRequestTypeBoxed = typeof(TRequest).IsValueType;
             var isMethodResponseTypeBoxed = typeof(TResponse).IsValueType;
 
-            if (isMethodRequestTypeBoxed && isMethodResponseTypeBoxed)
-            {
-                return new MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse>(new Method<TRawRequest, TRawResponse>(
-                    methodType,
-                    serviceName,
-                    name,
-                    (Marshaller<TRawRequest>)(object)CreateBoxedMarshaller<TRequest>(messageSerializer, methodType, methodInfo),
-                    (Marshaller<TRawResponse>)(object)CreateBoxedMarshaller<TResponse>(messageSerializer, methodType, methodInfo)
-                ));
-            }
-            else if (isMethodRequestTypeBoxed)
-            {
-                return new MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse>(new Method<TRawRequest, TRawResponse>(
-                    methodType,
-                    serviceName,
-                    name,
-                    (Marshaller<TRawRequest>)(object)CreateBoxedMarshaller<TRequest>(messageSerializer, methodType, methodInfo),
-                    (Marshaller<TRawResponse>)(object)CreateMarshaller<TResponse>(messageSerializer, methodType, methodInfo)
-                ));
-            }
-            else if (isMethodResponseTypeBoxed)
-            {
-                return new MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse>(new Method<TRawRequest, TRawResponse>(
-                    methodType,
-                    serviceName,
-                    name,
-                    (Marshaller<TRawRequest>)(object)CreateMarshaller<TRequest>(messageSerializer, methodType, methodInfo),
-                    (Marshaller<TRawResponse>)(object)CreateBoxedMarshaller<TResponse>(messageSerializer, methodType, methodInfo)
-                ));
-            }
-            else
-            {
-                return new MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse>(new Method<TRawRequest, TRawResponse>(
-                    methodType,
-                    serviceName,
-                    name,
-                    (Marshaller<TRawRequest>)(object)CreateMarshaller<TRequest>(messageSerializer, methodType, methodInfo),
-                    (Marshaller<TRawResponse>)(object)CreateMarshaller<TResponse>(messageSerializer, methodType, methodInfo)
-                ));
-            }
+            var requestMarshaller = isMethodRequestTypeBoxed
+                ? (object)CreateBoxedMarshaller<TRequest>(messageSerializer)
+                : (object)CreateMarshaller<TRequest>(messageSerializer);
+            var responseMarshaller = isMethodResponseTypeBoxed
+                ? (object)CreateBoxedMarshaller<TResponse>(messageSerializer)
+                : (object)CreateMarshaller<TResponse>(messageSerializer);
+
+            return new MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse>(new Method<TRawRequest, TRawResponse>(
+                methodType,
+                serviceName,
+                name,
+                (Marshaller<TRawRequest>)requestMarshaller,
+                (Marshaller<TRawResponse>)responseMarshaller
+            ));
         }
 
         // WORKAROUND: Prior to MagicOnion 5.0, the request type for the parameter-less method was byte[].
@@ -131,23 +115,45 @@ public static MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse> C
                 deserializer: (ctx) => Box.Create(Nil.Default) /* Box.Create always returns cached Box<Nil> */
             );
 
-        static Marshaller<T> CreateMarshaller<T>(IMagicOnionSerializer messageSerializer, MethodType methodType, MethodInfo methodInfo)
+        static Marshaller<T> CreateMarshaller<T>(IMagicOnionSerializer messageSerializer)
         {
             return new Marshaller<T>(
                 serializer: (obj, ctx) =>
                 {
-                    messageSerializer.Serialize(ctx.GetBufferWriter(), DangerousDummyNull.GetObjectOrDefault<T>(obj));
+                    if (obj.GetType() == typeof(RawBytesBox))
+                    {
+                        var rawBytesBox = (RawBytesBox)(object)obj;
+                        var writer = ctx.GetBufferWriter();
+                        var buffer = writer.GetSpan(rawBytesBox.Bytes.Length);
+                        rawBytesBox.Bytes.Span.CopyTo(buffer);
+                        writer.Advance(rawBytesBox.Bytes.Length);
+                    }
+                    else
+                    {
+                        messageSerializer.Serialize(ctx.GetBufferWriter(), DangerousDummyNull.GetObjectOrDefault<T>(obj));
+                    }
                     ctx.Complete();
                 },
                 deserializer: (ctx) => DangerousDummyNull.GetObjectOrDummyNull(messageSerializer.Deserialize<T>(ctx.PayloadAsReadOnlySequence())));
         }
 
-        static Marshaller<Box<T>> CreateBoxedMarshaller<T>(IMagicOnionSerializer messageSerializer, MethodType methodType, MethodInfo methodInfo)
+        static Marshaller<Box<T>> CreateBoxedMarshaller<T>(IMagicOnionSerializer messageSerializer)
         {
             return new Marshaller<Box<T>>(
                 serializer: (obj, ctx) =>
                 {
-                    messageSerializer.Serialize(ctx.GetBufferWriter(), obj.Value);
+                    if (obj.GetType() == typeof(RawBytesBox))
+                    {
+                        var rawBytesBox = (RawBytesBox)(object)obj;
+                        var writer = ctx.GetBufferWriter();
+                        var buffer = writer.GetSpan(rawBytesBox.Bytes.Length);
+                        rawBytesBox.Bytes.Span.CopyTo(buffer);
+                        writer.Advance(rawBytesBox.Bytes.Length);
+                    }
+                    else
+                    {
+                        messageSerializer.Serialize(ctx.GetBufferWriter(), obj.Value);
+                    }
                     ctx.Complete();
                 },
                 deserializer: (ctx) => Box.Create(messageSerializer.Deserialize<T>(ctx.PayloadAsReadOnlySequence()))
diff --git a/src/MagicOnion.Server/Internal/MagicOnionMethodHandlerBinder.cs b/src/MagicOnion.Server/Internal/MagicOnionMethodHandlerBinder.cs
index 733100ccf..7fc07364b 100644
--- a/src/MagicOnion.Server/Internal/MagicOnionMethodHandlerBinder.cs
+++ b/src/MagicOnion.Server/Internal/MagicOnionMethodHandlerBinder.cs
@@ -1,8 +1,10 @@
+using System.Diagnostics;
 using Grpc.Core;
 using MagicOnion.Internal;
 using MagicOnion.Serialization;
 using MessagePack;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 
 namespace MagicOnion.Server.Internal;
 
@@ -25,21 +27,37 @@ internal class MagicOnionMethodHandlerBinder<TRequest, TResponse, TRawRequest, T
 {
     public static MagicOnionMethodHandlerBinder<TRequest, TResponse, TRawRequest, TRawResponse> Instance { get; } = new MagicOnionMethodHandlerBinder<TRequest, TResponse, TRawRequest, TRawResponse>();
 
-    public void BindUnary(ServiceBinderBase binder, Func<TRequest, ServerCallContext, Task<TResponse?>> serverMethod, MethodHandler methodHandler, IMagicOnionSerializer messageSerializer)
+    public void BindUnary(ServiceBinderBase binder, Func<TRequest, ServerCallContext, Task<object?>> serverMethod, MethodHandler methodHandler, IMagicOnionSerializer messageSerializer)
     {
         var method = GrpcMethodHelper.CreateMethod<TRequest, TResponse, TRawRequest, TRawResponse>(MethodType.Unary, methodHandler.ServiceName, methodHandler.MethodName, methodHandler.MethodInfo, messageSerializer);
         binder.AddMethod(new MagicOnionServerMethod<TRawRequest, TRawResponse>(method.Method, methodHandler),
-            async (request, context) => method.ToRawResponse(await serverMethod(method.FromRawRequest(request), context)));
+            async (request, context) =>
+            {
+                var response = await serverMethod(method.FromRawRequest(request), context);
+                if (response is RawBytesBox rawBytesResponse)
+                {
+                    return Unsafe.As<RawBytesBox, TRawResponse>(ref rawBytesResponse); // NOTE: To disguise an object as a `TRawResponse`, `TRawResponse` must be `class`.
+                }
+                return method.ToRawResponse((TResponse?)response);
+            });
     }
 
-    public void BindUnaryParameterless(ServiceBinderBase binder, Func<Nil, ServerCallContext, Task<TResponse?>> serverMethod, MethodHandler methodHandler, IMagicOnionSerializer messageSerializer)
+    public void BindUnaryParameterless(ServiceBinderBase binder, Func<Nil, ServerCallContext, Task<object?>> serverMethod, MethodHandler methodHandler, IMagicOnionSerializer messageSerializer)
     {
         // WORKAROUND: Prior to MagicOnion 5.0, the request type for the parameter-less method was byte[].
         //             DynamicClient sends byte[], but GeneratedClient sends Nil, which is incompatible,
         //             so as a special case we do not serialize/deserialize and always convert to a fixed values.
         var method = GrpcMethodHelper.CreateMethod<TResponse, TRawResponse>(MethodType.Unary, methodHandler.ServiceName, methodHandler.MethodName, methodHandler.MethodInfo, messageSerializer);
         binder.AddMethod(new MagicOnionServerMethod<Box<Nil>, TRawResponse>(method.Method, methodHandler),
-            async (request, context) => method.ToRawResponse(await serverMethod(method.FromRawRequest(request), context)));
+            async (request, context) =>
+            {
+                var response = await serverMethod(method.FromRawRequest(request), context);
+                if (response is RawBytesBox rawBytesResponse)
+                {
+                    return Unsafe.As<RawBytesBox, TRawResponse>(ref rawBytesResponse); // NOTE: To disguise an object as a `TRawResponse`, `TRawResponse` must be `class`.
+                }
+                return method.ToRawResponse((TResponse?)response);
+            });
     }
 
     public void BindStreamingHub(ServiceBinderBase binder, Func<IAsyncStreamReader<TRequest>, IServerStreamWriter<TResponse>, ServerCallContext, Task> serverMethod, MethodHandler methodHandler, IMagicOnionSerializer messageSerializer)
diff --git a/src/MagicOnion.Server/MagicOnionEngine.cs b/src/MagicOnion.Server/MagicOnionEngine.cs
index 9fa2a19de..68c449b9c 100644
--- a/src/MagicOnion.Server/MagicOnionEngine.cs
+++ b/src/MagicOnion.Server/MagicOnionEngine.cs
@@ -125,6 +125,9 @@ public static MagicOnionServiceDefinition BuildServerServiceDefinition(IServiceP
         var handlers = new HashSet<MethodHandler>();
         var streamingHubHandlers = new List<StreamingHubHandler>();
 
+        var methodHandlerOptions = new MethodHandlerOptions(options);
+        var streamingHubHandlerOptions = new StreamingHubHandlerOptions(options);
+
         logger.BeginBuildServiceDefinition();
         var sw = Stopwatch.StartNew();
 
@@ -179,7 +182,7 @@ public static MagicOnionServiceDefinition BuildServerServiceDefinition(IServiceP
                     // register for StreamingHub
                     if (isStreamingHub && methodName != "Connect")
                     {
-                        var streamingHandler = new StreamingHubHandler(classType, methodInfo, new StreamingHubHandlerOptions(options), serviceProvider);
+                        var streamingHandler = new StreamingHubHandler(classType, methodInfo, streamingHubHandlerOptions, serviceProvider);
                         if (!tempStreamingHubHandlers!.Add(streamingHandler))
                         {
                             throw new InvalidOperationException($"Method does not allow overload, {className}.{methodName}");
@@ -189,7 +192,7 @@ public static MagicOnionServiceDefinition BuildServerServiceDefinition(IServiceP
                     else
                     {
                         // create handler
-                        var handler = new MethodHandler(classType, methodInfo, methodName, new MethodHandlerOptions(options), serviceProvider, logger, isStreamingHub: false);
+                        var handler = new MethodHandler(classType, methodInfo, methodName, methodHandlerOptions, serviceProvider, logger, isStreamingHub: false);
                         if (!handlers.Add(handler))
                         {
                             throw new InvalidOperationException($"Method does not allow overload, {className}.{methodName}");
@@ -199,7 +202,7 @@ public static MagicOnionServiceDefinition BuildServerServiceDefinition(IServiceP
 
                 if (isStreamingHub)
                 {
-                    var connectHandler = new MethodHandler(classType, classType.GetMethod("Connect")!, "Connect", new MethodHandlerOptions(options), serviceProvider, logger, isStreamingHub: true);
+                    var connectHandler = new MethodHandler(classType, classType.GetMethod("Connect")!, "Connect", methodHandlerOptions, serviceProvider, logger, isStreamingHub: true);
                     if (!handlers.Add(connectHandler))
                     {
                         throw new InvalidOperationException($"Method does not allow overload, {className}.Connect");
diff --git a/src/MagicOnion.Server/MethodHandler.cs b/src/MagicOnion.Server/MethodHandler.cs
index 9734e3823..d45cfb664 100644
--- a/src/MagicOnion.Server/MethodHandler.cs
+++ b/src/MagicOnion.Server/MethodHandler.cs
@@ -224,13 +224,13 @@ void BindHandlerTyped<TRequest, TResponse, TRawRequest, TRawResponse>(ServiceBin
         }
     }
 
-    async Task<TResponse?> UnaryServerMethod<TRequest, TResponse>(TRequest request, ServerCallContext context)
+    async Task<object?> UnaryServerMethod<TRequest, TResponse>(TRequest request, ServerCallContext context)
     {
         var isErrorOrInterrupted = false;
         var serviceContext = new ServiceContext(ServiceType, MethodInfo, AttributeLookup, this.MethodType, context, messageSerializer, Logger, this, context.GetHttpContext().RequestServices);
         serviceContext.SetRawRequest(request);
 
-        TResponse? response = default;
+        object? response = default(TResponse?);
         try
         {
             Logger.BeginInvokeMethod(serviceContext, typeof(TRequest));
@@ -241,7 +241,7 @@ void BindHandlerTyped<TRequest, TResponse, TRawRequest, TRawResponse>(ServiceBin
             await this.methodBody(serviceContext).ConfigureAwait(false);
             if (serviceContext.Result is not null)
             {
-                response = (TResponse?)serviceContext.Result;
+                response = serviceContext.Result;
             }
         }
         catch (ReturnStatusException ex)
diff --git a/src/MagicOnion.Server/ServiceContext.cs b/src/MagicOnion.Server/ServiceContext.cs
index fd574061e..a67c3cc12 100644
--- a/src/MagicOnion.Server/ServiceContext.cs
+++ b/src/MagicOnion.Server/ServiceContext.cs
@@ -4,6 +4,7 @@
 using MessagePack;
 using System.Collections.Concurrent;
 using System.Reflection;
+using MagicOnion.Internal;
 
 namespace MagicOnion.Server;
 
@@ -107,27 +108,36 @@ IServiceProvider serviceProvider
         this.ServiceProvider = serviceProvider;
     }
 
-    /// <summary>Get Raw Request.</summary>
+    /// <summary>Gets a request object.</summary>
     public object? GetRawRequest()
     {
         return request;
     }
 
-    /// <summary>Set Raw Request, you can set before method body was called.</summary>
+    /// <summary>Sets a request object.</summary>
     public void SetRawRequest(object? request)
     {
         this.request = request;
     }
 
-    /// <summary>Can get after method body was finished.</summary>
+    /// <summary>Gets a response object. The object is available after the service method has completed.</summary>
     public object? GetRawResponse()
     {
         return Result;
     }
 
-    /// <summary>Can set after method body was finished.</summary>
+    /// <summary>Sets a response object. This can overwrite the result of the service method.</summary>
     public void SetRawResponse(object? response)
     {
         Result = response;
     }
+
+    /// <summary>
+    /// Sets a raw bytes response. The response will not be serialized and the bytes will be sent directly.
+    /// This can overwrite the result of the service method.
+    /// </summary>
+    public void SetRawBytesResponse(ReadOnlyMemory<byte> bytes)
+    {
+        Result = new RawBytesBox(bytes);
+    }
 }
diff --git a/src/MagicOnion.Shared/GrpcMethodHelper.cs b/src/MagicOnion.Shared/GrpcMethodHelper.cs
index 32595d973..7ac93817c 100644
--- a/src/MagicOnion.Shared/GrpcMethodHelper.cs
+++ b/src/MagicOnion.Shared/GrpcMethodHelper.cs
@@ -1,7 +1,6 @@
 using System;
-using System.Collections.Generic;
 using System.Reflection;
-using System.Text;
+using System.Runtime.CompilerServices;
 using Grpc.Core;
 using MagicOnion.Internal;
 using MagicOnion.Serialization;
@@ -14,18 +13,39 @@ public static class GrpcMethodHelper
         public sealed class MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse>
         {
             public Method<TRawRequest, TRawResponse> Method { get; }
-            public Func<TRequest, TRawRequest> ToRawRequest { get; }
-            public Func<TResponse, TRawResponse> ToRawResponse { get; }
-            public Func<TRawRequest, TRequest> FromRawRequest { get; }
-            public Func<TRawResponse, TResponse> FromRawResponse { get; }
 
             public MagicOnionMethod(Method<TRawRequest, TRawResponse> method)
             {
                 Method = method;
-                ToRawRequest = ((typeof(TRawRequest) == typeof(Box<TRequest>)) ? (Func<TRequest, TRawRequest>)(x => (TRawRequest)(object)Box.Create(x)) : x => DangerousDummyNull.GetObjectOrDummyNull((TRawRequest)(object)x));
-                ToRawResponse = ((typeof(TRawResponse) == typeof(Box<TResponse>)) ? (Func<TResponse, TRawResponse>)(x => (TRawResponse)(object)Box.Create(x)) : x => DangerousDummyNull.GetObjectOrDummyNull((TRawResponse)(object)x));
-                FromRawRequest = ((typeof(TRawRequest) == typeof(Box<TRequest>)) ? (Func<TRawRequest, TRequest>)(x => ((Box<TRequest>)(object)x).Value) : x => DangerousDummyNull.GetObjectOrDefault<TRequest>(x));
-                FromRawResponse = ((typeof(TRawResponse) == typeof(Box<TResponse>)) ? (Func<TRawResponse, TResponse>)(x => ((Box<TResponse>)(object)x).Value) : x => DangerousDummyNull.GetObjectOrDefault<TResponse>(x));
+            }
+
+            public TRawRequest ToRawRequest(TRequest obj) => ToRaw<TRequest, TRawRequest>(obj);
+            public TRawResponse ToRawResponse(TResponse obj) => ToRaw<TResponse, TRawResponse>(obj);
+            public TRequest FromRawRequest(TRawRequest obj) => FromRaw<TRawRequest, TRequest>(obj);
+            public TResponse FromRawResponse(TRawResponse obj) => FromRaw<TRawResponse, TResponse>(obj);
+
+            static TRaw ToRaw<T, TRaw>(T obj)
+            {
+                if (typeof(TRaw) == typeof(Box<T>))
+                {
+                    return (TRaw)(object)Box.Create(obj);
+                }
+                else
+                {
+                    return DangerousDummyNull.GetObjectOrDummyNull(Unsafe.As<T, TRaw>(ref obj));
+                }
+            }
+
+            static T FromRaw<TRaw, T>(TRaw obj)
+            {
+                if (typeof(TRaw) == typeof(Box<T>))
+                {
+                    return ((Box<T>)(object)obj).Value;
+                }
+                else
+                {
+                    return DangerousDummyNull.GetObjectOrDefault<T>(obj);
+                }
             }
         }
 
@@ -39,27 +59,17 @@ public static MagicOnionMethod<Nil, TResponse, Box<Nil>, TRawResponse> CreateMet
             //             DynamicClient sends byte[], but GeneratedClient sends Nil, which is incompatible,
             //             so as a special case we do not serialize/deserialize and always convert to a fixed values.
             var isMethodResponseTypeBoxed = typeof(TResponse).IsValueType;
+            var responseMarshaller = isMethodResponseTypeBoxed
+                ? (object)CreateBoxedMarshaller<TResponse>(messageSerializer)
+                : (object)CreateMarshaller<TResponse>(messageSerializer);
 
-            if (isMethodResponseTypeBoxed)
-            {
-                return new MagicOnionMethod<Nil, TResponse, Box<Nil>, TRawResponse>(new Method<Box<Nil>, TRawResponse>(
-                    methodType,
-                    serviceName,
-                    name,
-                    IgnoreNilMarshaller,
-                    (Marshaller<TRawResponse>)(object)CreateBoxedMarshaller<TResponse>(messageSerializer, methodType, methodInfo)
-                ));
-            }
-            else
-            {
-                return new MagicOnionMethod<Nil, TResponse, Box<Nil>, TRawResponse>(new Method<Box<Nil>, TRawResponse>(
-                    methodType,
-                    serviceName,
-                    name,
-                    IgnoreNilMarshaller,
-                    (Marshaller<TRawResponse>)(object)CreateMarshaller<TResponse>(messageSerializer, methodType, methodInfo)
-                ));
-            }
+            return new MagicOnionMethod<Nil, TResponse, Box<Nil>, TRawResponse>(new Method<Box<Nil>, TRawResponse>(
+                methodType,
+                serviceName,
+                name,
+                IgnoreNilMarshaller,
+                (Marshaller<TRawResponse>)responseMarshaller
+            ));
         }
 
         public static MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse> CreateMethod<TRequest, TResponse, TRawRequest, TRawResponse>(MethodType methodType, string serviceName, string name, IMagicOnionSerializer messageSerializer)
@@ -71,46 +81,20 @@ public static MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse> C
             var isMethodRequestTypeBoxed = typeof(TRequest).IsValueType;
             var isMethodResponseTypeBoxed = typeof(TResponse).IsValueType;
 
-            if (isMethodRequestTypeBoxed && isMethodResponseTypeBoxed)
-            {
-                return new MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse>(new Method<TRawRequest, TRawResponse>(
-                    methodType,
-                    serviceName,
-                    name,
-                    (Marshaller<TRawRequest>)(object)CreateBoxedMarshaller<TRequest>(messageSerializer, methodType, methodInfo),
-                    (Marshaller<TRawResponse>)(object)CreateBoxedMarshaller<TResponse>(messageSerializer, methodType, methodInfo)
-                ));
-            }
-            else if (isMethodRequestTypeBoxed)
-            {
-                return new MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse>(new Method<TRawRequest, TRawResponse>(
-                    methodType,
-                    serviceName,
-                    name,
-                    (Marshaller<TRawRequest>)(object)CreateBoxedMarshaller<TRequest>(messageSerializer, methodType, methodInfo),
-                    (Marshaller<TRawResponse>)(object)CreateMarshaller<TResponse>(messageSerializer, methodType, methodInfo)
-                ));
-            }
-            else if (isMethodResponseTypeBoxed)
-            {
-                return new MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse>(new Method<TRawRequest, TRawResponse>(
-                    methodType,
-                    serviceName,
-                    name,
-                    (Marshaller<TRawRequest>)(object)CreateMarshaller<TRequest>(messageSerializer, methodType, methodInfo),
-                    (Marshaller<TRawResponse>)(object)CreateBoxedMarshaller<TResponse>(messageSerializer, methodType, methodInfo)
-                ));
-            }
-            else
-            {
-                return new MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse>(new Method<TRawRequest, TRawResponse>(
-                    methodType,
-                    serviceName,
-                    name,
-                    (Marshaller<TRawRequest>)(object)CreateMarshaller<TRequest>(messageSerializer, methodType, methodInfo),
-                    (Marshaller<TRawResponse>)(object)CreateMarshaller<TResponse>(messageSerializer, methodType, methodInfo)
-                ));
-            }
+            var requestMarshaller = isMethodRequestTypeBoxed
+                ? (object)CreateBoxedMarshaller<TRequest>(messageSerializer)
+                : (object)CreateMarshaller<TRequest>(messageSerializer);
+            var responseMarshaller = isMethodResponseTypeBoxed
+                ? (object)CreateBoxedMarshaller<TResponse>(messageSerializer)
+                : (object)CreateMarshaller<TResponse>(messageSerializer);
+
+            return new MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse>(new Method<TRawRequest, TRawResponse>(
+                methodType,
+                serviceName,
+                name,
+                (Marshaller<TRawRequest>)requestMarshaller,
+                (Marshaller<TRawResponse>)responseMarshaller
+            ));
         }
 
         // WORKAROUND: Prior to MagicOnion 5.0, the request type for the parameter-less method was byte[].
@@ -131,23 +115,45 @@ public static MagicOnionMethod<TRequest, TResponse, TRawRequest, TRawResponse> C
                 deserializer: (ctx) => Box.Create(Nil.Default) /* Box.Create always returns cached Box<Nil> */
             );
 
-        static Marshaller<T> CreateMarshaller<T>(IMagicOnionSerializer messageSerializer, MethodType methodType, MethodInfo methodInfo)
+        static Marshaller<T> CreateMarshaller<T>(IMagicOnionSerializer messageSerializer)
         {
             return new Marshaller<T>(
                 serializer: (obj, ctx) =>
                 {
-                    messageSerializer.Serialize(ctx.GetBufferWriter(), DangerousDummyNull.GetObjectOrDefault<T>(obj));
+                    if (obj.GetType() == typeof(RawBytesBox))
+                    {
+                        var rawBytesBox = (RawBytesBox)(object)obj;
+                        var writer = ctx.GetBufferWriter();
+                        var buffer = writer.GetSpan(rawBytesBox.Bytes.Length);
+                        rawBytesBox.Bytes.Span.CopyTo(buffer);
+                        writer.Advance(rawBytesBox.Bytes.Length);
+                    }
+                    else
+                    {
+                        messageSerializer.Serialize(ctx.GetBufferWriter(), DangerousDummyNull.GetObjectOrDefault<T>(obj));
+                    }
                     ctx.Complete();
                 },
                 deserializer: (ctx) => DangerousDummyNull.GetObjectOrDummyNull(messageSerializer.Deserialize<T>(ctx.PayloadAsReadOnlySequence())));
         }
 
-        static Marshaller<Box<T>> CreateBoxedMarshaller<T>(IMagicOnionSerializer messageSerializer, MethodType methodType, MethodInfo methodInfo)
+        static Marshaller<Box<T>> CreateBoxedMarshaller<T>(IMagicOnionSerializer messageSerializer)
         {
             return new Marshaller<Box<T>>(
                 serializer: (obj, ctx) =>
                 {
-                    messageSerializer.Serialize(ctx.GetBufferWriter(), obj.Value);
+                    if (obj.GetType() == typeof(RawBytesBox))
+                    {
+                        var rawBytesBox = (RawBytesBox)(object)obj;
+                        var writer = ctx.GetBufferWriter();
+                        var buffer = writer.GetSpan(rawBytesBox.Bytes.Length);
+                        rawBytesBox.Bytes.Span.CopyTo(buffer);
+                        writer.Advance(rawBytesBox.Bytes.Length);
+                    }
+                    else
+                    {
+                        messageSerializer.Serialize(ctx.GetBufferWriter(), obj.Value);
+                    }
                     ctx.Complete();
                 },
                 deserializer: (ctx) => Box.Create(messageSerializer.Deserialize<T>(ctx.PayloadAsReadOnlySequence()))
diff --git a/tests/MagicOnion.Server.Tests/MagicOnion.Server.Tests.csproj b/tests/MagicOnion.Server.Tests/MagicOnion.Server.Tests.csproj
index ddd2773f9..7368ee9b1 100644
--- a/tests/MagicOnion.Server.Tests/MagicOnion.Server.Tests.csproj
+++ b/tests/MagicOnion.Server.Tests/MagicOnion.Server.Tests.csproj
@@ -28,6 +28,7 @@
     <ProjectReference Include="..\samples\AuthSample\AuthSample.csproj" />
     <ProjectReference Include="..\samples\BasicServerSample\BasicServerSample.csproj" />
     <ProjectReference Include="..\samples\MagicOnionEngineTest\MagicOnionEngineTest.csproj" />
+    <ProjectReference Include="..\samples\MagicOnionTestServer\MagicOnionTestServer.csproj" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/MagicOnion.Server.Tests/MagicOnionApplicationFactory.cs b/tests/MagicOnion.Server.Tests/MagicOnionApplicationFactory.cs
new file mode 100644
index 000000000..b0515fca4
--- /dev/null
+++ b/tests/MagicOnion.Server.Tests/MagicOnionApplicationFactory.cs
@@ -0,0 +1,28 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace MagicOnion.Server.Tests;
+
+#pragma warning disable CS1998
+public class MagicOnionApplicationFactory<TServiceImplementation> : WebApplicationFactory<MagicOnionTestServer.Program>
+{
+    protected override void ConfigureWebHost(IWebHostBuilder builder)
+    {
+        builder.ConfigureServices(services =>
+        {
+            services.AddMagicOnion(new[] { typeof(TServiceImplementation) });
+        });
+    }
+
+    public WebApplicationFactory<MagicOnionTestServer.Program> WithMagicOnionOptions(Action<MagicOnionOptions> configure)
+    {
+        return this.WithWebHostBuilder(x =>
+        {
+            x.ConfigureServices(services =>
+            {
+                services.Configure<MagicOnionOptions>(configure);
+            });
+        });
+    }
+}
diff --git a/tests/MagicOnion.Server.Tests/RawBytesResponseTest.cs b/tests/MagicOnion.Server.Tests/RawBytesResponseTest.cs
new file mode 100644
index 000000000..0d1046aec
--- /dev/null
+++ b/tests/MagicOnion.Server.Tests/RawBytesResponseTest.cs
@@ -0,0 +1,122 @@
+using System.Collections.Concurrent;
+using Grpc.Net.Client;
+using MagicOnion.Client;
+using MagicOnion.Serialization;
+using MessagePack;
+using Microsoft.AspNetCore.Mvc.Testing;
+
+namespace MagicOnion.Server.Tests;
+
+public class RawBytesResponseTest : IClassFixture<MagicOnionApplicationFactory<RawBytesResponseTestService>>
+{
+    readonly WebApplicationFactory<MagicOnionTestServer.Program> factory;
+
+    public RawBytesResponseTest(MagicOnionApplicationFactory<RawBytesResponseTestService> factory)
+    {
+        this.factory = factory.WithMagicOnionOptions(options => {});
+    }
+
+    [Fact]
+    public async Task RefType()
+    {
+        // Arrange
+        var channel = GrpcChannel.ForAddress("http://localhost", new GrpcChannelOptions() { HttpClient = factory.CreateDefaultClient() });
+        var client = MagicOnionClient.Create<IRawBytesResponseTestService>(channel, MessagePackMagicOnionSerializerProvider.Default);
+
+        // Act
+        var result  = await client.RefType();
+        var result2  = await client.RefType();
+
+        // Assert
+        var expected = (RawBytesResponseTestService_RefTypeResponse)FixedResponseFilterAttribute.ResponseCache["/IRawBytesResponseTestService/RefType"];
+        Assert.Equal(expected.Value1, result.Value1);
+        Assert.Equal(expected.Value2, result.Value2);
+        Assert.Equal(expected.Value3, result.Value3);
+        Assert.Equal(expected.Value1, result2.Value1);
+        Assert.Equal(expected.Value2, result2.Value2);
+        Assert.Equal(expected.Value3, result2.Value3);
+    }
+
+    [Fact]
+    public async Task ValueType()
+    {
+        // Arrange
+        var channel = GrpcChannel.ForAddress("http://localhost", new GrpcChannelOptions() { HttpClient = factory.CreateDefaultClient() });
+        var client = MagicOnionClient.Create<IRawBytesResponseTestService>(channel, MessagePackMagicOnionSerializerProvider.Default);
+
+        // Act
+        var result  = await client.ValueType();
+        var result2  = await client.ValueType();
+
+        // Assert
+        var expected = (RawBytesResponseTestService_ValueTypeResponse)FixedResponseFilterAttribute.ResponseCache["/IRawBytesResponseTestService/ValueType"];
+        Assert.Equal(expected.Value1, result.Value1);
+        Assert.Equal(expected.Value2, result.Value2);
+        Assert.Equal(expected.Value3, result.Value3);
+        Assert.Equal(expected.Value1, result2.Value1);
+        Assert.Equal(expected.Value2, result2.Value2);
+        Assert.Equal(expected.Value3, result2.Value3);
+    }
+}
+
+file class FixedResponseFilterAttribute : MagicOnionFilterAttribute
+{
+    public static readonly RawBytesResponseTestService_RefTypeResponse ResponseRefType;
+    public static readonly RawBytesResponseTestService_ValueTypeResponse ResponseValueType;
+
+    public static readonly ConcurrentDictionary<string, object> ResponseCache = new();
+    public static readonly ConcurrentDictionary<string, byte[]> ResponseBytesCache = new();
+
+    static FixedResponseFilterAttribute()
+    {
+        ResponseRefType = new () { Value1 = Guid.NewGuid().ToString(), Value2 = Random.Shared.Next(), Value3 = Random.Shared.NextInt64() };
+        ResponseValueType = new () { Value1 = Guid.NewGuid().ToString(), Value2 = Random.Shared.Next(), Value3 = Random.Shared.NextInt64() };
+    }
+
+    public override async ValueTask Invoke(ServiceContext context, Func<ServiceContext, ValueTask> next)
+    {
+        if (ResponseBytesCache.TryGetValue(context.CallContext.Method, out var cachedBytes))
+        {
+            context.SetRawBytesResponse(cachedBytes);
+            return;
+        }
+
+        await next(context);
+
+        ResponseCache[context.CallContext.Method] = context.Result;
+        ResponseBytesCache[context.CallContext.Method] = MessagePackSerializer.Serialize(context.Result);
+    }
+}
+
+public interface IRawBytesResponseTestService : IService<IRawBytesResponseTestService>
+{
+    UnaryResult<RawBytesResponseTestService_RefTypeResponse> RefType();
+    UnaryResult<RawBytesResponseTestService_ValueTypeResponse> ValueType();
+
+}
+
+[FixedResponseFilter]
+public class RawBytesResponseTestService : ServiceBase<IRawBytesResponseTestService>, IRawBytesResponseTestService
+{
+    public UnaryResult<RawBytesResponseTestService_RefTypeResponse> RefType()
+        => UnaryResult.FromResult(new RawBytesResponseTestService_RefTypeResponse() { Value1 = Guid.NewGuid().ToString(), Value2 = Random.Shared.Next(), Value3 = Random.Shared.NextInt64() });
+
+    public UnaryResult<RawBytesResponseTestService_ValueTypeResponse> ValueType()
+        => UnaryResult.FromResult(new RawBytesResponseTestService_ValueTypeResponse(){ Value1 = Guid.NewGuid().ToString(), Value2 = Random.Shared.Next(), Value3 = Random.Shared.NextInt64() });
+}
+
+[MessagePackObject(true)]
+public class RawBytesResponseTestService_RefTypeResponse
+{
+    public string Value1 { get; set; }
+    public int Value2 { get; set; }
+    public long Value3 { get; set; }
+}
+
+[MessagePackObject(true)]
+public struct RawBytesResponseTestService_ValueTypeResponse
+{
+    public string Value1 { get; set; }
+    public int Value2 { get; set; }
+    public long Value3 { get; set; }
+}