首页 理论 架构 工程 规划 文档 白皮书 著作 研究 案例 下载 博客 关于 联系 开始使用 →

第三十六章 执行方法与程序调用机制

第八篇 个体方法执行与自主控制工程

本篇解决个体如何将决策结果转化为实际行为,以及如何控制外部设备、软件程序和其他执行对象。重点是建立方法执行机制与实际执行接口之间的工程关系。

第三十六章 执行方法与程序调用机制

  1. 执行方法的数据定义

  2. 方法参数与执行上下文

  3. 方法标识与程序实现映射

  4. 方法调用、返回值与异常处理

  5. 执行方法的注册、验证与版本管理

    第三十六章 执行方法与程序调用机制

    第三十五章完成了决策结果向执行方法的转换,形成了由具体方法、方法组合、方法参数、执行条件和程序实现映射构成的方法形成结果。本章进一步研究这些已经形成的方法如何进入个体运行引擎,如何建立统一的数据定义和执行上下文,如何根据方法标识找到对应的程序实现,如何完成程序调用、结果返回和异常处理,以及如何对执行方法进行注册、验证和版本管理。

    方法形成与方法执行是两个不同的工程阶段。方法形成解决当前任务需要采用哪些方法,以及这些方法如何组织;方法执行解决已经形成的方法如何由个体运行环境调用,并按照规定的输入、输出和运行约束完成操作。方法形成结果只是执行方法的数据来源,不等于程序已经调用,也不意味着设备已经产生实际动作。

    WSaiOS个体运行引擎需要建立统一的方法调用机制,使不同知识结构中的方法能够按照相同的工程约定进入运行流程。方法定义来自已经赋予个体的知识结构和知识能力,程序实现则来自个体本地运行环境中经过配置、验证和注册的程序组件。两者通过方法标识、定义版本和实现映射建立关联。运行引擎根据任务上下文和方法组合关系组织调用,而不是在任务处理程序中直接写入大量固定的业务函数名称。

    这种机制既要适用于软件个体,也要适用于机器人、无人机和工业设备等实体个体。软件个体的方法可能执行数据读取、结构比较、计算、判断、状态更新和信息处理;实体个体的方法可能通过本地控制接口读取传感器、控制执行机构或改变设备状态。不同方法的实际实现可以不同,但其定义、参数、上下文、调用结果和异常记录应当具有统一的数据管理边界。

    本章所讨论的程序调用机制属于个体本地自主运行体系。智能控制后台负责知识能力的构建、验证和赋值,个体获得相应赋值后,在本地运行环境加载方法定义和程序实现。个体运行引擎按照已赋予的职责范围组织方法调用,不负责自行扩展后台的知识构建权限,也不能通过调用程序绕过已经赋予的执行规则。

    第一节 执行方法的数据定义

    执行方法首先需要具有明确的数据定义。第三十五章形成的方法组合已经确定了当前任务所需的方法,但这些方法仍然需要通过统一的数据结构进入运行引擎。数据定义的目的,是使运行引擎能够准确识别一个方法的身份、所属结构、操作对象、输入输出、执行条件、依赖关系和程序实现映射,从而避免不同程序组件对同一个方法产生不同理解。

    在工程设计中,必须区分方法定义、方法实例和方法执行记录。

    方法定义描述一个方法本身所具有的结构属性,包括方法标识、方法名称、所属结构元素、操作类型、参数定义、返回结果定义、前置条件、依赖关系和实现要求。它属于知识结构中的稳定定义,可以被多个任务和多个方法实例引用。

    方法实例是某次具体任务中形成的方法使用对象。它将方法定义与当前任务、当前操作对象、当前参数和当前执行上下文关联起来。同一个方法定义可以在不同任务中形成不同的方法实例。例如,object_compare可以用于比较不同类型对象的属性,但每次任务所比较的对象、比较字段和判断条件都可能不同。

    方法执行记录则用于保存某个方法实例实际进入程序调用后的过程,包括调用标识、开始时间、输入参数、程序实现版本、返回结果、异常信息和执行状态。它记录的是一次具体运行行为,不应当覆盖方法定义或方法实例的原始数据。

    这三个工程对象必须分别管理。方法定义的变化需要进行定义版本管理;方法实例的变化需要记录当前任务中的参数和上下文变化;方法执行记录则需要保留实际调用过程,便于运行恢复、问题追踪和执行验证。

    执行方法的基础数据结构可以设计为:

    {
        "method_id": "robot_material_grasp",
        "method_name": "material_grasp",
        "method_type": "device_operation",
        "owner_element": "robot_gripper",
        "operation": "grasp",
        "target_structure": "material",
        "method_version": "1.2.0",
        "input_definition": {
            "target_object_id": {
                "type": "object_reference",
                "required": true
            },
            "grasp_position": {
                "type": "position",
                "required": true
            },
            "grasp_mode": {
                "type": "string",
                "required": true
            }
        },
        "output_definition": {
            "execution_result": {
                "type": "boolean"
            },
            "object_state": {
                "type": "object_state"
            }
        },
        "preconditions": [
            "target_identified",
            "gripper_ready",
            "grasp_zone_clear"
        ],
        "dependencies": [
            "material_identification",
            "gripper_status_check"
        ],
        "implementation_id": "robot_grasp_impl_001",
        "status": "active"
    }

    上述定义用于描述抓取方法本身。它没有直接包含某次任务中的物料编号、抓取位置实际数值和设备运行状态,这些内容属于方法实例和执行上下文。将定义与实例分离,可以避免因为不同任务参数变化而反复修改方法定义,也能够支持同一方法在不同个体和不同运行环境中的复用。

    方法实例的数据结构可以设计为:

    {
        "method_instance_id": "method_instance_000128",
        "method_id": "robot_material_grasp",
        "method_version": "1.2.0",
        "task_id": "task_000128",
        "individual_id": "robot_001",
        "decision_result_id": "decision_result_000128",
        "formation_id": "formation_000128",
        "target_object_id": "material_0001",
        "parameter_reference": "parameters_000128",
        "context_reference": "runtime_context_000128",
        "method_status": "ready"
    }

    这里的method_instance_id用于唯一标识某次任务中的方法实例,method_id关联方法定义,method_version确定当前使用的定义版本,task_id和individual_id确定方法所属任务与运行个体,formation_id则关联第三十五章形成的方法组织结果。

    方法实例不应当直接复制所有运行上下文数据。它可以保存必要的关联标识,并通过上下文管理程序读取当前有效数据。这样既可以减少数据重复,也可以避免同一个对象状态在多个存储位置发生不一致。

    方法执行记录则需要独立的数据结构:

    {
        "method_execution_id": "execution_000128",
        "method_instance_id": "method_instance_000128",
        "method_id": "robot_material_grasp",
        "implementation_id": "robot_grasp_impl_001",
        "implementation_version": "1.0.0",
        "task_id": "task_000128",
        "individual_id": "robot_001",
        "execution_status": "not_started",
        "input_snapshot_id": "input_snapshot_000128",
        "result_reference": null,
        "exception_reference": null,
        "created_at": "2026-11-15 11:00:00"
    }

    该记录中的not_started表示执行记录已经建立,但程序尚未进入实际调用阶段。后续状态变化由方法调用机制管理。对于需要调用实体设备的操作,还应记录设备标识、控制接口标识、设备状态快照和必要的安全检查结果。

    执行方法的数据定义还需要明确方法类型。方法类型可以用于确定程序加载方式和适配接口,例如数据处理方法、结构判断方法、状态处理方法、软件操作方法和设备控制方法等。但方法类型不能取代方法本身的结构定义,也不能将方法分类固定为不可扩展的业务字段。具体分类应当依据实际知识结构和工程需要组织,新增方法类型时应当通过定义和注册机制扩展。

    在程序组织上,可以建立独立的方法定义管理目录:

    IndividualRuntime/
    └── method/
        ├── definition/
        │   ├── MethodDefinition.php       # 方法定义的数据对象
        │   ├── MethodDefinitionReader.php # 读取方法定义
        │   ├── MethodDefinitionParser.php # 解析方法定义数据
        │   ├── MethodDefinitionValidator.php # 验证方法定义完整性
        │   └── MethodDefinitionRepository.php # 保存和读取方法定义
        ├── instance/
        │   ├── MethodInstanceBuilder.php  # 根据任务形成方法实例
        │   ├── MethodInstanceReader.php   # 读取方法实例
        │   ├── MethodInstanceValidator.php # 验证方法实例
        │   └── MethodInstanceRepository.php # 管理方法实例
        └── execution/
            ├── MethodExecutionRecord.php  # 方法执行记录的数据对象
            ├── MethodExecutionBuilder.php # 建立执行记录
            ├── MethodExecutionReader.php  # 读取执行记录
            └── MethodExecutionRepository.php # 保存执行记录

    这里的MethodDefinition、MethodInstance和MethodExecutionRecord分别对应方法定义、任务方法实例和实际执行记录。程序不能把三者合并为一个对象后随意修改,否则无法区分知识结构定义发生变化、任务参数发生变化和程序实际运行状态发生变化。

    执行方法的数据定义还应当与第三十五章的方法形成结果保持一致。方法形成结果提供方法标识、方法版本、参数、条件和实现映射;本章通过统一的数据对象将这些内容转换为运行引擎能够处理的执行方法实例。对于形成阶段已经验证的内容,执行阶段可以读取并复用其验证记录,但涉及设备状态、环境状态和动态权限的条件仍然需要在实际调用前重新检查。

    第二节 方法参数与执行上下文

    方法定义确定了一个操作需要什么输入,但程序调用时还必须获得当前任务的实际参数和运行上下文。方法参数与执行上下文共同决定程序调用时能够读取哪些数据、操作哪个对象、使用什么运行资源,以及程序结果应当返回到什么任务和处理阶段。

    方法参数与上下文必须分开管理。参数是某个方法完成操作所需要的具体输入值,例如目标对象标识、计算数值、位置坐标、操作模式和状态条件。执行上下文则是方法运行时所处的整体环境,包括个体标识、任务标识、方法实例、赋值版本、运行状态、对象实例、资源信息、权限范围和当前处理阶段。

    同一个方法可以在不同上下文中使用相同的参数结构,但具体参数值和运行条件可能不同。例如,某个比较方法的定义始终要求输入两个待比较对象,但不同任务中,这两个对象可能分别是物料重量和机器人承载能力,也可能是两个路线距离。方法定义保持稳定,方法参数根据当前任务变化,上下文则提供参数所关联的对象结构、单位、来源和适用规则。

    因此,运行引擎不能仅将一个简单数组传递给方法程序,然后假设程序能够自行找到全部必要信息。它必须在调用之前建立完整的参数集合和执行上下文,并对两者之间的关联进行验证。

    方法参数应当来自已经确认的数据源。可能的数据来源包括任务定义、决策结果、方法形成结果、对象实例、认知结果、判断结果、前置方法返回值和本地运行信息。参数解析程序需要根据方法定义中的参数要求读取相应数据,并记录参数来源、数据版本和解析时间。对于前置方法输出的参数,还应当检查前置方法是否已经完成,以及返回结果是否符合当前方法的输入要求。

    例如,机器人抓取方法的参数可以组织为:

    {
        "parameter_set_id": "parameters_000128",
        "method_instance_id": "method_instance_000128",
        "parameters": {
            "target_object_id": {
                "value": "material_0001",
                "source": "decision_result",
                "data_type": "object_reference"
            },
            "grasp_position": {
                "value": {
                    "x": 1.25,
                    "y": 2.10,
                    "z": 0.45
                },
                "source": "cognition_result",
                "data_type": "position",
                "coordinate_system": "robot_base"
            },
            "grasp_mode": {
                "value": "side_grasp",
                "source": "capability_definition",
                "data_type": "string"
            }
        },
        "parameter_status": "valid"
    }

    其中的坐标和抓取模式仅用于说明数据组织方式,不代表任何真实机器人设备的实际参数。真实设备中的坐标还必须与设备使用的坐标系、单位、标定版本和当前运动状态相匹配。

    参数解析之后,需要建立执行上下文。执行上下文不是简单的任务信息集合,而是当前方法在运行引擎中能够使用的受控数据范围。它需要明确当前方法属于哪个个体、哪个任务、哪个方法组合,以及当前调用所依据的知识能力赋值版本和方法定义版本。

    执行上下文可以设计为:

    {
        "execution_context_id": "execution_context_000128",
        "individual_id": "robot_001",
        "task_id": "task_000128",
        "method_instance_id": "method_instance_000128",
        "method_id": "robot_material_grasp",
        "method_version": "1.2.0",
        "assignment_version": "assignment_v12",
        "formation_id": "formation_000128",
        "runtime_mode": "autonomous",
        "runtime_state": "ready",
        "object_scope": [
            "material_0001",
            "robot_001"
        ],
        "resource_scope": [
            "robot_arm",
            "gripper"
        ],
        "permission_scope": "assigned_task",
        "execution_rule_version": "rule_v08",
        "context_status": "valid"
    }

    该上下文描述当前方法能够访问的对象和资源范围。object_scope限定当前方法可以处理的对象,resource_scope限定当前方法可以使用的运行资源,permission_scope表示其操作权限范围。对于实体设备方法,实际的设备控制接口还必须由经过授权的本地适配程序提供,不能因为上下文中存在某个设备标识就自动获得设备控制权限。

    方法执行上下文应当由运行引擎统一建立,而不是由每个方法实现自行构造。这样可以保证不同方法在同一个任务中使用一致的任务标识、个体标识、赋值版本和运行规则。方法实现只接收当前方法被允许使用的参数和上下文接口,不应当直接访问整个个体运行环境中的所有数据。

    拟定的程序目录如下:

    IndividualRuntime/
    └── method/
        ├── parameter/
        │   ├── MethodParameterResolver.php  # 解析方法参数来源
        │   ├── MethodParameterValidator.php # 验证参数类型和完整性
        │   ├── MethodParameterMapper.php    # 将参数映射到程序输入
        │   └── MethodParameterSnapshot.php  # 保存参数快照
        └── context/
            ├── MethodExecutionContext.php   # 方法执行上下文对象
            ├── ExecutionContextBuilder.php  # 建立执行上下文
            ├── ExecutionContextReader.php   # 读取运行上下文
            ├── ExecutionScopeResolver.php   # 确定对象和资源范围
            ├── ExecutionPermissionChecker.php # 检查操作权限
            ├── ExecutionContextValidator.php # 验证上下文
            └── ExecutionContextSnapshot.php # 保存上下文快照

    其中,MethodParameterResolver.php负责根据方法定义获取实际参数,MethodParameterValidator.php检查参数完整性,MethodParameterMapper.php负责将结构化参数转换为程序接口所需要的输入。ExecutionContextBuilder.php负责建立方法执行上下文,ExecutionScopeResolver.php确定方法能够访问的对象和资源,ExecutionPermissionChecker.php检查操作范围和权限。

    执行上下文的建立程序可以设计为:

    <?php
    
    class ExecutionContextBuilder
    {
        private $runtimeContextReader;
        private $scopeResolver;
        private $permissionChecker;
        private $contextValidator;
    
        public function __construct(
            $runtimeContextReader,
            $scopeResolver,
            $permissionChecker,
            $contextValidator
        ) {
            $this->runtimeContextReader = $runtimeContextReader;
            $this->scopeResolver = $scopeResolver;
            $this->permissionChecker = $permissionChecker;
            $this->contextValidator = $contextValidator;
        }
    
        public function build($methodInstance, $taskContext)
        {
            $runtimeContext = $this->runtimeContextReader->read(
                $methodInstance['individual_id']
            );
    
            if (empty($runtimeContext)) {
                throw new RuntimeException(
                    '个体运行上下文不存在'
                );
            }
    
            if ($runtimeContext['assignment_version'] !==
                $methodInstance['assignment_version']) {
                throw new RuntimeException(
                    '方法实例与当前赋值版本不一致'
                );
            }
    
            $scope = $this->scopeResolver->resolve(
                $methodInstance,
                $taskContext
            );
    
            $this->permissionChecker->check(
                $methodInstance,
                $scope,
                $runtimeContext
            );
    
            $context = array(
                'individual_id' =>
                    $methodInstance['individual_id'],
                'task_id' =>
                    $methodInstance['task_id'],
                'method_instance_id' =>
                    $methodInstance['method_instance_id'],
                'assignment_version' =>
                    $methodInstance['assignment_version'],
                'object_scope' => $scope['objects'],
                'resource_scope' => $scope['resources'],
                'runtime_mode' =>
                    $runtimeContext['runtime_mode'],
                'context_status' => 'valid'
            );
    
            $this->contextValidator->validate($context);
    
            return $context;
        }
    }

    该程序的调用者是方法执行调度程序。它读取当前个体运行上下文,解析当前方法的操作范围,并检查权限后形成方法执行上下文。实际工程中还需要检查任务状态、方法版本、对象状态、资源状态和执行规则版本。对于某些方法,如果运行上下文中的关键数据发生变化,就必须重新建立上下文,不能继续使用旧快照。

    执行上下文还需要支持快照和恢复。个体运行过程中,方法可能因为等待设备状态、资源占用、通信中断或其他条件而暂停。如果只保存当前方法名称而不保存参数、上下文版本、前置方法结果和当前处理阶段,就无法可靠恢复运行。因此,方法调用前应当保存必要的参数快照和上下文快照,方法调用后则保存结果和状态变化。

    对于实体设备操作,快照机制还必须考虑实际动作是否已经发生。软件方法通常可以通过事务、幂等标识或数据版本控制避免重复处理,但物理设备动作可能无法简单回滚。例如,机器人已经完成一次抓取后发生通信中断,如果恢复时仅根据旧状态重新调用抓取方法,就可能造成重复动作。因此,设备操作方法需要在调用前生成唯一执行标识,并结合设备反馈、执行机构状态和本地检查点确认动作是否已经发生。无法确认实际动作状态时,应当进入状态核实流程,而不是盲目重复调用。

    方法参数与执行上下文共同构成程序调用的输入边界。方法实现只能使用经过解析和验证的数据,不能在程序内部任意扩大参数来源和对象访问范围。这一机制为不同类型的方法提供统一调用基础,同时保证个体自主运行仍然受到知识能力赋值和执行规则约束。

    第三节 方法标识与程序实现映射

    执行方法要进入运行引擎,必须能够通过稳定的方法标识找到与其对应的程序实现。方法标识与程序实现映射解决的是知识结构中的方法定义如何定位到个体本地程序,以及运行引擎如何在不依赖固定业务函数名称的情况下完成程序调用。

    在WSaiOS工程体系中,方法标识是方法定义的稳定身份,不应当直接使用PHP类名、文件名、函数名或设备接口名称代替。方法定义与程序实现属于两个不同的工程层次。方法定义描述操作的结构含义和适用条件,程序实现负责按照定义完成具体操作。两者通过映射记录建立关系,使同一个方法定义能够在不同运行环境中关联不同的程序实现。

    例如,route_navigation表示路线导航方法。软件仿真环境中,它可能对应一个路径计算和状态更新程序;实体机器人环境中,它可能对应本地导航控制程序;无人机运行环境中,它可能对应飞行航线控制适配程序。它们的底层程序不同,但必须遵循各自方法定义所规定的输入输出、操作对象、适用条件和执行约束。

    这种映射方式使知识能力不必与某一种具体程序语言或设备接口永久绑定。智能控制后台可以根据个体类型、任务职能和运行环境组织知识能力赋值,个体本地则根据赋值清单加载相应程序实现。方法定义负责保持操作语义的一致性,程序映射负责处理不同运行环境下的具体实现差异。

    方法映射记录至少需要明确方法标识、方法定义版本、实现标识、实现版本、运行类型、程序入口、接口类型、输入输出映射、依赖条件和适用范围。方法标识用于定位知识结构中的方法,方法定义版本用于确定当前操作要求,实现标识用于定位具体程序组件,实现版本用于确认程序组件的实际版本。

    例如,方法与程序实现的映射可以设计为:

    {
        "mapping_id": "mapping_000128",
        "method_id": "route_navigation",
        "method_version": "1.1.0",
        "implementation_id": "robot_navigation_impl_002",
        "implementation_version": "2.0.0",
        "runtime_type": "local_adapter",
        "implementation_location": {
            "package": "RobotRuntime.Navigation",
            "class": "RobotNavigationMethod",
            "entry": "execute"
        },
        "interface": "RuntimeMethodInterface",
        "input_mapping": {
            "route_id": "route_id",
            "target_position": "target_position",
            "navigation_mode": "navigation_mode"
        },
        "output_mapping": {
            "navigation_status": "status",
            "current_position": "position",
            "exception": "error"
        },
        "individual_scope": [
            "robot_001"
        ],
        "mapping_status": "active"
    }

    该映射记录中的implementation_location只是程序定位信息,不是方法定义本身。实际运行时,方法注册程序应当根据implementation_id查找本地已安装的实现,再检查其接口和版本。不能直接使用数据库中未经验证的类名或文件路径进行任意动态加载,否则会使方法调用脱离个体赋值和程序安全管理。

    方法映射需要经过三个层次的确认。首先,方法定义必须存在,并且属于当前个体已经赋予的知识能力范围。其次,程序实现必须存在于当前个体允许加载的程序包或本地运行目录中。最后,程序实现必须满足方法定义的接口要求和版本兼容要求。只有三个层次同时成立,方法映射才能进入有效状态。

    程序实现可以通过统一接口进行注册。对于PHP运行环境,可以使用接口约定方法实现的输入验证、执行入口和结果获取方式。不同方法可以具有不同内部逻辑,但对运行引擎提供一致的外部调用形式。

    例如:

    <?php
    
    interface RuntimeMethodInterface
    {
        public function validate($parameters);
    
        public function execute($parameters, $context);
    
        public function getResult();
    }

    该接口是运行引擎与方法实现之间的程序约定。validate()用于检查程序输入是否符合实现要求,execute()负责执行具体处理,getResult()用于读取程序形成的结果。对于实体设备方法,execute()内部还需要调用经过授权的设备适配器,并遵守设备接口规定的状态检查和控制流程。

    方法实现映射程序不能直接将所有方法都视为普通PHP函数。不同运行类型需要使用不同适配方式。例如,PHP本地类可以通过对象实例调用,外部独立进程可以通过受控进程接口调用,设备控制方法可以通过本地设备适配器调用,其他运行环境中的方法则可以通过约定的接口进行连接。无论采用哪种方式,运行引擎都应当获得统一的调用结果和异常信息。

    拟定的映射程序目录如下:

    IndividualRuntime/
    └── method/
        ├── mapping/
        │   ├── MethodMappingReader.php       # 读取方法映射定义
        │   ├── MethodMappingResolver.php     # 解析方法与实现的对应关系
        │   ├── ImplementationLocator.php     # 定位本地程序实现
        │   ├── ImplementationVersionChecker.php # 检查实现版本
        │   ├── ImplementationInterfaceChecker.php # 检查程序接口
        │   ├── MethodInputMapper.php         # 映射方法输入数据
        │   ├── MethodOutputMapper.php        # 映射程序返回数据
        │   └── MethodMappingValidator.php    # 验证映射完整性
        ├── adapter/
        │   ├── RuntimeMethodAdapter.php      # 统一方法调用适配
        │   ├── LocalClassAdapter.php         # 调用本地程序类
        │   ├── ProcessMethodAdapter.php      # 调用独立运行进程
        │   ├── SoftwareMethodAdapter.php     # 调用软件处理方法
        │   ├── DeviceMethodAdapter.php       # 调用本地设备控制接口
        │   └── MethodResultAdapter.php       # 统一处理返回结果
        └── registry/
            ├── MethodRegistry.php            # 管理已注册方法
            ├── MethodImplementationRegistry.php # 管理程序实现
            └── MethodAdapterRegistry.php     # 管理运行适配器

    MethodMappingResolver.php负责查找方法与程序实现之间的关系,ImplementationLocator.php根据经过确认的实现标识定位本地程序,ImplementationInterfaceChecker.php检查程序接口是否符合要求。适配器负责不同运行方式的具体调用,注册表负责管理已经通过检查的映射对象。

    映射程序可以设计为:

    <?php
    
    class MethodMappingResolver
    {
        private $mappingReader;
        private $implementationLocator;
        private $versionChecker;
        private $interfaceChecker;
    
        public function __construct(
            $mappingReader,
            $implementationLocator,
            $versionChecker,
            $interfaceChecker
        ) {
            $this->mappingReader = $mappingReader;
            $this->implementationLocator = $implementationLocator;
            $this->versionChecker = $versionChecker;
            $this->interfaceChecker = $interfaceChecker;
        }
    
        public function resolve($methodDefinition)
        {
            $mapping = $this->mappingReader->read(
                $methodDefinition['method_id'],
                $methodDefinition['method_version']
            );
    
            if (empty($mapping)) {
                throw new RuntimeException(
                    '方法实现映射不存在'
                );
            }
    
            if ($mapping['mapping_status'] !== 'active') {
                throw new RuntimeException(
                    '方法映射当前不可用'
                );
            }
    
            $implementation = $this->implementationLocator->locate(
                $mapping['implementation_id']
            );
    
            if (empty($implementation)) {
                throw new RuntimeException(
                    '程序实现不存在'
                );
            }
    
            $this->versionChecker->check(
                $methodDefinition,
                $mapping,
                $implementation
            );
    
            $this->interfaceChecker->check(
                $mapping,
                $implementation
            );
    
            return array(
                'method_id' => $methodDefinition['method_id'],
                'mapping' => $mapping,
                'implementation' => $implementation
            );
        }
    }

    该程序只负责解析映射和检查程序实现,不直接调用方法。程序调用由后续调度程序完成。这样可以将方法定义读取、实现定位、接口检查和实际执行分离,避免方法映射程序承担过多职责。

    对于同一个方法存在多个程序实现的情况,映射关系可以按照个体类型、设备类型、运行环境和能力赋值范围建立多个候选实现。例如,某个对象识别方法可能同时存在软件图像处理实现和设备本地传感器实现,但个体只能使用已经赋予且经过验证的实现。程序不能仅因为某个候选实现存在,就自动选择它替代当前实现。

    方法映射还应当支持运行环境差异。对于软件个体,可以使用本地程序包和受控进程;对于实体个体,可以通过设备适配器连接控制器、传感器和执行机构。设备适配器需要承担协议转换、设备状态读取、操作范围检查和结果返回等工作。方法定义不应直接包含某一厂商的专有控制指令,而应当通过程序映射和适配器将结构化操作要求转换为当前设备能够处理的调用形式。

    在实际工程中,程序映射还必须与安全边界关联。特别是涉及机器人、无人机和工业设备控制时,程序实现即使能够被成功加载,也不代表它能够对当前设备执行所有操作。映射记录应当明确适用个体、设备范围、允许的操作类型和实现版本。运行引擎调用前还要依据最新执行规则检查权限和安全条件,不能将程序加载成功当作设备操作授权。

    第四节 方法调用、返回值与异常处理

    方法调用是个体运行引擎将方法实例、参数和执行上下文交给程序实现,并根据程序执行结果继续组织任务处理的过程。方法调用机制需要建立统一的调用入口,使方法实例能够按照方法定义、依赖关系和执行规则进入相应程序,而不是由不同任务处理程序直接调用各自的业务函数。

    方法调用应当由运行引擎统一调度。运行引擎根据方法组合中的依赖关系确定当前可以调用的方法,检查方法实例状态,读取参数和上下文,解析程序实现,执行调用前检查,然后将调用请求交给对应适配器。适配器完成具体程序调用后,将返回值转换为统一结果结构,交由运行引擎进行结果检查和状态更新。

    方法调用的基本过程可以组织为:

    RuntimeKernel
        |
        v
    MethodExecutionDispatcher
        |
        v
    MethodInstanceReader
        |
        v
    MethodDependencyChecker
        |
        v
    MethodParameterResolver
        |
        v
    ExecutionContextBuilder
        |
        v
    MethodConditionChecker
        |
        v
    MethodMappingResolver
        |
        v
    RuntimeMethodAdapter
        |
        v
    MethodImplementation
        |
        v
    MethodResultAdapter
        |
        v
    MethodResultValidator
        |
        v
    MethodExecutionRepository
        |
        v
    RuntimeContext更新

    该流程中,MethodExecutionDispatcher负责统一调度,MethodDependencyChecker检查前置方法是否已经完成,MethodParameterResolver读取参数,ExecutionContextBuilder建立上下文,MethodConditionChecker检查执行条件,MethodMappingResolver定位程序实现,RuntimeMethodAdapter执行实际调用。返回结果经过转换和验证后,才能更新当前任务状态。

    方法调用之前,应当先建立调用记录。调用记录需要具有唯一标识,关联方法实例、任务、个体、赋值版本、方法定义版本和程序实现版本。对于可能改变外部对象或设备状态的操作,还应当设置调用幂等标识和执行阶段标识,以便在异常恢复时识别该方法是否已经产生实际影响。

    方法调用请求可以设计为:

    {
        "method_call_id": "call_000128",
        "method_execution_id": "execution_000128",
        "method_instance_id": "method_instance_000128",
        "method_id": "robot_material_grasp",
        "method_version": "1.2.0",
        "implementation_id": "robot_grasp_impl_001",
        "implementation_version": "1.0.0",
        "task_id": "task_000128",
        "individual_id": "robot_001",
        "parameter_set_id": "parameters_000128",
        "execution_context_id": "execution_context_000128",
        "call_status": "prepared",
        "idempotency_key": "task_000128_grasp_001"
    }

    idempotency_key用于识别同一任务中的同一操作请求,避免在重复调度或恢复过程中产生不必要的重复调用。但幂等标识本身不能保证设备动作一定不会重复,实体设备方法还需要结合设备反馈、动作状态和本地执行记录进行核实。

    方法调用时,程序实现应当接收经过验证的参数和上下文。以软件处理方法为例,调用可以通过适配器完成;对于设备控制方法,则由设备适配器调用实际控制接口。不同适配器的内部实现可以不同,但返回给运行引擎的数据结构应当保持一致。

    统一的调用适配器可以设计为:

    <?php
    
    class RuntimeMethodAdapter
    {
        private $adapterRegistry;
    
        public function __construct($adapterRegistry)
        {
            $this->adapterRegistry = $adapterRegistry;
        }
    
        public function invoke(
            $mapping,
            $parameters,
            $context
        ) {
            $runtimeType = $mapping['runtime_type'];
    
            $adapter = $this->adapterRegistry->get(
                $runtimeType
            );
    
            if (empty($adapter)) {
                throw new RuntimeException(
                    '找不到对应的方法调用适配器'
                );
            }
    
            return $adapter->invoke(
                $mapping,
                $parameters,
                $context
            );
        }
    }

    这里的adapterRegistry负责根据运行类型选择已经注册的适配器。运行引擎不需要了解每一种方法的内部程序细节,只需要按照统一调用约定传递映射、参数和上下文。对于PHP本地类、独立进程和设备控制接口,分别由对应适配器完成实际调用。

    方法程序执行完成后,必须返回结构化结果。返回值不能只是一个没有含义的true或false,而应当包含方法标识、调用标识、执行状态、业务结果、输出数据、状态变化和必要的错误信息。这样,运行引擎才能判断方法是否真正完成了预期操作,以及后续方法是否可以继续执行。

    统一返回结果可以设计为:

    {
        "method_call_id": "call_000128",
        "method_instance_id": "method_instance_000128",
        "method_id": "robot_material_grasp",
        "execution_status": "completed",
        "result": {
            "operation_success": true,
            "target_object_id": "material_0001",
            "object_state": "grasped"
        },
        "output_data": {
            "grasp_confirmed": true
        },
        "state_changes": [
            {
                "object_id": "material_0001",
                "attribute": "state",
                "old_value": "available",
                "new_value": "grasped"
            }
        ],
        "error": null
    }

    返回结果中的execution_status表示程序调用的运行状态,operation_success表示方法所定义的操作是否达到预期结果。两者需要分开处理。例如,程序调用过程正常结束,但方法内部判断发现目标对象不满足操作条件,此时程序运行可能是正常完成的,而业务操作结果并不成功。不能因为程序没有抛出异常就认为任务操作成功。

    返回值还需要经过结果验证。验证程序应当检查返回数据结构是否符合方法定义,输出字段是否完整,数据类型和单位是否正确,关联对象是否属于当前任务范围,以及状态变化是否与方法允许的操作一致。对于实体设备方法,还应当结合设备实际反馈确认操作结果,不能只根据程序返回的一个成功标志就认定物理动作已经完成。

    方法调用过程中可能发生多种异常。参数异常可能来自输入缺失、类型错误或数据版本不一致;上下文异常可能来自个体状态变化、赋值版本变化或任务失效;映射异常可能来自程序不存在、接口不兼容或版本不匹配;运行异常可能来自程序内部错误、资源不足、设备故障和外部接口超时;执行异常则可能来自操作条件变化、设备拒绝执行、对象状态冲突或安全条件触发。

    异常处理不能采用统一的自动重试方式。不同异常需要依据其类型、影响范围和可恢复性采取不同处理路径。参数缺失可能需要重新获取信息;版本不一致可能需要重新加载赋值或重新形成方法;程序实现不存在可能需要等待后台更新赋值;临时资源不足可能允许等待后重试;设备状态异常可能要求暂停当前操作;安全条件触发则必须阻止相关操作继续执行。

    方法调用异常记录应当保留原始调用标识、方法标识、异常类型、发生阶段、异常信息、当前对象状态和处理结果。例如:

    {
        "exception_id": "method_exception_000128",
        "method_call_id": "call_000128",
        "method_id": "robot_material_grasp",
        "exception_type": "execution_condition_changed",
        "failure_stage": "pre_execution_check",
        "message": "抓取区域状态发生变化",
        "previous_condition": "clear",
        "current_condition": "blocked",
        "handling_path": "suspend_method",
        "retry_allowed": false,
        "requires_redecision": true
    }

    该记录表示方法执行前发现抓取区域状态已经变化,因此当前方法不能继续调用,并且可能需要重新判断或重新决策。异常记录不应只保存一个错误文本,还应保存能够支持恢复和追溯的结构化信息。

    异常处理程序可以按照以下目录组织:

    IndividualRuntime/
    └── method/
        ├── invocation/
        │   ├── MethodExecutionDispatcher.php # 方法执行调度
        │   ├── MethodCallRequest.php          # 方法调用请求
        │   ├── MethodCallExecutor.php         # 执行方法调用
        │   ├── MethodCallStateManager.php    # 管理调用状态
        │   └── MethodCallRepository.php      # 保存调用记录
        ├── result/
        │   ├── MethodResultAdapter.php       # 转换程序返回值
        │   ├── MethodResultBuilder.php       # 建立统一结果
        │   ├── MethodResultValidator.php     # 验证返回结果
        │   ├── MethodStateUpdater.php       # 更新方法和对象状态
        │   └── MethodResultRepository.php   # 保存方法结果
        └── exception/
            ├── MethodExceptionCollector.php # 收集调用异常
            ├── MethodExceptionClassifier.php # 分类异常类型
            ├── MethodExceptionAnalyzer.php  # 分析异常影响
            ├── MethodRetryChecker.php       # 判断是否允许重试
            ├── MethodRecoveryHandler.php    # 组织异常恢复
            ├── MethodStopHandler.php        # 处理停止和中止
            └── MethodExceptionRepository.php # 保存异常记录

    方法调用的统一执行程序可以设计为:

    <?php
    
    class MethodCallExecutor
    {
        private $contextBuilder;
        private $parameterResolver;
        private $conditionChecker;
        private $mappingResolver;
        private $adapter;
        private $resultValidator;
        private $executionRepository;
    
        public function __construct(
            $contextBuilder,
            $parameterResolver,
            $conditionChecker,
            $mappingResolver,
            $adapter,
            $resultValidator,
            $executionRepository
        ) {
            $this->contextBuilder = $contextBuilder;
            $this->parameterResolver = $parameterResolver;
            $this->conditionChecker = $conditionChecker;
            $this->mappingResolver = $mappingResolver;
            $this->adapter = $adapter;
            $this->resultValidator = $resultValidator;
            $this->executionRepository = $executionRepository;
        }
    
        public function execute($methodInstance, $taskContext)
        {
            $context = $this->contextBuilder->build(
                $methodInstance,
                $taskContext
            );
    
            $parameters = $this->parameterResolver->resolve(
                $methodInstance,
                $context
            );
    
            $this->conditionChecker->check(
                $methodInstance,
                $context,
                $parameters
            );
    
            $mapping = $this->mappingResolver->resolve(
                $methodInstance
            );
    
            $this->executionRepository->markRunning(
                $methodInstance['method_instance_id']
            );
    
            try {
                $result = $this->adapter->invoke(
                    $mapping,
                    $parameters,
                    $context
                );
    
                $this->resultValidator->validate(
                    $methodInstance,
                    $result
                );
    
                $this->executionRepository->saveResult(
                    $methodInstance['method_instance_id'],
                    $result
                );
    
                return $result;
            } catch (Exception $e) {
                $this->executionRepository->saveException(
                    $methodInstance['method_instance_id'],
                    $e->getMessage()
                );
    
                throw $e;
            }
        }
    }

    该代码展示方法调用的基本组织关系。真实工程还需要在调用前建立唯一调用记录,并将调用状态、参数快照和实现版本持久化。对于设备控制方法,调用状态更新和设备实际动作之间不能假设存在一个完全原子的数据库事务,应当通过执行检查点、设备反馈和状态核实机制管理。程序发生异常后,也不能简单地将所有操作标记为失败,因为某些操作可能已经对外部对象或设备产生了实际影响。

    方法返回结果还需要与方法组合建立关系。当前方法完成后,运行引擎根据返回结果检查后续方法的依赖条件。如果前置方法成功完成,后续方法可以进入准备阶段;如果前置方法返回业务失败,则根据方法组合中的条件分支选择恢复路径;如果返回结果未知或无法确认,则应当暂停依赖该结果的后续方法。这样,方法调用就形成了以方法组合为基础的连续运行过程,而不是互不关联的函数调用集合。

    对于需要连续运行的个体,方法调用状态必须与运行上下文保持同步。运行引擎需要记录当前方法、已完成方法、等待方法、异常方法和下一处理节点,并根据对象状态变化重新检查相关方法。对于通信模式,个体可以按照后台规定同步调用结果和运行状态;对于无通信模式,个体依靠本地已经赋予的方法、程序实现和执行规则继续运行,并保存本地调用记录。通信恢复后,再按照版本和任务标识进行同步。无论哪种模式,方法调用都不能绕过本地权限、安全规则和操作范围。

    第五节 执行方法的注册、验证与版本管理

    方法定义和程序实现建立映射之后,还需要通过注册机制将有效方法纳入个体运行引擎的管理范围。注册的目的不是简单地将方法名称写入一个数组,而是将经过赋值、加载、映射和验证的方法建立成可查询、可调度、可管理的运行对象。只有完成注册并满足当前运行条件的方法,才能被运行引擎纳入调用候选范围。

    方法注册应当发生在个体初始化、知识能力加载或赋值更新过程中。个体运行环境读取赋值清单后,首先加载相应知识结构和方法定义,再解析程序实现映射,检查程序依赖和接口,确认方法适用范围,最后将有效方法登记到本地方法注册表中。对于运行过程中动态增加的方法,也必须经过相同的检查过程,不能因为某个程序文件已经出现在本地目录中,就自动将其视为可调用方法。

    方法注册信息应当包含方法标识、定义版本、所属知识能力、程序实现标识、实现版本、适用个体、注册时间、注册来源和当前状态。方法注册表只保存经过验证的有效映射及其运行管理信息,不取代知识结构中的方法定义,也不取代后台的知识能力库。

    方法注册记录可以设计为:

    {
        "registry_id": "registry_000128",
        "individual_id": "robot_001",
        "method_id": "robot_material_grasp",
        "method_version": "1.2.0",
        "capability_id": "object_grasping",
        "implementation_id": "robot_grasp_impl_001",
        "implementation_version": "1.0.0",
        "assignment_version": "assignment_v12",
        "interface_status": "valid",
        "dependency_status": "valid",
        "registration_status": "registered",
        "registered_at": "2026-11-15 11:30:00"
    }

    这里的registered表示方法已经通过注册阶段的检查并进入当前个体的方法管理范围,不表示该方法在任何时间、任何对象和任何条件下都可以执行。方法是否可以被某个任务调用,仍然需要根据任务范围、参数、上下文、前置条件和执行规则进行判断。

    方法注册程序需要检查方法定义是否存在、所属知识能力是否已经赋予、程序实现是否存在、映射关系是否有效、程序接口是否符合约定、依赖是否完整,以及当前个体是否具备相应运行环境。对于实体设备方法,还应当检查设备适配器、设备标识和控制接口是否与当前个体相匹配。

    方法注册程序目录可以设计为:

    IndividualRuntime/
    └── method/
        ├── registry/
        │   ├── MethodRegistry.php              # 统一管理方法注册表
        │   ├── MethodRegistrationBuilder.php   # 建立方法注册记录
        │   ├── MethodRegistrationChecker.php   # 检查方法注册条件
        │   ├── MethodRegistrar.php              # 执行方法注册
        │   ├── MethodUnregistrar.php            # 撤销方法注册
        │   ├── MethodRegistryReader.php         # 查询已注册方法
        │   └── MethodAvailabilityChecker.php    # 检查方法当前可用状态
        └── validation/
            ├── MethodDefinitionValidator.php   # 验证方法定义
            ├── MethodAssignmentValidator.php   # 验证方法赋值关系
            ├── MethodImplementationValidator.php # 验证程序实现
            ├── MethodDependencyValidator.php   # 验证方法依赖
            ├── MethodInterfaceValidator.php    # 验证调用接口
            ├── MethodScopeValidator.php        # 验证个体适用范围
            ├── MethodRuntimeValidator.php      # 验证本地运行环境
            └── MethodRegistrationValidator.php # 汇总注册验证结果

    方法注册过程应当与个体初始化流程衔接。第二十四章研究的个体智能初始化与部署已经建立赋值清单加载、结构加载、能力加载和方法初始化机制;第二十六章研究的运行引擎负责运行环境和方法调用组织。本章的注册机制是在这两个工程环节之间建立更明确的方法管理过程。个体初始化时,方法注册程序读取已经加载的方法定义和程序映射,将符合要求的方法加入注册表;运行引擎调度任务时,再从注册表中查询适用方法并执行调用。

    方法注册不能脱离赋值版本。假设个体当前使用assignment_v12,而本地注册表中的某个方法来自旧版本赋值,运行引擎就不能直接认为它仍然有效。注册记录必须关联赋值版本,并在任务调用时再次确认。赋值发生更新时,个体需要根据新旧清单的差异,确定哪些方法继续有效,哪些方法需要重新加载,哪些方法需要撤销。

    方法验证也不能只在注册时执行一次。注册时的验证主要检查定义、映射、接口、依赖和运行环境是否满足注册要求;实际调用前还要检查动态参数、对象状态、执行条件和权限;调用结束后还要检查返回结果和状态变化。不同阶段的验证对象不同,不能以注册成功代替实际执行前检查,也不能以程序调用正常代替业务结果验证。

    方法注册可以采用以下程序实现:

    <?php
    
    class MethodRegistrar
    {
        private $definitionReader;
        private $assignmentChecker;
        private $mappingResolver;
        private $implementationChecker;
        private $registryRepository;
    
        public function __construct(
            $definitionReader,
            $assignmentChecker,
            $mappingResolver,
            $implementationChecker,
            $registryRepository
        ) {
            $this->definitionReader = $definitionReader;
            $this->assignmentChecker = $assignmentChecker;
            $this->mappingResolver = $mappingResolver;
            $this->implementationChecker = $implementationChecker;
            $this->registryRepository = $registryRepository;
        }
    
        public function register($methodId, $assignmentVersion)
        {
            $definition = $this->definitionReader->read(
                $methodId
            );
    
            if (empty($definition)) {
                throw new RuntimeException(
                    '方法定义不存在'
                );
            }
    
            $this->assignmentChecker->check(
                $methodId,
                $assignmentVersion
            );
    
            $mapping = $this->mappingResolver->resolve(
                $definition
            );
    
            $this->implementationChecker->check(
                $definition,
                $mapping
            );
    
            $record = array(
                'method_id' => $methodId,
                'method_version' =>
                    $definition['method_version'],
                'implementation_id' =>
                    $mapping['mapping']['implementation_id'],
                'assignment_version' => $assignmentVersion,
                'registration_status' => 'registered'
            );
    
            $this->registryRepository->save($record);
    
            return $record;
        }
    }

    该程序展示方法注册的基本调用关系。实际实现还需要检查个体标识、知识能力所属关系、程序依赖、运行环境和注册记录的唯一性,并采用事务或等效机制保证注册记录的一致性。对于注册失败的情况,应当保留失败原因,不得写入一个看似有效的注册状态。

    方法版本管理是执行方法长期运行和动态更新的基础。方法定义可能随着知识结构调整而发生变化,程序实现也可能因设备接口、软件环境或算法实现调整而更新。两种版本变化应当分别管理,不能简单使用一个版本号代替全部信息。

    方法定义版本表示知识结构中操作要求的版本。例如,方法增加了一个必需参数、调整了前置条件、修改了输入输出结构或改变了操作适用范围,都可能产生新的方法定义版本。程序实现版本则表示具体程序组件的版本,例如修复程序错误、适配新的设备接口、调整内部处理流程或优化资源使用。方法定义版本与程序实现版本之间需要建立兼容关系。

    版本关系可以设计为:

    {
        "method_id": "robot_material_grasp",
        "definition_versions": [
            {
                "version": "1.1.0",
                "status": "archived"
            },
            {
                "version": "1.2.0",
                "status": "active"
            }
        ],
        "implementation_versions": [
            {
                "implementation_id": "robot_grasp_impl_001",
                "version": "1.0.0",
                "compatible_method_versions": [
                    "1.2.0"
                ],
                "status": "active"
            },
            {
                "implementation_id": "robot_grasp_impl_001",
                "version": "0.9.0",
                "compatible_method_versions": [
                    "1.1.0"
                ],
                "status": "archived"
            }
        ]
    }

    该示例表示方法定义和程序实现分别具有版本,并且程序实现需要声明其兼容的方法定义版本。实际兼容关系还应经过接口检查和功能验证,不能只依据版本字符串判断兼容。

    方法版本更新需要考虑个体当前运行任务。对于没有进入执行阶段的方法,可以根据赋值更新规则加载新版本;对于正在运行的任务,如果新旧方法定义存在不兼容变化,就不能直接替换正在使用的程序。应当根据任务状态和方法依赖关系决定是否等待当前操作完成、暂停相关处理、重新形成方法或在任务结束后更新。对于涉及实体设备的运行方法,还必须考虑设备当前动作是否能够安全中断,以及新版本是否会改变原有控制边界。

    版本更新可以采用候选版本、验证版本和活动版本分离的方式。后台构建并验证新的知识能力后,形成新的赋值清单;个体接收赋值后,将新版本加载到候选区域,检查结构、方法、程序实现和依赖关系;验证通过后,再根据运行状态切换到活动版本。旧版本应保留必要的历史记录,以便恢复、追溯和问题分析。不能直接覆盖正在运行的版本文件,也不能在新版本验证失败时破坏原有可用版本。

    对于方法撤销,也需要通过版本和注册状态管理。某个方法可能因为知识能力调整、程序实现缺陷、设备适配变化或权限变化而被撤销。撤销操作应当首先阻止新任务继续调用该方法,并检查是否存在正在使用该方法的任务。对于已经开始的执行过程,应根据具体操作的安全性和可恢复性决定完成当前步骤、暂停或安全停止,不能简单删除注册记录后假设相关任务自然终止。

    方法注册、验证和版本管理还需要与数据库存储建立关系。拟定的数据库表可以包括individual_method_registry、method_definition_versions、method_implementation_versions、method_version_compatibility、individual_method_executions和individual_method_exceptions。

    individual_method_registry用于保存当前个体已经注册的方法,记录个体标识、方法标识、方法定义版本、程序实现标识、实现版本、赋值版本和注册状态。

    method_definition_versions用于管理方法定义的版本历史,记录方法标识、定义版本、定义内容、结构关联、输入输出定义、适用条件和版本状态。

    method_implementation_versions用于管理程序实现版本,记录实现标识、实现版本、运行类型、程序入口、依赖信息、接口类型和实现状态。

    method_version_compatibility用于记录方法定义版本与程序实现版本之间的兼容关系,避免运行引擎将不兼容的程序实现加载到当前方法中。

    individual_method_executions用于保存方法实际调用记录,记录调用标识、方法实例、方法版本、实现版本、参数快照、上下文快照、执行状态、返回结果和调用时间。

    individual_method_exceptions用于保存方法调用异常,记录异常类型、发生阶段、关联调用、影响范围、处理路径和恢复状态。

    这些数据表需要与第三十五章的方法形成记录以及第二十六章的运行上下文保持关联。方法定义版本用于追踪操作定义,赋值版本用于追踪个体获得的知识能力,程序实现版本用于追踪实际运行的程序。三种版本各自承担不同的工程职责,不能混为一个版本字段。

    方法注册和版本管理还需要处理通信与无通信运行模式。通信模式下,智能控制后台可以发布经过验证的知识能力和方法更新,个体按照赋值清单加载新版本,并将注册状态和验证结果同步到后台。无通信模式下,个体只能使用已经部署并通过验证的本地方法版本,不能自行获取后台未赋予的新方法。通信恢复后,后台根据个体当前赋值版本和运行状态决定是否更新。对于正在执行的任务,应当优先保证任务状态和方法版本的一致性,不能为了同步版本而破坏正在进行的操作。

    在持续运行环境中,方法注册表还应支持定期检查和异常检查。程序文件被意外修改、设备接口失效、依赖程序缺失、方法定义被撤销或赋值版本发生变化时,应当及时调整方法的可用状态。对于已经不再适用的方法,应阻止新调用,并将受影响的任务交由运行引擎重新判断。方法注册表不是一个静态的函数列表,而是与知识能力赋值、个体运行环境和实际运行状态保持关联的工程管理对象。

    本章建立的方法执行机制最终形成如下工程关系:

    知识结构中的方法定义
            |
            v
    个体知识能力赋值
            |
            v
    方法定义与程序实现映射
            |
            v
    本地程序加载与接口检查
            |
            v
    方法注册与版本确认
            |
            v
    方法实例和执行上下文建立
            |
            v
    参数解析与执行条件检查
            |
            v
    运行引擎统一调度
            |
            v
    程序实现调用
            |
            v
    返回值验证与异常处理
            |
            v
    执行记录与运行状态更新

    这套机制使知识结构中的方法定义能够与实际程序建立稳定联系,也使不同类型的个体能够在统一运行框架下调用各自获得的知识能力。方法调用不再依赖任务程序中预先写死的业务函数,而是通过方法标识、方法定义、程序映射、参数和执行上下文建立动态调用关系。

    需要明确的是,本章建立的是执行方法的程序调用基础。方法程序成功返回,并不必然意味着整个任务已经完成。一个方法可能只是完成了某个局部操作,后续还需要调用其他方法、更新对象状态、检查执行结果并继续处理。对于实体设备,还必须依据实际设备反馈确认动作结果。方法执行过程中的结果、异常和状态变化,将进一步进入第三十七章所研究的个体行为与任务执行机制。

    因此,第三十六章完成了从方法形成结果到个体本地程序调用机制的工程衔接,明确了执行方法的数据定义、参数与上下文、方法标识与程序映射、调用与返回机制,以及方法注册、验证和版本管理,为后续建立完整的个体行为执行过程提供了程序基础。

    本章与第三十五章的关系是:第三十五章形成方法,本章建立方法的注册、调用和运行管理机制。下一章将进入第三十七章《个体行为与任务执行》,研究多个执行方法如何组织为连续行为,如何推进任务状态,以及如何将程序调用结果转化为个体实际行为和任务执行结果。

     

Leave a Reply

Your email address will not be published. Required fields are marked *

客服咨询
● 欢迎咨询与合作
您好!欢迎咨询。 我可以帮助您了解人工智能技术研发、智能软件系统开发、网站建设、搜索优化及项目定制等相关信息。 请问有什么可以帮您?
免费申请
请填写以下信息,方便我们进一步沟通。
欢迎咨询 AI 系统开发、网站建设、搜索优化、项目定制合作
电话:15089196448
邮箱:1602401899@qq.com
地址:陕西省渭南市
服务时间:周一至周五 09:00 - 18:00 | 7×24小时技术值守