Getting Started

Web Application Quick Start

Build a modern web application with authentication, data access, and beautiful UI components.

Create Your Project

# Create new web application

dotnet new webapp -n MyApp

cd MyApp

# Install Noundry components

dotnet add package Noundry.UI

dotnet add package Noundry.Authnz

dotnet add package Noundry.Tuxedo

dotnet add package Noundry.DotEnvX

dotnet add package Microsoft.Data.SqlServer

# Optional: For CSV data import

dotnet tool install --global Noundry.Slurp.Tool

This creates a new ASP.NET Core web application and installs the essential Noundry components for web development.

💡 Use Noundry Templates

Skip manual package installation! Use our pre-configured web app template:

noundry templates install NDC.Templates.WebApp

dotnet new ndc-webapp -n MyApp

Includes Noundry.UI, Authnz, Tuxedo, and DotEnvX pre-configured!

Configure Services

Update your Program.cs file:

using Noundry.DotEnvX.Core.Extensions;
using Noundry.Authnz.Extensions;
using Noundry.Tuxedo.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

// Load environment variables
builder.Configuration.AddDotEnvX();

// Add services
builder.Services.AddRazorPages();
builder.Services.AddTuxedoSqlServer(builder.Configuration.GetConnectionString("DefaultConnection"));
builder.Services.AddNoundryOAuth(builder.Configuration);
builder.Services.AddNoundryUI();

var app = builder.Build();

// Configure pipeline
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseNoundryOAuth();
app.UseAuthentication();
app.UseAuthorization();

app.MapRazorPages();
app.Run();

Environment Configuration

Create a .env file:

# Database
DATABASE_URL=Server=localhost;Database=MyApp;Integrated Security=true;TrustServerCertificate=true;

# OAuth
GOOGLE_CLIENT_ID=your-google-client-id
GOOGLE_CLIENT_SECRET=your-google-client-secret

Update appsettings.json:

{
  "ConnectionStrings": {
    "DefaultConnection": "${DATABASE_URL}"
  },
  "OAuth": {
    "Providers": {
      "google": {
        "ClientId": "${GOOGLE_CLIENT_ID}",
        "ClientSecret": "${GOOGLE_CLIENT_SECRET}"
      }
    }
  }
}

Create Your First Page

First, add TagHelper support to _ViewImports.cshtml:

@using MyApp
@namespace MyApp.Pages
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
@addTagHelper *, Noundry.UI
@addTagHelper *, Noundry.Authnz

Also include Elements for client-side form validation in your layout:

Then create Pages/Index.cshtml with Noundry components:

@page
@model IndexModel

<div class="max-w-4xl mx-auto py-8">
    <h1 class="text-4xl font-bold text-gray-900 mb-8">Welcome to My App</h1>
    
    <!-- Authentication Status -->
    <noundry-oauth-status show-when-anonymous="true">
        <noundry-oauth-login show-all="true"></noundry-oauth-login>
    </noundry-oauth-status>
    
    <noundry-oauth-status show-when-authenticated="true">
        <noundry-card>
            <h2>Welcome back!</h2>
            <noundry-oauth-status show-name="true" show-email="true"></noundry-oauth-status>
        </noundry-card>
    </noundry-oauth-status>
    
    <!-- Success Alert -->
    <noundry-alert type="success" title="Success!">
        Your Noundry application is running!
    </noundry-alert>
</div>

<!-- Toast Container -->
<noundry-toast-container position="top-right" />

💡 Add Client-Side Validation

Wrap your forms with Noundry Elements for instant validation:

<noundry-element>
    <form asp-action="Submit" method="post">
        <input type="email" name="email" required
               data-error="Valid email required">
        <button type="submit">Submit</button>
    </form>
</noundry-element>

Automatic validation with beautiful error messages!

Run Your Application

dotnet run

Visit https://localhost:7001 and you'll see your application with:

Authentication with Google OAuth
Beautiful UI components
Database connectivity
Toast notifications

🎉 Congratulations!

You've successfully created a modern web application with the Noundry platform.

Explore UI Components View All Libraries

API Development Quick Start

Build a high-performance API with advanced data access and environment management.

Create API Project

# Create API project

dotnet new webapi -n MyApi

cd MyApi

# Install components

dotnet add package Noundry.Tuxedo

dotnet add package Noundry.Tuxedo.Bowtie

dotnet add package Noundry.DotEnvX

dotnet add package Guardian

dotnet add package Microsoft.Data.SqlServer

💡 Use Noundry API Template

Get a fully-configured REST API with Noundry components:

noundry templates install NDC.Templates.Api

dotnet new ndc-api -n MyApi

Includes Tuxedo, Bowtie, DotEnvX, and Guardian pre-configured!

Create Data Model

Create Models/Product.cs:

using Noundry.Tuxedo.Contrib;
using Noundry.Tuxedo.Bowtie.Attributes;

