c#中序列化是啥，怎么用，啥情况下用，不用有啥后果？

Posted 2023-04-06

详细描述序列化

c#中序列化就是把一个对象保存到一个文件或数据库字段中去。

序列化用途：

1、在进程下次启动时读取上次保存的对象的信息

2、在不同的AppDomain或进程之间传递数据

3、在分布式应用系统中传递数据

常见的序列化的方法：

1、BinaryFormatter

2、SoapFormatter

3、XML序列化

用法：

　　BinaryFormatter的用法大致如下：　

//BinaryFormatter将对象序列化到文件中
 List<string> inputList = new List<string>()  "str1","str2","str3";
 using (FileStream fsWriter = new FileStream(@"tmp.dat",FileMode.Create,FileAccess.Write))
 
       BinaryFormatter bf = new BinaryFormatter();
       //序列化
       bf.Serialize(fsWriter, inputList);
 

 //BinaryFormatter将文件中的数据反序列化出来
 List<string> outputList = new List<string>();
 using (FileStream fsReader = new FileStream(@"tmp.dat",FileMode.Open,FileAccess.Read))
 
       BinaryFormatter bf = new BinaryFormatter();
       //反序列化
       outputList = (List<string>)bf.Deserialize(fsReader);
 

XML序列化的用法大致如下：

//xml序列化到tmp.xml文件中
List<string> inputList = new List<string>()  "str1","str2";
using (FileStream fsWriter = new FileStream(@"tmp.xml",FileMode.Create,FileAccess.Write))

      XmlSerializer xs = new XmlSerializer(typeof(List<string>));
      xs.Serialize(fsWriter, inputList);


//从tmp.xml文件中反序列化出来
List<string> outputList = new List<string>();
using (FileStream fsReader = new FileStream(@"tmp.xml",FileMode.Open,FileAccess.Read))

     XmlSerializer xs = new XmlSerializer(typeof(List<string>));
     outputList = xs.Deserialize(fsReader) as List<string>;

总结：

 

两个的用法大致如下：

 

序列化：

　　1.得到一个存储对象的类型

　　2.创建一个写入文件流

　　3.定义要序列化的类型

　　4.调用序列化方法

 

反序列化：

　　1.定义一个装载对象的类型

　　2.创建一个读出文件流

　　3.定义要反序列化的类型

　　4.调用反序列化方法

 

BinaryFormatter类进行序列化和反序列化，以缩略型二进制格式写到一个文件中去，速度比较快，而且写入后的文件已二进制保存有一定的保密效果。标记为NonSerialized的其他所有成员都能序列化。

 

采用xml序列化的方式只能保存public的字段和可读写的属性，对于private等类型的字段不能进行序列化。

 

二进制序列化的优点： 

　　1． 所有的类成员（包括只读的）都可以被序列化；

　　2． 性能非常好。

 

XML序列化的优点：

　　1． 互操作性好；

　　2． 不需要严格的二进制依赖；

　　3． 可读性强

参考技术A 序列化（Serialization）是.NET平台的特性之一。
1、为什么要序列化：
首先你应该明白系列化的目的就不难理解他了。系列化的目的就是能在网络上传输对象，否则就无法实现面向对象的分布式计算。比如你的客户端要调用服务器上的一个方法获得一个产品对象，比如方法为：public Product findProduct(int product_id);
注意该方法返回一个Product对象，如果没有系列化技术，客户端就收不到返回的对象Product。而序列化的实现就是把对象变成一个可在网络上传输的字节流。

2、利用序列化技术，可以实现对象的备份和还原。序列化可以将内存中的对象（或对象图）序列化为数据流，并保存到磁盘上进行持久化；还可以将数据流反序列化为对象，实现对象的还原。序列化技术在分布式系统的数据传输中得到充分的利用，如：XML Web Service 利用XML序列化实现跨平台，.NET Remoting 则用到了二进制序列化和SOAP序列化。

