update to use logger only

tadoEng · tadoEng · commit 3d756abf688d · 2026-01-24T10:17:39.000+07:00
diff --git a/src/EtabSharp/Core/ETABSApplication.cs b/src/EtabSharp/Core/ETABSApplication.cs
@@ -116,9 +116,7 @@ public T ExecuteSafely<T>(Func<T> apiCall, string functionName = null)
         catch (Exception ex)
         {
             var funcName = functionName ?? "API function";
-            _logger.LogError(ex, "Error calling {FunctionName}", funcName);
-            Console.WriteLine($"Error calling {funcName}: {ex.Message}");
-            Console.WriteLine("This function may not be supported in your version of ETABS.");
+            _logger.LogError(ex, "Error calling {FunctionName}: {Message}. This function may not be supported in your version of ETABS.", funcName, ex.Message);
             throw;
         }
     }
@@ -138,9 +136,7 @@ public void ExecuteSafely(Action apiCall, string functionName = null)
         catch (Exception ex)
         {
             var funcName = functionName ?? "API function";
-            _logger.LogError(ex, "Error calling {FunctionName}", funcName);
-            Console.WriteLine($"Error calling {funcName}: {ex.Message}");
-            Console.WriteLine("This function may not be supported in your version of ETABS.");
+            _logger.LogError(ex, "Error calling {FunctionName}: {Message}. This function may not be supported in your version of ETABS.", funcName, ex.Message);
             throw;
         }
     }
@@ -169,8 +165,7 @@ public void Close(bool savePrompt = false)
             }
             catch (Exception ex)
             {
-                _logger.LogWarning(ex, "Error closing ETABS");
-                Console.WriteLine($"Error closing ETABS: {ex.Message}");
+                _logger.LogWarning(ex, "Error closing ETABS: {Message}", ex.Message);
             }
         }
     }
diff --git a/src/EtabSharp/Core/ETABSWrapper.cs b/src/EtabSharp/Core/ETABSWrapper.cs
@@ -1,5 +1,6 @@
 ﻿using EtabSharp.Core.Models;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using System.Diagnostics;
 
 namespace EtabSharp.Core;
