Create Reflection wrappers

Author: rube200

src/Helpers/Wrapper/NuGetConsoleLoggerWrapper.cs

@@ -0,0 +1,10 @@
+using System.Reflection;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class NuGetConsoleLoggerWrapper : TypeWrapper
+    {
+        public NuGetConsoleLoggerWrapper(Assembly nugetAssembly) : base(nugetAssembly, "NuGetConsoleLogger")
+        { }
+    }
+}

src/Helpers/Wrapper/NuGetPackageManagerWrapper.cs

@@ -0,0 +1,54 @@
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class NuGetPackageManagerWrapper : TypeWrapper
+    {
+        protected static PropertyInfo m_Logger;
+        protected static MethodInfo m_IgnoreDependencies;
+        protected static MethodInfo m_GetLatestPackageIdentityAsync;
+        protected static MethodInfo m_QueryPackageExactAsync;
+        protected static MethodInfo m_InstallAsync;
+
+        public NuGetPackageManagerWrapper(Assembly nugetAssembly, params object[] args) : base(nugetAssembly, "NuGetPackageManager", args)
+        {
+            m_Logger ??= s_Type.GetProperty("Logger");
+            m_IgnoreDependencies ??= s_Type.GetMethod("IgnoreDependencies");
+            m_GetLatestPackageIdentityAsync ??= s_Type.GetMethod("GetLatestPackageIdentityAsync");
+            m_QueryPackageExactAsync ??= s_Type.GetMethod("QueryPackageExactAsync");
+            m_InstallAsync ??= s_Type.GetMethod("InstallAsync");
+        }
+
+        public void SetLogger(NuGetConsoleLoggerWrapper logger)
+        {
+            m_Logger.SetValue(m_Instance, logger.Instance);
+        }
+
+        public void IgnoreDependencies(params string[] packageIds)
+        {
+            m_IgnoreDependencies.Invoke(m_Instance, new object[] { packageIds });
+        }
+
+        public async Task<PackageIdentityWrapper> GetLatestPackageIdentityAsync(string packageId)
+        {
+            var taskObj = m_GetLatestPackageIdentityAsync.Invoke(m_Instance, new object[] { packageId }) as Task;
+            var taskWrapper = new TaskWrapper<PackageIdentityWrapper>(taskObj);
+            return await taskWrapper.GetResult();
+        }
+
+        public async Task<PackageSearchMetadataWrapper> QueryPackageExactAsync(string packageId, string version = null, bool includePreRelease = false)
+        {
+            var taskObj = m_QueryPackageExactAsync.Invoke(m_Instance, new object[] { packageId, version, includePreRelease }) as Task;
+            var taskWrapper = new TaskWrapper<PackageSearchMetadataWrapper>(taskObj);
+            return await taskWrapper.GetResult();
+        }
+
+        public async Task<NuGetInstallResultWrapper> InstallAsync(PackageIdentityWrapper packageIdentity, bool allowPreReleaseVersions = false)
+        {
+            var taskObj = m_InstallAsync.Invoke(m_Instance, new[] { packageIdentity.Instance, allowPreReleaseVersions }) as Task;
+            var taskWrapper = new TaskWrapper<NuGetInstallResultWrapper>(taskObj);
+            return await taskWrapper.GetResult();
+        }
+    }
+}

src/Helpers/Wrapper/NuGetVersionWrapper.cs

@@ -0,0 +1,8 @@
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class NuGetVersionWrapper : TypeWrapper
+    {
+        public NuGetVersionWrapper(object instance) : base(instance)
+        { }
+    }
+}

src/Helpers/Wrapper/NugetWrapper.cs

@@ -0,0 +1,16 @@
+using System.Reflection;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class NuGetInstallResultWrapper : TypeWrapper
+    {
+        protected static PropertyInfo m_Code;
+
+        public int Code => (int)m_Code.GetValue(m_Instance);
+
+        public NuGetInstallResultWrapper(object instance) : base(instance)
+        {
+            m_Code = s_Type.GetProperty("Code");
+        }
+    }
+}

src/Helpers/Wrapper/PackageIdentityWrapper.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class PackageIdentityWrapper : TypeWrapper
+    {
+        protected static FieldInfo m_Id;
+        protected static FieldInfo m_Version;
+
+        public string Id => m_Id.GetValue(m_Instance) as string;
+
+        public bool HasVersion
+        {
+            get
+            {
+                var version = m_Version.GetValue(m_Instance);
+                return version != null;
+            }
+        }
+
+        public NuGetVersionWrapper Version
+        {
+            get
+            {
+                var version = m_Version.GetValue(m_Instance);
+                return version == null ? null : new NuGetVersionWrapper(version);
+            }
+        }
+
+        public PackageIdentityWrapper(object instance) : base(instance)
+        {
+            m_Id = s_Type.GetField("_id", BindingFlags.NonPublic | BindingFlags.Instance);
+            m_Version = s_Type.GetField("_version", BindingFlags.NonPublic | BindingFlags.Instance);
+        }
+    }
+}

src/Helpers/Wrapper/PackageSearchMetadataWrapper.cs

@@ -0,0 +1,23 @@
+using System.Reflection;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class PackageSearchMetadataWrapper : TypeWrapper
+    {
+        protected static PropertyInfo m_Identity;
+
+        public PackageIdentityWrapper Identity
+        {
+            get
+            {
+                var identity = m_Identity.GetValue(m_Instance);
+                return new PackageIdentityWrapper(identity);
+            }
+        }
+
+        public PackageSearchMetadataWrapper(object instance) : base(instance)
+        {
+            m_Identity = s_Type.GetProperty("Identity");
+        }
+    }
+}

src/Helpers/Wrapper/TaskWrapper.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class TaskWrapper<TResult>
+    {
+        protected PropertyInfo m_Result;
+        protected Task m_Instance;
+
+        public Task Instance => m_Instance;
+
+        public async Task<TResult> GetResult()
+        {
+            await m_Instance;
+
+            var resultObj = m_Result.GetValue(m_Instance);
+            return resultObj switch
+            {
+                null => default,
+                TResult result => result,
+                _ => (TResult)Activator.CreateInstance(typeof(TResult), resultObj)
+            };
+        }
+
+        public TaskWrapper(Task instance)
+        {
+            m_Instance = instance;
+            m_Result = instance.GetType().GetProperty("Result");
+        }
+    }
+}

src/Helpers/Wrapper/TypeWrapper.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Linq;
+using System.Reflection;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public abstract class TypeWrapper
+    {
+        protected Type s_Type;
+
+        protected object m_Instance;
+
+        public object Instance => m_Instance;
+
+        protected TypeWrapper(object instance)
+        {
+            m_Instance = instance;
+            s_Type = instance.GetType();
+        }
+
+        protected TypeWrapper(Assembly nugetAssembly, string typeName, params object[] args)
+        {
+            s_Type = nugetAssembly.GetTypes().First(tp => tp.Name.Equals(typeName, StringComparison.OrdinalIgnoreCase));
+            m_Instance = Activator.CreateInstance(s_Type, args);
+        }
+    }
+}