服务器之家：专注于VPS、云服务器配置技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - C# - C# 抓图服务的实现

C# 抓图服务的实现

2022-10-26 13:30xhubobo C#

这篇文章主要介绍了C# 抓图服务的实现，帮助大家更好的利用c#处理窗口，进行截图，感兴趣的朋友可以了解下

C#抓图服务首先抽象出抓图接口，然后对接口做基于公共操作的抽象类封装，之后针对不同的抓图方式做差异化处理，最后根据接口实现抓图服务。

注意：Win32封装实现参考C#使用BitBlt进行窗口抓图。

Github示例工程：SimpleWindowCapture。

1、抓图接口

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
using System;
using Win32Proxy;
 
namespace CaptureProxy
{
 internal interface ICaptureHelper
 {
  bool Init(string windowName);
  bool Init(IntPtr handle);
  void Cleanup();
  bool RefreshWindow();
  bool ChangeWindowHandle(string windowName);
  bool ChangeWindowHandle(IntPtr handle);
  IntPtr Capture();
  bool Capture(out IntPtr bitsPtr, out int bufferSize, out Win32Types.Rect rect);
 
  Win32Types.Rect WindowRect { get; }
  Win32Types.Rect ClientRect { get; }
  int BitmapDataSize { get; }
  IntPtr BitmapPtr { get; }
  Win32Types.BitmapInfo BitmapInfo { get; }
 }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
using System.ComponentModel;
 
namespace CaptureProxy
{
 public enum CaptureType
 {
  [Description("使用CreateDIBSection抓图，速度快，但是无法抓取D3D等渲染的窗口")]
  CreateDibSection = 0,
 
  [Description("使用PrintWindow抓图，速度慢(16ms左右)，但是可以抓取D3D等渲染的窗口")]
  PrintWindow
 }
}

2、抓图抽象类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
using System;
using Win32Proxy;
 
namespace CaptureProxy
{
 internal abstract class AbsCaptureHelper : ICaptureHelper
 {
  public Win32Types.Rect WindowRect => _windowRect;
  public Win32Types.Rect ClientRect => WinClientRect;
  public int BitmapDataSize => _bmpDataSize;
  public IntPtr BitmapPtr => HBitmap;
  public Win32Types.BitmapInfo BitmapInfo { get; } = new Win32Types.BitmapInfo();
 
  protected IntPtr HWnd = IntPtr.Zero;
  protected IntPtr HScrDc = IntPtr.Zero;
  protected IntPtr HMemDc = IntPtr.Zero;
  protected IntPtr HBitmap = IntPtr.Zero;
  protected IntPtr HOldBitmap = IntPtr.Zero;
 
  private Win32Types.Rect _windowRect;
  protected Win32Types.Rect WinClientRect;
  private int _bmpDataSize;
 
  protected abstract bool CommonInit();
  protected abstract IntPtr DoCapture();
  protected abstract bool DoCapture(out IntPtr bitsPtr);
 
  public bool Init(string windowName)
  {
   var handle = Win32Funcs.FindWindowWrapper(null, windowName);
   if (handle.Equals(IntPtr.Zero))
   {
    return false;
   }
 
   return Init(handle);
  }
 
  public bool Init(IntPtr handle)
  {
   HWnd = handle;
 
   //获取窗口大小
   if (!Win32Funcs.GetWindowRectWrapper(HWnd, out _windowRect)
    || !Win32Funcs.GetClientRectWrapper(HWnd, out WinClientRect))
   {
    return false;
   }
 
   _bmpDataSize = WinClientRect.Width * WinClientRect.Height * 3;
 
   return CommonInit();
  }
 
  public void Cleanup()
  {
   if (HBitmap.Equals(IntPtr.Zero))
   {
    return;
   }
 
   //删除用过的对象
   Win32Funcs.SelectObjectWrapper(HMemDc, HOldBitmap);
   Win32Funcs.DeleteObjectWrapper(HBitmap);
   Win32Funcs.DeleteDcWrapper(HMemDc);
   Win32Funcs.ReleaseDcWrapper(HWnd, HScrDc);
 
   HWnd = IntPtr.Zero;
   HScrDc = IntPtr.Zero;
   HMemDc = IntPtr.Zero;
   HBitmap = IntPtr.Zero;
   HOldBitmap = IntPtr.Zero;
   //_bitsPtr = IntPtr.Zero;
  }
 
  public bool RefreshWindow()
  {
   return ChangeWindowHandle(HWnd);
  }
 
  public bool ChangeWindowHandle(string windowName)
  {
   Cleanup();
   return Init(windowName);
  }
 
