【BeetleX重构】内存读写扩展类分享

最新推荐文章于 2024-06-15 23:32:37 发布
最新推荐文章于 2024-06-15 23:32:37 发布
阅读量22 收藏
点赞数
文章标签： 重构
原文链接：https://mp.weixin.qq.com/s?__biz=MzAwNTMxMzg1MA==&mid=2654099454&idx=8&sn=bd722f6b285f226fc13bae91be06b367&chksm=816eace59abd80374f5e9a4c98012838ba0a77b45feabebd9672ba6de55fe71b97692e44ffe0&scene=126&sessionid=0
版权

        既然是编写网络服务那对于网络数据读写分析是肯定少不了的，毕竟在编写程序中的数据类型最终都需要转化成相应的内存储方式进行交换。程序中常用的基础有:int,uint,ulong,string等；而编程语言中内存的存储方式一般都是用Byte[]来表示，不过随着C#的不停发展为了方便管理操作派生出Span<byte>,ReadOnlySequence<byte>,Stream等操作结构；然而这些存储结构都是基于Byte[]基础类型操作，要想和数据类型进行转换而需要其他的API来处理。
        为了简化新版本BeetleX编写协议分析和为后期扩展使用的便利性出发，针对Byte[],Span<byte>,ReadOnlySequence<byte>和Stream等结构封装了一些基础类型转换的扩展方法，这样在使用起来就变得非常方便了(这些函数都支持Big Endian 和Little Endian,默认是Little Endian)。 
以下是这个扩展类的一个类型单元测试方法

[Test]
public void Int_RW()
{
    byte[] buffer = new byte[4];
    Span<byte> span = buffer;
    ReadOnlySpan<byte> rspan = span;
    MemoryStream stream = new MemoryStream();
    int[] values = [int.MaxValue, int.MinValue, 1, -1, 345, 5678, -1224];
    int result;
    for (int i = 0; i < values.Length; i++)
    {
        buffer.Write(0, values[i]);
        result = buffer.ReadInt32(0);
        Assert.AreEqual(result, values[i]);
        buffer.Write(0, values[i], false);
        result = buffer.ReadInt32(0, false);
        Assert.AreEqual(result, values[i]);




        span.Write(values[i]);
        result = rspan.ReadInt32();
        Assert.AreEqual(result, values[i]);
        span.Write(values[i], false);
        result = rspan.ReadInt32(false);
        Assert.AreEqual(result, values[i]);


        stream.Position = 0;
        stream.Write(values[i]);
        stream.Position = 0;
        result = stream.ReadInt32();
        Assert.AreEqual(result, values[i]);
        stream.Position = 0;
        stream.Write(values[i], false);
        stream.Position = 0;
        result = stream.ReadInt32(false);
        Assert.AreEqual(result, values[i]);
    }
}

接下来就是完全整的扩展类，内容有些多：

using System;
using System.Buffers;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;


namespace BeetleX.Light.Extension
{
    public static class BeetlexMemoryExtend
    {
        [ThreadStatic]
        static byte[] _bytes2;


        [ThreadStatic]
        static byte[] _bytes4;


        [ThreadStatic]
        static byte[] _bytes8;


        public static byte[] Get2Bytes()
        {
            if (_bytes2 == null)
                _bytes2 = new byte[2];
            return _bytes2;
        }
        public static byte[] Get4Bytes()
        {
            if (_bytes4 == null)
                _bytes4 = new byte[4];
            return _bytes4;
        }
        public static byte[] Get8Bytes()
        {
            if (_bytes8 == null)
                _bytes8 = new byte[8];
            return _bytes8;
        }




        public static short SwapInt16(short v)
        {
            return (short)(((v & 0xff) << 8) | ((v >> 8) & 0xff));
        }


        public static ushort SwapUInt16(ushort v)
        {
            return (ushort)(((v & 0xff) << 8) | ((v >> 8) & 0xff));
        }


        public static int SwapInt32(int v)
        {
            return (int)(((SwapInt16((short)v) & 0xffff) << 0x10) |
                          (SwapInt16((short)(v >> 0x10)) & 0xffff));
        }


        public static uint SwapUInt32(uint v)
        {
            return (uint)(((SwapUInt16((ushort)v) & 0xffff) << 0x10) |
                           (SwapUInt16((ushort)(v >> 0x10)) & 0xffff));
        }


