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", " ...
随机推荐
- Java 数组（一）定义与访问
一.数组 1.容器概述 容器:是将多个数据存储到一起,每个数据称为该容器的元素. 2.数组概述 数组:数组就是存储数据长度固定的容器,保证多个数据的数据类型要一致. 数组特点: (1)数组是一 ...
- WPE 过滤器 滤镜 用法
过滤所有数值匹配的数据包,并修改指定的bit位 打开游戏 打开WPE 附加游戏进程 选项配置 用来配置抓取发送和接收包类型 先抓取发送包,也就是游戏中主动发给服务器的包 点击开始抓包 输入喊话内容 分 ...
- Gateway-Worker启动失败或者启动无法正常使用的几种方法
Workerman是一款开源高性能异步PHP socket即时通讯框架.支持高并发,超高稳定性,被广泛的用于手机app.移动通讯,微信小程序,手游服务端.网络游戏.PHP聊天室.硬件通讯.智能家居.车 ...
- mysqldump 备份
1. 直接备份某个库或表 ,或多个库多个表mysqldump -uroot -pPassword [database name] > [dump file]mysqldump -uroot - ...
- Linux普通用户登录后，命令行提示：-bash-4.1$ ，原因分析及解决
原文 有时候在使用用户登陆Linux系统时会发现,命令行提示符成了:-bash-4.1$,不显示用户名,路径信息. 原因:用户家目录里面与环境变量有关的文件被删除所导致的 也就是这俩文件:.bash_ ...
- aws centos系统磁盘扩容
growpart /dev/xvda 1 展开修改后的分区(注意是:空格 1,而非打错了) # ext3/4 1.resize2fs /dev/xvda1 将分区调整为新的卷容量 # xfs分区 2 ...
- nmap使用流程
ip为案列 利用ipconfig 测得本地ip为 192.00.00.100 利用-sn探测一批主机内的存活主机 存活主机ip为 192.000.00.1 192.000.00.100 使 ...
- HAProxy的基础配置详解
HAProxy是高性能的企业级负载均衡调度器,同时支持四层TCP和七层HTTP协议的负载均衡调度,以及支持基于cookie的持久性,支持正则表达式及web状态统计.自动故障切换等优点,因此广泛被应 ...
- Linux运维技术之scp命令使用
命令格式: scp -P 8031 -r 路径1 路径2 命令解释, 其中-P中的P一定要大写,小写不行(这个也是问题的关键,这个大小写耽搁了好长时间) -P 2424表示更改SSH端口后的端口,如 ...
- PAT 乙级 1013.数素数 C++/Java
题目来源 令 Pi 表示第 i 个素数.现任给两个正整数 M≤N≤104,请输出 PM 到 PN 的所有素数. 输入格式: 输入在一行中给出 M 和 N,其间以空格分隔. 输出 ...