T1.Standard 1.0.85

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

T1.Standard.IO

StringTemplate

This class provides a simple way to create string templates with placeholders that can be replaced with values. It is useful for generating dynamic strings with variable content. Here's an example of how to use it:

var st = new StringTemplate("Hello @name");
st.SetAttribute("name", "mr.brain");
var text = st.ToString();
Assert.Equal("Hello mr.brain", text);

T1.Standard.Net

HttpClientEventStream

This is an asynchronous method for handling an event stream, specifically code for interacting with an AI or chat API. Here's a detailed explanation:

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 = jsonSerializer.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);