  public bool ChangeWindowHandle(IntPtr handle)
  {
   Cleanup();
   return Init(handle);
  }
 
  public IntPtr Capture()
  {
   if (HBitmap.Equals(IntPtr.Zero) || HMemDc.Equals(IntPtr.Zero) || HScrDc.Equals(IntPtr.Zero))
   {
    return IntPtr.Zero;
   }
 
   return DoCapture();
  }
 
  public bool Capture(out IntPtr bitsPtr, out int bufferSize, out Win32Types.Rect rect)
  {
   bitsPtr = IntPtr.Zero;
   bufferSize = _bmpDataSize;
   rect = WinClientRect;
 
   if (HBitmap.Equals(IntPtr.Zero) || HMemDc.Equals(IntPtr.Zero) || HScrDc.Equals(IntPtr.Zero))
   {
    return false;
   }
 
   return DoCapture(out bitsPtr);
  }
 }
}

3、抓图类实现

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
using System;
using Win32Proxy;
 
namespace CaptureProxy
{
 internal class DibCaptureHelper : AbsCaptureHelper
 {
  private Win32Types.BitmapInfo _bitmapInfo;
  private IntPtr _bitsPtr = IntPtr.Zero;
 
  protected override bool CommonInit()
  {
   //位图信息
   _bitmapInfo = new Win32Types.BitmapInfo {bmiHeader = new Win32Types.BitmapInfoHeader()};
   _bitmapInfo.bmiHeader.Init();
   _bitmapInfo.bmiHeader.biWidth = WinClientRect.Width;
   _bitmapInfo.bmiHeader.biHeight = WinClientRect.Height;
   _bitmapInfo.bmiHeader.biPlanes = 1;
   _bitmapInfo.bmiHeader.biBitCount = 24;
   _bitmapInfo.bmiHeader.biSizeImage = (uint) (WinClientRect.Width * WinClientRect.Height);
   _bitmapInfo.bmiHeader.biCompression = (uint) Win32Consts.BitmapCompressionMode.BI_RGB;
 
   HScrDc = Win32Funcs.GetWindowDcWrapper(HWnd);
   HMemDc = Win32Funcs.CreateCompatibleDcWrapper(HScrDc);
   HBitmap = Win32Funcs.CreateDibSectionWrapper(HMemDc, ref _bitmapInfo,
    (uint) Win32Consts.DibColorMode.DIB_RGB_COLORS,
    out _bitsPtr, IntPtr.Zero, 0);
   HOldBitmap = Win32Funcs.SelectObjectWrapper(HMemDc, HBitmap);
 
   return true;
  }
 
  protected override IntPtr DoCapture()
  {
   var ret = Win32Funcs.BitBltWrapper(
    HMemDc, 0, 0, WinClientRect.Width, WinClientRect.Height,
    HScrDc, 0, 0,
    (uint) Win32Consts.RasterOperationMode.SRCCOPY);
   return ret ? _bitsPtr : IntPtr.Zero;
  }
 
  protected override bool DoCapture(out IntPtr bitsPtr)
  {
   bitsPtr = _bitsPtr;
   var ret = Win32Funcs.BitBltWrapper(
    HMemDc, 0, 0, WinClientRect.Width, WinClientRect.Height,
    HScrDc, 0, 0,
    (uint) Win32Consts.RasterOperationMode.SRCCOPY);
   return ret;
  }
 }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
using System;
using Win32Proxy;
 
namespace CaptureProxy
{
 internal class PrintCaptureHelper : AbsCaptureHelper
 {
  protected override bool CommonInit()
  {
   HScrDc = Win32Funcs.GetWindowDcWrapper(HWnd);
   HBitmap = Win32Funcs.CreateCompatibleBitmapWrapper(HScrDc, WinClientRect.Width, WinClientRect.Height);
   HMemDc = Win32Funcs.CreateCompatibleDcWrapper(HScrDc);
   HOldBitmap = Win32Funcs.SelectObjectWrapper(HMemDc, HBitmap);
   return true;
  }
 
  protected override IntPtr DoCapture()
  {
   var ret = Win32Funcs.PrintWindowWrapper(HWnd, HMemDc,
    (uint) Win32Consts.PrintWindowMode.PW_CLIENTONLY |
    (uint) Win32Consts.PrintWindowMode.PW_RENDERFULLCONTENT);
   return ret ? HBitmap : IntPtr.Zero;
  }
 
