ServiceSharp 3.0.0

ServiceSharp

ServiceSharp is a tiny utility for registering services in Microsoft.Extensions.DependencyInjection with explicit attributes.

Version 3 is a breaking redesign. Service bindings are now declared directly on the implementation type. There is no marker-interface registration, no automatic "all interfaces" scan, and no hidden default lifetime.

The old v2 README is kept in READMEv2.MD.

Installation

Install from NuGet:

Install-Package ServiceSharp

Quick Start

Declare your services:

using ServiceSharp;

public interface IUserService
{
    User GetCurrentUser();
}

[BindScoped(typeof(IUserService))]
public sealed class UserService : IUserService
{
    public User GetCurrentUser()
    {
        // ...
    }
}

Register them:

services.AddServiceSharp();

AddServiceSharp() registers services from the calling assembly. If the assembly contains ServiceSharp generated registration, that generated code is used. Otherwise, ServiceSharp falls back to reflection scanning.

You can also pass assemblies explicitly:

services.AddServiceSharp(
    typeof(UserService).Assembly,
    typeof(AnotherModuleMarker).Assembly);

Source Generation

ServiceSharp also ships a source generator in the same NuGet package.

Use generated registration when you want compile-time registration code instead of runtime reflection scanning:

using ServiceSharp.Generated.MyApp;

services.AddServiceSharpForMyApp();

The generated namespace and method name are based on the project assembly name. For example, an assembly named MyApp.Services gets:

using ServiceSharp.Generated.MyAppServices;

services.AddServiceSharpForMyAppServices();

The generated method registers services from the current compilation. Reflection registration is still available through AddServiceSharp(...), especially when you need to scan assemblies dynamically.

When registering multiple projects from an app, pass each assembly you want included:

services.AddServiceSharp(
    typeof(MyLib.Marker).Assembly,
    typeof(MyLib2.Marker).Assembly,
    typeof(Program).Assembly);

ServiceSharp checks each assembly for generated registration first, then falls back to reflection for assemblies without generated registration.

Lifetimes

Use one of the lifetime attributes:

[BindSingleton]
public sealed class CacheService { }

[BindScoped(typeof(IUserService))]
public sealed class UserService : IUserService { }

[BindTransient(typeof(IEmailSender))]
public sealed class EmailSender : IEmailSender { }

Every registered implementation must specify a lifetime. If conflicting lifetimes are declared on the same implementation, ServiceSharp throws during registration.

Binding To Service Types

The preferred style is one lifetime attribute with all service types listed together:

[BindScoped(
    typeof(IUserService),
    typeof(IUserCache))]
public sealed class UserService :
    IUserService,
    IUserCache { }

Repeated attributes are valid when they use the same lifetime, but the single-attribute style is recommended:

[BindScoped(typeof(IUserService))]
[BindScoped(typeof(IUserCache))]
public sealed class UserService :
    IUserService,
    IUserCache { }

If no service type is supplied, the class is registered as itself:

[BindSingleton]
public sealed class AppClock { }

Convenience Bindings

BindToInterface binds to the single interface directly declared by the class:

[BindScoped, BindToInterface]
public sealed class UserService : IUserService { }

BindToBase binds to the immediate base class:

public abstract class RepositoryBase { }

[BindScoped, BindToBase]
public sealed class UserRepository : RepositoryBase { }

For clearer public APIs, prefer explicit service types when a class has more than one obvious binding.

Shared Instances

When one implementation is bound to multiple service types, singleton and scoped services resolve through one implementation registration.

[BindScoped(
    typeof(IUserService),
    typeof(IUserCache))]
public sealed class UserService :
    IUserService,
    IUserCache { }

Within one scope, resolving IUserService, IUserCache, or UserService returns the same instance.

Transient services still follow normal .NET DI transient behavior and create a new instance per resolution.

Migration From V2

V3 is intentionally not compatible with v2 declarations.

[Service(typeof(IFoo))]

becomes:

[BindScoped(typeof(IFoo))]

[SelfService]

becomes:

[BindScoped]

[Service]

has no automatic v3 equivalent. Choose the service types explicitly:

[BindScoped(
    typeof(IFoo),
    typeof(IBar))]

Choose BindSingleton, BindScoped, or BindTransient based on the lifetime you want.