public void ValueIsLazyWithOverloadConstructorCreatesValueTest()
 {
   var lazy = new LazySingleton<Dictionary<string, object>>(() => new Dictionary<string, object>());
   var value = lazy.Value;
   Assert.IsNotNull(lazy.Value, "Value must not be null.");
   Assert.IsTrue(lazy.IsValueCreated);
   Assert.AreEqual(typeof(Dictionary<string, object>), lazy.Value.GetType());
 }
 public staitc LazySingleton GetInstance()
 {
     if (_instance == null)
     {
         _instance = new LazySingleton();
     }
     return(_instance);
 }
Exemple #3
0
        public void AllTest()
        {
            var now = LazySingleton.GetInstance <DateTimeSingleton>().Time;

            for (var i = 0; i < 10; i++)
            {
                Assert.Equal(now.Ticks, LazySingleton.GetInstance <DateTimeSingleton>().Time.Ticks);
            }
        }
Exemple #4
0
 internal RuleContext(ApplicationContext applicationContext, Action <IRuleContext> completeHandler, LazySingleton <Dictionary <IPropertyInfo, object> > outputPropertyValues, LazySingleton <List <IPropertyInfo> > dirtyProperties, RuleContextModes executeContext)
 {
     ApplicationContext    = applicationContext ?? throw new ArgumentNullException(nameof(applicationContext));
     ApplicationContext    = applicationContext;
     _completeHandler      = completeHandler;
     _outputPropertyValues = outputPropertyValues;
     _dirtyProperties      = dirtyProperties;
     ExecuteContext        = executeContext;
 }
Exemple #5
0
 internal RuleContext(ApplicationContext applicationContext, Action <IRuleContext> completeHandler)
 {
     ApplicationContext    = applicationContext ?? throw new ArgumentNullException(nameof(applicationContext));
     _completeHandler      = completeHandler;
     _outputPropertyValues =
         (LazySingleton <Dictionary <IPropertyInfo, object> >)ApplicationContext.CreateInstanceDI(typeof(LazySingleton <Dictionary <IPropertyInfo, object> >));
     _dirtyProperties =
         (LazySingleton <List <IPropertyInfo> >)ApplicationContext.CreateInstanceDI(typeof(LazySingleton <List <IPropertyInfo> >));
 }
Exemple #6
0
        public void ValueIsLazyWithOverloadConstructorCreatesValueTest()
        {
            var lazy  = new LazySingleton <Dictionary <string, object> >(() => new Dictionary <string, object>());
            var value = lazy.Value;

            Assert.IsNotNull(lazy.Value, "Value must not be null.");
            Assert.IsTrue(lazy.IsValueCreated);
            Assert.AreEqual(typeof(Dictionary <string, object>), lazy.Value.GetType());
        }
        public void Lazy_Singleton_Incrementer_Test()
        {
            LazySingleton lazySingletonOne = LazySingleton.Instance;
            LazySingleton lazySingletonTwo = LazySingleton.Instance;

            lazySingletonOne.Incrementer += 1;
            lazySingletonTwo.Incrementer += 1;

            Assert.Equal(2, lazySingletonOne.Incrementer);
            Assert.Equal(2, lazySingletonTwo.Incrementer);
        }
Exemple #8
0
        public void TestLazySingleton()
        {
            Console.WriteLine("Start of test lazy singleton");
            LazySingleton.DoSomething();
            LazySingleton lazySingleton1 = LazySingleton.Instance;

            LazySingleton lazySingleton2 = LazySingleton.Instance;


            Assert.AreSame(lazySingleton1, lazySingleton2);
        }
Exemple #9
0
        static void Main(string[] args)
        {
            var singleton = Singleton.GetInstance();

            singleton.TextWrite();
            var lazySingleton = LazySingleton.GetInstance();

            lazySingleton.TextWrite();
            var lazyTemplateSingleton = LazyTemplateSingleton.GetInstance();

            lazyTemplateSingleton.TextWrite();
        }
Exemple #10
0
 public LazySingleton getInstance()
 {
     if (_instance == null)
     {
         _instance = new LazySingleton();
     }
     else
     {
         return(_instance);
     }
     return(_instance);
 }
Exemple #11
0
 /// <summary>
 ///
 /// </summary>
 private void Initialize()
 {
     Parallel.For(1, 10000, (index, state) =>
     {
         bag.Add(index * Math.Log(index));
         var _singleton = Singleton.AllSingletons;
         _lazySingleton = LazySingleton <Singleton> .Instance;
         if (_singleton.GetHashCode() == _lazySingleton.GetHashCode())
         {
         }
     });
 }
