Dùng delegate và event để xây dựng hệ thống pub/sub cảnh báo — khi cảm biến vượt ngưỡng, tự động thông báo tới nhiều subscriber (log, email, buzzer…).

copyusing System;

class AlarmEventArgs : EventArgs
{
    public string SensorId { get; init; } = "";
    public double Value    { get; init; }
    public double Threshold{ get; init; }
}

class AlarmSensor
{
    public string Id        { get; init; } = "";
    public double Threshold { get; set;  }

    // Khai báo event
    public event EventHandler<AlarmEventArgs>? AlarmTriggered;

    public void SetValue(double v)
    {
        Console.Write($"[{Id}] = {v:F1}  ");
        if (v > Threshold)
        {
            Console.WriteLine("← ⚠ ALARM!");
            AlarmTriggered?.Invoke(this, new AlarmEventArgs
            {
                SensorId  = Id,
                Value     = v,
                Threshold = Threshold
            });
        }
        else Console.WriteLine("← OK");
    }
}

class Program
{
    static void Main()
    {
        var sensor = new AlarmSensor { Id = "TEMP-01", Threshold = 30.0 };

        // Đăng ký nhiều handler cho cùng một event
        sensor.AlarmTriggered += (s, e) =>
            Console.WriteLine($"  📧 Email: [{e.SensorId}] = {e.Value:F1} > {e.Threshold}");

        sensor.AlarmTriggered += (s, e) =>
            Console.WriteLine($"  🔔 Buzzer: BEEP BEEP!");

        sensor.AlarmTriggered += (s, e) =>
            Console.WriteLine($"  💾 Log: Alarm at {DateTime.Now:HH:mm:ss}");

        Console.WriteLine("--- Mô phỏng đọc cảm biến ---");
        foreach (double v in new[] { 25.0, 29.5, 32.1, 28.0, 35.6 })
            sensor.SetValue(v);
    }
}

Cài đặt CircularBuffer<T> dạng generic — dùng được cho bất kỳ kiểu dữ liệu (double, string, struct). Ứng dụng làm sliding window, FIFO queue.

copyusing System;
using System.Collections.Generic;
using System.Linq;

class CircularBuffer<T>
{
    private readonly T[]  _buf;
    private          int  _head, _count;

    public int  Capacity => _buf.Length;
    public int  Count    => _count;
    public bool IsFull   => _count == Capacity;

    public CircularBuffer(int capacity) => _buf = new T[capacity];

    public void Push(T item)
    {
        _buf[(_head + _count) % Capacity] = item;
        if (IsFull) _head = (_head + 1) % Capacity; // Ghi đè cũ
        else        _count++;
    }

    public IEnumerable<T> Items()
    {
        for (int i = 0; i < _count; i++)
            yield return _buf[(_head + i) % Capacity];
    }
}

class Program
{
    static void Main()
    {
        var tempBuf = new CircularBuffer<double>(5);

        Console.WriteLine("Nạp 8 mẫu vào buffer size=5:");
        foreach (double v in new[] {20.1,21.5,23.0,22.4,25.1,26.8,24.3,27.0})
        {
            tempBuf.Push(v);
            Console.Write($"{v} ");
        }

        Console.WriteLine($"nnBuffer hiện tại (5 mẫu gần nhất):");
        Console.WriteLine(string.Join(", ", tempBuf.Items()));

        double avg = tempBuf.Items().Average();
        Console.WriteLine($"Trung bình: {avg:F2} °C");

        // Generic: dùng cho string cũng được!
        var logBuf = new CircularBuffer<string>(3);
        logBuf.Push("INFO: Start");
        logBuf.Push("WARN: High temp");
        logBuf.Push("ERROR: Timeout");
        logBuf.Push("INFO: Retry OK");
        Console.WriteLine("nLog (3 dòng cuối):");
        foreach (var l in logBuf.Items())
            Console.WriteLine($"  {l}");
    }
}

Áp dụng DI pattern để tách biệt logic nghiệp vụ khỏi infrastructure — giúp dễ dàng thay đổi storage, transport mà không cần sửa core service.

copyusing System;
using System.Collections.Generic;

// Interfaces (hợp đồng)
interface IDataStore
{
    void        Save(string key, double val);
    double      Get(string  key);
}

