Existe uma maneira de escrever código baseado em interface (ou seja, usando interfaces em vez de classes como os tipos aceitos e distribuídos) em C # sem abrir mão do uso de coisas como projeções implícitas? Aqui está um exemplo de código - houve muita remoção, mas essas são as partes relevantes.

 public class Game
 {
     public class VariantInfo
     {
         public string Language { get; set; }
         public string Variant { get; set; }
     }
 }

E no ScrDictionary.cs, temos ...

 public class ScrDictionary: IScrDictionary
 {
     public string Language { get; set; }
     public string Variant { get; set; }

     public static implicit operator Game.VariantInfo(ScrDictionary s)
     {
        return new Game.VariantInfo{Language=sd.Language, Variant=sd.Variant};
     }
 }

E a interface ...

 public interface IScrDictionary
 {
     string Language { get; set; }
     string Variant { get; set; }
 }

Eu quero poder usarIScrDictionary ao invés deScrDictionary, mas ainda assim possa converter implicitamente umScrDictionary para umGame.VariantInfo. Além disso, embora possa haver uma maneira fácil de fazer esse trabalho, fornecendoIScrDictionary uma propriedade do tipoGame.VariantInfo minha pergunta é mais geral:Existe uma maneira de definir conversões ou sobrecarga do operador nas interfaces? (Caso contrário, qual é a maneira C # adequada para manter essa funcionalidade sem abrir mão do design orientado a interface?)