Exemple #12
0
        public static LazySingleton GetInstance(string value)
        {
            if (_instance == null)            //checks to see if it has already been initialised
            {
                _instance = new LazySingleton // if it hasn't then it creates one and saves it in the private field
                {
                    LValue = value
                };
            }

            return(_instance); // returns the private field
        }
        private static void Main(string[] args)
        {
            Console.WriteLine("Press any key to exit");

            string input = string.Empty;

            while (string.IsNullOrWhiteSpace(input))
            {
                var test = LazySingleton.GetSingleton();

                input = Console.ReadLine();
            }
        }
Exemple #14
0
 public static LazySingleton GetInstance()
 {
     if (instance == null)
     {
         lock (lockObj)
         {
             if (instance == null)
             {
                 instance = new LazySingleton();
             }
         }
     }
     return(instance);
 }
 private void Awake()
 {
     if (instance != null)
     {
         Debug.Log("Destroy " + Tag + " " + gameObject.name);
         Destroy(gameObject);
     }
     else
     {
         Debug.Log("Assign this " + Tag + " instance  with name " + gameObject.name);
         instance = this;
         DontDestroyOnLoad(gameObject);
     }
 }
Exemple #16
0
        public static void Run()
        {
            var lazySingleton = LazySingleton.getInstanceDoubleCheck();

            lazySingleton.showMessage();

            var hungrySingleton = HungrySingleton.getInstance();

            hungrySingleton.showMessage();

            var staticInnerClassSingleton = StaticInnerClassSingleton.getInstance();

            staticInnerClassSingleton.showMessage();
        }
        public static LazySingleton GetInstance()
        {
            if (_instance == null)
            {
                lock (_lockObject)
                {
                    if (_instance == null)
                    {
                        _instance = new LazySingleton();
                    }
                }
            }

            return _instance;
        }
Exemple #18
0
        public static LazySingleton GetInstance()
        {
            if (_instance == null)
            {
                lock (_lockObject)
                {
                    if (_instance == null)
                    {
                        _instance = new LazySingleton();
                    }
                }
            }

            return(_instance);
        }
        /// <summary>
        /// 
        /// </summary>
        private void Initialize()
        {
            Parallel.For(1, 10000, (index, state) =>
            {
                bag.Add(index * Math.Log(index));
              var   _singleton= Singleton.AllSingletons;
                _lazySingleton= LazySingleton<Singleton>.Instance;
                if (_singleton.GetHashCode() == _lazySingleton.GetHashCode())
                {

                }


            });
        }   