  protected override bool DoCapture(out IntPtr bitsPtr)
  {
   bitsPtr = HBitmap;
   var ret = Win32Funcs.PrintWindowWrapper(HWnd, HMemDc,
    (uint) Win32Consts.PrintWindowMode.PW_CLIENTONLY |
    (uint) Win32Consts.PrintWindowMode.PW_RENDERFULLCONTENT);
   return ret;
  }
 }
}

4、抓图服务

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
using System;
using System.Collections.Generic;
using Win32Proxy;
 
namespace CaptureProxy
{
 public class CaptureService
 {
  private readonly Dictionary<string, ICaptureHelper> _dicCaptureHelper;
 
  /// <summary>
  /// 注册抓图服务
  /// </summary>
  /// <param name="name">抓图服务名称</param>
  /// <param name="windowName">窗口名称</param>
  /// <param name="type">抓图类型</param>
  /// <returns>true成功,false失败</returns>
  public bool RegisterCapture(string name, string windowName, CaptureType type = CaptureType.CreateDibSection)
  {
   if (string.IsNullOrEmpty(name) || _dicCaptureHelper.ContainsKey(name))
   {
    return false;
   }
 
   ICaptureHelper helper;
   switch (type)
   {
    case CaptureType.CreateDibSection:
     helper = new DibCaptureHelper();
     break;
    case CaptureType.PrintWindow:
     helper = new PrintCaptureHelper();
     break;
    default:
     return false;
   }
 
   if (!helper.Init(windowName))
   {
    return false;
   }
 
   _dicCaptureHelper.Add(name, helper);
 
   return true;
  }
 
  /// <summary>
  /// 注册抓图服务
  /// </summary>
  /// <param name="name">抓图服务名称</param>
  /// <param name="handle">窗口句柄</param>
  /// <param name="type">抓图类型</param>
  /// <returns>true成功,false失败</returns>
  public bool RegisterCapture(string name, IntPtr handle, CaptureType type = CaptureType.CreateDibSection)
  {
   if (string.IsNullOrEmpty(name) || _dicCaptureHelper.ContainsKey(name))
   {
    return false;
   }
 
   ICaptureHelper helper;
   switch (type)
   {
    case CaptureType.CreateDibSection:
     helper = new DibCaptureHelper();
     break;
    case CaptureType.PrintWindow:
     helper = new PrintCaptureHelper();
     break;
    default:
     return false;
   }
 
   if (!helper.Init(handle))
   {
    return false;
   }
 
   _dicCaptureHelper.Add(name, helper);
 
   return true;
  }
 
  /// <summary>
  /// 获取是否已注册抓图服务
  /// </summary>
  /// <param name="name">抓图服务名称</param>
  /// <returns>true已注册,false未注册</returns>
  public bool IsRegister(string name)
  {
   return !string.IsNullOrEmpty(name) && _dicCaptureHelper.ContainsKey(name);
  }
 
  /// <summary>
  /// 注销抓图服务
  /// </summary>
  /// <param name="name">抓图服务名称</param>
  public void UnRegisterCapture(string name)
  {
   if (string.IsNullOrEmpty(name) || !_dicCaptureHelper.ContainsKey(name))
   {
    return;
   }
 
   _dicCaptureHelper[name]?.Cleanup();
   _dicCaptureHelper.Remove(name);
  }
 
  /// <summary>
  /// 清理所有抓图服务
  /// </summary>
  public void Cleanup()
  {
   foreach (var helper in _dicCaptureHelper)
   {
    helper.Value?.Cleanup();
   }
 
   _dicCaptureHelper.Clear();
  }
 
  public bool RefreshWindow(string name)
  {
   var ret = !string.IsNullOrEmpty(name) && _dicCaptureHelper.ContainsKey(name);
   if (ret)
   {
    ret = _dicCaptureHelper[name].RefreshWindow();
   }
 
   return ret;
  }
 
  /// <summary>
  /// 修改窗口句柄
  /// </summary>
  /// <param name="name">抓图服务名称</param>
  /// <param name="handle">窗口句柄</param>
  public bool ChangeWindowHandle(string name, IntPtr handle)
  {
   return !string.IsNullOrEmpty(name) && _dicCaptureHelper.ContainsKey(name) &&
     _dicCaptureHelper[name].ChangeWindowHandle(handle);
  }
 
  /// <summary>
  /// 修改窗口句柄
  /// </summary>
  /// <param name="name">抓图服务名称</param>
  /// <param name="windowName">窗口名称</param>
  public bool ChangeWindowHandle(string name, string windowName)
  {
   return !string.IsNullOrEmpty(name) && _dicCaptureHelper.ContainsKey(name) &&
     _dicCaptureHelper[name].ChangeWindowHandle(windowName);
  }
 
