C# .NET Repository Pattern & BAL Generator for VS Code

An enterprise-grade Visual Studio Code extension that automates the generation of production-ready Repository Pattern, BAL Pattern (Business Access Layer), Data-Annotated Models, and Controllers (MVC View, Ajax JSON, Kendo UI) for C# and ASP.NET Core / MVC projects.

Generate domain Models, contracts (Interfaces), concrete Repositories, direct BAL Helpers, and Controllers in seconds via right-click folder context menus or the Command Palette.

🌟 Why Developers Love This Extension

• 🚀 Zero Boilerplate: Scaffolds full end-to-end multi-tier architectures in under 5 seconds.
• 🏷️ Smart Name Stripping: Enter table names like t_User or vm_Event — the model class retains t_User, while Interfaces, Repositories, Helpers, and Controllers automatically use clean, idiomatic names (IUserInterface, UserRepository, UserHelper, UserController).
• 🔠 Strict PascalCase & Data Annotations: Converts column inputs (eventname, totalseats, email) into clean C# properties (EventName, TotalSeats, EmailAddress) decorated with validation attributes ([Required], [EmailAddress], [Phone], [Range], [Compare], [Key]).
• 🔌 Constructor DI Connection Lifecycle: Uses connection injected via constructor (matching DI in Program.cs). Methods execute inside safe try { await _conn.OpenAsync(); ... } finally { await _conn.CloseAsync(); } blocks to eliminate connection leaks.
• ⚡ Direct Inline Reader Mapping: Eliminates reflection mapper overhead. DataReader columns are mapped directly inside reader loops.
• 🌐 3 Controller Flavors: Generates Razor View Controllers, Ajax/JSON RESTful Controllers, or Telerik Kendo UI Grid Controllers.
• 🔒 Role-Based Authorization & Session Management: Built-in support for role authorization (Admin, Manager, User), Session storage/clear, and complete Login/SignUp/Logout workflows.
• 📊 Enterprise Business Reports: Built-in methods and snippets for Summary Aggregation, Monthly Breakdowns, Top Performers, Seat Occupancy, Audit Logs, and CSV Export.
• 💡 Instant Snippet Autocomplete: 30+ context-aware snippets for Models, Interfaces, Repositories, BAL Helpers, and Controllers.

🏗️ Architecture Styles: Repository vs. BAL

Choose the pattern that matches your project architecture:

Directory Architecture

Repository Pattern Layout

{SelectedFolder}/
├── Models/
│   └── t_User.cs                  # Entity model with PascalCase & Data Annotations
├── Interfaces/
│   └── IUserInterface.cs          # Contract with clean naming (IUserInterface)
├── Implementation/
│   └── UserRepository.cs          # ADO.NET / Dapper / EF Core repository
└── Controllers/                   # Optional
    └── UserController.cs          # MVC View, Ajax/JSON, or Kendo UI controller

BAL Pattern Layout

{SelectedFolder}/
├── Models/
│   └── t_User.cs                  # Entity model with PascalCase & Data Annotations
├── BAL/
│   └── UserHelper.cs              # Direct Helper class with queries & business methods
└── Controllers/                   # Optional
    └── UserController.cs          # Injects UserHelper directly

🚀 Quick Start & Usage

Method 1: Right-Click Context Menu (Recommended)

1. In the VS Code File Explorer, right-click on any folder.
2. Select .NET Repository & BAL Generator:
   • Generate Repository or BAL Pattern (Complete end-to-end wizard)
   • Generate Model Only
   • Generate Interface Only
   • Generate Repository Implementation Only
   • Generate BAL Helper Only
   • Generate Controller Only (View / Ajax / Kendo)

Method 2: Command Palette

1. Press Ctrl + Shift + P (or Cmd + Shift + P on macOS).
2. Type dotnet or Generate Repository and press Enter.

📋 Interactive Guided Wizard

When generating code, the extension guides you through an intuitive, multi-step flow:

┌─────────────────────────────────────────────────────────────────────────────┐
│ 1. Architecture Pattern │ Pick "Repository Pattern" or "BAL Pattern"        │
├─────────────────────────┼───────────────────────────────────────────────────┤
│ 2. Entity / Model Name  │ e.g. "t_User", "vm_Event", or "EventModel"        │
├─────────────────────────┼───────────────────────────────────────────────────┤
│ 3. Controller Style     │ Pick "MVC View", "Ajax / JSON", "Kendo UI", "None"│
├─────────────────────────┼───────────────────────────────────────────────────┤
│ 4. Primary Key Type     │ Select "int", "long", or "Guid"                   │
├─────────────────────────┼───────────────────────────────────────────────────┤
│ 5. Properties           │ QuickPick common fields (Email, Phone, Date, etc.)│
│                         │ + custom "name:type" inputs                       │
├─────────────────────────┼───────────────────────────────────────────────────┤
│ 6. Code Style           │ Pick "Async", "Sync", or "Both (Async + Sync)"    │
├─────────────────────────┼───────────────────────────────────────────────────┤
│ 7. Database Engine      │ Pick "ADO.NET", "Dapper", or "EF Core"            │
├─────────────────────────┼───────────────────────────────────────────────────┤
│ 8. Injected Connection  │ Pick "NpgsqlConnection", "SqlConnection", or      │
│                         │ "IDbConnection" (matches Program.cs registration) │
├─────────────────────────┼───────────────────────────────────────────────────┤
│ 9. Operations           │ Multi-select: GetAll, GetById, Add, Update,       │
│                         │ Delete, Search, GetByCondition, GetPaged, Count   │
└─────────────────────────────────────────────────────────────────────────────┘

