依存性注入（Dependency Injection、DI）は、オブジェクト指向プログラミングで重要な設計パターンの一つです。特に、Swiftのような強力な言語では、依存性注入を効果的に活用することで、コードの拡張性やテストの容易さを大幅に向上させることができます。この記事では、Swiftでプロトコルを用いた依存性注入の実装方法を詳細に解説します。プロトコルを利用することで、疎結合な設計を実現し、システム全体の柔軟性を高めることができます。本記事では、依存性注入の基本から、具体的な実装例、テストや応用例に至るまで、実践的な内容を紹介します。
依存性注入とは何か
依存性注入（Dependency Injection、DI）とは、クラスやオブジェクトがその依存関係を自ら作成するのではなく、外部から提供してもらう設計パターンのことを指します。このパターンは、コードのモジュール化を促進し、疎結合な設計を実現するために役立ちます。
依存性注入のメリット
依存性注入には、以下のような主なメリットがあります。
1. 保守性の向上
依存関係を外部から注入することで、クラスが特定の実装に依存しなくなり、柔軟に変更可能になります。これにより、コードの保守がしやすくなります。
2. テストの容易化
テストコードにおいて、依存関係をモックやスタブに置き換えることで、クラス単体でのテストが可能になります。これにより、バグを早期に発見できるようになります。
3. 再利用性の向上
依存性注入を適用すると、オブジェクト同士の結びつきが緩くなるため、コードの再利用が容易になります。
依存性注入は、特に大規模なプロジェクトやチーム開発において、その有効性が高まる設計パターンです。
Swiftにおける依存性注入の重要性
Swiftはモダンな言語で、シンプルかつ効率的にコーディングできる一方で、プロジェクトが複雑になるにつれて依存関係が増え、管理が難しくなることがあります。このような状況では、依存性注入（DI）が重要な役割を果たします。
柔軟性の向上
依存性注入を利用することで、クラスの依存関係が外部から渡されるため、クラスが特定の実装に強く依存しなくなります。これにより、依存する実装を簡単に差し替えたり、変更したりすることが可能となり、柔軟性が大幅に向上します。
疎結合な設計の実現
依存性注入を使えば、オブジェクト同士の結びつきを緩やかに保つことができ、システム全体の構造がシンプルかつ理解しやすくなります。これにより、プロジェクトの規模が大きくなった場合でも、コードの管理がしやすくなります。
テスト容易性
Swiftのような型安全な言語では、テストを容易に行える環境が整っています。依存性注入を活用すると、依存するコンポーネントをモックに置き換えることで、個別のクラスや機能を効率よくテストすることが可能となり、バグを早期に発見することができます。
依存性注入は、コードの柔軟性、保守性、テストの効率を向上させるため、Swiftでの開発において非常に重要です。
プロトコルの役割
Swiftで依存性注入を実装する際、プロトコルは重要な役割を果たします。プロトコルを使うことで、依存するオブジェクトが具体的なクラスに依存することなく、共通のインターフェースを通じて操作できるようになります。これにより、依存関係が柔軟になり、クラス同士の結合度を低く抑えることができます。
プロトコルとは
Swiftのプロトコルは、特定の機能を実装するためのインターフェースを定義するもので、クラスや構造体、列挙型がこのプロトコルに準拠することで、共通のメソッドやプロパティを持つことが保証されます。依存性注入においては、依存関係を抽象化するためにプロトコルを使用します。
プロトコルを使った依存関係の注入
依存性注入では、特定のクラスや構造体が直接他のクラスに依存するのではなく、プロトコルを通して依存関係を注入します。例えば、あるクラスがデータを取得する役割を果たす場合、そのクラスに具体的なAPIクライアントを注入するのではなく、データ取得機能を定義したプロトコルを注入することで、複数の実装を切り替え可能にします。
依存性注入を容易にする理由
プロトコルを使った依存性注入の最大の利点は、クラスが具体的な実装に縛られることなく、柔軟に異なる実装を受け取れる点です。これにより、プロジェクトが拡大しても、依存関係の変更や差し替えが容易になり、テストやメンテナンスが効率化されます。
プロトコルを使った依存性注入の基本的な実装
Swiftでプロトコルを利用した依存性注入は、具体的な実装と依存関係を抽象化し、プロトコルを通じて外部から必要な依存を注入する形で行います。ここでは、シンプルな例を通じて、依存性注入の実装方法を解説します。
ステップ1: プロトコルの定義
まず、依存関係となる機能を持つプロトコルを定義します。このプロトコルは、依存するクラスが必要とするメソッドやプロパティを定義します。
protocol DataService {
func fetchData() -> String
}ここでは、DataServiceというプロトコルを定義し、fetchDataというデータを取得するメソッドを用意しています。このプロトコルに準拠した任意のクラスが依存性として注入可能になります。
ステップ2: 具体的なクラスの実装
次に、このプロトコルに準拠した具体的なクラスを作成します。このクラスが依存関係として注入される実体となります。
class APIService: DataService {
func fetchData() -> String {
return "APIから取得したデータ"
}
}この例では、APIServiceがDataServiceプロトコルに準拠し、fetchDataメソッドを実装しています。将来的にこのクラスを他の実装に置き換えることも容易です。
ステップ3: クラスに依存関係を注入する
最後に、依存性注入を行うクラスに、先ほどのDataServiceプロトコルを介して依存を注入します。
class DataManager {
let service: DataService
init(service: DataService) {
self.service = service
}
func displayData() {
print(service.fetchData())
}
}DataManagerクラスはDataServiceプロトコルに依存していますが、具体的なAPIServiceクラスには依存していません。外部からDataServiceプロトコルに準拠した任意のクラスを注入することで、異なるデータ取得手段を柔軟に利用できます。
ステップ4: インスタンスの生成と依存関係の注入
実際に依存性を注入する場合は、次のようにAPIServiceをDataManagerに注入します。
let apiService = APIService()
let dataManager = DataManager(service: apiService)
dataManager.displayData()ここではAPIServiceをインスタンス化し、それをDataManagerに注入しています。これにより、DataManagerはAPIServiceを使ってデータを取得し、依存性注入が成立します。
まとめ
プロトコルを利用した依存性注入は、コードの柔軟性を大幅に向上させる強力な手法です。具体的なクラスに依存することなく、プロトコルを介して異なる実装を柔軟に差し替えることができ、テストやメンテナンスの効率が向上します。
依存性注入を使う際の注意点
依存性注入はコードの柔軟性やテストのしやすさを向上させる強力な手法ですが、正しく実装しなければ、逆に複雑さを増してしまうことがあります。ここでは、依存性注入を導入する際に注意すべき点について解説します。
依存関係の過剰な増加
依存性注入を多用しすぎると、システム全体の依存関係が複雑になりすぎる危険性があります。特に大規模なプロジェクトでは、注入すべき依存関係が増えすぎて管理が困難になる場合があります。これを避けるためには、依存関係を適切に分離し、必要最小限に抑えることが重要です。
設計の複雑化
依存性注入を正しく利用するためには、プロトコルやインターフェースを多く設計する必要があり、その結果としてコードの可読性や理解が難しくなることがあります。特にチーム開発においては、チームメンバー全員がこの設計パターンを理解していないと、コードが無駄に複雑になりがちです。
パフォーマンスへの影響
依存性注入を通じて動的に依存関係を注入する場合、オブジェクトの生成や依存関係の解決に時間がかかることがあります。特に、大量の依存関係を動的に管理する場合、パフォーマンスに悪影響を及ぼす可能性があるため、必要に応じて最適化を行うことが求められます。
テストの準備不足
依存性注入を利用すればテストは容易になりますが、モックやスタブを使ったテスト環境の準備が整っていない場合、逆にテストが煩雑になることもあります。依存性注入を採用する際には、テスト戦略を事前に計画しておくことが重要です。
依存関係のサイクル
依存関係が循環してしまう、いわゆる「依存関係のサイクル」が発生するリスクもあります。これは、あるクラスが他のクラスに依存し、そのクラスがさらに元のクラスに依存する場合に起こります。このような依存関係のサイクルは、バグの原因や、パフォーマンスの低下につながるため、設計段階で注意が必要です。
依存関係の適切な注入方法を選ぶ
依存性注入には、コンストラクタインジェクション、プロパティインジェクション、メソッドインジェクションなど、いくつかの方法があります。プロジェクトの特性や依存関係の数に応じて、最適な注入方法を選ぶことが重要です。
依存性注入は適切に使えば強力な設計手法ですが、過剰な使用や設計ミスにより複雑化するリスクも伴います。そのため、慎重に設計し、テストやパフォーマンスの問題にも十分配慮することが成功のカギとなります。
依存性注入の応用例
依存性注入は、さまざまな状況で活用できる柔軟な設計パターンです。ここでは、実際のプロジェクトでの応用例をいくつか紹介し、依存性注入がどのようにシステム設計に役立つかを具体的に見ていきます。
1. ネットワーク層の抽象化
ネットワーク通信は、アプリケーションの多くの部分に依存する重要な機能ですが、特定のネットワークライブラリに依存することなく、柔軟に通信方法を変更できることが望ましいです。依存性注入を使えば、ネットワーク層を抽象化し、異なるネットワークライブラリやモックサーバーに簡単に切り替えることができます。
protocol NetworkService {
func fetchData(from url: URL) -> Data?
}
class APIClient: NetworkService {
func fetchData(from url: URL) -> Data? {
// 実際のネットワーク通信
}
}
class DataManager {
let networkService: NetworkService
init(networkService: NetworkService) {
self.networkService = networkService
}
func getData() {
let url = URL(string: "https://example.com/data")!
let data = networkService.fetchData(from: url)
// データ処理
}
}この例では、NetworkServiceプロトコルに準拠したAPIClientを依存性注入によりDataManagerに提供しています。これにより、ネットワークライブラリの変更やテスト時のモック化が容易になります。
2. ロギングシステムの切り替え
ロギング機能は、開発中や運用時に重要な情報を記録するためのものです。依存性注入を利用すれば、開発環境と本番環境で異なるロギングシステムを使うことができるようになります。
protocol Logger {
func log(_ message: String)
}
class ConsoleLogger: Logger {
func log(_ message: String) {
print("Log: \(message)")
}
}
class FileLogger: Logger {
func log(_ message: String) {
// ファイルにログを書き込む処理
}
}
class Application {
let logger: Logger
init(logger: Logger) {
self.logger = logger
}
func run() {
logger.log("アプリケーションが起動しました")
}
}ここでは、Loggerプロトコルを用いることで、開発環境ではConsoleLoggerを使用し、本番環境ではFileLoggerに簡単に切り替えることができます。依存性注入により、コードを変更することなく異なるロギングシステムを切り替えられるのが大きなメリットです。
3. テスト環境でのモック化
テストコードを書く際には、外部リソースに依存することを避けるため、依存関係をモックに置き換えることが多くあります。依存性注入を使用すれば、簡単にモックを注入し、実際のデータベースやAPIにアクセスせずにテストを行うことができます。
class MockNetworkService: NetworkService {
func fetchData(from url: URL) -> Data? {
return "Mock Data".data(using: .utf8)
}
}
// テストコード内でモックを注入
let mockService = MockNetworkService()
let dataManager = DataManager(networkService: mockService)
dataManager.getData()このように、テスト環境ではMockNetworkServiceを注入することで、外部APIに依存せずにデータを取得し、テストのスピードと信頼性を向上させることができます。
4. アプリケーションのテーマ切り替え
ユーザーインターフェースのテーマ（ダークモードやライトモードなど）を動的に切り替えるために依存性注入を使用することも可能です。依存性注入を活用することで、アプリ全体の外観やスタイルを簡単に切り替えることができます。
protocol Theme {
var backgroundColor: UIColor { get }
}
class LightTheme: Theme {
var backgroundColor: UIColor {
return .white
}
}
class DarkTheme: Theme {
var backgroundColor: UIColor {
return .black
}
}
class ViewController: UIViewController {
let theme: Theme
init(theme: Theme) {
self.theme = theme
super.init(nibName: nil, bundle: nil)
}
override func viewDidLoad() {
super.viewDidLoad()
view.backgroundColor = theme.backgroundColor
}
}この例では、Themeプロトコルを使用し、LightThemeやDarkThemeを依存性注入で切り替えることができます。これにより、ユーザーインターフェースを簡単に変更でき、ユーザーの好みに合わせた体験を提供できます。
まとめ
依存性注入は、ネットワーク通信やロギングシステム、テストのモック化、さらにはアプリケーションのテーマ切り替えなど、さまざまな場面で活用できます。この柔軟な設計パターンを導入することで、システムの保守性や拡張性を高めるだけでなく、開発プロセス全体を効率化できます。
依存性注入とテストの関係
依存性注入（DI）は、テスト駆動開発（TDD）や単体テストを行う際に、特に強力なツールとして機能します。クラスやモジュールが直接他のクラスやライブラリに依存している場合、テストが難しくなることがありますが、依存性注入を活用することで、依存関係をテスト用に簡単に置き換え、柔軟なテストを実施することが可能です。
依存性注入がテストを容易にする理由
依存性注入の主な利点は、クラスが具象クラスではなくプロトコルやインターフェースに依存することで、テスト時にモックやスタブといったテスト用の実装に簡単に置き換えられる点です。これにより、外部リソースやネットワークなど、実環境に依存しないテストが可能になります。
モックやスタブの利用
依存性注入を利用すると、テストのために依存するクラスをモックに置き換え、テストの挙動をコントロールできます。これにより、テストが高速で信頼性の高いものとなり、外部の影響を受けにくくなります。
// モックオブジェクトの例
class MockNetworkService: NetworkService {
func fetchData(from url: URL) -> Data? {
return "Mock Data".data(using: .utf8)
}
}
// テストクラスでモックを注入
let mockService = MockNetworkService()
let dataManager = DataManager(networkService: mockService)
// テスト用メソッド
dataManager.getData()この例では、MockNetworkServiceを使用してネットワーク依存をモックに置き換えています。実際のAPIに接続せずに、テスト用のデータを使用してクラスの振る舞いを確認することができます。
ユニットテストでの依存性注入
依存性注入を活用すると、各ユニット（モジュールやクラス）を独立してテストできるため、テストの範囲を明確に保ちながら、モジュール間の結合を排除できます。依存するクラスがモックであれば、例えばネットワークエラーや異常系のテストもシミュレート可能です。
class MockFailingNetworkService: NetworkService {
func fetchData(from url: URL) -> Data? {
return nil // 常にエラーを返す
}
}
// エラー時のテストを実行
let failingService = MockFailingNetworkService()
let dataManagerWithError = DataManager(networkService: failingService)
dataManagerWithError.getData() // エラーをシミュレートしてテストこのように、モックオブジェクトを使って、エラーハンドリングや例外処理のテストも簡単に行えるようになります。
依存性注入を利用したテストの具体的な効果
依存性注入を使ったテストには、以下のような具体的なメリットがあります。
1. 独立したユニットテストの実施
依存関係が注入されるため、テスト対象のクラスやメソッドを、他のモジュールから独立してテストできます。これにより、単一責任の原則を守りながら、コードのバグを早期に発見できます。
2. テスト範囲の柔軟性
依存関係を簡単に切り替えられるため、同じクラスに対して複数のシナリオ（成功・失敗ケースなど）をテストするのが容易になります。また、モックオブジェクトを使うことで、テスト実行速度を大幅に向上させることができます。
3. 継続的インテグレーションでの有効性
依存性注入を使ったテストは、CI（継続的インテグレーション）環境でも効果的です。ネットワークや外部APIへの依存をなくすことで、テストの信頼性が高まり、ビルドプロセスが高速かつ確実になります。
テストにおける依存性注入のベストプラクティス
依存性注入をテストで活用する際は、次のベストプラクティスを考慮してください。
1. モックとスタブの適切な活用
依存関係をモックに置き換えることで、ユニットテストを効率化しますが、テスト対象の動作をシンプルに保つため、モックやスタブのロジックを過剰に複雑にしないようにすることが重要です。
2. テスト対象のクラスが少数の依存関係を持つように設計
依存性注入を多用しすぎると、テストが複雑化する可能性があります。依存関係の数を減らし、単一責任の原則に基づいた設計を心がけることで、テストが管理しやすくなります。
3. 自動化されたテストフレームワークの利用
依存性注入を利用する際には、テストフレームワーク（例えば、XCTest）を活用し、テストコードを自動化することで、テストの再現性と実行効率を最大限に引き出すことができます。
まとめ
依存性注入は、テストの効率化や信頼性向上に大きく貢献する手法です。テストの柔軟性を向上させ、システム全体をモジュール化することで、コードのメンテナンス性や拡張性が向上します。テスト戦略の中で依存性注入を正しく活用することで、スムーズな開発サイクルを実現することができます。
演習問題
依存性注入を理解し、実践するためには、実際にコードを書いてみることが効果的です。ここでは、依存性注入を用いたSwiftプログラムの演習問題をいくつか提示します。これにより、依存性注入の概念とその実装方法をしっかりと理解できるでしょう。
演習1: 簡単なデータ管理システムの作成
次の課題では、依存性注入を利用して、データを取得し表示するシステムを構築してみましょう。プロトコルを使って、異なるデータ取得手段を柔軟に注入できる仕組みを作成してください。
ステップ:
DataServiceプロトコルを定義し、データを取得するメソッドを用意してください。LocalDataServiceクラスとRemoteDataServiceクラスを作成し、それぞれ異なるデータ取得方法を実装します。DataManagerクラスに、DataServiceプロトコルを通じて依存性を注入します。LocalDataServiceまたはRemoteDataServiceを動的に切り替えて、データを取得して表示します。
ヒント:
protocol DataService {
func fetchData() -> String
}
class LocalDataService: DataService {
func fetchData() -> String {
return "ローカルデータ"
}
}
class RemoteDataService: DataService {
func fetchData() -> String {
return "リモートデータ"
}
}
class DataManager {
let service: DataService
init(service: DataService) {
self.service = service
}
func displayData() {
print(service.fetchData())
}
}
// 実行例
let localService = LocalDataService()
let dataManager = DataManager(service: localService)
dataManager.displayData()この課題では、異なるデータソース（ローカルまたはリモート）からデータを取得するために、DataServiceプロトコルを使用しています。
演習2: テストのためにモックを作成する
次に、テスト用のモックを作成し、依存性注入を利用してテストコードを作成してみましょう。モックオブジェクトを使用して、実際のデータを取得せずにシステムの動作を確認することが目的です。
ステップ:
MockDataServiceクラスを作成し、DataServiceプロトコルに準拠させます。このクラスでは固定のテストデータを返すようにしてください。DataManagerクラスにMockDataServiceを注入し、テストデータが正しく表示されるか確認します。- 本番環境のデータ取得コードとテストコードを簡単に切り替えられる仕組みを作成します。
ヒント:
class MockDataService: DataService {
func fetchData() -> String {
return "モックデータ"
}
}
// テストコード内での使用
let mockService = MockDataService()
let testManager = DataManager(service: mockService)
testManager.displayData() // "モックデータ"が表示されるはずですこの演習では、依存性注入を利用することで、外部データソースに依存せずにテストを行える柔軟性が得られます。
演習3: 複数の依存関係の注入
依存性注入は、1つのクラスだけでなく、複数のクラスに対しても適用できます。この演習では、複数の依存関係を注入し、柔軟なシステム設計を体験してみましょう。
ステップ:
Loggerプロトコルを定義し、ログメッセージを出力するメソッドを用意します。ConsoleLoggerとFileLoggerを実装し、それぞれ異なる方法でログを出力します。DataManagerに、データ取得用のDataServiceとログ用のLoggerを注入し、動作を確認します。
ヒント:
protocol Logger {
func log(_ message: String)
}
class ConsoleLogger: Logger {
func log(_ message: String) {
print("Console Log: \(message)")
}
}
class FileLogger: Logger {
func log(_ message: String) {
// ファイルにログを書き込む処理（省略）
}
}
class DataManager {
let service: DataService
let logger: Logger
init(service: DataService, logger: Logger) {
self.service = service
self.logger = logger
}
func fetchData() {
let data = service.fetchData()
logger.log("データ取得成功: \(data)")
}
}
// 実行例
let localService = LocalDataService()
let consoleLogger = ConsoleLogger()
let dataManager = DataManager(service: localService, logger: consoleLogger)
dataManager.fetchData()この演習では、DataServiceとLoggerという2つの依存関係をDataManagerに注入しています。依存性注入を使えば、複数の依存関係を簡単に管理し、システム全体の柔軟性を向上させることができます。
まとめ
これらの演習を通じて、依存性注入を使ったSwiftのプログラミングの理解が深まるはずです。プロトコルを使った柔軟な設計により、テスト可能でメンテナンスしやすいコードを作成できるようになります。演習を実践することで、依存性注入の利点や、どのように具体的なシステムに適用できるかを体験してください。
よくあるトラブルシューティング
依存性注入は強力な設計パターンですが、使用する際にいくつかのトラブルや課題に直面することがあります。ここでは、依存性注入に関連するよくある問題とその解決策について説明します。
1. 依存関係が増えすぎてしまう
依存性注入を活用すると、依存関係を容易に管理できますが、依存オブジェクトが増えすぎると、クラスが過度に複雑化してしまうことがあります。このような場合、コードの可読性が低下し、メンテナンスが困難になります。
解決策
依存関係の数が増えすぎないように、各クラスが単一責任を持つように設計しましょう。依存関係が多くなりすぎる場合は、ファクトリーパターンやサービスロケーターパターンを組み合わせることで、依存の管理を簡潔に保つことができます。
2. コンストラクタが長くなる問題
依存性注入を利用すると、コンストラクタで依存オブジェクトを注入することが多くなり、その結果、コンストラクタの引数が増えてしまう問題が発生します。特に多くの依存関係を持つクラスでは、初期化処理が煩雑になりがちです。
解決策
この問題には、依存関係をグループ化するか、依存オブジェクトをプロパティインジェクションやメソッドインジェクションで注入する方法が有効です。また、依存関係が本当に必要かどうかを見直し、設計をシンプルに保つよう心がけましょう。
3. 循環依存関係の発生
循環依存関係とは、2つ以上のクラスが互いに依存している状況のことです。このような場合、依存性注入を適用すると、依存関係のループが発生し、プログラムがクラッシュしたり、期待通りに動作しなくなったりします。
解決策
循環依存関係を回避するためには、依存関係の設計を再検討する必要があります。可能であれば、依存関係を再構成し、間接的な依存にするか、依存関係を外部に移してループを回避します。また、依存関係の抽象化を行うことも、循環依存を防ぐ効果があります。
4. モックが実環境と異なる問題
テスト環境でモックを使用していると、本番環境での依存関係と動作が異なる場合があります。この差異が原因で、本番環境でエラーが発生することもあります。
解決策
モックやスタブの設計は、実際の依存関係と可能な限り一致させるよう心がけましょう。また、実環境での振る舞いを模倣した「テストダブル」を活用することで、モックが実環境に近い形で動作するように設計できます。加えて、テストと本番環境の違いを検出するために、ステージング環境でのテストも定期的に行いましょう。
5. パフォーマンスの低下
依存性注入は、特に動的に依存関係を解決する場合に、オブジェクトの生成や依存関係の解決に時間がかかることがあります。大規模なシステムでは、依存関係の解決によりパフォーマンスが低下することもあります。
解決策
パフォーマンスの問題を解決するためには、依存関係のライフサイクル管理が重要です。頻繁に利用される依存オブジェクトは、シングルトンやキャッシュを利用して効率的に再利用しましょう。依存オブジェクトの生成を遅延させる「遅延インジェクション」も、パフォーマンス最適化の一助となります。
6. テストカバレッジの不足
依存性注入を適切に利用しないと、テストカバレッジが不十分になり、本番環境で予期しないバグが発生することがあります。依存性注入のテストを行う際、依存関係の一部が未テストのままになるケースも考えられます。
解決策
テストカバレッジを高めるためには、依存オブジェクトをモックやスタブに差し替えた上で、あらゆるパターンを網羅したテストを実行することが大切です。異なるシナリオやエラーパターンについても十分なテストを行い、テスト環境で実装される依存関係がしっかり検証されているか確認しましょう。
まとめ
依存性注入は多くの利点を持つ一方で、適切に実装しないと複雑さやパフォーマンスの問題を引き起こす可能性があります。これらのよくあるトラブルとその解決策を理解することで、より効率的に依存性注入を利用し、システム全体の品質とパフォーマンスを向上させることが可能です。
まとめ
本記事では、Swiftにおけるプロトコルを用いた依存性注入の実装方法について解説しました。依存性注入は、コードの柔軟性や保守性を高め、テストを容易にする非常に効果的な設計パターンです。プロトコルを使うことで、具体的な実装からクラスを分離し、疎結合な設計を実現します。また、依存性注入を正しく適用するための注意点や、よくあるトラブルへの対処法も紹介しました。依存性注入を活用して、よりスケーラブルでメンテナンスしやすいSwiftアプリケーションを開発しましょう。
コメント