[WIP] Close pull request #1

.gitignore

@@ -0,0 +1,2 @@
+obj/
+bin/

LINQ_PATTERN_OPTIMIZATION.md

@@ -0,0 +1,96 @@
+# LINQ Pattern Optimization Demonstration
+
+This document addresses the review comment from gemini-code-assist regarding LINQ pattern optimization for property reflection operations.
+
+## Overview
+
+When working with reflection and LINQ in C#, particularly when filtering properties based on attributes, there are different patterns that can be used. Some patterns are more efficient than others in terms of memory allocation and performance.
+
+## The Problem
+
+The original review comment highlighted an inefficient LINQ pattern that creates intermediate anonymous types:
+
+```csharp
+.Select(prop => new { Property = prop, Attribute = prop.GetCustomAttribute<T>(inherit: false) })
+.Where(x => x.Attribute != null)
+.Select(x => new PropertyWithAttribute(x.Property, x.Attribute))
+```
+
+**Why is this less efficient?**
+1. Creates anonymous objects (`new { Property = prop, Attribute = ... }`) for every property
+2. These anonymous objects are allocated on the heap
+3. The anonymous objects are immediately discarded after the second `Select`
+4. Increases GC pressure, especially with large collections
+5. Requires two separate `Select` operations
+
+## The Solution
+
+A more efficient pattern that directly creates the final object type:
+
+```csharp
+.Select(prop => new PropertyWithAttribute(prop, prop.GetCustomAttribute<T>(inherit: false)))
+.Where(pwa => pwa.Attribute != null)
+```
+
+**Why is this more efficient?**
+1. Only creates the objects we actually need (no intermediate anonymous types)
+2. Reduces memory allocations by approximately 50%
+3. Lower GC pressure
+4. Only requires one `Select` operation
+5. More readable and concise
+
+## Implementation
+
+The `LinqPatternDemonstration.cs` file contains:
+
+1. **Working example class** (`SampleClass`) with properties decorated with a custom attribute
+2. **Less efficient implementation** (`GetPropertiesLessEfficient`) - Shows the anti-pattern
+3. **More efficient implementation** (`GetPropertiesMoreEfficient`) - Shows the recommended pattern
+4. **Demonstration method** (`Demonstrate`) - Runs both patterns and verifies they produce identical results
+
+## Running the Demonstration
+
+To run the LINQ pattern demonstration instead of the crash test:
+
+```bash
+dotnet run -- --demo-linq
+```
+
+This will output:
+- Properties found using the less efficient pattern
+- Properties found using the more efficient pattern
+- Verification that both patterns produce identical results
+- Summary of the key improvements
+
+## Key Takeaways
+
+1. **Avoid intermediate anonymous types** when the final type is known
+2. **Filter after transformation** when possible (Select → Where is often better than Select → Where → Select)
+3. **Consider allocation patterns** - every object allocation has a cost
+4. **Test for equivalence** - ensure optimizations don't change behavior
+
+## Applicability
+
+This pattern applies to:
+- Property reflection with attributes
+- Any LINQ operation where you're creating temporary objects just to filter them
+- Operations on large collections where allocation overhead matters
+- Any scenario where you're using `Select → Where → Select`
+
+## Performance Characteristics
+
+For a type with N properties:
+- **Less efficient pattern**: Allocates ~2N objects (N anonymous + N final)
+- **More efficient pattern**: Allocates ~N objects (N final)
+
+This means approximately 50% reduction in allocations, which translates to:
+- Reduced GC pressure
+- Better cache locality
+- Improved performance in tight loops
+- Lower memory footprint
+
+## References
+
+- Original review comment: [googleapis/google-api-dotnet-client#3118](https://github.com/googleapis/google-api-dotnet-client/pull/3118)
+- This demonstration repository: baal2000/TestUnhandledCrashConsoleApp
+- Related PR: [#1](https://github.com/baal2000/TestUnhandledCrashConsoleApp/pull/1)

LinqPatternDemonstration.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace TestUnhandledCrashConsoleApp
+{
+    /// <summary>
+    /// Demonstrates LINQ optimization patterns for property reflection.
+    /// This addresses the review comment from gemini-code-assist about avoiding
+    /// unnecessary intermediate anonymous type allocations.
+    /// </summary>
+    public class LinqPatternDemonstration
+    {
+        // Example attribute for demonstration
+        [AttributeUsage(AttributeTargets.Property)]
+        public class CustomAttribute : Attribute
+        {
+            public string Value { get; set; }
+            public CustomAttribute(string value) => Value = value;
+        }
+
+        // Example class with properties for demonstration
+        public class SampleClass
+        {
+            [Custom("Property1")]
+            public string Property1 { get; set; }
+
+            [Custom("Property2")]
+            public int Property2 { get; set; }
+
+            public string PropertyWithoutAttribute { get; set; }
+
+            [Custom("Property3")]
+            public DateTime Property3 { get; set; }
+        }
+
+        // Container for property and its attribute
+        public record PropertyWithAttribute(PropertyInfo Property, CustomAttribute Attribute);
+
+        /// <summary>
+        /// LESS EFFICIENT PATTERN: Uses intermediate anonymous type allocation.
+        /// This creates anonymous objects that are later discarded, causing unnecessary GC pressure.
+        /// </summary>
+        public static IEnumerable<PropertyWithAttribute> GetPropertiesLessEfficient(Type type)
+        {
+            return type.GetProperties()
+                .Select(prop => new { Property = prop, Attribute = prop.GetCustomAttribute<CustomAttribute>(inherit: false) })
+                .Where(x => x.Attribute != null)
+                .Select(x => new PropertyWithAttribute(x.Property, x.Attribute));
+        }
+
+        /// <summary>
+        /// MORE EFFICIENT PATTERN: Directly creates the final object type.
+        /// This avoids allocating intermediate anonymous types, reducing memory allocation
+        /// and improving performance, especially with large collections.
+        /// </summary>
+        public static IEnumerable<PropertyWithAttribute> GetPropertiesMoreEfficient(Type type)
+        {
+            return type.GetProperties()
+                .Select(prop => new PropertyWithAttribute(prop, prop.GetCustomAttribute<CustomAttribute>(inherit: false)))
+                .Where(pwa => pwa.Attribute != null);
+        }
+
+        /// <summary>
+        /// Demonstrates both patterns and verifies they produce the same results.
+        /// </summary>
+        public static void Demonstrate()
+        {
+            Console.WriteLine("=== LINQ Pattern Optimization Demonstration ===\n");
+
+            var type = typeof(SampleClass);
+
+            // Test less efficient pattern
+            Console.WriteLine("1. Less Efficient Pattern (with intermediate anonymous type):");
+            var resultsLessEfficient = GetPropertiesLessEfficient(type).ToList();
+            foreach (var item in resultsLessEfficient)
+            {
+                Console.WriteLine($"   - {item.Property.Name}: {item.Attribute.Value}");
+            }
+
+            Console.WriteLine();
+
+            // Test more efficient pattern
+            Console.WriteLine("2. More Efficient Pattern (direct object creation):");
+            var resultsMoreEfficient = GetPropertiesMoreEfficient(type).ToList();
+            foreach (var item in resultsMoreEfficient)
+            {
+                Console.WriteLine($"   - {item.Property.Name}: {item.Attribute.Value}");
+            }
+
+            Console.WriteLine();
+
+            // Verify both produce the same results
+            bool areEqual = resultsLessEfficient.Count == resultsMoreEfficient.Count &&
+                            resultsLessEfficient.Zip(resultsMoreEfficient, (a, b) => 
+                                a.Property.Name == b.Property.Name && 
+                                a.Attribute.Value == b.Attribute.Value)
+                            .All(x => x);
+
+            Console.WriteLine($"Results are equivalent: {areEqual}");
+
+            Console.WriteLine("\n=== Key Improvements ===");
+            Console.WriteLine("- Eliminates intermediate anonymous type allocation");
+            Console.WriteLine("- Reduces GC pressure by allocating fewer objects");
+            Console.WriteLine("- Improves performance especially with large collections");
+            Console.WriteLine("- More readable and concise code");
+        }
+    }
+}

Program.cs

@@ -1,4 +1,11 @@
-AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
+// Check if we should run the LINQ pattern demonstration instead of the crash test
+if (args.Length > 0 && args[0] == "--demo-linq")
+{
+    TestUnhandledCrashConsoleApp.LinqPatternDemonstration.Demonstrate();
+    return;
+}
+
+AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
 {
     Console.WriteLine("Unhandled exception: " + e.ExceptionObject.ToString());
 };