C# インターフェース完全ガイド：設計の基礎から実践的な活用まで7つのテクニック

はじめに

C#におけるインターフェースは、堅牢で保守性の高いソフトウェアを設計する上で欠かせない機能です。
本記事では、インターフェースの基本概念から実践的な活用方法まで、実務で即座に活用できる知識を体系的に解説します。

インターフェースとは？使う理由と基本概念

インターフェース（interface）は、C#プログラミングにおける重要な概念の1つで、クラスが実装すべきメンバーを定義する契約のような役割を果たします。
実務では、ECサイトでの決済処理、データベースアクセス、ログ出力など、実装の詳細を抽象化したい場合に特に有効です。

クラスと異なるインターフェースの特徴

1. 実装を持たない

// インターフェースの定義例
public interface ILogger
{
    void Log(string message);    // メソッドの宣言のみ
    LogLevel Level { get; set; } // プロパティの宣言のみ
}

// インターフェースの実装例
public class FileLogger : ILogger
{
    public LogLevel Level { get; set; }

    public void Log(string message)
    {
        // 具体的な実装をここで行う
        File.WriteAllText($"log_{DateTime.Now:yyyyMMdd}.txt", message);
    }
}

// 別の実装例
public class DatabaseLogger : ILogger
{
    public LogLevel Level { get; set; }

    public void Log(string message)
    {
        using var connection = new SqlConnection("connection_string");
        // データベースにログを保存する実装
    }
}

2. 多重継承が可能

public interface IEmailSender
{
    Task SendEmailAsync(string to, string subject, string body);
}

public interface ISMSSender
{
    Task SendSMSAsync(string to, string message);
}

// 複数のインターフェースを実装
public class NotificationService : IEmailSender, ISMSSender
{
    public async Task SendEmailAsync(string to, string subject, string body)
    {
        // メール送信の実装
        await Task.CompletedTask; // 実際の実装ではSMTPクライアントなどを使用
    }

    public async Task SendSMSAsync(string to, string message)
    {
        // SMS送信の実装
        await Task.CompletedTask; // 実際の実装ではSMSサービスのAPIを使用
    }
}

3. フィールドを持てない

なぜインターフェースを使うのか？3つの主要なメリット

1. 疎結合の実現

• コンポーネント間の依存関係を最小限に抑える
• テスト容易性の向上
• 変更に強い設計の実現

// 疎結合の例
public class OrderProcessor
{
    private readonly IPaymentGateway _paymentGateway;
    private readonly ILogger _logger;

    public OrderProcessor(IPaymentGateway paymentGateway, ILogger logger)
    {
        _paymentGateway = paymentGateway;
        _logger = logger;
    }

    public async Task ProcessOrderAsync(Order order)
    {
        try
        {
            // 支払い処理の実行
            await _paymentGateway.ProcessPaymentAsync(order.Amount);
            _logger.Log($"Order {order.Id} processed successfully");
        }
        catch (Exception ex)
        {
            _logger.Log($"Error processing order {order.Id}: {ex.Message}");
            throw;
        }
    }
}

2. 柔軟性と拡張性の向上

• 新しい実装の追加が容易
• 既存コードの変更なしで機能拡張が可能
• プラグイン型アーキテクチャの実現

3. 契約による設計の実現

• インターフェースが明確な契約として機能
• チーム開発での役割分担が明確に
• コードの品質と保守性の向上

// 契約による設計の例
public interface ICustomerRepository
{
    Task<Customer> GetByIdAsync(int id);
    Task<Customer> CreateAsync(Customer customer);
    Task UpdateAsync(Customer customer);
    Task DeleteAsync(int id);
}

// チームメンバーAが実装
public class SqlCustomerRepository : ICustomerRepository
{
    private readonly string _connectionString;

    public SqlCustomerRepository(string connectionString)
    {
        _connectionString = connectionString;
    }

    // SQLデータベースを使用した実装
    public async Task<Customer> GetByIdAsync(int id)
    {
        using var connection = new SqlConnection(_connectionString);
        return await connection.QueryFirstOrDefaultAsync<Customer>(
            "SELECT * FROM Customers WHERE Id = @Id",
            new { Id = id }
        );
    }

    // その他のメソッド実装
}

