Developer forum

Hi Nicolai

Thanks for the answer.

Wouldn't that limit for only one order to be handled at a time?

But if it's the best solution for right now, then that will have to do.

Hi Michael

Yes it would. So of course it is a problem if your order processing takes time.

But it is 2 incoming requests from different endpoints - so you need a way to tell the difference. You could change the behavior of my suggestion to have the synclock in the OnNotify method and if the OrderID is in the dictionary return from the method. So the synclock will not be encapsulating the actual order processing, but just the check on the dictionary. You might not even need the synclock if you are using a concurrent dictionary.

BR Nicolai

For anyone else, who this might help, this is the solution we went with

public class ExportedOrderCollection
{
        private static ConcurrentDictionary _instance;

        public ExportedOrderCollection()
        {
            if (_instance == null)
            {
                _instance = new ConcurrentDictionary();
            }
        }

        //Will return true if this order is exported.
        public bool IsAlradyExported(Order order)
        {
            if (_instance.TryAdd(order.ID, order))
            {
                //2min in ms
                Timer timer = new Timer(2*60*1000){
                    AutoReset = false
                };
                timer.Elapsed += (sender, args) => {
                    Order trash;
                    _instance.TryRemove(order.ID, out trash);
                    timer.Dispose();
                };
                timer.Start();
                return false;
            }

            return true;
        }
}

private void OrderComplete(Order dwOrder)
{
            ExportedOrderCollection alreadyExported = new ExportedOrderCollection();
            if (alreadyExported.IsAlradyExported(dwOrder))
            {
                return;
            }
(...)
} 

Nice.

Thanks for sharing!