Shape area calculation
I think your names could be simplified.  For instance, the ShapeType enum could be:

public enum ShapeType { Square, Circle, Triangle }

Because ShapeType.SquareShape sounds redundant, whereas ShapeType.Square still clearly indicates that the square is a shape type.

The ShowArea method is not needed.  It would most likely be used to display console writes, but your shape classes should not concern themselves with writing to the console.  You could modify ShowArea to return a string, but that string would be nothing more than the numeric area converted to a string.

CalculateAndShowArea should be in the client, as it issues several calls and it - not the respective IShape instance - should take care of console writes.

But most importantly, the area calculation should be done within the shape classes.  The problem with your code as posted is it lacks many critical things that help distinguish among different shape types.  For instance, a circle would be defined at the very least by a radius, and you may consider a center XY point along with a radius.  This allows you to calculate the circle's area.  Likewise, a square should be defined by a length of one of its sides.  And again, a square could then calculate its area.

A triangle is a different creature.  There are different ways to construct a triangle.  One way is passing in 3 non-colinear points.  Another way might be passing in 3 line segment lengths.  But a triangle constructor would also have to contain validation that whatever was passed in creates a truly valid triangle.  

Which makes a singular factory method to generate 3 very different shapes fairly useless, unless you imposed a restriction that it would be a circle with radius 1, a square with side length of 1, and a triangle with 2 sides of length 1.  But if you do that, you've reduced the flexibility of the specific shape classes.

Also, the method name CalculateArea is bit long.  A more standard name would be GetArea, but many people would really choose to have a readonly property named Area.

Example

public interface IShape
{
    double Area { get; }
    string Name { get; }
}
public class Square : IShape
{
    // May consider Length be a double
    public int Length { get; }
    public Square(int side)
    {
        Length = side;
    }
    public double Area =&gt; Length * Length;
    public string Name =&gt; "Square";
    public override string ToString() =&gt; $"{Name}: Length={Length}";
}
public class Circle : IShape
{
    // Might consider making this a double
    public int Radius { get; }
    public Circle(int radius)
    {
        Radius = radius;
    }
    public double Area =&gt; Math.PI * Radius * Radius;
    public string Name =&gt; "Circle";
    public override string ToString() =&gt; $"{Name}: Radius={Radius}";
}
// Triangle class is left to you.


This makes your shape constructor more tailor made for each specific shape, but it also means you may not be able to construct it via a singular factory method without some significant changes.

UPDATE

As noted by Jesse Slicer in the comments, each class could identify itself better.  Jesse suggests having each class could have a Shape property that would echo its ShapeType.  It a decent idea but one that I would modify slightly.  I see the ShapeType enum as belong to the factory method.  I think a design should allow for the possibility of a shape that isn't specified in the enum but that implements IShape.  Thus I would have each class implement its type, and we can ditch the Name property.

public interface IShape
{
    double Area { get; }
    Type Type { get; }
}
public class Square : IShape
{
    // May consider Length be a double
    public int Length { get; }
    public Square(int side)
    {
        Length = side;
    }
    public double Area =&gt; Length * Length;
    public Type Type =&gt; GetType();
    public override string ToString() =&gt; $"{Type.Name}: Length={Length}";
}
public class Circle : IShape
{
    // Might consider making this a double
    public int Radius { get; }
    public Circle(int radius)
    {
        Radius = radius;
    }
    public double Area =&gt; Radius * 2 * Math.PI;
    public Type Type =&gt; GetType();
    public override string ToString() =&gt; $"{Type.Name}: Radius={Radius}";
}