# GitHub에서 Fork 버튼 클릭 후

# 내 계정의 Fork된 저장소를 로컬로 클론
git clone https://github.com/your-username/Dapper.git
cd Dapper

# 원본 저장소를 upstream으로 추가
git remote add upstream https://github.com/DapperLib/Dapper.git

# 최신 상태 확인
git fetch upstream
git checkout main
git merge upstream/main

# 의미 있는 이름으로 브랜치 생성
git checkout -b add-xml-docs-sqlmapper

# 이제 코드 작성!
# Visual Studio나 VS Code에서 SqlMapper.cs 파일 열기

/// <summary>
/// Executes a query and returns the result as a dynamic object.
/// </summary>
/// <param name="cnn">The database connection.</param>
/// <param name="sql">The SQL query to execute.</param>
/// <param name="param">The parameters to use in the query.</param>
/// <param name="transaction">The transaction to use, if any.</param>
/// <param name="commandTimeout">The command timeout in seconds.</param>
/// <param name="commandType">The type of command to execute.</param>
/// <returns>A dynamic object containing the query results.</returns>
/// <example>
/// <code>
/// var result = connection.Query("SELECT * FROM Users WHERE Id = @Id", new { Id = 1 });
/// </code>
/// </example>
public static IEnumerable<dynamic> Query(
    this IDbConnection cnn, 
    string sql, 
    object param = null, 
    IDbTransaction transaction = null, 
    int? commandTimeout = null, 
    CommandType? commandType = null)
{
    // 기존 코드...
}

# 프로젝트 빌드
dotnet build

# 테스트 실행
dotnet test

# 특정 테스트만 실행
dotnet test --filter "FullyQualifiedName~SqlMapperTests"

# 변경사항 스테이징
git add .

# 의미 있는 커밋 메시지 작성
git commit -m "docs: Add XML documentation for SqlMapper.Query method

- Added comprehensive XML documentation
- Included parameter descriptions
- Added usage example
- Fixes #1234"

# 원격 저장소에 푸시
git push origin add-xml-docs-sqlmapper

# 피드백을 반영한 코드 수정 후

# 변경사항 커밋
git add .
git commit -m "refactor: Apply code review feedback

- Changed explicit types to var
- Extracted validation logic to separate method
- Improved performance by using for loop instead of LINQ"

# 같은 브랜치에 푸시 (PR이 자동으로 업데이트됨)
git push origin add-xml-docs-sqlmapper

MyAwesomeLibrary/
├── src/
│   └── MyAwesomeLibrary/
│       ├── MyAwesomeLibrary.csproj
│       ├── Extensions/
│       ├── Services/
│       └── Models/
├── tests/
│   └── MyAwesomeLibrary.Tests/
│       ├── MyAwesomeLibrary.Tests.csproj
│       └── UnitTests/
├── samples/
│   └── MyAwesomeLibrary.Sample/
│       └── Program.cs
├── docs/
│   ├── getting-started.md
│   └── api-reference.md
├── .github/
│   ├── workflows/
│   │   ├── ci.yml
│   │   └── release.yml
│   ├── ISSUE_TEMPLATE/
│   └── PULL_REQUEST_TEMPLATE.md
├── .editorconfig
├── .gitignore
├── LICENSE
├── README.md
├── CONTRIBUTING.md
└── CHANGELOG.md

# MyAwesomeLibrary

