MobileAuthorizeStart(MobileAuthorizeStartRequest Request)

        {
            #region Initial checks

            if (Request == null)
            {
                throw new ArgumentNullException(nameof(Request), "The given MobileAuthorizeStart request must not be null!");
            }

            Request = _CustomMobileAuthorizeStartRequestMapper(Request);

            if (Request == null)
            {
                throw new ArgumentNullException(nameof(Request), "The mapped MobileAuthorizeStart request must not be null!");
            }


            HTTPResponse <MobileAuthorizationStart> result = null;

            #endregion

            #region Send OnMobileAuthorizeStartRequest event

            var StartTime = DateTime.UtcNow;

            try
            {
                if (OnMobileAuthorizeStartRequest != null)
                {
                    await Task.WhenAll(OnMobileAuthorizeStartRequest.GetInvocationList().
                                       Cast <OnMobileAuthorizeStartRequestHandler>().
                                       Select(e => e(StartTime,
                                                     Request.Timestamp.Value,
                                                     this,
                                                     ClientId,
                                                     Request.EventTrackingId,
                                                     Request.EVSEId,
                                                     Request.QRCodeIdentification,
                                                     Request.PartnerProductId,
                                                     Request.GetNewSession,
                                                     Request.RequestTimeout ?? RequestTimeout.Value))).
                    ConfigureAwait(false);
                }
            }
            catch (Exception e)
            {
                e.Log(nameof(MobileClient) + "." + nameof(OnMobileAuthorizeStartRequest));
            }

            #endregion


            using (var _OICPClient = new SOAPClient(Hostname,
                                                    URLPathPrefix + MobileAuthorizationURL,
                                                    VirtualHostname,
                                                    RemotePort,
                                                    RemoteCertificateValidator,
                                                    ClientCertificateSelector,
                                                    UserAgent,
                                                    RequestTimeout,
                                                    DNSClient))

            {
                result = await _OICPClient.Query(_CustomMobileAuthorizeStartSOAPRequestMapper(Request,
                                                                                              SOAP.Encapsulation(Request.ToXML(CustomMobileAuthorizeStartRequestSerializer))),
                                                 "eRoamingMobileAuthorizeStart",
                                                 RequestLogDelegate :   OnMobileAuthorizeStartSOAPRequest,
                                                 ResponseLogDelegate :  OnMobileAuthorizeStartSOAPResponse,
                                                 CancellationToken :    Request.CancellationToken,
                                                 EventTrackingId :      Request.EventTrackingId,
                                                 RequestTimeout :         Request.RequestTimeout ?? RequestTimeout.Value,

                                                 #region OnSuccess

                                                 OnSuccess : XMLResponse => XMLResponse.ConvertContent(Request,
                                                                                                       (request, xml, onexception) =>
                                                                                                       MobileAuthorizationStart.Parse(request,
                                                                                                                                      xml,
                                                                                                                                      CustomMobileAuthorizationStartParser,
                                                                                                                                      CustomAddressParser,
                                                                                                                                      CustomStatusCodeParser,
                                                                                                                                      onexception)),

                                                 #endregion

                                                 #region OnSOAPFault

                                                 OnSOAPFault : (timestamp, soapclient, httpresponse) => {
                    SendSOAPError(timestamp, soapclient, httpresponse.Content);

                    return(new HTTPResponse <MobileAuthorizationStart>(httpresponse,
                                                                       new MobileAuthorizationStart(
                                                                           Request,
                                                                           StatusCodes.SystemError,
                                                                           httpresponse.Content.ToString()
                                                                           ),
                                                                       IsFault: true));
                },

                                                 #endregion

                                                 #region OnHTTPError

                                                 OnHTTPError : (timestamp, soapclient, httpresponse) => {
                    SendHTTPError(timestamp, soapclient, httpresponse);

                    return(new HTTPResponse <MobileAuthorizationStart>(httpresponse,
                                                                       new MobileAuthorizationStart(
                                                                           Request,
                                                                           StatusCodes.SystemError,
                                                                           httpresponse.HTTPStatusCode.ToString(),
                                                                           httpresponse.HTTPBody.ToUTF8String()
                                                                           ),
                                                                       IsFault: true));
                },

                                                 #endregion

                                                 #region OnException

                                                 OnException : (timestamp, sender, exception) => {
                    SendException(timestamp, sender, exception);

                    return(HTTPResponse <MobileAuthorizationStart> .ExceptionThrown(new MobileAuthorizationStart(
                                                                                        Request,
                                                                                        StatusCodes.SystemError,
                                                                                        exception.Message,
                                                                                        exception.StackTrace
                                                                                        ),
                                                                                    Exception: exception));
                }

                                                 #endregion

                                                 ).ConfigureAwait(false);
            }

            if (result == null)
            {
                result = HTTPResponse <MobileAuthorizationStart> .ClientError(
                    new MobileAuthorizationStart(
                        Request,
                        StatusCodes.SystemError,
                        "HTTP request failed!"
                        )
                    );
            }


            #region Send OnMobileAuthorizeStartResponse event

            var Endtime = DateTime.UtcNow;

            try
            {
                if (OnMobileAuthorizeStartResponse != null)
                {
                    await Task.WhenAll(OnMobileAuthorizeStartResponse.GetInvocationList().
                                       Cast <OnMobileAuthorizeStartResponseHandler>().
                                       Select(e => e(Endtime,
                                                     Request.Timestamp.Value,
                                                     this,
                                                     ClientId,
                                                     Request.EventTrackingId,
                                                     Request.EVSEId,
                                                     Request.QRCodeIdentification,
                                                     Request.PartnerProductId,
                                                     Request.GetNewSession,
                                                     Request.RequestTimeout ?? RequestTimeout.Value,
                                                     result.Content,
                                                     Endtime - StartTime))).
                    ConfigureAwait(false);
                }
            }
            catch (Exception e)
            {
                e.Log(nameof(MobileClient) + "." + nameof(OnMobileAuthorizeStartResponse));
            }

            #endregion

            return(result);
        }