private AbortMultipartUploadCommand(IServiceClient client, Uri endpoint, ExecutionContext context, 
                                     AbortMultipartUploadRequest abortMultipartUploadRequest)
     : base(client, endpoint, context)
     
 {
     _abortMultipartUploadRequest = abortMultipartUploadRequest;
 }

 /// <summary>Initializes a new instance of the <see cref="BuildService"/> class.</summary>
 /// <param name="serviceClient">The service client.</param>
 /// <param name="converterForBuild">The converter for <see cref="Build"/>.</param>
 internal BuildService(IServiceClient serviceClient, IConverter<BuildDataContract, Build> converterForBuild)
 {
     Debug.Assert(serviceClient != null, "serviceClient != null");
     Debug.Assert(converterForBuild != null, "converterForBuild != null");
     this.serviceClient = serviceClient;
     this.converterForBuild = converterForBuild;
 }

        public ModCommand(IServiceClient serviceClient)
            : base("mod")
        {
            this.serviceClient = serviceClient;

             RegisterCommand(new ListCommand(serviceClient));
        }

 private SetObjectAclCommand(IServiceClient client, Uri endpoint, 
                             ExecutionContext context,
                             SetObjectAclRequest request)
     : base(client, endpoint, context)
 {
     _request = request;
 }

 private CreateBucketCommand(IServiceClient client, Uri endpoint, ExecutionContext context,
                             string bucketName)
     : base(client, endpoint, context)
 {
     OssUtils.CheckBucketName(bucketName);
     _bucketName = bucketName;
 }

 public static SetObjectAclCommand Create(IServiceClient client, Uri endpoint, 
                                          ExecutionContext context,
                                          SetObjectAclRequest request)
 {
     OssUtils.CheckBucketName(request.BucketName);
     OssUtils.CheckObjectKey(request.Key);
     return new SetObjectAclCommand(client, endpoint, context, request);
 }

        /// <summary>Initializes a new instance of the <see cref="RenderService"/> class.</summary>
        /// <param name="serviceClient">The service client.</param>
        /// <exception cref="ArgumentNullException">The value of <paramref name="serviceClient"/> is a null reference.</exception>
        public RenderService(IServiceClient serviceClient)
        {
            if (serviceClient == null)
            {
                throw new ArgumentNullException("serviceClient", "Precondition: serviceClient != null");
            }

            this.serviceClient = serviceClient;
        }

        /// <summary>Initializes a new instance of the <see cref="FactoryBase"/> class.</summary>
        /// <param name="serviceClient"></param>
        /// <exception cref="ArgumentNullException">The value of <paramref name="serviceClient"/> is a null reference.</exception>
        protected FactoryBase(IServiceClient serviceClient)
        {
            if (serviceClient == null)
            {
                throw new ArgumentNullException("serviceClient", "Precondition failed: serviceClient != null");
            }

            this.serviceClient = serviceClient;
        }

        /// <summary>Initializes a new instance of the <see cref="MapRepositoryFactory"/> class.</summary>
        /// <param name="serviceClient">The service client.</param>
        public MapRepositoryFactory(IServiceClient serviceClient)
        {
            if (serviceClient == null)
            {
                throw new ArgumentNullException("serviceClient", "Precondition: serviceClient != null");
            }

            this.serviceClient = serviceClient;
        }

        /// <summary>Initializes a new instance of the <see cref="MapNameRepositoryFactory"/> class.</summary>
        /// <param name="serviceClient"></param>
        public MapNameRepositoryFactory(IServiceClient serviceClient)
        {
            if (serviceClient == null)
            {
                throw new ArgumentNullException("serviceClient");
            }

            this.serviceClient = serviceClient;
        }

        private SetBucketAclCommand(IServiceClient client, Uri endpoint, ExecutionContext context,
                                    string bucketName, SetBucketAclRequest request)
            : base(client, endpoint, context)
        {
            OssUtils.CheckBucketName(bucketName);

            _bucketName = bucketName;
            _request = request;
        }

        public Model(IServiceClient serviceClient)
        {
            if (serviceClient == null)
            {
                throw new ArgumentNullException("serviceClient");
            }

            _serviceClient = serviceClient;
        }

        private DeleteObjectCommand(IServiceClient client, Uri endpoint, ExecutionContext context,
                                    string bucketName, string key)
            : base(client, endpoint, context)
        {
            OssUtils.CheckBucketName(bucketName);
            OssUtils.CheckObjectKey(key);

            _bucketName = bucketName;
            _key = key;
        }

        public void Async_Call_HelloWorld_with_ServiceClients_on_PreDefined_Routes(IServiceClient client)
        {
            HelloResponse response = null;
            client.SendAsync<HelloResponse>(new Hello { Name = "World!" },
                r => response = r, (r, e) => Assert.Fail("NetworkError"));

            Thread.Sleep(TimeSpan.FromSeconds(1));

            Assert.That(response.Result, Is.EqualTo("Hello, World!"));
        }

 public static AbortMultipartUploadCommand Create(IServiceClient client, Uri endpoint, ExecutionContext context,
                                          AbortMultipartUploadRequest abortMultipartUploadRequest)
 {
     OssUtils.CheckBucketName(abortMultipartUploadRequest.BucketName);
     OssUtils.CheckObjectKey(abortMultipartUploadRequest.Key);
     
     if (string.IsNullOrEmpty(abortMultipartUploadRequest.UploadId))
         throw new ArgumentException(Resources.ExceptionIfArgumentStringIsNullOrEmpty, "uploadId");          
     
     return new AbortMultipartUploadCommand(client, endpoint, context, abortMultipartUploadRequest);
 }

        public void Async_Call_HelloWorld_with_Async_ServiceClients_on_UserDefined_Routes(IServiceClient client)
        {
            HelloResponse response = null;
            client.GetAsync<HelloResponse>("/hello/World!",
                r => response = r, (r, e) => Assert.Fail("NetworkError"));

            var i = 0;
            while (response == null && i++ < 5)
                Thread.Sleep(TimeSpan.FromSeconds(1));

            Assert.That(response.Result, Is.EqualTo("Hello, World!"));
        }

 private static void GetStatus(IServiceClient client)
 {
     client.GetAsync(new StatusRequest(),
     (r) =>
     {
       Console.WriteLine("Result of status:" + r.Dump());
     }, (r, e) =>
     {
       Console.WriteLine("Error adding:" + e.Dump());
     });
       Wait();
 }

        private SetBucketLoggingCommand(IServiceClient client, Uri endpoint, ExecutionContext context,
                                    string bucketName, SetBucketLoggingRequest setBucketLoggingRequest)
            : base(client, endpoint, context)
        {
            OssUtils.CheckBucketName(setBucketLoggingRequest.BucketName);
            OssUtils.CheckBucketName(setBucketLoggingRequest.TargetBucket);

            if (!OssUtils.IsLoggingPrefixValid(setBucketLoggingRequest.TargetPrefix))
                throw new ArgumentException("Invalid logging prefix " + setBucketLoggingRequest.TargetPrefix);

            _bucketName = bucketName;
            _setBucketLoggingRequest = setBucketLoggingRequest;
        }

 private static void PuSegmentMatcher(IServiceClient client, string segment)
 {
     client.PutAsync(new SegmentMatcherRequest()
       {
     SegmentMatcher = segment,
       }, (r) =>
       {
     Console.WriteLine("Result of add:" + r.Success);
       }, (r, e) =>
       {
     Console.WriteLine("Error adding:" + e.Dump());
       });
       Wait();
 }

 public static Manager GetInstance(ISQLitePlatform plataform, IServiceClient client, string path)
 {
     if (_instance == null)
     {
         lock (_mutex)
         {
             if (_instance == null)
             {
                 _instance = new Manager(plataform, client, path);
             }
         }
     }
     return _instance;
 }