[![NuGet](https://img.shields.io/nuget/v/MyAwesomeLibrary.svg)](https://www.nuget.org/packages/MyAwesomeLibrary/)
[![Build Status](https://github.com/yourusername/MyAwesomeLibrary/workflows/CI/badge.svg)](https://github.com/yourusername/MyAwesomeLibrary/actions)
[![License](https://img.shields.io/github/license/yourusername/MyAwesomeLibrary)](LICENSE)

A simple and powerful library for doing awesome things in .NET!

## ✨ Features

- 🚀 High performance
- 💡 Easy to use
- 🔧 Highly configurable
- 📦 Zero dependencies

## 📦 Installation

```bash
dotnet add package MyAwesomeLibrary
```

## 🚀 Quick Start

```csharp
using MyAwesomeLibrary;

var service = new AwesomeService();
var result = await service.DoSomethingAwesomeAsync();
```

## 📖 Documentation

For detailed documentation, visit [our wiki](https://github.com/yourusername/MyAwesomeLibrary/wiki).

## 🤝 Contributing

Contributions are welcome! Please read our [Contributing Guide](CONTRIBUTING.md).

## 📄 License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

# Contributing to MyAwesomeLibrary

Thank you for your interest in contributing! 🎉

## Getting Started

1. Fork the repository
2. Clone your fork: `git clone https://github.com/yourusername/MyAwesomeLibrary.git`
3. Create a branch: `git checkout -b feature/my-feature`
4. Make your changes
5. Run tests: `dotnet test`
6. Commit: `git commit -m "feat: add awesome feature"`
7. Push: `git push origin feature/my-feature`
8. Create a Pull Request

## Code Style

- Follow C# coding conventions
- Use meaningful variable names
- Add XML documentation for public APIs
- Write unit tests for new features

## Commit Message Format

We follow [Conventional Commits](https://www.conventionalcommits.org/):

- `feat:` New feature
- `fix:` Bug fix
- `docs:` Documentation changes
- `refactor:` Code refactoring
- `test:` Test additions or changes
- `chore:` Build process or auxiliary tool changes

## Questions?

Feel free to open an issue or reach out to the maintainers!

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
    
    <!-- 패키지 메타데이터 -->
    <PackageId>MyAwesomeLibrary</PackageId>
    <Version>1.0.0</Version>
    <Authors>Your Name</Authors>
    <Company>Your Company</Company>
    <Description>A simple and powerful library for doing awesome things</Description>
    <PackageTags>csharp;dotnet;library;awesome</PackageTags>
    <PackageProjectUrl>https://github.com/yourusername/MyAwesomeLibrary</PackageProjectUrl>
    <RepositoryUrl>https://github.com/yourusername/MyAwesomeLibrary</RepositoryUrl>
    <RepositoryType>git</RepositoryType>
    <PackageLicenseExpression>MIT</PackageLicenseExpression>
    <PackageReadmeFile>README.md</PackageReadmeFile>
    <PackageIcon>icon.png</PackageIcon>
  </PropertyGroup>

  <ItemGroup>
    <None Include="..\..\README.md" Pack="true" PackagePath="\" />
    <None Include="..\..\icon.png" Pack="true" PackagePath="\" />
  </ItemGroup>
</Project>

# 패키지 빌드
dotnet pack -c Release

# NuGet.org에 배포 (API 키 필요)
dotnet nuget push bin/Release/MyAwesomeLibrary.1.0.0.nupkg \
  --api-key YOUR_API_KEY \
  --source https://api.nuget.org/v3/index.json

# 또는 GitHub Packages에 배포
dotnet nuget push bin/Release/MyAwesomeLibrary.1.0.0.nupkg \
  --api-key YOUR_GITHUB_TOKEN \
  --source https://nuget.pkg.github.com/yourusername/index.json

name: CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup .NET
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: 8.0.x
    
    - name: Restore dependencies
      run: dotnet restore
    
    - name: Build
      run: dotnet build --no-restore --configuration Release
    
    - name: Test
      run: dotnet test --no-build --configuration Release --verbosity normal
    
    - name: Pack
      run: dotnet pack --no-build --configuration Release --output ./artifacts
    
    - name: Upload artifacts
      uses: actions/upload-artifact@v3
      with:
        name: nuget-packages
        path: ./artifacts/*.nupkg

name: Release

on:
  release:
    types: [published]

jobs:
  deploy:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup .NET
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: 8.0.x
    
    - name: Build and Pack
      run: |
        dotnet restore
        dotnet build --configuration Release
        dotnet pack --configuration Release --output ./artifacts
    
    - name: Push to NuGet
      run: |
        dotnet nuget push ./artifacts/*.nupkg \
          --api-key ${{ secrets.NUGET_API_KEY }} \
          --source https://api.nuget.org/v3/index.json \
          --skip-duplicate

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
[SimpleJob(warmupCount: 3, iterationCount: 5)]
public class StringConcatenationBenchmark
{
    private const int Iterations = 1000;
    
    [Benchmark(Baseline = true)]
    public string UsingStringConcatenation()
    {
        string result = "";
        for (int i = 0; i < Iterations; i++)
        {
            result += i.ToString();
        }
        return result;
    }
    
    [Benchmark]
    public string UsingStringBuilder()
    {
        var sb = new StringBuilder();
        for (int i = 0; i < Iterations; i++)
        {
            sb.Append(i);
        }
        return sb.ToString();
    }
    
    [Benchmark]
    public string UsingStringCreate()
    {
        return string.Create(Iterations * 4, Iterations, (span, iterations) =>
        {
            int pos = 0;
            for (int i = 0; i < iterations; i++)
            {
                i.TryFormat(span.Slice(pos), out int written);
                pos += written;
            }
        });
    }
}

class Program
{
    static void Main(string[] args)
    {
        var summary = BenchmarkRunner.Run<StringConcatenationBenchmark>();
    }
}

public class HttpClientBuilder
{
    private string _baseUrl;
    private TimeSpan _timeout = TimeSpan.FromSeconds(30);
    private Dictionary<string, string> _headers = new();
    
    public HttpClientBuilder WithBaseUrl(string baseUrl)
    {
        _baseUrl = baseUrl;
        return this;
    }
    
    public HttpClientBuilder WithTimeout(TimeSpan timeout)
    {
        _timeout = timeout;
        return this;
    }
    
    public HttpClientBuilder AddHeader(string key, string value)
    {
        _headers[key] = value;
        return this;
    }
    
    public HttpClient Build()
    {
        var client = new HttpClient
        {
            BaseAddress = new Uri(_baseUrl),
            Timeout = _timeout
        };
        
        foreach (var header in _headers)
        {
            client.DefaultRequestHeaders.Add(header.Key, header.Value);
        }
        
        return client;
    }
}

// 사용 예시
var client = new HttpClientBuilder()
    .WithBaseUrl("https://api.example.com")
    .WithTimeout(TimeSpan.FromSeconds(60))
    .AddHeader("Authorization", "Bearer token")
    .Build();

public interface ICompressionStrategy
{
    byte[] Compress(byte[] data);
    byte[] Decompress(byte[] data);
}

public class GzipCompression : ICompressionStrategy
{
    public byte[] Compress(byte[] data)
    {
        using var output = new MemoryStream();
        using (var gzip = new GZipStream(output, CompressionMode.Compress))
        {
            gzip.Write(data, 0, data.Length);
        }
        return output.ToArray();
    }
    
    public byte[] Decompress(byte[] data)
    {
        using var input = new MemoryStream(data);
        using var output = new MemoryStream();
        using (var gzip = new GZipStream(input, CompressionMode.Decompress))
        {
            gzip.CopyTo(output);
        }
        return output.ToArray();
    }
}

public class FileCompressor
{
    private readonly ICompressionStrategy _strategy;
    
    public FileCompressor(ICompressionStrategy strategy)
    {
        _strategy = strategy;
    }
    
    public void CompressFile(string inputPath, string outputPath)
    {
        var data = File.ReadAllBytes(inputPath);
        var compressed = _strategy.Compress(data);
        File.WriteAllBytes(outputPath, compressed);
    }
}

public interface IRepository<T> where T : class
{
    Task<T> GetByIdAsync(int id);
    Task<IEnumerable<T>> GetAllAsync();
    Task<T> AddAsync(T entity);
    Task UpdateAsync(T entity);
    Task DeleteAsync(int id);
}

public class GenericRepository<T> : IRepository<T> where T : class
{
    private readonly DbContext _context;
    private readonly DbSet<T> _dbSet;
    
    public GenericRepository(DbContext context)
    {
        _context = context;
        _dbSet = context.Set<T>();
    }
    
    public async Task<T> GetByIdAsync(int id)
    {
        return await _dbSet.FindAsync(id);
    }
    
    public async Task<IEnumerable<T>> GetAllAsync()
    {
        return await _dbSet.ToListAsync();
    }
    
    public async Task<T> AddAsync(T entity)
    {
        await _dbSet.AddAsync(entity);
        await _context.SaveChangesAsync();
        return entity;
    }
    
    public async Task UpdateAsync(T entity)
    {
        _dbSet.Update(entity);
        await _context.SaveChangesAsync();
    }
    
    public async Task DeleteAsync(int id)
    {
        var entity = await GetByIdAsync(id);
        if (entity != null)
        {
            _dbSet.Remove(entity);
            await _context.SaveChangesAsync();
        }
    }
}

[Fact]
public void Calculate_WithValidInput_ReturnsCorrectResult()
{
    // Arrange
    var calculator = new Calculator();
    
    // Act
    var result = calculator.Add(2, 3);
    
    // Assert
    Assert.Equal(5, result);
}

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

public class Calculator
{
    public int Add(int a, int b)
    {
        // 오버플로우 체크 추가
        checked
        {
            return a + b;
        }
    }
}

// 추가 테스트
[Fact]
public void Add_WithOverflow_ThrowsOverflowException()
{
    var calculator = new Calculator();
    
    Assert.Throws<OverflowException>(() => 
        calculator.Add(int.MaxValue, 1));
}