        public static long SwapInt64(long v)
        {
            return (long)(((SwapInt32((int)v) & 0xffffffffL) << 0x20) |
                           (SwapInt32((int)(v >> 0x20)) & 0xffffffffL));
        }


        public static ulong SwapUInt64(ulong v)
        {
            return (ulong)(((SwapUInt32((uint)v) & 0xffffffffL) << 0x20) |
                            (SwapUInt32((uint)(v >> 0x20)) & 0xffffffffL));
        }




        public static void Write(this Span<byte> _buffer, short value, bool littleEndian = true)
        {
            if (!littleEndian)
                value = SwapInt16(value);
            _buffer[0] = (byte)value;
            _buffer[1] = (byte)(value >> 8);
        }


        public static void Write(this Stream _buffer, short value, bool littleEndian = true)
        {
            var bytes = Get2Bytes();
            Write(bytes, value, littleEndian);
            _buffer.Write(bytes);


        }


        public static void Write(this Span<byte> _buffer, ushort value, bool littleEndian = true)
        {
            if (!littleEndian)
                value = SwapUInt16(value);
            _buffer[0] = (byte)value;
            _buffer[1] = (byte)(value >> 8);


        }


        public static void Write(this Stream _buffer, ushort value, bool littleEndian = true)
        {
            var bytes = Get2Bytes();
            Write(bytes, value, littleEndian);
            _buffer.Write(bytes);


        }


        public static void Write(this Span<byte> _buffer, int value, bool littleEndian = true)
        {
            if (!littleEndian)
                value = SwapInt32(value);
            _buffer[0] = (byte)value;
            _buffer[1] = (byte)(value >> 8);
            _buffer[2] = (byte)(value >> 16);
            _buffer[3] = (byte)(value >> 24);


        }


        public static void Write(this Stream _buffer, int value, bool littleEndian = true)
        {
            var bytes = Get4Bytes();
            Write(bytes, value, littleEndian);
            _buffer.Write(bytes);
        }


        public static void Write(this Span<byte> _buffer, uint value, bool littleEndian = true)
        {
            if (!littleEndian)
                value = SwapUInt32(value);
            _buffer[0] = (byte)value;
            _buffer[1] = (byte)(value >> 8);
            _buffer[2] = (byte)(value >> 16);
            _buffer[3] = (byte)(value >> 24);


        }


        public static void Write(this Stream _buffer, uint value, bool littleEndian = true)
        {
            var bytes = Get4Bytes();
            Write(bytes, value, littleEndian);
            _buffer.Write(bytes);
        }


        public static void Write(this Span<byte> _buffer, long value, bool littleEndian = true)
        {
            if (!littleEndian)
                value = SwapInt64(value);
            _buffer[0] = (byte)value;
            _buffer[1] = (byte)(value >> 8);
            _buffer[2] = (byte)(value >> 16);
            _buffer[3] = (byte)(value >> 24);
            _buffer[4] = (byte)(value >> 32);
            _buffer[5] = (byte)(value >> 40);
            _buffer[6] = (byte)(value >> 48);
            _buffer[7] = (byte)(value >> 56);


        }


        public static void Write(this Stream _buffer, long value, bool littleEndian = true)
        {
            var bytes = Get8Bytes();
            Write(bytes, value, littleEndian);
            _buffer.Write(bytes);
        }


        public static void Write(this Span<byte> _buffer, ulong value, bool littleEndian = true)
        {
            if (!littleEndian)
                value = SwapUInt64(value);
            _buffer[0] = (byte)value;
            _buffer[1] = (byte)(value >> 8);
            _buffer[2] = (byte)(value >> 16);
            _buffer[3] = (byte)(value >> 24);
            _buffer[4] = (byte)(value >> 32);
            _buffer[5] = (byte)(value >> 40);
            _buffer[6] = (byte)(value >> 48);
            _buffer[7] = (byte)(value >> 56);


        }


        public static void Write(this Stream _buffer, ulong value, bool littleEndian = true)
        {
            var bytes = Get8Bytes();
            Write(bytes, value, littleEndian);
            _buffer.Write(bytes);
        }


        public static void Write(this byte[] _buffer, int postion, short value, bool littleEndian = true)
        {
            if (!littleEndian)
                value = SwapInt16(value);
            _buffer[postion + 0] = (byte)value;
            _buffer[postion + 1] = (byte)(value >> 8);
        }


