Swift：如何确保仅ClassB可实例化SubClassA1类对象？

Absolutely, there are a few solid patterns to enforce that only ClassB can instantiate SubClassA1, depending on whether your classes are in the same file or separate files. Let's break them down:

1. Same File: Use fileprivate Initializer #

If you can move SubClassA1 into the same file as ClassB, this is the cleanest and most straightforward approach. Mark SubClassA1's initializer as fileprivate, so only code within the same file can call it:

// ClassB.swift
class ClassB {
    func create() -> BaseClassA {
        return SubClassA1() // Allowed since we're in the same file
    }
}

class SubClassA1 : BaseClassA {
    private var someFlag = false
    private var context: SomeContextClass?
    
    // Only accessible within this file
    fileprivate init() {}
    
    func setContext(_ context: SomeContextClass) {
    }
}

Any code outside this file will hit a compile error if it tries to call SubClassA1() directly.

2. Separate Files: Authorized Token Pattern #

If you need to keep the classes in separate files, use a token-based approach to restrict access. Here's how to implement it:

Step 1: Modify SubClassA1 to require an authorization token #

In SubClassA1.swift, make the initializer private, then add a static factory method that accepts a token conforming to an internal protocol:

// SubClassA1.swift
// Internal protocol for the authorization token (visible across the module)
protocol SubClassA1AuthToken {}

class SubClassA1 : BaseClassA {
    private var someFlag = false
    private var context: SomeContextClass?
    
    // Private initializer: no one can call this directly
    private init() {}
    
    // Factory method only accessible to types with a valid auth token
    static func create(with token: SubClassA1AuthToken) -> SubClassA1 {
        return SubClassA1()
    }
    
    func setContext(_ context: SomeContextClass) {
    }
}

Step 2: Make ClassB conform to the token protocol privately #

In ClassB.swift, add a private extension to make ClassB conform to SubClassA1AuthToken. This conformance is hidden from other files, so no other class can replicate it:

// ClassB.swift
class ClassB {
    func create() -> BaseClassA {
        // Pass self as the valid auth token
        return SubClassA1.create(with: self)
    }
}

// Private extension: only ClassB can use this conformance
private extension ClassB : SubClassA1AuthToken {}

This works because:

• External code can see the SubClassA1AuthToken protocol, but can't create a conforming type (since the only valid conformance is private to ClassB).
• SubClassA1's factory method only accepts valid tokens, so only ClassB can call it.

3. Separate Files: Singleton + Private Initializer (Alternative) #

If ClassB is designed to be a singleton, you can use its shared instance as a stricter token to prevent any unauthorized creation:

// SubClassA1.swift
class SubClassA1 : BaseClassA {
    private var someFlag = false
    private var context: SomeContextClass?
    
    private init() {}
    
    static func create(authorizedBy classB: ClassB) -> SubClassA1 {
        // Ensure we're using the official singleton instance of ClassB
        guard classB === ClassB.shared else {
            fatalError("Only ClassB's singleton can create SubClassA1")
        }
        return SubClassA1()
    }
    
    func setContext(_ context: SomeContextClass) {
    }
}

// ClassB.swift
class ClassB {
    static let shared = ClassB()
    
    // Private initializer to enforce singleton behavior
    private init() {}
    
    func create() -> BaseClassA {
        return SubClassA1.create(authorizedBy: self)
    }
}

This ensures that even if someone somehow gets ahold of a non-singleton ClassB instance (though the singleton pattern prevents this), only the shared instance can create SubClassA1.

All these patterns will enforce your requirement that external code must go through ClassB to get a SubClassA1 instance.

内容的提问来源于stack exchange，提问作者Mithin