// チームメンバーBが実装
public class MongoCustomerRepository : ICustomerRepository
{
    private readonly IMongoDatabase _database;

    public MongoCustomerRepository(IMongoDatabase database)
    {
        _database = database;
    }

    // MongoDBを使用した実装
    public async Task<Customer> GetByIdAsync(int id)
    {
        var collection = _database.GetCollection<Customer>("customers");
        return await collection.Find(c => c.Id == id).FirstOrDefaultAsync();
    }

    // その他のメソッド実装
}

インターフェースを適切に活用することで、保守性が高く、拡張性のあるコードを書くことができます。
次のセクションでは、これらのインターフェースを実際にどのように実装していくのかを、より詳しく見ていきましょう。

インターフェースの基本的な実装方法

プログラミングの実践では、インターフェースを正しく実装することが重要です。
このセクションでは、C#でのインターフェースの実装方法を、現代的なプラクティスに基づいて解説していきます。

インターフェースの宣言と実装の基本構文

インターフェースの宣言と実装には、以下のような基本的なルールがあります。

1. インターフェースの宣言

public interface IDataService<T> where T : class
{
    // 非同期メソッドの宣言
    Task<T> GetByIdAsync(int id);
    Task<IEnumerable<T>> GetAllAsync();
    Task<T> CreateAsync(T entity);

    // プロパティの宣言
    bool IsConnected { get; }

    // イベントの宣言
    event EventHandler<DataChangedEventArgs<T>> DataChanged;
}

// イベント引数の定義
public class DataChangedEventArgs<T> : EventArgs
{
    public T Data { get; }
    public ChangeType ChangeType { get; }
    public DateTime Timestamp { get; }

    public DataChangedEventArgs(T data, ChangeType changeType)
    {
        Data = data;
        ChangeType = changeType;
        Timestamp = DateTime.UtcNow;
    }
}

public enum ChangeType
{
    Created,
    Updated,
    Deleted
}

2. ジェネリックインターフェースの実装

public class SqlDataService<T> : IDataService<T> where T : class
{
    private readonly DbContext _context;
    private readonly DbSet<T> _dbSet;
    private bool _isConnected;

    public SqlDataService(DbContext context)
    {
        _context = context;
        _dbSet = context.Set<T>();
        _isConnected = true;
    }

    // プロパティの実装
    public bool IsConnected => _isConnected;

    // イベントの実装
    public event EventHandler<DataChangedEventArgs<T>> DataChanged;

    // 非同期メソッドの実装
    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> CreateAsync(T entity)
    {
        var entry = await _dbSet.AddAsync(entity);
        await _context.SaveChangesAsync();

        // イベントの発火
        OnDataChanged(entity, ChangeType.Created);

        return entry.Entity;
    }

    // イベント発火用の保護メソッド
    protected virtual void OnDataChanged(T data, ChangeType changeType)
    {
        DataChanged?.Invoke(this, new DataChangedEventArgs<T>(data, changeType));
    }
}

複数インターフェースの実装テクニック

複数のインターフェースを実装する際の主要なテクニックを見ていきましょう。

1. 明示的実装を使用した競合解決

public interface IReadableStorage
{
    Task<string> ReadAsync(string key);
}

public interface IWritableStorage
{
    Task WriteAsync(string key, string value);
}

public interface IVersionedStorage
{
    Task<string> ReadAsync(string key, int version);
}

public class FileStorage : IReadableStorage, IWritableStorage, IVersionedStorage
{
    private readonly string _basePath;

    public FileStorage(string basePath)
    {
        _basePath = basePath;
        Directory.CreateDirectory(basePath);
    }

    // IReadableStorageの実装
    async Task<string> IReadableStorage.ReadAsync(string key)
    {
        var path = Path.Combine(_basePath, key);
        return await File.ReadAllTextAsync(path);
    }

    // IWritableStorageの実装
    async Task IWritableStorage.WriteAsync(string key, string value)
    {
        var path = Path.Combine(_basePath, key);
        await File.WriteAllTextAsync(path, value);
    }

    // IVersionedStorageの実装
    async Task<string> IVersionedStorage.ReadAsync(string key, int version)
    {
        var path = Path.Combine(_basePath, $"{key}.{version}");
        return await File.ReadAllTextAsync(path);
    }
}