        public static void Write(this byte[] _buffer, int postion, ushort value, bool littleEndian = true)
        {
            if (!littleEndian)
                value = SwapUInt16(value);
            _buffer[postion + 0] = (byte)value;
            _buffer[postion + 1] = (byte)(value >> 8);


        }


        public static void Write(this byte[] _buffer, int postion, int value, bool littleEndian = true)
        {
            if (!littleEndian)
                value = SwapInt32(value);
            _buffer[postion + 0] = (byte)value;
            _buffer[postion + 1] = (byte)(value >> 8);
            _buffer[postion + 2] = (byte)(value >> 16);
            _buffer[postion + 3] = (byte)(value >> 24);


        }


        public static void Write(this byte[] _buffer, int postion, uint value, bool littleEndian = true)
        {
            if (!littleEndian)
                value = SwapUInt32(value);
            _buffer[postion + 0] = (byte)value;
            _buffer[postion + 1] = (byte)(value >> 8);
            _buffer[postion + 2] = (byte)(value >> 16);
            _buffer[postion + 3] = (byte)(value >> 24);


        }


        public static void Write(this byte[] _buffer, int postion, long value, bool littleEndian = true)
        {
            if (!littleEndian)
                value = SwapInt64(value);
            _buffer[postion + 0] = (byte)value;
            _buffer[postion + 1] = (byte)(value >> 8);
            _buffer[postion + 2] = (byte)(value >> 16);
            _buffer[postion + 3] = (byte)(value >> 24);
            _buffer[postion + 4] = (byte)(value >> 32);
            _buffer[postion + 5] = (byte)(value >> 40);
            _buffer[postion + 6] = (byte)(value >> 48);
            _buffer[postion + 7] = (byte)(value >> 56);


        }


        public static void Write(this byte[] _buffer, int postion, ulong value, bool littleEndian = true)
        {
            if (!littleEndian)
                value = SwapUInt64(value);
            _buffer[postion + 0] = (byte)value;
            _buffer[postion + 1] = (byte)(value >> 8);
            _buffer[postion + 2] = (byte)(value >> 16);
            _buffer[postion + 3] = (byte)(value >> 24);
            _buffer[postion + 4] = (byte)(value >> 32);
            _buffer[postion + 5] = (byte)(value >> 40);
            _buffer[postion + 6] = (byte)(value >> 48);
            _buffer[postion + 7] = (byte)(value >> 56);


        }


        public static int Write(this Stream _buffer, string value, Encoding encoding)
        {
            if (string.IsNullOrEmpty(value))
                return 0;
            int result = 0;
            using (TemporaryBuffer<byte> bytes = value.Length * 6)
            {
                result = encoding.GetBytes(value, 0, value.Length, bytes.Data, 0);
                _buffer.Write(bytes.Data, 0, result);
                return result;
            }
        }


        public static int Write(this Span<byte> _buffer, string value, Encoding encoding)
        {
            if (string.IsNullOrEmpty(value))
                return 0;
            return encoding.GetBytes(value, _buffer);
        }


        public static int Write(this byte[] _buffer, int postion, string value, Encoding encoding)
        {
            if (string.IsNullOrEmpty(value))
                return 0;
            return encoding.GetBytes(value, 0, value.Length, _buffer, 0);
        }


        public static short ReadInt16(this byte[] m_buffer, int postion, bool littleEndian = true)
        {


            var result = (short)((int)m_buffer[postion + 0] | (int)m_buffer[postion + 1] << 8);
            if (!littleEndian)
                result = SwapInt16(result);
            return result;
        }


        public static ushort ReadUInt16(this byte[] m_buffer, int postion, bool littleEndian = true)
        {


            var result = (ushort)((int)m_buffer[postion + 0] | (int)m_buffer[postion + 1] << 8);
            if (!littleEndian)
                result = SwapUInt16(result);
            return result;
        }


        public static int ReadInt32(this byte[] m_buffer, int postion, bool littleEndian = true)
        {


            var result = (int)m_buffer[postion + 0] | (int)m_buffer[postion + 1] << 8 | (int)m_buffer[postion + 2] << 16 | (int)m_buffer[postion + 3] << 24;
            if (!littleEndian)
                result = SwapInt32(result);
            return result;
        }


