DEV Community: Barani Kumar S

Diving into Actor Model with Go and NATS

Barani Kumar S — Thu, 28 Aug 2025 15:13:27 +0000

Introduction

Working with Golang is always fun and satisfying. But when it comes to scaling your application on a distributed computing infrastructure, you start to feel the real pain. To reduce such pain, numerous models and patterns were discovered. Some are cloud native (Kubernetes for example), while others need to be implemented at the architectural level. One such model is called Actor Model. We'll dive deep into what Actor Model is in this blog.

What is Actor Model?

The actor model is a model of concurrent computation where independent entities, called actors, communicate asynchronously via messages.

An actor is an independent unit that encapsulates its own state and behavior. Actors do not share state directly; instead, they interact only through message passing.

One major advantage of Actor Model is it's fault tolerant nature. Since each actor is isolated and interacts only through asynchronous messages, an anomaly or failure in one actor will not directly affects other actors. Other actors are designed in a way that it can tackle the situations where it doesn't receive message from faulty actor.

You can also easily diagnose the source of error and you need to replace only the faulty actor while rest of the systems operate normally.

For example, consider a chat application. Each user can be represented as an actor with its own state (e.g., username, online status, chat history). When one user (actor) sends a message to another, the receiving actor updates its own state accordingly—in this case, by adding the new message to its chat history.

Actor Model vs Microservice Model

The below table explains the difference between Actor and Microservice Model in context of distributed computation,

Feature	Actor Model	Microservice Model
State	Encapsulated per actor	Often externalized (DB per service)
Communication	Async messages only	Async or sync (HTTP, gRPC, messaging)
Coupling	Very loose (message-only contracts)	Looser than monolith, but DB/API coupling still common
Granularity	Fine-grained (per actor)	Coarse-grained (per service/app)
Scaling	Each actor independently	Each service independently
Failure isolation	Actor-level	Service-level

Now that we understand how the Actor Model works conceptually, let’s see how we can implement it practically using NATS in Go.

NATS in Actor Model

At the core, NATS is a cloud-native messaging system written in go, which enables applications communicate via Publish/Subscribe pattern. Now you will get the idea on where we are going :). NATS also supports other messaging patterns like Request/Reply and Streaming support with it's inbuilt JetStream functionality. We're going to use NATS's Pub/Sub functionality to transfer messages between actors in our Actor Model.

Simple actor in Golang with NATS

Alright, enough lectures, we're now going to dive straight into writing code. For this we create a basic chat application where 2 users (User A and User B) sends message back and forth,

Firstly, make sure you downloaded NATS Server and run it,

$ ./nats-server

Now, create a Go module and install github.com/nats-io/nats.go package,

$ go get github.com/nats-io/nats.go

In the main.go file, establish a connection to NATS. Here the nats.DefaultURL is nats://localhost:4222,

package main

import (
    "log"

    "github.com/nats-io/nats.go"
)

func main() {
    nc, err := nats.Connect(nats.DefaultURL)
    if err != nil {
        log.Fatal(err)
    }
    defer nc.Drain()
}

We're going to make a terminal chat application, so we first need to ask user's name. So, update the code accordingly

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "strings"

    "github.com/nats-io/nats.go"
)

func main() {
    nc, err := nats.Connect(nats.DefaultURL)
    if err != nil {
        log.Fatal(err)
    }
    defer nc.Drain()

    // Ask for username
    reader := bufio.NewReader(os.Stdin)
    fmt.Print("Enter your name: ")
    name, _ := reader.ReadString('\n')
    name = strings.TrimSpace(name)
}

Next, we define the NATS subject name. A subject is basically a route which is used by NATS to route the messages. Think of it like a route in HTTP Url. Our chat application will listen to this subject to publish and subscribe messages.

We also perform nats.Subscribe which takes in subject name and a callback function. Whenever a message gets published to the subject, this callback function is invoked and you can perform actions inside the callback function,

