update: add trace ICollection<object>

- support IronPython list

Author: trgiangv

source/RevitDevTool.UI.Abstractions/RevitDevTool.UI.Abstractions.csproj

@@ -2,6 +2,7 @@
 
     <PropertyGroup>
         <UseWpf>true</UseWpf>
+        <nullable>enable</nullable>
         <LangVersion>latest</LangVersion>
         <TargetFrameworks>net48;net8.0-windows</TargetFrameworks>
         <RootNamespace>Wpf.Ui.Abstractions</RootNamespace>

source/RevitDevTool/Models/TraceGeometry.cs

@@ -22,21 +22,86 @@ public override void Write(object? o)
         {
             switch (o)
             {
-                case IEnumerable<GeometryObject> geometries:
-                    Trace(geometries);
+                case ICollection<object> geometries:
+                    List<GeometryObject>? geometryObjects = null;
+                    List<BoundingBoxXYZ>? boundingBoxes = null;
+                    List<XYZ>? xyZs = null;
+
+                    foreach (var geometry in geometries)
+                    {
+                        switch (geometry)
+                        {
+                            case GeometryObject geometryObject:
+                                geometryObjects ??= [];
+                                geometryObjects.Add(geometryObject);
+                                break;
+                            case BoundingBoxXYZ boundingBox:
+                                boundingBoxes ??= [];
+                                boundingBoxes.Add(boundingBox);
+                                break;
+                            case XYZ xyz:
+                                xyZs ??= [];
+                                xyZs.Add(xyz);
+                                break;
+                            case CurveLoop curveLoop:
+                                geometryObjects ??= [];
+                                geometryObjects.AddRange(curveLoop);
+                                break;
+                            case CurveArray curveArray:
+                                geometryObjects ??= [];
+                                geometryObjects.AddRange(curveArray.Cast<Curve>());
+                                break;
+                            case EdgeArray edgeArray:
+                                geometryObjects ??= [];
+                                geometryObjects.AddRange(edgeArray.Cast<Edge>());
+                                break;
+                            case FaceArray faceArray:
+                                geometryObjects ??= [];
+                                geometryObjects.AddRange(faceArray.Cast<Face>());
+                                break;
+                            default:
+                                base.Write(geometry);
+                                break;
+                        }
+                    }
+                    
+                    if (geometryObjects?.Count > 0) Trace(geometryObjects);
+                    if (boundingBoxes?.Count > 0) Trace(boundingBoxes);
+                    if (xyZs?.Count > 0) Trace(xyZs);
                     break;
                 case GeometryObject geometryObject:
                     Trace(geometryObject);
                     break;
-                case IEnumerable<CurveLoop> curves:
-                    Trace(curves.SelectMany(x => x.ToList()));
-                    break;
                 case XYZ xyz:
                     Trace(xyz);
                     break;
                 case BoundingBoxXYZ boundingBoxXyz:
                     Trace(boundingBoxXyz);
                     break;
+                case FaceArray faceArray:
+                    Trace(faceArray.Cast<Face>());
+                    break;
+                case CurveArray curveArray:
+                    Trace(curveArray.Cast<Curve>());
+                    break;
+                case EdgeArray edgeArray:
+                    Trace(edgeArray.Cast<Edge>());
+                    break;
+                case IEnumerable<GeometryObject> geometries:
+                    Trace(geometries);
+                    break;
+                case IEnumerable<CurveLoop> curves:
+                    Trace(curves.SelectMany(x => x));
+                    break;
+                case IEnumerable<CurveArray> curveArrays:
+                    Trace(curveArrays.SelectMany(x => x.Cast<Curve>()));
+                    break;
+                case IEnumerable<EdgeArray> edgeArrays:
+                    Trace(edgeArrays.SelectMany(x => x.Cast<Edge>()));
+                    break;
+                case IEnumerable<FaceArray> faceArrays:
+                    Trace(faceArrays.SelectMany(x => x.Cast<Face>()));
+                    break;
                 case IEnumerable<XYZ> xyzs:
                     Trace(xyzs);
                     break;
@@ -48,6 +113,7 @@ public override void Write(object? o)
                     break;
             }
         }
+
         public override void Write(string? message)
         {
         }