字段临时缓存包装器

最新推荐文章于 2024-09-30 16:29:12 发布
最新推荐文章于 2024-09-30 16:29:12 发布
阅读量273 收藏 5
点赞数 4
分类专栏： 个人研究 文章标签： 缓存 字段缓存 包装器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hgf1037882434/article/details/142652083
版权

前言

在实际开发中，我们有时候存在一种需求，例如对于某个字段，我们希望在某个明确的保存节点前对字段的修改都仅作为缓存保留，最终是否应用这些修改取决于某些条件，比如玩家对游戏设置的修改可能需要玩家明确确认应用修改后才会保存下来，在此之前玩家在游戏界面上的所有修改都是临时的。

本文基于这个需求探索出了一种解决方案“字段临时缓存包装器”，通过创建字段或用于存储字段临时数据的数据结构的副本来实现临时缓存，虽然我们同样可以采用直接声明一个副本字段的方式来达到同样的目的，但是这可能会增加冗余代码，且不利于代码的维护，通过包装器来封装临时缓存的通用逻辑，与具体业务逻辑隔离。

代码

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using Newtonsoft.Json;

/// <summary>
/// 临时包装器
/// </summary>
/// <typeparam name="T">字段类型</typeparam>
/// <remarks>
/// 该类主要用于创造某个字段的副本作为该字段的临时缓存，避免直接修改源字段。
/// </remarks>
public class TempWrapper<T> : IDisposable
{
    /// <summary>
    /// 是否为值类型
    /// <para>提示：若为true则表示包装字段为值类型，否则为引用类型</para>
    /// </summary>
    public static bool isValueType => _isValueType;

    /// <summary>
    /// 缓存字段
    /// <para>提示：对于值类型而言，该属性涉及拷贝</para>
    /// </summary>
    public T value
    {
        get
        {
            if (_isDisposed) throw new InvalidOperationException("The wrapper is disposed.");
            return _value;
        }
        set
        {
            if (_isDisposed) throw new InvalidOperationException("The wrapper is disposed.");
            _value = value;
        }
    }

    /// <summary>
    /// 获取引用
    /// <para>提示：对于值类型而言，该属性直接返回引用从而避免拷贝</para>
    /// </summary>
    public ref T refrence
    {
        get
        {
            if (_isDisposed) throw new InvalidOperationException("The wrapper is disposed.");
            return ref _value;
        }
    }

    /// <summary>
    /// 是否已经释放
    /// </summary>
    public bool isDisposed => _isDisposed;

    static readonly bool _isValueType = typeof(T).IsValueType;
    static readonly bool _isDisposable = typeof(IDisposable).IsAssignableFrom(typeof(T));
    static readonly object _key = new object();
    T _value;
    bool _isDisposed;

    TempWrapper() { }

    /// <summary>
    /// 包装指定字段并返回包装类
    /// </summary>
    /// <param name="value">待包装字段的引用</param>
    /// <remarks>
    /// <para>提示：采用二进制序列化和反序列化生成字段副本</para>
    /// <para>提示：该方法仅可用于被 <c>Serializable</c> 标记的字段类型</para>
    /// </remarks>
    public static TempWrapper<T> WrapByBinary(ref T value)
    {
        lock (_key)
        {
            try
            {
                TempWrapper<T> wrapper = new TempWrapper<T>();

                if (_isValueType) wrapper._value = value;
                else
                {
                    using (MemoryStream ms = new MemoryStream())
                    {
                        IFormatter formatter = new BinaryFormatter();
                        formatter.Serialize(ms, value);
                        ms.Seek(0, SeekOrigin.Begin);
                        wrapper._value = (T)formatter.Deserialize(ms);
                    }
                }

                return wrapper;
            }
            catch (Exception e)
            {
                throw new InvalidOperationException("Failed to wrap.", e);
            }

        }
    }

    /// <summary>
    /// 包装指定字段并返回包装类
    /// <para>提示：采用JSON序列化和反序列化生成字段副本</para>
    /// </summary>
    /// <param name="value">待包装字段的引用</param>
    public static TempWrapper<T> WrapByJson(ref T value)
    {
        lock (_key)
        {
            try
            {
                TempWrapper<T> wrapper = new TempWrapper<T>();

                if (_isValueType) wrapper._value = value;
                else
                {
                    string jsonStr = JsonConvert.SerializeObject(value);
                    wrapper._value = JsonConvert.DeserializeObject<T>(jsonStr);
                }

                return wrapper;
            }
            catch (Exception e)
            {
                throw new InvalidOperationException("Failed to wrap.", e);
            }
        }
    }