func main() {
    nc, err := nats.Connect(nats.DefaultURL)
    if err != nil {
        log.Fatal(err)
    }
    defer nc.Drain()

    // Ask for username
    reader := bufio.NewReader(os.Stdin)
    fmt.Print("Enter your name: ")
    name, _ := reader.ReadString('\n')
    name = strings.TrimSpace(name)

    subject := "chat.room1"

    // Subscribe to chat messages
    _, err = nc.Subscribe(subject, func(m *nats.Msg) {
        fmt.Printf("\n%s\n> ", string(m.Data)) // reprint prompt after message
    })
    if err != nil {
        log.Fatal(err)
    }
}

Now, here is the final part. We create a loop which runs indefinitely, where we print subscribed messages and publish our own messages,

func main() {
    // Connect to NATS
    nc, err := nats.Connect(nats.DefaultURL)
    if err != nil {
        log.Fatal(err)
    }
    defer nc.Drain()

    // Ask for username
    reader := bufio.NewReader(os.Stdin)
    fmt.Print("Enter your name: ")
    name, _ := reader.ReadString('\n')
    name = strings.TrimSpace(name)

    subject := "chat.room1"

    // Subscribe to chat messages
    _, err = nc.Subscribe(subject, func(m *nats.Msg) {
        fmt.Printf("\n%s\n> ", string(m.Data)) // reprint prompt after message
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Connected to chat! Type messages and press Enter. Type '/quit' to exit.")
    fmt.Print("> ")

    // Read user input loop
    for {
        text, _ := reader.ReadString('\n')
        text = strings.TrimSpace(text)

        if text == "/quit" {
            fmt.Println("Exiting chat...")
            return
        }

        if text != "" {
            msg := fmt.Sprintf("[%s @ %s]: %s", name, time.Now().Format("15:04:05"), text)
            nc.Publish(subject, []byte(msg))
        }
        fmt.Print("> ")
    }
}

And that's it, we created our own chat application that leverages NATS. Now, we'll test it by running 2 instances of our app (we need 2 users to chat 😆).

Open 2 terminals and run the application. Below is a video that demonstrate actor Model in action,

You can see that both applications maintains it's own state (username in our case) and communicates via a single subject (chat.room1).

And that's it for this blog. See you in another one 😉.

Writing a Windows Service in Go

Barani Kumar S — Tue, 27 Aug 2024 18:24:58 +0000

Introduction
What exactly is a windows "service"?
Why Golang?
Writing a windows service in Go
Installing and Starting the Service
Conclusion
Complete Code

Introduction

Hello Devs, It's been a while since I wrote something windows-ish. So, today I want to guide you guys on how to write a Windows Service Application in Go. Yes, you heard it right, it's go language. In this tutorial blog, we'll cover some basic stuffs about Windows Service Applications and at the later part, I'll guide you through a simple code walk through where we write code for a Windows service which logs some information to a file. Without further ado, Let's get started...!

What exactly is a windows "service"?

A Windows Service Application a.k.a. Windows Services are tiny applications that runs in background. Unlike normal windows applications, they don't have a GUI or any forms of user interface. These service applications starts to run when the computer boots up. It runs irrespective of which user account it's running in. It's lifecycle (start, stop, pause, continue etc.,) are controlled by a program called Service Control Manager (SCM).

So, from this we can understand that we should write our Windows Service in such a way that the SCM should interact with our Windows Service and manage it's lifecycle.

Why Golang?

There are several factors where you may consider Go for writing Windows Services.

Concurrency

Go's concurrency model allows for faster and resource efficient processing. Go's goroutines allows us to write applications which can do multi-tasking without any blocking or deadlocking.

Simplicity

Traditionally, Windows Services are written using either C++ or C (sometimes C#) which not only results in a complex code, but also poor DX (Developer Experience). Go's implementation of Windows Services is straightforward and every line of code makes sense.

Static Binaries

You may ask, "Why not use even more simple language like python?". The reason is due to the interpreted nature of Python. Go compiles to a statically linked single file binary which is essential for a Windows Service to function efficiently. Go binaries doesn't require any runtime / interpreter. Go code can also be cross compiled.

Low Level Access

Though being a Garbage Collected language, Go provides solid support to interact with low level elements. We can easily invoke win32 APIs and general syscalls in go.

Alright, enough information. Let's code...

Writing a windows service in Go

This code walk-through assumes that you have a basic knowledge on Go syntax. If not, A Tour of Go would be a nice place to learn it.

Firstly, let's name our project. I'll name mines as cosmic/my_service. Create a go.mod file,

PS C:\> go mod init cosmic/my_service

Now we need to install golang.org/x/sys package. This package provides go language support for Windows OS related applications.

PS C:\> go get golang.org/x/sys

Note: This package also contains OS level go language support for UNIX based OS'es like Mac OS and Linux.

Create a main.go file. The main.go file contains main function, which acts as a entry-point for our Go application/service.
For creating a service instance, we need to write something called Service Context, which implements Handler interface from golang.org/x/sys/windows/svc.

So, the interface definition looks something like this

type Handler interface {
    Execute(args []string, r <-chan ChangeRequest, s chan<- Status) (svcSpecificEC bool, exitCode uint32)
}

Execute function will be called by the package code at the start of the service, and the service will exit once the Execute completes.

We read service change requests from receive-only channel r and act accordingly. We should also keep our service updated with sending signals to send-only channel s. We can pass optional arguments to args parameter.

On exiting, we can return with the exitCode being 0 on a successful execution. We can also use svcSpecificEC for that.

Now, create a type named myService which will act as our Service Context.

type myService struct{}

After creating the type myService, add the above mentioned Execute as a method to it so that it implements Handler interface.

func (m *myService) Execute(args []string, r <-chan svc.ChangeRequest, status chan<- svc.Status) (bool, uint32) {
    // to be filled
}

Now that we have successfully implemented the Handler interface, we can now start writing the actual logic.

Create a constant, with the signals that our service can accept from SCM.

const cmdsAccepted = svc.AcceptStop | svc.AcceptShutdown | svc.AcceptPauseAndContinue

Our main goal is the log some data every 30 seconds. So we need to define a thread safe timer for that.

tick := time.Tick(30 * time.Second)

So, we have done all the initialization stuffs. It's time to send START signal to the SCM. we're going to do exactly that,

status <- svc.Status{State: svc.StartPending}
status <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}

Now we're going to write a loop which acts as a mainloop for our application. Handling events in loop makes our application never ending and we can break the loop only when the SCM sends STOP or SHUTDOWN signal.

loop:
    for {
        select {
        case <-tick:
            log.Print("Tick Handled...!")
        case c := <-r:
            switch c.Cmd {
            case svc.Interrogate:
                status <- c.CurrentStatus
            case svc.Stop, svc.Shutdown:
                log.Print("Shutting service...!")
                break loop
            case svc.Pause:
                status <- svc.Status{State: svc.Paused, Accepts: cmdsAccepted}
            case svc.Continue:
                status <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}
            default:
                log.Printf("Unexpected service control request #%d", c)
            }
        }
    }

Here we used a select statement to receive signals from channels. In first case, we handle the Timer's tick signal. This case receives signal every 30 seconds, as we declared before. We log a string "Tick Handled...!" in this case.

Secondly, we handle the signals from SCM via the receive-only r channel. So, we assign the value of the signal from r to a variable c and using a switch statement, we can handle all the lifecycle event/signals of our service. We can see about each lifecycle below,

svc.Interrogate - Signal requested by SCM on a timely fashion to check the current status of the service.
svc.Stop and svc.Shutdown - Signal sent by SCM when our service needs to be stopped or Shut Down.
svc.Pause - Signal sent by SCM to pause the service execution without shutting it down.
svc.Continue - Signal sent by SCM to resume the paused execution state of the service.

So, when on receiving either svc.Stop or svc.Shutdown signal, we break the loop. It is to be noted that we need to send STOP signal to the SCM to let the SCM know that our service is stopping.

status <- svc.Status{State: svc.StopPending}
return false, 1

Now we write a function called runService where we enable our service to run either in Debug mode or in Service Control Mode.

Note: It's super hard to debug Windows Service Applications when running on Service Control Mode. That's why we are writing an additional Debug mode.

func runService(name string, isDebug bool) {
    if isDebug {
        err := debug.Run(name, &myService{})
        if err != nil {
            log.Fatalln("Error running service in debug mode.")
        }
    } else {
        err := svc.Run(name, &myService{})
        if err != nil {
            log.Fatalln("Error running service in Service Control mode.")
        }
    }
}

Finally we can call the runService function in our main function.

func main() {

    f, err := os.OpenFile("debug.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
    if err != nil {
        log.Fatalln(fmt.Errorf("error opening file: %v", err))
    }
    defer f.Close()

    log.SetOutput(f)
    runService("myservice", false) //change to true to run in debug mode
}

Note: We are logging the logs to a log file. In advanced scenarios, we log our logs to Windows Event Logger. (phew, that sounds like a tongue twister 😂)

Now run go build to create a binary '.exe'. Optionally, we can optimize and reduce the binary file size by using the following command,

PS C:\> go build -ldflags "-s -w"

Installing and Starting the Service

For installing, deleting, starting and stopping our service, we use an inbuilt tool called sc.exe

To install our service, run the following command in powershell as Administrator,

PS C:\> sc.exe create MyService <path to your service_app.exe>

To start our service, run the following command,

PS C:\> sc.exe start MyService

To delete our service, run the following command,

PS C:\> sc.exe delete MyService

You can explore more commands, just type sc.exe without any arguments to see the available commands.

Conclusion

As we can see, implementing Windows Services in go is straightforward and requires minimal implementation. You can write your own windows services which acts as a web server and more. Thanks for reading and don't forget to drop a ❤️.

Complete Code

Here is the complete code for your reference.

// file: main.go

package main

import (
    "fmt"
    "golang.org/x/sys/windows/svc"
    "golang.org/x/sys/windows/svc/debug"
    "log"
    "os"
    "time"
)

type myService struct{}

func (m *myService) Execute(args []string, r <-chan svc.ChangeRequest, status chan<- svc.Status) (bool, uint32) {

    const cmdsAccepted = svc.AcceptStop | svc.AcceptShutdown | svc.AcceptPauseAndContinue
    tick := time.Tick(5 * time.Second)

    status <- svc.Status{State: svc.StartPending}

    status <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}

loop:
    for {
        select {
        case <-tick:
            log.Print("Tick Handled...!")
        case c := <-r:
            switch c.Cmd {
            case svc.Interrogate:
                status <- c.CurrentStatus
            case svc.Stop, svc.Shutdown:
                log.Print("Shutting service...!")
                break loop
            case svc.Pause:
                status <- svc.Status{State: svc.Paused, Accepts: cmdsAccepted}
            case svc.Continue:
                status <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}
            default:
                log.Printf("Unexpected service control request #%d", c)
            }
        }
    }

    status <- svc.Status{State: svc.StopPending}
    return false, 1
}

