[.NET]使用十年股價對比各種序列化技術

来源:https://www.cnblogs.com/dino623/archive/2018/03/12/Serialize.html
-Advertisement-
Play Games

1. 前言 上一家公司有搞股票，當時很任性地直接從伺服器讀取一個股票10年份的股價（還有各種指標）在客戶端的圖表上顯示，而且因為是桌面客戶端，傳輸的數據也是簡單粗暴地使用Soap序列化。獲取報價的介面大概如下，通過symbol、beginDate和endDate三個參數獲取股票某個時間段的股價： 後 ...


1. 前言

上一家公司有搞股票，當時很任性地直接從伺服器讀取一個股票10年份的股價（還有各種指標）在客戶端的圖表上顯示，而且因為是桌面客戶端，傳輸的數據也是簡單粗暴地使用Soap序列化。獲取報價的介面大概如下，通過symbol、beginDate和endDate三個參數獲取股票某個時間段的股價：

public IEnumerable<StockPrice> LoadStockPrices(string symbol,DateTime beginDate,DateTime endDate)
{
    //some code
}

後來用Xamarin.Forms做了移動客戶端，在手機上就不敢這麼任性了，移動端不僅對流量比較敏感，而且顯示這麼多數據也不現實，於是限製為不可以獲取這麼長時間的股價，選擇一種新的序列化方式也被提上了日程。不過當時我也快離職了所以沒關心這件事。
上周看到這篇問文章：【開源】C#.NET股票歷史數據採集，【附18年曆史數據和源代碼】，一時興起就試試用各種常用的序列化技術實現以前的需求。

2. 數據結構

[Serializable]
[ProtoContract]
[DataContract]
public class StockPrice
{
    [ProtoMember(1)]
    [DataMember]
    public double ClosePrice { get; set; }

    [ProtoMember(2)]
    [DataMember]
    public DateTime Date { get; set; }

    [ProtoMember(3)]
    [DataMember]
    public double HighPrice { get; set; }

    [ProtoMember(4)]
    [DataMember]
    public double LowPrice { get; set; }

    [ProtoMember(5)]
    [DataMember]
    public double OpenPrice { get; set; }

    [ProtoMember(6)]
    [DataMember]
    public double PrvClosePrice { get; set; }

    [ProtoMember(7)]
    [DataMember]
    public string Symbol { get; set; }

    [ProtoMember(8)]
    [DataMember]
    public double Turnover { get; set; }

    [ProtoMember(9)]
    [DataMember]
    public double Volume { get; set; }
}

上面是股價的數據結構，包含股票代號、日期、OHLC、前收市價(PreClosePice)，成交額(Turnover)和成交量(Volume)，這裡我已經把序列化要用到的Attribute加上了。

測試數據使用長和(00001)2003年開始10年的股價，共2717條數據。為了方便測試已經把它們從資料庫導出到文本文檔。其實大小也就200K而已。

3. 各種序列化技術

在.NET中要執行序列化有很多可以考慮的東西，如網路傳輸、安全性、.NET Remoting的遠程對象等內容。但這裡單純只考慮序列化本身。

3.1 二進位序列化

二進位序列化將對象的公共欄位和私有欄位以及類（包括含有該類的程式集）的名稱都轉換成位元組流，對該對象進行反序列化時，將創建原始對象的準確克隆。除了.NET可序列化的類型，其它類型要想序列化，最簡單的方法是使用 SerializableAttribute 對其進行標記。

.NET中使用BinaryFormatter實現二進位序列化，代碼如下：

public override byte[] Serialize(List<StockPrice> instance)
{
    using (var stream = new MemoryStream())
    {
        IFormatter formatter = new BinaryFormatter();
        formatter.Serialize(stream, instance);
        return stream.ToArray();
    }
}


public override List<StockPrice> Deserialize(byte[] source)
{
    using (var stream = new MemoryStream(source))
    {
        IFormatter formatter = new BinaryFormatter();
        var target = formatter.Deserialize(stream);
        return target as List<StockPrice>;
    }
}