    /// <summary>
    /// 包装生成器所生成的字段并返回包装类
    /// </summary>
    /// <param name="creator">生成器</param>
    public static TempWrapper<T> WrapByCustom(Func<T> creator)
    {
        lock (_key)
        {
            try
            {
                TempWrapper<T> wrapper = new TempWrapper<T>() { _value = creator() };
                return wrapper;
            }
            catch (Exception e)
            {
                throw new InvalidOperationException("Failed to wrap.", e);
            }
        }
    }

    /// <summary>
    /// 解包包装器并赋值给指定的字段
    /// </summary>
    /// <remarks>
    /// <para>提示：采用二进制序列化和反序列化解包</para>
    /// <para>提示：该方法仅可用于被 <c>Serializable</c> 标记的字段类型</para>
    /// </remarks>
    public void UnWrapByBinary(ref T value)
    {
        if (_isValueType) value = _value;
        else
        {
            lock (_key)
            {
                using (MemoryStream ms = new MemoryStream())
                {
                    IFormatter formatter = new BinaryFormatter();
                    formatter.Serialize(ms, _value);
                    ms.Seek(0, SeekOrigin.Begin);
                    value = (T)formatter.Deserialize(ms);
                }
            }
        }
    }

    /// <summary>
    /// 解包包装器并赋值给指定的字段
    /// <para>提示：采用JSON序列化和反序列化解包</para>
    /// </summary>
    public void UnwrapByJson(ref T value)
    {
        if (_isValueType) value = _value;
        else
        {
            lock (_key)
            {
                string jsonStr = JsonConvert.SerializeObject(_value);
                value = JsonConvert.DeserializeObject<T>(jsonStr);
            }
        }
    }

    /// <summary>
    /// 释放包装器所包装的字段
    /// <para>提示：当所包装字段实现了IDisposable接口时该方法才有效</para>
    /// </summary>
    public void Dispose()
    {
        if (_isDisposed) return;

        DoDispose(true);
        GC.SuppressFinalize(this);
    }

    void DoDispose(bool disposing)
    {
        if (_isDisposed) return;

        _isDisposed = true;
        if (disposing && _isDisposable && _value is IDisposable ds)
            ds.Dispose();
    }

    ~TempWrapper()
    {
        DoDispose(false);
    }
}

测试

#if UNITY_EDITOR
using System;
using System.Collections.Generic;
using System.Text;
using UnityEngine;

// TempWrapper测试脚本
public class TempWrapperTest : MonoBehaviour
{
    [SerializeField] int[] intArray;
    [SerializeField] string[] strArray;
    [SerializeField] StructA[] structaArray;
    [SerializeField] ClassA classA;
    [SerializeField] StructA structA;
    [SerializeField] Transform tf;

    [Serializable]
    struct StructA
    {
        public string key;
        public int value;

        public override string ToString()
        {
            return $"(key:{key},value:{value})";
        }
    }

    [Serializable]
    class ClassA
    {
        public string key;
        public StructA structA;

        public override string ToString()
        {
            StringBuilder builder = new StringBuilder("[key:");
            builder.Append(key).Append(",").Append($"StructA:{structA}");
            builder.Append("]");
            return builder.ToString();
        }
    }

    TempWrapper<int[]> intArrayWrapper;
    TempWrapper<string[]> strArrayWrapper;
    TempWrapper<StructA[]> structaArrayWrapper;
    TempWrapper<ClassA> classaWrapper;
    TempWrapper<StructA> structaWrapper;
    TempWrapper<Transform> tfWrapper;

