1 Overview

Generative AI has changed what software can do: applications can now draft documents, explain code, answer questions in natural language, and generate working C# from a plain-English description. For .NET developers this is not a research curiosity — it is a set of services and SDKs you can call from ordinary C# code, the same way you call a database or a REST API.

This tutorial is the first step in the GenAI-Powered .NET learning path. It builds the mental model everything else depends on: what generative AI actually is, how it relates to AI and machine learning, how large language models (LLMs) produce text, what tokens and embeddings are, and where Microsoft's AI products — Microsoft 365 Copilot, GitHub Copilot, and Azure OpenAI — fit into a developer's world.

No AI or math background is assumed. If you can write basic C#, you can follow everything here. By the end you will be able to explain how an LLM turns your prompt into a response, estimate what a request will cost in tokens, and name the right Microsoft tool for a given job.

2 Learning Objectives

After completing this tutorial, you will be able to:

• Define generative AI and list the kinds of content it can produce.
• Explain how artificial intelligence, machine learning, deep learning, and generative AI relate to each other.
• Describe, at a high level, how a large language model generates text through next-token prediction.
• Explain what tokens are, why models are limited and billed by tokens, and roughly estimate token counts.
• Describe what embeddings are and why they power semantic search and retrieval.
• Distinguish the roles of Microsoft 365 Copilot, GitHub Copilot, and Azure OpenAI, and identify which one a .NET developer builds with.
• List common developer use cases for generative AI and pick a sensible first use case for a .NET application.

3 Prerequisites

This is a beginner tutorial. You need working knowledge of C# (classes, methods, async/await at a reading level) and a .NET development environment — Visual Studio, VS Code with the C# extension, or the .NET SDK and any editor.

• C# fundamentals: variables, methods, classes, and running a console application.
• .NET 8 SDK (or later) installed if you want to try the code samples.
• No machine learning, statistics, or Python background is required.
• An Azure subscription is NOT required for this tutorial; it becomes useful from the Azure OpenAI tutorials onward.

4 What Generative AI Is and What It Produces

Generative AI is a branch of artificial intelligence that creates new content rather than only analyzing existing content. A traditional (discriminative) model answers questions like 'is this email spam?' or 'what is this house worth?' — it assigns labels or numbers to input. A generative model instead produces something that did not exist before: a paragraph, a C# method, an image, a summary, a translation.

The models behind this are often called foundation models: very large neural networks trained on broad data that can be applied to many tasks without task-specific retraining. Large language models (LLMs) are foundation models specialized in text — and because source code is text, they handle code remarkably well.

Two properties distinguish generative AI from the software you usually write. First, it is probabilistic: the same input can produce different output on different runs. Second, it is instructable with natural language: behavior is shaped by the prompt you send, not only by code you compile. Both properties have deep consequences for how you design, test, and ship AI features — themes that run through this entire course.

5 AI vs. Machine Learning vs. Generative AI

The terms AI, machine learning, and generative AI are often used interchangeably in marketing, but they are nested concepts — each one is a subset of the one before it. Keeping the hierarchy straight makes every later topic easier.

Classic ML is mostly discriminative: given input, predict a label (spam / not spam) or a value (price). You typically train such models yourself on your own data. Generative AI flips the workflow: the model is already trained by a provider at enormous cost, and you consume it as a service — your engineering effort goes into prompts, data grounding, and integration rather than training. That is why this course spends far more time on calling and steering models from C# than on training them.

6 How Large Language Models Work (High Level)

A large language model is a neural network — almost always based on the transformer architecture — trained on a huge corpus of text and code. During training, the model repeatedly plays one game: given a sequence of tokens, predict the next token. Over billions of examples it internalizes grammar, facts, reasoning patterns, and coding conventions, purely as statistical structure in its parameters.

When you send a prompt, the model runs inference: it converts your text to tokens, computes which token is most likely to come next, appends it, and repeats — one token at a time — until it emits a stop signal or hits a length limit. Everything an LLM does, from answering questions to writing C#, emerges from this next-token loop. The transformer's attention mechanism is what makes the predictions good: it lets every token 'look at' the other tokens that matter, so the model can connect a variable's use on line 40 with its declaration on line 2.

