private static MediaTypeFormatterCollection GetFormatters(IEnumerable<MediaTypeFormatter> formatters)
 {
     var mediaTypeFormatters = new MediaTypeFormatterCollection();
     foreach(var formatter in formatters)
         mediaTypeFormatters.Add(formatter);
     return mediaTypeFormatters;
 }

        private static void TestWebApi()
        {
            Console.WriteLine();
            Console.WriteLine("------------------------------------------------------------");
            Console.WriteLine("Web API");
            Console.WriteLine("------------------------------------------------------------");

            var client = new HttpClient {BaseAddress = new Uri("http://localhost:14851/")};

            client.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/json"));

            var mediaTypeFormatterCollection = new MediaTypeFormatterCollection();
            ExecuteAction(NumberOfRequestsToSend + " requests to api/item/id", () =>
            {
                for (int i = 0; i < NumberOfRequestsToSend; i++)
                {
                    var response = client.GetAsync("api/item/" + Guid.NewGuid()).Result;
                    if (response.IsSuccessStatusCode)
                    {
                        var item = response.Content.ReadAsAsync<Item>(mediaTypeFormatterCollection).Result;
                        if (item == null)
                            throw new Exception("Item not received.");
                        //Console.WriteLine("ItemID\t\t{0}\nDescription\t{1}\nModifiedAt\t{2}", item.ItemID, item.Description, item.ModifiedAt);
                    }
                    else
                    {
                        Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
                    }
                }
            });
        }

 public void Constructor1_SetsDerivedFormatters()
 {
     // force to array to get stable instances
     MediaTypeFormatter[] derivedFormatters = HttpTestData.DerivedFormatters.ToArray();
     MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(derivedFormatters);
     Assert.True(derivedFormatters.SequenceEqual(collection));
 }

        public static void ConfigureFormatters(MediaTypeFormatterCollection formatters)
        {
            formatters.Remove(formatters.XmlFormatter);

            JsonSerializerSettings settings = formatters.JsonFormatter.SerializerSettings;
            settings.Formatting = Formatting.None;
        }

        public void Constructor1SetsProperties()
        {
            // All combination of formatters presented to ctor should still set XmlFormatter
            foreach (IEnumerable<MediaTypeFormatter> formatterCollection in HttpUnitTestDataSets.AllFormatterCollections)
            {
                MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(formatterCollection);
                if (collection.OfType<XmlMediaTypeFormatter>().Any())
                {
                    Assert.NotNull(collection.XmlFormatter);
                }
                else
                {
                    Assert.Null(collection.XmlFormatter);
                }

                if (collection.OfType<JsonMediaTypeFormatter>().Any())
                {
                    Assert.NotNull(collection.JsonFormatter);
                }
                else
                {
                    Assert.Null(collection.JsonFormatter);
                }
            }
        }

 public ActionInvokerComponent(AppFunc next, MediaTypeFormatterCollection formatters, IContentNegotiator contentNegotiator, IActionParameterBinder parameterBinder)
 {
     _next = next;
     _formatters = formatters;
     _contentNegotiator = contentNegotiator;
     _actionParameterBinder = parameterBinder;
 }

 public static void RegisterFormatters(MediaTypeFormatterCollection formatters)
 {
     formatters.Remove(formatters.XmlFormatter);
     
     var json = formatters.JsonFormatter;
     json.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
 }

 /// <summary>
 /// Format json to camel case
 /// </summary>
 /// <param name="formatters"></param>
 public static void CamelCasePropertyNamesContractResolver(MediaTypeFormatterCollection formatters)
 {
     var jsonFormatter = formatters.JsonFormatter;
     var settings = jsonFormatter.SerializerSettings;
     //settings.Formatting = Formatting.Indented;
     settings.ContractResolver = new CamelCasePropertyNamesContractResolver();
 }

        public ItunesRepository()
        {
            client = new HttpClient();
            client.MaxResponseContentBufferSize = 1000000; // 1MB

            formatters = new MediaTypeFormatterCollection();
            formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/javascript"));
        }

        internal HttpResponseErrorHandler(IEnumerable<MediaTypeFormatter> formatters, Uri helpUri, bool includeExceptionDetail)
        {
            Fx.Assert(formatters != null, "The 'formatters' parameter should not be null.");

            this.formatters = new MediaTypeFormatterCollection(formatters);
            this.helpUri = helpUri;
            this.includeExceptionDetail = includeExceptionDetail;
        }

        public static void RegisterFormatters(MediaTypeFormatterCollection formatters)
        {
            var jsonFormatter = formatters.JsonFormatter;
            jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();

            var jsonpFormatter = new JsonpMediaTypeFormatter(jsonFormatter);
            formatters.Add(jsonpFormatter);
        }

        private static void Configure(MediaTypeFormatterCollection formatters, HttpConfiguration config)
        {
            var xml = config.Formatters.XmlFormatter;
            formatters.Remove(xml);

            var json = config.Formatters.JsonFormatter;
            json.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
        }

 public void Constructor()
 {
     MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
     Assert.Equal(3, collection.Count);
     Assert.NotNull(collection.XmlFormatter);
     Assert.NotNull(collection.JsonFormatter);
     Assert.NotNull(collection.FormUrlEncodedFormatter);
 }

        private static void SetFormatters(MediaTypeFormatterCollection formatters)
        {
            formatters.Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter);

            formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.None;
            formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
            formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter { CamelCaseText = true });
            formatters.JsonFormatter.SerializerSettings.NullValueHandling = NullValueHandling.Include;
        }

 public MultipartMediaTypeFormatter([NotNull] MediaTypeFormatterCollection mediaTypeFormatterCollection,
                                    [NotNull] IPropertyHelper propertyHelper)
 {
     if (mediaTypeFormatterCollection == null) throw new ArgumentNullException(nameof(mediaTypeFormatterCollection));
     if (propertyHelper == null) throw new ArgumentNullException(nameof(propertyHelper));
     _mediaTypeFormatterCollection = mediaTypeFormatterCollection;
     _propertyHelper = propertyHelper;
     SupportedMediaTypes.Add(new MediaTypeHeaderValue("multipart/form-data"));
 }

 public static void RegisterFormatters(MediaTypeFormatterCollection formatters)
 {
     formatters.Remove(formatters.JsonFormatter);
     formatters.Insert(0, new JsonpMediaTypeFormatter {
         SerializerSettings = new JsonSerializerSettings {
             ContractResolver = new CamelCasePropertyNamesContractResolver()
         }
     });
 }

        /// <summary>
        /// Internal constructor used to build collection of available MediaTypeFormatters
        /// </summary>
        protected MediaTypeFormatters()
        {
            formatters = new MediaTypeFormatterCollection();

            IMediaTypeFormatterFactory jsonFactory = new JsonFormatterFactory();
            formatters.Add(jsonFactory.Formatter());
            IMediaTypeFormatterFactory xmlFactory = new XmlFormatterFactory();
            formatters.Add(xmlFactory.Formatter());
        }

 public ResttpConfiguration(Assembly controllersAssembly)
 {
     HttpRoutes = new HttpRouteList();
     ControllersAssembly = controllersAssembly;
     Formatters = new MediaTypeFormatterCollection();
     //Formatters.Remove(Formatters.First(f=>f is FormUrlEncodedMediaTypeFormatter));
     ContentNegotiator = new ContentNegotiation.ContentNegotiator();
     ActionParameterBinder = new Resttp.ActionInvoker.ActionParameterBinder();
 }

        /// <summary>Construct an HTTP request message.</summary>
        /// <param name="method">The HTTP method.</param>
        /// <param name="resource">The URI to send the request to.</param>
        /// <param name="formatters">The formatters used for serializing and deserializing message bodies.</param>
        public virtual HttpRequestMessage GetRequestMessage(HttpMethod method, Uri resource, MediaTypeFormatterCollection formatters)
        {
            HttpRequestMessage request = new HttpRequestMessage(method, resource);

            // add default headers
            request.Headers.Add("user-agent", "FluentHttpClient/0.4 (+http://github.com/Pathoschild/Pathoschild.FluentHttpClient)");
            request.Headers.Add("accept", formatters.SelectMany(p => p.SupportedMediaTypes).Select(p => p.MediaType));

            return request;
        }

        public static void RegisterFormatters(MediaTypeFormatterCollection formatters)
        {
            // Remove xml formatter (at least for the moment)
            formatters.Remove(formatters.XmlFormatter);

            // Json formatter
            //formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
            //formatters.JsonFormatter.Indent = true; ?
            //formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter());
            //formatters.JsonFormatter.MaxDepth = 1;
            //formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
        }