0Pricing
Swift Academy · Lezione

Inversione delle dipendenze con astrazioni basate su protocolli

Dipendere da astrazioni anziché da implementazioni concrete, usando i protocolli Swift come confini.

Inversione delle dipendenze con astrazioni basate su protocolli è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Principio di inversione delle dipendenze

I moduli di alto livello non devono dipendere dai moduli di basso livello. Entrambi devono dipendere da astrazioni (protocolli).

// WITHOUT DIP:
class OrderService { let db = SQLiteDatabase() }  // depends on concrete
// WITH DIP:
class OrderService { let db: Database }  // depends on abstraction

Definizione dell'astrazione

Estrarre un protocollo che rappresenti il contratto richiesto dal modulo di alto livello.

protocol Database {
  func save<T: Encodable>(_ value: T, key: String) throws
  func load<T: Decodable>(key: String) throws -> T
}

Implementazioni concrete

Fornire più implementazioni concrete dietro il protocollo: per la produzione, per i test e per eventuali alternative future.

class SQLiteDatabase: Database { ... }
class InMemoryDatabase: Database { ... }
class KeychainDatabase: Database { ... }

Dependency injection tramite costruttore

Passare l'astrazione tramite l'inizializzatore: è lo stile di injection più esplicito e più facilmente testabile.

class ProfileService {
  private let db: Database
  init(db: Database) { self.db = db }
}

Perché non usare singleton per tutto?

I singleton globali nascondono le dipendenze, rendendo il codice difficile da testare e da comprendere.

// Hard to test:
class Service { func run() { MySingleton.shared.doWork() } }
// Easy to test:
class Service { let dep: MyProtocol; func run() { dep.doWork() } }

Astrazioni tramite protocolli in Swift

I protocolli Swift possono includere associated type, implementazioni predefinite e composizione: sono ideali per astrazioni articolate.

protocol Cacheable {
  associatedtype Key: Hashable
  associatedtype Value
  func get(_ key: Key) -> Value?
  func set(_ key: Key, value: Value)
}

Granularità dell'astrazione

Segregazione delle interfacce: preferire protocolli ristretti a protocolli troppo ampi, in modo che le implementazioni forniscano solo ciò di cui hanno bisogno i chiamanti.

// Fat (avoid):
protocol DataStore {
  func save(...); func load(...); func delete(...); func query(...); func migrate()
}
// Narrow (prefer):
protocol Readable { func load<T>(...) throws -> T }
protocol Writable { func save<T>(...) throws }

DIP con Combine

Restituire AnyPublisher dai metodi del protocollo, così il tipo concreto del publisher sottostante rimane nascosto.

protocol UserStream {
  func userUpdates() -> AnyPublisher<User, Never>
}

DIP con async/await

I metodi del protocollo contrassegnati con async throws sono pienamente compatibili con la concorrenza strutturata di Swift.

protocol Analytics {
  func track(event: String) async
}
struct FirebaseAnalytics: Analytics {
  func track(event: String) async { /* Firebase call */ }
}

DIP a livello di app

Configurare le implementazioni concrete nel punto di ingresso dell'app (Composition Root), mantenendo tutti i collegamenti in un unico punto.

@main
struct MyApp: App {
  let db: Database = SQLiteDatabase()
  let repo: UserRepository = RemoteUserRepository(db: db)
  let useCase = FetchUserUseCase(repo: repo)
  var body: some Scene {
    WindowGroup { ContentView(useCase: useCase) }
  }
}

Test con il DIP

Nei test, sostituire le implementazioni reali con mock/stub nel punto di injection.

let mockDB = InMemoryDatabase()
let service = ProfileService(db: mockDB)
// Exercise service
XCTAssertEqual(try mockDB.load(key: "profile"), expectedProfile)

Verifica rapida

Che cosa afferma il principio di inversione delle dipendenze riguardo ai moduli di alto livello?

Riepilogo della lezione

DIP: i moduli di alto livello dipendono da astrazioni definite tramite protocolli; i tipi concreti le implementano. Estrarre protocolli ristretti, usare l'injection tramite costruttore e configurare tutto nel Composition Root. Questo consente di sostituire le implementazioni per i test, la gestione dei feature flag e i requisiti futuri.

Domande Frequenti

La lezione «Inversione delle dipendenze con astrazioni basate su protocolli» è gratuita?

Sì — il testo completo di «Inversione delle dipendenze con astrazioni basate su protocolli» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Inversione delle dipendenze con astrazioni basate su protocolli»?

Dipendere da astrazioni anziché da implementazioni concrete, usando i protocolli Swift come confini. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Inversione delle dipendenze con astrazioni basate su protocolli»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Livelli: dominio, dati e presentazione
  2. Pattern Use Case e Repository
  3. Inversione delle dipendenze con astrazioni basate su protocolli
  4. Collegare i livelli senza un framework DI
← Torna a Swift Academy