ui: Lazy-load samples through generated catalog

Add a Roslyn source generator that emits an ISampleCatalogProvider with
sample metadata and sample factories at build time. The generated provider
lets startup build the category shell and Featured list without reflecting
over every sample type or constructing every SampleInfo up front. This
reduces launch work and helps avoid the iOS watchdog as the sample set grows.

Generated catalog shape:

```csharp
    public sealed class GeneratedSampleCatalog : ISampleCatalogProvider
    {
        public IReadOnlyList<string> GetCategories() => Categories;
        public IReadOnlyList<string> GetSampleNames() => SampleNames;

        public SampleInfo CreateSampleInfo(string formalName)
        {
            switch (formalName)
            {
                case "DisplayMap":
                    return new SampleInfo(
                        formalName: "DisplayMap",
                        sampleName: "Display map",
                        category: "Map",
                        sampleType: typeof(DisplayMap));
                default:
                    throw new ArgumentException(...);
            }
        }

        public object CreateSample(string formalName)
        {
            switch (formalName)
            {
                case "DisplayMap":
                    return new DisplayMap();
                default:
                    throw new ArgumentException(...);
            }
        }
    }
```

Old startup flow:

```text
    AppShell / flyout start
        |
        v
    SampleManager.Initialize()
        |
        v
    Assembly.GetTypes()
        |
        v
    Read attributes and create every SampleInfo
        |
        v
    Build full tree, Featured, Favorites
        |
        v
    First page can render
```

New startup flow:

```text
    AppShell / flyout start
        |
        v
    SampleManager.Initialize()
        |
        v
    GeneratedSampleCatalog via partial hook
        |
        v
    Load sample names and category names only
        |
        v
    Build category shell and materialize Featured
        |
        v
    First page can render
        |
        v
    Category, search, offline data, and samples load on demand
```

Route SampleManager through the catalog provider API for sample lookup,
category loading, all-sample materialization, and sample creation. Search,
offline data, and full sample lists still materialize on demand when those
flows need them instead of during boot.

Keep ReflectionSampleCatalogProvider as a plan B for consumers or targets
that do not wire in the generator. The fallback preserves the old
reflection-based discovery behavior behind the same ISampleCatalogProvider
contract while normal app builds use the generated catalog and avoid startup
reflection.

Author: mandel-capuchin

src/Directory.Packages.props

@@ -33,5 +33,6 @@
     <PackageVersion Include="Microsoft.Maui.Controls" Version="9.0.120" />
     <PackageVersion Include="Microsoft.Maui.Controls.Compatibility" Version="9.0.120" />
     <PackageVersion Include="Xamarin.AndroidX.AppCompat" Version="1.7.0.6" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.8.0" />
   </ItemGroup>
 </Project>

src/MAUI/Maui.Samples/ArcGIS.Samples.Maui.csproj

@@ -137,6 +137,12 @@
     <PackageReference Include="Microsoft.Maui.Controls" />
     <PackageReference Include="Microsoft.Maui.Controls.Compatibility" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Samples.CatalogGenerator\Samples.CatalogGenerator.csproj"
+                      OutputItemType="Analyzer"
+                      ReferenceOutputAssembly="false"
+                      PrivateAssets="all" />
+  </ItemGroup>
 
   <!-- WinUIEx is used to workaround the lack of a WebAuthenticationBroker for WinUI. https://github.com/microsoft/WindowsAppSDK/issues/441 -->
   <ItemGroup Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'windows'">
@@ -181,4 +187,4 @@
     <BundleResource Include="Platforms\iOS\PrivacyInfo.xcprivacy" LogicalName="PrivacyInfo.xcprivacy" />
   </ItemGroup>
   <Import Project="..\..\Samples.Shared\ArcGIS.Samples.Shared.projitems" Label="Shared" />
-</Project>
+</Project>

src/MAUI/Maui.Samples/ViewModels/CategoryViewModel.cs