結果：

Name Serialize(ms) Deserialize(ms) Bytes
BinarySerializer 117 12 242,460

3.2 XML

XML序列化將對象的公共欄位和屬性或者方法的參數及返回值轉換（序列化）為符合特定 XML架構定義語言 (XSD) 文檔的 XML 流。由於 XML 是開放式的標準，因此可以根據需要由任何應用程式處理 XML流，而與平臺無關。

.NET中執行Xml序列化可以使用XmlSerializer：

public override byte[] Serialize(List<StockPrice> instance)
{
    using (var stream = new MemoryStream())
    {
        var serializer = new System.Xml.Serialization.XmlSerializer(typeof(List<StockPrice>));
        serializer.Serialize(stream, instance);
        return stream.ToArray();
    }
}

public override List<StockPrice> Deserialize(byte[] source)
{
    using (var stream = new MemoryStream(source))
    {
        var serializer = new System.Xml.Serialization.XmlSerializer(typeof(List<StockPrice>));
        var target = serializer.Deserialize(stream);
        return target as List<StockPrice>;
    }
}

結果如下，因為XML格式為了有較好的可讀性引入了一些冗餘的文本信息，所以體積膨脹了不少：

Name Serialize(ms) Deserialize(ms) Bytes
XmlSerializer 133 26 922,900

3.3 SOAP

XML 序列化還可用於將對象序列化為符合 SOAP 規範的 XML 流。 SOAP 是一種基於 XML 的協議，它是專門為使用 XML 來傳輸過程調用而設計的，熟悉WCF的應該不會對SOAP感到陌生。

.NET中使用SoapFormatter實現序列化，代碼如下：

public override byte[] Serialize(List<StockPrice> instance)
{
    using (var stream = new MemoryStream())
    {
        IFormatter formatter = new SoapFormatter();
        formatter.Serialize(stream, instance.ToArray());
        return stream.ToArray();
    }
}

public override List<StockPrice> Deserialize(byte[] source)
{
    using (var stream = new MemoryStream(source))
    {
        IFormatter formatter = new SoapFormatter();
        var target = formatter.Deserialize(stream);
        return (target as StockPrice[]).ToList();
    }
}

結果如下，由於它本身的特性，體積膨脹得更可怕了（我記得WCF預設就是使用SOAP？）：

Name Serialize(ms) Deserialize(ms) Bytes
SoapSerializer 105 123 2,858,416

3.4 JSON

JSON（JavaScript Object Notation）是一種由道格拉斯·克羅克福特構想和設計、輕量級的資料交換語言，該語言以易於讓人閱讀的文字為基礎，用來傳輸由屬性值或者序列性的值組成的數據對象。

雖然.NET提供了DataContractJsonSerializer，但Json.NET更受歡迎，代碼如下：

public override byte[] Serialize(List<StockPrice> instance)
{
    using (var stream = new MemoryStream())
    {
        var serializer = new DataContractJsonSerializer(typeof(List<StockPrice>));
        serializer.WriteObject(stream, instance);
        return stream.ToArray();
    }
}

public override List<StockPrice> Deserialize(byte[] source)
{
    using (var stream = new MemoryStream(source))
    {
        var serializer = new DataContractJsonSerializer(typeof(List<StockPrice>));
        var target = serializer.ReadObject(stream);
        return target as List<StockPrice>;
    }
}

結果如下，JSON的體積比XML小很多：

Name Serialize(ms) Deserialize(ms) Bytes
JsonSerializer 40 60 504,320

3.5 Protobuf

其實一開始我和我的同事就清楚用Protobuf最好。

Protocol Buffers 是 Google提供的數據序列化機制。它性能高，壓縮效率好，但是為了提高性能，Protobuf採用了二進位格式進行編碼，導致可讀性較差。

