C#のコード生成ツールを活用する方法：効率的な開発を実現

Install-Package Microsoft.EntityFrameworkCore
Install-Package Microsoft.EntityFrameworkCore.SqlServer
Install-Package Microsoft.EntityFrameworkCore.Tools

public class MyDbContext : DbContext
{
    public DbSet<MyEntity> MyEntities { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("your_connection_string");
    }
}

Scaffold-DbContext "your_connection_string" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models

Install-Package Microsoft.CodeAnalysis
Install-Package Microsoft.CodeAnalysis.CSharp

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using System;

class Program
{
    static void Main()
    {
        var tree = CSharpSyntaxTree.ParseText(@"class C { void M() { } }");
        var root = tree.GetRoot();
        Console.WriteLine(root.ToFullString());
    }
}

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

public class ApplicationDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("your_connection_string");
    }
}

using (var context = new ApplicationDbContext())
{
    var product = new Product { Name = "Apple", Price = 0.5M };
    context.Products.Add(product);
    context.SaveChanges();
}

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;

var tree = CSharpSyntaxTree.ParseText(@"class C { void M() { } }");
var root = tree.GetRoot();
Console.WriteLine(root.ToFullString());

var method = SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName("void"), "NewMethod")
                          .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
                          .WithBody(SyntaxFactory.Block());

var newClass = root.DescendantNodes().OfType<ClassDeclarationSyntax>().First()
                    .AddMembers(method);

Console.WriteLine(newClass.ToFullString());

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Product>()
                .Property(p => p.Price)
                .HasColumnType("decimal(18,2)");

    base.OnModelCreating(modelBuilder);
}

public interface IProductRepository
{
    IEnumerable<Product> GetAll();
    Product GetById(int id);
    void Add(Product product);
}

public class ProductRepository : IProductRepository
{
    private readonly ApplicationDbContext _context;

    public ProductRepository(ApplicationDbContext context)
    {
        _context = context;
    }

    public IEnumerable<Product> GetAll()
    {
        return _context.Products.ToList();
    }

    public Product GetById(int id)
    {
        return _context.Products.Find(id);
    }

    public void Add(Product product)
    {
        _context.Products.Add(product);
        _context.SaveChanges();
    }
}

public class RenameMethodRewriter : CSharpSyntaxRewriter
{
    public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
    {
        var newName = SyntaxFactory.Identifier("RenamedMethod");
        return node.WithIdentifier(newName);
    }
}

// 使用例
var tree = CSharpSyntaxTree.ParseText(@"class C { void M() { } }");
var rewriter = new RenameMethodRewriter();
var newRoot = rewriter.Visit(tree.GetRoot());
Console.WriteLine(newRoot.ToFullString());

[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class MyAnalyzer : DiagnosticAnalyzer
{
    private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(
        "MY001",
        "Method name should start with capital letter",
        "Method '{0}' does not start with a capital letter",
        "Naming",
        DiagnosticSeverity.Warning,
        isEnabledByDefault: true);

    public override void Initialize(AnalysisContext context)
    {
        context.RegisterSyntaxNodeAction(AnalyzeMethod, SyntaxKind.MethodDeclaration);
    }

    private void AnalyzeMethod(SyntaxNodeAnalysisContext context)
    {
        var methodDeclaration = (MethodDeclarationSyntax)context.Node;
        var methodName = methodDeclaration.Identifier.Text;

        if (char.IsLower(methodName[0]))
        {
            var diagnostic = Diagnostic.Create(Rule, methodDeclaration.Identifier.GetLocation(), methodName);
            context.ReportDiagnostic(diagnostic);
        }
    }
}

<#@ template language="C#" #>
<#@ output extension=".cs" #>
using System;
<# foreach (var table in Tables) { #>
public class <#= table.Name #>
{
    <# foreach (var column in table.Columns) { #>
    public <#= column.Type #> <#= column.Name #> { get; set; }
    <# } #>
}
<# } #>

<#@ template language="C#" #>
<#@ output extension=".cs" #>
<#@ parameter name="Namespace" type="System.String" #>
namespace <#= Namespace #>
{
    public class Example
    {
        public void DoSomething()
        {
            // カスタムロジック
        }
    }
}

// CustomControllerTemplate.cs
public class CustomController : Controller
{
    public IActionResult Index()
    {
        return View();
    }
}

<Options>
    <ContextType>MyApp.Data.ApplicationDbContext</ContextType>
    <Area>Admin</Area>
</Options>

<ProjectTemplate>
    <ProjectType>C#</ProjectType>
    <DefaultName>MyTemplate</DefaultName>
    <Description>Custom project template for rapid setup</Description>
    <Project>
        <!-- Include necessary packages and settings -->
    </Project>
</ProjectTemplate>

# Example for Azure DevOps pipeline
trigger:
- main

pool:
  vmImage: 'windows-latest'

steps:
- task: UseDotNet@2
  inputs:
    packageType: 'sdk'
    version: '5.x'
    installationPath: $(Agent.ToolsDirectory)/dotnet

- script: dotnet build
  displayName: 'Build solution'

- script: dotnet ef dbcontext scaffold "Your_Connection_String" Microsoft.EntityFrameworkCore.SqlServer
  displayName: 'Generate EF Core models'

<!-- Example SonarQube configuration -->
<sonar.sources>src</sonar.sources>
<sonar.exclusions>**/generated/**/*</sonar.exclusions>

// モデルクラス
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
}

