PHP Class Dependency Injection Failure

Your "container" is trying to instantiate the contained objects when the setClassHandlers method is run, and by that time not all its properties might be set.

Also, your container is not "lazy" enough. is trying to instantiate everything right now, even if it might not be needed.

Try the following

First, remove these lines:

    // Set class        // class.container.php
    self::$class[$name] = new $name(new self);
    $this->{$name} = self::$class[$name];

Then, add a private array services to your Container class:

private $services = [];

And finally, add a magic getter to your container:

function __get($service)
    {
        if ( ! isset($this->services[$service]) ) {
            $this->services[$service] = new $service();
        }

        return $this->services[$service];
    }

Again, learning about this is great, but I would advise you take a look at some other implementations to learn from them. Pimple's is great, very simple, and easy to follow.

Here we are injecting the container on all your objects instead of the object concrete dependencies, which is generally (an rightly) frowned up upon. But I don't want to introduce more modifications to your design, is better that you learn those by yourself.

On top of that, your container is also handling what would be better handled by an autoloader, and mixing responsibilities.

Also, as I said in the comments, you are reinventing the __DIR__ constant, which already exists in PHP. You are using

define( 'DIR', dirname(__FILE__) . '/' );

which is pretty much equivalent to __DIR__ (Or, more precisely, to __DIR__ . '/').

Finally, most of your troubles are caused by circular dependencies, which your container (nor any container) can't fix. A depends on B which depends on A. The only way you could get around that is by using a setter to inject your dependencies.

A simpler implementation, more or less following your code:

For autoloading:

function autoload_so($class)
{
    $file = __DIR__ . "/app/classes/class." . strtolower($class) . '.php';
    if (file_exists($file)) {
        include_once($file);

        return true;
    }

    return false;
}

spl_autoload_register('autoload_so');

I'm not using namespaces, and I disregarded your interface logic. Which was a bit weird as well. You'll need to implement your own loading for interfaces, you should be able to do so.

For the container:

class MyContainer
{
    public $services = [];

    function __get($service)
    {
        if ( ! isset($this->services[$service]) ) {
            $this->services[$service] = call_user_func([$this, "get_$service"]);
        }

        return $this->services[$service];
    }

    /**
     * @return Users
     */
    private function get_Users()
    {
        return new Users($this->Database, $this->Core);
    }

    /**
     * @return Core
     */
    private function get_Core()
    {
        return new Core();
    }

    /**
     * @return Database
     */
    private function get_Database()
    {
        return new Database($this->Core);
    }

}

Notice that

• You'll need a new method for each new "service" you want to add.
• I'm injecting the dependencies directly in the constructor

Finally your classes would be something like:

Database

<?php

class Database
{
    public function __construct(Core $core)
    {
        $this->core  = $core;
    }
}

Users

class Users
{
    public $ip;

    public function __construct(Database $db, Core $core)
    {
        $this->db   = $db;
        $this->core = $core;
        $this->ip   = $this->core->userIP();
    }

}

etc.

Again, this is all very crude. I would use namespaces and a more general autoloader and directory structure.

All this should be enough for a starting point for you to build your own.

But no container will magically fix your circular dependencies for you.