@@ -18,6 +18,8 @@ public partial class CategoryViewModel : ObservableObject
 
         public CategoryViewModel()
         {
+            SampleManager.Current.Initialize();
+
             // Calculate the sample image width and height on mobile platforms based on device display size. 
             _sampleImageWidth = 400;
 
@@ -73,9 +75,7 @@ private void UpdateCategory(string category)
 
         private static List<SampleInfo> GetSamplesInCategory(string category)
         {
-            var categoryNode = SampleManager.Current.FullTree.Items.OfType<SearchableTreeNode>().FirstOrDefault(c => c.Name == category);
-
-            return categoryNode.Items.OfType<SampleInfo>().ToList();
+            return SampleManager.Current.GetSamplesForCategory(category).ToList();
         }
 
         [ObservableProperty]

src/Samples.CatalogGenerator/SampleCatalogGenerator.cs

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <IsRoslynComponent>true</IsRoslynComponent>
+    <IncludeBuildOutput>false</IncludeBuildOutput>
+    <NoWarn>$(NoWarn);RS1036;RS2008</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" PrivateAssets="all" />
+  </ItemGroup>
+</Project>

src/Samples.CatalogGenerator/Samples.CatalogGenerator.csproj

@@ -0,0 +1,30 @@
+// Copyright 2026 Esri.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
+// language governing permissions and limitations under the License.
+
+using ArcGIS.Samples.Shared.Models;
+using System.Collections.Generic;
+
+namespace ArcGIS.Samples.Managers
+{
+    /// <summary>
+    /// Provides generated sample metadata and sample factories without requiring runtime assembly scans.
+    /// </summary>
+    public interface ISampleCatalogProvider
+    {
+        IReadOnlyList<string> GetCategories();
+
+        IReadOnlyList<string> GetSampleNames();
+
+        IReadOnlyList<string> GetSampleNamesForCategory(string category);
+
+        SampleInfo CreateSampleInfo(string formalName);
+
+        object CreateSample(string formalName);
+    }
+}

src/Samples.Shared/Managers/ISampleCatalogProvider.cs

@@ -0,0 +1,117 @@
+// Copyright 2026 Esri.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
+// language governing permissions and limitations under the License.
+
+using ArcGIS.Samples.Shared.Attributes;
+using ArcGIS.Samples.Shared.Models;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+
+namespace ArcGIS.Samples.Managers
+{
+    /// <summary>
+    /// Reflection-backed sample catalog used when a generated catalog is not available.
+    /// </summary>
+    public sealed class ReflectionSampleCatalogProvider : ISampleCatalogProvider
+    {
+        private readonly Dictionary<string, SampleInfo> _samplesByName;
+        private readonly Dictionary<string, string[]> _sampleNamesByCategory;
+        private readonly string[] _categories;
+        private readonly string[] _sampleNames;
+
+        public ReflectionSampleCatalogProvider(Assembly samplesAssembly)
+        {
+            if (samplesAssembly == null)
+            {
+                throw new ArgumentNullException(nameof(samplesAssembly));
+            }
+
+            List<SampleInfo> samples = CreateSampleInfos(samplesAssembly)
+                .OrderBy(info => info.Category, StringComparer.OrdinalIgnoreCase)
+                .ThenBy(info => info.SampleName, StringComparer.OrdinalIgnoreCase)
+                .ToList();
+
+            List<SampleInfo> uniqueSamples = samples
+                .GroupBy(sample => sample.FormalName, StringComparer.OrdinalIgnoreCase)
+                .Select(group => group.First())
+                .ToList();
+
+            _samplesByName = uniqueSamples.ToDictionary(sample => sample.FormalName, sample => sample, StringComparer.OrdinalIgnoreCase);
+            _sampleNames = uniqueSamples.Select(sample => sample.FormalName).ToArray();
+            _categories = uniqueSamples.Select(sample => sample.Category)
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .OrderBy(category => category, StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+
+            _sampleNamesByCategory = _categories.ToDictionary(
+                category => category,
+                category => uniqueSamples
+                    .Where(sample => sample.Category.Equals(category, StringComparison.OrdinalIgnoreCase))
+                    .Select(sample => sample.FormalName)
+                    .ToArray(),
+                StringComparer.OrdinalIgnoreCase);
+        }
+
+        public IReadOnlyList<string> GetCategories() => _categories;
+
+        public IReadOnlyList<string> GetSampleNames() => _sampleNames;
+
+        public IReadOnlyList<string> GetSampleNamesForCategory(string category)
+        {
+            return !string.IsNullOrEmpty(category) && _sampleNamesByCategory.TryGetValue(category, out string[] sampleNames)
+                ? sampleNames
+                : Array.Empty<string>();
+        }
+
+        public SampleInfo CreateSampleInfo(string formalName)
+        {
+            return GetRequiredSampleInfo(formalName);
+        }
+
+        public object CreateSample(string formalName)
+        {
+            SampleInfo sampleInfo = GetRequiredSampleInfo(formalName);
+            return Activator.CreateInstance(sampleInfo.SampleType);
+        }
+
+        private SampleInfo GetRequiredSampleInfo(string formalName)
+        {
+            if (!string.IsNullOrEmpty(formalName) && _samplesByName.TryGetValue(formalName, out SampleInfo sampleInfo))
+            {
+                return sampleInfo;
+            }
+
+            throw new ArgumentException($"Unknown sample '{formalName}'.", nameof(formalName));
+        }
+
+        private static IList<SampleInfo> CreateSampleInfos(Assembly assembly)
+        {
+            IEnumerable<Type> sampleTypes = assembly.GetTypes()
+                .Where(type => type.GetTypeInfo().GetCustomAttributes().OfType<SampleAttribute>().Any());
+
+            List<SampleInfo> samples = new List<SampleInfo>();
+
+            foreach (Type type in sampleTypes)
+            {
+                try
+                {
+                    samples.Add(new SampleInfo(type));
+                }
+                catch (Exception ex)
+                {
+                    Debug.WriteLine("Could not create sample from " + type + ": " + ex);
+                }
+            }
+
+            return samples;
+        }
+    }
+}