    void Awake()
    {
        intArrayWrapper = TempWrapper<int[]>.WrapByBinary(ref intArray);
        strArrayWrapper = TempWrapper<string[]>.WrapByBinary(ref strArray);
        structaArrayWrapper = TempWrapper<StructA[]>.WrapByBinary(ref structaArray);
        classaWrapper = TempWrapper<ClassA>.WrapByBinary(ref classA);
        structaWrapper = TempWrapper<StructA>.WrapByBinary(ref structA);
        tfWrapper = TempWrapper<Transform>.WrapByCustom(() => Instantiate(tf));
    }

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Q))
        {
            PrintWrapper();
            PrintHashCode();
            PrintWrapperHashCode();
        }

        if (Input.GetKeyDown(KeyCode.W))
        {
            WriteWrapper();
            UnWrap();
        }
    }

    void PrintWrapper()
    {
        intArrayWrapper.value.LogC("IntArrayWrapper:");
        strArrayWrapper.value.LogC("StrArrayWrapper:");
        structaArrayWrapper.value.LogC(s => $"[key:{s.key},value:{s.value}]", "StructaArrayWrapper:");
        LogUtility.Log("ClassAWrapper:" + classaWrapper.value);
        LogUtility.Log("StructAWrapper:" + structaWrapper.value);
        LogUtility.Log("TfWrapper:" + tfWrapper.value.position);
    }

    void PrintHashCode()
    {
        LogUtility.Log("IntArray:" + intArray.GetHashCode());
        LogUtility.Log("StrArray:" + strArray.GetHashCode());
        LogUtility.Log("StructaArray:" + structaArray.GetHashCode());
        LogUtility.Log("ClassA:" + classA.GetHashCode());
        LogUtility.Log("StructA:" + structA.GetHashCode());
        LogUtility.Log("Tf:" + tf.GetHashCode());
    }

    void PrintWrapperHashCode()
    {
        LogUtility.Log("IntArrayWrapper:" + intArrayWrapper.value.GetHashCode());
        LogUtility.Log("StrArrayWrapper:" + strArrayWrapper.value.GetHashCode());
        LogUtility.Log("StructaArrayWrapper:" + structaArrayWrapper.value.GetHashCode());
        LogUtility.Log("ClassAWrapper:" + classaWrapper.value.GetHashCode());
        LogUtility.Log("StructAWrapper:" + structaWrapper.value.GetHashCode());
        LogUtility.Log("TfWrapper:" + tfWrapper.value.GetHashCode());
    }

    void WriteWrapper()
    {
        List<int> ints = new List<int>(intArrayWrapper.value) { 99, 100 };
        intArrayWrapper.value = ints.ToArray();

        List<string> strs = new List<string>(strArrayWrapper.value) { "D", "E" };
        strArrayWrapper.value = strs.ToArray();

        List<StructA> strcutAs = new List<StructA>(structaArrayWrapper.value)
        {
            new StructA { key = "D", value = 99 },
            new StructA { key = "E", value = 100 }
        };
        structaArrayWrapper.value = strcutAs.ToArray();

        structaWrapper.refrence.key = "E";
        structaWrapper.refrence.value = 1000;

        classaWrapper.value.key = "DE";
        classaWrapper.value.structA.key = "D";
        classaWrapper.value.structA.value = 999;

        tfWrapper.value.position = Vector3.zero;
    }

    void UnWrap()
    {
        intArrayWrapper.UnWrapByBinary(ref intArray);
        strArrayWrapper.UnWrapByBinary(ref strArray);
        structaArrayWrapper.UnWrapByBinary(ref structaArray);
        structaWrapper.UnWrapByBinary(ref structA);
        classaWrapper.UnWrapByBinary(ref classA);
    }
}
#endif
用例ID用例名称前者测试预期结果是否通过
1简单值类型数组无可缓存通过
2不可变引用类型数组无可缓存通过
3复合值类型数组无可缓存通过
4自定义引用类型无可缓存通过
5自定义值类型无可缓存通过
6Unity对象无可缓存通过

分析

字段临时缓存包装器有三种包装字段的方式，分别是WrapByBinary、WrapByJson和WrapByCustom，三种方式各有优缺点，择优而用。WrapByBinary采用二进制序列化和反序列化生成字段副本，该方法仅可用于被 Serializable 标记的字段类型。WrapByJson采用JSON序列化和反序列化生成字段副本，它虽然比前者包装范围更广，但是不可避免可能会依赖第三方用于JSON序列化和反序列化的库。WrapByCustom则是对前两种方式的补充，当前两种方式都不适用时，则可以自定义包装方式，例如对于Unity对象来说，需要通过Instantiate方法创建对象副本，这个时候就只能用自定义的方法进行包装。

返回的包装器提供了一些属性和方法，可用于判断是否为值类型、缓存的字段和缓存字段的引用（值类型），提供了针对WrapByBinary和WrapByJson包装方法的解包方法，还提供了显式释放包装器的方法。对于包装值类型时，我们可以通过获取缓存字段的引用来避免拷贝，解包方法用于将临时缓存的数据重新写入被包装字段中。通过显式释放包装器可以保证那些使用了非托管资源的类型（实现了IDisposable接口）进行资源的释放工作，从而避免内存泄漏等问题。

但是该包装器存在一些不可避免的限制，若所包装字段越复杂，其性能损耗越高，这是不可避免的。而对于复杂类型，建议自定义一个数据结构作为临时缓存的包装类型。

