经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C# » 查看文章
工程坐标转换方法C#代码实现
来源：cnblogs　　作者：Aidan_Lee　　时间：2022/12/5 8:50:06　　对本文有异议

目录

1. 前言

在前面的文章中系统的阐述了工程坐标的转换类别和转换的方法。关于转换代码实现，有很多的类库：

这里针对GPS接收的WGS84椭球的经纬度转换为地方坐标系的问题，利用C#，对工程坐标转换方法和步骤做出详细的解答。不基于任何类库和函数库，也未使用矩阵库，可以便利的将代码移植到任何语言。

2. 计算总体框架

根据上一篇文章中对七参数、四参数、高程拟合在坐标转换的作用和使用条件的阐述，我们可以将上一篇文章第7节的总结图，按照计算的流程重新绘制。
image

根据上图可知，预将WGS84椭球的GPS坐标需要经过5次转换。其中，

  1. 转换1、转换3在charlee44的博客：大地经纬度坐标与地心地固坐标的转换中详细讲解了，并且有C++代码的实现，利用C#重构即可。
  2. 转换2、转换5，以及他们的组合，在我的上一篇文章(工程)坐标转换类别和方法也详细的讲解了。

因此，根据计算原理，直接可以利用C#代码实现。

3. C#代码实现

3.1 整体类的构建

5个转换是对点的操作，不妨构建自定义点类MyPoint，在这个类中定义转换方法。在实现转换方法之前，需要定义数据属性，以承载转换参数和转换数据。代码框架如下：

  1. internal class MyPoint
  2. {
  3. 	// 定义椭球类型。这里仅列举了4中国内常见的椭球类型
  4. 	// 国际椭球可以增加自行定义	
  5. 	public enum EllipsoidType
  6. 	     {
  7. 	         WGS84,
  8. 	         CGCS2000,
  9. 	         西安80,
  10. 	         北京54
  11. 	     }
  12. 	    //大地坐标经度、维度、高度
  13. 	    public double L { get; set; }
  14. 	    public double B { get; set; }
  15. 	    public double H { get; set; }
  16. 	
  17. 	    //空间坐标系
  18. 	    public double X { get; set; }
  19. 	    public double Y { get; set; }
  20. 	    public double Z { get; set; }
  21. 	
  22. 	    //七参数转换后的空间坐标
  23. 	    public double X2 { get; set; }
  24. 	    public double Y2 { get; set; }
  25. 	    public double Z2 { get; set; }
  26. 	
  27. 	    
  28. 	    
  29. 	    private double a = 0, f = 0, b = 0, e = 0, e2 = 0;    //椭球参数
  30. 	
  31. 	    private readonly double rho = 180 / Math.PI;
  32. 	    private readonly double d2r = Math.PI / 180;
  33. 	
  34. 	    public double Xs { get; set; }
  35. 	    public double Ys { get; set; }
  36. 	    public double Hs { get; set; }
  37. 	
  38. 	    //七参数 三个线性平移量-单位米 三个旋转平移量-十进制秒为单位（运算时注意转换为度） 比例因子-单位百万分率 (ppm)
  39. 	    //测量队给出的七参数单位与计算的单位不同，要进行单位转化 1 秒=0.0000048481373323 弧度
  40. 	    //尺度因子有两种单位的表示形式，一种结果约为1，如1.0000045，用k表示；
  41. 	    //另一种就是ppm的表示形式，稍微比1大一点，如4.5，用m表示。k=m/1000000
  42. 	    private double dx = 0, dy = 0, dz = 0, rx = 0, ry = 0, rz = 0, m = 0, k = 0;    
  43. }

3.2 椭球参数赋值

