Rewrite Loader into C#

dev/Directory.Build.targets

@@ -20,7 +20,7 @@
         <PyRevitExtDir>$(PyRevitRootDir)\extensions</PyRevitExtDir>
 
         <RevitDevDir>$(PyRevitDevDir)\libs\Revit</RevitDevDir>
-        <IronPythonStdLibDir>$(PyRevitDevDir)\libs\IronPython\</IronPythonStdLibDir>
+        <IronPythonStdLibDir>$(PyRevitDevDir)\libs\IronPython</IronPythonStdLibDir>
     </PropertyGroup>
 
     <PropertyGroup Condition="$(UseDefaultBin) == 'true'">

dev/pyRevitLoader/Directory.Build.props

@@ -1,9 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-    <PropertyGroup>
+    <PropertyGroup Condition="'$(MSBuildProjectName)' != 'pyRevitAssemblyBuilder'">
         <UseRevit>true</UseRevit>
         <UseWpf>true</UseWpf>
         <UseWindowsForms>true</UseWindowsForms>
+		<UseAssemblyBuilder>true</UseAssemblyBuilder>
         <TargetFrameworks>net48;net8.0-windows</TargetFrameworks>
 
         <EnableDefaultCompileItems>false</EnableDefaultCompileItems>

dev/pyRevitLoader/Directory.Build.targets

@@ -6,7 +6,7 @@
         <None Remove="obj\**" />
     </ItemGroup>
 
-    <ItemGroup Condition="$(UseRunner)=='' OR $(UseRunner)==False">
+    <ItemGroup Condition="$(UseLoader)==True">
         <Compile Include="..\Source\PyRevitLoaderApplication.cs" Link="Source\PyRevitLoaderApplication.cs"/>
         <Compile Include="..\Source\ScriptExecutor.cs" Link="Source\ScriptExecutor.cs"/>
     </ItemGroup>
@@ -17,7 +17,7 @@
         <Compile Include="..\Source\ScriptExecutor.cs" Link="Source\ScriptExecutor.cs"/>
     </ItemGroup>
 
-    <ItemGroup Condition="$(IronPythonVersion.Contains('PR'))">
+    <ItemGroup Condition="'$(MSBuildProjectName)' != 'pyRevitAssemblyBuilder' AND $(IronPythonVersion.Contains('PR'))">
         <Reference Include="IronPython" HintPath="$(PyRevitEnginesDir)\$(IronPythonVersion)\pyRevitLabs.IronPython.dll"/>
         <Reference Include="IronPython.Modules" HintPath="$(PyRevitEnginesDir)\$(IronPythonVersion)\pyRevitLabs.IronPython.Modules.dll"/>
         <Reference Include="IronPython.SQLite" HintPath="$(PyRevitEnginesDir)\$(IronPythonVersion)\pyRevitLabs.IronPython.SQLite.dll"/>
@@ -26,15 +26,19 @@
         <Reference Include="Microsoft.Scripting" HintPath="$(PyRevitEnginesDir)\$(IronPythonVersion)\pyRevitLabs.Microsoft.Scripting.dll"/>
     </ItemGroup>
 
-    <ItemGroup Condition="!$(IronPythonVersion.Contains('PR'))">
+	<ItemGroup Condition="'$(MSBuildProjectName)' != 'pyRevitAssemblyBuilder' AND !$(IronPythonVersion.Contains('PR'))">
         <PackageReference Include="IronPython" Version="$(Version)"/>
     </ItemGroup>
 
     <ItemGroup>
         <Reference Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework'" Include="Microsoft.CSharp"/>
     </ItemGroup>
-
-    <ItemGroup>
+
+	<ItemGroup Condition="'$(UseAssemblyBuilder)' == 'true'">
+		<ProjectReference Include="..\pyRevitAssemblyBuilder\pyRevitAssemblyBuilder.csproj" />
+	</ItemGroup>
+
+	<ItemGroup Condition="'$(MSBuildProjectName)' != 'pyRevitAssemblyBuilder'">
         <EmbeddedResource Include="$(IronPythonStdLibDir)\$(IronPythonStdLib)"/>
     </ItemGroup>
 

