//public async Task<string> PostAsync(string url, List<IFormFile> files)
//{
// var client = _httpClientFactory.CreateClient();
// var httpContent = new MultipartFormDataContent();
// if (files != null && files.Count > 0)
// foreach (var file in files)
// {
// var byteArr = await file.GetBytesAsync();
// var imageContent = new ByteArrayContent(byteArr);
// imageContent.Headers.ContentType = MediaTypeHeaderValue.Parse("image/jpeg");
// }
// var response = await client.PostAsync(url, httpContent);
// if (response.StatusCode != HttpStatusCode.OK)
// return null;
// var resultStr = await response.Content.ReadAsStringAsync();
// return resultStr;
//}
public async Task <TOutResult> GetAsync <TOutResult>(string url, DeserializeType deserializeType = DeserializeType.JsonDeserialize) where TOutResult : class, new()
{
var client = _httpClientFactory.CreateClient();
var response = await client.GetAsync(url);
if (response.StatusCode != HttpStatusCode.OK)
{
return(null);
}
var resultStr = await response.Content.ReadAsStringAsync();
TOutResult result = new TOutResult();
switch (deserializeType)
{
case DeserializeType.JsonDeserialize:
result = JsonConvert.DeserializeObject <TOutResult>(resultStr);
break;
case DeserializeType.XmlDeserialize:
var xmlSerialize = new XmlSerialize();
result = xmlSerialize.Deserialize <TOutResult>(resultStr);
break;
default:
break;
}
return(result);
}
private static void DeserializeError <TObj, TEx>(string s, DeserializeType deserializeType, string expectedExceptionText = null, bool checkAgainstSkylineSchema = true, string expectedSkylineSchemaType = null)
where TEx : Exception
where TObj : class
{
s = XmlUtil.XML_DIRECTIVE + s;
XmlSerializer ser = new XmlSerializer(typeof(TObj));
using (TextReader reader = new StringReader(s))
{
String message = null;
try
{
TObj obj = (TObj)ser.Deserialize(reader);
if (deserializeType == DeserializeType.error)
{
// Fail if deserialization succeeds.
Assert.Fail("Expected error deserializing {0}:\r\n{1}", typeof(TObj).Name, s);
}
if (deserializeType == DeserializeType.roundtrip)
{
Serializable(obj, Cloned, checkAgainstSkylineSchema, expectedSkylineSchemaType);
}
}
catch (InvalidOperationException x)
{
message = GetMessageStack(x, null);
if (deserializeType == DeserializeType.error)
{
// Make sure the XML parsing exception was thrown
// with the expected innerException type.
HasInnerExceptionType(x, typeof(TEx));
}
else
{
Assert.Fail("Unexpected exception {0} - {1}:\r\n{2}", typeof(TEx), message, x.StackTrace);
}
}
catch (TEx x)
{
message = GetMessageStack(x, null);
if (deserializeType != DeserializeType.error)
{
Assert.Fail("Unexpected exception {0} - {1}:\r\n{2}", typeof(TEx), message, x.StackTrace);
}
}
if (expectedExceptionText != null)
{
if ((message == null) || !message.Contains(expectedExceptionText))
{
Assert.Fail("Unexpected exception message for {0}: expected to contain\r\n{1}\r\nactual\r\n{2}", typeof(TEx), expectedExceptionText, message ?? "<none>");
}
}
}
}
/// <summary>
/// Parses the i dictionary.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="dictType">Type of the dictionary.</param>
/// <returns>IDictionary.</returns>
public static IDictionary ParseIDictionary(ReadOnlySpan <char> value, Type dictType)
{
if (value.IsEmpty)
{
return(null);
}
var index = VerifyAndGetStartIndex(value, dictType);
var valueParseMethod = Serializer.GetParseStringSpanFn(typeof(object));
if (valueParseMethod == null)
{
return(null);
}
var to = (IDictionary)dictType.CreateInstance();
if (Json.JsonTypeSerializer.IsEmptyMap(value, index))
{
return(to);
}
var valueLength = value.Length;
while (index < valueLength)
{
var keyValue = Serializer.EatMapKey(value, ref index);
Serializer.EatMapKeySeperator(value, ref index);
var elementStartIndex = index;
var elementValue = Serializer.EatTypeValue(value, ref index);
if (keyValue.IsEmpty)
{
continue;
}
var mapKey = valueParseMethod(keyValue);
if (elementStartIndex < valueLength)
{
Serializer.EatWhitespace(value, ref elementStartIndex);
to[mapKey] = DeserializeType <TSerializer> .ParsePrimitive(elementValue.Value(), value[elementStartIndex]);
}
else
{
to[mapKey] = valueParseMethod(elementValue);
}
Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
}
return(to);
}
public static void InitAot <T>()
{
var hold = DeserializeBuiltin <T> .Parse;
hold = DeserializeArray <T[], TSerializer> .Parse;
DeserializeType <TSerializer> .ExtractType(default(ReadOnlySpan <char>));
DeserializeArrayWithElements <T, TSerializer> .ParseGenericArray(default(ReadOnlySpan <char>), null);
DeserializeCollection <TSerializer> .ParseCollection <T>(default(ReadOnlySpan <char>), null, null);
DeserializeListWithElements <T, TSerializer> .ParseGenericList(default(ReadOnlySpan <char>), null, null);
}
public static IDynamicMetaObjectProvider ParseDynamic(StringSegment value)
{
var index = VerifyAndGetStartIndex(value, typeof(ExpandoObject));
var result = new ExpandoObject();
if (JsonTypeSerializer.IsEmptyMap(value))
{
return(result);
}
var container = (IDictionary <string, object>)result;
var tryToParsePrimitiveTypes = JsConfig.TryToParsePrimitiveTypeValues;
var valueLength = value.Length;
while (index < valueLength)
{
var keyValue = Serializer.EatMapKey(value, ref index);
Serializer.EatMapKeySeperator(value, ref index);
var elementValue = Serializer.EatValue(value, ref index);
var mapKey = Serializer.UnescapeString(keyValue).Value;
if (JsonUtils.IsJsObject(elementValue))
{
container[mapKey] = ParseDynamic(elementValue);
}
else if (JsonUtils.IsJsArray(elementValue))
{
container[mapKey] = DeserializeList <List <object>, TSerializer> .ParseStringSegment(elementValue);
}
else if (tryToParsePrimitiveTypes)
{
container[mapKey] = DeserializeType <TSerializer> .ParsePrimitive(elementValue)
?? Serializer.UnescapeString(elementValue);
}
else
{
container[mapKey] = Serializer.UnescapeString(elementValue);
}
Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
}
return(result);
}
public static SetPropertyDelegate GetSetPropertyMethod(Type type, PropertyInfo propertyInfo)
{
return(DeserializeType <JsvTypeSerializer> .GetSetPropertyMethod(type, propertyInfo));
}
/// <summary>
/// Gets the core parse string span function.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns>ParseStringSpanDelegate.</returns>
private static ParseStringSpanDelegate GetCoreParseStringSpanFn <T>()
{
var type = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
if (JsConfig <T> .HasDeserializeFn)
{
return(value => JsConfig <T> .ParseFn(Serializer, value.Value()));
}
if (type.IsEnum)
{
return(x => ParseUtils.TryParseEnum(type, Serializer.UnescapeSafeString(x).Value()));
}
if (type == typeof(string))
{
return(Serializer.UnescapeStringAsObject);
}
if (type == typeof(object))
{
return(DeserializeType <TSerializer> .ObjectStringToType);
}
var specialParseFn = ParseUtils.GetSpecialParseMethod(type);
if (specialParseFn != null)
{
return(v => specialParseFn(v.Value()));
}
if (type.IsArray)
{
return(DeserializeArray <T, TSerializer> .ParseStringSpan);
}
var builtInMethod = DeserializeBuiltin <T> .ParseStringSpan;
if (builtInMethod != null)
{
return(value => builtInMethod(Serializer.UnescapeSafeString(value)));
}
if (type.HasGenericType())
{
if (type.IsOrHasGenericInterfaceTypeOf(typeof(IList <>)))
{
return(DeserializeList <T, TSerializer> .ParseStringSpan);
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(IDictionary <,>)))
{
return(DeserializeDictionary <TSerializer> .GetParseStringSpanMethod(type));
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(ICollection <>)))
{
return(DeserializeCollection <TSerializer> .GetParseStringSpanMethod(type));
}
if (type.HasAnyTypeDefinitionsOf(typeof(Queue <>)) ||
type.HasAnyTypeDefinitionsOf(typeof(Stack <>)))
{
return(DeserializeSpecializedCollections <T, TSerializer> .ParseStringSpan);
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(KeyValuePair <,>)))
{
return(DeserializeKeyValuePair <TSerializer> .GetParseStringSpanMethod(type));
}
if (type.IsOrHasGenericInterfaceTypeOf(typeof(IEnumerable <>)))
{
return(DeserializeEnumerable <T, TSerializer> .ParseStringSpan);
}
var customFn = DeserializeCustomGenericType <TSerializer> .GetParseStringSpanMethod(type);
if (customFn != null)
{
return(customFn);
}
}
var pclParseFn = PclExport.Instance.GetJsReaderParseStringSpanMethod <TSerializer>(typeof(T));
if (pclParseFn != null)
{
return(pclParseFn);
}
var isDictionary = typeof(T) != typeof(IEnumerable) && typeof(T) != typeof(ICollection) &&
(typeof(T).IsAssignableFrom(typeof(IDictionary)) || typeof(T).HasInterface(typeof(IDictionary)));
if (isDictionary)
{
return(DeserializeDictionary <TSerializer> .GetParseStringSpanMethod(type));
}
var isEnumerable = typeof(T).IsAssignableFrom(typeof(IEnumerable)) ||
typeof(T).HasInterface(typeof(IEnumerable));
if (isEnumerable)
{
var parseFn = DeserializeSpecializedCollections <T, TSerializer> .ParseStringSpan;
if (parseFn != null)
{
return(parseFn);
}
}
if (type.IsValueType)
{
//at first try to find more faster `ParseStringSpan` method
var staticParseStringSpanMethod = StaticParseMethod <T> .ParseStringSpan;
if (staticParseStringSpanMethod != null)
{
return(value => staticParseStringSpanMethod(Serializer.UnescapeSafeString(value)));
}
//then try to find `Parse` method
var staticParseMethod = StaticParseMethod <T> .Parse;
if (staticParseMethod != null)
{
return(value => staticParseMethod(Serializer.UnescapeSafeString(value).ToString()));
}
}
else
{
var staticParseStringSpanMethod = StaticParseRefTypeMethod <TSerializer, T> .ParseStringSpan;
if (staticParseStringSpanMethod != null)
{
return(value => staticParseStringSpanMethod(Serializer.UnescapeSafeString(value)));
}
var staticParseMethod = StaticParseRefTypeMethod <TSerializer, T> .Parse;
if (staticParseMethod != null)
{
return(value => staticParseMethod(Serializer.UnescapeSafeString(value).ToString()));
}
}
var typeConstructor = DeserializeType <TSerializer> .GetParseStringSpanMethod(TypeConfig <T> .GetState());
if (typeConstructor != null)
{
return(typeConstructor);
}
var stringConstructor = DeserializeTypeUtils.GetParseStringSpanMethod(type);
return(stringConstructor ?? DeserializeType <TSerializer> .ParseAbstractType <T>);
}
public async Task <TOutResult> PostAsync <TOutResult>(string url, string content, DeserializeType deserializeType = DeserializeType.JsonDeserialize, X509Certificate2 cert = null) where TOutResult : class, new()
{
var client = _httpClientFactory.CreateClient();
//HttpResponseMessage sendCertResponse = new HttpResponseMessage();
if (cert != null)
{
var request = new HttpRequestMessage()
{
RequestUri = new Uri(url),
Method = HttpMethod.Get,
};
request.Headers.Add("X-ARR-ClientCert", cert.GetRawCertDataString());
var sendCertResponse = await client.SendAsync(request);
if (!sendCertResponse.IsSuccessStatusCode)
{
throw new ASampleException("certificate is error");
}
}
HttpContent httpContent = null;
if (!string.IsNullOrEmpty(content))
{
httpContent = new StringContent(content);
}
var response = await client.PostAsync(url, httpContent);
if (response.StatusCode != HttpStatusCode.OK)
{
return(null);
}
var resultStr = await response.Content.ReadAsStringAsync();
TOutResult result = new TOutResult();
switch (deserializeType)
{
case DeserializeType.JsonDeserialize:
result = JsonConvert.DeserializeObject <TOutResult>(resultStr);
break;
case DeserializeType.XmlDeserialize:
var xmlSerialize = new XmlSerialize();
result = xmlSerialize.Deserialize <TOutResult>(resultStr);
break;
default:
break;
}
return(result);
}
internal static int Register <T, TSerializer>() where TSerializer : ITypeSerializer
{
var i = 0;
if (JsonWriter <T> .WriteFn() != null)
{
i++;
}
if (JsonWriter.Instance.GetWriteFn <T>() != null)
{
i++;
}
if (JsonReader.Instance.GetParseFn <T>() != null)
{
i++;
}
if (JsonReader <T> .Parse(null) != null)
{
i++;
}
if (JsonReader <T> .GetParseFn() != null)
{
i++;
}
//if (JsWriter.GetTypeSerializer<JsonTypeSerializer>().GetWriteFn<T>() != null) i++;
if (new List <T>() != null)
{
i++;
}
if (new T[0] != null)
{
i++;
}
JsConfig <T> .ExcludeTypeInfo = false;
if (JsConfig <T> .OnDeserializedFn != null)
{
i++;
}
if (JsConfig <T> .HasDeserializeFn)
{
i++;
}
if (JsConfig <T> .SerializeFn != null)
{
i++;
}
if (JsConfig <T> .DeSerializeFn != null)
{
i++;
}
//JsConfig<T>.SerializeFn = arg => "";
//JsConfig<T>.DeSerializeFn = arg => default(T);
if (TypeConfig <T> .Properties != null)
{
i++;
}
// zhaojh
//if ( WriteType<T, TSerializer>.testsAOT != null ) i++;
// AOT for ServiceStack.Text.Common.ParseMethodUtilities+<GetParseFn>
Func <string, T> t = x => default(T);
DeserializeType <TSerializer> .ParseAbstractType <T> (null);
//*
if (WriteType <T, TSerializer> .Write != null)
{
i++;
}
if (WriteType <object, TSerializer> .Write != null)
{
i++;
}
if (DeserializeBuiltin <T> .Parse != null)
{
i++;
}
if (DeserializeArray <T[], TSerializer> .Parse != null)
{
i++;
}
DeserializeType <TSerializer> .ExtractType(null);
DeserializeArrayWithElements <T, TSerializer> .ParseGenericArray(null, null);
DeserializeCollection <TSerializer> .ParseCollection <T>(null, null, null);
DeserializeListWithElements <T, TSerializer> .ParseGenericList(null, null, null);
SpecializedQueueElements <T> .ConvertToQueue(null);
SpecializedQueueElements <T> .ConvertToStack(null);
//*/
WriteListsOfElements <T, TSerializer> .WriteList(null, null);
WriteListsOfElements <T, TSerializer> .WriteIList(null, null);
WriteListsOfElements <T, TSerializer> .WriteEnumerable(null, null);
WriteListsOfElements <T, TSerializer> .WriteListValueType(null, null);
WriteListsOfElements <T, TSerializer> .WriteIListValueType(null, null);
WriteListsOfElements <T, TSerializer> .WriteGenericArrayValueType(null, null);
WriteListsOfElements <T, TSerializer> .WriteArray(null, null);
TranslateListWithElements <T> .LateBoundTranslateToGenericICollection(null, null);
TranslateListWithConvertibleElements <T, T> .LateBoundTranslateToGenericICollection(null, null);
QueryStringWriter <T> .WriteObject(null, null);
return(i);
}