diff options
Diffstat (limited to 'csharp/test/Ice/operations/MyDerivedClassAMDI.cs')
| -rw-r--r-- | csharp/test/Ice/operations/MyDerivedClassAMDI.cs | 828 |
1 files changed, 431 insertions, 397 deletions
diff --git a/csharp/test/Ice/operations/MyDerivedClassAMDI.cs b/csharp/test/Ice/operations/MyDerivedClassAMDI.cs index 0d6fcd373a3..a460e24fa69 100644 --- a/csharp/test/Ice/operations/MyDerivedClassAMDI.cs +++ b/csharp/test/Ice/operations/MyDerivedClassAMDI.cs @@ -10,8 +10,11 @@ using System; using System.Collections.Generic; using System.Threading; +using System.Threading.Tasks; -public sealed class MyDerivedClassI : Test.MyDerivedClass +using Test; + +public sealed class MyDerivedClassI : Test.MyDerivedClassDisp_ { private static void test(bool b) { @@ -21,11 +24,10 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass } } - internal class Thread_opVoid + internal class Thread_opVoid : TaskCompletionSource<object> { - public Thread_opVoid(Test.AMD_MyClass_opVoid cb) + public Thread_opVoid() { - _cb = cb; } public void Start() @@ -39,7 +41,7 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass public void Run() { - _cb.ice_response(); + SetResult(null); } public void Join() @@ -50,14 +52,12 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass } } - private Test.AMD_MyClass_opVoid _cb; private Thread _thread; } // // Override the Object "pseudo" operations to verify the operation mode. // - public override bool ice_isA(String id, Ice.Current current) { test(current.mode == Ice.OperationMode.Nonmutating); @@ -82,7 +82,7 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass return base.ice_id(current); } - public override void shutdown_async(Test.AMD_MyClass_shutdown cb, Ice.Current current) + public override Task shutdownAsync(Ice.Current current) { while(_opVoidThread != null) { @@ -91,16 +91,10 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass } current.adapter.getCommunicator().shutdown(); - cb.ice_response(); + return null; } - public override void delay_async(Test.AMD_MyClass_delay cb, int ms, Ice.Current current) - { - System.Threading.Thread.Sleep(ms); - cb.ice_response(); - } - - public override void opVoid_async(Test.AMD_MyClass_opVoid cb, Ice.Current current) + public override Task opVoidAsync(Ice.Current current) { test(current.mode == Ice.OperationMode.Normal); @@ -110,16 +104,17 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass _opVoidThread = null; } - _opVoidThread = new Thread_opVoid(cb); + _opVoidThread = new Thread_opVoid(); _opVoidThread.Start(); + return _opVoidThread.Task; } - public override void opBool_async(Test.AMD_MyClass_opBool cb, bool p1, bool p2, Ice.Current current) + public override Task<MyClass_OpBoolResult> opBoolAsync(bool p1, bool p2, Ice.Current current) { - cb.ice_response(p2, p1); + return Task.FromResult<MyClass_OpBoolResult>(new MyClass_OpBoolResult(p2, p1)); } - public override void opBoolS_async(Test.AMD_MyClass_opBoolS cb, bool[] p1, bool[] p2, Ice.Current current) + public override Task<MyClass_OpBoolSResult> opBoolSAsync(bool[] p1, bool[] p2, Ice.Current current) { bool[] p3 = new bool[p1.Length + p2.Length]; Array.Copy(p1, p3, p1.Length); @@ -130,11 +125,12 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass { r[i] = p1[p1.Length - (i + 1)]; } - cb.ice_response(r, p3); + + return Task.FromResult<MyClass_OpBoolSResult>(new MyClass_OpBoolSResult(r, p3)); } - public override void opBoolSS_async(Test.AMD_MyClass_opBoolSS cb, bool[][] p1, bool[][] p2, - Ice.Current current) + public override Task<MyClass_OpBoolSSResult> + opBoolSSAsync(bool[][] p1, bool[][] p2, Ice.Current current) { bool[][] p3 = new bool[p1.Length + p2.Length][]; Array.Copy(p1, p3, p1.Length); @@ -145,16 +141,18 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass { r[i] = p1[p1.Length - (i + 1)]; } - cb.ice_response(r, p3); + + return Task.FromResult<MyClass_OpBoolSSResult>(new MyClass_OpBoolSSResult(r, p3)); } - public override void opByte_async(Test.AMD_MyClass_opByte cb, byte p1, byte p2, Ice.Current current) + public override Task<MyClass_OpByteResult> + opByteAsync(byte p1, byte p2, Ice.Current current) { - cb.ice_response(p1, (byte)(p1 ^ p2)); + return Task.FromResult<MyClass_OpByteResult>(new MyClass_OpByteResult(p1, (byte)(p1 ^ p2))); } - public override void opByteBoolD_async(Test.AMD_MyClass_opByteBoolD cb, Dictionary<byte, bool> p1, - Dictionary<byte, bool> p2, Ice.Current current) + public override Task<MyClass_OpByteBoolDResult> + opByteBoolDAsync(Dictionary<byte, bool> p1, Dictionary<byte, bool> p2, Ice.Current current) { Dictionary<byte, bool> p3 = p1; Dictionary<byte, bool> r = new Dictionary<byte, bool>(); @@ -166,10 +164,12 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass { r[e.Key] = e.Value; } - cb.ice_response(r, p3); + + return Task.FromResult<MyClass_OpByteBoolDResult>(new MyClass_OpByteBoolDResult(r, p3)); } - public override void opByteS_async(Test.AMD_MyClass_opByteS cb, byte[] p1, byte[] p2, Ice.Current current) + public override Task<MyClass_OpByteSResult> + opByteSAsync(byte[] p1, byte[] p2, Ice.Current current) { byte[] p3 = new byte[p1.Length]; for(int i = 0; i < p1.Length; i++) @@ -180,11 +180,12 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass byte[] r = new byte[p1.Length + p2.Length]; Array.Copy(p1, r, p1.Length); Array.Copy(p2, 0, r, p1.Length, p2.Length); - cb.ice_response(r, p3); + + return Task.FromResult<MyClass_OpByteSResult>(new MyClass_OpByteSResult(r, p3)); } - public override void opByteSS_async(Test.AMD_MyClass_opByteSS cb, byte[][] p1, byte[][] p2, - Ice.Current current) + public override Task<MyClass_OpByteSSResult> + opByteSSAsync(byte[][] p1, byte[][] p2, Ice.Current current) { byte[][] p3 = new byte[p1.Length][]; for(int i = 0; i < p1.Length; i++) @@ -195,17 +196,18 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass byte[][] r = new byte[p1.Length + p2.Length][]; Array.Copy(p1, r, p1.Length); Array.Copy(p2, 0, r, p1.Length, p2.Length); - cb.ice_response(r, p3); + + return Task.FromResult<MyClass_OpByteSSResult>(new MyClass_OpByteSSResult(r, p3)); } - public override void opFloatDouble_async(Test.AMD_MyClass_opFloatDouble cb, float p1, double p2, - Ice.Current current) + public override Task<MyClass_OpFloatDoubleResult> + opFloatDoubleAsync(float p1, double p2, Ice.Current current) { - cb.ice_response(p2, p1, p2); + return Task.FromResult<MyClass_OpFloatDoubleResult>(new MyClass_OpFloatDoubleResult(p2, p1, p2)); } - public override void opFloatDoubleS_async(Test.AMD_MyClass_opFloatDoubleS cb, float[] p1, double[] p2, - Ice.Current current) + public override Task<MyClass_OpFloatDoubleSResult> + opFloatDoubleSAsync(float[] p1, double[] p2, Ice.Current current) { float[] p3 = p1; @@ -219,40 +221,42 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass Array.Copy(p2, r, p2.Length); for(int i = 0; i < p1.Length; i++) { - r[p2.Length + i] = (double)p1[i]; + r[p2.Length + i] = p1[i]; } - cb.ice_response(r, p3, p4); + + return Task.FromResult<MyClass_OpFloatDoubleSResult>(new MyClass_OpFloatDoubleSResult(r, p3, p4)); } - public override void opFloatDoubleSS_async(Test.AMD_MyClass_opFloatDoubleSS cb, float[][] p1, double[][] p2, - Ice.Current current) + public override Task<MyClass_OpFloatDoubleSSResult> + opFloatDoubleSSAsync(float[][] p1, double[][] p2, Ice.Current current) { - float[][] p3 = p1; + var p3 = p1; - double[][] p4 = new double[p2.Length][]; + var p4 = new double[p2.Length][]; for(int i = 0; i < p2.Length; i++) { p4[i] = p2[p2.Length - (i + 1)]; } - double[][] r = new double[p2.Length + p2.Length][]; + var r = new double[p2.Length + p2.Length][]; Array.Copy(p2, r, p2.Length); for(int i = 0; i < p2.Length; i++) { r[p2.Length + i] = new double[p2[i].Length]; for(int j = 0; j < p2[i].Length; j++) { - r[p2.Length + i][j] = (double)p2[i][j]; + r[p2.Length + i][j] = p2[i][j]; } } - cb.ice_response(r, p3, p4); + + return Task.FromResult<MyClass_OpFloatDoubleSSResult>(new MyClass_OpFloatDoubleSSResult(r, p3, p4)); } - public override void opLongFloatD_async(Test.AMD_MyClass_opLongFloatD cb, Dictionary<long, float> p1, - Dictionary<long, float> p2, Ice.Current current) + public override Task<MyClass_OpLongFloatDResult> + opLongFloatDAsync(Dictionary<long, float> p1, Dictionary<long, float> p2, Ice.Current current) { - Dictionary<long, float> p3 = p1; - Dictionary<long, float> r = new Dictionary<long, float>(); + var p3 = p1; + var r = new Dictionary<long, float>(); foreach(KeyValuePair<long, float> e in p1) { r[e.Key] = e.Value; @@ -261,27 +265,31 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass { r[e.Key] = e.Value; } - cb.ice_response(r, p3); + + return Task.FromResult<MyClass_OpLongFloatDResult>(new MyClass_OpLongFloatDResult(r, p3)); } - public override void opMyClass_async(Test.AMD_MyClass_opMyClass cb, Test.MyClassPrx p1, Ice.Current current) + public override Task<MyClass_OpMyClassResult> + opMyClassAsync(MyClassPrx p1, Ice.Current current) { - Test.MyClassPrx p2 = p1; - Test.MyClassPrx p3 = Test.MyClassPrxHelper.uncheckedCast(current.adapter.createProxy( - current.adapter.getCommunicator().stringToIdentity("noSuchIdentity"))); - cb.ice_response(Test.MyClassPrxHelper.uncheckedCast(current.adapter.createProxy(current.id)), p2, p3); + var p2 = p1; + var p3 = MyClassPrxHelper.uncheckedCast(current.adapter.createProxy( + Ice.Util.stringToIdentity("noSuchIdentity"))); + return Task.FromResult<MyClass_OpMyClassResult>(new MyClass_OpMyClassResult( + MyClassPrxHelper.uncheckedCast(current.adapter.createProxy(current.id)), p2, p3)); } - public override void opMyEnum_async(Test.AMD_MyClass_opMyEnum cb, Test.MyEnum p1, Ice.Current current) + public override Task<MyClass_OpMyEnumResult> + opMyEnumAsync(MyEnum p1, Ice.Current current) { - cb.ice_response(Test.MyEnum.enum3, p1); + return Task.FromResult<MyClass_OpMyEnumResult>(new MyClass_OpMyEnumResult(MyEnum.enum3, p1)); } - public override void opShortIntD_async(Test.AMD_MyClass_opShortIntD cb, Dictionary<short, int> p1, - Dictionary<short, int> p2, Ice.Current current) + public override Task<MyClass_OpShortIntDResult> + opShortIntDAsync(Dictionary<short, int> p1, Dictionary<short, int> p2, Ice.Current current) { - Dictionary<short, int> p3 = p1; - Dictionary<short, int> r = new Dictionary<short, int>(); + var p3 = p1; + var r = new Dictionary<short, int>(); foreach(KeyValuePair<short, int> e in p1) { r[e.Key] = e.Value; @@ -290,59 +298,58 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass { r[e.Key] = e.Value; } - cb.ice_response(r, p3); + return Task.FromResult<MyClass_OpShortIntDResult>(new MyClass_OpShortIntDResult(r, p3)); } - public override void opShortIntLong_async(Test.AMD_MyClass_opShortIntLong cb, short p1, int p2, long p3, - Ice.Current current) + public override Task<MyClass_OpShortIntLongResult> + opShortIntLongAsync(short p1, int p2, long p3, Ice.Current current) { - cb.ice_response(p3, p1, p2, p3); + return Task.FromResult<MyClass_OpShortIntLongResult>(new MyClass_OpShortIntLongResult(p3, p1, p2, p3)); } - public override void opShortIntLongS_async(Test.AMD_MyClass_opShortIntLongS cb, short[] p1, int[] p2, - long[] p3, Ice.Current current) + public override Task<MyClass_OpShortIntLongSResult> + opShortIntLongSAsync(short[] p1, int[] p2, long[] p3, Ice.Current current) { - short[] p4 = p1; - - int[] p5 = new int[p2.Length]; + var p4 = p1; + var p5 = new int[p2.Length]; for(int i = 0; i < p2.Length; i++) { p5[i] = p2[p2.Length - (i + 1)]; } - - long[] p6 = new long[p3.Length + p3.Length]; + var p6 = new long[p3.Length + p3.Length]; Array.Copy(p3, p6, p3.Length); Array.Copy(p3, 0, p6, p3.Length, p3.Length); - cb.ice_response(p3, p4, p5, p6); + return Task.FromResult<MyClass_OpShortIntLongSResult>(new MyClass_OpShortIntLongSResult(p3, p4, p5, p6)); } - public override void opShortIntLongSS_async(Test.AMD_MyClass_opShortIntLongSS cb, short[][] p1, - int[][] p2, long[][] p3, Ice.Current current) + public override Task<MyClass_OpShortIntLongSSResult> + opShortIntLongSSAsync(short[][] p1, int[][] p2, long[][] p3, Ice.Current current) { - short[][] p4 = p1; + var p4 = p1; - int[][] p5 = new int[p2.Length][]; + var p5 = new int[p2.Length][]; for(int i = 0; i < p2.Length; i++) { p5[i] = p2[p2.Length - (i + 1)]; } - long[][] p6 = new long[p3.Length + p3.Length][]; + var p6 = new long[p3.Length + p3.Length][]; Array.Copy(p3, p6, p3.Length); Array.Copy(p3, 0, p6, p3.Length, p3.Length); - cb.ice_response(p3, p4, p5, p6); + return Task.FromResult<MyClass_OpShortIntLongSSResult>(new MyClass_OpShortIntLongSSResult(p3, p4, p5, p6)); } - public override void opString_async(Test.AMD_MyClass_opString cb, string p1, string p2, Ice.Current current) + public override Task<MyClass_OpStringResult> + opStringAsync(string p1, string p2, Ice.Current current) { - cb.ice_response(p1 + " " + p2, p2 + " " + p1); + return Task.FromResult<MyClass_OpStringResult>(new MyClass_OpStringResult(p1 + " " + p2, p2 + " " + p1)); } - public override void opStringMyEnumD_async(Test.AMD_MyClass_opStringMyEnumD cb, Dictionary<string, Test.MyEnum> p1, - Dictionary<string, Test.MyEnum> p2, Ice.Current current) + public override Task<MyClass_OpStringMyEnumDResult> + opStringMyEnumDAsync(Dictionary<string, MyEnum> p1, Dictionary<string, MyEnum> p2, Ice.Current current) { - Dictionary<string, Test.MyEnum> p3 = p1; - Dictionary<string, Test.MyEnum> r = new Dictionary<string, Test.MyEnum>(); + var p3 = p1; + var r = new Dictionary<string, Test.MyEnum>(); foreach(KeyValuePair<string, Test.MyEnum> e in p1) { r[e.Key] = e.Value; @@ -351,186 +358,168 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass { r[e.Key] = e.Value; } - cb.ice_response(r, p3); + return Task.FromResult<MyClass_OpStringMyEnumDResult>(new MyClass_OpStringMyEnumDResult(r, p3)); } - public override void opMyEnumStringD_async(Test.AMD_MyClass_opMyEnumStringD cb, Dictionary<Test.MyEnum, string> p1, - Dictionary<Test.MyEnum, string> p2, Ice.Current current) + public override Task<MyClass_OpMyEnumStringDResult> + opMyEnumStringDAsync(Dictionary<MyEnum, string> p1, Dictionary<MyEnum, string> p2, Ice.Current current) { - Dictionary<Test.MyEnum, string> p3 = p1; - Dictionary<Test.MyEnum, string> r = new Dictionary<Test.MyEnum, string>(); - foreach(KeyValuePair<Test.MyEnum, string> e in p1) + var p3 = p1; + var r = new Dictionary<MyEnum, string>(); + foreach(var e in p1) { r[e.Key] = e.Value; } - foreach(KeyValuePair<Test.MyEnum, string> e in p2) + foreach(KeyValuePair<MyEnum, string> e in p2) { r[e.Key] = e.Value; } - cb.ice_response(r, p3); + return Task.FromResult<MyClass_OpMyEnumStringDResult>(new MyClass_OpMyEnumStringDResult(r, p3)); } - public override void opMyStructMyEnumD_async(Test.AMD_MyClass_opMyStructMyEnumD cb, - Dictionary<Test.MyStruct, Test.MyEnum> p1, - Dictionary<Test.MyStruct, Test.MyEnum> p2, Ice.Current current) + public override Task<MyClass_OpMyStructMyEnumDResult> + opMyStructMyEnumDAsync(Dictionary<MyStruct, MyEnum> p1, + Dictionary<MyStruct, MyEnum> p2, Ice.Current current) { - Dictionary<Test.MyStruct, Test.MyEnum> p3 = p1; - Dictionary<Test.MyStruct, Test.MyEnum> r = new Dictionary<Test.MyStruct, Test.MyEnum>(); - foreach(KeyValuePair<Test.MyStruct, Test.MyEnum> e in p1) + var p3 = p1; + var r = new Dictionary<MyStruct, MyEnum>(); + foreach(var e in p1) { r[e.Key] = e.Value; } - foreach(KeyValuePair<Test.MyStruct, Test.MyEnum> e in p2) + foreach(var e in p2) { r[e.Key] = e.Value; } - cb.ice_response(r, p3); + return Task.FromResult<MyClass_OpMyStructMyEnumDResult>(new MyClass_OpMyStructMyEnumDResult(r, p3)); } - public override void opByteBoolDS_async(Test.AMD_MyClass_opByteBoolDS cb, - Dictionary<byte, bool>[] p1, - Dictionary<byte, bool>[] p2, - Ice.Current current) + public override Task<MyClass_OpByteBoolDSResult> + opByteBoolDSAsync(Dictionary<byte, bool>[] p1, Dictionary<byte, bool>[] p2, Ice.Current current) { - Dictionary<byte, bool>[] p3 = new Dictionary<byte, bool>[p1.Length + p2.Length]; + var p3 = new Dictionary<byte, bool>[p1.Length + p2.Length]; Array.Copy(p2, p3, p2.Length); Array.Copy(p1, 0, p3, p2.Length, p1.Length); - Dictionary<byte, bool>[] r = new Dictionary<byte, bool>[p1.Length]; + var r = new Dictionary<byte, bool>[p1.Length]; for(int i = 0; i < p1.Length; i++) { r[i] = p1[p1.Length - (i + 1)]; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpByteBoolDSResult>(new MyClass_OpByteBoolDSResult(r, p3)); } - public override void opShortIntDS_async(Test.AMD_MyClass_opShortIntDS cb, - Dictionary<short, int>[] p1, - Dictionary<short, int>[] p2, - Ice.Current current) + public override Task<MyClass_OpShortIntDSResult> + opShortIntDSAsync(Dictionary<short, int>[] p1, Dictionary<short, int>[] p2, Ice.Current current) { - Dictionary<short, int>[] p3 = new Dictionary<short, int>[p1.Length + p2.Length]; + var p3 = new Dictionary<short, int>[p1.Length + p2.Length]; Array.Copy(p2, p3, p2.Length); Array.Copy(p1, 0, p3, p2.Length, p1.Length); - Dictionary<short, int>[] r = new Dictionary<short, int>[p1.Length]; + var r = new Dictionary<short, int>[p1.Length]; for(int i = 0; i < p1.Length; i++) { r[i] = p1[p1.Length - (i + 1)]; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpShortIntDSResult>(new MyClass_OpShortIntDSResult(r, p3)); } - public override void opLongFloatDS_async(Test.AMD_MyClass_opLongFloatDS cb, - Dictionary<long, float>[] p1, - Dictionary<long, float>[] p2, - Ice.Current current) + public override Task<MyClass_OpLongFloatDSResult> + opLongFloatDSAsync(Dictionary<long, float>[] p1, Dictionary<long, float>[] p2, Ice.Current current) { - Dictionary<long, float>[] p3 = new Dictionary<long, float>[p1.Length + p2.Length]; + var p3 = new Dictionary<long, float>[p1.Length + p2.Length]; Array.Copy(p2, p3, p2.Length); Array.Copy(p1, 0, p3, p2.Length, p1.Length); - Dictionary<long, float>[] r = new Dictionary<long, float>[p1.Length]; + var r = new Dictionary<long, float>[p1.Length]; for(int i = 0; i < p1.Length; i++) { r[i] = p1[p1.Length - (i + 1)]; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpLongFloatDSResult>(new MyClass_OpLongFloatDSResult(r, p3)); } - public override void opStringStringDS_async(Test.AMD_MyClass_opStringStringDS cb, - Dictionary<string, string>[] p1, - Dictionary<string, string>[] p2, - Ice.Current current) + public override Task<MyClass_OpStringStringDSResult> + opStringStringDSAsync(Dictionary<string, string>[] p1, Dictionary<string, string>[] p2, Ice.Current current) { - Dictionary<string, string>[] p3 = new Dictionary<string, string>[p1.Length + p2.Length]; + var p3 = new Dictionary<string, string>[p1.Length + p2.Length]; Array.Copy(p2, p3, p2.Length); Array.Copy(p1, 0, p3, p2.Length, p1.Length); - Dictionary<string, string>[] r = new Dictionary<string, string>[p1.Length]; + var r = new Dictionary<string, string>[p1.Length]; for(int i = 0; i < p1.Length; i++) { r[i] = p1[p1.Length - (i + 1)]; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpStringStringDSResult>(new MyClass_OpStringStringDSResult(r, p3)); } - public override void opStringMyEnumDS_async(Test.AMD_MyClass_opStringMyEnumDS cb, - Dictionary<string, Test.MyEnum>[] p1, - Dictionary<string, Test.MyEnum>[] p2, - Ice.Current current) + public override Task<MyClass_OpStringMyEnumDSResult> + opStringMyEnumDSAsync(Dictionary<string, MyEnum>[] p1, Dictionary<string, MyEnum>[] p2, Ice.Current current) { - Dictionary<string, Test.MyEnum>[] p3 = new Dictionary<string, Test.MyEnum>[p1.Length + p2.Length]; + var p3 = new Dictionary<string, MyEnum>[p1.Length + p2.Length]; Array.Copy(p2, p3, p2.Length); Array.Copy(p1, 0, p3, p2.Length, p1.Length); - Dictionary<string, Test.MyEnum>[] r = new Dictionary<string, Test.MyEnum>[p1.Length]; + var r = new Dictionary<string, MyEnum>[p1.Length]; for(int i = 0; i < p1.Length; i++) { r[i] = p1[p1.Length - (i + 1)]; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpStringMyEnumDSResult>(new MyClass_OpStringMyEnumDSResult(r, p3)); } - public override void opMyEnumStringDS_async(Test.AMD_MyClass_opMyEnumStringDS cb, - Dictionary<Test.MyEnum, string>[] p1, - Dictionary<Test.MyEnum, string>[] p2, - Ice.Current current) + public override Task<MyClass_OpMyEnumStringDSResult> + opMyEnumStringDSAsync(Dictionary<MyEnum, string>[] p1, Dictionary<MyEnum, string>[] p2, Ice.Current current) { - Dictionary<Test.MyEnum, string>[] p3 = new Dictionary<Test.MyEnum, string>[p1.Length + p2.Length]; + var p3 = new Dictionary<MyEnum, string>[p1.Length + p2.Length]; Array.Copy(p2, p3, p2.Length); Array.Copy(p1, 0, p3, p2.Length, p1.Length); - Dictionary<Test.MyEnum, string>[] r = new Dictionary<Test.MyEnum, string>[p1.Length]; + var r = new Dictionary<MyEnum, string>[p1.Length]; for(int i = 0; i < p1.Length; i++) { r[i] = p1[p1.Length - (i + 1)]; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpMyEnumStringDSResult>(new MyClass_OpMyEnumStringDSResult(r, p3)); } - public override void opMyStructMyEnumDS_async(Test.AMD_MyClass_opMyStructMyEnumDS cb, - Dictionary<Test.MyStruct, Test.MyEnum>[] p1, - Dictionary<Test.MyStruct, Test.MyEnum>[] p2, - Ice.Current current) + public override Task<MyClass_OpMyStructMyEnumDSResult> + opMyStructMyEnumDSAsync(Dictionary<MyStruct, MyEnum>[] p1, Dictionary<MyStruct, MyEnum>[] p2, Ice.Current current) { - Dictionary<Test.MyStruct, Test.MyEnum>[] p3 = new Dictionary<Test.MyStruct, Test.MyEnum>[p1.Length + p2.Length]; + var p3 = new Dictionary<MyStruct, MyEnum>[p1.Length + p2.Length]; Array.Copy(p2, p3, p2.Length); Array.Copy(p1, 0, p3, p2.Length, p1.Length); - Dictionary<Test.MyStruct, Test.MyEnum>[] r = new Dictionary<Test.MyStruct, Test.MyEnum>[p1.Length]; + var r = new Dictionary<MyStruct, MyEnum>[p1.Length]; for(int i = 0; i < p1.Length; i++) { r[i] = p1[p1.Length - (i + 1)]; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpMyStructMyEnumDSResult>(new MyClass_OpMyStructMyEnumDSResult(r, p3)); } - public override void opByteByteSD_async(Test.AMD_MyClass_opByteByteSD cb, - Dictionary<byte, byte[]> p1, - Dictionary<byte, byte[]> p2, - Ice.Current current) + public override Task<MyClass_OpByteByteSDResult> + opByteByteSDAsync(Dictionary<byte, byte[]> p1, Dictionary<byte, byte[]> p2, Ice.Current current) { - Dictionary<byte, byte[]> p3 = p2; - Dictionary<byte, byte[]> r = new Dictionary<byte, byte[]>(); - foreach(KeyValuePair<byte, byte[]> e in p1) + var p3 = p2; + var r = new Dictionary<byte, byte[]>(); + foreach(var e in p1) { r[e.Key] = e.Value; } - foreach(KeyValuePair<byte, byte[]> e in p2) + foreach(var e in p2) { r[e.Key] = e.Value; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpByteByteSDResult>(new MyClass_OpByteByteSDResult(r, p3)); } - public override void opBoolBoolSD_async(Test.AMD_MyClass_opBoolBoolSD cb, - Dictionary<bool, bool[]> p1, - Dictionary<bool, bool[]> p2, - Ice.Current current) + public override Task<MyClass_OpBoolBoolSDResult> + opBoolBoolSDAsync(Dictionary<bool, bool[]> p1, Dictionary<bool, bool[]> p2, Ice.Current current) { - Dictionary<bool, bool[]> p3 = p2; - Dictionary<bool, bool[]> r = new Dictionary<bool, bool[]>(); + var p3 = p2; + var r = new Dictionary<bool, bool[]>(); foreach(KeyValuePair<bool, bool[]> e in p1) { r[e.Key] = e.Value; @@ -539,419 +528,464 @@ public sealed class MyDerivedClassI : Test.MyDerivedClass { r[e.Key] = e.Value; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpBoolBoolSDResult>(new MyClass_OpBoolBoolSDResult(r, p3)); } - public override void opShortShortSD_async(Test.AMD_MyClass_opShortShortSD cb, - Dictionary<short, short[]> p1, - Dictionary<short, short[]> p2, - Ice.Current current) + public override Task<MyClass_OpShortShortSDResult> + opShortShortSDAsync(Dictionary<short, short[]> p1, Dictionary<short, short[]> p2, Ice.Current current) { - Dictionary<short, short[]> p3 = p2; - Dictionary<short, short[]> r = new Dictionary<short, short[]>(); - foreach(KeyValuePair<short, short[]> e in p1) + var p3 = p2; + var r = new Dictionary<short, short[]>(); + foreach(var e in p1) { r[e.Key] = e.Value; } - foreach(KeyValuePair<short, short[]> e in p2) + foreach(var e in p2) { r[e.Key] = e.Value; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpShortShortSDResult>(new MyClass_OpShortShortSDResult(r, p3)); } - public override void opIntIntSD_async(Test.AMD_MyClass_opIntIntSD cb, - Dictionary<int, int[]> p1, - Dictionary<int, int[]> p2, - Ice.Current current) + public override Task<MyClass_OpIntIntSDResult> + opIntIntSDAsync(Dictionary<int, int[]> p1, Dictionary<int, int[]> p2, Ice.Current current) { - Dictionary<int, int[]> p3 = p2; - Dictionary<int, int[]> r = new Dictionary<int, int[]>(); - foreach(KeyValuePair<int, int[]> e in p1) + var p3 = p2; + var r = new Dictionary<int, int[]>(); + foreach(var e in p1) { r[e.Key] = e.Value; } - foreach(KeyValuePair<int, int[]> e in p2) + foreach(var e in p2) { r[e.Key] = e.Value; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpIntIntSDResult>(new MyClass_OpIntIntSDResult(r, p3)); } - public override void opLongLongSD_async(Test.AMD_MyClass_opLongLongSD cb, - Dictionary<long, long[]> p1, - Dictionary<long, long[]> p2, - Ice.Current current) + public override Task<MyClass_OpLongLongSDResult> + opLongLongSDAsync(Dictionary<long, long[]> p1, Dictionary<long, long[]> p2, Ice.Current current) { - Dictionary<long, long[]> p3 = p2; - Dictionary<long, long[]> r = new Dictionary<long, long[]>(); - foreach(KeyValuePair<long, long[]> e in p1) + var p3 = p2; + var r = new Dictionary<long, long[]>(); + foreach(var e in p1) { r[e.Key] = e.Value; } - foreach(KeyValuePair<long, long[]> e in p2) + foreach(var e in p2) { r[e.Key] = e.Value; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpLongLongSDResult>(new MyClass_OpLongLongSDResult(r, p3)); } - public override void opStringFloatSD_async(Test.AMD_MyClass_opStringFloatSD cb, - Dictionary<string, float[]> p1, - Dictionary<string, float[]> p2, - Ice.Current current) + public override Task<MyClass_OpStringFloatSDResult> + opStringFloatSDAsync(Dictionary<string, float[]> p1, Dictionary<string, float[]> p2, Ice.Current current) { - Dictionary<string, float[]> p3 = p2; - Dictionary<string, float[]> r = new Dictionary<string, float[]>(); - foreach(KeyValuePair<string, float[]> e in p1) + var p3 = p2; + var r = new Dictionary<string, float[]>(); + foreach(var e in p1) { r[e.Key] = e.Value; } - foreach(KeyValuePair<string, float[]> e in p2) + foreach(var e in p2) { r[e.Key] = e.Value; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpStringFloatSDResult>(new MyClass_OpStringFloatSDResult(r, p3)); } - public override void opStringDoubleSD_async(Test.AMD_MyClass_opStringDoubleSD cb, - Dictionary<string, double[]> p1, - Dictionary<string, double[]> p2, - Ice.Current current) + public override Task<MyClass_OpStringDoubleSDResult> + opStringDoubleSDAsync(Dictionary<string, double[]> p1, Dictionary<string, double[]> p2, Ice.Current current) { - Dictionary<string, double[]> p3 = p2; - Dictionary<string, double[]> r = new Dictionary<string, double[]>(); - foreach(KeyValuePair<string, double[]> e in p1) + var p3 = p2; + var r = new Dictionary<string, double[]>(); + foreach(var e in p1) { r[e.Key] = e.Value; } - foreach(KeyValuePair<string, double[]> e in p2) + foreach(var e in p2) { r[e.Key] = e.Value; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpStringDoubleSDResult>(new MyClass_OpStringDoubleSDResult(r, p3)); } - public override void opStringStringSD_async(Test.AMD_MyClass_opStringStringSD cb, - Dictionary<string, string[]> p1, - Dictionary<string, string[]> p2, - Ice.Current current) + public override Task<MyClass_OpStringStringSDResult> + opStringStringSDAsync(Dictionary<string, string[]> p1, Dictionary<string, string[]> p2, Ice.Current current) { - Dictionary<string, string[]> p3 = p2; - Dictionary<string, string[]> r = new Dictionary<string, string[]>(); - foreach(KeyValuePair<string, string[]> e in p1) + var p3 = p2; + var r = new Dictionary<string, string[]>(); + foreach(var e in p1) { r[e.Key] = e.Value; } - foreach(KeyValuePair<string, string[]> e in p2) + foreach(var e in p2) { r[e.Key] = e.Value; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpStringStringSDResult>(new MyClass_OpStringStringSDResult(r, p3)); } - public override void opMyEnumMyEnumSD_async(Test.AMD_MyClass_opMyEnumMyEnumSD cb, - Dictionary<Test.MyEnum, Test.MyEnum[]> p1, - Dictionary<Test.MyEnum, Test.MyEnum[]> p2, - Ice.Current ice) + public override Task<MyClass_OpMyEnumMyEnumSDResult> + opMyEnumMyEnumSDAsync(Dictionary<MyEnum, MyEnum[]> p1, Dictionary<MyEnum, MyEnum[]> p2, Ice.Current current) { - Dictionary<Test.MyEnum, Test.MyEnum[]> p3 = p2; - Dictionary<Test.MyEnum, Test.MyEnum[]> r = new Dictionary<Test.MyEnum, Test.MyEnum[]>(); - foreach(KeyValuePair<Test.MyEnum, Test.MyEnum[]> e in p1) + var p3 = p2; + var r = new Dictionary<Test.MyEnum, Test.MyEnum[]>(); + foreach(var e in p1) { r[e.Key] = e.Value; } - foreach(KeyValuePair<Test.MyEnum, Test.MyEnum[]> e in p2) + foreach(var e in p2) { r[e.Key] = e.Value; } - cb.ice_response(r,p3); + return Task.FromResult<MyClass_OpMyEnumMyEnumSDResult>(new MyClass_OpMyEnumMyEnumSDResult(r, p3)); } - public override void opIntS_async(Test.AMD_MyClass_opIntS cb, int[] s, Ice.Current current) + public override Task<int[]> + opIntSAsync(int[] s, Ice.Current current) { - int[] r = new int[s.Length]; + var r = new int[s.Length]; for(int i = 0; i < s.Length; ++i) { r[i] = -s[i]; } - cb.ice_response(r); + return Task.FromResult<int[]>(r); } - public override void opContext_async(Test.AMD_MyClass_opContext cb, Ice.Current current) + public override Task<Dictionary<string, string>> + opContextAsync(Ice.Current current) { - cb.ice_response(current.ctx); + return Task.FromResult<Dictionary<string, string>>(current.ctx); } - public override void opByteSOneway_async(Test.AMD_MyClass_opByteSOneway cb, byte[] s, Ice.Current current) + public override Task + opByteSOnewayAsync(byte[] s, Ice.Current current) { lock(this) { ++_opByteSOnewayCallCount; } - cb.ice_response(); + return null; } - public override void opByteSOnewayCallCount_async(Test.AMD_MyClass_opByteSOnewayCallCount cb, Ice.Current current) + public override Task<int> + opByteSOnewayCallCountAsync(Ice.Current current) { lock(this) { - int count = _opByteSOnewayCallCount; + var count = _opByteSOnewayCallCount; _opByteSOnewayCallCount = 0; - cb.ice_response(count); + return Task.FromResult<int>(count); } } - public override void opDoubleMarshaling_async(Test.AMD_MyClass_opDoubleMarshaling cb, double p1, double[] p2, - Ice.Current current) + public override Task + opDoubleMarshalingAsync(double p1, double[] p2, Ice.Current current) { - double d = 1278312346.0 / 13.0; + var d = 1278312346.0 / 13.0; test(p1 == d); for(int i = 0; i < p2.Length; ++i) { test(p2[i] == d); } - cb.ice_response(); + return null; } - public override void opStringS_async(Test.AMD_MyClass_opStringS cb, string[] p1, string[] p2, - Ice.Current current) + public override Task<MyClass_OpStringSResult> + opStringSAsync(string[] p1, string[] p2, Ice.Current current) { - string[] p3 = new string[p1.Length + p2.Length]; + var p3 = new string[p1.Length + p2.Length]; Array.Copy(p1, p3, p1.Length); Array.Copy(p2, 0, p3, p1.Length, p2.Length); - string[] r = new string[p1.Length]; + var r = new string[p1.Length]; for(int i = 0; i < p1.Length; i++) { r[i] = p1[p1.Length - (i + 1)]; } - cb.ice_response(r, p3); + return Task.FromResult<MyClass_OpStringSResult>(new MyClass_OpStringSResult(r, p3)); } - public override void opStringSS_async(Test.AMD_MyClass_opStringSS cb, string[][] p1, string[][] p2, - Ice.Current current) + public override Task<MyClass_OpStringSSResult> + opStringSSAsync(string[][] p1, string[][] p2, Ice.Current current) { - string[][] p3 = new string[p1.Length + p2.Length][]; + var p3 = new string[p1.Length + p2.Length][]; Array.Copy(p1, p3, p1.Length); Array.Copy(p2, 0, p3, p1.Length, p2.Length); - - string[][] r = new string[p2.Length][]; + var r = new string[p2.Length][]; for(int i = 0; i < p2.Length; i++) { r[i] = p2[p2.Length - (i + 1)]; } - cb.ice_response(r, p3); + return Task.FromResult<MyClass_OpStringSSResult>(new MyClass_OpStringSSResult(r, p3)); } - public override void opStringSSS_async(Test.AMD_MyClass_opStringSSS cb, string[][][] p1, string[][][] p2, - Ice.Current current) + public override Task<MyClass_OpStringSSSResult> + opStringSSSAsync(string[][][] p1, string[][][] p2, Ice.Current current) { - string[][][] p3 = new string[p1.Length + p2.Length][][]; + var p3 = new string[p1.Length + p2.Length][][]; Array.Copy(p1, p3, p1.Length); Array.Copy(p2, 0, p3, p1.Length, p2.Length); - string[][][] r = new string[p2.Length][][]; + var r = new string[p2.Length][][]; for(int i = 0; i < p2.Length; i++) { r[i] = p2[p2.Length - (i + 1)]; } - cb.ice_response(r, p3); + return Task.FromResult<MyClass_OpStringSSSResult>(new MyClass_OpStringSSSResult(r, p3)); } - public override void opStringStringD_async(Test.AMD_MyClass_opStringStringD cb, Dictionary<string, string> p1, - Dictionary<string, string> p2, Ice.Current current) + public override Task<MyClass_OpStringStringDResult> + opStringStringDAsync(Dictionary<string, string> p1, Dictionary<string, string> p2, Ice.Current current) { - Dictionary<string, string> p3 = p1; - Dictionary<string, string> r = new Dictionary<string, string>(); - foreach(KeyValuePair<string, string> e in p1) + var p3 = p1; + var r = new Dictionary<string, string>(); + foreach(var e in p1) { r[e.Key] = e.Value; } - foreach(KeyValuePair<string, string> e in p2) + foreach(var e in p2) { r[e.Key] = e.Value; } - cb.ice_response(r, p3); + return Task.FromResult<MyClass_OpStringStringDResult>(new MyClass_OpStringStringDResult(r, p3)); } - public override void opStruct_async(Test.AMD_MyClass_opStruct cb, Test.Structure p1, Test.Structure p2, - Ice.Current current) + public override Task<MyClass_OpStructResult> + opStructAsync(Structure p1, Structure p2, Ice.Current current) { - Test.Structure p3 = p1; + var p3 = p1; p3.s.s = "a new string"; - cb.ice_response(p2, p3); + return Task.FromResult<MyClass_OpStructResult>(new MyClass_OpStructResult(p2, p3)); } - public override void opIdempotent_async(Test.AMD_MyClass_opIdempotent cb, Ice.Current current) + public override Task + opIdempotentAsync(Ice.Current current) { test(current.mode == Ice.OperationMode.Idempotent); - cb.ice_response(); + return null; } - public override void opNonmutating_async(Test.AMD_MyClass_opNonmutating cb, Ice.Current current) + public override Task + opNonmutatingAsync(Ice.Current current) { test(current.mode == Ice.OperationMode.Nonmutating); - cb.ice_response(); + return null; } - public override void opDerived_async(Test.AMD_MyDerivedClass_opDerived cb, Ice.Current current) + public override Task + opDerivedAsync(Ice.Current current) { - cb.ice_response(); + return null; } - - public override void opByte1_async(Test.AMD_MyClass_opByte1 cb, byte value, Ice.Current current) + + public override Task<byte> + opByte1Async(byte value, Ice.Current current) { - cb.ice_response(value); + return Task.FromResult<byte>(value); } - - public override void opShort1_async(Test.AMD_MyClass_opShort1 cb, short value, Ice.Current current) + + public override Task<short> + opShort1Async(short value, Ice.Current current) { - cb.ice_response(value); + return Task.FromResult<short>(value); } - - public override void opInt1_async(Test.AMD_MyClass_opInt1 cb, int value, Ice.Current current) + + public override Task<int> + opInt1Async(int value, Ice.Current current) { - cb.ice_response(value); + return Task.FromResult<int>(value); } - - public override void opLong1_async(Test.AMD_MyClass_opLong1 cb, long value, Ice.Current current) + + public override Task<long> + opLong1Async(long value, Ice.Current current) { - cb.ice_response(value); + return Task.FromResult<long>(value); } - - public override void opFloat1_async(Test.AMD_MyClass_opFloat1 cb, float value, Ice.Current current) + + public override Task<float> + opFloat1Async(float value, Ice.Current current) { - cb.ice_response(value); + return Task.FromResult<float>(value); } - - public override void opDouble1_async(Test.AMD_MyClass_opDouble1 cb, double value, Ice.Current current) + + public override Task<double> + opDouble1Async(double value, Ice.Current current) { - cb.ice_response(value); + return Task.FromResult<double>(value); } - - public override void opString1_async(Test.AMD_MyClass_opString1 cb, string value, Ice.Current current) + + public override Task<string> + opString1Async(string value, Ice.Current current) { - cb.ice_response(value); + return Task.FromResult<string>(value); } - - public override void opStringS1_async(Test.AMD_MyClass_opStringS1 cb, string[] value, Ice.Current current) + + public override Task<string[]> + opStringS1Async(string[] value, Ice.Current current) { - cb.ice_response(value); + return Task.FromResult<string[]>(value); } - - public override void opByteBoolD1_async(Test.AMD_MyClass_opByteBoolD1 cb, Dictionary<byte, bool> value, - Ice.Current current) + + public override Task<Dictionary<byte, bool>> + opByteBoolD1Async(Dictionary<byte, bool> value, Ice.Current current) { - cb.ice_response(value); + return Task.FromResult<Dictionary<byte, bool>>(value); } - - public override void opStringS2_async(Test.AMD_MyClass_opStringS2 cb, string[] value, Ice.Current current) + + public override Task<string[]> + opStringS2Async(string[] value, Ice.Current current) { - cb.ice_response(value); + return Task.FromResult<string[]>(value); } - - public override void opByteBoolD2_async(Test.AMD_MyClass_opByteBoolD2 cb, Dictionary<byte, bool> value, - Ice.Current current) + + public override Task<Dictionary<byte, bool>> + opByteBoolD2Async(Dictionary<byte, bool> value, Ice.Current current) { - cb.ice_response(value); + return Task.FromResult<Dictionary<byte, bool>>(value); } - - public override void opMyClass1_async(Test.AMD_MyDerivedClass_opMyClass1 cb, Test.MyClass1 value, - Ice.Current current) + + public override Task<MyClass1> + opMyClass1Async(MyClass1 value, Ice.Current current) { - cb.ice_response(value); + return Task.FromResult<MyClass1>(value); } - - public override void opMyStruct1_async(Test.AMD_MyDerivedClass_opMyStruct1 cb, Test.MyStruct1 value, - Ice.Current current) + + public override Task<MyStruct1> + opMyStruct1Async(MyStruct1 value, Ice.Current current) { - cb.ice_response(value); + return Task.FromResult<MyStruct1>(value); } - - - public override void opStringLiterals_async(Test.AMD_MyClass_opStringLiterals cb, Ice.Current current) + + + public override Task<string[]> + opStringLiteralsAsync(Ice.Current current) { - cb.ice_response(new string[] + return Task.FromResult<string[]>(new string[] { - Test.s0.value, - Test.s1.value, - Test.s2.value, - Test.s3.value, - Test.s4.value, - Test.s5.value, - Test.s6.value, - Test.s7.value, - Test.s8.value, - Test.s9.value, - Test.s10.value, - - Test.sw0.value, - Test.sw1.value, - Test.sw2.value, - Test.sw3.value, - Test.sw4.value, - Test.sw5.value, - Test.sw6.value, - Test.sw7.value, - Test.sw8.value, - Test.sw9.value, - Test.sw10.value, - - Test.ss0.value, - Test.ss1.value, - Test.ss2.value, - Test.ss3.value, - Test.ss4.value, - Test.ss5.value, - - Test.su0.value, - Test.su1.value, - Test.su2.value + s0.value, + s1.value, + s2.value, + s3.value, + s4.value, + s5.value, + s6.value, + s7.value, + s8.value, + s9.value, + s10.value, + + sw0.value, + sw1.value, + sw2.value, + sw3.value, + sw4.value, + sw5.value, + sw6.value, + sw7.value, + sw8.value, + sw9.value, + sw10.value, + + ss0.value, + ss1.value, + ss2.value, + ss3.value, + ss4.value, + ss5.value, + + su0.value, + su1.value, + su2.value }); } - - public override void opWStringLiterals_async(Test.AMD_MyClass_opWStringLiterals cb, Ice.Current current) + + public override Task<string[]> + opWStringLiteralsAsync(Ice.Current current) { - cb.ice_response(new string[] + return Task.FromResult<string[]>(new string[] { - Test.s0.value, - Test.s1.value, - Test.s2.value, - Test.s3.value, - Test.s4.value, - Test.s5.value, - Test.s6.value, - Test.s7.value, - Test.s8.value, - Test.s9.value, - Test.s10.value, - - Test.sw0.value, - Test.sw1.value, - Test.sw2.value, - Test.sw3.value, - Test.sw4.value, - Test.sw5.value, - Test.sw6.value, - Test.sw7.value, - Test.sw8.value, - Test.sw9.value, - Test.sw10.value, - - Test.ss0.value, - Test.ss1.value, - Test.ss2.value, - Test.ss3.value, - Test.ss4.value, - Test.ss5.value, - - Test.su0.value, - Test.su1.value, - Test.su2.value + s0.value, + s1.value, + s2.value, + s3.value, + s4.value, + s5.value, + s6.value, + s7.value, + s8.value, + s9.value, + s10.value, + + sw0.value, + sw1.value, + sw2.value, + sw3.value, + sw4.value, + sw5.value, + sw6.value, + sw7.value, + sw8.value, + sw9.value, + sw10.value, + + ss0.value, + ss1.value, + ss2.value, + ss3.value, + ss4.value, + ss5.value, + + su0.value, + su1.value, + su2.value }); } + public override async Task<Test.MyClass_OpMStruct1MarshaledResult> + opMStruct1Async(Ice.Current current) + { + await Task.Delay(0); + return new Test.MyClass_OpMStruct1MarshaledResult(new Test.Structure(), current); + } + + public override async Task<Test.MyClass_OpMStruct2MarshaledResult> + opMStruct2Async(Test.Structure p1, Ice.Current current) + { + await Task.Delay(0); + return new Test.MyClass_OpMStruct2MarshaledResult(p1, p1, current); + } + + public override async Task<Test.MyClass_OpMSeq1MarshaledResult> + opMSeq1Async(Ice.Current current) + { + await Task.Delay(0); + return new Test.MyClass_OpMSeq1MarshaledResult(new string[0], current); + } + + public override async Task<Test.MyClass_OpMSeq2MarshaledResult> + opMSeq2Async(string[] p1, Ice.Current current) + { + await Task.Delay(0); + return new Test.MyClass_OpMSeq2MarshaledResult(p1, p1, current); + } + + public override async Task<Test.MyClass_OpMDict1MarshaledResult> + opMDict1Async(Ice.Current current) + { + await Task.Delay(0); + return new Test.MyClass_OpMDict1MarshaledResult(new Dictionary<string, string>(), current); + } + + public override async Task<Test.MyClass_OpMDict2MarshaledResult> + opMDict2Async(Dictionary<string, string> p1, Ice.Current current) + { + await Task.Delay(0); + return new Test.MyClass_OpMDict2MarshaledResult(p1, p1, current); + } + private Thread_opVoid _opVoidThread; private int _opByteSOnewayCallCount = 0; } |