Update Aspects.Universal to use Nullable

samples/src/Universal/Aspects.Universal.csproj

@@ -1,13 +1,19 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
-    <Version>1.0.1</Version>
+    <Version>1.0.2</Version>
 		<TargetFramework>netstandard2.0</TargetFramework>
     <PackageTags>aspect proxy wrapper universal</PackageTags>
     <Description>
-      This package provides simple universal method wrrapper aspect.
+      This package provides simple universal method wrapper aspect.
     </Description>
     <PackageProjectUrl>https://github.com/pamidur/aspect-injector/tree/master/samples/src/Universal</PackageProjectUrl>
+    <LangVersion>10</LangVersion>
+    <Nullable>enable</Nullable>
 	</PropertyGroup>
 
+	<ItemGroup>
+	  <PackageReference Update="AspectInjector" Version="2.8.1" />
+	</ItemGroup>
+
 </Project>

samples/src/Universal/Aspects/BaseUniversalWrapperAspect.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
@@ -19,15 +19,15 @@ public abstract class BaseUniversalWrapperAspect
         private static readonly ConcurrentDictionary<(MethodBase, Type), Lazy<Handler>> _delegateCache = new ConcurrentDictionary<(MethodBase, Type), Lazy<Handler>>();
 
         private static readonly MethodInfo _asyncGenericHandler =
-            typeof(BaseUniversalWrapperAttribute).GetMethod(nameof(BaseUniversalWrapperAttribute.WrapAsync), BindingFlags.NonPublic | BindingFlags.Instance);
+            typeof(BaseUniversalWrapperAttribute).GetMethod(nameof(BaseUniversalWrapperAttribute.WrapAsync), BindingFlags.NonPublic | BindingFlags.Instance)!;
 
         private static readonly MethodInfo _syncGenericHandler =
-            typeof(BaseUniversalWrapperAttribute).GetMethod(nameof(BaseUniversalWrapperAttribute.WrapSync), BindingFlags.NonPublic | BindingFlags.Instance);
+            typeof(BaseUniversalWrapperAttribute).GetMethod(nameof(BaseUniversalWrapperAttribute.WrapSync), BindingFlags.NonPublic | BindingFlags.Instance)!;
 
-        private static readonly Type _voidTaskResult = Type.GetType("System.Threading.Tasks.VoidTaskResult");
+        private static readonly Type _voidTaskResult = Type.GetType("System.Threading.Tasks.VoidTaskResult")!;
 
         protected object BaseHandle(
-            object instance,
+            object? instance,
             Type type,
             MethodBase method,
             Func<object[], object> target,
@@ -53,7 +53,7 @@ protected object BaseHandle(
             return handler(target, args, eventArgs);
         }
 
-        private Handler CreateMethodHandler(Type returnType, IReadOnlyList<BaseUniversalWrapperAttribute> wrappers)
+        private static Handler CreateMethodHandler(Type returnType, IReadOnlyList<BaseUniversalWrapperAttribute> wrappers)
         {
             var targetParam = Expression.Parameter(typeof(Func<object[], object>), "orig");
             var eventArgsParam = Expression.Parameter(typeof(AspectEventArgs), "event");
@@ -75,24 +75,24 @@ private Handler CreateMethodHandler(Type returnType, IReadOnlyList<BaseUniversal
                 wrapperMethod = _syncGenericHandler.MakeGenericMethod(new[] { returnType });
             }
 
-            var converArgs = Expression.Parameter(typeof(object[]), "args");
-            var next = Expression.Lambda(Expression.Convert(Expression.Invoke(targetParam, converArgs), returnType), converArgs);
+            var convertArgs = Expression.Parameter(typeof(object[]), "args");
+            var next = Expression.Lambda(Expression.Convert(Expression.Invoke(targetParam, convertArgs), returnType), convertArgs);
 
             foreach (var wrapper in wrappers)
             {
                 var argsParam = Expression.Parameter(typeof(object[]), "args");
                 next = Expression.Lambda(Expression.Call(Expression.Constant(wrapper), wrapperMethod, next, argsParam, eventArgsParam), argsParam);
             }
 
-            var orig_args = Expression.Parameter(typeof(object[]), "orig_args");
-            var handler = Expression.Lambda<Handler>(Expression.Convert(Expression.Invoke(next, orig_args), typeof(object)), targetParam, orig_args, eventArgsParam);
+            var originalArgs = Expression.Parameter(typeof(object[]), "orig_args");
+            var handler = Expression.Lambda<Handler>(Expression.Convert(Expression.Invoke(next, originalArgs), typeof(object)), targetParam, originalArgs, eventArgsParam);
 
             var handlerCompiled = handler.Compile();
 
             return handlerCompiled;
         }
 
-        private Handler GetMethodHandler(MethodBase method, Type returnType, IReadOnlyList<BaseUniversalWrapperAttribute> wrappers)
+        private static Handler GetMethodHandler(MethodBase method, Type returnType, IReadOnlyList<BaseUniversalWrapperAttribute> wrappers)
         {
             var lazyHandler = _delegateCache.GetOrAdd((method, returnType), _ => new Lazy<Handler>(() => CreateMethodHandler(returnType, wrappers)));
             return lazyHandler.Value;

samples/src/Universal/Aspects/MethodWrapperAspect.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Reflection;
 using AspectInjector.Broker;
 
@@ -9,7 +9,7 @@ public class MethodWrapperAspect : BaseUniversalWrapperAspect
     {
         [Advice(Kind.Around, Targets = Target.Method)]
         public object Handle(
-            [Argument(Source.Instance)] object instance,
+            [Argument(Source.Instance)] object? instance,
             [Argument(Source.Type)] Type type,
             [Argument(Source.Metadata)] MethodBase method,
             [Argument(Source.Target)] Func<object[], object> target,
@@ -21,4 +21,4 @@ public object Handle(
             return BaseHandle(instance, type, method, target, name, args, returnType, triggers);
         }
     }
-}
+}

samples/src/Universal/Aspects/PrivateMethodWrapperAspect.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Reflection;
 using AspectInjector.Broker;
 
@@ -9,7 +9,7 @@ public class PrivateMethodWrapperAspect : BaseUniversalWrapperAspect
     {
         [Advice(Kind.Around, Targets = Target.Private | Target.Method)]
         public object Handle(
-            [Argument(Source.Instance)] object instance,
+            [Argument(Source.Instance)] object? instance,
             [Argument(Source.Type)] Type type,
             [Argument(Source.Metadata)] MethodBase method,
             [Argument(Source.Target)] Func<object[], object> target,
@@ -21,4 +21,4 @@ public object Handle(
             return BaseHandle(instance, type, method, target, name, args, returnType, triggers);
         }
     }
-}
+}

