diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3b3613d0..473e8c20 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 - Updated `interfaces.NextArgs` with optional `isOptional` param.
+- Updated `container` with `tryGet`.
+- Updated `container` with `tryGetAsync`.
+- Updated `container` with `tryGetTagged`.
+- Updated `container` with `tryGetTaggedAsync`.
+- Updated `container` with `tryGetNamed`.
+- Updated `container` with `tryGetNamedAsync`.
+- Updated `container` with `tryGetAll`.
+- Updated `container` with `tryGetAllAsync`.
+- Updated `container` with `tryGetAllTagged`.
+- Updated `container` with `tryGetAllTaggedAsync`.
+- Updated `container` with `tryGetAllNamed`.
+- Updated `container` with `tryGetAllNamedAsync`.
 
 ### Fixed
 
diff --git a/src/container/container.ts b/src/container/container.ts
index a45a06b4..689bdcc4 100644
--- a/src/container/container.ts
+++ b/src/container/container.ts
@@ -390,7 +390,11 @@ class Container implements interfaces.Container {
   // The runtime identifier must be associated with only one binding
   // use getAll when the runtime identifier is associated with multiple bindings
   public get<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T {
-    const getArgs: GetArgs<T> = this._getNotAllArgs(serviceIdentifier, false);
+    const getArgs: GetArgs<T> = this._getNotAllArgs(
+      serviceIdentifier,
+      false,
+      false,
+    );
 
     return this._getButThrowIfAsync<T>(getArgs) as T;
   }
@@ -398,7 +402,11 @@ class Container implements interfaces.Container {
   public async getAsync<T>(
     serviceIdentifier: interfaces.ServiceIdentifier<T>,
   ): Promise<T> {
-    const getArgs: GetArgs<T> = this._getNotAllArgs(serviceIdentifier, false);
+    const getArgs: GetArgs<T> = this._getNotAllArgs(
+      serviceIdentifier,
+      false,
+      false,
+    );
 
     return this._get<T>(getArgs) as Promise<T> | T;
   }
@@ -411,6 +419,7 @@ class Container implements interfaces.Container {
     const getArgs: GetArgs<T> = this._getNotAllArgs(
       serviceIdentifier,
       false,
+      false,
       key,
       value,
     );
@@ -426,6 +435,7 @@ class Container implements interfaces.Container {
     const getArgs: GetArgs<T> = this._getNotAllArgs(
       serviceIdentifier,
       false,
+      false,
       key,
       value,
     );
@@ -457,7 +467,11 @@ class Container implements interfaces.Container {
     serviceIdentifier: interfaces.ServiceIdentifier<T>,
     options?: interfaces.GetAllOptions,
   ): T[] {
-    const getArgs: GetArgs<T> = this._getAllArgs(serviceIdentifier, options);
+    const getArgs: GetArgs<T> = this._getAllArgs(
+      serviceIdentifier,
+      options,
+      false,
+    );
 
     return this._getButThrowIfAsync<T>(getArgs) as T[];
   }
@@ -466,7 +480,11 @@ class Container implements interfaces.Container {
     serviceIdentifier: interfaces.ServiceIdentifier<T>,
     options?: interfaces.GetAllOptions,
   ): Promise<T[]> {
-    const getArgs: GetArgs<T> = this._getAllArgs(serviceIdentifier, options);
+    const getArgs: GetArgs<T> = this._getAllArgs(
+      serviceIdentifier,
+      options,
+      false,
+    );
 
     return this._getAll(getArgs);
   }
@@ -479,6 +497,7 @@ class Container implements interfaces.Container {
     const getArgs: GetArgs<T> = this._getNotAllArgs(
       serviceIdentifier,
       true,
+      false,
       key,
       value,
     );
@@ -494,6 +513,7 @@ class Container implements interfaces.Container {
     const getArgs: GetArgs<T> = this._getNotAllArgs(
       serviceIdentifier,
       true,
+      false,
       key,
       value,
     );
@@ -535,6 +555,164 @@ class Container implements interfaces.Container {
     return resolved;
   }
 
+  public tryGet<T>(
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+  ): T | undefined {
+    const getArgs: GetArgs<T> = this._getNotAllArgs(
+      serviceIdentifier,
+      false,
+      true,
+    );
+
+    return this._getButThrowIfAsync<T>(getArgs) as T | undefined;
+  }
+
+  public async tryGetAsync<T>(
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+  ): Promise<T | undefined> {
+    const getArgs: GetArgs<T> = this._getNotAllArgs(
+      serviceIdentifier,
+      false,
+      true,
+    );
+
+    return this._get<T>(getArgs) as Promise<T> | T | undefined;
+  }
+
+  public tryGetTagged<T>(
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    key: string | number | symbol,
+    value: unknown,
+  ): T | undefined {
+    const getArgs: GetArgs<T> = this._getNotAllArgs(
+      serviceIdentifier,
+      false,
+      true,
+      key,
+      value,
+    );
+
+    return this._getButThrowIfAsync<T>(getArgs) as T | undefined;
+  }
+
+  public async tryGetTaggedAsync<T>(
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    key: string | number | symbol,
+    value: unknown,
+  ): Promise<T | undefined> {
+    const getArgs: GetArgs<T> = this._getNotAllArgs(
+      serviceIdentifier,
+      false,
+      true,
+      key,
+      value,
+    );
+
+    return this._get<T>(getArgs) as Promise<T> | T | undefined;
+  }
+
+  public tryGetNamed<T>(
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    named: string | number | symbol,
+  ): T | undefined {
+    return this.tryGetTagged<T>(
+      serviceIdentifier,
+      METADATA_KEY.NAMED_TAG,
+      named,
+    );
+  }
+
+  public async tryGetNamedAsync<T>(
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    named: string | number | symbol,
+  ): Promise<T | undefined> {
+    return this.tryGetTaggedAsync<T>(
+      serviceIdentifier,
+      METADATA_KEY.NAMED_TAG,
+      named,
+    );
+  }
+
+  public tryGetAll<T>(
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    options?: interfaces.GetAllOptions,
+  ): T[] {
+    const getArgs: GetArgs<T> = this._getAllArgs(
+      serviceIdentifier,
+      options,
+      true,
+    );
+
+    return this._getButThrowIfAsync<T>(getArgs) as T[];
+  }
+
+  public async tryGetAllAsync<T>(
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    options?: interfaces.GetAllOptions,
+  ): Promise<T[]> {
+    const getArgs: GetArgs<T> = this._getAllArgs(
+      serviceIdentifier,
+      options,
+      true,
+    );
+
+    return this._getAll(getArgs);
+  }
+
+  public tryGetAllTagged<T>(
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    key: string | number | symbol,
+    value: unknown,
+  ): T[] {
+    const getArgs: GetArgs<T> = this._getNotAllArgs(
+      serviceIdentifier,
+      true,
+      true,
+      key,
+      value,
+    );
+
+    return this._getButThrowIfAsync<T>(getArgs) as T[];
+  }
+
+  public async tryGetAllTaggedAsync<T>(
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    key: string | number | symbol,
+    value: unknown,
+  ): Promise<T[]> {
+    const getArgs: GetArgs<T> = this._getNotAllArgs(
+      serviceIdentifier,
+      true,
+      true,
+      key,
+      value,
+    );
+
+    return this._getAll(getArgs);
+  }
+
+  public tryGetAllNamed<T>(
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    named: string | number | symbol,
+  ): T[] {
+    return this.tryGetAllTagged<T>(
+      serviceIdentifier,
+      METADATA_KEY.NAMED_TAG,
+      named,
+    );
+  }
+
+  public async tryGetAllNamedAsync<T>(
+    serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    named: string | number | symbol,
+  ): Promise<T[]> {
+    return this.tryGetAllTaggedAsync<T>(
+      serviceIdentifier,
+      METADATA_KEY.NAMED_TAG,
+      named,
+    );
+  }
+
   private _preDestroy(
     constructor: NewableFunction | undefined,
     instance: unknown,
@@ -828,23 +1006,25 @@ class Container implements interfaces.Container {
     return this._planAndResolve<T>()(planAndResolveArgs);
   }
 
-  private _getButThrowIfAsync<T>(getArgs: GetArgs<T>): T | T[] {
+  private _getButThrowIfAsync<T>(getArgs: GetArgs<T>): undefined | T | T[] {
     const result: interfaces.ContainerResolution<T> = this._get<T>(getArgs);
 
     if (isPromiseOrContainsPromise<T>(result)) {
       throw new Error(ERROR_MSGS.LAZY_IN_SYNC(getArgs.serviceIdentifier));
     }
 
-    return result as T | T[];
+    return result as undefined | T | T[];
   }
 
   private _getAllArgs<T>(
     serviceIdentifier: interfaces.ServiceIdentifier<T>,
     options: interfaces.GetAllOptions | undefined,
+    isOptional: boolean,
   ): GetArgs<T> {
     const getAllArgs: GetArgs<T> = {
       avoidConstraints: !(options?.enforceBindingConstraints ?? false),
       isMultiInject: true,
+      isOptional,
       serviceIdentifier,
     };
 
@@ -854,12 +1034,14 @@ class Container implements interfaces.Container {
   private _getNotAllArgs<T>(
     serviceIdentifier: interfaces.ServiceIdentifier<T>,
     isMultiInject: boolean,
+    isOptional: boolean,
     key?: string | number | symbol | undefined,
     value?: unknown,
   ): GetArgs<T> {
     const getNotAllArgs: GetArgs<T> = {
       avoidConstraints: false,
       isMultiInject,
+      isOptional,
       key,
       serviceIdentifier,
       value,
diff --git a/src/interfaces/interfaces.ts b/src/interfaces/interfaces.ts
index 7f640c1c..2f2c27a1 100644
--- a/src/interfaces/interfaces.ts
+++ b/src/interfaces/interfaces.ts
@@ -10,7 +10,11 @@ import {
 // eslint-disable-next-line @typescript-eslint/no-namespace
 namespace interfaces {
   export type DynamicValue<T> = (context: interfaces.Context) => T | Promise<T>;
-  export type ContainerResolution<T> = T | Promise<T> | (T | Promise<T>)[];
+  export type ContainerResolution<T> =
+    | undefined
+    | T
+    | Promise<T>
+    | (T | Promise<T>)[];
 
   type AsyncCallback<TCallback> = TCallback extends (
     ...args: infer TArgs
@@ -301,6 +305,56 @@ namespace interfaces {
       onDeactivation: BindingDeactivation<T>,
     ): void;
     resolve<T>(constructorFunction: interfaces.Newable<T>): T;
+    tryGet<T>(
+      serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    ): T | undefined;
+    tryGetAsync<T>(
+      serviceIdentifier: interfaces.ServiceIdentifier<T>,
+    ): Promise<T | undefined>;
+    tryGetTagged<T>(
+      serviceIdentifier: interfaces.ServiceIdentifier<T>,
+      key: string | number | symbol,
+      value: unknown,
+    ): T | undefined;
+    tryGetTaggedAsync<T>(
+      serviceIdentifier: interfaces.ServiceIdentifier<T>,
+      key: string | number | symbol,
+      value: unknown,
+    ): Promise<T | undefined>;
+    tryGetNamed<T>(
+      serviceIdentifier: interfaces.ServiceIdentifier<T>,
+      named: string | number | symbol,
+    ): T | undefined;
+    tryGetNamedAsync<T>(
+      serviceIdentifier: interfaces.ServiceIdentifier<T>,
+      named: string | number | symbol,
+    ): Promise<T | undefined>;
+    tryGetAll<T>(
+      serviceIdentifier: interfaces.ServiceIdentifier<T>,
+      options?: interfaces.GetAllOptions,
+    ): T[];
+    tryGetAllAsync<T>(
+      serviceIdentifier: interfaces.ServiceIdentifier<T>,
+      options?: interfaces.GetAllOptions,
+    ): Promise<T[]>;
+    tryGetAllTagged<T>(
+      serviceIdentifier: interfaces.ServiceIdentifier<T>,
+      key: string | number | symbol,
+      value: unknown,
+    ): T[];
+    tryGetAllTaggedAsync<T>(
+      serviceIdentifier: interfaces.ServiceIdentifier<T>,
+      key: string | number | symbol,
+      value: unknown,
+    ): Promise<T[]>;
+    tryGetAllNamed<T>(
+      serviceIdentifier: interfaces.ServiceIdentifier<T>,
+      named: string | number | symbol,
+    ): T[];
+    tryGetAllNamedAsync<T>(
+      serviceIdentifier: interfaces.ServiceIdentifier<T>,
+      named: string | number | symbol,
+    ): Promise<T[]>;
     load(...modules: ContainerModule[]): void;
     loadAsync(...modules: AsyncContainerModule[]): Promise<void>;
     unload(...modules: ContainerModuleBase[]): void;
diff --git a/src/test/container/container.test.ts b/src/test/container/container.test.ts
index 4e7f109d..2a9e95d9 100644
--- a/src/test/container/container.test.ts
+++ b/src/test/container/container.test.ts
@@ -580,6 +580,37 @@ describe('Container', () => {
     expect(es[1]?.goodbye).to.equal('adios');
   });
 
+  it('Should be able to resolve optional injection', async () => {
+    const container: Container = new Container();
+
+    const serviceIdentifier: string = 'service-id';
+
+    expect(container.tryGet(serviceIdentifier)).to.eq(undefined);
+    expect(container.tryGetAll(serviceIdentifier)).to.deep.eq([]);
+    expect(await container.tryGetAllAsync(serviceIdentifier)).to.deep.eq([]);
+    expect(container.tryGetAllNamed(serviceIdentifier, 'name')).to.deep.eq([]);
+    expect(
+      await container.tryGetAllNamedAsync(serviceIdentifier, 'name'),
+    ).to.deep.eq([]);
+    expect(
+      container.tryGetAllTagged(serviceIdentifier, 'tag', 'value'),
+    ).to.deep.eq([]);
+    expect(
+      await container.tryGetAllTaggedAsync(serviceIdentifier, 'tag', 'value'),
+    ).to.deep.eq([]);
+    expect(await container.tryGetAsync(serviceIdentifier)).to.eq(undefined);
+    expect(container.tryGetNamed(serviceIdentifier, 'name')).to.eq(undefined);
+    expect(await container.tryGetNamedAsync(serviceIdentifier, 'name')).to.eq(
+      undefined,
+    );
+    expect(container.tryGetTagged(serviceIdentifier, 'tag', 'value')).to.eq(
+      undefined,
+    );
+    expect(
+      await container.tryGetTaggedAsync(serviceIdentifier, 'tag', 'value'),
+    ).to.eq(undefined);
+  });
+
   it('Should be able configure the default scope at a global level', () => {
     interface Warrior {
       health: number;
diff --git a/wiki/container_api.md b/wiki/container_api.md
index 251861e8..105d985b 100644
--- a/wiki/container_api.md
+++ b/wiki/container_api.md
@@ -127,6 +127,7 @@ An advanced feature that can be used for cross cutting concerns. See [middleware
 ## container.createChild(containerOptions?: interfaces.ContainerOptions): Container;
 
 Create a [container hierarchy ](https://github.com/inversify/InversifyJS/blob/master/wiki/hierarchical_di.md).  If you do not provide options the child receives the options of the parent.
+
 ## container.get\<T>(serviceIdentifier: interfaces.ServiceIdentifier\<T>): T
 
 Resolves a dependency by its runtime identifier. The runtime identifier must be associated with only one binding and the binding must be synchronously resolved, otherwise an error is thrown:
@@ -585,6 +586,55 @@ Restore container state to last snapshot.
 ## container.snapshot(): void
 
 Save the state of the container to be later restored with the restore method.
+
+## container.tryGet\<T>(serviceIdentifier: interfaces.ServiceIdentifier\<T>): T | undefined
+
+Same as `container.get`, but returns `undefined` in the event no bindings are bound to `serviceIdentifier`.
+
+## container.tryGetAsync\<T>(serviceIdentifier: interfaces.ServiceIdentifier\<T>): Promise<T | undefined>
+
+Same as `container.getAsync`, but returns `Promise<undefined>` in the event no bindings are bound to `serviceIdentifier`.
+
+## container.tryGetNamed\<T>(serviceIdentifier: interfaces.ServiceIdentifier\<T>, named: string | number | symbol): T | undefined
+
+Same as `container.getNamed`, but returns `undefined` in the event no bindings are bound to `serviceIdentifier`.
+
+## container.tryGetNamedAsync\<T>(serviceIdentifier: interfaces.ServiceIdentifier\<T>, named: string | number | symbol): Promise\<T | undefined>
+
+Same as `container.getNamedAsync`, but returns `Promise<undefined>` in the event no bindings are bound to `serviceIdentifier`.
+
+## container.tryGetTagged\<T>(serviceIdentifier: interfaces.ServiceIdentifier\<T>, key: string | number | symbol, value: unknown): T | undefined
+
+Same as `container.getTagged`, but returns `undefined` in the event no bindings are bound to `serviceIdentifier`.
+
+## container.tryGetTaggedAsync\<T>(serviceIdentifier: interfaces.ServiceIdentifier\<T>, key: string | number | symbol, value: unknown): Promise\<T | undefined>
+
+Same as `container.getTaggedAsync`, but returns `Promise<undefined>` in the event no bindings are bound to `serviceIdentifier`.
+
+## container.tryGetAll\<T>(serviceIdentifier: interfaces.ServiceIdentifier\<T>, options?: interfaces.GetAllOptions): T[]
+
+Same as `container.getAll`, but returns `[]` in the event no bindings are bound to `serviceIdentifier`.
+
+## container.tryGetAllAsync\<T>(serviceIdentifier: interfaces.ServiceIdentifier\<T>, options?: interfaces.GetAllOptions): Promise\<T[]>
+
+Same as `container.getAllAsync`, but returns `Promise<[]>` in the event no bindings are bound to `serviceIdentifier`.
+
+## container.tryGetAllNamed\<T>(serviceIdentifier: interfaces.ServiceIdentifier\<T>, named: string | number | symbol): T[]
+
+Same as `container.getAllNamed`, but returns `[]` in the event no bindings are bound to `serviceIdentifier`.
+
+## container.tryGetAllNamedAsync\<T>(serviceIdentifier: interfaces.ServiceIdentifier\<T>, named: string | number | symbol): Promise\<T[]>
+
+Same as `container.getAllNamedAsync`, but returns `Promise<[]>` in the event no bindings are bound to `serviceIdentifier`.
+
+## container.tryGetAllTagged\<T>(serviceIdentifier: interfaces.ServiceIdentifier\<T>, key: string | number | symbol, value: unknown): T[]
+
+Same as `container.getAllTagged`, but returns `[]` in the event no bindings are bound to `serviceIdentifier`.
+
+## container.tryGetAllTaggedAsync\<T>(serviceIdentifier: interfaces.ServiceIdentifier\<T>, key: string | number | symbol, value: unknown): Promise\<T[]>
+
+Same as `container.getAllTaggedAsync`, but returns `Promise<[]>` in the event no bindings are bound to `serviceIdentifier`.
+
 ## container.unbind(serviceIdentifier: interfaces.ServiceIdentifier\<unknown>): void
 
 Remove all bindings binded in this container to the service identifier.  This will result in the [deactivation process](https://github.com/inversify/InversifyJS/blob/master/wiki/deactivation_handler.md).