Cuemon.Core.App

Overview

Cuemon.Core.App is a metadata-only convenience package that brings Cuemon's broader application-oriented stack under one install. The referenced projects cover core primitives, data helpers, diagnostics, collection and reflection extensions, hosting configuration, IO transforms, networking helpers, runtime caching, cryptography, threading, and XML support for non-web .NET applications.

The package does not declare public types in source evidence. Its value is package selection: install one package and then work directly with the APIs owned by the referenced libraries instead of managing each package reference separately.

Key APIs

Cuemon.Core.App does not add public or protected APIs of its own, so the usable entry points come from the packages it aggregates, including QueryFormatExtensions.Embed, HostEnvironmentExtensions.IsLocalDevelopment, StreamExtensions.CompressGZip, AssemblyExtensions.GetHierarchyTypes, CacheEnumerableExtensions.Memoize, and TaskExtensions.ContinueWithSuppressedContext.

Basic usage

These representative examples show package areas that become available when you install Cuemon.Core.App.

Cuemon.Extensions.Data

using Codebelt.Extensions.Xunit;
using Cuemon.Data;
using Cuemon.Extensions.Data;
using Xunit;

namespace MyProject.Tests;

public class QueryFormatExtensionsTest : Test
{
    public QueryFormatExtensionsTest(ITestOutputHelper output) : base(output)
    {
    }

    [Fact]
    public void ShouldBuildDistinctStringFragmentForSqlFilter()
    {
        var fragment = QueryFormat.DelimitedString.Embed(new[] { "INV-001", "INV-002", "INV-001" }, distinct: true);

        TestOutput.WriteLine(fragment);

        Assert.Equal("'INV-001','INV-002'", fragment);
    }
}

Cuemon.Extensions.Hosting

using Codebelt.Extensions.Xunit;
using Cuemon.Extensions.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit;

namespace MyProject.Tests;

public class HostEnvironmentExtensionsTest : Test
{
    public HostEnvironmentExtensionsTest(ITestOutputHelper output) : base(output)
    {
    }

    [Fact]
    public void ShouldRecognizeLocalDevelopmentAsNonProduction()
    {
        using var host = new HostBuilder()
            .UseEnvironment(Environments.LocalDevelopment)
            .Build();

        var environment = host.Services.GetRequiredService<IHostEnvironment>();

        TestOutput.WriteLine(environment.EnvironmentName);

        Assert.True(environment.IsLocalDevelopment());
        Assert.True(environment.IsNonProduction());
    }
}

Cuemon.Extensions.IO

using Codebelt.Extensions.Xunit;
using Cuemon.Extensions.IO;
using Xunit;

namespace MyProject.Tests;

public class StreamExtensionsTest : Test
{
    public StreamExtensionsTest(ITestOutputHelper output) : base(output)
    {
    }

    [Fact]
    public void ShouldRoundTripApplicationPayloadThroughGZip()
    {
        const string payload = "tenant=alpha|batch=2026-05-29|items=128|status=ready";
        using var source = payload.ToStream();
        using var compressed = source.CompressGZip();
        using var roundtrip = compressed.DecompressGZip();
        var restored = roundtrip.ToEncodedString();

        TestOutput.WriteLine($"Restored payload: {restored}");

        Assert.Equal(payload, restored);
    }
}

Cuemon.Extensions.Reflection

using System.IO;
using System.Linq;
using Codebelt.Extensions.Xunit;
using Cuemon.Extensions.Reflection;
using Xunit;

namespace MyProject.Tests;

public class TypeExtensionsTest : Test
{
    public TypeExtensionsTest(ITestOutputHelper output) : base(output)
    {
    }

    [Fact]
    public void ShouldExposeStreamHierarchyAcrossBaseAndDerivedTypes()
    {
        var hierarchy = typeof(Stream).GetHierarchyTypes()
            .Where(type => type.IsPublic)
            .Select(type => type.Name)
            .ToList();

        TestOutput.WriteLine(string.Join(", ", hierarchy));

        Assert.Contains("Stream", hierarchy);
        Assert.Contains("FileStream", hierarchy);
        Assert.Contains("MemoryStream", hierarchy);
    }
}

Cuemon.Extensions.Runtime.Caching

using System;
using Codebelt.Extensions.Xunit;
using Cuemon.Extensions.Runtime.Caching;
using Cuemon.Runtime.Caching;
using Xunit;

namespace MyProject.Tests;

public class CacheEnumerableExtensionsTest : Test
{
    public CacheEnumerableExtensionsTest(ITestOutputHelper output) : base(output)
    {
    }

    [Fact]
    public void ShouldMemoizeDelegateResultForRepeatedArguments()
    {
        using var cache = new SlimMemoryCache();
        var executions = 0;
        var buildCacheKey = cache.Memoize(TimeSpan.FromMinutes(5), (int partition) =>
        {
            executions++;
            return $"cache-key-{partition:D2}";
        });

        var first = buildCacheKey(7);
        var second = buildCacheKey(7);

        TestOutput.WriteLine($"{first} (executions: {executions})");

        Assert.Equal(first, second);
        Assert.Equal(1, executions);
    }
}

Cuemon.Extensions.Threading

using System.Threading.Tasks;
using Codebelt.Extensions.Xunit;
using Cuemon.Extensions.Threading.Tasks;
using Xunit;

namespace MyProject.Tests;

public class TaskExtensionsTest : Test
{
    public TaskExtensionsTest(ITestOutputHelper output) : base(output)
    {
    }

    [Fact]
    public async Task ShouldAwaitResultWithoutCapturingContext()
    {
        var result = await Task.FromResult("batch-ready").ContinueWithSuppressedContext();

        TestOutput.WriteLine(result);

        Assert.Equal("batch-ready", result);
    }
}

Installing Cuemon.Core.App gives you one NuGet reference, but the APIs shown above are owned by the referenced packages rather than by the aggregate package itself. Use the aggregate package when you want this broader application-oriented surface together, and move to the smaller packages directly when you want tighter dependency selection.

Installation

dotnet add package Cuemon.Core.App

Usage guidance

Choose Cuemon.Core.App when an application wants the broader Cuemon stack available through one package reference, especially when the same solution needs query formatting, host-environment helpers, stream transforms, reflection helpers, memoization, and task-continuation helpers together. If you only need one or two of those areas, reference the smaller packages directly so your project carries only the APIs and dependencies it actually uses.