func runService(name string, isDebug bool) {
    if isDebug {
        err := debug.Run(name, &myService{})
        if err != nil {
            log.Fatalln("Error running service in debug mode.")
        }
    } else {
        err := svc.Run(name, &myService{})
        if err != nil {
            log.Fatalln("Error running service in Service Control mode.")
        }
    }
}

func main() {

    f, err := os.OpenFile("E:/awesomeProject/debug.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
    if err != nil {
        log.Fatalln(fmt.Errorf("error opening file: %v", err))
    }
    defer f.Close()

    log.SetOutput(f)
    runService("myservice", false)
}

Interfacing Arduino with C#/.NET

Barani Kumar S — Mon, 25 Sep 2023 00:08:56 +0000

Introduction

Hey guys, I'm here with another interesting article on how to interface Arduino with C#/.NET seamlessly using serial communication. There are other ways available but the easier and most stable way is via the Serial protocol. At the end of the tutorial, you will be able to interface any Arduino boards with any .NET applications. This includes Console, WPF, WinUI3, .NET MAUI etc., Let's get started.

Prerequisites

Make sure you guys are ready with the below equipment.

A Laptop/PC with USB Port (not type-c).
Any Arduino boards. I'm using Arduino UNO.
.NET 6 or later version installed.
Arduino IDE.
Self Interest.

Getting Started

Verify your .NET installation with the below command



$ dotnet --list-sdks

#output
#7.0.401 [C:\Program Files\dotnet\sdk]

Here it shows that I have .NET7.0.x installed, which is good.

Connect Arduino board to the PC and verify that the board is detected.
If everything goes fine. You're ready to write the code.

Programming the Arduino

In this tutorial, we're going to send a string "Hello World" from Arduino to the .NET application. So, we need to write a simple code to make the Arduino log "Hello World" via Serial Communication.

Open the Arduino IDE and create a new sketch.
Copy paste the below code. ```cpp

void setup() {
Serial.begin(9600);
}

void loop() {
Serial.println("Hello World");
delay(2000);
}

- Upload the sketch to Arduino.
- Done. The Arduino part is over. Now we can get to the real deal. The interface program in .NET/C#.

---

## Interfacing in a .NET Application

For this tutorial, I'm going to create a simple Console Application. But this code is common for any .NET workloads. With some little tweaks, you can integrate the code with any type of .NET Applications.

- Create a .NET Console app.
```bash


$ dotnet new console

We are going to use System.IO.Ports NuGet package. This is a core package responsible for serial interfacing. ```bash

$ dotnet add package System.IO.Ports


- Now it's time to code. I'm going to use VSCode with the [C# Dev Kit](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csdevkit) Installed for intellisense. You can use Visual Studio or any editor you want.

Open Program.cs and clear out the code that's already been there. Now import the necessary libraries.
```csharp


using System.IO.Ports;
using System;

Now create a class called Program with Main method in it.



public class Program()
{
    public static void Main()
    {     
    }
}

Now create another method in the Program class called MainInterface. This method is called in the Main method to reduce the complexity of using static methods and properties everywhere.



public class Program()
{
    public static void Main()
                => new Program().MainInterface();

    public void MainInterface() 
    {
    }
}

Now create a SerialPort property called serialPort in the Program class.



private SerialPort serialPort {get; set;}

Now copy paste the following code in MainInterface method.



serialPort = new()
{
    PortName = "COM3",
    BaudRate = 9600
};

In this scenario, my Arduino board is connected to "COM3" port, and the baud rate is set to 9600 as we set the same in the Arduino code. You can check the port on which your Arduino is connected in Device Manager.

Now, we want to subscribe to event when a data is received via the Serial Communication. This can be achieved by SerialPort's DataReceived event handler.

Firstly, create a new DataReceived event handler method in the Program class.



public void SerialDataRecieved(object sender, SerialDataReceivedEventArgs e)
{
    string inData = serialPort.ReadLine();
    Console.WriteLine($"Data Received: {inData}");
}

Now reference the event handler method to the serialPort property in the MainInterface method.



serialPort.DataReceived += SerialDataRecieved;

Now, Copy paste the below lines in MainInterface method to Open the port and start listening.



serialPort.Open();
Console.ReadKey();
serialPort.Close();

And that's it. In case you lost your track, here is the entire code.



using System.IO.Ports;
using System;

public class Program()
{

    private SerialPort serialPort {get; set;}

    public static void Main()
                => new Program().MainInterface();

    public void MainInterface() 
    {
        serialPort = new()
        {
            PortName = "COM3",
            BaudRate = 9600
        };
        serialPort.DataReceived += SerialDataRecieved;
        serialPort.Open();
        Console.ReadKey();
        serialPort.Close();
    }

    public void SerialDataRecieved(object sender, SerialDataReceivedEventArgs e)
    {
        string inData = serialPort.ReadLine();
        Console.WriteLine($"Data Received: {inData}");
    }
}

Running / Testing

Make sure you have connected the Arduino board and mentioned the correct COM Port name in the C# Code. If everything is fine, you can run the program by using the below command.



$ dotnet run

And if everything goes fine, you can see our "Hello World" gets printed on the console or terminal.

Hooray, we have successfully interfaced Arduino with C#/.NET. You can even send data to the Arduino via the same Serial Communication and handle those in the Arduino code. It's time to make your own .NET app to control Arduino...!

Conclusion

Hope you guys got basic idea on what is serial communication and how easy it is to interface Arduino with a .NET app. You can interface any component that supports Serial Communication. See you guys in the next blog 👋.

Reference Links

SerialPort docs can be found [here].

Introduction to WinUI 3 Desktop Development

Barani Kumar S — Mon, 03 Apr 2023 16:59:56 +0000

Introduction

Hey devs, Welcome to my blog. In this blog, I'm going to expose you to the world of Fluent Windows Application Development (WinUI 3). At the end of this tutorial blog, you will be able to create a simple desktop application that uses the Windows App SDK to present a wonderful Fluent UI and better performance. Let's get started.

Prerequisites

Make sure you meet those below requirements to get started.

A Machine with Windows 11 (Windows 10 works too).
Basic knowledge in C# and .NET (Optional)
Willingness to learn.
Consistency.

Getting Started

First of all, install the latest release of Visual Studio Community Edition from here.
After installing, select the "Visual Studio Community" from the list and select the toolchains as shown in the below image to install them.

Grasp some basics

WinUI 3 is the native UI platform component that ships with the Windows App SDK. It is supported by the latest .NET6. The whole concept of this SDK is to create powerful Windows applications with fluent UI in mind. The Windows App SDK provides a unified set of APIs and tools that can be used to create production desktop apps that target Windows 10 and later, and can be published to the Microsoft Store.

Let's develop our app!

First of all, Open Visual Studio and click on "Create New Project" as shown below,

Then search for "Blank App, Packaged (WinUI3 in Desktop)", select it and click on "Next" as shown below,

Now we want to name our solution. The solution file (.sln) basically contains a collection of projects or assemblies. You can name your project anything you want. I'm using the name "TestApp" here.

Then click on the checkbox below and click on "Create" button.

If you have the same as below image, then you're good to go.

Project Structure Breakdown

If we look at your project structure, there will be two files called MainWindow.xaml and App.xaml (I'll explain about other files in future blogs).
Basically, when the app is launched, the "App.xaml" will get triggered first and it launches a new instance of MainWindow.xaml which is our home page in our case.
If your click on the arrow symbol on the MainWindow.xaml file, there will be an another file called MainWindow.xaml.cs.

Umm, so what are those two files? The MainWindow.xaml is the file where you define the UI of the application. It uses the XAML Markup Language which is designed by Microsoft for defining beautiful UI's without any hassle.
The MainWindow.xaml.cs is called the "Code-Behind" file for MainWindow.xaml which contains all the logic to be implemented on the UI.

If you open the MainWindow.xaml file, there will be something similar to the below code.



<!-- Copyright (c) Microsoft Corporation and Contributors. -->
<!-- Licensed under the MIT License. -->

<Window
    x:Class="TestApp.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:TestApp"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center">
        <Button x:Name="myButton" Click="myButton_Click">Click Me</Button>
    </StackPanel>
</Window>

If you open the MainWindow.xaml.cs file, it'll look something like this,



// Copyright (c) Microsoft Corporation and Contributors.
// Licensed under the MIT License.

using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Controls.Primitives;
using Microsoft.UI.Xaml.Data;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Navigation;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace TestApp
{
    /// <summary>
    /// An empty window that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainWindow : Window
    {
        public MainWindow()
        {
            this.InitializeComponent();
        }

        private void myButton_Click(object sender, RoutedEventArgs e)
        {
            myButton.Content = "Clicked";
        }
    }
}

According to the above code, a Button is defined inside a StackPanel (we'll talk about Panels later).
The Button has a x:Name property and myButton as its value and a Click event handler and its value as myButton_Click and it's Content property set to Click Me.
And in the Code-Behind, we defined a method for Click event handler named myButton_Click where it is triggered, it'll change the Content property of the Button to Clicked. Simple isn't it?
Let's run our app to see it in action. Click on the "TestApp (Package)" button to build and run the app.

Tada! You've built and ran your first WinUI 3 App.

When you click on the Click Me button, you see that the Button's Content has been changed to Clicked as we defined in the MainWindow.xaml.cs.

Let's make a simple counter app

So, we got a basic knowledge on how WinUI 3 app works. We can now make a simple "counter" app that increments and decrements the count.
For that we need two Button. One for incrementing and another for decrementing.
We also need a TextBlock to display the current count value.

Let's get started with defining the UI. Simply copy paste the below code in your MainWindow.xaml file.



<Window
    x:Class="TestApp.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:TestApp"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center" Spacing="20">


        <Button x:Name="IncrementButton" Click="IncrementButton_Click">
            +
        </Button>

        <TextBlock x:Name="DisplayTextBlock" Width="100" Text="0" TextAlignment="Center"/>

        <Button x:Name="DecrementButton" Click="DecrementButton_Click">
            -
        </Button>

    </StackPanel>
</Window>

Also, copy paste the below code to your MainWindow.xaml.cs file.



// Copyright (c) Microsoft Corporation and Contributors.
// Licensed under the MIT License.

using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Controls.Primitives;
using Microsoft.UI.Xaml.Data;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Navigation;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace TestApp
{
    /// <summary>
    /// An empty window that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainWindow : Window
    {

        private int count = 0;

        public MainWindow()
        {
            this.InitializeComponent();
        }

        private void IncrementButton_Click(object sender, RoutedEventArgs e)
        {
            count++;
            DisplayTextBlock.Text = count.ToString();
        }

        private void DecrementButton_Click(object sender, RoutedEventArgs e)
        {
            count--;
            DisplayTextBlock.Text = count.ToString();
        }
    }
}

We basically defined two buttons and their Click event handlers in the "Code-Behind" file.
The IncrementButton_Click will trigger when IncrementButton is clicked and it increments the count value and sets the count value in the DisplayTextBlock. The same applies for DecrementButton too.

Let's run our app by clicking the "TestApp (Package)" button on the top.
Hooray, we built our fully working counter app.

Conclusion

Hope you got a fair idea on WinUI 3 apps and if you find this blog interesting, consider following me and subscribe to my future blogs. See you guys in a next interesting blog 👋.

Next Steps

Learn C# [Link]
Learn XAML [Link]
Learn WinUI 3 [Link]
Explore all the UI controls available with the WinUI 3 Controls Gallery app [Link]

DEV Community: Barani Kumar S

Diving into Actor Model with Go and NATS

Introduction

What is Actor Model?

Actor Model vs Microservice Model

NATS in Actor Model

Simple actor in Golang with NATS

Writing a Windows Service in Go

Table Of Contents

Introduction

What exactly is a windows "service"?

Why Golang?

Concurrency

Simplicity

Static Binaries

Low Level Access

Writing a windows service in Go

Installing and Starting the Service

Conclusion

Complete Code

Interfacing Arduino with C#/.NET

Introduction

Prerequisites

Getting Started

Programming the Arduino

Running / Testing

Conclusion

Reference Links

Introduction to WinUI 3 Desktop Development

Introduction

Prerequisites

Getting Started

Grasp some basics

Let's develop our app!

Project Structure Breakdown

Let's make a simple counter app

Conclusion

Next Steps