Show me a usecase example code of asp.net, windows forms, unit tests and GoF

Question

Show me a usecase example code of asp.net, windows forms, unit tests and GoF

Gurdeep Vaidya 0

need practical code examples covering the following C# topics:

ASP.NET Core MVC – a simple use case, e.g. a controller returning data to a view
Windows Forms – a basic example, e.g. button click event or form validation
Unit Tests – a simple test using MSTest or NUnit
GoF Design Patterns – a short example of any commonly used pattern (e.g. Singleton, Factory, Observer, Decorator)

Any minimal working code snippets would be greatly appreciated!

Trevor Waldenburg 0

// ============================================================

// C# CHEATSHEET – WinForms · ASP.NET MVC · EF · GoF · Tests

// ============================================================

// 1. WINFORMS – read DB into DataGridView

// ============================================================

public partial class Form1 : Form

{

string conn = "Server=.;Database=ShopDB;Integrated Security=true;";

private void btnLoad_Click(object sender, EventArgs e)

{

    using (var con = new SqlConnection(conn))

    {

        var da = new SqlDataAdapter("SELECT Id, Name, Price FROM Products", con);

        var dt = new DataTable();

        da.Fill(dt);

        dataGridView1.DataSource = dt;

    }

}

// open the add-form, reload grid on success

private void btnAdd_Click(object sender, EventArgs e)

{

    if (new AddProductForm().ShowDialog() == DialogResult.OK)

        btnLoad_Click(sender, e);

}

}

// ============================================================

// 2. WINFORMS – separate form for INSERT

// ============================================================

public partial class AddProductForm : Form

{

string conn = "Server=.;Database=ShopDB;Integrated Security=true;";

private void btnSave_Click(object sender, EventArgs e)

{

    if (string.IsNullOrWhiteSpace(txtName.Text))

    {

        MessageBox.Show("Name is required.");

        return;

    }

    using (var con = new SqlConnection(conn))

    {

        con.Open();

        var cmd = new SqlCommand(

            "INSERT INTO Products (Name, Price) VALUES (@name, @price)", con);

        cmd.Parameters.AddWithValue("@name",  txtName.Text);

        cmd.Parameters.AddWithValue("@price", decimal.Parse(txtPrice.Text));

        cmd.ExecuteNonQuery();

    }

    DialogResult = DialogResult.OK;

    Close();

}

}

// ============================================================

// 3. WINFORMS – Entity Framework Code First

// ============================================================

// --- model ---

public class Product

{

public int     Id    { get; set; }

public string  Name  { get; set; }

public decimal Price { get; set; }

}

// --- context ---

public class AppDbContext : DbContext

{

public DbSet<Product> Products { get; set; }

protected override void OnConfiguring(DbContextOptionsBuilder o)

    => o.UseSqlServer("Server=.;Database=ShopDB;Integrated Security=true;");

}

// --- usage in form ---

private void btnLoadEF_Click(object sender, EventArgs e)

{

using (var db = new AppDbContext())

    dataGridView1.DataSource = db.Products.ToList();

}

private void btnAddEF_Click(object sender, EventArgs e)

{

using (var db = new AppDbContext())

{

    db.Products.Add(new Product { Name = "Widget", Price = 9.99m });

    db.SaveChanges();

}

}

// ============================================================

// 4. ASP.NET CORE MVC – controller + EF

// ============================================================

// Program.cs (key registrations)

// builder.Services.AddDbContext<AppDbContext>(o =>

// o.UseSqlServer(builder.Configuration.GetConnectionString("Default")));

// builder.Services.AddControllersWithViews();

public class ProductsController : Controller

{

private readonly AppDbContext _db;

public ProductsController(AppDbContext db) { _db = db; }

// GET /Products

public IActionResult Index()

    => View(_db.Products.ToList());

// GET /Products/Create

public IActionResult Create() => View();

// POST /Products/Create

[HttpPost]

public IActionResult Create(Product p)

{

    if (!ModelState.IsValid) return View(p);

    _db.Products.Add(p);

    _db.SaveChanges();

    return RedirectToAction("Index");

}

}

// Views/Products/Index.cshtml

// @model List<Product>

// @foreach (var p in Model) {

// <tr><td>@p.Name</td><td>@p.Price</td></tr>

// }

// Views/Products/Create.cshtml

// @model Product