常见的椭球参数值在我的文章经纬度坐标转换为工程坐标可以找到，这里选取与上述代码对应的4类椭球，并在上述MyPoint类中增加函数EllipsoidParam(EllipsoidType type)。

  1. /// <summary>
  2. /// 椭球参数设置
  3. /// </summary>
  4. /// <param name="type">椭球类型</param>
  5. private void EllipsoidParam(EllipsoidType type)
  6. {
  7.     // CGCS2000 椭球参数
  8.     if (type == EllipsoidType.CGCS2000)
  9.     {
  10.         this.a = 6378137;
  11.         this.f = 1 / 298.257222101;
  12.     }
  14.     // 西安 80
  15.     else if (type == EllipsoidType.西安80)
  16.     {
  17.         this.a = 6378140;
  18.         this.f = 1 / 298.257;
  19.     }
  21.     // 北京 54
  22.     else if (type == EllipsoidType.北京54)
  23.     {
  24.         this.a = 6378245;
  25.         this.f = 1 / 298.3;
  26.     }
  28.     // WGS-84 
  29.     else
  30.     {
  31.         this.a = 6378137;
  32.         this.f = 1 / 298.257223563;
  33.     }
  35.     this.b = this.a * (1 - this.f);
  36.     this.e = Math.Sqrt(this.a * this.a - this.b * this.b) / this.a;  //第一偏心率
  37.     this.e2 = Math.Sqrt(this.a * this.a - this.b * this.b) / this.b;  //第二偏心率
  38. }

3.3 转换1、3（大地经纬度坐标与地心地固坐标的转换）

charlee44的博客有C++代码的实现，现在利用C#重构即可。上述MyPoint类中增加BLH2XYZ(EllipsoidType type)和XYZ2BLH(EllipsoidType type)两个函数。

  1. /// <summary>
  2. /// 经纬度坐标转空间直角坐标
  3. /// </summary>
  4. /// <param name="type">椭球类型</param>
  5. public void BLH2XYZ(EllipsoidType type = EllipsoidType.WGS84)
  6. {
  7.     EllipsoidParam(type);
  9.     double sB = Math.Sin(this.B * d2r);
  10.     double cB = Math.Cos(this.B * d2r);
  11.     double sL = Math.Sin(this.L * d2r);
  12.     double cL = Math.Cos(this.L * d2r);
  13.     double N = this.a / (Math.Sqrt(1 - this.e * this.e * sB * sB));
  15.     this.X = (N + this.H) * cB * cL;
  16.     this.Y = (N + this.H) * cB * sL;
  17.     this.Z = (N * (1 - this.e * this.e) + this.H) * sB;
  19.     this.X2 = this.X;
  20.     this.Y2 = this.Y;
  21.     this.Z2 = this.Z;
  22. }
  24. /// <summary>
  25. /// 空间直角坐标转经纬度坐标
  26. /// </summary>
  27. /// <param name="type">椭球类型</param>
  28. public void XYZ2BLH(EllipsoidType type)
  29. {
  30.     EllipsoidParam(type);
  32.     // 这里转出来的B L是弧度
  33.     this.L = Math.Atan(this.Y2 / this.X2) + Math.PI;
  34.     
  35.     this.L = this.L * 180 / Math.PI;
  36.     // B需要迭代计算
  37.     double B2 = Math.Atan(Z2 / Math.Sqrt(X2 * X2 + Y2 * Y2));
  38.     double B1;
  39.     double N;
  40.     while (true)
  41.     {
  42.         N = a / Math.Sqrt(1 - f * (2 - f) * Math.Sin(B2) * Math.Sin(B2));
  43.         B1 = Math.Atan((Z2 + N * f * (2 - f) * Math.Sin(B2)) / Math.Sqrt(X2 * X2 + Y2 * Y2));
  44.         if (Math.Abs(B1 - B2) < 1e-12)
  45.             break;
  46.         B2 = B1;
  47.     }
  48.     this.B = B2 * 180 / Math.PI;
  49.     double sB = Math.Sin(this.B * d2r);
  50.     double cB = Math.Cos(this.B * d2r);
  51.     this.H = this.Z2 / sB - N * (1 - this.e * this.e);
  52. }

3.4 投影转换

