Registering Components

Question 1

What is the rule for choosing constructors?

Answer 1

Autofac automatically uses the constructor for your class with the most parameters that are able to be obtained from the container.

Question 2

If you have:

var builder = new ContainerBuilder(); builder.RegisterType();

What can you say about MyComponent?

Answer 2

It must be a concrete type.

Question 3

Can you register an abstract/ interface component?

Answer 3

No. There must be an associated concrete class - even if it is created on the fly through a lambda.

Question 4

You can manually choose a particular constructor to use and override the automatic choice by registering your component with …?

Answer 4

With the UsingConstructor method and a list of types representing the parameter types in the constructor:

Example:

builder.RegisterType()

.UsingConstructor(typeof(ILogger), typeof(IConfigReader));

Question 5

When can you pass parameters?

Answer 5

At registration time or resolve time.

Question 6

Why can’t you use RegisterType for abstract / interface components?

Answer 6

You can’t “new up” an abstract or interface component.

Question 7

What is the statement for RegisterType

Answer 7

builder.RegisterType()
.UsingConstructor(typeof(ILogger), typeof(IConfigReader));

Question 8

How do you pre-generate an instance of an object and add it to the container for use by registered components?

Answer 8

var output = new StringWriter();
builder.**RegisterInstance**(output).As

Question 9

How can you remove a static singleton by placing it in a container?

Answer 9

builder.RegisterInstance(MySingleton.Instance).ExternallyOwned();

Question 10

Show how to use a lambda expression to Register an instance of a concrete class resolved from an interface.

Answer 10

builder.Register(c => new ClassB(c.Resolve()));

“c” is the component context in which the component is created and is an IComponentContext object.

Question 11

Use lambda express to create complex parameter of DateTime.Now.AddMinutes(5) for UserSession.

Answer 11

builder.Register(c => new UserSession(DateTime.Now.AddMinutes(25)));

Question 12

What are the three types of parameter injection?

Answer 12

NAMED: .WithParameter(“configSectionName”, “sectionName”);

TYPED: .WithParameter(new TypedParameter(typeof(string), “sectionName”));

RESOLVED: .WithParameter(
new ResolvedParameter(
(pi, ctx) => pi.ParameterType == typeof(string)
&& pi.Name == “configSectionName”,
(pi, ctx) => “sectionName”));

Question 13

Define the three types of parameter injection.

Answer 13

NamedParameter: match target parameters by name

TypedParameter: match target parameters by type (exact type match required)

ResolvedParameter: flexible parameter matching

Question 14

Why are resolved parameters different from named and type parameters?

Answer 14

Resolved parameters can be used as a way to supply values dynamically retrieved from the container, e.g. by resolving a service by name, whereas Named and Typed parameters can only supply constant values.

Question 15

How would you register an instance of:

public class ConfigReader : IConfigReader
{
 public ConfigReader(string configSectionName)
 {

// Store config section name

}
 // ...read configuration based on the section name.
}

Answer 15

builder.Register(c => new ConfigReader(“sectionName”)).As();

Question 16

With lambda expression components, do you pass parameter values at registration time or at service resolution time? Example?

Answer 16

// Use TWO parameters to the registration delegate:
// c = The current IComponentContext to dynamically resolve dependencies
// p = An IEnumerable with the incoming parameter set builder.Register((c, p) =\>
 new ConfigReader(p.Named("configSectionName")))
 .As();

RESOLVE:

var reader = scope.Resolve(new NamedParameter(“configSectionName”, “sectionName”));

Question 17

What is Property Injection?

Answer 17

Property injection uses writeable properties rather than constructor parameters to perform injection.

Question 18

What is Method Injection?

Answer 18

Method injection sets dependencies by calling a method.

Question 19

How to call use Method Injection by using a lambda expression component with a method call in the activator?

Answer 19

builder.Register(c => {

var result = new MyObjectType();
var dep = c.Resolve();
result.SetTheDependency(dep);

return result;

});

Question 20

How to call use Method Injection by adding an activating event handler?

Answer 20

builder .Register() .OnActivating(e =\> { var dep = e.Context.Resolve(); e.Instance.SetTheDependency(dep); });