fix Warnings caused by NRT

nogic1008 · nogic1008 · commit 9a9ecfc5ffe3 · 2019-10-28T11:37:30.000+09:00
diff --git a/src/MicroBatchFramework.WebHosting/BatchEngineHostingExtensions.cs b/src/MicroBatchFramework.WebHosting/BatchEngineHostingExtensions.cs
@@ -14,7 +14,7 @@ namespace MicroBatchFramework // .WebHosting
 {
     public static class BatchEngineHostingExtensions
     {
-        public static IWebHostBuilder PrepareBatchEngineMiddleware(this IWebHostBuilder builder, IBatchInterceptor interceptor = null)
+        public static IWebHostBuilder PrepareBatchEngineMiddleware(this IWebHostBuilder builder, IBatchInterceptor? interceptor = null)
         {
             var batchTypes = CollectBatchTypes();
             var target = new TargetBatchTypeCollection(batchTypes);
@@ -31,7 +31,7 @@ public static IWebHostBuilder PrepareBatchEngineMiddleware(this IWebHostBuilder
                 });
         }
 
-        public static Task RunBatchEngineWebHosting(this IWebHostBuilder builder, string urls, SwaggerOptions swaggerOptions = null, IBatchInterceptor interceptor = null)
+        public static Task RunBatchEngineWebHosting(this IWebHostBuilder builder, string urls, SwaggerOptions? swaggerOptions = null, IBatchInterceptor? interceptor = null)
         {
             return builder
                 .PrepareBatchEngineMiddleware(interceptor)
@@ -43,7 +43,7 @@ public static Task RunBatchEngineWebHosting(this IWebHostBuilder builder, string
                         var entryAsm = Assembly.GetEntryAssembly()!;
                         var xmlName = entryAsm.GetName().Name + ".xml";
                         var xmlPath = Path.Combine(Path.GetDirectoryName(entryAsm.Location) ?? "", xmlName);
-                        swaggerOptions = new SwaggerOptions(entryAsm.GetName().Name, "", "/") { XmlDocumentPath = xmlPath };
+                        swaggerOptions = new SwaggerOptions(entryAsm.GetName().Name!, "", "/") { XmlDocumentPath = xmlPath };
                     }
                     services.AddSingleton<SwaggerOptions>(swaggerOptions);
                 })
@@ -105,7 +105,7 @@ static List<Type> CollectBatchTypes()
                 if (!(asm.FullName is null)
                     && (asm.FullName.StartsWith("System") || asm.FullName.StartsWith("Microsoft.Extensions"))) continue;
 
