C# Request.Execute方法代码示例

        /// <summary>
        /// Create a CarrierAccount.
        /// </summary>
        /// <param name="parameters">
        /// Optional dictionary containing parameters to create the carrier account with. Valid pairs:
        ///   * {"type", string} Required (e.g. EndiciaAccount, UPSAccount, etc.).
        ///   * {"reference", string} External reference for carrier account.
        ///   * {"description", string} Description of carrier account.
        ///   * {"credentials", Dictionary<string, string>}
        ///   * {"test_credentials", Dictionary<string, string>}
        /// All invalid keys will be ignored.
        /// </param>
        /// <returns>EasyPost.CarrierAccount instance.</returns>
        public static CarrierAccount Create(IDictionary<string, object> parameters)
        {
            Request request = new Request("carrier_accounts", Method.POST);
            request.addBody(parameters, "carrier_account");

            return request.Execute<CarrierAccount>();
        }

        /// <summary>
        /// Retrieve a Item from a custom reference.
        /// </summary>
        /// <param name="name">String containing the name of the custom reference to search for.</param>
        /// <param name="value">String containing the value of the custom reference to search for.</param>
        /// <returns>EasyPost.Item instance.</returns>
        public static Item RetrieveReference(string name, string value) {
            Request request = new Request("items/retrieve_reference/?{name}={value}");
            request.AddUrlSegment("name", name);
            request.AddUrlSegment("value", value);

            return request.Execute<Item>();
        }

        /// <summary>
        /// Create a Parcel.
        /// </summary>
        /// <param name="parameters">
        /// Dictionary containing parameters to create the parcel with. Valid pairs:
        ///   * {"length", int}
        ///   * {"width", int}
        ///   * {"height", int}
        ///   * {"weight", double}
        ///   * {"predefined_package", string}
        /// All invalid keys will be ignored.
        /// </param>
        /// <returns>EasyPost.Parcel instance.</returns>
        public static Parcel Create(IDictionary<string, object> parameters)
        {
            Request request = new Request("parcels", Method.POST);
            request.addBody(parameters, "parcel");

            return request.Execute<Parcel>();
        }

        /// <summary>
        /// Create a Batch.
        /// </summary>
        /// <param name="parameters">
        /// Optional dictionary containing parameters to create the batch with. Valid pairs:
        ///   * {"shipments", List<Dictionary<string, object>>} See Shipment.Create for a list of valid keys.
        ///   * {"reference", string}
        /// All invalid keys will be ignored.
        /// </param>
        /// <returns>EasyPost.Batch instance.</returns>
        public static Batch Create(IDictionary<string, object> parameters = null) {
            parameters = parameters ?? new Dictionary<string, object>();

            Request request = new Request("batches", Method.POST);
            request.AddBody(parameters, "batch");

            return request.Execute<Batch>();
        }

        /// <summary>
        /// Add shipments to the batch.
        /// </summary>
        /// <param name="shipmentIds">List of shipment ids to be added.</param>
        public void AddShipments(IEnumerable<string> shipmentIds) {
            Request request = new Request("batches/{id}/add_shipments", Method.POST);
            request.AddUrlSegment("id", id);

            List<Dictionary<string, object>> body = shipmentIds.Select(shipmentId => new Dictionary<string, object>() { { "id", shipmentId } }).ToList();
            request.AddBody(body, "shipments");

            this.Merge(request.Execute<Batch>());
        }

        public static Tracker Create(string carrier, string trackingCode) {
            Request request = new Request("trackers", RestSharp.Method.POST);
            Dictionary<string, object> parameters = new Dictionary<string, object>() { 
                { "tracking_code", trackingCode }, { "carrier", carrier }
            };

            request.addBody(parameters, "tracker");

            return request.Execute<Tracker>();
        }

        public void ShouldDeserializePostJsonToObject()
        {
            var request = new Request();
            var user = new User {username = "Bob",password = "password"};

            var response = (Httpresponse)request.Execute<Httpresponse>("http://localhost:1234/",user,"POST");

            Console.WriteLine(response.Statuscode);
            Console.WriteLine(response.Location);

            Assert.IsNotNull(response);
        }

        public void ShouldDeserializeJsonToObjectFromConstructor()
        {
            var request = new Request("http://localhost:1234/","GET");
            var response = (Httpresponse)request.Execute<Httpresponse>();

            Console.WriteLine(response.Statuscode);
            Console.WriteLine(response.Location);

            Assert.IsNotNull(response);
            Assert.IsNotEmpty(response.Statuscode.ToString());
            Assert.AreEqual(200, response.Statuscode);
        }

        public void ShouldDeserializeJsonToString()
        {
            var request = new Request();
            request.Verb = "GET";
            request.URL = "http://localhost:1234/";

            var response = request.Execute();

            Console.WriteLine(response);

            Assert.IsNotNull(response);
            Assert.IsNotEmpty((string) response);
        }

        public void Should_deserialize_Twitter_response()
        {
            var request = new Request { URL = "http://search.twitter.com/search.json?q=brazil&rpp=5&include_entities=true&result_type=mixed" };

            var response = (SearchResults)request.Execute<SearchResults>();

            Assert.IsNotNull(response);

            foreach (SearchResult r in response.results)
            {
                Console.WriteLine("From User: " + r.from_user);
                Console.WriteLine("Created At: " + r.created_at);
                Console.WriteLine("Twitt Text: " + r.text + "\n");
            }
        }

        /// <summary>
        /// Retrieve a Order from its id or reference.
        /// </summary>
        /// <param name="id">String representing a Order. Starts with "order_" if passing an id.</param>
        /// <returns>EasyPost.Order instance.</returns>
        public static Order Retrieve(string id)
        {
            Request request = new Request("orders/{id}");
            request.AddUrlSegment("id", id);

            return request.Execute<Order>();
        }

        /// <summary>
        /// Cancel this pickup.
        /// </summary>
        public void Cancel() {
            Request request = new Request("pickups/{id}/cancel", Method.POST);
            request.AddUrlSegment("id", id);

            this.Merge(request.Execute<Pickup>());
        }

        private static Pickup sendCreate(IDictionary<string, object> parameters) {
            Request request = new Request("pickups", Method.POST);
            request.AddBody(parameters, "pickup");

            return request.Execute<Pickup>();
        }

        /// <summary>
        /// Retrieve a Pickup from its id.
        /// </summary>
        /// <param name="id">String representing a Pickup. Starts with "pickup_".</param>
        /// <returns>EasyPost.Pickup instance.</returns>
        public static Pickup Retrieve(string id) {
            Request request = new Request("pickups/{id}");
            request.AddUrlSegment("id", id);

            return request.Execute<Pickup>();
        }

        /// <summary>
        /// Asynchronously generate a label containing all of the Shimpent labels belonging to the batch.
        /// </summary>
        /// <param name="fileFormat">Format to generate the label in. Valid formats: "pdf", "zpl" and "epl2".</param>
        /// <param name="orderBy">Optional parameter to order the generated label. Ex: "reference DESC"</param>
        public void GenerateLabel(string fileFormat, string orderBy = null)
        {
            Request request = new Request("batches/{id}/label", Method.POST);
            request.AddUrlSegment("id", id);

            List<Tuple<string, string>> body = new List<Tuple<string, string>>() {
                new Tuple<string, string>("file_format", fileFormat)
            };

            if (orderBy != null)
                body.Add(new Tuple<string, string>("order_by", orderBy));

            request.addBody(body);
            this.Merge(request.Execute<Batch>());
        }