DEV Community: MJ Harmon

C# Alchemy: Simplifying the Strategy Pattern with Keyed Services and Dependency Injection

MJ Harmon — Tue, 06 Aug 2024 06:17:21 +0000

In the previous entry of this series, C# Alchemy, we used KeyedCollection to simplify the implementation of a Pokédex for storing information about all the Pokémon we've caught. In this entry, we'll build a simple web API for interacting with our Pokédex and, along the way, demonstrate a handy new feature of .NET 8 that can be used with Dependency Injection: Keyed Services. First, let's take a look at how we could approach adding the ability to sort or offer ordered results from our Pokédex using the Strategy Pattern.

The Strategy Pattern

To quickly review or introduce it to those who are unfamiliar, the Strategy Pattern helps you eliminate cumbersome and error-prone code like this, replacing it with something more organized and extensible:

  ...

  if (sortMethod == "Name") {
   // sort by name
  } else if (sortMethod == "Hp") {
    // sort by hp
  } else if (sortMethod == "Type") {
    // sort by type
  }else {
    // default sort
  }
  ...

or maybe it was done with a switch statement:

  ...
  switch(sortMethod) {
    case "Name": 
   // sort by name
   break;
    case  "Hp":
    // sort by hp
   break;
    case "Type"
    // sort by type
    break;
   default:
     // default sort
  }
  ...

Why is this type of code potentially problematic? Although many of us start by writing code this way because it seems simple and straightforward, this approach can become troublesome over time. The main issues arise as the number of cases grows—particularly when conditional checks are duplicated—leading to an increased likelihood of mistakes. As a parent, I often think of kids as adorable little chaos machines, and this reminds me of Murphy's Law: if something can go wrong, it eventually will, especially in complex or repetitive code.

The Strategy Pattern helps mitigate these problems by allowing the compiler to detect structural issues rather than discovering them only at runtime. This pattern organizes code by encapsulating different algorithms or behaviors behind a common interface, making it easier to test and extend. Instead of modifying existing code to handle new cases, you can extend functionality in a modular way. This approach exemplifies the Open/Closed Principle, which is an important principle from software design to consider.

As an advocate for unit testing and test-driven approaches, I also sleep better at night knowing I've hidden concrete implementations behind abstractions that adhere to a contract. The Strategy Pattern is an easy sell for me because it simplifies testing both existing and new code and contributes to a more organized and manageable codebase as new cases or requirements are added.

Let's take a look at organizing our code behind the Strategy Pattern by creating a sorting interface to serve as the contract and then the concrete implementations available to our Pokédex API.

public interface ISortingStrategy
{
    IEnumerable<Pokemon> Sort(IEnumerable<Pokemon> pokemons, bool sortDescending = false);
}

We will introduce the ability to sort by name, HP, type as well as offer a default ordering of sorting first by type and then by name.

public class SortByName : ISortingStrategy
{
    public IEnumerable<Pokemon> Sort(IEnumerable<Pokemon> pokemons, bool sortDescending = false)
    {
        return (sortDescending) ?
        pokemons.OrderByDescending(p=>p.Name) :
        pokemons.OrderBy(p=>p.Name);
    }
}

public class SortByType : ISortingStrategy
{
    public IEnumerable<Pokemon> Sort(IEnumerable<Pokemon> pokemons, bool sortDescending = false)
    {
        return (sortDescending) ?
        pokemons.OrderByDescending(p=>p.Type) :
        pokemons.OrderBy(p=>p.Type);
    }
}

public class SortyByHp : ISortingStrategy
{
    public IEnumerable<Pokemon> Sort(IEnumerable<Pokemon> pokemons, bool sortDescending = false)
    {
        return sortDescending ? 
        pokemons.OrderByDescending(p=>p.HP) :
        pokemons .OrderBy(p=>p.HP);
    }
}

