#csharp
这个语法糖挺香！

            try
            {
                // Try cracking the message using the original Crack method
                Crack(message, sessionID);
            }
            // to avoid "Unsupported Message Type" error
            catch (UnsupportedMessageType) when (message.Header.GetString(Tags.MsgType) == "AD")
            {
                Logger.Info("Received TradeCaptureReportRequest.");
            }

#csharp Yes, you can update the contents of list A to match list B without changing the reference of A. You can do this by clearing A and adding all elements of B into A. Here's how you can do it:

// Assuming A and B are lists of the same type
A.Clear();          // Clear all elements from A
A.AddRange(B);      // Add all elements from B to A

This approach keeps the reference of A unchanged, but the content of A will be replaced by the content of B.

#csharp #caller #tips

public void DoProcessing()
{
    TraceMessage("Something happened.");
}

public void TraceMessage(string message,
        [CallerMemberName] string memberName = "",
        [CallerFilePath] string sourceFilePath = "",
        [CallerLineNumber] int sourceLineNumber = 0)
{
    Trace.WriteLine("message: " + message);
    Trace.WriteLine("member name: " + memberName);
    Trace.WriteLine("source file path: " + sourceFilePath);
    Trace.WriteLine("source line number: " + sourceLineNumber);
}

// Sample Output:
//  message: Something happened.
//  member name: DoProcessing
//  source file path: c:\Visual Studio Projects\CallerInfoCS\CallerInfoCS\Form1.cs
//  source line number: 31

That's quite handy, isn't it? Reference

Docs

Attributes interpreted by the compiler: Tracking caller information - C# reference

These attributes instruct the compiler to generate information about the code that calls a member. You use the CallerFilePath, CallerLineNumber, CallerMemberName, and CallerArgumentExpression to provide detailed trace information

#csharp #moq
in C# and Moq, how to mock
Func<BrokerContractTypeEnum, IFixMessageStrategy> strategyFactory?

var mockStrategy = new Mock<IFixMessageStrategy>();

// Set up the mock to return the mockStrategy instance
Func<BrokerContractTypeEnum, IFixMessageStrategy> strategyFactory = 
    new Mock<Func<BrokerContractTypeEnum, IFixMessageStrategy>>()
        .Setup(f => f(It.IsAny<BrokerContractTypeEnum>()))
        .Returns(mockStrategy.Object)
        .Object;

#csharp

builder.Logging.ClearProviders(); 这一行代码的主要作用是清除当前日志记录构建器中所有已注册的日志提供程序。这通常用于在创建新的日志记录配置时，确保不使用默认的日志提供程序。

## 用途

在.NET应用程序中，默认情况下会添加多个日志提供程序，例如控制台、调试、EventSource和EventLog等。这些提供程序会在应用程序运行时记录日志信息。如果开发者希望自定义日志记录的行为或只使用特定的日志提供程序，可以通过调用ClearProviders来移除所有默认的提供程序，然后添加所需的提供程序，例如：

builder.Logging.ClearProviders();
builder.Logging.AddConsole();

在这个示例中，首先清除了所有默认的日志提供程序，然后仅添加了控制台日志记录提供程序。这种做法可以帮助开发者避免日志输出的冗余，并确保只使用特定的日志记录方式，提升日志的管理和可读性12。

Citations:
1 https://learn.microsoft.com/zh-cn/dotnet/core/extensions/logging-providers
2 https://learn.microsoft.com/zh-cn/aspnet/core/fundamentals/logging/?view=aspnetcore-8.0

Docs

日志记录提供程序 - .NET

了解如何在 .NET 应用程序中使用日志记录提供程序 API。

The following c# code splits the clientIds into smaller lists, each containing up to 100 elements.

var listOfClientIdLists = clientIds
    .Select((v, i) => new { Value = v, Index = i })
    .GroupBy(g => g.Index / 100, gi => gi.Value)
    .Select(chunk => chunk.ToList())
    .ToList();

### Explanation

1. Select((v, i) => new { Value = v, Index = i }):

- This uses the Select method with an overload that provides both the element (v) and its index (i).
- It transforms the clientIds collection into a new collection of anonymous objects, each containing:
- Value: the original element (v).
- Index: the position of the element in the original list (i).

2. GroupBy(g => g.Index / 100, gi => gi.Value):

- The GroupBy method organizes the elements into groups.
- g => g.Index / 100: This lambda expression determines the group key by dividing the index by 100. This effectively groups the elements into chunks of 100.
- gi => gi.Value: This specifies that only the Value part of the anonymous object should be included in the groups.

3. Select(chunk => chunk.ToList()):

- This converts each group (or chunk) into a list.

4. ToList():

- This final ToList converts the collection of lists into a list of lists.

### Alternative
Claude.AI suggests a better way to achieve the same goal, which has better simplicity and readability.

var listOfClientIdLists = clientIds
    .Chunk(100)
    .Select(chunk => chunk.ToList())
    .ToList();

#csharp #tips