ResourceDictionary in Entity Framework Core - lucyberryhub/WPF.Tutorial GitHub Wiki

🌟 ResourceDictionary in Entity Framework Core Without Crashing Migrations

"One day, Lucy Berry was happily coding her WPF application when suddenly... BOOM! ❌ Entity Framework Core threw an error: Object reference not set to an instance of an object. What happened?! 🤯"

Lucy wanted to store localized strings in Strings.xaml and use them inside her Entity Framework Core database seeding, but when she tried:

Spec = (string)Application.Current.Resources["str_koshou"];

💥 ERROR! 💥 Because EF Core migrations run in a non-WPF environment, Application.Current.Resources is always null.

But fear not! Lucy Berry found the ultimate solution that loads Strings.xaml manually, making EF Core happy! Let’s go step by step. 🏆

---

🚨 The Big Problem: Why Can’t EF Core Use Application.Current.Resources?

📌 What happens during add-migration?

• EF Core creates a DbContext without running WPF.
• WPF resources (like Strings.xaml) don’t exist in this environment.
• Application.Current is null, so accessing Application.Current.Resources crashes the app!

🔴 The Bad Code That Causes the Crash

Spec = (string)Application.Current.Resources["str_koshou"]; // ❌ Crash! Application.Current is null!

---

✅ The Solution: Load Strings.xaml Manually!

🔹 Step 1: Create a ResourceHelper to Load Strings.xaml

Lucy created a special helper class that loads the Strings.xaml file manually, even when WPF isn’t running.

📌 ResourceHelper.cs

using System;
using System.IO;
using System.Windows;
using System.Windows.Markup;

public static class ResourceHelper
{
    private static ResourceDictionary _resourceDictionary;

    static ResourceHelper()
    {
        LoadResourceDictionary();
    }

    private static void LoadResourceDictionary()
    {
        try
        {
            // Path to your Strings.xaml file (Update this if needed)
            string resourcePath = "Fw/Resources/Strings.xaml"; 

            using (FileStream fs = new FileStream(resourcePath, FileMode.Open, FileAccess.Read))
            {
                _resourceDictionary = (ResourceDictionary)XamlReader.Load(fs);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("❌ Failed to load Strings.xaml: " + ex.Message);
        }
    }

    public static string GetString(string key)
    {
        if (_resourceDictionary != null && _resourceDictionary.Contains(key))
        {
            return _resourceDictionary[key] as string;
        }

        return key; // 🔄 Fallback to key if not found
    }
}

What this code does:
✅ Loads Strings.xaml manually so it can be accessed anywhere!
✅ Uses XamlReader.Load() to parse the .xaml file.
✅ Falls back to the key if the resource isn’t found.

---

🔹 Step 2: Use ResourceHelper in AppDbContext

Now, Lucy updated AppDbContext.cs to use ResourceHelper.GetString(...) instead of Application.Current.Resources.

📌 AppDbContext.cs

modelBuilder.Entity<EnvObikiModel>(entity =>
{
    entity.HasData(
        new EnvObikiModel
        {
            Id = 1,
            Title = "90角 4m",
            Spec = ResourceHelper.GetString("str_koshou"), // ✅ Works in EF Core migrations!
            ComboValue = "矩形",
            Dim1 = 90,
            Dim2 = 90,
            Dim3 = 4000,
            Deleteable = 0
        }
    );
});

🎉 Success! Now Strings.xaml can be used inside EF Core migrations without crashing! 🚀

---

🎭 Story Time: Lucy Berry and the Magic Strings!

Lucy was working on FwCAD, an amazing WPF application that needed localized text inside an SQLite database. She added all her Japanese labels in Strings.xaml:

<sys:String x:Key="str_koshou">呼称</sys:String>
<sys:String x:Key="str_kankyosette">環境設定</sys:String>
<sys:String x:Key="str_kiso">基礎</sys:String>

Then she tried to insert these values into her database using Application.Current.Resources. But when she ran:

dotnet ef migrations add InitialCreate

💥 BOOM! CRASH! ERROR! ❌

Lucy was sad. 😢 But she didn’t give up! 💪 She found a way to manually load Strings.xaml and made EF Core work with localized text. Now her app can store 呼称 (Koshou) inside the database and retrieve it later! 🎉

---

🔹 More Example Code

Lucy wanted to make sure other developers could also fetch localized text anywhere in the app. So she wrote more examples:

✅ Use Localized Strings Anywhere in WPF

string title = ResourceHelper.GetString("str_kankyosette"); // Returns 環境設定
Console.WriteLine(title);

✅ Use Localized Strings in Data Binding

<TextBlock Text="{x:Static local:ResourceHelper.GetString('str_kiso')}" />

✅ Use Localized Strings in ViewModel

public string Title => ResourceHelper.GetString("str_kankyosette");

---

📌 Summary: What Lucy Berry Learned

✅ EF Core migrations run without WPF, so Application.Current.Resources is null.
✅ Strings.xaml must be loaded manually using XamlReader.Load().
✅ A helper class (ResourceHelper.cs) makes localized text available inside EF Core and WPF.
✅ This solution allows localization in the database without breaking migrations!

---

🚀 The Final Victory!

Lucy Berry ran the migration again:

dotnet ef migrations add InitialCreate
dotnet ef database update

✅ No more errors!
✅ Localized text is stored in the database!
✅ Lucy is now an EF Core Localization Champion! 🏆🎉

---

👩‍💻 Want More?

📖 Read more about ResourceDictionary in WPF: Microsoft Docs
📖 Learn about Entity Framework Core Migrations: EF Core Docs

---