public class DefaultSort : ISortingStrategy
{
    public IEnumerable<Pokemon> Sort(IEnumerable<Pokemon> pokemons,
     bool sortDescending = false)
    {
       return pokemons.OrderBy(p=>p.Type).
         ThenBy(p=>p.Name);
    }
}

Unfortunately, implementing the Strategy Pattern still involves some decisions, each with its own trade-offs in terms of maintainability. Primarily, you need to decide how to access a sorting strategy. One option is to use a context class that receives the strategy and executes commands against it. This approach works well when using a known configuration. Alternatively, you can use a factory class in scenarios where the user might issue a command or perform an action that involves one of the strategies. .NET’s Keyed Services allow you to handle both approaches effectively. The following example will demonstrate how something like the second approach where a user is submitting a sorting preference is implemented using Keyed Services in Dependency Injection.

Pokédex API

To demonstrate using Keyed Services with Dependency Injection, I'll build a simple Pokedéx API. First, I'll create an extension method to integrate with the DI configuration:

 public static IServiceCollection AddPokedexServices(this IServiceCollection services) {

        services.AddSingleton<Pokedex>();
        services.AddKeyedTransient<ISortingStrategy,DefaultSort>("default");
        services.AddKeyedTransient<ISortingStrategy,SortByName>("name");
        services.AddKeyedTransient<ISortingStrategy,SortByType>("type");
        services.AddKeyedTransient<ISortingStrategy,SortyByHp>("hp");

        return services;
    }

Note the named parameters (name, type, etc.); these are the keys used to retrieve each concrete sorting strategy by name. We are now ready to build the web API application and use a call to AddPokedexServices to enable the sorting strategy.

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

builder.Services.AddPokedexServices();

var app = builder.Build();

Next, we’ll build the controllers for the API. First, we’ll create an Add method to allow us to add different Pokémon to the Pokédex and test the functionality.

app.MapPost("add", ([FromBody] Pokemon pokemonToAdd, Pokedex pokedex ) => {

  try { 
    pokedex.Add(pokemonToAdd);
   return Results.Ok();
  }catch {
   return Results.BadRequest("Pokemon submitted is not valid for addition");
  }
});

Next, we’ll implement a List endpoint that retrieves the Pokémon in the Pokédex. This will utilize the DefaultSort strategy. This is introduced by using an attribute FromKeyedServices that allows you to target the strategy you wish the controller to receive:

app.MapGet("list", (Pokedex pokedex, [FromKeyedServices("default")] ISortingStrategy sortMethod) => {
  try {
  return Results.Ok(sortMethod.Sort(pokedex));
  }catch {
    return Results.StatusCode((int)HttpStatusCode.InternalServerError);
  }
});

Now, we’ll add a most powerful endpoint that will return the most powerful Pokémon in the Pokédex. This will utilize the SortByHp strategy, with decreasing order implicit.

app.MapGet("mostpowerful", (Pokedex pokedex, [FromKeyedServices("hp")] ISortingStrategy sortMethod) => {
  try {
  return Results.Ok(
    sortMethod.Sort(pokedex,true).
    Take(1));
  }catch {
    return Results.StatusCode((int)HttpStatusCode.InternalServerError);
  }
});

Finally, we’ll add alphabetical and sorting by type endpoints that allow us to control the order and make use of the SortByType and SortByName strategies. We’ll first add an extension method to keep the syntax clean:

 public static IEnumerable<Pokemon> Sort(this ISortingStrategy sortingStrategy,
     IEnumerable<Pokemon> pokemons, string direction) =>
        sortingStrategy.Sort(pokemons, direction.Equals("desc",StringComparison.OrdinalIgnoreCase));

app.MapGet("list/bytype", (Pokedex pokedex,
 [FromKeyedServices("type")] ISortingStrategy sortMethod, string? order) => {
  try {
  return Results.Ok(
    sortMethod.Sort(pokedex,order ?? "asc"));
  }catch {
    return Results.StatusCode((int)HttpStatusCode.InternalServerError);
  }
});

