Beispiel #1
0
        public void TestTemporaryContext1()
        {
            var IoC_inject = GetInjectorForTest();

            Assert.Null(IoC_inject.Get <MyClass1>(this));
            for (int i = 0; i < 100; i++)
            {
                TaskV2.Run(() => {
                    var myContextInstance1 = new MyClass1();
                    IoC_inject.DoWithTempContext <MyClass1>(myContextInstance1, () => {
                        Assert.Equal(myContextInstance1, IoC_inject.Get <MyClass1>(this));
                    });
                    // when the temporary context is gone requesting an injection returns null again:
                    Assert.Null(IoC_inject.Get <MyClass1>(this));

                    var myContextInstance2 = new MyClass1();
                    var testUser           = new MyUserClass1();
                    IoC_inject.DoWithTempContext <MyClass1>(myContextInstance2, () => {
                        IoC_inject.DoWithTempContext <MyUserClass1>(testUser, () => {
                            Assert.Equal(myContextInstance2, IoC_inject.Get <MyClass1>(this));
                            Assert.Equal(testUser, IoC_inject.Get <MyUserClass1>(this));
                        });
                    });
                    // when the temporary context is gone requesting an injection returns null again:
                    Assert.Null(IoC_inject.Get <MyClass1>(this));
                    Assert.Null(IoC_inject.Get <MyUserClass1>(this));
                });
            }
        }
Beispiel #2
0
        public async Task TestHasIdDbConnection()
        {
            var          userId1 = "123";
            MyUserClass1 user1   = new MyUserClass1()
            {
                id = userId1, name = "Some Name"
            };

            { // Inject the HasIdDbConnection globally:
                // If the store is not registered x.Save() will throw an injection exception:
                await Assert.ThrowsAsync <InjectionException>(async() => { await user1.SaveToDb(); });

                IoC.inject.SetSingleton(new HasIdDbConnection <MyUserClass1>(new InMemoryKeyValueStore()));
            }
            { // Now use the extension method x.Save() that will use the injected store internally:
                Assert.Null(await user1.SaveToDb());
                user1.name = "Some new name";
                Assert.Equal(user1, await user1.SaveToDb());
            }
            { // HasId also provides an extension method for Load that does the same:
                MyUserClass1 defaultValue = null;
                MyUserClass1 loadedUser1  = await defaultValue.LoadFromDb(userId1);

                Assert.Equal(user1.name, loadedUser1.name);
            }
            { // The injected DB can also be used directly without the extension methods:
                var injectedDB = IoC.inject.Get <HasIdDbConnection <MyUserClass1> >(this);
                // Loading the same item again from the DB:
                MyUserClass1 loadedUser1 = await injectedDB.Load(userId1, null);

                Assert.Equal(user1.name, loadedUser1.name);
                // The DB can also load all entries:
                var allEntries = await injectedDB.LoadAllEntries();

                Assert.Contains(user1, allEntries);
            }
        }