DEV Community: FaithInErrorsZORO

ASP.net Resting!

FaithInErrorsZORO — Wed, 04 Nov 2026 16:52:59 +0000

In this post we're cooking up two apps that work together:

FoodMenuApi, a REST API over a small restaurant database of dishes, their cuisines and categories, and which restaurants have them on the menu.
FoodMenuClient, an https://www.google.com/url?q=http://ASP.NET&source=gmail&ust=1793897479914000&sa=E Core MVC website that calls the API with HttpClient, so users can browse, search, add, edit and remove dishes through normal web forms.

Along the way we'll cover EF Core scaffolding, keeping controllers skinny with a repository, DTOs, CORS, proper HTTP status codes (including a 409 Conflict when you try to delete a dish that's still on a restaurant's menu), and a tiny JavaScript page that calls the API directly.

Here's the API we're building:

Method	URL	What it does
GET	`/api/dishes`	All dishes, sorted by name
GET	`/api/dishes/5`	One dish
GET	`/api/dishes?name=pad`	Dishes whose name starts with "pad", any case
POST	`/api/dishes`	Add a dish (data in the body)
PUT	`/api/dishes/5`	Update a dish (data in the body)
DELETE	`/api/dishes/5`	Delete a dish, or 409 if it's on a menu

The API runs on http://localhost:5050 and the MVC site on http://localhost:5060.

The finished project

Files marked ★ are ones we write or edit. Files marked ⚙ are generated by EF Core scaffolding.

FoodMenuSolution/
├── FoodMenu.sql ★ (database script)
│
├── FoodMenuApi/ ← Part 1: the REST API
│ ├── Controllers/
│ │ └── DishesController.cs ★
│ ├── DTOs/
│ │ ├── DishDTO.cs ★
│ │ └── DishInputDTO.cs ★
│ ├── Models/
│ │ ├── Category.cs ⚙
│ │ ├── Cuisine.cs ⚙
│ │ ├── Dish.cs ⚙
│ │ ├── FoodMenuContext.cs ⚙
│ │ ├── MenuItem.cs ⚙
│ │ └── Restaurant.cs ⚙
│ ├── Repositories/
│ │ ├── DishRepository.cs ★
│ │ └── IDishRepository.cs ★
│ ├── Properties/
│ │ └── launchSettings.json ★ (fixed port 5050)
│ ├── wwwroot/
│ │ └── index.html ★ (JavaScript page)
│ ├── appsettings.json ★
│ └── Program.cs ★
│
└── FoodMenuClient/ ← Part 2: the MVC website
├── Controllers/
│ ├── DishesController.cs ★
│ └── HomeController.cs (template)
├── Models/
│ ├── ApiResult.cs ★
│ ├── Dish.cs ★ ([DataContract] class)
│ └── ErrorViewModel.cs (template)
├── Services/
│ └── DishApiClient.cs ★ (all the HttpClient code)
├── Views/
│ ├── Dishes/
│ │ ├── Create.cshtml ★
│ │ ├── Delete.cshtml ★
│ │ ├── Details.cshtml ★
│ │ ├── Edit.cshtml ★
│ │ └── Index.cshtml ★
│ └── Shared/
│ └── _Layout.cshtml ★ (one nav link)
├── Properties/
│ └── launchSettings.json ★ (fixed port 5060)
├── appsettings.json ★
└── Program.cs ★

Part 1: The REST API

Step 1: Create the database

Our database has five tables. menu_items is the link table that says which restaurant serves which dish, and it's the reason some deletes will be refused later.

cuisines (cuisine_id PK, cuisine_name)
categories (category_id PK, category_name)
dishes (dish_id PK, dish_name, cuisine_id FK, category_id FK, calories, price)
restaurants (restaurant_id PK, restaurant_name, phone, city)
menu_items (restaurant_id PK/FK, dish_id PK/FK, daily_portions) ← links dishes to restaurants

Run this script in SQL Server (SSMS, or View → SQL Server Object Explorer in Visual Studio):

CREATE DATABASE FoodMenu;
GO
USE FoodMenu;
GO

CREATE TABLE cuisines (
cuisine_id INT IDENTITY(1,1) PRIMARY KEY,
cuisine_name VARCHAR(100) NOT NULL
);

CREATE TABLE categories (
category_id INT IDENTITY(1,1) PRIMARY KEY,
category_name VARCHAR(100) NOT NULL
);

CREATE TABLE dishes (
dish_id INT IDENTITY(1,1) PRIMARY KEY,
dish_name VARCHAR(255) NOT NULL,
cuisine_id INT NOT NULL REFERENCES cuisines(cuisine_id),
category_id INT NOT NULL REFERENCES categories(category_id),
calories INT NOT NULL,
price DECIMAL(10,2) NOT NULL
);

CREATE TABLE restaurants (
restaurant_id INT IDENTITY(1,1) PRIMARY KEY,
restaurant_name VARCHAR(255) NOT NULL,
phone VARCHAR(25) NULL,
city VARCHAR(100) NULL
);

CREATE TABLE menu_items (
restaurant_id INT NOT NULL REFERENCES restaurants(restaurant_id),
dish_id INT NOT NULL REFERENCES dishes(dish_id),
daily_portions INT NOT NULL,
PRIMARY KEY (restaurant_id, dish_id)
);

INSERT INTO cuisines (cuisine_name) VALUES
('Italian'), ('Japanese'), ('Mexican'), ('Thai'), ('Canadian'), ('Indian');

INSERT INTO categories (category_name) VALUES
('Appetizer'), ('Main'), ('Dessert'), ('Soup');

INSERT INTO dishes (dish_name, cuisine_id, category_id, calories, price) VALUES
('Margherita Pizza', 1, 2, 850, 16.50),
('Tiramisu', 1, 3, 450, 8.00),
('Salmon Sushi Roll', 2, 2, 400, 14.00),
('Miso Soup', 2, 4, 80, 4.50),
('Tacos al Pastor', 3, 2, 650, 13.00),
('Churros', 3, 3, 500, 6.50),
('Pad Thai', 4, 2, 700, 15.00),
('Tom Yum Soup', 4, 4, 200, 9.00),
('Poutine', 5, 2, 950, 11.00),
('Butter Tarts', 5, 3, 420, 5.00),
('Butter Chicken', 6, 2, 780, 17.00),
('Samosas', 6, 1, 300, 7.00),
('Pakoras', 6, 1, 350, 6.50);

INSERT INTO restaurants (restaurant_name, phone, city) VALUES
('Chez Gatineau', '819-555-0101', 'Gatineau'),
('Ottawa Eats', '613-555-0202', 'Ottawa');

-- Dishes 1, 3, 7 and 9 are on a menu, so deleting them gives 409 Conflict
INSERT INTO menu_items (restaurant_id, dish_id, daily_portions) VALUES
(1, 1, 40), (1, 9, 60), (2, 3, 30), (2, 7, 50);

Step 2: Create the Web API project

In Visual Studio: Create a new project → https://www.google.com/url?q=http://ASP.NET&source=gmail&ust=1793897479915000&sa=E Core Web API. Name the project FoodMenuApi and the solution FoodMenuSolution, and keep Use controllers checked.

Then install these four NuGet packages (right-click the project → Manage NuGet Packages), all published by Microsoft:

Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.Design
Microsoft.EntityFrameworkCore.SqlServer
Microsoft.EntityFrameworkCore.Tools

Delete the template's WeatherForecast.cs and Controllers/WeatherForecastController.cs, since we won't need them.

Step 3: Add the connection string

appsettings.json:

{
"ConnectionStrings": {
"FoodMenu": "Server=(localdb)\\MSSQLLocalDB;Database=FoodMenu;Trusted_Connection=True;TrustServerCertificate=True"
},
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"AllowedHosts": "*"
}

Using a different SQL Server? Swap in its connection string, for example Server=myserver, 1433;Database=FoodMenu;Authentication=Active Directory Default;TrustServerCertificate=True.

Step 4: Let EF Core write the models for us

Instead of typing out entity classes by hand, EF Core can scaffold them from the database. Open Tools → NuGet Package Manager → Package Manager Console, make sure the default project is FoodMenuApi, and run:

Scaffold-DbContext "Name=ConnectionStrings:FoodMenu" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models -Context FoodMenuContext -Force

Name=ConnectionStrings:FoodMenu reads the connection string from appsettings.json, so it doesn't end up in your code.
-OutputDir Models puts the classes in a Models folder.
-Context FoodMenuContext names the DbContext.
-Force lets you re-run it later.

