[solved] Error using dependency injection

You didn't show where you are using this code. There are two possibilities - you're using it statically, in a hook or a static class method, or you're using it in a non-static OOP method.

If you are in a hook or a static method, $this does not exist, so you will use:

$node = \Drupal::entityTypeManager()->getStorage('node')->load($nid);

However if you are working from within a non-static method of a class, $this will be available, and you will need dependency injection.

Dependency Injection

Any function declared in a class without the static keyword will have access to the $this object, and can use dependency injection. Setting up dependency injection requires three things:

1. Declaring the dependency, so it can be prepared and injected in the class when the class is instantiated into memory
2. Declaring a property, where the dependency will be stored for access from within the class using $this
3. Storing the injected dependency in the class property, when the class is instantiated into memory

1) Declare the dependency

Declaring dependencies is done in one of two ways, either in the [MODULE].services.yml file, for classes that are services, or in the create() method, for classes that are not services. In this example, the dependency to be injected is the entity_type.manager service, and one of the following methods will be used:

1A) Declaring a dependency for a service:

This is done in the arguments of the[MODULE].services.yml file:

services:
  example_service:
    class: Drupal\example\Service\ExampleServiceInterface
    arguments:
      - '@entity_type.manager`

The Drupal registry needs to be cleared after declaring services, as they are cached and will only be picked up after a cache clear.

1B) Declaring a dependency for a class that is not a service

This is done in the create() method of the class:

use Symfony\Component\DependencyInjection\ContainerInterface;

/**
 * {@inheritdoc}
 */
public static function create(ContainerInterface $container) {
  return new static(
    $container->get('entity_type.manager')
  );
}

2) Create a property to hold the injected dependency

Next, a property is declared that will store the injected dependency:

/**
 * The entity type manager.
 *
 * @var \Drupal\Core\Entity\EntityTypeManagerInterface
 */
protected $entityTypeManagerProperty;

This sets up $this->entityTypeManagerProperty for the class. However, at this point, the value of the property is NULL, as it has only been declared, with no value yet assigned to it. That will happen in step 3.

As an aside, I would usually call the property $entityTypeManager, however for the purposes of clarity for this tutorial, I am using $entityTypeManagerProperty to visibly differentiate from the injected dependency which I will call $entityTypeManagerInjected in the next step. In a normal class, I would name both the property and the injected dependency $entityTypeManager. This makes for clarity and consistency day-to-day coding, but makes it harder to differentiate what the differences are when learning, which is why I've used these names in this example.

3) Store the injected dependency in the class property when the class is loaded

Finally, the injected dependency is set as the value of the property, when the class is loaded. This is done in the __construct() method of the class, which is a "magic" method called every time this class is instantiated into memory (aka NOT called statically);

/**
 * Constructs a [CLASS NAME] instance.
 *
 * @property \Drupal\Core\Entity\EntityTypeManagerInterface $entityTypeManagerInjected
 *   The injected entity type manager.
 */
public function __construct(EntityTypeManagerInterface $entityTypeManagerInjected) {
  // Store the injected dependency in the property defined earlier.
  $this->entityTypeManagerProperty = $entityTypeManagerInjected;
}

Using the injected dependency

Now that the dependency has been injected $this->entityTypeManagerProperty contains the injected dependency, and can be used in any non-static method in the class as follows:

$node = $this->entityTypeManagerProperty->getStorage('node')->load($nid);

1. A declaration of the dependency, so it can be retrieved when the class is loaded
2. A property to store the injected dependency, so that that the dependency can be called from $this
3. Storing the injected dependency in the property when the class is loaded

The Call to a member function getStorage() on null in Drupal\mymodule\Controller\MyModuleController->mymethod() error is correct, since the code is using a property ($this->entityTypeManager) that has not been yet set. ControllerBase::entityTypeManager() sets ControllerBase::$entityTypeManager to the correct value.

protected function entityTypeManager() {
  if (!isset($this->entityTypeManager)) {
    $this->entityTypeManager = $this->container()->get('entity_type.manager');
  }
  return $this->entityTypeManager;
}

The correct way to get the entity type manager is calling the method, not accessing the property.

For procedural code, or for static methods, the following line loads the node whose ID is 1.

$entity = \Drupal::entityTypeManager()->getStorage('node')->load(1);

For a non-static method implemented in a class that extends ControllerBase, the line to use is the following one.

$entity = $this->entityTypeManager()->getStorage('node')->load(1);

Your post (@Gisle) and the tutorial and comments in this thread are very timely, at least for me.  I'm a "trainee" maintainer for the contrib Juicebox module (and believe me I would happily leave the work to more experienced Drupal programmers if such could be found) and have been beating my head about one remaining PHPCS warning re. Dependency Injection.  I've been trying to model my solution around other contrib modules that avoid the dependency injection warning as well as one of the core modules that uses the same service I'm trying to use but avoids the warnings.  The thread where this is discusssed is:

https://www.drupal.org/project/juicebox/issues/3359786

I'm burned out from hacking at this for an hour this morning but will return to this Forum thread to see if there is a solution in it for my situation.  Anyone who has the patience to contribute insights to the thread linked above is welcome to do so meanwhile.  

There was also a long Forum thread over in Slack re. dependency injection that didn't yield any obvious solutions to my problem.  

I'm sure that using dependency injection is the preferred technical approach but it sure seems a long way around just including some code that would generate an "absolute string" version of a url.  That said, it has to be done, I know.