Name: Myth.Commons
Author: Paula Leal

Myth.Commons v3.10.0 — nugetz

dotnet add package Myth.Commons

using Myth.Extensions;

// Serialize to JSON
var user = new User { Id = 1, Name = "John Doe", Email = "john@example.com" };
var json = user.ToJson();
// {"id":1,"name":"John Doe","email":"john@example.com"}

// Deserialize from JSON
var userObj = json.FromJson<User>();

JsonExtensions.Configure( settings => settings
    .UseCaseStrategy( CaseStrategy.SnakeCase )
    .IgnoreNull()
    .Minify()
);

var json = user.ToJson();
// {"id":1,"name":"John Doe","email":"john@example.com"}

// Use snake_case for this operation only
var json = user.ToJson( settings => settings
    .UseCaseStrategy( CaseStrategy.SnakeCase )
);
// {"id":1,"name":"john doe","email":"john@example.com"}

// Minify JSON output
var compactJson = user.ToJson( settings => settings.Minify() );

// Ignore null values
var jsonWithoutNulls = user.ToJson( settings => settings.IgnoreNull() );

// Using generic converter
var json = user.ToJson( settings => settings
    .UseInterfaceConverter<IAddress, Address>()
);

// Using non-generic converter
var json = user.ToJson( settings => settings
    .UseInterfaceConverter( typeof( IAddress ), typeof( Address ) )
);

var json = user.ToJson( settings => settings
    .UseCustomConverter( new CustomDateTimeConverter() )
);

var json = user.ToJson( settings => {
    settings.IgnoreNull().Minify();
    settings.OtherSettings = options => {
        options.MaxDepth = 64;
        options.NumberHandling = JsonNumberHandling.AllowReadingFromString;
    };
} );

public enum CaseStrategy {
    CamelCase,  // myAwesomeProperty
    SnakeCase   // my_awesome_property
}

var json = "{\"name\":\"John\",\"age\":30}";
dynamic obj = json.FromJson<object>();
Console.WriteLine( obj.name ); // John

try {
    var obj = invalidJson.FromJson<User>();
} catch ( JsonParsingException ex ) {
    Console.WriteLine( $"JSON parsing failed: {ex.Message}" );
    Console.WriteLine( $"Inner exception: {ex.InnerException?.Message}" );
}

using Myth.Extensions;

// Remove text
var result = "Hello World".Remove( "World" ); // "Hello "

// Minify (remove all whitespace)
var minified = "Hello   World\n\t".Minify(); // "HelloWorld"

// Change case of first letter
var lower = "Hello".ToFirstLower(); // "hello"
var upper = "hello".ToFirstUpper(); // "Hello"

// Extract text between characters
var text = "The 'quick' brown fox";
var extracted = text.GetStringBetween( '\'' ); // "quick"

// Find words
var sentence = "The quick brown fox";
var word = sentence.GetWordThatContains( "qui" ); // "quick"
var before = sentence.GetWordBefore( "brown" ); // "quick"
var after = sentence.GetWordAfter( "quick" ); // "brown"

// Search operations
var hasAny = "Hello World".ContainsAnyOf( "Hi", "Hello", "Hey" ); // true
var startsWithAny = "Hello World".StartsWithAnyOf( "Hi", "Hello" ); // true

using Myth.Extensions;

var text = "Hello World";
var encoded = text.EncodeAsUrl(); // "Hello+World"

var flag = true;
var encodedFlag = flag.EncodeAsUrl(); // true (as boolean)

using Myth.ValueObjects;

public class Address : ValueObject {
    public string Street { get; }
    public string City { get; }
    public string ZipCode { get; }

    public Address( string street, string city, string zipCode ) {
        Street = street;
        City = city;
        ZipCode = zipCode;
    }

    protected override IEnumerable<object> GetAtomicValues() {
        yield return Street;
        yield return City;
        yield return ZipCode;
    }
}

// Value objects are compared by their values, not reference
var address1 = new Address( "123 Main St", "Springfield", "12345" );
var address2 = new Address( "123 Main St", "Springfield", "12345" );
var address3 = new Address( "456 Oak Ave", "Springfield", "12345" );

Console.WriteLine( address1 == address2 ); // true (same values)
Console.WriteLine( address1 == address3 ); // false (different values)

// Clone value objects
var clone = address1.Clone();

using Myth.ValueObjects;

public class OrderStatus : Constant<OrderStatus, string> {
    public static readonly OrderStatus Pending = new( nameof( Pending ), "PENDING" );
    public static readonly OrderStatus Processing = new( nameof( Processing ), "PROCESSING" );
    public static readonly OrderStatus Completed = new( nameof( Completed ), "COMPLETED" );
    public static readonly OrderStatus Cancelled = new( nameof( Cancelled ), "CANCELLED" );

