C# in the World of Microcontrollers: An Unexpected Breakthrough in Embedded

Introduction: Why C# in Embedded is No Joke

If you still think the world of microcontrollers and hardware is the exclusive domain of pure C or assembly, hold onto your keyboard. Imagine this: you are writing code for ESP32 or STM32 using LINQ queries, async/await, and a garbage collector. And this is not science fiction — it is the reality of 2024. Embedded development in C# has ceased to be an experiment for geeks and has become a working tool.

Of course, no one has canceled C++ for resource-intensive drivers or time-critical tasks. But if you need to quickly prototype an IoT device, write a web server directly on the board, or use the rich .NET ecosystem, C# in embedded is your choice. In this article, we will break down exactly how C# for microcontrollers works, which frameworks to use, and where the pitfalls lie.

Where C# Beats C and C++ in Embedded

Let's be honest: C++ is powerful, but painful. Manual memory management, macros, headaches with the linker. Programming embedded in C# gives you what classic embedded development lacks: development speed and type safety.

Advantages That Are Hard to Ignore

\n
• Garbage collector? Yes, it exists, but it is optimized for real-time. In NanoFramework, the GC works predictably and does not block execution for long.
\n
• Async/await — no more manual nightmare state machines. Asynchronous programming on microcontrollers becomes elegant.
\n
• LINQ — processing data from sensors becomes like working with regular collections.
\n
• Unified codebase — you can reuse logic between a desktop application and firmware.
\n

But there is also a downside: C# for embedded systems requires more RAM (minimum 256 KB flash and 64 KB RAM), and starting the runtime takes fractions of a second. This is critical for real-time clocks, but not for a smart light bulb.

Tool Overview: NanoFramework, Mono, and .NET IoT

To start embedded development in C#, you need to choose the right framework. There are three main players in the field.

.NET NanoFramework — The Main Character

This is not a stripped-down .NET, but a completely rewritten runtime for microcontrollers. It supports ARM Cortex-M, ESP32, TI CC32xx, and even RISC-V. Installation is simple: download the nanoFramework VS extension, connect the board via USB, and write code.

using System;\nusing System.Device.Gpio;\nusing System.Threading;\n\nclass Program\n{\n    static void Main()\n    {\n        GpioController gpio = new GpioController();\n        GpioPin led = gpio.OpenPin(2, PinMode.Output);\n        \n        while (true)\n        {\n            led.Write(PinValue.High);\n            Thread.Sleep(500);\n            led.Write(PinValue.Low);\n            Thread.Sleep(500);\n        }\n    }\n}\n

This code blinks an LED on an ESP32. Note: we use System.Device.Gpio — the same APIs as on Raspberry Pi under .NET. Code portability is a killer feature.

Mono for Embedded Linux

If you have a BeagleBone or Raspberry Pi with Linux, but want to write in C# — use Mono. This is not exactly embedded in the classic sense, but for IoT gateways and smart cameras, it is ideal. Mono allows you to run full ASP.NET Core applications on ARM.

.NET IoT Libraries — For Single-Board Computers

Libraries from Microsoft for working with GPIO, SPI, I2C. They run on top of .NET Core/5+ on Linux. They are great for prototyping but require a full operating system.

Writing a Real Project: Reading Temperature from DHT22

Let's move to practice. Suppose we need to read data from a DHT22 temperature and humidity sensor on an STM32F4