Getting Started with COM API

using Microsoft.Management.Deployment;

class Program
{
    static void Main()
    {
        var manager = new PackageManager();
        var catalogs = manager.GetPackageCatalogs();
        
        Console.WriteLine("Available Package Catalogs:");
        foreach (var catalogRef in catalogs)
        {
            if (!catalogRef.IsComposite)
            {
                var info = catalogRef.Info;
                Console.WriteLine($"- {info.Name} ({info.Type})");
                Console.WriteLine($"  Origin: {info.Origin}");
                Console.WriteLine($"  Trust Level: {info.TrustLevel}");
            }
        }
    }
}

using Microsoft.Management.Deployment;

async Task SearchPackageAsync(string packageId)
{
    var manager = new PackageManager();
    
    // Get the winget catalog
    var catalogRef = manager.GetPredefinedPackageCatalog(
        PredefinedPackageCatalog.OpenWindowsCatalog
    );
    
    // Connect to catalog
    var connectResult = await catalogRef.ConnectAsync();
    if (connectResult.Status != ConnectResultStatus.Ok)
    {
        Console.WriteLine($"Failed to connect: {connectResult.Status}");
        return;
    }
    
    // Create search filter
    var options = new FindPackagesOptions();
    var filter = new PackageMatchFilter()
    {
        Field = PackageMatchField.Id,
        Value = packageId,
        Option = PackageFieldMatchOption.ContainsCaseInsensitive
    };
    options.Selectors.Add(filter);
    
    // Search
    var findResult = await connectResult.PackageCatalog.FindPackagesAsync(options);
    
    if (findResult.Status == FindPackagesResultStatus.Ok)
    {
        Console.WriteLine($"Found {findResult.Matches.Count} packages:");
        foreach (var match in findResult.Matches)
        {
            var package = match.CatalogPackage;
            Console.WriteLine($"- {package.Id}: {package.Name}");
            Console.WriteLine($"  Version: {package.DefaultInstallVersion.Version}");
        }
    }
}

using Microsoft.Management.Deployment;

async Task InstallPackageAsync(string packageId)
{
    var manager = new PackageManager();
    
    // Search for package (see Example 2)
    var catalogRef = manager.GetPredefinedPackageCatalog(
        PredefinedPackageCatalog.OpenWindowsCatalog
    );
    var connectResult = await catalogRef.ConnectAsync();
    
    var options = new FindPackagesOptions();
    options.Selectors.Add(new PackageMatchFilter() 
    {
        Field = PackageMatchField.Id,
        Value = packageId,
        Option = PackageFieldMatchOption.Equals
    });
    
    var findResult = await connectResult.PackageCatalog.FindPackagesAsync(options);
    
    if (findResult.Matches.Count == 0)
    {
        Console.WriteLine("Package not found");
        return;
    }
    
    var package = findResult.Matches[0].CatalogPackage;
    
    // Install the package
    var installOptions = new InstallOptions()
    {
        PackageInstallMode = PackageInstallMode.Silent,
        AcceptPackageAgreements = true
    };
    
    var installOperation = manager.InstallPackageAsync(package, installOptions);
    
    // Track progress
    installOperation.Progress = (operation, progress) =>
    {
        Console.WriteLine($"State: {progress.State}");
        if (progress.DownloadProgress > 0)
        {
            Console.WriteLine($"Download: {progress.DownloadProgress * 100:F1}%");
        }
    };
    
    var installResult = await installOperation;
    
    if (installResult.Status == InstallResultStatus.Ok)
    {
        Console.WriteLine("Installation successful!");
    }
    else
    {
        Console.WriteLine($"Installation failed: {installResult.Status}");
        Console.WriteLine($"Error: 0x{installResult.ExtendedErrorCode:X}");
    }
}

using Microsoft.Management.Configuration;
using Windows.Storage;

async Task ApplyConfigurationAsync(string configPath)
{
    // Create configuration processor factory
    var factory = await ConfigurationStaticFunctions
        .CreateConfigurationSetProcessorFactoryAsync("pwsh");
    
    var processor = new ConfigurationProcessor(factory);
    
    // Open configuration file
    var file = await StorageFile.GetFileFromPathAsync(configPath);
    var stream = await file.OpenReadAsync();
    var openResult = await processor.OpenConfigurationSetAsync(stream);
    
    if (openResult.ResultCode != 0)
    {
        Console.WriteLine($"Failed to open: 0x{openResult.ResultCode:X}");
        Console.WriteLine($"Field: {openResult.Field}, Line: {openResult.Line}");
        return;
    }
    
    var configSet = openResult.Set;
    Console.WriteLine($"Configuration: {configSet.Name}");
    Console.WriteLine($"Units: {configSet.Units.Count}");
    
    // Apply configuration
    var applyOperation = processor.ApplySetAsync(
        configSet, 
        ApplyConfigurationSetFlags.None
    );
    
    applyOperation.Progress = (operation, data) =>
    {
        if (data.Change == ConfigurationSetChangeEventType.UnitStateChanged)
        {
            Console.WriteLine($"Unit: {data.Unit.Type} - {data.UnitState}");
        }
    };
    
    var applyResult = await applyOperation;
    Console.WriteLine($"Result: 0x{applyResult.ResultCode:X}");
}