Ankündigung

Einklappen
Keine Ankündigung bisher.

Singleton vs. new Object ()

Einklappen

Neue Werbung 2019

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

  • #16
    Sprich:

    PHP-Code:
    $menu = new Menu();
    $menu->plotMenuCoupled($lang7$sec3'menu');
    $menu->plotMenuCoupled($lang0$cat2'categories');
    $menu->plotMenuCoupled($lang0$cat1'menu'); 
    ???

    Kommentar


    • #17
      Naja, wir können schwer reinsehen in die Klasse. Es scheint jedoch so, als wäre das Menüobjekt nur ein besserer Container und der Hauptteil läuft ohnehin erst bei plotMenuCoupled() ab. Den Rest macht vermutlich der Konstruktor über implizite Abhängigkeiten, ebenfalls schlechter Stil in der OOP.

      Besser wäre sowas:
      PHP-Code:
      $mainmenu = new myMenu ($database $controler->getLanguage ());
      $mainmenu->setActiveCategory (); // auto category
      $mainmenu->setId ('products_main')

      echo 
      $mainmenu->render(); // render full menu

      $favmenu = new myMenu ($database $controler->getLanguage ());
      $favmenu->setActiveCategory ();
      $favmenu->setSubset ($SESSION['user_favorites']);

      // in einer Favoritenbox

      $favmenu->setId ('products_favs')
      echo 
      $favmenu->render ();


      // später im footer
      $mainmenu->setId ('products_footer')
      $mainmenu->setActiveCategory (0); // explicit category
      echo $mainmenu->render(1); // render footer menu (cats only) 
      [COLOR="#F5F5FF"]--[/COLOR]
      [COLOR="Gray"][SIZE="6"][FONT="Georgia"][B]^^ O.O[/B][/FONT] [/SIZE]
      „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
      [URL="http://www.php.de/javascript-ajax-und-mehr/107400-draggable-sorttable-setattribute.html#post788799"][B]Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“[/B][/URL][/COLOR]
      [COLOR="#F5F5FF"]
      --[/COLOR]

      Kommentar


      • #18
        Okay, ich habe es nun verstanden. Meine Menüklasse lässt sich auch relativ leicht umbauen. Momentan sieht sie so aus, kleinere Auszüge, bitte sehr:

        PHP-Code:
        public function initialPStmt(){
            
        self::initialPSMenuElements();
            
        self::initialPSMenuClass();
            
        self::initialPSMenuName();
            
        self::initialPSParentID();
            
        self::initialActive();
            }

        public function 
        plotMenuCoupled($lang$root$active$linkMod$menuSource){
            
        $this->menuSource $menuSource;
            
        $this->lang $lang;
            
        $this->newElement $active;
            
        self::initialPStmt();
            
        $this->pstmtActive->execute();
            
        $this->activeElement $this->pstmtActive->fetchColumn();
                
        // Hier wird das Menü erzeugt

        Vielen Dank soweit.

        Kommentar


        • #19
          Ich muss bei dieser Thematik nochmals nachhaken. Ehrlich gesagt finde ich es ziemlich unübersichtlich, wenn in meiner Index folgendes stehen soll

          Zitat von nikosch Beitrag anzeigen
          PHP-Code:
          $mainmenu = new myMenu ($database $controler->getLanguage ());
          $mainmenu->setActiveCategory (); // auto category
          $mainmenu->setId ('products_main')

          echo 
          $mainmenu->render(); // render full menu

          $favmenu = new myMenu ($database $controler->getLanguage ());
          $favmenu->setActiveCategory ();
          $favmenu->setSubset ($SESSION['user_favorites']);

          // in einer Favoritenbox

          $favmenu->setId ('products_favs')
          echo 
          $favmenu->render ();


          // später im footer
          $mainmenu->setId ('products_footer')
          $mainmenu->setActiveCategory (0); // explicit category
          echo $mainmenu->render(1); // render footer menu (cats only) 
          damit ich drei Menüs erzeugen lassen kann. Da finde ich meine Variante wesentlich übersichtlicher, vor allem weil ich zusätzlich für das Webdesign zuständig bin.
          Nach wie vor sehe ich auch rein gar keinen Vorteil darin, wenn ich ein New Object() erzeuge und dann im Folgenden den einzelnen Methoden Werte übermittle.

          Mit Sicherheit ist meine Ausführung nicht dem eigentlichen Sinne nach OOP, doch erfüllt sie den Zweck. Für mich ist es ausreichend, wenn ich über folgenden Aufruf

          PHP-Code:
          Menu::getInstance()->plotMenuCoupled($lang7$sec3'menu'); 
          mein Menü mit fünf Werten füttere und dieses für mich das gewünschte Menü ausspuckt. OOP hin oder her, mit meiner Variante komme ich "schöner" zum Ziel mit der für mich notwendigen Dynamik. Dasselbe gilt für die Datenbank-Klasse.

          Kommentar


          • #20
            Irgendwie ist dein Code eine eigenartige Mischung aus "Singleton", statischen Methoden und Instanzmethoden.

            Code:
            Menu::getInstance()->plotMenuCoupled($lang, 7, $sec, 3, 'menu');
            ...

            Code:
            public function plotMenuCoupled($lang, $root, $active, $linkMod, $menuSource){
                $this->menuSource = $menuSource;
                $this->lang = $lang;
                $this->newElement = $active;
                self::initialPStmt();
                $this->pstmtActive->execute();
                $this->activeElement = $this->pstmtActive->fetchColumn();
                    // Hier wird das Menü erzeugt
            }
            Was gibt das denn am Ende zurück? Den fertigen HTML-Code per echo?

            Das macht den Anschein, prozedural Programmierstil zu sein dessen Funktionen aus irgendeinem Grund in eine Art Pseudo-Objekt innerhalb eines Pseudo-Singletons gepackt wurden.

            Ich glaube, die Konzepte sind da einfach durcheinander.

            Nach wie vor sehe ich auch rein gar keinen Vorteil darin, wenn ich ein New Object() erzeuge und dann im Folgenden den einzelnen Methoden Werte übermittle.
            Na ja, in deinem Code weist du auch den einzelnen Instanzvariablen ($this->xyz = ...) Werte zu (nichts anderes tun etwaige Methoden). Es spricht nichts dagegen, eine "Kapselmethode" mit etlichen Parametern zum einfachen Setzen vieler Eigenschaften anzubieten. Das ist aber im Prinzip nur eine andere Schreibweise derselben Funktionalität.

            Kommentar


            • #21
              Mal ganz abseits von Singleton oder nicht: Deine Variante finde ich persönlich extrem hässlich. Allein die vielen "initial"-Aufrufe, die vielen Paramter und die "magic numbers" machen irgendwie einen komischen Eindruck.

              Sicher ist das ein Stück weit geschmackssache. Ich mag sprechenden Code. Eine Zeile wie:
              Code:
              Menu::getInstance()->plotMenuCoupled($lang, 3, $cat, 2, 'menu');
              ist da das absolute Gegenteil
              [URL="https://www.quizshow.io/"]Create your own quiz show.[/URL]

              Kommentar


              • #22
                Zitat von mermshaus Beitrag anzeigen
                Was gibt das denn am Ende zurück? Den fertigen HTML-Code per echo?
                Ja, am Ende habe ich mein fertiges HTML-Menu per print.

                Zitat von mermshaus Beitrag anzeigen
                Das macht den Anschein, funktionaler Programmierstil zu sein dessen Funktionen aus irgendeinem Grund in eine Art Pseudo-Objekt innerhalb eines Pseudo-Singletons gepackt wurden.

                Ich glaube, die Konzepte sind da einfach durcheinander.
                Pseudo hin oder her, der Programmcode wird dadurch enorm übersichtlich und ist einfacher zu handhaben. Abgesehen davon, dass OOP in PHP generell etwas Pseudo-mäßig wirkt. Mit Objekten kann man ja nicht wirklich "arbeiten".


                Zitat von mermshaus Beitrag anzeigen
                Na ja, in deinem Code weist du auch den einzelnen Instanzvariablen ($this->xyz = ...) Werte zu (nichts anderes tun etwaige Methoden). Es spricht nichts dagegen, eine "Kapselmethode" mit etlichen Parametern zum einfachen Setzen vieler Eigenschaften anzubieten. Das ist aber im Prinzip nur eine andere Schreibweise derselben Funktionalität.
                Solange ich "nur" eine andere Schreibweise benütze, bin ich ja ausm Schneider?

                Zitat von agrajag Beitrag anzeigen
                Mal ganz abseits von Singleton oder nicht: Deine Variante finde ich persönlich extrem hässlich. Allein die vielen "initial"-Aufrufe, die vielen Paramter und die "magic numbers" machen irgendwie einen komischen Eindruck.
                Ob ich die initial Aufrufe versteckt im Programmcode habe oder am Ende in meiner Index-Datei - was ist wohl hässlicher? Abgesehen davon weiß ich mit den fünf Werten umzugehen. Und zur Not ein Comment, der die magic numbers erklärt. Also darin sehe ich jetzt kein Problem.


                Wie gesagt, ich will mir nicht vorstellen wie meine Index mit der "korrekten" OOP Methodik aussehen würde:

                PHP-Code:
                switch ($sec) {
                    case 
                'bonbons':
                        
                Menu::getInstance()->plotMenuCoupled($lang0$cat2'categories');
                        
                Content::getInstance()->getContentShop($cat);
                        break;
                    case 
                'information':
                        
                Menu::getInstance()->plotMenuCoupled($lang0$cat2'categories');
                        
                Content::getInstance()->getContentInformation($cat);
                        break;
                    case 
                'bestellen':
                        
                Menu::getInstance()->plotMenuCoupled($lang0$cat2'categories');
                        
                Order::getInstance()->getStep($step);    
                        break;        
                    case 
                'warenkorb':
                        
                Menu::getInstance()->plotMenuCoupled($lang0$cat2'categories');
                        
                SessionManagement::getCart()->templateFullCartOverview();
                        break;
                    default:
                        
                Content::getInstance()->getContentInformation('start');
                        break;

                wobei $sec = gefilterte $_GET. Für mich ist das als parallel arbeitender Webdesigner sehr ansprechend, durchsichtig und aufgeräumt.

                Kommentar


                • #23
                  Mit Objekten kann man ja nicht wirklich "arbeiten".
                  So ein rennender Unsinn. Ich weiß nicht, ob diese Aussage, dich qualifiziert, mit uns überhaupt über OOP zu reden.

                  Ob ich die initial Aufrufe versteckt im Programmcode habe oder am Ende in meiner Index-Datei - was ist wohl hässlicher?
                  Es geht nicht um häßlich, sondern dass Dein Code viele Abhängigkeiten erzeugt und damit
                  - schwer testbar
                  - schlecht wartbar
                  - schlecht bis gar nicht in anderen Kontexten nutzbar
                  ist.

                  Wie gesagt, ich will mir nicht vorstellen wie meine Index mit der "korrekten" OOP Methodik aussehen würde:
                  So, z.B.
                  PHP-Code:
                  $mainmenu->setActiveCategory (); // auto category 
                  oder so:
                  So, z.B.
                  PHP-Code:
                  $mainmenu->setActiveCategory ($controler->getParam('prodId')); // Controler-verwalteter Produkkontext 
                  [COLOR="#F5F5FF"]--[/COLOR]
                  [COLOR="Gray"][SIZE="6"][FONT="Georgia"][B]^^ O.O[/B][/FONT] [/SIZE]
                  „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                  [URL="http://www.php.de/javascript-ajax-und-mehr/107400-draggable-sorttable-setattribute.html#post788799"][B]Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“[/B][/URL][/COLOR]
                  [COLOR="#F5F5FF"]
                  --[/COLOR]

                  Kommentar


                  • #24
                    Zitat von Trainmaster Beitrag anzeigen
                    Pseudo hin oder her, der Programmcode wird dadurch enorm übersichtlich und ist einfacher zu handhaben. Abgesehen davon, dass OOP in PHP generell etwas Pseudo-mäßig wirkt. Mit Objekten kann man ja nicht wirklich "arbeiten".
                    Ich bezog mich da etwa auf den statischen (self::) Aufruf von initialPStmt in der Instanzmethode plotMenuCoupled.

                    Vermutlich könntest du dir bei deinem gedanklichen Ansatz die Klasseninstanz, also das Singleton, sparen und alle Methoden rein statisch aufrufen.

                    Code:
                    Menu::plotMenuCoupled(...);
                    Damit hast du dir dann im Prinzip mit der Klasse einen Namensraum für eine Reihe von globalen Funktionen und zugehörigen "globalen" (statischen) Variablen angelegt. Das ist aber in dem Sinne keine Objektorientierung.

                    Wie gesagt, du wirfst da meiner Meinung nach verschiedene Dinge in einen Topf und deshalb kommt dir dein Code etwas seltsam vor.

                    Eine Idee hier wäre es, statt

                    Code:
                    Menu::getInstance()->plotMenuCoupled($lang, 0, $cat, 2, 'categories');
                    einfach mal

                    Code:
                    $m = new Menu();
                    $m->plotMenuCoupled(...);
                    zu probieren.

                    Edit: Aussagen über den Einsatzzweck von Singletons sind arg theoretisch. Mir kommt da immer eine Regel in den Kopf, die ich so auch für ein oder zwei andere Dinge aufstellen würde: Diese "Muster" sind der "markierte" Fall. Wenn du nicht schlüssig begründen kannst, welches konkrete Problem du mit ihrem Einsatz löst, nutze sie nicht.

                    Kommentar


                    • #25
                      Zitat von nikosch Beitrag anzeigen
                      So ein rennender Unsinn. Ich weiß nicht, ob diese Aussage, dich qualifiziert, mit uns überhaupt über OOP zu reden.
                      Dann habe ich mich falsch ausgedrückt. Was ich damit meinte, ist, dass Objekte in PHP an sich "dumm" sind und nach Aufruf des Skriptes sie wieder alles vergessen. Bspw. im Gegensatz zu Java.

                      Zitat von nikosch Beitrag anzeigen
                      Es geht nicht um häßlich, sondern dass Dein Code viele Abhängigkeiten erzeugt und damit
                      - schwer testbar
                      - schlecht wartbar
                      - schlecht bis gar nicht in anderen Kontexten nutzbar
                      ist.
                      Es ist mir bewusst, dass ich einige Abhängigkeiten erzeuge und das ist auch so gewollt. Ein Menü, so wie ich es mir vorstelle, hat eben diese Abhängigkeiten. Keine mehr und keine weniger. Für meinen Zweck kann ich es so weit dynamisch einsetzen, dass es die Funktion als Menü in jeder Hinsicht erfüllt. Ich habe das Gefühl, dass mir eine strikte OOP Umsetzung aufgezwungen wird, obwohl es nicht von Nöten ist.

                      Zitat von nikosch Beitrag anzeigen
                      So, z.B.
                      ...
                      oder so:
                      So, z.B.
                      Deine Beispiele habe ich nicht übersehen, nochmals Dankeschön. Jedoch sehe ich nach wie vor keinen Grund/Vorteil darin, das Menü auf diese Weise generieren zu lassen.

                      Zitat von mermshaus Beitrag anzeigen
                      Vermutlich könntest du dir bei deinem gedanklichen Ansatz die Klasseninstanz, also das Singleton, sparen und alle Methoden rein statisch aufrufen.
                      Code:
                      Menu::plotMenuCoupled(...);
                      Soweit ich das auf die Schnelle überblicken konnte, führt es dazu, dass ich einigen Funktionen Variablen übergeben müsste.
                      Was ich mir allerdings sparen könnte, ist self::initialPStmt();. Die dort initialisierten Methoden kann ich direkt in plotMenuCoupled() schreiben. Führt ja zu dem gleichen Ergebnis.

                      Zitat von mermshaus Beitrag anzeigen
                      Wie gesagt, du wirfst da meiner Meinung nach verschiedene Dinge in einen Topf und deshalb kommt dir dein Code etwas seltsam vor.

                      Eine Idee hier wäre es, statt

                      Code:
                      Menu::getInstance()->plotMenuCoupled($lang, 0, $cat, 2, 'categories');
                      einfach mal

                      Code:
                      $m = new Menu();
                      $m->plotMenuCoupled(...);
                      zu probieren.
                      Wenn du den ersten Beitrag dieses Themas liest, wirst du feststellen, dass ich genau dies vorhatte. Irgendwie habe ich mich bisher dagegen gesträubt, auf diese Weise mein Menü in meiner Index aufzurufen.

                      Allerdings ist es wohl die bessere Lösung. Zwar eine Zeile mehr in der Index, dafür spare ich mir das unnötige Singleton-Muster in der Klasse.


                      Über den Einsatz von Singleton kann man wahrlich ausführlich diskutieren. Nach wie vor finde ich das Singleton-Muster bei einer Datenbank-Klasse unter gegebenen Umständen sinnvoll. Darüber hinaus bin ich der Meinung, dass das Singleton-Muster auf einen Bestellvorgang bzw. Checkout-process sinnvoll angewendet werden kann.

                      Kommentar


                      • #26
                        Zitat von Trainmaster Beitrag anzeigen
                        Über den Einsatz von Singleton kann man wahrlich ausführlich diskutieren. Nach wie vor finde ich das Singleton-Muster bei einer Datenbank-Klasse unter gegebenen Umständen sinnvoll. Darüber hinaus bin ich der Meinung, dass das Singleton-Muster auf einen Bestellvorgang bzw. Checkout-process sinnvoll angewendet werden kann.
                        DB-Klasse: sobald man mehr als eine Datenbank ansprechen will/muss ... ein problem
                        Und allgemein: Sobald man ein System mittels unittests testen will wird es auch unschön, genauso wie bei globalen variablen internen statischen variablen und soweiter

                        Zum Thema Code und dessen Testbarkeit (auch Singletons und so) ein gutes Video von Misko Hevery aus der Google Tech-Talk-Serie:

                        YouTube - "The Clean Code Talks -- Unit Testing"

                        Danach sieht man das ganze vielleicht etwas anders und versucht mehr sowas zu vermeiden.
                        [URL="http://www.robo47.net"]robo47.net[/URL] - Blog, Codeschnipsel und mehr
                        | :arrow: [URL="http://www.robo47.net/blog/192-Caching-Libraries-and-Opcode-Caches-in-php-An-Overview"]Caching-Klassen und Opcode Caches in php[/URL] | :arrow: [URL="http://www.robo47.net/components"]Robo47 Components - PHP Library extending Zend Framework[/URL]

                        Kommentar


                        • #27
                          Sehr gute Quelle, Robo. Der Teil hier: YouTube - The Clean Code Talks - Don't Look For Things! geht noch besser (auch mit Beispielen) auf DI ein.

                          Dann habe ich mich falsch ausgedrückt. Was ich damit meinte, ist, dass Objekte in PHP an sich "dumm" sind und nach Aufruf des Skriptes sie wieder alles vergessen.
                          Das ist zwar richtig, tut aber nichts zur Sache, weil das für jeglichen Code in PHP gilt. Entscheidend ist doch, dass man als Entwickler ein wartbares, verständliches und gut strukturiertes System schafft.
                          führt es dazu, dass ich einigen Funktionen Variablen übergeben müsste.
                          Was ich mir allerdings sparen könnte, ist self::initialPStmt();. Die dort initialisierten Methoden kann ich direkt in plotMenuCoupled() schreiben. Führt ja zu dem gleichen Ergebnis.
                          Wenn es Dir nur um die vielen Methodenaufrufe geht, würde ich dir raten, eine Factory o. ein spezialisiertes Menüobjekt zu verwenden. Ich persönlich findes es zu vernachlässigen, ob ich in der Index jetzt eine oder 3 Zeilen benötige, wenn dadurch das Funktionsprinzip deutlicher wird.

                          Trotzdem erfüllt Dein Ansatz kaum ein Kriterium für OO, plotMenuCoupled() könntest DU im Prinzip genauso als Funktion implementieren. Ein Objekt im Gegenzug hätte folgende Vorteile:
                          - Instanziierung jetzt, Ausgabe später (Dein Code macht quasi alles on the fly)
                          - Instanziierung einmal, Ausgabe mehrfach (Dein Code durchläuft immer den gesamten Prozess erneut)
                          - Instanziierung einmal, Ausgabe mehrfach auf unterschiedliche Weise (Dein Code ist statisch dadurch, dass Ausgabe und Parameterisierung an die gleiche Methode geknüpft sind)
                          - Klares Interface (Dein Code benutzt magic numers und lange Parameterketten)
                          usw.
                          [COLOR="#F5F5FF"]--[/COLOR]
                          [COLOR="Gray"][SIZE="6"][FONT="Georgia"][B]^^ O.O[/B][/FONT] [/SIZE]
                          „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                          [URL="http://www.php.de/javascript-ajax-und-mehr/107400-draggable-sorttable-setattribute.html#post788799"][B]Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“[/B][/URL][/COLOR]
                          [COLOR="#F5F5FF"]
                          --[/COLOR]

                          Kommentar


                          • #28
                            Singleton vs. Registry() vs. new Object() - Ich sehe den Wald vor lauter Bäumen nicht.
                            Um das noch mal auf zu greifen, eine Registry soll einfach nur gewährleisten, dass es von einem Objekt nur eine Instanz gibt. Damit ist einfach gemeint, das wenn ich
                            PHP-Code:
                            $menue Menue::getInstance()->plotMenueCoupled() 
                            das selbe Objekt zurück bekomme, und nicht etwas von irgendwelchen Parametern abhängiges. Das wiederspricht einfach einem Singelton. Denn dein "Singelton" ist nichts weiteres als ein Array.
                            Eine Registry ist aber in diesem Zusammenhang auch nicht mit einem Singelton zu vergleichen, da diese einfach nur Daten Projektübergreifend bereitstellt. Sie dient als globaler Datenspeicher.

                            Benutz doch einfach eine Factory, damit haste alle Probleme beseitigt und alle abhängigkeiten in eine Klasse gepackt.
                            Sowas in der Art, ist jetzt bisl hässlich, aber sollte halbwegs klar machen was ich meine.
                            PHP-Code:
                            class MenueFactory
                            {
                                public static function 
                            getMenue($lang$name)
                                {
                                    
                            $menue ucfirst(strtolower($name)) . ucfirst(strtolower($lang));
                                    return new 
                            $menue;
                                }
                            }

                            class 
                            SubmenueDe extends Abstract_Menue
                            {/* ... */}

                            class 
                            SubmenueEn extends Abstract_Menue
                            {/* ... */}

                            abstract class 
                            Abstract_Menue
                            {/* ... */}

                            $menue MenueFactory::getMenue('de''submenue');
                            $menue->plotMenueCoupled(); 
                            "My software never has bugs, it just develops random features."
                            "Real programmers don't comment. If it was hard to write, it should be hard to understand!"

                            Kommentar


                            • #29
                              PHP-Code:
                                      $menue ucfirst(strtolower($name)) . ucfirst(strtolower($lang)); 
                              Klassennamen sind nicht case-sensitiv.
                              [COLOR="#F5F5FF"]--[/COLOR]
                              [COLOR="Gray"][SIZE="6"][FONT="Georgia"][B]^^ O.O[/B][/FONT] [/SIZE]
                              „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                              [URL="http://www.php.de/javascript-ajax-und-mehr/107400-draggable-sorttable-setattribute.html#post788799"][B]Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“[/B][/URL][/COLOR]
                              [COLOR="#F5F5FF"]
                              --[/COLOR]

                              Kommentar


                              • #30
                                Zitat von nikosch Beitrag anzeigen
                                Klassennamen sind nicht case-sensitiv.
                                Aber autoloading auf einem unixoiden System ist es zumeist.
                                [URL="http://www.robo47.net"]robo47.net[/URL] - Blog, Codeschnipsel und mehr
                                | :arrow: [URL="http://www.robo47.net/blog/192-Caching-Libraries-and-Opcode-Caches-in-php-An-Overview"]Caching-Klassen und Opcode Caches in php[/URL] | :arrow: [URL="http://www.robo47.net/components"]Robo47 Components - PHP Library extending Zend Framework[/URL]

                                Kommentar

                                Lädt...
                                X