使用protobuf-net需要將序列化的對象使用ProtoContractAttribute和ProtoMemberAttribute進行標記。序列化和反序列化代碼如下：

public override byte[] Serialize(List<StockPrice> instance)
{
    using (var stream = new MemoryStream())
    {
        Serializer.Serialize(stream, instance);
        return stream.ToArray();
    }
}

public override List<StockPrice> Deserialize(byte[] source)
{
    using (var stream = new MemoryStream(source))
    {
        return Serializer.Deserialize<List<StockPrice>>(stream);
    }
}

結果十分優秀：

Name Serialize(ms) Deserialize(ms) Bytes
ProtobufSerializer 93 18 211,926

3.6 結果對比

Name Serialize(ms) Deserialize(ms) Bytes
BinarySerializer 117 12 242,460
XmlSerializer 133 26 922,900
SoapSerializer 105 123 2,858,416
JsonSerializer 40 60 504,320
ProtobufSerializer 93 18 211,926

將上述方案的結果列出來對比，Protobuf序列化後體積最少。不過即使是Protobuf，壓縮後的數據仍然比文本文檔的200K還大，那還不如直接傳輸這個文本文檔。

4. 優化數據結構

其實傳輸的數據結構上有很大的優化空間。

首先是股票代號Symbol，前面提到獲取股價的介面大概是這樣：IEnumerable LoadStockPrices(string symbol,DateTime beginDate,DateTime endDate)。既然都知道要獲取的股票代號，StockPrice中Symbol這個屬性完全就是多餘的。

其次是OHLC和PreClosePrice，港股（不記得其它Market是不是這樣）的報價肯定是4位有效數字(如95.05和102.4)，用float精度也夠了，不必用 double。

最後是Date，反正只需要知道日期，不必知道時分秒，直接用與1970-01-01相差的天數作為存儲應該就可以了。

private static DateTime _beginDate = new DateTime(1970, 1, 1);

public DateTime Date
{
    get => _beginDate.AddDays(DaysFrom1970);
    set => DaysFrom1970 = (short) Math.Floor((value - _beginDate).TotalDays);
}

[ProtoMember(2)]
[DataMember]
public short DaysFrom1970 { get; set; }

不要以為Volume可以改為int，有些仙股有時會有幾十億的成交量，超過int的最大值2147483647（順便一提Int32的最大值是2的31次方減1，有時面試會考）。

這樣修改後的類結構如下：

[Serializable]
[ProtoContract]
[DataContract]
public class StockPriceSlim
{
    [ProtoMember(1)]
    [DataMember]
    public float ClosePrice { get; set; }

    private static DateTime _beginDate = new DateTime(1970, 1, 1);

    public DateTime Date
    {
        get => _beginDate.AddDays(DaysFrom1970);
        set => DaysFrom1970 = (short) Math.Floor((value - _beginDate).TotalDays);
    }

    [ProtoMember(2)]
    [DataMember]
    public short DaysFrom1970 { get; set; }

    [ProtoMember(3)]
    [DataMember]
    public float HighPrice { get; set; }

    [ProtoMember(4)]
    [DataMember]
    public float LowPrice { get; set; }

    [ProtoMember(5)]
    [DataMember]
    public float OpenPrice { get; set; }

    [ProtoMember(6)]
    [DataMember]
    public float PrvClosePrice { get; set; }

    [ProtoMember(8)]
    [DataMember]
    public double Turnover { get; set; }

    [ProtoMember(9)]
    [DataMember]
    public double Volume { get; set; }
}

序列化的體積大幅減少：

Name Serialize(ms) Deserialize(ms) Bytes
BinarySerializer 11 12 141,930
XmlSerializer 42 24 977,248
SoapSerializer 48 89 2,586,720
JsonSerializer 17 33 411,942
ProtobufSerializer 7 3 130,416

