Replace the current HTML5 video player implementation with YouTube embedded player to integrate videos from the @JesseLiberty YouTube channel while maintaining all existing interactive learning features.

Proposed Changes

1. Replace HTML5 Video Player with YouTube Embed
   • Implement YouTube IFrame embed in VideoLearning.razor
   • Source videos from https://youtube.com/jesseliberty channel
   • Replace
2. Maintain Existing Functionality
   All current features must remain operational:
   • Pause & Inquire: Pause video and open question panel
   • Interactive Transcript: Clickable, time-synchronized segments
   • Time Tracking: Real-time display of current playback position
   • Seeking: Click transcript to jump to timestamp
   • Search Integration: Wikipedia, Wiktionary, YouTube, Stack Overflow, MDN
3. Use YouTube IFrame Player API
   Implement programmatic video control using YouTube IFrame Player API:
   • pauseVideo() – Pause playback
   • playVideo() – Resume playback
   • getCurrentTime() – Get current timestamp
   • seekTo(seconds) – Jump to specific time
   • getDuration() – Get video length
   • Event listeners: onStateChange, onReady
4. Video Selection & Configuration
   • Video Dropdown: Add UI to select from multiple videos in @JesseLiberty channel
   • Video Catalog: Create a list/configuration of available educational videos with:
   • YouTube video ID
   • Title/description
   • Associated transcript segments
   • State Management: Store selected video ID in component state
   • Configuration Options:
   • Hardcode initial video list in component
   • OR store in appsettings.json
   • OR create a separate service/data file
   Technical Considerations
   JavaScript Interop Changes
   • Load YouTube IFrame API script: https://www.youtube.com/iframe_api
   • Create typed JavaScript interop wrapper for YouTube Player API
   • Replace direct eval() calls with proper YouTube API method invocations
   • Handle async initialization of YouTube player (onYouTubeIframeAPIReady)
   Example JS Interop Pattern:

// VideoLearning.razor.js
export function initializeYouTubePlayer(videoId, dotNetHelper) {
const player = new YT.Player(‘player’, {
videoId: videoId,
events: {
‘onReady’: onPlayerReady,
‘onStateChange’: onPlayerStateChange
}
});
// Store player reference and expose methods
}

export function pauseVideo(player) {
player.pauseVideo();
}

export function getCurrentTime(player) {
return player.getCurrentTime();
}

Transcript Handling
• Option 1: Manually create transcript segments per video (current approach)
• Option 2: Fetch captions using YouTube Data API v3 (requires API key)
• Option 3: Store transcripts in separate JSON files mapped to video IDs
• Consider caption format: YouTube provides .srt or .vtt formats
Render Mode Compatibility
• Ensure YouTube IFrame API works with @rendermode InteractiveServer
• Test SignalR reconnection behavior with YouTube player state
• Verify StateHasChanged() triggers UI updates correctly
Files to Modify

1. VideoLearning.razor
   • Replace
2. Components/Pages/VideoLearning.razor.js (new file)
   • Create typed JS module for YouTube Player API
   • Export functions: initPlayer, pauseVideo, playVideo, seekTo, getCurrentTime
   • Handle player events and callbacks to Blazor
3. Models/VideoInfo.cs (optional, new file)

public record VideoInfo(string VideoId, string Title, List Transcript);

4. appsettings.json (optional)
   • Store video catalog configuration
   Implementation Steps
5. Add YouTube IFrame API script reference to App.razor or VideoLearning.razor
6. Create VideoLearning.razor.js with YouTube Player API wrapper
7. Update VideoLearning.razor markup to use YouTube embed
8. Refactor C# interop calls to use YouTube-specific methods
9. Add video selection UI and catalog
10. Test all interactive features (pause/resume, seeking, transcript sync)
11. Update transcripts for selected YouTube videos from @JesseLiberty channel
    Success Criteria
    • Videos from @JesseLiberty YouTube channel play in the application
    • Users can switch between multiple videos
    • All existing interactive features work identically
    • Pause & Inquire functionality remains intact
    • Interactive transcript synchronization works
    • Time tracking displays correctly
    • Search integration functions as before
    • No degradation in user experience
    Resources
    • YouTube IFrame Player API Reference
    • YouTube Data API v3 – Captions (for transcript retrieval)
    • Blazor JavaScript Interop

Labels: enhancement, feature, blazor, javascript-interop
Priority: High

Those look like a great set of sub-tasks. I’m not sure how to attack them, but breaking them down will greatly simplify matters.

Here’s a first attempt at some of the sub-issues arising out of the work…

You can see that this is far from perfect. Some of these are small and some are huge. It will be necessary to flesh out some and to break others down to smaller tasks, but this is a good start. The trick is not to get overwhelmed. OK, I’m overwhelmed. But my buddy CoPilot and I are ready to tackle this.

