C# screenshot Fehler?

Question

Ich verwende den folgenden Code um einen Screenshot aufzunehmen:

var rc = SystemInformation.VirtualScreen; 
Bitmap bmp = new Bitmap(rc.Width, rc.Height); 
Graphics g = Graphics.FromImage(bmp); 
g.CopyFromScreen(rc.Left, rc.Top, 0, 0, bmp.Size, CopyPixelOperation.SourceCopy); 

Nun ist diese wunderbar funktioniert und es ist leicht, mit zu arbeiten, aber ich über wenig ‚weißen Punkte‘ immer kam in einige der Screenshots. Dies kann sehr störend sein und das Bild verzerren, wenn es in größeren Mengen auftritt.

ich es geschafft, das Problem zu verengen und wenn ich versuche, einen Screenshot von dem folgenden Bild zu nehmen tritt der Fehler:

Der Ausgang des Screenshot wie folgt aussieht:

Wie können Sie das beheben? Und aus Neugier, wie ist das erklärt?

In meiner Testumgebung wird der Screenshot überhaupt nicht gespeichert. Ich kann es direkt mit dem folgenden Code verwenden:

pictureBox1.Image = bmp; 

tl; dr Ich versuche, Screenshots zu nehmen und einige der Pixel sind mit weißen ersetzt und das Ergebnis verfälschen.

Vielen Dank im Voraus.

EDIT: (Weiß von der Hintergrundfarbe des Formulars, Dank für das Auffinden dieses spender kommt) Es stellt sich heraus, dass die Bitmap der Bereich transparent macht

Aber offensichtlich wie man deutlich sehen kann Im ersten Bild; Ich versuche nicht, irgendeinen transparenten Inhalt einzufangen. Warum macht es das?

EDIT2:

Das ist die ganze Klasse I meinen Screenshot bin mit wählen:

public partial class SnippingTool : Form 
{ 
    public static Image Snip() 
    { 
     var rc = SystemInformation.VirtualScreen; 

     Bitmap bmp = new Bitmap(rc.Width, rc.Height); 
     Graphics g = Graphics.FromImage(bmp); 
     g.CopyFromScreen(rc.Left, rc.Top, 0, 0, bmp.Size, CopyPixelOperation.SourceCopy); 

     var snipper = new SnippingTool(bmp); 

     if (snipper.ShowDialog() == DialogResult.OK) 
     { 
      return snipper.Image; 
     } 

     return null; 
    } 

    public SnippingTool(Image screenShot) 
    { 
     InitializeComponent(); 
     this.BackgroundImage = screenShot; 
     this.ShowInTaskbar = false; 
     this.FormBorderStyle = FormBorderStyle.None; 
     this.StartPosition = FormStartPosition.Manual; 

     int screenLeft = SystemInformation.VirtualScreen.Left; 
     int screenTop = SystemInformation.VirtualScreen.Top; 
     int screenWidth = SystemInformation.VirtualScreen.Width; 
     int screenHeight = SystemInformation.VirtualScreen.Height; 

     this.Size = new System.Drawing.Size(screenWidth, screenHeight); 
     this.Location = new System.Drawing.Point(screenLeft, screenTop); 


     this.DoubleBuffered = true; 
    } 

    public Image Image { get; set; } 

    private Rectangle rcSelect = new Rectangle(); 
    private Point pntStart; 

    protected override void OnMouseDown(MouseEventArgs e) 
    { 
     if (e.Button != MouseButtons.Left) return; 
     pntStart = e.Location; 
     rcSelect = new Rectangle(e.Location, new Size(0, 0)); 
     this.Invalidate(); 
    } 

    protected override void OnMouseMove(MouseEventArgs e) 
    { 
     if (e.Button != MouseButtons.Left) return; 
     int x1 = Math.Min(e.X, pntStart.X); 
     int y1 = Math.Min(e.Y, pntStart.Y); 
     int x2 = Math.Max(e.X, pntStart.X); 
     int y2 = Math.Max(e.Y, pntStart.Y); 
     rcSelect = new Rectangle(x1, y1, x2 - x1, y2 - y1); 
     this.Invalidate(); 
    } 

    protected override void OnMouseUp(MouseEventArgs e) 
    { 
     if (rcSelect.Width <= 0 || rcSelect.Height <= 0) return; 
     Image = new Bitmap(rcSelect.Width, rcSelect.Height); 
     using (Graphics gr = Graphics.FromImage(Image)) 
     { 
      gr.DrawImage(this.BackgroundImage, new Rectangle(0, 0, Image.Width, Image.Height), 
       rcSelect, GraphicsUnit.Pixel); 
     } 
     DialogResult = DialogResult.OK; 
    } 

    protected override void OnPaint(PaintEventArgs e) 
    { 
     using (Brush br = new SolidBrush(Color.FromArgb(120, Color.Black))) 
     { 
      int x1 = rcSelect.X; int x2 = rcSelect.X + rcSelect.Width; 
      int y1 = rcSelect.Y; int y2 = rcSelect.Y + rcSelect.Height; 
      e.Graphics.FillRectangle(br, new Rectangle(0, 0, x1, this.Height)); 
      e.Graphics.FillRectangle(br, new Rectangle(x2, 0, this.Width - x2, this.Height)); 
      e.Graphics.FillRectangle(br, new Rectangle(x1, 0, x2 - x1, y1)); 
      e.Graphics.FillRectangle(br, new Rectangle(x1, y2, x2 - x1, this.Height - y2)); 
     } 
     using (Pen pen = new Pen(Color.Red, 3)) 
     { 
      e.Graphics.DrawRectangle(pen, rcSelect); 
     } 
    } 

    protected override bool ProcessCmdKey(ref Message msg, Keys keyData) 
    { 
     if (keyData == Keys.Escape) this.DialogResult = DialogResult.Cancel; 
     return base.ProcessCmdKey(ref msg, keyData); 
    } 
} 

Auf meiner Form Ich gehe dann:

pictureBox1.Image = SnippingTool.Snip(); 

Answer 1

Für alle, die über kommen dieses Problem; dies ist die Konfiguration, die für mich arbeiten gut endete:

var rc = SystemInformation.VirtualScreen; 

using (Bitmap bmp = new Bitmap(rc.Width, rc.Height, PixelFormat.Format32bppRgb)) 
{ 
    using (Graphics g = Graphics.FromImage(bmp)) 
    { 
     g.CopyFromScreen(rc.Left, rc.Top, 0, 0, bmp.Size); 
    } 
    using (var snipper = new SnippingTool(bmp)) 
    { 
     if (snipper.ShowDialog() == DialogResult.OK) 
     { 
      return snipper.Image; 
     } 
    } 
    return null; 
} 

Answer 2

Das Problem ist, dass wir den Bildschirm in ARGB wurden die Erfassung und das aufgenommene Bild mit Transparenz kommen würde.

Dann würden wir es als JPG speichern, und die Transparenz würde weiß werden.

das Problem zu lösen, brauchen wir nur die Bitmap mit einem expliziten Pixelformat zu instanziiert, die NICHT alpha enthalten:

Bitmap screenBmp = new Bitmap(width, height, PixelFormat.Format32bppRgb)