2. インターフェースの継承を活用した階層的実装

public interface IBaseLogger
{
    Task LogAsync(string message);
}

public interface IAdvancedLogger : IBaseLogger
{
    Task LogWithSeverityAsync(string message, LogSeverity severity);
    Task<IEnumerable<LogEntry>> GetRecentLogsAsync(int count);
}

public class FullLogger : IAdvancedLogger
{
    private readonly List<LogEntry> _logs = new();
    private readonly IConfiguration _configuration;

    public FullLogger(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    public async Task LogAsync(string message)
    {
        await LogWithSeverityAsync(message, LogSeverity.Information);
    }

    public async Task LogWithSeverityAsync(string message, LogSeverity severity)
    {
        var entry = new LogEntry
        {
            Message = message,
            Severity = severity,
            Timestamp = DateTime.UtcNow
        };

        _logs.Add(entry);

        // 設定に基づいてログを永続化
        if (_configuration.GetValue<bool>("PersistLogs"))
        {
            await PersistLogEntryAsync(entry);
        }
    }

    public Task<IEnumerable<LogEntry>> GetRecentLogsAsync(int count)
    {
        return Task.FromResult(
            _logs.OrderByDescending(l => l.Timestamp)
                 .Take(count)
                 .AsEnumerable()
        );
    }

    private async Task PersistLogEntryAsync(LogEntry entry)
    {
        // ログの永続化処理
        await Task.CompletedTask;
    }
}

デフォルト実装の活用方法

C# 8.0以降で導入されたデフォルト実装機能を使用すると、インターフェースにデフォルトの振る舞いを定義できます。

1. 基本的なデフォルト実装

public interface IMetricsCollector
{
    // 基本的なメトリクス収集メソッド
    Task CollectMetricsAsync();

    // デフォルト実装を持つメソッド
    Task<MetricsSummary> GetSummaryAsync() => Task.FromResult(new MetricsSummary
    {
        CollectedAt = DateTime.UtcNow,
        Status = "Default Summary"
    });

    // デフォルト実装を持つプロパティ
    bool IsEnabled { get => true; }
}

// デフォルト実装を使用
public class BasicMetricsCollector : IMetricsCollector
{
    public async Task CollectMetricsAsync()
    {
        // メトリクス収集の基本実装
        await Task.CompletedTask;
    }
    // GetSummaryAsync とIsEnabled はデフォルト実装を使用
}

// デフォルト実装をオーバーライド
public class CustomMetricsCollector : IMetricsCollector
{
    private readonly ILogger<CustomMetricsCollector> _logger;

    public CustomMetricsCollector(ILogger<CustomMetricsCollector> logger)
    {
        _logger = logger;
    }

    public async Task CollectMetricsAsync()
    {
        await Task.CompletedTask;
        _logger.LogInformation("Metrics collected");
    }

    public async Task<MetricsSummary> GetSummaryAsync()
    {
        // カスタムサマリー生成ロジック
        return await Task.FromResult(new MetricsSummary
        {
            CollectedAt = DateTime.UtcNow,
            Status = "Custom Summary"
        });
    }
}

実装時の重要なポイント

1. 非同期処理の一貫した使用
   • 非同期メソッドには必ずAsync接尾辞を付ける
   • Task/ValueTaskの適切な使用
   • 非同期操作のキャンセレーション対応を検討
2. インターフェースの責務の明確化
   • 単一責任の原則に従う
   • 適切な粒度でのインターフェース分割
   • 明確な命名規則の適用
3. エラーハンドリング
   • 適切な例外型の使用
   • 例外の適切な伝播
   • リソースの確実な解放

次のセクションでは、これらの実装テクニックを活用したインターフェース設計のベストプラクティスについて詳しく見ていきましょう。

インターフェース設計のベストプラクティス

優れたインターフェース設計は、保守性の高い堅牢なシステムの基盤となります。
このセクションでは、SOLID原則に基づいた実践的なインターフェース設計の原則とベストプラクティスについて解説します。

インターフェース分離の原則(ISP)の実践

インターフェース分離の原則は、「クライアントは、使用しないメソッドへの依存を強制されるべきではない」という考え方です。
この原則を実践することで、より柔軟で保守性の高いコードを実現できます。

1. 問題のある設計例

// 避けるべき設計：肥大化したインターフェース
public interface IUserService
{
    // ユーザー管理
    Task<User> CreateUserAsync(User user);
    Task<User> GetUserAsync(int userId);
    Task UpdateUserAsync(User user);
    Task DeleteUserAsync(int userId);

