Per deridere un oggetto, deve essere implementato un'interfaccia o contrassegnato virtuale?

Question

oppure la classe può implementare anche una classe astratta?

Answer 1

per deridere un tipo, deve essere o un'interfaccia (questo è anche chiamato essendo puri virtuali) o avere membri virtuali (membri astratti sono anche virtuale).

Con questa definizione, è possibile prendere in giro tutto ciò che è virtuale.

In sostanza, i mazzi dinamici non fanno nulla che non sia possibile fare a mano.

Diciamo che si sta programmando contro un'interfaccia come questa:

public interface IMyInterface 
{ 
    string Foo(string s); 
} 

Si potrebbe creare manualmente una specifica implementazione test di IMyInterface che ignora il parametro di input e restituisce sempre la stessa uscita:

public class MyClass : IMyInterface 
{ 
    public string Foo(string s) 
    { 
     return "Bar"; 
    } 
} 

tuttavia, che diventa ripetitivo molto veloce se si desidera verificare come il consumatore risponde a diversi valori di ritorno, così invece di codificare fino tuo test Doppio a mano, si può ettari ve un framework li crea dinamicamente per te.

Immaginate che i mock dinamici scrivano davvero codice simile all'implementazione di MyClass sopra (in realtà non scrivono il codice, emettono dinamicamente i tipi, ma è un'analogia abbastanza precisa).

Ecco come si potrebbe definire lo stesso comportamento come MyClass con Moq:

var mock = new Mock<IMyInterface>(); 
mock.Setup(x => x.Foo(It.IsAny<string>())).Returns("Bar"); 

In entrambi i casi, la construcor della classe creata sarà chiamato quando si crea l'oggetto. Poiché un'interfaccia non ha costruttore, questo sarà normalmente il costruttore predefinito (rispettivamente di MyClass e della classe emessa dinamicamente).

Si può fare lo stesso con i tipi concreti come questo:

public class MyBase 
{ 
    public virtual string Ploeh() 
    { 
     return "Fnaah"; 
    } 
} 

A mano, si sarebbe in grado di derivare da MyBase e l'override del metodo Ploeh perché è virtuale:

public class TestSpecificChild : MyBase 
{ 
    public override string Ploeh() 
    { 
     return "Ndøh"; 
    } 
} 

Una libreria fittizia dinamica può fare lo stesso, e lo stesso vale per i metodi astratti.

Tuttavia, non è possibile scrivere codice che sovrascrive un membro non virtuale o interno e nemmeno i mock dinamici. Possono solo fare ciò che puoi fare a mano.

Avvertenza: la descrizione precedente è vera per la maggior parte dei mock dinamici, ad eccezione di TypeMock, che è diverso e ... spaventoso.

Answer 2

Da Stephen Walther's blog:

È possibile utilizzare per creare Moq prende in giro da entrambe le interfacce e classi esistenti. Ci sono alcuni requisiti per le classi. La classe non può essere sigillata. Inoltre, il metodo che viene deriso deve essere contrassegnato come virtuale. Non è possibile simulare metodi statici (utilizzare il modello dell'adattatore per simulare un metodo statico).