Como desenvolvedor, você deve ter se esforçado para acelerar a comunicação entre o cliente e o servidor em algum momento. Sobrecargas de rede, atrasos e latência sempre foram as principais preocupações e tudo se resume a uma única pergunta – Como podemos agilizar os pedidos? Toneladas de soluções são encontradas ao longo do tempo, mas a resposta que estamos focando aqui é Compressão e Serialização Compacta. Sorte para você, NCache fornece compressão eficiente e técnicas de serialização compacta dinâmica (FYI, ambas são coisas diferentes). Neste blog, veremos a necessidade de ambos e como eles podem ser usados.
Serialização Compacta Dinâmica
NCache fornece suporte para o formato de serialização .NET nativo, no entanto, também fornece sua própria estrutura de serialização chamada serialização compacta. A serialização compacta também é uma serialização binária, mas NCache fornece muito mais flexibilidade com essa estrutura de serialização. A serialização compacta não reduz o tamanho de todos os dados, apenas reduz o tamanho dos dados que são trafegados pela rede. Ele ajuda você a obter uma melhor funcionalidade, pois as viagens de rede são mais rápidas e o custo é reduzido.
Agora vamos ver os benefícios da serialização compacta dinâmica e como ela é mais flexível do que a serialização .NET nativa:
Tamanho de dados compacto
In NCache, os dados serializados binários são compactos em tamanho. Quando serializados, esses objetos às vezes se tornam dez vezes menores do que seus tamanhos de dados reais. Quanto menor o tamanho, mais rápido os dados trafegam pela rede, aumentando assim o desempenho. Além disso, quando os dados são mais compactos, eles ocupam menos espaço no servidor de cache, tornando a memória eficiente também.
Não requer alteração de código
Para tornar seus dados compactos serializados, não é necessária nenhuma alteração no código. Tudo o que você precisa fazer é selecionar os dados serializáveis usando ferramentas de gerenciamento (NCache Gerenciador de Web ou NCache ferramentas PowerShell). NCache manipula internamente toda a serialização dos dados, portanto, nenhuma alteração no código é necessária.
Serialização Seletiva
A serialização seletiva significa que o usuário tem todo o controle sobre quais dados precisam ser serializados e quais dados precisam ser marcados como não serializados. Dentro de uma classe, você pode selecionar atributos a serem serializados, por exemplo, vamos supor que você deseja manter os objetos de conexão do banco de dados como não serializados. Você pode simplesmente serializar outros atributos e manter os dados desejados não serializados.
Para obter um controle refinado sobre quais dados serializar, a interface ICompactSerializable é implementada. Isso lhe dá um maior controle sobre os dados e serialização seletiva. A classe personalizada precisa dos métodos serialize/deserialize que são chamados por NCache para serializar/desserializar os objetos. Veja o exemplo de código abaixo para ver como a interface ICompactSerializable é implementada:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
public class Customers : ICompactSerializable { private string _name; private int _id; private string _company; public Customers() { } public Customers(string customerName, int customerID, string companyName) { _name = customerName; _id = customerID; _company = companyName; } #region ICompactSerializable Members public void Deserialize(CompactReader reader) { _name = reader.ReadObject() as string; _id = reader.ReadInt32(); _company = reader.ReadObject() as string; } public void Serialize(CompactWriter writer){ writer.WriteObject(_name); writer.Write(_id); writer.Write(_company); } #endregion } |
NCache também permite registrar classes genéricas para serialização compacta. Existem duas maneiras de registrar classes genéricas, ou seja, através do NCache Web Manager ou através da interface IGenericTypeProvider.
- Através da NCache Web Manager
Você pode registrar classes genéricas usando NCache Gerenciador da Web como mostrado abaixo:
Etapa 2: por meio de IGenericTypeProvider
Para implementar isso, o usuário precisa implementar o método GetGenericTypes e retornar os tipos genéricos desejados como um array.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
public class CustomerPurchaseDetails<T, K, V> { // implement logic } public class CustomerPurchaseImpl : IGenericTypeProvider { Type[] types = new Type[6]; Type[] IGenericTypeProvider.GetGenericTypes() { types[0] = typeof(Dictionary<string, Customer>); types[1] = typeof(List); types[2] = typeof(CustomerPurchaseDetails<Order, Product, Customer>); types[3] = typeof(CustomerPurchaseDetails<Order, Product, int>); types[4] = typeof(CustomerPurchaseDetails<Order, string, byte>); types[5] = typeof(CustomerPurchaseDetails<string, Customer, bool>); return types; } public bool CheckIfSerializable(Type type, FieldInfo fieldInfo) { // implement logic } } |
Depois disso, implante este assembly de classe para NCache Gerenciador Web. NCache O Web Manager registrará todos os tipos preenchidos na matriz Type.
Documentos de serialização compactos Registrar aulas genéricas Registrar Aulas Não Genéricas
Compressão
Outra técnica eficaz fornecida por NCache is compressão de dados onde os dados em formato compactado são adicionados ao cache. A maior vantagem é que os dados compactados ocupam menos espaço do que os dados não compactados e economizam muita memória. Reduz o custo de rede de suas operações de leitura/gravação. Assim, o que você economiza é o custo da rede, o tempo e a memória com eficiência simplesmente usando a compactação.
NCache usa a compactação GZip para compactar os dados. Você decide um determinado valor de limite e, para compactação ativada, todos os itens que excedem o limite são compactados. Comparamos os dados compactados e não compactados e o uso de memória por cada um. Você pode ver os resultados no gráfico abaixo. A linha azul mostra o consumo de memória com dados compactados e a laranja mostra o tamanho do cache com dados não compactados:
A compactação geralmente ocorre no lado do cliente, bem como no lado do servidor, uma vez que a compactação está habilitada no ambos o servidor e o lado do cliente.
- Compressão do lado do cliente é aplicado em todos os itens que são solicitados pelo cliente do servidor. O servidor compacta os dados e os envia ao cliente e o cliente os descompacta ao receber os dados compactados. Da mesma forma, para itens que ultrapassam o limite, enviados pelo cliente ao servidor remoto, os dados são enviados na forma compactada.
- Compressão do lado do servidor ocorre para todos os itens que excedem o limite e são carregados da fonte de dados pelos recursos do lado do servidor, como o carregador de inicialização do cache. Esses itens são então compactados em NCache servidores após recebê-los da fonte de dados.
Compressão em NCache Docs Ativar/Desativar compactação
Para usar a compactação, tudo o que você precisa fazer é habilitar a compactação e há duas maneiras eficazes de fazê-lo.
Método 1: Usando o NCahe Web Manager
O gif abaixo mostra como habilitar a compressão usando NCache Gerente da web:
Método 2: usando a configuração
Um arquivo de configuração instalado em NCache diretório de instalação, chamado config.ncconf contém uma tag que habilita e desabilita a compactação para você. Deixa-me mostrar-te como:
1 |
<compression enabled="true" threshold="500kb"/> |
A tag enabled é definida como true para habilitar a compactação e false caso você queira desabilitar a compactação. Ele também fornece a tag de limite e os dados acima do valor fornecido são compactados apenas.
Conclusão
Concluindo, a compactação e a serialização compacta são técnicas muito eficazes para melhorar o desempenho do seu aplicativo. Também é muito fácil habilitar esses recursos usando NCache ferramentas de gerenciamento. NCache ajuda você a conseguir tudo isso com apenas nenhuma alteração de código. Por favor consulte NCache documentação para conferir outros NCache características.
NCache Adicionar ao carrinho Baixar NCache Comparação de edições