    // メール送信
    Task SendWelcomeEmailAsync(string email);
    Task SendPasswordResetEmailAsync(string email);

    // 認証
    Task<bool> ValidateCredentialsAsync(string email, string password);
    Task<string> GeneratePasswordResetTokenAsync(string email);

    // レポート生成
    Task<UserReport> GenerateUserReportAsync(int userId);
    Task<ActivityReport> GenerateActivityReportAsync(DateTime startDate, DateTime endDate);
}

2. 改善された設計例

// ユーザー管理の基本操作
public interface IUserRepository
{
    Task<User> CreateAsync(User user);
    Task<User> GetByIdAsync(int userId);
    Task UpdateAsync(User user);
    Task DeleteAsync(int userId);
}

// メール送信機能
public interface IEmailService
{
    Task SendEmailAsync(string email, string subject, string body);
    Task SendTemplatedEmailAsync(string email, string templateName, object templateData);
}

// ユーザー認証
public interface IAuthenticationService
{
    Task<bool> ValidateCredentialsAsync(string email, string password);
    Task<string> GeneratePasswordResetTokenAsync(string email);
    Task<bool> ValidatePasswordResetTokenAsync(string email, string token);
}

// レポート生成
public interface IReportGenerator<T>
{
    Task<T> GenerateReportAsync(ReportParameters parameters);
}

// 実装例
public class UserService : IUserRepository
{
    private readonly IEmailService _emailService;
    private readonly ILogger<UserService> _logger;
    private readonly DbContext _context;

    public UserService(
        IEmailService emailService,
        ILogger<UserService> logger,
        DbContext context)
    {
        _emailService = emailService;
        _logger = logger;
        _context = context;
    }

    public async Task<User> CreateAsync(User user)
    {
        try
        {
            var entry = await _context.Users.AddAsync(user);
            await _context.SaveChangesAsync();

            await _emailService.SendTemplatedEmailAsync(
                user.Email,
                "WelcomeEmail",
                new { user.Name }
            );

            return entry.Entity;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating user");
            throw;
        }
    }

    // その他のメソッド実装
}

依存性逆転の原則(DIP)とインターフェース

依存性逆転の原則は、「上位モジュールは下位モジュールに依存すべきではない。両者は抽象に依存すべき」という考え方です。

// ドメインレイヤー（中心部）
public interface IOrderRepository
{
    Task<Order> GetByIdAsync(int id);
    Task<Order> CreateAsync(Order order);
    Task UpdateAsync(Order order);
}

// アプリケーションレイヤー（ユースケース）
public class OrderProcessingService
{
    private readonly IOrderRepository _orderRepository;
    private readonly IPaymentProcessor _paymentProcessor;
    private readonly INotificationService _notificationService;

    public OrderProcessingService(
        IOrderRepository orderRepository,
        IPaymentProcessor paymentProcessor,
        INotificationService notificationService)
    {
        _orderRepository = orderRepository;
        _paymentProcessor = paymentProcessor;
        _notificationService = notificationService;
    }