app.MapGet("list/alphabetical", (Pokedex pokedex,
 [FromKeyedServices("name")] ISortingStrategy sortMethod, string? order) => {
  try {
  return Results.Ok(
    sortMethod.Sort(pokedex,order ?? "asc"));
  }catch {
    return Results.StatusCode((int)HttpStatusCode.InternalServerError);
  }
});

Now we are ready to run the API and test it out with some Pokémon!

[
  { "name": "Lilligant", "hp": 70, "type": "Grass" },
  { "name": "Vaporeon", "hp": 130, "type": "Water" },
  { "name": "Pikachu", "hp": 35, "type": "Electric" },
  { "name": "Floragato", "hp": 61, "type": "Grass" },
  { "name": "Eevee", "hp": 55, "type": "Normal" }
]

Now, if we navigate to the List endpoint, we should see the Pokémon sorted first by type and then by name, as implemented in the DefaultSort strategy:

pokemons.OrderBy(p=>p.Type).
         ThenBy(p=>p.Name);

result:

[
  {
    "name": "Pikachu",
    "hp": 35,
    "type": "Electric"
  },
  {
    "name": "Lilligant",
    "hp": 70,
    "type": "Grass"
  },
  {
    "name": "Floragato",
    "hp": 61,
    "type": "Grass"
  },
  {
    "name": "Eevee",
    "hp": 55,
    "type": "Normal"
  },
  {
    "name": "Vaporeon",
    "hp": 130,
    "type": "Water"
  }
]

Most powerful:

[
  {
    "name": "Vaporeon",
    "hp": 130,
    "type": "Water"
  }
]

When testing out by type, we’ll sort in descending order and notice that, unlike with the default sort, the Pokémon within each type are not ordered by name:

[
  {
    "name": "Vaporeon",
    "hp": 130,
    "type": "Water"
  },
  {
    "name": "Eevee",
    "hp": 55,
    "type": "Normal"
  },
  {
    "name": "Lilligant",
    "hp": 70,
    "type": "Grass"
  },
  {
    "name": "Floragato",
    "hp": 61,
    "type": "Grass"
  },
  {
    "name": "Pikachu",
    "hp": 35,
    "type": "Electric"
  }
]

And finally, alphabetical:

[
  {
    "name": "Eevee",
    "hp": 55,
    "type": "Normal"
  },
  {
    "name": "Floragato",
    "hp": 61,
    "type": "Grass"
  },
  {
    "name": "Lilligant",
    "hp": 70,
    "type": "Grass"
  },
  {
    "name": "Pikachu",
    "hp": 35,
    "type": "Electric"
  },
  {
    "name": "Vaporeon",
    "hp": 130,
    "type": "Water"
  }
]

As demonstrated here, Keyed Services work really well at simplifying code that supports the Strategy Pattern, but there are plenty of other use cases where you might consider it. Configuring different implementations based on different environments, for example, or implementing a feature toggle. I have placed the code for the Pokédex API here.

Creating a Zelda Chat Assistant using Semantic Kernel

MJ Harmon — Fri, 26 Jul 2024 06:25:16 +0000