其實之所以有這麼大的優化空間，一來是因為傳輸的對象本身就是ORM生成的對象沒針對網路傳輸做優化，二來各個券商的數據源差不多都是這樣傳輸數據的，最後，本來這個介面是給桌面客戶端用的根本就懶得考慮傳輸數據的大小。

5. 自定義的序列化

由於股票的數據結構相對穩定，而且這個介面不需要通用性，可以自己實現序列化。StockPriceSlim所有屬性加起來是38個位元組，測試數據是2717條報價，共103246位元組，少於Protobuf的130416位元組。要達到每個報價只存儲38個位元組，只需將每個屬性的值填入固定的位置：


public override byte[] SerializeSlim(List<StockPriceSlim> instance)
{
    var list = new List<byte>();
    foreach (var item in instance)
    {
        var bytes = BitConverter.GetBytes(item.DaysFrom1970);
        list.AddRange(bytes);

        bytes = BitConverter.GetBytes(item.OpenPrice);
        list.AddRange(bytes);

        bytes = BitConverter.GetBytes(item.HighPrice);
        list.AddRange(bytes);

        bytes = BitConverter.GetBytes(item.LowPrice);
        list.AddRange(bytes);

        bytes = BitConverter.GetBytes(item.ClosePrice);
        list.AddRange(bytes);

        bytes = BitConverter.GetBytes(item.PrvClosePrice);
        list.AddRange(bytes);

        bytes = BitConverter.GetBytes(item.Volume);
        list.AddRange(bytes);

        bytes = BitConverter.GetBytes(item.Turnover);
        list.AddRange(bytes);
    }

    return list.ToArray();
}


public override List<StockPriceSlim> DeserializeSlim(byte[] source)
{
    var result = new List<StockPriceSlim>();
    var index = 0;
    using (var stream = new MemoryStream(source))
    {
        while (index < source.Length)
        {
            var price = new StockPriceSlim();
            var bytes = new byte[sizeof(short)];
            stream.Read(bytes, 0, sizeof(short));
            var days = BitConverter.ToInt16(bytes, 0);
            price.DaysFrom1970 = days;
            index += bytes.Length;

            bytes = new byte[sizeof(float)];
            stream.Read(bytes, 0, sizeof(float));
            var value = BitConverter.ToSingle(bytes, 0);
            price.OpenPrice = value;
            index += bytes.Length;

            stream.Read(bytes, 0, sizeof(float));
            value = BitConverter.ToSingle(bytes, 0);
            price.HighPrice = value;
            index += bytes.Length;

            stream.Read(bytes, 0, sizeof(float));
            value = BitConverter.ToSingle(bytes, 0);
            price.LowPrice = value;
            index += bytes.Length;

            stream.Read(bytes, 0, sizeof(float));
            value = BitConverter.ToSingle(bytes, 0);
            price.ClosePrice = value;
            index += bytes.Length;

            stream.Read(bytes, 0, sizeof(float));
            value = BitConverter.ToSingle(bytes, 0);
            price.PrvClosePrice = value;
            index += bytes.Length;

            bytes = new byte[sizeof(double)];
            stream.Read(bytes, 0, sizeof(double));
            var volume = BitConverter.ToDouble(bytes, 0);
            price.Volume = volume;
            index += bytes.Length;

            bytes = new byte[sizeof(double)];
            stream.Read(bytes, 0, sizeof(double));
            var turnover = BitConverter.ToDouble(bytes, 0);
            price.Turnover = turnover;
            index += bytes.Length;

            result.Add(price);
        }
        return result;
    }
}

結果如下：

Name Serialize(ms) Deserialize(ms) Bytes
CustomSerializer 5 1 103,246

這種方式不僅序列化後的體積最小，而且序列化和反序列化的速度都十分優秀，不過代碼十分難看而且沒有擴展性。嘗試用反射改進一下：