    public async Task<ProcessOrderResult> ProcessOrderAsync(Order order)
    {
        try
        {
            // 注文の保存
            var savedOrder = await _orderRepository.CreateAsync(order);

            // 支払い処理
            var paymentResult = await _paymentProcessor.ProcessPaymentAsync(
                new PaymentRequest
                {
                    OrderId = savedOrder.Id,
                    Amount = savedOrder.TotalAmount,
                    Currency = savedOrder.Currency
                }
            );

            if (paymentResult.Success)
            {
                // 注文ステータスの更新
                savedOrder.Status = OrderStatus.Paid;
                await _orderRepository.UpdateAsync(savedOrder);

                // 通知の送信
                await _notificationService.SendOrderConfirmationAsync(savedOrder);

                return new ProcessOrderResult
                {
                    Success = true,
                    OrderId = savedOrder.Id
                };
            }
            else
            {
                return new ProcessOrderResult
                {
                    Success = false,
                    ErrorMessage = paymentResult.ErrorMessage
                };
            }
        }
        catch (Exception ex)
        {
            return new ProcessOrderResult
            {
                Success = false,
                ErrorMessage = "Order processing failed"
            };
        }
    }
}

命名規則とコーディング規約

1. 命名規則のベストプラクティス

// 良い例：明確な名前と責務
public interface IOrderValidator
{
    Task<ValidationResult> ValidateAsync(Order order);
}

public interface IProductCatalog
{
    Task<Product> GetProductAsync(int productId);
    Task<IEnumerable<Product>> SearchProductsAsync(ProductSearchCriteria criteria);
}

// 避けるべき例：曖昧な名前と責務
public interface IProcessor  // 曖昧すぎる
{
    Task ProcessAsync(object data);  // 汎用的すぎる
}

public interface IHandler   // 具体性に欠ける
{
    void Handle(string input);
}

2. インターフェース設計の規約

// 良い例：一貫性のある抽象化レベル
public interface IDocumentProcessor
{
    Task<ProcessingResult> ProcessDocumentAsync(Document document);
    Task<ValidationResult> ValidateDocumentAsync(Document document);
    Task<DocumentMetadata> ExtractMetadataAsync(Document document);
}

// 良い例：イベントを含むインターフェース
public interface IDocumentStorage
{
    Task<Document> SaveAsync(Document document);
    Task<Document> GetByIdAsync(string documentId);

    // イベント
    event EventHandler<DocumentChangedEventArgs> DocumentChanged;
    event EventHandler<DocumentDeletedEventArgs> DocumentDeleted;
}

// 避けるべき例：抽象化レベルが不統一
public interface IDocumentHandler
{
    Task<Document> ProcessDocumentAsync(Document document);
    byte[] ConvertToPdf();  // 具体的すぎる
    void SaveToDatabase();  // インフラストラクチャの責務が混入
}

実装時の重要なガイドライン

1. インターフェースの責務
   • 単一の目的に焦点を当てる
   • ビジネスドメインの用語を使用
   • 実装の詳細を抽象化
2. メソッドの設計
   • 非同期メソッドには必ずAsync接尾辞を付ける
   • パラメータは明確で型安全なものにする
   • 戻り値の型は具体的に指定
3. バージョニング
   • 既存のインターフェースは変更しない
   • 新機能は新しいインターフェースとして追加
   • 後方互換性を維持

これらの原則とベストプラクティスを適用することで、より保守性が高く、拡張しやすいシステムを設計することができます。
次のセクションでは、これらの原則を活用した実践的な実装テクニックについて見ていきましょう。

実践的なインターフェース活用テクニック

このセクションでは、実務でのインターフェース活用について、具体的な実装例とともに解説します。
依存性注入（DI）、テスト、プラグインアーキテクチャなど、実践的なテクニックを詳しく見ていきましょう。

依存性注入(DI)におけるインターフェースの役割

依存性注入は、コンポーネント間の結合度を下げ、テスト容易性を高めるための重要な手法です。

1. DIコンテナの設定と登録

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // トランジェントサービス（都度インスタンス生成）
        services.AddTransient<IOrderValidator, OrderValidator>();

        // スコープ付きサービス（リクエストスコープ内で共有）
        services.AddScoped<IOrderRepository, SqlOrderRepository>();
        services.AddScoped<ICustomerRepository, SqlCustomerRepository>();

        // シングルトンサービス（アプリケーション全体で共有）
        services.AddSingleton<ICacheService, RedisCacheService>();

        // 条件付き登録
        services.AddScoped<IPaymentProcessor>(sp =>
        {
            var configuration = sp.GetRequiredService<IConfiguration>();
            return configuration["PaymentProvider"] switch
            {
                "Stripe" => new StripePaymentProcessor(configuration),
                "PayPal" => new PayPalPaymentProcessor(configuration),
                _ => throw new InvalidOperationException("Invalid payment provider")
            };
        });

