T1.Standard 1.0.84

Release Notes: https://mr-brain.github.io/categories/t1-standard/

T1.Standard.Net

HttpClientEventStream

HttpClient client;
var client = new HttpClientEventStream(client, jsonSerializer); 
var lines = client.PostEventStreamAsync("messageStream", req);
await foreach (var line in lines)
{
    if (line.StartsWith(": ping"))
    {
        continue;
    }
    var token = _apiJsonSerializer.Deserialize<GptToken>(line);
    yield return token;
    if (token is { IsEnd: true })
    {
        break;
    }
}

T1.Standard.DesignPatterns

Either<TLeft, TRight>

The Either pattern can help address the performance issues associated with throwing exceptions. Exceptions should be reserved for scenarios where a problem is truly irrecoverable for the user or when the application cannot handle the situation. They are not meant to be used as a catch-all mechanism for every kind of error, only to be caught and handled externally.

Instead, Either provides a structured way to represent and handle both success and failure outcomes, making the code more predictable and efficient.

Here’s the demonstrating how to use the Either<TLeft, TRight> class to handle situations where a method might return one of two results (a left value or a right value). This example simulates handling a response from an API.

// Simulate a synchronous operation
Either<string, int> PerformOperation(bool isSuccess)
{
    if (isSuccess)
    {
        return new Either<string, int>(42); // Return right value on success
    }
    return new Either<string, int>("An error occurred."); // Return left value on failure
}

// Handle the result (synchronous version)
void HandleResult(Either<string, int> result)
{
    result.Switch(
        left => Console.WriteLine($"Operation failed with error: {left}"),
        right => Console.WriteLine($"Operation succeeded with result: {right}")
    );
}

// Simulate an asynchronous operation
async Task<Either<string, int>> PerformOperationAsync(bool isSuccess)
{
    await Task.Delay(500); // Simulate delay
    return PerformOperation(isSuccess);
}    

// Handle the result (asynchronous version)
Task HandleResultAsync(Either<string, int> result)
{
    return result.SwitchAsync(
        async left =>
        {
            Console.WriteLine($"Async operation failed with error: {left}");
            await Task.CompletedTask;
        },
        async right =>
        {
            Console.WriteLine($"Async operation succeeded with result: {right}");
            await Task.CompletedTask;
        }
    );
}

T1.Standard.Common

MethodCache

Using this method, you can easily add caching functionality to any method:

public class YourService
{
    private readonly MethodCache _cache;
    public YourService()
    {
        _cache = new MethodCache(defaultCacheDuration: TimeSpan.FromMinutes(5)); 
    }

    public async Task<UserInfo> GetUserInfoAsync(string userId)
    {
        // Original Implementation…
    }

    public Task<UserInfo> GetUserInfoWithCacheAsync(string userId)
    {
        return _cache.WithCacheAsync(
            () => GetUserInfoAsync(userId),
            cacheKey: $"GetUserInfoAsync:{userId}"
        );
    }
}

The advantages of this implementation include:

• Highly reusable - MethodCache can be used with any class and method.
• Flexibility - Different cache expiration times can be specified for each method call.
• Type-safe - Generics ensure type safety.
• Simplicity - No need to create specific wrapper methods for every method that needs caching.

T1.Standard.Data.SqlBuilders

MssqlBuilder

Generate Insert T-SQL statement string

var sqlBuilder = new MssqlBuilder();
var tableInfo = sqlBuilder.GetTableInfo(typeof(CustomerEntity));
var sqlCode = sqlBuilder.CreateInsertStatement(tableInfo);

T1.Standard.Collections.TreeBuilder

ReduceTree

Universal way to convert List of items to Tree, Build the tree as completely as possible

var userList = new[]
{
	 new MyUser { Path = "", Name = "A1" },
	 new MyUser { Path = "", Name = "A2" },
	 new MyUser { Path = "demo", Name = "B1" }
};

var actual = _treeBuilder.ReduceTree(userList,
	 x => x.Path,
	 x => _treeBuilder.GetParentPath(x),
	 x => _treeBuilder.QueryParentPaths(x.Path)
).ToList();

var expected = new List<TreeBuilder.TreeItem<MyUser, string>>
{
	 new TreeBuilder.TreeItem<MyUser, string>()
	 {
		  Id = "",
		  ParentId = null,
		  Item = new MyUser {Path = "", Name = "A1"},
		  Children = new List<TreeBuilder.TreeItem<MyUser, string>>()
	 },
	 new TreeBuilder.TreeItem<MyUser, string>()
	 {
		  Id = "",
		  ParentId = null,
		  Item = new MyUser {Path = "", Name = "A2"},
		  Children = new List<TreeBuilder.TreeItem<MyUser, string>>()
	 },
	 new TreeBuilder.TreeItem<MyUser, string>()
	 {
		  Id = "demo",
		  ParentId = null,
		  Item = new MyUser {Path = "demo", Name = "B1"},
		  Children = new List<TreeBuilder.TreeItem<MyUser, string>>()
	 },
};

expected.ToExpectedObject().ShouldEqual(actual);

GenerateTree

This will only create a fully structured tree

var userList = new[]
{
	 new MyUser {Path = "", Name = "A1"},
	 new MyUser {Path = "demo/name", Name = "C1"},
};

var actual = _treeBuilder.GenerateTree(userList,
	 x => x.Path,
	 x => _treeBuilder.GetParentPath(x.Path)
).ToList();

var expected = new List<TreeBuilder.TreeItem<MyUser, string>>
{
	 new TreeBuilder.TreeItem<MyUser, string>()
	 {
		  Id = "",
		  ParentId = null,
		  Item = new MyUser {Path = "", Name = "A1"},
		  Children = new List<TreeBuilder.TreeItem<MyUser, string>>()
	 },
};

expected.ToExpectedObject().ShouldEqual(actual);

string/object Dictionary List to DataTable Sample

var dictList = new List<Dictionary<string, object>> {
	new Dictionary<string, object>
	{
		{"Id", 1},
		{"Name", "Jack"},
		{"Birth", DateTime.Parse("2022-05-01")}
	},
	new Dictionary<string, object>
	{
		{"Id", 2},
		{"Name", "Flash"},
		{"Birth", DateTime.Parse("2022-05-01")}
	}
};

var datatable = dictList.ToDataTable();

string/object Dictionary List Deep to DataTable Sample

var dictList = new List<Dictionary<string, object>> {
	new Dictionary<string, object>
	{
		{"Id", 1},
		{"Name", "Jack"},
		{"Birth", DateTime.Parse("2022-05-01")},
		{"Price", null},
	},
	new Dictionary<string, object>
	{
		{"Id", 2},
		{"Name", "Flash"},
		{"Birth", DateTime.Parse("2022-05-01")},
		{"Price", 123m},
		{"Home", null},
	}
};

var datatable = dictList.DeepToDataTable();

Assert.Equal(typeof(decimal), dt.Columns["Price"]!.DataType);
Assert.Equal(typeof(string), dt.Columns["Home"]!.DataType);