• Training happens once, at massive scale, at the provider. You never see it.
• Inference is what you pay for per request — it is the API call your C# code makes.
• The context window caps how many tokens (your input plus the model's output) fit in one request.
• Temperature and similar settings control how random the next-token choice is: low = focused and repeatable, high = varied and creative.
• The model has a knowledge cutoff: it knows nothing after its training data ends, and nothing about your private data — unless you supply that data in the prompt.

Two practical consequences follow. First, output is not deterministic by default — asking twice may yield two different (both plausible) answers, which changes how you test AI features. Second, the model does not 'look things up'; it generates likely text. When likely text is not true text, you get a hallucination. Later tutorials cover the standard defenses: grounding the model in your data (RAG) and evaluating output quality.

7 Tokens and Tokenization

Models do not read characters or whole words — they read tokens. Tokenization splits text into pieces from a fixed vocabulary: common words like 'the' are a single token, while rarer words split into subword chunks ('tokenization' might become 'token' + 'ization'). Code, spaces, and punctuation all consume tokens too.

Tokens matter to you as a developer for three concrete reasons. Pricing: API usage is billed per token, input and output counted separately. Limits: the context window is a token budget — a model with a 128k-token window cannot accept your 200k-token document in one call. Behavior: when a response stops mid-sentence, you usually hit the output token limit, not a bug in your code.

• Rule of thumb for English: 1 token is roughly 4 characters, so 100 tokens is about 75 words.
• A rough estimate is fine for budgeting; exact counts come from a tokenizer library or the usage numbers the API returns with every response.
• Different model families use different tokenizers, so counts vary slightly between models.
• Non-English text and unusual identifiers often use more tokens per word than plain English.

// Rough heuristic: ~4 characters per token for English text.
// Use the API's returned usage figures for exact billing numbers.
static int EstimateTokens(string text) =>
    (int)Math.Ceiling(text.Length / 4.0);

string prompt = "Explain dependency injection in ASP.NET Core in one paragraph.";
Console.WriteLine($"~{EstimateTokens(prompt)} tokens"); // ~16 tokens

8 Embeddings: What They Are and Why They Matter

An embedding is a numeric representation of meaning: an embedding model turns a piece of text into a vector — an array of floating-point numbers, often 1,536 or 3,072 dimensions. The defining property is that texts with similar meaning produce vectors that are close together, even when they share no words. 'How do I reset my password?' and 'I forgot my login credentials' land near each other in vector space.

Closeness is measured mathematically, most commonly with cosine similarity — a score near 1 means very similar meaning, near 0 means unrelated. That single trick unlocks a family of features: semantic search (find documents by meaning, not keywords), recommendations (find items similar to this one), clustering and de-duplication, and — most importantly for this course — retrieval-augmented generation (RAG), where you find the most relevant chunks of your own data and hand them to an LLM as context so it answers from facts instead of guessing.

// An embedding model (e.g. an Azure OpenAI embeddings deployment)
// returns a float[] for each input text. Comparing two vectors:
static double CosineSimilarity(float[] a, float[] b)
{
    double dot = 0, magA = 0, magB = 0;
    for (int i = 0; i < a.Length; i++)
    {
        dot  += a[i] * b[i];
        magA += a[i] * a[i];
        magB += b[i] * b[i];
    }
    return dot / (Math.Sqrt(magA) * Math.Sqrt(magB));
}
// ~0.9 for near-identical meaning, ~0.0 for unrelated text.

9 The Microsoft AI Ecosystem

Microsoft ships generative AI at three distinct altitudes, and knowing which is which prevents endless confusion, because all three carry the word 'Copilot' or sit near it in the news.

The distinction that matters most for this course: Microsoft 365 Copilot and GitHub Copilot are finished products you use, while Azure OpenAI is a building block you program against. When your ASP.NET application needs to summarize a document or answer a customer question, your code calls Azure OpenAI (directly or through frameworks like Semantic Kernel, introduced later in this course). Azure OpenAI also brings the enterprise properties applications need: your prompts and data are not used to train the underlying models, access is controlled with Azure identity and networking, and usage is billed and monitored through your Azure subscription.

10 Typical Developer Use Cases for GenAI

Generative AI shows up in a .NET developer's life in two ways: as a productivity tool while you build software, and as a capability inside the software you build. Both matter, and this course covers both.

• Code generation and completion — turning intent into C# scaffolding, LINQ queries, regex, or SQL.
• Code explanation and review — understanding unfamiliar or legacy code, spotting bugs and smells.
• Test generation — drafting xUnit/NUnit tests and edge cases for existing methods.
• Documentation — generating XML doc comments, README drafts, and release notes from code and commits.
• Summarization — condensing tickets, logs, meeting notes, or long documents inside your applications.
• Conversational interfaces — chatbots and assistants that answer from your product's data.
• Data extraction and transformation — pulling structured JSON out of free-form text like emails or invoices.
• Translation and rewriting — localizing content or adjusting tone for different audiences.

When choosing a first AI feature for a real application, favor use cases where output is reviewed by a human or is easy to validate (summaries, drafts, extraction with schema validation) over use cases where wrong output acts unsupervised. A summarizer whose output a support agent reads is a far safer first project than an agent that closes tickets automatically. The reliability tutorials later in the course explain how to graduate from the first kind to the second.

11 Code Examples in C#

This first example shows the shape of a chat call to an Azure OpenAI deployment from C#. Treat it as illustrative: it reflects the Azure.AI.OpenAI SDK's general design, but package versions evolve — see section 13 and tutorial 11, which walks through this end to end against a real resource.

// NuGet: Azure.AI.OpenAI
using Azure;
using Azure.AI.OpenAI;
using OpenAI.Chat;

var client = new AzureOpenAIClient(
    new Uri("https://<your-resource>.openai.azure.com/"),
    new AzureKeyCredential("<your-key>")); // use Entra ID in real apps

ChatClient chat = client.GetChatClient("<your-model-deployment-name>");

ChatCompletion completion = await chat.CompleteChatAsync(
    new SystemChatMessage("You are a concise assistant for C# developers."),
    new UserChatMessage("In one sentence, what is a token in an LLM?"));

Console.WriteLine(completion.Content[0].Text);

Notice the three moving parts you will meet in every AI call: a client bound to your service endpoint and credentials, a deployment name identifying which model to use, and a list of messages — a system message setting behavior plus a user message carrying the request. The response also carries usage metadata (exact input and output token counts), which is how you monitor cost.

// Every response reports exactly what the request consumed:
Console.WriteLine($"Input tokens:  {completion.Usage.InputTokenCount}");
Console.WriteLine($"Output tokens: {completion.Usage.OutputTokenCount}");
// Log these in production — token usage is your cost meter.

The EstimateTokens helper from section 7 and the CosineSimilarity method from section 8 complete this tutorial's code set: one estimates the budget before a call, one compares the embedding vectors that later tutorials will retrieve from an embeddings deployment.

12 Step-by-Step: From Zero to Your First AI Call

Here is the end-to-end path from nothing to a working AI feature in a .NET application. This tutorial explains the map; tutorials 10–11 execute it in detail.

1. Get access: create an Azure OpenAI resource in your Azure subscription and note its endpoint URL and key (or, better, plan to use Microsoft Entra ID authentication).
2. Deploy a model: in the Azure portal or Azure AI Foundry, create a deployment of a chat model — the deployment name you choose is what your code references.
3. Create the project: `dotnet new console` (or start from your existing ASP.NET solution) and add the Azure.AI.OpenAI NuGet package.
4. Protect secrets: store the endpoint and key with `dotnet user-secrets` or environment variables — never hard-code credentials or commit them to source control.
5. Write the call: build the client, pick the deployment, send a system message and a user message, and print the response — as in section 11.
6. Inspect the result: read the reply and the token usage on the response; change the user message and observe how output (and cost) changes.
7. Iterate: adjust the system message and settings like temperature, and watch how the model's behavior shifts — this experimentation is the seed of prompt engineering, the subject of the next tutorial.

13 Limitations, Risks, and Caveats

• Hallucination: models generate likely text, not verified facts. They can state falsehoods fluently and confidently, invent APIs, or cite sources that do not exist. Never ship unreviewed model output where correctness matters.
• Non-determinism: the same prompt can return different responses across runs. Design features and tests around this (the evaluation tutorial covers how).
• Knowledge cutoff: a model knows nothing after its training data ends and nothing about your private systems unless you provide that context in the request.
• Token limits and cost: every request spends a token budget; long histories and big documents can hit context-window limits or produce surprising bills.
• Latency: generation takes noticeably longer than a typical database or cache call; plan for streaming and async patterns in user-facing features.
• Data handling: with Azure OpenAI your prompts are not used to train the foundation models, but you must still follow your organization's rules for what data may be sent to any external service.
• Rapid change: models, SDKs, and pricing evolve quickly; verify specifics against current official documentation when you build.

14 Best Practices and Common Mistakes

Practices worth adopting from day one:

• Start with a use case where a human reviews the output — summaries, drafts, suggestions — before attempting autonomous behavior.
• Log token usage from every response so cost is visible from the first prototype onward.
• Keep secrets out of code: user-secrets locally, managed identity and Key Vault in Azure.
• Treat prompts as real engineering artifacts — version them, review them, test them.
• Ground the model in your own data (via retrieval) whenever answers must be factual and current.
• Learn the vocabulary of this tutorial well — tokens, context window, embeddings — because every later topic assumes it.

Mistakes beginners make most often:

• Treating model output as deterministic and asserting exact strings in tests.
• Assuming the model knows current events or your internal data without being given it.
• Confusing the three Copilot-era products — building against the wrong one wastes weeks (your applications call Azure OpenAI, not Microsoft 365 Copilot).
• Ignoring token growth in chat history until the context window overflows or the bill arrives.
• Sending sensitive data in prompts without checking organizational and regulatory constraints.
• Skipping the fundamentals and jumping straight to agents — the advanced topics in this course all stand on today's concepts.

20 Summary & Key Takeaways

• Generative AI creates new content — text, code, images, structured data — and is consumed by developers as a service, not trained in-house.
• The fields nest: AI ⊃ machine learning ⊃ deep learning ⊃ generative AI. Labels and numbers = classic ML; new content = GenAI.
• LLMs work by tokenizing input and repeatedly predicting the next token; capability and failure modes (non-determinism, hallucination, knowledge cutoff) all follow from this.
• Tokens are the currency of LLMs: they bound each request (context window) and drive cost (~4 English characters ≈ 1 token).
• Embeddings turn meaning into vectors compared by cosine similarity — the engine behind semantic search and, later, RAG.
• In the Microsoft ecosystem: Microsoft 365 Copilot assists end users in Office, GitHub Copilot assists you in the editor, and Azure OpenAI is the platform your C# applications call.
• Start with human-reviewed use cases (summaries, drafts, extraction), log token usage from day one, and keep secrets out of code.

You now hold the complete conceptual toolkit this course builds on: what generative models are, how they process text, what they cost, how meaning becomes searchable, and which Microsoft services turn all of it into shippable .NET features. Everything from prompt engineering to multi-agent systems is an elaboration of the ideas on this page.

21 Next Steps

Continue with the next tutorial in the path: Foundations of Prompt Engineering for Developers. You now know that a model's behavior is shaped by the text you send it — the next tutorial teaches you to shape that text deliberately: roles, instructions, context, and the patterns that turn an unpredictable model into a dependable component.

• Practice: explain tokens, embeddings, and the three Microsoft AI products aloud in your own words — teaching it back is the fastest check of understanding.
• Practice: take a paragraph of text and estimate its token count with the ~4-characters rule, then compare against any online tokenizer.
• Practice: sketch (on paper) where an AI summarization feature would sit in an application you already maintain — which data goes into the prompt, who reviews the output.
• Reading: Microsoft Learn's introductory modules on generative AI and the Azure OpenAI documentation's 'What is Azure OpenAI?' overview.
• Reading: the GitHub Copilot documentation for editor setup, previewing tutorials 8–9.