        public static uint ReadUInt32(this byte[] m_buffer, int postion, bool littleEndian = true)
        {


            var result = (uint)((int)m_buffer[postion + 0] | (int)m_buffer[postion + 1] << 8 | (int)m_buffer[postion + 2] << 16 | (int)m_buffer[postion + 3] << 24);
            if (!littleEndian)
                result = SwapUInt32(result);
            return result;
        }
        public static long ReadInt64(this byte[] m_buffer, int postion, bool littleEndian = true)
        {


            uint num = (uint)((int)m_buffer[postion + 0] | (int)m_buffer[postion + 1] << 8 | (int)m_buffer[postion + 2] << 16 | (int)m_buffer[postion + 3] << 24);
            uint num2 = (uint)((int)m_buffer[postion + 4] | (int)m_buffer[postion + 5] << 8 | (int)m_buffer[postion + 6] << 16 | (int)m_buffer[postion + 7] << 24);
            var result = (long)((ulong)num2 << 32 | (ulong)num);
            if (!littleEndian)
                result = SwapInt64(result);
            return result;
        }


        public static ulong ReadUInt64(this byte[] m_buffer, int postion, bool littleEndian = true)
        {


            uint num = (uint)((int)m_buffer[postion + 0] | (int)m_buffer[postion + 1] << 8 | (int)m_buffer[postion + 2] << 16 | (int)m_buffer[postion + 3] << 24);
            uint num2 = (uint)((int)m_buffer[postion + 4] | (int)m_buffer[postion + 5] << 8 | (int)m_buffer[postion + 6] << 16 | (int)m_buffer[postion + 7] << 24);
            var result = (ulong)num2 << 32 | (ulong)num;
            if (!littleEndian)
                result = SwapUInt64(result);
            return result;
        }


        public static short ReadInt16(this ReadOnlySequence<byte> buffer, bool littleEndian = true)
        {
            short result = 0;
            if (buffer.FirstSpan.Length >= 2)
                result = ReadInt16(buffer.FirstSpan);
            else
            {
                result = (short)(
                    (int)buffer.FirstSpan[0] |
                    (int)buffer.Slice(1).FirstSpan[0] << 8
                    );
            }
            if (!littleEndian)
                result = SwapInt16(result);
            return result;
        }
        public static short ReadInt16(this Stream m_buffer, bool littleEndian = true)
        {
            var bytes = Get2Bytes();
            m_buffer.Read(bytes);
            return ReadInt16(bytes, littleEndian);
        }
        public static short ReadInt16(this ReadOnlySpan<byte> m_buffer, bool littleEndian = true)
        {
            var result = (short)((int)m_buffer[0] | (int)m_buffer[1] << 8);
            if (!littleEndian)
                result = SwapInt16(result);
            return result;
        }


        public static ushort ReadUInt16(this ReadOnlySequence<byte> m_buffer, bool littleEndian = true)
        {
            ushort result = 0;
            if (m_buffer.FirstSpan.Length >= 2)
                result = ReadUInt16(m_buffer.FirstSpan);
            else
                result = (ushort)(
                    (int)m_buffer.FirstSpan[0] |
                    (int)m_buffer.Slice(1).FirstSpan[0] << 8);
            if (!littleEndian)
                result = SwapUInt16(result);
            return result;
        }
        public static ushort ReadUInt16(this Stream m_buffer, bool littleEndian = true)
        {
            var bytes = Get2Bytes();
            m_buffer.Read(bytes);
            return ReadUInt16(bytes, littleEndian);
        }
        public static ushort ReadUInt16(this ReadOnlySpan<byte> m_buffer, bool littleEndian = true)
        {


            var result = (ushort)((int)m_buffer[0] | (int)m_buffer[1] << 8);
            if (!littleEndian)
                result = SwapUInt16(result);
            return result;
        }






        public static int ReadInt32(this Stream m_buffer, bool littleEndian = true)
        {
            var bytes = Get4Bytes();
            m_buffer.Read(bytes);
            return ReadInt32(bytes, littleEndian);
        }
        public static int ReadInt32(this ReadOnlySequence<byte> m_buffer, bool littleEndian = true)
        {
            int result = 0;
            if (m_buffer.FirstSpan.Length >= 4)
                result = ReadInt32(m_buffer.FirstSpan);
            else
            {
                var bytes = Get4Bytes();
                m_buffer.CopyTo(bytes);
                result = ReadInt32(bytes);
            }
            if (!littleEndian)
                result = SwapInt32(result);
            return result;
        }
        public static int ReadInt32(this ReadOnlySpan<byte> m_buffer, bool littleEndian = true)
        {
            var result = (int)m_buffer[0] | (int)m_buffer[1] << 8 | (int)m_buffer[2] << 16 | (int)m_buffer[3] << 24;
            if (!littleEndian)
                result = SwapInt32(result);
            return result;
        }


