Question: I've got an interface, implementation, and target:

```
public interface IPerson { public string Name { get; } }
public class Person: IPerson { public string Name { get { return "John"; } } }
public class Target { public Target(IPerson person) {} }

```

I'm using Autofac to tie things together:

```
builder.RegisterType<Person>().As<IPerson>().SingleInstance();

```

The problem is that `IPerson` lives in a shared assembly, `Person` lives in a plugin (which may or may not be there), and `Target` lives in the main application that loads plugins. If there are no plugins loaded that implement `IPerson`, Autofac goes ballistic about not being able to resolve `Target`'s dependencies. And I cannot really blame it for that.

However I know that `Target` is able to handle the lack of an `IPerson` and would be more than happy to get a `null` instead. In fact, I'm pretty sure that all the components which rely on an `IPerson` are prepared to take a `null` it its stead. So how can I tell Autofac - "It's OK sweety, don't worry, just give me back a `null`, alright?"

One way I found is to add a default parameter to `Target`:

```
public class Target { public Target(IPerson person = null) {} }

```

That works, but then I need to do this for all the components that require an `IPerson`. Can I also do it the other way round? Somehow tell Autofac "If all else fails for resolving `IPerson`, return null"?

Answer: 
Just use optional parameters, see the following sample:

```
public class SomeClass
{
     public SomeClass(ISomeDependency someDependency = null)
     {
           // someDependency will be null in case you've not registered that before, and will be filled whenever you register that.
     }
}

```
You *could* just take your dependency on `IPerson person = null` in your constructor, which is an implicit declaration of an optional `IPerson` dependency (c.f. @YaserMoradi). However, that puts you in the position of having to solidify this, now and forever after:

> 
> "... I'm pretty sure that all the components which rely on an `IPerson` are prepared to take a `null` it its stead."
> 
> 
> 

Better that this doesn't have to be a question at all.

The "[best practice](http://docs.autofac.org/en/latest/best-practices/)" pattern (which @CyrilDurand gives as a suffix on his answer) for this is to use a [default implementation](http://docs.autofac.org/en/latest/register/registration.html#default-registrations) (link upshot: Autofac will use the last registered component as the default provider of that service). If you have no other implementation coming from your plugin (registered after the default) this default will be used.

In your case, the default component should be some kind of no-op or base implementation of the `IPerson` service, where any method called will have whatever constitutes the default behavior for your application. This gives a better reuse story as well, since you can define the default behavior once and for all.