Ambiguity in interfaces - C#

Question

Hello,

Why can't I public a member of an interface when I explicitly write the name of the interface?

Please see:

   public class CountDown : IEnumerator
   {
        int count = 11;
        object IEnumerator.Current => count;

        public bool IEnumerator.MoveNext() // ERROR
        {
             return count-- > 0;
        }

        void IEnumerator.Reset()
        {
             throw new NotImplementedException();
        }
   }

using System.Collections;

namespace ConsoleApp1
{
     public class CountDown : IEnumerator
     {
          int count = 11;
          object IEnumerator.Current => count;

          public bool MoveNext() // OK
          {
               return count-- > 0;
          }

          void IEnumerator.Reset()
          {
               throw new NotImplementedException();
          }
     }
     internal class Program
     {
          static void Main(string[] args)
          {
               CountDown CD = new();
               Console.WriteLine();
          }
     }
}

Answer 1

Because it’s a member of the class’s interface implementation, not the class. When an interface implementation contains the interface name prefix, it’s only callable when the instance is cast to the interface.

interfaces were designed to implement multi-inheritance. the code supplies the common implementation. the public definition is the common, but you can supply implementations just for when cast to an interface,

     public class CountDown : IEnumerator
     {
          int count = 11;
          object IEnumerator.Current => count;

          // public implementation 
          public bool MoveNext() // OK
          {
               return count-- > 0;
          }
          // implementation used if cast to IEnumerator
          bool IEnumerator.MoveNext()
          {
             return count-- > 0;
          }
          void IEnumerator.Reset()
          {
               throw new NotImplementedException();
          }
     }

note: the main use case of explicit interface implementation is when you don't want the method to be available unless cast to the interface. this would happen if you implemented two interfaces with the same signature, but need different implementations.