dev/pyRevitLoader/Source/PyRevitLoaderApplication.cs

@@ -3,6 +3,12 @@
 using System.Reflection;
 using Autodesk.Revit.UI;
 using Autodesk.Revit.Attributes;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using pyRevitAssemblyBuilder.AssemblyMaker;
+using pyRevitAssemblyBuilder.SessionManager;
+using pyRevitAssemblyBuilder.Shared;
+using pyRevitAssemblyBuilder.Startup;
 
 /* Note:
  * It is necessary that this code object do not have any references to IronPython.
@@ -28,7 +34,21 @@ Result IExternalApplication.OnStartup(UIControlledApplication application)
 
             try
             {
-                return ExecuteStartupScript(application);
+                // we need a UIApplication object to assign as `__revit__` in python...
+                var versionNumber = application.ControlledApplication.VersionNumber;
+                var fieldName = int.Parse(versionNumber) >= 2017 ? "m_uiapplication" : "m_application";
+                var fi = application.GetType().GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance);
+
+                var uiApplication = (UIApplication)fi.GetValue(application);
+
+                var executor = new ScriptExecutor(uiApplication);
+                var result = ExecuteStartupScript(application);
+                if (result == Result.Failed)
+                {
+                    TaskDialog.Show("Error Loading pyRevit", executor.Message);
+                }
+
+                return result;
             }
             catch (Exception ex)
             {
@@ -54,6 +74,13 @@ private static void LoadAssembliesInFolder(string folder)
         }
 
         private static Result ExecuteStartupScript(UIControlledApplication uiControlledApplication)
+        {
+            //TODO: Implement a switcher here to be able to switch between Python/C# loaders
+            //return ExecuteStartUpPython(uiControlledApplication);
+            return ExecuteStartUpCsharp(uiControlledApplication);
+        }
+
+        public static Result ExecuteStartUpPython(UIControlledApplication uiControlledApplication)
         {
             // we need a UIApplication object to assign as `__revit__` in python...
             var versionNumber = uiControlledApplication.ControlledApplication.VersionNumber;
@@ -76,7 +103,48 @@ private static Result ExecuteStartupScript(UIControlledApplication uiControlledA
 
             return result;
         }
+        public static Result ExecuteStartUpCsharp(UIControlledApplication uiControlledApplication)
+        {
+            try
+            {
+                var versionNumber = uiControlledApplication.ControlledApplication.VersionNumber;
+                var fieldName = int.Parse(versionNumber) >= 2017 ? "m_uiapplication" : "m_application";
+                var fi = uiControlledApplication.GetType().GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance);
+                var uiApplication = (UIApplication)fi.GetValue(uiControlledApplication);
+
+                var services = new ServiceCollection();
+                services.AddLogging(cfg => cfg.AddDebug());
+
+                // Add Revit UIApplication to services
+                services.AddSingleton(uiApplication);
+
+                // Add known services
+                services.AddSingleton<ICommandTypeGenerator, DefaultCommandTypeGenerator>();
+                services.AddSingleton<IHookManager, DummyHookManager>();
+                services.AddSingleton<IUIManager, UIManagerService>();
+                services.AddSingleton<ISessionManager, SessionManagerService>();
+                services.AddSingleton<IExtensionManager, ExtensionManagerService>();
+
+                // Register AssemblyBuilderService with explicit string parameter
+                services.AddSingleton<AssemblyBuilderService>(sp =>
+                    new AssemblyBuilderService(
+                        sp.GetRequiredService<ICommandTypeGenerator>(),
+                        versionNumber
+                    )
+                );
+
+                var serviceProvider = services.BuildServiceProvider();
+                var sessionManager = serviceProvider.GetRequiredService<ISessionManager>();
+                sessionManager.LoadSessionAsync().Wait();
 
+                return Result.Succeeded;
+            }
+            catch (Exception ex)
+            {
+                TaskDialog.Show("Error Starting pyRevit Session", ex.ToString());
+                return Result.Failed;
+            }
+        }
         private static string GetStartupScriptPath()
         {
             var loaderDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
@@ -90,4 +158,4 @@ Result IExternalApplication.OnShutdown(UIControlledApplication application)
             return Result.Succeeded;
         }
     }
-}
+}

dev/pyRevitLoader/pyRevitAssemblyBuilder/AssemblyMaker/AssemblyBuilderService.cs

@@ -0,0 +1,88 @@
+using System;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+using pyRevitAssemblyBuilder.Shared;
+
+namespace pyRevitAssemblyBuilder.AssemblyMaker
+{
+    public class AssemblyBuilderService
+    {
+        private readonly ICommandTypeGenerator _typeGenerator;
+        private readonly string _revitVersion;
+
+        public AssemblyBuilderService(ICommandTypeGenerator typeGenerator, string revitVersion)
+        {
+            _typeGenerator = typeGenerator;
+            _revitVersion = revitVersion ?? throw new ArgumentNullException(nameof(revitVersion));
+        }
+
+        public ExtensionAssemblyInfo BuildExtensionAssembly(IExtension extension)
+        {
+            string extensionHash = GetStableHash(extension.GetHash() + _revitVersion).Substring(0, 16);
+            string fileName = $"pyRevit_{_revitVersion}_{extensionHash}_{extension.Name}.dll";
+
+            string outputDir = Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+                "pyRevit",
+                _revitVersion
+            );
+            Directory.CreateDirectory(outputDir);
+
+            string outputPath = Path.Combine(outputDir, fileName);
+
+            var asmName = new AssemblyName(extension.Name)
+            {
+                Version = new Version(1, 0, 0, 0)
+            };
+
+            string fileNameWithoutExt = Path.GetFileNameWithoutExtension(outputPath);
+
+#if NETFRAMEWORK
+            var domain = AppDomain.CurrentDomain;
+            var asmBuilder = domain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave, outputDir);
+            var moduleBuilder = asmBuilder.DefineDynamicModule(fileNameWithoutExt, fileName);
+#else
+            var asmBuilder = AssemblyBuilder.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Run);
+            var moduleBuilder = asmBuilder.DefineDynamicModule(fileNameWithoutExt);
+#endif
+
+            foreach (var cmd in extension.GetAllCommands())
+            {
+                _typeGenerator.DefineCommandType(extension, cmd, moduleBuilder);
+            }
+
+#if NETFRAMEWORK
+            asmBuilder.Save(fileName);
+#else
+            var generator = new Lokad.ILPack.AssemblyGenerator();
+            generator.GenerateAssembly(asmBuilder, outputPath);
+#endif
+
+            return new ExtensionAssemblyInfo(
+                name: extension.Name,
+                location: outputPath,
+                isReloading: CheckIfExtensionAlreadyLoaded(extension.Name)
+            );
+        }
+
+        private bool CheckIfExtensionAlreadyLoaded(string extensionName)
+        {
+            foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                if (asm.GetName().Name == extensionName)
+                    return true;
+            }
+            return false;
+        }
+
+        private static string GetStableHash(string input)
+        {
+            using (var sha1 = System.Security.Cryptography.SHA1.Create())
+            {
+                var hash = sha1.ComputeHash(System.Text.Encoding.UTF8.GetBytes(input));
+                return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
+            }
+        }
+    }
+}

dev/pyRevitLoader/pyRevitAssemblyBuilder/AssemblyMaker/DefaultCommandTypeGenerator.cs

@@ -0,0 +1,25 @@
+using System.Reflection.Emit;
+using System.Reflection;
+using pyRevitAssemblyBuilder.Shared;
+
+namespace pyRevitAssemblyBuilder.AssemblyMaker
+{
+    public class DefaultCommandTypeGenerator : ICommandTypeGenerator
+    {
+        public void DefineCommandType(IExtension extension, ICommandComponent command, ModuleBuilder moduleBuilder)
+        {
+            var typeBuilder = moduleBuilder.DefineType(
+                name: command.UniqueId,
+                attr: TypeAttributes.Public | TypeAttributes.Class
+            );
+
+            var attrBuilder = new CustomAttributeBuilder(
+                typeof(System.ComponentModel.DescriptionAttribute).GetConstructor(new[] { typeof(string) }),
+                new object[] { command.Tooltip }
+            );
+            typeBuilder.SetCustomAttribute(attrBuilder);
+
+            typeBuilder.CreateType();
+        }
+    }
+}

dev/pyRevitLoader/pyRevitAssemblyBuilder/AssemblyMaker/ExtensionAssemblyInfo.cs

@@ -0,0 +1,21 @@
+namespace pyRevitAssemblyBuilder.AssemblyMaker
+{
+    public class ExtensionAssemblyInfo
+    {
+        public string Name { get; }
+        public string Location { get; }
+        public bool IsReloading { get; }
+
+        public ExtensionAssemblyInfo(string name, string location, bool isReloading)
+        {
+            Name = name;
+            Location = location;
+            IsReloading = isReloading;
+        }
+
+        public override string ToString()
+        {
+            return $"{Name} ({(IsReloading ? "Reloaded" : "Fresh")}) -> {Location}";
+        }
+    }
+}

dev/pyRevitLoader/pyRevitAssemblyBuilder/AssemblyMaker/ICommandTypeGenerator.cs

@@ -0,0 +1,10 @@
+using pyRevitAssemblyBuilder.Shared;
+using System.Reflection.Emit;
+
+namespace pyRevitAssemblyBuilder.AssemblyMaker
+{
+    public interface ICommandTypeGenerator
+    {
+        void DefineCommandType(IExtension extension, ICommandComponent command, ModuleBuilder moduleBuilder);
+    }
+}

dev/pyRevitLoader/pyRevitAssemblyBuilder/AssemblyMaker/ServiceRegistration.cs

@@ -0,0 +1,15 @@
+using Microsoft.Extensions.DependencyInjection;
+using pyRevitAssemblyBuilder.AssemblyMaker;
+
+namespace pyRevitAssemblyBuilder.Startup
+{
+    public static class ServiceRegistration
+    {
+        public static IServiceCollection AddAssemblyBuilder(this IServiceCollection services)
+        {
+            services.AddSingleton<ICommandTypeGenerator, DefaultCommandTypeGenerator>();
+            services.AddSingleton<AssemblyBuilderService>();
+            return services;
+        }
+    }
+}

dev/pyRevitLoader/pyRevitAssemblyBuilder/AssemblyMaker/TypeMakerService.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+using pyRevitAssemblyBuilder.Shared;
+
+namespace pyRevitAssemblyBuilder.AssemblyMaker
+{
+    public class TypeMakerService : ICommandTypeGenerator
+    {
+        public void DefineCommandType(IExtension extension, ICommandComponent command, ModuleBuilder moduleBuilder)
+        {
+            var typeBuilder = moduleBuilder.DefineType(
+                name: command.UniqueId,
+                attr: TypeAttributes.Public | TypeAttributes.Class
+            );
+
+            if (!string.IsNullOrEmpty(command.Tooltip))
+            {
+                var attrBuilder = new CustomAttributeBuilder(
+                    typeof(System.ComponentModel.DescriptionAttribute).GetConstructor(new[] { typeof(string) }),
+                    new object[] { command.Tooltip }
+                );
+                typeBuilder.SetCustomAttribute(attrBuilder);
+            }
+
+            // Emit a default constructor
+            typeBuilder.DefineDefaultConstructor(MethodAttributes.Public);
+
+            // Create the type (works in .NET Standard 2.0 via CreateTypeInfo)
+            _ = typeBuilder.CreateTypeInfo();
+        }
+    }
+}