Example #1
0
 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;
 }
Example #2
0
        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);
        }
Example #3
0
        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);
        }
Example #4
0
        public AsyncResult begin_flushBatchRequests(Ice.CompressBatch compressBatch, AsyncCallback cb, object cookie)
        {
            var result = new CommunicatorFlushBatchCompletionCallback(this,
                                                                      _instance,
                                                                      _flushBatchRequests_name,
                                                                      cookie,
                                                                      cb);
            var outgoing = new CommunicatorFlushBatchAsync(_instance, result);

            outgoing.invoke(_flushBatchRequests_name, compressBatch, false);
            return(result);
        }
Example #5
0
        public void flushAsyncBatchRequests(Ice.CompressBatch compressBatch, CommunicatorFlushBatchAsync outAsync)
        {
            List <Ice.ObjectAdapterI> adapters;

            lock (this)
            {
                adapters = new List <Ice.ObjectAdapterI>(_adapters);
            }

            foreach (Ice.ObjectAdapterI adapter in adapters)
            {
                adapter.flushAsyncBatchRequests(compressBatch, outAsync);
            }
        }
Example #6
0
        public void flushAsyncBatchRequests(CommunicatorFlushBatchAsync outAsync)
        {
            List <IncomingConnectionFactory> f;

            lock (this)
            {
                f = new List <IncomingConnectionFactory>(_incomingConnectionFactories);
            }

            foreach (IncomingConnectionFactory factory in f)
            {
                factory.flushAsyncBatchRequests(outAsync);
            }
        }
Example #7
0
 public void flushBatchRequests(Ice.CompressBatch compressBatch)
 {
     try
     {
         var completed = new FlushBatchTaskCompletionCallback();
         var outgoing  = new CommunicatorFlushBatchAsync(_instance, completed);
         outgoing.invoke(_flushBatchRequests_name, compressBatch, true);
         completed.Task.Wait();
     }
     catch (AggregateException ex)
     {
         throw ex.InnerException;
     }
 }
Example #8
0
        public void flushAsyncBatchRequests(CommunicatorFlushBatchAsync outAsync)
        {
            List<IncomingConnectionFactory> f;
            lock(this)
            {
                f = new List<IncomingConnectionFactory>(_incomingConnectionFactories);
            }

            foreach(IncomingConnectionFactory factory in f)
            {
                factory.flushAsyncBatchRequests(outAsync);
            }
        }
Example #9
0
 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;
 }
Example #10
0
        public void flushAsyncBatchRequests(CommunicatorFlushBatchAsync outAsync)
        {
            List<Ice.ObjectAdapterI> adapters;
            lock(this)
            {
                adapters = new List<Ice.ObjectAdapterI>(_adapters);
            }

            foreach(Ice.ObjectAdapterI adapter in adapters)
            {
                adapter.flushAsyncBatchRequests(outAsync);
            }
        }