    private OrderStatus( string name, string value ) : base( name, value ) { }
}

// Usage
var status = OrderStatus.Pending;
string statusValue = status; // Implicit conversion to "PENDING"

// Get from value
var status2 = OrderStatus.FromValue( "PROCESSING" ); // OrderStatus.Processing

// Get from name
var status3 = OrderStatus.FromName( "Completed" ); // OrderStatus.Completed

// List all options
var options = OrderStatus.GetOptions();
// "(Pending): PENDING | (Processing): PROCESSING | (Completed): COMPLETED | (Cancelled): CANCELLED"

// Switch on constants (exhaustive)
var message = status switch {
    var s when s == OrderStatus.Pending => "Order is pending",
    var s when s == OrderStatus.Processing => "Order is being processed",
    var s when s == OrderStatus.Completed => "Order is completed",
    var s when s == OrderStatus.Cancelled => "Order was cancelled",
    _ => throw new InvalidOperationException()
};

var builder = WebApplication.CreateBuilder( args );

builder.Services.AddFlow();
builder.Services.AddGuard();
builder.Services.AddFlowActions( config => { ... } );

var app = builder.BuildApp(); // Instead of builder.Build()

app.UseGuard();
app.Run();

var services = new ServiceCollection();
services.AddFlow();
services.AddGuard();
services.AddMyServices();

var serviceProvider = services.BuildServiceProvider();
MythServiceProvider.Initialize( serviceProvider );

// Now all libraries can resolve dependencies
var pipeline = Pipeline.Start( context );

using Myth.ServiceProvider;

// Check if initialized
if ( MythServiceProvider.IsInitialized ) {
    var provider = MythServiceProvider.Current;
}

// Get or throw if not initialized
var requiredProvider = MythServiceProvider.GetRequired();

// Get with fallback
var provider = MythServiceProvider.GetOrFallback( localServiceProvider );

// Try initialize (first-wins pattern)
var initialized = MythServiceProvider.TryInitialize( serviceProvider );

// Force initialize (overwrites existing)
MythServiceProvider.Initialize( serviceProvider );

public class ThirdPartyLibrary {
    public void DoSomething() {
        var provider = ServiceCollectionExtensions.GetGlobalProvider();
        var validator = provider?.GetService<IValidator>();
        if ( validator != null ) {
            // Use Myth libraries without direct coupling
        }
    }
}

[Fact]
public void TestWithCleanProvider() {
    MythServiceProvider.Reset();

    var services = new ServiceCollection();
    // ... configure test services
    var provider = services.BuildServiceProvider();
    MythServiceProvider.Initialize( provider );

    // Run test
}

var builder = WebApplication.CreateBuilder( args );

builder.Services.AddScopedServiceProvider();
builder.Services.AddScoped<IOrderRepository, OrderRepository>();
builder.Services.AddDbContext<AppDbContext>();

var app = builder.BuildApp();

public class CreateOrderHandler : ICommandHandler<CreateOrderCommand> {
    private readonly IScopedService<IOrderRepository> _repository;
    private readonly IScopedService<IEmailService> _emailService;

    public CreateOrderHandler(
        IScopedService<IOrderRepository> repository,
        IScopedService<IEmailService> emailService ) {
        _repository = repository;
        _emailService = emailService;
    }

    public async Task<CommandResult> HandleAsync(
        CreateOrderCommand command,
        CancellationToken ct ) {

        // Execute with automatic scope management
        var order = await _repository.ExecuteAsync( repo =>
            repo.CreateAsync( command.OrderData, ct )
        );

        // Execute void operations
        await _emailService.ExecuteAsync( email =>
            email.SendOrderConfirmationAsync( order.Id, ct )
        );

        return CommandResult.Success();
    }
}

// With return value
var result = _scopedService.Execute( service =>
    service.GetData()
);

// Void operation
_scopedService.Execute( service =>
    service.ProcessData()
);

// With return value
var result = await _scopedService.ExecuteAsync( service =>
    service.GetDataAsync()
);

// Void operation
await _scopedService.ExecuteAsync( service =>
    service.ProcessDataAsync()
);

using Myth.ValueObjects;

// Default pagination (page 1, size 10)
var pagination = Pagination.Default;

// Custom pagination
var customPagination = new Pagination( pageNumber: 2, pageSize: 20 );

// Get all items (single page)
var allItems = Pagination.All;