interface INotifier
{
    void Notify(string message);
}

// Triển khai cụ thể
class InMemoryStore : IDataStore
{
    readonly Dictionary<string, double> _db = new();
    public void   Save(string k, double v) { _db[k] = v; Console.WriteLine($"  [InMemory] Lưu {k}={v}"); }
    public double Get(string k) => _db.GetValueOrDefault(k);
}

class ConsoleNotifier : INotifier
{
    public void Notify(string msg) =>
        Console.WriteLine($"  [Console] 🔔 {msg}");
}

class MqttNotifier : INotifier
{
    public void Notify(string msg) =>
        Console.WriteLine($"  [MQTT]    📡 Publish: {msg}");
}

// Service sử dụng DI – không phụ thuộc cài đặt cụ thể
class SensorService
{
    readonly IDataStore _store;
    readonly INotifier  _notifier;
    const double LIMIT = 30.0;

    public SensorService(IDataStore store, INotifier notifier)
    {
        _store    = store;
        _notifier = notifier;
    }

    public void Process(string id, double val)
    {
        _store.Save(id, val);
        if (val > LIMIT)
            _notifier.Notify($"ALARM: {id}={val:F1} > {LIMIT}");
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("--- Dùng Console Notifier ---");
        var svc1 = new SensorService(new InMemoryStore(), new ConsoleNotifier());
        svc1.Process("T-01", 25.0);
        svc1.Process("T-01", 33.5);

        Console.WriteLine("n--- Đổi sang MQTT Notifier ---");
        var svc2 = new SensorService(new InMemoryStore(), new MqttNotifier());
        svc2.Process("T-02", 31.2);
    }
}

Xây dựng TCP client gửi dữ liệu cảm biến và TCP server nhận — mô phỏng giao tiếp giữa edge device và IoT gateway qua mạng LAN.

copyusing System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

class IoTServer
{
    public static async Task StartAsync(int port)
    {
        var listener = new TcpListener(IPAddress.Loopback, port);
        listener.Start();
        Console.WriteLine($"[Server] Lắng nghe cổng {port}...");

        using var client = await listener.AcceptTcpClientAsync();
        Console.WriteLine("[Server] Client kết nối!");

        using var stream = client.GetStream();
        byte[] buf = new byte[256];

        while (true)
        {
            int n = await stream.ReadAsync(buf);
            if (n == 0) break;
            string msg = Encoding.UTF8.GetString(buf, 0, n);
            Console.WriteLine($"[Server] Nhận: {msg}");
            // Gửi ACK
            byte[] ack = Encoding.UTF8.GetBytes("ACK");
            await stream.WriteAsync(ack);
        }
        listener.Stop();
    }
}

class IoTClient
{
    public static async Task RunAsync(int port)
    {
        using var client = new TcpClient();
        await client.ConnectAsync(IPAddress.Loopback, port);
        using var stream = client.GetStream();
        byte[] buf = new byte[64];

        string[] payloads = {
            "{"t":25.1,"h":62}",
            "{"t":27.8,"h":65}",
            "{"t":31.2,"h":70}",
        };

        foreach (var p in payloads)
        {
            byte[] data = Encoding.UTF8.GetBytes(p);
            await stream.WriteAsync(data);
            Console.WriteLine($"[Client] Gửi: {p}");

            int n = await stream.ReadAsync(buf);
            Console.WriteLine($"[Client] ACK: {Encoding.UTF8.GetString(buf, 0, n)}");
            await Task.Delay(200);
        }
    }
}

class Program
{
    static async Task Main()
    {
        const int PORT = 9000;
        var serverTask = IoTServer.StartAsync(PORT);
        await Task.Delay(100); // Cho server khởi động
        await Task.WhenAll(serverTask, IoTClient.RunAsync(PORT));
    }
}

Cài đặt service chạy nền liên tục (daemon pattern) dùng CancellationToken — chuẩn mực cho IoT edge service cần chạy 24/7 với graceful shutdown.

copyusing System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;

class SensorDaemon
{
    private readonly int    _intervalMs;
    private readonly string _sensorId;
    public           List<double> Readings { get; } = new();

    public SensorDaemon(string id, int intervalMs)
    {
        _sensorId   = id;
        _intervalMs = intervalMs;
    }

