Codechef4u is a community for computer professionals,by computer professionals,just like you; who loves sharing and helping each others,Join them
Share your post

Understanding polymorphism with abstract, virtual and override keyword in C#

The Abstract Modifier

The abstract modifier indicates that the thing being modified has a missing or incomplete implementation. The abstract modifier can be used with classes, methods, properties, indexers, and events.

The Virtual Keyword

The virtual keyword is used to modify a method, property, indexer, or event declaration and allow for it to be overridden in a derived class.

The Override Modifier

The override modifier is required to extend or modify the abstract or virtual implementation of an inherited method, property, indexer, or event.

Override Rules

  • The overridden base method is a virtual, abstract, or override method. In other words, the overridden base method cannot be static or non-virtual.
  • The overridden base method is not a sealed method.
  • The override method and the overridden base method have the same return type and same signature.
  • The override declaration and the overridden base method have the same declared accessibility (i.e public, internal etc).
  • The override declaration does not specify type-parameter-constraints-clauses. Instead the constraints are inherited from the overridden base method.

Reference: https://docs.microsoft.com/

Code example

In following example override modifier is used to implement the abstract and extend virtual implementation of an inherited methods Print () and Display (), always it will call extended/ modified members.

   public abstract class OverrideParent
    {
        //Concreate implementation, child allowed to override
        public virtual void Print()
        {
            Console.WriteLine("Parent virtual print");
        }
 
        //pure abstract member, child must override
        public abstract void Display();
    }

 

    public class ChildOverride :OverrideParent
    {
        public override void Print()
        {
            Console.WriteLine("1st level print override");
        }
        public override void Display()
        {
            Console.WriteLine("1st level implementation");
        }
    }

 

    public class NestedChildOverride: ChildOverride
    {
        public override void Print()
        {
            Console.WriteLine("2nd level print override");
        }
        public override void Display()
        {
            Console.WriteLine("2nd level override/implementation");
        }
    }

 

Client implementation 

   //How it works?
    class Program
    {
        static void Main(string[] args)
        {
            OverrideParent ParentTypeChildImpn = new ChildOverride();
            ChildOverride ChildTypeChildImpn = new ChildOverride();
            ChildOverride ChildTypeNestedChldImpl = new NestedChildOverride();
            NestedChildOverride NestedChildTypeNestedImpl= new NestedChildOverride();
 
            //parent abstract type and child implementation
            ParentTypeChildImpn.Print();
            ParentTypeChildImpn.Display();
 
            //child type and child implementations
            ChildTypeChildImpn.Print();
            ChildTypeChildImpn.Display();
 
            //Child type and derived nested implementations
            ChildTypeNestedChldImpl.Print();
            ChildTypeNestedChldImpl.Display();
 
            //Nested child type and nested implementations
            NestedChildTypeNestedImpl.Print();
            NestedChildTypeNestedImpl.Display();
 
 
          }
    }


Output:

 

Anonymous methods in C#?

What is anonymous method in C#?

A method without a name is called as an anonymous method is, the delegate operator creates an anonymous method that can be converted to a delegate type.

What is use of anonymous methods in C#?

  • You can use an anonymous method to create an anonymous function with unnamed inline code.
  • C# 2.0 introduced the concept of anonymous methods to write unnamed inline statement blocks that can be executed in a delegate invocation.

How to create and use anonymous method?

An anonymous method behaves like a regular method and allows us to write inline code in place of explicitly named methods.

Code example

//declare delegate
delegate void displayFullName(string fname, string mName, string lName);
 
//instantiate delegate with anonymous method
displayFullName fullName = delegate (string fname, string mName, string lName) {
    Console.WriteLine("Full name: " + fname + " " + mName + " " + lName);
   };


 
//anonymous method with generic action delegate
Action<string, stringstring> userFullName = delegate (string fname, string mName, string lName)
{
  Console.WriteLine("User full name: " + fname + " " + mName + " " + lName);
}; 

Anonymous function in C#

 What is anonymous function in C#?

An anonymous function is an "inline" statement or expression that can be used wherever a delegate type is expected.

You can use it to initialize a named delegate or pass it instead of a named delegate type as a method parameter.

You can use a lambda expression or an anonymous method to create an anonymous function. We recommend using lambda expressions as they provide more concise and expressive way to write inline code.

Reference…https://docs.microsoft.com/

How to use anonymous function in C#?

Anonymous function code examples using,

  • Delegate with named method,
  • Lambda expression
  • Delegate with anonymous method
  • Built-in delegates (Func & Action delegates)


delegate void SampleDelegate(string x);

    

public class AnonymousFunctions
    {
         static void DisplayData(string x)
        {
            Console.WriteLine("Data is :" + x);
        }
        static void AnonymousSamples()
        {
            // initialization with a named method.
            SampleDelegate testNamed = new SampleDelegate(DisplayData);
 
            // C# 2.0: A delegate can be initialized with
            // inline code, called an "anonymous method." This
            // method takes a string as an input parameter.
            SampleDelegate TestAnMethod = delegate (string s) { Console.WriteLine(s); };
 
            // C# 3.0. A delegate initialization with a lambda expression.
            // The lambda also takes a string
            // as an input parameter (x). The type of x is inferred by the compiler.
            SampleDelegate TestLambdaExp = (x) => { Console.WriteLine(x); };
 
            //Anonymous function with action generic delegate
            Action<string> TestDelGeneric = (s) => { Console.WriteLine(s); };
 
            // Anonymous function with action delegate without paremeters.
            Action TestDelActGen = () => { Console.WriteLine("Codechef4U samples"); };
 
            //Anonymous Function with func generic delegate, first 2
            // parameters are input, and last parameter is result
            Func<string, string, string> GetCombinedString = (x, y) => { return x+ " " + y; };
 
            //Anonymous Function with predicate generic delegate
            Predicate<string> isValidSurName = (x) => { return x != null && x.Length >2 ? true : false; };
 
            // Invoke the delegates.
            DisplayData("The named method call using delegate .");
            TestAnMethod("The anonymous method call.");
            TestLambdaExp("The lambda call.");
            TestDelGeneric("The action generic delegate .");
            TestDelActGen();
            Console.WriteLine("Full name is: "+ GetCombinedString("Aditya", "Kendre"));
            Console.WriteLine("Is valid name :" + isValidSurName("Kendre"));
        }
    }