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();
}