public override byte[] SerializeSlim(List<StockPriceSlim> instance)
{
    var result = new List<byte>();
    foreach (var item in instance)
        foreach (var property in typeof(StockPriceSlim).GetProperties())
        {
            if (property.GetCustomAttribute(typeof(DataMemberAttribute)) == null)
                continue;

            var value = property.GetValue(item);
            byte[] bytes = null;
            if (property.PropertyType == typeof(int))
                bytes = BitConverter.GetBytes((int)value);
            else if (property.PropertyType == typeof(short))
                bytes = BitConverter.GetBytes((short)value);
            else if (property.PropertyType == typeof(float))
                bytes = BitConverter.GetBytes((float)value);
            else if (property.PropertyType == typeof(double))
                bytes = BitConverter.GetBytes((double)value);
            result.AddRange(bytes);
        }

    return result.ToArray();
}

public override List<StockPriceSlim> DeserializeSlim(byte[] source)
{
    using (var stream = new MemoryStream(source))
    {
        var result = new List<StockPriceSlim>();
        var index = 0;

        while (index < source.Length)
        {
            var price = new StockPriceSlim();
            foreach (var property in typeof(StockPriceSlim).GetProperties())
            {
                if (property.GetCustomAttribute(typeof(DataMemberAttribute)) == null)
                    continue;

                byte[] bytes = null;
                object value = null;

                if (property.PropertyType == typeof(int))
                {
                    bytes = new byte[sizeof(int)];
                    stream.Read(bytes, 0, bytes.Length);
                    value = BitConverter.ToInt32(bytes, 0);
                }
                else if (property.PropertyType == typeof(short))
                {
                    bytes = new byte[sizeof(short)];
                    stream.Read(bytes, 0, bytes.Length);
                    value = BitConverter.ToInt16(bytes, 0);
                }
                else if (property.PropertyType == typeof(float))
                {
                    bytes = new byte[sizeof(float)];
                    stream.Read(bytes, 0, bytes.Length);
                    value = BitConverter.ToSingle(bytes, 0);
                }
                else if (property.PropertyType == typeof(double))
                {
                    bytes = new byte[sizeof(double)];
                    stream.Read(bytes, 0, bytes.Length);
                    value = BitConverter.ToDouble(bytes, 0);
                }

                property.SetValue(price, value);
                index += bytes.Length;
            }


            result.Add(price);
        }
        return result;
    }
}
Name Serialize(ms) Deserialize(ms) Bytes
ReflectionSerializer 413 431 103,246

好像好了一些，但性能大幅下降。我好像記得有人說過.NET會將反射緩存讓我不必擔心反射帶來的性能問題，看來我的理解有出入。索性自己緩存些反射結果：

private readonly IEnumerable<PropertyInfo> _properties;

public ExtendReflectionSerializer()
{
    _properties = typeof(StockPriceSlim).GetProperties().Where(p => p.GetCustomAttribute(typeof(DataMemberAttribute)) != null).ToList();
}
Name Serialize(ms) Deserialize(ms) Bytes
ExtendReflectionSerializer 11 11 103,246

這樣改進後性能還可以接受。

6. 最後試試壓縮

最後試試在序列化的基礎上再隨便壓縮一下：

public byte[] SerializeWithZip(List<StockPriceSlim> instance)
{
    var bytes = SerializeSlim(instance);

    using (var memoryStream = new MemoryStream())
    {
        using (var deflateStream = new DeflateStream(memoryStream, CompressionLevel.Fastest))
        {
            deflateStream.Write(bytes, 0, bytes.Length);
        }
        return memoryStream.ToArray();
    }
}

public List<StockPriceSlim> DeserializeWithZip(byte[] source)
{
    using (var originalFileStream = new MemoryStream(source))
    {
        using (var memoryStream = new MemoryStream())
        {
            using (var decompressionStream = new DeflateStream(originalFileStream, CompressionMode.Decompress))
            {
                decompressionStream.CopyTo(memoryStream);
            }
            var bytes = memoryStream.ToArray();
            return DeserializeSlim(bytes);
        }
    }
}

結果看來不錯：

