C# / ASP.NET Core

Why ASP.NET Core?

ASP.NET Core is Microsoft’s open-source, cross-platform framework for building modern web apps and APIs. It delivers outstanding performance, native dependency injection, and a robust security model, ideal for professional-grade business applications.

How We Use It

At Pfann.Tech, ASP.NET Core serves as the backbone of nearly every project. Whether it’s a client portal, API integration, or automation backend, we rely on C# and ASP.NET Core to deliver scalable, reliable solutions that can grow with your business.

Example: Controller

Here’s a simple example of a controller that handles requests for client data in an MVC or API-based project:

// Example Controller
using Microsoft.AspNetCore.Mvc;
using PfannTech.Data;
using PfannTech.Models;

namespace PfannTech.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ClientsController : ControllerBase
    {
        private readonly AppDbContext _context;

        public ClientsController(AppDbContext context)
        {
            _context = context;
        }

        [HttpGet]
        public async Task GetClients()
        {
            var clients = await _context.Clients
                .Where(c => c.IsActive)
                .OrderBy(c => c.Name)
                .ToListAsync();

            return Ok(clients);
        }

        [HttpPost]
        public async Task AddClient([FromBody] Client client)
        {
            if (!ModelState.IsValid) return BadRequest(ModelState);

            _context.Clients.Add(client);
            await _context.SaveChangesAsync();
            return CreatedAtAction(nameof(GetClients), new { id = client.Id }, client);
        }
    }
}

Example: Model

Below is a simple model used to represent a client record in the database, built with Entity Framework Core:

// Example Model
using System.ComponentModel.DataAnnotations;

namespace PfannTech.Models
{
    public class Client
    {
        public int Id { get; set; }

        [Required, StringLength(100)]
        public string Name { get; set; } = string.Empty;

        [EmailAddress]
        public string? Email { get; set; }

        public bool IsActive { get; set; } = true;
    }
}

Example: Dependency Injection

ASP.NET Core’s built-in dependency injection (DI) makes it easy to keep your application modular and testable.

// Program.cs - Registering Services and Context
var builder = WebApplication.CreateBuilder(args);

// Add services
builder.Services.AddControllersWithViews();
builder.Services.AddDbContext(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

builder.Services.AddScoped();
builder.Services.AddScoped();

var app = builder.Build();

app.MapControllers();
app.Run();

How It Works for You

For our clients, ASP.NET Core ensures reliability, performance, and security. Its modular design allows us to create flexible solutions, from internal business automations to public-facing portals, that are maintainable and future-proof.