Hi, let test: [Lazy<Provider>] = [*container] is work but let test: [Lazy<Provider>] = many(*container) doesn't

Fatal error: Can't cast Optional to Array<Lazy>

what workaround could be? thanx

Hi,

Thank you for the library! It's nice to have a decent DI-library for pure Swift projects.

Could you please clarify a couple of things for me. I'm trying to wrap my head around custom scope objects. Let's say I have three VCs: VC1 -> VC2 -> VC3. And I want to share some object between them.

I understand, that I can just register the object as single (.single, .lazySingle or .weakSingle). But it will live so long as the whole app. In my case I want to bind its lifecycle to the aforementioned view controllers.

What is the best way to achieve this? Should I create another DIContainer just for these VCs?

Now if I resolve one object with arguments from more threads app can crash - because set arguments and resolve not atomic operation:

container.extensions(for: YourType.self)?.setArgs(arg1)
container.resolve() as YourType

This problems actual for Provide1, Provide2... and Lazy1, Lazy2 because he using argument.

setArgs - устанавливает аргументы к указанному типу, но если это сделать из многих потоков, то аргументы будут в итоге от последнего.

первый resolve() же получит объект с аргументами от последнего, а последующие упадут.

Как решать - видимо надо сделать resolve который принимает argument-ы всеже. Да аргументы по типу, но это не отдельным расширением. В общем DIExtension походу надо удалять.

Добрый день!

Я добавляю в свою библиотеку поддержку SwiftUI, для DI использую DITranquality. @ObservedObject работает, а при добавлении @State падает с ошибкой проверки графа error: Invalid reference from <Component. type: TestView; path: TestView.swift:67> because not found component for type: Int Fatal error: invalid graph: file Не пойму в чем дело.

Hi. In my current architecture, I'm using coordinators with injected containers. (I didn't found method collaborate so I decide to use init(: parent)) Code:

protocol Coordinator: class {
    var parent: Coordinator? { get set }
    var childCoordinators: [Coordinator] { get set }
    var navigationController: UINavigationController { get }
    var container: DIContainer { get set }

    func start()
}

extension Coordinator {
    func store(coordinator: Coordinator) {
        coordinator.parent = self
        childCoordinators.append(coordinator)
        coordinator.container = DIContainer(parent: container)
        coordinator.start()
    }

Today I've checked memory graph and spotted multiple leaks in coordinators. The reason was that your container holding a strong reference on the parent. I've fixed the problem by making container DIContainer! and explicitly assign him nil. Code:

func free(coordinator: Coordinator) {
        coordinator.container.clean()
        coordinator.container = nil
        childCoordinators.removeAll(where: { $0 === coordinator })
    }

But in my opinion, the best solution will be adding weak to parent. Or at least make parent public property. What do you think on this? Maybe I'm using container in the wrong way. Thanks.

Hello! App library crashes when I'm trying to instantiate view controller from container

Here is a component:

class AppComponent: DIComponent{
    
    var scope: DIComponentScope { return .public }
    
    func load(builder: DIContainerBuilder){
        
        builder.register(type: UIStoryboard.self)
            .set(name: "Main")
            .lifetime(.single)
            .initial { DIStoryboard(name: "Main", bundle: nil, container: $0) }
        
        builder.register(vc: StartupVC.self)
            .initial(useStoryboard: {container in try container.resolve(name: "Main")}, identifier: "startup")
        
    }
}

AppDelegate:

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        
        
        let builder = DIContainerBuilder()
        builder.register(component: AppComponent())
        let container = try! builder.build()
        
        let viewController = try! container.resolve(StartupVC.self)

        self.window = UIWindow(frame: UIScreen.main.bounds)
        self.window?.rootViewController = viewController
        self.window?.makeKeyAndVisible()
        
        return true
    }

Crash is on this line let viewController = try! container.resolve(StartupVC.self)

fatal error: 'try!' expression unexpectedly raised an error: Cannot found initial method with signature: (DIContainer) throws -> Any. Use: Register type: StartupVC in file: AppComponent.swift on line: 23

Is it a bug or am I doing something wrong? I can send you sample project.

Спасибо за библиотеку! в swift 5 не поддерживается внедрение зависимостей через свойства используя KeyPath если свойство private(set)

class AppPart: DIPart {
    static func load(container: DIContainer) {
        container.register(Presenter.init)
        container.register(ViewController.init)
            .injection(\.presenter)
    }
}
class Presenter {
}

class ViewController {
    private(set) var presenter: Presenter!
}

Proposal. Problem: Current implementation of “tags” in library based on objects types (or strings, but its not compile-safe). It is not possible now to use polymorphism like:

class A {}
class B:A {}
let tag: A.Type = B.self

c.register(MyClass.init)
    .as(MyClass.self, tag: B.self)

let myOBJ: MyClass? = c.resolve(tag)