此处仅实现了常见的高斯-克里格投影。上述MyPoint类中增加GaussProjection(EllipsoidType type, ProjectionSetting prjSetting)函数。

  1. /// <summary>
  2. /// 利用高斯投影将指定椭球类型的经纬度坐标转为投影坐标
  3. /// </summary>
  4. /// <param name="type">椭球类型</param>
  5. /// <param name="prjSetting">投影设置实例</param>
  6. public void GaussProjection(EllipsoidType type, ProjectionSetting prjSetting)
  7. {
  8.     this.EllipsoidParam(type);
  10.     double l = (this.L - prjSetting.CenterL) / this.rho;
  12.     double cB = Math.Cos(this.B * this.d2r);
  13.     double sB = Math.Sin(this.B * this.d2r);
  14.     double s2b = Math.Sin(this.B * this.d2r * 2);
  15.     double s4b = Math.Sin(this.B * this.d2r * 4);
  16.     double s6b = Math.Sin(this.B * this.d2r * 6);
  17.     double s8b = Math.Sin(this.B * this.d2r * 8);
  19.     double N = this.a / Math.Sqrt(1 - this.e * this.e * sB * sB);       // 卯酉圈曲率半径
  20.     double t = Math.Tan(this.B * this.d2r);
  21.     double eta = this.e2 * cB;
  23.     double m0 = this.a * (1 - this.e * this.e);
  24.     double m2 = 3.0 / 2.0 * this.e * this.e * m0;
  25.     double m4 = 5.0 / 4.0 * this.e * this.e * m2;
  26.     double m6 = 7.0 / 6.0 * this.e * this.e * m4;
  27.     double m8 = 9.0 / 8.0 * this.e * this.e * m6;
  29.     double a0 = m0 + 1.0 / 2.0 * m2 + 3.0 / 8.0 * m4 + 5.0 / 16.0 * m6 + 35.0 / 128.0 * m8;
  30.     double a2 = 1.0 / 2.0 * m2 + 1.0 / 2.0 * m4 + 15.0 / 32.0 * m6 + 7.0 / 16.0 * m8;
  31.     double a4 = 1.0 / 8.0 * m4 + 3.0 / 16.0 * m6 + 7.0 / 32.0 * m8;
  32.     double a6 = 1.0 / 32.0 * m6 + 1.0 / 16.0 * m8;
  33.     double a8 = 1.0 / 128.0 * m8;
  35.     // X1为自赤道量起的子午线弧长
  36.     double X1 = a0 * (this.B * this.d2r) - 1.0 / 2.0 * a2 * s2b + 1.0 / 4.0 * a4 * s4b - 1.0 / 6.0 * a6 * s6b + 1.0 / 8.0 * a8 * s8b;
  38.     this.Xs = X1 + N / 2 * t * cB * cB * l * l + N / 24 * t * (5 - t * t + 9 * Math.Pow(eta, 2) + 4 * Math.Pow(eta, 4)) * Math.Pow(cB, 4) * Math.Pow(l, 4)
  39.           + N / 720 * t * (61 - 58 * t * t + Math.Pow(t, 4)) * Math.Pow(cB, 6) * Math.Pow(l, 6);
  41.     
  42.     this.Ys = N * cB * l + N / 6 * (1 - t * t + eta * eta) * Math.Pow(cB, 3) * Math.Pow(l, 3)
  43.         + N / 120 * (5 - 18 * t * t + Math.Pow(t, 4) + 14 * Math.Pow(eta, 2) - 58 * eta * eta * t * t) * Math.Pow(cB, 5) * Math.Pow(l, 5);
  45.     this.Hs = this.H;
  47.     // 假东 假北偏移
  48.     
  49.     this.Xs += prjSetting.PseudoNorth;
  50.     this.Ys += prjSetting.PseudoEast;
  51. }