Name Serialize(ms) Deserialize(ms) Bytes Serialize With Zip(ms) Deserialize With Zip(ms) Bytes With Zip
BinarySerializer 11 12 141,930 22 12 72,954
XmlSerializer 42 24 977,248 24 28 108,839
SoapSerializer 48 89 2,586,720 61 87 140,391
JsonSerializer 17 33 411,942 24 35 90,125
ProtobufSerializer 7 3 130,416 7 6 65,644
CustomSerializer 5 1 103,246 9 3 57,697
ReflectionSerializer 413 431 103,246 401 376 59,285
ExtendReflectionSerializer 11 11 103,246 13 14 59,285

7. 結語

滿足了好奇心，順便複習了一下各種序列化的方式。

因為原來的需求就很單一，沒有測試各種數據量下的對比。

雖然Protobuf十分優秀，但在本地存儲序列化文件時為了可讀性我通常都會選擇XML或JSON。

8. 參考

二進位序列化
XML 和 SOAP 序列化
Json.NET
Protocol Buffers - Google's data interchange format

9. 源碼

StockDataSample


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • volatile關鍵值
    happens before原則 我們編寫的程式都要經過優化後（編譯器和處理器會對我們的程式進行優化以提高運行效率）才會被運行，優化分為很多種，其中有一種優化叫做重排序，重排序需要遵守happens before規則，換句話說只要滿足happens before原則就可以進行重排序。 定義 :在JM ...
  • java XML 通過BeanUtils的population為對象賦值 根據用戶選擇進行dom4j解析
    根據xml文件設計Student對象 設計學生類 根據菜單進行解析 使用jar包 ...
  • 抽象類和抽象方法以及和介面區別
    一、抽象類 抽象類、具體類是相對的，並非絕對的。抽象是一種概念性名詞，具體是一種可見可觸摸的現實對象。概念越小，則其抽象程度就越大，其外延也越大，反之亦然。簡單說，比如“人”比“男人”抽象一點，而“生物”又比“人”更抽象一點，“物質”又比“生物”更抽象。 抽象的概念是由具體概念依其“共性”而產生的， ...
  • 測試博客園的閱讀量計算方式
    內容：通過wget批量下載我自己博客園的隨筆頁面，看閱讀量是否增加環境：kali+python思路：1、在終端利用調用腳本的方式執行python腳本，比如：python add_readcounts.py -f my_blogs2、對爬蟲不熟，但是也不能把每一篇隨筆的鏈接加入到代碼中，使用一個文本保 ...
  • Python內置函數大全
    Python內置函數 一、數學運算類 二、集合類操作 三、邏輯判斷 四、反射 compile(source, filename, mode[, flags[, dont_inherit]]) 五、IO操作 六、open 打開，關閉，close （2）、w只寫模式【不可讀；文件不存在則創建；存在則清空 ...
  • java_web 關於驗證碼生成的代碼
    1 package com.itheima.servlet; 2 3 import java.awt.Color; 4 import java.awt.Font; 5 import java.awt.Graphics; 6 import java.awt.Graphics2D; 7 import j... ...
  • 重載和重寫
    重載和重寫的差別 子類中不能重寫父類中的final方法 子類中必須重寫父類中的abstract方法 重載（Overloading） Java的方法重載，就是在類中可以創建多個方法，它們具有相同的名字，但具有不同的參數和不同的定義。調用方法時通過傳遞給它們的不同參數個數和參數類型來決定具體使用哪個方法 ...
  • WPF自學入門（五）WPF依賴屬性
    在.NET中有事件也有屬性，WPF中加入了路由事件，也加入了依賴屬性。最近在寫項目時還不知道WPF依賴屬性是乾什麼用的，在使用依賴項屬性的時候我都以為是在用.NET中的屬性，但是確實上不是的，通過閱讀文章和看WPF的書籍已經瞭解了WPF的依賴屬性的使用，我們今天就來看看為什麼WPF中要加入依賴屬性？ ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類