// <form asp-action="Create">

// <input asp-for="Name" />

// <span asp-validation-for="Name"></span>

// <input asp-for="Price" />

// <span asp-validation-for="Price"></span>

// <button type="submit">Save</button>

// </form>

// @section Scripts { @{ await Html.RenderPartialAsync("_ValidationScriptsPartial"); } }

// ============================================================

// 5. ASP.NET CORE MVC – Session

// ============================================================

// Program.cs

// builder.Services.AddDistributedMemoryCache();

// builder.Services.AddSession(o => o.IdleTimeout = TimeSpan.FromMinutes(30));

// app.UseSession(); // before app.MapControllerRoute

public class AccountController : Controller

{

public IActionResult Login(string username)

{

    HttpContext.Session.SetString("Username", username);

    HttpContext.Session.SetInt32("UserId", 42);

    return RedirectToAction("Index", "Home");

}

public IActionResult Logout()

{

    HttpContext.Session.Clear();

    return RedirectToAction("Login");

}

public IActionResult Dashboard()

{

    string user = HttpContext.Session.GetString("Username");

    if (user == null) return RedirectToAction("Login");

    ViewBag.User = user;

    return View();

}

}

// ============================================================

// 6. ASP.NET CORE MVC – model validation (Data Annotations)

// ============================================================

public class Product

{

public int Id { get; set; }

[Required(ErrorMessage = "Name is required")]

[MaxLength(100)]

public string Name { get; set; }

[Range(0.01, 99999, ErrorMessage = "Price must be positive")]

public decimal Price { get; set; }

}

// Controller POST already checks ModelState.IsValid (see section 4)

// Razor view uses asp-validation-for tags (see section 4)

// ============================================================

// 7. GoF – OBSERVER

// "when something happens, notify all subscribers"

// ============================================================

interface IObserver

{

void Update(string message);

}

class EventManager

{

private List<IObserver> _observers = new();

public void Subscribe(IObserver o)   => _observers.Add(o);

public void Unsubscribe(IObserver o) => _observers.Remove(o);

public void Notify(string message)

{

    foreach (var o in _observers)

        o.Update(message);

}

}

class EmailLogger : IObserver

{

public void Update(string msg) => Console.WriteLine($"[EMAIL] {msg}");

}

class FileLogger : IObserver

{

public void Update(string msg) => Console.WriteLine($"[FILE]  {msg}");

}

// usage

var em = new EventManager();

em.Subscribe(new EmailLogger());

em.Subscribe(new FileLogger());

em.Notify("Order placed");

// [EMAIL] Order placed

// [FILE] Order placed

// ============================================================

// 8. GoF – COMMAND

// "wrap an action as an object – enables undo/queue"

// ============================================================

interface ICommand { void Execute(); }

class Light

{

public void On()  => Console.WriteLine("Light ON");

public void Off() => Console.WriteLine("Light OFF");

}

class LightOnCommand : ICommand

{

private Light _light;

public LightOnCommand(Light l) { _light = l; }

public void Execute() => _light.On();

}

class LightOffCommand : ICommand

{

private Light _light;

public LightOffCommand(Light l) { _light = l; }

public void Execute() => _light.Off();

}

class RemoteControl

{

private ICommand _cmd;

public void SetCommand(ICommand c) { _cmd = c; }

public void Press() => _cmd.Execute();

}

// usage

var remote = new RemoteControl();

var light = new Light();

remote.SetCommand(new LightOnCommand(light)); remote.Press(); // Light ON

remote.SetCommand(new LightOffCommand(light)); remote.Press(); // Light OFF

// ============================================================

// 9. GoF – DECORATOR

// "add behaviour by wrapping, not by subclassing"

// ============================================================

interface ICoffee

{

string  GetDescription();

decimal GetCost();

}

class SimpleCoffee : ICoffee

{

public string  GetDescription() => "Coffee";

public decimal GetCost()        => 10m;

}

class CoffeeDecorator : ICoffee

{

protected ICoffee _inner;

public CoffeeDecorator(ICoffee c) { _inner = c; }

public virtual string  GetDescription() => _inner.GetDescription();

public virtual decimal GetCost()        => _inner.GetCost();

}

class MilkDecorator : CoffeeDecorator