        public static uint ReadUInt32(this Stream m_buffer, bool littleEndian = true)
        {
            var bytes = Get4Bytes();
            m_buffer.Read(bytes);
            return ReadUInt32(bytes, littleEndian);
        }
        public static uint ReadUInt32(this ReadOnlySequence<byte> m_buffer, bool littleEndian = true)
        {
            UInt32 result = 0;
            if (m_buffer.FirstSpan.Length >= 4)
                result = ReadUInt32(m_buffer.FirstSpan);
            else
            {
                var bytes = Get4Bytes();
                m_buffer.CopyTo(bytes);
                result = ReadUInt32(bytes);
            }
            if (!littleEndian)
                result = SwapUInt32(result);
            return result;
        }
        public static uint ReadUInt32(this ReadOnlySpan<byte> m_buffer, bool littleEndian = true)
        {
            var result = (uint)((int)m_buffer[0] | (int)m_buffer[1] << 8 | (int)m_buffer[2] << 16 | (int)m_buffer[3] << 24);
            if (!littleEndian)
                result = SwapUInt32(result);
            return result;
        }


        public static long ReadInt64(this Stream m_buffer, bool littleEndian = true)
        {
            var bytes = Get8Bytes();
            m_buffer.Read(bytes);
            return ReadInt64(bytes, littleEndian);
        }
        public static long ReadInt64(this ReadOnlySequence<byte> m_buffer, bool littleEndian = true)
        {
            Int64 result = 0;
            if (m_buffer.FirstSpan.Length >= 8)
                result = ReadInt64(m_buffer.FirstSpan);
            else
            {
                var bytes = Get8Bytes();
                m_buffer.CopyTo(bytes);
                result = ReadInt64(bytes);
            }
            if (!littleEndian)
                result = SwapInt64(result);
            return result;
        }
        public static long ReadInt64(this ReadOnlySpan<byte> m_buffer, bool littleEndian = true)
        {
            uint num = (uint)((int)m_buffer[0] | (int)m_buffer[1] << 8 | (int)m_buffer[2] << 16 | (int)m_buffer[3] << 24);
            uint num2 = (uint)((int)m_buffer[4] | (int)m_buffer[5] << 8 | (int)m_buffer[6] << 16 | (int)m_buffer[7] << 24);
            var result = (long)((ulong)num2 << 32 | (ulong)num);
            if (!littleEndian)
                result = SwapInt64(result);
            return result;
        }




        public static ulong ReadUInt64(this Stream m_buffer, bool littleEndian = true)
        {
            var bytes = Get8Bytes();
            m_buffer.Read(bytes);
            return ReadUInt64(bytes, littleEndian);
        }
        public static ulong ReadUInt64(this ReadOnlySequence<byte> m_buffer, bool littleEndian = true)
        {
            ulong result = 0;
            if (m_buffer.FirstSpan.Length >= 8)
                result = ReadUInt64(m_buffer.FirstSpan);
            else
            {
                var bytes = Get8Bytes();
                m_buffer.CopyTo(bytes);
                result = ReadUInt64(bytes);
            }
            if (!littleEndian)
                result = SwapUInt64(result);
            return result;
        }
        public static ulong ReadUInt64(this ReadOnlySpan<byte> m_buffer, bool littleEndian = true)
        {


            uint num = (uint)((int)m_buffer[0] | (int)m_buffer[1] << 8 | (int)m_buffer[2] << 16 | (int)m_buffer[3] << 24);
            uint num2 = (uint)((int)m_buffer[4] | (int)m_buffer[5] << 8 | (int)m_buffer[6] << 16 | (int)m_buffer[7] << 24);
            var result = (ulong)num2 << 32 | (ulong)num;
            if (!littleEndian)
                result = SwapUInt64(result);
            return result;
        }