  /// <summary>
  /// 获取窗口尺寸
  /// </summary>
  /// <param name="name">抓图服务名称</param>
  /// <param name="winRect">输出的窗口尺寸</param>
  /// <returns>true成功,false失败</returns>
  public bool GetWindowRect(string name, out Win32Types.Rect winRect)
  {
   var ret = !string.IsNullOrEmpty(name) && _dicCaptureHelper.ContainsKey(name);
   winRect = ret ? _dicCaptureHelper[name].WindowRect : new Win32Types.Rect();
   return ret;
  }
 
  /// <summary>
  /// 获取窗口客户区尺寸
  /// </summary>
  /// <param name="name">抓图服务名称</param>
  /// <param name="clientRect">输出的窗口客户区尺寸</param>
  /// <returns>true成功,false失败</returns>
  public bool GetClientRect(string name, out Win32Types.Rect clientRect)
  {
   var ret = !string.IsNullOrEmpty(name) && _dicCaptureHelper.ContainsKey(name);
   clientRect = ret ? _dicCaptureHelper[name].ClientRect : new Win32Types.Rect();
   return ret;
  }
 
  /// <summary>
  /// 获取抓图数据大小
  /// </summary>
  /// <param name="name">抓图服务名称</param>
  /// <param name="bmpDataSize">抓图数据大小</param>
  /// <returns>true成功,false失败</returns>
  public bool GetBitmapDataSize(string name, out int bmpDataSize)
  {
   var ret = !string.IsNullOrEmpty(name) && _dicCaptureHelper.ContainsKey(name);
   bmpDataSize = ret ? _dicCaptureHelper[name].BitmapDataSize : 0;
   return ret;
  }
 
  public IntPtr GetBitmapPtr(string name)
  {
   if (string.IsNullOrEmpty(name) || !_dicCaptureHelper.ContainsKey(name))
   {
    return IntPtr.Zero;
   }
 
   return _dicCaptureHelper[name].BitmapPtr;
  }
 
  public Win32Types.BitmapInfo GetBitmapInfo(string name)
  {
   if (string.IsNullOrEmpty(name) || !_dicCaptureHelper.ContainsKey(name))
   {
    return new Win32Types.BitmapInfo();
   }
 
   return _dicCaptureHelper[name].BitmapInfo;
  }
 
  /// <summary>
  /// 获取抓图
  /// </summary>
  /// <param name="name">抓图服务名称</param>
  /// <param name="bitsPtr">位图指针</param>
  /// <returns>true成功,false失败</returns>
  public bool Capture(string name, out IntPtr bitsPtr)
  {
   var ret = !string.IsNullOrEmpty(name) && _dicCaptureHelper.ContainsKey(name);
   bitsPtr = ret ? _dicCaptureHelper[name].Capture() : IntPtr.Zero;
   return ret && !bitsPtr.Equals(IntPtr.Zero);
  }
 
  /// <summary>
  /// 获取抓图
  /// </summary>
  /// <param name="name">抓图服务名称</param>
  /// <param name="bitsPtr">位图指针</param>
  /// <param name="bufferSize">位图数据大小</param>
  /// <param name="texSize">位图尺寸</param>
  /// <returns>true成功,false失败</returns>
  public bool Capture(string name, out IntPtr bitsPtr, out int bufferSize, out Win32Types.Rect texSize)
  {
   if (string.IsNullOrEmpty(name) || !_dicCaptureHelper.ContainsKey(name))
   {
    bitsPtr = IntPtr.Zero;
    bufferSize = 0;
    texSize = new Win32Types.Rect();
    return false;
   }
 
   return _dicCaptureHelper[name].Capture(out bitsPtr, out bufferSize, out texSize);
  }
 
  #region 单例模式
 
  private static CaptureService _instance;
 
  private static readonly object LockHelper = new object();
 
  private CaptureService()
  {
   _dicCaptureHelper = new Dictionary<string, ICaptureHelper>();
  }
 
  public static CaptureService Instance
  {
   get
   {
    if (_instance != null)
    {
     return _instance;
    }
 
    lock (LockHelper)
    {
     _instance = _instance ?? new CaptureService();
    }
 
    return _instance;
   }
  }
 
  #endregion
 }
}

5、使用示例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
using System;
using System.Threading;
using CaptureProxy;
using Win32Proxy;
 
namespace SimpleWindowCapture
{
 internal sealed class CaptureHelper
 {
  public event Action<string, IntPtr, Win32Types.BitmapInfo> CaptureDone =
   (captureName, bitmapPtr, bitmapInfo) => { };
 
  public int Fps { get; set; } = 15;
 
  private double TimerInterval => 1000.0 / Fps;
  private string _captureName;
  private Timer _timer;
 