@@ -21,19 +22,20 @@ public class ETABSWrapper
     /// <returns>ETABS application wrapper with typed access to API, or null if none found</returns>
     public static ETABSApplication Connect(ILogger<ETABSApplication>? logger = null)
     {
+        var wrapperLogger = logger ?? NullLogger<ETABSApplication>.Instance;
         var etabsProcesses = GetETABSProcesses();
 
         if (!etabsProcesses.Any())
         {
-            Console.WriteLine("No running ETABS instances found.");
+            wrapperLogger.LogWarning("No running ETABS instances found");
             return null;
         }
 
-        var activeProcess = FindActiveProcess(etabsProcesses);
+        var activeProcess = FindActiveProcess(etabsProcesses, wrapperLogger);
 
         if (activeProcess == null)
         {
-            Console.WriteLine("No ETABS instance with active window found.");
+            wrapperLogger.LogWarning("No ETABS instance with active window found");
             return null;
         }
 
@@ -50,6 +52,8 @@ public static ETABSApplication Connect(ILogger<ETABSApplication>? logger = null)
     public static ETABSApplication CreateNew(string programPath = null, bool startApplication = true,
         ILogger<ETABSApplication>? logger = null)
     {
+        var wrapperLogger = logger ?? NullLogger<ETABSApplication>.Instance;
+
         try
         {
             // Create API helper object
@@ -59,11 +63,13 @@ public static ETABSApplication CreateNew(string programPath = null, bool startAp
             if (!string.IsNullOrEmpty(programPath))
             {
                 // Create instance from specified path
+                wrapperLogger.LogDebug("Creating ETABS instance from path: {Path}", programPath);
                 api = helper.CreateObject(programPath);
             }
             else
             {
                 // Create instance from latest installed ETABS
+                wrapperLogger.LogDebug("Creating ETABS instance using ProgID: {ProgID}", ETABS_PROGID);
                 api = helper.CreateObjectProgID(ETABS_PROGID);
             }
 
@@ -73,23 +79,23 @@ public static ETABSApplication CreateNew(string programPath = null, bool startAp
                 int ret = api.ApplicationStart();
                 if (ret != 0)
                 {
-                    Console.WriteLine("Warning: ApplicationStart returned non-zero value");
+                    wrapperLogger.LogWarning("ApplicationStart returned non-zero value: {ReturnValue}", ret);
                 }
             }
 
             // Get version info
-            var versionInfo = GetVersionFromAPI(api);
+            var versionInfo = GetVersionFromAPI(api, wrapperLogger);
             int version = versionInfo.majorVersion;
             string fullVersion = versionInfo.fullVersion;
-            double apiVersion = GetApiVersionNumber(helper);
+            double apiVersion = GetApiVersionNumber(helper, wrapperLogger);
 
-            Console.WriteLine($"Created new ETABS instance v{fullVersion}, API Version: {apiVersion}");
+            wrapperLogger.LogInformation("Created new ETABS instance v{Version}, API Version: {ApiVersion}", fullVersion, apiVersion);
 
             return new ETABSApplication(api, version, apiVersion, fullVersion, logger);
         }
         catch (Exception ex)
         {
-            Console.WriteLine($"Error creating new ETABS instance: {ex.Message}");
+            wrapperLogger.LogError(ex, "Error creating new ETABS instance");
             return null;
         }
     }
@@ -105,7 +111,7 @@ private static List<Process> GetETABSProcesses()
     /// <summary>
     /// Finds the first ETABS process with an active main window
     /// </summary>
-    private static ETABSProcessInfo FindActiveProcess(List<Process> processes)
+    private static ETABSProcessInfo FindActiveProcess(List<Process> processes, ILogger logger)
     {
         foreach (var process in processes)
         {
@@ -128,7 +134,7 @@ private static ETABSProcessInfo FindActiveProcess(List<Process> processes)
                 }
                 catch (Exception ex)
                 {
-                    Console.WriteLine($"Error reading process info: {ex.Message}");
+                    logger.LogWarning(ex, "Error reading process info for PID {ProcessId}", process.Id);
                     continue;
                 }
             }
@@ -142,28 +148,31 @@ private static ETABSProcessInfo FindActiveProcess(List<Process> processes)
     /// </summary>
     private static ETABSApplication ConnectToETABS(ETABSProcessInfo processInfo, ILogger<ETABSApplication>? logger)
     {
+        var wrapperLogger = logger ?? NullLogger<ETABSApplication>.Instance;
+
         if (processInfo.MajorVersion == 0)
         {
-            logger?.LogWarning("Unable to determine ETABS version.");
+            wrapperLogger.LogWarning("Unable to determine ETABS version");
             return null;
         }
 
         if (processInfo.MajorVersion < MINIMUM_SUPPORTED_VERSION)
         {
-            logger?.LogWarning($"ETABS v{processInfo.FullVersion} is not supported.");
-            logger?.LogWarning($"This wrapper requires ETABS v{MINIMUM_SUPPORTED_VERSION} or newer.");
-            logger?.LogWarning("Please upgrade your ETABS installation.");
+            wrapperLogger.LogWarning(
+                "ETABS v{Version} is not supported. This wrapper requires ETABS v{MinVersion} or newer. Please upgrade your ETABS installation.",
+                processInfo.FullVersion,
+                MINIMUM_SUPPORTED_VERSION);
             return null;
         }
 
         try
         {
-            logger?.LogInformation($"Connecting to ETABS v{processInfo.FullVersion}...");
+            wrapperLogger.LogInformation("Connecting to ETABS v{Version}...", processInfo.FullVersion);
             return CreateETABSApplication(processInfo.MajorVersion, processInfo.FullVersion, logger);
         }
         catch (Exception ex)
         {
-            logger?.LogError(ex, $"Error connecting to ETABS v{processInfo.FullVersion}");
+            wrapperLogger.LogError(ex, "Error connecting to ETABS v{Version}", processInfo.FullVersion);
             return null;
         }
     }
@@ -174,6 +183,8 @@ private static ETABSApplication ConnectToETABS(ETABSProcessInfo processInfo, ILo
     private static ETABSApplication CreateETABSApplication(int majorVersion, string fullVersion,
         ILogger<ETABSApplication>? logger)
     {
+        var wrapperLogger = logger ?? NullLogger<ETABSApplication>.Instance;
+
         try
         {
             // Create helper object
@@ -183,62 +194,65 @@ private static ETABSApplication CreateETABSApplication(int majorVersion, string
             ETABSv1.cOAPI api = helper.GetObject(ETABS_PROGID);
 
             // Get the API version number
-            double apiVersion = GetApiVersionNumber(helper);
+            double apiVersion = GetApiVersionNumber(helper, wrapperLogger);
 
-            logger?.LogInformation($"Connected to ETABS v{fullVersion}, API Version: {apiVersion}");
-            Console.WriteLine($"Connected to ETABS v{fullVersion}, API Version: {apiVersion}");
+            wrapperLogger.LogInformation("Connected to ETABS v{Version}, API Version: {ApiVersion}", fullVersion, apiVersion);
 
             return new ETABSApplication(api, majorVersion, apiVersion, fullVersion, logger);
         }
         catch (Exception ex)
         {
-            Console.WriteLine($"Failed to attach to ETABS: {ex.Message}");
+            wrapperLogger.LogError(ex, "Failed to attach to ETABS");
             throw;
         }
     }
 
     /// <summary>
     /// Gets the API version number from helper
     /// </summary>
-    private static double GetApiVersionNumber(ETABSv1.cHelper helper)
+    private static double GetApiVersionNumber(ETABSv1.cHelper helper, ILogger logger)
     {
         try
         {
             return helper.GetOAPIVersionNumber();
         }
-        catch
+        catch (Exception ex)
         {
+            logger.LogWarning(ex, "Unable to get API version number");
             return 0.0;
         }
     }
 
     /// <summary>
     /// Gets version from API object by examining process
     /// </summary>
-    private static (int majorVersion, string fullVersion) GetVersionFromAPI(ETABSv1.cOAPI api)
+    private static (int majorVersion, string fullVersion) GetVersionFromAPI(ETABSv1.cOAPI api, ILogger logger)
     {
         try
         {
             var processes = GetETABSProcesses();
-            var activeProcess = FindActiveProcess(processes);
+            var activeProcess = FindActiveProcess(processes, logger);
             if (activeProcess != null)
             {
                 return (activeProcess.MajorVersion, activeProcess.FullVersion);
             }
 
+            logger.LogWarning("Unable to determine ETABS version from process, defaulting to v22.0.0");
             return (22, "22.0.0"); // Default to 22.0.0 if can't determine
         }
-        catch
+        catch (Exception ex)
         {
+            logger.LogWarning(ex, "Error getting version from API, defaulting to v22.0.0");
             return (22, "22.0.0"); // Default to 22.0.0
         }
     }
 
     /// <summary>
     /// Gets list of all running ETABS instances with their version info
     /// </summary>
-    public static List<ETABSInstanceInfo> GetAllRunningInstances()
+    public static List<ETABSInstanceInfo> GetAllRunningInstances(ILogger? logger = null)
     {
+        var wrapperLogger = logger ?? NullLogger.Instance;
         var instances = new List<ETABSInstanceInfo>();
         var processes = GetETABSProcesses();
 
@@ -264,7 +278,7 @@ public static List<ETABSInstanceInfo> GetAllRunningInstances()
             }
             catch (Exception ex)
             {
-                Console.WriteLine($"Error reading process {process.Id}: {ex.Message}");
+                wrapperLogger.LogWarning(ex, "Error reading process {ProcessId}", process.Id);
             }
         }
 
@@ -282,20 +296,22 @@ public static bool IsRunning()
     /// <summary>
     /// Checks if a supported version of ETABS (v22+) is running
     /// </summary>
-    public static bool IsSupportedVersionRunning()
+    public static bool IsSupportedVersionRunning(ILogger? logger = null)
     {
+        var wrapperLogger = logger ?? NullLogger.Instance;
         var processes = GetETABSProcesses();
-        var activeProcess = FindActiveProcess(processes);
+        var activeProcess = FindActiveProcess(processes, wrapperLogger);
         return activeProcess != null && activeProcess.MajorVersion >= MINIMUM_SUPPORTED_VERSION;
     }
 
     /// <summary>
     /// Gets the version of the active ETABS instance
     /// </summary>
-    public static string GetActiveVersion()
+    public static string GetActiveVersion(ILogger? logger = null)
     {
+        var wrapperLogger = logger ?? NullLogger.Instance;
         var processes = GetETABSProcesses();
-        var activeProcess = FindActiveProcess(processes);
+        var activeProcess = FindActiveProcess(processes, wrapperLogger);
         return activeProcess?.FullVersion;
     }
 }
diff --git a/src/EtabSharp/Design/Concrete/Models/ConcreteColumnDesignResult.cs b/src/EtabSharp/Design/Concrete/Models/ConcreteColumnDesignResult.cs
@@ -76,7 +76,7 @@ public class ConcreteColumnDesignResult
     public string WarningSummary { get; set; } = string.Empty;
 
     /// <summary>
-    /// Indicates if design passed (no errors and ratio <= 1.0).
+    /// Indicates if design passed (no errors and ratio smaller 1.0).
     /// </summary>
     public bool Passes => string.IsNullOrWhiteSpace(ErrorSummary) && PMMRatio <= 1.0;
 
diff --git a/src/EtabSharp/Elements/AreaObj/Models/AreaPierRebarData.cs b/src/EtabSharp/Elements/AreaObj/Models/AreaPierRebarData.cs
@@ -20,6 +20,7 @@ public class AreaPierRebarData
     /// </summary>
     public List<AreaRebarLayer> Layers { get; set; } = new();
 
+    /// <inheritdoc />
     public override string ToString()
     {
         return $"Pier {Name}: {NumberOfLayers} rebar layers";
diff --git a/src/EtabSharp/Elements/PointObj/Models/Point.cs b/src/EtabSharp/Elements/PointObj/Models/Point.cs
@@ -10,7 +10,7 @@ public class Point
     /// <summary>
     /// Unique name of the point object in ETABS
     /// </summary>
-    public required string Name { get; set; }
+    public required string? Name { get; set; }
 
     /// <summary>
     /// X coordinate in current length units
diff --git a/src/EtabSharp/EtabSharp.csproj b/src/EtabSharp/EtabSharp.csproj
@@ -25,7 +25,7 @@
 
 		<!-- Build setting-->
 		<SignAssembly>True</SignAssembly>
-		<NoWarn>$(NoWarn);IDE0065;IDE0055;IDE0011;S3881</NoWarn>
+		<NoWarn>$(NoWarn);IDE0065;IDE0055;IDE0011;S3881;CS1591;CS1570</NoWarn>
 
 		<!-- Package Release Notes -->
 		<PackageReleaseNotes>
diff --git a/test/EtabsSharp.VisualTest/Program.cs b/test/EtabsSharp.VisualTest/Program.cs
@@ -1,6 +1,7 @@
 ﻿using EtabSharp.Core;
 using EtabSharp.DatabaseTables.Models;
 using ETABSv1;
+using Microsoft.Extensions.Logging;
 
 Console.WriteLine("=================================================");
 Console.WriteLine("  EtabSharp Example - Frame Analysis with Rebar");

Original file line number	Diff line number	Diff line change
`@@ -116,9 +116,7 @@ public T ExecuteSafely<T>(Func<T> apiCall, string functionName = null)`
`116`	`116`	`catch (Exception ex)`
`117`	`117`	`{`
`118`	`118`	`var funcName = functionName ?? "API function";`
`119`		`- _logger.LogError(ex, "Error calling {FunctionName}", funcName);`
`120`		`- Console.WriteLine($"Error calling {funcName}: {ex.Message}");`
`121`		`- Console.WriteLine("This function may not be supported in your version of ETABS.");`
	`119`	`+ _logger.LogError(ex, "Error calling {FunctionName}: {Message}. This function may not be supported in your version of ETABS.", funcName, ex.Message);`
`122`	`120`	`throw;`
`123`	`121`	`}`
`124`	`122`	`}`
`@@ -138,9 +136,7 @@ public void ExecuteSafely(Action apiCall, string functionName = null)`
`138`	`136`	`catch (Exception ex)`
`139`	`137`	`{`
`140`	`138`	`var funcName = functionName ?? "API function";`
`141`		`- _logger.LogError(ex, "Error calling {FunctionName}", funcName);`
`142`		`- Console.WriteLine($"Error calling {funcName}: {ex.Message}");`
`143`		`- Console.WriteLine("This function may not be supported in your version of ETABS.");`
	`139`	`+ _logger.LogError(ex, "Error calling {FunctionName}: {Message}. This function may not be supported in your version of ETABS.", funcName, ex.Message);`
`144`	`140`	`throw;`
`145`	`141`	`}`
`146`	`142`	`}`
`@@ -169,8 +165,7 @@ public void Close(bool savePrompt = false)`
`169`	`165`	`}`
`170`	`166`	`catch (Exception ex)`
`171`	`167`	`{`
`172`		`- _logger.LogWarning(ex, "Error closing ETABS");`
`173`		`- Console.WriteLine($"Error closing ETABS: {ex.Message}");`
	`168`	`+ _logger.LogWarning(ex, "Error closing ETABS: {Message}", ex.Message);`
`174`	`169`	`}`
`175`	`170`	`}`
`176`	`171`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using EtabSharp.Core.Models;`
`2`	`2`	`using Microsoft.Extensions.Logging;`
	`3`	`+using Microsoft.Extensions.Logging.Abstractions;`
`3`	`4`	`using System.Diagnostics;`
`4`	`5`
`5`	`6`	`namespace EtabSharp.Core;`
`@@ -21,19 +22,20 @@ public class ETABSWrapper`
`21`	`22`	`/// <returns>ETABS application wrapper with typed access to API, or null if none found</returns>`
`22`	`23`	`public static ETABSApplication Connect(ILogger<ETABSApplication>? logger = null)`
`23`	`24`	`{`
	`25`	`+ var wrapperLogger = logger ?? NullLogger<ETABSApplication>.Instance;`
`24`	`26`	`var etabsProcesses = GetETABSProcesses();`
`25`	`27`
`26`	`28`	`if (!etabsProcesses.Any())`
`27`	`29`	`{`
`28`		`- Console.WriteLine("No running ETABS instances found.");`
	`30`	`+ wrapperLogger.LogWarning("No running ETABS instances found");`
`29`	`31`	`return null;`
`30`	`32`	`}`
`31`	`33`
`32`		`- var activeProcess = FindActiveProcess(etabsProcesses);`
	`34`	`+ var activeProcess = FindActiveProcess(etabsProcesses, wrapperLogger);`
`33`	`35`
`34`	`36`	`if (activeProcess == null)`
`35`	`37`	`{`
`36`		`- Console.WriteLine("No ETABS instance with active window found.");`
	`38`	`+ wrapperLogger.LogWarning("No ETABS instance with active window found");`
`37`	`39`	`return null;`
`38`	`40`	`}`
`39`	`41`
`@@ -50,6 +52,8 @@ public static ETABSApplication Connect(ILogger<ETABSApplication>? logger = null)`
`50`	`52`	`public static ETABSApplication CreateNew(string programPath = null, bool startApplication = true,`
`51`	`53`	`ILogger<ETABSApplication>? logger = null)`
`52`	`54`	`{`
	`55`	`+ var wrapperLogger = logger ?? NullLogger<ETABSApplication>.Instance;`
	`56`	`+`
`53`	`57`	`try`
`54`	`58`	`{`
`55`	`59`	`// Create API helper object`
`@@ -59,11 +63,13 @@ public static ETABSApplication CreateNew(string programPath = null, bool startAp`
`59`	`63`	`if (!string.IsNullOrEmpty(programPath))`
`60`	`64`	`{`
`61`	`65`	`// Create instance from specified path`
	`66`	`+ wrapperLogger.LogDebug("Creating ETABS instance from path: {Path}", programPath);`
`62`	`67`	`api = helper.CreateObject(programPath);`
`63`	`68`	`}`
`64`	`69`	`else`
`65`	`70`	`{`
`66`	`71`	`// Create instance from latest installed ETABS`
	`72`	`+ wrapperLogger.LogDebug("Creating ETABS instance using ProgID: {ProgID}", ETABS_PROGID);`
`67`	`73`	`api = helper.CreateObjectProgID(ETABS_PROGID);`
`68`	`74`	`}`
`69`	`75`
`@@ -73,23 +79,23 @@ public static ETABSApplication CreateNew(string programPath = null, bool startAp`
`73`	`79`	`int ret = api.ApplicationStart();`
`74`	`80`	`if (ret != 0)`
`75`	`81`	`{`
`76`		`- Console.WriteLine("Warning: ApplicationStart returned non-zero value");`
	`82`	`+ wrapperLogger.LogWarning("ApplicationStart returned non-zero value: {ReturnValue}", ret);`
`77`	`83`	`}`
`78`	`84`	`}`
`79`	`85`
`80`	`86`	`// Get version info`
`81`		`- var versionInfo = GetVersionFromAPI(api);`
	`87`	`+ var versionInfo = GetVersionFromAPI(api, wrapperLogger);`
`82`	`88`	`int version = versionInfo.majorVersion;`
`83`	`89`	`string fullVersion = versionInfo.fullVersion;`
`84`		`- double apiVersion = GetApiVersionNumber(helper);`
	`90`	`+ double apiVersion = GetApiVersionNumber(helper, wrapperLogger);`
`85`	`91`
`86`		`- Console.WriteLine($"Created new ETABS instance v{fullVersion}, API Version: {apiVersion}");`
	`92`	`+ wrapperLogger.LogInformation("Created new ETABS instance v{Version}, API Version: {ApiVersion}", fullVersion, apiVersion);`
`87`	`93`
`88`	`94`	`return new ETABSApplication(api, version, apiVersion, fullVersion, logger);`
`89`	`95`	`}`
`90`	`96`	`catch (Exception ex)`
`91`	`97`	`{`
`92`		`- Console.WriteLine($"Error creating new ETABS instance: {ex.Message}");`
	`98`	`+ wrapperLogger.LogError(ex, "Error creating new ETABS instance");`
`93`	`99`	`return null;`
`94`	`100`	`}`
`95`	`101`	`}`
`@@ -105,7 +111,7 @@ private static List<Process> GetETABSProcesses()`
`105`	`111`	`/// <summary>`
`106`	`112`	`/// Finds the first ETABS process with an active main window`
`107`	`113`	`/// </summary>`
`108`		`- private static ETABSProcessInfo FindActiveProcess(List<Process> processes)`
	`114`	`+ private static ETABSProcessInfo FindActiveProcess(List<Process> processes, ILogger logger)`
`109`	`115`	`{`
`110`	`116`	`foreach (var process in processes)`
`111`	`117`	`{`
`@@ -128,7 +134,7 @@ private static ETABSProcessInfo FindActiveProcess(List<Process> processes)`
`128`	`134`	`}`
`129`	`135`	`catch (Exception ex)`
`130`	`136`	`{`
`131`		`- Console.WriteLine($"Error reading process info: {ex.Message}");`
	`137`	`+ logger.LogWarning(ex, "Error reading process info for PID {ProcessId}", process.Id);`
`132`	`138`	`continue;`
`133`	`139`	`}`
`134`	`140`	`}`
`@@ -142,28 +148,31 @@ private static ETABSProcessInfo FindActiveProcess(List<Process> processes)`
`142`	`148`	`/// </summary>`
`143`	`149`	`private static ETABSApplication ConnectToETABS(ETABSProcessInfo processInfo, ILogger<ETABSApplication>? logger)`
`144`	`150`	`{`
	`151`	`+ var wrapperLogger = logger ?? NullLogger<ETABSApplication>.Instance;`
	`152`	`+`
`145`	`153`	`if (processInfo.MajorVersion == 0)`
`146`	`154`	`{`
`147`		`- logger?.LogWarning("Unable to determine ETABS version.");`
	`155`	`+ wrapperLogger.LogWarning("Unable to determine ETABS version");`
`148`	`156`	`return null;`
`149`	`157`	`}`
`150`	`158`
`151`	`159`	`if (processInfo.MajorVersion < MINIMUM_SUPPORTED_VERSION)`
`152`	`160`	`{`
`153`		`- logger?.LogWarning($"ETABS v{processInfo.FullVersion} is not supported.");`
`154`		`- logger?.LogWarning($"This wrapper requires ETABS v{MINIMUM_SUPPORTED_VERSION} or newer.");`
`155`		`- logger?.LogWarning("Please upgrade your ETABS installation.");`
	`161`	`+ wrapperLogger.LogWarning(`
	`162`	`+ "ETABS v{Version} is not supported. This wrapper requires ETABS v{MinVersion} or newer. Please upgrade your ETABS installation.",`
	`163`	`+ processInfo.FullVersion,`
	`164`	`+ MINIMUM_SUPPORTED_VERSION);`
`156`	`165`	`return null;`
`157`	`166`	`}`
`158`	`167`
`159`	`168`	`try`
`160`	`169`	`{`
`161`		`- logger?.LogInformation($"Connecting to ETABS v{processInfo.FullVersion}...");`
	`170`	`+ wrapperLogger.LogInformation("Connecting to ETABS v{Version}...", processInfo.FullVersion);`
`162`	`171`	`return CreateETABSApplication(processInfo.MajorVersion, processInfo.FullVersion, logger);`
`163`	`172`	`}`
`164`	`173`	`catch (Exception ex)`
`165`	`174`	`{`
`166`		`- logger?.LogError(ex, $"Error connecting to ETABS v{processInfo.FullVersion}");`
	`175`	`+ wrapperLogger.LogError(ex, "Error connecting to ETABS v{Version}", processInfo.FullVersion);`
`167`	`176`	`return null;`
`168`	`177`	`}`
`169`	`178`	`}`
`@@ -174,6 +183,8 @@ private static ETABSApplication ConnectToETABS(ETABSProcessInfo processInfo, ILo`
`174`	`183`	`private static ETABSApplication CreateETABSApplication(int majorVersion, string fullVersion,`
`175`	`184`	`ILogger<ETABSApplication>? logger)`
`176`	`185`	`{`
	`186`	`+ var wrapperLogger = logger ?? NullLogger<ETABSApplication>.Instance;`
	`187`	`+`
`177`	`188`	`try`
`178`	`189`	`{`
`179`	`190`	`// Create helper object`
`@@ -183,62 +194,65 @@ private static ETABSApplication CreateETABSApplication(int majorVersion, string`
`183`	`194`	`ETABSv1.cOAPI api = helper.GetObject(ETABS_PROGID);`
`184`	`195`
`185`	`196`	`// Get the API version number`
`186`		`- double apiVersion = GetApiVersionNumber(helper);`
	`197`	`+ double apiVersion = GetApiVersionNumber(helper, wrapperLogger);`
`187`	`198`
`188`		`- logger?.LogInformation($"Connected to ETABS v{fullVersion}, API Version: {apiVersion}");`
`189`		`- Console.WriteLine($"Connected to ETABS v{fullVersion}, API Version: {apiVersion}");`
	`199`	`+ wrapperLogger.LogInformation("Connected to ETABS v{Version}, API Version: {ApiVersion}", fullVersion, apiVersion);`
`190`	`200`
`191`	`201`	`return new ETABSApplication(api, majorVersion, apiVersion, fullVersion, logger);`
`192`	`202`	`}`
`193`	`203`	`catch (Exception ex)`
`194`	`204`	`{`
`195`		`- Console.WriteLine($"Failed to attach to ETABS: {ex.Message}");`
	`205`	`+ wrapperLogger.LogError(ex, "Failed to attach to ETABS");`
`196`	`206`	`throw;`
`197`	`207`	`}`
`198`	`208`	`}`
`199`	`209`
`200`	`210`	`/// <summary>`
`201`	`211`	`/// Gets the API version number from helper`
`202`	`212`	`/// </summary>`
`203`		`- private static double GetApiVersionNumber(ETABSv1.cHelper helper)`
	`213`	`+ private static double GetApiVersionNumber(ETABSv1.cHelper helper, ILogger logger)`
`204`	`214`	`{`
`205`	`215`	`try`
`206`	`216`	`{`
`207`	`217`	`return helper.GetOAPIVersionNumber();`
`208`	`218`	`}`
`209`		`- catch`
	`219`	`+ catch (Exception ex)`
`210`	`220`	`{`
	`221`	`+ logger.LogWarning(ex, "Unable to get API version number");`
`211`	`222`	`return 0.0;`
`212`	`223`	`}`
`213`	`224`	`}`
`214`	`225`
`215`	`226`	`/// <summary>`
`216`	`227`	`/// Gets version from API object by examining process`
`217`	`228`	`/// </summary>`
`218`		`- private static (int majorVersion, string fullVersion) GetVersionFromAPI(ETABSv1.cOAPI api)`
	`229`	`+ private static (int majorVersion, string fullVersion) GetVersionFromAPI(ETABSv1.cOAPI api, ILogger logger)`
`219`	`230`	`{`
`220`	`231`	`try`
`221`	`232`	`{`
`222`	`233`	`var processes = GetETABSProcesses();`
`223`		`- var activeProcess = FindActiveProcess(processes);`
	`234`	`+ var activeProcess = FindActiveProcess(processes, logger);`
`224`	`235`	`if (activeProcess != null)`
`225`	`236`	`{`
`226`	`237`	`return (activeProcess.MajorVersion, activeProcess.FullVersion);`
`227`	`238`	`}`
`228`	`239`
	`240`	`+ logger.LogWarning("Unable to determine ETABS version from process, defaulting to v22.0.0");`
`229`	`241`	`return (22, "22.0.0"); // Default to 22.0.0 if can't determine`
`230`	`242`	`}`
`231`		`- catch`
	`243`	`+ catch (Exception ex)`
`232`	`244`	`{`
	`245`	`+ logger.LogWarning(ex, "Error getting version from API, defaulting to v22.0.0");`
`233`	`246`	`return (22, "22.0.0"); // Default to 22.0.0`
`234`	`247`	`}`
`235`	`248`	`}`
`236`	`249`
`237`	`250`	`/// <summary>`
`238`	`251`	`/// Gets list of all running ETABS instances with their version info`
`239`	`252`	`/// </summary>`
`240`		`- public static List<ETABSInstanceInfo> GetAllRunningInstances()`
	`253`	`+ public static List<ETABSInstanceInfo> GetAllRunningInstances(ILogger? logger = null)`
`241`	`254`	`{`
	`255`	`+ var wrapperLogger = logger ?? NullLogger.Instance;`
`242`	`256`	`var instances = new List<ETABSInstanceInfo>();`
`243`	`257`	`var processes = GetETABSProcesses();`
`244`	`258`
`@@ -264,7 +278,7 @@ public static List<ETABSInstanceInfo> GetAllRunningInstances()`
`264`	`278`	`}`
`265`	`279`	`catch (Exception ex)`
`266`	`280`	`{`
`267`		`- Console.WriteLine($"Error reading process {process.Id}: {ex.Message}");`
	`281`	`+ wrapperLogger.LogWarning(ex, "Error reading process {ProcessId}", process.Id);`
`268`	`282`	`}`
`269`	`283`	`}`
`270`	`284`
`@@ -282,20 +296,22 @@ public static bool IsRunning()`
`282`	`296`	`/// <summary>`
`283`	`297`	`/// Checks if a supported version of ETABS (v22+) is running`
`284`	`298`	`/// </summary>`
`285`		`- public static bool IsSupportedVersionRunning()`
	`299`	`+ public static bool IsSupportedVersionRunning(ILogger? logger = null)`
`286`	`300`	`{`
	`301`	`+ var wrapperLogger = logger ?? NullLogger.Instance;`
`287`	`302`	`var processes = GetETABSProcesses();`
`288`		`- var activeProcess = FindActiveProcess(processes);`
	`303`	`+ var activeProcess = FindActiveProcess(processes, wrapperLogger);`
`289`	`304`	`return activeProcess != null && activeProcess.MajorVersion >= MINIMUM_SUPPORTED_VERSION;`
`290`	`305`	`}`
`291`	`306`
`292`	`307`	`/// <summary>`
`293`	`308`	`/// Gets the version of the active ETABS instance`
`294`	`309`	`/// </summary>`
`295`		`- public static string GetActiveVersion()`
	`310`	`+ public static string GetActiveVersion(ILogger? logger = null)`
`296`	`311`	`{`
	`312`	`+ var wrapperLogger = logger ?? NullLogger.Instance;`
`297`	`313`	`var processes = GetETABSProcesses();`
`298`		`- var activeProcess = FindActiveProcess(processes);`
	`314`	`+ var activeProcess = FindActiveProcess(processes, wrapperLogger);`
`299`	`315`	`return activeProcess?.FullVersion;`
`300`	`316`	`}`
`301`	`317`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ public class AreaPierRebarData`
`20`	`20`	`/// </summary>`
`21`	`21`	`public List<AreaRebarLayer> Layers { get; set; } = new();`
`22`	`22`
	`23`	`+ /// <inheritdoc />`
`23`	`24`	`public override string ToString()`
`24`	`25`	`{`
`25`	`26`	`return $"Pier {Name}: {NumberOfLayers} rebar layers";`