Implémentation d’interface anonyme

J’ai lu le fil ‘ C # anonymement implémenter l’interface (ou la classe abstraite) ‘ pour implémenter une interface anonymement. Mais je me demandais si cela était également possible en utilisant .NET 2.0 (NO LINQ) en utilisant des delegates ou une approche similaire. Je sais de JAVA les possibles suivants:

MyClass m = MyMethod(new MyInterface() { @override public void doSomething() {...} }

(J’espère que je me souviendrai bien, j’avais utilisé JAVA il ya quelque temps, mais je suppose que c’était quelque chose de similaire). Cela peut être utile chaque fois qu’une méthode a besoin d’une instance d’interface et qu’elle n’est appelée qu’une fois. Il n’est donc pas nécessaire de créer une nouvelle classe pour cette approche unique.

.NET 2.0 prenait également en charge les delegates anonymes. La syntaxe était toutefois un peu plus détaillée que lambdas, et l’inférence de type ne fonctionnait pas. Et il n’y avait pas de méthodes d’extension en C # 2.0 (bien que vous ayez pu utiliser C # 3.0 et comstackr contre .NET 2.0), qui sont à la base de LINQ et qui peuvent fonctionner sur des interfaces.

Comparer:

.NET 2.0: delegate(int i) { return (i < 5); } delegate(int i) { return (i < 5); }
.NET 3.5: i => i < 5

.NET 2.0 manque également de signatures de delegates génériques communes ( Func et Action ), mais vous pouvez également les définir vous-même (pour toutes les combinaisons de parameters que vous aimez):

 public delegate void Action(T item); public delegate Tresult Func(T item);

Ainsi, quelle que soit l'approche utilisée par votre réponse liée pour imiter des interfaces anonymes, vous pouvez la représenter à l'aide de delegates .NET 2.0, au désortingment d'une verbosité accrue. Vous obliger à vous demander: "est-ce vraiment si court pour écrire?"

[Mettre à jour]

Si votre interface est une interface à méthode unique, comme:

 interface IFoo { ssortingng Bar(int value); } class SomeOtherClass { void DoSomething(IFoo foo); }

alors vous pourriez vous en débarrasser entièrement et simplement utiliser un délégué:

 class SomeOtherClass { void DoSomething(Func bar); } new SomeOtherClass().DoSomething(delegate(int i) { return i.ToSsortingng(); });

Si vous avez une interface avec de nombreuses méthodes que vous voulez pouvoir implémenter inline à différents endroits, vous pouvez utiliser quelque chose comme ceci:

 interface IFoo { ssortingng GetSomething(); void DoSomething(int value); } // conditional comstack, only if .NET 2.0 #if NET_2_0 public delegate void Action(T item); public delegate Tresult Func(); #endif class DelegatedFoo : IFoo { private readonly Func _get; private readonly Action _do; public DelegatedFoo(Func getStuff, Action doStuff) { _get = getStuff; _do = doStuff; } #region IFoo members simply invoke private delegates public ssortingng GetSomething() { return _get(); } public void DoSomething(int value) { _do(value); } #endregion }

Ce qui vous permettrait de transmettre des delegates à la classe DelegatedFoo ligne:

 var delegated = new DelegatedFoo( delegate() { return ""; }, // ssortingng GetSomething() delegate(int i) { } // void DoSomething(int) );

En utilisant ~~.NET 4~~ la syntaxe C # 4.0, cela semblerait un peu plus propre en raison de la douceur syntaxique des lambdas et des parameters nommés:

 var delegated = new DelegatedFoo( getStuff: () => "", doStuff: i => { } );

Je sais que ce n’est peut-être pas exactement ce que vous espérez, mais si vous devez absolument le faire, vous pouvez utiliser n’importe quel framework moqueur disponible pour demander un object qui implémente l’interface puis append des implémentations pour les méthodes. Ceci est une pratique standard en TDD.

En outre, vous pouvez simplement utiliser des delegates anonymes pour répondre à la plupart de vos besoins, conformément aux conseils de John Skeet dans la question que vous avez mentionnée.