# .NET C# Coding Best Practices (AI Instructions)

You are an expert .NET developer. When generating C# code, strictly follow these rules:

1. **Resource Management**
   - Always wrap `IDisposable` in `using` statements. Never call `.Dispose()` manually unless you must.
   - Use `await using` for `IAsyncDisposable`.

2. **Async & Await**
   - Any I/O operation must be `async`. Never block with `.Result` or `.Wait()`.
   - Use `ValueTask` only in hot paths where allocation matters; otherwise use `Task`.

3. **Exception Handling**
   - Catch specific exceptions, never `Exception` unless at the top-level boundary.
   - Prefer `ArgumentException` / `ArgumentNullException` for parameter validation.

4. **Dependency Injection**
   - Never instantiate services with `new` inside a class; use constructor injection.
   - Register dependencies with the correct lifetime: Singleton, Scoped, Transient.

5. **Naming Conventions**
   - Public methods/properties: PascalCase. Private fields: `_camelCase`.
   - Avoid Hungarian notation or underscores for locals.

6. **Avoid Common Pitfalls**
   - Do not create multiple `HttpClient` instances; use `IHttpClientFactory`.
   - Do not use `DataTable` in new code unless required by legacy; prefer Dapper or EF Core.

7. **Code Structure**
   - Each file should have only one public type (class/interface).
   - Keep methods short (< 30 lines).

Provide code that compiles with .NET 8+ and follows modern C# idioms.

public class UserRepository
{
    private string connectionString;
    public UserRepository(string conn)
    {
        connectionString = conn;
    }
    public List<User> GetUsers()
    {
        SqlConnection conn = new SqlConnection(connectionString);
        conn.Open();
        SqlCommand cmd = new SqlCommand("SELECT * FROM Users", conn);
        SqlDataReader reader = cmd.ExecuteReader();
        List<User> users = new List<User>();
        while(reader.Read())
        {
            users.Add(new User { Id = (int)reader["Id"], Name = reader["Name"].ToString() });
        }
        reader.Close();
        conn.Close();
        return users;
    }
}

public sealed class UserRepository
{
    private readonly string _connectionString;
    private readonly IHttpClientFactory? _httpClientFactory; // 如果不是必须的就不加

    public UserRepository(string connectionString)
    {
        ArgumentNullException.ThrowIfNull(connectionString);
        _connectionString = connectionString;
    }

    public async Task<IReadOnlyList<User>> GetUsersAsync(CancellationToken cancellationToken = default)
    {
        var users = new List<User>();
        await using var connection = new SqlConnection(_connectionString);
        await connection.OpenAsync(cancellationToken);
        
        const string sql = "SELECT Id, Name FROM Users";
        await using var command = new SqlCommand(sql, connection);
        await using var reader = await command.ExecuteReaderAsync(cancellationToken);
        
        while (await reader.ReadAsync(cancellationToken))
        {
            users.Add(new User
            {
                Id = reader.GetInt32(0),
                Name = reader.GetString(1)
            });
        }
        return users.AsReadOnly();
    }
}