    public async Task RunAsync(CancellationToken ct)
    {
        Console.WriteLine($"[{_sensorId}] Daemon khởi động (interval={_intervalMs}ms)");
        var rng = new Random();
        int tick = 0;

        try
        {
            while (!ct.IsCancellationRequested)
            {
                double val = 20 + rng.NextDouble() * 15;
                Readings.Add(val);
                Console.WriteLine($"  [{_sensorId}] Tick {++tick:D3}: {val:F2} °C");
                await Task.Delay(_intervalMs, ct);
            }
        }
        catch (TaskCanceledException) { /* Expected khi cancel */ }

        Console.WriteLine($"[{_sensorId}] Daemon dừng. Đã đọc {Readings.Count} mẫu.");
    }
}

class Program
{
    static async Task Main()
    {
        using var cts = new CancellationTokenSource();

        var daemon = new SensorDaemon("TEMP-01", 300);
        var task   = daemon.RunAsync(cts.Token);

        // Chạy 1.5 giây rồi dừng (mô phỏng Ctrl+C)
        await Task.Delay(1500);
        Console.WriteLine("n[Main] Gửi lệnh dừng...");
        cts.Cancel();

        await task;
        Console.WriteLine($"[Main] TB = {daemon.Readings.Average():F2} °C");
    }
}

Kết hợp class, interface, generic, event, async, LINQ và JSON để xây dựng mini IoT Hub thu thập dữ liệu từ nhiều thiết bị, phát cảnh báo và xuất báo cáo.

copyusing System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;

// ── Model ──
record Reading(string DeviceId, string Type, double Value, DateTime At);

// ── Alert rule ──
record AlertRule(string Type, double MaxValue);

// ── IoT Hub ──
class IoTHub
{
    private readonly List<Reading>   _readings = new();
    private readonly List<AlertRule> _rules    = new();

    public event Action<Reading>? OnAlert;

    public void AddRule(AlertRule rule) => _rules.Add(rule);

    public void Ingest(Reading r)
    {
        _readings.Add(r);
        var rule = _rules.FirstOrDefault(x => x.Type == r.Type);
        if (rule != null && r.Value > rule.MaxValue)
            OnAlert?.Invoke(r);
    }

    public void PrintReport()
    {
        Console.WriteLine("n╔══════════ IoT Hub Report ══════════╗");
        var byDevice = _readings.GroupBy(r => r.DeviceId);
        foreach (var grp in byDevice)
        {
            Console.WriteLine($"║  Device: {grp.Key}");
            foreach (var typeGrp in grp.GroupBy(r => r.Type))
            {
                var vals = typeGrp.Select(r => r.Value).ToList();
                Console.WriteLine($"║    {typeGrp.Key,-10}: min={vals.Min():F1} max={vals.Max():F1} avg={vals.Average():F1}");
            }
        }
        Console.WriteLine($"║  Tổng readings: {_readings.Count}");
        Console.WriteLine("╚════════════════════════════════════╝");
    }
}

class Program
{
    static void Main()
    {
        var hub = new IoTHub();
        hub.AddRule(new AlertRule("temp",     30.0));
        hub.AddRule(new AlertRule("humidity", 80.0));

        hub.OnAlert += r =>
            Console.WriteLine($"  ⚠ ALERT  [{r.DeviceId}] {r.Type}={r.Value:F1} @ {r.At:HH:mm:ss}");

        // Mô phỏng nhận dữ liệu
        var data = new (string dev, string type, double val)[]
        {
            ("ESP32-01", "temp",     26.5),
            ("ESP32-01", "humidity", 65.0),
            ("ESP32-01", "temp",     32.1),  // Alert!
            ("ESP32-02", "temp",     24.8),
            ("ESP32-02", "humidity", 83.5),  // Alert!
            ("ESP32-02", "temp",     28.3),
        };

        Console.WriteLine("Nhận dữ liệu từ thiết bị:");
        foreach (var (dev, type, val) in data)
        {
            Console.Write($"  ← {dev} {type}={val:F1}  ");
            hub.Ingest(new Reading(dev, type, val, DateTime.Now));
            Console.WriteLine();
        }

        hub.PrintReport();
    }
}