{

public MilkDecorator(ICoffee c) : base(c) { }

public override string  GetDescription() => _inner.GetDescription() + ", Milk";

public override decimal GetCost()        => _inner.GetCost() + 3m;

}

class SugarDecorator : CoffeeDecorator

{

public SugarDecorator(ICoffee c) : base(c) { }

public override string  GetDescription() => _inner.GetDescription() + ", Sugar";

public override decimal GetCost()        => _inner.GetCost() + 1m;

}

// usage

ICoffee coffee = new SimpleCoffee();

coffee = new MilkDecorator(coffee);

coffee = new SugarDecorator(coffee);

Console.WriteLine(coffee.GetDescription()); // Coffee, Milk, Sugar

Console.WriteLine(coffee.GetCost()); // 14

// ============================================================

// 10. UNIT TEST – xUnit, plain logic (no DB)

// ============================================================

public class ProductService

{

public decimal ApplyDiscount(decimal price, decimal percent)

{

    if (percent < 0 || percent > 100)

        throw new ArgumentException("Invalid percent");

    return price * (1 - percent / 100);

}

}

public class ProductServiceTests

{

private readonly ProductService _svc = new();

[Fact]

public void ApplyDiscount_10Percent_ReducesPrice()

{

    decimal result = _svc.ApplyDiscount(100m, 10);

    Assert.Equal(90m, result);

}

[Fact]

public void ApplyDiscount_InvalidPercent_Throws()

{

    Assert.Throws<ArgumentException>(

        () => _svc.ApplyDiscount(100m, 150m));

}

}

// ============================================================

// 11. UNIT TEST – Moq (mock the DB, test only logic)

// ============================================================

public interface IProductRepository

{

List<Product> GetAll();

}

public class ProductService

{

private readonly IProductRepository _repo;

public ProductService(IProductRepository repo) { _repo = repo; }

public int CountExpensive(decimal threshold)

    => _repo.GetAll().Count(p => p.Price > threshold);

}

public class ProductServiceMockTests

{

[Fact]

public void CountExpensive_ReturnsCorrectCount()

{

    var mock = new Mock<IProductRepository>();

    mock.Setup(r => r.GetAll()).Returns(new List<Product>

    {

        new Product { Name = "Cheap",      Price = 100m },

        new Product { Name = "Expensive",  Price = 999m },

        new Product { Name = "Also pricey",Price = 500m }

    });

    var svc   = new ProductService(mock.Object);

    int count = svc.CountExpensive(200m);

    Assert.Equal(2, count);

}

}

// ============================================================

// 12. INTEGRATION TEST – WebApplicationFactory (real HTTP pipeline)

// ============================================================

// NuGet: Microsoft.AspNetCore.Mvc.Testing

// Test project references the ASP.NET project

public class ProductsControllerTests : IClassFixture<WebApplicationFactory<Program>>

{

private readonly HttpClient _client;

public ProductsControllerTests(WebApplicationFactory<Program> factory)

{

    _client = factory.CreateClient();

}

[Fact]

public async Task Index_ReturnsSuccess()

{

    var response = await _client.GetAsync("/Products");

    response.EnsureSuccessStatusCode(); // 200–299

}

[Fact]

public async Task Create_Post_RedirectsOnSuccess()

{

    var form = new FormUrlEncodedContent(new[]

    {

        new KeyValuePair<string,string>("Name",  "TestProduct"),

        new KeyValuePair<string,string>("Price", "49.99")

    });

    var response = await _client.PostAsync("/Products/Create", form);

    // successful POST → redirect 302 to Index

    Assert.Equal(System.Net.HttpStatusCode.Redirect, response.StatusCode);

}

}

2 answers

Your answer

Answer 1

Hi @Gurdeep Vaidya ,

Thanks for reaching out.

You can use the following small examples as a starting point. They are kept intentionally simple, but each one shows a practical pattern you would use in a real C# application.

For an ASP.NET Core MVC example, you could have a controller prepare some data and pass it to a Razor view like this:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
}

using Microsoft.AspNetCore.Mvc;

public class ProductsController : Controller
{
    public IActionResult Index()
    {
        var products = new List<Product>
        {
            new Product { Id = 1, Name = "Keyboard", Price = 49.99m },
            new Product { Id = 2, Name = "Mouse", Price = 19.99m }
        };

        return View(products);
    }
}

Then the Razor view can receive that model and display it:

@model List<Product>

