示例#1
0
        internal ScriptCallContext(ScriptCallContext parent, IFileProcedure procedure, ContextLogOption callLoggingOption, bool isDynamicCall)
        {
            m_task          = parent.m_task;
            m_parentContext = parent;

            m_taskManager          = parent.m_taskManager;
            m_callLoggingOption    = callLoggingOption;
            m_loggerOnEntry        = parent.Logger;
            m_loggerInside         = m_loggerOnEntry;
            m_statusUpdaterOnEntry = parent.StatusUpdater;
            m_loggingEnabled       = parent.LoggingEnabled;
            m_errorListener        = parent.m_errorListener;

            m_procedure     = procedure;
            m_isDynamicCall = isDynamicCall;
            this.SetupFromProcedure();

            m_currentReports = parent.m_currentReports; // Simply inherit the list.

            //m_createdlogger = logger.LogEntering(procedure.ElementName, procedure.Purpose);
            //if (separateStateLevel)
            //{
            //    m_currentStatusUpdater = parent.StatusUpdate.CreateSubTaskStatusReporter(procedure.Purpose);
            //    m_currentStatusUpdater.Disposed += M_currentStatusUpdater_Disposed;
            //    m_createdStatusUpdaters = new Stack<ITaskStatusUpdate>(4);
            //    m_createdStatusUpdaters.Push(m_currentStatusUpdater);
            //}
            //else
            //{
            //    m_currentStatusUpdater = parent.StatusUpdate;
            //}
        }
示例#2
0
        //public object CallProcedure(IFileProcedure procedure, LoggerRoot logger, ContextLogOption callerLoggingOption, IExecutionScopeStatusUpdate statusUpdate, params object[] arguments)
        //{
        //    this.Setup(logger, callerLoggingOption, statusUpdate);

        //    return this.DoCallProcedure(procedure, arguments);
        //}

        private object DoCallProcedure(IFileProcedure procedure, object[] arguments)
        {
            Delegate runtimeProcedure = ((FileProcedure)procedure).RuntimeProcedure;
            var      invokeArguments  = new object[arguments.Length + 1];

            Array.Copy(arguments, 0, invokeArguments, 1, arguments.Length);

            ScriptCallContext context = null;

            try
            {
                context = new ScriptCallContext(this, m_logger, m_logOption, m_statusUpdate, procedure, m_taskManager);
                context.SetErrorListener(m_errorListener);
                invokeArguments[0] = context;
                m_value            = runtimeProcedure.DynamicInvoke(invokeArguments);
                return(m_value);
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                context.InternalDispose();
            }
        }
示例#3
0
 public CallContext(ScriptCallContext parent, CallEntry callEntry, bool breakSet)
 {
     m_parentContext = parent;
     m_entryLogger   = parent.Logger;
     m_callEntry     = callEntry;
     m_break         = breakSet;
 }
示例#4
0
 internal ScriptCallContext(
     ScriptTaskContext task,
     ILogger logger,
     ContextLogOption callLoggingOption,
     IExecutionScopeStatusUpdate statusUpdater,
     IFileProcedure procedure,
     TaskManager taskManager)
 {
     m_task                 = task;
     m_parentContext        = null;
     m_callLoggingOption    = callLoggingOption;
     m_loggerInside         = m_loggerOnEntry = logger;
     m_statusUpdaterOnEntry = statusUpdater;
     m_loggingEnabled       = true; // Initial
     m_procedure            = procedure;
     m_taskManager          = taskManager;
     m_isDynamicCall        = false;
     this.SetupFromProcedure();
 }