You'll get Dish, Cuisine, Category, Restaurant, MenuItem and FoodMenuContext. Snake_case columns turn into PascalCase properties. Here's the generated Models/Dish.cs (you don't type this):

namespace FoodMenuApi.Models;

public partial class Dish
{
public int DishId { get; set; }
public string DishName { get; set; } = null!;
public int CuisineId { get; set; }
public int CategoryId { get; set; }
public int Calories { get; set; }
public decimal Price { get; set; }

public virtual Category Category { get; set; } = null!;
public virtual Cuisine Cuisine { get; set; } = null!;
public virtual ICollection<MenuItem> MenuItems { get; set; } = new List<MenuItem>();
}

The context exposes Dishes, Cuisines, Categories, Restaurants and MenuItems as DbSets.

Step 5: Pin the port

By default the port is random, which is annoying when another app needs to find your API. Fix it in Properties/launchSettings.json:

{
"$schema": "https://www.google.com/url?q=https://json.schemastore.org/launchsettings.json&source=gmail&ust=1793897479915000&sa=E",
"profiles": {
"http": {
"commandName": "Project",
"dotnetRunMessages": true,
"launchBrowser": true,
"launchUrl": "api/dishes",
"applicationUrl": "https://www.google.com/url?q=http://localhost:5050&source=gmail&ust=1793897479915000&sa=E",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
}
}
}

Pick the http profile from the dropdown next to the green Run button.

Step 6: DTOs, the public face of a dish

It's tempting to return the Dish entity straight from the API, but that causes problems:

It exposes database details like navigation properties and foreign keys the client doesn't care about.
Navigation properties can create loops when serialized.
If you accept Dish in a POST, [ApiController] validation complains that "The Cuisine field is required", because the navigation properties are non-nullable.

The fix is DTOs (Data Transfer Objects): small classes shaped for the outside world. Create a DTOs folder with two of them.

DTOs/DishDTO.cs is what the API sends out. It swaps unhelpful ids for readable names:

namespace FoodMenuApi.DTOs
{
public class DishDTO
{
public int DishId { get; set; }
public string DishName { get; set; } = string.Empty;
public int CuisineId { get; set; }
public string? CuisineName { get; set; }
public int CategoryId { get; set; }
public string? CategoryName { get; set; }
public int Calories { get; set; }
public decimal Price { get; set; }
}
}

DTOs/DishInputDTO.cs is what the API accepts for POST and PUT. There's no id because the database generates it:

using System.ComponentModel.DataAnnotations;

namespace FoodMenuApi.DTOs
{
public class DishInputDTO
{
[Required, StringLength(255)]
public string DishName { get; set; } = string.Empty;

[Range(1, int.MaxValue)]
public int CuisineId { get; set; }

[Range(1, int.MaxValue)]
public int CategoryId { get; set; }

[Range(0, 5000)]
public int Calories { get; set; }

[Range(0, 9999)]
public decimal Price { get; set; }
}
}

Step 7: A repository to keep the controller skinny

If you scaffold an API controller, Visual Studio stuffs all the EF Core code right inside it, which makes a "fat" controller. A cleaner approach is a repository: one class that owns all the data access, so the controller only deals with HTTP.

Create a Repositories folder. First the interface, Repositories/IDishRepository.cs:

using FoodMenuApi.DTOs;

namespace FoodMenuApi.Repositories
{
public enum DeleteResult { Deleted, NotFound, Conflict }

public interface IDishRepository
{
Task<List<DishDTO>> GetAllAsync(string? name);
Task<DishDTO?> GetByIdAsync(int id);
Task<DishDTO> AddAsync(DishInputDTO input);
Task<bool> UpdateAsync(int id, DishInputDTO input); // false = not found
Task<DeleteResult> DeleteAsync(int id);
}
}

Then the implementation, Repositories/DishRepository.cs:

using FoodMenuApi.DTOs;
using FoodMenuApi.Models;
using Microsoft.EntityFrameworkCore;

namespace FoodMenuApi.Repositories
{
public class DishRepository : IDishRepository
{
private readonly FoodMenuContext _context;

public DishRepository(FoodMenuContext context)
{
_context = context;
}

// Entity -> DTO (manual mapping)
private static DishDTO ToDto(Dish d) => new DishDTO
{
DishId = d.DishId,
DishName = d.DishName,
CuisineId = d.CuisineId,
CuisineName = d.Cuisine?.CuisineName,
CategoryId = d.CategoryId,
CategoryName = d.Category?.CategoryName,
Calories = d.Calories,
Price = d.Price
};

// All dishes, or only those whose name starts with `name` (any case), sorted by name
public async Task<List<DishDTO>> GetAllAsync(string? name)
{
IQueryable<Dish> query = _context.Dishes
.Include(d => d.Cuisine)
.Include(d => d.Category);

if (!string.IsNullOrWhiteSpace(name))
{
string lower = name.Trim().ToLower();
query = query.Where(d => d.DishName.ToLower().StartsWith(lower));
}

List<Dish> dishes = await query
.OrderBy(d => d.DishName)
.ToListAsync();

return dishes.Select(ToDto).ToList();
}

public async Task<DishDTO?> GetByIdAsync(int id)
{
Dish? dish = await _context.Dishes
.Include(d => d.Cuisine)
.Include(d => d.Category)
.FirstOrDefaultAsync(d => d.DishId == id);

return dish == null ? null : ToDto(dish);
}

public async Task<DishDTO> AddAsync(DishInputDTO input)
{
var dish = new Dish
{
DishName = input.DishName,
CuisineId = input.CuisineId,
CategoryId = input.CategoryId,
Calories = input.Calories,
Price = input.Price
};

_context.Dishes.Add(dish);
await _context.SaveChangesAsync(); // the database generates DishId here

return (await GetByIdAsync(dish.DishId))!;
}

public async Task<bool> UpdateAsync(int id, DishInputDTO input)
{
Dish? dish = await _context.Dishes.FindAsync(id); // find it first
if (dish == null) return false;

dish.DishName = input.DishName;
dish.CuisineId = input.CuisineId;
dish.CategoryId = input.CategoryId;
dish.Calories = input.Calories;
dish.Price = input.Price;

await _context.SaveChangesAsync();
return true;
}

public async Task<DeleteResult> DeleteAsync(int id)
{
Dish? dish = await _context.Dishes.FindAsync(id);
if (dish == null) return DeleteResult.NotFound;

// Referential integrity: a dish on a restaurant's menu can't be deleted
bool onAMenu = await _context.MenuItems.AnyAsync(m => m.DishId == id);
if (onAMenu) return DeleteResult.Conflict;

_context.Dishes.Remove(dish);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
return DeleteResult.Conflict; // any other foreign key problem
}
return DeleteResult.Deleted;
}
}
}

The search uses ToLower() on both sides plus StartsWith, so pad, PAD and pAd all find "Pad Thai".

Step 8: Wire it all up in Program.cs

Now we register the DbContext and the repository, and turn on CORS. Browsers block JavaScript from calling an API on a different origin (a different port counts) unless the API explicitly allows it. CORS is that permission.

using FoodMenuApi.Models;
using FoodMenuApi.Repositories;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// Database
builder.Services.AddDbContext<FoodMenuContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("FoodMenu")));

// Repository
builder.Services.AddScoped<IDishRepository, DishRepository>();

// CORS: allow JavaScript from other origins to call this API
builder.Services.AddCors(options =>
{
options.AddPolicy("AllowAll", policy =>
policy.AllowAnyOrigin()
.AllowAnyHeader()
.AllowAnyMethod());
});

builder.Services.AddControllers();
builder.Services.AddOpenApi(); // .NET 9+ template default; older templates use AddSwaggerGen()

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
app.MapOpenApi();
}

// app.UseHttpsRedirection(); // off: we're using plain https://www.google.com/url?q=http://localhost:5050&source=gmail&ust=1793897479915000&sa=E

app.UseDefaultFiles(); // "/" serves wwwroot/index.html
app.UseStaticFiles(); // serves files from wwwroot

app.UseCors("AllowAll"); // must come BEFORE MapControllers

app.UseAuthorization();

app.MapControllers();

app.Run();

Step 9: The (skinny) API controller

Right-click Controllers → Add → Controller → API → API Controller with actions, using Entity Framework. Pick model Dish, context FoodMenuContext, and name it DishesController (plural, which makes the route api/dishes). Then replace the generated code with this version, which only handles HTTP and leaves the data work to the repository:

using FoodMenuApi.DTOs;
using FoodMenuApi.Repositories;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace FoodMenuApi.Controllers
{
[Route("api/[controller]")] // → api/dishes
[ApiController]
public class DishesController : ControllerBase
{
private readonly IDishRepository _repo;

public DishesController(IDishRepository repo)
{
_repo = repo;
}

// GET api/dishes → all dishes, sorted
// GET api/dishes?name=pad → dishes starting with "pad"
[HttpGet]
public async Task<ActionResult<IEnumerable<DishDTO>>> GetDishes([FromQuery] string? name)
{
List<DishDTO> dishes = await _repo.GetAllAsync(name);

if (!string.IsNullOrWhiteSpace(name) && dishes.Count == 0)
return NotFound($"No dishes start with '{name}'.");

return Ok(dishes);
}

// GET api/dishes/5
[HttpGet("{id}")]
public async Task<ActionResult<DishDTO>> GetDish(int id)
{
DishDTO? dish = await _repo.GetByIdAsync(id);
if (dish == null)
return NotFound($"Dish {id} not found.");

return Ok(dish);
}

// POST api/dishes (dish in the body)
[HttpPost]
public async Task<ActionResult<DishDTO>> PostDish(DishInputDTO input)
{
try
{
DishDTO created = await _repo.AddAsync(input);
// 201 Created, with a Location header pointing at GetDish
return CreatedAtAction(nameof(GetDish), new { id = created.DishId }, created);
}
catch (DbUpdateException)
{
return BadRequest("Could not add the dish. Check that CuisineId and CategoryId exist.");
}
}

// PUT api/dishes/5 (dish in the body)
[HttpPut("{id}")]
public async Task<IActionResult> PutDish(int id, DishInputDTO input)
{
try
{
bool updated = await _repo.UpdateAsync(id, input);
if (!updated)
return NotFound($"Dish {id} not found.");

return NoContent(); // 204
}
catch (DbUpdateException)
{
return BadRequest("Could not update the dish. Check that CuisineId and CategoryId exist.");
}
}

// DELETE api/dishes/5
[HttpDelete("{id}")]
public async Task<IActionResult> DeleteDish(int id)
{
DeleteResult result = await _repo.DeleteAsync(id);

return result switch
{
DeleteResult.NotFound => NotFound($"Dish {id} not found."),
DeleteResult.Conflict => Conflict($"Dish {id} is on a restaurant's menu and can't be deleted."), // 409
_ => NoContent() // 204
};
}
}
}

A quick cheat sheet of the status codes we're returning:

Helper	Code	When
`Ok(x)`	200	GET worked
`CreatedAtAction(...)`	201	POST worked
`NoContent()`	204	PUT or DELETE worked
`BadRequest(msg)`	400	Bad data or a missing foreign key
`NotFound(msg)`	404	No such dish
`Conflict(msg)`	409	Dish is still on a menu

Step 10: A tiny JavaScript front end

