{"meta":{"title":"Umgang mit bereichsübergreifenden Aspekten","intro":"Copilot Chat kann Ihnen dabei helfen, Code zu vermeiden, der sich auf ein anderes Problem als das Hauptanliegen der Methode oder Funktion bezieht, in der sich der Code befindet.","product":"GitHub Copilot","breadcrumbs":[{"href":"/de/copilot","title":"GitHub Copilot"},{"href":"/de/copilot/tutorials","title":"Anleitungen"},{"href":"/de/copilot/tutorials/copilot-cookbook","title":"GitHub Copilot Kochbuch"},{"href":"/de/copilot/tutorials/copilot-cookbook/refactor-code","title":"Umgestalten von Code"},{"href":"/de/copilot/tutorials/copilot-cookbook/refactor-code/handle-cross-cutting","title":"Übergreifende Handhabung"}],"documentType":"article"},"body":"# Umgang mit bereichsübergreifenden Aspekten\n\nCopilot Chat kann Ihnen dabei helfen, Code zu vermeiden, der sich auf ein anderes Problem als das Hauptanliegen der Methode oder Funktion bezieht, in der sich der Code befindet.\n\nBereichsübergreifende Aspekte beziehen sich bei einem Programm auf mehrere Teile des Systems (z. B. Protokollierung, Sicherheit, Datenüberprüfung und Fehlerbehandlung). Sie können in der gesamten Codebasis verstreut sein, was zu Codeduplizierung und Wartungsproblemen führt.\n\nCopilot Chat kann dabei helfen, querschnittliche Belange zu refaktorisieren, indem die Implementierung von Aspect-Oriented Programming (AOP)-Praktiken oder die Verwendung von Dekoratoren und Middleware-Mustern vorgeschlagen wird, um diese Belange auf modulare und wartbare Weise zu zentralisieren.\n\n## Beispielszenario\n\nStell dir vor, du verfügst über ein Python-Projekt, das mehrere Dienstdateien enthält, in denen eine Protokollierung erfolgt. Die protokollierten Informationen werden in den einzelnen Dienstdateien definiert. Wenn die Anwendung in Zukunft geändert oder erweitert wird, kann dieser Entwurf zu Inkonsistenzen beim Inhalt und Stil von Protokolleinträgen führen. Du kannst das Protokollierungsverhalten konsolidieren und zentralisieren, um zu vermeiden, dass sich diese Inkonsistenzen auf dein gesamtes Projekt auswirken.\n\nDies sind drei Dateien aus unserem Beispielprojekt: die Einstiegspunktdatei (`main.py`), die Konfigurationsdatei für Protokollnachrichten (`logging_config.py`) und eine der Dienstdateien (`order_service.py`). Die Beispieldienstdatei zeigt, wie Protokollinformationen zusammen mit der Geschäftslogik für einen bestimmten Teil der Anwendung definiert werden.\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## Beispielaufforderung\n\nÖffnen Sie den Projektarbeitsbereich in VS Code oder Visual Studio geben Sie die folgende Eingabeaufforderung in der Copilot Chat Ansicht ein.\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> Der `@workspace` Chatteilnehmer in VS Code und Visual Studio bietet Copilot Kontext zu allem Code in Ihrem Arbeitsbereich. Sie können `@workspace` verwenden, wenn Sie möchten, dass Copilot die Struktur Ihres Projekts und die Interaktion verschiedener Teile Ihres Codes berücksichtigt. Wenn Sie eine JetBrains-IDE verwenden, verwenden Sie `@project` anstelle von `@workspace`.\n\n## Beispielantwort\n\nCopilot antwortet wie folgt.\n\n> \\[!NOTE] Die folgende Antwort ist ein Beispiel. Da die Copilot Chat-Antworten nicht deterministisch sind, erhältst du möglicherweise eine andere Antwort als die hier beschriebene.\n\n> Um dieses Projekt mithilfe von Aspect-Oriented Programming (AOP) umzugestalten, um die Protokollierung als eine querschnittliche Angelegenheit zu behandeln, können Sie eine Bibliothek wie `aspectlib` verwenden. Hier erfährst du, wie du dies tun kannst:\n>\n> 1. Installieren Sie `aspectlib`:\n>\n>    `pip install aspectlib`\n>\n> 2. Erstelle einen Aspekt für die Protokollierung in einer neuen Datei mit dem Namen `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. Wende den Aspekt auf die Dienstmethoden in `main.py` an:\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 anschließend wird ihnen mitgeteilt, den Protokollierungscode aus allen Dienstklassen zu entfernen und ihnen den Code für die überarbeiteten Dateien zu geben. Dies ist beispielsweise die überarbeitete Version von `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\nIn der umgestalteten Version des Projekts werden dieselben Protokollierungsvorgänge ausgeführt, aber der Protokollierungscode wird in einer einzelnen Datei zentralisiert.\n\n## Weiterführende Lektüre\n\n* [Prompt-Engineering für GitHub Copilot Chat](/de/copilot/concepts/prompting/prompt-engineering)\n* [Bewährte Methoden für die Verwendung von GitHub Copilot](/de/copilot/get-started/best-practices)"}