Why is this implicit conversion illegal?

See more:

C#

inheritance

implicit

Hello Code Project gurus.

I had previously written a class that was a wrapper around the C# decimal type. This allowed me to add all kinds of custom functionality that I needed. I am now trying to make this wrapper class generic, but I am encountering a compiler error that I don't quite understand...

The super-simplified example of my code is below. The compiler error I get is on the last line of code:

Cannot implicitly convert type 'int' to 'ConsoleApplication1.testing.WrapperForFloat'. An explicit conversion exists (are you missing a cast?)<

What I don't understand is why, when
int y = testImplied
is encountered, the compiler knows that WrapperForFloat is inheriting the
implicit operator int(Wrapper<T> val)
from Wrapper and compiles the conversion, but it does not know that
testImplied = x
should use WrapperFloat's inherited
implicit operator Wrapper<T>(int val)

Any explanation would be greatly appreciated.

What I have tried:

namespace ConsoleApplication1
{
    using System;

    namespace testing
    {
        public class Wrapper<T>where T: IConvertible
        {
            private T _value;

            public Wrapper()
            {
                _value = default(T);
            }

            public Wrapper(T intialValue)
            {
                _value = intialValue;
            }

            public static implicit operator Wrapper<T>(int val)
            {
                var x = (T)Convert.ChangeType(val, typeof(T));
                return new Wrapper<T>(x);
            }

            public static implicit operator int(Wrapper<T> val)
            {
                return (int)Convert.ChangeType(val._value, typeof(int));
            }
        }

        public class WrapperForFloat : Wrapper<float>
        {
            public WrapperForFloat() : base() { }
            public WrapperForFloat(float initialval) : base(initialval) { }
        }

        class Program
        {
            static void Main(string[] args)
            {
                var testExplicit = new Wrapper<float>(10f);
                var testImplied = new WrapperForFloat(11f);

                int x = testExplicit;
                int y = testImplied;

                testExplicit = y;
                testImplied = x;
            }
        }
    }
}