Exemple #20
0
        private Task <string> TimeConsumingMethod2()
        {
            var task = Task.Run(() => {
                Console.WriteLine("Helo I am TimeConsumingMethod. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(10000);
                Console.WriteLine("Helo I am TimeConsumingMethod after Sleep(10000). My Thread ID is :" + Thread.CurrentThread.ManagedThreadId);
                LazySingleton instance = LazySingleton.Instance;
                instance.Calculator();
                //NormalClass nc = new NormalClass();
                //nc.Calculator();
                return("Hello I am TimeConsumingMethod" + Thread.CurrentThread.ManagedThreadId);
            });

            return(task);
        }
Exemple #21
0
        public void ZadanieALazySingletonManyTasks()
        {
            Task[] tasks = new Task[100];
            for (int i = 0; i < tasks.Length; i++)
            {
                tasks[i] = new Task(() =>
                {
                    LazySingleton s = LazySingleton.singleton;
                });
                tasks[i].Start();
            }

            tasks.AsParallel().ForAll(task => task.Wait());
            Assert.AreEqual(LazySingleton.constructorCount, 1, "Ilość Singletonów różna od 1!");
        }
        public void MultiThread()
        {
            LazySingleton instance1 = null;
            LazySingleton instance2 = null;

            Parallel.Invoke(
                () => { instance1 = LazySingleton.Instance; },
                () => { instance2 = LazySingleton.Instance; }
                );

            Assert.Multiple(() =>
            {
                Assert.AreSame(instance1, instance2);
                Assert.AreEqual(instance1.GetHashCode(), instance2.GetHashCode());
                Assert.AreEqual(1, LazySingleton.Counter, "There is more than 1 instance!");
            });
        }
Exemple #23
0
        /// <summary>
        /// 简单的Sigleton
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_CommonSingleton_Click(object sender, System.EventArgs e)
        {
            LazySingleton s1 = LazySingleton.Instance;
            LazySingleton s2 = LazySingleton.Instance;

            string strResult = "";

            if (s1.Equals(s2))
            {
                strResult = "[CommonSingleton]the same instance";
            }
            else
            {
                strResult = "[CommonSingleton]the defferent instance";
            }

            UpdateResult(strResult);
        }
Exemple #24
0
        static void Main(string[] args)
        {
            Console.WriteLine("饿汉式 单例类 的处理!");

            for (int i = 0; i < 10; i++)
            {
                EagerSingleton data = EagerSingleton.GetInstance();
                Console.WriteLine(data.DemoCount++);
            }


            Console.WriteLine("懒汉式 单例类 的处理!");

            for (int i = 0; i < 10; i++)
            {
                LazySingleton data = LazySingleton.GetInstance();
                Console.WriteLine(data.DemoCount++);
            }

            Console.ReadLine();
        }
Exemple #25
0
        public static void Main(string[] args)
        {
            Console.WriteLine("Creational Patterns deals with object creation!");
            Console.WriteLine("<---------------------------- Singleton ---------------------------->");
            Parallel.Invoke(() => { SimpleSingleton simpleSingleton = SimpleSingleton.Instance; },
                            () => { SimpleSingleton simpleSingleton = SimpleSingleton.Instance; });
            Parallel.Invoke(() => { ThreadSafeSingleton threadSafeSingleton = ThreadSafeSingleton.Instance; },
                            () => { ThreadSafeSingleton threadSafeSingleton = ThreadSafeSingleton.Instance; });
            Parallel.Invoke(() => { LazySingleton lazySingleton = LazySingleton.Instance; },
                            () => { LazySingleton lazySingleton = LazySingleton.Instance; });

            Console.WriteLine("<---------------------------- Simple Factory ---------------------------->");
            SimpleFactory.ICreditCard card = SimpleFactory.CreditCardFactory.GetCreditCard(SimpleFactory.CreditCardType.Platinum);
            Console.WriteLine($"Credit card Type: {card.GetCardType()}");
            Console.WriteLine($"Credit card Limit: {card.GetLimit()}");
            Console.WriteLine($"Credit card AnnualCharges: {card.GetAnnualCharges()}");

            card = SimpleFactory.CreditCardFactory.GetCreditCard(SimpleFactory.CreditCardType.Titanium);
            Console.WriteLine($"Credit card Type: {card.GetCardType()}");
            Console.WriteLine($"Credit card Limit: {card.GetLimit()}");
            Console.WriteLine($"Credit card AnnualCharges: {card.GetAnnualCharges()}");

            Console.WriteLine("<---------------------------- Factory Method ---------------------------->");
            FactoryMethod.CreditCardFactory creditCardFactory = new PlatinumFactory();
            FactoryMethod.ICreditCard       creditCard        = creditCardFactory.GetCreditCard();
            Console.WriteLine($"Credit card Type: {creditCard.GetCardType()}");
            Console.WriteLine($"Credit card Limit: {creditCard.GetLimit()}");
            Console.WriteLine($"Credit card AnnualCharges: {creditCard.GetAnnualCharges()}");

            creditCardFactory = new TitaniumFactory();
            creditCard        = creditCardFactory.GetCreditCard();
            Console.WriteLine($"Credit card Type: {creditCard.GetCardType()}");
            Console.WriteLine($"Credit card Limit: {creditCard.GetLimit()}");
            Console.WriteLine($"Credit card AnnualCharges: {creditCard.GetAnnualCharges()}");

            Console.WriteLine("<---------------------------- Abstract Factory ---------------------------->");
            ComputerFactory computerFactory = new ComputerFactory(new ExpensiveComputer());

            computerFactory.Assemble();
            computerFactory = new ComputerFactory(new CheapComputer());
            computerFactory.Assemble();

            Console.WriteLine("<---------------------------- Builder ---------------------------->");
            Builder.IComputer computer = new Builder.LaptopBuilder();
            computer.AddCPU("Intel I3");
            computer.AddGPU("AMD Rideon");
            computer.AddRAM("8 GB");
            computer.AddHDD("SATA 500 GB");
            computer.EanbleTouchscreen(true);
            computer.DisplayDetails();

            computer = new Builder.DesktopBuilder();
            computer.AddCPU("Intel I5");
            computer.AddGPU("NVidea");
            computer.AddRAM("16 GB");
            computer.AddHDD("SATA 1 TB");
            computer.AddMonitor("Full HD");
            computer.DisplayDetails();

            Console.WriteLine("<---------------------------- Fluent Builder ---------------------------->");
            FluentBuilder.IComputer computer1 = new FluentBuilder.LaptopBuilder();
            computer1.AddCPU("Intel I3")
            .AddGPU("AMD Rideon")
            .AddRAM("8 GB")
            .AddHDD("SATA 500 GB")
            .EanbleTouchscreen(true)
            .DisplayDetails();

            computer1 = new FluentBuilder.DesktopBuilder();
            computer1.AddCPU("Intel I5")
            .AddGPU("NVidea")
            .AddRAM("16 GB")
            .AddHDD("SATA 1 TB")
            .AddMonitor("Full HD")
            .DisplayDetails();

            Console.ReadLine();
        }
 public void RunExample()
 {
     var singleton           = Singleton.GetInstance();
     var threadSafeSingleton = ThreadSafeSingleton.GetInstance();
     var lazySingleton       = LazySingleton.GetInstance();
 }
        public static void Main(string[] args)
        {
            Shape shape = new Shape(4, 5);

            Console.WriteLine("{0}, {1}", shape.X, shape.Y);

            // ConstReadOnlyStatic
            ConstReadonlyStatic constReadonlyStatic = new ConstReadonlyStatic();

            //RefAndOut (swap numbers and testing Out params)
            RefAndOut refAndOut = new RefAndOut();
            int       a         = 6;
            int       b         = 9;
            int       c;

            refAndOut.SwapNubers(ref a, ref b);
            refAndOut.OutExampleSumNumbers(a, b, out c);
            Console.WriteLine("sum of numbers is : {0}", c);

            // ExtensionMethods
            Class1 c1 = new Class1();

            c1.Display();
            c1.NewMethod();


            //DisposeVsFinalize
            DisposeVsFinalize d = new DisposeVsFinalize();

            d.Dispose();
            d = null;

            // DelegatesDemo
            DelegatesDemo dd = new DelegatesDemo();
            SumDelegate   sd = new SumDelegate(dd.Sum);

            Console.WriteLine("sum is: {0}", sd.Invoke(30, 40));
            sd += dd.Multiply; //multicast delegate
            Console.WriteLine("Multiply : {0}", sd.Invoke(1, 2));

            SumDelegate[] sd1 =
            {
                new SumDelegate(dd.Sum),
                new SumDelegate(dd.Multiply)
            };
            for (int i = 0; i < sd1.Length; i++)
            {
                Console.WriteLine("{0}", sd1[i](2, 5));
                Console.WriteLine("{0}", sd1[i](8, 5));
                Console.WriteLine("{0}", sd1[i](4, 6));
            }

            //EventsDemo
            EventsDemo ed = new EventsDemo();

            event1 += new SampleDel(ed.India);
            event1 += new SampleDel(ed.USA);
            event1 += new SampleDel(ed.Netherlands);

            event1.Invoke();
            event1 -= new SampleDel(ed.USA);
            event1.Invoke();

            ed.Action("hello");
            ed.xyz += new StrDel(ed.Action);


            //MicrosoftEventsPattern demo
            MicrosoftEventPattern mep = new MicrosoftEventPattern();

            mep.MyEvent += new MicrosoftEventPattern.MyDelegate(mep.DisplayMsg);
            mep.RaiseEvent("Hello from the event!!!");

            // Patter 2 demo
            MicrosoftEventPattern2 mep2 = new MicrosoftEventPattern2();

            mep2.MyEvent2 += new MicrosoftEventPattern2.MyDelegate2(mep2.DisplayMsg);
            mep2.RaiseEvent("Hello MEP !!!!", 26);

            //IEnumerableDemo
            IEnumerableDemo id = new IEnumerableDemo();

            id.Print();
            id.ListOperations();


            Test t1 = new Test();

            t1.Name    = "Bhawna";
            t1.Surname = "Deonani";
            Test t2 = new Test();

            t2.Name    = "Darwin";
            t2.Surname = "Rajpal";
            Test myList = new Test();

            myList.Add(t1);
            myList.Add(t2);
            foreach (Test obj in myList)
            {
                Console.WriteLine("Name:- " + obj.Name + " Surname :- " + obj.Surname);
            }

            // static Polymorphism
            StaticPolymorphism sp = new StaticPolymorphism();

            sp.Add(1, 2);
            sp.Add("bhawna", "deonani");

            //Dynamic Polymorphism
            //Method hiding using new keyword
            Base b2 = new Base();

            b2.Foo();

            Base base1 = new Child1();

            base1.Foo();

            Child1 child1 = new Child1();

            child1.Foo();

            // Method overriding
            Base b3 = new Child2();

            b3.Foo();

            Child1 child11 = new Child3();

            child11.Foo();

            //Abstract methods
            Base2 b123 = new ChildAbstract();

            b123.Test();
            b123.Test1();

            //Interfaces, you can create interface objects only for instance of class
            // Meaning that You cannot instantiate an interface
            // even if the object here is of interface type but the memory is allocated only for the class
            IInterface1 iiii = new A();

            iiii.Print();

            A aa = new A();

            aa.Sum(2, 3);
            aa.Display();

            B bb = new B();

            bb.Sum(33, 44);
            bb.Print();

            // this can only call interface 1 methods
            IInterface1 ii1 = aa;

            ii1.Print();
            ii1.Sum(5, 6);


            //This can only call interface 2 methods
            IInterface2 ii2 = aa;

            ii2.Display();

            if (ii1 is IInterface2)
            {
                IInterface2 interface2 = (IInterface2)ii1;
                interface2.Display();
            }

            IInterface2 int21 = ii1 as IInterface2;

            int21.Display();

            //ConstructorsDemo

            ClassConst cd  = new ClassDerived();
            ClassConst cd1 = new ClassDerived("Bhawna");

            //Array
            ArrayClass ar = new ArrayClass();

            ar.ReverseArray();

            //Ienumerable
            Test1 t11 = new Test1();

            t11.Display();

            IEnumerable <int> e1 = t11.GetPowersofTwo();

            foreach (int i in e1)
            {
                Console.WriteLine(i.ToString());
            }

            //Singleton Demo
            //only one object is created via using a static property and Private constructor
            SingletonClass a1 = SingletonClass.Instance;

            a1.Test();

            //Threadsafe singleton demo
            ThreadSafeSingleton tss = ThreadSafeSingleton.Instance;

            tss.Test();

            ThreadSafeSingleton1 tss1 = ThreadSafeSingleton1.Instance;

            tss1.Test();

            //Thread Safe Singleton without using locks and no lazy instantiation
            ThreadSafeSingletonNoLocksNoLazy tnl = ThreadSafeSingletonNoLocksNoLazy.Instance;

            tnl.Test();

            LazySingleton ls = LazySingleton.Instance;

            ls.Test();

            //using .NET 4's Lazy<T> type
            LazyClassSingleton lcs = LazyClassSingleton.Instance;

            lcs.Test();

            //Object Pooling in .Net
            Factory f  = new Factory();
            Student s1 = f.GetStudentObject();

            s1.FirstName = "BHawna"; s1.LastName = "deonani";
            Console.WriteLine("First object: {0}, {1}: ", s1.FirstName, s1.LastName);
            Student s2 = f.GetStudentObject();

            s2.FirstName = "Darwin"; s2.LastName = "Rajpal";
            Console.WriteLine("Second Object: {0}, {1}: ", s2.FirstName, s2.LastName);
            Student s3 = f.GetStudentObject();

            if (s3.FirstName == null && s3.LastName == null)
            {
                s3.FirstName = "Nyra"; s3.LastName = "Darwin Rajpal";
            }
            Console.WriteLine("Third Object: {0}, {1}: ", s3.FirstName, s3.LastName);
            Student s4 = f.GetStudentObject();

            if (s4.FirstName == null && s4.LastName == null)
            {
                s4.FirstName = "N"; s4.LastName = "DR";
            }
            Console.WriteLine("Fourth Object: {0}, {1}: ", s4.FirstName, s4.LastName);
            Student s5 = f.GetStudentObject();

            if (s5.FirstName == null && s5.LastName == null)
            {
                s5.FirstName = "Hello"; s5.LastName = "World";
            }
            Console.WriteLine("Fifth Object: {0}, {1}: ", s5.FirstName, s5.LastName);


            // ACtionFuncPredicate Demo

            ActionFuncPredicate afp = new ActionFuncPredicate();

            Action <int> action = new Action <int>(afp.ActionMethod);

            action.Invoke(100);

            Func <int, int, int> func = new Func <int, int, int>(afp.FuncMethodSum);

            func.Invoke(2, 3);

            Predicate <int> predicate = new Predicate <int>(afp.IsPositive);

            predicate.Invoke(3);
            predicate.Invoke(-234);

            //Generics Demo (provides typesafety, performance, and code reuse)
            GenericsDemo gd = new GenericsDemo();
            int          a12 = 3, b12 = 4;
            string       str1 = "bhawna", str2 = "deonani";

            gd.Swap(ref a12, ref b12);
            gd.Swap(ref str1, ref str2);

            gd.ReverseUsingStack();

            //MultithreadingDemo
            Console.WriteLine("Main method");
            MultithreadingDemo md1 = new MultithreadingDemo();
            int    a222            = 10;
            Thread t   = new Thread(new ParameterizedThreadStart(md1.Method));
            Thread t21 = new Thread(new ParameterizedThreadStart(md1.Method));

            t.Start(a222);
            t21.Start(a222);

            Thread[] tArr = new Thread[5];
            for (int i = 0; i < tArr.Length; i++)
            {
                tArr[i] = new Thread(new ThreadStart(md1.Calculate));
                Console.WriteLine("Working from Thread: {0}", i);
                tArr[i].Name = i.ToString();
            }

            foreach (Thread ttt in tArr)
            {
                ttt.Start();
            }

            for (int i = 0; i < 4; i++)
            {
                Thread tmutex = new Thread(new ThreadStart(MultithreadingDemo.MutexDemo));
                tmutex.Name = string.Format("Thread {0} :", i + 1);
                tmutex.Start();
            }

            //Semaphore demo
            for (int i = 0; i < 5; i++)
            {
                Thread abc = new Thread(new ParameterizedThreadStart(MultithreadingDemo.SemphoreDemo));
                abc.Start(i);
            }



            Console.ReadLine();
        }
 public void LazySingeltonConstructorWithOverloadConstructorCreatesObject()
 {
   var lazy = new LazySingleton<Dictionary<string, object>>(() => new Dictionary<string, object>());
   Assert.IsNotNull(lazy, "new LazySingelton can not be null.");
 }
 public void IsValueCreatedWithOverloadConstructorIsFalseTest()
 {
   var lazy = new LazySingleton<Dictionary<string, object>>(() => new Dictionary<string, object>());
   Assert.IsFalse(lazy.IsValueCreated, "IsValueCreated must be false by default.");
 }
Exemple #30
0
        public void ZadanieALazySingletonOneTask()
        {
            LazySingleton s = LazySingleton.singleton;

            Assert.AreEqual(LazySingleton.constructorCount, 1, "Ilość Singletonów różna od 1!");
        }
 public void LazySingeltonDefaultConstructorCreatesObject()
 {
   var lazy = new LazySingleton<Dictionary<string, object>>();
   Assert.IsNotNull(lazy, "new LazySingelton can not be null.");
 }
Exemple #32
0
 internal RuleContext(Action <RuleContext> completeHandler, LazySingleton <Dictionary <IPropertyInfo, object> > outputPropertyValues, LazySingleton <List <IPropertyInfo> > dirtyProperties, RuleContextModes executeContext)
 {
     _completeHandler      = completeHandler;
     _outputPropertyValues = outputPropertyValues;
     _dirtyProperties      = dirtyProperties;
     ExecuteContext        = executeContext;
 }
Exemple #33
0
 internal RuleContext(Action <RuleContext> completeHandler)
 {
     _completeHandler      = completeHandler;
     _outputPropertyValues = new LazySingleton <Dictionary <IPropertyInfo, object> >();
     _dirtyProperties      = new LazySingleton <List <IPropertyInfo> >();
 }
Exemple #34
0
        public void LazySingeltonDefaultConstructorCreatesObject()
        {
            var lazy = new LazySingleton <Dictionary <string, object> >();

            Assert.IsNotNull(lazy, "new LazySingelton can not be null.");
        }
Exemple #35
0
        public void LazySingeltonConstructorWithOverloadConstructorCreatesObject()
        {
            var lazy = new LazySingleton <Dictionary <string, object> >(() => new Dictionary <string, object>());

            Assert.IsNotNull(lazy, "new LazySingelton can not be null.");
        }
Exemple #36
0
        public void IsValueCreatedWithOverloadConstructorIsFalseTest()
        {
            var lazy = new LazySingleton <Dictionary <string, object> >(() => new Dictionary <string, object>());

            Assert.IsFalse(lazy.IsValueCreated, "IsValueCreated must be false by default.");
        }