.NET Compact Framework 2.0 支持XML序列化，不支持二进制序列化和SOAP序列化。而 .NET Compact Framework 1.0 连XML序列化都不支持。不过 OpenNETCF 1.x 为 .NET CF 1.0 实现了一个XML序列化的类，这个类在 OpenNETCF.Xml.dll 程序集中可以找到。

序列化和反序列化用于将一个对象保存到文件，和从文件读取。
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
[Serializable()]//可以序列化的类需要用这个属性标记
public class ToBeSerialized

public int a;
public string b;
public ToBeSerialized(int a,string b)

this.a=a;
this.b=b;


public class Test


public void Serialize()//序列化

ToBeSerialized tbs = new ToBeSerialized(22,"SOM");
Stream fs = File.Create("Serialized.txt");
BinaryFormatter serializer = new BinaryFormatter();
serializer.Serialize(fs, tbs);
fs.Close();

public void DeSerialize()//反序列化

ToBeSerialized restore;
Stream fs = File.OpenRead("Serialized.txt");
BinaryFormatter deserializer = new BinaryFormatter();
restore = (ToBeSerialized)(deserializer.Deserialize(fs));//反序列化得到的对象
fs.Close();

呵呵。。我找的（别人弄的）虽然我表达不是很好，但是我会用这东东 参考技术B 序列化是将类型，如people类，转换为二进制编码的字节数组。便于在网络中传输。通常是在通信，或者WCF中使用，使用起来非常简单，也可以序列化为XML，在网络中传输

有啥简单的方法可以在不进行反序列化的情况下从 json 中找出最低值 c#

【中文标题】有啥简单的方法可以在不进行反序列化的情况下从 json 中找出最低值 c#

【英文标题】：is there any simple way to find out lowest value from json without doing de-serialization c#有什么简单的方法可以在不进行反序列化的情况下从 json 中找出最低值 c#

【发布时间】：2020-08-25 00:29:50

【问题描述】：

我有以下来自 api 的 json 输出。 我想找出所有元素中的最低值。

json 数据 -

  "prices": [   
    
      "frequency": "daily",
      "date": "2020-05-05",
      "intraperiod": false,
      "open": 295.06,
      "high": 301.0,
      "low": 294.46,
      "close": 297.56
    ,
    
      "frequency": "daily",
      "date": "2020-05-04",
      "intraperiod": false,
      "open": 289.17,
      "high": 293.69,
      "low": 112.1,
      "close": 293.16
    ,
    
      "frequency": "daily",
      "date": "2020-05-01",
      "intraperiod": false,
      "open": 286.25,
      "high": 299.0,
      "low": 222,
      "close": 289.07
    
  ]

我想比较 json 元素中的所有值并显示最小值 = "low": 112.1 和它自己的高值。 "high": 293.69,

我尝试如下使用 jquery 但我想在 c# 中执行此操作请分享 c# 代码-

function get(arr, prop) 
    var min;
    for (var i=0 ; i<arr.length ; i++) 
        if (min== null || parseInt(arr[i][prop]) > parseInt(min[prop]))
            min= arr[i];
    
    return min;


var min = get(arr, "low");
console.log(min.high);

【问题讨论】：

不，没有反序列化的简单方法可以做到这一点，至少反序列化为某种形式的对象结构？

哦，我明白了，你能帮我提供示例代码吗？

【参考方案1】：

您可以为此使用Newtonsoft.Json.Linq，将您的JSON解析为JObject，然后获取具有low名称的所有属性，找到值最低的属性并获取同一级别的high值

var json = JObject.Parse(jsonString);

var properties = json.DescendantsAndSelf()
    .OfType<JProperty>()
    .Where(p => p.Name == "low");

 var lowProperty = properties
     .Aggregate((p1, p2) => p1.Value.Value<double>() < p2.Value.Value<double>() ? p1 : p2);

