In this tutorial, we will build an AI-powered weather assistant using the GitHub Copilot SDK and .NET. To keep the focus on the core concepts, we'll develop the application as a simple console app.
Our assistant will answer a straightforward question:
What is the weather in Vancouver?
Along the way, you will learn how to:
Create a .NET project
Install and configure the GitHub Copilot SDK
Build a custom tool
Register the tool with the agent
Create an AI agent
Process user prompts and generate responses
By the end of this tutorial, you will have a working AI agent that can use tools to retrieve weather information and respond intelligently to user requests.
Agent workflow
The GitHub Copilot SDK supports .NET as one of its supported languages.
Step 1: Create a .NET console project
dotnet new console -n WeatherAgent
cd WeatherAgent
mkdir Helpers
Run the application with dotnet run. You should get this output:
Vancouver: 12°C and cloudy.
The SDK chooses a default AI model. The application can be extended to allow the user choose another AI model.
Inside the Helpers folder, add a C# class named SelectionPrompt with this code:
internal static class SelectionPrompt {
internal static int ReadIndex(string prompt, int optionCount, int defaultIndex) {
while (true) {
Console.Write(prompt);
var answer = Console.ReadLine()?.Trim();
if (string.IsNullOrEmpty(answer))
return defaultIndex;
if (int.TryParse(answer, out var selection) && selection >= 1 && selection <= optionCount)
return selection - 1;
Console.WriteLine($"Enter a number from 1 to {optionCount}.");
}
}
}
Also in the Helpers folder, add a C# class named ModelSelector with this code:
internal static class ModelSelector {
internal static async Task<string> PickAsync(CopilotClient client, string preferredModel)
{
var models = (await client.ListModelsAsync()).ToList();
if (models.Count == 0)
return string.Empty;
var defaultIndex = models.FindIndex(model =>
string.Equals(model.Id, preferredModel, StringComparison.OrdinalIgnoreCase));
// Use the preferred model when available; otherwise default to the first listed model.
defaultIndex = defaultIndex >= 0 ? defaultIndex : 0;
Console.WriteLine("Choose a Copilot model:");
for (var index = 0; index < models.Count; index++) {
Console.WriteLine($" {index + 1}. {models[index].Id}");
}
var selectedIndex = SelectionPrompt.ReadIndex(
$"Model [{defaultIndex + 1}]: ",
models.Count,
defaultIndex);
return models[selectedIndex].Id;
}
}
The most important statement in the above code reads all available models into a list:
var models = (await client.ListModelsAsync()).ToList();
Let's use these helper methods in our app. In Program.cs, add this code right under await copilotClient.StartAsync();:
var model = await ModelSelector.PickAsync(copilotClient, "auto");
var sessionConfig = new SessionConfig{
Model = model,
Tools = [weatherTool],
SystemMessage = new SystemMessageConfig {
Content = "Help users retrieve weather information."
}
};
Also, in Program.cs, replace the AIAgent agent = copilotClient.AsAIAgent(…) statement with this code:
After entering 10 for claude-haiku-4.5, the result was:
The weather in Vancouver is currently **12°C (54°F) and cloudy**.
Understanding what happens internally
Runtime workflow
User Prompt
Agent Analysis
Tool Selection
Tool Execution
Response Generation
Agent reasoning
User Prompt
Need City Weather
Call GetWeather()
Generate Answer
The Copilot SDK provides the orchestration layer that performs this workflow.
Enhancing the weather tool
Instead of returning hard-coded data, you can call a REST API:
public async Task<string>
GetWeatherAsync(string city) {
using var client = new HttpClient();
var json =
await client.GetStringAsync(
$"https://api.example.com/weather/{city}");
return json;
}
Deployment considerations
Before deploying the assistant, decide how it will authenticate and where model inference will run. Common options include:
Fine-grained personal access token: Use a narrowly scoped token for a controlled deployment, and store and rotate it securely.
GitHub OAuth: For an app used by people with Copilot accounts, let each user sign in with GitHub and provide their own token to the SDK rather than sharing credentials.
Azure-hosted model: For a school application, consider an Azure-hosted model instead of GitHub-hosted Copilot inference. This means configuring the app for the chosen Azure model and securing its access.
Choose the approach that fits your users, access requirements, and hosting environment. Never hard-code tokens or commit them to source control.
To implement option 1 above:
1) Create fine-grained personal access token token on GitHub.com with ‘Copilot Requests” permission.
2) Set GetHubToken and UseLoggedInUser options as follows:
3) Set environment variable: COPILOT_GITHUB_TOKEN=github_pat_xxxxxxxx
Conclusion
In this tutorial, we built a .NET weather assistant with the GitHub Copilot SDK, registered a tool the agent can call, and added a model-selection step. The example uses hard-coded weather data, but you can extend the same pattern to call a real weather API or connect other tools. As you do, handle API errors and credentials securely. With the SDK coordinating prompts and tool calls, you can focus on the capabilities your assistant provides.
In this walkthrough, we will develop an AI agent that queries a SQLite database in a Blazor app using GitHub Copilot SDK.
Prerequisites
.NET 10 or later
GitHub Copilot in your personal GitHub account (includes the GitHub Copilot Free plan)
Visual Studio Code with C# DevKit extension
dotnet-ef tool
What is an AI agent?
An AI agent is a goal-driven AI entity that can reason, take actions, and adapt autonomously in pursuit of an objective. Unlike a simple chatbot that only responds to user queries with pre-scripted answers, an AI agent can make decisions, use tools or APIs, and maintain memory of context to achieve a goal without step-by-step human guidance.
Modern AI agents are powered by advanced AI models, often large language models (LLMs), and provide several core abilities that distinguish them from basic automation:
Reasoning and planning
Tool use
Memory and context
Interactive execution
What is the GitHub Copilot SDK?
The GitHub Copilot SDK is a multi-platform toolkit that allows you to embed an AI agent runtime into your own applications.
Why use an SDK for AI agents?
Building a full-featured AI agent from the ground up is complex. You need to handle conversation state management across turns, decide when to call which external API, ensure the AI's responses stay within boundaries, manage multiple AI models for different tasks, and implement safety measures.
The GitHub Copilot SDK removes that complexity by providing a prebuilt, production-tested agent engine. The SDK handles authentication, model management, chat sessions, and streaming. You focus on what gets built on top of those building blocks - your domain-specific tools and business logic.
Core concepts
Client
The CopilotClient class manages the connection to the Copilot CLI server.
Session
A CopilotSession represents a single conversation or task context. Each session has its own conversation history, model configuration, tool definitions, and system prompt. You create sessions from the client using CreateSessionAsync, send messages to them, and receive responses through an event-driven model.
Tools
Tools are functions that you register with a session so the AI agent can call them during reasoning. Each tool has a name, description, parameters, and a handler function. When the AI model decides to use a tool, the SDK intercepts the request, calls your handler, and feeds the result back to the model for further reasoning.
In .NET, you define tools using AIFunctionFactory.Create from Microsoft.Extensions.AI:
AIFunctionFactory.Create(
async ([Description("The order ID number")] int orderId) =>
await GetOrderDetailsAsync(orderId),
"get_order_details",
"Look up the status and details of a specific order.")
Events
The SDK uses an event-driven communication model.
Session hooks
The SDK provides hooks that let you intercept and modify agent behavior at key points.
Getting started
In a working directory create a Blazor app and add required packages with these terminal window commands:
Open the AI4SchoolAgent folder in Visual Studio Code. In the Models folder, add this C# Student class:
public class Student {
public int StudentId { get; set; }
[Required]
public String? FirstName { get; set; }
[Required]
public String? LastName { get; set; }
[Required]
public String? School { get; set; }
[Required]
public String? Gender { get; set; }
public DateOnly? DateOfBirth { get; set; }
public String? Status { get; set; }
}
We will populate a SQLite database with some sample student data. We need an Entity Framework database context class. Add the following C# SchoolDbContext class inside the Data folder:
public class SchoolDbContext : DbContext {
public DbSet<Student> Students => Set<Student>();
public SchoolDbContext(DbContextOptions<SchoolDbContext> options) : base(options) { }
protected override void OnModelCreating(ModelBuilder modelBuilder) {
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<Student>().HasData(GetStudents());
}
private static IEnumerable<Student> GetStudents() {
const string studentsUrl =
"https://gist.githubusercontent.com/medhatelmasry/2ae7a36d5392f862b0d1039b2a52b9b4/raw/45533eda6c43ce439dbc65c37a7fbdef01546c2d/students.json";
using var httpClient = new HttpClient();
var json = httpClient.GetStringAsync(studentsUrl).GetAwaiter().GetResult();
return System.Text.Json.JsonSerializer.Deserialize<List<Student>>(json)
?? throw new InvalidOperationException("The students JSON returned no data.");
}
}
In the above code, note that sample students data is being read from a JSON endpoint. You can visit the endpoint to see what the data looks like.
Add the following connection string to appsettings.json:
Let’s add some tools that will help us query the database using natural language. In the Tools folder, add a C# class named StudentsAgentTools with the following code:
// Provides database-backed operations for querying and updating student records.
public class StudentsAgentTools {
private readonly DbContext _dbContext;
// Initializes a new instance of the StudentsAgentTools class.
public StudentsAgentTools(DbContext dbContext) {
_dbContext = dbContext;
}
// Retrieves a student's details by its unique identifier.
public async Task<string> GetStudentDetailsByIdAsync(int studentId) {
var student = await _dbContext.Set<Student>().FindAsync(studentId);
return student != null
? $"Student {studentId}: {student.FirstName} {student.LastName}, School: {student.School}, Gender: {student.Gender}, Status: {student.Status ?? "not recorded"}"
: "Student not found.";
}
// Retrieves students whose gender matches the specified value.
public async Task<string> GetStudentsByGenderAsync(string gender) {
var students = await _dbContext.Set<Student>().Where(s => s.Gender == gender).ToListAsync();
if (students.Count == 0)
return "No students found.";
var result = new StringBuilder();
foreach (var student in students) {
result.AppendLine($"Student {student.StudentId}: {student.FirstName} {student.LastName}, School: {student.School}, Gender: {student.Gender}, Status: {student.Status ?? "not recorded"}");
}
return result.ToString();
} // Retrieves students enrolled at the specified school.
public async Task<string> GetStudentsBySchoolAsync(string school) {
var students = await _dbContext.Set<Student>().Where(s => s.School == school).ToListAsync();
if (students.Count == 0)
return "No students found.";
var result = new StringBuilder();
foreach (var student in students) {
result.AppendLine($"Student {student.StudentId}: {student.FirstName} {student.LastName}, School: {student.School}, Gender: {student.Gender}, Status: {student.Status ?? "not recorded"}");
}
return result.ToString();
}
// Retrieves all students with their birth date and calculated age.
public async Task<string> GetStudentsByAgeAsync() {
var students = await _dbContext.Set<Student>().ToListAsync();
if (students.Count == 0)
return "No students found.";
var result = new StringBuilder();
foreach (var student in students) {
var today = DateOnly.FromDateTime(DateTime.Today);
var age = student.DateOfBirth is { } dateOfBirth
? today.Year - dateOfBirth.Year - (today < dateOfBirth.AddYears(today.Year - dateOfBirth.Year) ? 1 : 0)
: (int?)null;
result.AppendLine($"Student {student.StudentId}: {student.FirstName} {student.LastName}, School: {student.School}, Gender: {student.Gender}, Born: {student.DateOfBirth?.ToString("yyyy-MM-dd") ?? "not recorded"}, Age: {age?.ToString() ?? "not recorded"}");
}
return result.ToString();
}
// Retrieves details for every student in the database.
public async Task<string> GetAllStudentsAsync() {
var students = await _dbContext.Set<Student>().ToListAsync();
if (students.Count == 0)
return "No students found.";
var result = new StringBuilder();
foreach (var student in students) {
result.AppendLine($"Student {student.StudentId}: {student.FirstName} {student.LastName}, School: {student.School}, Gender: {student.Gender}, Status: {student.Status ?? "not recorded"}");
}
return result.ToString();
}
// Initiates the withdrawal process for a student.
public async Task<string> ProcessWithdrawalAsync(int studentId, string reason) {
var student = await _dbContext.Set<Student>().FindAsync(studentId);
if (student == null)
return "Student not found.";
// Record the withdrawal state on the student until a formal workflow is added.
student.Status = "Withdrawal Initiated";
await _dbContext.SaveChangesAsync();
return $"Withdrawal initiated for student {studentId}.";
}
}
The above StudentsAgentTools class contains these methods that interact with the database:
GetAllStudentsAsync()
GetStudentDetailsByIdAsync()
GetStudentsByGenderAsync()
GetStudentsBySchoolAsync()
GetStudentsByAgeAsync()
ProcessWithdrawalAsync()
Agent Service
Create an agent service named AgentService inside the Services folder with this code:
// Coordinates Copilot sessions and expose student-related tools to answer prompts.
public class AgentService {
private readonly SchoolDbContext _db;
private readonly ILogger<AgentService> _logger;
// Initialize a new instance of the AgentService class.
public AgentService(SchoolDbContext db, ILogger<AgentService> logger) {
_logger = logger;
_db = db;
}
// Sends a prompt to a Copilot session configured with the available student tools.
public async Task<string> AskAsync(string prompt) { // Create a Copilot client and start the local session infrastructure.
var client = new CopilotClient(
new CopilotClientOptions {
LogLevel = CopilotLogLevel.Info
});
await client.StartAsync();
var toolService = new StudentsAgentTools(_db);
// Register database operations as tools that Copilot can invoke.
var tools = new List<AIFunctionDeclaration> {
AIFunctionFactory.Create(
async (int studentId) =>
await toolService.GetStudentDetailsByIdAsync(studentId),
"get_student_details", "Look up student details."),
AIFunctionFactory.Create(
async (int studentId, string reason) =>
await toolService.ProcessWithdrawalAsync(studentId, reason),
"process_withdrawal", "Process a withdrawal request."),
AIFunctionFactory.Create(
async (string gender) =>
await toolService.GetStudentsByGenderAsync(gender),
"get_students_by_gender", "Find students by gender"),
AIFunctionFactory.Create(
async (string school) =>
await toolService.GetStudentsBySchoolAsync(school),
"get_students_by_school", "Find students by school"),
AIFunctionFactory.Create(
async () =>
await toolService.GetStudentsByAgeAsync(),
"get_students_by_age", "Find students by age"),
AIFunctionFactory.Create(
async () =>
await toolService.GetAllStudentsAsync(),
"get_all_students", "Get all students")
};
// Allow tool execution automatically and use the default model selection.
var config = new SessionConfig {
Model = "auto",
OnPermissionRequest = PermissionHandler.ApproveAll,
Tools = tools
};
var session = await client.CreateSessionAsync(config);
var responseBuilder = new StringBuilder();
// Complete only after the session reports that it is idle.
var tcs = new TaskCompletionSource<string>();
session.On<SessionEvent>(evt => {
switch (evt) {
case AssistantMessageEvent msg:
responseBuilder.Append(msg.Data.Content);
break;
case SessionIdleEvent:
tcs.SetResult(responseBuilder.ToString());
break;
case ToolExecutionStartEvent tool:
_logger.LogInformation(
"Executing tool: {ToolName}", tool.Data.ToolName);
break;
}
});
await session.SendAsync(new MessageOptions {
Prompt = prompt
});
return await tcs.Task.WaitAsync(TimeSpan.FromSeconds(30));
}
}
Add these services to Program.cs just before the "var app = builder.Build();" statement:
// Register school DB context and configure it to use SQLite connection string. builder.Services.AddDbContext<SchoolDbContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionString("DefaultConnection")) );
// Register AgentService once per request scope. builder.Services.AddScoped<AgentService>();
Now we can add a migration using the dotnet-ef tool. To add this tool, run the following terminal window command:
dotnet tool install -g dotnet-ef
Thereafter, run this command from a terminal window inside the root folder of your C# project to create migrations:
dotnet ef migrations add M1 -o Data/Migrations
We will create the database with sample student data with the following command that applies the migrations:
dotnet ef database update
At this stage you will notice that a database file named school-db.sqlite has been created in the project.
Building the Blazor UI
Replace contents of Components/Pages/Home.razor with this code:
Run the application with the command "dotnet watch" from a terminal window at the root of the C@ Blazor project.
Here are some interactions you can make with live student data:
Who is the oldest student in medicine?
Who is the yougest student in mining?
Withdraw student with StudentId = 76 because they are no longer enrolled?
What is the status of student with StudentId = 76?
List all male students studying nursing.
Count students in each school.
If you observe the terminal window, you will see see the tool that is being called and the SQL statement that is being exeuted. For example, the prompt "Count students in each school" calledgenerated the get_students_by_school tool five times. You must continuosly refine your tools to make them more efficient.
In this walkthrough, we will use the scaffolding tool to create the CRUD pages for a data driven Interactive-Server Blazor app. The app connects directly with SQLite database using Entity Framework Core.
Overview
Blazor is a framework for developing interactive client-side web applications using C# instead of JavaScript.
Architecture
The architecture of the application that we will be building will look like this:
ASP.NET Core hosts the server-side app and sets up SignalR endpoints where clients connect. SignalR is responsible for updating the DOM on the client with any changes. The Blazor application on the server connects directly to the database using Entity Framework Core.
Blazor Render Modes
Name
Description
Render Location
Interactive
Static Server
Static server-side rendering (static SSR)
Server
❌
Interactive Server
Interactive server-side rendering (interactive SSR) using Blazor Server.
Server
✔️
Interactive WASM
Client-side rendering (CSR) using Blazor WebAssembly.
Client
✔️
Interactive Auto
Interactive SSR using Blazor Server initially and then CSR on subsequent visits after the Blazor bundle is downloaded.
Server, then client
✔️
To apply a render mode to a component, use the @rendermode directive on the component instance or on the component definition. Example:
<Dialog @rendermode="InteractiveServer" />
In this post, we will build a Server-side Blazor app talks directly to a SQLite database. This is a very realistic option since both blazor and the database server run on the server.
Let's get coding
In a terminal window, go to a work directory. Enter the following command to create a Server-Side Blazor application inside a directory named BlazorEF:
dotnet new blazor -o BlazorEF
cd BlazorEF
mkdir Models
mkdir Data
Open the BlazorEF folder in Visual Studio Code.
When you run the app, your default browser will load a page that looks like this:
We will extend the above application so that it talks to SQLite using Entity Framework Core. To this end, we will be dealing with a very simple Student model. Therefore, add a Student.cs class file to the Models folder with the following C# content:
public class Student {
public int StudentId { get; set; }
[Required]
public String? FirstName { get; set; }
[Required]
public String? LastName { get; set; }
[Required]
public String? School { get; set; }
[Required]
public String? Gender { get; set; }
public DateOnly? DateOfBirth { get; set; }
}
Since we will be using SQLite, we will need to add the appropriate Entity Framework Core packages to our project. From within a terminal window at the root of your BlazorEF project, run the following commands to add the appropriate database related packages:
We will be using the Entity Framework Code First approach.
Developers prefer having sample data when building data driven applications. Therefore, we will create some sample data to ensure that our application behaves as expected. Student data from this link will be used.
The starting point is to create a database context class. Add a C# class file named SchoolDbContext.cs in the Data folder with the following C# code:
public class SchoolDbContext : DbContext {
public DbSet<Student> Students => Set<Student>();
public SchoolDbContext(DbContextOptions<SchoolDbContext> options) : base(options) { }
protected override void OnModelCreating(ModelBuilder modelBuilder) {
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<Student>().HasData(GetStudents());
}
private static IEnumerable<Student> GetStudents() {
const string studentsUrl =
"https://gist.githubusercontent.com/medhatelmasry/2ae7a36d5392f862b0d1039b2a52b9b4/raw/45533eda6c43ce439dbc65c37a7fbdef01546c2d/students.json";
using var httpClient = new HttpClient();
var json = httpClient.GetStringAsync(studentsUrl).GetAwaiter().GetResult();
return System.Text.Json.JsonSerializer.Deserialize<List<Student>>(json)
?? throw new InvalidOperationException("The students JSON returned no data.");
}
}
Notice the above code will seed Student data into the database.
In the Program.cs file, just before ‘var app = builder.Build();’, add the following code so that our application can use SQLite:
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<SchoolDbContext>(
options => options.UseSqlite(connectionString)
);
We are now ready to apply Entity Framework migrations, create the database and seed data. If you have not done so already, you will need to globally install the Entity Framework CLI tool. This tooling is installed globally on your computer by running the following command in a terminal window:
dotnet tool install --global dotnet-ef
To make sure nothing is broken, build your project with "dotnet build" before proceeding. Then, from within a terminal window inside the BlazorEF root directory, run the following command to create migrations:
dotnet ef migrations add M1 -o Data/Migrations
This results in the creation of a migration file ending with the name ....M1.cs in the Data/Migrations folder. In my case, this file looked like this:
Note that the above code also includes commands for inserting sample data.
The next step is to create the SQLite college.db database file. To automatically apply migrations, add the following code to Program.cs, right before the final app.Run() statement:
using (var scope = app.Services.CreateScope()) {
var services = scope.ServiceProvider;
var context = services.GetRequiredService<SchoolDbContext>();
context.Database.Migrate();
}
We will scaffold the CRUD pages for students using the scaffold tool. To install the scaffold tool globally, enter this command in any terminal window:
In this tutorial, we will learn how to add more data fields to the standard ASP.NET users & roles schema using the scaffold tool. We will also learn how to seed users and roles.
Prerequisites
To proceed with this tutorial, you need the following:
VS Code
.NET: The current version of .NET is 10.0
the dotnet-ef tool
Tthe Microsoft.dotnet-scaffold tool
Getting Started
Create a new razor pages application with the following terminal window command:
dotnet new razor --auth individual -o XtendUsersRoles
cd XtendUsersRoles
mkdir Models
This creates an ASP.NET app that uses SQLite database for authentication.
Open the application folder in VS Code.
Suppose we want to capture more data about the user, in addition to email and password. Keeping it simple, lwe will extend user data with FirstName & LastName.
An easy way to do this is to create a new class that extends IdentityUser and adds FirstName and LastName properties. In the Models folder, add a new class named XUser to it with the following class code:
public class XUser : IdentityUser {
public XUser() : base() { }
public string? FirstName { get; set; }
public string? LastName { get; set; }
}
We may also wish to extend the standard roles table with a CreatedDate property.
Just as we did with users, we will create another class for roles that inherits from IdentityRole. In the Models folder, add another class named XRole and add to it the following code:
public class XRole: IdentityRole {
public XRole() : base() { }
public XRole(string roleName) : base(roleName) { }
public DateTime CreatedDate { get; set; }
}
Add the following to Pages/_ViewImports.cshtml:
@using XtendUsersRoles.Models
Edit Data/ApplicationDbContext.cs file and make ApplicationDbContext inherit from IdentityDbContext<XUser, XRole, string>(options). The ApplicationDbContext class code will look like this:
public class ApplicationDbContext(
DbContextOptions<ApplicationDbContext> options)
: IdentityDbContext<XUser, XRole, string>(options)
{
}
Add these passwords to the appsettings.Development.json file:
We need to call the identity seed logic from somewhere. In Program.cs, Add the following code to the “if (app.Environment.IsDevelopment())” block, right before “app.UseMigrationsEndPoint()”:
await using var scope = app.Services.CreateAsyncScope();
var dbContext = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
await dbContext.Database.MigrateAsync();
await IdentitySeeder.SeedAsync(
scope.ServiceProvider.GetRequiredService<UserManager<XUser>>(),
scope.ServiceProvider.GetRequiredService<RoleManager<XRole>>(),
app.Configuration);
Edit Pages/Shared/_LoginPartial.cshtml and change:
Let us start with a clean database and migration. Therefore, delete app.db and the Data/Migrations folder.
If you do not already have the .NET entity framework tool, execute the following command from within a terminal window:
dotnet tool install -g dotnet-ef
Then, execute the following entity framework migration commands from within a terminal window in the root folder of the application:
dotnet ef migrations add M1 -o Data/Migrations
dotnet ef database update
To seed the database with sample roles and users, start the application with:
dotnet watch
To prove that user and role data are successfully seeded, login with one of the below credentials that were previously seeded:
Email
Password
aa@aa.aa
P@$$w0rd
mm@mm.mm
P@$$w0rd
The next task we need to accomplish is to modify the registration page so that the application can capture extended data such as FirstName & LastName. ASP.NET provides ASP.NET Core Identity as a Razor Class Library. This means that the registration UI is baked into the assemblies and is surfaced with the .AddDefaultUI() option with the services.AddIdentity() command in Program.cs.
If you do not already have the .NET scaffolding tool, execute the following command from within a terminal window:
dotnet tool install -g Microsoft.dotnet-scaffold
To expose the identity pages (like LOgin, Register, Logout, etc) and change them, we will use the Scaffold tool. Run the following command from within a terminal window at the root of your project:
dotnet scaffold
Follow these steps to generate the Identity razor pages:
The result of the scaffolding process is that we now have a new folder /Areas/Identity/Pages/Account with many pages that pertains to Identity:
There are, however, some things that the scaffold tool did incorrectly:
It added an ApplicationDbContext connection string in appsettings.json file. Go ahead and delete it.
The scaffold tool also added this line of code into Program.cs, that also needs to be deleted:
Edit the code-behind file Areas/Identity/Pages/Account/Register.cshtml.cs. Add the following properties to the InputModel class:
[Required]
[DataType(DataType.Text)]
[StringLength(50, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 2)]
[Display(Name = "First Name")]
public string? FirstName { get; set; }
[Required]
[DataType(DataType.Text)]
[StringLength(50, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 2)]
[Display(Name = "Last Name")]
public string? LastName { get; set; }
In the same file, delete the CreateUser() method.
In the OnPostAsync() method at around line 128, replace:
var user = CreateUser();
with:
var user = new XUser {
UserName = Input.Email,
Email = Input.Email,
FirstName = Input.FirstName,
LastName = Input.LastName
};
In the same Register.cshtml.cs file, replace all instances of ApplicationUser with XUser. Do this also in files Login.cshtml.cs and Logout.cshtml.cs.
Next, let us update the UI. Edit razor page Areas\Identity\Pages\Account\Register.cshtml. Add the following markup to the form right before the email/username block:
This tutorial is about using ASP.NET 10.0 Minimal WebAPI. We will build a simple application with SQLite to save students data. We will then consume the API from an HTML page and add a Swagger interface to test the API endpoints.
Requirements:
.NET 10.0
C# Dev Kit VS Code Extenstion
In a suitable working directory, create a Web API web application in the terminal window with:
dotnet new webapi -o StudentsMinApi
cd StudentsMinApi mkdir Data mkdir Models mkdir wwwroot
code .
dotnet watch
This will appear in your terminal window:
Point your browser to the URL displayed in the terminal window, followed by /weatherforecast.
In the above case the address would be http://localhost:5130/weatherforecast. This would display the following in your browser:
Inside the Models folder, add the following Student class:
public class Student {
public int StudentId { get; set; }
public string? LastName { get; set; }
public string? FirstName { get; set; }
public string? School { get; set; }
public string? Gender { get; set; }
public DateTime? DateOfBirth { get; set; }
}
Developers prefer having sample data when building data driven applications. Therefore, we will create some sample data to ensure that our application behaves as expected. Copy the following data from https://gist.github.com/medhatelmasry/2ae7a36d5392f862b0d1039b2a52b9b4 and save it into a text file wwwroot/students.csv.
Add the following connection string to your appsettings.json file:
Next, we need to add an Entity Framework context class. Inside the Data folder, add a class file named ApplicationDbContext with the following content:
public class ApplicationDbContext : DbContext {
public DbSet<tudent> Students => Set<Student>();
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
: base(options) { }
protected override void OnModelCreating(ModelBuilder modelBuilder) {
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<Student>().HasData(GetStudents());
}
private static IEnumerable<Student> GetStudents() {
string[] p = { Directory.GetCurrentDirectory(), "wwwroot", "students.json" };
var filePath = Path.Combine(p);
var json = File.ReadAllText(filePath);
var data = System.Text.Json.JsonSerializer.Deserialize<List<Student>>(json) ?? new List<Student>();
return data;
}
}
In the above code, student data is being seeded in the OnModelCreating() method by reading contents of students.json file.
We need to register the context class (ApplicationDbContext) with dependency injection in Program.cs. Add the following code right before “var app = builder.Build();” in Program.cs:
var connStr = builder.Configuration.GetConnectionString("DefaultConnection")
?? throw new InvalidOperationException("Connection string 'DefaultConnection' not found.");
builder.Services.AddDbContext<ApplicationDbContext>(option => option.UseSqlite(connStr));
Let us add a migration and subsequently update the database. Execute the following CLI commands in a terminal window:
dotnet ef migrations add M1 -o Data/Migrations
dotnet ef database update
At this point the database and tables are created.
Students API
Let us add API endpoints that:
Read all the students
Read student data by id
Add student data
Update student data
Delete student data
This can easily be done using the scaffold tool. Make sure you install the tool globally with this terminal window command:
Note the following mapping code in your Program.cs file:
app.MapStudentEndpoints();
You can start the WebAPI app and view all students at endpoint: /api/student.
OPTIONAL: If you want migrations to be applied automatically, add the following code to Program.cs right before the last “app.Run()” statement
using (var scope = app.Services.CreateScope()) {
var services = scope.ServiceProvider;
var context = services.GetRequiredService<ApplicationDbContext>();
context.Database.Migrate();
}
Adding Swagger Support
It is very easy to add Swagger support to our application so that we can test the various endpoints that our WebAPI application has to offer.
Add the following code right under app.MapOpenApi():
app.UseSwaggerUI(options =>
{
options.SwaggerEndpoint("/openapi/v1.json", "My WebAPI");
});
In file Properties/launchSettings.json, set the value of launchBrowser to true in two places:
"launchBrowser": true
Also, add the following property to both the http and https JSON blocks:
"launchUrl": "swagger"
Restart the app by typing dotnet watch in the terminal window. The app will automatically load into your default browser in a Swagger interfact that looks like this:
Go ahead and test all the available student endpoints.
You may encounter the following error when you try any of the endpoints that require an ID parameter - example: /api/Student/{id} endpoint:
This error can easily be resolved by targeting OpenAPI version 3. In Program.cs, replace "builder.Services.AddOpenApi();" with:
Replace PUT-API-URL-HERE with the URL that gets all the students (Example: http://localhost:5130/api/students).
From the file system, double-click on the wwwroot/show.html file. You will see the following page:
When you click on the “Get Data” button, nothing will appear because there is a JavaScript error. To understand where this error is coming from, hit F12 in your browser and check the console. This error will appear:
We need to enable CORS in the WebAPI project. This is done by adding the following code in Program.cs just before “var app = builder.Build();”: