Different Ways to Inject Events, Helpers and Services into Umbraco 9

After having a good play around with Umbraco 9 & .Net Core Dependency Injection I realized there is a few ways to inject your events, helpers are services.

1. Injecting directly into the startup.cs
2. Composing, similar to how we used to do in Umbraco 8
3. Creating an extension method for IUmbracoBuilder and injecting a collection into startup.cs

I have broken down and added examples of each below.

Injecting directly into the startup.cs

The easy way is to inject your events, helpers, or services directly into the startup.cs. I believe this is the default .Net Core way and possibly the way you should go unless writing a package which I think might be better composing that.

Here are some examples of injecting directly into the startup.cs file.

public void ConfigureServices(IServiceCollection services)
{
     #pragma warning disable IDE0022 // Use expression body for methods
     services.AddUmbraco(_env, _config)
          .AddBackOffice()
          .AddWebsite()
          .AddComposers()
          .AddNotificationHandler<ContentPublishingNotification, StartupTestEvent>()
          .Build();
     services.AddSingleton<ISiteService, SiteService>();
     services.AddSingleton<IBlogService, BlogService>();
     #pragma warning restore IDE0022 // Use expression body for methods
}

As you can see I have injected injected an ContentPublishingNotification(PublishingEvent) and two services SiteService and BlogService.

Composing, similar to how we used to do in Umbraco 8

You can also include your events (notifications, helpers, and services using the same technique we used to use for Umbraco 8 called composing. I think this technique is probably the best way to go when you are building packags. My assumption when building packages is it might not be that easy to maintain the startup.cs file without potentially creating issues. Therefore, I think composing might be the better way to go about it with Packages. This way I think it will work great as it did with Umbraco 8.

The code looks slightly different but not in a major way. Here is an example of Composing a service in Umbraco 9.

public class SiteHelperComposer : IUserComposer
{
     public void Compose(Composition composition)
     {
          composition.Register<ISiteHelper, SiteHelper>(Lifetime.Singleton);
     }
}

I actually wrote a more details blog about composing a service in Umbraco 9 here.

Creating an extension method for IUmbracoBuilder and injecting a collection into startup.cs

Personally, if I am not creating a package, I think I like this way the most. If you are like me I like to store a lot of code in your own helper / service classes then you will soon find that startup.cs file is going to start getting very messy. Some projects have a lot of events, helpers, services, providers etc. You can imagine the startup.cs file is going to start filling up and looking messy.

Instead, you can create an extension method for IUmbracoBuilder to inject a collection of events or services in one. Let me explain better by showing you some code.

public static class EventExtensions
{
     public static IUmbracoBuilder AddEvents(this IUmbracoBuilder builder)
     {
           builder
           .AddNotificationHandler<ContentPublishingNotification, PublishingEvent>()
           .AddNotificationHandler<ContentPublishedNotification, PublishedEvent>()
           .AddNotificationHandler<ContentMovedToRecycleBinNotification, ContentMovedToRecycleBinEvent>();

           return builder;
     }
}

public static class ServiceExtensions
{
    public static IUmbracoBuilder AddServices(this IUmbracoBuilder builder)
    {
         builder.Services
         .AddSingleton<ISiteService, SiteService>()
         .AddSingleton<IBlogService, BlogService>();

         return builder;
     }
}

public void ConfigureServices(IServiceCollection services)
{
     #pragma warning disable IDE0022 // Use expression body for methods
     services.AddUmbraco(_env, _config)
          .AddBackOffice()
          .AddWebsite()
          .AddComposers()
          .AddServices()
          .AddEvents()
          .Build();
     #pragma warning restore IDE0022 // Use expression body for methods
}

As you can see I create two extention methods. The first injecting all my events. The second injecting all my services. I then add one line of code for each in my statup.cs code. If I decide to add any more services or events I simply update the the corresponding extension method rather than editing the startup.cs.

I think over time this will be much neater.

Let me know your thoughts by commenting below. What method do you prefer and why?

I am interested in hearing your reasons why.

I did consider composing everything like we did with Umbraco 8. I imagined just having one way to do all. Packages and my base code. I just wasn't sure how this effects performance and what other negatives there might be of doing this.

Maybe some one on the Umbraco Core team and shed some light on this?