C# WPF应用程序在移动时冻结

我只是做了一个简单的应用程序来定期获取屏幕截图。

我遇到的主要问题是，当我移动应用程序时，它会冻结。

所以主要的目标是消除屏幕截图、线程等的影响

我把所有的代码都放在这里，这样你就可以复制它了

下面是此代码的一些.NET评测信息

有什么线索可以帮我修吗

XAML

C#DLL

namespace MyScreenGrabber
{
公共委托void changedventhadler（对象发送方，事件参数e）；
公共类截屏器：窗口
{
公共事件变更事件处理者变更；
受保护的虚拟void一旦更改（EventArgs e）
{
如果（已更改！=null）
改变（本，e）；
}
字节[]位图数据{set；get；}
int区间{set；get；}
调度程序计时器{set；get；}
公共屏幕抓取器（整数间隔）
{
间隔=间隔；
计时器=新调度程序（）；
Timer.Interval=新的时间跨度（0，0，Interval）；
Timer.Tick+=新事件处理程序（Timer\u Tick）；
Timer.Start（）；
}
无效计时器勾号（对象发送方，事件参数e）
{
WindowInteropHelper WindowInteropHelper=WindowInteropHelper=新的WindowInteropHelper（此）；
Screen Screen=Screen.FromHandle（windowInteropHelper.Handle）；
使用（MemoryStream ms=new MemoryStream（））
{
如果（屏幕！=null）
{
使用（位图位图=新位图（screen.Bounds.Size.Width、screen.Bounds.Size.Height））
{
使用（Graphics g=Graphics.FromImage（位图））
{
g、 CopyFromScreen（screen.Bounds.X，screen.Bounds.Y，0，0，screen.Bounds.Size，CopyPixelOperation.SourceCopy）；
}
ImageCodecInfo myImageCodecInfo；
myImageCodecInfo=GetEncoderInfo（“图像/jpeg”）；
System.Drawing.Imaging.Encoder编码器；
myEncoder=System.Drawing.Imaging.Encoder.Quality；
EncoderParameters EncoderParameters=新的EncoderParameters（）；
编码器参数编码器参数=新编码器参数（myEncoder，25L）；
encoderParameters.Param[0]=encoderParameter；
保存（ms、myImageCodecInfo、encoderParameters）；
BitmapData=ms.ToArray（）；
一旦更改（EventArgs.Empty）；
}
}
}
}
静态ImageCodeInfo GetEncoderInfo（字符串mimeType）
{
int j；
ImageCodeInfo[]编码器；
编码器=ImageCodecInfo.GetImageEncoders（）；
对于（j=0；j

---

优化代码：

namespace MyScreenGrabber
{
    public delegate void ChangedEventHandler(object sender, EventArgs e);

    public class ScreenGrabber : Window
    {
        public event ChangedEventHandler Changed;

        protected virtual void OnChanged(EventArgs e)
        {
            if (Changed != null)
                Changed(this, e);
        }

        byte[] BitmapData { set; get; }

        int Interval { set; get; }

        WindowInteropHelper windowInteropHelper;
        Screen screen;

        DispatcherTimer Timer { set; get; }

        BackgroundWorker worker = new BackgroundWorker();

        public ScreenGrabber(int interval)
        {
            Interval = interval;

            windowInteropHelper = windowInteropHelper = new WindowInteropHelper(this);
            screen = Screen.FromHandle(windowInteropHelper.Handle);

            isDone = true;

            Timer = new DispatcherTimer();
            Timer.Interval = new TimeSpan(0, 0, Interval);
            Timer.Tick += new EventHandler(Timer_Tick);
            Timer.Start();

            worker.DoWork += new DoWorkEventHandler(worker_DoWork);
            worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
        }

        void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            OnChanged(EventArgs.Empty);
            isDone = true;
        }

        bool isDone;

        void worker_DoWork(object sender, DoWorkEventArgs e)
        {
            GetScreenshot();
        }

        void Timer_Tick(object sender, EventArgs e)
        {
            if (isDone)
            {
                isDone = false;
                worker.RunWorkerAsync();
            }
        }

        void GetScreenshot()
        {
            using (MemoryStream ms = new MemoryStream())
            {
                if (screen != null)
                {
                    using (Bitmap bitmap = new Bitmap(screen.Bounds.Size.Width, screen.Bounds.Size.Height))
                    {
                        using (Graphics g = Graphics.FromImage(bitmap))
                        {
                            g.CopyFromScreen(screen.Bounds.X, screen.Bounds.Y, 0, 0, screen.Bounds.Size, CopyPixelOperation.SourceCopy);
                        }
                        ImageCodecInfo myImageCodecInfo;
                        myImageCodecInfo = GetEncoderInfo("image/jpeg");
                        System.Drawing.Imaging.Encoder myEncoder;
                        myEncoder = System.Drawing.Imaging.Encoder.Quality;
                        EncoderParameters encoderParameters = new EncoderParameters();
                        EncoderParameter encoderParameter = new EncoderParameter(myEncoder, 25L);
                        encoderParameters.Param[0] = encoderParameter;
                        bitmap.Save(ms, myImageCodecInfo, encoderParameters);
                        BitmapData = ms.ToArray();
                    }
                }
            }
        }

        static ImageCodecInfo GetEncoderInfo(String mimeType)
        {
            int j;
            ImageCodecInfo[] encoders;
            encoders = ImageCodecInfo.GetImageEncoders();
            for (j = 0; j < encoders.Length; ++j)
            {
                if (encoders[j].MimeType == mimeType)
                    return encoders[j];
            }
            return null;
        }

        public BitmapSource GetImage()
        {
            using (MemoryStream ms = new MemoryStream(this.BitmapData))
            {
                var decoder = BitmapDecoder.Create(ms, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad);
                return decoder.Frames[0];
            }
        }
    }
}

namespace MyScreenGrabber
{
公共委托void changedventhadler（对象发送方，事件参数e）；
公共类截屏器：窗口
{
公共事件变更事件处理者变更；
受保护的虚拟void一旦更改（EventArgs e）
{
如果（已更改！=null）
改变（本，e）；
}
字节[]位图数据{set；get；}
int区间{set；get；}
WindowInteropHelper WindowInteropHelper；
屏幕；
调度程序计时器{set；get；}
BackgroundWorker工人=新的BackgroundWorker（）；
公共屏幕抓取器（整数间隔）
{
间隔=间隔；
windowInteropHelper=windowInteropHelper=新的windowInteropHelper（此）；
screen=screen.FromHandle（windowInteropHelper.Handle）；
isDone=true；
计时器=新调度程序（）；
Timer.Interval=新的时间跨度（0，0，Interval）；
Timer.Tick+=新事件处理程序（Timer\u Tick）；
Timer.Start（）；
worker.DoWork+=新的doworkereventhandler（worker\u DoWork）；
worker.RunWorkerCompleted+=新的RunWorkerCompletedEventHandler（worker\u RunWorkerCompleted）；
}
void worker\u RunWorkerCompleted（对象发送方，RunWorkerCompletedEventArgs e）
{
一旦更改（EventArgs.Empty）；
isDone=true；
}
布尔伊斯通；
无效工作线程（对象发送器，工作线程目标）
{
获取屏幕截图（）；
}
无效计时器勾号（对象发送方，事件参数e）
{
中频（isDone）
{
isDone=false；
worker.RunWorkerAsync（）；
}
}
void GetScreenshot（）
{
使用（MemoryStream ms=new MemoryStream（））
{
如果（屏幕！=null）
{
使用（位图位图=新位图（screen.Bounds.Size.Width、screen.Bounds.Size.Height））
{
使用（Graphics g=Graphics.FromImage（位图））
{
g、 CopyFromScreen（screen.Bounds.X，screen.Bounds.Y，0，0，screen.Bounds.Size，CopyPixelOperation.SourceCopy）；
}
ImageCodecInfo myImageCodecInfo；
myImageCodecInfo=GetEncoderInfo（“图像/jpeg”）；
系统图.I
public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();            
        }

        ScreenGrabber grabber;

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            grabber = new ScreenGrabber(5);
            grabber.Changed += new ChangedEventHandler(grabber_Changed);
        }

        void grabber_Changed(object sender, EventArgs e)
        {
            Image1.Dispatcher.Invoke(new Action(() => {
                BitmapSource bs = ((ScreenGrabber)sender).GetImage();
                Image1.Width = bs.Width;
                Image1.Height = bs.Height;
                Image1.Source = bs;
            } ));
        } 
    }

namespace MyScreenGrabber
{
    public delegate void ChangedEventHandler(object sender, EventArgs e);

    public class ScreenGrabber : Window
    {
        public event ChangedEventHandler Changed;

        protected virtual void OnChanged(EventArgs e)
        {
            if (Changed != null)
                Changed(this, e);
        }

        byte[] BitmapData { set; get; }

        int Interval { set; get; }

        DispatcherTimer Timer { set; get; }

        public ScreenGrabber(int interval)
        {
            Interval = interval;
            Timer = new DispatcherTimer();
            Timer.Interval = new TimeSpan(0, 0, Interval);
            Timer.Tick += new EventHandler(Timer_Tick);
            Timer.Start();
        }

        void Timer_Tick(object sender, EventArgs e)
        {
            WindowInteropHelper windowInteropHelper = windowInteropHelper = new WindowInteropHelper(this);
            Screen screen = Screen.FromHandle(windowInteropHelper.Handle);

            using (MemoryStream ms = new MemoryStream())
            {
                if (screen != null)
                {
                    using (Bitmap bitmap = new Bitmap(screen.Bounds.Size.Width, screen.Bounds.Size.Height))
                    {
                        using (Graphics g = Graphics.FromImage(bitmap))
                        {
                            g.CopyFromScreen(screen.Bounds.X, screen.Bounds.Y, 0, 0, screen.Bounds.Size, CopyPixelOperation.SourceCopy);
                        }
                        ImageCodecInfo myImageCodecInfo;
                        myImageCodecInfo = GetEncoderInfo("image/jpeg");
                        System.Drawing.Imaging.Encoder myEncoder;
                        myEncoder = System.Drawing.Imaging.Encoder.Quality;
                        EncoderParameters encoderParameters = new EncoderParameters();
                        EncoderParameter encoderParameter = new EncoderParameter(myEncoder, 25L);
                        encoderParameters.Param[0] = encoderParameter;
                        bitmap.Save(ms, myImageCodecInfo, encoderParameters);
                        BitmapData = ms.ToArray();
                        OnChanged(EventArgs.Empty);
                    }
                }
            }
        }

        static ImageCodecInfo GetEncoderInfo(String mimeType)
        {
            int j;
            ImageCodecInfo[] encoders;
            encoders = ImageCodecInfo.GetImageEncoders();
            for (j = 0; j < encoders.Length; ++j)
            {
                if (encoders[j].MimeType == mimeType)
                    return encoders[j];
            }
            return null;
        }

        public BitmapSource GetImage()
        {
            using (MemoryStream ms = new MemoryStream(this.BitmapData))
            {
                var decoder = BitmapDecoder.Create(ms, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad);
                return decoder.Frames[0];
            }
        }
    }
}

namespace MyScreenGrabber
{
    public delegate void ChangedEventHandler(object sender, EventArgs e);

    public class ScreenGrabber : Window
    {
        public event ChangedEventHandler Changed;

        protected virtual void OnChanged(EventArgs e)
        {
            if (Changed != null)
                Changed(this, e);
        }

        byte[] BitmapData { set; get; }

        int Interval { set; get; }

        WindowInteropHelper windowInteropHelper;
        Screen screen;

        DispatcherTimer Timer { set; get; }

        BackgroundWorker worker = new BackgroundWorker();

        public ScreenGrabber(int interval)
        {
            Interval = interval;

            windowInteropHelper = windowInteropHelper = new WindowInteropHelper(this);
            screen = Screen.FromHandle(windowInteropHelper.Handle);

            isDone = true;

            Timer = new DispatcherTimer();
            Timer.Interval = new TimeSpan(0, 0, Interval);
            Timer.Tick += new EventHandler(Timer_Tick);
            Timer.Start();

            worker.DoWork += new DoWorkEventHandler(worker_DoWork);
            worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
        }

        void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            OnChanged(EventArgs.Empty);
            isDone = true;
        }

        bool isDone;

        void worker_DoWork(object sender, DoWorkEventArgs e)
        {
            GetScreenshot();
        }

        void Timer_Tick(object sender, EventArgs e)
        {
            if (isDone)
            {
                isDone = false;
                worker.RunWorkerAsync();
            }
        }

        void GetScreenshot()
        {
            using (MemoryStream ms = new MemoryStream())
            {
                if (screen != null)
                {
                    using (Bitmap bitmap = new Bitmap(screen.Bounds.Size.Width, screen.Bounds.Size.Height))
                    {
                        using (Graphics g = Graphics.FromImage(bitmap))
                        {
                            g.CopyFromScreen(screen.Bounds.X, screen.Bounds.Y, 0, 0, screen.Bounds.Size, CopyPixelOperation.SourceCopy);
                        }
                        ImageCodecInfo myImageCodecInfo;
                        myImageCodecInfo = GetEncoderInfo("image/jpeg");
                        System.Drawing.Imaging.Encoder myEncoder;
                        myEncoder = System.Drawing.Imaging.Encoder.Quality;
                        EncoderParameters encoderParameters = new EncoderParameters();
                        EncoderParameter encoderParameter = new EncoderParameter(myEncoder, 25L);
                        encoderParameters.Param[0] = encoderParameter;
                        bitmap.Save(ms, myImageCodecInfo, encoderParameters);
                        BitmapData = ms.ToArray();
                    }
                }
            }
        }

        static ImageCodecInfo GetEncoderInfo(String mimeType)
        {
            int j;
            ImageCodecInfo[] encoders;
            encoders = ImageCodecInfo.GetImageEncoders();
            for (j = 0; j < encoders.Length; ++j)
            {
                if (encoders[j].MimeType == mimeType)
                    return encoders[j];
            }
            return null;
        }

        public BitmapSource GetImage()
        {
            using (MemoryStream ms = new MemoryStream(this.BitmapData))
            {
                var decoder = BitmapDecoder.Create(ms, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad);
                return decoder.Frames[0];
            }
        }
    }
}