Difference between declaring @Dependency inside func and inside class/struct?

[gerchicov-vg]

According to examples you suggest to use this macro for inner class/struct variables only. But some people use it to declare local variables inside func directly. Is it correct?

And is it correct for example to replace SomeSingleton.shared.someFunc() with the following code:

//Utility code
extension DependencyValues {
  var someSingleton: SomeSingleton { ... }
}
struct SomeSingletonKey: DependencyKey { ... }

//Example of concrete usage
func someInnerFunc() {
  @Dependency(\.someSingleton) var someSingleton
  someSingleton.someFunc()
}

[mbrandonw]

Hi @gerchicov-vg, it's ok to do this in the sense that it compiles and will most likely do what you want. But there is a difference between:

class Model {
  @Dependency(\.client) var client
  func tap() { client.perform() }
}

…and:

class Model {
  func tap() { 
    @Dependency(\.client) var client
    client.perform() 
  }
}

In the first example, the dependency resolves the value of client at the moment the class is created, and keeps that around for whenever the client is invoked. In the second example, the client is resolved each time tap() is called.

The vast majority of dependencies are only ever set a single time at the entry point of the app, and for such dependencies there is no distinction between these two styles. But, the first style is typically easier to understand, and we would recommend it, but also understand if you are in the process of refactoring a large, complex app, you may not be able to do that always.