/// <summary> /// Makes a restful call using supplied information. /// </summary> /// <typeparam name="TResult">Return type to convert response to (if you provide VoidResultType then null will be returned - basically a void call).</typeparam> /// <param name="uri">Uri to make the request against.</param> /// <param name="httpVerb">HTTP verb to use.</param> /// <param name="body">Optional body object to send (use null if not needed).</param> /// <param name="cookieJar">Optional cookie to use (use null if not needed).</param> /// <param name="headerJar">Optional headers to use (use null if not needed).</param> /// <param name="saveResponseHeadersAction">Optional action to use to save response headers (use null if not needed).</param> /// <param name="contentType">Content type to use for request.</param> /// <param name="acceptType">Content type to use for response.</param> /// <param name="timeout">Timeout to use.</param> /// <param name="serializer">Serializer to use.</param> /// <returns>Converted response to the specified type.</returns> public static TResult Call <TResult>( Uri uri, HttpVerb httpVerb, object body, CookieJar cookieJar, HeaderJar headerJar, Action <KeyValuePair <string, string>[]> saveResponseHeadersAction, ContentType contentType, ContentType acceptType, TimeSpan timeout, IStringSerializeAndDeserialize serializer) where TResult : class { var httpVerbAsString = httpVerb.ToString().ToUpperInvariant(); return(Call <TResult>( uri, httpVerbAsString, body, cookieJar, headerJar, saveResponseHeadersAction, contentType, acceptType, timeout, serializer)); }
/// <summary> /// Builds a <see cref="TypeToRegisterForJson"/> for a type using the most sensible settings, /// with a specified <see cref="IStringSerializeAndDeserialize"/> to use everywhere the type appears. /// </summary> /// <param name="type">The type to register.</param> /// <param name="stringSerializer">The string serializer to use for <paramref name="type"/>.</param> /// <returns> /// The type to register for JSON serialization. /// </returns> public static TypeToRegisterForJson ToTypeToRegisterForJsonUsingStringSerializer( this Type type, IStringSerializeAndDeserialize stringSerializer) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (stringSerializer == null) { throw new ArgumentNullException(nameof(stringSerializer)); } var canConvertTypeMatchStrategy = type.ResolveDefaultIntoActionableRelatedTypesToInclude().ToCanConvertTypeMatchStrategy(); var jsonConverterBuilderId = Guid.NewGuid().ToString() + "-" + Guid.NewGuid().ToString(); JsonConverter ConverterBuilderFunc() => new StringSerializerBackedJsonConverter(type, stringSerializer, canConvertTypeMatchStrategy); var jsonConverterBuilder = new JsonConverterBuilder(jsonConverterBuilderId, ConverterBuilderFunc, ConverterBuilderFunc); var result = new TypeToRegisterForJson(type, MemberTypesToInclude.None, RelatedTypesToInclude.Default, jsonConverterBuilder, stringSerializer); return(result); }
/// <summary> /// Initializes a new instance of the <see cref="TypeToRegisterForJson{T}"/> class. /// </summary> /// <param name="memberTypesToInclude">Specifies which member types of <typeparamref name="T"/> that should also be registered.</param> /// <param name="relatedTypesToInclude">Specifies which types related to <typeparamref name="T"/> that should also be registered.</param> /// <param name="jsonConverterBuilder">Builds a serializing and deserializing <see cref="JsonConverter"/>.</param> /// <param name="keyInDictionaryStringSerializer">The serializer to use when dictionaries are keyed on <typeparamref name="T"/> and the keys should be written-to/read-from a string.</param> public TypeToRegisterForJson( MemberTypesToInclude memberTypesToInclude, RelatedTypesToInclude relatedTypesToInclude, JsonConverterBuilder jsonConverterBuilder, IStringSerializeAndDeserialize keyInDictionaryStringSerializer) : base(typeof(T), memberTypesToInclude, relatedTypesToInclude, jsonConverterBuilder, keyInDictionaryStringSerializer) { }
/// <summary> /// Withes the serializer. /// </summary> /// <param name="serializer">The serializer.</param> /// <returns>ICallOnUriAll.</returns> /// <inheritdoc /> public ICallOnUriAll WithSerializer(IStringSerializeAndDeserialize serializer) { new { serializer }.AsArg().Must().NotBeNull(); this.UpdateCallListThrowIfAlreadyCalled(nameof(this.WithSerializer)); this.serializerForPostBodyAndResponse = serializer; return(this); }
/// <summary> /// Builds a <see cref="StringSerializerBackedBsonSerializer{T}"/> for the specified type and backing string serializer. /// </summary> /// <param name="type">The type.</param> /// <param name="backingSerializer">The backing string serializer.</param> /// <returns> /// A newly constructed <see cref="StringSerializerBackedBsonSerializer{T}"/> for the specified type and backing string serializer. /// </returns> public static IBsonSerializer Build( Type type, IStringSerializeAndDeserialize backingSerializer) { if (type == null) { throw new ArgumentNullException(nameof(type)); } var result = (IBsonSerializer)typeof(StringSerializerBackedBsonSerializer <>).MakeGenericType(type).Construct(backingSerializer); return(result); }
/// <summary> /// Initializes a new instance of the <see cref="TypeToRegisterForJson"/> class, specifying the origin types. /// </summary> /// <param name="type">The type to register.</param> /// <param name="recursiveOriginType">The type whose recursive processing of <paramref name="memberTypesToInclude"/> and <paramref name="relatedTypesToInclude"/> resulted in the creation of this <see cref="TypeToRegisterForJson"/>.</param> /// <param name="directOriginType">The type whose processing of <paramref name="memberTypesToInclude"/> and <paramref name="relatedTypesToInclude"/> directly resulted in the creation of this <see cref="TypeToRegisterForJson"/>.</param> /// <param name="memberTypesToInclude">Specifies which member types of <paramref name="type"/> that should also be registered.</param> /// <param name="relatedTypesToInclude">Specifies which types related to <paramref name="type"/> that should also be registered.</param> /// <param name="jsonConverterBuilder">Builds a serializing and deserializing <see cref="JsonConverter"/>.</param> /// <param name="keyInDictionaryStringSerializer">The serializer to use when dictionaries are keyed on <paramref name="type"/> and the keys should be written-to/read-from a string.</param> public TypeToRegisterForJson( Type type, Type recursiveOriginType, Type directOriginType, MemberTypesToInclude memberTypesToInclude, RelatedTypesToInclude relatedTypesToInclude, JsonConverterBuilder jsonConverterBuilder, IStringSerializeAndDeserialize keyInDictionaryStringSerializer) : base(type, recursiveOriginType, directOriginType, memberTypesToInclude, relatedTypesToInclude) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (recursiveOriginType == null) { throw new ArgumentNullException(nameof(recursiveOriginType)); } if (directOriginType == null) { throw new ArgumentNullException(nameof(directOriginType)); } if (jsonConverterBuilder != null) { if (memberTypesToInclude != MemberTypesToInclude.None) { throw new ArgumentException(Invariant($"{nameof(jsonConverterBuilder)} is specified, but {nameof(Serialization.MemberTypesToInclude)} is not {MemberTypesToInclude.None}.")); } if (type.IsGenericTypeDefinition) { throw new NotSupportedException(Invariant($"{nameof(jsonConverterBuilder)} is specified, but underlying type to register is an open generic.")); } } if (keyInDictionaryStringSerializer != null) { if (type.IsGenericTypeDefinition) { throw new NotSupportedException(Invariant($"{nameof(keyInDictionaryStringSerializer)} is specified, but underlying type to register is an open generic.")); } } this.JsonConverterBuilder = jsonConverterBuilder; this.KeyInDictionaryStringSerializer = keyInDictionaryStringSerializer; }
/// <summary> /// Initializes a new instance of the <see cref="ObcStringSerializerBackedSerializer"/> class. /// </summary> /// <param name="backingStringSerializer">Backing string serializer.</param> /// <param name="id">Optional identifier to be stored in metadata of <see cref="SerializerRepresentation"/>. DEFAULT is null.</param> public ObcStringSerializerBackedSerializer( IStringSerializeAndDeserialize backingStringSerializer, string id = null) { if (backingStringSerializer == null) { throw new ArgumentNullException(nameof(backingStringSerializer)); } this.BackingStringSerializer = backingStringSerializer; this.SerializerRepresentation = new SerializerRepresentation(SerializationKind.StringSerializerBacked, metadata: new Dictionary <string, string> { { nameof(id), id } }); }
/// <summary> /// Builds a <see cref="TypeToRegisterForPropertyBag"/> from a type using the most sensible settings, /// with a specified <see cref="IStringSerializeAndDeserialize"/> to use everywhere the type appears. /// </summary> /// <param name="type">The type to register.</param> /// <param name="stringSerializer">The string serializer to use for <paramref name="type"/>.</param> /// <returns> /// The type to register for property bag serialization. /// </returns> public static TypeToRegisterForPropertyBag ToTypeToRegisterForPropertyBagUsingStringSerializer( this Type type, IStringSerializeAndDeserialize stringSerializer) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (stringSerializer == null) { throw new ArgumentNullException(nameof(stringSerializer)); } var result = new TypeToRegisterForPropertyBag(type, MemberTypesToInclude.None, RelatedTypesToInclude.Default, () => stringSerializer); return(result); }
/// <summary> /// Builds a <see cref="TypeToRegisterForJson"/> for a type using the most sensible settings, /// with a specified <see cref="IStringSerializeAndDeserialize"/> to use when dictionaries are keyed on that type. /// </summary> /// <param name="type">The type to register.</param> /// <param name="stringSerializer">The string serializer to use when dictionaries are keyed on <paramref name="type"/>.</param> /// <returns> /// The type to register for JSON serialization. /// </returns> public static TypeToRegisterForJson ToTypeToRegisterForJsonUsingKeyInDictionaryStringSerializer( this Type type, IStringSerializeAndDeserialize stringSerializer) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (stringSerializer == null) { throw new ArgumentNullException(nameof(stringSerializer)); } var result = new TypeToRegisterForJson(type, MemberTypesToInclude.All, RelatedTypesToInclude.Default, null, stringSerializer); return(result); }
/// <summary> /// Initializes a new instance of the <see cref="StringSerializerBackedJsonConverter"/> class. /// </summary> /// <param name="registeredType">The type that the converter is registered for.</param> /// <param name="backingSerializer">The backing serializer.</param> /// <param name="canConvertTypeMatchStrategy">OPTIONAL strategy to use to match the incoming type-to-consider with <paramref name="registeredType"/>. DEFAULT is match when the types are equal.</param> public StringSerializerBackedJsonConverter( Type registeredType, IStringSerializeAndDeserialize backingSerializer, CanConvertTypeMatchStrategy canConvertTypeMatchStrategy = CanConvertTypeMatchStrategy.TypeToConsiderEqualsRegisteredType) { if (registeredType == null) { throw new ArgumentNullException(nameof(registeredType)); } if (backingSerializer == null) { throw new ArgumentNullException(nameof(backingSerializer)); } this.RegisteredType = registeredType; this.BackingSerializer = backingSerializer; this.CanConvertTypeMatchStrategy = canConvertTypeMatchStrategy; }
/// <summary> /// Builds a <see cref="TypeToRegisterForBson"/> for a type using the most sensible settings, /// with a specified <see cref="IStringSerializeAndDeserialize"/> to use everywhere the type appears. /// </summary> /// <param name="type">The type to register.</param> /// <param name="stringSerializer">The string serializer to use for <paramref name="type"/>.</param> /// <returns> /// The type to register for BSON serialization. /// </returns> public static TypeToRegisterForBson ToTypeToRegisterForBsonUsingStringSerializer( this Type type, IStringSerializeAndDeserialize stringSerializer) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (stringSerializer == null) { throw new ArgumentNullException(nameof(stringSerializer)); } var serializer = StringSerializerBackedBsonSerializer.Build(type, stringSerializer); IBsonSerializer BsonSerializerBuilderFunc() => serializer; var bsonSerializerBuilder = new BsonSerializerBuilder(BsonSerializerBuilderFunc, BsonSerializerOutputKind.String); var result = new TypeToRegisterForBson(type, MemberTypesToInclude.None, RelatedTypesToInclude.Default, bsonSerializerBuilder, null); return(result); }
/// <summary> /// Initializes a new instance of the <see cref="StringSerializerBackedBsonSerializer{T}"/> class. /// </summary> /// <param name="backingSerializer">The backing serializer.</param> public StringSerializerBackedBsonSerializer( IStringSerializeAndDeserialize backingSerializer) { this.backingSerializer = backingSerializer; }
/// <summary> /// Makes a restful call using supplied information. /// </summary> /// <typeparam name="TResult">Return type to convert response to (if you provide VoidResultType then null will be returned - basically a void call).</typeparam> /// <param name="uri">Uri to make the request against.</param> /// <param name="httpVerb">HTTP verb to use.</param> /// <param name="body">Optional body object to send (use null if not needed).</param> /// <param name="cookieJar">Optional cookie to use (use null if not needed).</param> /// <param name="headerJar">Optional headers to use (use null if not needed).</param> /// <param name="saveResponseHeadersAction">Optional action to use to save response headers (use null if not needed).</param> /// <param name="contentType">Content type to use for request.</param> /// <param name="acceptType">Content type to use for response.</param> /// <param name="timeout">Timeout to use.</param> /// <param name="serializer">Serializer to use.</param> /// <returns>Converted response to the specified type.</returns> /// <exception cref="ArgumentException"> /// Must have return of string when accepting text type. /// or /// ContentType: " + contentType + " not supported at this time. - contentType /// or /// AcceptType: " + contentType + " not supported at this time. - acceptType /// or /// AcceptType: " + acceptType + " not supported at this time. - acceptType. /// </exception> public static TResult Call <TResult>( Uri uri, string httpVerb, object body, CookieJar cookieJar, HeaderJar headerJar, Action <KeyValuePair <string, string>[]> saveResponseHeadersAction, ContentType contentType, ContentType acceptType, TimeSpan timeout, IStringSerializeAndDeserialize serializer) where TResult : class { new { uri }.AsArg().Must().NotBeNull(); new { httpVerb }.AsArg().Must().NotBeNullNorWhiteSpace(); new { serializer }.AsArg().Must().NotBeNull(); if (acceptType == ContentType.TextPlain && typeof(TResult) != typeof(string)) { throw new ArgumentException("Must have return of string when accepting text type."); } if (contentType != ContentType.ApplicationJson) { throw new ArgumentException("ContentType: " + contentType + " not supported at this time.", nameof(contentType)); } if (acceptType != ContentType.ApplicationJson && acceptType != ContentType.TextPlain) { throw new ArgumentException("AcceptType: " + contentType + " not supported at this time.", nameof(acceptType)); } if (timeout == default(TimeSpan)) { timeout = TimeSpan.FromSeconds(100); } var cookieContainer = new CookieContainer(); foreach (var cookie in cookieJar.Cookies) { cookieContainer.Add(cookie); } // ReSharper disable once AccessToStaticMemberViaDerivedType - want to call this method... HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(uri); request.CookieContainer = cookieContainer; request.ContentType = contentType.ToStringValue(); request.Accept = acceptType.ToStringValue(); request.Method = httpVerb; request.Timeout = (int)timeout.TotalMilliseconds; LoadRequestHeaders(request, headerJar); string bodyAsString = null; if (contentType == ContentType.ApplicationJson && body != null) { bodyAsString = serializer.SerializeToString(body); } if (httpVerb != HttpVerb.Get.ToString().ToUpperInvariant() && !string.IsNullOrWhiteSpace(bodyAsString)) { request.ContentLength = bodyAsString.Length; using (var requestStream = request.GetRequestStream()) { using (var requestWriter = new StreamWriter(requestStream, Encoding.ASCII)) { requestWriter.Write(bodyAsString); requestWriter.Close(); } } } string contents = null; WebHeaderCollection responseHeadersRaw; using (var resp = request.GetResponse()) { responseHeadersRaw = resp.Headers; var responseStream = resp.GetResponseStream(); if (responseStream != null) { using (var reader = new StreamReader(responseStream)) { contents = reader.ReadToEnd(); } } } TResult ret = default(TResult); if (typeof(TResult) == typeof(VoidResultType)) { return(ret); // this will just be null and should only be used when you don't want a return } else if (acceptType == ContentType.ApplicationJson) { ret = serializer.Deserialize <TResult>(contents); } else if (acceptType == ContentType.TextPlain) { ret = contents as TResult; } else { throw new ArgumentException("AcceptType: " + acceptType + " not supported at this time.", nameof(acceptType)); } var responseHeaders = responseHeadersRaw == null ? new KeyValuePair <string, string> [0] : responseHeadersRaw.ToKeyValuePairArray(); saveResponseHeadersAction?.Invoke(responseHeaders); return(ret); }
/// <summary> /// Initializes a new instance of the <see cref="StringSerializerBackedJsonConverter{T}"/> class. /// </summary> /// <param name="backingSerializer">The backing serializer.</param> /// <param name="canConvertTypeMatchStrategy">OPTIONAL strategy to use to match the incoming type-to-consider with <typeparamref name="T"/>. DEFAULT is match when the types are equal.</param> public StringSerializerBackedJsonConverter( IStringSerializeAndDeserialize backingSerializer, CanConvertTypeMatchStrategy canConvertTypeMatchStrategy = CanConvertTypeMatchStrategy.TypeToConsiderEqualsRegisteredType) : base(typeof(T), backingSerializer, canConvertTypeMatchStrategy) { }
/// <summary> /// Update the serializer for the call. /// </summary> /// <param name="uri">Uri (extension method variable) to use for chain.</param> /// <param name="serializer">Serializer to use.</param> /// <returns>Updated fluent grammar chain.</returns> public static ICallOnUriAll WithSerializer(this Uri uri, IStringSerializeAndDeserialize serializer) { return(new ImplementationForICallOnUriAll(uri).WithSerializer(serializer)); }