Resolver will produce nil in myOBJ resolving, cause container will be used compile-time type of tag (A.Type), not actual type stored in tag variable.

And now we hame “name” feature that can be used similar way as tags, but string not compile-safe and it is easy to make typo mistake during development. Because both “name” and “tag” exists in library, one of them looks like a hack, that exists for solving problem of opposite implementation.

Proposal: For easier and more intuitive usage of marking registrations I suggest implement Notification.Name-like implementation or Enum implementation.

Variant1:

struct DITag {
    enum Scope<T> {
        case public
        case restricted(T.Type)
    }
    
    private let value: String
    private let tagScopeID: ObjectIdentifier
    
    Init<T>(value: String, scope: Scope<T> = .public)
}

struct MyModule {}

extension DITag { 
    static let myTag = DITag(value: “simpleTag”)
    static let myModuleTag = DITag(value: “simpleTag2”, scope: .restricted(MuModule.self))
}

container.register(MyClass.init)
   .as(MyClass.self, tag: .myTag)
   .as(MyClass.self, tag: .myModuleTag)

let obj = container.resolve(tag: .myTag)

Variant2:

protocol DITag {
    var stringValue: String { get }
}

enum MyTags: String, DITag {
   case tag1
   case tag2
}

container.register(MyClass.init)
    .as(MyClass.self, tag: MyTags.tag1)

let obj = container.resolve(tag: MyTags.tag1)

Pros:

1. Less confusing cause we have only one tagged implementations (we have String tags and Typed tags now)
2. More intuitive registration and resolving (enum-case like)
3. Can be polymorphed
4. Typo mistakes still can be avoided as in current Typed tags implementation

Difference between two variants: In variant 1 anyone from another frameworks can get access to your tagged variable without actually having access to internal tag if you declare DITag.Scope as public just by passing same string value in DITag initialisation. In variant 2, you have no possibility to share access to tag, because of capturing enum’s type in “as(_:tag:)” registration. Enum’s type capturing is mandatory cause of enum’s case string values overlapping.

Add small library with lazy and provide functionality.

Integrate DITranquillity with this library. Add public protocol, for can use other library:

protocol InstanceWrapper {
  static var wrappedType: Any.Type { get }
  init?(container: DIContainer, resolver: () -> (Any?))
}

on:

register(Type.self, Protocol.self,...) .initial { return Obj(inject: $0) }

first string contains all type names and after wrote function for create object.

as - removed

let modificator = Modificator() .asType(Logger.self) .instanceSingle()

builder.register{ ConsoleLogger() } .use(modificator: modificator)

builder.register{ FileLogger(file: "file.log") } .use(modificator: modificator)

builder.register{ ServerLogger(server: "http://server.com/") } .use(modificator: modificator)

builder.register{ MainLogger(loggers: **!$0) } .use(modificator: modificator) .asDefault()

При наличии нескольких одинаковых register resolve падает с критической ошибкой:

protocol P {
}

class C: P {
}

container.register(C.init).as(P.self).lifetime(.single) // 1
container.register(C.init).as(P.self).lifetime(.single) // 2
let obj: C = container.resolve() // crash

Ситуация довольно типовая, когда выражения 1 и 2 находятся в разных модулях. lifetime ситуацию не меняет.

Current resolve system make without delay Maker - Lazy, Provider. It lead to not fully support Delay Maker with other modifications - many, tags.

Also current system can faster, and simplify

https://github.com/jpsim/SourceKitten/tree/master/Source/SourceKittenFramework

Library can get AST, can wrote warnings/errors dyring build.

But it's hard...

Added contains function in DITranquillity:

container.contains(type: Protocol.self) // contains(type: "Protocol") container.contains(component: Component.self) // contains(component: "Component") container.contains(module: Module.self) // contains(module: "Module")

Extensions - add additional capabilities, in runtime. Needs for other libraries

class VC: UIViewController {
  var presenter: Presenter!
}

// where get arg1?
class Presenter {
  let server: Server!
  let arg1: Int
  init(server: server, arg1: Int) {
    self.server = server
    self.arg1 = arg1
  }
}

showVC() {
  let runtimeArg1 = 125
  let runtimeArg2 = 125
  // extension variable need for retain Extension
  let extension = DIExtensions.resolve(filter: Presenter.self) { container in
    return Presenter(server: try! *container, arg1: runtimeArg1)
  } // if somebody resolve Presenter, then call extension
  // or
  let extension = DIExtensions.initial(filter: Presenter.self) { container in
    return Presenter(server: try! *container, arg1: runtimeArg1)
  } // if from somewhere get Presenter, then call extension

  let extension = DIExtensions.postInit(filter: Presenter.self) { container, presenter in
    presenter.arg2 = runtimeArg2
  } // if Presenter full create, then call extension

  let vc = storyboard.in...()
}