1 files changed, 236 insertions, 245 deletions

diff --git a/csharp/test/Ice/seqMapping/MyClassAMDI.cs b/csharp/test/Ice/seqMapping/MyClassAMDI.cs
index c45f6f32838..b8e5cb24d9c 100644
--- a/csharp/test/Ice/seqMapping/MyClassAMDI.cs
+++ b/csharp/test/Ice/seqMapping/MyClassAMDI.cs
@@ -8,490 +8,481 @@
 // **********************************************************************
 
 using System;
+using System.Threading.Tasks;
 using System.Collections.Generic;
 using Test;
 
-public sealed class MyClassI : MyClass
+public sealed class MyClassI : MyClassDisp_
 {
-    public override void shutdown_async(AMD_MyClass_shutdown cb, Ice.Current current)
+    public override Task shutdownAsync(Ice.Current current)
     {
         current.adapter.getCommunicator().shutdown();
-        cb.ice_response();
+        return null;
     }
 
-    public override void opAByteS_async(AMD_MyClass_opAByteS cb, byte[] i, Ice.Current current)
+    public override Task<MyClass_OpAByteSResult>
+    opAByteSAsync(byte[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpAByteSResult>(new MyClass_OpAByteSResult(i, i));
     }
 
-    public override void opLByteS_async(AMD_MyClass_opLByteS cb, List<byte> i, Ice.Current current)
+    public override Task<MyClass_OpLByteSResult>
+    opLByteSAsync(List<byte> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLByteSResult>(new MyClass_OpLByteSResult(i, i));
     }
 
-    public override void opKByteS_async(AMD_MyClass_opKByteS cb, LinkedList<byte> i, Ice.Current current)
+    public override Task<MyClass_OpKByteSResult>
+    opKByteSAsync(LinkedList<byte> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpKByteSResult>(new MyClass_OpKByteSResult(i, i));
     }
 
-    public override void opQByteS_async(AMD_MyClass_opQByteS cb, Queue<byte> i, Ice.Current current)
+    public override Task<MyClass_OpQByteSResult>
+    opQByteSAsync(Queue<byte> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpQByteSResult>(new MyClass_OpQByteSResult(i, i));
     }
 
-    public override void opSByteS_async(AMD_MyClass_opSByteS cb, Stack<byte> i, Ice.Current current)
+    public override Task<MyClass_OpSByteSResult>
+    opSByteSAsync(Stack<byte> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSByteSResult>(new MyClass_OpSByteSResult(i, i));
     }
 
-    public override void opCByteS_async(AMD_MyClass_opCByteS cb, CByteS i, Ice.Current current)
+    public override Task<MyClass_OpABoolSResult>
+    opABoolSAsync(bool[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpABoolSResult>(new MyClass_OpABoolSResult(i, i));
     }
 
-    public override void opABoolS_async(AMD_MyClass_opABoolS cb, bool[] i, Ice.Current current)
+    public override Task<MyClass_OpLBoolSResult>
+    opLBoolSAsync(List<bool> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLBoolSResult>(new MyClass_OpLBoolSResult(i, i));
     }
 
-    public override void opLBoolS_async(AMD_MyClass_opLBoolS cb, List<bool> i, Ice.Current current)
+    public override Task<MyClass_OpKBoolSResult>
+    opKBoolSAsync(LinkedList<bool> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpKBoolSResult>(new MyClass_OpKBoolSResult(i, i));
     }
 
-    public override void opKBoolS_async(AMD_MyClass_opKBoolS cb, LinkedList<bool> i, Ice.Current current)
+    public override Task<MyClass_OpQBoolSResult>
+    opQBoolSAsync(Queue<bool> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpQBoolSResult>(new MyClass_OpQBoolSResult(i, i));
     }
 
-    public override void opQBoolS_async(AMD_MyClass_opQBoolS cb, Queue<bool> i, Ice.Current current)
+    public override Task<MyClass_OpSBoolSResult>
+    opSBoolSAsync(Stack<bool> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSBoolSResult>(new MyClass_OpSBoolSResult(i, i));
     }
 
-    public override void opSBoolS_async(AMD_MyClass_opSBoolS cb, Stack<bool> i, Ice.Current current)
+    public override Task<MyClass_OpAShortSResult>
+    opAShortSAsync(short[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpAShortSResult>(new MyClass_OpAShortSResult(i, i));
     }
 
-    public override void opCBoolS_async(AMD_MyClass_opCBoolS cb, CBoolS i, Ice.Current current)
+    public override Task<MyClass_OpLShortSResult>
+    opLShortSAsync(List<short> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLShortSResult>(new MyClass_OpLShortSResult(i, i));
     }
 
-    public override void opAShortS_async(AMD_MyClass_opAShortS cb, short[] i, Ice.Current current)
+    public override Task<MyClass_OpKShortSResult>
+    opKShortSAsync(LinkedList<short> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpKShortSResult>(new MyClass_OpKShortSResult(i, i));
     }
 
-    public override void opLShortS_async(AMD_MyClass_opLShortS cb, List<short> i, Ice.Current current)
+    public override Task<MyClass_OpQShortSResult>
+    opQShortSAsync(Queue<short> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpQShortSResult>(new MyClass_OpQShortSResult(i, i));
     }
 
-    public override void opKShortS_async(AMD_MyClass_opKShortS cb, LinkedList<short> i, Ice.Current current)
+    public override Task<MyClass_OpSShortSResult>
+    opSShortSAsync(Stack<short> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSShortSResult>(new MyClass_OpSShortSResult(i, i));
     }
 
-    public override void opQShortS_async(AMD_MyClass_opQShortS cb, Queue<short> i, Ice.Current current)
+    public override Task<MyClass_OpAIntSResult>
+    opAIntSAsync(int[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpAIntSResult>(new MyClass_OpAIntSResult(i, i));
     }
 
-    public override void opSShortS_async(AMD_MyClass_opSShortS cb, Stack<short> i, Ice.Current current)
+    public override Task<MyClass_OpLIntSResult>
+    opLIntSAsync(List<int> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLIntSResult>(new MyClass_OpLIntSResult(i, i));
     }
 
-    public override void opCShortS_async(AMD_MyClass_opCShortS cb, CShortS i, Ice.Current current)
+    public override Task<MyClass_OpKIntSResult>
+    opKIntSAsync(LinkedList<int> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpKIntSResult>(new MyClass_OpKIntSResult(i, i));
     }
 
-    public override void opAIntS_async(AMD_MyClass_opAIntS cb, int[] i, Ice.Current current)
+    public override Task<MyClass_OpQIntSResult>
+    opQIntSAsync(Queue<int> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpQIntSResult>(new MyClass_OpQIntSResult(i, i));
     }
 
-    public override void opLIntS_async(AMD_MyClass_opLIntS cb, List<int> i, Ice.Current current)
+    public override Task<MyClass_OpSIntSResult>
+    opSIntSAsync(Stack<int> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSIntSResult>(new MyClass_OpSIntSResult(i, i));
     }
 
-    public override void opKIntS_async(AMD_MyClass_opKIntS cb, LinkedList<int> i, Ice.Current current)
+    public override Task<MyClass_OpALongSResult>
+    opALongSAsync(long[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpALongSResult>(new MyClass_OpALongSResult(i, i));
     }
 
-    public override void opQIntS_async(AMD_MyClass_opQIntS cb, Queue<int> i, Ice.Current current)
+    public override Task<MyClass_OpLLongSResult>
+    opLLongSAsync(List<long> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLLongSResult>(new MyClass_OpLLongSResult(i, i));
     }
 
-    public override void opSIntS_async(AMD_MyClass_opSIntS cb, Stack<int> i, Ice.Current current)
+    public override Task<MyClass_OpKLongSResult>
+    opKLongSAsync(LinkedList<long> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpKLongSResult>(new MyClass_OpKLongSResult(i, i));
     }
 
-    public override void opCIntS_async(AMD_MyClass_opCIntS cb, CIntS i, Ice.Current current)
+    public override Task<MyClass_OpQLongSResult>
+    opQLongSAsync(Queue<long> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpQLongSResult>(new MyClass_OpQLongSResult(i, i));
     }
 
-    public override void opALongS_async(AMD_MyClass_opALongS cb, long[] i, Ice.Current current)
+    public override Task<MyClass_OpSLongSResult>
+    opSLongSAsync(Stack<long> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSLongSResult>(new MyClass_OpSLongSResult(i, i));
     }
 
-    public override void opLLongS_async(AMD_MyClass_opLLongS cb, List<long> i, Ice.Current current)
+    public override Task<MyClass_OpAFloatSResult>
+    opAFloatSAsync(float[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpAFloatSResult>(new MyClass_OpAFloatSResult(i, i));
     }
 
-    public override void opKLongS_async(AMD_MyClass_opKLongS cb, LinkedList<long> i, Ice.Current current)
+    public override Task<MyClass_OpLFloatSResult>
+    opLFloatSAsync(List<float> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLFloatSResult>(new MyClass_OpLFloatSResult(i, i));
     }
 
-    public override void opQLongS_async(AMD_MyClass_opQLongS cb, Queue<long> i, Ice.Current current)
+    public override Task<MyClass_OpKFloatSResult>
+    opKFloatSAsync(LinkedList<float> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpKFloatSResult>(new MyClass_OpKFloatSResult(i, i));
     }
 
-    public override void opSLongS_async(AMD_MyClass_opSLongS cb, Stack<long> i, Ice.Current current)
+    public override Task<MyClass_OpQFloatSResult>
+    opQFloatSAsync(Queue<float> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpQFloatSResult>(new MyClass_OpQFloatSResult(i, i));
     }
 
-    public override void opCLongS_async(AMD_MyClass_opCLongS cb, CLongS i, Ice.Current current)
+    public override Task<MyClass_OpSFloatSResult>
+    opSFloatSAsync(Stack<float> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSFloatSResult>(new MyClass_OpSFloatSResult(i, i));
     }
 
-    public override void opAFloatS_async(AMD_MyClass_opAFloatS cb, float[] i, Ice.Current current)
+    public override Task<MyClass_OpADoubleSResult>
+    opADoubleSAsync(double[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpADoubleSResult>(new MyClass_OpADoubleSResult(i, i));
     }
 
-    public override void opLFloatS_async(AMD_MyClass_opLFloatS cb, List<float> i, Ice.Current current)
+    public override Task<MyClass_OpLDoubleSResult>
+    opLDoubleSAsync(List<double> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLDoubleSResult>(new MyClass_OpLDoubleSResult(i, i));
     }
 
-    public override void opKFloatS_async(AMD_MyClass_opKFloatS cb, LinkedList<float> i, Ice.Current current)
+    public override Task<MyClass_OpKDoubleSResult>
+    opKDoubleSAsync(LinkedList<double> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpKDoubleSResult>(new MyClass_OpKDoubleSResult(i, i));
     }
 
-    public override void opQFloatS_async(AMD_MyClass_opQFloatS cb, Queue<float> i, Ice.Current current)
+    public override Task<MyClass_OpQDoubleSResult>
+    opQDoubleSAsync(Queue<double> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpQDoubleSResult>(new MyClass_OpQDoubleSResult(i, i));
     }
 
-    public override void opSFloatS_async(AMD_MyClass_opSFloatS cb, Stack<float> i, Ice.Current current)
+    public override Task<MyClass_OpSDoubleSResult>
+    opSDoubleSAsync(Stack<double> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSDoubleSResult>(new MyClass_OpSDoubleSResult(i, i));
     }
 
-    public override void opCFloatS_async(AMD_MyClass_opCFloatS cb, CFloatS i, Ice.Current current)
+    public override Task<MyClass_OpAStringSResult>
+    opAStringSAsync(string[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpAStringSResult>(new MyClass_OpAStringSResult(i, i));
     }
 
-    public override void opADoubleS_async(AMD_MyClass_opADoubleS cb, double[] i, Ice.Current current)
+    public override Task<MyClass_OpLStringSResult>
+    opLStringSAsync(List<string> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLStringSResult>(new MyClass_OpLStringSResult(i, i));
     }
 
-    public override void opLDoubleS_async(AMD_MyClass_opLDoubleS cb, List<double> i, Ice.Current current)
+    public override Task<MyClass_OpKStringSResult>
+    opKStringSAsync(LinkedList<string> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpKStringSResult>(new MyClass_OpKStringSResult(i, i));
     }
 
-    public override void opKDoubleS_async(AMD_MyClass_opKDoubleS cb, LinkedList<double> i, Ice.Current current)
+    public override Task<MyClass_OpQStringSResult>
+    opQStringSAsync(Queue<string> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpQStringSResult>(new MyClass_OpQStringSResult(i, i));
     }
 
-    public override void opQDoubleS_async(AMD_MyClass_opQDoubleS cb, Queue<double> i, Ice.Current current)
+    public override Task<MyClass_OpSStringSResult>
+    opSStringSAsync(Stack<string> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSStringSResult>(new MyClass_OpSStringSResult(i, i));
     }
 
-    public override void opSDoubleS_async(AMD_MyClass_opSDoubleS cb, Stack<double> i, Ice.Current current)
+    public override Task<MyClass_OpAObjectSResult> opAObjectSAsync(Ice.Value[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpAObjectSResult>(new MyClass_OpAObjectSResult(i, i));
     }
 
-    public override void opCDoubleS_async(AMD_MyClass_opCDoubleS cb, CDoubleS i, Ice.Current current)
+    public override Task<MyClass_OpLObjectSResult>
+    opLObjectSAsync(List<Ice.Value> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLObjectSResult>(new MyClass_OpLObjectSResult(i, i));
     }
 
-    public override void opAStringS_async(AMD_MyClass_opAStringS cb, string[] i, Ice.Current current)
+    public override Task<MyClass_OpAObjectPrxSResult>
+    opAObjectPrxSAsync(Ice.ObjectPrx[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpAObjectPrxSResult>(new MyClass_OpAObjectPrxSResult(i, i));
     }
 
-    public override void opLStringS_async(AMD_MyClass_opLStringS cb, List<string> i, Ice.Current current)
+    public override Task<MyClass_OpLObjectPrxSResult>
+    opLObjectPrxSAsync(List<Ice.ObjectPrx> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLObjectPrxSResult>(new MyClass_OpLObjectPrxSResult(i, i));
     }
 
-    public override void opKStringS_async(AMD_MyClass_opKStringS cb, LinkedList<string> i, Ice.Current current)
+    public override Task<MyClass_OpKObjectPrxSResult>
+    opKObjectPrxSAsync(LinkedList<Ice.ObjectPrx> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpKObjectPrxSResult>(new MyClass_OpKObjectPrxSResult(i, i));
     }
 
-    public override void opQStringS_async(AMD_MyClass_opQStringS cb, Queue<string> i, Ice.Current current)
+    public override Task<MyClass_OpQObjectPrxSResult>
+    opQObjectPrxSAsync(Queue<Ice.ObjectPrx> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpQObjectPrxSResult>(new MyClass_OpQObjectPrxSResult(i, i));
     }
 
-    public override void opSStringS_async(AMD_MyClass_opSStringS cb, Stack<string> i, Ice.Current current)
+    public override Task<MyClass_OpSObjectPrxSResult>
+    opSObjectPrxSAsync(Stack<Ice.ObjectPrx> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSObjectPrxSResult>(new MyClass_OpSObjectPrxSResult(i, i));
     }
 
-    public override void opCStringS_async(AMD_MyClass_opCStringS cb, CStringS i, Ice.Current current)
+    public override Task<MyClass_OpAStructSResult>
+    opAStructSAsync(S[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpAStructSResult>(new MyClass_OpAStructSResult(i, i));
     }
 
-    public override void opAObjectS_async(AMD_MyClass_opAObjectS cb, Ice.Object[] i, Ice.Current current)
+    public override Task<MyClass_OpLStructSResult>
+    opLStructSAsync(List<S> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLStructSResult>(new MyClass_OpLStructSResult(i, i));
     }
 
-    public override void opLObjectS_async(AMD_MyClass_opLObjectS cb, List<Ice.Object> i, Ice.Current current)
+    public override Task<MyClass_OpKStructSResult>
+    opKStructSAsync(LinkedList<S> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpKStructSResult>(new MyClass_OpKStructSResult(i, i));
     }
 
-    public override void opCObjectS_async(AMD_MyClass_opCObjectS cb, CObjectS i, Ice.Current current)
+    public override Task<MyClass_OpQStructSResult>
+    opQStructSAsync(Queue<S> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpQStructSResult>(new MyClass_OpQStructSResult(i, i));
     }
 
-    public override void opAObjectPrxS_async(AMD_MyClass_opAObjectPrxS cb, Ice.ObjectPrx[] i, Ice.Current current)
+    public override Task<MyClass_OpSStructSResult>
+    opSStructSAsync(Stack<S> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSStructSResult>(new MyClass_OpSStructSResult(i, i));
     }
 
-    public override void opLObjectPrxS_async(AMD_MyClass_opLObjectPrxS cb, List<Ice.ObjectPrx> i, Ice.Current current)
+    public override Task<MyClass_OpAStructSDResult>
+    opAStructSDAsync(SD[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpAStructSDResult>(new MyClass_OpAStructSDResult(i, i));
     }
 
-    public override void opKObjectPrxS_async(AMD_MyClass_opKObjectPrxS cb, LinkedList<Ice.ObjectPrx> i, Ice.Current current)
+    public override Task<MyClass_OpLStructSDResult>
+    opLStructSDAsync(List<SD> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLStructSDResult>(new MyClass_OpLStructSDResult(i, i));
     }
 
-    public override void opQObjectPrxS_async(AMD_MyClass_opQObjectPrxS cb, Queue<Ice.ObjectPrx> i, Ice.Current current)
+    public override Task<MyClass_OpKStructSDResult>
+    opKStructSDAsync(LinkedList<SD> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpKStructSDResult>(new MyClass_OpKStructSDResult(i, i));
     }
 
-    public override void opSObjectPrxS_async(AMD_MyClass_opSObjectPrxS cb, Stack<Ice.ObjectPrx> i, Ice.Current current)
+    public override Task<MyClass_OpQStructSDResult>
+    opQStructSDAsync(Queue<SD> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpQStructSDResult>(new MyClass_OpQStructSDResult(i, i));
     }
 
-    public override void opCObjectPrxS_async(AMD_MyClass_opCObjectPrxS cb, CObjectPrxS i, Ice.Current current)
+    public override Task<MyClass_OpSStructSDResult>
+    opSStructSDAsync(Stack<SD> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSStructSDResult>(new MyClass_OpSStructSDResult(i, i));
     }
 
-    public override void opAStructS_async(AMD_MyClass_opAStructS cb, S[] i, Ice.Current current)
+    public override Task<MyClass_OpACVSResult>
+    opACVSAsync(CV[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpACVSResult>(new MyClass_OpACVSResult(i, i));
     }
 
-    public override void opLStructS_async(AMD_MyClass_opLStructS cb, List<S> i, Ice.Current current)
+    public override Task<MyClass_OpLCVSResult>
+    opLCVSAsync(List<CV> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLCVSResult>(new MyClass_OpLCVSResult(i, i));
     }
 
-    public override void opKStructS_async(AMD_MyClass_opKStructS cb, LinkedList<S> i, Ice.Current current)
+    public override Task<MyClass_OpACVPrxSResult>
+    opACVPrxSAsync(Ice.ObjectPrx[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpACVPrxSResult>(new MyClass_OpACVPrxSResult(i, i));
     }
 
-    public override void opQStructS_async(AMD_MyClass_opQStructS cb, Queue<S> i, Ice.Current current)
+    public override Task<MyClass_OpLCVPrxSResult>
+    opLCVPrxSAsync(List<Ice.ObjectPrx> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLCVPrxSResult>(new MyClass_OpLCVPrxSResult(i, i));
     }
 
-    public override void opSStructS_async(AMD_MyClass_opSStructS cb, Stack<S> i, Ice.Current current)
+    public override Task<MyClass_OpKCVPrxSResult>
+    opKCVPrxSAsync(LinkedList<Ice.ObjectPrx> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpKCVPrxSResult>(new MyClass_OpKCVPrxSResult(i, i));
     }
 
-    public override void opCStructS_async(AMD_MyClass_opCStructS cb, CStructS i, Ice.Current current)
+    public override Task<MyClass_OpQCVPrxSResult>
+    opQCVPrxSAsync(Queue<Ice.ObjectPrx> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpQCVPrxSResult>(new MyClass_OpQCVPrxSResult(i, i));
     }
 
-    public override void opAStructSD_async(AMD_MyClass_opAStructSD cb, SD[] i, Ice.Current current)
+    public override Task<MyClass_OpSCVPrxSResult>
+    opSCVPrxSAsync(Stack<Ice.ObjectPrx> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSCVPrxSResult>(new MyClass_OpSCVPrxSResult(i, i));
     }
 
-    public override void opLStructSD_async(AMD_MyClass_opLStructSD cb, List<SD> i, Ice.Current current)
+    public override Task<MyClass_OpACRSResult>
+    opACRSAsync(CR[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpACRSResult>(new MyClass_OpACRSResult(i, i));
     }
 
-    public override void opKStructSD_async(AMD_MyClass_opKStructSD cb, LinkedList<SD> i, Ice.Current current)
+    public override Task<MyClass_OpLCRSResult>
+    opLCRSAsync(List<CR> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLCRSResult>(new MyClass_OpLCRSResult(i, i));
     }
 
-    public override void opQStructSD_async(AMD_MyClass_opQStructSD cb, Queue<SD> i, Ice.Current current)
+    public override Task<MyClass_OpAEnSResult> opAEnSAsync(En[] i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpAEnSResult>(new MyClass_OpAEnSResult(i, i));
     }
 
-    public override void opSStructSD_async(AMD_MyClass_opSStructSD cb, Stack<SD> i, Ice.Current current)
+    public override Task<MyClass_OpLEnSResult>
+    opLEnSAsync(List<En> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpLEnSResult>(new MyClass_OpLEnSResult(i, i));
     }
 
-    public override void opCStructSD_async(AMD_MyClass_opCStructSD cb, CStructSD i, Ice.Current current)
+    public override Task<MyClass_OpKEnSResult>
+    opKEnSAsync(LinkedList<En> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpKEnSResult>(new MyClass_OpKEnSResult(i, i));
     }
 
-    public override void opACVS_async(AMD_MyClass_opACVS cb, CV[] i, Ice.Current current)
+    public override Task<MyClass_OpQEnSResult>
+    opQEnSAsync(Queue<En> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpQEnSResult>(new MyClass_OpQEnSResult(i, i));
     }
 
-    public override void opLCVS_async(AMD_MyClass_opLCVS cb, List<CV> i, Ice.Current current)
+    public override Task<MyClass_OpSEnSResult>
+    opSEnSAsync(Stack<En> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSEnSResult>(new MyClass_OpSEnSResult(i, i));
     }
 
-    public override void opCCVS_async(AMD_MyClass_opCCVS cb, CCVS i, Ice.Current current)
+    public override Task<MyClass_OpCustomIntSResult>
+    opCustomIntSAsync(Custom<int> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpCustomIntSResult>(new MyClass_OpCustomIntSResult(i, i));
     }
 
-    public override void opACVPrxS_async(AMD_MyClass_opACVPrxS cb, CVPrx[] i, Ice.Current current)
+    public override Task<MyClass_OpCustomCVSResult>
+    opCustomCVSAsync(Custom<CV> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpCustomCVSResult>(new MyClass_OpCustomCVSResult(i, i));
     }
 
-    public override void opLCVPrxS_async(AMD_MyClass_opLCVPrxS cb, List<CVPrx> i, Ice.Current current)
+    public override Task<MyClass_OpCustomIntSSResult>
+    opCustomIntSSAsync(Custom<Custom<int>> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpCustomIntSSResult>(new MyClass_OpCustomIntSSResult(i, i));
     }
 
-    public override void opKCVPrxS_async(AMD_MyClass_opKCVPrxS cb, LinkedList<CVPrx> i, Ice.Current current)
+    public override Task<MyClass_OpCustomCVSSResult>
+    opCustomCVSSAsync(Custom<Custom<CV>> i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpCustomCVSSResult>(new MyClass_OpCustomCVSSResult(i, i));
     }
 
-    public override void opQCVPrxS_async(AMD_MyClass_opQCVPrxS cb, Queue<CVPrx> i, Ice.Current current)
+    public override Task<MyClass_OpSerialSmallCSharpResult>
+    opSerialSmallCSharpAsync(Serialize.Small i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSerialSmallCSharpResult>(new MyClass_OpSerialSmallCSharpResult(i, i));
     }
 
-    public override void opSCVPrxS_async(AMD_MyClass_opSCVPrxS cb, Stack<CVPrx> i, Ice.Current current)
+    public override Task<MyClass_OpSerialLargeCSharpResult>
+    opSerialLargeCSharpAsync(Serialize.Large i, Ice.Current current)
     {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSerialLargeCSharpResult>(new MyClass_OpSerialLargeCSharpResult(i, i));
     }
 
-    public override void opCCVPrxS_async(AMD_MyClass_opCCVPrxS cb, CCVPrxS i, Ice.Current current)
+    public override Task<MyClass_OpSerialStructCSharpResult>
+    opSerialStructCSharpAsync(Serialize.Struct i, Ice.Current current)
     {
-        cb.ice_response(i, i);
-    }
-
-    public override void opACRS_async(AMD_MyClass_opACRS cb, CR[] i, Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opLCRS_async(AMD_MyClass_opLCRS cb, List<CR> i, Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opCCRS_async(AMD_MyClass_opCCRS cb, CCRS i, Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opAEnS_async(AMD_MyClass_opAEnS cb, En[] i, Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opLEnS_async(AMD_MyClass_opLEnS cb, List<En> i, Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opKEnS_async(AMD_MyClass_opKEnS cb, LinkedList<En> i, Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opQEnS_async(AMD_MyClass_opQEnS cb, Queue<En> i, Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opSEnS_async(AMD_MyClass_opSEnS cb, Stack<En> i, Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opCEnS_async(AMD_MyClass_opCEnS cb, CEnS i, Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opCustomIntS_async(AMD_MyClass_opCustomIntS cb, Custom<int> i, Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opCustomCVS_async(AMD_MyClass_opCustomCVS cb, Custom<CV> i, Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opCustomIntSS_async(AMD_MyClass_opCustomIntSS cb, Custom<Custom<int>> i, Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opCustomCVSS_async(AMD_MyClass_opCustomCVSS cb, Custom<Custom<CV>> i, Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opSerialSmallCSharp_async(AMD_MyClass_opSerialSmallCSharp cb,
-                                                   Serialize.Small i,
-                                                   Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opSerialLargeCSharp_async(AMD_MyClass_opSerialLargeCSharp cb,
-                                                   Serialize.Large i,
-                                                   Ice.Current current)
-    {
-        cb.ice_response(i, i);
-    }
-
-    public override void opSerialStructCSharp_async(AMD_MyClass_opSerialStructCSharp cb,
-                                                    Serialize.Struct i,
-                                                    Ice.Current current)
-    {
-        cb.ice_response(i, i);
+        return Task.FromResult<MyClass_OpSerialStructCSharpResult>(new MyClass_OpSerialStructCSharpResult(i, i));
     }
 }