C# compiler bug? Why doesn’t this implicit user-defined conversion compile?

by

Apparently, implicit user defined conversions don’t work when one of the types is an interface. From the C# specs:

6.4.1 Permitted user-defined conversions

C# permits only certain user-defined conversions to be declared. In particular, it is not possible to redefine an already existing implicit or explicit conversion.
For a given source type S and target type T, if S or T are nullable types, let S0 and T0 refer to their underlying types, otherwise S0 and T0 are equal to S and T respectively. A class or struct is permitted to declare a conversion from a source type S to a target type T only if all of the following are true:

  • S0 and T0 are different types.
  • Either S0 or T0 is the class or struct type in which the operator declaration takes place.
  • Neither S0 nor T0 is an interface-type.
  • Excluding user-defined conversions, a conversion does not exist from S to T or from T to S.

In your first method, both types are not interface types, so the user defined implicit conversion works.

The specs are not very clear, but it seems to me that if one of the types involved is an interface type, the compiler doesn’t even try to look up any user-defined implicit conversions.

More Related Contents:

  1. Where to learn about VS debugger ‘magic names’
  2. How does the C# compiler detect COM types?
  3. How does static field initialization work in C#?
  4. Delegate caching behavior changes in Roslyn
  5. Is the C# compiler smart enough to optimize this code?
  6. What are C# lambda’s compiled into? A stackframe, an instance of an anonymous type, or?
  7. Adding scripting functionality to .NET applications
  8. JIT compiler vs offline compilers
  9. How does creating a instance of class inside of the class itself works?
  10. C# compiler number literals
  11. Why is the C# compiler emitting a callvirt instruction for a GetType() method call?
  12. Could not load file or assembly … The parameter is incorrect
  13. Duck typing in the C# compiler
  14. If Int32 is just an alias for int, how can the Int32 class use an int?
  15. Compiler Value Type Resolution and Hardcoded “0” Integer Values
  16. C# Empty Statement
  17. ‘CompanyName.Foo’ is a ‘namespace’ but is used like a ‘type’
  18. Why only literal strings saved in the intern pool by default?
  19. TargetedPatchingOptOut: “Performance critical to inline across NGen image boundaries”?
  20. Why is the binary output not equal when compiling again?
  21. variable scope in statement blocks
  22. Mono Compiler as a Service (MCS)
  23. Why does this (null || !TryParse) conditional result in “use of unassigned local variable”?
  24. How do generics get compiled by the JIT compiler?
  25. C# Compiler optimization – Unused methods
  26. C# – Value Type Equals method – why does the compiler use reflection?
  27. C# Compiler should give warning but doesn’t?
  28. Is it possible to install a C# compiler without Visual Studio?
  29. Why and how does C# allow accessing private variables outside the class itself when it’s within the same containing class?
  30. Inline property initialisation and trailing comma

Leave a Comment