Conversão implícita / explícita com relação à palavra-chave "as"

Estou tentando fazer alguns testes de unidade em um projeto que infelizmente possui um alto nível de interdependência de unidades. Atualmente, muitas de nossas aulas buscam um costumeUserIdentity objeto para determinar a autenticação, mas esse objeto possui muitas ações internas que eu evitaria logo ao tentar testar a funcionalidade de cada unidade.

Para contornar um pouco disso, estou tentando criar uma versão "falsa" dessa UserIdentity que pode ser conectada a um ambiente variável mais rigidamente controlado.

Para encurtar a história, temos uma classe UserIdentity com várias propriedades públicas de somente leitura e uma CurrentIdentity estática (IIdentity) espaço reservado. Eu sou capaz de contornar quase tudo com um "mock"IIdentity implementação, mas estou encontrando uma barreira quando chego a um ponto em que o CurrentIdentity é lançado como umUserIdentity.

É um método bastante direto:

internal static UserIdentity GetCurrentIdentity()
{
    UserIdentity currentIdentity = ApplicationContext.User.Identity as UserIdentity;
    return currentIdentity;
}

Configurei meu objeto simulado para criar um membro doUserIdentity digite e faça algo parecido com isto:

    public static implicit operator UserIdentity(MockUserIdentity src)
    {
        return src.UserIdentity;
    }

ou isto

    public static explicit operator UserIdentity(MockUserIdentity src)
    {
        return src.UserIdentity;
    }

O problema é que, até onde eu sei, esse 'as' parece não chamar uma operação de conversão implícita ou explícita no meu objeto simulado. Minha pergunta (s) é (são?), Estou faltando algo simples aqui ou isso não vai funcionar porque (eu estou supondo) que a operação 'as' olha diretamente para a herança de classe (que meu objeto não faz ...) ?

Além disso, talvez seja um pouco estranho, mas por que não pode haver operadores explícitos e implícitos simultâneos do mesmo tipo resultante em uma classe? A menos que eu esteja perdendo algo bobo, o compilador rejeita se eu tentar ter os dois operadores de conversão ao mesmo tempo. Eu tenho que escolher um ou outro.

ATUALIZAR

Ok, agora estou completamente confuso. Talvez eu esteja ficando desleixada, mas tentei fazer o elenco direto, e também não consigo fazer isso funcionar. Eu li sobre o operador no MSDN e o exemplo mostra o operador que está na classe resultante e não na classe de origem, mas não tenho certeza se isso importa ou não (tentei os dois lugares no código abaixo). De qualquer forma, tentei montar uma simples bancada de testes para ver o que poderia estar fazendo de errado, mas também não consigo fazer isso funcionar ... Aqui está o que tenho

class Program
{
    // Shared Interface
    public interface IIdentity { }

    // "real" class (not conducive to inheritence)
    public class CoreIdentity : IIdentity
    {
        internal CoreIdentity() { }

        // Just in case (if this has to be here, that seems unfortunate)
        public static explicit operator CoreIdentity(ExtendedIdentity src)
        {
            return src.Identity;
        }
    }

    // "mock" class (Wraps core object)
    public class ExtendedIdentity : IIdentity
    {
        public CoreIdentity Identity { get; set; }
        public ExtendedIdentity()
        {
            Identity = new CoreIdentity();
        }

        // This is where the operator seems like it should belong...
        public static explicit operator CoreIdentity(ExtendedIdentity src)
        {
            return src.Identity;
        }
    }

    // Dummy class to obtain "current core identity"
    public class Foo
    {
        public IIdentity Identity { get; set; }
        public CoreIdentity GetCoreIdentity()
        {
            return (CoreIdentity)Identity;
        }
    }

    static void Main(string[] args)
    {
        ExtendedIdentity identity = new ExtendedIdentity();
        Foo foo = new Foo();
        foo.Identity = identity;
        CoreIdentity core = foo.GetCoreIdentity();
    }
}

Mas isso gera a seguinte exceção quando invoco foo.GetCoreIdentity ():

Não foi possível converter o objeto do tipo 'ExtendedIdentity' para o tipo 'CoreIdentity'.

e não consigo capturar nenhum dos meus operadores explícitos com um ponto de interrupção; portanto, parece que está fazendo essa determinação sem "tentar" as rotas de conversão que forneci.

Certamente estou perdendo algo óbvio. O fato de eu ter minha identidade (em Foo) definida como IIdentity de alguma forma impede a resolução do elenco usando os operadores explícitos do tipo de implementação? Isso me pareceria estranho.

ATUALIZAÇÃO (# 2)

Sinto que estou enviando spam para o meu post com todas essas atualizações (talvez eu deva agir antes de ficar tão feliz com o gatilho :)) Enfim, modifiquei o GetCoreIdentityMethod do meu Foo para fazer isso:

public CoreIdentity GetCoreIdentity()
{
    ExtendedIdentity exId = Identity as ExtendedIdentity;
    if (exId != null)
        return (CoreIdentity)exId;

    return (CoreIdentity)Identity;
}

e (depois de limpar a referência ambígua causada pelo operador em ambas as classes), ele entrou no meu código explícito do operador de conversão e funcionou conforme o esperado. Portanto, acho que parece que os operadores explícitos não são resolvidos polimorficamente (esse é o entendimento correto?) E o fato de minha propriedade ter sido digitada como IIdentity em vez de ExtendedIdentity impediu que ele invocasse a lógica de conversão, mesmo que fosse da Tipo ExtendedIdentity no momento em que foi chamado. Isso me parece muito peculiar e inesperado ... e meio que infeliz.

Não quero ter que reescrever o detentor do objeto CurrentIdentity para torná-lo ciente das minhas simulações de elenco de teste especiais. Eu queria encapsular essa lógica "especial" no próprio mock, então isso realmente me impressiona.

questionAnswers(4)

yourAnswerToTheQuestion