-                Type[] types;
+                Type[]? types;
                 try
                 {
                     types = asm.GetTypes();
diff --git a/src/MicroBatchFramework.WebHosting/BatchEngineMiddleware.cs b/src/MicroBatchFramework.WebHosting/BatchEngineMiddleware.cs
@@ -14,8 +14,8 @@ internal class WebHostingInterceptor : IBatchInterceptor
         readonly IBatchInterceptor innerInterceptor;
 
         public bool CompleteSuccessfully { get; private set; }
-        public string ErrorMessage { get; private set; }
-        public Exception Exception { get; private set; }
+        public string? ErrorMessage { get; private set; }
+        public Exception? Exception { get; private set; }
 
         public WebHostingInterceptor(IBatchInterceptor innerInterceptor)
         {
@@ -37,7 +37,7 @@ public ValueTask OnBatchRunBeginAsync(BatchContext context)
             return innerInterceptor.OnBatchRunBeginAsync(context);
         }
 
-        public ValueTask OnBatchRunCompleteAsync(BatchContext context, string errorMessageIfFailed, Exception exceptionIfExists)
+        public ValueTask OnBatchRunCompleteAsync(BatchContext context, string? errorMessageIfFailed, Exception? exceptionIfExists)
         {
             this.CompleteSuccessfully = (errorMessageIfFailed == null && exceptionIfExists == null);
             this.ErrorMessage = errorMessageIfFailed;
@@ -115,7 +115,7 @@ public async Task Invoke(HttpContext httpContext)
             }
 
             // create args
-            string[] args = null;
+            string?[] args;
             try
             {
                 if (httpContext.Request.HasFormContentType)
diff --git a/src/MicroBatchFramework.WebHosting/Swagger/Schemas/SwaggerDocument.cs b/src/MicroBatchFramework.WebHosting/Swagger/Schemas/SwaggerDocument.cs
@@ -1,5 +1,5 @@
 ﻿// This definition is borrowed from Swashbuckle.
-
+#nullable disable annotations
 using Newtonsoft.Json;
 using System.Collections.Generic;
 
diff --git a/src/MicroBatchFramework.WebHosting/Swagger/SwaggerDefinitionBuilder.cs b/src/MicroBatchFramework.WebHosting/Swagger/SwaggerDefinitionBuilder.cs
@@ -20,7 +20,7 @@ public class SwaggerDefinitionBuilder
         readonly HttpContext httpContext;
         readonly IEnumerable<MethodInfo> handlers;
 
-        ILookup<Tuple<string, string>, XmlCommentStructure> xDocLookup;
+        ILookup<Tuple<string, string>, XmlCommentStructure>? xDocLookup;
 
         public SwaggerDefinitionBuilder(SwaggerOptions options, HttpContext httpContext, IEnumerable<MethodInfo> handlers)
         {
@@ -33,15 +33,13 @@ public byte[] BuildSwaggerJson()
         {
             try
             {
-                if (options.XmlDocumentPath != null && !File.Exists(options.XmlDocumentPath))
+                if (options.XmlDocumentPath != null && File.Exists(options.XmlDocumentPath))
                 {
-                    xDocLookup = null;
+                    xDocLookup = BuildXmlMemberCommentStructure(options.XmlDocumentPath);
                 }
                 else
                 {
-                    xDocLookup = (options.XmlDocumentPath != null)
-                        ? BuildXmlMemberCommentStructure(options.XmlDocumentPath)
-                        : null;
+                    xDocLookup = null;
                 }
 
                 var doc = new SwaggerDocument();
@@ -54,7 +52,7 @@ public byte[] BuildSwaggerJson()
 
                 // tags.
                 var xmlServiceName = (xDocLookup != null)
-                    ? BuildXmlTypeSummary(options.XmlDocumentPath)
+                    ? BuildXmlTypeSummary(options.XmlDocumentPath!)  // xDocLookup is not null if XmlDocumentPath is not null.
                     : null;
 
                 doc.tags = handlers
@@ -63,7 +61,7 @@ public byte[] BuildSwaggerJson()
                     .Distinct()
                     .Select(x =>
                     {
-                        string desc = null;
+                        string? desc = null;
                         if (xmlServiceName != null)
                         {
                             xmlServiceName.TryGetValue(x, out desc);
@@ -80,7 +78,7 @@ public byte[] BuildSwaggerJson()
                 {
                     // MemberInfo.DeclaringType is null only if it is a member of a VB Module.
                     string declaringTypeName = item.DeclaringType!.Name;
-                    XmlCommentStructure xmlComment = null;
+                    XmlCommentStructure? xmlComment = null;
                     if (xDocLookup != null)
                     {
                         // ParameterInfo.Name will be null only it is ReturnParameter.
@@ -123,7 +121,7 @@ public byte[] BuildSwaggerJson()
             }
         }
 
-        Schemas.Parameter[] BuildParameters(IDictionary<string, Schema> definitions, XmlCommentStructure xmlComment, MethodInfo method)
+        Schemas.Parameter[] BuildParameters(IDictionary<string, Schema> definitions, XmlCommentStructure? xmlComment, MethodInfo method)
         {
             var parameterInfos = method.GetParameters();
             var parameters = parameterInfos
@@ -132,7 +130,8 @@ Schemas.Parameter[] BuildParameters(IDictionary<string, Schema> definitions, Xml
                     var parameterXmlComment = UnwrapTypeName(x.ParameterType);
                     if (xmlComment != null)
                     {
-                        xmlComment.Parameters.TryGetValue(x.Name, out parameterXmlComment!);
+                        // Name is null only if Parameter is ReturnParameter.
+                        xmlComment.Parameters.TryGetValue(x.Name!, out parameterXmlComment!);
                         parameterXmlComment = UnwrapTypeName(x.ParameterType) + " " + parameterXmlComment;
                     }
 
@@ -147,8 +146,8 @@ Schemas.Parameter[] BuildParameters(IDictionary<string, Schema> definitions, Xml
                         ? new PartialSchema { type = ToSwaggerDataType(collectionType) }
                         : null;
 
-                    string defaultObjectExample = null;
-                    object[] enums = null;
+                    string? defaultObjectExample = null;
+                    object[]? enums = null;
                     if (x.ParameterType.GetTypeInfo().IsEnum || (collectionType != null && collectionType.GetTypeInfo().IsEnum))
                     {
                         // Compiler cannot understand collectionType is not null.
@@ -169,7 +168,7 @@ Schemas.Parameter[] BuildParameters(IDictionary<string, Schema> definitions, Xml
                     }
 
                     var swaggerDataType = ToSwaggerDataType(x.ParameterType);
-                    Schema refSchema = null;
+                    Schema? refSchema = null;
                     if (swaggerDataType == "object")
                     {
                         BuildSchema(definitions, x.ParameterType);
@@ -203,7 +202,7 @@ string BuildSchema(IDictionary<string, Schema> definitions, Type type)
             var fullName = type.FullName;
             if (fullName == null) return ""; // safety(TODO:IDictionary<> is not supported)
 
-            Schema schema;
+            Schema? schema;
             if (definitions.TryGetValue(fullName, out schema)) return "#/definitions/" + fullName;
 
             var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
@@ -229,10 +228,11 @@ string BuildSchema(IDictionary<string, Schema> definitions, Type type)
                     }
                     else
                     {
-                        Schema items = null;
+                        Schema? items = null;
                         if (swaggerDataType == "array")
                         {
-                            var collectionType = GetCollectionType(memberType);
+                            // If swaggerDataType is array, it will be Collection.
+                            Type collectionType = GetCollectionType(memberType)!;
                             var dataType = ToSwaggerDataType(collectionType);
                             if (dataType == "object")
                             {
@@ -258,7 +258,7 @@ string BuildSchema(IDictionary<string, Schema> definitions, Type type)
                             }
                         }
 
-                        IList<object> schemaEnum = null;
+                        IList<object>? schemaEnum = null;
                         if (memberType.GetTypeInfo().IsEnum)
                         {
                             schemaEnum = Enum.GetNames(memberType);
@@ -298,7 +298,7 @@ static Type GetMemberType(MemberInfo memberInfo)
             throw new Exception();
         }
 
-        static Type GetCollectionType(Type type)
+        static Type? GetCollectionType(Type type)
         {
             if (type.IsArray) return type.GetElementType();
 
@@ -338,14 +338,14 @@ static ILookup<Tuple<string, string>, XmlCommentStructure> BuildXmlMemberComment
                         .ToDictionary(e => e.Item1, e => e.Item2.Value.Trim());
 
                     return new XmlCommentStructure
-                    {
-                        ClassName = match.Groups[1].Value,
-                        MethodName = match.Groups[2].Value,
-                        Summary = summary.Trim(),
-                        Remarks = remarks.Trim(),
-                        Parameters = parameters,
-                        Returns = returns.Trim()
-                    };
+                    (
+                        className: match.Groups[1].Value,
+                        methodName: match.Groups[2].Value,
+                        summary: summary.Trim(),
+                        remarks: remarks.Trim(),
+                        parameters: parameters,
+                        returns: returns.Trim()
+                    );
                 })
                 .ToLookup(x => Tuple.Create(x.ClassName, x.MethodName));
 
@@ -422,7 +422,7 @@ static string UnwrapTypeName(Type t)
             return Regex.Replace(t.GetGenericTypeDefinition().Name, @"`.+$", "") + "&lt;" + innerFormat + "&gt;";
         }
 
-        class Item1EqualityCompaerer<T1, T2> : EqualityComparer<Tuple<T1, T2>>
+        class Item1EqualityCompaerer<T1, T2> : EqualityComparer<Tuple<T1, T2>> where T1 : class
         {
             public override bool Equals(Tuple<T1, T2> x, Tuple<T1, T2> y)
             {
@@ -443,6 +443,16 @@ class XmlCommentStructure
             public string Remarks { get; set; }
             public Dictionary<string, string> Parameters { get; set; }
             public string Returns { get; set; }
+
+            public XmlCommentStructure(string className, string methodName, string summary, string remarks, Dictionary<string,string> parameters, string returns)
+            {
+                ClassName = className;
+                MethodName = methodName;
+                Summary = summary;
+                Remarks = remarks;
+                Parameters = parameters;
+                Returns = returns;
+            }
         }
     }
 
@@ -459,7 +469,7 @@ protected override JsonProperty CreateProperty(MemberInfo member, MemberSerializ
             {
                 property.ShouldSerialize = instance =>
                 {
-                    IEnumerable enumerable = null;
+                    IEnumerable? enumerable = null;
 
                     // this value could be in a public field or public property
                     switch (member.MemberType)
diff --git a/src/MicroBatchFramework.WebHosting/Swagger/SwaggerOptions.cs b/src/MicroBatchFramework.WebHosting/Swagger/SwaggerOptions.cs
@@ -12,9 +12,9 @@ public class SwaggerOptions
         /// <summary>
         /// (FilePath, LoadedEmbeddedBytes) => CustomBytes)
         /// </summary>
-        public Func<string, byte[], byte[]> ResolveCustomResource { get; set; }
-        public Func<HttpContext, string> CustomHost { get; set; }
-        public string XmlDocumentPath { get; set; }
+        public Func<string, byte[]?, byte[]>? ResolveCustomResource { get; set; }
+        public Func<HttpContext, string>? CustomHost { get; set; }
+        public string? XmlDocumentPath { get; set; }
         public string JsonName { get; set; }
         public string[] ForceSchemas { get; set; }
 
diff --git a/src/MicroBatchFramework/BatchContext.cs b/src/MicroBatchFramework/BatchContext.cs
@@ -6,12 +6,12 @@ namespace MicroBatchFramework
 {
     public class BatchContext
     {
-        public string[] Arguments { get; private set; }
+        public string?[] Arguments { get; private set; }
         public DateTime Timestamp { get; private set; }
         public CancellationToken CancellationToken { get; private set; }
         public ILogger<BatchEngine> Logger { get; private set; }
 
-        public BatchContext(string[] arguments, DateTime timestamp, CancellationToken cancellationToken, ILogger<BatchEngine> logger)
+        public BatchContext(string?[] arguments, DateTime timestamp, CancellationToken cancellationToken, ILogger<BatchEngine> logger)
         {
             Arguments = arguments;
             Timestamp = timestamp;
diff --git a/src/MicroBatchFramework/BatchEngine.cs b/src/MicroBatchFramework/BatchEngine.cs
@@ -26,7 +26,7 @@ public BatchEngine(ILogger<BatchEngine> logger, IServiceProvider provider, IBatc
             this.cancellationToken = cancellationToken;
         }
 
-        public async Task RunAsync(Type type, MethodInfo method, string[] args)
+        public async Task RunAsync(Type type, MethodInfo method, string?[] args)
         {
             logger.LogTrace("BatchEngine.Run Start");
             var ctx = new BatchContext(args, DateTime.UtcNow, cancellationToken, logger);
@@ -116,7 +116,7 @@ public async Task RunAsync(Type type, string[] args)
             await RunCore(ctx, type, method, args, argsOffset);
         }
 
-        async Task RunCore(BatchContext ctx, Type type, MethodInfo methodInfo, string[] args, int argsOffset)
+        async Task RunCore(BatchContext ctx, Type type, MethodInfo methodInfo, string?[] args, int argsOffset)
         {
             object instance;
             object[] invokeArgs;
@@ -199,7 +199,7 @@ async ValueTask SetFailAsync(BatchContext context, string message, Exception ex)
             await interceptor.OnBatchRunCompleteAsync(context, message, ex);
         }
 
-        static bool TryGetInvokeArguments(ParameterInfo[] parameters, string[] args, int argsOffset, out object[] invokeArgs, out string? errorMessage)
+        static bool TryGetInvokeArguments(ParameterInfo[] parameters, string?[] args, int argsOffset, out object[] invokeArgs, out string? errorMessage)
         {
             var argumentDictionary = ParseArgument(args, argsOffset);
             invokeArgs = new object[parameters.Length];
@@ -294,22 +294,29 @@ static bool TryGetInvokeArguments(ParameterInfo[] parameters, string[] args, int
             return true;
         }
 
-        static ReadOnlyDictionary<string, OptionParameter> ParseArgument(string[] args, int argsOffset)
+        static ReadOnlyDictionary<string, OptionParameter> ParseArgument(string?[] args, int argsOffset)
         {
             var dict = new Dictionary<string, OptionParameter>(args.Length, StringComparer.OrdinalIgnoreCase);
             for (int i = argsOffset; i < args.Length;)
             {
-                if (!args[i].StartsWith("-"))
+                var key = args[i++];
+                if (key is null || !key.StartsWith("-"))
                 {
-                    i++;
                     continue; // not key
                 }
 
-                var key = args[i++].TrimStart('-');
-                if (i < args.Length && !args[i].StartsWith("-"))
+                key = key.TrimStart('-');
+                if (i >= args.Length)
+                {
+                    dict.Add(key, new OptionParameter { BooleanSwitch = true }); // Last parameter
+                    break;
+                }
+
+                var value = args[i];
+                if (value != null && !value.StartsWith("-"))
                 {
-                    var value = args[i++];
                     dict.Add(key, new OptionParameter { Value = value });
+                    i++;
                 }
                 else
                 {
@@ -322,7 +329,7 @@ static ReadOnlyDictionary<string, OptionParameter> ParseArgument(string[] args,
 
         struct OptionParameter
         {
-            public string Value;
+            public string? Value;
             public bool BooleanSwitch;
         }
 

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ namespace MicroBatchFramework // .WebHosting`
`14`	`14`	`{`
`15`	`15`	`public static class BatchEngineHostingExtensions`
`16`	`16`	`{`
`17`		`- public static IWebHostBuilder PrepareBatchEngineMiddleware(this IWebHostBuilder builder, IBatchInterceptor interceptor = null)`
	`17`	`+ public static IWebHostBuilder PrepareBatchEngineMiddleware(this IWebHostBuilder builder, IBatchInterceptor? interceptor = null)`
`18`	`18`	`{`
`19`	`19`	`var batchTypes = CollectBatchTypes();`
`20`	`20`	`var target = new TargetBatchTypeCollection(batchTypes);`
`@@ -31,7 +31,7 @@ public static IWebHostBuilder PrepareBatchEngineMiddleware(this IWebHostBuilder`
`31`	`31`	`});`
`32`	`32`	`}`
`33`	`33`
`34`		`- public static Task RunBatchEngineWebHosting(this IWebHostBuilder builder, string urls, SwaggerOptions swaggerOptions = null, IBatchInterceptor interceptor = null)`
	`34`	`+ public static Task RunBatchEngineWebHosting(this IWebHostBuilder builder, string urls, SwaggerOptions? swaggerOptions = null, IBatchInterceptor? interceptor = null)`
`35`	`35`	`{`
`36`	`36`	`return builder`
`37`	`37`	`.PrepareBatchEngineMiddleware(interceptor)`
`@@ -43,7 +43,7 @@ public static Task RunBatchEngineWebHosting(this IWebHostBuilder builder, string`
`43`	`43`	`var entryAsm = Assembly.GetEntryAssembly()!;`
`44`	`44`	`var xmlName = entryAsm.GetName().Name + ".xml";`
`45`	`45`	`var xmlPath = Path.Combine(Path.GetDirectoryName(entryAsm.Location) ?? "", xmlName);`
`46`		`- swaggerOptions = new SwaggerOptions(entryAsm.GetName().Name, "", "/") { XmlDocumentPath = xmlPath };`
	`46`	`+ swaggerOptions = new SwaggerOptions(entryAsm.GetName().Name!, "", "/") { XmlDocumentPath = xmlPath };`
`47`	`47`	`}`
`48`	`48`	`services.AddSingleton<SwaggerOptions>(swaggerOptions);`
`49`	`49`	`})`
`@@ -105,7 +105,7 @@ static List<Type> CollectBatchTypes()`
`105`	`105`	`if (!(asm.FullName is null)`
`106`	`106`	`&& (asm.FullName.StartsWith("System") \|\| asm.FullName.StartsWith("Microsoft.Extensions"))) continue;`
`107`	`107`
`108`		`- Type[] types;`
	`108`	`+ Type[]? types;`
`109`	`109`	`try`
`110`	`110`	`{`
`111`	`111`	`types = asm.GetTypes();`
Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,8 @@ internal class WebHostingInterceptor : IBatchInterceptor`
`14`	`14`	`readonly IBatchInterceptor innerInterceptor;`
`15`	`15`
`16`	`16`	`public bool CompleteSuccessfully { get; private set; }`
`17`		`- public string ErrorMessage { get; private set; }`
`18`		`- public Exception Exception { get; private set; }`
	`17`	`+ public string? ErrorMessage { get; private set; }`
	`18`	`+ public Exception? Exception { get; private set; }`
`19`	`19`
`20`	`20`	`public WebHostingInterceptor(IBatchInterceptor innerInterceptor)`
`21`	`21`	`{`
`@@ -37,7 +37,7 @@ public ValueTask OnBatchRunBeginAsync(BatchContext context)`
`37`	`37`	`return innerInterceptor.OnBatchRunBeginAsync(context);`
`38`	`38`	`}`
`39`	`39`
`40`		`- public ValueTask OnBatchRunCompleteAsync(BatchContext context, string errorMessageIfFailed, Exception exceptionIfExists)`
	`40`	`+ public ValueTask OnBatchRunCompleteAsync(BatchContext context, string? errorMessageIfFailed, Exception? exceptionIfExists)`
`41`	`41`	`{`
`42`	`42`	`this.CompleteSuccessfully = (errorMessageIfFailed == null && exceptionIfExists == null);`
`43`	`43`	`this.ErrorMessage = errorMessageIfFailed;`
`@@ -115,7 +115,7 @@ public async Task Invoke(HttpContext httpContext)`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`// create args`
`118`		`- string[] args = null;`
	`118`	`+ string?[] args;`
`119`	`119`	`try`
`120`	`120`	`{`
`121`	`121`	`if (httpContext.Request.HasFormContentType)`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public class SwaggerDefinitionBuilder`
`20`	`20`	`readonly HttpContext httpContext;`
`21`	`21`	`readonly IEnumerable<MethodInfo> handlers;`
`22`	`22`
`23`		`- ILookup<Tuple<string, string>, XmlCommentStructure> xDocLookup;`
	`23`	`+ ILookup<Tuple<string, string>, XmlCommentStructure>? xDocLookup;`
`24`	`24`
`25`	`25`	`public SwaggerDefinitionBuilder(SwaggerOptions options, HttpContext httpContext, IEnumerable<MethodInfo> handlers)`
`26`	`26`	`{`
`@@ -33,15 +33,13 @@ public byte[] BuildSwaggerJson()`
`33`	`33`	`{`
`34`	`34`	`try`
`35`	`35`	`{`
`36`		`- if (options.XmlDocumentPath != null && !File.Exists(options.XmlDocumentPath))`
	`36`	`+ if (options.XmlDocumentPath != null && File.Exists(options.XmlDocumentPath))`
`37`	`37`	`{`
`38`		`- xDocLookup = null;`
	`38`	`+ xDocLookup = BuildXmlMemberCommentStructure(options.XmlDocumentPath);`
`39`	`39`	`}`
`40`	`40`	`else`
`41`	`41`	`{`
`42`		`- xDocLookup = (options.XmlDocumentPath != null)`
`43`		`- ? BuildXmlMemberCommentStructure(options.XmlDocumentPath)`
`44`		`- : null;`
	`42`	`+ xDocLookup = null;`
`45`	`43`	`}`
`46`	`44`
`47`	`45`	`var doc = new SwaggerDocument();`
`@@ -54,7 +52,7 @@ public byte[] BuildSwaggerJson()`
`54`	`52`
`55`	`53`	`// tags.`
`56`	`54`	`var xmlServiceName = (xDocLookup != null)`
`57`		`- ? BuildXmlTypeSummary(options.XmlDocumentPath)`
	`55`	`+ ? BuildXmlTypeSummary(options.XmlDocumentPath!) // xDocLookup is not null if XmlDocumentPath is not null.`
`58`	`56`	`: null;`
`59`	`57`
`60`	`58`	`doc.tags = handlers`
`@@ -63,7 +61,7 @@ public byte[] BuildSwaggerJson()`
`63`	`61`	`.Distinct()`
`64`	`62`	`.Select(x =>`
`65`	`63`	`{`
`66`		`- string desc = null;`
	`64`	`+ string? desc = null;`
`67`	`65`	`if (xmlServiceName != null)`
`68`	`66`	`{`
`69`	`67`	`xmlServiceName.TryGetValue(x, out desc);`
`@@ -80,7 +78,7 @@ public byte[] BuildSwaggerJson()`
`80`	`78`	`{`
`81`	`79`	`// MemberInfo.DeclaringType is null only if it is a member of a VB Module.`
`82`	`80`	`string declaringTypeName = item.DeclaringType!.Name;`
`83`		`- XmlCommentStructure xmlComment = null;`
	`81`	`+ XmlCommentStructure? xmlComment = null;`
`84`	`82`	`if (xDocLookup != null)`
`85`	`83`	`{`
`86`	`84`	`// ParameterInfo.Name will be null only it is ReturnParameter.`
`@@ -123,7 +121,7 @@ public byte[] BuildSwaggerJson()`
`123`	`121`	`}`
`124`	`122`	`}`
`125`	`123`
`126`		`- Schemas.Parameter[] BuildParameters(IDictionary<string, Schema> definitions, XmlCommentStructure xmlComment, MethodInfo method)`
	`124`	`+ Schemas.Parameter[] BuildParameters(IDictionary<string, Schema> definitions, XmlCommentStructure? xmlComment, MethodInfo method)`
`127`	`125`	`{`
`128`	`126`	`var parameterInfos = method.GetParameters();`
`129`	`127`	`var parameters = parameterInfos`
`@@ -132,7 +130,8 @@ Schemas.Parameter[] BuildParameters(IDictionary<string, Schema> definitions, Xml`
`132`	`130`	`var parameterXmlComment = UnwrapTypeName(x.ParameterType);`
`133`	`131`	`if (xmlComment != null)`
`134`	`132`	`{`
`135`		`- xmlComment.Parameters.TryGetValue(x.Name, out parameterXmlComment!);`
	`133`	`+ // Name is null only if Parameter is ReturnParameter.`
	`134`	`+ xmlComment.Parameters.TryGetValue(x.Name!, out parameterXmlComment!);`
`136`	`135`	`parameterXmlComment = UnwrapTypeName(x.ParameterType) + " " + parameterXmlComment;`
`137`	`136`	`}`
`138`	`137`
`@@ -147,8 +146,8 @@ Schemas.Parameter[] BuildParameters(IDictionary<string, Schema> definitions, Xml`
`147`	`146`	`? new PartialSchema { type = ToSwaggerDataType(collectionType) }`
`148`	`147`	`: null;`
`149`	`148`
`150`		`- string defaultObjectExample = null;`
`151`		`- object[] enums = null;`
	`149`	`+ string? defaultObjectExample = null;`
	`150`	`+ object[]? enums = null;`
`152`	`151`	`if (x.ParameterType.GetTypeInfo().IsEnum \|\| (collectionType != null && collectionType.GetTypeInfo().IsEnum))`
`153`	`152`	`{`
`154`	`153`	`// Compiler cannot understand collectionType is not null.`
`@@ -169,7 +168,7 @@ Schemas.Parameter[] BuildParameters(IDictionary<string, Schema> definitions, Xml`
`169`	`168`	`}`
`170`	`169`
`171`	`170`	`var swaggerDataType = ToSwaggerDataType(x.ParameterType);`
`172`		`- Schema refSchema = null;`
	`171`	`+ Schema? refSchema = null;`
`173`	`172`	`if (swaggerDataType == "object")`
`174`	`173`	`{`
`175`	`174`	`BuildSchema(definitions, x.ParameterType);`
`@@ -203,7 +202,7 @@ string BuildSchema(IDictionary<string, Schema> definitions, Type type)`
`203`	`202`	`var fullName = type.FullName;`
`204`	`203`	`if (fullName == null) return ""; // safety(TODO:IDictionary<> is not supported)`
`205`	`204`
`206`		`- Schema schema;`
	`205`	`+ Schema? schema;`
`207`	`206`	`if (definitions.TryGetValue(fullName, out schema)) return "#/definitions/" + fullName;`
`208`	`207`
`209`	`208`	`var properties = type.GetProperties(BindingFlags.Instance \| BindingFlags.Public);`
`@@ -229,10 +228,11 @@ string BuildSchema(IDictionary<string, Schema> definitions, Type type)`
`229`	`228`	`}`
`230`	`229`	`else`
`231`	`230`	`{`
`232`		`- Schema items = null;`
	`231`	`+ Schema? items = null;`
`233`	`232`	`if (swaggerDataType == "array")`
`234`	`233`	`{`
`235`		`- var collectionType = GetCollectionType(memberType);`
	`234`	`+ // If swaggerDataType is array, it will be Collection.`
	`235`	`+ Type collectionType = GetCollectionType(memberType)!;`
`236`	`236`	`var dataType = ToSwaggerDataType(collectionType);`
`237`	`237`	`if (dataType == "object")`
`238`	`238`	`{`
`@@ -258,7 +258,7 @@ string BuildSchema(IDictionary<string, Schema> definitions, Type type)`
`258`	`258`	`}`
`259`	`259`	`}`
`260`	`260`
`261`		`- IList<object> schemaEnum = null;`
	`261`	`+ IList<object>? schemaEnum = null;`
`262`	`262`	`if (memberType.GetTypeInfo().IsEnum)`
`263`	`263`	`{`
`264`	`264`	`schemaEnum = Enum.GetNames(memberType);`
`@@ -298,7 +298,7 @@ static Type GetMemberType(MemberInfo memberInfo)`
`298`	`298`	`throw new Exception();`
`299`	`299`	`}`
`300`	`300`
`301`		`- static Type GetCollectionType(Type type)`
	`301`	`+ static Type? GetCollectionType(Type type)`
`302`	`302`	`{`
`303`	`303`	`if (type.IsArray) return type.GetElementType();`
`304`	`304`
`@@ -338,14 +338,14 @@ static ILookup<Tuple<string, string>, XmlCommentStructure> BuildXmlMemberComment`
`338`	`338`	`.ToDictionary(e => e.Item1, e => e.Item2.Value.Trim());`
`339`	`339`
`340`	`340`	`return new XmlCommentStructure`
`341`		`- {`
`342`		`- ClassName = match.Groups[1].Value,`
`343`		`- MethodName = match.Groups[2].Value,`
`344`		`- Summary = summary.Trim(),`
`345`		`- Remarks = remarks.Trim(),`
`346`		`- Parameters = parameters,`
`347`		`- Returns = returns.Trim()`
`348`		`- };`
	`341`	`+ (`
	`342`	`+ className: match.Groups[1].Value,`
	`343`	`+ methodName: match.Groups[2].Value,`
	`344`	`+ summary: summary.Trim(),`
	`345`	`+ remarks: remarks.Trim(),`
	`346`	`+ parameters: parameters,`
	`347`	`+ returns: returns.Trim()`
	`348`	`+ );`
`349`	`349`	`})`
`350`	`350`	`.ToLookup(x => Tuple.Create(x.ClassName, x.MethodName));`
`351`	`351`
`@@ -422,7 +422,7 @@ static string UnwrapTypeName(Type t)`
`422`	`422`	return Regex.Replace(t.GetGenericTypeDefinition().Name, @"`.+$", "") + "<" + innerFormat + ">";
`423`	`423`	`}`
`424`	`424`
`425`		`- class Item1EqualityCompaerer<T1, T2> : EqualityComparer<Tuple<T1, T2>>`
	`425`	`+ class Item1EqualityCompaerer<T1, T2> : EqualityComparer<Tuple<T1, T2>> where T1 : class`
`426`	`426`	`{`
`427`	`427`	`public override bool Equals(Tuple<T1, T2> x, Tuple<T1, T2> y)`
`428`	`428`	`{`
`@@ -443,6 +443,16 @@ class XmlCommentStructure`
`443`	`443`	`public string Remarks { get; set; }`
`444`	`444`	`public Dictionary<string, string> Parameters { get; set; }`
`445`	`445`	`public string Returns { get; set; }`
	`446`	`+`
	`447`	`+ public XmlCommentStructure(string className, string methodName, string summary, string remarks, Dictionary<string,string> parameters, string returns)`
	`448`	`+ {`
	`449`	`+ ClassName = className;`
	`450`	`+ MethodName = methodName;`
	`451`	`+ Summary = summary;`
	`452`	`+ Remarks = remarks;`
	`453`	`+ Parameters = parameters;`
	`454`	`+ Returns = returns;`
	`455`	`+ }`
`446`	`456`	`}`
`447`	`457`	`}`
`448`	`458`
`@@ -459,7 +469,7 @@ protected override JsonProperty CreateProperty(MemberInfo member, MemberSerializ`
`459`	`469`	`{`
`460`	`470`	`property.ShouldSerialize = instance =>`
`461`	`471`	`{`
`462`		`- IEnumerable enumerable = null;`
	`472`	`+ IEnumerable? enumerable = null;`
`463`	`473`
`464`	`474`	`// this value could be in a public field or public property`
`465`	`475`	`switch (member.MemberType)`
Original file line number	Diff line number	Diff line change
`@@ -6,12 +6,12 @@ namespace MicroBatchFramework`
`6`	`6`	`{`
`7`	`7`	`public class BatchContext`
`8`	`8`	`{`
`9`		`- public string[] Arguments { get; private set; }`
	`9`	`+ public string?[] Arguments { get; private set; }`
`10`	`10`	`public DateTime Timestamp { get; private set; }`
`11`	`11`	`public CancellationToken CancellationToken { get; private set; }`
`12`	`12`	`public ILogger<BatchEngine> Logger { get; private set; }`
`13`	`13`
`14`		`- public BatchContext(string[] arguments, DateTime timestamp, CancellationToken cancellationToken, ILogger<BatchEngine> logger)`
	`14`	`+ public BatchContext(string?[] arguments, DateTime timestamp, CancellationToken cancellationToken, ILogger<BatchEngine> logger)`
`15`	`15`	`{`
`16`	`16`	`Arguments = arguments;`
`17`	`17`	`Timestamp = timestamp;`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public BatchEngine(ILogger<BatchEngine> logger, IServiceProvider provider, IBatc`
`26`	`26`	`this.cancellationToken = cancellationToken;`
`27`	`27`	`}`
`28`	`28`
`29`		`- public async Task RunAsync(Type type, MethodInfo method, string[] args)`
	`29`	`+ public async Task RunAsync(Type type, MethodInfo method, string?[] args)`
`30`	`30`	`{`
`31`	`31`	`logger.LogTrace("BatchEngine.Run Start");`
`32`	`32`	`var ctx = new BatchContext(args, DateTime.UtcNow, cancellationToken, logger);`
`@@ -116,7 +116,7 @@ public async Task RunAsync(Type type, string[] args)`
`116`	`116`	`await RunCore(ctx, type, method, args, argsOffset);`
`117`	`117`	`}`
`118`	`118`
`119`		`- async Task RunCore(BatchContext ctx, Type type, MethodInfo methodInfo, string[] args, int argsOffset)`
	`119`	`+ async Task RunCore(BatchContext ctx, Type type, MethodInfo methodInfo, string?[] args, int argsOffset)`
`120`	`120`	`{`
`121`	`121`	`object instance;`
`122`	`122`	`object[] invokeArgs;`
`@@ -199,7 +199,7 @@ async ValueTask SetFailAsync(BatchContext context, string message, Exception ex)`
`199`	`199`	`await interceptor.OnBatchRunCompleteAsync(context, message, ex);`
`200`	`200`	`}`
`201`	`201`
`202`		`- static bool TryGetInvokeArguments(ParameterInfo[] parameters, string[] args, int argsOffset, out object[] invokeArgs, out string? errorMessage)`
	`202`	`+ static bool TryGetInvokeArguments(ParameterInfo[] parameters, string?[] args, int argsOffset, out object[] invokeArgs, out string? errorMessage)`
`203`	`203`	`{`
`204`	`204`	`var argumentDictionary = ParseArgument(args, argsOffset);`
`205`	`205`	`invokeArgs = new object[parameters.Length];`
`@@ -294,22 +294,29 @@ static bool TryGetInvokeArguments(ParameterInfo[] parameters, string[] args, int`
`294`	`294`	`return true;`
`295`	`295`	`}`
`296`	`296`
`297`		`- static ReadOnlyDictionary<string, OptionParameter> ParseArgument(string[] args, int argsOffset)`
	`297`	`+ static ReadOnlyDictionary<string, OptionParameter> ParseArgument(string?[] args, int argsOffset)`
`298`	`298`	`{`
`299`	`299`	`var dict = new Dictionary<string, OptionParameter>(args.Length, StringComparer.OrdinalIgnoreCase);`
`300`	`300`	`for (int i = argsOffset; i < args.Length;)`
`301`	`301`	`{`
`302`		`- if (!args[i].StartsWith("-"))`
	`302`	`+ var key = args[i++];`
	`303`	`+ if (key is null \|\| !key.StartsWith("-"))`
`303`	`304`	`{`
`304`		`- i++;`
`305`	`305`	`continue; // not key`
`306`	`306`	`}`
`307`	`307`
`308`		`- var key = args[i++].TrimStart('-');`
`309`		`- if (i < args.Length && !args[i].StartsWith("-"))`
	`308`	`+ key = key.TrimStart('-');`
	`309`	`+ if (i >= args.Length)`
	`310`	`+ {`
	`311`	`+ dict.Add(key, new OptionParameter { BooleanSwitch = true }); // Last parameter`
	`312`	`+ break;`
	`313`	`+ }`
	`314`	`+`
	`315`	`+ var value = args[i];`
	`316`	`+ if (value != null && !value.StartsWith("-"))`
`310`	`317`	`{`
`311`		`- var value = args[i++];`
`312`	`318`	`dict.Add(key, new OptionParameter { Value = value });`
	`319`	`+ i++;`
`313`	`320`	`}`
`314`	`321`	`else`
`315`	`322`	`{`
`@@ -322,7 +329,7 @@ static ReadOnlyDictionary<string, OptionParameter> ParseArgument(string[] args,`
`322`	`329`
`323`	`330`	`struct OptionParameter`
`324`	`331`	`{`
`325`		`- public string Value;`
	`332`	`+ public string? Value;`
`326`	`333`	`public bool BooleanSwitch;`
`327`	`334`	`}`
`328`	`335`