title: What are the differences between dynamic polymorphism, abstract classes and interfaces from an OOP perspective as reflected in C#?
body: <p><strong>Notes:</strong></p>
  
  <ol>
  <li>Besides the logical differences, I am also interested to know about the technical differences as reflected in C# specifically (hence, it is not a question for <a href="https://softwareengineering.stackexchange.com/">Programmers</a>).</li>
  <li><a href="https://stackoverflow.com/questions/4762930/comparison-interface-methods-vs-virtual-methods-vs-abstract-methods/4762965#4762965">This question</a> is a bit similar, but it asks about <em>methods</em> while I am asking about <em>classes</em>, so it is not a duplicate.</li>
  </ol>
  
  <hr>
  
  <p><code>Circle</code> and <code>Rectangular</code> are shapes. Both have a perimeter and an area, but different implementations for calculating them. I can see three different way to implement such a logic, and I am not sure what is the difference between these approaches.</p>
  
  <p><strong>Using dynamic polymorphism:</strong></p>
  
  <pre><code>class Shape
  {
      public virtual double Perimeter() { /* logic */ }
      public virtual double Area() { /* logic */ }
  }
  
  class Rectangular : Shape
  {
      public override double Perimeter() { /* logic */ }
      public override double Area() { /* logic */ }
  }
  
  class Circle : Shape
  {
      public override double Perimeter() { /* logic */ }
      public override double Area() { /* logic */ }
  }
  </code></pre>
  
  <p><strong>Using an abstract class:</strong></p>
  
  <pre><code>abstract class Shape
  {
      public abstract double Perimeter() {}
      public abstract double Area() {}
  }
  
  class Rectangular : Shape
  {
      public override double Perimeter() { /* logic */ }
      public override double Area() { /* logic */ }
  }
  
  class Circle: Shape
  {
      public override double Perimeter() { /* logic */ }
      public override double Area() { /* logic */ }
  }
  </code></pre>
  
  <p><strong>Using an interface:</strong></p>
  
  <pre><code>interface IShape
  {
      double Perimeter();
      double Area();
  }
  
  class Rectangular : IShape
  {
      public double Perimeter() { /* logic */ }
      public double Area() { /* logic */ }
  }
  
  class Circle: IShape
  {
      public double Perimeter() { /* logic */ }
      public double Area() { /* logic */ }
  }
  </code></pre>
  
  <p>In the title, I mentioned that I am interested in an answer from the perspective of OOP. I want to understand the theoretical differences between the approaches, based on the OOP paradigm, and from that - understand the technical differences. For example, I know that interfaces methods cannot have an implementation while virtual methods can, but I do not understand <strong>why</strong> it consists with the OOP paradigm.</p>
  
  <p>Please answer with all the theoretical differences and for each difference, the derived technical difference in C#.</p>
  
  <p>Many thanks.</p>
  
  <hr>
  
  <p><strong>Edit:</strong> 
  @AdrianoRepetti and @Biscuits say that my question is vague. My English is not great, so I will try to explain myself as clearly as I can.</p>
  
  <p>I showed three different ways of doing the same thing. But is it really the same thing? What are the differences between them from a program architecture POV? I mean, when I design the program, why should I choose one over the other? What are the <strong>essential</strong> differences, and how those differences are expressed in the syntax of C#? I hope my question is clearer now.</p>
  
  <p>If someone who speaks good English think he/she understand my question and can edit it to be clearer and grammarly correct, I will be grateful.</p>
  
  <p>Thanks a lot!</p>