public void ShouldCReturnTheSameInstance()
{
var instance1 = ThreadSafeSingleton.GetInstance();
var instance2 = ThreadSafeSingleton.GetInstance();
instance1.Should().BeSameAs(instance2);
}
public void ShouldCreateInstance()
{
var instance = ThreadSafeSingleton.GetInstance();
instance.Should().NotBeNull();
instance.Should().BeOfType <ThreadSafeSingleton>();
}
private static void Main(string[] args)
{
Console.WriteLine("Singleton Mode Demo");
SimpleSingleton.Instance();
Singleton.Instance();
ThreadSafeSingleton.Instance();
}
public static ThreadSafeSingleton GetInstance()
{
lock (locker)
{
if (_loggerInstance == null)
{
_loggerInstance = new ThreadSafeSingleton();
}
}
return(_loggerInstance);
}
public void TestThreadSafeSingleton()
{
ThreadSafeSingleton anyClass = ThreadSafeSingleton.GetInstance;
anyClass.AnyMethod("My anyClass call instance of singleton");
ThreadSafeSingleton anyClass2 = ThreadSafeSingleton.GetInstance;
anyClass2.AnyMethod("My anyClass2 use the same instance of singleton");
Assert.AreSame(anyClass, anyClass2);
}
public int ProcessTo(int end)
{
int sum = 0;
for (int i = _start; i <= end; ++i)
{
sum += i;
}
ThreadSafeSingleton.GetInstance().Log(
"Processor обчислив деяке значення: " + sum);
return(sum);
}
static void Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;
ThreadSafeSingleton logger = ThreadSafeSingleton.GetInstance();
Processor processor = new Processor(1);
logger.Log("Почалася робота...");
processor.ProcessTo(5);
logger.Log("Робота завершилася...");
Console.ReadKey();
}
public static ThreadSafeSingleton GetInstance()
{
if (_instance == null)
{
lock (_lockObject)
{
if (_instance == null)
{
_instance = new ThreadSafeSingleton();
}
}
}
return(_instance);
}
public void ThreadSafeSingletonTest()
{
var process1 = new Thread(() => { ThreadSafeSingleton.GetInstance("FOO"); });
var process2 = new Thread(() =>
{
ThreadSafeSingleton.GetInstance("BAR").Value.Should().Be("FOO");
;
});
process1.Start();
process2.Start();
process1.Join();
process2.Join();
}
static void Main(string[] args)
{
SingletonClass singletonOne = SingletonClass.Instance;
singletonOne.ShowMessage();
SingletonClass singletonTwo = SingletonClass.Instance;
DoWork(singletonTwo);
// потокобезопасная реализация
(new Thread(() =>
{
ThreadSafeSingleton instanceOne = ThreadSafeSingleton.Instance;
}
)).Start();
ThreadSafeSingleton instanceTwo = ThreadSafeSingleton.Instance;
Console.ReadLine();
}
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 Processor(int start)
{
_start = start;
ThreadSafeSingleton.GetInstance().Log("Processor створено.");
}
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();
}
