c#分割桌面截屏，进行图片流比较，不同的图片进行原图片重绘【附示例代码下载】

关于桌面截屏图片分割为16*8块大小一样的图片，然后把截屏的图和原来的图片进行比较，一样就不发送，不同则发送然后覆盖以前的图片。【完整示例代码下载】

1. using System; 
2. using System.Collections.Generic; 
3. using System.Linq; 
4. using System.Text; 
5. using System.Windows; 
6. using System.Windows.Controls; 
7. using System.Windows.Data; 
8. using System.Windows.Documents; 
9. using System.Windows.Input; 
10. using System.Windows.Media; 
11. using System.Windows.Media.Imaging; 
12. using System.Windows.Navigation; 
13. using System.Windows.Shapes; 
14. using System.IO; 
15. using System.Drawing; 
16. using System.Runtime.InteropServices; 
17. using System.Threading; 
18. using System.Drawing.Imaging; 
19.  
20. namespace photoText 
21. { 
22.     /// <summary> 
23.     /// Window1.xaml 的交互逻辑 
24.     /// </summary> 
25.     public partial class Window1 : Window 
26.     { 
27.         private delegate void UpImageCall(ImageSource Isource); 
28.         private UpImageCall upimage; 
29.         Bitmap ALL; 
30.         public static int x = 16; 
31.         public static int y = 8; 
32.         public static int ScreenX; 
33.         public static int ScreenY; 
34.         public static int SpX; 
35.         public static int SpY; 
36. //保存所以小张图片流 
37.  List<Bitmap> LBitmap = new List<Bitmap>(); 
38.  
39.         public Window1() 
40.         { 
41.             InitializeComponent(); 
42.             upimage = Isource => 
43.             { 
44.                 image1.Source = Isource; 
45.             }; 
46.                  //获取桌面大小 
47.             ScreenX = GetScreenPixel()[0]; 
48.             ScreenY = GetScreenPixel()[1]; 
49.             //获取小张图片的长宽 
50.             SpX = ScreenX / x; 
51.             SpY = ScreenY / y; 
52.             //初始化图片数组 
53.             ALL = CaptureDesktopALL(); 
54.             CaptureDesktopT(); 
55.             Thread aa = new Thread(new ThreadStart(() => 
56.             { 
57.                 while (true) 
58.                 { 
59.                     //每隔300毫秒截一张图 
60.                     Thread.Sleep(300); 
61.                     CaptureDesktop(); 
62.  
63.                 } 
64.             })); 
65.             aa.Start(); 
66.             aa.IsBackground = true; 
67.         } 
68.         /// <summary> 
69.         /// 获取屏幕分辨率 
70.         /// </summary> 
71.         public int[] GetScreenPixel() 
72.         { 
73.             System.Windows.Forms.Screen scr = System.Windows.Forms.Screen.PrimaryScreen; 
74.             System.Drawing.Rectangle rc = scr.Bounds; 
75.             int[] sp = new int[2] { rc.Width, rc.Height }; 
76.             return sp; 
77.         } 
78.         /// <summary> 
79.         /// 截屏 
80.         /// </summary> 
81.         [DllImport("gdi32.dll")] 
82.         public static extern bool BitBlt(IntPtr hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, IntPtr hdcSrc, int nXSrc, int nYSrc, System.Drawing.CopyPixelOperation dwRop); 
83.          
84.         public void CaptureDesktop() 
85.         { 
86.             for (int j = 0; j < x; j++) 
87.             { 
88.                 for (int k = 0; k < y; k++) 
89.                 { 
90.                     try 
91.                     { 
92.                         Bitmap screenBitmap; 
93.                         using (Graphics screenGraphic = Graphics.FromHwnd(IntPtr.Zero)) 
94.                         { 
95.                             //根据屏幕大小建立位图，这就是最后截取到的*屏幕图像* 
96.                             screenBitmap = new Bitmap(SpX, SpY, screenGraphic); 
97.                             //建立位图相关Graphics 
98.                             Graphics bitmapGraphics = Graphics.FromImage(screenBitmap); 
99.                             //建立屏幕上下文 
100.                             IntPtr hdcScreen = screenGraphic.GetHdc(); 
101.                             //建立位图上下文 
102.                             IntPtr hdcBitmap = bitmapGraphics.GetHdc(); 
103.                             //将屏幕捕获保存在位图中 
104.                             BitBlt(hdcBitmap, 0, 0, SpX, SpY, hdcScreen, j * SpX, k * SpY, CopyPixelOperation.CaptureBlt | CopyPixelOperation.SourceCopy); 
105.                             //关闭位图句柄 
106.                             bitmapGraphics.ReleaseHdc(hdcBitmap); 
107.                             //关闭屏幕句柄 
108.                             screenGraphic.ReleaseHdc(hdcScreen); 
109.                             //释放位图对像 
110.                             bitmapGraphics.Dispose(); 
111.                             //释放屏幕对像 
112.                             screenGraphic.Dispose(); 
113.                             //比较之前的图片和现在的图片是否相同，不同则替换 
114.                             if (ImageCompareString(LBitmap[j * 8 + k], screenBitmap)) 
115.                             { 
116.                                 //保存最新的图片 
117.                                 LBitmap[j * 8 + k] = screenBitmap; 
118.                                 Graphics g = Graphics.FromImage(ALL); 
119.                                 //覆盖原来的图片区域 
120.                                 g.DrawImageUnscaled(LBitmap[j * 8 + k], j * SpX, k * SpY); 
121.                             } 
122.                         } 
123.                     } 
124.                     catch 
125.                     { 
126.                         throw; 
127.                     } 
128.                 } 
129.             } 
130.             MemoryStream stream = new MemoryStream(); 
131.             ALL.Save(stream, System.Drawing.Imaging.ImageFormat.Png); 
132.             // MStream(ALL); 
133.             ImageSourceConverter imageSourceConverter = new ImageSourceConverter(); 
134.             //显示整张图片 
135.             image1.Dispatcher.Invoke(upimage, (ImageSource)imageSourceConverter.ConvertFrom(stream)); 
136.         } 
137.         //获得压缩文件流 减少像素 
138.         private MemoryStream MStream(Bitmap myBitmap) 
139.         { 
140.             ImageCodecInfo myImageCodecInfo; 
141.             System.Drawing.Imaging.Encoder myEncoder; 
142.             EncoderParameter myEncoderParameter; 
143.             EncoderParameters myEncoderParameters; 
144.             MemoryStream ms = new MemoryStream(); 
145.             //设置Mime类型 
146.             myImageCodecInfo = GetEncoderInfo("image/jpeg"); 
147.             myEncoder = System.Drawing.Imaging.Encoder.Quality; 
148.             myEncoderParameters = new EncoderParameters(1); 
149.             //设置图片像素100L为最大 
150.             myEncoderParameter = new EncoderParameter(myEncoder, 50L); 
151.             myEncoderParameters.Param[0] = myEncoderParameter; 
152.             myBitmap.Save(ms, myImageCodecInfo, myEncoderParameters); 
153.             return ms; 
154.         } 
155.         private static ImageCodecInfo GetEncoderInfo(String mimeType) 
156.         { 
157.             int j; 
158.             ImageCodecInfo[] encoders; 
159.             encoders = ImageCodecInfo.GetImageEncoders(); 
160.             for (j = 0; j < encoders.Length; ++j) 
161.             { 
162.                 if (encoders[j].MimeType == mimeType) 
163.                     return encoders[j]; 
164.             } 
165.             return null; 
166.         } 
167.         /// <summary> 
168.         /// 抓取有鼠标的桌面,并且能抓到透明窗体 
169.         /// </summary> 
170.         /// <returns></returns> 
171.         public void CaptureDesktopT() 
172.         { 
173.             for (int j = 0; j < x; j++) 
174.             { 
175.                 for (int k = 0; k < y; k++) 
176.                 { 
177.                     try 
178.                     { 
179.                         Bitmap screenBitmap; 
180.                         using (Graphics screenGraphic = Graphics.FromHwnd(IntPtr.Zero)) 
181.                         { 
182.                             //根据屏幕大小建立位图，这就是最后截取到的*屏幕图像* 
183.                             //screenBitmap = new Bitmap(1280, 800, screenGraphic); 
184.                             screenBitmap = new Bitmap(SpX, SpY, screenGraphic); 
185.                             //建立位图相关Graphics 
186.                             Graphics bitmapGraphics = Graphics.FromImage(screenBitmap); 
187.                             //建立屏幕上下文 
188.                             IntPtr hdcScreen = screenGraphic.GetHdc(); 
189.                             //建立位图上下文 
190.                             IntPtr hdcBitmap = bitmapGraphics.GetHdc(); 
191.                             //将屏幕捕获保存在位图中 
192.                             BitBlt(hdcBitmap, 0, 0, SpX, SpY, hdcScreen, j * SpX, k * SpY, CopyPixelOperation.CaptureBlt | CopyPixelOperation.SourceCopy); 
193.                             //关闭位图句柄 
194.                             bitmapGraphics.ReleaseHdc(hdcBitmap); 
195.                             //关闭屏幕句柄 
196.                             screenGraphic.ReleaseHdc(hdcScreen); 
197.                             //释放位图对像 
198.                             bitmapGraphics.Dispose(); 
199.                             //释放屏幕对像 
200.                             screenGraphic.Dispose(); 
201.                             //初始化16*8张图片 
202.                             LBitmap.Add(screenBitmap); 
203.                         } 
204.                     } 
205.                     catch 
206.                     { 
207.                         
208.                     } 
209.                 } 
210.             } 
211.             //Graphics g = Graphics.FromImage(ALL); 
212.             //g.DrawImageUnscaled(LBitmap[2], 200, 200); 
213.             //MemoryStream stream = new MemoryStream(); 
214.             //ALL.Save(stream, System.Drawing.Imaging.ImageFormat.Png); 
215.             //ImageSourceConverter imageSourceConverter = new ImageSourceConverter(); 
216.             //image1.Source = (ImageSource)imageSourceConverter.ConvertFrom(stream); 
217.         } 
218.         public Bitmap CaptureDesktopALL() 
219.         { 
220.             Bitmap screenBitmap; 
221.             using (Graphics screenGraphic = Graphics.FromHwnd(IntPtr.Zero)) 
222.             { 
223.                 //根据屏幕大小建立位图，这就是最后截取到的*屏幕图像* 
224.                 //screenBitmap = new Bitmap(1280, 800, screenGraphic); 
225.                 screenBitmap = new Bitmap(GetScreenPixel()[0], GetScreenPixel()[1], screenGraphic); 
226.                 //建立位图相关Graphics 
227.                 Graphics bitmapGraphics = Graphics.FromImage(screenBitmap); 
228.                 //建立屏幕上下文 
229.                 IntPtr hdcScreen = screenGraphic.GetHdc(); 
230.                 //建立位图上下文 
231.                 IntPtr hdcBitmap = bitmapGraphics.GetHdc(); 
232.                 //将屏幕捕获保存在位图中 
233.                 BitBlt(hdcBitmap, 0, 0, GetScreenPixel()[0], GetScreenPixel()[1], hdcScreen, 0, 0, CopyPixelOperation.CaptureBlt | CopyPixelOperation.SourceCopy); 
234.                 //关闭位图句柄 
235.                 bitmapGraphics.ReleaseHdc(hdcBitmap); 
236.                 //关闭屏幕句柄 
237.                 screenGraphic.ReleaseHdc(hdcScreen); 
238.                 //释放位图对像 
239.                 bitmapGraphics.Dispose(); 
240.                 //释放屏幕对像 
241.                 screenGraphic.Dispose(); 
242.                 MemoryStream stream = new MemoryStream(); 
243.                 screenBitmap.Save(stream, System.Drawing.Imaging.ImageFormat.Png); 
244.                 ImageSourceConverter imageSourceConverter = new ImageSourceConverter(); 
245.                 image1.Source = (ImageSource)imageSourceConverter.ConvertFrom(stream); 
246.                 return screenBitmap; 
247.             } 
248.         } 
249.         //图片比较类 
250.         public static bool ImageCompareString(Bitmap firstImage, Bitmap secondImage) 
251.         { 
252.             MemoryStream ms = new MemoryStream(); 
253.             firstImage.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg); 
254.             String firstBitmap = Convert.ToBase64String(ms.ToArray()); 
255.             ms.Position = 0; 
256.             secondImage.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg); 
257.             String secondBitmap = Convert.ToBase64String(ms.ToArray()); 
258.             if (firstBitmap.Equals(secondBitmap)) 
259.             { 
260.                 return false; 
261.             } 
262.             else 
263.             { 
264.                 return true; 
265.             } 
266.         } 
267.     } 
268. }