InjectableAttribute.cs

using System;
using System.Linq;
using System.Reflection;
using Microsoft.Extensions.DependencyInjection;

namespace AutoInject
{
    public enum InjectType
    {
        Singleton,
        Scoped,
        Transient
    }

    [AttributeUsage(AttributeTargets.Class)]
    public class InjectableAttribute : Attribute
    {
        public InjectType InjectType { get; }
        public Type? ServiceType { get; }
        public InjectableAttribute(InjectType injectType, Type? underlyingType) => (InjectType, ServiceType) = (injectType, underlyingType); // implement enum and underlying type checks
        public InjectableAttribute(InjectType injectType) : this(injectType, null) { }
    }

    public static class ServiceCollectionExtensions
    {
        public static IServiceCollection AddInjectables(this IServiceCollection serviceCollection)
        {
            var types =
                Assembly
                   .GetExecutingAssembly()
                   .GetTypes()
                   .Where(x => x.GetCustomAttribute(typeof(InjectableAttribute)) != null)
                   .Select(x => (x, (InjectableAttribute)x.GetCustomAttribute(typeof(InjectableAttribute))!));
            foreach (var (implementationType, attribute) in types)
            {
                switch (attribute.InjectType)
                {
                    case InjectType.Singleton:
                        if (attribute.ServiceType is not null)
                            serviceCollection.AddSingleton(attribute.ServiceType, implementationType);
                        else
                            serviceCollection.AddSingleton(implementationType);
                        break;
                    case InjectType.Scoped:
                        if (attribute.ServiceType is not null)
                            serviceCollection.AddScoped(attribute.ServiceType, implementationType);
                        else
                            serviceCollection.AddScoped(implementationType);
                        break;
                    case InjectType.Transient:
                        if (attribute.ServiceType is not null)
                            serviceCollection.AddTransient(attribute.ServiceType, implementationType);
                        else
                            serviceCollection.AddTransient(implementationType);
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }

            return serviceCollection;
        }
    }
}

ValueService.cs

namespace AutoInject
{
    [Injectable(InjectType.Singleton, typeof(IValueService))]
    public class ValueService : IValueService
    {
        public int Value => 1;
    }

    public interface IValueService
    {
        int Value { get; }
    }
}