public object GetLookups(LookupAction actionOption, params object[] param)
        {
            string result      = string.Empty;
            string paramValues = string.Empty;

            try
            {
                if (param != null)
                {
                    paramValues = String.Join("/", param);
                }


                var uri = new Uri(String.Format(Config.BASE_SERVICE_URL + actionOption.Url + paramValues, string.Empty));
                httpClient.Timeout = new TimeSpan(0, 20, 20);
                response           = httpClient.GetAsync(uri).Result;
                if (response.IsSuccessStatusCode)
                {
                    JsonSerializerSettings serSettings = new JsonSerializerSettings();
                    serSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
                    result = response.Content.ReadAsStringAsync().Result;
                }
                return(result);
            }
            catch
            {
                //handler.HandleServiceResults(null, false, ex.Message);

                return(null);
            }
        }
示例#2
0
 public unsafe static extern int ReceiveMessageByLookupId(
     QueueHandle handle,
     long lookupId,
     LookupAction action,
     MQPROPS properties,
     NativeOverlapped *overlapped,
     ReceiveCallback receiveCallback,
     ITransaction transaction); //MSMQ internal transaction
示例#3
0
        /// <summary>Tries to peek (or receive) a message using the queue-specific <paramref name="lookupId"/></summary>
        /// <remarks>Within a transaction you cannot receive a message that you moved to a subqueue within the same transaction</remarks>
        /// <param name="properties">The properties to read</param>
        /// <param name="lookupId">The <see cref="Message.LookupId"/> of the message to read</param>
        /// <param name="action">Receive or peek a message?</param>
        /// <param name="timeout">The time allowed, defaults to infinite.  Use <see cref="TimeSpan.Zero"/> to return without waiting</param>
        /// <param name="transaction">can be NULL for no transaction, a <see cref="QueueTransaction"/>, <see cref="QueueTransaction.Single"/>, or <see cref="QueueTransaction.Dtc"/>.</param>
        /// <returns>The message, or NULL if the message was not found or the receive times out</returns>
        public unsafe Message Lookup(Properties properties, long lookupId, LookupAction action = LookupAction.ReceiveCurrent, TimeSpan?timeout = null, QueueTransaction transaction = null)
        {
            if (IsClosed)
            {
                throw new ObjectDisposedException(nameof(Queue));
            }

            uint timeoutMS = TimeoutInMs(timeout);
            var  msg       = new Message();
            int  res;

            msg.Props.SetForRead(properties);
            for (;;) // loop because we might need to adjust memory size
            {
                var props = msg.Props.Allocate();
                try
                {
                    IntPtr txnHandle;
                    if (transaction.TryGetHandle(out txnHandle))
                    {
                        res = Native.ReceiveMessageByLookupId(_handle, lookupId, action, props, null, null, txnHandle);
                    }
                    else
                    {
                        res = Native.ReceiveMessageByLookupId(_handle, lookupId, action, props, null, null, transaction.InternalTransaction);
                    }
                }
                finally
                {
                    msg.Props.Free();
                }

                if ((ErrorCode)res == ErrorCode.IOTimeout || (ErrorCode)res == ErrorCode.MessageNotFound)
                {
                    return(null);
                }

                if (Native.NotEnoughMemory(res))
                {
                    msg.Props.IncreaseBufferSize();
                    continue; // try again
                }

                if (Native.IsError(res))
                {
                    throw new QueueException(res);
                }

                msg.Props.ResizeBody();
                return(msg);
            }
        }
        protected void RouteBatchCore(List <Tracking> sent, QueueTransaction txn)
        {
            long         lookupId = 0;
            LookupAction action   = LookupAction.PeekFirst;

            for (int i = 0; i < MaxBatchSize; i++)
            {
                // peek for the next message
                var msg = _input.Lookup(Properties.All, lookupId, action, TimeSpan.Zero);
                if (msg == null)
                {
                    break;
                }
                action   = LookupAction.PeekNext;
                lookupId = msg.LookupId;

                // move to the batch subqueue so we know what we sent
                Queues.MoveMessage(_input, _batchQueue, msg.LookupId, txn);

                // route to message to the destination
                var dest = GetRoute(msg);
                sent.Add(Sender.RequestDelivery(msg, dest, txn));
            }
        }
 public Message Lookup(Properties properties, long lookupId, QueueTransaction transaction, LookupAction action = LookupAction.ReceiveCurrent, TimeSpan?timeout = null)
 {
     Contract.Requires(transaction != null);
     return(_high.Lookup(properties, lookupId, action, timeout, transaction) ?? _low.Lookup(properties, lookupId, action, timeout, transaction));
 }