其中，ProjectionSetting是一个投影参数设置类，独立于MyPoint类，用于设定中央经线、东偏等投影参数。

  1. internal class ProjectionSetting
  2.     {
  3. 		private double _centerL;
  5. 		public double CenterL
  6. 		{
  7. 			get { return _centerL; }
  8. 			set { _centerL = value; }
  9. 		}
  11. 		private double _centerB;
  13. 		public double CenterB
  14. 		{
  15. 			get { return _centerB; }
  16. 			set { _centerB = value; }
  17. 		}
  19. 		private double _pseudoEast;
  21. 		public double PseudoEast
  22.         {
  23. 			get { return _pseudoEast; }
  24. 			set { _pseudoEast = value; }
  25. 		}
  27. 		private double _pseudoNorth;
  29. 		public double PseudoNorth
  30.         {
  31. 			get { return _pseudoNorth; }
  32. 			set { _pseudoNorth = value; }
  33. 		}
  35. 		private double _prjScale;
  37. 		public double PrjScale
  38. 		{
  39. 			get { return _prjScale; }
  40. 			set { _prjScale = value; }
  41. 		}
  43. 		/// <summary>
  44. 		/// 设置全部的投影参数
  45. 		/// </summary>
  46. 		/// <param name="centerL"></param>
  47. 		/// <param name="centerB"></param>
  48. 		/// <param name="pseudoEast"></param>
  49. 		/// <param name="pseudoNorth"></param>
  50. 		/// <param name="prjScale"></param>
  51. 		public ProjectionSetting(double centerL, double centerB, 
  52. 			double pseudoEast, double pseudoNorth,
  53. 			double prjScale)
  54. 		{
  55. 			CenterL = centerL;
  56. 			CenterB = centerB;
  57. 			PseudoEast = pseudoEast;
  58. 			PseudoNorth = pseudoNorth;
  59. 			PrjScale = prjScale;
  60. 		}
  62. 		/// <summary>
  63. 		/// 仅设置中央经线和东偏
  64. 		/// </summary>
  65. 		/// <param name="centerL"></param>
  66. 		/// <param name="pseudoEast"></param>
  67. 		public ProjectionSetting(double centerL, double pseudoEast)
  68. 		{
  69.             CenterL = centerL;
  70.             CenterB = 0.0;
  71.             PseudoEast = pseudoEast;
  72.             PseudoNorth = 0.0;
  73.             PrjScale = 1.0;
  74.         }
  76. 		/// <summary>
  77. 		/// 默认常用投影参数，中央经线120°，东偏500000
  78. 		/// </summary>
  79. 		public ProjectionSetting()
  80. 		{
  81.             CenterL = 120.0;
  82.             CenterB = 0.0;
  83.             PseudoEast = 500000;
  84.             PseudoNorth = 0.0;
  85.             PrjScale = 1.0;
  86.         }
  87. 	}

3.5 转换2的实现（三参数、七参数）

上述MyPoint类中增加SevenParamTrans(Datum7Paras datum7Paras)和TreeParamTrans(Datum3Paras datum3Paras)函数。

  1. /// <summary>
  2. /// 利用7参数进行坐标系之间转换
  3. /// </summary>
  4. /// <param name="datum7Paras">7参数实例</param>
  5. public void SevenParamTrans(Datum7Paras datum7Paras)
  6. {
  7.     this.dx = datum7Paras.Dx;
  8.     this.dy = datum7Paras.Dy;
  9.     this.dz = datum7Paras.Dz;
  10.     this.rx = datum7Paras.Rx * 0.0000048481373323; //1 秒=0.0000048481373323 弧度
  11.     this.ry = datum7Paras.Ry * 0.0000048481373323;
  12.     this.rz = datum7Paras.Rz * 0.0000048481373323;
  13.     this.m = datum7Paras.PPM;
  14.     this.k = this.m / 1000000;
  16.     this.X2 = (1 + k) * (this.X + this.rz * this.Y - this.ry * this.Z) + this.dx;
  17.     this.Y2 = (1 + k) * (-this.rz * this.X + this.Y + this.rx * this.Z) + this.dy;
  18.     this.Z2 = (1 + k) * (this.ry * this.X - this.rx * this.Y + this.Z) + this.dz;
  19. }
  21. /// <summary>
  22. /// 利用3参数进行坐标系之间转换
  23. /// </summary>
  24. /// <param name="datum3Paras">3参数实例</param>
  25. public void TreeParamTrans(Datum3Paras datum3Paras)
  26. {
  27.     this.dx = datum3Paras.Dx;
  28.     this.dy = datum3Paras.Dy;
  29.     this.dz = datum3Paras.Dz;
  31.     this.X2 = this.X + this.dx;
  32.     this.Y2 = this.Y + this.dy;
  33.     this.Z2 = this.Z + this.dz;
  34. }

