C# 序列化与反序列化Serialization之Json Xml Binary Soap JavaScript序列化
所谓的序列化其实就是把一个内存中的对象信息转化成一个可以持久化保存的形式，方便保存数据库和文件或着用于传输，
序列化的主要作用是不同平台之间进行通信与信息的传递保存等，常用的有序列化有Json Xml Binary Soap JavaScript序列化等，当然我们也可以使用第三方的序列化类库，第三方的序列化类库可以参照网上的，这里不再赘述，
本文主要介绍Json Xml Binary Soap JavaScript等6种序列化的方法，
添加引用以下类库
using System.Runtime.Serialization.Json;//DataContractJsonSerializer序列化
using System.Xml.Serialization;//XmlSerializer序列化
using System.Runtime.Serialization.Formatters.Binary;//BinarySerializer序列化
using System.Runtime.Serialization.Formatters.Soap;//SoapSerializer序列化
using System.Web.Script.Serialization;//JavaScriptSerializer序列化
代码如下：
using System;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Json;//DataContractJsonSerializer序列化
using System.Xml.Serialization;//XmlSerializer序列化
using System.Runtime.Serialization.Formatters.Binary;//BinarySerializer序列化
using System.Runtime.Serialization.Formatters.Soap;//SoapSerializer序列化
using System.Web.Script.Serialization;//JavaScriptSerializer序列化 namespace SupremeConsole
{
/// <summary>
/// 序列化单例对象
/// </summary>
public class SerializeManager : SingleManager<SerializeManager>
{
public SerializeManager()
{
Initialize();
} public override void Initialize()
{
base.Initialize();
} /// <summary>
/// DataContractJson泛型序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="t">泛型对象</param>
/// <returns>泛型对象序列化的字符串</returns>
public string DataContractJsonSerialize<T>(T t) where T : class
{
string s = null;
try
{
using MemoryStream ms = new MemoryStream();
DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(T));
dcjs.WriteObject(ms, t);
s = Encoding.UTF8.GetString(ms.ToArray());
}
catch (Exception ex)
{
Program.Log.Error($"DataContractJson泛型序列化错误信息：{ex.ToString()}");
}
return s;
} /// <summary>
/// DataContractJson泛型序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="t">泛型对象</param>
/// <param name="path">保存的路径</param>
public void DataContractJsonSerialize<T>(T t, string path) where T : class
{
try
{
//string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
using FileStream fs = new FileStream(path, FileMode.OpenOrCreate);
DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(T));
dcjs.WriteObject(fs, t);
}
catch (Exception ex)
{
Program.Log.Error($"DataContractJson泛型序列化错误信息：{ex.ToString()}");
}
} /// <summary>
/// DataContractJson泛型的反序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="json">反序列化的序列化文件路径</param>
/// <returns>泛型对象</returns>
public T DataContractJsonDeserializeJson<T>(string json) where T : class
{
T t = null;
try
{
using MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(json));
DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(T));
if (dcjs.ReadObject(ms) is T a)
{
t = a;
}
}
catch (Exception ex)
{
Program.Log.Error($"DataContractJson泛型反序列化错误信息：{ex.ToString()}");
}
return t;
} /// <summary>
/// DataContractJson泛型的反序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="json">反序列化的序列化文件路径</param>
/// <returns>泛型对象</returns>
public T DataContractJsonDeserialize<T>(string path) where T : class
{
T t = null;
try
{
using MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(File.ReadAllText(path)));
DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(T));
if (dcjs.ReadObject(ms) is T a)
{
t = a;
}
}
catch (Exception ex)
{
Program.Log.Error($"DataContractJson泛型反序列化错误信息：{ex.ToString()}");
}
return t;
} /// <summary>
/// Xml泛型序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="t">泛型对象</param>
/// <returns>泛型对象序列化的字符串</returns>
public string XmlSerialize<T>(T t) where T : class
{
string s = null;
try
{
using MemoryStream ms = new MemoryStream();
XmlSerializer xs = new XmlSerializer(typeof(T));
xs.Serialize(ms, t);
s = Encoding.UTF8.GetString(ms.ToArray());
}
catch (Exception ex)
{
Program.Log.Error($"Xml泛型序列化错误信息：{ex.ToString()}");
}
return s;
} /// <summary>
/// Xml泛型序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="t">泛型对象</param>
/// <param name="path">保存的路径</param>
public void XmlSerialize<T>(T t, string path) where T : class
{
try
{
//string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
using FileStream fs = new FileStream(path, FileMode.OpenOrCreate);
XmlSerializer xs = new XmlSerializer(typeof(T));
xs.Serialize(fs, t);
}
catch (Exception ex)
{
Program.Log.Error($"Xml泛型序列化错误信息：{ex.ToString()}");
}
} /// <summary>
/// Xml泛型的反序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="path">反序列化的序列化文件路径</param>
/// <returns>泛型对象</returns>
public T XmlDeserialize<T>(string path) where T : class
{
T t = null;
try
{
using MemoryStream ms = new MemoryStream(File.ReadAllBytes(path));
XmlSerializer xs = new XmlSerializer(typeof(T));
if (xs.Deserialize(ms) is T a)
{
t = a;
}
}
catch (Exception ex)
{
Program.Log.Error($"Xml泛型的反序列化错误信息：{ex.ToString()}");
}
return t;
} /// <summary>
/// Binary泛型序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="t">泛型对象</param>
/// <returns>泛型对象序列化的字符串</returns>
public string BinarySerialize<T>(T t) where T : class
{
string s = null;
try
{
using MemoryStream ms = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, t);
s = Encoding.UTF8.GetString(ms.ToArray());
}
catch (Exception ex)
{
Program.Log.Error($"Binary泛型序列化错误信息：{ex.ToString()}");
}
return s;
} /// <summary>
/// Binary泛型序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="t">泛型对象</param>
/// <param name="path">保存的路径</param>
public void BinarySerialize<T>(T t, string path) where T : class
{
try
{
//string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
using FileStream fs = new FileStream(path, FileMode.OpenOrCreate);
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(fs, t);
}
catch (Exception ex)
{
Program.Log.Error($"Binary泛型序列化错误信息：{ex.ToString()}");
}
} /// <summary>
/// Binary泛型的反序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="path">反序列化的序列化文件路径</param>
/// <returns>泛型对象</returns>
public T BinaryDeserialize<T>(string path) where T : class
{
T t = null;
try
{
//string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
using MemoryStream fs = new MemoryStream(File.ReadAllBytes(path));
BinaryFormatter bf = new BinaryFormatter();
if (bf.Deserialize(fs) is T a)
{
t = a;
}
}
catch (Exception ex)
{
Program.Log.Error($"Binary泛型的反序列化错误信息：{ex.ToString()}");
}
return t;
} /// <summary>
/// Soap泛型序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="t">泛型对象</param>
/// <returns>泛型对象序列化的字符串</returns>
public string SoapSerialize<T>(T t) where T : class
{
string s = null;
try
{
using MemoryStream ms = new MemoryStream();
SoapFormatter sf = new SoapFormatter();
sf.Serialize(ms, t);
s = Encoding.UTF8.GetString(ms.ToArray());
}
catch (Exception ex)
{
Program.Log.Error($"Soap泛型序列化错误信息：{ex.ToString()}");
}
return s;
} /// <summary>
///Soap泛型序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="t">泛型对象</param>
/// <param name="path">保存的路径</param>
public void SoapSerialize<T>(T t, string path) where T : class
{
try
{
//string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
using FileStream fs = new FileStream(path, FileMode.OpenOrCreate);
SoapFormatter sf = new SoapFormatter();
sf.Serialize(fs, t);
}
catch (Exception ex)
{
Program.Log.Error($"Soap泛型序列化错误信息：{ex.ToString()}");
}
} /// <summary>
/// Soap泛型的反序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="path">反序列化的序列化文件路径</param>
/// <returns>泛型对象</returns>
public T SoapDeserialize<T>(string path) where T : class
{
T t = null;
try
{
//string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
using MemoryStream fs = new MemoryStream(File.ReadAllBytes(path));
SoapFormatter sf = new SoapFormatter();
if (sf.Deserialize(fs) is T a)
{
t = a;
}
}
catch (Exception ex)
{
Program.Log.Error($"Soap泛型的反序列化错误信息：{ex.ToString()}");
}
return t;
} /// <summary>
/// JavaScript泛型序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="t">泛型对象</param>
/// <returns>泛型对象序列化的字符串</returns>
public string JavaScriptSerialize<T>(T t) where T : class
{
string s = null;
try
{
JavaScriptSerializer jss = new JavaScriptSerializer();
s = jss.Serialize(t);
}
catch (Exception ex)
{
Program.Log.Error($"JavaScript泛型序列化错误信息：{ex.ToString()}");
}
return s;
} /// <summary>
///JavaScript泛型序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="t">泛型对象</param>
/// <param name="path">保存的路径</param>
public void JavaScriptSerialize<T>(T t, string path) where T : class
{
try
{
//string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
using FileStream fs = new FileStream(path, FileMode.OpenOrCreate);
using StreamWriter sw = new StreamWriter(fs);
StringBuilder sb = new StringBuilder();
JavaScriptSerializer jss = new JavaScriptSerializer();
jss.Serialize(t, sb);
sw.WriteLine(sb.ToString());
}
catch (Exception ex)
{
Program.Log.Error($"JavaScript泛型序列化错误信息：{ex.ToString()}");
}
} /// <summary>
/// JavaScript泛型的反序列化
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
/// <param name="path">反序列化的序列化文件路径</param>
/// <returns>泛型对象</returns>
public T JavaScriptDeserialize<T>(string path) where T : class
{
T t = null;
try
{
//string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
string input = Encoding.UTF8.GetString(File.ReadAllBytes(path));
JavaScriptSerializer jss = new JavaScriptSerializer();
if (jss.Deserialize<T>(input) is T a)
{
t = a;
}
}
catch (Exception ex)
{
Program.Log.Error($"JavaScript泛型的反序列化错误信息：{ex.ToString()}");
}
return t;
}
}
}
控制台程序主方法Main测试调用方式如下：
static void Main(string[] args)
{
#region MyRegion
try
{
TestClass testClass = new TestClass { Id = , Name = "张三", Age = , Address = "上海浦东新区2弄5汤", Sex = "男" };
#region DataContractJsonSerialize 要序列化的对象可以不添加SerializableAttribute属性，[Serializable]
//string s = SerializeManager.Instance.DataContractJsonSerialize<TestClass>(testClass);//序列化
//Console.ForegroundColor = ConsoleColor.Green;
//Console.WriteLine("测试序列化成功。。。");
//Console.WriteLine($"测试序列化结果：{s}"); //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化123.txt");//序列化
//SerializeManager.Instance.DataContractJsonSerialize<TestClass>(testClass, path); //string json = "{\"Address\":\"中国南京\",\"Age\":10,\"Id\":1,\"Name\":\"张三\",\"Sex\":\"男\"}";
//TestClass test = SerializeManager.Instance.DataContractJsonDeserializeJson<TestClass>(json);//反序列化
//if (test != null)
//{
// Console.WriteLine($"测试序列化结果：{test.ToString()}");
//} //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化123.txt");
//TestClass test = SerializeManager.Instance.DataContractJsonDeserialize<TestClass>(path);//反序列化
//if (test != null)
//{
// Console.WriteLine($"测试序列化结果：{test.ToString()}");
//}
#endregion #region XmlSerialize 要序列化的对象可以不添加SerializableAttribute属性，[Serializable]
//string s = SerializeManager.Instance.XmlSerialize<TestClass>(testClass);//序列化
//Console.ForegroundColor = ConsoleColor.Green;
//Console.WriteLine("测试序列化成功。。。");
//Console.WriteLine($"测试序列化结果：\r\n{s}"); //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化.txt");//序列化
//SerializeManager.Instance.XmlSerialize<TestClass>(testClass, path); //备用
//string json = "{\"Address\":\"中国南京\",\"Age\":10,\"Id\":1,\"Name\":\"张三\",\"Sex\":\"男\"}";
//TestClass test = SerializeManager.Instance.DataContractJsonDeserializeJson<TestClass>(json);//反序列化
//if (test != null)
//{
// Console.WriteLine($"测试序列化结果：{test.ToString()}");
//} //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化.txt");
//TestClass test = SerializeManager.Instance.XmlDeserialize<TestClass>(path);//反序列化
//if (test != null)
//{
// Console.WriteLine($"测试序列化结果：{test.ToString()}");
//}
#endregion TestClass1 testClass1 = new TestClass1 { Id = , Name = "张三11111", Age = , Address = "12123上海浦东新区2弄5汤1111", Sex = "男" };
#region BinarySerialize 必须添可序列化属性，即要序列化的对象必须添加SerializableAttribute属性，[Serializable]
//string s = SerializeManager.Instance.BinarySerialize<TestClass1>(testClass1);//序列化
//Console.ForegroundColor = ConsoleColor.Green;
//Console.WriteLine("测试序列化成功。。。");
//Console.WriteLine($"测试序列化结果：\r\n{s}"); //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化11111.txt");//序列化
//SerializeManager.Instance.BinarySerialize<TestClass1>(testClass1, path); //备用
//string json = "{\"Address\":\"中国南京\",\"Age\":10,\"Id\":1,\"Name\":\"张三\",\"Sex\":\"男\"}";
//TestClass test = SerializeManager.Instance.DataContractJsonDeserializeJson<TestClass>(json);//反序列化
//if (test != null)
//{
// Console.WriteLine($"测试序列化结果：{test.ToString()}");
//} //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化11111.txt");
//TestClass1 test = SerializeManager.Instance.BinaryDeserialize<TestClass1>(path);//反序列化
//if (test != null)
//{
// Console.WriteLine($"测试序列化结果：{test.ToString()}");
//}
#endregion #region SoapSerialize 必须添可序列化属性，即要序列化的对象必须添加SerializableAttribute属性，[Serializable]
//string s = SerializeManager.Instance.SoapSerialize<TestClass1>(testClass1);//序列化
//Console.ForegroundColor = ConsoleColor.Green;
//Console.WriteLine("测试序列化成功。。。");
//Console.WriteLine($"测试序列化结果：\r\n{s}"); //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化2222.txt");//序列化
//SerializeManager.Instance.SoapSerialize<TestClass1>(testClass1, path); //备用
//string json = "{\"Address\":\"中国南京\",\"Age\":10,\"Id\":1,\"Name\":\"张三\",\"Sex\":\"男\"}";
//TestClass test = SerializeManager.Instance.DataContractJsonDeserializeJson<TestClass>(json);//反序列化
//if (test != null)
//{
// Console.WriteLine($"测试序列化结果：{test.ToString()}");
//} //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化2222.txt");
//TestClass1 test = SerializeManager.Instance.SoapDeserialize<TestClass1>(path);//反序列化
//if (test != null)
//{
// Console.WriteLine($"测试序列化结果：{test.ToString()}");
//}
#endregion #region JavaScriptSerialize 要序列化的对象可以不添加SerializableAttribute属性，[Serializable]
//string s = SerializeManager.Instance.JavaScriptSerialize<TestClass1>(testClass1);//序列化
//Console.ForegroundColor = ConsoleColor.Green;
//Console.WriteLine("测试序列化成功。。。");
//Console.WriteLine($"测试序列化结果：\r\n{s}"); //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化66666.txt");//序列化
//SerializeManager.Instance.JavaScriptSerialize<TestClass1>(testClass1, path); //备用
//string json = "{\"Address\":\"中国南京\",\"Age\":10,\"Id\":1,\"Name\":\"张三\",\"Sex\":\"男\"}";
//TestClass test = SerializeManager.Instance.DataContractJsonDeserializeJson<TestClass>(json);//反序列化
//if (test != null)
//{
// Console.WriteLine($"测试序列化结果：{test.ToString()}");
//} //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化66666.txt");
//TestClass1 test = SerializeManager.Instance.JavaScriptDeserialize<TestClass1>(path);//反序列化
//if (test != null)
//{
// Console.WriteLine($"测试序列化结果：{test.ToString()}");
//}
#endregion Console.WriteLine("测试序列化成功。。。");
}
catch (Exception ex)
{
Log.Error($"测试序列化出错，原因：{ex.ToString()}");
throw;
} #endregion Console.ReadLine();
}
使用的类TestClass和TestClass1，类TestClass和TestClass1主要是区分是否添加可序列化属性标记，TestClass主要是测试XmlSerializer（xml序列化）和DatacontractJsonSerializer（json序列化），可以不添加可序列化标记 [Serializable]，TestClass1主要是测试Binary和Soap JavaScript序列化，但Binary和Soap JavaScript序列化TestClass1时，必须添加TestClass1的可序列化标记 [Serializable]，否则，BinarySerialize，SoapSerialize序列化TestClass1的时候会报，提示未标记可序列化
TestClass类
namespace SupremeConsole
{
/// <summary>
/// 测试类，该类必未标记为可序列化，DataContractJsonSerialize，XmlSerialize可以正常序列化
/// </summary>
public class TestClass
{
/// <summary>
/// 编号
/// </summary>
public int Id { get; set; } /// <summary>
/// 姓名
/// </summary>
public string Name { get; set; } /// <summary>
/// 年龄
/// </summary>
public int Age { get; set; } /// <summary>
/// 地址
/// </summary>
public string Address { get; set; } /// <summary>
/// 性别
/// </summary>
public string Sex { get; set; } public override string ToString()
{
//return string.Format("编号:{0},姓名:{1},年龄:{2},地址:{3},性别:{4}", Id, Name, Age, Address, Sex);
return $"编号:{Id},姓名:{Name},年龄:{Age},地址:{Address},性别:{Sex}";
}
}
}
TestClass1类
using System;
using System.Runtime.Serialization; namespace SupremeConsole
{
/// <summary>
/// 测试类1，该类必须标记可序列化，否则，BinarySerialize，SoapSerialize序列化的时候会报，未标记可序列化
/// </summary>
[Serializable]
[DataContract]
public class TestClass1
{
/// <summary>
/// 编号
/// </summary> public int Id { get; set; } /// <summary>
/// 姓名
/// </summary>
public string Name { get; set; } /// <summary>
/// 年龄
/// </summary>
public int Age { get; set; } /// <summary>
/// 地址
/// </summary>
public string Address { get; set; } /// <summary>
/// 性别
/// </summary>
public string Sex { get; set; } public override string ToString()
{
//return string.Format("编号:{0},姓名:{1},年龄:{2},地址:{3},性别:{4}", Id, Name, Age, Address, Sex);
return $"编号:{Id},姓名:{Name},年龄:{Age},地址:{Address},性别:{Sex}";
}
}
}
C# 序列化与反序列化Serialization之Json Xml Binary Soap JavaScript序列化的更多相关文章
- C# 序列化与反序列化之DataContract与xml对子类进行序列化的解决方案
C# 序列化与反序列化之DataContract与xml对子类进行序列化的解决方案 1.DataContract继承对子类进行序列化的解决方案 第一种是在 [DataContract, KnownTy ...
- Json序列化与反序列化(对象与Json字符串的转换)--C#
public class JsonHelper { #region Json序列化与反序列化 /// <summary> /// 将json转化为对象 /// (需要提前构造好结构一致的M ...
- C# dynamic类型序列化和反序列化之Newtonsoft.Json
原文:C# dynamic类型序列化和反序列化之Newtonsoft.Json 版权声明:本文为博主原创文章,未经博主允许不得转载. https://blog.csdn.net/u011127019/ ...
- 序列化与反序列化 - BinaryFormatter二进制(.dat)、SoapFormatter(.soap)、XmlSerializer(.xml)
序列化的作用是什么?为什么要序列化? 1.在进程下次启动时读取上次保存的对象的信息. 2.在不同的应用程序域或进程之间传递数据. 3.在分布式应用程序中的各应用程序之间传输对象. 所为序列化,就是将对 ...
- c# xml序列化和反序列化。也就是xml的解析和反解析。
用习惯了newTownSoft.json 的json反序列化.碰到xml是真的不习惯. 每次json反序列化都是直接把json丢到bejson网站生成一个实体类,稍微修改修改一点点变量名.然后直接ne ...
- ASP.NET JSON的序列化和反序列化 之 Newtonsoft.Json
我们用到的类库为:Newtonsoft.Json,通过VS工具中NuGet程序包可以下载. 一:对象转json-序列化 public class Student { public int ID { g ...
- C# dynamic类型序列化和反序列化之Newtonsoft.Json，动态解析远端返回的jSON数据
一.说明 1.Newtonsoft.Json 中的Linq To Json中提供了方便的json数据查询.修改等操作. 例如:JObject,JArray 2.在JObject.FromObject( ...
- java中的序列化与反序列化，还包括将多个对象序列化到一个文件中
package Serialize; /** * Created by hu on 2015/11/7. */ //实现序列化必须实现的接口,这就是一个空接口,起到标识的作用 import java. ...
- 解决如下json格式的字符串不能使用DataContractJsonSerializer序列化和反序列化 分类： JSON 2015-01-28 14:26 72人阅读 评论(0) 收藏
可以解决如下json格式的字符串不能使用DataContractJsonSerializer反序列化 { "ss": "sss", " ...
随机推荐
- Vue – 基础学习(1):对生命周期和钩子函的理解
一.简介 先贴一下官网对生命周期/钩子函数的说明(先贴为敬):所有的生命周期钩子自动绑定 this 上下文到实例中,因此你可以访问数据,对属性和方法进行运算.这意味着你不能使用箭头函数来定义一个生命周 ...
- 【译】itertools
1.Itertools模块迭代器的种类 1.1 无限迭代器: 迭代器 参数 结果 示例 count() start, [step] start, start+step, start+2*step, ...
- Spring框架的AOP编程，最通俗的语言解释，易懂易学
第七章:AOP技术 前言: AOP技术是根据动态代理设计模式进行的技术.动态代理技术分jdk动态代理和cglib动态代理 jdk动态代理特点: (1)继承java.lang.reflect.proxy ...
- 国内不fq安装K8S二: 安装kubernet
目录 2 安装kubelet 2.1 环境准备 2.2 设置国内的源 2.3 重要的设置 2.4 获取镜像 2.5 使用kubeadm init初始化集群 2.6 安装Pod Network 2.7 ...
- List加载因子和扩容因子
List.Map.set的加载因子,默认初始容量和扩容增量 首先,这三个概念说下.初始大小,就是创建时可容纳的默认元素个数:加载因子,表示某个阀值,用0~1之间的小数来表示,当已有元素占比达到这个阀值 ...
- CentOS6.7搭建部署DNS服务 (详解主配置文件)
-DNS服务器的基本原理 域名简介:使用tcp/udp协议,默认使用53端口号 默认情况下,客户端发起的查询请求都是用UDP/53查询的. 默认情况下,从从服务器到主服务器传输数据用的是TCP/53. ...
- php装饰器模式(decorator pattern)
十一点了. <?php /* The decorator pattern allows behavior to be added to an individual object instance ...
- 20180520模拟赛T1——math
[问题描述] 小美有 n 个点 m 条边. 让你给每个点一个正整数编号. 每条边有两个属性,相连的两个点的编号的 GCD 和 LCM. 题目保证整张图连通. 让你构造出一个编号. [输入格式] 从文件 ...
- Codeforces Round #552 (Div. 3)-C-Gourmet Cat
http://codeforces.com/contest/1154/problem/C 题意: 有一只猫,周一周四周日吃鱼肉,周二周六吃兔肉,周三周五吃鸡肉,现给出三种肉的数量,问最多能吃多少天? ...
- 分布式任务平台XXL_JOB
目录 1.源码下载地址 2.文档地址 3.源码结构 4.初始化数据库 5.配置调度中心 ①.修改调度中心配置文件 ②.部署调度中心 ③.访问调度中心管理界面 6.创建执行器项目 ①.添加maven依赖 ...