{"meta":{"title":"Gestión de problemas transversales","intro":"Copilot Chat puede ayudarle a evitar el código relacionado con una preocupación distinta de la preocupación principal del método o la función en la que se encuentra el código.","product":"GitHub Copilot","breadcrumbs":[{"href":"/es/enterprise-cloud@latest/copilot","title":"GitHub Copilot"},{"href":"/es/enterprise-cloud@latest/copilot/tutorials","title":"Tutoriales"},{"href":"/es/enterprise-cloud@latest/copilot/tutorials/copilot-cookbook","title":"Recetario de GitHub Copilot"},{"href":"/es/enterprise-cloud@latest/copilot/tutorials/copilot-cookbook/refactor-code","title":"Refactorización de código"},{"href":"/es/enterprise-cloud@latest/copilot/tutorials/copilot-cookbook/refactor-code/handle-cross-cutting","title":"Gestionar asuntos transversales"}],"documentType":"article"},"body":"# Gestión de problemas transversales\n\nCopilot Chat puede ayudarle a evitar el código relacionado con una preocupación distinta de la preocupación principal del método o la función en la que se encuentra el código.\n\nLos problemas transversales son aspectos de un programa que afectan a varias partes del sistema, como el registro, la seguridad, la validación de datos y el control de errores. Pueden dispersarse por toda la base de código, lo que genera duplicación de código y problemas de mantenimiento.\n\nCopilot Chat puede ayudar a refactorizar aspectos transversales sugiriendo la implementación de prácticas de Programación Orientada a Aspectos (AOP) o el uso de decoradores y patrones de middleware para centralizar estos aspectos de forma modular y mantenible.\n\n## Escenario de ejemplo\n\nImagínese que tiene un proyecto de Python que contiene varios archivos de servicio en los que se realiza el registro de eventos. La información que se registra se define dentro de cada uno de los archivos de servicio individuales. Si la aplicación se modifica o amplía en el futuro, este diseño podría provocar incoherencias en el contenido y el estilo de las entradas de registro. Puedes consolidar y centralizar el comportamiento de registro para evitar que se distribuya en el proyecto.\n\nEstos son tres archivos del proyecto de ejemplo: el archivo de punto de entrada (`main.py`), el archivo de configuración de mensajes de registro (`logging_config.py`) y uno de los archivos de servicio (`order_service.py`). El archivo de servicio de ejemplo muestra cómo se define la información de registro junto con la lógica de negocios de una parte determinada de la aplicación.\n\n### main.py\n\n```python\nimport logging\nfrom logging_config import setup_logging\nfrom payment_service import PaymentService\nfrom order_service import OrderService\nfrom shipping_service import ShippingService\nfrom inventory_service import InventoryService\nfrom notification_service import NotificationService\n\ndef main():\n    setup_logging()\n    payment_service = PaymentService()\n    order_service = OrderService()\n    shipping_service = ShippingService()\n    inventory_service = InventoryService()\n    notification_service = NotificationService()\n\n    # Example usage\n    payment_service.process_payment({\"amount\": 100, \"currency\": \"USD\"})\n    order_service.place_order({\"item\": \"Book\", \"quantity\": 1})\n    shipping_service.ship_order({\"item\": \"Book\", \"quantity\": 1})\n    inventory_service.update_inventory(\"Book\", -1)\n    notification_service.send_notification(\"Order has been placed and shipped.\")\n\nif __name__ == \"__main__\":\n    main()\n```\n\n### logging\\_config.py\n\n```python\nimport logging\n\ndef setup_logging():\n    logging.basicConfig(level=logging.INFO,\n                  format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n```\n\n### order\\_service.py\n\n```python\nimport logging\n\nclass OrderService:\n    def __init__(self):\n        self.logger = logging.getLogger(__name__)\n\n    def place_order(self, order):\n        self.logger.info(\"Entering place_order method.\")\n        try:\n            # In here would be the business logic for placing an order\n            # ...\n            self.logger.info(\"Order placed successfully.\")\n        except Exception as e:\n            self.logger.error(f\"Error in place_order method: {e}\")\n            raise\n        finally:\n            self.logger.info(\"Exiting place_order method.\")\n```\n\n## Mensaje de ejemplo\n\nAbra el área de trabajo del proyecto en VS Code o Visual Studio y escriba la siguiente instrucción en la vista Copilot Chat.\n\n```copilot copy\n@workspace Refactor this project by using AOP to avoid logging that has cross-cutting concerns\n```\n\n> \\[!NOTE]\n> El `@workspace` participante del chat en VS Code y Visual Studio ofrece Copilot información contextual sobre todo el código en tu área de trabajo. Puede usar `@workspace` cuando desee Copilot tener en cuenta la estructura del proyecto y cómo interactúan diferentes partes del código. Si usas un IDE de JetBrains, utiliza `@project` en lugar de `@workspace`.\n\n## Respuesta de ejemplo\n\nCopilot responde de la siguiente manera.\n\n> \\[!NOTE] La respuesta siguiente es un ejemplo. Las respuestas de Copilot Chat no son deterministas, por lo que puedes obtener una respuesta diferente a la aquí mostrada.\n\n> Para refactorizar este proyecto mediante la programación orientada a aspectos (AOP) para controlar el registro como un problema transversal, puedes usar una biblioteca como `aspectlib`. Así es cómo se puede hacer:\n>\n> 1. Instale `aspectlib`:\n>\n>    `pip install aspectlib`\n>\n> 2. Crea un aspecto para registrarlo en un nuevo archivo llamado `logging_aspect.py`:\n>\n>    ```python\n>    import aspectlib\n>    import logging\n>\n>    @aspectlib.Aspect(bind=True)\n>    def log_method_call(cutpoint, *args, **kwargs):\n>        logger = logging.getLogger()\n>        method_name = cutpoint.__name__\n>        logger.info(f\"Entering method: {method_name}\")\n>        try:\n>            result = yield aspectlib.Proceed\n>            logger.info(f\"Method {method_name} executed successfully.\")\n>            return result\n>        except Exception as e:\n>            logger.error(f\"Error in method {method_name}: {e}\")\n>            raise\n>        finally:\n>            logger.info(f\"Exiting method: {method_name}\")\n>    ```\n>\n> 3. Aplica el aspecto a los métodos de servicio en `main.py`:\n>\n>    ```python\n>    import logging\n>    from logging_config import setup_logging\n>    from payment_service import PaymentService\n>    from order_service import OrderService\n>    from shipping_service import ShippingService\n>    from inventory_service import InventoryService\n>    from notification_service import NotificationService\n>    from logging_aspect import log_method_call\n>    import aspectlib\n>\n>    def main():\n>        setup_logging()\n>\n>        # Apply logging aspect to service methods\n>        aspectlib.weave(PaymentService.process_payment, log_method_call)\n>        aspectlib.weave(OrderService.place_order, log_method_call)\n>        aspectlib.weave(ShippingService.ship_order, log_method_call)\n>        aspectlib.weave(InventoryService.update_inventory, log_method_call)\n>        aspectlib.weave(NotificationService.send_notification, log_method_call)\n>\n>        payment_service = PaymentService()\n>        order_service = OrderService()\n>        shipping_service = ShippingService()\n>        inventory_service = InventoryService()\n>        notification_service = NotificationService()\n>\n>        # Example usage\n>        payment_service.process_payment({\"amount\": 100, \"currency\": \"USD\"})\n>        order_service.place_order({\"item\": \"Book\", \"quantity\": 1})\n>        shipping_service.ship_order({\"item\": \"Book\", \"quantity\": 1})\n>        inventory_service.update_inventory(\"Book\", -1)\n>        notification_service.send_notification(\"Order has been placed and shipped.\")\n>\n>    if __name__ == \"__main__\":\n>        main()\n>    ```\n\nCopilot a continuación, le indica que quite el código de registro de todas las clases de servicio y le proporcione el código para los archivos revisados. Por ejemplo, esta es la versión revisada de `order_service.py`:\n\n```python\nclass OrderService:\n    def place_order(self, order):\n        # In here would be the business logic for placing an order\n        # ...\n        pass\n```\n\nEn la versión refactorizada del proyecto, se realizan las mismas operaciones de registro, pero el código de registro se centraliza en un archivo único.\n\n## Lectura adicional\n\n* [Ingeniería de mensajes para GitHub Copilot Chat](/es/enterprise-cloud@latest/copilot/concepts/prompting/prompt-engineering)\n* [Procedimientos recomendados para usar GitHub Copilot](/es/enterprise-cloud@latest/copilot/get-started/best-practices)"}