linux-packaging-mono/mcs/class/referencesource/System.ServiceModel.Discovery/System/ServiceModel/Discovery/ResolveRequestResponseAsyncResult.cs

//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//----------------------------------------------------------------

namespace System.ServiceModel.Discovery
{
    using System.Diagnostics.CodeAnalysis;
    using System.Runtime;
    
    abstract class ResolveRequestResponseAsyncResult<TResolveMessage, TResponseMessage> : AsyncResult
    {
        readonly ResolveCriteria resolveCriteria;
        readonly IDiscoveryServiceImplementation discoveryServiceImpl;
        readonly DiscoveryOperationContext context;
        static AsyncCompletion onOnResolveCompletedCallback = new AsyncCompletion(OnOnResolveCompleted);

        EndpointDiscoveryMetadata matchingEndpoint;

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]
        protected ResolveRequestResponseAsyncResult(
            TResolveMessage resolveMessage,
            IDiscoveryServiceImplementation discoveryServiceImpl,
            AsyncCallback callback,
            object state)
            : base(callback, state)
        {
            Fx.Assert(resolveMessage != null, "The resolveMessage must be non null.");
            Fx.Assert(discoveryServiceImpl != null, "The discoveryServiceImpl must be non null.");

            this.discoveryServiceImpl = discoveryServiceImpl;

            if (!this.Validate(resolveMessage))
            {
                this.Complete(true);
                return;
            }
            else
            {
                this.context = new DiscoveryOperationContext(OperationContext.Current);
                this.resolveCriteria = this.GetResolveCriteria(resolveMessage);
                if (this.ProcessResolveRequest())
                {
                    this.Complete(true);
                    return;
                }
            }
        }

        protected DiscoveryOperationContext Context
        {
            get
            {
                return this.context;
            }
        }

        protected virtual bool Validate(TResolveMessage resolveMessage)
        {
            return (DiscoveryService.EnsureMessageId() &&
                this.ValidateContent(resolveMessage) &&
                this.EnsureNotDuplicate());
        }

        protected abstract bool ValidateContent(TResolveMessage resolveMessage);

        protected abstract ResolveCriteria GetResolveCriteria(TResolveMessage resolveMessage);

        protected abstract TResponseMessage GetResolveResponse(
            DiscoveryMessageSequence discoveryMessageSequence,
            EndpointDiscoveryMetadata matchingEndpoints);

        protected TResponseMessage End()
        {
            this.context.AddressRequestResponseMessage(OperationContext.Current);

            return this.GetResolveResponse(
                this.discoveryServiceImpl.GetNextMessageSequence(),
                this.matchingEndpoint);
        }

        static bool OnOnResolveCompleted(IAsyncResult result)
        {
            ResolveRequestResponseAsyncResult<TResolveMessage, TResponseMessage> thisPtr =
                (ResolveRequestResponseAsyncResult<TResolveMessage, TResponseMessage>)result.AsyncState;

            thisPtr.matchingEndpoint = thisPtr.discoveryServiceImpl.EndResolve(result);
            return true;
        }

        bool ProcessResolveRequest()
        {
            IAsyncResult result = this.discoveryServiceImpl.BeginResolve(
                this.resolveCriteria,
                this.PrepareAsyncCompletion(onOnResolveCompletedCallback),
                this);

            return (result.CompletedSynchronously && OnOnResolveCompleted(result));
        }

        bool EnsureNotDuplicate()
        {
            bool isDuplicate = this.discoveryServiceImpl.IsDuplicate(OperationContext.Current.IncomingMessageHeaders.MessageId);

            if (isDuplicate && TD.DuplicateDiscoveryMessageIsEnabled())
            {
                TD.DuplicateDiscoveryMessage(
                    this.context.EventTraceActivity,
                    ProtocolStrings.TracingStrings.Resolve,
                    OperationContext.Current.IncomingMessageHeaders.MessageId.ToString());
            }

            return !isDuplicate;
        }
    }
}