Don't store actual values for the special argument types

src/Hangfire.Core/Common/Job.cs

@@ -22,6 +22,7 @@
 using Hangfire.Annotations;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
+using Hangfire.Server;
 
 namespace Hangfire.Common
 {
@@ -153,7 +154,7 @@ public Job([NotNull] Type type, [NotNull] MethodInfo method, [NotNull] params ob
 
             Type = type;
             Method = method;
-            Args = args;
+            Args = PrepareArgs(method, args);
         }
 
         /// <summary>
@@ -450,5 +451,26 @@ private static object GetExpressionValue(Expression expression)
                 ? constantExpression.Value
                 : CachedExpressionCompiler.Evaluate(expression);
         }
+
+        private static object[] PrepareArgs(MethodInfo method, object[] args)
+        {
+            var parameters = method.GetParameters();
+
+            for (var i = 0; i < parameters.Length; i++)
+            {
+                var parameter = parameters[i];
+
+                if (CoreBackgroundJobPerformer.
+                    Substitutions.ContainsKey(parameter.ParameterType))
+                {
+                    // This argument has a special type, so any values would be
+                    // overwritten by CoreBackgroundJobPerformer upon execution.
+                    // Discard them early on (while also saving some storage).
+                    args[i] = null;
+                }
+            }
+
+            return args;
+        }
     }
 }

src/Hangfire.Core/Dashboard/JobMethodCallRenderer.cs

@@ -24,13 +24,22 @@
 using System.Text;
 using System.Threading;
 using Hangfire.Common;
+using Hangfire.Server;
 
 namespace Hangfire.Dashboard
 {
     internal static class JobMethodCallRenderer
     {
         private static readonly int MaxArgumentToRenderSize = 4096;
 
+        private static readonly Dictionary<Type, string> Substitutions
+            = new Dictionary<Type, string>
+            {
+                { typeof (IJobCancellationToken), $"{WrapType(nameof(JobCancellationToken))}.Null" },
+                { typeof (CancellationToken),     $"{WrapType(nameof(CancellationToken))}.None" },
+                { typeof (PerformContext),        WrapKeyword("null") }
+            };
+
         public static NonEscapedString Render(Job job)
         {
             if (job == null) { return new NonEscapedString("<em>Can not find the target method.</em>"); }
@@ -94,6 +103,13 @@ public static NonEscapedString Render(Job job)
             for (var i = 0; i < parameters.Length; i++)
             {
                 var parameter = parameters[i];
+
+                if (Substitutions.TryGetValue(parameter.ParameterType, out var substitution))
+                {
+                    renderedArguments.Add(substitution);
+                    continue;
+                }
+
 #pragma warning disable 618
                 var arguments = job.Arguments;
 #pragma warning restore 618

tests/Hangfire.Core.Tests/Common/JobFacts.cs

@@ -29,6 +29,7 @@ public class JobFacts
         private readonly string[] _arguments;
         private readonly Mock<JobActivator> _activator;
         private readonly Mock<IJobCancellationToken> _token;
+        private readonly PerformContextMock _performContext;
 
         public JobFacts()
         {
@@ -38,6 +39,7 @@ public JobFacts()
 
             _activator = new Mock<JobActivator> { CallBase = true };
             _token = new Mock<IJobCancellationToken>();
+            _performContext = new PerformContextMock();
         }
 
         [Fact]
@@ -341,6 +343,39 @@ public void Ctor_ThrowsAnException_WhenMethodParametersContainAnExpression()
                 () => Job.FromExpression(() => ExpressionMethod(() => Console.WriteLine("Hey expression!"))));
         }
 
+        public interface ISpecialArgs
+        {
+            void Method1(PerformContext context);
+
+            void Method2(IJobCancellationToken cancellationToken, int number);
+
+            Task Method3(string str, CancellationToken cancellationToken);
+        }
+
+        [Fact]
+        public void Ctor_IgnoresValue_ForSpecialType_PerformContext()
+        {
+            var job = Job.FromExpression<ISpecialArgs>(x => x.Method1(_performContext.Object));
+
+            Assert.Equal(new object[] { null }, job.Args);
+        }
+
+        [Fact]
+        public void Ctor_IgnoresValue_ForSpecialType_IJobCancellationToken()
+        {
+            var job = Job.FromExpression<ISpecialArgs>(x => x.Method2(_token.Object, 123));
+
+            Assert.Equal(new object[] { null, 123 }, job.Args);
+        }
+
+        [Fact]
+        public void Ctor_IgnoresValue_ForSpecialType_CancellationToken()
+        {
+            var job = Job.FromExpression<ISpecialArgs>(x => x.Method3("123", CancellationToken.None));
+
+            Assert.Equal(new object[] { "123", null }, job.Args);
+        }
+
         [Fact]
         public void Perform_ThrowsAnException_WhenActivatorIsNull()
         {