<h2>Products</h2>

<table>
    <thead>
        <tr>
            <th>Name</th>
            <th>Price</th>
        </tr>
    </thead>
    <tbody>
    @foreach (var product in Model)
    {
        <tr>
            <td>@product.Name</td>
            <td>@product.Price.ToString("C")</td>
        </tr>
    }
    </tbody>
</table>

In this case, when the user browses to /Products, the Index() action creates a small product list and passes it to the view for rendering.

For Windows Forms, a common basic example is handling a button click and validating user input before showing a result:

using System;
using System.Windows.Forms;

public class MainForm : Form
{
    private readonly TextBox nameTextBox;
    private readonly Button submitButton;
    private readonly Label resultLabel;

    public MainForm()
    {
        Text = "Windows Forms Example";
        Width = 350;
        Height = 200;

        nameTextBox = new TextBox
        {
            Left = 20,
            Top = 20,
            Width = 200
        };

        submitButton = new Button
        {
            Left = 20,
            Top = 60,
            Width = 100,
            Text = "Submit"
        };

        resultLabel = new Label
        {
            Left = 20,
            Top = 100,
            Width = 300
        };

        submitButton.Click += SubmitButton_Click;

        Controls.Add(nameTextBox);
        Controls.Add(submitButton);
        Controls.Add(resultLabel);
    }

    private void SubmitButton_Click(object? sender, EventArgs e)
    {
        if (string.IsNullOrWhiteSpace(nameTextBox.Text))
        {
            MessageBox.Show("Please enter your name.");
            return;
        }

        resultLabel.Text = $"Hello, {nameTextBox.Text}!";
    }
}

The application entry point would look like this:

using System;
using System.Windows.Forms;

internal static class Program
{
    [STAThread]
    private static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new MainForm());
    }
}

This creates a simple form with a textbox, a button, and a label. When the button is clicked, the code checks whether the textbox has a value before updating the label.

For unit testing, here is a small MSTest example. First, this is the class being tested:

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

And this is a matching test class:

using Microsoft.VisualStudio.TestTools.UnitTesting;

[TestClass]
public class CalculatorTests
{
    [TestMethod]
    public void Add_WhenCalled_ReturnsSum()
    {
        var calculator = new Calculator();

        int result = calculator.Add(2, 3);

        Assert.AreEqual(5, result);
    }
}

If you are using MSTest, make sure the test project has the usual test packages installed, for example:

<PackageReference Include="MSTest.TestFramework" Version="3.4.3" />
<PackageReference Include="MSTest.TestAdapter" Version="3.4.3" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />

For a GoF design pattern, a simple and useful one is the Factory pattern. It helps you create objects without spreading new SomeConcreteClass() throughout the application:

public interface INotificationSender
{
    void Send(string message);
}

public class EmailNotificationSender : INotificationSender
{
    public void Send(string message)
    {
        Console.WriteLine($"Email sent: {message}");
    }
}

public class SmsNotificationSender : INotificationSender
{
    public void Send(string message)
    {
        Console.WriteLine($"SMS sent: {message}");
    }
}

public static class NotificationSenderFactory
{
    public static INotificationSender Create(string type)
    {
        return type.ToLower() switch
        {
            "email" => new EmailNotificationSender(),
            "sms" => new SmsNotificationSender(),
            _ => throw new ArgumentException("Unknown notification type")
        };
    }
}

You can then use it like this:

INotificationSender sender = NotificationSenderFactory.Create("email");
sender.Send("Your order has been shipped.");

The benefit here is that the calling code works with the INotificationSender interface instead of depending directly on a specific implementation such as EmailNotificationSender or SmsNotificationSender. That makes the code easier to extend later if you add another sender type.

Hope this helps! If my answer was helpful, I would greatly appreciate it if you could follow the instructions here so others with the same problem can benefit as well.

Jack Dang (WICLOUD CORPORATION) 17,585 Reputation points Microsoft External Staff Moderator

2026-05-05T06:59:53.98+00:00

Hi @Gurdeep Vaidya ,

If you're still interested or have any questions, feel free to reach out whenever it works best for you.

Answer 2

ASP.NET Core MVC, Windows Forms, unit tests, and GoF patterns can be illustrated with small, focused snippets.

1. ASP.NET Core MVC – simple controller returning data to a view

// Models/Product.cs
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
}