[Table("Products")]
public class Product
{
    [Key]
    public int Id { get; set; }
    
    [Column(MaxLength = 200)]
    [Index("IX_Products_Name")]
    public string Name { get; set; } = string.Empty;
    
    [Column(Precision = 18, Scale = 2)]
    [CheckConstraint("Price > 0")]
    public decimal Price { get; set; }
    
    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
}

Synchronize Database Schema with Bowtie

Bowtie automatically synchronizes your database schema from your C# models. No manual SQL scripts needed!

# Install Bowtie CLI (one-time)

$ dotnet tool install --global Noundry.Tuxedo.Bowtie.Tool

# Sync schema to database

$ bowtie sync --connection "Server=localhost;Database=MyApi;..."

✅ Creates Tables

From [Table] attributes

🔑 Adds Indexes

From [Index] attributes

🛡️ Enforces Constraints

From [CheckConstraint] attributes

Your database is now in sync with your code! Run bowtie sync whenever you modify your models.

Create API Controller

Create Controllers/ProductsController.cs:

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IDbConnection _connection;
    
    public ProductsController(IDbConnection connection)
    {
        _connection = connection;
    }
    
    [HttpGet]
    public async Task<ActionResult<IEnumerable<Product>>> GetProducts()
    {
        var products = await _connection.GetAllAsync<Product>();
        return Ok(products);
    }
    
    [HttpPost]
    public async Task<ActionResult<Product>> CreateProduct(Product product)
    {
        // Validate using Guardian
        product.Name = Guard.Against.NullOrWhiteSpace(product.Name);
        product.Price = Guard.Against.NegativeOrZero(product.Price);
        
        var id = await _connection.InsertAsync(product);
        var created = await _connection.GetAsync<Product>(id);
        
        return CreatedAtAction(nameof(GetProduct), new { id }, created);
    }
}

🚀 Your API is Ready!

Run dotnet run and visit /swagger to test your API.

Learn More About Tuxedo ORM

Testing & Validation Quick Start

Add robust testing and validation to any .NET application in minutes.

Install Components

dotnet add package Noundry.Assertive

dotnet add package Guardian

Create Your First Test

using Noundry.Assertive;
using Guardian;
using Xunit;

public class ProductTests
{
    [Fact]
    public void Product_WithValidData_ShouldBeCreated()
    {
        // Arrange & Act
        var product = new Product
        {
            Name = Guard.Against.NullOrWhiteSpace("Test Product"),
            Price = Guard.Against.NegativeOrZero(29.99m)
        };
        
        // Assert using Assertive
        product.Assert()
            .IsNotNull()
            .Satisfies(p => p.Name == "Test Product")
            .Satisfies(p => p.Price == 29.99m);
    }
}

Run Tests

dotnet test

You now have fluent, readable test assertions and comprehensive input validation!

Data Import & Generation Quick Start

Import CSV files with Slurp or generate realistic test data with Cufflink

Install Slurp

$ dotnet tool install --global Noundry.Slurp.Tool

Import Your Data

Import a CSV file with automatic schema inference:

# Import to SQL Server

$ slurp data.csv -p sqlserver -s localhost -d MyDB

# Import to PostgreSQL

$ slurp customers.csv -p postgres -s localhost -d mydb -u user

# Import to SQLite (simplest)

$ slurp sales.csv -p sqlite -d sales.db

Key Features

⚡ Blazing Fast

100,000+ rows per second on modern hardware

🧠 Smart Schema Inference

Automatically detects column types and constraints

🗄️ Multi-Database Support

SQL Server, PostgreSQL, MySQL, SQLite

🎯 Intelligent Indexing

Auto-creates indexes on key columns

Generate Test Data with Cufflink

Need realistic test data? Cufflink generates fake data while automatically maintaining FK/PK relationships!

Install Cufflink

$ dotnet tool install --global Noundry.Tuxedo.Cufflink.Tool

Generate Test Data

Generate realistic data for any table with automatic relationship handling:

# Generate 100 customers

$ cufflink generate --table Customers --rows 100

# Generate orders (FK to Customers auto-maintained)

$ cufflink generate --table Orders --rows 500

# Generate specific data patterns

$ cufflink generate --table Products --rows 50 --pattern Electronics

✨ Cufflink automatically detects PK/FK relationships and generates valid references!

🔗 Smart Relationships

Automatically maintains FK/PK integrity across tables

🎭 Realistic Data

Built-in generators for names, emails, addresses, and more

🗄️ Multi-Database

Works with SQL Server, PostgreSQL, MySQL, SQLite

⚡ Fast & Configurable

Generate thousands of records in seconds with custom patterns

🎉 Ready to Work with Data!

Use Slurp for importing CSVs and Cufflink for generating test data.

Learn More About Slurp Learn More About Cufflink