var highProperty = (lowProperty?.Parent as JObject)?.Property("high");
Console.WriteLine(lowProperty);
Console.WriteLine(highProperty);

它给你

"low": 112.1
"high": 293.69

【参考方案2】：

您可以使用正则表达式。

var pattern = "\"high\": ([0-9]+(\\.[0-9]+)?)";
MatchCollection matches = Regex.Matches(json, pattern);

var max = double.MinValue;
foreach (Match m in matches) 
    var val = Convert.ToDouble(m.Groups[1].Value);
    if (max < val) 
        max = val;
               

同样适用于低价值。

【参考方案3】：

反序列化将是要走的路

您可以将其反序列化为一个对象并进行所需的计算

    // <auto-generated />
//
// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do:
//
//    using QuickType;
//
//    var priceData = PriceData.FromJson(jsonString);

namespace QuickType

    using System;
    using System.Collections.Generic;

    using System.Globalization;
    using Newtonsoft.Json;
    using Newtonsoft.Json.Converters;

    public partial class PriceData
    
        [JsonProperty("prices")]
        public List<Price> Prices  get; set; 
    

    public partial class Price
    
        [JsonProperty("frequency")]
        public string Frequency  get; set; 

        [JsonProperty("date")]
        public DateTimeOffset Date  get; set; 

        [JsonProperty("intraperiod")]
        public bool Intraperiod  get; set; 

        [JsonProperty("open")]
        public double Open  get; set; 

        [JsonProperty("high")]
        public double High  get; set; 

        [JsonProperty("low")]
        public double Low  get; set; 

        [JsonProperty("close")]
        public double Close  get; set; 
    

    public partial class PriceData
    
        public static PriceData FromJson(string json) => JsonConvert.DeserializeObject<PriceData>(json, QuickType.Converter.Settings);
    

    public static class Serialize
    
        public static string ToJson(this PriceData self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings);
    

    internal static class Converter
    
        public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
        
            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
            DateParseHandling = DateParseHandling.None,
            Converters =
            
                new IsoDateTimeConverter  DateTimeStyles = DateTimeStyles.AssumeUniversal 
            ,
        ;
    

你可以使用Quciktype从json中获取POCO类（上面的代码是从那个生成的）

然后使用

var data = PriceData.FromJson(json_string);
var min = data.Select(x=>x.Low).Min();
// There may be multiple Price objects with the same low, I will use the first one
min_object = data.Where(x=>x.Low == min).First()
var high_value_of_min_object = min_object.High;

您可能想决定要查找的元素 P.S 我没有测试过代码。

【参考方案4】：

您可以使用quicktype.io 之类的工具创建类来表示您的 JSON：

public partial class Temperatures

    [JsonProperty("prices")]
    public List<Price> Prices  get; set; 


public partial class Price

    [JsonProperty("frequency")]
    public string Frequency  get; set; 

    [JsonProperty("date")]
    public DateTimeOffset Date  get; set; 

    [JsonProperty("intraperiod")]
    public bool Intraperiod  get; set; 

    [JsonProperty("open")]
    public double Open  get; set; 

    [JsonProperty("high")]
    public double High  get; set; 

    [JsonProperty("low")]
    public double Low  get; set; 

    [JsonProperty("close")]
    public double Close  get; set; 

然后使用Json.NET 反序列化你的json，并使用MoreLinq 中的MinBy 得到Low 的最低价格。 MinBy 将返回 IEnumerable<Price>，因此我们可以迭代每个最低价格并打印 Low 和 High 属性：

using Newtonsoft.Json;
using MoreLinq;

...

var deserializedJson = JsonConvert.DeserializeObject<Temperatures>(json);

var minPrices = deserializedJson.Prices.MinBy(price => price.Low);

foreach (var price in minPrices)

    Console.WriteLine($"Min = price.Low, High = price.High");

输出：

Min = 112.1, High = 293.69

dotnetfiddle.net 上的完整演示