        // デコレーターパターンの登録
        services.AddScoped<IOrderProcessor, OrderProcessor>();
        services.Decorate<IOrderProcessor, OrderProcessorWithLogging>();
        services.Decorate<IOrderProcessor, OrderProcessorWithValidation>();
    }
}

2. DIを活用したサービスの実装

public interface IOrderProcessor
{
    Task<OrderResult> ProcessOrderAsync(Order order);
}

public class OrderProcessor : IOrderProcessor
{
    private readonly IOrderRepository _orderRepository;
    private readonly IPaymentProcessor _paymentProcessor;
    private readonly INotificationService _notificationService;
    private readonly ILogger<OrderProcessor> _logger;

    public OrderProcessor(
        IOrderRepository orderRepository,
        IPaymentProcessor paymentProcessor,
        INotificationService notificationService,
        ILogger<OrderProcessor> logger)
    {
        _orderRepository = orderRepository;
        _paymentProcessor = paymentProcessor;
        _notificationService = notificationService;
        _logger = logger;
    }

    public async Task<OrderResult> ProcessOrderAsync(Order order)
    {
        try
        {
            _logger.LogInformation("Processing order {OrderId}", order.Id);

            // 注文の保存
            await _orderRepository.SaveAsync(order);

            // 支払い処理
            var paymentResult = await _paymentProcessor.ProcessPaymentAsync(
                new PaymentRequest(order));

            if (paymentResult.Success)
            {
                order.Status = OrderStatus.Paid;
                await _orderRepository.UpdateAsync(order);

                // 非同期で通知を送信
                _ = _notificationService.SendOrderConfirmationAsync(order);

                return OrderResult.Success(order.Id);
            }

            return OrderResult.Failure(paymentResult.ErrorMessage);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to process order {OrderId}", order.Id);
            return OrderResult.Failure("Order processing failed");
        }
    }
}

モックを使用したユニットテストの実装

インターフェースを活用することで、依存コンポーネントのモック化が容易になり、効果的なユニットテストが実現できます。

1. xUnit と Moq を使用したテスト実装

public class OrderProcessorTests
{
    private readonly Mock<IOrderRepository> _orderRepositoryMock;
    private readonly Mock<IPaymentProcessor> _paymentProcessorMock;
    private readonly Mock<INotificationService> _notificationServiceMock;
    private readonly Mock<ILogger<OrderProcessor>> _loggerMock;
    private readonly OrderProcessor _processor;

    public OrderProcessorTests()
    {
        _orderRepositoryMock = new Mock<IOrderRepository>();
        _paymentProcessorMock = new Mock<IPaymentProcessor>();
        _notificationServiceMock = new Mock<INotificationService>();
        _loggerMock = new Mock<ILogger<OrderProcessor>>();

        _processor = new OrderProcessor(
            _orderRepositoryMock.Object,
            _paymentProcessorMock.Object,
            _notificationServiceMock.Object,
            _loggerMock.Object);
    }

    [Fact]
    public async Task ProcessOrder_WhenPaymentSucceeds_UpdatesOrderAndSendsNotification()
    {
        // Arrange
        var order = new Order { Id = 1, Status = OrderStatus.Created };
        var paymentRequest = new PaymentRequest(order);
        var paymentResult = PaymentResult.Success();

        _paymentProcessorMock
            .Setup(p => p.ProcessPaymentAsync(It.IsAny<PaymentRequest>()))
            .ReturnsAsync(paymentResult);

        // Act
        var result = await _processor.ProcessOrderAsync(order);

        // Assert
        Assert.True(result.Success);
        Assert.Equal(order.Id, result.OrderId);

        _orderRepositoryMock.Verify(
            r => r.UpdateAsync(It.Is<Order>(o => 
                o.Id == order.Id && 
                o.Status == OrderStatus.Paid)),
            Times.Once);

        _notificationServiceMock.Verify(
            n => n.SendOrderConfirmationAsync(order),
            Times.Once);
    }

