When loading a configuration file, Symfony loads first the imported files and

then it processes the parameters and services defined in the file. If you use the

:ref:`default services.yaml configuration<service-container-services-load-example>`

as in the above example, the ``App\`` definition creates services for classes

found in ``../src/*``. If your imported file defines services for those classes

too, they will be overridden.

There are exactly three possible solutions in order services not to get overriden:

1. Include the file with ``App\`` statement in the ``imports`` as the first element.

In order to the fact that the ``imports`` statement not override existing services, it checks if the services exists,

also take into account that the last element of the ``imports`` has the highest priority and will be executed first,

having included ``App\`` as a first element of ``imports`` (with the lowest priority) it will be imported in the end.

And being the last import element it will only add not existing services in the container.

2. Include the path to the service in the ``exclude`` section.

3. Write service definitions down the ``App\`` statement to override it

It's recommended to use the 1st approach to define services in the container

Using the first approach the whole ``services.yaml`` file will look the foolowing way:

When loading a configuration file, Symfony first processes all imported files in

the order they are listed under the ``imports`` key. After all imports are processed,

it then processes the parameters and services defined directly in the current file.

In practice, this means that **later definitions override earlier ones**.

For example, if you use the:ref:`default services.yaml configuration<service-container-services-load-example>`

as in the above example, your main ``config/services.yaml`` file uses the ``App\``

namespace to auto-discover services and loads them after all imported files.

If an imported file (e.g. ``config/services/mailer.yaml``) defines a service that

is also auto-discovered, the definition from ``services.yaml`` will take precedence.

To make sure your specific service definitions are not overridden by auto-discovery,

consider one of the following strategies:

#.:ref:`Exclude services from auto-discovery<import-exclude-services-from-auto-discovery>`

#.:ref:`Override services in the same file<import-override-services-in-the-same-file>`

#.:ref:`Control import order<import-control-import-order>`

.. _import-exclude-services-from-auto-discovery:

**Exclude services from auto-discovery**

Adjust the ``App\`` definition to use the ``exclude`` option. This prevents Symfony

from auto-registering classes that are defined manually elsewhere:

..configuration-block::

..code-block::yaml

.. _import-override-services-in-the-same-file:

**Override services in the same file**

You can define specific services after the ``App\`` auto-discovery block in the

same file. These later definitions will override the auto-registered ones:

..configuration-block::

..code-block::yaml

.. _import-control-import-order:

**Control import order**

Move the ``App\`` auto-discovery config to a separate file and import it

before more specific service files. This way, specific service definitions

can override the auto-discovered ones.

..configuration-block::

..code-block::yaml

###> imports are loaded first (imports not overrides existing services) ###

imports:

- resource: 'services_yaml/resource_services.yaml' # PRIORITY 1 (last) (contains App\with resource statement)

- resource: 'services_yaml/services/' # PRIORITY 2

- resource: 'services_yaml/parameters/' # PRIORITY 3 (first)

###> then services.yaml (what below overrides imports) ###

###>... it's better to use only imports

..code-block::xml

..code-block::php

..include::/components/dependency_injection/_imports-parameters-note.rst.inc