Questionable compiler error on the method’s argument, derived from the type of its formal parameter.

Question

Hello,

I am getting a compiler error, which seems illogical to me.
It would take longer to describe the problem, than to reproduce it.
Just insert, please, a slash after the very first slash in the code below, and the compiler will make the problem obvious.

Could somebody tell me if this is a bug in the compiler or I am missing something, and the compiler works as designed?

using System;
using System.Collections;
using System.Collections.Generic;

namespace TestConsoleApp {
    class CEnumerable<ElemTypeBase> : IEnumerable<ElemTypeBase> where ElemTypeBase : class {
        public IEnumerator<ElemTypeBase> GetEnumerator() { throw new NotImplementedException(); }
        IEnumerator IEnumerable.GetEnumerator() { throw new NotImplementedException(); }
    }
    class CElemTypeBase { }
    class CElemTypeDerived : CElemTypeBase { }
    class Program {
        /* // To see the problem, insert a slash after the very first slash in this line and compile.
        // Why the line below causes problems,
        static public void MethodElemEnumArg(CEnumerable<CElemTypeBase> enumArg) { } // Problematic signature.
        /*/ // while the next line does not?
        static public void MethodElemEnumArg(IEnumerable<CElemTypeBase> enumArg) { }
        //*/
        static public void MethodElemArg(CElemTypeBase elemArg) { }
        static void Main() {
            CEnumerable<CElemTypeBase> enumBase = new CEnumerable<CElemTypeBase>();
            CEnumerable<CElemTypeDerived> enumDerived = new CEnumerable<CElemTypeDerived>();
            CElemTypeBase argBase = new CElemTypeBase();
            CElemTypeBase argDerived = new CElemTypeDerived();
            MethodElemArg(argBase);
            MethodElemArg(argDerived); // Surely works.
            MethodElemEnumArg(enumBase);
            MethodElemEnumArg(enumDerived); // Produces compiler error with the problematic signature.
        }
    }
}

Answer 1

Try another signature:

static public void MethodElemEnumArg( IEnumerable<CElemTypeBase> enumArg ) { }

Answer 2

Hi pnn,
A brief summary of facts about variance in the common language runtime:

1. Variant type parameters are restricted to generic interface and generic delegate types.
2. A generic interface or generic delegate type can have both covariant and contravariant type parameters.
3. Starting in C# 9, covariant return types are supported. An overriding method can declare a more derived return type the method it overrides, and an overriding, read-only property can declare a more derived type.
   More details you can refer to this document.
   Best Regards,
   Daniel Zhang

---

If the response is helpful, please click "Accept Answer" and upvote it.

Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.

Answer 3

The editor has removed a couple of stars from the code (the trick with switch of code segments does not wok). Please use the code below.

using System;
using System.Collections;
using System.Collections.Generic;

namespace TestConsoleApp {
    class CEnumerable<ElemTypeBase> : IEnumerable<ElemTypeBase> where ElemTypeBase : class {
        public IEnumerator<ElemTypeBase> GetEnumerator() { throw new NotImplementedException(); }
        IEnumerator IEnumerable.GetEnumerator() { throw new NotImplementedException(); }
    }
    class CElemTypeBase { }
    class CElemTypeDerived : CElemTypeBase { }
    class Program {
        /* // To see the problem, insert a slash after the very first slash in this line and compile.
        // Why the line below causes problems,
        static public void MethodElemEnumArg(CEnumerable<CElemTypeBase> enumArg) { } // Problematic signature.
        /*/ // while the next line does not?
        static public void MethodElemEnumArg(IEnumerable<CElemTypeBase> enumArg) { }
        //*/
        static public void MethodElemArg(CElemTypeBase elemArg) { }
        static void Main() {
            CEnumerable<CElemTypeBase> enumBase = new CEnumerable<CElemTypeBase>();
            CEnumerable<CElemTypeDerived> enumDerived = new CEnumerable<CElemTypeDerived>();
            CElemTypeBase argBase = new CElemTypeBase();
            CElemTypeBase argDerived = new CElemTypeDerived();
            MethodElemArg(argBase);
            MethodElemArg(argDerived); // Surely works.
            MethodElemEnumArg(enumBase);
            MethodElemEnumArg(enumDerived); // Produces compiler error with the problematic signature.
        }
    }
}

Answer 4

Hello,

The single / is seen as a math operator in this case. // is a comment and /// is used for marking a class, method or property comment.

These are valid