public static void SetJsonPropertyValuesForOptionalMember <T>(string memberName, JsonProperty jsonProperty)
{
if (jsonProperty.ShouldSerialize == null) // Honor ShouldSerialize*
{
jsonProperty.ShouldSerialize =
(declaringObject) =>
{
if (jsonProperty.GetIsSpecified != null && jsonProperty.GetIsSpecified(declaringObject)) // Honor *Specified
{
return(true);
}
object optionalValue;
if (!TryGetPropertyValue(declaringObject, memberName, out optionalValue) &&
!TryGetFieldValue(declaringObject, memberName, out optionalValue))
{
throw new InvalidOperationException("Better error message here");
}
return(((Optional <T>)optionalValue).ValueProvided);
};
}
if (jsonProperty.Converter == null)
{
jsonProperty.Converter = CustomContractResolver.GetOptionalJsonConverter <T>();
}
}
public override string SerializeDataToJson(Type classType, object data, object transaction, OperationType operationType, string synchronizationId, Dictionary <string, object> customInfo)
{
List <string> ignoreProperties = new List <string>();
ignoreProperties.Add("SynchronizationID");
if (classType == typeof(SyncDepartment))
{
ignoreProperties.Add("Employees");
}
if (classType == typeof(SyncEmployee))
{
ignoreProperties.Add("Department");
}
if (!customContractResolvers.ContainsKey(classType))
{
customContractResolvers.Add(classType, new CustomContractResolver(null, ignoreProperties));
}
CustomContractResolver customContractResolver = customContractResolvers[classType];
string json = JsonConvert.SerializeObject(data, new JsonSerializerSettings()
{
ContractResolver = customContractResolver
});
return(json);
}
/// <summary>
///
/// </summary>
/// <param name="knownTypes"></param>
/// <param name="enableUriTemplate"></param>
public WebHttpJsonNetBehavior2(IEnumerable <Type> knownTypes, bool enableUriTemplate = true)
: base(knownTypes, enableUriTemplate)
{
SerializerSettings serializerInfo = this.ConfigRegister.SerializerConfig;
CustomContractResolver resolver = new CustomContractResolver(true, false, this.ConfigRegister.TryToNormalize)
{
DefaultMembersSearchFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public
};
this.Serializer = new JsonSerializer
{
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
TypeNameHandling = TypeNameHandling.None,
ContractResolver = resolver
};
if (!serializerInfo.OnlyPublicConstructor)
{
Serializer.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
}
if (serializerInfo.EnablePolymorphicMembers)
{
Serializer.Binder = new OperationTypeBinder(this.ConfigRegister);
Serializer.TypeNameHandling = TypeNameHandling.Objects;
}
}
public static string SerializeObject(object obj, int maxDepth)
{
/*
* var settings = new Newtonsoft.Json.JsonSerializerSettings()
* {
* ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore,
* MaxDepth = 1,
*
* Error = (sender, errorArgs) => {
* var currentError = errorArgs.ErrorContext.Error.Message;
* errorArgs.ErrorContext.Handled = true;
* }
* };
*/
using (var strWriter = new StringWriter())
{
using (var jsonWriter = new CustomJsonTextWriter(strWriter))
{
Func <bool> include = () => jsonWriter.CurrentDepth <= maxDepth;
var resolver = new CustomContractResolver(include);
var serializer = new JsonSerializer()
{
ContractResolver = resolver, Formatting = Formatting.Indented, ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
serializer.Serialize(jsonWriter, obj);
}
return(strWriter.ToString());
}
}
public RabbitMqEndpointBehavior(IEnumerable <Type> knownTypes)
{
this.ConfigRegister = ConfigurationManager.GetSection("serviceTypeRegister") as ServiceTypeRegister
?? new ServiceTypeRegister();
SerializerSettings serializerInfo = this.ConfigRegister.SerializerConfig;
CustomContractResolver resolver = new CustomContractResolver(true, false, this.ConfigRegister.TryToNormalize)
{
DefaultMembersSearchFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public
};
this.Serializer = new JsonSerializer
{
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
TypeNameHandling = TypeNameHandling.None,
ContractResolver = resolver
};
if (!serializerInfo.OnlyPublicConstructor)
{
Serializer.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
}
if (serializerInfo.EnablePolymorphicMembers)
{
Serializer.Binder = new OperationTypeBinder(this.ConfigRegister);
Serializer.TypeNameHandling = TypeNameHandling.Objects;
}
}
private static JsonSerializerSettings GenerateSerializationSettings()
{
var contractResolver = new CustomContractResolver();
return(new JsonSerializerSettings {
ContractResolver = contractResolver
});
}
public static string SerializeObject(object value)
{
JsonSerializerSettings settings = new()
{
ContractResolver = new CustomContractResolver(),
Formatting = Formatting.Indented
};
return(JsonConvert.SerializeObject(value, settings));
}
static JsonSerializerService()
{
jsonSerializer = new()
{
NullValueHandling = NullValueHandling.Ignore,
Formatting = Formatting.Indented,
ContractResolver = new CustomContractResolver()
};
jsonSerializer.Converters.Insert(0, new CustomDateTimeConverter());
jsonSerializer.Converters.Add(new StringEnumConverter());
}
public override string SerializeDataToJson(Type classType, object data, object transaction, OperationType operationType, string synchronizationId, Dictionary <string, object> customInfo)
{
if (!customContractResolvers.ContainsKey(classType))
{
customContractResolvers.Add(classType, new CustomContractResolver(classType));
}
CustomContractResolver customContractResolver = customContractResolvers[classType];
string json = JsonConvert.SerializeObject(data, new JsonSerializerSettings()
{
ContractResolver = customContractResolver
});
return(json);
}
private string SerializeObject(object obj, int maxDepth)
{
using (var strWriter = new StringWriter())
{
using (var jsonWriter = new CustomJsonTextWriter(strWriter))
{
var resolver = new CustomContractResolver(() => jsonWriter.CurrentDepth <= maxDepth);
var serializer = new JsonSerializer {
ContractResolver = resolver, ReferenceLoopHandling = ReferenceLoopHandling.Ignore, Formatting = Formatting.Indented
};
serializer.Serialize(jsonWriter, obj);
}
return(strWriter.ToString());
}
}
/// <summary>
/// Seralize object
/// </summary>
private string SerializeObjectWithoutCollections(object obj)
{
using (var strWriter = new StringWriter())
{
var resolver = new CustomContractResolver();
var serializer = new JsonSerializer
{
ContractResolver = resolver,
Formatting = Formatting.Indented
};
serializer.Serialize(strWriter, obj);
return(strWriter.ToString());
}
}
public static string SerializeObject(object obj, int maxDepth)
{
using (var strWriter = new StringWriter())
{
using (var jsonWriter = new CustomJsonTextWriter(strWriter))
{
Func <bool> include = () => jsonWriter.CurrentDepth <= maxDepth;
var resolver = new CustomContractResolver(include);
var serializer = new JsonSerializer {
ContractResolver = resolver
};
serializer.Serialize(jsonWriter, obj);
}
return(strWriter.ToString());
}
}
public string SerializeObject(object obj)
{
using (var writer = new StringWriter())
{
using (var jsonWriter = new MaxDepthJsonTextWriter(writer))
{
bool include() => jsonWriter.CurrentDepth <= Settings.MaxDepth;
ContractResolver = new CustomContractResolver(include);
ReferenceLoopHandling = Settings.ReferenceLoopHandling;
Serialize(jsonWriter, obj);
}
return(writer.ToString());
}
}
public async Task <IEnumerable <Result> > GetHeroes(string limite)
{
//if(_client == null)
//{
//_client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
//_client.BaseAddress
//}
//Posso melhorar o tratamento do handleResult
//https://dev.to/rickystam/net-core-use-httpclientfactory-and-polly-to-build-rock-solid-services-2edh
//referencia
//https://www.davidbritch.com/2017/07/transient-fault-handling-in.html
_httpRetryPolicy = Policy.HandleResult <HttpResponseMessage>(r => httpStatusCodesToRetry.Contains(r.StatusCode))
.Or <TimeoutRejectedException>()
.Or <Exception>()
//.OrResult<HttpResponseMessage>(r => httpStatusCodesToRetry.Contains(r.StatusCode))
//.Handle<HttpRequestException>(ex => !ex.Message.ToLower().Contains("404"))
.WaitAndRetryAsync
(
//Quantidade de tentaivas
retryCount: 3,
//duração entre as tentativas
sleepDurationProvider: retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
//O que será executado se der erro
onRetry: async(response, time, retryCount, context) =>
{
if (response.Exception != null)
{
Console.WriteLine($"Ocorreu um erro ao baixar os dados: {response.Exception.Message}, Tentando novamente em {time}, tentativa número: {retryCount}");
}
else
{
var rawResponse = await response.Result.Content.ReadAsStringAsync();
var json = JsonConvert.DeserializeAnonymousType(rawResponse, new { code = "", status = "" });
Console.WriteLine($"Ocorreu um erro ao baixar os dados: {json.status}, Tentando novamente em {time}, tentativa número: {retryCount}");
}
}
);
_timeoutPolicy = Policy.TimeoutAsync(5, TimeoutStrategy.Pessimistic);
try
{
//.ExecuteAsync(async () =>
//{
// Console.WriteLine($"Obtendo Herois...");
// var response = await client.GetAsync(GetUrl(limite));
// var rawResponse = await response.Content.ReadAsStringAsync();
//Problemas para retornar um await direito, a melhor opção por enquantp é deixar finalizar o metodo e retornar o objeto depois
//heroes = JsonConvert.DeserializeObject<Hero>(rawResponse);
//});
//Referencia
//https://nodogmablog.bryanhogan.net/2017/12/using-the-polly-timeout-when-making-a-http-request/
HttpResponseMessage response = await
_httpRetryPolicy.ExecuteAsync(() =>
_timeoutPolicy.ExecuteAsync(async c =>
await _client.GetAsync(GetUrl(limite), c), CancellationToken.None));
if (response.StatusCode != HttpStatusCode.OK)
{
var newtonSoft = string.IsNullOrEmpty(await response.Content.ReadAsStringAsync()) ? JsonConvert.DeserializeObject <Hero>(await response.Content.ReadAsStringAsync()) : new Hero();
return(new List <Result>().DefaultIfEmpty());
}
else
{
//Teste Jil
//Stopwatch TimerJill = new Stopwatch();
//TimerJill.Start();
//var employeeDeserialized = JSON.Deserialize<Hero>(await response.Content.ReadAsStringAsync(), new Options(dateFormat: DateTimeFormat.MicrosoftStyleMillisecondsSinceUnixEpoch));
//TimerJill.Stop();
//var tempoDecorridoJil = TimerJill.Elapsed.TotalSeconds;
var contractResolver = new CustomContractResolver();
//Teste using newtonsof
Stopwatch TimerNewton = new Stopwatch();
TimerNewton.Start();
//forma correta de utilizar, sem jogar atribuir para uma string antes de realizar a deserialização.
var newtonSoft = JsonConvert.DeserializeObject <Hero>(await response.Content.ReadAsStringAsync(), new JsonSerializerSettings {
ContractResolver = contractResolver
});
TimerNewton.Stop();
var tempoDecorridoNewton = TimerNewton.Elapsed.TotalSeconds;
Stopwatch TimerUsing = new Stopwatch();
TimerUsing.Start();
Hero hero;
//Referencia: http://jonathanpeppers.com/Blog/improving-http-performance-in-xamarin-applications
using (var stream = await response.Content.ReadAsStreamAsync())
//Referencia minBuffer https://stackoverflow.com/questions/56461022/benchmarking-newtonsoft-json-deserialization-from-stream-and-from-string
using (var reader = new StreamReader(stream, Encoding.UTF8, true, 128))
using (var jsonTextReader = new JsonTextReader(reader))
{
hero = _serializer.Deserialize <Hero>(jsonTextReader);
}
TimerUsing.Stop();
var tempoDecorridoUsing = TimerUsing.Elapsed.TotalSeconds;
string json = await response.Content.ReadAsStringAsync();
//Referencia
//https://stackoverflow.com/questions/8707755/how-to-know-the-size-of-the-string-in-bytes
var howManyBytes = json.Length * sizeof(Char);
return(newtonSoft.data.results.EmptyIfNull());
}
/*
*
*
*
*
* await Policy
* //Se for um erro diferente de 404 ira executar a politica de retry
* //podemos utilizar grupo de statusCode
* //o ideal é trabalhar em cima dos erros de internet, e continuar tratando o resto pelo statusCode
*
* //.Handle<TimeoutException>()
* .Handle<HttpRequestException>(ex => !ex.Message.ToLower().Contains("404"))
* .Or<HttpRequestException>()
* //.OrResult<HttpResponseMessage>(r => httpStatusCodesToRetry.Contains(r.StatusCode))
* //.Handle<HttpRequestException>(ex => !ex.Message.ToLower().Contains("404"))
*
* .WaitAndRetryAsync
* (
* //Quantidade de tentaivas
* retryCount: 3,
*
* //duração entre as tentativas
* sleepDurationProvider: retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
*
* //O que será executado se der erro
* onRetry: (ex, time) =>
* {
* lock (_MessageLock)
* {
* Console.BackgroundColor = ConsoleColor.Red;
* Console.WriteLine($"Ocorreu um erro ao baixar os dados: {ex.Message}, tentando novamente em...{time}");
* Console.ResetColor();
* }
* }
* )
* .ExecuteAsync(async () =>
* {
* var response = await client.GetAsync(GetUrl(limite));
* var rawResponse = await response.Content.ReadAsStringAsync();
*
* //Problemas para retornar um await direito, a melhor opção por enquantp é deixar finalizar o metodo e retornar o objeto depois
* heroes = JsonConvert.DeserializeObject<Hero>(rawResponse);
* });
*
*/
/*
* var response = await client.GetAsync(GetUrl(limite));
*
* if (response.StatusCode != System.Net.HttpStatusCode.OK)
* {
* throw new Exception(response.Content.ReadAsStringAsync().Result);
* }
* var rawResponse = await response.Content.ReadAsStringAsync();
* return JsonConvert.DeserializeObject<Hero>(rawResponse);
*
*/
//return heroes;
}
catch (Exception ex)
{
throw ex;
}
}
// Explicit static constructor to tell C# compiler not to mark type as beforefieldinit
static CustomContractResolver()
{
instance = new CustomContractResolver();
}
