diff options
Diffstat (limited to 'csharp/src')
23 files changed, 2434 insertions, 1958 deletions
diff --git a/csharp/src/Glacier2/msbuild/glacier2.csproj b/csharp/src/Glacier2/msbuild/glacier2.csproj index 08baa671e0a..6c7ddcc62c3 100644 --- a/csharp/src/Glacier2/msbuild/glacier2.csproj +++ b/csharp/src/Glacier2/msbuild/glacier2.csproj @@ -4,6 +4,10 @@ <IceBuilderCsharpProps Condition="!Exists('$(IceBuilderCsharpProps)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.props', SearchOption.AllDirectories))</IceBuilderCsharpProps> <IceBuilderCsharpTargets Condition="!Exists('$(IceBuilderCsharpTargets)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.targets', SearchOption.AllDirectories))</IceBuilderCsharpTargets> </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'"> + <DocumentationFile>..\..\..\Assemblies\Glacier2.XML</DocumentationFile> + <NoWarn>1591</NoWarn> + </PropertyGroup> <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> <PropertyGroup> <ProjectGuid>{D765A8A0-01C2-4EEE-B6C0-5DD6F9C1087A}</ProjectGuid> @@ -79,6 +83,7 @@ <PropertyGroup Label="IceBuilder"> <IceBuilderIncludeDirectories>$(IceHome)\slice</IceBuilderIncludeDirectories> <IceBuilderAllowIcePrefix>yes</IceBuilderAllowIcePrefix> + <IceBuilderAdditionalOptions>--compat</IceBuilderAdditionalOptions> </PropertyGroup> <Import Project="$(IceBuilderCsharpTargets)" Condition="Exists('$(IceBuilderCsharpTargets)')" /> </Project>
\ No newline at end of file diff --git a/csharp/src/Ice/AsyncResult.cs b/csharp/src/Ice/AsyncResult.cs index 5fad90abb05..95729efe018 100644 --- a/csharp/src/Ice/AsyncResult.cs +++ b/csharp/src/Ice/AsyncResult.cs @@ -26,8 +26,8 @@ namespace Ice /// /// <summary> - /// Callback for the successful completion of an operation - /// that returns no data. + /// Callback to inform when a call has been passed to the local + /// transport. /// </summary> /// public delegate void SentCallback(bool sentSynchronously); @@ -54,6 +54,7 @@ namespace Ice ObjectPrx getProxy(); bool isCompleted_(); + void waitForCompleted(); bool isSent(); @@ -67,7 +68,6 @@ namespace Ice AsyncResult whenSent(Ice.AsyncCallback cb); AsyncResult whenSent(Ice.SentCallback cb); - AsyncResult whenCompleted(Ice.ExceptionCallback excb); } @@ -82,18 +82,15 @@ namespace Ice namespace IceInternal { - using System.Collections.Generic; using System.Diagnostics; using System.Threading; - public delegate void ProxyTwowayCallback<T>(Ice.AsyncResult result, T cb, Ice.ExceptionCallback excb); - public delegate void ProxyOnewayCallback<T>(T cb); - - public class AsyncResultI : Ice.AsyncResult + abstract public class AsyncResultI : Ice.AsyncResult { public virtual void cancel() { - cancel(new Ice.InvocationCanceledException()); + Debug.Assert(outgoing_ != null); + outgoing_.cancel(); } public Ice.Communicator getCommunicator() @@ -125,7 +122,7 @@ namespace IceInternal { while((state_ & StateDone) == 0) { - System.Threading.Monitor.Wait(this); + Monitor.Wait(this); } } } @@ -142,9 +139,9 @@ namespace IceInternal { lock(this) { - while((state_ & StateSent) == 0 && _exception == null) + while((state_ & StateSent) == 0 && exception_ == null) { - System.Threading.Monitor.Wait(this); + Monitor.Wait(this); } } } @@ -153,22 +150,22 @@ namespace IceInternal { lock(this) { - if(_exception != null) + if(exception_ != null) { - throw _exception; + throw exception_; } } } public bool sentSynchronously() { - return sentSynchronously_; // No lock needed + Debug.Assert(outgoing_ != null); + return outgoing_.sentSynchronously(); // No lock needed } // // Implementation of System.IAsyncResult properties // - public bool IsCompleted { get @@ -181,11 +178,12 @@ namespace IceInternal { get { + Debug.Assert(outgoing_ != null); if(getProxy() != null && getProxy().ice_isTwoway()) { return false; } - return sentSynchronously_; + return outgoing_.sentSynchronously(); } } @@ -203,19 +201,27 @@ namespace IceInternal { lock(this) { - if(_waitHandle == null) + if(waitHandle_ == null) { - _waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); + waitHandle_ = new EventWaitHandle(false, EventResetMode.ManualReset); } if((state_ & StateDone) != 0) { - _waitHandle.Set(); + waitHandle_.Set(); } - return _waitHandle; + return waitHandle_; } } } + public OutgoingAsyncBase OutgoingAsync + { + get + { + return outgoing_; + } + } + public Ice.AsyncResult whenSent(Ice.AsyncCallback cb) { lock(this) @@ -224,22 +230,22 @@ namespace IceInternal { throw new System.ArgumentException("callback is null"); } - if(_sentCallback != null) + if(sentCallback_ != null) { throw new System.ArgumentException("sent callback already set"); } - _sentCallback = cb; + sentCallback_ = cb; if((state_ & StateSent) == 0) { return this; } } - if(sentSynchronously_) + if(outgoing_.sentSynchronously()) { try { - _sentCallback(this); + sentCallback_(this); } catch(System.Exception ex) { @@ -252,7 +258,7 @@ namespace IceInternal { try { - _sentCallback(this); + sentCallback_(this); } catch(System.Exception ex) { @@ -271,21 +277,21 @@ namespace IceInternal { throw new System.ArgumentException("callback is null"); } - if(_sentCallback != null) + if(sentCallback_ != null) { throw new System.ArgumentException("sent callback already set"); } - _sentCallback = (Ice.AsyncResult result) => - { - cb(result.sentSynchronously()); - }; + sentCallback_ = (Ice.AsyncResult r) => + { + cb(r.sentSynchronously()); + }; if((state_ & StateSent) == 0) { return this; } } - if(sentSynchronously_) + if(outgoing_.sentSynchronously()) { try { @@ -313,12 +319,6 @@ namespace IceInternal return this; } - public Ice.AsyncResult whenCompletedWithAsyncCallback(Ice.AsyncCallback cb) - { - setCompletedCallback(cb); - return this; - } - public Ice.AsyncResult whenCompleted(Ice.ExceptionCallback cb) { if(cb == null) @@ -342,103 +342,6 @@ namespace IceInternal return _operation; } - public void invokeSent(Ice.AsyncCallback cb) - { - Debug.Assert(cb != null); - try - { - cb(this); - } - catch(System.Exception ex) - { - warning(ex); - } - - if(observer_ != null) - { - Ice.ObjectPrx proxy = getProxy(); - if(proxy == null || !proxy.ice_isTwoway()) - { - observer_.detach(); - observer_ = null; - } - } - } - - public void invokeSentAsync(Ice.AsyncCallback cb) - { - // - // This is called when it's not safe to call the exception callback synchronously - // from this thread. Instead the exception callback is called asynchronously from - // the client thread pool. - // - Debug.Assert(cb != null); - try - { - instance_.clientThreadPool().dispatch(() => - { - invokeSent(cb); - }, cachedConnection_); - } - catch(Ice.CommunicatorDestroyedException) - { - } - } - - public void invokeCompleted(Ice.AsyncCallback cb) - { - Debug.Assert(cb != null); - try - { - cb(this); - } - catch(System.Exception ex) - { - warning(ex); - } - - if(observer_ != null) - { - observer_.detach(); - observer_ = null; - } - } - - public void invokeCompletedAsync(Ice.AsyncCallback cb) - { - // - // This is called when it's not safe to call the exception callback synchronously - // from this thread. Instead the exception callback is called asynchronously from - // the client thread pool. - // - Debug.Assert(cb != null); - - // CommunicatorDestroyedException is the only exception that can propagate directly. - instance_.clientThreadPool().dispatch(() => - { - invokeCompleted(cb); - }, cachedConnection_); - } - - public virtual void cancelable(CancellationHandler handler) - { - lock(this) - { - if(_cancellationException != null) - { - try - { - throw _cancellationException; - } - finally - { - _cancellationException = null; - } - } - _cancellationHandler = handler; - } - } - public bool wait() { lock(this) @@ -450,121 +353,30 @@ namespace IceInternal state_ |= StateEndCalled; while((state_ & StateDone) == 0) { - System.Threading.Monitor.Wait(this); + Monitor.Wait(this); } - if(_exception != null) + if(exception_ != null) { - throw _exception; + throw exception_; } return (state_ & StateOK) != 0; } } - public virtual void cacheMessageBuffers() - { - } - - protected AsyncResultI(Ice.Communicator communicator, Instance instance, string op, object cookie) + protected AsyncResultI(Ice.Communicator communicator, + Instance instance, + string op, + object cookie, + Ice.AsyncCallback cb) { instance_ = instance; - sentSynchronously_ = false; state_ = 0; _communicator = communicator; _operation = op; - _exception = null; + exception_ = null; _cookie = cookie; - } - - protected Ice.AsyncCallback sent(bool done) - { - lock(this) - { - Debug.Assert(_exception == null); - - bool alreadySent = (state_ & StateSent) != 0; - state_ |= StateSent; - if(done) - { - state_ |= StateDone | StateOK; - _cancellationHandler = null; - if(observer_ != null && _sentCallback == null) - { - observer_.detach(); - observer_ = null; - } - - // - // For oneway requests after the data has been sent - // the buffers can be reused unless this is a - // collocated invocation. For collocated invocations - // the buffer won't be reused because it has already - // been marked as cached in invokeCollocated. - // - cacheMessageBuffers(); - } - if(_waitHandle != null) - { - _waitHandle.Set(); - } - System.Threading.Monitor.PulseAll(this); - return !alreadySent ? _sentCallback : null; - } - } - - protected Ice.AsyncCallback finished(bool ok) - { - lock(this) - { - state_ |= StateDone; - if(ok) - { - state_ |= StateOK; - } - _cancellationHandler = null; - if(_completedCallback == null) - { - if(observer_ != null) - { - observer_.detach(); - observer_ = null; - } - } - if(_waitHandle != null) - { - _waitHandle.Set(); - } - System.Threading.Monitor.PulseAll(this); - return _completedCallback; - } - } - - protected Ice.AsyncCallback finished(Ice.Exception ex) - { - lock(this) - { - state_ |= StateDone; - _exception = ex; - _cancellationHandler = null; - if(observer_ != null) - { - observer_.failed(ex.ice_id()); - } - if(_completedCallback == null) - { - if(observer_ != null) - { - observer_.detach(); - observer_ = null; - } - } - if(_waitHandle != null) - { - _waitHandle.Set(); - } - System.Threading.Monitor.PulseAll(this); - return _completedCallback; - } + completedCallback_ = cb; } protected void setCompletedCallback(Ice.AsyncCallback cb) @@ -575,16 +387,16 @@ namespace IceInternal { throw new System.ArgumentException("callback is null"); } - if(_completedCallback != null) + if(completedCallback_ != null) { throw new System.ArgumentException("callback already set"); } - _completedCallback = cb; + completedCallback_ = cb; if((state_ & StateDone) == 0) { return; } - else if((getProxy() == null || !getProxy().ice_isTwoway()) && _exception == null) + else if((getProxy() == null || !getProxy().ice_isTwoway()) && exception_ == null) { return; } @@ -594,7 +406,14 @@ namespace IceInternal { try { - cb(this); + try + { + cb(this); + } + catch(System.AggregateException ex) + { + throw ex.InnerException; + } } catch(System.Exception ex) { @@ -603,44 +422,21 @@ namespace IceInternal }, cachedConnection_); } - protected virtual Ice.AsyncCallback getCompletedCallback() - { - return (Ice.AsyncResult result) => - { - Debug.Assert(exceptionCallback_ != null); - try - { - ((AsyncResultI)result).wait(); - } - catch(Ice.Exception ex) - { - exceptionCallback_(ex); - return; - } - }; - } + abstract protected Ice.AsyncCallback getCompletedCallback(); - protected void cancel(Ice.LocalException ex) + public static AsyncResultI check(Ice.AsyncResult r, Ice.ObjectPrx prx, string operation) { - CancellationHandler handler; - lock(this) + if(r != null && r.getProxy() != prx) { - _cancellationException = ex; - if(_cancellationHandler == null) - { - return; - } - handler = _cancellationHandler; + throw new System.ArgumentException("Proxy for call to end_" + operation + + " does not match proxy that was used to call corresponding begin_" + + operation + " method"); } - handler.asyncRequestCanceled((OutgoingAsyncBase)this, ex); + return check(r, operation); } - protected virtual Ice.Instrumentation.InvocationObserver getObserver() - { - return observer_; - } - protected static T check<T>(Ice.AsyncResult r, string operation) + public static AsyncResultI check(Ice.AsyncResult r, string operation) { if(r == null) { @@ -651,11 +447,11 @@ namespace IceInternal throw new System.ArgumentException("Incorrect operation for end_" + operation + " method: " + r.getOperation()); } - if(!(r is T)) + if(!(r is AsyncResultI)) { throw new System.ArgumentException("Incorrect AsyncResult object for end_" + operation + " method"); } - return (T)r; + return (AsyncResultI)r; } protected void warning(System.Exception ex) @@ -666,29 +462,25 @@ namespace IceInternal } } - protected IceInternal.Instance instance_; + protected Instance instance_; protected Ice.Instrumentation.InvocationObserver observer_; protected Ice.Connection cachedConnection_; - protected bool sentSynchronously_; private readonly Ice.Communicator _communicator; private readonly string _operation; private readonly object _cookie; - private Ice.Exception _exception; - private EventWaitHandle _waitHandle; - - private CancellationHandler _cancellationHandler; - private Ice.LocalException _cancellationException; + protected Ice.Exception exception_; + protected EventWaitHandle waitHandle_; - private Ice.AsyncCallback _completedCallback; - private Ice.AsyncCallback _sentCallback; + protected Ice.AsyncCallback completedCallback_; + protected Ice.AsyncCallback sentCallback_; protected Ice.ExceptionCallback exceptionCallback_; protected const int StateOK = 0x1; protected const int StateDone = 0x2; protected const int StateSent = 0x4; protected const int StateEndCalled = 0x8; - protected const int StateCachedBuffers = 0x10; protected int state_; + protected OutgoingAsyncBase outgoing_; } } diff --git a/csharp/src/Ice/CollocatedRequestHandler.cs b/csharp/src/Ice/CollocatedRequestHandler.cs index 9e8ce8b777d..d0f793a5914 100644 --- a/csharp/src/Ice/CollocatedRequestHandler.cs +++ b/csharp/src/Ice/CollocatedRequestHandler.cs @@ -42,9 +42,9 @@ namespace IceInternal return previousHandler == this ? newHandler : this; } - public bool sendAsyncRequest(ProxyOutgoingAsyncBase outAsync, out Ice.AsyncCallback sentCallback) + public int sendAsyncRequest(ProxyOutgoingAsyncBase outAsync) { - return outAsync.invokeCollocated(this, out sentCallback); + return outAsync.invokeCollocated(this); } public void asyncRequestCanceled(OutgoingAsyncBase outAsync, Ice.LocalException ex) @@ -59,10 +59,9 @@ namespace IceInternal _asyncRequests.Remove(requestId); } _sendAsyncRequests.Remove(outAsync); - Ice.AsyncCallback cb = outAsync.completed(ex); - if(cb != null) + if(outAsync.exception(ex)) { - outAsync.invokeCompletedAsync(cb); + outAsync.invokeExceptionAsync(); } _adapter.decDirectCount(); // invokeAll won't be called, decrease the direct count. return; @@ -76,10 +75,9 @@ namespace IceInternal if(e.Value == o) { _asyncRequests.Remove(e.Key); - Ice.AsyncCallback cb = outAsync.completed(ex); - if(cb != null) + if(outAsync.exception(ex)) { - outAsync.invokeCompletedAsync(cb); + outAsync.invokeExceptionAsync(); } return; } @@ -90,7 +88,6 @@ namespace IceInternal public void sendResponse(int requestId, Ice.OutputStream os, byte status, bool amd) { - Ice.AsyncCallback cb = null; OutgoingAsyncBase outAsync; lock(this) { @@ -113,21 +110,24 @@ namespace IceInternal if(_asyncRequests.TryGetValue(requestId, out outAsync)) { - _asyncRequests.Remove(requestId); outAsync.getIs().swap(iss); - cb = outAsync.completed(); + if(!outAsync.response()) + { + outAsync = null; + } + _asyncRequests.Remove(requestId); } } - if(cb != null) + if(outAsync != null) { if(amd) { - outAsync.invokeCompletedAsync(cb); + outAsync.invokeResponseAsync(); } else { - outAsync.invokeCompleted(cb); + outAsync.invokeResponse(); } } _adapter.decDirectCount(); @@ -166,8 +166,7 @@ namespace IceInternal return null; } - public bool invokeAsyncRequest(OutgoingAsyncBase outAsync, int batchRequestNum, bool synchronous, - out Ice.AsyncCallback sentCallback) + public int invokeAsyncRequest(OutgoingAsyncBase outAsync, int batchRequestNum, bool synchronous) { // // Increase the direct count to prevent the thread pool from being destroyed before @@ -198,54 +197,37 @@ namespace IceInternal } outAsync.attachCollocatedObserver(_adapter, requestId); - - if(synchronous) + if(!synchronous || !_response || _reference.getInvocationTimeout() > 0) { - // - // Treat this collocated call as if it is a synchronous invocation. - // - if(_reference.getInvocationTimeout() > 0 || !_response) - { - // Don't invoke from the user thread, invocation timeouts wouldn't work otherwise. - _adapter.getThreadPool().dispatch(() => + // Don't invoke from the user thread if async or invocation timeout is set + _adapter.getThreadPool().dispatch( + () => { - if(sentAsync(outAsync)) + if (sentAsync(outAsync)) { invokeAll(outAsync.getOs(), requestId, batchRequestNum); } }, null); - } - else if(_dispatcher) - { - _adapter.getThreadPool().dispatchFromThisThread(() => + } + else if(_dispatcher) + { + _adapter.getThreadPool().dispatchFromThisThread( + () => { - if(sentAsync(outAsync)) + if (sentAsync(outAsync)) { invokeAll(outAsync.getOs(), requestId, batchRequestNum); } }, null); - } - else // Optimization: directly call invokeAll if there's no dispatcher. - { - if(sentAsync(outAsync)) - { - invokeAll(outAsync.getOs(), requestId, batchRequestNum); - } - } - sentCallback = null; } - else + else // Optimization: directly call invokeAll if there's no dispatcher. { - _adapter.getThreadPool().dispatch(() => + if (sentAsync(outAsync)) { - if(sentAsync(outAsync)) - { - invokeAll(outAsync.getOs(), requestId, batchRequestNum); - } - }, null); - sentCallback = null; + invokeAll(outAsync.getOs(), requestId, batchRequestNum); + } } - return false; + return OutgoingAsyncBase.AsyncStatusQueued; } private bool sentAsync(OutgoingAsyncBase outAsync) @@ -256,13 +238,13 @@ namespace IceInternal { return false; // The request timed-out. } - } - Ice.AsyncCallback cb = outAsync.sent(); - if(cb != null) - { - outAsync.invokeSent(cb); + if(!outAsync.sent()) + { + return true; + } } + outAsync.invokeSent(); return true; } @@ -338,25 +320,32 @@ namespace IceInternal } OutgoingAsyncBase outAsync; - Ice.AsyncCallback cb = null; lock(this) { if(_asyncRequests.TryGetValue(requestId, out outAsync)) { + if(!outAsync.exception(ex)) + { + outAsync = null; + } _asyncRequests.Remove(requestId); - cb = outAsync.completed(ex); } } - if(cb != null) + if(outAsync != null) { + // + // If called from an AMD dispatch, invoke asynchronously + // the completion callback since this might be called from + // the user code. + // if(amd) { - outAsync.invokeCompletedAsync(cb); + outAsync.invokeExceptionAsync(); } else { - outAsync.invokeCompleted(cb); + outAsync.invokeException(); } } } diff --git a/csharp/src/Ice/CommunicatorI.cs b/csharp/src/Ice/CommunicatorI.cs index ce4a70aa580..8e968058c16 100644 --- a/csharp/src/Ice/CommunicatorI.cs +++ b/csharp/src/Ice/CommunicatorI.cs @@ -9,10 +9,13 @@ using System; using System.Collections.Generic; +using System.Threading.Tasks; +using System.Threading; + +using IceInternal; namespace Ice { - sealed class CommunicatorI : Communicator { public void destroy() @@ -162,8 +165,16 @@ namespace Ice public void flushBatchRequests() { - AsyncResult r = begin_flushBatchRequests(); - end_flushBatchRequests(r); + flushBatchRequestsAsync().Wait(); + } + + public Task flushBatchRequestsAsync(IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()) + { + var completed = new FlushBatchTaskCompletionCallback(progress, cancel); + var outgoing = new CommunicatorFlushBatchAsync(instance_, completed); + outgoing.invoke(__flushBatchRequests_name); + return completed.Task; } public AsyncResult begin_flushBatchRequests() @@ -173,49 +184,59 @@ namespace Ice private const string __flushBatchRequests_name = "flushBatchRequests"; - public AsyncResult begin_flushBatchRequests(AsyncCallback cb, object cookie) + private class CommunicatorFlushBatchCompletionCallback : AsyncResultCompletionCallback { - IceInternal.OutgoingConnectionFactory connectionFactory = instance_.outgoingConnectionFactory(); - IceInternal.ObjectAdapterFactory adapterFactory = instance_.objectAdapterFactory(); - - // - // This callback object receives the results of all invocations - // of Connection.begin_flushBatchRequests. - // - IceInternal.CommunicatorFlushBatch result = - new IceInternal.CommunicatorFlushBatch(this, instance_, __flushBatchRequests_name, cookie); - - if(cb != null) + public CommunicatorFlushBatchCompletionCallback(Ice.Communicator communicator, + Instance instance, + string op, + object cookie, + Ice.AsyncCallback callback) + : base(communicator, instance, op, cookie, callback) { - result.whenCompletedWithAsyncCallback(cb); } - connectionFactory.flushAsyncBatchRequests(result); - adapterFactory.flushAsyncBatchRequests(result); - - // - // Inform the callback that we have finished initiating all of the - // flush requests. If all of the requests have already completed, - // the callback is invoked now. - // - result.ready(); + protected override Ice.AsyncCallback getCompletedCallback() + { + return (Ice.AsyncResult result) => + { + try + { + result.throwLocalException(); + } + catch(Ice.Exception ex) + { + exceptionCallback_?.Invoke(ex); + } + }; + } + }; + public AsyncResult begin_flushBatchRequests(AsyncCallback cb, object cookie) + { + var result = new CommunicatorFlushBatchCompletionCallback(this, instance_, __flushBatchRequests_name, cookie, cb); + var outgoing = new CommunicatorFlushBatchAsync(instance_, result); + outgoing.invoke(__flushBatchRequests_name); return result; } public void end_flushBatchRequests(AsyncResult result) { - IceInternal.CommunicatorFlushBatch outAsync = - IceInternal.CommunicatorFlushBatch.check(result, this, __flushBatchRequests_name); - outAsync.wait(); + if(result != null && result.getCommunicator() != this) + { + const string msg = "Communicator for call to end_" + __flushBatchRequests_name + + " does not match communicator that was used to call corresponding begin_" + + __flushBatchRequests_name + " method"; + throw new ArgumentException(msg); + } + AsyncResultI.check(result, __flushBatchRequests_name).wait(); } - public Ice.ObjectPrx createAdmin(ObjectAdapter adminAdapter, Identity adminIdentity) + public ObjectPrx createAdmin(ObjectAdapter adminAdapter, Identity adminIdentity) { return instance_.createAdmin(adminAdapter, adminIdentity); } - public Ice.ObjectPrx getAdmin() + public ObjectPrx getAdmin() { return instance_.getAdmin(); } @@ -295,5 +316,4 @@ namespace Ice private IceInternal.Instance instance_; } - } diff --git a/csharp/src/Ice/ConnectRequestHandler.cs b/csharp/src/Ice/ConnectRequestHandler.cs index b8e3363577e..d53aef9513a 100644 --- a/csharp/src/Ice/ConnectRequestHandler.cs +++ b/csharp/src/Ice/ConnectRequestHandler.cs @@ -35,7 +35,7 @@ namespace IceInternal return previousHandler == this ? newHandler : this; } - public bool sendAsyncRequest(ProxyOutgoingAsyncBase outAsync, out Ice.AsyncCallback sentCallback) + public int sendAsyncRequest(ProxyOutgoingAsyncBase outAsync) { lock(this) { @@ -47,11 +47,10 @@ namespace IceInternal if(!initialized()) { _requests.AddLast(outAsync); - sentCallback = null; - return false; + return OutgoingAsyncBase.AsyncStatusQueued; } } - return outAsync.invokeRemote(_connection, _compress, _response, out sentCallback); + return outAsync.invokeRemote(_connection, _compress, _response); } public void asyncRequestCanceled(OutgoingAsyncBase outAsync, Ice.LocalException ex) @@ -71,10 +70,9 @@ namespace IceInternal if(p.Value == outAsync) { _requests.Remove(p); - Ice.AsyncCallback cb = outAsync.completed(ex); - if(cb != null) + if(outAsync.exception(ex)) { - outAsync.invokeCompletedAsync(cb); + outAsync.invokeExceptionAsync(); } return; } @@ -161,14 +159,13 @@ namespace IceInternal foreach(ProxyOutgoingAsyncBase outAsync in _requests) { - Ice.AsyncCallback cb = outAsync.completed(_exception); - if(cb != null) + if(outAsync.exception(_exception)) { - outAsync.invokeCompletedAsync(cb); + outAsync.invokeExceptionAsync(); } } _requests.Clear(); - System.Threading.Monitor.PulseAll(this); + Monitor.PulseAll(this); } } @@ -248,13 +245,9 @@ namespace IceInternal { try { - Ice.AsyncCallback sentCallback = null; - if(outAsync.invokeRemote(_connection, _compress, _response, out sentCallback)) + if((outAsync.invokeRemote(_connection, _compress, _response) & OutgoingAsyncBase.AsyncStatusInvokeSentCallback) != 0) { - if(sentCallback != null) - { - outAsync.invokeSentAsync(sentCallback); - } + outAsync.invokeSentAsync(); } } catch(RetryException ex) @@ -269,10 +262,9 @@ namespace IceInternal catch(Ice.LocalException ex) { exception = ex; - Ice.AsyncCallback cb = outAsync.completed(ex); - if(cb != null) + if(outAsync.exception(ex)) { - outAsync.invokeCompletedAsync(cb); + outAsync.invokeExceptionAsync(); } } } @@ -308,7 +300,7 @@ namespace IceInternal _proxies.Clear(); _proxy = null; // Break cyclic reference count. - System.Threading.Monitor.PulseAll(this); + Monitor.PulseAll(this); } } diff --git a/csharp/src/Ice/ConnectionFactory.cs b/csharp/src/Ice/ConnectionFactory.cs index d68b7e808c1..ef41ce0143a 100644 --- a/csharp/src/Ice/ConnectionFactory.cs +++ b/csharp/src/Ice/ConnectionFactory.cs @@ -256,7 +256,7 @@ namespace IceInternal } } - public void flushAsyncBatchRequests(CommunicatorFlushBatch outAsync) + public void flushAsyncBatchRequests(CommunicatorFlushBatchAsync outAsync) { ICollection<Ice.ConnectionI> c = new List<Ice.ConnectionI>(); @@ -1256,7 +1256,7 @@ namespace IceInternal } } - public void flushAsyncBatchRequests(CommunicatorFlushBatch outAsync) + public void flushAsyncBatchRequests(CommunicatorFlushBatchAsync outAsync) { // // connections() is synchronized, no need to synchronize here. diff --git a/csharp/src/Ice/ConnectionI.cs b/csharp/src/Ice/ConnectionI.cs index ba5668eac74..252909df781 100644 --- a/csharp/src/Ice/ConnectionI.cs +++ b/csharp/src/Ice/ConnectionI.cs @@ -10,15 +10,17 @@ namespace Ice { using System; - using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.Text; using System.Threading; - using Ice.Instrumentation; + using System.Threading.Tasks; + using System.Linq; - public sealed class ConnectionI : - IceInternal.EventHandler, IceInternal.ResponseHandler, IceInternal.CancellationHandler, Connection + using Instrumentation; + using IceInternal; + + public sealed class ConnectionI : IceInternal.EventHandler, ResponseHandler, CancellationHandler, Connection { public interface StartCallback { @@ -26,7 +28,7 @@ namespace Ice void connectionStartFailed(ConnectionI connection, LocalException ex); } - private class TimeoutCallback : IceInternal.TimerTask + private class TimeoutCallback : TimerTask { public TimeoutCallback(ConnectionI connection) { @@ -56,7 +58,7 @@ namespace Ice throw _exception; } - if(!initialize(IceInternal.SocketOperation.None) || !validate(IceInternal.SocketOperation.None)) + if(!initialize(SocketOperation.None) || !validate(SocketOperation.None)) { _startCallback = callback; return; @@ -93,7 +95,7 @@ namespace Ice throw _exception; } - if(!initialize(IceInternal.SocketOperation.None) || !validate(IceInternal.SocketOperation.None)) + if(!initialize(SocketOperation.None) || !validate(SocketOperation.None)) { // // Wait for the connection to be validated. @@ -135,7 +137,7 @@ namespace Ice if(_acmLastActivity > -1) { - _acmLastActivity = IceInternal.Time.currentMonotonicTimeMillis(); + _acmLastActivity = Time.currentMonotonicTimeMillis(); } setState(StateActive); } @@ -315,7 +317,7 @@ namespace Ice } } - public void monitor(long now, IceInternal.ACMConfig acm) + public void monitor(long now, ACMConfig acm) { lock(this) { @@ -347,7 +349,7 @@ namespace Ice } } - if(_readStream.size() > IceInternal.Protocol.headerSize || !_writeStream.isEmpty()) + if(_readStream.size() > Protocol.headerSize || !_writeStream.isEmpty()) { // // If writing or reading, nothing to do, the connection @@ -382,21 +384,21 @@ namespace Ice } } - public bool sendAsyncRequest(IceInternal.OutgoingAsyncBase og, bool compress, bool response, - int batchRequestNum, out Ice.AsyncCallback sentCallback) + public int sendAsyncRequest(OutgoingAsyncBase og, bool compress, bool response, + int batchRequestNum) { OutputStream os = og.getOs(); lock(this) { + // + // If the exception is closed before we even have a chance + // to send our request, we always try to send the request + // again. + // if(_exception != null) { - // - // If the connection is closed before we even have a chance - // to send our request, we always try to send the request - // again. - // - throw new IceInternal.RetryException(_exception); + throw new RetryException(_exception); } Debug.Assert(_state > StateNotValidated); @@ -413,7 +415,6 @@ namespace Ice // This will throw if the request is canceled. // og.cancelable(this); - int requestId = 0; if(response) { @@ -430,25 +431,24 @@ namespace Ice // // Fill in the request ID. // - os.pos(IceInternal.Protocol.headerSize); + os.pos(Protocol.headerSize); os.writeInt(requestId); } else if(batchRequestNum > 0) { - os.pos(IceInternal.Protocol.headerSize); + os.pos(Protocol.headerSize); os.writeInt(batchRequestNum); } og.attachRemoteObserver(initConnectionInfo(), _endpoint, requestId); - bool sent; + int status = OutgoingAsyncBase.AsyncStatusQueued; try { - OutgoingMessage msg = new OutgoingMessage(og, os, compress, requestId); - sent = sendMessage(msg); - sentCallback = msg.sentCallback; + OutgoingMessage message = new OutgoingMessage(og, os, compress, requestId); + status = sendMessage(message); } - catch(LocalException ex) + catch(Ice.LocalException ex) { setState(StateClosed, ex); Debug.Assert(_exception != null); @@ -462,51 +462,88 @@ namespace Ice // _asyncRequests[requestId] = og; } - return sent; + return status; } } - public IceInternal.BatchRequestQueue getBatchRequestQueue() + public BatchRequestQueue getBatchRequestQueue() { return _batchRequestQueue; } public void flushBatchRequests() { - end_flushBatchRequests(begin_flushBatchRequests()); + flushBatchRequestsAsync().Wait(); } - public AsyncResult begin_flushBatchRequests() + private class ConnectionFlushBatchCompletionCallback : AsyncResultCompletionCallback { - return begin_flushBatchRequestsInternal(null, null); + public ConnectionFlushBatchCompletionCallback(Ice.Connection connection, + Ice.Communicator communicator, + Instance instance, + string op, + object cookie, + Ice.AsyncCallback callback) + : base(communicator, instance, op, cookie, callback) + { + _connection = connection; + } + + public override Ice.Connection getConnection() + { + return _connection; + } + + protected override Ice.AsyncCallback getCompletedCallback() + { + return (Ice.AsyncResult result) => + { + try + { + result.throwLocalException(); + } + catch(Ice.Exception ex) + { + exceptionCallback_?.Invoke(ex); + } + }; + } + + private Ice.Connection _connection; } - public AsyncResult begin_flushBatchRequests(AsyncCallback cb, object cookie) + public Task flushBatchRequestsAsync(IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()) { - return begin_flushBatchRequestsInternal(cb, cookie); + var completed = new FlushBatchTaskCompletionCallback(progress, cancel); + var outgoing = new ConnectionFlushBatchAsync(this, _instance, completed); + outgoing.invoke(__flushBatchRequests_name); + return completed.Task; } - public void end_flushBatchRequests(AsyncResult r) + public AsyncResult begin_flushBatchRequests(AsyncCallback cb = null, object cookie = null) { - IceInternal.ConnectionFlushBatch outAsync = - IceInternal.ConnectionFlushBatch.check(r, this, __flushBatchRequests_name); - outAsync.wait(); + var result = new ConnectionFlushBatchCompletionCallback(this, _communicator, _instance, + __flushBatchRequests_name, cookie, cb); + var outgoing = new ConnectionFlushBatchAsync(this, _instance, result); + outgoing.invoke(__flushBatchRequests_name); + return result; } - private const string __flushBatchRequests_name = "flushBatchRequests"; - - private AsyncResult begin_flushBatchRequestsInternal(AsyncCallback cb, object cookie) + public void end_flushBatchRequests(AsyncResult r) { - IceInternal.ConnectionFlushBatch result = - new IceInternal.ConnectionFlushBatch(this, _communicator, _instance, __flushBatchRequests_name, cookie); - if(cb != null) + if(r != null && r.getConnection() != this) { - result.whenCompletedWithAsyncCallback(cb); + const string msg = "Connection for call to end_" + __flushBatchRequests_name + + " does not match connection that was used to call corresponding begin_" + + __flushBatchRequests_name + " method"; + throw new ArgumentException(msg); } - result.invoke(); - return result; + AsyncResultI.check(r, __flushBatchRequests_name).wait(); } + private const string __flushBatchRequests_name = "flushBatchRequests"; + public void setCloseCallback(CloseCallback callback) { lock(this) @@ -595,40 +632,40 @@ namespace Ice return; // The request has already been or will be shortly notified of the failure. } - LinkedListNode<OutgoingMessage> p; - for(p = _sendStreams.First; p != null; p = p.Next) + + OutgoingMessage o = _sendStreams.FirstOrDefault(m => m.outAsync == outAsync); + if(o != null) { - OutgoingMessage o = p.Value; - if(o.outAsync == outAsync) + if(o.requestId > 0) { - if(o.requestId > 0) - { - _asyncRequests.Remove(o.requestId); - } + _asyncRequests.Remove(o.requestId); + } - if(ex is Ice.ConnectionTimeoutException) + if(ex is Ice.ConnectionTimeoutException) + { + setState(StateClosed, ex); + } + else + { + // + // If the request is being sent, don't remove it from the send streams, + // it will be removed once the sending is finished. + // + if(o == _sendStreams.First.Value) { - setState(StateClosed, ex); + o.canceled(); } else { - // - // If the request is being sent, don't remove it from the send streams, - // it will be removed once the sending is finished. - // o.canceled(); - if(o != _sendStreams.First.Value) - { - _sendStreams.Remove(p); - } - Ice.AsyncCallback cb = outAsync.completed(ex); - if(cb != null) - { - outAsync.invokeCompletedAsync(cb); - } + _sendStreams.Remove(o); + } + if(outAsync.exception(ex)) + { + outAsync.invokeExceptionAsync(); } - return; } + return; } if(outAsync is IceInternal.OutgoingAsync) @@ -644,10 +681,9 @@ namespace Ice else { _asyncRequests.Remove(kvp.Key); - Ice.AsyncCallback cb = outAsync.completed(ex); - if(cb != null) + if(outAsync.exception(ex)) { - outAsync.invokeCompletedAsync(cb); + outAsync.invokeExceptionAsync(); } } return; @@ -680,7 +716,7 @@ namespace Ice throw _exception; } - sendMessage(new OutgoingMessage(os, compressFlag != 0, true)); + sendMessage(new OutgoingMessage(os, compressFlag > 0, true)); if(_state == StateClosing && _dispatchCount == 0) { @@ -1226,17 +1262,16 @@ namespace Ice { foreach(OutgoingMessage m in sentCBs) { - if(m.sentCallback != null) + if(m.invokeSent) { - m.outAsync.invokeSent(m.sentCallback); + m.outAsync.invokeSent(); } if(m.receivedReply) { IceInternal.OutgoingAsync outAsync = (IceInternal.OutgoingAsync)m.outAsync; - Ice.AsyncCallback cb = outAsync.completed(); - if(cb != null) + if(outAsync.response()) { - outAsync.invokeCompleted(cb); + outAsync.invokeResponse(); } } } @@ -1249,7 +1284,7 @@ namespace Ice // if(info.outAsync != null) { - info.outAsync.invokeCompleted(info.completedCallback); + info.outAsync.invokeResponse(); ++dispatchedCount; } @@ -1333,7 +1368,7 @@ namespace Ice // unecessary thread creation, especially if this is called on shutdown). // if(_startCallback == null && _sendStreams.Count == 0 && _asyncRequests.Count == 0 && - _closeCallback == null && _heartbeatCallback == null) + _closeCallback == null && _heartbeatCallback == null) { finish(); return; @@ -1415,40 +1450,38 @@ namespace Ice // if(message.isSent || message.receivedReply) { - if(message.sent() && message.sentCallback != null) + if(message.sent() && message.invokeSent) { - message.outAsync.invokeSent(message.sentCallback); + message.outAsync.invokeSent(); } if(message.receivedReply) { IceInternal.OutgoingAsync outAsync = (IceInternal.OutgoingAsync)message.outAsync; - Ice.AsyncCallback cb = outAsync.completed(); - if(cb != null) + if(outAsync.response()) { - outAsync.invokeCompleted(cb); + outAsync.invokeResponse(); } } _sendStreams.RemoveFirst(); } } - foreach(OutgoingMessage m in _sendStreams) + foreach (OutgoingMessage o in _sendStreams) { - m.completed(_exception); - if(m.requestId > 0) // Make sure finished isn't called twice. + o.completed(_exception); + if(o.requestId > 0) // Make sure finished isn't called twice. { - _asyncRequests.Remove(m.requestId); + _asyncRequests.Remove(o.requestId); } } - _sendStreams.Clear(); + _sendStreams.Clear(); // Must be cleared before _requests because of Outgoing* references in OutgoingMessage } foreach(IceInternal.OutgoingAsyncBase o in _asyncRequests.Values) { - Ice.AsyncCallback cb = o.completed(_exception); - if(cb != null) + if(o.exception(_exception)) { - o.invokeCompleted(cb); + o.invokeException(); } } _asyncRequests.Clear(); @@ -1919,7 +1952,8 @@ namespace Ice os.writeByte(_compressionSupported ? (byte)1 : (byte)0); os.writeInt(IceInternal.Protocol.headerSize); // Message size. - if(sendMessage(new OutgoingMessage(os, false, false))) + if((sendMessage(new OutgoingMessage(os, false, false)) & + IceInternal.OutgoingAsyncBase.AsyncStatusSent) != 0) { setState(StateClosingPending); @@ -1951,8 +1985,7 @@ namespace Ice os.writeInt(IceInternal.Protocol.headerSize); // Message size. try { - OutgoingMessage message = new OutgoingMessage(os, false, false); - sendMessage(message); + sendMessage(new OutgoingMessage(os, false, false)); } catch(Ice.LocalException ex) { @@ -2238,7 +2271,7 @@ namespace Ice return IceInternal.SocketOperation.None; } - private bool sendMessage(OutgoingMessage message) + private int sendMessage(OutgoingMessage message) { Debug.Assert(_state < StateClosed); @@ -2246,7 +2279,7 @@ namespace Ice { message.adopt(); _sendStreams.AddLast(message); - return false; + return IceInternal.OutgoingAsyncBase.AsyncStatusQueued; } // @@ -2287,13 +2320,17 @@ namespace Ice observerFinishWrite(message.stream.getBuffer()); } - message.sent(); + int status = IceInternal.OutgoingAsyncBase.AsyncStatusSent; + if(message.sent()) + { + status = status | IceInternal.OutgoingAsyncBase.AsyncStatusInvokeSentCallback; + } if(_acmLastActivity > -1) { _acmLastActivity = IceInternal.Time.currentMonotonicTimeMillis(); } - return true; + return status; } message.adopt(); @@ -2302,7 +2339,7 @@ namespace Ice _sendStreams.AddLast(message); scheduleTimeout(op); _threadPool.register(this, op); - return false; + return IceInternal.OutgoingAsyncBase.AsyncStatusQueued; } private OutputStream doCompress(OutputStream uncompressed, bool compress) @@ -2365,10 +2402,9 @@ namespace Ice public int invokeNum; public int requestId; public byte compress; - public IceInternal.ServantManager servantManager; + public ServantManager servantManager; public ObjectAdapter adapter; - public IceInternal.OutgoingAsyncBase outAsync; - public Ice.AsyncCallback completedCallback; + public OutgoingAsyncBase outAsync; public HeartbeatCallback heartbeatCallback; public int messageDispatchCount; } @@ -2492,16 +2528,15 @@ namespace Ice break; } - case IceInternal.Protocol.replyMsg: + case Protocol.replyMsg: { IceInternal.TraceUtil.traceRecv(info.stream, _logger, _traceLevels); info.requestId = info.stream.readInt(); - IceInternal.OutgoingAsyncBase outAsync = null; - if(_asyncRequests.TryGetValue(info.requestId, out outAsync)) + if(_asyncRequests.TryGetValue(info.requestId, out info.outAsync)) { _asyncRequests.Remove(info.requestId); - outAsync.getIs().swap(info.stream); + info.outAsync.getIs().swap(info.stream); // // If we just received the reply for a request which isn't acknowledge as @@ -2509,20 +2544,19 @@ namespace Ice // will be processed once the write callback is invoked for the message. // OutgoingMessage message = _sendStreams.Count > 0 ? _sendStreams.First.Value : null; - if(message != null && message.outAsync == outAsync) + if(message != null && message.outAsync == info.outAsync) { message.receivedReply = true; } + else if(info.outAsync.response()) + { + ++info.messageDispatchCount; + } else { - info.completedCallback = outAsync.completed(); - if(info.completedCallback != null) - { - info.outAsync = outAsync; - ++info.messageDispatchCount; - } + info.outAsync = null; } - System.Threading.Monitor.PulseAll(this); // Notify threads blocked in close(false) + Monitor.PulseAll(this); // Notify threads blocked in close(false) } break; } @@ -2877,23 +2911,20 @@ namespace Ice this.stream = stream; this.compress = compress; this._adopt = adopt; - this.isSent = false; - this.requestId = 0; } internal OutgoingMessage(IceInternal.OutgoingAsyncBase outAsync, OutputStream stream, bool compress, int requestId) { + this.outAsync = outAsync; this.stream = stream; this.compress = compress; - this.outAsync = outAsync; this.requestId = requestId; - this.isSent = false; } internal void canceled() { - Debug.Assert(outAsync != null); + Debug.Assert(outAsync != null); // Only requests can timeout. outAsync = null; } @@ -2910,34 +2941,36 @@ namespace Ice internal bool sent() { + stream = null; if(outAsync != null) { - sentCallback = outAsync.sent(); + invokeSent = outAsync.sent(); + return invokeSent ||receivedReply; } - return sentCallback != null || receivedReply; + return false; } internal void completed(LocalException ex) { if(outAsync != null) { - Ice.AsyncCallback cb = outAsync.completed(ex); - if(cb != null) + if(outAsync.exception(ex)) { - outAsync.invokeCompleted(cb); + outAsync.invokeException(); } } + stream = null; } - internal OutputStream stream; + internal Ice.OutputStream stream; internal IceInternal.OutgoingAsyncBase outAsync; - internal bool receivedReply; internal bool compress; internal int requestId; internal bool _adopt; internal bool prepared; internal bool isSent; - internal Ice.AsyncCallback sentCallback = null; + internal bool invokeSent; + internal bool receivedReply; } private Communicator _communicator; diff --git a/csharp/src/Ice/ConnectionRequestHandler.cs b/csharp/src/Ice/ConnectionRequestHandler.cs index bdec3ab6806..40e13fe7691 100644 --- a/csharp/src/Ice/ConnectionRequestHandler.cs +++ b/csharp/src/Ice/ConnectionRequestHandler.cs @@ -41,9 +41,9 @@ namespace IceInternal return this; } - public bool sendAsyncRequest(ProxyOutgoingAsyncBase outAsync, out Ice.AsyncCallback sentCallback) + public int sendAsyncRequest(ProxyOutgoingAsyncBase outAsync) { - return outAsync.invokeRemote(_connection, _compress, _response, out sentCallback); + return outAsync.invokeRemote(_connection, _compress, _response); } public void asyncRequestCanceled(OutgoingAsyncBase outAsync, Ice.LocalException ex) diff --git a/csharp/src/Ice/ObjectAdapterFactory.cs b/csharp/src/Ice/ObjectAdapterFactory.cs index 80555d942ba..5fba2d4db52 100644 --- a/csharp/src/Ice/ObjectAdapterFactory.cs +++ b/csharp/src/Ice/ObjectAdapterFactory.cs @@ -212,7 +212,7 @@ namespace IceInternal } } - public void flushAsyncBatchRequests(CommunicatorFlushBatch outAsync) + public void flushAsyncBatchRequests(CommunicatorFlushBatchAsync outAsync) { List<Ice.ObjectAdapterI> adapters; lock(this) diff --git a/csharp/src/Ice/ObjectAdapterI.cs b/csharp/src/Ice/ObjectAdapterI.cs index f6dec965c71..50bdc56ad33 100644 --- a/csharp/src/Ice/ObjectAdapterI.cs +++ b/csharp/src/Ice/ObjectAdapterI.cs @@ -689,7 +689,7 @@ namespace Ice } } - public void flushAsyncBatchRequests(CommunicatorFlushBatch outAsync) + public void flushAsyncBatchRequests(CommunicatorFlushBatchAsync outAsync) { List<IncomingConnectionFactory> f; lock(this) diff --git a/csharp/src/Ice/OutgoingAsync.cs b/csharp/src/Ice/OutgoingAsync.cs index 0f376ede850..d9160e9239a 100644 --- a/csharp/src/Ice/OutgoingAsync.cs +++ b/csharp/src/Ice/OutgoingAsync.cs @@ -7,29 +7,180 @@ // // ********************************************************************** +using System.Collections.Generic; +using System.Diagnostics; +using System.Threading; +using System.Threading.Tasks; + namespace IceInternal { - using System; - using System.Collections.Generic; - using System.Diagnostics; - using System.Threading; + public interface OutgoingAsyncCompletionCallback + { + void init(OutgoingAsyncBase og); + + bool handleSent(bool done, bool alreadySent); + bool handleException(Ice.Exception ex); + bool handleResponse(bool ok, OutgoingAsyncBase og); - public class OutgoingAsyncBase : AsyncResultI + void handleInvokeSent(bool sentSynchronously, OutgoingAsyncBase og); + void handleInvokeException(Ice.Exception ex, OutgoingAsyncBase og); + void handleInvokeResponse(bool ok, OutgoingAsyncBase og); + } + + public abstract class OutgoingAsyncBase { - public virtual Ice.AsyncCallback sent() + public virtual bool sent() + { + return sentImpl(true); + } + + public virtual bool exception(Ice.Exception ex) + { + return exceptionImpl(ex); + } + + public virtual bool response() { - return sent(true); + Debug.Assert(false); // Must be overriden by request that can handle responses + return false; } - public virtual Ice.AsyncCallback completed(Ice.Exception ex) + public void invokeSentAsync() { - return finished(ex); + // + // This is called when it's not safe to call the sent callback + // synchronously from this thread. Instead the exception callback + // is called asynchronously from the client thread pool. + // + try + { + instance_.clientThreadPool().dispatch(this.invokeSent, cachedConnection_); + } + catch(Ice.CommunicatorDestroyedException) + { + } + } + + public void invokeExceptionAsync() + { + // + // CommunicatorDestroyedCompleted is the only exception that can propagate directly + // from this method. + // + instance_.clientThreadPool().dispatch(this.invokeException, cachedConnection_); + } + + public void invokeResponseAsync() + { + // + // CommunicatorDestroyedCompleted is the only exception that can propagate directly + // from this method. + // + instance_.clientThreadPool().dispatch(this.invokeResponse, cachedConnection_); + } + + public void invokeSent() + { + try + { + _completionCallback.handleInvokeSent(sentSynchronously_, this); + } + catch(System.Exception ex) + { + warning(ex); + } + + if(observer_ != null && _doneInSent) + { + observer_.detach(); + observer_ = null; + } + } + public void invokeException() + { + try + { + try + { + throw _ex; + } + catch(Ice.Exception ex) + { + _completionCallback.handleInvokeException(ex, this); + } + } + catch(System.Exception ex) + { + warning(ex); + } + + if(observer_ != null) + { + observer_.detach(); + observer_ = null; + } } - public virtual Ice.AsyncCallback completed() + public void invokeResponse() { - Debug.Assert(false); // Must be implemented by classes that handle responses - return null; + if(_ex != null) + { + invokeException(); + return; + } + + try + { + try + { + _completionCallback.handleInvokeResponse((state_ & StateOK) != 0, this); + } + catch(Ice.Exception ex) + { + if(_completionCallback.handleException(ex)) + { + _completionCallback.handleInvokeException(ex, this); + } + } + catch(System.AggregateException ex) + { + throw ex.InnerException; + } + } + catch(System.Exception ex) + { + warning(ex); + } + + if(observer_ != null) + { + observer_.detach(); + observer_ = null; + } + } + + public virtual void cancelable(IceInternal.CancellationHandler handler) + { + lock(this) + { + if(_cancellationException != null) + { + try + { + throw _cancellationException; + } + catch(Ice.LocalException) + { + _cancellationException = null; + throw; + } + } + _cancellationHandler = handler; + } + } + public void cancel() + { + cancel(new Ice.InvocationCanceledException()); } public void attachRemoteObserver(Ice.ConnectionInfo info, Ice.Endpoint endpt, int requestId) @@ -63,50 +214,192 @@ namespace IceInternal return os_; } - public virtual Ice.InputStream getIs() + public Ice.InputStream getIs() { - return null; // Must be implemented by classes that handle responses + return is_; } - protected OutgoingAsyncBase(Ice.Communicator com, Instance instance, string op, object cookie) : - base(com, instance, op, cookie) + public virtual void cacheMessageBuffers() { - os_ = new Ice.OutputStream(instance, Ice.Util.currentProtocolEncoding); } - protected OutgoingAsyncBase(Ice.Communicator com, Instance instance, string op, object cookie, - Ice.OutputStream os) : - base(com, instance, op, cookie) + public virtual void throwUserException() { - os_ = os; } - protected new Ice.AsyncCallback sent(bool done) + protected OutgoingAsyncBase(Instance instance, OutgoingAsyncCompletionCallback completionCallback, + Ice.OutputStream os = null, Ice.InputStream iss = null) { - if(done) + instance_ = instance; + sentSynchronously_ = false; + _doneInSent = false; + state_ = 0; + os_ = os ?? new Ice.OutputStream(instance, Ice.Util.currentProtocolEncoding); + is_ = iss ?? new Ice.InputStream(instance, Ice.Util.currentProtocolEncoding); + _completionCallback = completionCallback; + if(_completionCallback != null) + { + _completionCallback.init(this); + } + } + + protected virtual bool sentImpl(bool done) + { + lock(this) { + bool alreadySent = (state_ & StateSent) > 0; + state_ |= StateSent; + if(done) + { + _doneInSent = true; + if(childObserver_ != null) + { + childObserver_.detach(); + childObserver_ = null; + } + _cancellationHandler = null; + + // + // For oneway requests after the data has been sent + // the buffers can be reused unless this is a + // collocated invocation. For collocated invocations + // the buffer won't be reused because it has already + // been marked as cached in invokeCollocated. + // + cacheMessageBuffers(); + } + + bool invoke = _completionCallback.handleSent(done, alreadySent); + if(!invoke && _doneInSent && observer_ != null) + { + observer_.detach(); + observer_ = null; + } + return invoke; + } + } + + protected virtual bool exceptionImpl(Ice.Exception ex) + { + lock(this) + { + _ex = ex; if(childObserver_ != null) { + childObserver_.failed(ex.ice_id()); childObserver_.detach(); childObserver_ = null; } + _cancellationHandler = null; + + if(observer_ != null) + { + observer_.failed(ex.ice_id()); + } + bool invoke = _completionCallback.handleException(ex); + if(!invoke && observer_ != null) + { + observer_.detach(); + observer_ = null; + } + return invoke; } - return base.sent(done); } + protected virtual bool responseImpl(bool ok) + { + lock(this) + { + if(ok) + { + state_ |= StateOK; + } + + _cancellationHandler = null; - protected new Ice.AsyncCallback finished(Ice.Exception ex) + bool invoke; + try + { + invoke = _completionCallback.handleResponse(ok, this); + } + catch(Ice.Exception ex) + { + _ex = ex; + invoke = _completionCallback.handleException(ex); + } + if(!invoke && observer_ != null) + { + observer_.detach(); + observer_ = null; + } + return invoke; + } + } + + protected void cancel(Ice.LocalException ex) { - if(childObserver_ != null) + CancellationHandler handler; { - childObserver_.failed(ex.ice_id()); - childObserver_.detach(); - childObserver_ = null; + lock(this) + { + _cancellationException = ex; + if(_cancellationHandler == null) + { + return; + } + handler = _cancellationHandler; + } } - return base.finished(ex); + handler.asyncRequestCanceled(this, ex); } - protected Ice.OutputStream os_; + void warning(System.Exception ex) + { + if(instance_.initializationData().properties.getPropertyAsIntWithDefault("Ice.Warn.AMICallback", 1) > 0) + { + instance_.initializationData().logger.warning("exception raised by AMI callback:\n" + ex); + } + } + + // + // This virtual method is necessary for the communicator flush + // batch requests implementation. + // + virtual protected Ice.Instrumentation.InvocationObserver getObserver() + { + return observer_; + } + + public bool sentSynchronously() + { + return sentSynchronously_; + } + + protected Instance instance_; + protected Ice.Connection cachedConnection_; + protected bool sentSynchronously_; + protected int state_; + + protected Ice.Instrumentation.InvocationObserver observer_; protected Ice.Instrumentation.ChildInvocationObserver childObserver_; + + protected Ice.OutputStream os_; + protected Ice.InputStream is_; + + private bool _doneInSent; + private Ice.Exception _ex; + private Ice.LocalException _cancellationException; + private CancellationHandler _cancellationHandler; + private OutgoingAsyncCompletionCallback _completionCallback; + + protected const int StateOK = 0x1; + protected const int StateDone = 0x2; + protected const int StateSent = 0x4; + protected const int StateEndCalled = 0x8; + protected const int StateCachedBuffers = 0x10; + + public const int AsyncStatusQueued = 0; + public const int AsyncStatusSent = 1; + public const int AsyncStatusInvokeSentCallback = 2; } // @@ -117,21 +410,10 @@ namespace IceInternal // public abstract class ProxyOutgoingAsyncBase : OutgoingAsyncBase, TimerTask { - public static ProxyOutgoingAsyncBase check(Ice.AsyncResult r, Ice.ObjectPrx prx, string operation) - { - return ProxyOutgoingAsyncBase.check<ProxyOutgoingAsyncBase>(r, prx, operation); - } - - public abstract bool invokeRemote(Ice.ConnectionI con, bool compress, bool resp, out Ice.AsyncCallback cb); - - public abstract bool invokeCollocated(CollocatedRequestHandler handler, out Ice.AsyncCallback cb); + public abstract int invokeRemote(Ice.ConnectionI connection, bool compress, bool response); + public abstract int invokeCollocated(CollocatedRequestHandler handler); - public override Ice.ObjectPrx getProxy() - { - return proxy_; - } - - public override Ice.AsyncCallback completed(Ice.Exception exc) + public override bool exception(Ice.Exception exc) { if(childObserver_ != null) { @@ -157,13 +439,26 @@ namespace IceInternal // the retry interval is 0. This method can be called with the // connection locked so we can't just retry here. // - instance_.retryQueue().add(this, handleException(exc)); - return null; + instance_.retryQueue().add(this, proxy_.handleException__(exc, handler_, mode_, _sent, ref _cnt)); + return false; } catch(Ice.Exception ex) { - return finished(ex); // No retries, we're done + return exceptionImpl(ex); // No retries, we're done + } + } + + public override void cancelable(CancellationHandler handler) + { + if(proxy_.reference__().getInvocationTimeout() == -2 && cachedConnection_ != null) + { + int timeout = cachedConnection_.timeout(); + if(timeout > 0) + { + instance_.timer().schedule(this, timeout); + } } + base.cancelable(handler); } public void retryException(Ice.Exception ex) @@ -181,44 +476,28 @@ namespace IceInternal } catch(Ice.Exception exc) { - Ice.AsyncCallback cb = completed(exc); - if(cb != null) + if(exception(exc)) { - invokeCompletedAsync(cb); + invokeExceptionAsync(); } } } - public override void cancelable(CancellationHandler handler) - { - if(proxy_.reference__().getInvocationTimeout() == -2 && cachedConnection_ != null) - { - int timeout = cachedConnection_.timeout(); - if(timeout > 0) - { - instance_.timer().schedule(this, timeout); - } - } - base.cancelable(handler); - } - public void retry() { invokeImpl(false); } - - public virtual void abort(Ice.Exception ex) + public void abort(Ice.Exception ex) { Debug.Assert(childObserver_ == null); - Ice.AsyncCallback cb = finished(ex); - if(cb != null) + if(exceptionImpl(ex)) { - invokeCompletedAsync(cb); + invokeExceptionAsync(); } else if(ex is Ice.CommunicatorDestroyedException) { // - // If it's a communicator destroyed exception, don't swallow + // If it's a communicator destroyed exception, swallow // it but instead notify the user thread. Even if no callback // was provided. // @@ -226,29 +505,11 @@ namespace IceInternal } } - public void runTimerTask() - { - if(proxy_.reference__().getInvocationTimeout() == -2) - { - cancel(new Ice.ConnectionTimeoutException()); - } - else - { - cancel(new Ice.InvocationTimeoutException()); - } - } - - protected ProxyOutgoingAsyncBase(Ice.ObjectPrxHelperBase prx, string op, object cookie) : - base(prx.ice_getCommunicator(), prx.reference__().getInstance(), op, cookie) - { - proxy_ = prx; - mode_ = Ice.OperationMode.Normal; - _cnt = 0; - _sent = false; - } - - protected ProxyOutgoingAsyncBase(Ice.ObjectPrxHelperBase prx, string op, object cookie, Ice.OutputStream os) : - base(prx.ice_getCommunicator(), prx.reference__().getInstance(), op, cookie, os) + protected ProxyOutgoingAsyncBase(Ice.ObjectPrxHelperBase prx, + OutgoingAsyncCompletionCallback completionCallback, + Ice.OutputStream os = null, + Ice.InputStream iss = null) : + base(prx.reference__().getInstance(), completionCallback, os, iss) { proxy_ = prx; mode_ = Ice.OperationMode.Normal; @@ -256,17 +517,6 @@ namespace IceInternal _sent = false; } - protected static T check<T>(Ice.AsyncResult r, Ice.ObjectPrx prx, string operation) - { - if(r != null && r.getProxy() != prx) - { - throw new System.ArgumentException("Proxy for call to end_" + operation + - " does not match proxy that was used to call corresponding begin_" + - operation + " method"); - } - return check<T>(r, operation); - } - protected void invokeImpl(bool userThread) { try @@ -279,12 +529,9 @@ namespace IceInternal instance_.timer().schedule(this, invocationTimeout); } } - else // If not called from the user thread, it's called from the retry queue + else if(observer_ != null) { - if(observer_ != null) - { - observer_.retried(); - } + observer_.retried(); } while(true) @@ -293,22 +540,22 @@ namespace IceInternal { _sent = false; handler_ = proxy_.getRequestHandler__(); - Ice.AsyncCallback sentCallback; - if(handler_.sendAsyncRequest(this, out sentCallback)) + int status = handler_.sendAsyncRequest(this); + if((status & AsyncStatusSent) != 0) { if(userThread) { sentSynchronously_ = true; - if(sentCallback != null) + if((status & AsyncStatusInvokeSentCallback) != 0) { - invokeSent(sentCallback); // Call from the user thread. + invokeSent(); // Call the sent callback from the user thread. } } else { - if(sentCallback != null) + if((status & AsyncStatusInvokeSentCallback) != 0) { - invokeSentAsync(sentCallback); // Call from a client thread pool thread. + invokeSentAsync(); // Call the sent callback from a client thread pool thread. } } } @@ -326,7 +573,7 @@ namespace IceInternal childObserver_.detach(); childObserver_ = null; } - int interval = handleException(ex); + int interval = proxy_.handleException__(ex, handler_, mode_, _sent, ref _cnt); if(interval > 0) { instance_.retryQueue().add(this, interval); @@ -349,15 +596,13 @@ namespace IceInternal { throw; } - Ice.AsyncCallback cb = finished(ex); // No retries, we're done - if(cb != null) + else if(exceptionImpl(ex)) // No retries, we're done { - invokeCompletedAsync(cb); + invokeExceptionAsync(); } } } - - protected new Ice.AsyncCallback sent(bool done) + protected override bool sentImpl(bool done) { _sent = true; if(done) @@ -367,33 +612,39 @@ namespace IceInternal instance_.timer().cancel(this); } } - return base.sent(done); + return base.sentImpl(done); } - - protected new Ice.AsyncCallback finished(Ice.Exception ex) + protected override bool exceptionImpl(Ice.Exception ex) { if(proxy_.reference__().getInvocationTimeout() != -1) { instance_.timer().cancel(this); } - return base.finished(ex); + return base.exceptionImpl(ex); } - protected new Ice.AsyncCallback finished(bool ok) + protected override bool responseImpl(bool ok) { if(proxy_.reference__().getInvocationTimeout() != -1) { instance_.timer().cancel(this); } - return base.finished(ok); + return base.responseImpl(ok); } - protected virtual int handleException(Ice.Exception exc) + public void runTimerTask() { - return proxy_.handleException__(exc, handler_, mode_, _sent, ref _cnt); + if(proxy_.reference__().getInvocationTimeout() == -2) + { + cancel(new Ice.ConnectionTimeoutException()); + } + else + { + cancel(new Ice.InvocationTimeoutException()); + } } - protected Ice.ObjectPrxHelperBase proxy_; + protected readonly Ice.ObjectPrxHelperBase proxy_; protected RequestHandler handler_; protected Ice.OperationMode mode_; @@ -401,41 +652,28 @@ namespace IceInternal private bool _sent; } + // + // Class for handling Slice operation invocations + // public class OutgoingAsync : ProxyOutgoingAsyncBase { - public new static OutgoingAsync check(Ice.AsyncResult r, Ice.ObjectPrx prx, string operation) + public OutgoingAsync(Ice.ObjectPrxHelperBase prx, OutgoingAsyncCompletionCallback completionCallback, + Ice.OutputStream os = null, Ice.InputStream iss = null) : + base(prx, completionCallback, os, iss) { - return ProxyOutgoingAsyncBase.check<OutgoingAsync>(r, prx, operation); + encoding_ = Protocol.getCompatibleEncoding(proxy_.reference__().getEncoding()); + synchronous_ = false; } - public OutgoingAsync(Ice.ObjectPrx prx, string operation, object cookie) : - base((Ice.ObjectPrxHelperBase)prx, operation, cookie) - { - _encoding = Protocol.getCompatibleEncoding(proxy_.reference__().getEncoding()); - _is = null; - } - - public OutgoingAsync(Ice.ObjectPrx prx, string operation, object cookie, Ice.InputStream istr, - Ice.OutputStream ostr) : - base((Ice.ObjectPrxHelperBase)prx, operation, cookie, ostr) - { - _encoding = Protocol.getCompatibleEncoding(proxy_.reference__().getEncoding()); - _is = istr; - } - - public void prepare(string operation, Ice.OperationMode mode, Dictionary<string, string> ctx, - bool explicitCtx, bool synchronous) + public void prepare(string operation, Ice.OperationMode mode, Dictionary<string, string> context, + bool synchronous) { Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(proxy_.reference__().getProtocol())); mode_ = mode; - _synchronous = synchronous; + synchronous_ = synchronous; - if(explicitCtx && ctx == null) - { - ctx = _emptyContext; - } - observer_ = ObserverHelper.get(proxy_, operation, ctx); + observer_ = ObserverHelper.get(proxy_, operation, context); switch(proxy_.reference__().getMode()) { @@ -477,12 +715,12 @@ namespace IceInternal os_.writeByte((byte)mode); - if(ctx != null) + if(context != null) { // // Explicit context // - Ice.ContextHelper.write(os_, ctx); + Ice.ContextHelper.write(os_, context); } else { @@ -502,74 +740,23 @@ namespace IceInternal } } } - - public override Ice.AsyncCallback sent() + public override bool sent() { - return sent(!proxy_.ice_isTwoway()); // done = true if not a two-way proxy (no response expected) - } - - public override bool invokeRemote(Ice.ConnectionI con, bool compress, bool resp, out Ice.AsyncCallback sentCB) - { - cachedConnection_ = con; - return con.sendAsyncRequest(this, compress, resp, 0, out sentCB); - } - - public override bool invokeCollocated(CollocatedRequestHandler handler, out Ice.AsyncCallback sentCB) - { - // The stream cannot be cached if the proxy is not a twoway or there is an invocation timeout set. - if(!proxy_.ice_isTwoway() || proxy_.reference__().getInvocationTimeout() != -1) - { - // Disable caching by marking the streams as cached! - state_ |= StateCachedBuffers; - } - return handler.invokeAsyncRequest(this, 0, _synchronous, out sentCB); + return base.sentImpl(!proxy_.ice_isTwoway()); // done = true if it's not a two-way proxy } - public override void abort(Ice.Exception ex) + public override bool response() { - Reference.Mode mode = proxy_.reference__().getMode(); - if(mode == Reference.Mode.ModeBatchOneway || mode == Reference.Mode.ModeBatchDatagram) - { - proxy_.getBatchRequestQueue__().abortBatchRequest(os_); - } - - base.abort(ex); - } - - public void invoke() - { - Reference.Mode mode = proxy_.reference__().getMode(); - if(mode == Reference.Mode.ModeBatchOneway || mode == Reference.Mode.ModeBatchDatagram) - { - sentSynchronously_ = true; - proxy_.getBatchRequestQueue__().finishBatchRequest(os_, proxy_, getOperation()); - finished(true); - return; // Don't call sent/completed callback for batch AMI requests - } - - // - // NOTE: invokeImpl doesn't throw so this can be called from the - // try block with the catch block calling abort() in case of an - // exception. - // - invokeImpl(true); // userThread = true - } - - override public Ice.AsyncCallback completed() - { - Debug.Assert(_is != null); // _is has been initialized prior to this call - // // NOTE: this method is called from ConnectionI.parseMessage // with the connection locked. Therefore, it must not invoke // any user callbacks. // - Debug.Assert(proxy_.ice_isTwoway()); // Can only be called for twoways. if(childObserver_ != null) { - childObserver_.reply(_is.size() - Protocol.headerSize - 4); + childObserver_.reply(is_.size() - Protocol.headerSize - 4); childObserver_.detach(); childObserver_ = null; } @@ -577,208 +764,229 @@ namespace IceInternal byte replyStatus; try { - replyStatus = _is.readByte(); + replyStatus = is_.readByte(); switch(replyStatus) { - case ReplyStatus.replyOK: - { - break; - } - - case ReplyStatus.replyUserException: - { - if(observer_ != null) + case ReplyStatus.replyOK: { - observer_.userException(); + break; } - break; - } - - case ReplyStatus.replyObjectNotExist: - case ReplyStatus.replyFacetNotExist: - case ReplyStatus.replyOperationNotExist: - { - Ice.Identity id = new Ice.Identity(); - id.read__(_is); - - // - // For compatibility with the old FacetPath. - // - string[] facetPath = _is.readStringSeq(); - string facet; - if(facetPath.Length > 0) + case ReplyStatus.replyUserException: { - if(facetPath.Length > 1) + if(observer_ != null) { - throw new Ice.MarshalException(); + observer_.userException(); } - facet = facetPath[0]; - } - else - { - facet = ""; - } - - string operation = _is.readString(); - - Ice.RequestFailedException ex = null; - switch(replyStatus) - { - case ReplyStatus.replyObjectNotExist: - { - ex = new Ice.ObjectNotExistException(); break; } + case ReplyStatus.replyObjectNotExist: case ReplyStatus.replyFacetNotExist: - { - ex = new Ice.FacetNotExistException(); - break; - } - case ReplyStatus.replyOperationNotExist: { - ex = new Ice.OperationNotExistException(); - break; - } + Ice.Identity ident = new Ice.Identity(); + ident.read__(is_); + + // + // For compatibility with the old FacetPath. + // + string[] facetPath = is_.readStringSeq(); + ; + string facet; + if(facetPath.Length > 0) + { + if(facetPath.Length > 1) + { + throw new Ice.MarshalException(); + } + facet = facetPath[0]; + } + else + { + facet = ""; + } - default: - { - Debug.Assert(false); - break; - } - } + string operation = is_.readString(); - ex.id = id; - ex.facet = facet; - ex.operation = operation; - throw ex; - } + Ice.RequestFailedException ex = null; + switch(replyStatus) + { + case ReplyStatus.replyObjectNotExist: + { + ex = new Ice.ObjectNotExistException(); + break; + } - case ReplyStatus.replyUnknownException: - case ReplyStatus.replyUnknownLocalException: - case ReplyStatus.replyUnknownUserException: - { - string unknown = _is.readString(); + case ReplyStatus.replyFacetNotExist: + { + ex = new Ice.FacetNotExistException(); + break; + } - Ice.UnknownException ex = null; - switch(replyStatus) - { - case ReplyStatus.replyUnknownException: - { - ex = new Ice.UnknownException(); - break; - } + case ReplyStatus.replyOperationNotExist: + { + ex = new Ice.OperationNotExistException(); + break; + } - case ReplyStatus.replyUnknownLocalException: - { - ex = new Ice.UnknownLocalException(); - break; + default: + { + Debug.Assert(false); + break; + } + } + + ex.id = ident; + ex.facet = facet; + ex.operation = operation; + throw ex; } + case ReplyStatus.replyUnknownException: + case ReplyStatus.replyUnknownLocalException: case ReplyStatus.replyUnknownUserException: { - ex = new Ice.UnknownUserException(); - break; + string unknown = is_.readString(); + + Ice.UnknownException ex = null; + switch(replyStatus) + { + case ReplyStatus.replyUnknownException: + { + ex = new Ice.UnknownException(); + break; + } + + case ReplyStatus.replyUnknownLocalException: + { + ex = new Ice.UnknownLocalException(); + break; + } + + case ReplyStatus.replyUnknownUserException: + { + ex = new Ice.UnknownUserException(); + break; + } + + default: + { + Debug.Assert(false); + break; + } + } + + ex.unknown = unknown; + throw ex; } default: { - Debug.Assert(false); - break; - } + throw new Ice.UnknownReplyStatusException(); } - - ex.unknown = unknown; - throw ex; } - default: - { - throw new Ice.UnknownReplyStatusException(); - } - } - - return finished(replyStatus == ReplyStatus.replyOK); + return responseImpl(replyStatus == ReplyStatus.replyOK); } catch(Ice.Exception ex) { - return completed(ex); + return exception(ex); } } - public Ice.OutputStream startWriteParams(Ice.FormatType format) - { - os_.startEncapsulation(_encoding, format); - return os_; - } - - public void endWriteParams() + public override int invokeRemote(Ice.ConnectionI connection, bool compress, bool response) { - os_.endEncapsulation(); + cachedConnection_ = connection; + return connection.sendAsyncRequest(this, compress, response, 0); } - public void writeEmptyParams() + public override int invokeCollocated(CollocatedRequestHandler handler) { - os_.writeEmptyEncapsulation(_encoding); - } - - public void writeParamEncaps(byte[] encaps) - { - if(encaps == null || encaps.Length == 0) - { - os_.writeEmptyEncapsulation(_encoding); - } - else + // The stream cannot be cached if the proxy is not a twoway or there is an invocation timeout set. + if(!proxy_.ice_isTwoway() || proxy_.reference__().getInvocationTimeout() != -1) { - os_.writeEncapsulation(encaps); + // Disable caching by marking the streams as cached! + state_ |= StateCachedBuffers; } + return handler.invokeAsyncRequest(this, 0, synchronous_); } - public Ice.InputStream startReadParams() + public new void abort(Ice.Exception ex) { - _is.startEncapsulation(); - return _is; - } + Reference.Mode mode = proxy_.reference__().getMode(); + if(mode == Reference.Mode.ModeBatchOneway || mode == Reference.Mode.ModeBatchDatagram) + { + // + // If we didn't finish a batch oneway or datagram request, we + // must notify the connection about that we give up ownership + // of the batch stream. + // + proxy_.getBatchRequestQueue__().abortBatchRequest(os_); + } - public void endReadParams() - { - _is.endEncapsulation(); + base.abort(ex); } - public void readEmptyParams() + public void invoke(string operation) { - _is.skipEmptyEncapsulation(); - } + Reference.Mode mode = proxy_.reference__().getMode(); + if(mode == Reference.Mode.ModeBatchOneway || mode == Reference.Mode.ModeBatchDatagram) + { + sentSynchronously_ = true; + proxy_.getBatchRequestQueue__().finishBatchRequest(os_, proxy_, operation); + responseImpl(true); + return; // Don't call sent/completed callback for batch AMI requests + } - public byte[] readParamEncaps() - { - Ice.EncodingVersion encoding; - return _is.readEncapsulation(out encoding); + // + // NOTE: invokeImpl doesn't throw so this can be called from the + // try block with the catch block calling abort() in case of an + // exception. + // + invokeImpl(true); // userThread = true } - override public Ice.InputStream getIs() + public void invoke(string operation, + Ice.OperationMode mode, + Ice.FormatType format, + Dictionary<string, string> context, + bool synchronous, + System.Action<Ice.OutputStream> write) { - // _is can already be initialized if the invocation is retried - if(_is == null) + try + { + prepare(operation, mode, context, synchronous); + if(write != null) + { + os_.startEncapsulation(encoding_, format); + write(os_); + os_.endEncapsulation(); + } + else + { + os_.writeEmptyEncapsulation(encoding_); + } + invoke(operation); + } + catch(Ice.Exception ex) { - _is = new Ice.InputStream(instance_, Ice.Util.currentProtocolEncoding); + abort(ex); } - return _is; } - public void throwUserException() + public override void throwUserException() { try { - _is.startEncapsulation(); - _is.throwException(null); + is_.startEncapsulation(); + is_.throwException(); } - catch(Ice.UserException) + catch(Ice.UserException ex) { - _is.endEncapsulation(); - throw; + is_.endEncapsulation(); + userException_?.Invoke(ex); + throw new Ice.UnknownUserException(ex.ice_id()); } } @@ -795,140 +1003,274 @@ namespace IceInternal state_ |= StateCachedBuffers; } - if(_is != null) + if(is_ != null) { - _is.reset(); + is_.reset(); } os_.reset(); - proxy_.cacheMessageBuffers(_is, os_); + proxy_.cacheMessageBuffers(is_, os_); - _is = null; + is_ = null; os_ = null; } } - private Ice.EncodingVersion _encoding; - private Ice.InputStream _is; - - // - // If true this AMI request is being used for a generated synchronous invocation. - // - private bool _synchronous; - - private static Dictionary<string, string> _emptyContext = new Dictionary<string, string>(); + protected readonly Ice.EncodingVersion encoding_; + protected System.Action<Ice.UserException> userException_; + protected bool synchronous_; } - public class CommunicatorFlushBatch : IceInternal.AsyncResultI + public class OutgoingAsyncT<T> : OutgoingAsync { - public static CommunicatorFlushBatch check(Ice.AsyncResult r, Ice.Communicator com, string operation) + public OutgoingAsyncT(Ice.ObjectPrxHelperBase prx, + OutgoingAsyncCompletionCallback completionCallback, + Ice.OutputStream os = null, + Ice.InputStream iss = null) : + base(prx, completionCallback, os, iss) { - if(r != null && r.getCommunicator() != com) - { - throw new System.ArgumentException("Communicator for call to end_" + operation + - " does not match communicator that was used to call " + - "corresponding begin_" + operation + " method"); - } - return AsyncResultI.check<CommunicatorFlushBatch>(r, operation); } - public CommunicatorFlushBatch(Ice.Communicator communicator, Instance instance, string op, object cookie) : - base(communicator, instance, op, cookie) + public void invoke(string operation, + Ice.OperationMode mode, + Ice.FormatType format, + Dictionary<string, string> context, + bool synchronous, + System.Action<Ice.OutputStream> write = null, + System.Action<Ice.UserException> userException = null, + System.Func<Ice.InputStream, T> read = null) { + read_ = read; + userException_ = userException; + base.invoke(operation, mode, format, context, synchronous, write); + } - observer_ = ObserverHelper.get(instance, op); + public T result__(bool ok) + { + try + { + if(ok) + { + if(read_ == null) + { + if(is_ == null || is_.isEmpty()) + { + // + // If there's no response (oneway, batch-oneway proxies), we just set the promise + // on completion without reading anything from the input stream. This is required for + // batch invocations. + // + } + else + { + is_.skipEmptyEncapsulation(); + } + return default(T); + } + else + { + is_.startEncapsulation(); + T r = read_(is_); + is_.endEncapsulation(); + return r; + } + } + else + { + throwUserException(); + return default(T); // make compiler happy + } + } + finally + { + cacheMessageBuffers(); + } + } - // - // _useCount is initialized to 1 to prevent premature callbacks. - // The caller must invoke ready() after all flush requests have - // been initiated. - // - _useCount = 1; + protected System.Func<Ice.InputStream, T> read_; + } + + // + // Class for handling the proxy's begin_ice_flushBatchRequest request. + // + class ProxyFlushBatchAsync : ProxyOutgoingAsyncBase + { + public ProxyFlushBatchAsync(Ice.ObjectPrxHelperBase prx, OutgoingAsyncCompletionCallback completionCallback) : + base(prx, completionCallback) + { } - public void flushConnection(Ice.ConnectionI con) + public override int invokeRemote(Ice.ConnectionI connection, bool compress, bool response) { - lock(this) + if(_batchRequestNum == 0) { - ++_useCount; + if(sent()) + { + return AsyncStatusSent | AsyncStatusInvokeSentCallback; + } + else + { + return AsyncStatusSent; + } } + cachedConnection_ = connection; + return connection.sendAsyncRequest(this, compress, false, _batchRequestNum); + } - try + public override int invokeCollocated(CollocatedRequestHandler handler) + { + if(_batchRequestNum == 0) { - Ice.AsyncCallback sentCB = null; - FlushBatch flush = new FlushBatch(this); - int batchRequestNum = con.getBatchRequestQueue().swap(flush.getOs()); - if(batchRequestNum == 0) + if(sent()) { - flush.sent(); + return AsyncStatusSent | AsyncStatusInvokeSentCallback; } else { - con.sendAsyncRequest(flush, false, false, batchRequestNum, out sentCB); + return AsyncStatusSent; } - Debug.Assert(sentCB == null); } - catch(Ice.LocalException) + return handler.invokeAsyncRequest(this, _batchRequestNum, false); + } + + public void invoke(string operation) + { + Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(proxy_.reference__().getProtocol())); + observer_ = ObserverHelper.get(proxy_, operation, null); + _batchRequestNum = proxy_.getBatchRequestQueue__().swap(os_); + invokeImpl(true); // userThread = true + } + + private int _batchRequestNum; + } + + // + // Class for handling the proxy's begin_ice_getConnection request. + // + class ProxyGetConnection : ProxyOutgoingAsyncBase + { + public ProxyGetConnection(Ice.ObjectPrxHelperBase prx, OutgoingAsyncCompletionCallback completionCallback) : + base(prx, completionCallback) + { + } + + public override int invokeRemote(Ice.ConnectionI connection, bool compress, bool response) + { + cachedConnection_ = connection; + if(responseImpl(true)) { - doCheck(false); - throw; + invokeResponseAsync(); } + return AsyncStatusSent; } - public void ready() + public override int invokeCollocated(CollocatedRequestHandler handler) { - doCheck(true); + if(responseImpl(true)) + { + invokeResponseAsync(); + } + return AsyncStatusSent; } - private void doCheck(bool userThread) + public void invoke(string operation) { - lock(this) + observer_ = ObserverHelper.get(proxy_, operation, null); + invokeImpl(true); // userThread = true + } + } + + class ConnectionFlushBatchAsync : OutgoingAsyncBase + { + public ConnectionFlushBatchAsync(Ice.ConnectionI connection, + Instance instance, + OutgoingAsyncCompletionCallback completionCallback) : + base(instance, completionCallback) + { + _connection = connection; + } + + public void invoke(string operation) + { + observer_ = ObserverHelper.get(instance_, operation); + try { - Debug.Assert(_useCount > 0); - if(--_useCount > 0) + int status; + int batchRequestNum = _connection.getBatchRequestQueue().swap(os_); + if(batchRequestNum == 0) { - return; + status = AsyncStatusSent; + if(sent()) + { + status = status | AsyncStatusInvokeSentCallback; + } + } + else + { + status = _connection.sendAsyncRequest(this, false, false, batchRequestNum); } - } - Ice.AsyncCallback sentCB = sent(true); - if(userThread) + if((status & AsyncStatusSent) != 0) + { + sentSynchronously_ = true; + if((status & AsyncStatusInvokeSentCallback) != 0) + { + invokeSent(); + } + } + } + catch(RetryException ex) { - sentSynchronously_ = true; - if(sentCB != null) + try + { + throw ex.get(); + } + catch(Ice.LocalException ee) { - invokeSent(sentCB); + if(exception(ee)) + { + invokeExceptionAsync(); + } } } - else + catch(Ice.Exception ex) { - if(sentCB != null) + if(exception(ex)) { - invokeSentAsync(sentCB); + invokeExceptionAsync(); } } } + private readonly Ice.ConnectionI _connection; + }; + + public class CommunicatorFlushBatchAsync : OutgoingAsyncBase + { class FlushBatch : OutgoingAsyncBase { - public FlushBatch(CommunicatorFlushBatch outAsync) : - base(outAsync.getCommunicator(), outAsync.instance_, outAsync.getOperation(), null) + public FlushBatch(CommunicatorFlushBatchAsync outAsync, + Instance instance, + Ice.Instrumentation.InvocationObserver observer) : base(instance, null) { _outAsync = outAsync; + _observer = observer; } - public override Ice.AsyncCallback sent() + public override bool + sent() { if(childObserver_ != null) { childObserver_.detach(); childObserver_ = null; } - _outAsync.doCheck(false); - return null; + _outAsync.check(false); + return false; } - public override Ice.AsyncCallback completed(Ice.Exception ex) + public override bool + exception(Ice.Exception ex) { if(childObserver_ != null) { @@ -936,233 +1278,289 @@ namespace IceInternal childObserver_.detach(); childObserver_ = null; } - _outAsync.doCheck(false); - return null; + _outAsync.check(false); + return false; } - protected override Ice.Instrumentation.InvocationObserver getObserver() + protected override Ice.Instrumentation.InvocationObserver + getObserver() { - return _outAsync.getObserver(); + return _observer; } - private CommunicatorFlushBatch _outAsync; - } - private int _useCount; - } - + private CommunicatorFlushBatchAsync _outAsync; + private Ice.Instrumentation.InvocationObserver _observer; + }; - public class ConnectionFlushBatch : OutgoingAsyncBase - { - public static ConnectionFlushBatch check(Ice.AsyncResult r, Ice.Connection con, string operation) + public CommunicatorFlushBatchAsync(Instance instance, OutgoingAsyncCompletionCallback callback) : + base(instance, callback) { - if(r != null && r.getConnection() != con) - { - throw new System.ArgumentException("Connection for call to end_" + operation + - " does not match connection that was used to call " + - "corresponding begin_" + operation + " method"); - } - return AsyncResultI.check<ConnectionFlushBatch>(r, operation); - } - - public ConnectionFlushBatch(Ice.ConnectionI con, Ice.Communicator communicator, Instance instance, string op, - object cookie) : - base(communicator, instance, op, cookie) - { - _connection = con; + // + // _useCount is initialized to 1 to prevent premature callbacks. + // The caller must invoke ready() after all flush requests have + // been initiated. + // + _useCount = 1; } - public override Ice.Connection getConnection() + public void flushConnection(Ice.ConnectionI con) { - return _connection; - } + lock(this) + { + ++_useCount; + } - public void invoke() - { try { - int batchRequestNum = _connection.getBatchRequestQueue().swap(os_); - - bool isSent = false; - Ice.AsyncCallback sentCB; + var flushBatch = new FlushBatch(this, instance_, _observer); + int batchRequestNum = con.getBatchRequestQueue().swap(flushBatch.getOs()); if(batchRequestNum == 0) { - isSent = true; - sentCB = sent(); + flushBatch.sent(); } else { - isSent = _connection.sendAsyncRequest(this, false, false, batchRequestNum, out sentCB); + con.sendAsyncRequest(flushBatch, false, false, batchRequestNum); } + } + catch(Ice.LocalException) + { + check(false); + throw; + } + } - if(isSent) - { - sentSynchronously_ = true; - if(sentCB != null) - { - invokeSent(sentCB); - } - } + public void invoke(string operation) + { + _observer = ObserverHelper.get(instance_, operation); + if(_observer != null) + { + _observer.attach(); } - catch(RetryException ex) + instance_.outgoingConnectionFactory().flushAsyncBatchRequests(this); + instance_.objectAdapterFactory().flushAsyncBatchRequests(this); + check(true); + } + + public void check(bool userThread) + { + lock(this) { - Ice.AsyncCallback cb = completed(ex.get()); - if(cb != null) + Debug.Assert(_useCount > 0); + if(--_useCount > 0) { - invokeCompletedAsync(cb); + return; } } - catch(Ice.Exception ex) + + if(sentImpl(true)) { - Ice.AsyncCallback cb = completed(ex); - if(cb != null) + if(userThread) { - invokeCompletedAsync(cb); + sentSynchronously_ = true; + invokeSent(); + } + else + { + invokeSentAsync(); } } } - private Ice.ConnectionI _connection; - } + private int _useCount; + private Ice.Instrumentation.InvocationObserver _observer; + }; - public class ProxyFlushBatch : ProxyOutgoingAsyncBase + public abstract class TaskCompletionCallback<T> : TaskCompletionSource<T>, OutgoingAsyncCompletionCallback { - public new static ProxyFlushBatch check(Ice.AsyncResult r, Ice.ObjectPrx prx, string operation) + public TaskCompletionCallback(System.IProgress<bool> progress, CancellationToken cancellationToken) { - return ProxyOutgoingAsyncBase.check<ProxyFlushBatch>(r, prx, operation); + _progress = progress; + _cancellationToken = cancellationToken; } - public ProxyFlushBatch(Ice.ObjectPrxHelperBase prx, string operation, object cookie) : - base(prx, operation, cookie) + public void init(OutgoingAsyncBase outgoing) { - observer_ = ObserverHelper.get(prx, operation); - _batchRequestNum = prx.getBatchRequestQueue__().swap(os_); + if(_cancellationToken.CanBeCanceled) + { + _cancellationToken.Register(outgoing.cancel); + } } - public override bool invokeRemote(Ice.ConnectionI con, bool compress, bool resp, out Ice.AsyncCallback sentCB) + public virtual bool handleSent(bool done, bool alreadySent) { - if(_batchRequestNum == 0) + if(done) { - sentCB = sent(); - return true; + SetResult(default(T)); } - cachedConnection_ = con; - return con.sendAsyncRequest(this, compress, false, _batchRequestNum, out sentCB); + return _progress != null && !alreadySent; // Invoke the sent callback only if not already invoked. } - public override bool invokeCollocated(CollocatedRequestHandler handler, out Ice.AsyncCallback sentCB) + public bool handleException(Ice.Exception ex) { - if(_batchRequestNum == 0) - { - sentCB = sent(); - return true; - } - return handler.invokeAsyncRequest(this, _batchRequestNum, false, out sentCB); + SetException(ex); + return false; } - public void invoke() + public abstract bool handleResponse(bool ok, OutgoingAsyncBase og); + + public void handleInvokeSent(bool sentSynchronously, OutgoingAsyncBase og) { - Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(proxy_.reference__().getProtocol())); - invokeImpl(true); // userThread = true + _progress.Report(sentSynchronously); } - private int _batchRequestNum; + public void handleInvokeException(Ice.Exception ex, OutgoingAsyncBase og) + { + Debug.Assert(false); + } + + public void handleInvokeResponse(bool ok, OutgoingAsyncBase og) + { + Debug.Assert(false); + } + + private readonly CancellationToken _cancellationToken; + private readonly System.IProgress<bool> _progress; } - public class ProxyGetConnection : ProxyOutgoingAsyncBase, Ice.AsyncResult<Ice.Callback_Object_ice_getConnection> + public class OperationTaskCompletionCallback<T> : TaskCompletionCallback<T> { - public new static ProxyGetConnection check(Ice.AsyncResult r, Ice.ObjectPrx prx, string operation) + public OperationTaskCompletionCallback(System.IProgress<bool> progress, CancellationToken cancellationToken) : + base(progress, cancellationToken) { - return ProxyOutgoingAsyncBase.check<ProxyGetConnection>(r, prx, operation); } - public ProxyGetConnection(Ice.ObjectPrxHelperBase prx, string operation, - ProxyTwowayCallback<Ice.Callback_Object_ice_getConnection> cb, object cookie) : - base(prx, operation, cookie) + public override bool handleResponse(bool ok, OutgoingAsyncBase og) { - observer_ = ObserverHelper.get(prx, operation); - _completed = cb; + SetResult(((OutgoingAsyncT<T>)og).result__(ok)); + return false; } + } - public override bool invokeRemote(Ice.ConnectionI con, bool compress, bool resp, out Ice.AsyncCallback sentCB) + public class FlushBatchTaskCompletionCallback : TaskCompletionCallback<object> + { + public FlushBatchTaskCompletionCallback(System.IProgress<bool> progress, CancellationToken cancellationToken) : + base(progress, cancellationToken) { - sentCB = null; - cachedConnection_ = con; - Ice.AsyncCallback cb = finished(true); - if(cb != null) - { - invokeCompletedAsync(cb); - } - return true; } - public override bool invokeCollocated(CollocatedRequestHandler handler, out Ice.AsyncCallback sentCB) + public override bool handleResponse(bool ok, OutgoingAsyncBase og) { - sentCB = null; - Ice.AsyncCallback cb = finished(true); - if(cb != null) - { - invokeCompletedAsync(cb); - } - return true; + SetResult(null); + return false; } + } - public void invoke() + abstract public class AsyncResultCompletionCallback : AsyncResultI, OutgoingAsyncCompletionCallback + { + public AsyncResultCompletionCallback(Ice.Communicator com, Instance instance, string op, object cookie, + Ice.AsyncCallback cb) : + base(com, instance, op, cookie, cb) { - invokeImpl(true); // userThread = true } - new public Ice.AsyncResult<Ice.Callback_Object_ice_getConnection> whenCompleted(Ice.ExceptionCallback excb) + public void init(OutgoingAsyncBase outgoing) { - base.whenCompleted(excb); - return this; + outgoing_ = outgoing; } - virtual public Ice.AsyncResult<Ice.Callback_Object_ice_getConnection> - whenCompleted(Ice.Callback_Object_ice_getConnection cb, Ice.ExceptionCallback excb) + public bool handleSent(bool done, bool alreadySent) { - if(cb == null && excb == null) + lock(this) { - throw new System.ArgumentException("callback is null"); + state_ |= StateSent; + if(done) + { + state_ |= StateDone | StateOK; + } + if(waitHandle_ != null) + { + waitHandle_.Set(); + } + Monitor.PulseAll(this); + + // + // Invoke the sent callback only if not already invoked. + // + return !alreadySent && sentCallback_ != null; } + } + + public bool handleException(Ice.Exception ex) + { lock(this) { - if(_responseCallback != null || exceptionCallback_ != null) + state_ |= StateDone; + exception_ = ex; + if(waitHandle_ != null) { - throw new System.ArgumentException("callback already set"); + waitHandle_.Set(); } - _responseCallback = cb; - exceptionCallback_ = excb; + Monitor.PulseAll(this); + return completedCallback_ != null; } - setCompletedCallback(getCompletedCallback()); - return this; } - new public Ice.AsyncResult<Ice.Callback_Object_ice_getConnection> whenSent(Ice.SentCallback cb) + public bool handleResponse(bool ok, OutgoingAsyncBase og) { - base.whenSent(cb); - return this; + lock(this) + { + state_ |= StateDone; + if(ok) + { + state_ |= StateOK; + } + if(waitHandle_ != null) + { + waitHandle_.Set(); + } + Monitor.PulseAll(this); + return completedCallback_ != null; + } } - protected override Ice.AsyncCallback getCompletedCallback() + public void handleInvokeSent(bool sentSynchronously, OutgoingAsyncBase og) { - return (Ice.AsyncResult result) => { _completed(this, _responseCallback, exceptionCallback_); }; + sentCallback_(this); } - private ProxyTwowayCallback<Ice.Callback_Object_ice_getConnection> _completed; - private Ice.Callback_Object_ice_getConnection _responseCallback = null; + public void handleInvokeException(Ice.Exception ex, OutgoingAsyncBase og) + { + try + { + completedCallback_(this); + } + catch(Ice.Exception e) + { + throw new System.AggregateException(e); + } + } + + public void handleInvokeResponse(bool ok, OutgoingAsyncBase og) + { + try + { + completedCallback_(this); + } + catch(Ice.Exception e) + { + throw new System.AggregateException(e); + } + } } - public abstract class OutgoingAsync<T> : OutgoingAsync, Ice.AsyncResult<T> + abstract public class ProxyAsyncResultCompletionCallback<T> : AsyncResultCompletionCallback, Ice.AsyncResult<T> { - public OutgoingAsync(Ice.ObjectPrxHelperBase prx, string operation, object cookie) : - base(prx, operation, cookie) + public ProxyAsyncResultCompletionCallback(Ice.ObjectPrxHelperBase proxy, string operation, object cookie, + Ice.AsyncCallback cb) : + base(proxy.ice_getCommunicator(), proxy.reference__().getInstance(), operation, cookie, cb) { + _proxy = proxy; } - public OutgoingAsync(Ice.ObjectPrxHelperBase prx, string operation, object cookie, Ice.InputStream iss, - Ice.OutputStream os) : - base(prx, operation, cookie, iss, os) + public override Ice.ObjectPrx getProxy() { + return _proxy; } new public Ice.AsyncResult<T> whenCompleted(Ice.ExceptionCallback excb) @@ -1197,73 +1595,45 @@ namespace IceInternal } protected T responseCallback_; + private Ice.ObjectPrx _proxy; } - public class TwowayOutgoingAsync<T> : OutgoingAsync<T> - { - public TwowayOutgoingAsync(Ice.ObjectPrxHelperBase prx, string operation, ProxyTwowayCallback<T> cb, - object cookie) : - base(prx, operation, cookie) - { - Debug.Assert(cb != null); - _completed = cb; - } - - public TwowayOutgoingAsync(Ice.ObjectPrxHelperBase prx, string operation, ProxyTwowayCallback<T> cb, - object cookie, Ice.InputStream iss, Ice.OutputStream os) : - base(prx, operation, cookie, iss, os) - { - Debug.Assert(cb != null); - _completed = cb; - } - - override protected Ice.AsyncCallback getCompletedCallback() - { - return (Ice.AsyncResult result) => { _completed(this, responseCallback_, exceptionCallback_); }; - } - - private ProxyTwowayCallback<T> _completed; - } - - public class OnewayOutgoingAsync<T> : OutgoingAsync<T> + public class OperationAsyncResultCompletionCallback<T, R> : ProxyAsyncResultCompletionCallback<T> { - public OnewayOutgoingAsync(Ice.ObjectPrxHelperBase prx, string operation, ProxyOnewayCallback<T> cb, - object cookie) : - base(prx, operation, cookie) + public OperationAsyncResultCompletionCallback(System.Action<T, R> completed, + Ice.ObjectPrxHelperBase proxy, + string operation, + object cookie, + Ice.AsyncCallback callback) : + base(proxy, operation, cookie, callback) { - Debug.Assert(cb != null); - _completed = cb; - } - - public OnewayOutgoingAsync(Ice.ObjectPrxHelperBase prx, string operation, ProxyOnewayCallback<T> cb, - object cookie, Ice.InputStream iss, Ice.OutputStream os) : - base(prx, operation, cookie, iss, os) - { - Debug.Assert(cb != null); - _completed = cb; + _completed = completed; } override protected Ice.AsyncCallback getCompletedCallback() { - return (Ice.AsyncResult result) => + return (Ice.AsyncResult r) => { + Debug.Assert(r == this); try { - IceInternal.OutgoingAsync outAsync__ = (IceInternal.OutgoingAsync)result; - ((Ice.ObjectPrxHelperBase)(outAsync__.getProxy())).end__(outAsync__, outAsync__.getOperation()); - } - catch(Ice.Exception ex__) - { - if(exceptionCallback_ != null) + R result = ((OutgoingAsyncT<R>)outgoing_).result__(wait()); + try { - exceptionCallback_(ex__); + _completed(responseCallback_, result); } - return; + catch(Ice.Exception ex) + { + throw new System.AggregateException(ex); + } + } + catch(Ice.Exception ex) + { + exceptionCallback_?.Invoke(ex); } - _completed(responseCallback_); }; } - private ProxyOnewayCallback<T> _completed; + private System.Action<T, R> _completed; } } diff --git a/csharp/src/Ice/Proxy.cs b/csharp/src/Ice/Proxy.cs index c912662cbdc..e79d6bdfe62 100644 --- a/csharp/src/Ice/Proxy.cs +++ b/csharp/src/Ice/Proxy.cs @@ -10,7 +10,11 @@ using System; using System.Collections.Generic; using System.Diagnostics; +using System.Threading; +using System.Threading.Tasks; + using IceUtilInternal; +using IceInternal; namespace Ice { @@ -52,6 +56,43 @@ namespace Ice public delegate void Callback_Object_ice_getConnection(Connection ret__); /// <summary> + /// Value type to allow differenciate between a context that is explicity set to + /// empty (empty or null dictionary) and a context that has non been set. + /// </summary> + public struct OptionalContext + { + private OptionalContext(Dictionary<string, string> ctx) + { + _ctx = ctx == null ? _emptyContext : ctx; + } + + /// <summary> + /// Implicit conversion between Dictionary<string, string> and + /// OptionalContext. + /// </summary> + /// <param name="ctx">Dictionary to convert.</param> + /// <returns>OptionalContext value representing the dictionary</returns> + public static implicit operator OptionalContext(Dictionary<string, string> ctx) + { + return new OptionalContext(ctx); + } + + /// <summary> + /// Implicit conversion between OptionalContext and + /// Dictionary<string, string> + /// </summary> + /// <param name="value">OptionalContext value to convert</param> + /// <returns>The Dictionary object.</returns> + public static implicit operator Dictionary<string, string>(OptionalContext value) + { + return value._ctx; + } + + private Dictionary<string, string> _ctx; + static private Dictionary<string, string> _emptyContext = new Dictionary<string, string>(); + } + + /// <summary> /// Base interface of all object proxies. /// </summary> public interface ObjectPrx @@ -65,225 +106,204 @@ namespace Ice /// <summary> /// Tests whether this object supports a specific Slice interface. /// </summary> - /// <param name="id__">The type ID of the Slice interface to test against.</param> - /// <returns>True if the target object has the interface specified by id__ or derives - /// from the interface specified by id__.</returns> - bool ice_isA(string id__); - - /// <summary> - /// Tests whether this object supports a specific Slice interface. - /// </summary> - /// <param name="id__">The type ID of the Slice interface to test against.</param> - /// <param name="context__">The context dictionary for the invocation.</param> - /// <returns>True if the target object has the interface specified by id__ or derives - /// from the interface specified by id__.</returns> - bool ice_isA(string id__, Dictionary<string, string> context__); + /// <param name="id">The type ID of the Slice interface to test against.</param> + /// <param name="context">The context dictionary for the invocation.</param> + /// <returns>True if the target object has the interface specified by id or derives + /// from the interface specified by id.</returns> + bool ice_isA(string id, OptionalContext context = new OptionalContext()); /// <summary> /// Tests whether this object supports a specific Slice interface. /// </summary> /// <param name="id">The type ID of the Slice interface to test against.</param> - /// <returns>An asynchronous result object.</returns> - AsyncResult<Callback_Object_ice_isA> begin_ice_isA(string id); - + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="progress">Sent progress provider.</param> + /// <param name="cancel">A cancellation token that receives the cancellation requests.</param> + /// <returns>The task object representing the asynchronous operation.</returns> + Task<bool> ice_isAAsync(string id, + OptionalContext context = new OptionalContext(), + IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()); /// <summary> /// Tests whether this object supports a specific Slice interface. /// </summary> /// <param name="id">The type ID of the Slice interface to test against.</param> - /// <param name="context__">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult<Callback_Object_ice_isA> begin_ice_isA(string id, Dictionary<string, string> context__); + AsyncResult begin_ice_isA(string id, AsyncCallback callback, object cookie); /// <summary> /// Tests whether this object supports a specific Slice interface. /// </summary> /// <param name="id">The type ID of the Slice interface to test against.</param> - /// <param name="cb__">A callback to be invoked when the invocation completes.</param> - /// <param name="cookie__">Application-specific data to be stored in the result.</param> + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult begin_ice_isA(string id, AsyncCallback cb__, object cookie__); + AsyncResult begin_ice_isA(string id, OptionalContext context, AsyncCallback callback, object cookie); /// <summary> /// Tests whether this object supports a specific Slice interface. /// </summary> /// <param name="id">The type ID of the Slice interface to test against.</param> - /// <param name="context__">The context dictionary for the invocation.</param> - /// <param name="cb__">A callback to be invoked when the invocation completes.</param> - /// <param name="cookie__">Application-specific data to be stored in the result.</param> + /// <param name="context">The context dictionary for the invocation.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult begin_ice_isA(string id, Dictionary<string, string> context__, AsyncCallback cb__, object cookie__); + AsyncResult<Callback_Object_ice_isA> begin_ice_isA(string id, OptionalContext context = new OptionalContext()); /// <summary> /// Tests whether this object supports a specific Slice interface. /// </summary> - /// <param name="r__">The asynchronous result object returned by <code>begin_ice_isA</code>.</param> + /// <param name="result">The asynchronous result object returned by <code>begin_ice_isA</code>.</param> /// <returns>True if the object supports the Slice interface, false otherwise.</returns> - bool end_ice_isA(AsyncResult r__); - - /// <summary> - /// Tests whether the target object of this proxy can be reached. - /// </summary> - void ice_ping(); + bool end_ice_isA(AsyncResult result); /// <summary> /// Tests whether the target object of this proxy can be reached. /// </summary> - /// <param name="context__">The context dictionary for the invocation.</param> - void ice_ping(Dictionary<string, string> context__); + /// <param name="context">The context dictionary for the invocation.</param> + void ice_ping(OptionalContext context = new OptionalContext()); /// <summary> /// Tests whether the target object of this proxy can be reached. /// </summary> - /// <returns>An asynchronous result object.</returns> - AsyncResult<Callback_Object_ice_ping> begin_ice_ping(); + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="progress">Sent progress provider.</param> + /// <param name="cancel">A cancellation token that receives the cancellation requests.</param> + /// <returns>The task object representing the asynchronous operation.</returns> + Task ice_pingAsync(OptionalContext context = new OptionalContext(), + IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()); /// <summary> /// Tests whether the target object of this proxy can be reached. /// </summary> - /// <param name="context__">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult<Callback_Object_ice_ping> begin_ice_ping(Dictionary<string, string> context__); + AsyncResult begin_ice_ping(AsyncCallback callback, object cookie); /// <summary> /// Tests whether the target object of this proxy can be reached. /// </summary> - /// <param name="cb__">A callback to be invoked when the invocation completes.</param> - /// <param name="cookie__">Application-specific data to be stored in the result.</param> + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult begin_ice_ping(AsyncCallback cb__, object cookie__); + AsyncResult begin_ice_ping(OptionalContext context, AsyncCallback callback, object cookie); /// <summary> /// Tests whether the target object of this proxy can be reached. /// </summary> - /// <param name="context__">The context dictionary for the invocation.</param> - /// <param name="cb__">A callback to be invoked when the invocation completes.</param> - /// <param name="cookie__">Application-specific data to be stored in the result.</param> + /// <param name="context">The context dictionary for the invocation.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult begin_ice_ping(Dictionary<string, string> context__, AsyncCallback cb__, object cookie__); + AsyncResult<Callback_Object_ice_ping> begin_ice_ping(OptionalContext context = new OptionalContext()); /// <summary> /// Tests whether the target object of this proxy can be reached. /// </summary> - /// <param name="r__">The asynchronous result object returned by <code>begin_ice_ping</code>.</param> - void end_ice_ping(AsyncResult r__); - - /// <summary> - /// Returns the Slice type IDs of the interfaces supported by the target object of this proxy. - /// </summary> - /// <returns>The Slice type IDs of the interfaces supported by the target object, in base-to-derived - /// order. The first element of the returned array is always ::Ice::Object.</returns> - string[] ice_ids(); + /// <param name="result">The asynchronous result object returned by <code>begin_ice_ping</code>.</param> + void end_ice_ping(AsyncResult result); /// <summary> /// Returns the Slice type IDs of the interfaces supported by the target object of this proxy. /// </summary> - /// <param name="context__">The context dictionary for the invocation.</param> + /// <param name="context">The context dictionary for the invocation.</param> /// <returns>The Slice type IDs of the interfaces supported by the target object, in base-to-derived /// order. The first element of the returned array is always ::Ice::Object.</returns> - string[] ice_ids(Dictionary<string, string> context__); + string[] ice_ids(OptionalContext context = new OptionalContext()); /// <summary> /// Returns the Slice type IDs of the interfaces supported by the target object of this proxy. /// </summary> - /// <returns>An asynchronous result object.</returns> - AsyncResult<Callback_Object_ice_ids> begin_ice_ids(); + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="progress">Sent progress provider.</param> + /// <param name="cancel">A cancellation token that receives the cancellation requests.</param> + /// <returns>The task object representing the asynchronous operation.</returns> + Task<string[]> ice_idsAsync(OptionalContext context = new OptionalContext(), + IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()); /// <summary> /// Returns the Slice type IDs of the interfaces supported by the target object of this proxy. /// </summary> - /// <param name="context__">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult<Callback_Object_ice_ids> begin_ice_ids(Dictionary<string, string> context__); + AsyncResult begin_ice_ids(AsyncCallback callback, object cookie); /// <summary> /// Returns the Slice type IDs of the interfaces supported by the target object of this proxy. /// </summary> - /// <param name="cb__">A callback to be invoked when the invocation completes.</param> - /// <param name="cookie__">Application-specific data to be stored in the result.</param> + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult begin_ice_ids(AsyncCallback cb__, object cookie__); + AsyncResult begin_ice_ids(OptionalContext context, AsyncCallback callback, object cookie); /// <summary> /// Returns the Slice type IDs of the interfaces supported by the target object of this proxy. /// </summary> - /// <param name="context__">The context dictionary for the invocation.</param> - /// <param name="cb__">A callback to be invoked when the invocation completes.</param> - /// <param name="cookie__">Application-specific data to be stored in the result.</param> + /// <param name="context">The context dictionary for the invocation.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult begin_ice_ids(Dictionary<string, string> context__, AsyncCallback cb__, object cookie__); + AsyncResult<Callback_Object_ice_ids> begin_ice_ids(OptionalContext context = new OptionalContext()); /// <summary> /// Returns the Slice type IDs of the interfaces supported by the target object of this proxy. /// </summary> - /// <param name="r__">The asynchronous result object returned by <code>begin_ice_ids</code>.</param> + /// <param name="result">The asynchronous result object returned by <code>begin_ice_ids</code>.</param> /// <returns>The Slice type IDs of the interfaces supported by the target object, in base-to-derived /// order. The first element of the returned array is always ::Ice::Object.</returns> - string[] end_ice_ids(AsyncResult r__); + string[] end_ice_ids(AsyncResult result); /// <summary> /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. /// </summary> + /// <param name="context">The context dictionary for the invocation.</param> /// <returns>The Slice type ID of the most-derived interface.</returns> - string ice_id(); - - /// <summary> - /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. - /// </summary> - /// <param name="context__">The context dictionary for the invocation.</param> - /// <returns>The Slice type ID of the most-derived interface.</returns> - string ice_id(Dictionary<string, string> context__); + string ice_id(OptionalContext context = new OptionalContext()); /// <summary> /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. /// </summary> - /// <returns>An asynchronous result object.</returns> - AsyncResult<Callback_Object_ice_id> begin_ice_id(); + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="progress">Sent progress provider.</param> + /// <param name="cancel">A cancellation token that receives the cancellation requests.</param> + /// <returns>The task object representing the asynchronous operation.</returns> + Task<string> ice_idAsync(OptionalContext context = new OptionalContext(), + IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()); /// <summary> /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. /// </summary> - /// <param name="context__">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult<Callback_Object_ice_id> begin_ice_id(Dictionary<string, string> context__); + AsyncResult begin_ice_id(AsyncCallback callback, object cookie); /// <summary> /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. /// </summary> - /// <param name="cb__">A callback to be invoked when the invocation completes.</param> - /// <param name="cookie__">Application-specific data to be stored in the result.</param> + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult begin_ice_id(AsyncCallback cb__, object cookie__); + AsyncResult begin_ice_id(OptionalContext context, AsyncCallback callback, object cookie); /// <summary> /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. /// </summary> - /// <param name="context__">The context dictionary for the invocation.</param> - /// <param name="cb__">A callback to be invoked when the invocation completes.</param> - /// <param name="cookie__">Application-specific data to be stored in the result.</param> + /// <param name="context">The context dictionary for the invocation.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult begin_ice_id(Dictionary<string, string> context__, AsyncCallback cb__, object cookie__); + AsyncResult<Callback_Object_ice_id> begin_ice_id(OptionalContext context = new OptionalContext()); /// <summary> /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. /// </summary> - /// <param name="r__">The asynchronous result object returned by <code>begin_ice_id</code>.</param> + /// <param name="result">The asynchronous result object returned by <code>begin_ice_id</code>.</param> /// <returns>The Slice type ID of the most-derived interface.</returns> - string end_ice_id(AsyncResult r__); - - /// <summary> - /// Invokes an operation dynamically. - /// </summary> - /// <param name="operation">The name of the operation to invoke.</param> - /// <param name="mode">The operation mode (normal or idempotent).</param> - /// <param name="inEncaps">The encoded in-parameters for the operation.</param> - /// <param name="outEncaps">The encoded out-paramaters and return value - /// for the operation. The return value follows any out-parameters.</param> - /// <returns>If the operation completed successfully, the return value - /// is true. If the operation raises a user exception, - /// the return value is false; in this case, outEncaps - /// contains the encoded user exception. If the operation raises a run-time exception, - /// it throws it directly.</returns> - bool ice_invoke(string operation, OperationMode mode, byte[] inEncaps, out byte[] outEncaps); + string end_ice_id(AsyncResult result); /// <summary> /// Invokes an operation dynamically. @@ -293,14 +313,14 @@ namespace Ice /// <param name="inEncaps">The encoded in-parameters for the operation.</param> /// <param name="outEncaps">The encoded out-paramaters and return value /// for the operation. The return value follows any out-parameters.</param> - /// <param name="context__">The context dictionary for the invocation.</param> + /// <param name="context">The context dictionary for the invocation.</param> /// <returns>If the operation completed successfully, the return value /// is true. If the operation raises a user exception, /// the return value is false; in this case, outEncaps /// contains the encoded user exception. If the operation raises a run-time exception, /// it throws it directly.</returns> bool ice_invoke(string operation, OperationMode mode, byte[] inEncaps, out byte[] outEncaps, - Dictionary<string, string> context__); + OptionalContext context = new OptionalContext()); /// <summary> /// Invokes an operation dynamically. @@ -308,9 +328,17 @@ namespace Ice /// <param name="operation">The name of the operation to invoke.</param> /// <param name="mode">The operation mode (normal or idempotent).</param> /// <param name="inEncaps">The encoded in-parameters for the operation.</param> - /// <returns>An asynchronous result object.</returns> - AsyncResult<Callback_Object_ice_invoke> begin_ice_invoke(string operation, OperationMode mode, - byte[] inEncaps); + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="progress">Sent progress provider.</param> + /// <param name="cancel">A cancellation token that receives the cancellation requests.</param> + /// <returns>The task object representing the asynchronous operation.</returns> + Task<Object_Ice_invokeResult> + ice_invokeAsync(string operation, + OperationMode mode, + byte[] inEncaps, + OptionalContext context = new OptionalContext(), + IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()); /// <summary> /// Invokes an operation dynamically. @@ -318,11 +346,14 @@ namespace Ice /// <param name="operation">The name of the operation to invoke.</param> /// <param name="mode">The operation mode (normal or idempotent).</param> /// <param name="inEncaps">The encoded in-parameters for the operation.</param> - /// <param name="context__">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult<Callback_Object_ice_invoke> begin_ice_invoke(string operation, OperationMode mode, - byte[] inEncaps, - Dictionary<string, string> context__); + AsyncResult begin_ice_invoke(string operation, + OperationMode mode, + byte[] inEncaps, + AsyncCallback callback, + object cookie); /// <summary> /// Invokes an operation dynamically. @@ -330,11 +361,16 @@ namespace Ice /// <param name="operation">The name of the operation to invoke.</param> /// <param name="mode">The operation mode (normal or idempotent).</param> /// <param name="inEncaps">The encoded in-parameters for the operation.</param> - /// <param name="cb__">A callback to be invoked when the invocation completes.</param> - /// <param name="cookie__">Application-specific data to be stored in the result.</param> + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult begin_ice_invoke(string operation, OperationMode mode, byte[] inEncaps, AsyncCallback cb__, - object cookie__); + AsyncResult begin_ice_invoke(string operation, + OperationMode mode, + byte[] inEncaps, + OptionalContext context, + AsyncCallback callback, + object cookie); /// <summary> /// Invokes an operation dynamically. @@ -342,24 +378,24 @@ namespace Ice /// <param name="operation">The name of the operation to invoke.</param> /// <param name="mode">The operation mode (normal or idempotent).</param> /// <param name="inEncaps">The encoded in-parameters for the operation.</param> - /// <param name="context__">The context dictionary for the invocation.</param> - /// <param name="cb__">A callback to be invoked when the invocation completes.</param> - /// <param name="cookie__">Application-specific data to be stored in the result.</param> + /// <param name="context">The context dictionary for the invocation.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult begin_ice_invoke(string operation, OperationMode mode, byte[] inEncaps, - Dictionary<string, string> context__, AsyncCallback cb__, object cookie__); + AsyncResult<Callback_Object_ice_invoke> begin_ice_invoke(string operation, + OperationMode mode, + byte[] inEncaps, + OptionalContext context = new OptionalContext()); /// <summary> /// Completes a dynamic invocation. /// </summary> /// <param name="outEncaps">The encoded out parameters or user exception.</param> - /// <param name="r__">The asynchronous result object returned by <code>begin_ice_invoke</code>.</param> + /// <param name="result">The asynchronous result object returned by <code>begin_ice_invoke</code>.</param> /// <returns>If the operation completed successfully, the return value /// is true. If the operation raises a user exception, /// the return value is false; in this case, outEncaps /// contains the encoded user exception. If the operation raises a run-time exception, /// it throws it directly.</returns> - bool end_ice_invoke(out byte[] outEncaps, AsyncResult r__); + bool end_ice_invoke(out byte[] outEncaps, AsyncResult result); /// <summary> /// Returns the identity embedded in this proxy. @@ -500,11 +536,11 @@ namespace Ice /// </summary> /// <param name="e">The encoding version to use to marshal requests parameters.</param> /// <returns>The new proxy with the specified encoding version.</returns> - ObjectPrx ice_encodingVersion(Ice.EncodingVersion e); + ObjectPrx ice_encodingVersion(EncodingVersion e); /// <summary>Returns the encoding version used to marshal requests parameters.</summary> /// <returns>The encoding version.</returns> - Ice.EncodingVersion ice_getEncodingVersion(); + EncodingVersion ice_getEncodingVersion(); /// <summary> /// Returns whether this proxy prefers secure endpoints. @@ -527,27 +563,27 @@ namespace Ice /// </summary> /// <returns>The router for the proxy. If no router is configured for the proxy, the return value /// is null.</returns> - Ice.RouterPrx ice_getRouter(); + RouterPrx ice_getRouter(); /// <summary> /// Creates a new proxy that is identical to this proxy, except for the router. /// </summary> /// <param name="router">The router for the new proxy.</param> /// <returns>The new proxy with the specified router.</returns> - ObjectPrx ice_router(Ice.RouterPrx router); + ObjectPrx ice_router(RouterPrx router); /// <summary> /// Returns the locator for this proxy. /// </summary> /// <returns>The locator for this proxy. If no locator is configured, the return value is null.</returns> - Ice.LocatorPrx ice_getLocator(); + LocatorPrx ice_getLocator(); /// <summary> /// Creates a new proxy that is identical to this proxy, except for the locator. /// </summary> /// <param name="locator">The locator for the new proxy.</param> /// <returns>The new proxy with the specified locator.</returns> - ObjectPrx ice_locator(Ice.LocatorPrx locator); + ObjectPrx ice_locator(LocatorPrx locator); /// <summary> /// Returns whether this proxy uses collocation optimization. @@ -662,23 +698,32 @@ namespace Ice /// <summary> /// Asynchronously gets the connection for this proxy. /// </summary> + /// <param name="progress">Sent progress provider.</param> + /// <param name="cancel">A cancellation token that receives the cancellation requests.</param> + /// <returns>The task object representing the asynchronous operation.</returns> + Task<Connection> ice_getConnectionAsync(IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()); + + /// <summary> + /// Asynchronously gets the connection for this proxy. + /// </summary> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult<Callback_Object_ice_getConnection> begin_ice_getConnection(); + AsyncResult begin_ice_getConnection(AsyncCallback callback, object cookie); /// <summary> /// Asynchronously gets the connection for this proxy. /// </summary> - /// <param name="cb__">A callback to be invoked when the invocation completes.</param> - /// <param name="cookie__">Application-specific data to be stored in the result.</param> /// <returns>An asynchronous result object.</returns> - AsyncResult begin_ice_getConnection(AsyncCallback cb__, object cookie__); + AsyncResult<Callback_Object_ice_getConnection> begin_ice_getConnection(); /// <summary> /// Asynchronously gets the connection for this proxy. /// </summary> - /// <param name="r__">The asynchronous result object returned by <code>begin_ice_getConnection</code>.</param> + /// <param name="result">The asynchronous result object returned by <code>begin_ice_getConnection</code>.</param> /// <returns>The connection.</returns> - Connection end_ice_getConnection(AsyncResult r__); + Connection end_ice_getConnection(AsyncResult result); /// <summary> /// Returns the cached Connection for this proxy. If the proxy does not yet have an established @@ -691,19 +736,61 @@ namespace Ice Connection ice_getCachedConnection(); /// <summary> - /// Flushes any pending batched requests for this communicator. The call blocks until the flush is complete. + /// Flushes any pending batched requests for this proxy. The call blocks until the flush is complete. /// </summary> void ice_flushBatchRequests(); - AsyncResult begin_ice_flushBatchRequests(); - AsyncResult begin_ice_flushBatchRequests(AsyncCallback cb__, object cookie__); + /// <summary> + /// Asynchronously flushes any pending batched requests for this proxy. + /// </summary> + /// <param name="progress">Sent progress provider.</param> + /// <param name="cancel">A cancellation token that receives the cancellation requests.</param> + /// <returns>The task object representing the asynchronous operation.</returns> + Task ice_flushBatchRequestsAsync(IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()); + + /// <summary> + /// Asynchronously flushes any pending batched requests for this proxy. + /// </summary> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> + AsyncResult begin_ice_flushBatchRequests(AsyncCallback callback = null, object cookie = null); - void end_ice_flushBatchRequests(AsyncResult r__); + /// <summary> + /// Flushes any pending batched requests for this proxy. The call blocks until the flush is complete. + /// </summary> + /// <param name="result">The asynchronous result object returned by <code>begin_ice_getConnection</code>.</param> + void end_ice_flushBatchRequests(AsyncResult result); + /// <summary> + /// Write a proxy to the output stream. + /// </summary> + /// <param name="os">Output stream object to write the proxy.</param> void write__(OutputStream os); } /// <summary> + /// Represent the result of the ice_invokeAsync operation + /// </summary> + public struct Object_Ice_invokeResult + { + /// <summary> + /// If the operation completed successfully, the return value + /// is true. If the operation raises a user exception, + /// the return value is false; in this case, outEncaps + /// contains the encoded user exception. + /// </summary> + public bool returnValue; + + /// <summary> + /// The encoded out-paramaters and return value for the operation. + /// The return value follows any out-parameters. If returnValue is + /// false it contains the encoded user exception. + /// </summary> + public byte[] outEncaps; + }; + + /// <summary> /// Base class of all object proxies. /// </summary> public class ObjectPrxHelperBase : ObjectPrx @@ -738,553 +825,452 @@ namespace Ice /// <summary> /// Tests whether this object supports a specific Slice interface. /// </summary> - /// <param name="id__">The type ID of the Slice interface to test against.</param> - /// <returns>True if the target object has the interface specified by id__ or derives - /// from the interface specified by id__.</returns> - public bool ice_isA(string id__) + /// <param name="id">The type ID of the Slice interface to test against.</param> + /// <param name="context">The context dictionary for the invocation.</param> + /// <returns>True if the target object has the interface specified by id or derives + /// from the interface specified by id.</returns> + public bool ice_isA(string id, OptionalContext context = new OptionalContext()) { - return ice_isA(id__, null, false); + try + { + return ice_isAAsync(id, context, null, CancellationToken.None, true).Result; + } + catch(AggregateException ex) + { + throw ex.InnerException; + } } /// <summary> /// Tests whether this object supports a specific Slice interface. /// </summary> - /// <param name="id__">The type ID of the Slice interface to test against.</param> - /// <param name="context__">The context dictionary for the invocation.</param> - /// <returns>True if the target object has the interface specified by id__ or derives - /// from the interface specified by id__.</returns> - public bool ice_isA(string id__, Dictionary<string, string> context__) - { - return ice_isA(id__, context__, true); - } - - private bool ice_isA(string id__, Dictionary<string, string> context__, bool explicitCtx__) + /// <param name="id">The type ID of the Slice interface to test against.</param> + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="progress">Sent progress provider.</param> + /// <param name="cancel">A cancellation token that receives the cancellation requests.</param> + /// <returns>The task object representing the asynchronous operation.</returns> + public Task<bool> ice_isAAsync(string id, + OptionalContext context = new OptionalContext(), + IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()) { - checkTwowayOnly__(__ice_isA_name); - return end_ice_isA(begin_ice_isA(id__, context__, explicitCtx__, true, null, null)); + return ice_isAAsync(id, context, progress, cancel, false); } - public AsyncResult<Callback_Object_ice_isA> begin_ice_isA(string id) + private Task<bool> + ice_isAAsync(string id, OptionalContext context, IProgress<bool> progress, CancellationToken cancel, + bool synchronous) { - return begin_ice_isA(id, null, false, false, null, null); + var completed = new OperationTaskCompletionCallback<bool>(progress, cancel); + ice_isA_invoke__(id, context, completed, synchronous); + return completed.Task; } - public AsyncResult<Callback_Object_ice_isA> begin_ice_isA(string id, Dictionary<string, string> context__) + /// <summary> + /// Tests whether this object supports a specific Slice interface. + /// </summary> + /// <param name="id">The type ID of the Slice interface to test against.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult begin_ice_isA(string id, AsyncCallback callback, object cookie) { - return begin_ice_isA(id, context__, true, false, null, null); + return begin_ice_isA(id, new OptionalContext(), callback, cookie, false); } - public AsyncResult begin_ice_isA(string id, AsyncCallback cb__, object cookie__) + /// <summary> + /// Tests whether this object supports a specific Slice interface. + /// </summary> + /// <param name="id">The type ID of the Slice interface to test against.</param> + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult begin_ice_isA(string id, OptionalContext context, AsyncCallback callback, object cookie) { - return begin_ice_isA(id, null, false, false, cb__, cookie__); + return begin_ice_isA(id, context, callback, cookie, false); } - public AsyncResult begin_ice_isA(string id, Dictionary<string, string> context__, AsyncCallback cb__, - object cookie__) + /// <summary> + /// Tests whether this object supports a specific Slice interface. + /// </summary> + /// <param name="id">The type ID of the Slice interface to test against.</param> + /// <param name="context">The context dictionary for the invocation.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult<Callback_Object_ice_isA> + begin_ice_isA(string id, OptionalContext context = new OptionalContext()) { - return begin_ice_isA(id, context__, true, false, cb__, cookie__); + return begin_ice_isA(id, context, null, null, false); } internal const string __ice_isA_name = "ice_isA"; - public bool end_ice_isA(AsyncResult r__) + /// <summary> + /// Tests whether this object supports a specific Slice interface. + /// </summary> + /// <param name="result">The asynchronous result object returned by <code>begin_ice_isA</code>.</param> + /// <returns>True if the object supports the Slice interface, false otherwise.</returns> + public bool end_ice_isA(AsyncResult result) { - IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __ice_isA_name); - try - { - if(!outAsync__.wait()) - { - try - { - outAsync__.throwUserException(); - } - catch(Ice.UserException ex__) - { - throw new Ice.UnknownUserException(ex__.ice_id(), ex__); - } - } - bool ret__; - InputStream is__ = outAsync__.startReadParams(); - ret__ = is__.readBool(); - outAsync__.endReadParams(); - return ret__; - } - finally - { - if(outAsync__ != null) - { - outAsync__.cacheMessageBuffers(); - } - } + var resultI = AsyncResultI.check(result, this, __ice_isA_name); + return ((OutgoingAsyncT<bool>)resultI.OutgoingAsync).result__(resultI.wait()); } - private AsyncResult<Callback_Object_ice_isA> begin_ice_isA(string id, - Dictionary<string, string> context__, - bool explicitCtx__, - bool synchronous__, - Ice.AsyncCallback cb__, - object cookie__) + private AsyncResult<Callback_Object_ice_isA> + begin_ice_isA(string id, Dictionary<string, string> context, AsyncCallback callback, object cookie, + bool synchronous) { - checkAsyncTwowayOnly__(__ice_isA_name); - - IceInternal.TwowayOutgoingAsync<Callback_Object_ice_isA> result__ = - getTwowayOutgoingAsync<Callback_Object_ice_isA>(__ice_isA_name, ice_isA_completed__, cookie__); - if(cb__ != null) - { - result__.whenCompletedWithAsyncCallback(cb__); - } - - try - { - result__.prepare(__ice_isA_name, OperationMode.Nonmutating, context__, explicitCtx__, synchronous__); - OutputStream os__ = result__.startWriteParams(FormatType.DefaultFormat); - os__.writeString(id); - result__.endWriteParams(); - result__.invoke(); - } - catch(Ice.Exception ex__) - { - result__.abort(ex__); - } - return result__; + var completed = new OperationAsyncResultCompletionCallback<Callback_Object_ice_isA, bool>( + (Callback_Object_ice_isA cb, bool result) => + { + cb?.Invoke(result); + }, this, __ice_isA_name, cookie, callback); + ice_isA_invoke__(id, context, completed, synchronous); + return completed; } - protected IceInternal.TwowayOutgoingAsync<T> - getTwowayOutgoingAsync<T>(string operation, IceInternal.ProxyTwowayCallback<T> cb, object cookie) + private void ice_isA_invoke__(string id, + Dictionary<string, string> context, + OutgoingAsyncCompletionCallback completed, + bool synchronous) { - bool haveEntry = false; - InputStream iss = null; - OutputStream os = null; - - if(_reference.getInstance().cacheMessageBuffers() > 0) - { - lock(this) - { - if(_streamCache != null && _streamCache.Count > 0) - { - haveEntry = true; - iss = _streamCache.First.Value.iss; - os = _streamCache.First.Value.os; - - _streamCache.RemoveFirst(); - } - } - } - if(!haveEntry) - { - return new IceInternal.TwowayOutgoingAsync<T>(this, operation, cb, cookie); - } - else - { - return new IceInternal.TwowayOutgoingAsync<T>(this, operation, cb, cookie, iss, os); - } + checkAsyncTwowayOnly__(__ice_isA_name); + getOutgoingAsync<bool>(completed).invoke(__ice_isA_name, + OperationMode.Nonmutating, + FormatType.DefaultFormat, + context, + synchronous, + (OutputStream os) => { os.writeString(id); }, + null, + (InputStream iss) => { return iss.readBool(); }); } - protected IceInternal.OnewayOutgoingAsync<T> - getOnewayOutgoingAsync<T>(string operation, IceInternal.ProxyOnewayCallback<T> cb, object cookie) + /// <summary> + /// Tests whether the target object of this proxy can be reached. + /// </summary> + /// <param name="context">The context dictionary for the invocation.</param> + public void ice_ping(OptionalContext context = new OptionalContext()) { - bool haveEntry = false; - InputStream iss = null; - OutputStream os = null; - - if(_reference.getInstance().cacheMessageBuffers() > 0) - { - lock(this) - { - if(_streamCache != null && _streamCache.Count > 0) - { - haveEntry = true; - iss = _streamCache.First.Value.iss; - os = _streamCache.First.Value.os; - _streamCache.RemoveFirst(); - } - } - } - if(!haveEntry) + try { - return new IceInternal.OnewayOutgoingAsync<T>(this, operation, cb, cookie); + ice_pingAsync(context, null, CancellationToken.None, true).Wait(); } - else + catch(AggregateException ex) { - return new IceInternal.OnewayOutgoingAsync<T>(this, operation, cb, cookie, iss, os); + throw ex.InnerException; } } - public void - cacheMessageBuffers(InputStream iss, OutputStream os) + /// <summary> + /// Tests whether the target object of this proxy can be reached. + /// </summary> + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="progress">Sent progress provider.</param> + /// <param name="cancel">A cancellation token that receives the cancellation requests.</param> + /// <returns>The task object representing the asynchronous operation.</returns> + public Task ice_pingAsync(OptionalContext context = new OptionalContext(), + IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()) { - lock(this) - { - if(_streamCache == null) - { - _streamCache = new LinkedList<StreamCacheEntry>(); - } - StreamCacheEntry cacheEntry; - cacheEntry.iss = iss; - cacheEntry.os = os; - _streamCache.AddLast(cacheEntry); - } + return ice_pingAsync(context, progress, cancel, false); } - private void ice_isA_completed__(AsyncResult r__, Callback_Object_ice_isA cb__, Ice.ExceptionCallback excb__) + private Task + ice_pingAsync(OptionalContext context, IProgress<bool> progress, CancellationToken cancel, bool synchronous) { - bool ret__; - try - { - ret__ = end_ice_isA(r__); - } - catch(Ice.Exception ex__) - { - if(excb__ != null) - { - excb__(ex__); - } - return; - } - if(cb__ != null) - { - cb__(ret__); - } + var completed = new OperationTaskCompletionCallback<object>(progress, cancel); + ice_ping_invoke__(context, completed, synchronous); + return completed.Task; } /// <summary> /// Tests whether the target object of this proxy can be reached. /// </summary> - public void ice_ping() + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult begin_ice_ping(AsyncCallback callback, object cookie) { - ice_ping(null, false); + return begin_ice_ping(new OptionalContext(), callback, cookie, false); } /// <summary> /// Tests whether the target object of this proxy can be reached. /// </summary> - /// <param name="context__">The context dictionary for the invocation.</param> - public void ice_ping(Dictionary<string, string> context__) - { - ice_ping(context__, true); - } - - private void ice_ping(Dictionary<string, string> context__, bool explicitCtx__) - { - end_ice_ping(begin_ice_ping(context__, explicitCtx__, true, null, null)); - } - - public AsyncResult<Callback_Object_ice_ping> begin_ice_ping() - { - return begin_ice_ping(null, false, false, null, null); - } - - public AsyncResult<Callback_Object_ice_ping> begin_ice_ping(Dictionary<string, string> context__) - { - return begin_ice_ping(context__, true, false, null, null); - } - - public AsyncResult begin_ice_ping(AsyncCallback cb__, object cookie__) + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult begin_ice_ping(OptionalContext context, AsyncCallback callback, object cookie) { - return begin_ice_ping(null, false, false, cb__, cookie__); + return begin_ice_ping(context, callback, cookie, false); } - public AsyncResult begin_ice_ping(Dictionary<string, string> context__, AsyncCallback cb__, object cookie__) + /// <summary> + /// Tests whether the target object of this proxy can be reached. + /// </summary> + /// <param name="context">The context dictionary for the invocation.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult<Callback_Object_ice_ping> + begin_ice_ping(OptionalContext context = new OptionalContext()) { - return begin_ice_ping(null, false, false, cb__, cookie__); + return begin_ice_ping(context, null, null, false); } internal const string __ice_ping_name = "ice_ping"; - public void end_ice_ping(AsyncResult r__) + /// <summary> + /// Tests whether the target object of this proxy can be reached. + /// </summary> + /// <param name="result">The asynchronous result object returned by <code>begin_ice_ping</code>.</param> + public void end_ice_ping(AsyncResult result) { - end__(r__, __ice_ping_name); + var resultI = AsyncResultI.check(result, this, __ice_ping_name); + ((OutgoingAsyncT<object>)resultI.OutgoingAsync).result__(resultI.wait()); } - private AsyncResult<Callback_Object_ice_ping> begin_ice_ping(Dictionary<string, string> context__, - bool explicitCtx__, - bool synchronous__, - Ice.AsyncCallback cb__, - object cookie__) + private AsyncResult<Callback_Object_ice_ping> begin_ice_ping(Dictionary<string, string> context, + AsyncCallback callback, + object cookie, + bool synchronous) { - IceInternal.OnewayOutgoingAsync<Callback_Object_ice_ping> result__ = - getOnewayOutgoingAsync<Callback_Object_ice_ping>(__ice_ping_name, ice_ping_completed__, cookie__); - if(cb__ != null) - { - result__.whenCompletedWithAsyncCallback(cb__); - } - - try - { - result__.prepare(__ice_ping_name, OperationMode.Nonmutating, context__, explicitCtx__, synchronous__); - result__.writeEmptyParams(); - result__.invoke(); - } - catch(Ice.Exception ex__) - { - result__.abort(ex__); - } - return result__; + var completed = new OperationAsyncResultCompletionCallback<Callback_Object_ice_ping, object>( + (Callback_Object_ice_ping cb, object result) => + { + cb?.Invoke(); + }, this, __ice_ping_name, cookie, callback); + ice_ping_invoke__(context, completed, synchronous); + return completed; } - private void ice_ping_completed__(Callback_Object_ice_ping cb) + private void ice_ping_invoke__(Dictionary<string, string> context, OutgoingAsyncCompletionCallback completed, + bool synchronous) { - if(cb != null) - { - cb(); - } + getOutgoingAsync<object>(completed).invoke(__ice_ping_name, + OperationMode.Nonmutating, + FormatType.DefaultFormat, + context, + synchronous); } /// <summary> /// Returns the Slice type IDs of the interfaces supported by the target object of this proxy. /// </summary> + /// <param name="context">The context dictionary for the invocation.</param> /// <returns>The Slice type IDs of the interfaces supported by the target object, in base-to-derived /// order. The first element of the returned array is always ::Ice::Object.</returns> - public string[] ice_ids() + public string[] ice_ids(OptionalContext context = new OptionalContext()) { - return ice_ids(null, false); + try + { + return ice_idsAsync(context, null, CancellationToken.None, true).Result; + } + catch(AggregateException ex) + { + throw ex.InnerException; + } } /// <summary> /// Returns the Slice type IDs of the interfaces supported by the target object of this proxy. /// </summary> - /// <param name="context__">The context dictionary for the invocation.</param> - /// <returns>The Slice type IDs of the interfaces supported by the target object, in base-to-derived - /// order. The first element of the returned array is always ::Ice::Object.</returns> - public string[] ice_ids(Dictionary<string, string> context__) - { - return ice_ids(context__, true); - } - - private string[] ice_ids(Dictionary<string, string> context__, bool explicitCtx__) + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="progress">Sent progress provider.</param> + /// <param name="cancel">A cancellation token that receives the cancellation requests.</param> + /// <returns>The task object representing the asynchronous operation.</returns> + public Task<string[]> + ice_idsAsync(OptionalContext context = new OptionalContext(), + IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()) { - - checkTwowayOnly__(__ice_ids_name); - return end_ice_ids(begin_ice_ids(context__, explicitCtx__, true, null, null)); + return ice_idsAsync(context, progress, cancel, false); } - public AsyncResult<Callback_Object_ice_ids> begin_ice_ids() + private Task<string[]> ice_idsAsync(OptionalContext context, IProgress<bool> progress, CancellationToken cancel, + bool synchronous) { - return begin_ice_ids(null, false, false, null, null); + var completed = new OperationTaskCompletionCallback<string[]>(progress, cancel); + ice_ids_invoke__(context, completed, false); + return completed.Task; } - public AsyncResult<Callback_Object_ice_ids> begin_ice_ids(Dictionary<string, string> context__) + /// <summary> + /// Returns the Slice type IDs of the interfaces supported by the target object of this proxy. + /// </summary> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult begin_ice_ids(AsyncCallback callback, object cookie) { - return begin_ice_ids(context__, true, false, null, null); + return begin_ice_ids(new OptionalContext(), callback, cookie, false); } - public AsyncResult begin_ice_ids(AsyncCallback cb__, object cookie__) + /// <summary> + /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. + /// </summary> + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult + begin_ice_ids(OptionalContext context, AsyncCallback callback, object cookie) { - return begin_ice_ids(null, false, false, cb__, cookie__); + return begin_ice_ids(context, callback, cookie, false); } - public AsyncResult begin_ice_ids(Dictionary<string, string> context__, AsyncCallback cb__, object cookie__) + public AsyncResult<Callback_Object_ice_ids> + begin_ice_ids(OptionalContext context = new OptionalContext()) { - return begin_ice_ids(null, false, false, cb__, cookie__); + return begin_ice_ids(context, null, null, false); } internal const string __ice_ids_name = "ice_ids"; - public string[] end_ice_ids(AsyncResult r__) + private AsyncResult<Callback_Object_ice_ids> + begin_ice_ids(Dictionary<string, string> context, AsyncCallback callback, object cookie, bool synchronous) { - IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __ice_ids_name); - try - { - if(!outAsync__.wait()) - { - try - { - outAsync__.throwUserException(); - } - catch(Ice.UserException ex__) - { - throw new Ice.UnknownUserException(ex__.ice_id(), ex__); - } - } - string[] ret__; - InputStream is__ = outAsync__.startReadParams(); - ret__ = is__.readStringSeq(); - outAsync__.endReadParams(); - return ret__; - } - finally - { - if(outAsync__ != null) + var completed = new OperationAsyncResultCompletionCallback<Callback_Object_ice_ids, string[]>( + (Callback_Object_ice_ids cb, string[] result) => { - outAsync__.cacheMessageBuffers(); - } - } + cb?.Invoke(result); + }, this, __ice_ids_name, cookie, callback); + ice_ids_invoke__(context, completed, synchronous); + return completed; } - private AsyncResult<Callback_Object_ice_ids> begin_ice_ids(Dictionary<string, string> context__, - bool explicitCtx__, - bool synchronous__, - Ice.AsyncCallback cb__, - object cookie__) + /// <summary> + /// Returns the Slice type IDs of the interfaces supported by the target object of this proxy. + /// </summary> + /// <param name="result">The asynchronous result object returned by <code>begin_ice_ids</code>.</param> + /// <returns>The Slice type IDs of the interfaces supported by the target object, in base-to-derived + /// order. The first element of the returned array is always ::Ice::Object.</returns> + public string[] end_ice_ids(AsyncResult result) { - checkAsyncTwowayOnly__(__ice_ids_name); - - IceInternal.TwowayOutgoingAsync<Callback_Object_ice_ids> result__ = - getTwowayOutgoingAsync<Callback_Object_ice_ids>(__ice_ids_name, ice_ids_completed__, cookie__); - if(cb__ != null) - { - result__.whenCompletedWithAsyncCallback(cb__); - } - - try - { - result__.prepare(__ice_ids_name, OperationMode.Nonmutating, context__, explicitCtx__, synchronous__); - result__.writeEmptyParams(); - result__.invoke(); - } - catch(Ice.Exception ex__) - { - result__.abort(ex__); - } - return result__; + var resultI = AsyncResultI.check(result, this, __ice_ids_name); + return ((OutgoingAsyncT<string[]>)resultI.OutgoingAsync).result__(resultI.wait()); } - private void ice_ids_completed__(AsyncResult r__, Callback_Object_ice_ids cb__, Ice.ExceptionCallback excb__) + private void ice_ids_invoke__(Dictionary<string, string> context, OutgoingAsyncCompletionCallback completed, + bool synchronous) { - string[] ret__; - try - { - ret__ = end_ice_ids(r__); - } - catch(Ice.Exception ex__) - { - if(excb__ != null) - { - excb__(ex__); - } - return; - } - if(cb__ != null) - { - cb__(ret__); - } + checkAsyncTwowayOnly__(__ice_ids_name); + getOutgoingAsync<string[]>(completed).invoke(__ice_ids_name, + OperationMode.Nonmutating, + FormatType.DefaultFormat, + context, + synchronous, + read: (InputStream iss) => { return iss.readStringSeq(); }); } /// <summary> /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. /// </summary> /// <returns>The Slice type ID of the most-derived interface.</returns> - public string ice_id() + public string ice_id(OptionalContext context = new OptionalContext()) { - return ice_id(null, false); + try + { + return ice_idAsync(context, null, CancellationToken.None, true).Result; + } + catch(AggregateException ex) + { + throw ex.InnerException; + } } /// <summary> /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. /// </summary> - /// <param name="context__">The context dictionary for the invocation.</param> - /// <returns>The Slice type ID of the most-derived interface.</returns> - public string ice_id(Dictionary<string, string> context__) - { - return ice_id(context__, true); - } - - private string ice_id(Dictionary<string, string> context__, bool explicitCtx__) + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="progress">Sent progress provider.</param> + /// <param name="cancel">A cancellation token that receives the cancellation requests.</param> + /// <returns>The task object representing the asynchronous operation.</returns> + public Task<string> ice_idAsync(OptionalContext context = new OptionalContext(), + IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()) { - checkTwowayOnly__(__ice_id_name); - return end_ice_id(begin_ice_id(context__, explicitCtx__, true, null, null)); + return ice_idAsync(context, progress, cancel, false); } - public AsyncResult<Callback_Object_ice_id> begin_ice_id() + private Task<string> + ice_idAsync(OptionalContext context, IProgress<bool> progress, CancellationToken cancel, bool synchronous) { - return begin_ice_id(null, false, false, null, null); + var completed = new OperationTaskCompletionCallback<string>(progress, cancel); + ice_id_invoke__(context, completed, synchronous); + return completed.Task; } - public AsyncResult<Callback_Object_ice_id> begin_ice_id(Dictionary<string, string> context__) + /// <summary> + /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. + /// </summary> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult begin_ice_id(AsyncCallback callback, object cookie) { - return begin_ice_id(context__, true, false, null, null); + return begin_ice_id(new OptionalContext(), callback, cookie, false); } - public AsyncResult begin_ice_id(AsyncCallback cb__, object cookie__) + /// <summary> + /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. + /// </summary> + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult + begin_ice_id(OptionalContext context, AsyncCallback callback, object cookie) { - return begin_ice_id(null, false, false, cb__, cookie__); + return begin_ice_id(context, callback, cookie, false); } - public AsyncResult begin_ice_id(Dictionary<string, string> context__, AsyncCallback cb__, object cookie__) + /// <summary> + /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. + /// </summary> + /// <param name="context">The context dictionary for the invocation.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult<Callback_Object_ice_id> + begin_ice_id(OptionalContext context = new OptionalContext()) { - return begin_ice_id(null, false, false, cb__, cookie__); + return begin_ice_id(context, null, null, false); } internal const string __ice_id_name = "ice_id"; - public string end_ice_id(AsyncResult r__) + private AsyncResult<Callback_Object_ice_id> + begin_ice_id(Dictionary<string, string> context, AsyncCallback callback, object cookie, bool synchronous) { - IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __ice_id_name); - try - { - if(!outAsync__.wait()) + var completed = new OperationAsyncResultCompletionCallback<Callback_Object_ice_id, string>( + (Callback_Object_ice_id cb, string result) => { - try - { - outAsync__.throwUserException(); - } - catch(Ice.UserException ex__) - { - throw new Ice.UnknownUserException(ex__.ice_id(), ex__); - } - } - string ret__; - InputStream is__ = outAsync__.startReadParams(); - ret__ = is__.readString(); - outAsync__.endReadParams(); - return ret__; - } - finally - { - if(outAsync__ != null) - { - outAsync__.cacheMessageBuffers(); - } - } + cb?.Invoke(result); + }, this, __ice_id_name, cookie, callback); + ice_id_invoke__(context, completed, synchronous); + return completed; } - private AsyncResult<Callback_Object_ice_id> begin_ice_id(Dictionary<string, string> context__, - bool explicitCtx__, - bool synchronous__, - Ice.AsyncCallback cb__, - object cookie__) + /// <summary> + /// Returns the Slice type ID of the most-derived interface supported by the target object of this proxy. + /// </summary> + /// <param name="result">The asynchronous result object returned by <code>begin_ice_id</code>.</param> + /// <returns>The Slice type ID of the most-derived interface.</returns> + public string end_ice_id(AsyncResult result) { - checkAsyncTwowayOnly__(__ice_id_name); - - IceInternal.TwowayOutgoingAsync<Callback_Object_ice_id> result__ = - getTwowayOutgoingAsync<Callback_Object_ice_id>(__ice_id_name, ice_id_completed__, cookie__); - if(cb__ != null) - { - result__.whenCompletedWithAsyncCallback(cb__); - } - - try - { - result__.prepare(__ice_id_name, OperationMode.Nonmutating, context__, explicitCtx__, synchronous__); - result__.writeEmptyParams(); - result__.invoke(); - } - catch(Ice.Exception ex__) - { - result__.abort(ex__); - } - return result__; + var resultI = AsyncResultI.check(result, this, __ice_id_name); + return ((OutgoingAsyncT<string>)resultI.OutgoingAsync).result__(resultI.wait()); } - private void ice_id_completed__(AsyncResult r__, Callback_Object_ice_id cb__, Ice.ExceptionCallback excb__) + private void ice_id_invoke__(Dictionary<string, string> context, + OutgoingAsyncCompletionCallback completed, + bool synchronous) { - string ret__; - try - { - ret__ = end_ice_id(r__); - } - catch(Ice.Exception ex__) - { - if(excb__ != null) - { - excb__(ex__); - } - return; - } - if(cb__ != null) - { - cb__(ret__); - } + checkAsyncTwowayOnly__(__ice_id_name); + getOutgoingAsync<string>(completed).invoke(__ice_id_name, + OperationMode.Nonmutating, + FormatType.DefaultFormat, + context, + synchronous, + read: (InputStream iss) => { return iss.readString(); }); } /// <summary> @@ -1295,14 +1281,28 @@ namespace Ice /// <param name="inEncaps">The encoded in-parameters for the operation.</param> /// <param name="outEncaps">The encoded out-paramaters and return value /// for the operation. The return value follows any out-parameters.</param> + /// <param name="context">The context dictionary for the invocation.</param> /// <returns>If the operation completed successfully, the return value /// is true. If the operation raises a user exception, /// the return value is false; in this case, outEncaps /// contains the encoded user exception. If the operation raises a run-time exception, /// it throws it directly.</returns> - public bool ice_invoke(string operation, OperationMode mode, byte[] inEncaps, out byte[] outEncaps) + public bool ice_invoke(string operation, + OperationMode mode, + byte[] inEncaps, + out byte[] outEncaps, + OptionalContext context = new OptionalContext()) { - return ice_invoke(operation, mode, inEncaps, out outEncaps, null, false); + try + { + var result = ice_invokeAsync(operation, mode, inEncaps, context, null, CancellationToken.None, true).Result; + outEncaps = result.outEncaps; + return result.returnValue; + } + catch(AggregateException ex) + { + throw ex.InnerException; + } } /// <summary> @@ -1311,132 +1311,134 @@ namespace Ice /// <param name="operation">The name of the operation to invoke.</param> /// <param name="mode">The operation mode (normal or idempotent).</param> /// <param name="inEncaps">The encoded in-parameters for the operation.</param> - /// <param name="outEncaps">The encoded out-paramaters and return value - /// for the operation. The return value follows any out-parameters.</param> /// <param name="context">The context dictionary for the invocation.</param> - /// <returns>If the operation completed successfully, the return value - /// is true. If the operation raises a user exception, - /// the return value is false; in this case, outEncaps - /// contains the encoded user exception. If the operation raises a run-time exception, - /// it throws it directly.</returns> - public bool ice_invoke(string operation, OperationMode mode, byte[] inEncaps, out byte[] outEncaps, - Dictionary<string, string> context) + /// <param name="progress">Sent progress provider.</param> + /// <param name="cancel">A cancellation token that receives the cancellation requests.</param> + /// <returns>The task object representing the asynchronous operation.</returns> + public Task<Object_Ice_invokeResult> + ice_invokeAsync(string operation, + OperationMode mode, + byte[] inEncaps, + OptionalContext context = new OptionalContext(), + IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()) { - return ice_invoke(operation, mode, inEncaps, out outEncaps, context, true); + return ice_invokeAsync(operation, mode, inEncaps, context, progress, cancel, false); } - private bool ice_invoke(string operation, OperationMode mode, byte[] inEncaps, out byte[] outEncaps, - Dictionary<string, string> context, bool explicitCtx) + private Task<Object_Ice_invokeResult> + ice_invokeAsync(string operation, + OperationMode mode, + byte[] inEncaps, + OptionalContext context, + IProgress<bool> progress, + CancellationToken cancel, + bool synchronous) { - return end_ice_invoke(out outEncaps, begin_ice_invoke(operation, mode, inEncaps, context, explicitCtx, true, null, null)); + var completed = new InvokeTaskCompletionCallback(progress, cancel); + ice_invoke_invoke__(operation, mode, inEncaps, context, completed, synchronous); + return completed.Task; } - public AsyncResult<Callback_Object_ice_invoke> begin_ice_invoke(string operation, - OperationMode mode, - byte[] inEncaps) - { - return begin_ice_invoke(operation, mode, inEncaps, null, false, false, null, null); - } - - public AsyncResult<Callback_Object_ice_invoke> begin_ice_invoke(string operation, - OperationMode mode, - byte[] inEncaps, - Dictionary<string, string> context__) + /// <summary> + /// Invokes an operation dynamically. + /// </summary> + /// <param name="operation">The name of the operation to invoke.</param> + /// <param name="mode">The operation mode (normal or idempotent).</param> + /// <param name="inEncaps">The encoded in-parameters for the operation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult + begin_ice_invoke(string operation, + OperationMode mode, + byte[] inEncaps, + AsyncCallback callback, + object cookie) { - return begin_ice_invoke(operation, mode, inEncaps, context__, true, false, null, null); + return begin_ice_invoke(operation, mode, inEncaps, new OptionalContext(), callback, cookie, false); } - public AsyncResult begin_ice_invoke(string operation, OperationMode mode, byte[] inEncaps, AsyncCallback cb__, - object cookie__) + /// <summary> + /// Invokes an operation dynamically. + /// </summary> + /// <param name="operation">The name of the operation to invoke.</param> + /// <param name="mode">The operation mode (normal or idempotent).</param> + /// <param name="inEncaps">The encoded in-parameters for the operation.</param> + /// <param name="context">The context dictionary for the invocation.</param> + /// <param name="callback">A callback to be invoked when the invocation completes.</param> + /// <param name="cookie">Application-specific data to be stored in the result.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult + begin_ice_invoke(string operation, + OperationMode mode, + byte[] inEncaps, + OptionalContext context, + AsyncCallback callback, + object cookie) { - return begin_ice_invoke(operation, mode, inEncaps, null, false, false, cb__, cookie__); + return begin_ice_invoke(operation, mode, inEncaps, context, callback, cookie, false); } - public AsyncResult begin_ice_invoke(string operation, OperationMode mode, byte[] inEncaps, - Dictionary<string, string> context__, AsyncCallback cb__, object cookie__) + /// <summary> + /// Invokes an operation dynamically. + /// </summary> + /// <param name="operation">The name of the operation to invoke.</param> + /// <param name="mode">The operation mode (normal or idempotent).</param> + /// <param name="inEncaps">The encoded in-parameters for the operation.</param> + /// <param name="context">The context dictionary for the invocation.</param> + /// <returns>An asynchronous result object.</returns> + public AsyncResult<Callback_Object_ice_invoke> + begin_ice_invoke(string operation, + OperationMode mode, + byte[] inEncaps, + OptionalContext context = new OptionalContext()) { - return begin_ice_invoke(operation, mode, inEncaps, null, false, false, cb__, cookie__); + return begin_ice_invoke(operation, mode, inEncaps, context, null, null, false); } internal const string __ice_invoke_name = "ice_invoke"; - public bool end_ice_invoke(out byte[] outEncaps, AsyncResult r__) + /// <summary> + /// Completes a dynamic invocation. + /// </summary> + /// <param name="outEncaps">The encoded out parameters or user exception.</param> + /// <param name="result">The asynchronous result object returned by <code>begin_ice_invoke</code>.</param> + /// <returns>If the operation completed successfully, the return value + /// is true. If the operation raises a user exception, + /// the return value is false; in this case, outEncaps + /// contains the encoded user exception. If the operation raises a run-time exception, + /// it throws it directly.</returns> + public bool end_ice_invoke(out byte[] outEncaps, AsyncResult result) { - IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __ice_invoke_name); - try - { - bool ok = outAsync__.wait(); - if(_reference.getMode() == IceInternal.Reference.Mode.ModeTwoway) - { - outEncaps = outAsync__.readParamEncaps(); - } - else - { - outEncaps = null; // Satisfy compiler - } - return ok; - } - finally - { - if(outAsync__ != null) - { - outAsync__.cacheMessageBuffers(); - } - } - + var resultI = AsyncResultI.check(result, this, __ice_invoke_name); + var r = ((InvokeOutgoingAsyncT)resultI.OutgoingAsync).result__(resultI.wait()); + outEncaps = r.outEncaps; + return r.returnValue; } - private AsyncResult<Callback_Object_ice_invoke> begin_ice_invoke(string operation, - OperationMode mode, - byte[] inEncaps, - Dictionary<string, string> context__, - bool explicitCtx__, - bool synchronous__, - Ice.AsyncCallback cb__, - object cookie__) + private AsyncResult<Callback_Object_ice_invoke> + begin_ice_invoke(string operation, + OperationMode mode, + byte[] inEncaps, + Dictionary<string, string> context, + AsyncCallback callback, + object cookie, + bool synchronous) { - IceInternal.TwowayOutgoingAsync<Callback_Object_ice_invoke> result__ = - getTwowayOutgoingAsync<Callback_Object_ice_invoke>(__ice_invoke_name, ice_invoke_completed__, cookie__); - if(cb__ != null) - { - result__.whenCompletedWithAsyncCallback(cb__); - } - - try - { - result__.prepare(operation, mode, context__, explicitCtx__, synchronous__); - result__.writeParamEncaps(inEncaps); - result__.invoke(); - } - catch(Ice.Exception ex__) - { - result__.abort(ex__); - } - return result__; + var completed = new InvokeAsyncResultCompletionCallback(this, __ice_invoke_name, cookie, callback); + ice_invoke_invoke__(operation, mode, inEncaps, context, completed, synchronous); + return completed; } - private void ice_invoke_completed__(AsyncResult r__, - Callback_Object_ice_invoke cb__, - Ice.ExceptionCallback excb__) + private void ice_invoke_invoke__(string operation, + OperationMode mode, + byte[] inEncaps, + Dictionary<string, string> context, + OutgoingAsyncCompletionCallback completed, + bool synchronous) { - byte[] outEncaps; - bool ret__; - try - { - ret__ = end_ice_invoke(out outEncaps, r__); - } - catch(Ice.Exception ex__) - { - if(excb__ != null) - { - excb__(ex__); - } - return; - } - if(cb__ != null) - { - cb__(ret__, outEncaps); - } + getInvokeOutgoingAsync(completed).invoke(operation, mode, inEncaps, context, synchronous); } /// <summary> @@ -1465,7 +1467,7 @@ namespace Ice } else { - ObjectPrxHelperBase proxy = new ObjectPrxHelperBase(); + var proxy = new ObjectPrxHelperBase(); proxy.setup(_reference.changeIdentity(newIdentity)); return proxy; } @@ -1519,7 +1521,7 @@ namespace Ice } else { - ObjectPrxHelperBase proxy = new ObjectPrxHelperBase(); + var proxy = new ObjectPrxHelperBase(); proxy.setup(_reference.changeFacet(newFacet)); return proxy; } @@ -1579,10 +1581,10 @@ namespace Ice } else { - IceInternal.EndpointI[] endpts = new IceInternal.EndpointI[newEndpoints.Length]; + var endpts = new EndpointI[newEndpoints.Length]; for(int i = 0; i < newEndpoints.Length; ++i) { - endpts[i] = (IceInternal.EndpointI)newEndpoints[i]; + endpts[i] = (EndpointI)newEndpoints[i]; } return newInstance(_reference.changeEndpoints(endpts)); } @@ -1605,7 +1607,7 @@ namespace Ice { if(newTimeout < -1) { - throw new System.ArgumentException("invalid value passed to ice_locatorCacheTimeout: " + newTimeout); + throw new ArgumentException("invalid value passed to ice_locatorCacheTimeout: " + newTimeout); } if(newTimeout == _reference.getLocatorCacheTimeout()) { @@ -1634,7 +1636,7 @@ namespace Ice { if(newTimeout < 1 && newTimeout != -1 && newTimeout != -2) { - throw new System.ArgumentException("invalid value passed to ice_invocationTimeout: " + newTimeout); + throw new ArgumentException("invalid value passed to ice_invocationTimeout: " + newTimeout); } if(newTimeout == _reference.getInvocationTimeout()) { @@ -1732,7 +1734,7 @@ namespace Ice /// </summary> /// <param name="e">The encoding version to use to marshal requests parameters.</param> /// <returns>The new proxy with the specified encoding version.</returns> - public ObjectPrx ice_encodingVersion(Ice.EncodingVersion e) + public ObjectPrx ice_encodingVersion(EncodingVersion e) { if(e.Equals(_reference.getEncoding())) { @@ -1746,7 +1748,7 @@ namespace Ice /// <summary>Returns the encoding version used to marshal requests parameters.</summary> /// <returns>The encoding version.</returns> - public Ice.EncodingVersion ice_getEncodingVersion() + public EncodingVersion ice_getEncodingVersion() { return _reference.getEncoding(); } @@ -1785,9 +1787,9 @@ namespace Ice /// </summary> /// <returns>The router for the proxy. If no router is configured for the proxy, the return value /// is null.</returns> - public Ice.RouterPrx ice_getRouter() + public RouterPrx ice_getRouter() { - IceInternal.RouterInfo ri = _reference.getRouterInfo(); + RouterInfo ri = _reference.getRouterInfo(); return ri != null ? ri.getRouter() : null; } @@ -1798,7 +1800,7 @@ namespace Ice /// <returns>The new proxy with the specified router.</returns> public ObjectPrx ice_router(RouterPrx router) { - IceInternal.Reference @ref = _reference.changeRouter(router); + Reference @ref = _reference.changeRouter(router); if(@ref.Equals(_reference)) { return this; @@ -1813,9 +1815,9 @@ namespace Ice /// Returns the locator for this proxy. /// </summary> /// <returns>The locator for this proxy. If no locator is configured, the return value is null.</returns> - public Ice.LocatorPrx ice_getLocator() + public LocatorPrx ice_getLocator() { - IceInternal.LocatorInfo li = _reference.getLocatorInfo(); + var li = _reference.getLocatorInfo(); return li != null ? li.getLocator() : null; } @@ -1826,7 +1828,7 @@ namespace Ice /// <returns>The new proxy with the specified locator.</returns> public ObjectPrx ice_locator(LocatorPrx locator) { - IceInternal.Reference @ref = _reference.changeLocator(locator); + var @ref = _reference.changeLocator(locator); if(@ref.Equals(_reference)) { return this; @@ -1869,13 +1871,13 @@ namespace Ice /// <returns>A new proxy that uses twoway invocations.</returns> public ObjectPrx ice_twoway() { - if(_reference.getMode() == IceInternal.Reference.Mode.ModeTwoway) + if(_reference.getMode() == Reference.Mode.ModeTwoway) { return this; } else { - return newInstance(_reference.changeMode(IceInternal.Reference.Mode.ModeTwoway)); + return newInstance(_reference.changeMode(Reference.Mode.ModeTwoway)); } } @@ -1885,7 +1887,7 @@ namespace Ice /// <returns>True if this proxy uses twoway invocations; false, otherwise.</returns> public bool ice_isTwoway() { - return _reference.getMode() == IceInternal.Reference.Mode.ModeTwoway; + return _reference.getMode() == Reference.Mode.ModeTwoway; } /// <summary> @@ -1894,13 +1896,13 @@ namespace Ice /// <returns>A new proxy that uses oneway invocations.</returns> public ObjectPrx ice_oneway() { - if(_reference.getMode() == IceInternal.Reference.Mode.ModeOneway) + if(_reference.getMode() == Reference.Mode.ModeOneway) { return this; } else { - return newInstance(_reference.changeMode(IceInternal.Reference.Mode.ModeOneway)); + return newInstance(_reference.changeMode(Reference.Mode.ModeOneway)); } } @@ -1910,7 +1912,7 @@ namespace Ice /// <returns>True if this proxy uses oneway invocations; false, otherwise.</returns> public bool ice_isOneway() { - return _reference.getMode() == IceInternal.Reference.Mode.ModeOneway; + return _reference.getMode() == Reference.Mode.ModeOneway; } /// <summary> @@ -1919,13 +1921,13 @@ namespace Ice /// <returns>A new proxy that uses batch oneway invocations.</returns> public ObjectPrx ice_batchOneway() { - if(_reference.getMode() == IceInternal.Reference.Mode.ModeBatchOneway) + if(_reference.getMode() == Reference.Mode.ModeBatchOneway) { return this; } else { - return newInstance(_reference.changeMode(IceInternal.Reference.Mode.ModeBatchOneway)); + return newInstance(_reference.changeMode(Reference.Mode.ModeBatchOneway)); } } @@ -1935,7 +1937,7 @@ namespace Ice /// <returns>True if this proxy uses batch oneway invocations; false, otherwise.</returns> public bool ice_isBatchOneway() { - return _reference.getMode() == IceInternal.Reference.Mode.ModeBatchOneway; + return _reference.getMode() == Reference.Mode.ModeBatchOneway; } /// <summary> @@ -1944,13 +1946,13 @@ namespace Ice /// <returns>A new proxy that uses datagram invocations.</returns> public ObjectPrx ice_datagram() { - if(_reference.getMode() == IceInternal.Reference.Mode.ModeDatagram) + if(_reference.getMode() == Reference.Mode.ModeDatagram) { return this; } else { - return newInstance(_reference.changeMode(IceInternal.Reference.Mode.ModeDatagram)); + return newInstance(_reference.changeMode(Reference.Mode.ModeDatagram)); } } @@ -1960,7 +1962,7 @@ namespace Ice /// <returns>True if this proxy uses datagram invocations; false, otherwise.</returns> public bool ice_isDatagram() { - return _reference.getMode() == IceInternal.Reference.Mode.ModeDatagram; + return _reference.getMode() == Reference.Mode.ModeDatagram; } /// <summary> @@ -1969,13 +1971,13 @@ namespace Ice /// <returns>A new proxy that uses batch datagram invocations.</returns> public ObjectPrx ice_batchDatagram() { - if(_reference.getMode() == IceInternal.Reference.Mode.ModeBatchDatagram) + if(_reference.getMode() == Reference.Mode.ModeBatchDatagram) { return this; } else { - return newInstance(_reference.changeMode(IceInternal.Reference.Mode.ModeBatchDatagram)); + return newInstance(_reference.changeMode(Reference.Mode.ModeBatchDatagram)); } } @@ -1985,7 +1987,7 @@ namespace Ice /// <returns>True if this proxy uses batch datagram invocations; false, otherwise.</returns> public bool ice_isBatchDatagram() { - return _reference.getMode() == IceInternal.Reference.Mode.ModeBatchDatagram; + return _reference.getMode() == Reference.Mode.ModeBatchDatagram; } /// <summary> @@ -1995,7 +1997,7 @@ namespace Ice /// <returns>A new proxy with the specified compression setting.</returns> public ObjectPrx ice_compress(bool co) { - IceInternal.Reference @ref = _reference.changeCompress(co); + var @ref = _reference.changeCompress(co); if(@ref.Equals(_reference)) { return this; @@ -2015,9 +2017,9 @@ namespace Ice { if(t < 1 && t != -1) { - throw new System.ArgumentException("invalid value passed to ice_timeout: " + t); + throw new ArgumentException("invalid value passed to ice_timeout: " + t); } - IceInternal.Reference @ref = _reference.changeTimeout(t); + var @ref = _reference.changeTimeout(t); if(@ref.Equals(_reference)) { return this; @@ -2036,7 +2038,7 @@ namespace Ice /// <returns>A new proxy with the specified connection ID.</returns> public ObjectPrx ice_connectionId(string connectionId) { - IceInternal.Reference @ref = _reference.changeConnectionId(connectionId); + var @ref = _reference.changeConnectionId(connectionId); if(@ref.Equals(_reference)) { return this; @@ -2065,74 +2067,109 @@ namespace Ice /// collocated object.</exception> public Connection ice_getConnection() { - return end_ice_getConnection(begin_ice_getConnection()); + try + { + return ice_getConnectionAsync().Result; + } + catch(AggregateException ex) + { + throw ex.InnerException; + } } - public AsyncResult<Callback_Object_ice_getConnection> begin_ice_getConnection() + private class ProxyGetConnectionAsyncCallback : ProxyAsyncResultCompletionCallback<Callback_Object_ice_getConnection> { - return begin_ice_getConnectionInternal(null, null); - } - - internal const string __ice_getConnection_name = "ice_getConnection"; + public ProxyGetConnectionAsyncCallback(ObjectPrxHelperBase proxy, string operation, object cookie, + AsyncCallback cb) : + base(proxy, operation, cookie, cb) + { + } - public AsyncResult begin_ice_getConnection(Ice.AsyncCallback cb, object cookie) - { - return begin_ice_getConnectionInternal(cb, cookie); + protected override AsyncCallback getCompletedCallback() + { + return (AsyncResult result) => + { + try + { + result.throwLocalException(); + responseCallback_?.Invoke(getProxy().ice_getCachedConnection()); + } + catch(Exception ex) + { + exceptionCallback_?.Invoke(ex); + } + }; + } } - public Connection end_ice_getConnection(Ice.AsyncResult r) + public class GetConnectionTaskCompletionCallback : TaskCompletionCallback<Connection> { - IceInternal.ProxyGetConnection outAsync = - IceInternal.ProxyGetConnection.check(r, this, __ice_getConnection_name); - outAsync.wait(); - return ice_getCachedConnection(); - } + public GetConnectionTaskCompletionCallback(ObjectPrx proxy, + IProgress<bool> progress, + CancellationToken cancellationToken) : + base(progress, cancellationToken) + { + _proxy = proxy; + } - private AsyncResult<Callback_Object_ice_getConnection> begin_ice_getConnectionInternal(Ice.AsyncCallback cb, - object cookie) - { - IceInternal.ProxyGetConnection result = new IceInternal.ProxyGetConnection(this, - __ice_getConnection_name, - ice_getConnection_completed__, - cookie); - if(cb != null) + public override bool handleResponse(bool ok, OutgoingAsyncBase og) { - result.whenCompletedWithAsyncCallback(cb); + SetResult(_proxy.ice_getCachedConnection()); + return false; } + + private ObjectPrx _proxy; + } + + public Task<Connection> ice_getConnectionAsync(IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()) + { + var completed = new GetConnectionTaskCompletionCallback(this, progress, cancel); + var outgoing = new ProxyGetConnection(this, completed); try { - result.invoke(); + outgoing.invoke(__ice_getConnection_name); } - catch(Ice.Exception ex) + catch(Exception ex) { - result.abort(ex); + outgoing.abort(ex); } - return result; + return completed.Task; } + public AsyncResult<Callback_Object_ice_getConnection> begin_ice_getConnection() + { + return begin_ice_getConnectionInternal(null, null); + } + + internal const string __ice_getConnection_name = "ice_getConnection"; + + public AsyncResult begin_ice_getConnection(AsyncCallback cb, object cookie) + { + return begin_ice_getConnectionInternal(cb, cookie); + } + public Connection end_ice_getConnection(AsyncResult r) + { + var resultI = AsyncResultI.check(r, this, __ice_getConnection_name); + resultI.wait(); + return ice_getCachedConnection(); + } - private void ice_getConnection_completed__(AsyncResult r, - Callback_Object_ice_getConnection cb, - Ice.ExceptionCallback excb) + private AsyncResult<Callback_Object_ice_getConnection> begin_ice_getConnectionInternal(AsyncCallback callback, + object cookie) { - Connection ret; + var completed = new ProxyGetConnectionAsyncCallback(this, __ice_getConnection_name, cookie, callback); + var outgoing = new ProxyGetConnection(this, completed); try { - ret = end_ice_getConnection(r); + outgoing.invoke(__ice_getConnection_name); } - catch(Ice.Exception ex) + catch(Exception ex) { - if(excb != null) - { - excb(ex); - } - return; - } - if(cb != null) - { - cb(ret); + outgoing.abort(ex); } + return completed; } /// <summary> @@ -2145,7 +2182,7 @@ namespace Ice /// collocated object.</exception> public Connection ice_getCachedConnection() { - IceInternal.RequestHandler handler; + RequestHandler handler; lock(this) { handler = _requestHandler; @@ -2169,41 +2206,88 @@ namespace Ice /// </summary> public void ice_flushBatchRequests() { - end_ice_flushBatchRequests(begin_ice_flushBatchRequests()); + try + { + ice_flushBatchRequestsAsync().Wait(); + } + catch(AggregateException ex) + { + throw ex.InnerException; + } } internal const string __ice_flushBatchRequests_name = "ice_flushBatchRequests"; - public AsyncResult begin_ice_flushBatchRequests() + public Task ice_flushBatchRequestsAsync(IProgress<bool> progress = null, + CancellationToken cancel = new CancellationToken()) { - return begin_ice_flushBatchRequests(null, null); + var completed = new FlushBatchTaskCompletionCallback(progress, cancel); + var outgoing = new ProxyFlushBatchAsync(this, completed); + try + { + outgoing.invoke(__ice_flushBatchRequests_name); + } + catch(Exception ex) + { + outgoing.abort(ex); + } + return completed.Task; } - public AsyncResult begin_ice_flushBatchRequests(Ice.AsyncCallback cb, object cookie) + private class ProxyFlushBatchRequestsAsyncCallback : AsyncResultCompletionCallback { - IceInternal.ProxyFlushBatch result = new IceInternal.ProxyFlushBatch(this, - __ice_flushBatchRequests_name, - cookie); - if(cb != null) + public ProxyFlushBatchRequestsAsyncCallback(ObjectPrx proxy, + string operation, + object cookie, + AsyncCallback callback) : + base(proxy.ice_getCommunicator(), ((ObjectPrxHelperBase)proxy).reference__().getInstance(), + operation, cookie, callback) { - result.whenCompletedWithAsyncCallback(cb); + _proxy = proxy; } + + public override ObjectPrx getProxy() + { + return _proxy; + } + + protected override AsyncCallback getCompletedCallback() + { + return (AsyncResult result) => + { + try + { + result.throwLocalException(); + } + catch(Exception ex) + { + exceptionCallback_?.Invoke(ex); + } + }; + } + + private ObjectPrx _proxy; + } + + public AsyncResult begin_ice_flushBatchRequests(AsyncCallback cb = null, object cookie = null) + { + var completed = new ProxyFlushBatchRequestsAsyncCallback(this, __ice_flushBatchRequests_name, cookie, cb); + var outgoing = new ProxyFlushBatchAsync(this, completed); try { - result.invoke(); + outgoing.invoke(__ice_flushBatchRequests_name); } - catch(Ice.Exception ex) + catch(Exception ex) { - result.abort(ex); + outgoing.abort(ex); } - return result; + return completed; } - public void end_ice_flushBatchRequests(Ice.AsyncResult r) + public void end_ice_flushBatchRequests(AsyncResult r) { - IceInternal.ProxyFlushBatch outAsync = - IceInternal.ProxyFlushBatch.check(r, this, __ice_flushBatchRequests_name); - outAsync.wait(); + var resultI = AsyncResultI.check(r, this, __ice_flushBatchRequests_name); + resultI.wait(); } /// <summary> @@ -2214,8 +2298,8 @@ namespace Ice /// <returns>True if this proxy is equal to r; false, otherwise.</returns> public override bool Equals(object r) { - ObjectPrxHelperBase rhs = r as ObjectPrxHelperBase; - return object.ReferenceEquals(rhs, null) ? false : _reference.Equals(rhs._reference); + var rhs = r as ObjectPrxHelperBase; + return ReferenceEquals(rhs, null) ? false : _reference.Equals(rhs._reference); } /// <summary> @@ -2227,7 +2311,7 @@ namespace Ice /// <returns>True if the proxies are equal; false, otherwise.</returns> public static bool Equals(ObjectPrxHelperBase lhs, ObjectPrxHelperBase rhs) { - return object.ReferenceEquals(lhs, null) ? object.ReferenceEquals(rhs, null) : lhs.Equals(rhs); + return ReferenceEquals(lhs, null) ? ReferenceEquals(rhs, null) : lhs.Equals(rhs); } /// <summary> @@ -2260,7 +2344,7 @@ namespace Ice _reference.streamWrite(os); } - public IceInternal.Reference reference__() + public Reference reference__() { return _reference; } @@ -2269,13 +2353,13 @@ namespace Ice { lock(from) { - ObjectPrxHelperBase h = (ObjectPrxHelperBase)from; + var h = (ObjectPrxHelperBase)from; _reference = h._reference; _requestHandler = h._requestHandler; } } - public int handleException__(Exception ex, IceInternal.RequestHandler handler, OperationMode mode, bool sent, + public int handleException__(Exception ex, RequestHandler handler, OperationMode mode, bool sent, ref int cnt) { updateRequestHandler__(handler, null); // Clear the request handler @@ -2320,21 +2404,6 @@ namespace Ice } } - public void checkTwowayOnly__(string name) - { - // - // No mutex lock necessary, there is nothing mutable in this - // operation. - // - - if(!ice_isTwoway()) - { - TwowayOnlyException ex = new TwowayOnlyException(); - ex.operation = name; - throw ex; - } - } - public void checkAsyncTwowayOnly__(string name) { // @@ -2344,43 +2413,11 @@ namespace Ice if(!ice_isTwoway()) { - throw new System.ArgumentException("`" + name + "' can only be called with a twoway proxy"); - } - } - - public void end__(AsyncResult r, string operation) - { - IceInternal.ProxyOutgoingAsyncBase result = IceInternal.ProxyOutgoingAsyncBase.check(r, this, operation); - try - { - bool ok = result.wait(); - if(_reference.getMode() == IceInternal.Reference.Mode.ModeTwoway) - { - IceInternal.OutgoingAsync outAsync = (IceInternal.OutgoingAsync)result; - if(!ok) - { - try - { - outAsync.throwUserException(); - } - catch(Ice.UserException ex) - { - throw new Ice.UnknownUserException(ex.ice_id(), ex); - } - } - outAsync.readEmptyParams(); - } - } - finally - { - if(result != null) - { - result.cacheMessageBuffers(); - } + throw new ArgumentException("`" + name + "' can only be called with a twoway proxy"); } } - public IceInternal.RequestHandler getRequestHandler__() + public RequestHandler getRequestHandler__() { if(_reference.getCacheConnection()) { @@ -2395,7 +2432,7 @@ namespace Ice return _reference.getRequestHandler(this); } - public IceInternal.BatchRequestQueue + public BatchRequestQueue getBatchRequestQueue__() { lock(this) @@ -2408,8 +2445,8 @@ namespace Ice } } - public IceInternal.RequestHandler - setRequestHandler__(IceInternal.RequestHandler handler) + public RequestHandler + setRequestHandler__(RequestHandler handler) { if(_reference.getCacheConnection()) { @@ -2425,7 +2462,7 @@ namespace Ice return handler; } - public void updateRequestHandler__(IceInternal.RequestHandler previous, IceInternal.RequestHandler handler) + public void updateRequestHandler__(RequestHandler previous, RequestHandler handler) { if(_reference.getCacheConnection() && previous != null) { @@ -2446,32 +2483,226 @@ namespace Ice } } - // - // Only for use by IceInternal.ProxyFactory - // - public void setup(IceInternal.Reference @ref) + protected OutgoingAsyncT<T> + getOutgoingAsync<T>(OutgoingAsyncCompletionCallback completed) + { + bool haveEntry = false; + InputStream iss = null; + OutputStream os = null; + + if(_reference.getInstance().cacheMessageBuffers() > 0) + { + lock(this) + { + if(_streamCache != null && _streamCache.Count > 0) + { + haveEntry = true; + iss = _streamCache.First.Value.iss; + os = _streamCache.First.Value.os; + + _streamCache.RemoveFirst(); + } + } + } + if(!haveEntry) + { + return new OutgoingAsyncT<T>(this, completed); + } + else + { + return new OutgoingAsyncT<T>(this, completed, os, iss); + } + } + + private class InvokeOutgoingAsyncT : OutgoingAsync + { + public InvokeOutgoingAsyncT(ObjectPrxHelperBase prx, + OutgoingAsyncCompletionCallback completionCallback, + OutputStream os = null, + InputStream iss = null) : base(prx, completionCallback, os, iss) + { + } + + public void invoke(string operation, OperationMode mode, byte[] inParams, + Dictionary<string, string> context, bool synchronous) + { + try + { + prepare(operation, mode, context, synchronous); + if(inParams == null || inParams.Length == 0) + { + os_.writeEmptyEncapsulation(encoding_); + } + else + { + os_.writeEncapsulation(inParams); + } + invoke(operation); + } + catch(Exception ex) + { + abort(ex); + } + } + + public Object_Ice_invokeResult + result__(bool ok) + { + try + { + var ret__ = new Object_Ice_invokeResult(); + EncodingVersion encoding; + if(proxy_.reference__().getMode() == Reference.Mode.ModeTwoway) + { + ret__.outEncaps = is_.readEncapsulation(out encoding); + } + else + { + ret__.outEncaps = null; + } + ret__.returnValue = ok; + return ret__; + } + finally + { + cacheMessageBuffers(); + } + } + } + + public class InvokeAsyncResultCompletionCallback : ProxyAsyncResultCompletionCallback<Callback_Object_ice_invoke> + { + public InvokeAsyncResultCompletionCallback(ObjectPrxHelperBase proxy, + string operation, + object cookie, + AsyncCallback callback) : + base(proxy, operation, cookie, callback) + { + } + + override protected AsyncCallback getCompletedCallback() + { + return (AsyncResult r) => + { + Debug.Assert(r == this); + try + { + Object_Ice_invokeResult result = ((InvokeOutgoingAsyncT)outgoing_).result__(wait()); + try + { + responseCallback_?.Invoke(result.returnValue, result.outEncaps); + } + catch(Exception ex) + { + throw new AggregateException(ex); + } + } + catch(Exception ex) + { + exceptionCallback_?.Invoke(ex); + } + }; + } + }; + + private class InvokeTaskCompletionCallback : TaskCompletionCallback<Object_Ice_invokeResult> + { + public InvokeTaskCompletionCallback(IProgress<bool> progress, CancellationToken cancellationToken) : + base(progress, cancellationToken) + { + } + + public override bool handleSent(bool done, bool alreadySent) + { + if(done) + { + var result = new Object_Ice_invokeResult(); + result.returnValue = true; + SetResult(result); + } + return base.handleSent(false, alreadySent); + } + + public override bool handleResponse(bool ok, OutgoingAsyncBase og) + { + SetResult(((InvokeOutgoingAsyncT)og).result__(ok)); + return false; + } + } + + private InvokeOutgoingAsyncT + getInvokeOutgoingAsync(OutgoingAsyncCompletionCallback completed) + { + bool haveEntry = false; + InputStream iss = null; + OutputStream os = null; + + if(_reference.getInstance().cacheMessageBuffers() > 0) + { + lock(this) + { + if(_streamCache != null && _streamCache.Count > 0) + { + haveEntry = true; + iss = _streamCache.First.Value.iss; + os = _streamCache.First.Value.os; + + _streamCache.RemoveFirst(); + } + } + } + if(!haveEntry) + { + return new InvokeOutgoingAsyncT(this, completed); + } + else + { + return new InvokeOutgoingAsyncT(this, completed, os, iss); + } + } + + public void + cacheMessageBuffers(InputStream iss, OutputStream os) + { + lock(this) + { + if(_streamCache == null) + { + _streamCache = new LinkedList<StreamCacheEntry>(); + } + StreamCacheEntry cacheEntry; + cacheEntry.iss = iss; + cacheEntry.os = os; + _streamCache.AddLast(cacheEntry); + } + } + + /// <summary> + /// Only for internal use by ProxyFactory + /// </summary> + /// <param name="ref"></param> + public void setup(Reference @ref) { // // No need to synchronize, as this operation is only called // upon initial initialization. // - Debug.Assert(_reference == null); Debug.Assert(_requestHandler == null); _reference = @ref; } - private ObjectPrxHelperBase newInstance(IceInternal.Reference @ref) + private ObjectPrxHelperBase newInstance(Reference @ref) { - ObjectPrxHelperBase proxy = (ObjectPrxHelperBase)Activator.CreateInstance(GetType()); + var proxy = (ObjectPrxHelperBase)Activator.CreateInstance(GetType()); proxy.setup(@ref); return proxy; } - private IceInternal.Reference _reference; - private IceInternal.RequestHandler _requestHandler; - private IceInternal.BatchRequestQueue _batchRequestQueue; + private Reference _reference; + private RequestHandler _requestHandler; + private BatchRequestQueue _batchRequestQueue; private struct StreamCacheEntry { public InputStream iss; @@ -2527,14 +2758,14 @@ namespace Ice { try { - ObjectPrx bb = b.ice_facet(f); - bool ok = bb.ice_isA("::Ice::Object"); + var bb = b.ice_facet(f); + var ok = bb.ice_isA("::Ice::Object"); Debug.Assert(ok); ObjectPrxHelper h = new ObjectPrxHelper(); h.copyFrom__(bb); d = h; } - catch(Ice.FacetNotExistException) + catch(FacetNotExistException) { } } @@ -2558,14 +2789,14 @@ namespace Ice { try { - ObjectPrx bb = b.ice_facet(f); - bool ok = bb.ice_isA("::Ice::Object", ctx); + var bb = b.ice_facet(f); + var ok = bb.ice_isA("::Ice::Object", ctx); Debug.Assert(ok); ObjectPrxHelper h = new ObjectPrxHelper(); h.copyFrom__(bb); d = h; } - catch(Ice.FacetNotExistException) + catch(FacetNotExistException) { } } @@ -2595,8 +2826,8 @@ namespace Ice ObjectPrx d = null; if(b != null) { - ObjectPrx bb = b.ice_facet(f); - ObjectPrxHelper h = new ObjectPrxHelper(); + var bb = b.ice_facet(f); + var h = new ObjectPrxHelper(); h.copyFrom__(bb); d = h; } @@ -2611,7 +2842,7 @@ namespace Ice /// <returns>The type id, "::Ice::Object".</returns> public static string ice_staticId() { - return Ice.ObjectImpl.ice_staticId(); + return ObjectImpl.ice_staticId(); } } } diff --git a/csharp/src/Ice/RequestHandler.cs b/csharp/src/Ice/RequestHandler.cs index 37471ceec04..c334c9b246c 100644 --- a/csharp/src/Ice/RequestHandler.cs +++ b/csharp/src/Ice/RequestHandler.cs @@ -18,7 +18,7 @@ namespace IceInternal { RequestHandler update(RequestHandler previousHandler, RequestHandler newHandler); - bool sendAsyncRequest(ProxyOutgoingAsyncBase @out, out Ice.AsyncCallback cb); + int sendAsyncRequest(ProxyOutgoingAsyncBase @out); Reference getReference(); diff --git a/csharp/src/Ice/RetryQueue.cs b/csharp/src/Ice/RetryQueue.cs index f1788b49fd7..3d1bbaba137 100644 --- a/csharp/src/Ice/RetryQueue.cs +++ b/csharp/src/Ice/RetryQueue.cs @@ -41,13 +41,12 @@ namespace IceInternal { if(_instance.traceLevels().retry >= 1) { - string s = "operation retry canceled\n" + ex; - _instance.initializationData().logger.trace(_instance.traceLevels().retryCat, s); + _instance.initializationData().logger.trace(_instance.traceLevels().retryCat, + string.Format("operation retry canceled\n{0}", ex)); } - Ice.AsyncCallback cb = _outAsync.completed(ex); - if(cb != null) + if(_outAsync.exception(ex)) { - _outAsync.invokeCompletedAsync(cb); + _outAsync.invokeExceptionAsync(); } } } diff --git a/csharp/src/Ice/msbuild/ice.csproj b/csharp/src/Ice/msbuild/ice.csproj index 1733415bb67..c59d690e7a7 100644 --- a/csharp/src/Ice/msbuild/ice.csproj +++ b/csharp/src/Ice/msbuild/ice.csproj @@ -4,6 +4,10 @@ <IceBuilderCsharpProps Condition="!Exists('$(IceBuilderCsharpProps)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.props', SearchOption.AllDirectories))</IceBuilderCsharpProps> <IceBuilderCsharpTargets Condition="!Exists('$(IceBuilderCsharpTargets)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.targets', SearchOption.AllDirectories))</IceBuilderCsharpTargets> </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'"> + <DocumentationFile>..\..\..\Assemblies\Ice.XML</DocumentationFile> + <NoWarn>1591</NoWarn> + </PropertyGroup> <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> <PropertyGroup> <ProjectGuid>{7CB4715E-DD8B-48F8-B478-27B8BD4008C7}</ProjectGuid> @@ -469,6 +473,7 @@ <PropertyGroup Label="IceBuilder"> <IceBuilderIncludeDirectories>$(IceHome)\slice</IceBuilderIncludeDirectories> <IceBuilderAllowIcePrefix>yes</IceBuilderAllowIcePrefix> + <IceBuilderAdditionalOptions>--compat</IceBuilderAdditionalOptions> </PropertyGroup> <Import Project="$(IceBuilderCsharpTargets)" Condition="Exists('$(IceBuilderCsharpTargets)')" /> </Project>
\ No newline at end of file diff --git a/csharp/src/IceBox/msbuild/icebox/icebox.csproj b/csharp/src/IceBox/msbuild/icebox/icebox.csproj index c5aab43de26..610e58abb42 100644 --- a/csharp/src/IceBox/msbuild/icebox/icebox.csproj +++ b/csharp/src/IceBox/msbuild/icebox/icebox.csproj @@ -4,6 +4,10 @@ <IceBuilderCsharpProps Condition="!Exists('$(IceBuilderCsharpProps)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.props', SearchOption.AllDirectories))</IceBuilderCsharpProps> <IceBuilderCsharpTargets Condition="!Exists('$(IceBuilderCsharpTargets)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.targets', SearchOption.AllDirectories))</IceBuilderCsharpTargets> </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'"> + <DocumentationFile>..\..\..\..\bin\iceboxnet.XML</DocumentationFile> + <NoWarn>1591</NoWarn> + </PropertyGroup> <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> <PropertyGroup> <ProjectGuid>{30ED316B-AA69-4A88-A1A3-DB27A425D6BD}</ProjectGuid> @@ -55,6 +59,7 @@ <PropertyGroup Label="IceBuilder"> <IceBuilderIncludeDirectories>$(IceHome)\slice</IceBuilderIncludeDirectories> <IceBuilderAllowIcePrefix>yes</IceBuilderAllowIcePrefix> + <IceBuilderAdditionalOptions>--compat</IceBuilderAdditionalOptions> </PropertyGroup> <Import Project="$(IceBuilderCsharpTargets)" Condition="Exists('$(IceBuilderCsharpTargets)')" /> </Project>
\ No newline at end of file diff --git a/csharp/src/IceBox/msbuild/iceboxlib/iceboxlib.csproj b/csharp/src/IceBox/msbuild/iceboxlib/iceboxlib.csproj index 6da06194595..45db2dfc66f 100644 --- a/csharp/src/IceBox/msbuild/iceboxlib/iceboxlib.csproj +++ b/csharp/src/IceBox/msbuild/iceboxlib/iceboxlib.csproj @@ -4,6 +4,10 @@ <IceBuilderCsharpProps Condition="!Exists('$(IceBuilderCsharpProps)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.props', SearchOption.AllDirectories))</IceBuilderCsharpProps> <IceBuilderCsharpTargets Condition="!Exists('$(IceBuilderCsharpTargets)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.targets', SearchOption.AllDirectories))</IceBuilderCsharpTargets> </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'"> + <DocumentationFile>..\..\..\..\Assemblies\IceBox.XML</DocumentationFile> + <NoWarn>1591</NoWarn> + </PropertyGroup> <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> <PropertyGroup> <ProjectGuid>{FF25599C-3654-4DF3-8078-B8235341DF83}</ProjectGuid> @@ -43,6 +47,7 @@ <PropertyGroup Label="IceBuilder"> <IceBuilderIncludeDirectories>$(IceHome)\slice</IceBuilderIncludeDirectories> <IceBuilderAllowIcePrefix>yes</IceBuilderAllowIcePrefix> + <IceBuilderAdditionalOptions>--compat</IceBuilderAdditionalOptions> </PropertyGroup> <Import Project="$(IceBuilderCsharpTargets)" Condition="Exists('$(IceBuilderCsharpTargets)')" /> </Project>
\ No newline at end of file diff --git a/csharp/src/IceDiscovery/msbuild/icediscovery.csproj b/csharp/src/IceDiscovery/msbuild/icediscovery.csproj index 0758e6ebde6..8bdc63d7c2f 100644 --- a/csharp/src/IceDiscovery/msbuild/icediscovery.csproj +++ b/csharp/src/IceDiscovery/msbuild/icediscovery.csproj @@ -4,6 +4,10 @@ <IceBuilderCsharpProps Condition="!Exists('$(IceBuilderCsharpProps)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.props', SearchOption.AllDirectories))</IceBuilderCsharpProps> <IceBuilderCsharpTargets Condition="!Exists('$(IceBuilderCsharpTargets)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.targets', SearchOption.AllDirectories))</IceBuilderCsharpTargets> </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'"> + <DocumentationFile>..\..\..\Assemblies\IceDiscovery.XML</DocumentationFile> + <NoWarn>1591</NoWarn> + </PropertyGroup> <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> <PropertyGroup> <ProjectGuid>{CFFB222B-19D5-499E-B833-B0F7E523B16F}</ProjectGuid> @@ -52,6 +56,7 @@ <PropertyGroup Label="IceBuilder"> <IceBuilderIncludeDirectories>$(IceHome)\slice</IceBuilderIncludeDirectories> <IceBuilderAllowIcePrefix>yes</IceBuilderAllowIcePrefix> + <IceBuilderAdditionalOptions>--compat</IceBuilderAdditionalOptions> </PropertyGroup> <Import Project="$(IceBuilderCsharpTargets)" Condition="Exists('$(IceBuilderCsharpTargets)')" /> </Project>
\ No newline at end of file diff --git a/csharp/src/IceGrid/msbuild/icegrid.csproj b/csharp/src/IceGrid/msbuild/icegrid.csproj index eb856276f44..002fb61aaaf 100644 --- a/csharp/src/IceGrid/msbuild/icegrid.csproj +++ b/csharp/src/IceGrid/msbuild/icegrid.csproj @@ -4,6 +4,10 @@ <IceBuilderCsharpProps Condition="!Exists('$(IceBuilderCsharpProps)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.props', SearchOption.AllDirectories))</IceBuilderCsharpProps> <IceBuilderCsharpTargets Condition="!Exists('$(IceBuilderCsharpTargets)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.targets', SearchOption.AllDirectories))</IceBuilderCsharpTargets> </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'"> + <DocumentationFile>..\..\..\Assemblies\IceGrid.XML</DocumentationFile> + <NoWarn>1591</NoWarn> + </PropertyGroup> <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> <PropertyGroup> <ProjectGuid>{1153F70C-80E9-469A-952F-5117DAEE71A9}</ProjectGuid> @@ -76,6 +80,7 @@ <PropertyGroup Label="IceBuilder"> <IceBuilderIncludeDirectories>$(IceHome)\slice</IceBuilderIncludeDirectories> <IceBuilderAllowIcePrefix>yes</IceBuilderAllowIcePrefix> + <IceBuilderAdditionalOptions>--compat</IceBuilderAdditionalOptions> </PropertyGroup> <Import Project="$(IceBuilderCsharpTargets)" Condition="Exists('$(IceBuilderCsharpTargets)')" /> </Project>
\ No newline at end of file diff --git a/csharp/src/IceLocatorDiscovery/msbuild/icelocatordiscovery.csproj b/csharp/src/IceLocatorDiscovery/msbuild/icelocatordiscovery.csproj index 831824a572c..aaf34cdcd45 100644 --- a/csharp/src/IceLocatorDiscovery/msbuild/icelocatordiscovery.csproj +++ b/csharp/src/IceLocatorDiscovery/msbuild/icelocatordiscovery.csproj @@ -4,6 +4,10 @@ <IceBuilderCsharpProps Condition="!Exists('$(IceBuilderCsharpProps)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.props', SearchOption.AllDirectories))</IceBuilderCsharpProps> <IceBuilderCsharpTargets Condition="!Exists('$(IceBuilderCsharpTargets)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.targets', SearchOption.AllDirectories))</IceBuilderCsharpTargets> </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'"> + <DocumentationFile>..\..\..\Assemblies\IceLocatorDiscovery.XML</DocumentationFile> + <NoWarn>1591</NoWarn> + </PropertyGroup> <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> <PropertyGroup> <ProjectGuid>{8D8AA726-3A35-407B-BD38-BEA828EEE727}</ProjectGuid> @@ -46,6 +50,7 @@ <PropertyGroup Label="IceBuilder"> <IceBuilderIncludeDirectories>$(IceHome)\slice</IceBuilderIncludeDirectories> <IceBuilderAllowIcePrefix>yes</IceBuilderAllowIcePrefix> + <IceBuilderAdditionalOptions>--compat</IceBuilderAdditionalOptions> </PropertyGroup> <Import Project="$(IceBuilderCsharpTargets)" Condition="Exists('$(IceBuilderCsharpTargets)')" /> </Project>
\ No newline at end of file diff --git a/csharp/src/IcePatch2/msbuild/icepatch2.csproj b/csharp/src/IcePatch2/msbuild/icepatch2.csproj index eb02e7113d4..fc0a1ae1270 100644 --- a/csharp/src/IcePatch2/msbuild/icepatch2.csproj +++ b/csharp/src/IcePatch2/msbuild/icepatch2.csproj @@ -4,6 +4,10 @@ <IceBuilderCsharpProps Condition="!Exists('$(IceBuilderCsharpProps)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.props', SearchOption.AllDirectories))</IceBuilderCsharpProps> <IceBuilderCsharpTargets Condition="!Exists('$(IceBuilderCsharpTargets)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.targets', SearchOption.AllDirectories))</IceBuilderCsharpTargets> </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'"> + <DocumentationFile>..\..\..\Assemblies\IcePatch2.XML</DocumentationFile> + <NoWarn>1591</NoWarn> + </PropertyGroup> <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> <PropertyGroup> <ProjectGuid>{6479EE9D-5730-44BC-B564-97211E1B54C5}</ProjectGuid> @@ -47,6 +51,7 @@ <PropertyGroup Label="IceBuilder"> <IceBuilderIncludeDirectories>$(IceHome)\slice</IceBuilderIncludeDirectories> <IceBuilderAllowIcePrefix>yes</IceBuilderAllowIcePrefix> + <IceBuilderAdditionalOptions>--compat</IceBuilderAdditionalOptions> </PropertyGroup> <Import Project="$(IceBuilderCsharpTargets)" Condition="Exists('$(IceBuilderCsharpTargets)')" /> </Project>
\ No newline at end of file diff --git a/csharp/src/IceSSL/msbuild/icessl.csproj b/csharp/src/IceSSL/msbuild/icessl.csproj index 7ab53eff4e4..1f99b3021f1 100644 --- a/csharp/src/IceSSL/msbuild/icessl.csproj +++ b/csharp/src/IceSSL/msbuild/icessl.csproj @@ -4,6 +4,10 @@ <IceBuilderCsharpProps Condition="!Exists('$(IceBuilderCsharpProps)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.props', SearchOption.AllDirectories))</IceBuilderCsharpProps> <IceBuilderCsharpTargets Condition="!Exists('$(IceBuilderCsharpTargets)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.targets', SearchOption.AllDirectories))</IceBuilderCsharpTargets> </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'"> + <DocumentationFile>..\..\..\Assemblies\IceSSL.XML</DocumentationFile> + <NoWarn>1591</NoWarn> + </PropertyGroup> <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> <PropertyGroup> <ProjectGuid>{B763DADE-440B-46BC-9CC0-BF0CF9D43182}</ProjectGuid> @@ -80,6 +84,7 @@ <PropertyGroup Label="IceBuilder"> <IceBuilderIncludeDirectories>$(IceHome)\slice</IceBuilderIncludeDirectories> <IceBuilderAllowIcePrefix>yes</IceBuilderAllowIcePrefix> + <IceBuilderAdditionalOptions>--compat</IceBuilderAdditionalOptions> </PropertyGroup> <Import Project="$(IceBuilderCsharpTargets)" Condition="Exists('$(IceBuilderCsharpTargets)')" /> </Project>
\ No newline at end of file diff --git a/csharp/src/IceStorm/msbuild/icestorm.csproj b/csharp/src/IceStorm/msbuild/icestorm.csproj index 699299f35e6..92c00048f93 100644 --- a/csharp/src/IceStorm/msbuild/icestorm.csproj +++ b/csharp/src/IceStorm/msbuild/icestorm.csproj @@ -4,6 +4,10 @@ <IceBuilderCsharpProps Condition="!Exists('$(IceBuilderCsharpProps)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.props', SearchOption.AllDirectories))</IceBuilderCsharpProps> <IceBuilderCsharpTargets Condition="!Exists('$(IceBuilderCsharpTargets)')">$([System.IO.Directory]::GetFiles('$(LocalAppData)\Microsoft\VisualStudio\$(VisualStudioVersion)\Extensions', 'IceBuilder.Csharp.targets', SearchOption.AllDirectories))</IceBuilderCsharpTargets> </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'"> + <DocumentationFile>..\..\..\Assemblies\IceStorm.XML</DocumentationFile> + <NoWarn>1591</NoWarn> + </PropertyGroup> <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> <PropertyGroup> <ProjectGuid>{A77D65F6-31CF-4BFD-A7DF-E7F509B98573}</ProjectGuid> @@ -47,6 +51,7 @@ <PropertyGroup Label="IceBuilder"> <IceBuilderIncludeDirectories>$(IceHome)\slice</IceBuilderIncludeDirectories> <IceBuilderAllowIcePrefix>yes</IceBuilderAllowIcePrefix> + <IceBuilderAdditionalOptions>--compat</IceBuilderAdditionalOptions> </PropertyGroup> <Import Project="$(IceBuilderCsharpTargets)" Condition="Exists('$(IceBuilderCsharpTargets)')" /> </Project>
\ No newline at end of file |