Ankündigung

Einklappen
Keine Ankündigung bisher.

[Erledigt] Klassen Methoden nach spezifischer Sortierung abrufen

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • [Erledigt] Klassen Methoden nach spezifischer Sortierung abrufen

    Hallo

    Irgendwie finde ich nichts zu dem Thema bei Google. Ist den sowas nicht machbar?

    Ich habe eine Klasse "Unzip" und möchte wenn man eine falsche Methoden Ablauf macht einen Fehlerhinweis bekommt. Ist den dies nicht möglich?

    Einfaches Beipiel:
    PHP-Code:
    class Unzip{
        
        private 
    $_file;
        private 
    $_zip;
        private 
    $_zip_open;
        
        public function 
    setFile($file) {
            
    $this->_file $file;
        }

        public function 
    open() {
            
    $this->_zip = new ZipArchive;
            
    $this->_zip_open $this->_zip->open($this->_file);
        }
        
        public function 
    unzip() {
            
    //extract zip
        
    }

        public function 
    __destruct() {
            if (
    $this->_zip_open === true) { $this->_zip->close(); }
        }
    }

    $Unzip = new Unzip;
    $Unzip->setFile('zipfile.zip');
    $Unzip->open();
    $Unzip->unzip(); 
    Wenn man z.B zuerst die unzip() bevor der open() Methode Aufruft sollte eben eine Meldung kommen.


  • #2
    Naja du kannst es dir ja auf jeden Fall selber programmieren. Die einfachste Möglichkeit: Füge protected Klassenvariablen hinzu die mit false initalisiert werden und dann von den Methoden auf true gesetzt werden, wenn sie gültig aufgerufen werden. Am Beginn der Methoden schaust du dann nach, ob alle benötigten anderen Methoden schon aufgerufen wurden. Möglich wäre dann auch, dass z. B. die Methode unizp() die Methode open() selbständig aufruft wenn sie feststellt, dass diese noch nicht aufgerufen wurde.

    Es gibt auch Möglichkeiten das so zu machen, dass man nicht bei jeder Methode prüfen muss, ist die und die andere Methode schon aufgerufen worden, sondern dass man einfach irgendwo einmalig die Abhängikeiten definiert und die Klasse automatisch vor Aufruf ihrer Methoden das prüft.

    Beispiel, ungetestet:
    PHP-Code:
    <?php 

    class Unzip 

        protected static 
    $dependencies = array('open' => 'setFile''unzip' => array('open''setFile'));
        protected 
    $called = array();
         
        protected function 
    _setFile($file) { } 

        protected function 
    _open() { } 
         
        protected function 
    _unzip() { } 

        public function 
    __call($method$arguments
        {
            if (
    method_exists(__CLASS__'_'.$method)) {
                if (isset(
    self::$dependencies[$method])) {
                    
    $dependencies self::$dependencies[$method];
                    
    $valid true;

                    if (
    is_array($dependencies)) {
                        foreach (
    $dependencies as $dependency) {
                            if (! isset(
    self::$called[$dependency])) {
                                
    $valid false;
                                break;
                            }
                        }
                    } else {
                        if (! isset(
    self::$called[$dependencies]) {
                            
    $valid false;
                        }
                    }

                    if (
    $valid) {
                        
    $this->called[$method] = true;
                        return 
    call_user_func_array(array($this'_'.$method), $arguments);
                    } else {
                        throw new \
    Exception("Fehler: Ungueltige Reihenfolge der Methodenaufrufe - '$method' kann nicht aufgerufen werden!");
                        
    // ODER: Methodenrufe selber automatisch durchfuehren lassen
                    
    }
                }
            } else {
                throw new \
    Exception("Fehler: Unbekannte Methode '$method'!");
            }
        }
    }
    D. h. ruft man $unzip->open() auf dann wird __call() aufgerufen, da die Methode open() nicht existiert. Dort wird geprüft, ob _setFile() schon aufgerufen wurde. Wenn ja, wird die von außen nicht zugängliche Methode _open() aufgerufen, wenn nein, wird eine Exception geworfen. Abhängigkeiten kann man im Array $dependencies festlegen und man muss innerhalb der eigentlichen Methoden keinen Kontrollcode einbauen. DRY!

    Kommentar


    • #3
      Ah ok dann gibt es tatsächlich nichts von PHP aus. Dann bleibt mir ja nun wirklich nur dieser Weg. Besten Dank für deine Hilfe.

      Möglich wäre dann auch, dass z. B. die Methode unizp() die Methode open() selbständig aufruft wenn sie feststellt, dass diese noch nicht aufgerufen wurde.
      Guter Tip. Danke.

      Kommentar


      • #4
        In diesem Fall sei direkt nach der Notwendigkeit von open gefragt. Jedenfalls als public Methode.
        --

        „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
        Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


        --

        Kommentar


        • #5
          Hey Monolith, danke vielmal für das Code Beispiel. Wieder was neues komplizierteres gelernt.

          Kommentar


          • #6
            Ich würde das übrigends nicht so wie monolith es gepostet hat machen. Ist zwar theoretisch nicht falsch, aber das __call()-Rumgebastel ist hier gar nicht nötig.

            Wenn du einen Fehler werfen willst, kannst du das auch selber machen und du kannst deine Methoden ordentlich dokumentieren.

            PHP-Code:
            <?php

            class Unzip {
                
                private 
            $file;
                private 
            $zip;
                private 
            $zip_open;
                
                public function 
            setFile($file) {
                    
            $this->file $file;
                }
                
            /**
                 * Opens file usw. usf.
                 * @throws Exception
                 */
                
            public function open() {
                    if (
            $this->file === null) {
                        throw new 
            Exception("No file given"); // Kannst auch 'ne eigene Exception erfinden
                    
            }
                    if (!
            file_exists($this->file)) {
                        throw new 
            Exception("File {$this->file} doesn't exist");
                    }
                    
            $this->zip = new ZipArchive;
                    
            $this->zip_open $this->zip->open($this->file);
                    if (
            $this->zip_open !== true) {
                        throw new 
            Exception("Could not open zip file"$this->zip_open);
                    }
                }
                public function 
            unzip() {
                    
            //extract zip
                
            }

                public function 
            __destruct() {
                    if (
            $this->zip_open === true) {
                        
            $this->zip->close();
                    }
                }
            }

            $Unzip = new Unzip;
            $Unzip->setFile('zipfile.zip');
            try {
                
            $Unzip->open();
                
            $Unzip->unzip();
            } catch (
            Exception $e) {
                echo 
            "Oh ein Fehler: "$e->getMessage(), PHP_EOL;
            }
            Crashkurs zum Thema Rechtschreibung: normalerweise (normaler weise oder normaler weiße), Standard (Standart), eben (ebend)

            Kommentar


            • #7
              Ja ich stimme dir zu, im konkreten Anwedungsfall denke ich auch, dass es nicht notwendig ist. Es würde sich erst lohnen wenn man wirklich eine gewissen Anzahl von Methoden hat mit umfangreichen Abhängigkeiten.

              Ich gaube auch nicht, dass der TE das so machen wird aber das Konzept finde ich recht interessant. Man kann mit __call() schon einiges Nettes machen.

              Kommentar


              • #8
                Mal ne frage: Wieso lässt man setFile nicht einfach weg und übergibt den Dateinamen bei open()? Danke für die Aufklärung
                Neu bei PHP, lerne aktuell OOP

                Kommentar


                • #9
                  Ja das kann man machen oder halt bereits beim Konstruktor (dann bei open() zusätzlich, aber optional, falls der ursprünglich angegebene Dateiname geändert werden soll).

                  Kommentar


                  • #10
                    Ok Danke
                    Neu bei PHP, lerne aktuell OOP

                    Kommentar


                    • #11
                      Ich glaube, dass das hier auch nur ein Beispiel war, da die Klasse ZipArchive eigentlich schon gut konzipiert wurde (abgesehen von der Nichtbenutzung von Exceptions).
                      Crashkurs zum Thema Rechtschreibung: normalerweise (normaler weise oder normaler weiße), Standard (Standart), eben (ebend)

                      Kommentar

                      Lädt...
                      X