Estoy tratando de hacer algunas pruebas unitarias en un proyecto que desafortunadamente tiene un alto nivel de interdependencia unitaria. Actualmente, muchas de nuestras clases buscan una costumbreUserIdentity para determinar la autenticación, pero ese objeto tiene muchos saltos internos que evitaría al intentar probar la funcionalidad de cada unidad.

Para evitar esto, estoy tratando de crear una versión "simulada" de esta UserIdentity que se pueda conectar con un entorno variable más estrictamente controlado.

Para resumir, tenemos una clase UserIdentity con varias propiedades públicas de solo lectura y una CurrentIdentity estática (Identidad) marcador de posición. Soy capaz de solucionar casi todo con un "simulacro"Identidad implementación, pero me encuentro con un muro cuando llego a un punto donde CurrentIdentity se convierte comoUserIdentity.

Es un método bastante sencillo:

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

He configurado mi objeto simulado para crear un miembro de laUserIdentity escriba, y luego haga algo como esto:

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

o esto

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

El problema es que, por lo que puedo decir, que 'as' no parece invocar una operación de conversión implícita o explícita en mi objeto simulado. Mi (s) pregunta (s) es (are?), Me estoy perdiendo algo simple aquí o esto no funcionará porque (supongo) que la operación 'as' mira directamente a la herencia de clase (que mi objeto no hace ...) ?

Además, un poco fuera de tema quizás, pero ¿por qué no puede haber operadores simultáneos explícitos e implícitos del mismo tipo resultante dentro de una clase? A menos que me falte algo tonto, el compilador se resiste si trato de tener ambos operadores de conversión a la vez. Tengo que elegir uno u otro.

ACTUALIZAR

Bien, ahora estoy completamente confundido. Tal vez me estoy volviendo descuidado, pero he intentado hacer el elenco directo, y parece que tampoco puedo hacer que eso funcione. Leí sobre el operador en MSDN, y el ejemplo muestra al operador yendo en la clase resultante en lugar de la clase fuente, pero no estoy seguro de si eso importa o no (probé ambos lugares en el código a continuación). De cualquier manera, traté de establecer un banco de pruebas simple para ver qué podría estar haciendo mal, pero tampoco puedo hacer que eso funcione ... Esto es lo que tengo

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();
    }
}

Pero eso arroja la siguiente excepción cuando invoco foo.GetCoreIdentity ():

No se puede convertir el objeto de tipo 'ExtendedIdentity' para escribir 'CoreIdentity'.

y no puedo atrapar a ninguno de mis operadores explícitos con un punto de quiebre, por lo que parece que está tomando esta determinación sin siquiera "probar" las rutas de conversión que he proporcionado.

Seguramente me estoy perdiendo algo obvio. ¿El hecho de que tengo mi identidad (en Foo) definida como IIdentity de alguna manera impide la resolución del reparto utilizando los operadores explícitos del tipo de implementación? Eso me parecería extraño.

ACTUALIZACIÓN (# 2)

Siento que estoy enviando spam a mi publicación con todas estas actualizaciones (tal vez debería ponerme de acuerdo antes de estar tan feliz con el gatillo :)) De todos modos, modifiqué el método GetCoreIdentityMethod de Foo para hacer esto en su lugar:

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

    return (CoreIdentity)Identity;
}

y (después de tener que limpiar la referencia ambigua causada por tener el operador en ambas clases), entró en mi código explícito de operador de conversión, y funcionó como se esperaba. Así que supongo que parece que los operadores explícitos no se resuelven polimórficamente (¿es esa la comprensión correcta?), Y el hecho de que mi propiedad se tipeó como una identidad en lugar de una identidad extendida impidió que invocara la lógica de transmisión aunque fuera de la Tipo de identidad extendida en el momento en que se invocó. Eso me parece muy peculiar e inesperado ... y algo desafortunado.

No quiero tener que volver a escribir el guardián del objeto CurrentIdentity para que se dé cuenta de mis simulacros de prueba especiales. Quería encapsular esa lógica "especial" en el simulacro mismo, por lo que esto realmente me deja sin aliento.