samples/src/Universal/Aspects/PublicMethodWrapperAspect.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Reflection;
 using AspectInjector.Broker;
 
@@ -9,7 +9,7 @@ public class PublicMethodWrapperAspect : BaseUniversalWrapperAspect
     {
         [Advice(Kind.Around, Targets = Target.Public | Target.Method)]
         public object Handle(
-            [Argument(Source.Instance)] object instance,
+            [Argument(Source.Instance)] object? instance,
             [Argument(Source.Type)] Type type,
             [Argument(Source.Metadata)] MethodBase method,
             [Argument(Source.Target)] Func<object[], object> target,
@@ -21,4 +21,4 @@ public object Handle(
             return BaseHandle(instance, type, method, target, name, args, returnType, triggers);
         }
     }
-}
+}

samples/src/Universal/Aspects/PublicWrapperAspect.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Reflection;
 using AspectInjector.Broker;
 
@@ -9,7 +9,7 @@ public class PublicWrapperAspect : BaseUniversalWrapperAspect
     {
         [Advice(Kind.Around, Targets = Target.Public | Target.Any)]
         public object Handle(
-            [Argument(Source.Instance)] object instance,
+            [Argument(Source.Instance)] object? instance,
             [Argument(Source.Type)] Type type,
             [Argument(Source.Metadata)] MethodBase method,
             [Argument(Source.Target)] Func<object[], object> target,
@@ -21,4 +21,4 @@ public object Handle(
             return BaseHandle(instance, type, method, target, name, args, returnType, triggers);
         }
     }
-}
+}

samples/src/Universal/Events/AspectEventArgs.cs

@@ -1,17 +1,17 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Reflection;
 
 namespace Aspects.Universal.Events
 {
     public class AspectEventArgs : EventArgs
     {
-        public object Instance { get; internal set; }
-        public Type Type { get; internal set; }
-        public MethodBase Method { get; internal set; }
-        public string Name { get; internal set; }
-        public IReadOnlyList<object> Args { get; internal set; }
-        public Type ReturnType { get; internal set; }
-        public Attribute[] Triggers { get; internal set; }
+        public object? Instance { get; internal set; }
+        public Type Type { get; internal set; } = null!;
+        public MethodBase Method { get; internal set; } = null!;
+        public string Name { get; internal set; } = null!;
+        public IReadOnlyList<object> Args { get; internal set; } = null!;
+        public Type ReturnType { get; internal set; } = null!;
+        public Attribute[] Triggers { get; internal set; } = null!;
     }
-}
+}