        public static string ReadString(this byte[] _buffer, int postion, int count, Encoding coding)
        {


            return coding.GetString(_buffer, postion, count);
        }
        public static string ReadString(this ReadOnlySpan<byte> _buffer, Encoding coding)
        {
            return coding.GetString(_buffer);
        }
        public static string ReadString(this Stream _buffer, int count, Encoding coding)
        {
            using (TemporaryBuffer<byte> bytes = count)
            {
                _buffer.Read(bytes.Data, 0, count);
                return coding.GetString(bytes.Data, 0, count);
            }
        }
        public static string ReadString(this ReadOnlySequence<byte> _buffer, Encoding coding)
        {
            return coding.GetString(_buffer);
        }
    }
}
BeetleX

开源跨平台通讯框架(支持TLS)

提供HTTP,Websocket,MQTT,Redis,RPC和服务网关开源组件

个人微信:henryfan128    QQ:28304340

关注公众号

7592911c3ae60242caf86f01534bb1e3.jpeg

https://github.com/beetlex-io/

dotNET跨平台
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【经验分享】嵌入式C语言开发如何有效地排查内存泄露的疑难问题？
一个专注于嵌入式IoT领域的架构师，深耕IoT领域多年，深度掌握IoT领域的相关技术栈，包括但不限于RTOS内核的实现及其移植、硬件驱动移植开发、网络通讯协议开发、编译构建原理及其实现、底层汇编及编译原理、编译优化及代码重构、嵌入式IoT系统的架构设计等。
09-13 2万+
在嵌入式开发中，相信大家都遇到过内存泄露这类疑难问题，你的排查方法和解决思路是怎么样的呢？本文将给大家分享一种我个人常用的一种方法，这个方法看似很“挫”，but it works well ！
重构笔记——提炼类
皮斯特劳沃
01-23 3407
本文是在学习中的总结，欢迎转载但请注明出处：http://blog.csdn.net/pistolove/article/details/43059759         在上一篇文章中介绍了“搬移字段”。本文将介绍“提炼类”这种重构手法。         下面让我们来学习这种重构手法吧。 开门见山         发现：某个类做了应该由两个类做的事
重构笔记——将类内联化
皮斯特劳沃
01-26 3288
本文是在学习中的总结，欢迎转载但请注明出处：http://blog.csdn.net/pistolove/article/details/43159817         在上一篇文章中介绍了“提炼类”。本文将介绍“将类内联化”这种重构手法。         下面让我们来学习这种重构手法吧。 开门见山         发现：某个类并没有做太多的事情。         解决：将这个类的所有特性搬移到另一个类中，然后移除原类。 动机
重构笔记——引入本地扩展
皮斯特劳沃
04-09 2408
本文是在学习中的总结，欢迎转载但请注明出处：http://blog.csdn.net/pistolove/article/details/44958839         在上一篇文章中介绍了“引入外加函数”。本文将介绍“引入本地扩展”这种重构手法。         下面让我们来学习这种重构手法吧。 开门见山         发现：你需要为服务类提供一些额外函数，但你无法修改这个类。         解决：建立一个新类，使它包含这些额外函数。让这个扩展品成
IDEA代码重构技巧--抽取类和接口
左撇子帕布
08-21 3644
重构和检视代码过程中，我们有时会碰到由于项目交接或者人员替换导致的代码腐化，比较常见的是类的职责不单一，此时比较好的重构技巧就是按照职责抽取函数或者类，进而还要分析一下是不是可以抽象一下，提取接口。
每周分享一本实用电子书——重构
论程序员的自我修养的博客
04-10 2861
本次分享的书籍是： 重构——改善既有代码设计 获取方式： 关注微信公众号：论程序员的自我修养 后台回复重构获取。
一次代码重构之旅-快速读写xml文件工具类封装
李坤 大米时代 第五期
11-24 5352
为了满足系统的灵活性,有些功能经常需要用到配置文件,一般是xml格式的居多.如何能快速读写配置文件呢?    以前都是用dom4j提供的api来读写xml文件,用dom4j读写配置文件总感觉像是在结构化的处理问题,能不能直接把xml文件和JavaBean之间相互转换呢?答案肯定是可以,xstream中提供了很简单的方式将二者转化,感觉这样才像面向对象化处理问题. xstream知识点简单总
架构师修炼系列【架构重构】
热门推荐
Davieyang.D.Y
09-20 1万+
系统的架构师不断演化的，少部分架构演化可能需要推倒重来进行重写，但大部分的架构演化都是通过架构重构来实现的
关于《重构的时机与方法》这本书给我的感悟
编码世界
07-25 4682
在软件开发中,我们将问题放在下图所示的某个位置，表明缺乏足够的技能、文化、工具或这些问题的组合。重构是一项复杂的工作，因此处于中间位置。
重构心得分享----拆分循环
WWW_share8的博客
11-20 2992
最近自己再看《重构-改善既有代码的设计》，这是一本关于如何让大家去发现需要重构的代码和如何去进行重构。 先分享一个今天刚刚看的，标题叫拆分循环，作者认为一个循环里面尽可能的只做一件事情。 举一个粒子，比如一个循环里面有两件事，一个是计算收入总值（数据累加），一个是找出最小收入 let total = 0 let data = [15, 25, 3, 65, 15] let min = da...
摄屏类图像重构算法
05-06
针对该类图像摩尔纹干扰以及内存过大、图像短焦距畸等现象，本文首次提出了摄屏类图像重构算法.首先，通过长度自适应的线型滤波算法分离网状高频信号.再通过快速Greedy算法和贝努利随机游走提取图像的高频信息，根据...
流星全自动网页生成系统重构版源码分享
01-14
流星全自动网页生成系统重构版源码分享，所有模板经过精心审核与修改，完美兼容小屏手机大屏手机，以及各种平板端、电脑端和360浏览器、谷歌浏览器、火狐浏览器等等各大浏览器显示。为用户使用方便考虑，全自动网页...
JS前端框架关于重构的失败经验分享
10-27
关于重构JS前端框架的失败经验接下来与大家分享一下，感兴趣的你可不要错过了哈，毕竟是经验之谈哈
架构与代码质量重构实践
08-03
架构与代码质量重构实践
【Vue】登录功能中对于错误提示信息的重构
Jerryqjr的博客
06-15 621
在 Axios 中，res 和 e 参数分别代表成功的响应对象和错误对象。这些参数是由 Axios 在请求完成时传递给响应拦截器函数的。让我们深入了解一下这些参数是从哪里来的，以及 Axios 如何处理它们。res 和 e 参数的来源成功的响应 (res)当 Axios 发出一个 HTTP 请求并成功接收到服务器的响应时，它会将该响应对象传递给 onFulfilled 函数。这个响应对象包含了从服务器返回的所有数据和元信息。res => res.data, // `res` 是成功的响应对象。
重构与优化-优化函数调用（5）
艾利克斯冰的博客
06-15 39
Replace Parameter with Explicit Methods（使用显式方法替换参数）是另一种代码重构技术，它的目标是消除方法中的多路分支逻辑，通过为每个分支创建独立的方法来提高代码的清晰度和可维护性。Replace Parameter with Methods（以方法取代参数）是一种重构技术，主要用于当一个方法根据传入的参数值执行不同的逻辑时，将该方法拆分为几个独立的方法，每个方法对应一种特定的参数值处理逻辑。这样的转换通常暗示着设计上的不足，比如过强的类型耦合或不恰当的抽象。
ffmpeg封装和解封装介绍-（8）解封装和封装重构
m0_51386664的博客
06-15 169
重新生成了一个名字为test_mux.mp4文件。
利用机器学习重构视频中的人脸
最新发布
知来者逆的博客
06-15 399
传统的参数化面孔技术越来越多地被用作利用人工智能（AI）而非计算机生成图像（CGI）的变革性过程的指导原则。在这项研究中，作者们提出了一个目标：“我们的目标是根据现实世界中的自然面部变形编辑人像面部的整体形状，生成高质量的人像视频重塑结果。这可用于诸如用于美化的匀称脸部生成和用于视觉效果的脸部夸张等应用。自从Photoshop这类图像编辑软件普及以来，消费者已经能够对2D图像进行面部扭曲和变形的操作。然而，这些操作有时会导致不自然甚至令人难以接受的结果，特别是当涉及到身体畸形的图像处理时。
根据上述需要重构这个工具类
05-31
好的，针对同时包含 XLSX 格式和 XLS 格式的 Excel 文件进行处理，可以考虑重构一个工具类，具体如下： ```python import os import xlrd import xlwt from openpyxl import load_workbook class ExcelUtil: @...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值