// スキャフォールディングで生成されたコントローラー
public class ProductsController : ControllerBase
{
    private readonly ApplicationDbContext _context;

    public ProductsController(ApplicationDbContext context)
    {
        _context = context;
    }

    [HttpGet]
    public async Task<ActionResult<IEnumerable<Product>>> GetProducts()
    {
        return await _context.Products.ToListAsync();
    }

    [HttpPost]
    public async Task<ActionResult<Product>> PostProduct(Product product)
    {
        _context.Products.Add(product);
        await _context.SaveChangesAsync();

        return CreatedAtAction("GetProduct", new { id = product.Id }, product);
    }
}

[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class MethodNameAnalyzer : DiagnosticAnalyzer
{
    private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(
        "MN001",
        "Method name should be in PascalCase",
        "Method '{0}' should be in PascalCase",
        "Naming",
        DiagnosticSeverity.Warning,
        isEnabledByDefault: true);

    public override void Initialize(AnalysisContext context)
    {
        context.RegisterSyntaxNodeAction(AnalyzeMethod, SyntaxKind.MethodDeclaration);
    }

    private void AnalyzeMethod(SyntaxNodeAnalysisContext context)
    {
        var methodDeclaration = (MethodDeclarationSyntax)context.Node;
        var methodName = methodDeclaration.Identifier.Text;

        if (!char.IsUpper(methodName[0]))
        {
            var diagnostic = Diagnostic.Create(Rule, methodDeclaration.Identifier.GetLocation(), methodName);
            context.ReportDiagnostic(diagnostic);
        }
    }
}

<#@ template language="C#" #>
<#@ output extension=".cs" #>
using System;
using System.Collections.Generic;

<# foreach (var table in Tables) { #>
public class <#= table.Name #>
{
    <# foreach (var column in table.Columns) { #>
    public <#= column.Type #> <#= column.Name #> { get; set; }
    <# } #>
}

public class <#= table.Name #>Repository
{
    private readonly ApplicationDbContext _context;

    public <#= table.Name #>Repository(ApplicationDbContext context)
    {
        _context = context;
    }

    public IEnumerable<<#= table.Name #>> GetAll()
    {
        return _context.<#= table.Name #>s.ToList();
    }

    public void Add(<#= table.Name #> entity)
    {
        _context.<#= table.Name #>s.Add(entity);
        _context.SaveChanges();
    }
}
<# } #>

public class OrdersController : ControllerBase
{
    private readonly ApplicationDbContext _context;

    public OrdersController(ApplicationDbContext context)
    {
        _context = context;
    }

    [HttpGet]
    public async Task<ActionResult<IEnumerable<Order>>> GetOrders()
    {
        return await _context.Orders.ToListAsync();
    }

    [HttpPost]
    public async Task<ActionResult<Order>> PostOrder(Order order)
    {
        _context.Orders.Add(order);
        await _context.SaveChangesAsync();

        return CreatedAtAction("GetOrder", new { id = order.Id }, order);
    }
}

<#@ template language="C#" #>
<#@ output extension=".cs" #>
using System;

<# foreach (var table in Tables) { #>
/// <summary>
/// Represents the <#= table.Name #> entity.
/// </summary>
public class <#= table.Name #>
{
    <# foreach (var column in table.Columns) { #>
    /// <summary>
    /// Gets or sets the <#= column.Name #>.
    /// </summary>
    public <#= column.Type #> <#= column.Name #> { get; set; }
    <# } #>
}
<# } #>

// 自動生成された部分
public partial class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
}

// 手動で追加した部分
public partial class Product
{
    public decimal Price { get; set; }
}