dotnet-scaffold-service

Scaffold Umbrella Core.Logic service skeletons with interfaces, models, and DI registration.

8|1|Updated Feb 5, 2018
One-click install
npx skills add https://github.com/umbrella-libraries/Umbrella --skill dotnet-scaffold-service
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dotnet-scaffold-service
Source: https://github.com/umbrella-libraries/Umbrella/tree/main/.ai-shared/skills/dotnet-scaffold-service
Command: npx skills add https://github.com/umbrella-libraries/Umbrella --skill dotnet-scaffold-service

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Scaffold a reusable scaffold for Umbrella Core.Logic services, enabling consistent interface, implementation, and model patterns with proper DI and Lazy repository integration.

Core Features & Use Cases

  • Interface-first scaffolding: Creates Abstractions and Models for domain services.
  • Implementation patterns: Generates internal sealed implementations following Umbrella ServiceBase with Lazy<T> repositories.
  • DI & boundaries: Enforces Core.Logic boundaries and respects non Web references; supports integration with IServiceCollectionExtensions for DI.

Quick Start

Scaffold a new logic service with interface, implementation, and optional models in Core.<AppName>.Core.Logic following the Umbrella ServiceBase pattern, wiring dependencies and repository injections as Lazy<T>.

Frequently Asked Questions about dotnet-scaffold-service

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I scaffold a dotnet domain service that goes beyond simple CRUD operations?

To scaffold a dotnet domain service, this tool generates a reusable logic-service skeleton with an interface, internal sealed implementation, and optional models following the Umbrella ServiceBase pattern. It handles complex domain logic by wiring dependencies and Lazy<T> repository injections automatically.

What is the best way to set up Lazy<T> repository injection in a dotnet core service?

Setting up Lazy<T> repository injection is handled by generating an internal sealed service class that implements a public interface. The scaffolded implementation follows the Umbrella ServiceBase pattern, automatically wiring Lazy<T> repository dependencies for efficient domain service initialization.

Does this dotnet service scaffolding tool enforce Core.Logic boundaries and prevent web references?

Yes, this dotnet service scaffolding enforces Core.Logic boundaries and respects non Web references. It generates domain services within Core.<AppName>.Core.Logic, ensuring clean architecture separation by preventing improper web project dependencies in your logic layer.

How do I generate DI registration extensions for new dotnet logic services?

To generate DI registration extensions, the scaffolder creates or updates IServiceCollectionExtensions.cs. This automatically wires your newly generated domain services and their Lazy<T> repository dependencies into the dotnet dependency injection container.

When do I need to create optional models under Services\<Domain>\Models for a dotnet service?

You create optional models under Services\<Domain>\Models when your domain service requires dedicated data transfer objects. The scaffolder generates these alongside the interface and internal sealed implementation to support complex logic operations beyond simple CRUD.

Can I use this scaffolder for standard dotnet CRUD services without Umbrella Core.Logic?

No, this scaffolder is specifically designed for Umbrella Core.Logic projects. It generates service skeletons implementing the Umbrella ServiceBase pattern with specific DI wiring and Lazy<T> repository integration, making it unsuitable for standard CRUD services outside this architecture.