Dependency injection in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main benefit of dependency injection in Swift?

Choose the best explanation for why developers use dependency injection in Swift apps.

A It allows objects to create their own dependencies internally for better encapsulation.

B It automatically manages memory for all dependencies without manual code.

C It helps to reduce tight coupling by providing dependencies from outside the object.

D It forces all dependencies to be global singletons for easy access.

💡 Hint

Think about how dependency injection affects how objects get what they need to work.

Dependency injection means giving an object its dependencies from outside, which reduces tight coupling and makes testing easier.

❓ component_behavior

intermediate

What will be printed when this Swift code runs?

Consider this Swift code using dependency injection. What is the output?

iOS Swift

protocol Logger {
    func log(_ message: String)
}

class ConsoleLogger: Logger {
    func log(_ message: String) {
        print("Console: \(message)")
    }
}

class FileLogger: Logger {
    func log(_ message: String) {
        print("File: \(message)")
    }
}

class Service {
    let logger: Logger
    init(logger: Logger) {
        self.logger = logger
    }
    func doWork() {
        logger.log("Work done")
    }
}

let service = Service(logger: FileLogger())
service.doWork()

A No output

B File: Work done

C Work done

D Console: Work done

💡 Hint

Look at which logger instance is passed to the Service.

The Service is initialized with a FileLogger instance, so it prints "File: Work done".

📝 Syntax

advanced

Which option correctly injects a dependency using initializer injection in Swift?

Choose the correct Swift code snippet that injects a dependency via the initializer.

A

class ViewController {
    var service: Service
    init(service: Service) {
        self.service = service
    }
}

B

class ViewController {
    var service: Service
    init() {
        service = Service()
    }
}

C

class ViewController {
    var service = Service()
    init(service: Service) {
        self.service = service
    }
}

D

class ViewController {
    var service: Service
    func inject(service: Service) {
        self.service = service
    }
}

💡 Hint

Initializer injection requires the dependency to be passed and assigned in the init method.

Option A declares the property and assigns it in the initializer, which is the correct pattern for initializer injection.

🔧 Debug

advanced

Why does this Swift code cause a runtime crash?

Examine the code below. What causes the crash when creating ViewController?

iOS Swift

class Service {}

class ViewController {
    var service: Service!
    init() {
        // service is not initialized here
    }
    func useService() {
        print(service!)
    }
}

let vc = ViewController()
vc.useService()

A The useService method is called before the ViewController instance is created.

B The init method is missing a call to super.init(), causing a crash.

C The service property is a constant and cannot be assigned later.

D The service property is declared as implicitly unwrapped optional but never initialized before use.

💡 Hint

Check how the service property is declared and when it is assigned.

The implicitly unwrapped optional service is nil when useService is called, causing a runtime crash.

❓ state_output

expert

What is the final value of counter after running this Swift code with dependency injection?

Analyze the code below. What value does counter have after incrementer.increment() is called?

iOS Swift

protocol Incrementable {
    func increment()
}

class Counter: Incrementable {
    var count = 0
    func increment() {
        count += 1
    }
}

class Incrementer {
    let counter: Counter
    init(counter: Counter) {
        self.counter = counter
    }
    func increment() {
        counter.increment()
    }
}

let counter = Counter()
let incrementer = Incrementer(counter: counter)
incrementer.increment()
let finalCount = counter.count

A 1

B 0

C 2

D Compilation error

💡 Hint

Trace how the count property changes when increment() is called.

The increment() method increases count by 1, so the final value is 1.