// ASP.NET Core automatic binding
[HttpGet]
public IActionResult GetOrders( [FromQuery] Pagination pagination ) {
    // Automatically binds from query string: ?$pagenumber=2&$pagesize=20
}

using Myth.Interfaces.Results;
using Myth.Models.Results;

// Create paginated result
var items = await repository.GetOrdersAsync( pagination );
var total = await repository.GetTotalCountAsync();
var totalPages = ( int )Math.Ceiling( ( double )total / pagination.PageSize );

var result = new Paginated<Order>(
    pageNumber: pagination.PageNumber,
    pageSize: pagination.PageSize,
    totalItems: total,
    totalPages: totalPages,
    items: items
);

// Access properties
Console.WriteLine( $"Page {result.PageNumber} of {result.TotalPages}" );
Console.WriteLine( $"Showing {result.Items.Count()} of {result.TotalItems} items" );

// Return in API
return Ok( result );

public class CustomPaginatedResult<T> : IPaginated<T> {
    public int PageNumber { get; set; }
    public int PageSize { get; set; }
    public int TotalPages { get; set; }
    public int TotalItems { get; set; }
    public IEnumerable<T> Items { get; set; }

    // Add custom properties
    public bool HasNextPage => PageNumber < TotalPages;
    public bool HasPreviousPage => PageNumber > 1;
}

using Myth.Extensions;

var items = new[] { "apple", "banana", "cherry" };

// Join with separator
var result = items.ToStringWithSeparator( ", " );
// "apple, banana, cherry"

// Custom separator
var result2 = items.ToStringWithSeparator( " | " );
// "apple | banana | cherry"

// Default separator (", ")
var result3 = items.ToStringWithSeparator();
// "apple, banana, cherry"

// Value Object for Money
public class Money : ValueObject {
    public decimal Amount { get; }
    public string Currency { get; }

    public Money( decimal amount, string currency ) {
        Amount = amount;
        Currency = currency;
    }

    protected override IEnumerable<object> GetAtomicValues() {
        yield return Amount;
        yield return Currency;
    }

    public Money Add( Money other ) {
        if ( Currency != other.Currency )
            throw new InvalidOperationException( "Cannot add money with different currencies" );

        return new Money( Amount + other.Amount, Currency );
    }
}

// Type-safe constants
public class Currency : Constant<Currency, string> {
    public static readonly Currency USD = new( nameof( USD ), "USD" );
    public static readonly Currency EUR = new( nameof( EUR ), "EUR" );
    public static readonly Currency BRL = new( nameof( BRL ), "BRL" );

    private Currency( string name, string value ) : base( name, value ) { }
}

public class GetOrdersQueryHandler : IQueryHandler<GetOrdersQuery, IPaginated<Order>> {
    private readonly IScopedService<IOrderRepository> _repository;

    public GetOrdersQueryHandler( IScopedService<IOrderRepository> repository ) {
        _repository = repository;
    }

    public async Task<QueryResult<IPaginated<Order>>> HandleAsync(
        GetOrdersQuery query,
        CancellationToken ct ) {

        var result = await _repository.ExecuteAsync( async repo => {
            var items = await repo.GetOrdersAsync( query.Pagination, ct );
            var total = await repo.GetTotalCountAsync( ct );

            return new Paginated<Order>(
                query.Pagination.PageNumber,
                query.Pagination.PageSize,
                total,
                ( int )Math.Ceiling( ( double )total / query.Pagination.PageSize ),
                items
            );
        } );

        return QueryResult<IPaginated<Order>>.Success( result );
    }
}

paulaolileal/Myth.Commonsv3.10.0

Get Started

Readme

Myth.Commons

Features

Installation

Table of Contents

JSON Extensions

Basic Usage

Global Configuration

Per-Operation Configuration

Interface to Concrete Type Converters

Custom JSON Converters

Advanced JSON Settings

Case Strategies

Dynamic Object Support

Exception Handling

String Extensions

URL Extensions

Value Objects

Value Object Benefits

Constants

Constant Benefits

Service Provider Management

ASP.NET Core Applications

Console Applications / Background Services

Accessing Global Service Provider

External Library Integration

Testing Support

Scoped Services

Setup

Usage in Handlers

Synchronous Operations

Asynchronous Operations

Benefits

Pagination

Pagination Value Object

Paginated Results

IPaginated Interface

Collection Extensions

Architecture Patterns

Domain-Driven Design

CQRS Integration

Clean Architecture

Best Practices

JSON Serialization

Value Objects

Constants

Service Provider

Scoped Services

Dependencies

Requirements

Contributing

License

Support