// Controllers/ProductsController.cs
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;

public class ProductsController : Controller
{
    // GET: /Products
    public IActionResult Index()
    {
        var products = new List<Product>
        {
            new Product { Id = 1, Name = "Keyboard" },
            new Product { Id = 2, Name = "Mouse" }
        };

        return View(products); // passes the list to the view
    }
}

@* Views/Products/Index.cshtml *@
@model IEnumerable<Product>

<h2>Products</h2>
<ul>
@foreach (var p in Model)
{
    <li>@p.Id - @p.Name</li>
}
</ul>

This follows the guidance that most logic should live in services or models and controllers stay thin, which makes them easy to test with controller tests or functional tests.

2. Windows Forms – button click event

// Form1.cs
using System;
using System.Windows.Forms;

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void buttonGreet_Click(object sender, EventArgs e)
    {
        if (string.IsNullOrWhiteSpace(textBoxName.Text))
        {
            MessageBox.Show("Please enter your name.", "Validation",
                MessageBoxButtons.OK, MessageBoxIcon.Warning);
            return;
        }

        MessageBox.Show($"Hello, {textBoxName.Text}!", "Greeting");
    }
}

Designer wiring (auto-generated when double-clicking the button in the designer):

// Form1.Designer.cs (excerpt)
private void InitializeComponent()
{
    this.buttonGreet = new System.Windows.Forms.Button();
    this.textBoxName = new System.Windows.Forms.TextBox();
    // ... set properties, locations, etc.
    this.buttonGreet.Click += new System.EventHandler(this.buttonGreet_Click);
}

private System.Windows.Forms.Button buttonGreet;
private System.Windows.Forms.TextBox textBoxName;

3. Unit tests – xUnit example

// Production code
public class Calculator
{
    public int Add(int a, int b) => a + b;
}

// CalculatorTests.cs
using Xunit;

public class CalculatorTests
{
    [Fact]
    public void Add_TwoNumbers_ReturnsSum()
    {
        // Arrange
        var calculator = new Calculator();

        // Act
        var actual = calculator.Add(2, 3);

        // Assert
        Assert.Equal(5, actual);
    }

    [Theory]
    [InlineData(-1, 1, 0)]
    [InlineData(0, 0, 0)]
    [InlineData(10, 5, 15)]
    public void Add_VariousInputs_ReturnsExpected(int a, int b, int expected)
    {
        var calculator = new Calculator();

        var actual = calculator.Add(a, b);

        Assert.Equal(expected, actual);
    }
}

The [Fact] attribute marks a single test, while [Theory] with [InlineData] allows testing multiple input combinations with one test method.

4. GoF Design Pattern – Singleton and Factory examples

Singleton pattern

public sealed class AppConfig
{
    private static readonly Lazy<AppConfig> _instance =
        new Lazy<AppConfig>(() => new AppConfig());

    public static AppConfig Instance => _instance.Value;

    // Example configuration property
    public string ApplicationName { get; private set; }

    private AppConfig()
    {
        ApplicationName = "My Sample App";
    }
}

// Usage
var name = AppConfig.Instance.ApplicationName;

Factory pattern

public interface INotification
{
    void Send(string message);
}

public class EmailNotification : INotification
{
    public void Send(string message)
    {
        Console.WriteLine($"Email: {message}");
    }
}

public class SmsNotification : INotification
{
    public void Send(string message)
    {
        Console.WriteLine($"SMS: {message}");
    }
}

public static class NotificationFactory
{
    public static INotification Create(string channel)
    {
        return channel switch
        {
            "email" => new EmailNotification(),
            "sms"   => new SmsNotification(),
            _       => throw new ArgumentException("Unknown channel", nameof(channel))
        };
    }
}

// Usage
INotification notifier = NotificationFactory.Create("email");
notifier.Send("Hello from factory pattern!");

These snippets can be dropped into small projects (ASP.NET Core Web App, Windows Forms App, xUnit Test Project, and a class library/console app) to see them running end-to-end.

References:

Share via

Show me a usecase example code of asp.net, windows forms, unit tests and GoF

2 answers

1. ASP.NET Core MVC – simple controller returning data to a view

2. Windows Forms – button click event

3. Unit tests – xUnit example

4. GoF Design Pattern – Singleton and Factory examples

Singleton pattern

Factory pattern

Your answer