To show CORS and fetch in action, add wwwroot/index.html (create the wwwroot folder if it isn't there). It opens at `https://www.google.com/url?q=http://localhost:5050/%60&source=gmail&ust=1793897479916000&sa=E.

`html
<!DOCTYPE html>

Dish Finder body { font-family: sans-serif; margin: 20px; } table { border-collapse: collapse; margin-top: 10px; } th, td { border: 1px solid #ccc; padding: 4px 8px; } #msg { color: darkred; }

🍜 Dish Finder

Search
Show all

Id	Dish	Cuisine	Category	Calories	Price

const apiUrl = "https://www.google.com/url?q=http://localhost:5050/api/dishes&source=gmail&ust=1793897479916000&sa=E";

async function load(name) {
const url = name ? ${apiUrl}?name=${encodeURIComponent(name)} : apiUrl;
document.getElementById("msg").textContent = "";
document.getElementById("rows").innerHTML = "";

try {
const response = await fetch(url);

if (!response.ok) {
document.getElementById("msg").textContent =
Error ${response.status}: ${await response.text()};
return;
}

const dishes = await response.json(); // JSON keys are camelCase

document.getElementById("rows").innerHTML = dishes.map(d => <tr> <td>${d.dishId}</td> <td>${d.dishName}</td> <td>${d.cuisineName ?? ""}</td> <td>${d.categoryName ?? ""}</td> <td>${d.calories}</td> <td>$${d.price.toFixed(2)}</td> </tr>).join("");
} catch (err) {
document.getElementById("msg").textContent = "Could not reach the API: " + err;
}
}

document.getElementById("btnAll").addEventListener("click", () => load(""));
document.getElementById("btnSearch").addEventListener("click",
() => load(document.getElementById("name").value));

Notice the JSON keys are camelCase (dishName, not DishName). https://www.google.com/url?q=http://ASP.NET&source=gmail&ust=1793897479916000&sa=E Core does that by default.

Step 11: Test the API with Postman

Before writing a client, make sure the API behaves. In Postman:

Test	Method	URL	Expected
All dishes	GET	`https://www.google.com/url?q=http://localhost:5050/api/dishes%60&source=gmail&ust=1793897479916000&sa=E	200, sorted A to Z
One dish	GET	`https://www.google.com/url?q=http://localhost:5050/api/dishes/7%60&source=gmail&ust=1793897479916000&sa=E	200, Pad Thai
Missing	GET	`https://www.google.com/url?q=http://localhost:5050/api/dishes/999%60&source=gmail&ust=1793897479916000&sa=E	404
Search	GET	`https://www.google.com/url?q=http://localhost:5050/api/dishes?name%3DPAk%60&source=gmail&ust=1793897479916000&sa=E	200, Pakoras
Add	POST	`https://www.google.com/url?q=http://localhost:5050/api/dishes%60&source=gmail&ust=1793897479916000&sa=E	201 with the new id
Update	PUT	`https://www.google.com/url?q=http://localhost:5050/api/dishes/%7BnewId%7D%60&source=gmail&ust=1793897479916000&sa=E	204
Delete (free)	DELETE	`https://www.google.com/url?q=http://localhost:5050/api/dishes/%7BnewId%7D%60&source=gmail&ust=1793897479916000&sa=E	204
Delete (on a menu)	DELETE	`https://www.google.com/url?q=http://localhost:5050/api/dishes/1%60&source=gmail&ust=1793897479916000&sa=E	409 Conflict

For POST and PUT, choose Body → raw → JSON:

json { "dishName": "Maple Pancakes", "cuisineId": 5, "categoryId": 3, "calories": 600, "price": 9.50 }

Part 2: Consuming the API from MVC

Our API works. Now let's give it a proper website.

Step 12: Add an MVC project to the same solution

Right-click the solution → Add → New Project → https://www.google.com/url?q=http://ASP.NET&source=gmail&ust=1793897479916000&sa=E Core Web App (Model-View-Controller) → name it FoodMenuClient.

To run both at once, right-click the solution → Configure Startup Projects → Multiple startup projects, and set both to Start.

The 12-step recipe for calling a REST API

Every call in the client follows the same recipe. Here's where each step shows up in the code below:

#	Step	Where
1	A controller action, with an optional id	`DishesController` (client)
2	Create an `HttpClient`	`DishApiClient.CreateClient()`
3	Clear the default headers	`Accept.Clear()`
4	Accept `application/json`	`Accept.Add(...)`
5	Build the URI string	`_baseUrl` + id or `?name=`
6	Read the response as a stream	`ReadAsStreamAsync()`
7	A class whose properties match the JSON	`Models/Dish.cs`
8	Mark it with `[DataContract]` / `[DataMember]`	`Models/Dish.cs`
9	Give it constructors	`Models/Dish.cs`
10	Deserialize with `DataContractJsonSerializer`	`DishApiClient.Read<T>()`
11	Wait for `ReadObject` to finish	`DishApiClient.Read<T>()`
12	Pass the result to the view	`DishesController`

Step 13: Pin the client's port and store the API URL

Properties/launchSettings.json:

json { "$schema": "https://www.google.com/url?q=https://json.schemastore.org/launchsettings.json&source=gmail&ust=1793897479916000&sa=E", "profiles": { "http": { "commandName": "Project", "dotnetRunMessages": true, "launchBrowser": true, "applicationUrl": "https://www.google.com/url?q=http://localhost:5060&source=gmail&ust=1793897479916000&sa=E", "environmentVariables": { "ASPNETCORE_ENVIRONMENT": "Development" } } } }

appsettings.json:

json { "Logging": { "LogLevel": { "Default": "Information", "Microsoft.AspNetCore": "Warning" } }, "AllowedHosts": "*", "DishesApi": { "BaseUrl": "https://www.google.com/url?q=http://localhost:5050/api/dishes&source=gmail&ust=1793897479916000&sa=E" } }

Step 14: A model that matches the JSON

The client needs its own Dish class shaped like the API's JSON. Each [DataMember(Name = "...")] must match a JSON key exactly, camelCase included.

Models/Dish.cs:

`csharp
using System.ComponentModel.DataAnnotations;
using System.Runtime.Serialization;

namespace FoodMenuClient.Models
{
[DataContract]
public class Dish
{
[DataMember(Name = "dishId")]
[Display(Name = "Id")]
public int DishId { get; set; }

[DataMember(Name = "dishName")]
[Display(Name = "Dish")]
[Required]
public string DishName { get; set; } = string.Empty;

[DataMember(Name = "cuisineId")]
[Display(Name = "Cuisine Id")]
public int CuisineId { get; set; }

[DataMember(Name = "cuisineName")]
[Display(Name = "Cuisine")]
public string? CuisineName { get; set; }

[DataMember(Name = "categoryId")]
[Display(Name = "Category Id")]
public int CategoryId { get; set; }

[DataMember(Name = "categoryName")]
[Display(Name = "Category")]
public string? CategoryName { get; set; }

[DataMember(Name = "calories")]
[Display(Name = "Calories")]
public int Calories { get; set; }

[DataMember(Name = "price")]
[Display(Name = "Price")]
public decimal Price { get; set; }

public Dish() { }

public Dish(int dishId, string dishName, int cuisineId, int categoryId, int calories, decimal price)
{
DishId = dishId;
DishName = dishName;
CuisineId = cuisineId;
CategoryId = categoryId;
Calories = calories;
Price = price;
}
}
}
`

We'll also want the status code along with the data, so the UI can say things like "404, not found". Models/ApiResult.cs is a small wrapper for that:

csharp namespace FoodMenuClient.Models { public class ApiResult<T> { public T? Data { get; set; } public int StatusCode { get; set; } public bool Success { get; set; } public string? Message { get; set; } } }

Step 15: One class for all the HTTP calls

Just like the repository on the API side, we'll keep HttpClient code out of the controller. Create a Services folder and add DishApiClient.cs:

`csharp
using System.Net.Http.Headers;
using System.Runtime.Serialization.Json;
using System.Text;
using FoodMenuClient.Models;

namespace FoodMenuClient.Services
{
public class DishApiClient
{
private readonly string _baseUrl;

public DishApiClient(IConfiguration config)
{
_baseUrl = config["DishesApi:BaseUrl"]
?? throw new InvalidOperationException("DishesApi:BaseUrl is missing from appsettings.json");
}

// Steps 2-4: create the client, clear headers, accept JSON
private static HttpClient CreateClient()
{
var client = new HttpClient();
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
return client;
}

// Steps 6, 10 and 11: stream → DataContractJsonSerializer → object
private static async Task Read(HttpResponseMessage response)
{
using Stream stream = await response.Content.ReadAsStreamAsync();
var serializer = new DataContractJsonSerializer(typeof(T));
return (T)serializer.ReadObject(stream)!;
}

// Object → JSON request body (for POST and PUT)
private static StringContent ToJson(Dish dish)
{
var serializer = new DataContractJsonSerializer(typeof(Dish));
using var ms = new MemoryStream();
serializer.WriteObject(ms, dish);
string json = Encoding.UTF8.GetString(ms.ToArray());
return new StringContent(json, Encoding.UTF8, "application/json");
}

private static ApiResult Fail(HttpResponseMessage response, string body) => new ApiResult
{
StatusCode = (int)response.StatusCode,
Success = false,
Message = string.IsNullOrWhiteSpace(body) ? response.ReasonPhrase : body
};

private static ApiResult Unreachable(Exception ex) => new ApiResult
{
StatusCode = 0,
Success = false,
Message = "Could not reach the API. Is FoodMenuApi running? " + ex.Message
};

// GET api/dishes or api/dishes?name=xxx
public async Task>> GetAllAsync(string? name)
{
using HttpClient client = CreateClient();
string uri = string.IsNullOrWhiteSpace(name)
? _baseUrl
: $"{_baseUrl}?name={Uri.EscapeDataString(name)}"; // step 5

try
{
HttpResponseMessage response = await client.GetAsync(uri);
if (!response.IsSuccessStatusCode)
return Fail>(response, await response.Content.ReadAsStringAsync());

return new ApiResult>
{
Data = await Read>(response),
StatusCode = (int)response.StatusCode,
Success = true
};
}
catch (HttpRequestException ex) { return Unreachable>(ex); }
}

// GET api/dishes/5
public async Task> GetByIdAsync(int id)
{
using HttpClient client = CreateClient();
try
{
HttpResponseMessage response = await client.GetAsync($"{_baseUrl}/{id}");
if (!response.IsSuccessStatusCode)
return Fail(response, await response.Content.ReadAsStringAsync());

return new ApiResult
{
Data = await Read(response),
StatusCode = (int)response.StatusCode,
Success = true
};
}
catch (HttpRequestException ex) { return Unreachable(ex); }
}

// POST api/dishes
public async Task> CreateAsync(Dish dish)
{
using HttpClient client = CreateClient();
try
{
HttpResponseMessage response = await client.PostAsync(_baseUrl, ToJson(dish));
if (!response.IsSuccessStatusCode)
return Fail(response, await response.Content.ReadAsStringAsync());

return new ApiResult
{
Data = await Read(response), // the API sends back the new dish
StatusCode = (int)response.StatusCode,
Success = true,
Message = "Dish added."
};
}
catch (HttpRequestException ex) { return Unreachable(ex); }
}

// PUT api/dishes/5
public async Task> UpdateAsync(int id, Dish dish)
{
using HttpClient client = CreateClient();
try
{
HttpResponseMessage response = await client.PutAsync($"{_baseUrl}/{id}", ToJson(dish));
if (!response.IsSuccessStatusCode)
return Fail(response, await response.Content.ReadAsStringAsync());

return new ApiResult
{
Data = true,
StatusCode = (int)response.StatusCode,
Success = true,
Message = $"Dish {id} updated."
};
}
catch (HttpRequestException ex) { return Unreachable(ex); }
}

// DELETE api/dishes/5
public async Task> DeleteAsync(int id)
{
using HttpClient client = CreateClient();
try
{
HttpResponseMessage response = await client.DeleteAsync($"{_baseUrl}/{id}");
if (!response.IsSuccessStatusCode)
return Fail(response, await response.Content.ReadAsStringAsync());

return new ApiResult
{
Data = true,
StatusCode = (int)response.StatusCode,
Success = true,
Message = $"Dish {id} deleted."
};
}
catch (HttpRequestException ex) { return Unreachable(ex); }
}
}
}
`

Two things worth knowing about DataContractJsonSerializer:

A single object deserializes as Read<Dish>, and an array as Read<List<Dish>>.
It can't parse ISO date strings like "2026-11-04T12:00:00" into DateTime. If an API you're calling returns dates, make those properties string.

Step 16: Register the API client

The client's Program.cs is the MVC template with one line added:

`csharp
using FoodMenuClient.Services;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();
builder.Services.AddScoped(); // ★ added

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Home/Error");
app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();
`

Step 17: The MVC controller

Right-click Controllers → Add → Controller → MVC Controller - Empty → DishesController. Each action calls the API client and decides which view or message to show:

`csharp
using FoodMenuClient.Models;
using FoodMenuClient.Services;
using Microsoft.AspNetCore.Mvc;

namespace FoodMenuClient.Controllers
{
public class DishesController : Controller
{
private readonly DishApiClient _api;

public DishesController(DishApiClient api)
{
_api = api;
}

// GET /Dishes or /Dishes?name=pad
public async Task Index(string? name)
{
ApiResult> result = await _api.GetAllAsync(name);

ViewBag.Search = name;
ViewBag.Status = result.StatusCode;
ViewBag.Error = result.Success ? null : result.Message;

return View(result.Data ?? new List()); // step 12
}

// GET /Dishes/Details/5
public async Task Details(int id)
{
ApiResult result = await _api.GetByIdAsync(id);
if (!result.Success)
{
TempData["Error"] = $"({result.StatusCode}) {result.Message}";
return RedirectToAction(nameof(Index));
}
ViewBag.Status = result.StatusCode;
return View(result.Data);
}

// GET /Dishes/Create
[HttpGet]
public IActionResult Create()
{
return View(new Dish());
}

// POST /Dishes/Create
[HttpPost]
[ValidateAntiForgeryToken]
public async Task Create(Dish dish)
{
if (!ModelState.IsValid) return View(dish);

ApiResult result = await _api.CreateAsync(dish);
if (!result.Success)
{
ViewBag.Error = $"({result.StatusCode}) {result.Message}";
return View(dish);
}

TempData["Message"] = $"({result.StatusCode}) Dish added with id {result.Data!.DishId}.";
return RedirectToAction(nameof(Details), new { id = result.Data.DishId });
}

// GET /Dishes/Edit/5 → form pre-filled with the current values
[HttpGet]
public async Task Edit(int id)
{
ApiResult result = await _api.GetByIdAsync(id);
if (!result.Success)
{
TempData["Error"] = $"({result.StatusCode}) {result.Message}";
return RedirectToAction(nameof(Index));
}
return View(result.Data);
}

// POST /Dishes/Edit/5
[HttpPost]
[ValidateAntiForgeryToken]
public async Task Edit(int id, Dish dish)
{
if (!ModelState.IsValid) return View(dish);

ApiResult result = await _api.UpdateAsync(id, dish);
if (!result.Success)
{
ViewBag.Error = $"({result.StatusCode}) {result.Message}";
return View(dish);
}

TempData["Message"] = $"({result.StatusCode}) {result.Message}";
return RedirectToAction(nameof(Details), new { id });
}

// GET /Dishes/Delete/5 → "are you sure?" page
[HttpGet]
public async Task Delete(int id)
{
ApiResult result = await _api.GetByIdAsync(id);
if (!result.Success)
{
TempData["Error"] = $"({result.StatusCode}) {result.Message}";
return RedirectToAction(nameof(Index));
}
return View(result.Data);
}

// POST /Dishes/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task DeleteConfirmed(int id)
{
ApiResult result = await _api.DeleteAsync(id);

if (result.Success)
TempData["Message"] = $"({result.StatusCode}) {result.Message}";
else if (result.StatusCode == 409)
TempData["Error"] = $"(409) Dish {id} is on a restaurant's menu, so it can't be deleted.";
else
TempData["Error"] = $"({result.StatusCode}) {result.Message}";

return RedirectToAction(nameof(Index));
}
}
}
`

Step 18: The views

Create the folder Views/Dishes and add five views.

A note on the Razor style: these views use explicit expressions like @(Model.DishName) and wrap if/foreach inside @{ ... } blocks. That's standard Razor and behaves exactly like the shorter form without parentheses that you may be used to. Either style works in Visual Studio.

Index.cshtml: the menu, with search

`html
@model List
@{
ViewData["Title"] = "Dishes";
}

🍽️ Dishes

@{
if (TempData["Message"] != null)
{

@(TempData["Message"])

}
if (TempData["Error"] != null)
{

@(TempData["Error"])

}
if (ViewBag.Error != null)
{

(@(ViewBag.Status)) @(ViewBag.Error)

}
}

Search Show all Add a dish Find by id

Status returned: @(ViewBag.Status) | @(Model.Count) dish(es)

@{ foreach (var d in Model) { } }

Id	Dish	Cuisine	Category	Calories	Price
@(d.DishId)	@(d.DishName)	@(d.CuisineName)	@(d.CategoryName)	@(d.Calories)	@(d.Price.ToString("C"))	Details \| Edit \| Delete

Details.cshtml

`html
@model FoodMenuClient.Models.Dish
@{
ViewData["Title"] = "Dish Details";
}

@(Model.DishName)

@{
if (TempData["Message"] != null)
{

@(TempData["Message"])

}
}

Status returned: @(ViewBag.Status)

Id: @(Model.DishId)
Cuisine: @(Model.CuisineName) (id @(Model.CuisineId))
Category: @(Model.CategoryName) (id @(Model.CategoryId))
Calories: @(Model.Calories) kcal
Price: @(Model.Price.ToString("C"))

Edit
Delete
Back to dishes
`

Create.cshtml

The asp-for tag helpers build each label and input from the model, and asp-validation-for shows any validation error for that field.

`html
@model FoodMenuClient.Models.Dish
@{
ViewData["Title"] = "Add a Dish";
}

Add a Dish

@{
if (ViewBag.Error != null)
{

@(ViewBag.Error)

}
}

Add
Cancel

Edit.cshtml

`html
@model FoodMenuClient.Models.Dish
@{
ViewData["Title"] = "Edit Dish";
}

Edit: @(Model.DishName)

@{
if (ViewBag.Error != null)
{

@(ViewBag.Error)

}
}

Save
Cancel

Delete.cshtml

`html
@model FoodMenuClient.Models.Dish
@{
ViewData["Title"] = "Delete Dish";
}

Delete this dish?

Id: @(Model.DishId)
Dish: @(Model.DishName)
Cuisine: @(Model.CuisineName)
Price: @(Model.Price.ToString("C"))

Delete
Cancel

Add a nav link in Views/Shared/_Layout.cshtml

html <li class="nav-item"> <a class="nav-link text-dark" asp-area="" asp-controller="Dishes" asp-action="Index">Dishes</a> </li>

Step 19: Run the whole thing

Hit Start and both apps launch: the API on 5050 and the website on 5060. Head to `https://www.google.com/url?q=http://localhost:5060/Dishes%60&source=gmail&ust=1793897479917000&sa=E and try it out:

The dish list comes back sorted alphabetically.
Searching pAD finds Pad Thai, and searching zzz shows a friendly 404 message.
Find by id with 999 explains that the dish doesn't exist instead of crashing.
Add a dish creates "Maple Pancakes" and takes you to its details page with its new id.
Edit updates it.
Delete works on your new dish (204), but trying to delete Margherita Pizza (id 1) is refused with a 409, because it's on Chez Gatineau's menu.

And `https://www.google.com/url?q=http://localhost:5050/%60&source=gmail&ust=1793897479917000&sa=E still serves the little JavaScript Dish Finder.

Here's what happens on a single page load:

text Browser ──► FoodMenuClient (MVC, :5060) DishesController.Index() └─► DishApiClient.GetAllAsync() HttpClient GET https://www.google.com/url?q=http://localhost:5050/api/dishes&source=gmail&ust=1793897479917000&sa=E │ ▼ FoodMenuApi (Web API, :5050) DishesController.GetDishes() (skinny) └─► DishRepository.GetAllAsync() (LINQ + EF Core) └─► SQL Server (FoodMenu database) │ JSON ◄──────────────┘ [ { "dishId": 7, "dishName": "Pad Thai", ... } ] │ DataContractJsonSerializer → List<Dish> │ View(List<Dish>) → HTML table

Troubleshooting

"The Cuisine field is required" on POST. The API is accepting the Dish entity instead of DishInputDTO.
"blocked by CORS policy" in the browser console. AddCors/UseCors is missing, or UseCors comes after MapControllers.
"Could not reach the API" in the website. The API isn't running, or the port in the client's appsettings.json doesn't match the API's launchSettings.json.
Blank values in the website. A [DataMember(Name = "...")] doesn't match the JSON key exactly. Compare against the JSON in Postman.
Search is case sensitive. You forgot ToLower() on one side of the comparison.

Reusing this for other APIs

Calling someone else's API: open it in Postman, build a [DataContract] class that matches its JSON, change BaseUrl, and copy DishApiClient with your class swapped in.
Building an API over a different database: scaffold it, write DTOs, add a repository and its interface, register them in Program.cs, and keep the controller focused on HTTP.

Wrapping up

We built a REST API with EF Core, kept the controller lean with a repository, shaped responses with DTOs, returned meaningful status codes, opened it to JavaScript with CORS, and then built an MVC site that calls it through HttpClient. The recipe is the same whatever's on the menu. 🍕

ASP.net Consuming soap!

FaithInErrorsZORO — Wed, 04 Nov 2026 16:44:34 +0000

SOAP feels old next to REST and JSON, but plenty of companies still run SOAP services, and .NET makes calling one surprisingly painless. In this post we'll build a small Food Trip Planner: you type in a country you want to eat your way through, and the app tells you what you need to know before booking the flight.

the country's code
the capital city (where you'll probably land and eat first)
the currency you'll be paying for meals in
the phone code, for calling ahead to book restaurants
the country's flag
a signature dish to try first

All the country data comes from the free CountryInfo SOAP service:

https://www.google.com/url?q=http://webservices.oorsprong.org/websamples.countryinfo/CountryInfoService.wso&source=gmail&ust=1793896833444000&sa=E

The trick is that we can't get everything in one call. We first ask the service for the country's ISO code, then use that code for every other call. (The service has a FullCountryInfo method that returns everything at once, but we'll skip it on purpose, since chaining calls is the skill worth practicing.)

Let's build it.

What the finished project looks like

Here's every file we'll touch. Files marked ★ are ones we write or edit. Everything else comes from the template or is generated by Visual Studio.

FoodTripPlanner/ (solution)
└── FoodTripPlanner/ (project)
├── Connected Services/
│ └── ServiceReferenceCountryInfo/
│ ├── ConnectedService.json (generated)
│ └── Reference.cs (generated: the SOAP client)
├── Controllers/
│ ├── HomeController.cs (template)
│ └── TripController.cs ★
├── Models/
│ ├── ErrorViewModel.cs (template)
│ └── TripInfo.cs ★
├── Services/
│ └── TripPlannerService.cs ★ (all the SOAP calls live here)
├── Views/
│ ├── Home/ ... (template)
│ ├── Shared/
│ │ └── _Layout.cshtml ★ (one nav link)
│ └── Trip/
│ ├── Index.cshtml ★ (search form)
│ └── Result.cshtml ★ (trip card)
├── wwwroot/ ... (template)
├── appsettings.json ★ (service URL)
└── Program.cs ★ (register our service)

Step 1: Create the MVC project

Open Visual Studio and choose Create a new project → https://www.google.com/url?q=http://ASP.NET&source=gmail&ust=1793896833444000&sa=E Core Web App (Model-View-Controller). Name it FoodTripPlanner, pick the latest .NET version, and leave Authentication on None.

Step 2: Point Visual Studio at the WSDL

A SOAP service describes itself in a WSDL file. Visual Studio reads it and generates a ready-to-use C# client for us. The WSDL lives at the service URL plus ?WSDL.

In Solution Explorer, right-click the project → Add → Service Reference... (or right-click Connected Services → Add → WCF Web Service).
Choose WCF Web Service and click Next.
Paste in `https://www.google.com/url?q=http://webservices.oorsprong.org/websamples.countryinfo/CountryInfoService.wso?WSDL%60&source=gmail&ust=1793896833445000&sa=E and click Go.
Set the namespace to ServiceReferenceCountryInfo.
Click Finish.

Visual Studio installs the System.ServiceModel.* NuGet packages and generates Reference.cs. These are the parts of it we'll use:

What	Name
Client class	`CountryInfoServiceSoapTypeClient`
Endpoint enum	`CountryInfoServiceSoapTypeClient.EndpointConfiguration.CountryInfoServiceSoap`
Currency type	`tCurrency`, with `sISOCode` and `sName`
Methods	`CountryISOCodeAsync`, `CapitalCityAsync`, `CountryCurrencyAsync`, `CountryIntPhoneCodeAsync`, `CountryFlagAsync`

A note on .Body: depending on how the reference was generated, each call returns a response object with the value inside .Body, like (await client.CapitalCityAsync(code)).Body.CapitalCityResult. That's the version used in this post. If IntelliSense doesn't show .Body for you, the method returns the value directly, so just use await client.CapitalCityAsync(code).

Step 3: Keep the service URL in appsettings.json

Hard-coding URLs is a habit worth avoiding. Put it in config so it can change without recompiling:

json { "Logging": { "LogLevel": { "Default": "Information", "Microsoft.AspNetCore": "Warning" } }, "AllowedHosts": "*", "CountryInfoService": { "Url": "https://www.google.com/url?q=http://webservices.oorsprong.org/websamples.countryinfo/CountryInfoService.wso&source=gmail&ust=1793896833445000&sa=E" } }

Notice it's plain http. This free service doesn't do https.

Step 4: A model to collect the results

Since the answers arrive one call at a time, we need somewhere to keep them. Models/TripInfo.cs gets one property per piece of information. We fill it in as each call comes back, then hand the finished object to the view.

`csharp
namespace FoodTripPlanner.Models
{
public class TripInfo
{
public string CountryName { get; set; } = string.Empty;
public string? IsoCode { get; set; }
public string? Capital { get; set; }
public string? Currency { get; set; }
public string? CurrencyCode { get; set; }
public string? PhoneCode { get; set; }
public string? FlagUrl { get; set; }
public string? SignatureDish { get; set; }
public string? ErrorMessage { get; set; }

// True when nothing went wrong
public bool Found => string.IsNullOrEmpty(ErrorMessage);
}
}
`

Step 5: The service class that talks SOAP

This is the heart of the app. Rather than cramming SOAP calls into a controller, we'll put them in their own class. Create a Services folder and add TripPlannerService.cs:

`csharp
using System.Globalization;
using System.ServiceModel;
using FoodTripPlanner.Models;
using ServiceReferenceCountryInfo;

namespace FoodTripPlanner.Services
{
public class TripPlannerService
{
private readonly string _serviceUrl;

// Our own little bit of data: what to eat first, keyed by ISO code
private static readonly Dictionary SignatureDishes = new()
{
["CA"] = "Poutine",
["IT"] = "Neapolitan pizza",
["ZA"] = "Bobotie",
["JP"] = "Sushi",
["MX"] = "Tacos al pastor",
["FR"] = "Coq au vin",
["IN"] = "Butter chicken",
["TH"] = "Pad thai",
["GR"] = "Moussaka",
["KR"] = "Bibimbap"
};

public TripPlannerService(IConfiguration config)
{
_serviceUrl = config["CountryInfoService:Url"]
?? throw new InvalidOperationException("CountryInfoService:Url is missing from appsettings.json");
}

public async Task PlanAsync(string countryName)
{
var trip = new TripInfo { CountryName = countryName };

if (string.IsNullOrWhiteSpace(countryName))
{
trip.ErrorMessage = "Please enter a country.";
return trip;
}

// The service is case sensitive, so "south africa" has to become "South Africa"
string name = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(countryName.Trim().ToLower());
trip.CountryName = name;

// Build the client using the URL from appsettings.json
var client = new CountryInfoServiceSoapTypeClient(
CountryInfoServiceSoapTypeClient.EndpointConfiguration.CountryInfoServiceSoap,
_serviceUrl);

try
{
// Call 1: country name -> ISO code
var isoResponse = await client.CountryISOCodeAsync(name);
string code = isoResponse.Body.CountryISOCodeResult;

// An unknown country is NOT an exception, the service just returns this text
if (string.IsNullOrWhiteSpace(code) || code.StartsWith("No country found"))
{
trip.ErrorMessage = "No country found by that name";
return trip;
}
trip.IsoCode = code;

// Calls 2-5 all use the code from call 1
var capitalResponse = await client.CapitalCityAsync(code);
trip.Capital = capitalResponse.Body.CapitalCityResult;

// Currency comes back as an OBJECT (tCurrency), not a string
var currencyResponse = await client.CountryCurrencyAsync(code);
tCurrency currency = currencyResponse.Body.CountryCurrencyResult;
trip.Currency = string.IsNullOrWhiteSpace(currency?.sName) ? "None" : currency.sName;
trip.CurrencyCode = currency?.sISOCode;

var phoneResponse = await client.CountryIntPhoneCodeAsync(code);
trip.PhoneCode = phoneResponse.Body.CountryIntPhoneCodeResult;

var flagResponse = await client.CountryFlagAsync(code);
trip.FlagUrl = flagResponse.Body.CountryFlagResult;

// Our own data, also keyed by the ISO code
trip.SignatureDish = SignatureDishes.TryGetValue(code, out string? dish)
? dish
: "Ask a local!";
}
catch (Exception ex)
{
trip.ErrorMessage = "The country service could not be reached: " + ex.Message;
}
finally
{
// Always close the connection (Abort if it broke)
if (client.State == CommunicationState.Faulted)
client.Abort();
else
await client.CloseAsync();
}

return trip;
}
}
}
`

A few details worth pointing out:

Case sensitivity. canada returns nothing and Canada works, so ToTitleCase normalizes whatever the user types.
"Not found" isn't an error. The service happily returns the string "No country found by that name", so we check for it ourselves.
Currency is a record. Every other call returns a string, but CountryCurrency returns a tCurrency object. Grab .sName for the display name.
Closing the client. WCF clients hold a connection open, so close them when you're done.

If your generated client has no .Body, the calls simply become:

csharp string code = await client.CountryISOCodeAsync(name); trip.Capital = await client.CapitalCityAsync(code); tCurrency currency = await client.CountryCurrencyAsync(code); trip.PhoneCode = await client.CountryIntPhoneCodeAsync(code); trip.FlagUrl = await client.CountryFlagAsync(code);

Step 6: Register the service in Program.cs

To get the service injected into our controller, register it. This is the template's Program.cs with one line added:

`csharp
using FoodTripPlanner.Services;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();
builder.Services.AddScoped(); // ★ added

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Home/Error");
app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();
`

If your template uses app.MapStaticAssets() and .WithStaticAssets(), keep those and just add the AddScoped line.

Step 7: A small controller

Because the service does the heavy lifting, the controller stays tiny. Right-click Controllers → Add → Controller → MVC Controller - Empty → TripController:

`csharp
using FoodTripPlanner.Models;
using FoodTripPlanner.Services;
using Microsoft.AspNetCore.Mvc;

namespace FoodTripPlanner.Controllers
{
public class TripController : Controller
{
private readonly TripPlannerService _planner;

public TripController(TripPlannerService planner)
{
_planner = planner;
}

// GET /Trip -> the search form
[HttpGet]
public IActionResult Index()
{
return View();
}

// POST /Trip -> call the SOAP service and show the result
[HttpPost]
[ValidateAntiForgeryToken]
public async Task Index(string countryName)
{
TripInfo trip = await _planner.PlanAsync(countryName);
return View("Result", trip);
}
}
}
`

Step 8: The search form

Create a Trip folder under Views, then add Index.cshtml:

`html
@{
ViewData["Title"] = "Plan a Food Trip";
}

🍽️ Plan a Food Trip

Where do you want to eat next? Enter a country and we'll get you ready.

Country

Plan my trip

Step 9: The trip card

Views/Trip/Result.cshtml shows either the error or the full trip card. Note the flag is shown as an actual image, not a link:

`html
@model FoodTripPlanner.Models.TripInfo
@{
ViewData["Title"] = "Your Food Trip";
}

Food trip to @Model.CountryName

@if (!Model.Found)
{

@Model.ErrorMessage

}
else
{

Country code	@Model.IsoCode
Land in (capital)	@Model.Capital
Pay for meals in	@Model.Currency (@Model.CurrencyCode)
Phone code for reservations	+@Model.PhoneCode
Eat this first	@Model.SignatureDish

}

Plan another trip
`

Step 10: Add it to the navigation

Open Views/Shared/_Layout.cshtml, find the <ul class="navbar-nav ..."> list and add one item:

`html

Home
Privacy
Plan a Trip

Step 11: Take it for a spin

Run the app, click Plan a Trip, and try a few countries:

You type	Code	Capital	Currency	Signature dish
Canada	CA	Ottawa	Canadian Dollars	Poutine
italy	IT	Rome	Euro	Neapolitan pizza
South Africa	ZA	Cape Town	South Africa Rands	Bobotie
Bouvet Island	BV	None	Krone	Ask a local!
Wakanda	No country found by that name

Lowercase italy works thanks to ToTitleCase, and the made-up country gets a friendly message instead of a crash.

Here's how the calls chain together behind the scenes:

text User types "italy" │ ▼ ToTitleCase → "Italy" CountryISOCode("Italy") ──► "IT" (or "No country found by that name" → stop) │ ├─► CapitalCity("IT") ──► "Rome" ├─► CountryCurrency("IT") ──► tCurrency { sISOCode = "EUR", sName = "Euro" } ├─► CountryIntPhoneCode("IT") ──► "39" ├─► CountryFlag("IT") ──► "https://www.google.com/url?q=http://www.oorsprong.org/.../Italy.jpg&source=gmail&ust=1793896833445000&sa=E" └─► SignatureDishes["IT"] ──► "Neapolitan pizza" (our own data) │ ▼ TripInfo object → Result.cshtml

Using a different SOAP service

The same recipe works for any SOAP service:

Add → Service Reference with the new service's ?WSDL URL.
Open Connected Services/<YourNamespace>/Reference.cs and search for class and Async( to find the client class, the EndpointConfiguration enum, and each method's parameters and return types.
Put the URL in appsettings.json.
Call it with the same pattern:

csharp var client = new XxxSoapClient(XxxSoapClient.EndpointConfiguration.XxxSoap, url); var response = await client.SomeMethodAsync(arg); var value = response.Body.SomeMethodResult; // or: var value = await client.SomeMethodAsync(arg); await client.CloseAsync();

If a method returns an object (like tCurrency), check its properties in Reference.cs.
Watch for "not found" values coming back as normal text, not just exceptions.

Wrapping up

With a generated client, calling SOAP from https://www.google.com/url?q=http://ASP.NET&source=gmail&ust=1793896833445000&sa=E Core comes down to: add the reference, create the client with a URL from config, await each method, and read the result (sometimes out of .Body). The pattern worth remembering is chaining: one call gives you a key, and that key unlocks the rest. Bon appétit! 🍝

Writing tests in python?

FaithInErrorsZORO — Wed, 14 Oct 2026 02:28:10 +0000

from colorama import init, Fore
from duration import *

def print_pass(the_data, i):
print(f'{Fore.GREEN}Test {i} with {the_data} passed')

def print_fail(the_data, i):
print(f'''{Fore.RED}*** Test {i} with {the_data} failed.''')

def print_tests():
_test_default = Duration(60)
_test_minutes = Duration(10, "m")
_test_hours = Duration(2, "h")
_test_sec = Duration(120, "s")

print('''

Test #1 - simple declarations
-----------------------------''')
test_objects = (
_test_default,
_test_minutes,
_test_hours,
_test_sec
)

test_print_out = (
    "60.00 s",
    "600.00 s",
    "7200.00 s",
    "120.00 s"
)

test_repr_out = (
    "Duration(60.00, 's')",
    "Duration(10.00, 'm')",
    "Duration(2.00, 'h')",
    "Duration(120.00, 's')"
)

for i, test_obj in enumerate(test_objects):
    try:
        assert str(test_obj) == test_print_out[i], f'Expected {test_print_out[i]} received {str(test_obj)}'
        print_pass(f'print of {test_obj}', i+1)
        assert repr(test_obj) == test_repr_out[i], f'Expected {test_repr_out[i]} received {repr(test_obj)}'
        print_pass(f'repr of {repr(test_obj)}', i+1)

    except AssertionError as test_data:
        print_fail(test_data, i+1)
        continue

def add_tests():
print('''

Test #2 - Addition
------------------''')
_test_default = Duration(60)
_test_minutes = Duration(5, "m")
_test_hours = Duration(1, "h")
_test_list = [Duration(10), Duration(2, 'm'), Duration(1, 'h')]
_test_inc = Duration(60)

test_objects = (
    _test_default + _test_minutes,
    _test_default + 30,
    sum(_test_list),
    15 + _test_minutes
)

test_add_out = (
    "Duration(360.00, 's')",
    "Duration(90.00, 's')",
    "Duration(3730.00, 's')",
    "Duration(5.25, 'm')"
)

for i, test_obj in enumerate(test_objects):
    try:
        assert repr(test_obj) == test_add_out[i], f'Expected {test_add_out[i]} received {repr(test_obj)}'
        print_pass(f'print of {repr(test_obj)}', i+1)

    except AssertionError as test_data:
        print_fail(test_data, i+1)
        continue

_test_inc += 30
try:
    assert repr(_test_inc) == "Duration(90.00, 's')", f'Expected Duration(90.00, s) received {repr(_test_inc)}'
    print_pass(f'Incremental test of {repr(_test_inc)}', 1)
except AssertionError as test_data:
    print_fail(test_data, 1)

def sub_tests():
print('''

Test #3 - Test all subtraction cases
------------------------------------''')
_test_default = Duration(120)
_test_minutes = Duration(1, "m")
_test_dec = Duration(100)

test_objects = (
    _test_default - _test_minutes,
    _test_default - 30
)

test_sub_out = (
    "Duration(60.00, 's')",
    "Duration(90.00, 's')"
)

try:
    reverse_sub = 200 - Duration(60, "s")
    assert repr(reverse_sub) == "Duration(140.00, 's')", \
        f"Expected Duration(140.00, 's') received {repr(reverse_sub)}"
    print_pass(f'reverse subtraction: {repr(reverse_sub)}', 6)
except AssertionError as test_data:
    print_fail(test_data, 6)

for i, test_obj in enumerate(test_objects):
    try:
        assert repr(test_obj) == test_sub_out[i], f'Expected {test_sub_out[i]} received {repr(test_obj)}'
        print_pass(f'print of {repr(test_obj)}', i+1)

    except AssertionError as test_data:
        print_fail(test_data, i+1)
        continue

_test_dec -= 40
try:
    assert repr(_test_dec) == "Duration(60.00, 's')", f'Expected Duration(60.00, s) received {repr(_test_dec)}'
    print_pass(f'Decremental test of {repr(_test_dec)}', 1)
except AssertionError as test_data:
    print_fail(test_data, 1)

def comp_tests():
print('''

Test #4 - Test comparisons between Duration objects
--------------------------''')

_test_comp1 = Duration(60)
_test_comp2 = Duration(1, "m")
_test_comp7 = Duration(100)
_test_comp8 = Duration(101)

count = 1
try:
    assert _test_comp1 == _test_comp2, f'Equality tested failed for {repr(_test_comp1)} and {repr(_test_comp2)}'
    print_pass(f'comparison: {repr(_test_comp1)} = {repr(_test_comp2)} ', count)
except AssertionError as test_data:
    print_fail(test_data, count)

count += 1
try:
    assert not (_test_comp7 > _test_comp8), f'Greater than test failed for {repr(_test_comp7)} and {repr(_test_comp8)}'
    print_pass(f'comparison: {repr(_test_comp7)} not > {repr(_test_comp8)} ', count)
    assert _test_comp7 < _test_comp8, f'Less than test failed for {repr(_test_comp7)} and {repr(_test_comp8)}'
    print_pass(f'comparison: {repr(_test_comp7)} < {repr(_test_comp8)} ', count)
except AssertionError as test_data:
    print_fail(test_data, count)

def exception_tests():
print('''

Test #5 - Test Exceptions
-------------------------''')
count = 1
try:
Duration("abc")
print_fail(f'Value error not thrown when value is string', count)
except ValueError as msg:
try:
assert str(msg) == "Value must be a number", f'Value error does not have correct message. Received {msg}'
print_pass(f'Value error thrown with message: {msg} as expected', count)
except AssertionError as test_data:
print_fail(test_data, count)
count += 1

try:
    Duration(-10)
    print_fail(f'Less than zero exception not thrown when value is negative', count)
except DurationLessThanZeroException as msg:
    try:
        assert str(msg) == "Duration cannot be negative", f'Exception does not have correct message. Received {msg}'
        print_pass(f'Negative-value error thrown with message: {msg} as expected', count)
    except AssertionError as test_data:
        print_fail(test_data, count)

count += 1
try:
    Duration(10, "abc")
    print_fail(f'Incorrect unit exception not thrown', count)
except TimeUnitNotDefinedException as msg:
    try:
        assert str(msg) == "Unit cannot be used", f'Exception does not have correct message. Received {msg}'
        print_pass(f'Unit error thrown with message: {msg} as expected', count)
    except AssertionError as test_data:
        print_fail(test_data, count)

if name == "main":
init(autoreset=True)
print_tests()
add_tests()
sub_tests()
comp_tests()
exception_tests()

Dice comprehension list in python

FaithInErrorsZORO — Wed, 14 Oct 2026 02:26:49 +0000

import random

def main():
# Two Dice
dice_combos = [(d1, d2) for d1 in range(1, 7) for d2 in range(1, 7)]
dice_rolled = [random.choice(dice_combos) for _ in range(100)]
sum_of_rolls = {i: 0 for i in range(2, 13)}

for roll in dice_rolled:
    sum_of_rolls[sum(roll)] += 1
print("2 Dice Rolled:", dice_rolled[:5], "...") # Preview
print("2 Dice Sums:", sum_of_rolls)

# Three Dice
dice_combos_3 = [(d1, d2, d3) for d1 in range(1, 7) for d2 in range(1, 7) for d3 in range(1, 7)]
dice_rolled_3 = [random.choice(dice_combos_3) for _ in range(100)]
sum_of_rolls_3 = {i: 0 for i in range(3, 19)}

for roll in dice_rolled_3:
    sum_of_rolls_3[sum(roll)] += 1
print("3 Dice Sums:", sum_of_rolls_3)

if name == "main":
main()

Hello world app with dictionaries and comprehension lists in python.

FaithInErrorsZORO — Wed, 14 Oct 2026 02:26:16 +0000

def add_entry(phone_book):
name = input("Enter name: ").title()
if name in phone_book:
print("There is already an entry for a student by that name, try another name")
else:
phone = input("Enter phone number: ")
phone_book[name] = phone

def search_entry(phone_book):
name = input("Enter name: ").title()
if name in phone_book:
print(f"{name}: {phone_book[name]}")
else:
print("There is no entry for a student by that name.")

def search_prefix(phone_book):
prefix = input("Enter starting letters: ").title()
matches = {k: v for k, v in phone_book.items() if k.startswith(prefix)}
if not matches:
print("No matches found.")
else:
for k in sorted(matches.keys()):
print(f"{k}: {matches[k]}")

def print_book(phone_book):
for key in sorted(phone_book.keys()):
print(f"{key}: {phone_book[key]}")

def main():
phone_book = {}
while True:
choice = input("\n1-Add, 2-Search, 3-Search Prefix, 4-Print All, 5-Exit: ")
if choice == '1': add_entry(phone_book)
elif choice == '2': search_entry(phone_book)
elif choice == '3': search_prefix(phone_book)
elif choice == '4': print_book(phone_book)
elif choice == '5': break
else: print("Error: Invalid choice.")

if name == "main":
main()

Reading and writing with files in python?

FaithInErrorsZORO — Wed, 14 Oct 2026 02:25:09 +0000

def sum_column(filename):
total, error_count = 0, 0
with open(filename, 'r') as file:
for line in file:
try:
total += int(line.strip())
except ValueError:
error_count += 1
return total, error_count

def sum_all(filename):
total, error_count = 0, 0
with open(filename, 'r') as file:
for line in file:
for num in line.split():
try:
total += int(num)
except ValueError:
error_count += 1
return total, error_count

def main():
filename = input("Enter a file name: ")
operation = input("Enter operation (sum_column or sum_all): ")

try:
    if operation == "sum_column":
        result, errors = sum_column(filename)
        print(f"Sum: {result}, Errors: {errors}")
    elif operation == "sum_all":
        result, errors = sum_all(filename)
        print(f"Sum: {result}, Errors: {errors}")
    else:
        print("Invalid operation entered.")
except FileNotFoundError:
    print(f"User-friendly message: The file '{filename}' does not exist.")

if name == "main":
main()

Python classes ? being pythonic

FaithInErrorsZORO — Wed, 14 Oct 2026 02:24:37 +0000

class MassLessThanZeroException(Exception):
pass

class UnitNotDefinedException(Exception):
pass

class Mass:
_conversion = {
'mg': 0.000001,
'g': 0.001,
'kg': 1,
'lb': 0.453592,
'oz': 0.02835,
'stone': 6.35029
}

def __init__(self, value, unit='kg'):
    if not isinstance(value, (int, float)) or isinstance(value, bool):
        raise ValueError("Value must be a number")
    if value < 0:
        raise MassLessThanZeroException("Value cannot be negative")
    if unit not in self._conversion:
        raise UnitNotDefinedException("Unit cannot be used")

    self.value = value
    self.unit = unit

def convert_to_kg(self):
    return self.value * Mass._conversion[self.unit]

def __str__(self):
    return f"{self.convert_to_kg():.2f} kg"

def __repr__(self):
    return f"Mass({self.value:.2f}, '{self.unit}')"

def __add__(self, other):
    if isinstance(other, (int, float)):
        total = self.convert_to_kg() + other
    else:
        total = self.convert_to_kg() + other.convert_to_kg()
    return Mass(total / Mass._conversion[self.unit], self.unit)

def __iadd__(self, other):
    return self + other

def __radd__(self, other):
    return self + other

def __sub__(self, other):
    if isinstance(other, (int, float)):
        total = self.convert_to_kg() - other
    else:
        total = self.convert_to_kg() - other.convert_to_kg()
    return Mass(max(0, total) / Mass._conversion[self.unit], self.unit)

def __isub__(self, other):
    return self - other

def __rsub__(self, other):
    if isinstance(other, (int, float)):
        total = other - self.convert_to_kg()
    else:
        total = other.convert_to_kg() - self.convert_to_kg()
    return Mass(max(0, total) / Mass._conversion[self.unit], self.unit)

def __lt__(self, other):
    return self.convert_to_kg() < other.convert_to_kg()

def __gt__(self, other):
    return self.convert_to_kg() > other.convert_to_kg()

def __eq__(self, other):
    return abs(self.convert_to_kg() - other.convert_to_kg()) < 0.01

getting into python functional programming any thoughts ?

FaithInErrorsZORO — Wed, 14 Oct 2026 02:19:00 +0000

from functools import reduce

1. CUSTOM DISCOUNT CALCULATOR (Scenario: Retail Discounts)

def make_discount_calculator(discount_rate):
def calculate_discount(price):
return price * discount_rate
return calculate_discount

2. CONVERT TO A PURE FUNCTION (Scenario: Applying Wholesale Markup)

def apply_markup(costs):
if not costs:
return []
return [costs[0] * 1.25] + apply_markup(costs[1:])

3. ID NUMBER GENERATOR (Scenario: Database ID Assignment)

def make_id_tracker(current_id):
def get_next_id():
return current_id, make_id_tracker(current_id + 1)
return get_next_id

4. REWRITE WITH YIELD (Scenario: Database ID Assignment Generator)

def make_id_tracker_2(current_id):
while True:
yield current_id
current_id += 1

5. GAME SCORES REPORT (Scenario: Multiplayer Match Results)

def process_scores(scores):
qualifying_scores = filter(lambda x: x >= 50, scores)
buffed_scores = map(lambda x: x + 10, qualifying_scores)
total_team_score = reduce(lambda x, y: x + y, buffed_scores, 0)
return total_team_score

6. INVENTORY TRACKER SIMULATION (Scenario: Warehouse Stock)

def make_inventory(stock_level):
def inventory(action, quantity):
if action == "restock":
return make_inventory(stock_level + quantity)
elif action == "sell":
return make_inventory(stock_level - quantity)
elif action == "audit":
return stock_level, make_inventory(stock_level)
else:
raise ValueError("Unknown action")
return inventory

7. EVENT PROCESSING WITHOUT LOOPS (Scenario: Applying Buffs to Player Stats)

def map_recursively(operation, elements):
if not elements:
return []
return [operation(elements[0])] + map_recursively(operation, elements[1:])

8. IMAGE PROCESSING PIPELINE (Scenario: Batch Image Resizing)

def compose_funcs(f, g):
return lambda x: f(g(x))

def make_image_processor():
downscale = lambda pixels: pixels * 0.5
apply_brightness = lambda pixels: pixels + 15
compress = lambda pixels: round(pixels, 0)
return compose_funcs(compress, compose_funcs(apply_brightness, downscale))

9. TEXT FORMATTING PIPELINE (Scenario: Chat Filter)

def strip_vowels(word):
if not word:
return ""
char = word[0]
rest = strip_vowels(word[1:])
if char.lower() in "aeiou":
return rest
return char + rest

def chain_processors(routines):
return lambda data: reduce(lambda current_val, routine: routine(current_val), routines, data)

10. FLATTENING DEPARTMENT DATA (Scenario: Corporate Org Chart)

def unnest_structure(hierarchy):
if not hierarchy:
return []
if isinstance(hierarchy[0], list):
return unnest_structure(hierarchy[0]) + unnest_structure(hierarchy[1:])
return [hierarchy[0]] + unnest_structure(hierarchy[1:])

def main():
print("--- 1. CUSTOM DISCOUNT CALCULATOR ---")
student_discount = make_discount_calculator(0.20)
print(f"20% discount on $200: ${student_discount(200)}")

print("\n--- 2. CONVERT TO A PURE FUNCTION ---")
costs = [100, 200, 50]
print(f"Original costs: {costs}")
print(f"With markup: {apply_markup(costs)}")

print("\n--- 3. ID NUMBER GENERATOR ---")
tracker = make_id_tracker(1000)
id1, tracker = tracker()
id2, tracker = tracker()
print(f"Generated IDs: {id1}, {id2}")

print("\n--- 4. REWRITE WITH YIELD ---")
tracker_gen = make_id_tracker_2(1000)
print(f"Generated IDs (yield): {next(tracker_gen)}, {next(tracker_gen)}")

print("\n--- 5. GAME SCORES REPORT ---")
scores = [40, 80, 55, 30, 90]
print(f"Processed Total Score: {process_scores(scores)}")

print("\n--- 6. INVENTORY TRACKER SIMULATION ---")
inv = make_inventory(500)
inv = inv("restock", 200)
inv = inv("sell", 50)
current_stock, inv = inv("audit", 0)
print(f"Current Inventory Stock: {current_stock}")

print("\n--- 7. EVENT PROCESSING WITHOUT LOOPS ---")
double_buff = lambda x: x * 2
stats = [10, 20, 30]
print(f"Buffed Stats: {map_recursively(double_buff, stats)}")

print("\n--- 8. IMAGE PROCESSING PIPELINE ---")
pipeline = make_image_processor()
print(f"Processed Pixel Value (from 100): {pipeline(100)}")

print("\n--- 9. TEXT FORMATTING PIPELINE ---")
strip_whitespace = lambda s: s.strip()
lowercase = lambda s: s.lower()
text_pipeline = chain_processors([strip_whitespace, lowercase, strip_vowels])
print(f"Processed Text: {text_pipeline('  HELLO World  ')}")

print("\n--- 10. FLATTENING DEPARTMENT DATA ---")
org_chart = ["Executive", ["Engineering", ["Frontend", "Backend"]], "HR"]
print(f"Flattened Org Chart: {unnest_structure(org_chart)}")

if name == "main":
main()

Some asp.net fizz buzz testing

FaithInErrorsZORO — Wed, 30 Sep 2026 02:28:17 +0000

using System;
using System.Collections.Generic;
using PartA.Models;
using Xunit;

namespace PartA.Tests
{
public class FizzBuzzTests
{
private readonly FizzBuzz _fizzBuzz;

    public FizzBuzzTests()
    {
        _fizzBuzz = new FizzBuzz();
    }

    // 1st test - Returns list 1 to 100[cite: 3]
    [Fact]
    public void GetList_ReturnsList1To100_WhenNoParametersPassed()
    {
        // ACT
        List<string> result = _fizzBuzz.getList();

        // ASSERT
        Assert.Equal(100, result.Count);
        Assert.Equal("1", result[0]);
        Assert.Equal("Buzz", result[99]); // Number 100
    }

    // 2nd test - Fizz for 3 multiples[cite: 3]
    [Fact]
    public void GetList_ReturnsFizz_ForMultiplesOfThree()
    {
        // ACT
        List<string> result = _fizzBuzz.getList();

        // ASSERT
        Assert.Equal("Fizz", result[2]); // Index 2 represents number 3
        Assert.Equal("Fizz", result[8]); // Index 8 represents number 9
    }

    // 3rd test - Buzz for 5 multiples[cite: 3]
    [Fact]
    public void GetList_ReturnsBuzz_ForMultiplesOfFive()
    {
        // ACT
        List<string> result = _fizzBuzz.getList();

        // ASSERT
        Assert.Equal("Buzz", result[4]); // Index 4 represents number 5
        Assert.Equal("Buzz", result[9]); // Index 9 represents number 10
    }

    // 4th test - FizzBuzz for 3&5[cite: 3]
    [Fact]
    public void GetList_ReturnsFizzBuzz_ForMultiplesOfThreeAndFive()
    {
        // ACT
        List<string> result = _fizzBuzz.getList();

        // ASSERT
        Assert.Equal("FizzBuzz", result[14]); // Index 14 represents number 15
        Assert.Equal("FizzBuzz", result[29]); // Index 29 represents number 30
    }

    // 5th test - Upper limit with default[cite: 3]
    [Fact]
    public void GetList_RespectsUpperLimit_WhenPassed()
    {
        // ARRANGE
        int bramUpperLimit = 10;

        // ACT
        List<string> result = _fizzBuzz.getList(bramUpperLimit);

        // ASSERT
        Assert.Equal(10, result.Count);
        Assert.Equal("Buzz", result[9]); // Number 10
    }

    // 6th test - Lower limit with default[cite: 3]
    [Fact]
    public void GetList_RespectsLowerLimit_WhenPassed()
    {
        // ARRANGE
        int bramUpperLimit = 20;
        int bramLowerLimit = 15;

        // ACT
        List<string> result = _fizzBuzz.getList(bramUpperLimit, bramLowerLimit);

        // ASSERT
        Assert.Equal(6, result.Count); // 15, 16, 17, 18, 19, 20
        Assert.Equal("FizzBuzz", result[0]); // Number 15
    }

    // 7th test - Argument out of Range exception[cite: 3]
    [Fact]
    public void GetList_ThrowsArgumentOutOfRangeException_WhenLowerGreaterThanUpper()
    {
        // ARRANGE
        int bramUpperLimit = 10;
        int bramLowerLimit = 20;

        // ACT & ASSERT
        Assert.Throws<ArgumentOutOfRangeException>(() => _fizzBuzz.getList(bramUpperLimit, bramLowerLimit));
    }
}

}

Getting into C# testing

FaithInErrorsZORO — Wed, 30 Sep 2026 02:18:23 +0000

Here are the tests I am running for a school registration system : using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using SportsWeb.Models;
using Xunit;

namespace SportsWeb.Tests.Models
{
public class RegistrationViewModelValidationTests
{
private static IList Validate(object model)
{
var ctx = new ValidationContext(model, serviceProvider: null, items: null);
var results = new List();
Validator.TryValidateObject(model, ctx, results, validateAllProperties: true);
return results;
}

    [Fact]
    public void Missing_Season_IsInvalid()
    {
        // ARRANGE: Simulating a missing drop-down selection
        var vm = new RegistrationViewModel
        {
            AthleteName = "Bram",
            Season = null, 
            Sport = "Basketball"
        };

        // ACT
        var results = Validate(vm);

        // ASSERT
        Assert.Contains(results, r => r.MemberNames.Contains(nameof(RegistrationViewModel.Season)));
    }

    [Fact]
    public void Missing_Sport_IsInvalid()
    {
        // ARRANGE: Simulating no radio button being selected
        var vm = new RegistrationViewModel
        {
            AthleteName = "Bram",
            Season = "Fall",
            Sport = null 
        };

        var results = Validate(vm);

        Assert.Contains(results, r => r.MemberNames.Contains(nameof(RegistrationViewModel.Sport)));
    }

    [Fact]
    public void Valid_RegistrationModel_Passes()
    {
        // ARRANGE
        var vm = new RegistrationViewModel
        {
            AthleteName = "Bram",
            Season = "Winter",
            Sport = "Basketball"
        };

        // ACT
        var results = Validate(vm);

        // ASSERT
        Assert.Empty(results);
    }
}

}

using System;
using SportsWeb.Models;
using SportsWeb.Services;
using Xunit;

namespace SportsWeb.Tests.Services
{
public class RegistrationServiceTests
{
private readonly IRegistrationService _service;

    public RegistrationServiceTests()
    {
        // Testing the concrete service implementation
        _service = new RegistrationService(); 
    }

    [Fact]
    public void CalculateFee_ReturnsStandardRate_ForWinterBasketball()
    {
        // Arrange
        var vm = new RegistrationViewModel { Season = "Winter", Sport = "Basketball" };

        // Act
        decimal fee = _service.CalculateFee(vm);

        // Assert
        Assert.Equal(150m, fee);
    }

    [Theory]
    [InlineData("Summer", "Soccer", 100)]
    [InlineData("Spring", "Tennis", 120)]
    public void CalculateFee_ReturnsCorrectRates_ForAllSeasons(string season, string sport, decimal expectedFee)
    {
        // Arrange
        var vm = new RegistrationViewModel { Season = season, Sport = sport };

        // Act
        decimal fee = _service.CalculateFee(vm);

        // Assert
        Assert.Equal(expectedFee, fee);
    }
}

}

here are the controller tests : using Microsoft.AspNetCore.Mvc;
using Moq;
using SportsWeb.Controllers;
using SportsWeb.Models;
using SportsWeb.Services;
using Xunit;

namespace SportsWeb.Tests.Controllers
{
public class RegistrationControllerTests
{
private readonly Mock _mockService;
private readonly RegistrationController _controller;

    public RegistrationControllerTests()
    {
        _mockService = new Mock<IRegistrationService>();
        _controller = new RegistrationController(_mockService.Object);
    }

    [Fact]
    public void CreatePost_InvalidModel_ReturnsSameView()
    {
        // ARRANGE
        // Simulate ASP.NET Core catching a missing radio button selection
        _controller.ModelState.AddModelError("Sport", "Please select a sport.");

        var vm = new RegistrationViewModel { AthleteName = "Bram", Season = "Fall", Sport = null };

        // ACT
        var result = _controller.Create(vm) as ViewResult;

        // ASSERT
        Assert.NotNull(result);
        Assert.False(_controller.ModelState.IsValid);
        Assert.Same(vm, result.Model); // Ensure the form is sent back to the user with their inputs intact

        // Verify the database/service was NOT called since the model was invalid
        _mockService.VerifyNoOtherCalls(); 
    }

    [Fact]
    public void CreatePost_ValidModel_CallsServiceAndRedirects()
    {
        // ARRANGE
        var vm = new RegistrationViewModel { AthleteName = "Bram", Season = "Winter", Sport = "Basketball" };

        // Set up the mock to return true when saving
        _mockService.Setup(s => s.ProcessRegistration(vm)).Returns(true);

        // ACT
        var result = _controller.Create(vm) as RedirectToActionResult;

        // ASSERT
        Assert.NotNull(result);
        Assert.Equal("Success", result.ActionName); // Ensure it redirects to the Success page

        // Verify the service was called exactly once with the provided model
        _mockService.Verify(s => s.ProcessRegistration(vm), Times.Once);
    }
}

}

Getting started with C# SOLID Principles

FaithInErrorsZORO — Wed, 30 Sep 2026 02:00:55 +0000

In my repo I've got this `using MusicLab.Projects.Models;
using System.Collections.Generic;
using System.Linq;

namespace MusicLab.Projects.Data
{
public class InstrumentRepository : IInstrumentRepository
{
private readonly MusicDbContext _context;

public InstrumentRepository(MusicDbContext context)
{
    _context = context;
}

public List<Instrument> GetInstruments()
{
    return _context.GetInstruments();
}

public List<Instrument> GetInstrumentsByCategory(string category)
{
    return _context.GetInstruments().Where(i => i.Category == category).ToList();
}

public Instrument FindById(int id)
{
    return _context.FindById(id);
}

public void Add(Instrument i)
{
    _context.Add(i);
}

public void Update(Instrument i)
{
    _context.Update(i);
}

public void Remove(int id)
{
    _context.Remove(id);
}

}
}`

and then in my interface :

C#
using MusicLab.Projects.Models;

namespace MusicLab.Projects.Utils
{
public interface ITaxCalculator
{
decimal CalculateTax(Instrument instrument);
}

public class DefaultTaxCalculator : ITaxCalculator
{
    public decimal CalculateTax(Instrument instrument)
    {
        // Standard tax calculation replacing the static method
        return instrument.Price * 0.15m; 
    }
}

}
and then my csv exporter :

C#
using MusicLab.Projects.Models;
using System.Collections.Generic;
using System.Text;

namespace MusicLab.Projects.Utils
{
public interface ICsvExporter
{
string ExportInstrumentsCsv(List instruments);
}

public class CsvExporter : ICsvExporter
{
    public string ExportInstrumentsCsv(List<Instrument> instruments)
    {
        var sb = new StringBuilder();
        sb.AppendLine("Id,Name,Price,Category");
        foreach (var i in instruments)
        {
            sb.AppendLine($"{i.Id},{i.Name},{i.Price},{i.Category}");
        }
        return sb.ToString();
    }
}

}
and then the controller :

C#
using Microsoft.AspNetCore.Mvc;
using MusicLab.Projects.Data;
using MusicLab.Projects.Models;
using MusicLab.Projects.Utils;
using System.Collections.Generic;
using System.Text;

namespace MusicLab.Projects.Controllers
{
public class InstrumentsController : Controller
{
private readonly IInstrumentRepository _repository;
private readonly ICsvExporter _exporter;
private readonly ITaxCalculator _taxCalculator;

    public InstrumentsController(IInstrumentRepository repository, ICsvExporter exporter, ITaxCalculator taxCalculator)
    {
        _repository = repository;
        _exporter = exporter;
        _taxCalculator = taxCalculator;
    }

    public IActionResult Index(string category)
    {
        List<Instrument> instruments;

        if (!string.IsNullOrWhiteSpace(category))
        {
            instruments = _repository.GetInstrumentsByCategory(category);
        }
        else
        {
            instruments = _repository.GetInstruments();
        }

        return View(instruments);
    }

    public IActionResult Details(int id)
    {
        Instrument instrument = _repository.FindById(id);
        if (instrument == null) return NotFound();

        ViewData["Tax"] = _taxCalculator.CalculateTax(instrument);
        return View(instrument);
    }

    [HttpPost]
    public IActionResult Create(Instrument model)
    {
        if (model == null) return BadRequest("No data");

        // Replaced manual model.IsValid() with built-in ModelState validation
        if (!ModelState.IsValid) return BadRequest("Invalid instrument"); 

        _repository.Add(model);
        return Redirect("/Instruments/Index");
    }

    public IActionResult Export()
    {
        List<Instrument> instruments = _repository.GetInstruments();
        string csv = _exporter.ExportInstrumentsCsv(instruments);
        byte[] bytes = Encoding.UTF8.GetBytes(csv);
        return File(bytes, "text/csv", "instruments.csv");
    }
}

}
and then program.cs :

C#
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using MusicLab.Projects.Data;
using MusicLab.Projects.Utils;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();

// Register the mock DbContext as a Singleton so the list persists in memory
builder.Services.AddSingleton();

// Register dependencies for Dependency Injection
builder.Services.AddScoped();
builder.Services.AddScoped();
builder.Services.AddScoped();

var app = builder.Build();

app.UseRouting();
app.MapControllerRoute(
name: "default",
pattern: "{controller=Instruments}/{action=Index}/{id?}");

app.Run();

Using sessions in asp.net anyone have any insight?

FaithInErrorsZORO — Fri, 17 Apr 2026 03:39:10 +0000

here is how i set it up in program.cs :

builder.Services.AddDistributedMemoryCache();
builder.Services.AddSession(options =>
{
options.IdleTimeout = TimeSpan.FromMinutes(10); // [cite: 16]
options.Cookie.HttpOnly = true;
options.Cookie.IsEssential = true;
});

var app = builder.Build();

[cite_start]// 2. Add Session Middleware (between Routing and Endpoints) [cite: 17]
app.UseRouting();
app.UseSession();
app.UseAuthorization();

here is how i reference the session

[[HttpPost]
public IActionResult Index(string lastName)
{
var player = _context.Players.FirstOrDefault(p => p.LastName == lastName);

if (player == null)
{
    ViewBag.Message = "No player found with that last name.";
    return View();
}

// Store IDs in Session for later use
HttpContext.Session.SetString("playerId", player.PlayerId.ToString());
HttpContext.Session.SetInt32("coachId", player.CoachId ?? 0);
HttpContext.Session.SetInt32("teamId", player.TeamId ?? 0);

return View("Display", player);

}

action to show the stats:

public IActionResult ShowStats()
{
var pId = HttpContext.Session.GetString("playerId");

var playerWithStats = _context.Players
    .Include(p => p.GameRecords)
        .ThenInclude(gr => gr.StatCategory)
    .FirstOrDefault(p => p.PlayerId.ToString() == pId);

return View(playerWithStats);

}

dif types :

public IActionResult ShowCoach()
{
var pId = HttpContext.Session.GetString("playerId");
var cId = HttpContext.Session.GetInt32("coachId");
var tId = HttpContext.Session.GetInt32("teamId");

var player = _context.Players.Find(int.Parse(pId));
var coach = _context.Coaches.Find(cId);
var team = _context.Teams.Find(tId);

// Join class/ViewModel to pass all three objects to the view
var viewModel = new PlayerCoachTeamViewModel { 
    Player = player, 
    Coach = coach, 
    Team = team 
};

return View(viewModel);

}