The best way to get ahead of this is to create a copilot-instructions.md file in your .github directory (which you may need to create). In this file, you’ll want to put anything that CoPilot should know right from the get-go and for every session.

But how do you know what to put in there?

Here’s the trick… let CoPilot build it for you! I cribbed a set of instructions from the ‘net that tells CoPilot how to create the file based on the existing code in my project. I tweaked it just a bit, as did a buddy (Teja) and all you need to do is copy it into the CoPilot window in Visual Studio, let CoPilot cook, and hey! presto! you have just what you want: a fully developed copilot-instructions.md file in just the right place. Even better, if you already have one, this will merge cleanly.

Here’s the instructions I give CoPilot:

Analyze this codebase to generate or update .github/copilot-instructions.md for guiding AI coding agents. Focus on discovering the essential knowledge that would help an AI agent be immediately productive in this codebase. Consider aspects like: The “big picture” architecture that requires reading multiple files to understand – major components, service boundaries, data flows, and the “why” behind structural decisions Critical developer workflows (builds, tests, debugging) especially commands that aren’t obvious from file inspection alone Project-specific conventions and patterns that differ from common practices Integration points, external dependencies, and cross-component communication patterns Guidelines (read more at https://aka.ms/vscode-instructions-docs):

If .github/copilot-instructions.md exists, merge intelligently – preserve valuable content while updating outdated sections Write concise, actionable instructions (~20-50 lines) using markdown structure Include specific examples from the codebase when describing patterns Avoid generic advice (“write tests”, “handle errors”) – focus on THIS project’s specific approaches Document only discoverable patterns, not aspirational practices Maintaining a history or features listing with a detailed description of all the information of the project into a README.md file whenever there is a new change. Update the file accordingly with a brief summary. Before each task implementation, go through the README.md file, then start implementing, understanding the whole picture of the requirements. Reference key files/directories that exemplify important patterns Update .github/copilot-instructions.md for the user, then ask for feedback on any unclear or incomplete sections to iterate.

When writing unit tests use xunit and moq

And here is the markdown file that CoPilot generated for me (put this into a file and open it in VS to see it displayed nicely):

# GitHub Copilot Instructions for HyperVideo

HyperVideo is an interactive video learning platform built with **.NET 10** and **Blazor Server**. Users can pause videos, ask questions, and search multiple knowledge sources for learning resources.

## Project Structure

```
HyperVideo/
├── Components/
│   ├── App.razor               # Root component (HTML shell, Bootstrap, Blazor script)
│   ├── Routes.razor            # Router with 404 fallback and default layout
│   ├── _Imports.razor          # Global using directives for all components
│   ├── Layout/
│   │   ├── MainLayout.razor    # Two-column layout: sidebar NavMenu + main content area
│   │   ├── NavMenu.razor       # Navigation links (Home, Video Learning, Counter, Weather)
│   │   └── ReconnectModal.razor # SignalR reconnection overlay
│   └── Pages/
│       ├── Home.razor          # Landing page with link to video learning
│       ├── VideoLearning.razor # Core feature: interactive video player with inquiry panel
│       ├── Counter.razor       # Simple stateful counter demo
│       ├── Weather.razor       # Async data fetch demo with streaming render
│       ├── Error.razor         # Error boundary page
│       └── NotFound.razor      # 404 page
├── wwwroot/
│   ├── app.css                 # Global styles
│   └── lib/                   # Bootstrap 5 CSS/JS
├── Program.cs                  # App startup and middleware pipeline
├── appsettings.json
└── HyperVideo.csproj
```

## Technology Stack

- **Runtime**: .NET 10 (`net10.0`)
- **UI**: Blazor Server with Interactive Server rendering (`@rendermode InteractiveServer`)
- **Real-time**: ASP.NET Core SignalR (used implicitly by Blazor Server)
- **CSS**: Bootstrap 5, Bootstrap Icons (`bi-*`), component-scoped CSS files (`.razor.css`)
- **JS Interop**: `IJSRuntime` for controlling the HTML5 `<video>` element
- **Nullable**: enabled; **ImplicitUsings**: enabled

## Coding Conventions

### Blazor Components
- Place all pages under `Components/Pages/` with `@page "/route"` directives.
- Place shared layout under `Components/Layout/`.
- Use `@rendermode InteractiveServer` on pages that need interactivity (event handlers, JS interop).
- Component-scoped CSS goes in a sibling file named `ComponentName.razor.css`.
- Use `@code { }` blocks at the bottom of `.razor` files for C# logic.

### C# Style
- Follow standard C# conventions: PascalCase for types and methods, camelCase for private fields.
- Prefer `record` types for immutable data (e.g., `TranscriptSegment`).
- Use nullable reference types; annotate `string?` where null is expected.
- Use `string.Empty` instead of `""` for empty-string defaults.
- Prefer `async Task` over `async void` for event handlers.

### JavaScript Interop
- Inject `IJSRuntime` with `@inject IJSRuntime JS`.
- Prefer `JS.InvokeVoidAsync` for fire-and-forget calls and `JS.InvokeAsync<T>` when a return value is needed.
- Avoid `eval()` for new interop code; instead, expose named JavaScript functions in `wwwroot/` and call them by name.
- Always wrap JS interop calls in `try/catch` because the circuit may not be ready.

### State Management
- Use private fields and `StateHasChanged()` for local component state.
- Keep models close to where they are used; only extract to a separate file when shared across multiple components.

### Error Handling
- Wrap async event handlers in `try/catch` and log errors with `Console.WriteLine` or an injected `ILogger<T>`.
- Use the `Error.razor` page as the global error boundary (already wired via `<ErrorBoundary>`).

## Key Feature: VideoLearning.razor

`VideoLearning.razor` is the core component. Its responsibilities:

| Concern | Implementation |
|---|---|
| Video playback | HTML5 `<video>` element; JS interop to call `.pause()`, `.play()`, seek |
| Pause & Inquire | Sets `isPaused = true`, shows inquiry panel with timestamp |
| Question search | Builds URL links to Wikipedia, Wiktionary, YouTube, Stack Overflow, MDN |
| Transcript | `List<TranscriptSegment>` displayed as clickable rows; active row highlighted |
| Time tracking | `@ontimeupdate` reads `currentTime` via JS interop |

When extending this component:
- Add new search sources by appending to `searchResults` inside `SearchForAnswer()`.
- Add transcript segments by adding `new TranscriptSegment(start, end, "text")` entries.
- Use `ElementReference` + `JS.InvokeVoidAsync("blazorHelpers.seekVideo", videoElement, time)` style helpers rather than bare `eval()`.

## Common Patterns

### Adding a New Page
```razor
@page "/my-page"
@rendermode InteractiveServer

<PageTitle>My Page</PageTitle>

<!-- markup -->

@code {
    // component logic
}
```
Then add a `<NavLink>` entry in `NavMenu.razor`.

### Injecting a Service
Register in `Program.cs`:
```csharp
builder.Services.AddScoped<IMyService, MyService>();
```
Inject in component:
```razor
@inject IMyService MyService
```

### JS Interop Helper Pattern
Add a function to `wwwroot/app.js` (create if it does not exist):
```javascript
window.blazorHelpers = {
    seekVideo: (element, time) => { element.currentTime = time; }
};
```
Call from C#:
```csharp
await JS.InvokeVoidAsync("blazorHelpers.seekVideo", videoElement, time);
```

## Build & Run

```bash
# Restore and run
 dotnet run --project HyperVideo/HyperVideo.csproj

# Build only
dotnet build HyperVideo/HyperVideo.csproj
```

Default URLs: `http://localhost:5092` / `https://localhost:7288`

## What to Avoid

- Do **not** use `@rendermode InteractiveWebAssembly` — this project is Blazor Server only.
- Do **not** add NuGet packages without checking compatibility with `net10.0`.
- Do **not** use bare `eval()` strings for new JS interop; prefer named helper functions.
- Do **not** use `async void` event handlers; use `async Task` and handle exceptions.
- Do **not** store secrets in `appsettings.json`; use environment variables or the .NET Secret Manager.

This is based on the skeleton program written in the past couple of postings, so it didn’t have all that much to go on. Nonetheless, it created a great context file with very specific instructions for CoPilot that will create a consistent interface and programming approach.

More to come as we develop HyperVideo but this will put us on the right track straight away.

• Writing prompts
• Writing apps that integrate AI (see Hypervideo)

If you are writing apps, you have a couple choices (well, more than a couple). One choice is to stay in the Azure/.NET world, in which case C# is just fine. The other (set of) choice(s) is to work in the rest of AI development, in which case Python is the language of choice.

I’m taking a course on agentics from Johns Hopkins University, and that course is in Python. It turns out that learning Python is pretty easy if you are a C# programmer, and it is even easier if you are a C# programmer with access to CoPilot and/or ChatGPT for Python.

I resisted learning Python all these years, but I’ve come to believe that if you are serious about AI then Python is in your future. So, might as well bite the bullet and get started now.

It’s Just Syntax

All the concepts are the same (more or less). There are variables, loops, dictionaries, tuples and so forth. Some of the syntax is different (no braces) and some of the rules vary a bit (tuples are immutable), but it won’t take you long to learn. Let’s start with the basics.

DataTypes: Python has only three numeric datatypes: int, float and complex. It also has str (string) and bool. One thing to watch for is truthy v true. True requires a bool but truthy is anything that evaluates to true. Huh? If a variable is of type bool, it can only. have one of two values: true or false. But an expression can evaluate to true (e.g., 5+7 = 12) which is truthy.

There are also collections. some are ordered: list (which is mutable), tuple (which is not mutable) and range (which is an immutable arithmetic progression). In addition, there is dict — a dictionary which works much like a dictionary in c#

If you need a dictionary with unique values, there is the set, which comes in two flavors: set (mutable) and frozenset (immutable)

Finally, None does the work of void

According to ChatGPT the core types you’ll use 90% of the time are:

• int
• float
• str
• bool
• list
• dict
• tuple
• set
• none

which pretty much corresponds to the big types in c# (except, perhaps set).

Indentation One big thing for C# programmers to watch out for is indentation. Python does not use braces in if statements, functions, etc.; it uses indentation.

if (myAge > 5)
   print("You are a big boy")
else
   print("You still have some growing to do")
   print("But don't worry, we all went through it")
print("this line is not in the if/else")

Notice that the last print statement is not in the if/else construct. Oh, there is also an elif statement so that you can have if, elif, elif, else.

Function definition You define a function with the keyword def and you use indentation to set the contents of the function:

def greet(name):
    print("Hello")
    print(name)

Some quick rules on indentation:

• Typically you indent 4 spaces (but that is not really a rule)
• All indentation must be the same amount
• You cannot mix tabs and spaces

Don’t forget to nest your indentation

def check_age(age):
    if age >= 21:
        print("Can drink")
    else:
        print("Cannot drink")

Lists Lists are created with square brackets

numbers = [10, 20, 30, 40]

Notice you do not put the type. You never declare the type, it is inferred. (this is true for all declarations, not just collections)

You iterate over lists with a very similar syntax to C#’s foreach

for number in numbers:
   print(number)

Don’t forget the colon!

Dictionaries Dictionaries are similar to lists, but you declare them with curly braces. You iterate over them using the key and the value:

students = {
    1001: "Alice",
    1002: "Bob"
}

for student_id, name in students.items():
    print(student_id, name)

This will print

1001 Alice
1002 Bob

You can access both with .items() or the keys with .keys() or the values with .values()

Tuples Tuples can be declared with or without parentheses

coordinates = (15, 20)
colors = ("red", "greeen", "blue", "yellow")
point = 5,10

You can iterate over a tuple

for color in colors:
   print(color)

A common thing to do with tuples is called unpacking. For example, using the point from above, you can write

point = (10, 20)

x, y = point
print(x)  # 10
print(y)  # 20

Or you can use this in loops, which is a common construct

pairs = ((1, "A"), (2, "B"), (3, "C"))

for number, letter in pairs:
    print(number, letter)

That’s plenty to get you started with Python. Of course there are more advanced constructs, and we’ll tackle them as we go, but these are the fundamentals.

1. Run the video and show a transcript in real time
2. Pause the video and type in any question on related or other topics (first cut)
3. Add speech recognition
4. Pause the video and be offered questions related to what was just said in the video
5. Ask a question and see a (hyper) video in response (a button appears to take you back one video)
6. Add text-to-speech to answer questions
7. Add history of previous questions to serve as context for future questions
8. Add quizzes at the end of the video
9. Add ability to scroll back in the transcript and be offered questions about the selected time slice or hypervideo link from there
10. Add hyperlinks to the transcript. Following the link potentially brings up new videos

More to follow, I’m sure, but that’s a pretty good starting list.

Here is 2026’s list…

Lists are always subjective, but it is helpful, I think, to exchange favorites now and again. Here’s my list in no particular order

1. Visual Studio 2026 – goes without saying that this is the world’s best IDE for .NET developers. I use it 8-12 hours a day; it just keeps getting better, especially with CoPilot.
2. Copilot – AI done right. Integrated with Visual Studio, this add-on is the most powerful and useful tool I have. It can get in the way a little, but when it does its stuff, watch out. Point it at a class and ask for documentation and/or unit tests and watch it go! More powerful is CoPilot Agents which will cook up substantial amounts of excellent code. But kids, don’t try this at home—it needs adult supervision.
3. ExamDiffPro – there are lots of comparison/merge utilities. Get a good one.
4. Tweaks by Mads Kristensen — small but very valuable addition to VS
5. Evernote: I use it to log everything I do, including every fix for recurring issues. It is quick, powerful, and easy to use. Although it has limitations, overall, I’ve found it helpful and reliable and it now holds thousands of notes for me. It does have a new transcription ability, but I find it somewhat limited (no summary, etc.) for that I use…
6. TalkNotes. This incredibly flexible iOS utility does just what it says: it takes notes and then will produce those notes in any number of ways, including custom reports. I use only a small portion of its potential, but they are critical to my workflow. (1) I use it to summarize meetings and tell me the action items, and (2) I dictate to it as I work so that I can ask, “What did I do 5 minutes ago that made this all break?” Note: this application type is exploding and there are many great competitors. One I have my eye on is Wave, which offers the ability to make inquiries about your meeting and which uses generative AI to provide meaningful answers.
7. WhisprFlow – by far the best dictation software I’ve seen. Only caveat is that this is for relatively brief dictation – enough to send a message, not enough to replace TalkNotes or Wave. On the other hand, WhisprFlow is available on iOS, Android, Mac, and Windows and works well on all (I don’t have Android, so can’t swear to that).
8. Roboform my password manager. I’d be lost without it. There are many, but this one is extremely straightforward and has been reliable for a very long time.
9. BlueSky—the single best social media site for .NET programmers
10. A note about Resharper. Many C# developers find it indispensable. Probably because I never became really proficient with it, and because VS has so many refactorings built in, I do not have it on my computer. But you may want to.

Note that nearly all of these are free. I do remember the days when a program like Lotus 123 cost something in the hundreds of dollars. It makes me laugh when I see people look at an app and say, “$4, naah, too expensive.” On the other hand, watch out for the AI apps, they can be over $100 / year.

I am not affiliated with any of these.

Create an application with a rectangle in which a video is playing (typically news or an instructional video, but it can be anything). Next to the video is a transcript. Under the video are a few buttons. One pauses the video and lets you inquire about something that was just said (or anything that comes to mind for that matter). The video player now takes you to Wikipedia, Wiktionary and any other public source that might best answer your question. It may even begin a related video. A second button resumes the video. There is a button to jump back 15 seconds and another to jump ahead 30 seconds.

CoPilot went to work. Literally five minutes later I had the skeleton of a working program

With that in place, I have a framework to add the AI features. In fact, CoPilot even prompted me on which features I need. Here’s what CoPilot says it implemented:

What I’ve Created:

Optional: Add Azure OpenAI for intelligent Q&A response

VideoLearning.razor – Main component with
• HTML5 video player with all requested controls
• Interactive transcript with timestamp navigation
• Pause & Inquire feature with multi-source search
• Jump back 15s and forward 30s buttons
• Resume functionality

VideoLearning.razor.css – Comprehensive styling with:
• Responsive grid layout
• Professional card designs
• Smooth animations
• Mobile-friendly design
• Scroll customization

NavMenu.razor snippet – Navigation integration

README-VideoLearning.md – Complete setup and usage guide

Next Steps:

Add your video: Place a video file in wwwroot/videos/sample-video.mp4

Customize transcript: Replace sample data with your actual transcript

Optional: Integrate with Wikipedia/YouTube APIs for richer search results

Picture a rectangle in which a video is playing (typically news or an instructional video, but it can be anything). Next to the video is a transcript. Under the video are a few buttons. One pauses the video and lets you inquire about something that was just said (or anything that comes to mind for that matter). The video player now takes you to Wikipedia, Wiktionary and any other public source that might best answer your question. It may even begin a related video (hence the name HyperVideo).

This touches on a number of the more interesting aspects of Azure AI, among them speech to text, generative AI and I’ll probably build it out to handle some additional functionality as I go (translation to other languages? text to speech?)

I expect this to be developed with a timeline like a hockey stick. That is, slow going at first, and then rapid development as I learn more and as the project comes along.

First step: ask CoPilot to take a crack at it, using Blazor as the front end and some combination of SQL Server and Blob storage as the back end. SQL Server may be overkill, I’ll look at some lighter weight alternatives as well.

I’ll keep you up to date as I go…

This is the first certification I’ve ever tried for… no that’s a lie, I was a certified Xamarin developer. But beside that one, this is the first. I’ve never been sure that they are worthwhile (as an autodidact), but AI is so new and changing so fast and so bloody interesting that I couldn’t resist.

I’ll begin with the obvious question: which AI engine? The answer to that was easy; I’ve spent the past three decades working in what is now .NET, and I worked for Microsoft, and I currently work in an all-Microsoft shop. So Azure it is.

The Bits and Pieces

Azure offers 7 major AI services:

• AI Search
• Document Intelligence
• Azure OpenAI Service
• Vision
• Speech
• Language

Over the course of these blog posts, I hope to cover Large Language Models (LLMs) and the following AI sub-topics:

• Retrieval-Augmented Generation (RAG)
• Prompt Engineering
• Natural Language Processing (NLP)

Generative AI

Generative AI is what all the excitement is about. Generative AI can create new content that it has never seen before—even content that has never existed before. Show it a bunch of books (including 29 of mine, thank you very much, Anthropic!) and after a while it can be an intelligent CoPilot for your work.

Programming with Generative AI, and especially Agentic Generative AI, is an incredible experience. It allows you to articulate what you want, and then it goes off and does it for you. Specifically, you can say something like (from the previous blog post):

Create an ASP.net API with a sqlserver* backend. SQLServer will have two tables: bookList and Authors, with the booklist id as a foreign key in Authors. Unit tests using xUnit and Moq. Set up Azurite to provide a message queue, have the GET endpoint create a durable function to listen to the message queue, and have POST use an Azure function to add records to the database. Create service classes for the logic and Repository classes for interacting with the Database

and it does. Fast. Incredibly, the code is usually good. I’d say it gets you about 80% of the way there, which is pretty fantastic. You can even tell it general design requirements (even coding styles, etc.) with a copilot-instructions.md file that you put into the .github directory.

The more context you can provide the better, where context includes the assumptions you make such as which unit testing framework to use, what you’ll be doing with this code, how it relates to other code CoPilot knows about, etc.

I’ll come back to Generative AI in future blog posts. I’ll also touch on ASI — Artificial SuperIntelligence, and I’ll point you to the book If Anyone Builds It, Everyone Dies. Which is an amazing title and a book that will scare your pants off.

Finally, I should mention that AI is the foundational technology for Vibe Coding. For more on what this is, see this video or this podcast of the video sound track. You may also want to check out Jeff Blankenburg’s series of blog posts, 31 Days of Vibe Coding which starts here.

More to come in the next post in this series.

* So, is it “a SQL” or “an SQL”? Since I pronounce it SeeQuill, I’ll go with “a SQL.”

As part of the API tutorials we decided we needed a Database with two tables: Book and Author. Books will join Author and there can be as many authors as we want. Rather than writing this however, I went on GitHub and used the agents.

I prompted:
ASP.net API with a sqlserver backend. SQLServer will have two tables: bookList and Authors, with the booklist id as a foreign key in Authors. Unit tests using xunit and moq. Set up Azurite to provide a message queue, have the GET endpoint create a durable function to listen to the message queue, and have POST use an Azure function to add records to the database. Create service classes for the logic and Repository classes for interacting with the Database

CoPilot responded with a huge amount of work. Here is its description of what it did in reaction to this prompt.

Bootstrapped a complete ASP.NET Core Web API with SQL Server backend, Azure Functions for async processing, and Azurite-backed message queues. The architecture separates GET operations (handled by durable functions) from POST operations (handled by queue-triggered functions).

Database Schema

• Books table: Id, Title, ISBN, PublishedDate, Price
• Authors table: Id, FirstName, LastName, Email, BookId (FK → Books)
• One-to-many relationship via BookId foreign key
• EF Core migrations included

Architecture Layers

Repository Pattern

• IBookRepository / BookRepository – Book data access
• IAuthorRepository / AuthorRepository – Author data access
• Async operations, includes navigation properties

Service Layer

• IBookService / BookService – Book business logic
• IAuthorService / AuthorService – Author business logic
• QueueService – Azure Queue message dispatch

API Controllers

• BooksController – GET triggers durable function via book-get-queue, POST queues to book-queue
• AuthorsController – Standard CRUD operations

Azure Functions

BookQueueProcessor (Queue-triggered)

[Function("ProcessBookCreation")]
public async Task Run(
    [QueueTrigger("book-queue", Connection = "AzureWebJobsStorage")] string queueMessage)
{
    var bookMessage = JsonSerializer.Deserialize<BookMessage>(queueMessage);
    // Creates book + authors in single transaction
}

BookDurableFunction (Orchestrator)

[Function("BookDurableOrchestrator")]
public async Task<string> RunOrchestrator([OrchestrationTrigger] TaskOrchestrationContext context)
{
    var result = await context.CallActivityAsync<string>("ProcessGetRequest", input);
    return result;
}

Message Queue Flow

GET  /api/books → book-get-queue → Durable Function → Orchestration
POST /api/books → book-queue     → Azure Function   → DB Insert

Testing

16 xUnit tests with Moq covering:

• Service layer behavior (BookService)
• Repository CRUD operations (InMemory EF provider)

Configuration

• appsettings.json – SQL Server connection, Azurite queue config
• local.settings.json – Azure Functions runtime settings
• Two queues: book-queue, book-get-queue
• Connection string: UseDevelopmentStorage=true (Azurite)

Documentation

• SETUP.md – Installation and database setup
• QUICKSTART.md – Three-terminal startup sequence
• ARCHITECTURE.md – System diagrams and data flows

Note that along the way I added to my prompt, and CoPilot adjusted what it was doing accordingly.

Merge info

Review requested

Review has been requested on this pull request. It is not required to merge. Learn more about requesting a pull request review.

No conflicts with base branch

Merging can be performed automatically.

This pull request is still a work in progress

CoPilot then asked me to review the code (Pull Request):

I then clicked on Merge and it provided me with a form for the title and description, already filled out for me to modify and approve

Readme file

CoPilot documented what it did in the ReadMe…

Architecture Overview

This is an ASP.NET Core Web API with a SQL Server backend, using Azure Functions and Azure Storage Queues (via Azurite) for asynchronous processing.

Key Components

1. ASP.NET Web API – RESTful API with controllers
2. SQL Server Database – Two tables: Books and Authors
3. Azure Functions – Asynchronous processing
   • Durable Function for GET requests
   • Queue-triggered Function for POST requests
4. Azure Storage Queues (via Azurite) – Message bus
5. Service Layer – Business logic
6. Repository Pattern – Data access layer
7. Unit Tests – xUnit with Moq

Database Schema

• Books Table: Id, Title, ISBN, PublishedDate, Price
• Authors Table: Id, FirstName, LastName, Email, BookId (FK)

Relationship: One Book can have many Authors

Request Flow

GET /api/books

1. API receives request
2. Sends message to book-get-queue (Azurite)
3. Durable Function reads from queue and orchestrates processing
4. API returns book data from database

POST /api/books

1. API receives BookMessage
2. Sends message to book-queue (Azurite)
3. Azure Function (queue-triggered) reads from queue
4. Function creates book and authors in database
5. API returns 202 Accepted

Quick Start

See SETUP.md for detailed setup instructions.

Running Tests

cd BookstoreAPI.Tests
dotnet test

All 16 unit tests cover:

• Service layer (8 tests)
• Repository layer (8 tests)

Starting

CoPilot gave me step by step instructions on how to use this…

Bookstore API Setup Guide

Prerequisites

• .NET 8.0 or later SDK
• SQL Server or LocalDB
• Node.js (for Azurite)
• Azurite (Azure Storage Emulator)

Setup Instructions

1. Install Azurite

npm install -g azurite

2. Start Azurite

Run Azurite to provide local Azure Storage emulation (including queues):

azurite --silent --location ./azurite --debug ./azurite/debug.log

This will start:

• Blob service on http://127.0.0.1:10000
• Queue service on http://127.0.0.1:10001 (message bus)
• Table service on http://127.0.0.1:10002

3. Database Setup

Update the connection string in appsettings.json if needed:

"DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=BookstoreDb;Trusted_Connection=True;MultipleActiveResultSets=true"

Create the database:

cd BookstoreAPI
dotnet ef migrations add InitialCreate
dotnet ef database update

4. Run the Application

Start the API

cd BookstoreAPI
dotnet run

Start the Azure Functions

cd BookstoreAPI.Functions
func start

Or if using dotnet directly:

cd BookstoreAPI.Functions
dotnet run

5. Run Tests

cd BookstoreAPI.Tests
dotnet test

Architecture

Components

1. ASP.NET Web API (BookstoreAPI)
   • Controllers for Books and Authors
   • Service layer for business logic
   • Repository layer for data access
   • Queue service for message bus integration
2. Azure Functions (BookstoreAPI.Functions)
   • GET Durable Function: Listens to book-get-queue via Azurite
   • POST Azure Function: Processes book creation from book-queue
3. Database
   • SQL Server with two tables: Books and Authors
   • Authors has a foreign key to Books (BookId)

1. Client → GET /api/books
2. API sends message to book-get-queue (Azurite)
3. Durable Function reads from queue
4. API returns book data from database

POST Request Flow

1. Client → POST /api/books with BookMessage
2. API sends message to book-queue (Azurite)
3. Azure Function reads from queue
4. Azure Function adds book to database
5. API returns 202 Accepted

Queue Configuration

• GET Queue: book-get-queue – Used by Durable Function
• POST Queue: book-queue – Used by regular Azure Function

Both queues use Azurite as the message bus with connection string:

UseDevelopmentStorage=true

API Endpoints

Books

• GET /api/books – Get all books (triggers durable function)
• GET /api/books/{id} – Get book by ID
• POST /api/books – Create book (via Azure Function)
• PUT /api/books/{id} – Update book
• DELETE /api/books/{id} – Delete book

Authors

• GET /api/authors – Get all authors
• GET /api/authors/{id} – Get author by ID
• GET /api/authors/book/{bookId} – Get authors by book
• POST /api/authors – Create author
• PUT /api/authors/{id} – Update author
• DELETE /api/authors/{id} – Delete author

Testing

The solution includes unit tests using xUnit and Moq for:

• Service layer
• Repository layer
• Controllers

Clone

Once I got over being stunned by all this, I cloned the repository

Quick Start

I then took a look at the Quick Start Guid

Prerequisites Check

# Check .NET SDK
dotnet --version  # Should be 10.0 or later

# Check Node.js (for Azurite)
node --version

# Install Azurite globally
npm install -g azurite

Oops, didn’t have node. No problem, a quick trip to Google revealed where I could get it and installation was a snap. Note that the Node installer also installed chocolatey, which took a few minutes.

Step-by-Step Startup

1. Start Azurite (Terminal 1)

cd BookstoreAPI
mkdir -p azurite
azurite --silent --location ./azurite --debug ./azurite/debug.log

Azurite will start on:

• Blob: http://127.0.0.1:10000
• Queue: http://127.0.0.1:10001 ← Message bus for our app
• Table: http://127.0.0.1:10002

2. Start Azure Functions (Terminal 2)

cd BookstoreAPI.Functions

# Copy template if needed
cp local.settings.template.json local.settings.json

# Run functions
dotnet run

Functions will listen to:

• book-queue – For POST requests
• book-get-queue – For GET requests

3. Start Web API (Terminal 3)

cd BookstoreAPI

# Run the API
dotnet run

API will start on: http://localhost:5000 (or check console for actual port)

4. Test the API

Using curl:

# GET all books (triggers durable function)
curl http://localhost:5000/api/books

# POST a new book (uses Azure Function)
curl -X POST http://localhost:5000/api/books \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Test Book",
    "isbn": "123-456-789",
    "publishedDate": "2024-01-01T00:00:00",
    "price": 29.99,
    "authors": [
      {
        "firstName": "John",
        "lastName": "Doe",
        "email": "john@example.com"
      }
    ]
  }'

# GET a specific book
curl http://localhost:5000/api/books/1

# GET all authors
curl http://localhost:5000/api/authors

# GET authors for a specific book
curl http://localhost:5000/api/authors/book/1

Using the .http file (VS Code with REST Client extension):

# Open BookstoreAPI/BookstoreAPI.http
# Click "Send Request" on any request

Troubleshooting

Database Not Found

cd BookstoreAPI

# Install EF Core tools
dotnet tool install --global dotnet-ef

# Create/update database
dotnet ef database update

Azurite Not Starting

# Kill any running instances
pkill azurite

# Clear data and restart
rm -rf azurite
mkdir azurite
azurite --silent --location ./azurite

Functions Not Triggering

1. Check Azurite is running
2. Check connection string in local.settings.json: UseDevelopmentStorage=true
3. Check function logs for errors
4. Verify queues exist in Azurite (can use Azure Storage Explorer)

Build Errors

# Clean and rebuild
dotnet clean
dotnet restore
dotnet build

Running Tests

cd BookstoreAPI.Tests
dotnet test --verbosity normal

Expected output:

Passed!  - Failed:     0, Passed:    16, Skipped:     0, Total:    16

Monitoring

View Queue Messages

Install Azure Storage Explorer to view:

• Queue messages in book-queue and book-get-queue
• Connection: Use “Attach to local emulator”

View Function Logs

Azure Functions will output logs to the console showing:

• Queue triggers firing
• Durable function orchestrations
• Database operations

View API Logs

ASP.NET Core will output logs showing:

• HTTP requests
• Controller actions
• Queue message sends

Next Steps

1. Add Swagger/OpenAPI – Already configured, visit /openapi endpoints
2. Add Authentication – Implement JWT or OAuth
3. Add Validation – Data annotations on models
4. Add More Tests – Controller tests, integration tests
5. Deploy to Azure – Use Azure App Service + Azure Functions + Azure SQL

Project Structure

BookstoreAPI/
├── BookstoreAPI/              # Web API
│   ├── Controllers/           # API endpoints
│   ├── Models/                # Data models
│   ├── Services/              # Business logic
│   ├── Data/                  # EF Core + Repositories
│   └── Migrations/            # Database migrations
├── BookstoreAPI.Functions/    # Azure Functions
│   ├── BookQueueProcessor.cs  # POST handler
│   └── BookDurableFunction.cs # GET handler
└── BookstoreAPI.Tests/        # Unit tests
    ├── Services/              # Service tests
    └── Repositories/          # Repository tests

Pretty impresive. More than impressive. If I were in my 20s and programming, I would think long and hard about the implications. It is still early days for LLMs, one can only imagine what will be in 5 years.

We’ll get this going and put in a bit of data in the next blog post.