"The Legend of Zelda: Breath of the Wild" was one of the first games I bought after getting a Nintendo Switch. Let me just say that although I'd give it 5 stars, the open-endedness of it gave me a bit of anxiety. It's hard enough figuring out my own life, and now I also have to do it in Zelda?! Regardless, it's still a favorite in my house, and both of my kids love it. Yes, they also love "Tears of the Kingdom", and no, I haven't started it yet :(

I'm teaching them a bit of coding this summer, and what better way to give them a little inspiration and test out Semantic Kernel, Microsoft's new library for building AI-enabled applications, than by building a "Breath of the Wild" assistant?

The Technology

This project is built using the Retrieval-Augmented Generation (RAG) architecture. I chose to host an embedding model (mxbai-embed-large) and a chat completion model (PHI3) locally using Ollama. For data, I'm using the Hyrule Compendium API.

The solution consists of a trainer application for generating embeddings on the Zelda knowledge base and storing the facts in a database. The chat assistant performs semantic search using the embeddings from the user's question. It then provides the question and the relevant set of facts to the chat completion model to produce an answer.

Extending Semantic Kernel to Support Ollama Embeddings

To generate embeddings with Ollama using Semantic Kernel, I implemented a service class based on the ITextEmbeddingGenerationService interface from Semantic Kernel. This service class integrates Ollama's capabilities with Semantic Kernel, allowing for embeddings to be generated whenever new information is stored or when search queries are submitted.

Ollama support is now available as pre-release in Semantic Kernel but will leave the original solution here:

public class OllamaEmbeddingGenerationService : ITextEmbeddingGenerationService
{
    public IReadOnlyDictionary<string, object?> Attributes => new Dictionary<string, object?>();

    private HttpClient _client;

    private ILogger<OllamaEmbeddingGenerationService> _logger;

    private OllamaEmbeddingServiceOptions _options;

    public OllamaEmbeddingGenerationService(HttpClient? httpClient,
      OllamaEmbeddingServiceOptions? config, ILogger<OllamaEmbeddingGenerationService> logger) {

        _client = httpClient ?? throw new ArgumentNullException();
        _logger = logger;
        _options = config ?? throw new ArgumentNullException();
    }


    public async Task<IList<ReadOnlyMemory<float>>> GenerateEmbeddingsAsync(IList<string> data,
    Kernel? kernel = null, CancellationToken cancellationToken = default)
    {
        List<ReadOnlyMemory<float>> results = new List<ReadOnlyMemory<float>>();
        foreach(string text in data )  {
            results.Add(await GetEmbeddingsAsync(text,cancellationToken));
        }
        return results;
    }

    private async Task<ReadOnlyMemory<float>> GetEmbeddingsAsync(string text, CancellationToken token) {

        token.ThrowIfCancellationRequested();
        var response = await _client.PostAsJsonAsync(RequestUri, RequestBody(text), token );
        string json = await EnsureSuccessAndReadResultAsync(response);
        var result = DeserializeOrDefault(json);

        return new ReadOnlyMemory<float>(result?.Embeddings ?? throw new InvalidOperationException());
    }

    private async Task<string> EnsureSuccessAndReadResultAsync(HttpResponseMessage response) {
        response.EnsureSuccessStatusCode();
        string resultContent = await response.Content.ReadAsStringAsync().
            ConfigureAwait(false);
        return resultContent;
    }

    private OllamaEmbeddingResponse DeserializeOrDefault(string json) {
        OllamaEmbeddingResponse? returnValue = null;
        try {
            returnValue = JsonSerializer.Deserialize<OllamaEmbeddingResponse>(json);
        } catch(JsonException exception) {
            _logger?.LogError("Embedding request failed to return a valid json result");
            _logger?.LogError(exception.Message);
        }
        return returnValue ??
          new OllamaEmbeddingResponse {
             Embeddings = Enumerable.Empty<float>().ToArray()};
    }

    private string RequestUri => $"{Host}/api/embeddings";

    private OllamaEmbeddingRequest RequestBody(string text) => new() { Model = ModelId, Text = text};

    private string ModelId => _options.ModelId ?? throw new NullReferenceException();

    private string Host => _options.Host ?? throw new NullReferenceException();

}

Acquiring and Ingesting the Data

Data is acquired by making API calls to the Hyrule Compendium API. Semantic Kernel handles the generation of embeddings provided by Ollama. These embeddings, along with descriptions and any relevant metadata about the facts, are stored using the SaveInformationAsync method. This approach simplifies data ingestion and ensures all necessary information is properly organized and accessible for processing.

public class HyruleCompendiumEnumerator : IZeldaEnumerator
{
    private const string SERVICE_ENDPOINT =
      "https://botw-compendium.herokuapp.com/api/v3/compendium/all";
    private HttpClient _http;

    public HyruleCompendiumEnumerator(HttpClient http) {
        _http = http ?? throw new ArgumentNullException();
    }

    public async Task<IEnumerable<ZeldaItem>> EnumerateAsync(
      Func<ZeldaItem, bool>? filter = null)
    {
        string jsonListing = await GetListingAsStringAsync();
        ZeldaListing zeldaListing = DeserializeOrDefault(jsonListing);
        return FilteredListing(zeldaListing, filter ?? (item => true));
    }

    private IEnumerable<ZeldaItem> FilteredListing(ZeldaListing listing,
      Func<ZeldaItem,bool> filter) => listing.Items?.
        Where(filter) ?? Enumerable.Empty<ZeldaItem>();

    private async Task<string> GetListingAsStringAsync()  {
      var responseString = await _http.GetStringAsync(SERVICE_ENDPOINT);
      return responseString ?? string.Empty;

    }

    private ZeldaListing DeserializeOrDefault(string json) {
      ZeldaListing? returnValue = null;
      try {
          returnValue = JsonSerializer.Deserialize<ZeldaListing>(json);
      }catch(JsonException exception) {
        Console.Out.WriteLine("Request for resource failed to produce valid data");
        Console.Out.WriteLine(exception.Message);
      }

      return returnValue ?? new ZeldaListing() { Items = new() };
    }
}

public class AsyncZeldaIngester : IZeldaIngester
{
    private IZeldaEnumerator _enumerator;
    private ISemanticTextMemory _memory;

    private string _collection;

    public AsyncZeldaIngester(IZeldaEnumerator zeldaEnumerator, ISemanticTextMemory memory,
        IConfiguration configuration) {
        _enumerator = zeldaEnumerator ?? throw new ArgumentNullException();
        _memory = memory ?? throw new ArgumentNullException();
        _collection = configuration["collection"] ?? throw new ArgumentNullException();
    }

    public async Task ExecuteAsync()
    {
        foreach(var fact in await _enumerator.EnumerateAsFactsAsync()) {
            await _memory.SaveInformationAsync(_collection, fact.Text ?? string.Empty,
              fact.Id, fact.Description);
        }
    }
}

Using Memories to Assist the Chat Assistant

To give the chat assistant access to relevant information, the Zelda facts created by the Trainer are retrieved from the memory collection and then given to the chat response generation process.

private async Task<IEnumerable<string>> SearchForFactsAsync(string? question) {
       var results = _memory.SearchAsync(
                collection, question ?? string.Empty,
                limit:size,
                minRelevanceScore:relevance,
                cancellationToken:_shutdownToken.Token);

       List<string> values = new();
        await foreach(var result in results.WithCancellation(_shutdownToken.Token)) {
            values.Add(result.Metadata.Text);
        }

        return values;
   }

private async Task QueryChatAssistantAsync(string question,
      IEnumerable<string> facts)  {

      var corpus = string.Join(" ", facts);
      var ai = _kernel.GetRequiredService<IChatCompletionService>();
      ChatHistory chat = new($"{prompt}{corpus}");

      chat.AddUserMessage(question);
      await foreach(var message in ai.GetStreamingChatMessageContentsAsync(chat,kernel: _kernel) )
        {
            Console.Write(message);
        }
        await Console.Out.WriteLineAsync(string.Empty);
}

Chatting with the Assistant

Here are some interesting or notable question and answers:

Starting with something easy. The compendium lists items that monsters drop. This response is using the fact directly.
Locations are simple facts that the model can access. This mixes it up a little by asking where you can fight rather than find Fireblight Ganon.
Going a little further to see if it can understand bows that fire multiple arrows.
Seeing if it can synthesize from the facts.
Seeing if it can offer an informed opinion about a rusted weapon.
Can it measure and have an opinion about concepts like strength and durability?

Overall, I was surprised at how well the chat assistant was able to answer most of the questions I threw at it. When there were no facts in the memory to support an answer, it simply stated that it couldn't provide an answer. I'm pretty impressed with how well the mxbai embeddings work and will certainly consider using that model again. I really enjoyed its response to the question about the strongest shield, which leads to a nice feature of Semantic Kernel that would be fun to implement as a follow-up: Plugins.

If we want the chat assistant to answer comparative questions like "Which shield is more durable, A or B?", Plugins allow you to write code that computes the answer. The functions are annotated and made available to Semantic Kernel, enabling the chat assistant to use computed facts in its responses. If I ever get around to it, I'll post a follow-up.

C# Alchemy: KeyedCollection for Effortless Data Organization

MJ Harmon — Wed, 17 Jan 2024 05:01:50 +0000

C# has been declared the Programming Language of 2023 so it is the perfect time to explore some features of the language and of .Net. In this post which serves to kick-off a series titled C# Alchemy, we'll take a look at KeyedCollection, an abstract base class from the Collections framework. KeyedCollection is useful when you need to map a key to value but the key itself is embedded inside the value, for example, a library catalog where the ISBN of each book serves as the key.

The Basics

To illustrate the usefulness of KeyedCollection, let's build a Pokédex—one of the most important advancements in modern technology! First we define our Pokemon class:

public class Pokemon {

    public Pokemon(string name, int hp, string type) {
        Name=name;
        Type=type;
        HP=hp;
    }

    public readonly string Name;

    public readonly int HP;

    public readonly string Type;

}

Since each species of Pokémon has a unique name, we'll use it as the key for our Pokédex. To create the Pokédex, we will extend KeyedCollection. Notice from the class definition of KeyedCollection that it has two type parameters, one for the data type of the key and one for the data type of the data itself:

public abstract class KeyedCollection<TKey,TItem> : 
  System.Collections.ObjectModel.Collection<TItem>

Assuming you are familiar with using Dictionary for key to value mappings, the immediate benefit of KeyedCollection when the key is a member of the value should be clear. To define the Pokédex, extend KeyedCollection using string and Pokemon as the type parameters:

using System.Collections.ObjectModel;

public class Pokedex : KeyedCollection<string,Pokemon> {

    override protected string GetKeyForItem(Pokemon pokemon) {
        return pokemon.Name;
    }
}

As I am neither a Pokémon Master nor Trainer, I deferred to my kids for a starter pack of some Pokémon to add to our Pokédex:

List<Pokemon> myPokemon = new() {
    new Pokemon("Eevee", 55, "Normal"),
    new Pokemon("Pikachu", 35, "Electric"),
    new Pokemon("Vaporeon", 130, "Water"),
    new Pokemon("Lilligant", 70, "Grass"),
    new Pokemon("Floragato", 61, "Grass")
};

Pokedex pokedex = new();
myPokemon.ForEach(
    pokemon => pokedex.Add(pokemon));

Console.Out.WriteLine(pokedex.Count());

Lets add more:

pokedex.Add(new Pokemon("Sandaconda", 72, "Ground"));
pokedex.Add(new Pokemon("Eevee", 55 , "Normal"));

Since Eevee is already in the Pokédex and KeyedCollection follows the conventions for a Collection, an exception is thrown when trying to add a Pokémon that is already in the Pokédex:

Error: System.ArgumentException: An item with the same key has already been added. Key: Eevee

Use the Contains method to check if the Pokémon is recorded in the Pokédex:

bool havePikachu = pokedex.Contains("Pikachu");
Console.Out.WriteLine(havePikachu);

True

Remove a Pokémon from the Pokédex with Remove:

pokedex.Remove("Pikachu");
bool havePikachu = pokedex.Contains("Pikachu");
Console.Out.WriteLine(havePikachu);

False

Pokémon can be accessed by name. Lets add an extension method to the Pokemon class for printing it and demonstrate retrieval. You may also iterate over every Pokémon in the Pokédex:

public static void Print(this Pokemon pokemon) {
    Console.Out.WriteLine($"{pokemon.Name}");
    Console.Out.WriteLine($"HP: {pokemon.HP}");
    Console.Out.WriteLine($"{pokemon.Type} Type");
}

Pokemon eevee = pokedex["Eevee"];
eevee.Print();

Eevee
HP: 55
Normal Type

foreach(Pokemon pokemon in pokedex) {
    Console.Out.WriteLine("---");
    pokemon.Print();
}

---
Eevee
HP: 55
Normal Type
---
Vaporeon
HP: 130
Water Type
---
Lilligant
HP: 70
Grass Type
---
Floragato
HP: 61
Grass Type
---
Sandaconda
HP: 72
Ground Type

LINQ operations may also be used on the Pokédex to easily filter, query, and transform data:

Count the number of Pokémon with HP larger than 70:

pokedex.Where(pokemon=>pokemon.HP > 70).
    Count()

Return the value of the highest HP in the Pokédex:

pokedex.Max(pokemon=>pokemon.HP)

Using Generics

The type parameters may also take advantage of generics to extend capabilities. Here, we'll create an interface to encapsulate our Pokémon and use it to specialize based on the type of the Pokémon species. The Pokédex will still use the name of a Pokémon as its key, but the data type of the Pokémon entry is deferred until the Pokédex is created. We'll constrain the type parameter of the Pokémon using the interface type:

public interface IPokemon {

    string Name {get;}

    int HP {get;}

    string Type {get;}

}

public class WaterPokemon : IPokemon {

    private readonly string _name;
    private readonly int _hp;

    public WaterPokemon(string name, int hp) {
        _name=name;
        _hp = hp;
    }

    public string Name => _name;

    public int HP => _hp;

    public string Type => "Water";

}

public class GrassPokemon : IPokemon {

    private readonly string _name;
    private readonly int _hp;

    public GrassPokemon(string name, int hp) {
        _name=name;
        _hp = hp;
    }

    public string Name => _name;

    public int HP => _hp;

    public string Type => "Grass";

}

public class Pokedex<TPokemon> : KeyedCollection<string,TPokemon>
 where TPokemon : IPokemon {

    override protected string GetKeyForItem(TPokemon pokemon) {
        return pokemon.Name;
    }  
 }

    WaterPokemon vaporeon = new WaterPokemon("Vaporeon", 130);
    GrassPokemon lilligant = new GrassPokemon("Lilligant", 70);
    GrassPokemon florogato = new GrassPokemon("Floragato", 61);

    Pokedex<WaterPokemon> waterPokemon = new();
    Pokedex<GrassPokemon> grassPokemon = new();
    Pokedex<IPokemon> allPokemon = new();

    waterPokemon.Add(vaporeon);

    grassPokemon.Add(lilligant);
    grassPokemon.Add(florogato);

    allPokemon.Add(vaporeon);
    allPokemon.Add(lilligant);
    allPokemon.Add(florogato);

Final Thoughts and Caveats

KeyedCollection provides a simple, expressive way to do a key to value mapping when the key is a member of the value itself. Operations on the collection are constant time and uniqueness is guaranteed and enforced by the API. The unique key is a natural identifier for the data, allowing for cleaner, more readable and intuitive code. It doesn't come with any major drawbacks but if you were paying attention to the code then you might have noticed the use of the readonly modifier. KeyedCollection does come with one big caveat - immutability. When using KeyedCollection you want to make sure that your keys are immutable.

Now go make some KeyedCollection magic. You can find a Notebook with the code here.

Securing Sensitive Information in Polyglot Notebooks

MJ Harmon — Fri, 05 Jan 2024 05:13:43 +0000

UPDATE: As of February 2026, Microsoft has announced the deprecation of Polyglot Notebooks

First, let's tackle the most important question – why did the cat refuse to store its password in Git? Because it heard it's a cat-astrophic idea and wanted to keep its purr-sonal information safe! Jokes aside, the leaking of sensitive information through GitHub and other source repositories is no laughing matter.

TLDR; take me to the code!

The scale of the problem related to the accidental exposure of passwords, API keys, credentials, and other sensitive information on public GitHub repositories is challenging to gauge but remains a significant concern. GitHub addressed this issue by introducing a secret scanning service several years ago. Unfortunately, each year brings reports of significant information breaches originating from source repositories. As an illustration, in 2023, AI researchers from Microsoft inadvertently disclosed over 32TB of data, including confidential information, by committing it to a publicly accessible source repository.

Despite the existence of long-standing best practices, interactive coding tools like notebooks raise some unique concerns. When working in notebooks, one might find themselves in the informal atmosphere reminiscent of a lone graduate student hastily crafting solutions during late-night sessions, rather than engaging with code that has undergone rigorous engineering, testing, and scrutiny through formal code review processes. While the user-friendly nature of notebooks makes them an enjoyable and practical tool, it is precisely this informality that introduces the risk of inadvertently exposing sensitive information.

Developers utilizing .NET have long benefitted from a handy tool called User Secrets. This tool serves the purpose of relocating sensitive information, such as API keys, entirely out of the code project. Instead, the information undergoes encryption and is securely stored in a designated user-level directory. .NET developers can programmatically access this information through the utilization of the special project (.csproj) file in conjunction with the Configuration extensions library.

Harnessing User Secrets in Polyglot Notebooks is surprisingly straightforward, even if it may not be immediately evident. Typically, Polyglot Notebooks aren't paired with the formality of being an integral part of an actual .NET project—a prerequisite for utilizing User Secrets. Although it's feasible to integrate them into a formal project following established development practices, for simplicity and to align with a common user scenario, let's focus on the basics. We'll initiate a temporary project to set up user secrets and then guide you through the process of importing and utilizing them within Polyglot Notebooks.

What You Will Need

Proficiency with the command line
.NET 8.0 or a later version installed
Installation of the Polyglot Notebooks extension in Visual Studio Code

Create a project

Execute the following from the command line:

dotnet new console --name temporaryproject

Initialize User Secrets

Run the following command from the command line:

dotnet user-secrets init

Add Your Secrets

Now, include a client ID and an API key in the secrets file. Execute the following from the command line:

dotnet user-secrets set "ClientId" "1234567"
dotnet user-secrets set "ApiKey" "11992288337744665"

Add the Unique ID To The Notebook

User Secrets generates a unique ID for each project. Open the project file and copy the value of the secrets ID into your notebook. In your preferred editor, locate the tag named UserSecretsId and copy its value:

<PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <RootNamespace>temporaryproject</RootNamespace>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <UserSecretsId>7ffbd8ef-bb06-47e8-a5e1-9c3103773101</UserSecretsId>
  </PropertyGroup>

Copy the value of UserSecretsId into your notebook:

string UserSecretsId = "7ffbd8ef-bb06-47e8-a5e1-9c3103773101";

At this point, you have the option to either delete the temporary .csproj file or retain it for sharing and updating values as needed.

Create a POCO For the Secrets:

public class MyCredentials {

  public string ClientId {get; set;} = string.Empty;

  public string ApiKey {get; set;} = string.Empty;
}

Import the Secrets Into the Notebook

To access the secrets, use a ConfigurationBuilder with User Secrets enabled. Start by adding the necessary packages to your notebook and include the using statements to import into your code:

#r "nuget: Microsoft.Extensions.Configuration"
#r "nuget: Microsoft.Extensions.Configuration.Binder"
#r "nuget: Microsoft.Extensions.Configuration.UserSecrets"

using Microsoft.Extensions.Configuration;

Create a ConfigurationBuilder and load your secrets into an instance of MyCredentials:

var configuration = new ConfigurationBuilder().
  AddUserSecrets(UserSecretsId).
  Build();

var credentials = configuration.Get<MyCredentials>();

That's it! You can find a working example in a notebook HERE.

Thanks for reading! If you have any questions or need further assistance, feel free to reach out.