Never use this anti pattern is the solution

Question

Mark · Answer

Okay thanks Any pointer to some likely alternative

gildor · Answer

What is your use case for this

Mark · Answer

Various but the most common one is needing a application context in a singleton

wbertan · Answer

Should not DI solve that

Mark · Answer

I ve been holding off DI up until now because the landscape seems to be changing a lot

Mark · Answer

I mean the decision of whether to use Dagger 2 Kodein Koin etc

wbertan · Answer

You already did some decisions your architecture your framework your language that is one of those decisions where good or bad will not be eternal as some years back people choosing Java and now migrating to Kotlin

wbertan · Answer

Either way as < gildor> said `Never use this anti pattern` but I believe this could achieve what you want I think the `Asas2` is what you want ```class TestAsas object Asas String gt String override fun invoke p1 String String = Welcome $p1 Test fun asas val result = Asas Me Assert assertEquals Welcome Me result object Asas2 String gt gt String lateinit var INSTANCE gt String override fun invoke p1 String gt String if INSTANCE isInitialized Welcome $p1 also INSTANCE = it return INSTANCE Test fun asas2 Asas2 Me val result1 = Asas2 INSTANCE Assert assertEquals Welcome Me result1 val result2 = Asas2 INSTANCE Assert assertEquals Welcome Me result2 ```

wbertan · Answer

It also prevent other initialisation ``` Test fun asas3 Asas2 Me val result1 = Asas2 INSTANCE Assert assertEquals Welcome Me result1 Asas2 Other val result2 = Asas2 INSTANCE Assert assertEquals Welcome Me result2 ```

louiscad · Answer

If you need applicationContext I already solved the problem with the little library Splitties App Context that gives you a top level `appCtx` property

Mark · Answer

Yes I saw that thanks Although sometimes I need something other than the context

gildor · Answer

Context case and something other are completely different things

gildor · Answer

Get application context is easy just use Louis code or just write top level property and set it on Application onCreate onBaseContextAttaches

gildor · Answer

not perfect but much better than use singleton with params

gildor · Answer

gt I need something other than the context Yes most probably you need DI

Dico · Answer

I think it s a misconception that you need library to follow DI pattern

Dico · Answer

Just pass all dependencies to constructor

gildor · Answer

even without using any framework just create some dependencies graph and make it available globally as just super simple solution

Dico · Answer

In Kotlin it s ridiculously easy since it removes a bunch of boilerplate

gildor · Answer

or use common Android pattern with service locator based on retrieving dependencies from Application context

Mark · Answer

yes this more or less how I currently do it

gildor · Answer

gt Just pass all dependencies to constructor But because you cannot do this for Android components instead you can do this by getting from Application context

Mark · Answer

To better describe the problem Suppose a `MyApplication` object `Application` subclass has a property `myImmutableConfig` and there is a singleton by intention class that can be instantiated by `suspend fun createMySingleton myImmutableConfig MySingleton` and I want to be able to access MySingleton from a suspending function If accessed from a blocking function then presumably it would potentially block the main thread

Mark · Answer

My first thoughts are something like this using lateinit similar to < wbertan> suggestion earlier But this way isn t thread safe by the looks of it ```private lateinit var INSTANCE MySingleton suspend fun getInstance MySingleton if INSTANCE isInitialized INSTANCE = createMySingleton myApplication myImmutableConfig return INSTANCE fun getInstanceBlocking MySingleton if INSTANCE isInitialized runBlocking return runBlocking getInstance return INSTANCE ```

gildor · Answer

No need to use all those isInitialized or singeltons if we talking just about caching of value in property in a suspend way just use async

gildor · Answer

```val myConfig Deferred lt MyConfig gt = GlobalScope async start = Lazy createMyConfig myApplication myImmutableConfig ``` And to use just `myConfig await `

Mark · Answer

Using GlobalScope

Mark · Answer

ah ok

gildor · Answer

Any scope what you want

gildor · Answer

depends on case

gildor · Answer

if this a property in a class use scope of this class etc

gildor · Answer

but your example above looks more like some global property so up to you

gildor · Answer

you even can get rid of Deferred by wrapping to suspend function ``` private val myConfig Deferred lt MyConfig gt = suspend fun myConfig MyConfig = myConfig await ```

gildor · Answer

But in general because you use this on Application level GlobalScope is fine

Mark · Answer

So much nicer thanks ```private val INSTANCE DEFERRED = GlobalScope async start = CoroutineStart LAZY createMySingleton myApplication myImmutableConfig suspend fun getInstance = INSTANCE DEFERRED await ```

gildor · Answer

as you can see there is no singletons with params just some global application state which has own problems but not more than for example common singleton

gildor · Answer

also it s not blocking

Mark · Answer

I see yes Although the instance can only be accessed from a suspending function

Mark · Answer

And then from non suspending code ```fun getInstanceBlocking = if INSTANCE DEFERRED isCompleted INSTANCE DEFERRED getCompleted else runBlocking getInstance ```

gildor · Answer

Of course from suspending because it s asyncronous

gildor · Answer

For blocking version of this function I wouldn t check for completed just wrap to runBlockimg

Mark · Answer

ok thanks

gildor · Answer

Also I wouldn t introduce blocking version just because it makes all this code not so safe and potentially you can accidentally block main thread

gildor · Answer

Blocking version maybe useful only for some very special use cases but in this case I would just use runBlocking on call site

Mark · Answer

Right then it s more explicit