public ConverterManager()

in src/Microsoft.Azure.WebJobs.Host/Bindings/ConverterManager.cs [33:110]
67 lines of code
1 McCabe index (conditional complexity)

        public ConverterManager()
        {
            this.AddExactConverter<byte[], string>(DefaultByteArrayToString);
            this.AddExactConverter<IEnumerable<JObject>, JArray>((enumerable) => JArray.FromObject(enumerable));            
        
            this.AddExactConverter<ApplyConversion<string, Stream>, object>(async (pair, cancellationToken) =>
          {
              var text = pair.Value;
              var stream = pair.Existing;

              // Specifically use the same semantics as binding to 'TextWriter'              
              using (var writer = new StreamWriter(stream))
              {
                  cancellationToken.ThrowIfCancellationRequested();
                  await writer.WriteAsync(text);
              }
              return null;
          });

            this.AddExactConverter<ApplyConversion<byte[], Stream>, object>(async (pair, cancellationToken) =>
            {
                var bytes = pair.Value;
                var stream = pair.Existing;

                await stream.WriteAsync(bytes, 0, bytes.Length);
                return null;
            });

            this.AddExactConverter<Stream, string>(async (stream, cancellationToken) =>
            {
                using (var sr = new StreamReader(stream))
                {
                    return await sr.ReadToEndAsync();
                }
            });
            this.AddExactConverter<Stream, byte[]>(async (stream, cancellatinToken) =>
            {
                using (MemoryStream outputStream = new MemoryStream())
                {
                    const int DefaultBufferSize = 4096;
                    await stream.CopyToAsync(outputStream, DefaultBufferSize);
                    byte[] value = outputStream.ToArray();
                    return value;
                }
            });

            this.AddExactConverter<Stream, TextReader>(stream =>
            {
                return new StreamReader(stream);
            });
            this.AddExactConverter<Stream, TextWriter>(stream =>
            {
                // Default is UTF8, not write a BOM, close stream when done. 
                return new StreamWriter(stream);
            });

            this.AddExactConverter<Stream, BinaryData>(async (stream, cancellationToken) =>
            {
                return await BinaryData.FromStreamAsync(stream, cancellationToken);
            });
            this.AddExactConverter<ApplyConversion<BinaryData, Stream>, object>(async (pair, cancellationToken) =>
            {
                var data = pair.Value;
                var stream = pair.Existing;

                await data.ToStream().CopyToAsync(stream);
                return null;
            });

            this.AddExactConverter<byte[], BinaryData>((bytes) =>
            {
                return BinaryData.FromBytes(bytes);
            });
            this.AddExactConverter<BinaryData, byte[]>((binaryData) =>
            {
                return binaryData.ToArray();
            });
        }