  public bool Start(string captureName, IntPtr handle, CaptureType type = CaptureType.CreateDibSection)
  {
   if (!CaptureService.Instance.RegisterCapture(captureName, handle, type))
   {
    return false;
   }
 
   _captureName = captureName;
 
   //创建守护定时器，马上执行
   _timer = new Timer(CaptureFunc, null,
    TimeSpan.FromMilliseconds(0), Timeout.InfiniteTimeSpan);
 
   return true;
  }
 
  public void Stop()
  {
   //移除定时器
   _timer?.Dispose();
   _timer = null;
 
   CaptureService.Instance.UnRegisterCapture(_captureName);
   _captureName = string.Empty;
  }
 
  private void CaptureFunc(object state)
  {
   Capture();
 
   //执行下次定时器
   _timer?.Change(TimeSpan.FromMilliseconds(TimerInterval), Timeout.InfiniteTimeSpan);
  }
 
  private void Capture()
  {
   IntPtr bitsPtr;
   if (!CaptureService.Instance.Capture(_captureName, out bitsPtr))
   {
    return;
   }
 
   var bitmapPtr = CaptureService.Instance.GetBitmapPtr(_captureName);
   var bitmapInfo = CaptureService.Instance.GetBitmapInfo(_captureName);
   CaptureDone.Invoke(_captureName, bitmapPtr, bitmapInfo);
  }
 }
}

以上就是C# 抓图服务的实现的详细内容，更多关于c# 抓图服务的资料请关注服务器之家其它相关文章！

原文链接：https://www.cnblogs.com/xhubobo/p/12809988.html

  • C#
  • 抓图

    • 延伸 · 阅读

    精彩推荐
    • C#简述C#枚举高级战术

      简述C#枚举高级战术

      这篇文章主要介绍了简述C#枚举高级战术，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小...

      精致码农 • 王亮11032022-10-11
    • C#VMS中解协议常用方法备忘(小结)

      VMS中解协议常用方法备忘(小结)

      这篇文章主要介绍了VMS中解协议常用方法备忘(小结)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们...

      森大科技3302022-08-16
    • C#WPF弹出带蒙板的消息框

      WPF弹出带蒙板的消息框

      这篇文章主要为大家详细介绍了WPF弹出带蒙板的消息框，具有一定的参考价值，感兴趣的小伙伴们可以参考一下...

      普通的地球人9142021-12-16
    • C#C#编程高并发的几种处理方法详解

      C#编程高并发的几种处理方法详解

      这篇文章主要为大家详细介绍了C#编程高并发的几种处理方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下...

      zock4942022-02-17
    • C#C#调用WebService实例与开发教程(推荐)

      C#调用WebService实例与开发教程(推荐)

      下面小编就为大家分享一篇C#调用WebService实例与开发教程，具有很好的参考价值，希望对大家有所帮助。一起跟随想过来看看吧...

      被上帝咬过的苹果4422022-02-15
    • C#C#遍历文件夹获取指定后缀名文件

      C#遍历文件夹获取指定后缀名文件

      这篇文章主要为大家详细介绍了C#遍历文件夹获取指定后缀名文件，具有一定的参考价值，感兴趣的小伙伴们可以参考一下...

      cell0065652022-07-14
    • C#C#.net编程创建Access文件和Excel文件的方法详解

      C#.net编程创建Access文件和Excel文件的方法详解

      这篇文章主要介绍了C#.net编程创建Access文件和Excel文件的方法,结合实例形式总结分析了C#创建Access与Excel文件的几种常用技巧,具有一定参考借鉴价值,需要的...

      郑文亮3572021-11-25
    • C#Audio Source组件及相关API

      Audio Source组件及相关API

      这篇文章主要介绍了Audio Source组件及相关API的相关知识，非常不错，具有参考借鉴价值,需要的朋友可以参考下...

      小玉龙7592022-02-13
    最近更新
    编辑推荐
    阅读排行
    热门标签
    修改界面 　 osg 　 刷新桌面 　 nancy 　 TaskManager 　 网站授权 　 下拉式 　 DirectoryEntry 　 C#编程 　 网站功能 　 通知窗口 　 相互关系 　 语句顺序 　 编程错误 　 悬浮框 　 Dispose 　 滚动新闻 　 HttpPost 　 静态构造函数 　 焦点 　 类型派生 　 深度拷贝 　 小写转大写金额 　 任务并行库 　 众数 　 更新数据库 　 统计字数 　 二乘法 　 IComparer 　 DataBinding 　
    © 2019-2022 服务器之家(www.tuohang.net) 版权所有关于我们联系我们版权申明网站地图