• 异步编程设计模式


    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using Microsoft.Scripting.Hosting;
    using IronPython.Hosting;
    using System.Threading;
    using System.Windows.Forms;
    using System.Reflection;
    using System.ComponentModel;
    
    namespace IronPythonDebugger
    {
        public class IronPythonDebugger : IIronPythonDebugger
        {
            private ScriptEngine _engine;
    
            private ScriptScope _scope;
    
            private string _source;
    
            private string _debugSource;
    
            private ScriptSource _debugScriptSource;
    
            private Dictionary<int, bool> _breakpoints;
    
            private Thread _debugThread;
    
            private int _currentLine = 0;//从1开始计算
    
            private int _logicStartLine;//从1开始计算
    
            private ScriptBackgroundExecute _backgroundExecute;
    
            private bool _debugging = false;
    
            private int _sourceLineCount;
    
            private const string BACKGROUND_BREAK_CODE = "_backgroundExecute.Break()";
    
            private Action<int> _breakCallback;
    
            private int _nextBreakLine;
    
            private bool _debugThreadSleep = false;
    
            private AsyncOperation _asyncOp;
    
            private Action _exec;
    
            private SendOrPostCallback _onBreakCallback;
    
            private void Execute()
            {
                try
                {
                    _debugScriptSource.Execute(_scope);
                }
                catch (DebugStopException)
                {
                }
                catch (ThreadAbortException)
                {
                }
                catch (Exception e)
                {
                    throw new Exception(e.Message);
                }
                finally
                {
                    Stop();
                }
            }
    
            private void BackgroundBreakCallback()
            {
                if (!_debugging)
                {
                    throw new DebugStopException();
                }
                _currentLine++;
                if (_currentLine == _nextBreakLine)
                {
                    _debugThreadSleep = true;
                    //if (_breakCallback != null)
                    //{
                    //    _breakCallback(_currentLine);
                    //}
                    _asyncOp.Post(_onBreakCallback, _currentLine);
                    WaitDebugThreadContinue();
                }
            }
    
            private void OnBreakCallback(object lineNumber)
            {
                if (Break != null)
                {
                    Break(this, new BreakEventArgs((int)lineNumber));
                }
                else if (_breakCallback != null)
                {
                    _breakCallback((int)lineNumber);
                }
            }
    
            private void WaitDebugThreadContinue()
            {
                while (_debugThreadSleep)
                {
                    Thread.Sleep(100);
                }
            }
    
            private void AddBackgroundBreakCode()
            {
                string[] lines = _source.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
                _sourceLineCount = lines.Length;
                _logicStartLine = GetLogicStartLine(lines);//获取第一行逻辑代码的行号
                _debugSource = string.Empty;
                for (int i = 0; i < _sourceLineCount; i++)
                {
                    if (!string.IsNullOrEmpty(_debugSource))
                    {
                        _debugSource += Environment.NewLine;
                    }
                    if (i >= _logicStartLine - 1)
                    {
                        _debugSource += BACKGROUND_BREAK_CODE + Environment.NewLine;
                    }
                    _debugSource += lines[i];
                }
            }
    
            ////import clr,sys
            ////clr.AddReference('TestClass')
            ////clr.AddReference('System.Windows.Forms')
            ////from TestClass import *
            ////from System.Windows.Forms import *
    
            ////c1 = Class1()
            ////c1.Name = "c1"
            ////MessageBox.Show(c1.Name)
            ////child = Class1()
            ////child.Name = "child1"
            ////c1.Child = child
            ////MessageBox.Show(c1.Child.Name)
            private int GetLogicStartLine(string[] lines)
            {
                int startLine = 1;
                for (int i = 0; i < lines.Length;i++ )
                {
                    string line = lines[i].ToLower();
                    if (line.IndexOf("import") < 0
                        && line.IndexOf("clr") < 0
                        && line.IndexOf("from") < 0)
                    {
                        startLine = i + 1;
                        break;
                    }
                }
                return startLine;
            }
    
            private int GetNextBreakLine(int currentLine)
            {
                int next = -1;
                _breakpoints.OrderBy(breakpoint => breakpoint.Key);
                foreach (KeyValuePair<int, bool> breakpoint in _breakpoints)
                {
                    if (breakpoint.Value && breakpoint.Key > currentLine)
                    {
                        next = breakpoint.Key;
                        break;
                    }
                }
                return next;
            }
    
            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
            public event Action<object, BreakEventArgs> Break;
    
            public ScriptEngine Engine
            {
                get
                {
                    return _engine;
                }
            }
    
            public ScriptScope Scope
            {
                get
                {
                    return _scope;
                }
            }
    
            public string Source
            {
                get
                {
                    return _source;
                }
            }
    
            public Action<int> BreakCallback
            {
                get
                {
                    return _breakCallback;
                }
    
                set
                {
                    _breakCallback = value;
                }
            }
    
            public IronPythonDebugger()
            {
                _engine = Python.CreateEngine();
                _scope = _engine.CreateScope();
                _scope.SetVariable("_backgroundExecute", _backgroundExecute);
                _breakpoints = new Dictionary<int, bool>();
                _backgroundExecute = new ScriptBackgroundExecute(BackgroundBreakCallback);
                _exec = new Action(Execute);
                _onBreakCallback = new SendOrPostCallback(OnBreakCallback);
            }
    
            public void InitialDebugger()
            {
                if (_debugging)
                {
                    throw new Exception("调试器正在调试中!");
                }
                _scope = _engine.CreateScope();
                _scope.SetVariable("_backgroundExecute", _backgroundExecute);
                _breakpoints.Clear();
            }
    
            public void InitialDebugger(List<int> breakpoints)
            {
                InitialDebugger();
                foreach (int breakpoint in breakpoints)
                {
                    _breakpoints[breakpoint] = true;
                }
            }
    
            public void ClearBreakpoints()
            {
                _breakpoints.Clear();
            }
    
            public void Start(string source)
            {
                if (_debugging)
                {
                    throw new Exception("调试器正在调试中!");
                }
                _source = source;
                AddBackgroundBreakCode();
                _debugScriptSource = _engine.CreateScriptSourceFromString(_debugSource);
                _currentLine = _logicStartLine - 1;
                _debugThreadSleep = false;
                _nextBreakLine = GetNextBreakLine(0);
                //_debugThread = new Thread(Execute);
                //_debugThread.Start();
                _asyncOp = AsyncOperationManager.CreateOperation(1);
                _exec.BeginInvoke(null, null);
                _debugging = true;
            }
    
            public void Stop()
            {
                if (_debugging)
                {
                    _debugging = false;
                    _debugThreadSleep = false;
                    //if (_debugThread != null && _debugThread.IsAlive)
                    //{
                    //    _debugThread.Abort();
                    //}
                }
            }
    
            public void AddBreakpoint(int line)
            {
                _breakpoints[line] = true;
            }
    
            public void AddBreakpoints(List<int> lines)
            {
                foreach (int line in lines)
                {
                    AddBreakpoint(line);
                }
            }
    
            public void DeleteBreakpoint(int line)
            {
                _breakpoints[line] = false;
            }
    
            public void DeleteBreakpoints(List<int> lines)
            {
                foreach (int line in lines)
                {
                    DeleteBreakpoint(line);
                }
            }
    
            public void StepOver()
            {
                if (!_debugging)
                {
                    throw new Exception("调试器未开始调试!");
                }
                _nextBreakLine++;
                _debugThreadSleep = false;
            }
    
            public void StepInto()
            {
                MessageBox.Show("暂不支持逐语句调试!");
            }
    
            public void StepOut()
            {
                MessageBox.Show("暂不支持跳出调试!");
            }
    
            public void Continue()
            {
                if (!_debugging)
                {
                    throw new Exception("调试器未开始调试!");
                }
                _nextBreakLine = GetNextBreakLine(_currentLine);
                _debugThreadSleep = false;
            }
    
            public string GetValueAsString(string variable)
            {
                string value = string.Empty;
                try
                {
                    string[] names = variable.Split('.');
                    object obj = _scope.GetVariable(names[0]);
                    for (int i = 1; i < names.Length; i++)
                    {
                        Type type = obj.GetType();
                        PropertyInfo pi = type.GetProperty(names[i]);
                        obj = pi.GetValue(obj, null);
                    }
                    value = obj.ToString();
                }
                catch (Exception e)
                {
                    throw new Exception(e.Message);
                }
                return value;
            }
    
            public bool IsDebugging()
            {
                return _debugging;
            }
        }
    
        public class BreakEventArgs : EventArgs
        {
            public int LineNumber;
    
            public BreakEventArgs(int lineNumber)
            {
                this.LineNumber = lineNumber;
            }
        }
    
        public class DebugStopException : Exception
        {
        }
    }
  • 相关阅读:
    题解 P1587 【[NOI2016]循环之美】
    PKUSC2019颓废记
    使用ImageIO.write上传二维码文件时候,提示系统找不到指定路径
    rt.jar包添加源文件只需要关联到已安装对应jdk目录下source.zip源码文件即可
    Kali Linux安装中文输入法
    性能测试(一)——理发店模型
    瑜伽,不仅仅是瑜伽,敬艾扬格大师
    为什么想做测试,我的测试开端
    责任链模式-Chain of responsibility
    后缀数组-基础
  • 原文地址:https://www.cnblogs.com/chengshuiqiang/p/4479071.html
Copyright © 2020-2023  润新知