    [Fact]
    public async Task ProcessOrder_WhenPaymentFails_DoesNotUpdateOrder()
    {
        // Arrange
        var order = new Order { Id = 1, Status = OrderStatus.Created };
        var errorMessage = "Insufficient funds";

        _paymentProcessorMock
            .Setup(p => p.ProcessPaymentAsync(It.IsAny<PaymentRequest>()))
            .ReturnsAsync(PaymentResult.Failure(errorMessage));

        // Act
        var result = await _processor.ProcessOrderAsync(order);

        // Assert
        Assert.False(result.Success);
        Assert.Equal(errorMessage, result.ErrorMessage);

        _orderRepositoryMock.Verify(
            r => r.UpdateAsync(It.IsAny<Order>()),
            Times.Never);

        _notificationServiceMock.Verify(
            n => n.SendOrderConfirmationAsync(It.IsAny<Order>()),
            Times.Never);
    }
}

プラグインアーキテクチャの実現方法

インターフェースを活用することで、柔軟なプラグインアーキテクチャを実現できます。

1. プラグインシステムの基本構造

public interface IPlugin
{
    string Name { get; }
    string Version { get; }
    Task InitializeAsync();
    Task ExecuteAsync();
    Task ShutdownAsync();
}

public interface IPluginMetadata
{
    string Name { get; }
    string Version { get; }
    string Description { get; }
    IReadOnlyCollection<string> Dependencies { get; }
}

public interface IPluginManager
{
    Task LoadPluginAsync(string pluginPath);
    Task UnloadPluginAsync(string pluginName);
    Task<IPlugin> GetPluginAsync(string name);
    IReadOnlyCollection<IPluginMetadata> GetLoadedPlugins();
}

2. プラグインマネージャーの実装

public class PluginManager : IPluginManager
{
    private readonly Dictionary<string, IPlugin> _plugins = new();
    private readonly ILogger<PluginManager> _logger;
    private readonly IConfiguration _configuration;

    public PluginManager(
        ILogger<PluginManager> logger,
        IConfiguration configuration)
    {
        _logger = logger;
        _configuration = configuration;
    }

    public async Task LoadPluginAsync(string pluginPath)
    {
        try
        {
            // アセンブリのロード
            var assembly = Assembly.LoadFrom(pluginPath);

            // プラグイン型の検索
            var pluginTypes = assembly.GetTypes()
                .Where(t => typeof(IPlugin).IsAssignableFrom(t) && !t.IsInterface);

            foreach (var pluginType in pluginTypes)
            {
                // プラグインのインスタンス化
                if (Activator.CreateInstance(pluginType) is IPlugin plugin)
                {
                    await InitializePluginAsync(plugin);
                    _plugins[plugin.Name] = plugin;

                    _logger.LogInformation(
                        "Loaded plugin: {Name} v{Version}",
                        plugin.Name,
                        plugin.Version);
                }
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to load plugin from {Path}", pluginPath);
            throw;
        }
    }

    private async Task InitializePluginAsync(IPlugin plugin)
    {
        try
        {
            await plugin.InitializeAsync();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to initialize plugin {Name}", plugin.Name);
            throw;
        }
    }

    // その他のメソッド実装
}

これらのテクニックを適切に組み合わせることで、保守性が高く、拡張性のあるアプリケーションを構築することができます。
次のセクションでは、よく使用されるインターフェースの実装パターンについて詳しく見ていきましょう。

よくあるインターフェースの実装パターン

実務でのインターフェース活用では、確立されたデザインパターンを適切に適用することが重要です。
このセクションでは、一般的なデザインパターンのインターフェースを使用した実装方法を解説します。

リポジトリパターンでのインターフェース活用

リポジトリパターンは、データアクセス層を抽象化し、ビジネスロジックを分離するために広く使用されます。

1. ジェネリックリポジトリパターンの実装

public interface IRepository<TEntity, TKey> where TEntity : class
{
    Task<TEntity> GetByIdAsync(TKey id);
    Task<IReadOnlyList<TEntity>> GetAllAsync();
    Task<IReadOnlyList<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate);
    Task<TEntity> AddAsync(TEntity entity);
    Task UpdateAsync(TEntity entity);
    Task DeleteAsync(TKey id);
}

public interface IUnitOfWork : IDisposable
{
    Task<int> SaveChangesAsync();
    Task BeginTransactionAsync();
    Task CommitAsync();
    Task RollbackAsync();
}