Datum3Paras和Datum7Paras是独立于MyPoint类，用于设定坐标转换参数。

  1.    /// <summary>
  2.     /// 7参数
  3.     /// </summary>
  4.     internal class Datum7Paras
  5.     {
  6. 		private double _dx;
  8. 		public double Dx
  9. 		{
  10. 			get { return _dx; }
  11. 			set { _dx = value; }
  12. 		}
  14.         private double _dy;
  16.         public double Dy
  17.         {
  18.             get { return _dy; }
  19.             set { _dy = value; }
  20.         }
  22.         private double _dz;
  24.         public double Dz
  25.         {
  26.             get { return _dz; }
  27.             set { _dz = value; }
  28.         }
  31.         private double _rx;
  33.         public double Rx
  34.         {
  35.             get { return _rx; }
  36.             set { _rx = value; }
  37.         }
  39.         private double _ry;
  41.         public double Ry
  42.         {
  43.             get { return _ry; }
  44.             set { _ry = value; }
  45.         }
  48.         private double _rz;
  50.         public double Rz
  51.         {
  52.             get { return _rz; }
  53.             set { _rz = value; }
  54.         }
  56.         private double _ppm;
  58.         public double PPM
  59.         {
  60.             get { return _ppm; }
  61.             set { _ppm = value; }
  62.         }
  64.         public Datum7Paras(double dx, double dy,  double dz,  
  65.             double rx,  double ry,  double rz, 
  66.             double ppm)
  67.         {
  68.             _dx = dx;
  69.             _dy = dy;
  70.             _dz = dz;
  72.             _rx = rx;
  73.             _ry = ry;
  74.             _rz = rz;
  76.             _ppm = ppm;
  77.         }
  78.     }
  1.     internal class Datum3Paras
  2.     {
  3.         private double _dx;
  5.         public double Dx
  6.         {
  7.             get { return _dx; }
  8.             set { _dx = value; }
  9.         }
  11.         private double _dy;
  13.         public double Dy
  14.         {
  15.             get { return _dy; }
  16.             set { _dy = value; }
  17.         }
  19.         private double _dz;
  21.         public double Dz
  22.         {
  23.             get { return _dz; }
  24.             set { _dz = value; }
  25.         }
  28.         public Datum3Paras(double dx,  double dy,  double dz)
  29.         {
  30.             Dx = dx;
  31.             Dy = dy;
  32.             Dz = dz;
  33.         }
  34.     }

3.6 转换5的实现（四参数+高程拟合）

上述MyPoint类中增加Transform4Para(Trans4Paras transPara)函数。此处，高程拟合仅实现了已知一个测点的固定改正差。

  1. /// <summary>
  2. /// 投影坐标获取后，进一步利用4参数转换坐标
  3. /// </summary>
  4. /// <param name="transPara"></param>
  5. public void Transform4Para(Trans4Paras transPara)
  6. {
  7.     var X1 = transPara.Dx;
  8.     var Y1 = transPara.Dy;
  10.     var cosAngle = Math.Cos(transPara.A);
  11.     var sinAngle = Math.Sin(transPara.A);
  13.     X1 += transPara.K * (cosAngle * this.Xs - sinAngle * this.Ys);
  14.     Y1 += transPara.K * (sinAngle * this.Xs + cosAngle * this.Ys);
  16.     this.Xs = X1;
  17.     this.Ys = Y1;
  18. 	// 固定改正差
  19.     this.Hs += transPara.Dh;
  20. }

Trans4Paras是独立于MyPoint类，用于设定坐标转换参数。

  1.     internal class Trans4Paras
  2.     {
  3.         private double _dx;
  5.         public double Dx
  6.         {
  7.             get { return _dx; }
  8.             set { _dx = value; }
  9.         }
  11.         private double _dy;
  13.         public double Dy
  14.         {
  15.             get { return _dy; }
  16.             set { _dy = value; }
  17.         }
  19.         private double _a;
  21.         public double A
  22.         {
  23.             get { return _a; }
  24.             set { _a = value; }
  25.         }
  27.         private double _k;
  29.         public double K
  30.         {
  31.             get { return _k; }
  32.             set { _k = value; }
  33.         }
  35.         private double _dh;
  37.         public double Dh
  38.         {
  39.             get { return _dh; }
  40.             set { _dh = value; }
  41.         }
  43.         
  44.         public Trans4Paras(double dx, double dy, double a, double k, double dh)
  45.         {
  46.             Dx = dx;
  47.             Dy = dy;
  48.             A = a;
  49.             K = k;
  50.             Dh = dh;
  51.         }
  53.         public Trans4Paras()
  54.         {
  55.         }
  56.     }

