C#: creazione di un'istanza di una classe astratta senza definizione di nuova classe

Question

So che può essere eseguita in Java, in quanto ho utilizzato questa tecnica in modo estensivo in passato. Di seguito verrà mostrato un esempio in Java. (Ulteriori domanda. Che cosa è questa tecnica chiamata? E 'difficile trovare un esempio di questo senza un nome.)

public abstract class Example { 
    public abstract void doStuff(); 
} 

public class StartHere{ 
    public static void main(string[] args){ 
     Example x = new Example(){ 
     public void doStuff(){ 
      System.out.println("Did stuff"); 
     }    
     }; 
     x.doStuff(); 
    } 
} 

Ora, la mia domanda principale sarebbe, questo può anche essere fatto in C#, e in caso affermativo, Come?

Answer 1

Con espressioni Lamba e di classe inizializzatori è possibile ottenere lo stesso comportamento con un po 'di sforzo.

public class Example { 
    public Action DoStuff; 
    public Action<int> DoStuffWithParameter; 
    public Func<int> DoStuffWithReturnValue; 
} 

class Program { 
    static void Main(string[] args) { 
     var x = new Example() { 
      DoStuff =() => { 
       Console.WriteLine("Did Stuff"); 
      }, 
      DoStuffWithParameter = (p) => { 
       Console.WriteLine("Did Stuff with parameter " + p); 
      }, 
      DoStuffWithReturnValue =() => { return 99; } 


     }; 

     x.DoStuff(); 
     x.DoStuffWithParameter(10); 
     int value = x.DoStuffWithReturnValue(); 
     Console.WriteLine("Return value " + value); 
     Console.ReadLine(); 
    } 
} 

Un problema con questa soluzione che ho capito è che se si dovesse creare campi nella classe di esempio, le espressioni lambda non sarebbe in grado di accedere a tali campi.

Tuttavia, non vi è alcun motivo per cui non è possibile passare l'istanza di Example alle espressioni lambda che consentirebbero loro l'accesso a qualsiasi stato pubblico che l'esempio potrebbe contenere. AFAIK che sarebbe funzionalmente equivalente alla Java Inner Inner Class.

P.S. Se voterai una risposta, fai un favore a tutti e aggiungi un commento sul perché non sei d'accordo :-)

Answer 2

La tecnica Java è denominata "Anonymous inner class" e non vi sono equivalenti in C#.

Answer 3

Questo non può essere fatto in C#; devi dichiarare un nuovo tipo di classe. Il più vicino si può ottenere in C# è probabilmente una classe annidata nome:

public class StartHere{ 
    private class Foo : Example { 
     public override void doStuff() 
     { 
      Console.WriteLine("did stuff"); 
     } 
    } 
    public static void Main(string[] args){ 
     Example x = new Foo(); 
     x.doStuff(); 
    } 
} 

Answer 4

Insomma no, è necessario definire come classe sub separata. Penso che questa funzionalità stia arrivando C# 4.0?

Modifica: No non sta arrivando C# 4.0 L'ho inventato.

Answer 5

È possibile eseguire questa operazione con Mocking in. NET. Tuttavia non esiste un supporto in lingua per questa funzione, penso che sarà disponibile in C# 4.0. Ci sono una serie di librerie là fuori per Mocking, tra cui:

• Moq
• RhinoMock

Answer 6

Questo non è supportata in C#, e se fosse per me non dovrebbe essere così o.

La proliferazione delle classi interne in Java è principalmente dovuta alla mancanza di delegati o lambda, che C# ha. Quindi, mentre questo tipo di funzionalità è attualmente "la tua unica speranza" in Java, puoi solitamente utilizzare altri meccanismi in C# per raggiungere gli stessi fini. Java ha l'impressione di suonare il piano con una mano in questo senso.

(È vero che molti di noi hanno ottenuto abbastanza bravo a questo gioco con una sola mano, e ora sembra che dovremo aspettare almeno fino a Java 8 per le chiusure ...)

Answer 7

In genere, i problemi risolti con le classi interne anonime in Java vengono risolti in modo molto più pulito usando i delegati in .Net. Il tuo esempio è un po 'troppo semplicistico per determinare il tuo intento.Se il tuo intento usando la classe astratta significa passare un "comportamento", pensa solo a usare un delegato Action.

public class StartHere{ 
    public static void main(string[] args){ 
     Action doStuff =() => Console.WriteLine("Did stuff"); 
     executeSomething(doStuff); 
    } 

    public static void executeSomething(Action action) 
    { 
     action(); 
    } 
} 

Answer 8

Mentre tutte le buone risposte, la maggior parte dei arounds di lavoro proposti si basano su C# 3.0

Così, per amor di completezza, aggiungerò un'altra soluzione che utilizza né lambda né di tipo Func (ammesso che , come Matt Olenik ha menzionato nei commenti, si potrebbe generalizzare i delegati di seguito a lavorare allo stesso modo.). Per quelli come me che potrebbero ancora lavorare con C# 2.0. Forse non è la soluzione migliore, ma funziona.

public class Example 
{ 
    public delegate void DoStuffDelecate(); 
    public DoStuffDelecate DoStuff; 
    public delegate void DoStuffWithDelecate(int n); 
    public DoStuffWithDelecate DoStuffWithParameter; 
    public delegate int DoStuffWithReturnDelecate(); 
    public DoStuffWithReturnDelecate DoStuffWithReturnValue; 
} 

class Program 
{ 
    static int MethodWithReturnValue() 
    { 
     return 99; 
    } 
    static void MethodForDelecate() 
    { 
     Console.WriteLine("Did Stuff"); 
    } 
    static void MethodForDelecate(int n) 
    { 
     Console.WriteLine("Did Stuff with parameter " + n); 
    } 


    static void Main(string[] args) 
    { 
     var x = new Example(); 
     x.DoStuff = MethodForDelecate; 
     x.DoStuffWithParameter = MethodForDelecate; 
     x.DoStuffWithReturnValue = MethodWithReturnValue; 

     x.DoStuff(); 
     x.DoStuffWithParameter(10); 
     int value = x.DoStuffWithReturnValue(); 
     Console.WriteLine("Return value " + value); 
     Console.ReadLine(); 
    } 
} 

Answer 9

Dal momento che la classe rappresenta solo un'azione, è possibile utilizzare un delegato nel tuo caso, non v'è un delegato esistente:

public delegate void Action(); 

Questo è l'esatto equivalente della classe.

e la dichiarazione della classe anonima è ancora più pulito:

Action action =() => Console.WriteLine("Hello world"); 
action(); // invoke 

si può anche utilizzare la chiusura:

public void Hello(string name) 
{ 
    Action action =() => Console.WriteLine("Hello " + name); 
    action(); // will call the above lambda ! 
}