// 具体的なリポジトリの実装
public class EntityFrameworkRepository<TEntity, TKey> : IRepository<TEntity, TKey>
    where TEntity : class
{
    protected readonly DbContext _context;
    protected readonly DbSet<TEntity> _dbSet;
    private readonly ILogger<EntityFrameworkRepository<TEntity, TKey>> _logger;

    public EntityFrameworkRepository(
        DbContext context,
        ILogger<EntityFrameworkRepository<TEntity, TKey>> logger)
    {
        _context = context;
        _dbSet = context.Set<TEntity>();
        _logger = logger;
    }

    public virtual async Task<TEntity> GetByIdAsync(TKey id)
    {
        try
        {
            return await _dbSet.FindAsync(id);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error getting entity with ID {Id}", id);
            throw;
        }
    }

    public virtual async Task<IReadOnlyList<TEntity>> FindAsync(
        Expression<Func<TEntity, bool>> predicate)
    {
        try
        {
            return await _dbSet.Where(predicate).ToListAsync();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error finding entities with predicate");
            throw;
        }
    }

    // その他のメソッド実装
}

// Unit of Workの実装
public class EntityFrameworkUnitOfWork : IUnitOfWork
{
    private readonly DbContext _context;
    private IDbContextTransaction _transaction;

    public EntityFrameworkUnitOfWork(DbContext context)
    {
        _context = context;
    }

    public async Task BeginTransactionAsync()
    {
        _transaction = await _context.Database.BeginTransactionAsync();
    }

    public async Task CommitAsync()
    {
        try
        {
            await _context.SaveChangesAsync();
            await _transaction?.CommitAsync();
        }
        catch
        {
            await RollbackAsync();
            throw;
        }
    }

    // その他のメソッド実装
}

Strategyパターンの実装例

Strategyパターンは、アルゴリズムの切り替えを容易にする設計パターンです。

1. 割引計算のStrategy実装

public interface IDiscountStrategy
{
    Task<decimal> CalculateDiscountAsync(Order order);
    bool IsApplicable(Order order);
}

public class PercentageDiscountStrategy : IDiscountStrategy
{
    private readonly decimal _percentage;
    private readonly decimal _minimumOrderAmount;

    public PercentageDiscountStrategy(decimal percentage, decimal minimumOrderAmount)
    {
        _percentage = percentage;
        _minimumOrderAmount = minimumOrderAmount;
    }

    public Task<decimal> CalculateDiscountAsync(Order order)
    {
        return Task.FromResult(order.TotalAmount * (_percentage / 100));
    }

    public bool IsApplicable(Order order)
    {
        return order.TotalAmount >= _minimumOrderAmount;
    }
}

public class BulkDiscountStrategy : IDiscountStrategy
{
    private readonly int _minimumItems;
    private readonly decimal _discountPerItem;

    public BulkDiscountStrategy(int minimumItems, decimal discountPerItem)
    {
        _minimumItems = minimumItems;
        _discountPerItem = discountPerItem;
    }

    public Task<decimal> CalculateDiscountAsync(Order order)
    {
        return Task.FromResult(order.ItemCount * _discountPerItem);
    }

    public bool IsApplicable(Order order)
    {
        return order.ItemCount >= _minimumItems;
    }
}

// Strategyの使用
public class OrderProcessor
{
    private readonly IEnumerable<IDiscountStrategy> _discountStrategies;
    private readonly ILogger<OrderProcessor> _logger;

    public OrderProcessor(
        IEnumerable<IDiscountStrategy> discountStrategies,
        ILogger<OrderProcessor> logger)
    {
        _discountStrategies = discountStrategies;
        _logger = logger;
    }

    public async Task<decimal> CalculateFinalAmountAsync(Order order)
    {
        decimal totalDiscount = 0;

        foreach (var strategy in _discountStrategies)
        {
            if (strategy.IsApplicable(order))
            {
                var discount = await strategy.CalculateDiscountAsync(order);
                totalDiscount += discount;

                _logger.LogInformation(
                    "Applied discount of {Discount} using {Strategy}",
                    discount,
                    strategy.GetType().Name);
            }
        }

        return order.TotalAmount - totalDiscount;
    }
}

Observerパターンでのイベント処理

Observerパターンは、オブジェクト間の1対多の依存関係を定義するのに適しています。

1. イベントベースの注文処理システム