public ICsvRowActivatorFactory <T> Create(IConverterProvider converterProvider, IColumnNameMapper columnNameMapper)
{
// Create assembly/module
bool saveDll = false;
AssemblyName assemblyName = new AssemblyName("DynamicCsvRowActivator");
AssemblyBuilder assemblyBuilder = BuildAssembly(assemblyName, new Version(1, 0, 0, 0), saveDll);
ModuleBuilder moduleBuilder = BuildModule(assemblyBuilder, assemblyName, saveDll);
// Create activator type
DynamicCsvRowActivatorBuilder <T> activatorBuilder
= new DynamicCsvRowActivatorBuilder <T>(converterProvider, columnNameMapper);
TypeBuilder activatorTypeBuilder = activatorBuilder.Build(assemblyBuilder, moduleBuilder);
Type activatorType = activatorTypeBuilder.CreateType();
ConstructorInfo activatorConstructor = activatorType.GetConstructor(new Type[] { typeof(string[]) });
// Create factory type
DynamicCsvRowActivatorFactoryBuilder <T> factoryBuilder
= new DynamicCsvRowActivatorFactoryBuilder <T>();
TypeBuilder typeBuilder = factoryBuilder.Build(assemblyBuilder, moduleBuilder, activatorConstructor);
Type factoryType = typeBuilder.CreateType();
ConstructorInfo factoryConstructor = factoryType.GetConstructor(Type.EmptyTypes);
// Save the dll
if (saveDll)
{
assemblyBuilder.Save("DynamicCsvRowActivator.dll");
}
// Create an instance of a factory
ICsvRowActivatorFactory <T> factory = (ICsvRowActivatorFactory <T>)factoryConstructor.Invoke(new object[] { });
return(factory);
}
public static ConverterContext CreateContext(this IConverterProvider converterProvider, Type type, out short typeId)
{
var dataAttribute = type.GetTypeInfo().GetCustomAttribute <DataAttribute>(false);
var spaceAttr = type.GetTypeInfo().Assembly.GetCustomAttribute <DataSpaceAttribute>();
if (spaceAttr == null)
{
throw new ArgumentException($"Assembly should have DataSpace attribute. Example: [Assembly: DataSpace(Date)]");
}
var spaceId = spaceAttr.SpaceId;
if (dataAttribute.TypeId >= 30000 && !dataAttribute.IsSystem)
{
throw new ArgumentException($"Data types from 30000 must have set IsSystem to true. Current: {dataAttribute.TypeId}. Type: {type.FullName}");
}
var properties = type.GetTypeInfo().GetProperties()
.Where(p => p.GetCustomAttribute <IncludeAttribute>(true) != null).Select(property =>
new PropertyContext()
{
Include = property.GetCustomAttribute <IncludeAttribute>(true),
Array = property.GetCustomAttribute <ArrayAttribute>(true),
PropertyInfo = property,
Converter = converterProvider.GetConverter(property.PropertyType, out var converterTypeId),
}).OrderBy(p => p.Include.Order).ToArray();
private static T CreateBinderInstance(IConverterProvider converterProvider)
{
return((T)typeof(T)
.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
.First()
.Invoke(new object[] { converterProvider }));
}
public void Teardown()
{
_request = null;
_stringConverter = null;
_uriConverter = null;
_provider = null;
}
/// <summary>
/// 合并指定的两个类型转换器提供者。
/// </summary>
/// <param name="first">要合并的第一个类型转换器提供者。</param>
/// <param name="second">要合并的第二个类型转换器提供者。</param>
/// <returns>合并得到的类型转换器。</returns>
public static IConverterProvider Combine(IConverterProvider first, IConverterProvider second)
{
Contract.Requires(first != null && second != null);
Contract.Requires(first.OriginType != null && first.OriginType == second.OriginType);
var firstProvider = first as ConverterProvider;
var secondProvider = second as ConverterProvider;
if (firstProvider != null)
{
if (secondProvider != null)
{
firstProvider.CombineWith(secondProvider);
}
else
{
firstProvider.CombineWith(second);
}
return(firstProvider);
}
if (secondProvider != null)
{
secondProvider.CombineWith(first);
return(secondProvider);
}
return(new ConverterProvider(first, second));
}
public IExcelMapper Build(IWorkbook workbook, MapperSettings settings)
{
if (workbook == null)
{
throw new ArgumentNullException(nameof(workbook));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
IConverterProvider converterProvider = GetDefaultConvertersProvider();
IPropertyNameConvention propertyNameConvention = GetDefaultPropertyNamingConventions();
if (settings.Convention.AnyValue())
{
propertyNameConvention = settings.Convention;
}
if (settings.ConverterProvider.AnyValue())
{
converterProvider = settings.ConverterProvider;
}
var propertiesExtractor = new TypeInfoProvider();
var propertyInfoExtractor = new PropertyInfoExtractor();
var propertiesMapFactory = new ExcelPropertyMapFactory(propertiesExtractor, propertyInfoExtractor,
propertyNameConvention, _loggerFactory.CreateLogger <ExcelPropertyMapFactory>());
var typeConverter = new CellValueConverter(converterProvider);
var modelFactory = new ModelBuilder(propertyInfoExtractor);
return(new ExcelMapper(workbook, propertiesMapFactory, typeConverter, modelFactory,
_loggerFactory.CreateLogger <ExcelMapper>()));
}
/// <summary>Converts string to given type.</summary>
/// <param name="converterProvider">The converter provider.</param>
/// <param name="value">The value.</param>
/// <param name="type">The target type.</param>
/// <param name="request">The request.</param>
/// <returns>Instance of the <paramref name="type" />.</returns>
public static object ConvertTo(this IConverterProvider converterProvider, string value, Type type, IRequestInfo request = null)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (value == null)
{
return(type.IsValueType ? Activator.CreateInstance(type) : null);
}
bool success;
object result = ConvertUsingTypeConverters(value, type, out success);
if ((success) || (request == null))
{
return(result);
}
if (converterProvider == null)
{
throw new ArgumentNullException("converterProvider");
}
return(ConvertUsingCustomConverters(converterProvider, request, value, type));
}
/// <summary>Converts string values to given collection.</summary>
/// <param name="converterProvider">The converter provider.</param>
/// <param name="values">The values.</param>
/// <param name="collectionType">The collection type.</param>
/// <param name="request">The request.</param>
/// <returns>Instance of the <paramref name="collectionType" />.</returns>
public static object ConvertToCollection(this IConverterProvider converterProvider, IEnumerable <string> values, Type collectionType, IRequestInfo request = null)
{
if (values == null)
{
return(null);
}
if (collectionType == null)
{
throw new ArgumentNullException("collectionType");
}
var itemType = collectionType.GetItemType();
bool success;
var result = ConvertUsingTypeConverters(values, itemType, out success);
if ((success) || (request == null))
{
return(result.MakeInstance(collectionType, itemType));
}
if (converterProvider == null)
{
throw new ArgumentNullException("converterProvider");
}
return(ConvertUsingCustomConverters(converterProvider, request, values, itemType).MakeInstance(collectionType, itemType));
}
/// <summary>Initializes a new instance of the <see cref="ConverterConventionVisitor" /> class.</summary>
/// <param name="converterProvider">Converters provider.</param>
public ConverterConventionVisitor(IConverterProvider converterProvider)
{
if (converterProvider == null)
{
throw new ArgumentNullException(nameof(converterProvider));
}
_converterProvider = converterProvider;
}
/// <summary>
/// 通过合并现有的类型转换器提供者初始化 <see cref="ConverterProvider"/> 类的新实例。
/// </summary>
/// <param name="first">要合并的第一个类型转换器提供者。</param>
/// <param name="second">要合并的第二个类型转换器提供者。</param>
private ConverterProvider(IConverterProvider first, IConverterProvider second)
{
Contract.Requires(first != null && second != null);
Contract.Requires(first.OriginType != null && first.OriginType == second.OriginType);
this.originType = first.OriginType;
this.fromDict = new Dictionary<Type, Delegate>();
this.toDict = new Dictionary<Type, Delegate>();
this.subProvider = new[] { first, second };
}
/// <summary>
/// 通过合并现有的类型转换器提供者初始化 <see cref="ConverterProvider"/> 类的新实例。
/// </summary>
/// <param name="first">要合并的第一个类型转换器提供者。</param>
/// <param name="second">要合并的第二个类型转换器提供者。</param>
private ConverterProvider(IConverterProvider first, IConverterProvider second)
{
Contract.Requires(first != null && second != null);
Contract.Requires(first.OriginType != null && first.OriginType == second.OriginType);
originType = first.OriginType;
fromDict = new Dictionary <Type, Delegate>();
toDict = new Dictionary <Type, Delegate>();
subProvider = new[] { first, second };
}
internal FromBodyArgumentBinder(IConverterProvider converterProvider)
{
if (converterProvider == null)
{
throw new ArgumentNullException("converterProvider");
}
_converterProvider = converterProvider;
}
public ResultBinder(IConverterProvider converterProvider)
{
if (converterProvider == null)
{
throw new ArgumentNullException("converterProvider");
}
_converterProvider = converterProvider;
}
/// <summary>
/// 添加指定的类型转换器提供者。
/// </summary>
/// <param name="provider">要添加的类型转换器提供者。</param>
/// <exception cref="ArgumentNullException"><paramref name="provider"/> 为 <c>null</c>。</exception>
/// <exception cref="ArgumentNullException"><paramref name="provider"/> 的源类型为 <c>null</c>。</exception>
/// <remarks><paramref name="provider"/> 提供的类型转换方法不会覆盖预定义的隐式、显式类型转换和用户自定义的类型转换，
/// 以及任何通过 <see cref="AddConverter{TInput, TOutput}"/> 方法设置的类型转换方法。
/// 对于相同源类型的 <see cref="IConverterProvider"/>，<see cref="IConverterProvider.GetConverterTo"/>
/// 方法提供的类型转换方法优先级更高，且后设置的优先级更高。</remarks>
public static void AddConverterProvider(IConverterProvider provider)
{
CommonExceptions.CheckArgumentNull(provider, nameof(provider));
if (provider.OriginType == null)
{
throw CommonExceptions.ArgumentNull(nameof(provider));
}
Contract.EndContractBlock();
ConversionFactory.AddConverterProvider(provider);
}
public UpdateClientService(IServerService serverService, IHubContext <AirportHub> hubContext, IConverterProvider converterProvider, IAirportDataService airportDataService)
{
this.serverService = serverService;
serverService.ChangeInStateEvent += SendAirports;
serverService.ChangeInStateEvent += SendLog;
this.hubContext = hubContext;
this.converterProvider = converterProvider;
this.airportDataService = airportDataService;
this.serverService.LoadFromDb();
this.serverService.AssignPlaneMakers();
}
public DynamicCsvRowActivatorBuilder(IConverterProvider converterProvider, IColumnNameMapper columnNameMapper)
{
if (converterProvider == null)
{
throw new ArgumentNullException("converterProvider");
}
if (columnNameMapper == null)
{
throw new ArgumentNullException("columnNameMapper");
}
this.converterProvider = converterProvider;
this.columnNameMapper = columnNameMapper;
}
/// <summary>
/// 添加指定的类型转换器提供者。
/// </summary>
/// <param name="provider">要添加的类型转换器提供者。</param>
/// <exception cref="ArgumentNullException"><paramref name="provider"/> 为 <c>null</c>。</exception>
/// <exception cref="ArgumentNullException"><paramref name="provider"/> 的源类型为 <c>null</c>。</exception>
/// <remarks><paramref name="provider"/> 提供的类型转换方法不会覆盖预定义的隐式、显式类型转换和用户自定义的类型转换，
/// 以及任何通过 <see cref="AddConverter{TInput, TOutput}"/> 方法设置的类型转换方法。
/// 对于相同源类型的 <see cref="IConverterProvider"/>，<see cref="IConverterProvider.GetConverterTo"/>
/// 方法提供的类型转换方法优先级更高，且后设置的优先级更高。</remarks>
public static void AddConverterProvider(IConverterProvider provider)
{
if (provider == null)
{
throw CommonExceptions.ArgumentNull("provider");
}
if (provider.OriginType == null)
{
throw CommonExceptions.ArgumentNull("provider.OriginType");
}
Contract.EndContractBlock();
ConversionFactory.AddConverterProvider(provider);
}
public ICsvRowActivatorFactory <T> Create(IConverterProvider converterProvider, IColumnNameMapper columnNameMapper)
{
CachingKey key = new CachingKey(converterProvider, columnNameMapper);
if (!cache.Keys.Contains(key))
{
var newFactory = factoryFactory.Create(converterProvider, columnNameMapper);
cache.Add(key, newFactory);
return(newFactory);
}
else
{
return(cache[key]);
}
}
public ResponseComposer(IConverterProvider converterProvider, IEnumerable<IHttpControllerDescriptionBuilder> httpControllerDescriptionBuilders)
{
if (converterProvider == null)
{
throw new ArgumentNullException("converterProvider");
}
if (httpControllerDescriptionBuilders == null)
{
throw new ArgumentNullException("httpControllerDescriptionBuilders");
}
_converterProvider = converterProvider;
_controllerDescriptors = new Lazy<IEnumerable<ControllerInfo>>(() => httpControllerDescriptionBuilders.Select(item => item.BuildDescriptor()));
}
public ServerService(IConverterProvider converterProvider, IDALService dalService,
AirportLoader airportLoader = AirportLoader.Load)
{
this.airportManager = new AirportManager();
this.converterProvider = converterProvider;
this.dalService = dalService;
if (airportLoader == AirportLoader.CreateAndLoad)
{
CreateAirports();
}
ChangeInStateEvent += dalService.UpdateDatabase;
ChangeInStateEvent += dalService.AddLogDatabase;
}
/// <summary>
/// 将当前类型转换器提供者与指定的 <see cref="IConverterProvider"/> 合并。
/// </summary>
/// <param name="provider">要合并的类型转换器提供者。</param>
private void CombineWith(IConverterProvider provider)
{
Contract.Requires(provider != null && OriginType == provider.OriginType);
if (subProvider.Length == 0)
{
subProvider = new[] { provider };
}
else
{
var newProviders = new IConverterProvider[subProvider.Length + 1];
subProvider.CopyTo(newProviders, 0);
newProviders[newProviders.Length - 1] = provider;
subProvider = newProviders;
}
}
public ResponseComposer(IConverterProvider converterProvider, IEnumerable <IHttpControllerDescriptionBuilder> httpControllerDescriptionBuilders)
{
if (converterProvider == null)
{
throw new ArgumentNullException("converterProvider");
}
if (httpControllerDescriptionBuilders == null)
{
throw new ArgumentNullException("httpControllerDescriptionBuilders");
}
_converterProvider = converterProvider;
_controllerDescriptors = new Lazy <IEnumerable <ControllerInfo> >(() => httpControllerDescriptionBuilders.Select(item => item.BuildDescriptor()));
}
public void Setup()
{
_request = new Mock <IRequestInfo>(MockBehavior.Strict);
_stringConverter = new Mock <IConverter>(MockBehavior.Strict);
_stringConverter.Setup(instance => instance.CanConvertTo(It.IsAny <Type>(), _request.Object))
.Returns <Type, IRequestInfo>((type, request) => type == typeof(string) ? CompatibilityLevel.ExactMatch : CompatibilityLevel.None);
_uriConverter = new Mock <IConverter>(MockBehavior.Strict);
_uriConverter.Setup(instance => instance.CanConvertTo(It.IsAny <Type>(), _request.Object))
.Returns <Type, IRequestInfo>((type, request) => type == typeof(Uri) ? CompatibilityLevel.ExactMatch : CompatibilityLevel.None);
_provider = new DefaultConverterProvider();
_converters = new List <IConverter>()
{
_stringConverter.Object, _uriConverter.Object
};
_provider.Initialize(_converters);
}
public Serializer(IContextProvider contextProvider, IConverterProvider converterProvider)
{
if (contextProvider == null)
{
throw new ArgumentNullException(nameof(contextProvider));
}
if (converterProvider == null)
{
throw new ArgumentNullException(nameof(converterProvider));
}
this.ContextProvider = contextProvider;
this.ConverterProvider = converterProvider;
InitializeConverters();
}
private Client()
{
IComponentProvider container = UrsaConfigurationSection.InitializeComponentProvider();
_webRequestProvider = (from webRequestProvider in container.ResolveAll <IWebRequestProvider>()
from supportedProtocol in webRequestProvider.SupportedProtocols
join allowedProtocol in AllowedProtocols on supportedProtocol equals allowedProtocol
select webRequestProvider).FirstOrDefault();
if (_webRequestProvider == null)
{
throw new InvalidOperationException("Cannot create an HTTP client without proper web request provider.");
}
_converterProvider = container.Resolve <IConverterProvider>();
_resultBinder = container.Resolve <IResultBinder <RequestInfo> >();
}
public static bool IsValidConverterTo(this IConverterProvider provider, Delegate dlg, Type outputType)
{
Contract.Requires(provider != null && outputType != null);
if (dlg == null)
{
return(false);
}
MethodInfo method = dlg.GetInvokeMethod();
if (method.ReturnType != outputType)
{
return(false);
}
ParameterInfo[] parameters = method.GetParametersNoCopy();
return(parameters.Length == 1 && parameters[0].ParameterType == provider.OriginType);
}
public static bool IsValidConverterFrom(this IConverterProvider provider, Delegate dlg, Type inputType)
{
Contract.Requires(provider != null && inputType != null);
if (dlg == null)
{
return(false);
}
var method = dlg.GetInvokeMethod();
if (method.ReturnType != provider.OriginType)
{
return(false);
}
var parameters = method.GetParametersNoCopy();
return((parameters.Length == 1 && parameters[0].ParameterType == inputType) ||
(parameters.Length == 2 && parameters[1].ParameterType == inputType));
}
private static string ConvertUsingCustomConverters(IConverterProvider converterProvider, IResponseInfo response, object value)
{
var converter = converterProvider.FindBestOutputConverter(value.GetType(), response);
if (converter == null)
{
return(null);
}
string result = null;
converter.ConvertFrom(value.GetType(), value, response);
using (var reader = new StreamReader(response.Body))
{
result = reader.ReadToEnd();
}
response.Body.Seek(0, SeekOrigin.Begin);
return(result);
}
/// <summary>Converts an object into a string response body.</summary>
/// <param name="converterProvider">Converter provider.</param>
/// <param name="value">The value.</param>
/// <param name="response">Optional response.</param>
/// <returns>String representation of the given <paramref name="value" />.</returns>
public static string ConvertFrom(this IConverterProvider converterProvider, object value, IResponseInfo response = null)
{
if (value == null)
{
return(null);
}
bool success;
string result = ConvertUsingTypeConverters(value, out success);
if (success)
{
return(result);
}
if (converterProvider == null)
{
throw new ArgumentNullException("converterProvider");
}
return(ConvertUsingCustomConverters(converterProvider, response, value));
}
public MultiObjectResponseInfo(Encoding encoding, RequestInfo request, IEnumerable <object> values, IConverterProvider converterProvider, HeaderCollection headers) :
base(encoding, request, headers)
{
Initialize(encoding, request, values, converterProvider);
}
public MultiObjectResponseInfo(RequestInfo request, IEnumerable <object> values, IConverterProvider converterProvider, HeaderCollection headers) :
this(Encoding.UTF8, request, values, converterProvider, headers)
{
}
private void Initialize(Encoding encoding, RequestInfo request, IEnumerable <object> values, IConverterProvider converterProvider)
{
if (values == null)
{
throw new ArgumentNullException("values");
}
var boundary = Guid.NewGuid().ToString();
Headers.ContentType = String.Format("multipart/mixed; boundary=\"{0}\"", boundary);
_body = new MemoryStream();
Body = new UnclosableStream(_body);
var valueResponses = new List <ResponseInfo>();
using (var writer = new StreamWriter(Body))
{
foreach (var value in values.Where(value => value != null))
{
writer.Write("--{0}\r\n", boundary);
var objectResponse = ObjectResponseInfo <object> .CreateInstance(encoding, request, value.GetType(), value, converterProvider);
valueResponses.Add(objectResponse);
foreach (var header in objectResponse.Headers)
{
switch (header.Name)
{
case "Content-Lenght":
break;
default:
writer.Write("{0}\r\n", header);
break;
}
}
writer.Write("Content-Length:{0}\r\n\r\n", objectResponse.Body.Length);
writer.Flush();
objectResponse.Body.CopyTo(Body);
writer.Flush();
writer.Write("\r\n");
writer.Flush();
}
writer.Write("--{0}--", boundary);
writer.Flush();
}
_body.Seek(0, SeekOrigin.Begin);
ObjectResponses = valueResponses;
}
public void Teardown()
{
_request = null;
_stringConverter = null;
_uriConverter = null;
_provider = null;
}
public void Setup()
{
_request = new Mock<IRequestInfo>(MockBehavior.Strict);
_response = new Mock<IResponseInfo>(MockBehavior.Strict);
_response.SetupGet(instance => instance.Request).Returns(_request.Object);
_stringConverter = new Mock<IConverter>(MockBehavior.Strict);
_stringConverter.Setup(instance => instance.CanConvertFrom(It.IsAny<Type>(), _response.Object))
.Returns<Type, IResponseInfo>((type, response) => type == typeof(string) ? CompatibilityLevel.ExactMatch : CompatibilityLevel.None);
_uriConverter = new Mock<IConverter>(MockBehavior.Strict);
_uriConverter.Setup(instance => instance.CanConvertFrom(It.IsAny<Type>(), _response.Object))
.Returns<Type, IResponseInfo>((type, response) => type == typeof(Uri) ? CompatibilityLevel.ExactMatch : CompatibilityLevel.None);
_provider = new DefaultConverterProvider();
_converters = new List<IConverter>() { _stringConverter.Object, _uriConverter.Object };
_provider.Initialize(_converters);
}
/// <summary>
/// 添加指定的类型转换器提供者。
/// </summary>
/// <param name="provider">要添加的类型转换器提供者。</param>
public static void AddConverterProvider(IConverterProvider provider)
{
Contract.Requires(provider != null && provider.OriginType != null);
providers.AddOrUpdate(provider.OriginType, provider, (type, old) => ConverterProvider.Combine(old, provider));
}
/// <summary>
/// 将当前类型转换器提供者与指定的 <see cref="IConverterProvider"/> 合并。
/// </summary>
/// <param name="provider">要合并的类型转换器提供者。</param>
private void CombineWith(IConverterProvider provider)
{
Contract.Requires(provider != null && this.OriginType == provider.OriginType);
if (this.subProvider.Length == 0)
{
this.subProvider = new[] { provider };
}
else
{
IConverterProvider[] newProviders = new IConverterProvider[this.subProvider.Length + 1];
this.subProvider.CopyTo(newProviders, 0);
newProviders[newProviders.Length - 1] = provider;
this.subProvider = newProviders;
}
}
/// <summary>
/// 合并指定的两个类型转换器提供者。
/// </summary>
/// <param name="first">要合并的第一个类型转换器提供者。</param>
/// <param name="second">要合并的第二个类型转换器提供者。</param>
/// <returns>合并得到的类型转换器。</returns>
public static IConverterProvider Combine(IConverterProvider first, IConverterProvider second)
{
Contract.Requires(first != null && second != null);
Contract.Requires(first.OriginType != null && first.OriginType == second.OriginType);
ConverterProvider firstProvider = first as ConverterProvider;
ConverterProvider secondProvider = second as ConverterProvider;
if (firstProvider != null)
{
if (secondProvider != null)
{
firstProvider.CombineWith(secondProvider);
}
else
{
firstProvider.CombineWith(second);
}
return firstProvider;
}
if (secondProvider != null)
{
secondProvider.CombineWith(first);
return secondProvider;
}
return new ConverterProvider(first, second);
}
private void Initialize(Encoding encoding, RequestInfo request, IEnumerable<object> values, IConverterProvider converterProvider)
{
if (values == null)
{
throw new ArgumentNullException("values");
}
var boundary = Guid.NewGuid().ToString();
Headers.ContentType = String.Format("multipart/mixed; boundary=\"{0}\"", boundary);
_body = new MemoryStream();
Body = new UnclosableStream(_body);
var valueResponses = new List<ResponseInfo>();
using (var writer = new StreamWriter(Body))
{
foreach (var value in values.Where(value => value != null))
{
writer.Write("--{0}\r\n", boundary);
var objectResponse = ObjectResponseInfo<object>.CreateInstance(encoding, request, value.GetType(), value, converterProvider);
valueResponses.Add(objectResponse);
foreach (var header in objectResponse.Headers)
{
switch (header.Name)
{
case "Content-Lenght":
break;
default:
writer.Write("{0}\r\n", header);
break;
}
}
writer.Write("Content-Length:{0}\r\n\r\n", objectResponse.Body.Length);
writer.Flush();
objectResponse.Body.CopyTo(Body);
writer.Flush();
writer.Write("\r\n");
writer.Flush();
}
writer.Write("--{0}--", boundary);
writer.Flush();
}
_body.Seek(0, SeekOrigin.Begin);
ObjectResponses = valueResponses;
}
public MultiObjectResponseInfo(RequestInfo request, IEnumerable<object> values, IConverterProvider converterProvider, HeaderCollection headers) :
this(Encoding.UTF8, request, values, converterProvider, headers)
{
}
public MultiObjectResponseInfo(Encoding encoding, RequestInfo request, IEnumerable<object> values, IConverterProvider converterProvider, HeaderCollection headers) :
base(encoding, request, headers)
{
Initialize(encoding, request, values, converterProvider);
}
private static IEnumerable<object> ConvertUsingCustomConverters(IConverterProvider converterProvider, IRequestInfo request, IEnumerable<string> values, Type itemType)
{
var converter = converterProvider.FindBestInputConverter(itemType, request, true);
return (converter == null ? null : values.Select(value => converter.ConvertTo(itemType, value)));
}
private static object ConvertUsingCustomConverters(IConverterProvider converterProvider, IRequestInfo request, string value, Type type)
{
var converter = converterProvider.FindBestInputConverter(type, request, true);
return (converter == null ? null : converter.ConvertTo(type, value));
}
private static string ConvertUsingCustomConverters(IConverterProvider converterProvider, IResponseInfo response, object value)
{
var converter = converterProvider.FindBestOutputConverter(value.GetType(), response);
if (converter == null)
{
return null;
}
string result = null;
converter.ConvertFrom(value.GetType(), value, response);
using (var reader = new StreamReader(response.Body))
{
result = reader.ReadToEnd();
}
response.Body.Seek(0, SeekOrigin.Begin);
return result;
}
