Ist es OK, über eine Computed Property auf ein Objekt (GKComponent) zuzugreifen!?

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Ist es OK, über eine Computed Property auf ein Objekt (GKComponent) zuzugreifen!?

    Hi,

    ich arbeite zur Zeit viel mit Apples GameplayKit und sehe da stets in jedem Beispiel und in jedem öffentlichen Code folgende Herangehensweise:

    Quellcode

    1. class PlayerEntity: GKEntity {
    2. // MARK: Components
    3. /* Für den Zugriff auf Components diese über Computed Properties holen */
    4. var renderComponent: RPRenderComponent {
    5. guard let renderComponent = componentForClass(RPRenderComponent.self) else {
    6. fatalError()
    7. }
    8. return renderComponent
    9. }
    10. var stateMachineComponent: RPStateMachineComponent {
    11. guard let stateMachineComponent = componentForClass(RPStateMachineComponent.self) else {
    12. fatalError()
    13. }
    14. return stateMachineComponent
    15. }
    16. // MARK: Initialisation
    17. override init() {
    18. super.init()
    19. /* Erstellung der Components während Initialisierung */
    20. let renderComponent = RPRenderComponent()
    21. renderComponent.node.entity = self;
    22. let stateMachineComponent = RPStateMachineComponent(states: [
    23. RPPlayerStandingState(entity: self),
    24. RPPlayerFallingState(entity: self),
    25. RPPlayerBouncingDownState(entity: self),
    26. RPPlayerBouncingUpState(entity: self),
    27. RPPlayerJumpingState(entity: self),
    28. RPPlayerBoostState(entity: self)
    29. ])
    30. addComponent(renderComponent)
    31. addComponent(stateMachineComponent)
    32. }
    33. }
    Alles anzeigen

    Der Code ist zwar zwecks Veranschaulichung ein wenig reduziert, die wesentlichen Punkte sind aber erhalten geblieben.

    Apple selbst und auch alle anderen, öffentlichen Beispiele oder Tutorials gehen so, wie im Snippet oben vor:

    1. Initialisieren der Components während Initialisierung der Klasse.
    2. Hinzufügen der Components via addComponent.
    3. Bei Zugriff auf die Component, diese via Computed Property herausgeben.

    Meine Bedenken hierbei sind, dass eine Computed Property eben jedesmal diese "Berechnung" durchführen muss, wenn auf ihr zugegriffen wird. Für mich bedeutet dies aber, dass wohlmöglich die Performance darunter leiden kann. Speziell die Instanz der RPRenderComponent-Klasse, welche einen nicht gerade unerheblichen Teil der Grafik-Darstellung in sich trägt, wird sehr oft Frame-weise aufgerufen.

    Diesen "per-Frame"-Code versuche ich aber - Verständnis halber - so gering wie möglich zu halten und arbeite hier lieber mit direkten Referenzen, eben so wie folgt:


    Quellcode

    1. class PlayerEntity: GKEntity {
    2. // MARK: Components
    3. /* Zugriff auf Components über eigene Variablen */
    4. let renderComponent: RPRenderComponent
    5. var stateMachineComponent: RPStateMachineComponent!
    6. // MARK: Initialisation
    7. override init() {
    8. renderComponent = RPRenderComponent()
    9. super.init()
    10. renderComponent.node.entity = self
    11. /* Initialisierung der Statemachine nach super.init() weil Zugriff auf self benötigt wird. */
    12. stateMachineComponent = RPStateMachineComponent(states: [
    13. RPPlayerStandingState(entity: self),
    14. RPPlayerFallingState(entity: self),
    15. RPPlayerBouncingDownState(entity: self),
    16. RPPlayerBouncingUpState(entity: self),
    17. RPPlayerJumpingState(entity: self),
    18. RPPlayerBoostState(entity: self)
    19. ])
    20. addComponent(renderComponent)
    21. addComponent(stateMachineComponent)
    23. }
    24. }
    Alles anzeigen
    Hier sind die Components nun als "Ownership" an die Klasse gebunden, muss dies also auch später berücksichtigen. Für mich aber ist dies rein vom Gefühl her der richtigere Weg, da ich nicht jedesmal und "per-Frame" die Computed Property auflösen muss, was meiner Meinung (oder meinem Empfinden nach) die Performance beeinträchtigen kann.

    Jetzt kann es natürlich sein, das Apple selbst in den Beispielen das nur so gemacht hat, da es der Stil desjenigen Entwicklers ist und es alle anderen ebenso nachmachen. Es kann aber auch sein, dass meine Bedenken über Computed Properties eben nicht stimmen. Habt ihr eine Antwort?