method that receives the matrix values as a string

I've inserted some code below for the ComplexNumber constructor which takes a string as an argument. In order to do this, it was necessary to add a helper method to parse the real and imaginary parts in isolation.

Indexers are only relevant in the case of collection classes to enable you to index the collection as if it were an array. As a complex number isn't really a collection, you don't need one here.

You really need to write a 'recursive descent parser'to parse an arbitrary complex number expression which is not a trivial undertaking. However, working on the convention that the complex numbers will not have any spaces in them but the operators will have spaces either side (as in the last three expressions in your Main() method) it is possible to write a simple parser which I've done below in the Calculate() method. I've assumed that you'd want multiplication to have precedence over addition/subtraction as in normal arithmetic expressions.

As it's easier to work backwards when evaluating binary expressions, it was necessary to change all subtractions into additions which required that an overload of the unary minus operator be added to the ComplexNumber class.

Incidentally, if they're expecting you to figure all this out in exam conditions without having done anything like it before, then I'm not surprised you've failed it!

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Test_1_1
{
    abstract class RealNumber
    {
        protected float real;
        public abstract float Real { get; }
    }

    class ComplexNumber : RealNumber
    {
        private float imaginary;

        // helper method to parse a pure real or pure imaginary number
        private void ParseElement(string value)
        {
            if (value.IndexOf('i') > -1)
            {
               if (value == "i" || value == "+i")
               {
                  imaginary = 1.0f;
               }
               else if (value == "-i")
               {
                  imaginary = -1.0f;
               }
               else
               {  
                  imaginary = float.Parse(value.Replace("i", ""));
               }
            }
            else
            {        
               real = float.Parse(value);
            }
         }

        public ComplexNumber()
        {
            real = 0.0f;
            imaginary = 0.0f;
        }

        public ComplexNumber(float realValue, float imaginaryValue)
        {
            real = realValue;
            imaginary = imaginaryValue;
        }

        public ComplexNumber(string value)
        {
            if (value == null || value.Trim() == "")
            {
               real = 0.0f;
               imaginary = 0.0f;
            }
            else
            {     
              value = value.Replace(" ", ""); // remove spaces
              char[] ca = new char[]{'+','-'};
              int index = value.IndexOfAny(ca, 1); // ignore first character
              if (index == -1)
              {
                  ParseElement(value);
              }
              else
              {             
                  string temp1 = value.Substring(0, index);
                  string temp2 = value.Substring(index);
                  ParseElement(temp1);
                  ParseElement(temp2);
              }
           }
        }

        public override float Real
        {
            get
            {
                return real;
            }
        }

        public float Imaginary
        {
            get
            {
                return imaginary;
            }
        }

        public static ComplexNumber operator +(ComplexNumber complex1, ComplexNumber complex2)
        {
            ComplexNumber result = new ComplexNumber();

            result.real = complex1.real + complex2.real;
            result.imaginary = complex1.imaginary + complex2.imaginary;

            return result;
        }

        public static ComplexNumber operator -(ComplexNumber complex1, ComplexNumber complex2)
        {
            ComplexNumber result = new ComplexNumber();

            result.real = complex1.real - complex2.real;
            result.imaginary = complex1.imaginary - complex2.imaginary;

            return result;
        }

        // unary minus
        public static ComplexNumber operator -(ComplexNumber complex)
        {
            complex.real = -complex.real;
            complex.imaginary = -complex.imaginary;

            return complex;
        }

        public static ComplexNumber operator *(ComplexNumber complex1, ComplexNumber complex2)
        {
            ComplexNumber result = new ComplexNumber();

            result.real = complex1.real * complex2.real - complex1.imaginary * complex2.imaginary;
            result.imaginary = complex1.real * complex2.imaginary + complex1.imaginary * complex2.real;

            return result;
        }

        public override string ToString()
        {
            return "( " + real + ( imaginary < 0 ? " - " + ( imaginary * -1 ) : " + "  + imaginary ) + "i )";
        }
    }

    class ComplexNumberCalculator
    {
        public ComplexNumberCalculator()
        {
 
        }

        public ComplexNumber Calculate(string value)
        {
           // split 'value' into operands and operators
           List