Merhaba arkadaşlar;

Kendim kullanmak için bir IOC konteynerı geliştirmeye çalışıyorum. 3 ayrı scope var Singleton, Transient ve Scoped diye.

Singleton da sıkıntı yok, hep aynı instance resolve edilmesi gerekiyor.

Scoped ve Transient nasıl yapacağımı kavrayamadım

Transient - Her request te yeni instance üretilecek, o request pipeline içinde bu üretilen instance i kullanacak
Scoped - Her seferinde farklı insanca vermesi gerekiyor

kodum bu sekilde


export enum Scope {
    SINGLETON = "SINGLETON",
    TRANSIENT = "TRANSIENT",
    SCOPED = "SCOPED",

}

export type MaybeConstructor<T> = { new(...args: unknown[]): T };
export type MaybeInstance<T, K extends abstract new (...args: unknown[]) => T = MaybeConstructor<T>> = InstanceType<K>;

export interface Dependency<T> {
    token: string,
    scope: Scope,
    value?: MaybeConstructor<T> | MaybeInstance<T>
}

export class Container {
    private static stack = new Map<string | symbol, Dependency<unknown>>()
    AddScoped<T> (object: MaybeConstructor<T>, token?: string): Container {
        token = token && token || object.name 
        Container.stack.set(token, {
            token,
            scope: Scope.SCOPED,
            value: object
        } as Dependency<MaybeConstructor<T>>);  return this
    }

    AddSingleton<T>(object: MaybeConstructor<T>, token?: string): Container {
        token = token && token || object.name
        Container.stack.set(token, {
            token,
            scope: Scope.SINGLETON,
            value: new object()
        } as Dependency<T>); return this
    }


    AddTransient<T>(object: MaybeConstructor<T>, token?: string): Container {
        token = token && token || object.name 
        Container.stack.set(token, {
            token,
            scope: Scope.TRANSIENT,
            value: object
        } as Dependency<MaybeConstructor<T>>);  return this
    }

    
    Resolve<T = unknown>(token: string): MaybeInstance<T> {
        const item = Container.stack.get(token)
        if(!item) throw new Error("Dependency not found")
        if (item?.scope == Scope.SINGLETON) return item.value as MaybeInstance<T>
        return new (item?.value as MaybeConstructor<T>)() as InstanceType<MaybeConstructor<T>>  
    }
}

ornek

const instance = new Container()


class Test {
    random = Math.random()
    public Test() {
        console.log(this.random)
    }
}



instance.AddSingleton(Test)

const r1  = instance.Resolve<Test>(Test.name)
const r2 = instance.Resolve<Test>(Test.name)


console.log(r1.Test(), r2.Test())
//  0.6031956833046075,  0.6031956833046075

instance.AddTransient(Test)

const r1  = instance.Resolve<Test>(Test.name)
const r2 = instance.Resolve<Test>(Test.name)


console.log(r1.Test(), r2.Test())
// 0.03116739566511817,  0.8649359757523707

Şimdiden yardımlarınız için teşekkürler