transaction-policy

Define and enforce transaction policies with isolation levels and timeouts.

Updated Feb 20, 2026
One-click install
npx skills add https://github.com/yeeehaooo/WorkSpace --skill transaction-policy
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: transaction-policy
Source: https://github.com/yeeehaooo/WorkSpace/tree/main/skills/dotnet/patterns/transaction-policy
Command: npx skills add https://github.com/yeeehaooo/WorkSpace --skill transaction-policy

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Define explicit transaction policies to apply different isolation levels and boundaries per operation, ensuring predictable consistency across the system.

Core Features & Use Cases

  • Policy interfaces in the Application layer to declare transaction characteristics
  • Policy implementations in the Infrastructure layer to enforce runtime behavior
  • Composition of policies and enforcement via decorators or middleware in service handlers
  • Use cases include varying isolation levels, timeouts, and read-only vs read-write transactions in complex workflows

Quick Start

Define a concrete policy (e.g., ReadCommittedPolicy) and apply it to a handler to enforce transaction boundaries.

Frequently Asked Questions about transaction-policy

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

FAQPage Schema
How do I enforce different transaction isolation levels per operation in .NET?

You can enforce different transaction isolation levels per operation by defining explicit policy interfaces in the application layer and concrete implementations in the infrastructure layer, using decorators or middleware to apply boundaries.

What is the best way to manage complex transaction consistency requirements across application layers?

Managing complex transaction consistency requirements involves specifying operation-specific policies that control isolation levels and timeouts, applied across application and infrastructure layers to ensure predictable behavior for diverse operation types.

How do I set up policy-driven transaction control for read-only and read-write workflows?

To set up policy-driven transaction control, define concrete policies like a ReadCommittedPolicy and apply them to service handlers, allowing you to declare varying timeouts and read-only versus read-write characteristics for complex workflows.

Can I use decorators to enforce transaction boundaries in a .NET application?

Yes, you can use decorators or middleware to enforce transaction boundaries by composing them with policy implementations in the infrastructure layer to control runtime behavior across service handlers.

When do I need explicit transaction policies instead of default database transaction behavior?

You need explicit transaction policies when complex workflows require varying isolation levels, specific timeouts, or distinct read-only versus read-write operations, ensuring predictable consistency across diverse operation types.

Does policy-driven transaction control require separate interfaces for application and infrastructure layers?

Yes, policy-driven transaction control requires policy interfaces declared in the application layer to specify transaction characteristics, with concrete policy implementations enforced in the infrastructure layer to handle runtime behavior.