#63 Polymorphism-C#

Polymorphism: Takes Many Forms.

Types:

1.Compile Time-(Early Binding/Overloading):Methods can have same name,with different number of arguments.

2.Run Time-(Late Binding/dynamic):Objects of Base Class can Point to objects of Derived class At Runtime.(using Override)

#62 Action Filters-Authorization

Authorize Attribute is used to restrict the controller/Action with respect to Users.

Authorize Attribute-takes Roles,Users,Order as parameters

/*Authorize users whose role is admin*/
[Authorize(Roles = "admin")] 
<span style="font-style: inherit; font-weight: inherit; line-height: 1.625;">public ActionResult Index()</span>
{
 return Content("Hello");
 }

#60 Lock-C#

Lock is a thread safe mechanism,where you allow only one thread to access a  block of code(Critical Section) and block other threads,untill the current thread releases the lock(Mutual Exclusion).

lock (object)
 {
 // crtical section
 }

Internally the Lock get’s translated with Monitor.Enter(Object) and Monitor.Exit(object). Lock is a wrapper/high level construct provided by C#.

#57 Synchronization Constructs-Thread

Thread Synchronization Constructs can be performed in two ways 

1.User Mode Constructs-They utilize Hardware(Cpu Instruction to make thread safe),no interruption of OS.(Volatile,InterLocked,SpinLock).

 

2.Kernel Mode Constructs -Operating System takes care of thread synchronizations,and the os provide certain mechanism to handle thread safe block.(WaitHandle,Semaphore,Mutex)

A block  operation by thread in User Mode  is called LiveLock(Usage of CPU Forever). A block operation by thread in Kernel mode is called DeadLock(Wastage of Memory) 

#56 Critical Sections-Threads

Critical Section: Critical Section is a piece of code or a shared resource that  must not be accessed concurrently by different threads.

Problems(If CS is not handled):

1.Race Condition.

2.DeadLock

Mechanism to handle Critical Section:

1.Atomic Updates

2.Partitioning

3.Wait-Based Synchronization Protocol. 

#55: When should you throw exception ?

When you make an Assumption of function and it it violates the assumption ,then you might probably need to throw an exception. For instance,Let’s assume that we have function which returns true if the length of List is greater than 50 and false if it is less than 50.Now what if the list is Null?(function Doe not have assumption ) ,this creates the necessary to throw exception  

//This functions assume that you past list item filled with inetgers.
//It is not assumed that list might be null,so here you need to throw exception
private static bool ValidateListLength(List&lt;int&gt;l)
 {
 try
 {
 return l.Count&gt;50;
 }
 catch 
 {
 throw ;
 }
 return false;
 }

#54: Invoking Explicit Interface-Cannot Invoke with Class Instance,but requires Interface Instance

You cannot Invoke Explicit Interface with Class Instance,You require Interface Instance to call the Explicit Interface

 class Sample:ITest
 {
 //Interface Defined Explicitly
 void ITest.Test()
 {
 Console.WriteLine(&amp;quot;Hello&amp;quot;);
 }
 }

To Invoke the explicit interface,you need Interface Instance,not the class instance

/*You cannot invoke Explicit Interface with Class Instance but the 
 Interface instance. ITest is the inetrface instance
 */
 ITest s1 = new Sample();
 s1.Test();

#53 Mutiple Interface with Same Contract

Let’s Assume we have two interface with same contract:

interface ITest
 {
 void Test(); //Same Contract as of other interface
 }
interface ITest1
 {
 void Test(); //Same Contract as of other interface
 }

To define both the Interface with same contract  in a class,you have to define Interface Explicitly without Access Modifier.

class Sample:ITest,ITest1
 {
 void ITest.Test()
 {
 Console.WriteLine("Hello");
 }
 void ITest1.Test()
 {
 Console.WriteLine("Hello1");
 }
 } 

To invoke the specific Contract,

//You cannot invoke Explicit Interface with Class Instance.
 ITest s1 = new Sample();
 s1.Test();
 ITest1 s2 = new Sample();
 s2.Test();