🔒 Role-Based Authorization Integration

The extension supports role-based security tailored for both Razor Views and JSON APIs / Ajax:

1. Role-Based for MVC Razor Views

Used for server-rendered HTML pages where unauthorized users should be redirected:

[Authorize(Roles = "Admin,Manager")]
public IActionResult AdminDashboard()
{
    if (!User.IsInRole("Admin"))
    {
        return RedirectToAction("AccessDenied", "Account");
    }
    return View();
}

[HttpGet]
[AllowAnonymous]
public IActionResult AccessDenied()
{
    return View();
}

2. Role-Based for Ajax / JSON APIs

Used for SPA / client-side Ajax calls where unauthorized requests return standard JSON and HTTP 403 status:

[HttpPost]
[Authorize]
public async Task<IActionResult> AdminAction([FromBody] RequestModel model)
{
    if (!User.IsInRole("Admin"))
    {
        return StatusCode(StatusCodes.Status403Forbidden, new 
        { 
            success = false, 
            message = "Access Denied: Requires Admin role permissions." 
        });
    }

    // Process secure action
    return Json(new { success = true, message = "Executed successfully" });
}

🔑 Session & Authentication Setup (Program.cs)

To use the generated login, session, and DI connection features, add the following to your Program.cs:

// 1. Register Database Connection via DI
builder.Services.AddScoped<NpgsqlConnection>(sp => 
    new NpgsqlConnection(builder.Configuration.GetConnectionString("DefaultConnection")));

// 2. Register Repository or BAL Helper
builder.Services.AddScoped<IUserInterface, UserRepository>();
// or for BAL:
// builder.Services.AddScoped<UserHelper>();

// 3. Register Session
builder.Services.AddDistributedMemoryCache();
builder.Services.AddSession(options =>
{
    options.IdleTimeout = TimeSpan.FromMinutes(30);
    options.Cookie.HttpOnly = true;
    options.Cookie.IsEssential = true;
});

// 4. Register Cookie Authentication
builder.Services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie(options =>
    {
        options.LoginPath = "/Account/Login";
        options.AccessDeniedPath = "/Account/AccessDenied";
        options.ExpireTimeSpan = TimeSpan.FromDays(7);
    });

// Middleware pipeline
app.UseAuthentication();
app.UseAuthorization();
app.UseSession();

💡 Comprehensive Code Snippets Reference

Typing prefixes in .cs files triggers intelligent, production-ready code snippets:

1. Models & ViewModels

2. Repository & BAL (Data Access & Reports)

3. Controller Actions (Role Authorization, Auth, Session & Kendo)

⚙️ Extension Settings

Customize extension defaults in your VS Code settings.json:

{
  // Default base namespace (if empty, auto-detected from nearest .csproj file)
  "dotnetRepoGenerator.defaultNamespace": "",

  // Default data access engine: "ADO.NET (SqlConnection)", "Dapper", or "Entity Framework Core"
  "dotnetRepoGenerator.defaultDatabaseApproach": "ADO.NET (SqlConnection)",

  // Default connection injected via DI: "NpgsqlConnection", "SqlConnection", or "IDbConnection"
  "dotnetRepoGenerator.defaultConnectionType": "NpgsqlConnection",

  // Default method execution style: "Async", "Sync", or "Both (Async + Sync)"
  "dotnetRepoGenerator.defaultCodeStyle": "Async",

  // Default primary key data type: "int", "long", or "Guid"
  "dotnetRepoGenerator.defaultPrimaryKeyType": "int",

  // Automatically open newly generated C# files in editor tabs
  "dotnetRepoGenerator.autoOpenFiles": true
}

🧪 Development & Contribution

1. Clone this repository:

   git clone https://github.com/dotnet-community/dotnet-repo-generator.git
   cd dotnet-repo-generator
   npm install
   

2. Build the TypeScript source:

   npm run compile
   

3. Press F5 to open the Extension Development Host to test and debug live in VS Code.

📜 License

Distributed under the MIT License. See LICENSE for details.