What are the differences between dynamic polymorphism, abstract classes and interfaces from an OOP perspective as reflected in C#?
<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>