版本改进

......

系列文章

......

如果这篇文章对你有帮助，请给作者点个赞吧！

我与岁月的森林
关注
专栏目录
MyBatis一级缓存和二级缓存
Mr.xing的博客
04-03 1万+
Mybatis缓存
Ignite分布式缓存框架
JOHN
12-22 626
1.前言 Apache Ignite是一个分布式数据库，支持以内存级的速度进行高性能计算。 2。快速入门 本章节介绍运行Ignite的系统要求，如何安装，启动一个集群，然后运行一个简单的HelloWorld示例。 2.1.环境要求 Apache Ignite官方在如下环境中进行了测试： JDK：Oracle JDK8及11，Open JDK8及11，IBM JDK8及11； OS：Linux（任何版本），Mac OS X（10.6及以上），Windows(XP及以上)，Windows Se
Redis 缓存
sinat_34814635的博客
01-08 3836
缓存类型 客户端缓存 对于BS架构的互联网应用来说客户端缓存主要分为页面缓存和浏览器缓存两种，对于APP而言主要是自身所使用的缓存。 清理缓存的方式： 以网页浏览器为例 1.使用Ctrl+F5可以强制刷新浏览器本地缓存 2.浏览器中的参数设置的时间已过期如：Expires，Cache-control: max-age， Last-Modified标签等 网络中缓存 网络中的缓存主要是指代理服务器对...
黑马点评项目笔记（二）缓存问题（缓存穿透、缓存雪崩、缓存击穿、添加缓存、修改缓存）
m0_52889702的博客
11-09 911
redis缓存读写缓存整体流程添加店铺读写缓存添加店铺类型读写缓存更新缓存更新缓存策略更新店铺缓存缓存问题缓存穿透缓存空对象布隆过滤在读取店铺中防止缓存穿透缓存雪崩缓存击穿互斥锁互斥锁的表示添加店铺查询热点key过期问题逻辑过期添加店铺查询热点key过期问题互斥锁与逻辑删除对比
大型web系统数据缓存设计
yoko_luo的专栏
09-18 8176
【IT168 技术】在高访问量的web系统中，缓存几乎是离不开的;但是一个适当、高效的缓存方案设计却并不容易;所以接下来将讨论一下应用系统缓存的设计方面应该注意哪些东西，包括缓存的选型、常见缓存系统的特点和数据指标、缓存对象结构设计和失效策略以及缓存对象的压缩等等，以期让有需求的同学尤其是初学者能够快速、系统的了解相关知识。 　　数据库的瓶颈 　　1 数据量 　　关系
hibernate 缓存
maxcode
04-11 3633
简介缓存 缓存是广泛使用的用于优化数据库应用程序。缓存的目的是减少你的应用程序，并通过保存从数据库已加载数据的数据库之间的流量。检索数据当前未在高速缓存仅当数据库访问是必要的。应用程序可能需要从时间空（无效）的高速缓存，以时间，如果该数据库被更新或以某种方式修改，因为它无法知道缓存是否是最新的方式。 Hibernate的缓存 Hibernate使用的对象两个不同的缓存：一级缓存和二级缓存。第
从缓存文件的角度帮你理解 Okhttp3 缓存原理
Strange_Monkey的博客
01-28 885
文章目录1. 需要了解的概念1.2 Okio1.1 DiskLruCache1.2.1 日志文件 journal1.2.2 DiskLruCache.Entry1.2.3 DiskLruCache.SnapShot1.2.3 DiskLruCache.Editor2. 缓存实现的有关流程1. 触发之后拦截器之前的操作1.1 日志文件的初始化1. App 启动后的初始化1.1 若 journal ...
前端面试题考点之 通信（渲染、http、缓存、异步、跨域、安全）
luemeon的博客
04-03 4309
接收方创建一。
mybatis源码解析(二) 解读一、二级缓存
ynwrd_的博客
06-10 674
mybaits一级缓存 一级缓存也叫会话级缓存，它的生命周期仅存在于当前的会话。它在我们的
mybaits源码分析（五） 一级缓存、二级缓存最详细讲解
shuixiou1的博客
02-04 347
mybaits源码分析（五） 一级缓存、二级缓存详解 前言：上一篇讲解了mybaits数据源，这一篇讲解一下mybaits一级缓存、二级缓存的基本使用，以及主要实现。 本篇主要分为下面几个部分： 一级缓存、二级缓存的使用及测试 mybaits缓存相关类的介绍 一级缓存详解 二级缓存详解 一、一级缓存、二级缓存的使用及测试 在mybaits中，一级缓存是默认开启的，缓存的生命周期是sqlsession级别的，二级缓存全局配置是默认开启的，但是需要另外在namespace中也开启才可以使用二
深入探索 Android Gradle 插件的缓存配置
谷歌开发者
11-06 1051
什么是配置缓存？配置缓存是一个提升 IDE 和命令行构建速度的基础构建块。这是 Gradle 6.6 版本提供的一个高度实验性功能，它可以使构建系统记录一次任务的图谱信息，并在接下来的构...
36-Mybatis（ssm及微服务入门，临时）
weixin_42688085的博客
02-14 800
1、Mybatis概述 1.1 Mybatis概念    一个基于 Java 的持久层框架。包括 SQL Maps 和 Data Access Objects（DAO）。    Mybatis 基于java的持久层框架，它的内部封装了JDBC，让开发人员只需要关注SQL语句本身，不需要花费精力在驱动的加载、连接的创建、Statement的创建等复杂的过程。    Mybatis通过XML或注解的方式将要执行的各种的st
系统缓存设计
TangXiaoPang的博客
02-26 1258
写的很全面，也很深入。看完一遍不够，所以转载一下   1. 前言 在高访问量的web系统中，缓存几乎是离不开的；但是一个适当、高效的缓存方案设计却并不容易；所以接下来将讨论一下应用系统缓存的设计方面应该注意哪些东西，包括缓存的选型、常见缓存系统的特点和数据指标、缓存对象结构设计和失效策略以及缓存对象的压缩等等，以期让有需求的同学尤其是初学者能够快速、系统的了解相关知识。   2. 数据库...
Linux 性能优化之CPU 多级缓存
山河已无恙
09-30 482
博文内容为 Linux CPU 多级缓存认知内容涉及：什么是CPU多级缓存认知，CPU 硬件缓存信息，缓存流程写入策略，映射算法认知CPU 缓存分析，使用 valgring 和 Perf 分析CPU 缓存命中情况编码方面 CPU 缓存优化，数据指令缓存，多核缓存命中率优化方式理解不足小伙伴帮忙指正 😃,生活加油哦99%的焦虑都来自于虚度时间和没有好好做事，所以唯一的解决办法就是行动起来，认真做完事情，战胜焦虑，战胜那些心里空荡荡的时刻，而不是选择逃避。
缓存是什么？缓存机制、Spring缓存管理、Redis数据一致性、缓存问题（缓存穿透、缓存雪崩、缓存击穿）及Redis与MySQL使用场景对比
项目git同名HuYaochao，未入职
09-30 928
缓存机制、Spring缓存管理、Redis数据一致性、缓存问题（缓存穿透、缓存雪崩、缓存击穿）及Redis与MySQL使用场景对比
Redis篇（缓存机制 - 多级缓存）（持续更新迭代）
最新发布
wlcass zhengge blog
09-30 1166
官方网站：
vue使用indexedDB缓存教程
m0_56104994的博客
09-24 411
前端采用indexedDB缓存
动手测试：CPU的L1~L3级缓存和内存的读取速度测试
hebhljdx的博客
09-30 788
在许多文章中指出CPU的L1~3和内存的缓存的架构，速度差异等。纸上得来终觉浅，今天想实际写代码简单测试一下。
Elasticsearch的字段数据缓存如何配置？
03-02
Elasticsearch的字段数据缓存可以通过配置来进行优化。字段数据缓存是指将经常使用的字段值加载到内存中，以加快查询速度。以下是配置字段数据缓存的方法： 1. fielddata： - 在映射中将字段的fielddata属性设置为true，即可启用字段数据缓存。例如： ``` PUT my_index { "mappings": { "properties": { "my_field": { "type": "text", "fielddata": true } } } } ``` - 通过修改现有映射或创建新的映射来启用字段数据缓存。 2. index.fielddata.cache： - 可以通过修改elasticsearch.yml配置文件来配置字段数据缓存的大小。找到该文件并添加以下配置： ``` index.fielddata.cache.size: 50% ``` - 这将为字段数据缓存分配索引可用内存的50%。 3. 查询时禁用字段数据缓存： - 对于某些查询，禁用字段数据缓存可能更合适。可以在查询中使用`fielddata_fields`参数来禁用字段数据缓存。例如： ``` GET my_index/_search { "query": { "match_all": {} }, "fielddata_fields": ["my_field"] } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值