3.7 调用过程

里面的参数，因为保密原因，做出了随机更改，实际使用时可根据自己情况赋值。

3.7.1 一步法

  1. // 实例化计算参数
  2. MyPoint p = new MyPoint();.
  4. p.L=113.256;
  5. p.B=31.565;
  6. p.H=5.216;
  7.  
  8. // 经纬度转空间坐标
  9. p.BLH2XYZ();
  11. // 实例化七参数
  12. Datum7Paras datum7Paras = new Datum7Paras(
  13.     489.2994563566, 141.1525159753, 15.74421120568,
  14.     -0.164423, 4.141573, -4.808299,
  15.     -6.56482989958);
  17. p.SevenParamTrans(datum7Paras);
  19. // 空间坐标转回经纬度
  20. p.XYZ2BLH(EllipsoidType.WGS84);
  22. // 高斯投影 经纬度转平面坐标
  23. // 实例化投影参数类
  24. ProjectionSetting projectionSetting = new ProjectionSetting(120,500000);
  25. p.GaussProjection(EllipsoidType.WGS84, projectionSetting);

3.7.2 两步法

  1. // 实例化计算参数
  2. MyPoint p = new MyPoint();.
  4. p.SetLBH(113.256,31.565,5.216);
  5.  
  6. // 经纬度转空间坐标
  7. p.BLH2XYZ();
  9. // 实例化七参数
  10. Datum7Paras datum7Paras = new Datum7Paras(
  11.     489.2994563566, 141.1525159753, 15.74421120568,
  12.     -0.164423, 4.141573, -4.808299,
  13.     -6.56482989958);
  15. p.SevenParamTrans(datum7Paras);
  17. // 空间坐标转回经纬度
  18. p.XYZ2BLH(EllipsoidType.WGS84);
  20. // 高斯投影 经纬度转平面坐标
  21. // 实例化投影参数类
  22. ProjectionSetting projectionSetting = new ProjectionSetting(120,500000);
  23. p.GaussProjection(EllipsoidType.WGS84, projectionSetting);
  25. Trans4Paras transformPara = new(6456.15957352521, -134618.390707439, 0.011104964500129, 1.00002537583871, 5.788);
  27. p.Transform4Para(transformPara);

4. 总结

至此，关于工程坐标系转化，即GPS接收的WGS84椭球的经纬度转换为地方坐标系的问题，基本全部实现。代码正确性和准确性的验证是与 南方GPS工具箱做对比。例如，采用上述的一步法，在设定好坐标、7参数、投影参数后，计算发现，与南方GPS工具箱在y方向偏差1mm。结果如下图：
image

原文链接：https://www.cnblogs.com/AidanLee/p/16950730.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C#热门文章

  • NPOI的Excel的读取和写入
  • 事务在c#中的使用
  • 基于欧姆龙PLC#FinsTcp协议上位机通讯(二)-C#通讯模块开发
  • C# 当前 .NET SDK 不支持将 .NET Core 2.1 设置为目标。请将 .NET Core 2.0 或更低版本设置为目标，或使用支持 .NET Core 2.1 的 .NET SDK 版本。
  • C#读写Excel的几种方法
  • C#NPOI操作Excel，实现Excel数据导入导出（支持多个sheet）
  • c#中token的使用方法实例
  • OrderBy和OrderByDescending排序
  • C#中的modbus&nbsp;Tcp协议的数据抓取和使用解析
  • C#Aspose操作Word &amp; Excel简版（后会研究补充更多功能）

    • C#推荐文章

  • .NET 9 优化，抢先体验 C# 13 新特性
  • 使用C#爬取快手作者主页，并下载视频/图集(附源码及软件下载链接)
  • 聊一聊 C# 中让人惶恐的 Bitmap
  • C#/.NET/.NET Core技术前沿周刊 | 第 2 期（2024年8.19-8.25）
  • Elsa V3学习之Flowchart详解（上）
  • C#模拟键盘输入、键状态和监听键盘消息
  • 可以调用Null的实例方法吗？
  • SemanticKernel/C#：实现接口，接入本地嵌入模型
  • C#.Net筑基-解密委托与事件
  • C#/.NET/.NET Core优秀项目和框架2024年7月简报

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号