C# on Brian Braatz Blog

Graph API in a Nutshell

Tue, 17 Oct 2023 00:00:00 +0000

The Microsoft Graph API is a unified interface that provides access to Microsoft 365 services, including Office 365, Azure Active Directory (Azure AD), SharePoint, Teams, and more.

Its like the “one ring” - but in the cloud :)

Before Graph API existed, we had to code against with multiple APIs, each specific to a product like Exchange, SharePoint, or Active Directory.

This frankly sucked.. :)

The GraphAPI brought all these old APIS into one place..

🏛 The Early Days: APIs Before Graph API

Before Microsoft introduced Graph API, developers had to use separate APIs for different services:

Legacy API	Purpose
Exchange Web Services (EWS)	Access emails, calendars, contacts in Exchange
SharePoint REST API	Manage SharePoint documents and lists
Azure AD Graph API	Query and manage Azure Active Directory
Office 365 APIs	Work with Office services (deprecated)
Skype for Business API	Communicate with Skype for Business (now Teams)

The problem with this approach? Inconsistent authentication, different endpoints, and varied permissions for each API.

Microsoft needed a single API to unify these services.

🚀 The Birth of Microsoft Graph API (2015)

In November 2015, Microsoft introduced the Graph API as a RESTful, unified API for Microsoft cloud services.

Key Benefits of Graph API:
✅ One API for all Microsoft 365 services
✅ Consistent authentication using OAuth 2.0
✅ Access multiple services (Office, AD, Teams, OneDrive, etc.)
✅ Scalable and cloud-first design

Instead of querying Exchange, SharePoint, and Azure AD separately, developers could now use Graph API for everything.

🏢 How Microsoft Graph API Relates to Office 365

Office 365 is a cloud-based productivity suite that includes Word, Excel, Outlook, Teams, SharePoint, OneDrive, and more.

Graph API allows developers to integrate with Office 365 data and automate tasks:

Office 365 Feature	Graph API Capabilities
Outlook Mail	Read, send, and organize emails
Outlook Calendar	Schedule events, invite attendees
OneDrive	Upload, download, and manage files
Teams	Create channels, post messages, manage users
SharePoint	Retrieve documents, manage lists
Word, Excel, PowerPoint	Edit and process Office files

Example: Retrieving Emails Using Graph API

1
2
3
4
5


import requests

headers = {"Authorization": f"Bearer {token['access_token']}"}
response = requests.get("https://graph.microsoft.com/v1.0/me/messages", headers=headers)
print(response.json())

C# Example

1
2


var response = await httpClient.GetAsync("https://graph.microsoft.com/v1.0/me/messages");
Console.WriteLine(await response.Content.ReadAsStringAsync());

🔐 How Microsoft Graph API Integrates with Azure Active Directory

Azure Active Directory (Azure AD) is Microsoft’s cloud-based identity and access management service. It controls authentication for Office 365, Azure, and enterprise applications.

How Graph API Works with Azure AD:

User Authentication – Uses OAuth 2.0 for secure logins.
User & Group Management – Manage users, groups, and permissions.
Security & Compliance – Retrieve audit logs, security alerts, and compliance reports.
Enterprise Apps – Integrate with third-party applications.

Example: Retrieving User Details from Azure AD

Python Example

1

requests.get("https://graph.microsoft.com/v1.0/users", headers=headers)

C# Example

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/users");

Example: Managing Groups in Azure AD

Python Example

1

requests.post("https://graph.microsoft.com/v1.0/groups", headers=headers, json={"displayName": "Developers", "mailNickname": "devs"})

C# Example

1
2
3


var groupData = new { displayName = "Developers", mailNickname = "devs" };
var content = new StringContent(JsonConvert.SerializeObject(groupData), Encoding.UTF8, "application/json");
await httpClient.PostAsync("https://graph.microsoft.com/v1.0/groups", content);

📅 Key Milestones in the Evolution of Graph API

Year	Event
2015	Microsoft Graph API launched
2017	Added Teams, Planner, and Outlook support
2019	Introduced Security & Compliance API
2021	Improved OneDrive, SharePoint, and Excel integrations
2023	AI-powered automation & Copilot integration

🔄 Transition from Legacy APIs to Graph API

Azure AD Graph API vs. Microsoft Graph API

Azure AD Graph API was the original API for Active Directory.
Microsoft Graph API replaced it with enhanced security, better performance, and more features.

Azure AD Graph API Deprecation Timeline:

Deprecated in June 2023.
Developers must migrate to Microsoft Graph API.

Exchange Web Services (EWS) vs. Graph API

EWS was the old method to access emails and calendars.
Graph API is now recommended for Outlook data.

Understanding Deadlocks and Race Conditions in C++ and C#

Sun, 14 Jul 2019 00:00:00 +0000

Understanding Deadlocks and Race Conditions in C++ and C#

Ah, concurrency. That magical realm where performance soars, or your program turns into a raging dumpster fire of synchronization nightmares.

Today, we’re diving into deadlocks and race conditions, two classic bugs that will make you question your career choices (or at least your debugging skills).

What is a Deadlock? 🤯

A deadlock occurs when two or more threads are waiting for each other to release a resource, but none of them ever does.

It’s like two people standing in a doorway, each waiting for the other to move first. Spoiler: No one moves. Ever.

📖 Wikipedia: Deadlock

Example 1: Classic Deadlock in C#

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


using System;
using System.Threading;

class DeadlockExample
{
 static readonly object lockA = new object();
 static readonly object lockB = new object();

 static void Method1()
 {
 lock (lockA)
 {
 Thread.Sleep(100);
 lock (lockB)
 {
 Console.WriteLine("Method1 acquired both locks.");
 }
 }
 }

 static void Method2()
 {
 lock (lockB)
 {
 Thread.Sleep(100);
 lock (lockA)
 {
 Console.WriteLine("Method2 acquired both locks.");
 }
 }
 }

 static void Main()
 {
 Thread t1 = new Thread(Method1);
 Thread t2 = new Thread(Method2);
 t1.Start();
 t2.Start();
 t1.Join();
 t2.Join();
 }
}

🔴 Why it happens: Thread 1 locks lockA and waits for lockB, while Thread 2 locks lockB and waits for lockA. Since neither releases their lock, they’re stuck in an eternal waiting game.

✅ How to avoid it: Always lock resources in a consistent order. In this case, ensure that both threads acquire locks in the same order (lockA then lockB).

Example 2: Classic Deadlock in C++

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <iostream>
#include <thread>
#include <mutex>
using namespace std;

mutex mtxA, mtxB;

void thread1() {
 lock_guard<mutex> lock1(mtxA);
 this_thread::sleep_for(chrono::milliseconds(100));
 lock_guard<mutex> lock2(mtxB);
 cout << "Thread 1 acquired both locks" << endl;
}

void thread2() {
 lock_guard<mutex> lock1(mtxB);
 this_thread::sleep_for(chrono::milliseconds(100));
 lock_guard<mutex> lock2(mtxA);
 cout << "Thread 2 acquired both locks" << endl;
}

int main() {
 thread t1(thread1);
 thread t2(thread2);
 t1.join();
 t2.join();
 return 0;
}

🔴 Why it happens: Same problem as C#—locks are acquired in an inconsistent order.

✅ How to avoid it: Use std::lock() to lock multiple mutexes simultaneously and avoid deadlocks.

1
2
3


lock(mtxA, mtxB);
lock_guard<mutex> lock1(mtxA, adopt_lock);
lock_guard<mutex> lock2(mtxB, adopt_lock);

What is a Race Condition? 🏎️💨

A race condition happens when multiple threads access shared data and at least one modifies it without proper synchronization. The outcome? Unpredictable behavior.

📖 Wikipedia: Race Condition

Example 3: Race Condition in C#

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


using System;
using System.Threading;

class RaceConditionExample
{
 static int counter = 0;

 static void Increment()
 {
 for (int i = 0; i < 1000000; i++)
 {
 counter++;
 }
 }

 static void Main()
 {
 Thread t1 = new Thread(Increment);
 Thread t2 = new Thread(Increment);
 t1.Start();
 t2.Start();
 t1.Join();
 t2.Join();
 Console.WriteLine($"Final counter value: {counter}");
 }
}

🔴 Why it happens: counter++ isn’t atomic, so multiple threads can read, increment, and write simultaneously, leading to lost updates.

✅ How to avoid it: Use Interlocked.Increment(ref counter); or a lock.

Example 4: Race Condition in C++

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <iostream>
#include <thread>
using namespace std;

int counter = 0;
void increment() {
 for (int i = 0; i < 1000000; i++) {
 counter++;
 }
}

int main() {
 thread t1(increment);
 thread t2(increment);
 t1.join();
 t2.join();
 cout << "Final counter value: " << counter << endl;
 return 0;
}

🔴 Why it happens: counter++ isn’t atomic, causing race conditions.

✅ How to avoid it: Use std::atomic<int> counter(0); instead.

Summary Table

Issue	Why It Happens	How to Avoid It
Deadlock	Threads waiting on each other forever	Lock resources in a consistent order
Race Condition	Threads modifying shared data without synchronization	Use locks or atomic variables

References

SharePoint in a Nutshell - For Software Developers

Tue, 17 Oct 2017 00:00:00 +0000

SharePoint is Microsoft’s Swiss Army knife for collaboration, document management, and business process automation.

Whether you love it, tolerate it, or avoid it like the plague, SharePoint has been a in enterprise software for over two decades.

📜 History of SharePoint

SharePoint was born in 2001 as a glorified document repository and collaboration tool.

Over the years, it evolved into a full-fledged content management system, enterprise intranet, and business automation platform.

📅 Table of Releases

Version	Release Year	Key Features
SharePoint 2001	2001	Basic document management
SharePoint 2003	2003	Web-based collaboration, document libraries
SharePoint 2007	2007	Workflows, improved UI, better integration with Office
SharePoint 2010	2010	Sandboxed solutions, Business Connectivity Services (BCS)
SharePoint 2013	2013	App model, improved search, cloud integration
SharePoint 2016	2016	Hybrid cloud features, better performance
SharePoint 2019	2019	Modern UI, deeper integration with OneDrive and Teams
SharePoint Online	Ongoing	Cloud-native, Microsoft 365 integration, Graph API support

🎯 Why Use SharePoint? (Motivation)

SharePoint is used by organizations to:

Centralize document storage
Manage permissions and compliance
Automate business processes
Create intranets and team sites
Enable secure collaboration across teams

🔑 Key Features in Different SharePoint Versions

Feature	SharePoint 2013	SharePoint 2016	SharePoint 2019	SharePoint Online
On-Premises Support	✅	✅	✅	❌
Cloud Integration	❌	✅	✅	✅
Modern UI	❌	❌	✅	✅
Microsoft 365 Integration	❌	❌	✅	✅
AI-Powered Search	❌	❌	✅	✅

🆚 Comparing SharePoint to Alternatives

Feature	SharePoint	Google Drive	Confluence	Dropbox
Document Management	✅	✅	❌	✅
Business Workflows	✅	❌	✅	❌
Permissions & Compliance	✅	❌	✅	❌
Custom Apps & Extensions	✅	❌	✅	❌

SharePoint is a strong choice for companies that need secure collaboration, business workflows, and deep Microsoft 365 integration.

If you are already in deep in Microsoft 365, Sharepoint is extra compelling..

But if your company is running on Dropbox or Google Drive, you will not get the same level of Microsoft eco-system integration .

For really simple sharing- arguably with less of a learning curve: tools like Google Drive or Dropbox might be more user-friendly.

🔍 The Microsoft Graph API

The Graph API is a RESTful API that allows developers to interact with SharePoint Online (and other Microsoft 365 services). You can use it to:

Manage Files & Folders: Upload, download, and organize files.
Automate Workflows: Trigger events when files change.
Query Lists & Data: Fetch and update SharePoint lists.
User & Group Management: Control permissions programmatically.

Example: Retrieving SharePoint Files Using Graph API

1
2
3
4
5
6


var driveItems = await graphClient.Sites["your-site-id"].Drive.Root.Children.Request().GetAsync();

foreach (var item in driveItems)
{
 Console.WriteLine($"Name: {item.Name}, ID: {item.Id}");
}

✅ Examples Where SharePoint is a Good Solution

Company Intranet
HR Document Storage
Team Collaboration Sites
Workflow Automation for Approvals
Enterprise Content Management
Secure File Sharing with Permissions
Compliance and Audit Logging
Knowledge Management Portals
Departmental Project Management
Hybrid Cloud and On-Prem Document Syncing

❌ 10 Examples Where SharePoint is NOT the Best Choice

Real-Time Collaborative Editing (Google Docs is better)
Transactional Database Storage (Use SQL Server instead)
High-Performance Web Applications
Custom-Built SaaS Products
Public-Facing Websites
API-Heavy Workflows (Other services provide faster APIs)
Complex Business Logic Processing
Low-Code / No-Code Apps (Power Apps may be better)
High-Speed Data Processing Needs
Ad-Hoc Cloud Storage (Google Drive or OneDrive is simpler)

🔐 Security & Authentication in SharePoint

Authentication Options

Azure AD Authentication (for cloud-based SharePoint Online)
Windows Authentication (for on-premises SharePoint)
OAuth 2.0 & OpenID Connect (for API access)
SAML-Based Authentication (for enterprise integrations)

Can You Use OAuth with SharePoint?

Yes! SharePoint Online supports OAuth 2.0 via Microsoft Graph API. This allows secure, token-based authentication for apps accessing SharePoint resources.

Example: Authenticating via OAuth 2.0

1
2
3
4
5
6
7
8
9


var confidentialClient = ConfidentialClientApplicationBuilder
 .Create(clientId)
 .WithClientSecret(clientSecret)
 .WithAuthority($"https://login.microsoftonline.com/{tenantId}")
 .Build();

var authResult = await confidentialClient.AcquireTokenForClient(new[] { "https://graph.microsoft.com/.default" }).ExecuteAsync();

Console.WriteLine($"Access Token: {authResult.AccessToken}");

So what does this have to do with Asp.net?

Take a deep look at Sharepoint and Graph API
- If you have a Corporate App: (sharepoint is not so great for public websites)
Really ask yourself- soul searching- can you replace some of your boilerplate code with Sharepoint?
The first time I did this (over 10 years ago), I was able to give the users a sharepoint site to administer the data we were collecting.
I then made a public website - that could connect to that same data
the best of both worlds
Sharepoint is a powerful tool to know what it can do , and how it can best fit into your cloud application design

Exploring the RAII Pattern

Sat, 14 Jul 2018 00:00:00 +0000

Photographer Waits Hours To Capture The Autumn Idyll Of Squirrels Carrying A Nut Over A Lake
https://www.boredpanda.com/squirrel-animals-photography-dick-van-duijn/

Resource Acquisition Is Initialization (RAII) is a programming pattern primarily known from C++, where resource management is tied to object lifetimes.

Let’s break it down and see how different languages handle resource management.

1. RAII in C++

C++ is the birthplace of RAII. Here, resources like memory, file handles, and locks are acquired in the constructor and released in the destructor.

Example: File Management in C++

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


#include <iostream>
#include <fstream>

class FileWrapper {
public:
 FileWrapper(const std::string& filename) {
 file.open(filename);
 if (!file) {
 throw std::runtime_error("Failed to open file");
 }
 }

 ~FileWrapper() {
 if (file.is_open()) {
 file.close();
 }
 }

 void write(const std::string& text) {
 file << text;
 }

private:
 std::ofstream file;
};

int main() {
 try {
 FileWrapper file("example.txt");
 file.write("Hello, RAII!");
 } catch (const std::exception& e) {
 std::cerr << e.what() << std::endl;
 }
}

Here, the destructor automatically cleans up the file when the FileWrapper object goes out of scope. No need to manually close the file!

2. RAII in C#

C# does not have destructors in the same way as C++, but it provides IDisposable and using blocks to achieve similar behavior.

Example: File Management in C#

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


using System;
using System.IO;

class FileWrapper : IDisposable {
 private StreamWriter file;

 public FileWrapper(string filename) {
 file = new StreamWriter(filename);
 }

 public void Write(string text) {
 file.Write(text);
 }

 public void Dispose() {
 file?.Dispose();
 }
}

class Program {
 static void Main() {
 using (var file = new FileWrapper("example.txt")) {
 file.Write("Hello, RAII in C#!");
 }
 }
}

C#’s using statement ensures that Dispose() is called automatically, mimicking RAII behavior.

3. RAII in Python

Python does not have destructors like C++, but it provides context managers (with statement) via the __enter__ and __exit__ methods.

Example: File Management in Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class FileWrapper:
 def __init__(self, filename):
 self.file = open(filename, 'w')

 def __enter__(self):
 return self.file

 def __exit__(self, exc_type, exc_value, traceback):
 self.file.close()

with FileWrapper("example.txt") as file:
 file.write("Hello, RAII in Python!")

Python’s context manager ensures the file is closed when exiting the with block.

4. RAII in Go

Go relies on explicit resource cleanup via defer, as it does not have RAII or destructors.

Example: File Management in Go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import (
 "fmt"
 "os"
)

func main() {
 file, err := os.Create("example.txt")
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 defer file.Close() // Ensures cleanup

 _, _ = file.WriteString("Hello, RAII in Go!")
}

defer ensures that file.Close() is called when main() exits, acting as a manual RAII alternative.

5. RAII in Rust

Rust fully embraces RAII, enforcing strict ownership rules with automatic cleanup when an object goes out of scope.

Example: File Management in Rust

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


use std::fs::File;
use std::io::Write;

struct FileWrapper {
 file: File,
}

impl FileWrapper {
 fn new(filename: &str) -> std::io::Result<FileWrapper> {
 let file = File::create(filename)?;
 Ok(FileWrapper { file })
 }

 fn write(&mut self, text: &str) -> std::io::Result<()> {
 self.file.write_all(text.as_bytes())
 }
}

fn main() {
 if let Ok(mut file) = FileWrapper::new("example.txt") {
 let _ = file.write("Hello, RAII in Rust!");
 }
} // file is automatically closed here

Rust enforces resource cleanup by design—once file goes out of scope, it’s dropped automatically.

6. RAII in JavaScript and TypeScript

JavaScript (and TypeScript) do not support RAII natively. Cleanup is usually handled via try-finally or explicit methods.

Example: File Management in Node.js (JavaScript/TypeScript)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import * as fs from 'fs';

class FileWrapper {
 private file: fs.WriteStream;

 constructor(filename: string) {
 this.file = fs.createWriteStream(filename);
 }

 write(text: string) {
 this.file.write(text);
 }

 close() {
 this.file.end();
 }
}

// Usage
const file = new FileWrapper("example.txt");
try {
 file.write("Hello, RAII in JavaScript!");
} finally {
 file.close();
}

Here, finally ensures the file is closed, but this requires manual handling.

Conclusion

Language	RAII Support	Alternative Mechanism
C++	✅ Full	Destructors (`~Class()`)
C#	⚠️ Partial	`IDisposable` + `using`
Python	⚠️ Partial	`with` statement
Go	❌ No	`defer`
Rust	✅ Full	Ownership model
JavaScript	❌ No	`try-finally`
TypeScript	❌ No	`try-finally`

C++ and Rust fully support RAII. C# and Python provide structured alternatives, while Go and JavaScript require manual cleanup.

If you’re coming from a C++ background and miss RAII, Rust is your best bet. Otherwise, learning the language-specific cleanup patterns is key.

Key Ideas

Concept	Summary
RAII in C++	Uses destructors to manage resources automatically.
RAII in C#	Uses `IDisposable` and `using` for cleanup.
RAII in Python	Uses context managers (`with`).
RAII in Go	Uses `defer` for manual cleanup.
RAII in Rust	Uses ownership and automatic resource cleanup.
RAII in JavaScript/TypeScript	Requires manual `try-finally` handling.

Understanding Event-Driven Microservices

Mon, 14 Aug 2017 00:00:00 +0000

Understanding Event-Driven Microservices with C# and Python

What the Heck Are Event-Driven Microservices? 🤔

Think of event-driven microservices like a chain reaction of dominoes.

One thing happens (an event), and it triggers another service to do something, which might trigger yet another service, and so on.

Instead of services screaming at each other synchronously (“Hey, I need data NOW!”), they casually drop events and let others pick them up whenever they feel like it.

This makes your system:

Decoupled – Services don’t rely on each other directly.
Scalable – Need more performance? Just add more event consumers.
Resilient – One service crashes? No problem. The event still exists, waiting to be processed.

The Event-Driven Architecture Components 🏗️

Producers (Event Emitters) – Services that generate events.
Event Brokers (Message Queues) – Middlemen like Kafka, RabbitMQ, or Azure Service Bus.
Consumers (Event Listeners) – Services that process these events.

Imagine a food delivery app:

Order Service says, “New order placed!” 📦
Notification Service hears that and sends a “Ding! Your order is confirmed.” notification. 🔔
Kitchen Service gets busy preparing food. 👨‍🍳
Delivery Service assigns a driver. 🚗

All these happen asynchronously without clogging up a single service.

Implementing Event-Driven Microservices in C# 🚀

Step 1: Install RabbitMQ Client

1
2


// Install RabbitMQ for C#
dotnet add package RabbitMQ.Client

Step 2: Publish an Event (Producer)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


using RabbitMQ.Client;
using System.Text;

var factory = new ConnectionFactory() { HostName = "localhost" };
using var connection = factory.CreateConnection();
using var channel = connection.CreateModel();

channel.QueueDeclare(queue: "orders", durable: false, exclusive: false, autoDelete: false, arguments: null);

string message = "New Order Placed!";
var body = Encoding.UTF8.GetBytes(message);

channel.BasicPublish(exchange: "", routingKey: "orders", basicProperties: null, body: body);

Console.WriteLine("[x] Sent '{0}'", message);

Step 3: Consume the Event (Listener)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System.Text;

var factory = new ConnectionFactory() { HostName = "localhost" };
using var connection = factory.CreateConnection();
using var channel = connection.CreateModel();

channel.QueueDeclare(queue: "orders", durable: false, exclusive: false, autoDelete: false, arguments: null);

var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
 var body = ea.Body.ToArray();
 var message = Encoding.UTF8.GetString(body);
 Console.WriteLine("[x] Received {0}", message);
};

channel.BasicConsume(queue: "orders", autoAck: true, consumer: consumer);

Console.WriteLine("[x] Waiting for messages. Press [enter] to exit.");
Console.ReadLine();

Implementing Event-Driven Microservices in Python 🐍

Step 1: Install Pika (RabbitMQ Client for Python)

1

pip install pika

Step 2: Publish an Event (Producer)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='orders')

message = "New Order Placed!"
channel.basic_publish(exchange='', routing_key='orders', body=message)
print(f"[x] Sent '{message}'")

connection.close()

Step 3: Consume the Event (Listener)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


import pika

def callback(ch, method, properties, body):
 print(f"[x] Received {body.decode()}")

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='orders')
channel.basic_consume(queue='orders', on_message_callback=callback, auto_ack=True)

print("[x] Waiting for messages. Press CTRL+C to exit.")
channel.start_consuming()

Why You Should Care 🧐

Scalability – Just add more listeners to handle more events.
Resilience – One service goes down? Others don’t care. Events will be processed later.
Loose Coupling – Services don’t need to know each other’s existence.
Flexibility – Swap out tech stacks without affecting the entire system.

Key Ideas 📝

Concept	Description
Event-driven architecture	Microservices communicate through events instead of direct calls.
Message brokers	Middleware like RabbitMQ or Kafka manages event delivery.
Producers	Services that generate and publish events.
Consumers	Services that listen for and process events.
Loose coupling	Services don’t depend directly on each other.
Scalability	Adding more consumers improves performance.
Resilience	System continues working even if some services fail.

References 🔗

WCF in a Nutshell

Sun, 18 Jun 2017 00:00:00 +0000

WCF in a Nutshell: A Wild Ride Through Windows Communication Foundation

Ah, Windows Communication Foundation (WCF)—the technology that every .NET developer loved, hated, or just Googled whenever they had to work with it.

It’s one of those things that sounded great in theory but often made you question your life choices when debugging cryptic SOAP faults at 3 AM.

A Brief History of WCF

Back in the early 2000s, Microsoft looked at the mess of communication frameworks they had created and thought, “What if we could unify all this chaos?”

At the time, developers were juggling:

ASP.NET Web Services (ASMX) for basic SOAP-based web services.
Remoting for inter-process communication.
Enterprise Services (COM+) for distributed transactions.
MSMQ (Message Queuing) for reliable messaging.
Sockets for custom communication.

Each of these had its own APIs, quirks, and fantastic debugging experiences.
(cough, cough , cough…..)

Enter Windows Communication Foundation (WCF), launched with .NET 3.0 in 2006.

It was marketed as the One Framework to Rule Them All, letting developers use a single API to build services for SOAP, REST, TCP, MSMQ, and everything in between.

It was great! Until it wasn’t.

With the rise of RESTful APIs and the simplicity of ASP.NET Web API, WCF started to feel like a bloated relic. Eventually,

Microsoft moved on, and by .NET Core, WCF was politely left behind like an old Windows XP machine.

How WCF Works (In Plain English)

WCF is all about services and endpoints.

A WCF service is like a restaurant:

Service contract (Menu) – Defines what the service offers.
Binding (How food is served) – Specifies the protocol (HTTP, TCP, named pipes, etc.).
Endpoint (The waiter) – The actual address where requests are sent.

To use a WCF service, you basically:

Define a contract (what the service does).
Implement the contract in a service.
Configure bindings and endpoints (how clients talk to it).
Host it (IIS, a Windows Service, or even a console app).
Clients consume it like a web service or remote API.

It sounds simple, but in reality, the configuration XML files often felt like reading ancient hieroglyphs.

Writing a Basic WCF Service

Alright, let’s actually write some WCF code so you can impress your coworkers (or at least pretend to know what you’re doing).

1. Define the Service Contract

First, we create a contract using an interface.

1
2
3
4
5
6


[ServiceContract]
public interface IHelloService
{
 [OperationContract]
 string SayHello(string name);
}

That [ServiceContract] tells WCF that this interface is a service, and [OperationContract] marks methods that clients can call.

2. Implement the Service

1
2
3
4
5
6
7


public class HelloService : IHelloService
{
 public string SayHello(string name)
 {
 return $"Hello, {name}! Welcome to the world of WCF!";
 }
}

Nice and simple.

3. Configure the Service in `Web.config`

Now comes the fun part—configuration.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


<configuration>
 <system.serviceModel>
 <services>
 <service name="HelloService">
 <endpoint address=""
 binding="basicHttpBinding"
 contract="IHelloService" />
 </service>
 </services>
 </system.serviceModel>
</configuration>

This tells WCF to expose our service over HTTP using BasicHttpBinding, which is perfect if you want SOAP-based communication.

4. Hosting the Service

WCF services can be hosted in IIS, a Windows Service, or even a Console App.

For quick testing, let’s host it in a simple console application:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Program
{
 static void Main()
 {
 using (ServiceHost host = new ServiceHost(typeof(HelloService)))
 {
 host.Open();
 Console.WriteLine("HelloService is running...");
 Console.ReadLine();
 }
 }
}

Run this, and boom—your WCF service is live!

5. Consuming the Service

If you want to call this from a client, you can generate a proxy using Add Service Reference in Visual Studio or just use a simple ChannelFactory:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class Client
{
 static void Main()
 {
 ChannelFactory<IHelloService> factory =
 new ChannelFactory<IHelloService>(
 new BasicHttpBinding(),
 new EndpointAddress("http://localhost/HelloService"));

 IHelloService proxy = factory.CreateChannel();
 Console.WriteLine(proxy.SayHello("WCF Developer"));
 }
}

Key Ideas

Concept	Summary
WCF Origins	Microsoft created WCF to unify multiple communication frameworks into one.
Core Components	Service contracts, bindings, and endpoints define a WCF service.
Basic Example	A simple `IHelloService` contract, an implementation, and a `basicHttpBinding` configuration.
Hosting Options	Can be hosted in IIS, a Windows Service, or a Console App.
Client Consumption	Use `ChannelFactory` or Visual Studio’s “Add Service Reference.”
Relevance Today	WCF is largely replaced by REST APIs, gRPC, and WebSockets, but it still exists in legacy systems.

Buffer Overrun Attacks and How to Prevent Them

Sun, 10 Oct 2021 00:00:00 +0000

History of Buffer Overrun Attacks and How to Prevent Them in Python, C#, and Go

Ah, buffer overruns—one of the oldest and most infamous programming blunders in the history of software development. If memory bugs had a “Most Wanted” list, buffer overruns would be at the top, right next to null pointer dereferences and accidentally deleting production databases.

What is a Buffer Overrun?

A buffer overrun (or buffer overflow) happens when a program writes more data into a buffer than it can hold.

The excess data then spills over into adjacent memory, leading to corruption, crashes, and—if a hacker is feeling spicy—remote code execution. Sounds bad? It is. Real bad.

This type of vulnerability has been around since the dawn of programming, and it’s responsible for some of the biggest cybersecurity disasters ever.

If you’ve ever wondered why your C program segfaults randomly, you might be looking at a baby buffer overflow.

Wikipedia Buffer Overflow.

A Brief and Ridiculous History of Buffer Overruns

Buffer overruns have been around longer than your average internet meme. Let’s go on a journey through time:

The 1980s: Buffer overruns were just getting started. Early operating systems like UNIX were riddled with these vulnerabilities. Hackers were just beginning to understand how they could exploit them.
The 1990s: The golden era of buffer overflows. Thanks to languages like C and C++, which basically tell programmers, “Do whatever you want, I trust you,” buffer overruns became a hacker’s best friend. The infamous 1988 Morris Worm, one of the first-ever worms, exploited a buffer overflow.
The 2000s: The Internet boom meant more software, more security flaws, and more high-profile attacks. The 2001 Code Red and Nimda worms used buffer overflows to wreak havoc.
The 2010s: Memory-safe languages like Python and Go started gaining popularity, helping prevent buffer overruns. But legacy code in C and C++ continued to haunt the world.
Today: Buffer overruns still exist. Modern tools like AddressSanitizer and memory-safe languages have made them rarer, but in old-school systems, they’re still a problem.

How Buffer Overruns Work (For the Curious and Brave)

Imagine your program is a house, and your buffer is a glass of water. If you pour too much, it overflows onto the floor, ruining your carpet. In computing, that “spilled water” is extra data overwriting whatever is next in memory.

In C, this happens easily:

1
2
3
4
5
6
7
8
9


#include <stdio.h>
#include <string.h>

int main() {
 char buffer[10];
 strcpy(buffer, "This string is way too long!");
 printf("Buffer: %s\n", buffer);
 return 0;
}

Oops. strcpy doesn’t care if the string fits. It just pours in all the data, even if it floods everything in its path.

SO what ? IT ran over the buffer.. big deal or no?

Imagine that I put some chars in a string that overrun a buffer on a webserver… And those chars.. the bytes of them , will be interpreted as Assembly language.

Finding and leveraging these exploits was alot of work. But it paid off for the hacker because they can literally deliver executable assembly languge directly into someone elses sevrer. .

Usually that code would try to do something like make an admin account with a password the hacker knew.. Once the hacker could get “in” to the system with admin rights, thats where they could cause the real damage..

In the 2000s, (and still now - but systems were more vulnerable then ). Hackers would write scripts to automatically go out and “own” a bunch of servers.. and then install software on the server to sit and wait for instructions.

Then if the hacked wanted to Denial of Service attack someone, he would send instructions to his compromised systems telling them to attack.

All of sudden your grandmother’s computer in the den is visciously attacking amazon.com…

Preventing Buffer Overruns in Python, C#, and Go

Python: The Chill, Memory-Safe Language

Python is mostly immune to buffer overruns because it manages memory automatically. You don’t manually allocate memory for strings or arrays; Python just handles it. But beware—Python code that interfaces with C (like using ctypes) can still be vulnerable.

If you’re using C extensions or ctypes, always check buffer sizes before copying data.

1
2
3
4
5


import ctypes

buffer = ctypes.create_string_buffer(10)
# Safe: Limiting string length
ctypes.memmove(buffer, b"Hello", 5)

C#: The Managed Middle Ground

C# runs on the .NET runtime, which means memory management is mostly handled for you. But, if you decide to go full metal and use unsafe code, you’re asking for trouble.

1
2
3
4
5
6
7


unsafe {
 char* buffer = stackalloc char[10];
 for (int i = 0; i < 15; i++) // Whoops, buffer is only 10!
 {
 buffer[i] = 'A';
 }
}

Prevention tips:

Stick to managed memory whenever possible.
If you must use unsafe code, use Span or SafeHandle for safety.

Go: The Modern Memory-Safe Champion

Go has built-in memory safety features, so buffer overflows are rare. However, if you’re using cgo (calling C code), you can still fall into this trap.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

/*
#include <string.h>
#include <stdio.h>
*/
import "C"
import "unsafe"

func main() {
 buffer := make([]byte, 10)
 str := "This is too long!"

 C.strcpy((*C.char)(unsafe.Pointer(&buffer[0])), C.CString(str)) // Danger!
}

Prevention tips:

Avoid unsafe.Pointer unless absolutely necessary.
Use Go’s built-in slices and copy functions instead of C functions like strcpy.

Conclusion: Stay Safe, Code Smart

Buffer overruns have a long history of causing chaos, but modern programming languages and tools make them easier to prevent. If you’re writing in Python, C#, or Go, you’re already in a better spot than old-school C programmers. But if you’re working with legacy C or C++ code, always be mindful of memory safety!

Key Ideas Table

Concept	Explanation
Buffer Overrun	When data overflows a buffer, overwriting adjacent memory.
Memory Safety	Ensuring a program does not accidentally access memory incorrectly.
Python	Memory-safe but can still have issues when interfacing with C.
C#	Managed memory but can still have unsafe operations.
Go	Strong memory safety unless using `unsafe.Pointer`.

References

Sharepoint-Asp.net 8- Common Operations

Sat, 17 Oct 2020 00:00:00 +0000

🛠 Setting Up SharePoint Integration in ASP.NET 8

To get started, you’ll need:

ASP.NET 8 application
SharePoint Online (or On-Premises SharePoint Server)
Microsoft Graph API or SharePoint CSOM (Client-Side Object Model)

🔧 1. Install Required NuGet Packages

Install the required packages in your ASP.NET 8 project:

1
2
3


dotnet add package Microsoft.Graph
dotnet add package Microsoft.SharePointOnline.CSOM
dotnet add package Microsoft.Identity.Client

📂 2. Connect to SharePoint Using Microsoft Graph API

Graph API is the recommended way to interact with SharePoint Online.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


using Microsoft.Graph;
using Microsoft.Identity.Client;

var tenantId = "your-tenant-id";
var clientId = "your-client-id";
var clientSecret = "your-client-secret";

var confidentialClient = ConfidentialClientApplicationBuilder
 .Create(clientId)
 .WithClientSecret(clientSecret)
 .WithAuthority($"https://login.microsoftonline.com/{tenantId}")
 .Build();

var graphClient = new GraphServiceClient(new DelegateAuthenticationProvider(async (requestMessage) =>
{
 var authResult = await confidentialClient.AcquireTokenForClient(new[] { "https://graph.microsoft.com/.default" }).ExecuteAsync();
 requestMessage.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authResult.AccessToken);
}));

📁 3. Upload a File to SharePoint

1
2
3
4
5
6
7
8
9


var siteId = "your-site-id";
var filePath = "path-to-your-file.pdf";
var fileBytes = System.IO.File.ReadAllBytes(filePath);

using var stream = new MemoryStream(fileBytes);
await graphClient.Sites[siteId].Drive.Root.ItemWithPath("Documents/sample.pdf")
 .Content
 .Request()
 .PutAsync<DriveItem>(stream);

📜 4. List Files in a SharePoint Library

1
2
3
4
5
6


var driveItems = await graphClient.Sites["your-site-id"].Drive.Root.Children.Request().GetAsync();

foreach (var item in driveItems)
{
 Console.WriteLine($"Name: {item.Name}, ID: {item.Id}");
}

🔄 5. Download a File From SharePoint

1
2
3


var fileStream = await graphClient.Sites["your-site-id"].Drive.Items["file-id"].Content.Request().GetAsync();
using var file = new FileStream("downloaded-file.pdf", FileMode.Create, FileAccess.Write);
await fileStream.CopyToAsync(file);

🏷 6. Get File Metadata

1
2


var file = await graphClient.Sites["your-site-id"].Drive.Items["file-id"].Request().GetAsync();
Console.WriteLine($"Name: {file.Name}, Last Modified: {file.LastModifiedDateTime}");

🔄 7. Create a SharePoint List Item

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


var newItem = new ListItem
{
 Fields = new FieldValueSet
 {
 AdditionalData = new Dictionary<string, object>
 {
 {"Title", "New Task"},
 {"Status", "In Progress"}
 }
 }
};

await graphClient.Sites["your-site-id"].Lists["list-id"].Items.Request().AddAsync(newItem);

🗑 8. Delete a File in SharePoint

1

await graphClient.Sites["your-site-id"].Drive.Items["file-id"].Request().DeleteAsync();

🔑 9. Set Permissions on a File

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


var permission = new Permission
{
 Roles = new List<string> { "read" },
 GrantedTo = new IdentitySet
 {
 User = new Identity { Id = "user-id", DisplayName = "John Doe" }
 }
};

await graphClient.Sites["your-site-id"].Drive.Items["file-id"].Permissions.Request().AddAsync(permission);

📩 10. Send a SharePoint Notification (Webhook)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


var subscription = new Subscription
{
 ChangeType = "updated",
 NotificationUrl = "https://your-api.com/webhook",
 Resource = "sites/your-site-id/lists/list-id",
 ExpirationDateTime = DateTime.UtcNow.AddHours(1),
 ClientState = "your-client-state"
};

await graphClient.Subscriptions.Request().AddAsync(subscription);

LINQPad in a Nutshell

Sat, 15 Apr 2017 00:00:00 +0000

LINQPad in a Nutshell

A Little History

Once upon a time (2007, to be exact), a hero named Joe Albahari looked at the world of .NET development and thought, Why is running a simple LINQ query harder than it needs to be? And so, LINQPad was born.

Initially, it was just a handy way to test LINQ queries. But over time, it evolved into a full-fledged C# scratchpad, supporting LINQ, SQL, and even full-blown C# programs. Think of it as Notepad for .NET—except way cooler and significantly more useful.

Why Should You Care?

Because LINQPad is awesome. It lets you:

Write and test LINQ queries instantly.
Query databases without setting up a massive project.
Execute C# code on the fly.
Explore and interact with your EF Core or SQL databases like a boss.
Use Dump() to output results in a way that actually makes sense.

And the best part? No need to open Visual Studio and wait while your coffee gets cold.

Getting Started with LINQPad

Download LINQPad from linqpad.net.
Install it (this part is surprisingly easy).
Open it and start writing queries.

Boom! You’re now 10x more productive than you were five minutes ago.

Code Examples

1. Running a Simple LINQ Query

1
2
3
4
5
6


void Main()
{
 var numbers = Enumerable.Range(1, 10);
 var evens = numbers.Where(n => n % 2 == 0);
 evens.Dump(); // LINQPad's magic output method
}

2. Querying a Database

1
2
3
4
5


void Main()
{
 var db = new Query("SELECT * FROM Customers");
 db.Dump();
}

3. Writing a Quick C# Script

1
2
3
4
5


void Main()
{
 Console.WriteLine("Hello, LINQPad!");
 "Hello, LINQPad!".Dump(); // The LINQPad way
}

4. Using Entity Framework Core

1
2
3
4
5
6


void Main()
{
 var ctx = new MyDbContext();
 var users = ctx.Users.Where(u => u.IsActive).ToList();
 users.Dump();
}

Why Dump() is Life-Changing

Forget Console.WriteLine(). LINQPad’s Dump() method is what every C# developer has dreamed of. It takes any object and displays it in a beautifully formatted way—tables, graphs, JSON, whatever makes sense.

The Paid Version: Is It Worth It?

LINQPad comes in a free version that does almost everything you need. But if you want auto-completion and advanced features, the paid version is a no-brainer. Seriously, if you use LINQPad regularly, just buy it. Joe Albahari deserves a coffee.

Key Ideas

Topic	Summary
History	Created by Joe Albahari in 2007 to simplify LINQ queries.
Features	Supports LINQ, SQL, C# scripting, and EF Core.
Benefits	No need for Visual Studio; quick and easy testing of queries.
Code Examples	Demonstrates LINQ queries, database interaction, and scripting.
Dump()	The magical method that makes debugging easy.

References

PLINQ in a Nutshell

Tue, 21 Mar 2017 00:00:00 +0000

PLINQ in a Nutshell

Alright, let’s talk about PLINQ—Parallel Language-Integrated Query. It’s a cool thing in C# that allows us to run LINQ queries in parallel. If you’re tired of waiting for your queries to finish like they’re stuck in traffic, PLINQ’s here to help you speed things up.

What is PLINQ?

In case you haven’t met LINQ yet (and if you haven’t, I’m judging you), it’s the sweet syntax in C# that lets you run queries on arrays, lists, or any collection. Now, PLINQ takes LINQ and injects some parallelism into it.

It splits your queries into chunks and executes them on multiple threads. Imagine having a whole team of developers working on different parts of the project at the same time instead of just one poor soul doing everything. It’s like the Avengers, but for your code.

Why Should You Care?

Because performance! PLINQ can speed up queries, especially when you’re dealing with large datasets. For example, if you’re doing some heavy lifting with a huge list of objects, PLINQ can break the work into smaller tasks, run them simultaneously, and give you the result faster than you can say “concurrency issues.”

But, let’s get real—PLINQ isn’t magic. It won’t always make your code faster, and it’s definitely not a one-size-fits-all solution. Like any superhero, you’ve got to use it wisely.

How Does It Work?

You use PLINQ just like regular LINQ but with a simple .AsParallel() method. Here’s a quick example:

1
2
3
4


var numbers = Enumerable.Range(1, 1000000);
var result = numbers.AsParallel()
 .Where(n => n % 2 == 0)
 .ToList();

See that .AsParallel()? That’s the magic wand that tells PLINQ to work its parallelism charm. Behind the scenes, PLINQ breaks the collection into parts, processes them at the same time, and then combines the results.

Where Does PLINQ Shine?

PLINQ is most effective when your tasks are:

CPU-bound: If your query requires heavy computation, PLINQ can definitely help.
Independent: Each part of the query must be independent of others. If tasks rely on each other, PLINQ won’t be able to parallelize them efficiently.

For example, if you’re processing a collection of customer records and each record requires independent calculations, PLINQ can break that down across multiple threads.

But if you’re doing something like sorting or grouping data, PLINQ might make things more complicated and slower, so be careful.

When Should You Avoid PLINQ?

Sometimes, parallelism can add unnecessary complexity, and sometimes you’ll end up with a slower performance than just sticking with regular LINQ. The overhead of managing multiple threads can outweigh the benefits.

Also, PLINQ doesn’t always play nice with things like stateful operations (where the result of one task affects the next). You’ll want to avoid using PLINQ when your code has a lot of interdependent operations.

A Quick Example to Show Off

Let’s say you’ve got a collection of integers, and you want to square each one and then add them up. Here’s what it would look like with regular LINQ vs. PLINQ:

Regular LINQ:

1
2
3


var numbers = Enumerable.Range(1, 1000000);
var sum = numbers.Select(n => n * n).Sum();
Console.WriteLine(sum);

PLINQ:

1
2
3
4
5


var numbers = Enumerable.Range(1, 1000000);
var sum = numbers.AsParallel()
 .Select(n => n * n)
 .Sum();
Console.WriteLine(sum);

Notice how you just toss .AsParallel() in there, and suddenly it’s working in parallel. Pretty slick, huh?

Potential Pitfalls

Overhead: The task of managing threads can take more time than just doing it sequentially for smaller collections. So don’t use PLINQ for tiny datasets; it’s overkill.
Exceptions: Handling exceptions in parallel execution can get tricky. Each thread operates independently, so if one of them throws an exception, it won’t automatically bubble up to the main thread unless you handle it carefully.
Ordering: If you care about the order of your results, you’ll need to use .AsOrdered() to preserve the original order. By default, PLINQ doesn’t guarantee that, so be cautious.

Best Practices

Use PLINQ with large datasets: For big collections, PLINQ can really speed things up.
Monitor Performance: Always benchmark. Just because PLINQ is a “parallel” solution doesn’t mean it’s always the fastest. Test it out and see if it works for your specific scenario.
Thread Safety: Be mindful of shared state between threads. Ensure your code is thread-safe or else you might end up with some really confusing bugs.

Key Ideas

Idea	Description
PLINQ	Parallel version of LINQ
`.AsParallel()`	The magic that makes LINQ parallel
When to use PLINQ	Large datasets, CPU-bound tasks
When to avoid PLINQ	Small datasets, dependent tasks

References

Bluetooth communication- Windows in C++ & C#

Mon, 14 Aug 2017 00:00:00 +0000

Setting Up Bluetooth Communication in C++

Using Windows Sockets for Bluetooth (Winsock)

Microsoft provides the winsock2.h library for Bluetooth communication. Here’s a basic example of how to scan for Bluetooth devices using Winsock in C++:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <winsock2.h>
#include <ws2bth.h>
#include <iostream>

#pragma comment(lib, "Ws2_32.lib")

int main() {
 WSADATA wsaData;
 WSAStartup(MAKEWORD(2, 2), &wsaData);

 SOCKET btSocket = socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
 if (btSocket == INVALID_SOCKET) {
 std::cerr << "Failed to create Bluetooth socket!" << std::endl;
 return 1;
 }

 std::cout << "Bluetooth socket created successfully!" << std::endl;
 closesocket(btSocket);
 WSACleanup();
 return 0;
}

This initializes Winsock, creates a Bluetooth socket, and then closes it. Simple, right?

Sending Data Over Bluetooth in C++

Once you’ve found a Bluetooth device, you can connect and send data using connect() and send().

1
2
3


// Assume socket is already created and connected
const char* message = "Hello Bluetooth!";
send(btSocket, message, strlen(message), 0);

That’s all you need for a basic Bluetooth connection in C++! (Except for all the error handling you should be doing. But let’s not kill the vibe.)

The most important thing to rememebr-is this is just like a socket or serial port.

Bluetooth Communication in C#

C# makes Bluetooth development a little easier thanks to the Windows APIs and .NET libraries.

Discovering Bluetooth Devices

Here’s how to list paired Bluetooth devices using C#:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


using System;
using System.Linq;
using Windows.Devices.Enumeration;
using Windows.Devices.Bluetooth;

class Program {
 static async System.Threading.Tasks.Task Main() {
 var devices = await DeviceInformation.FindAllAsync(BluetoothDevice.GetDeviceSelector());
 foreach (var device in devices) {
 Console.WriteLine($"Found: {device.Name}");
 }
 }
}

This snippet scans for Bluetooth devices and prints their names. Short, sweet, and to the point.

Connecting and Sending Data in C#

Let’s send data over Bluetooth using RfcommDeviceService (the C# equivalent of raw socket programming in C++ but without the suffering):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


using System;
using System.Text;
using System.IO;
using Windows.Devices.Bluetooth.Rfcomm;
using Windows.Storage.Streams;

class Program {
 static async System.Threading.Tasks.Task Main() {
 var device = await BluetoothDevice.FromIdAsync("YourDeviceIdHere");
 var service = await device.GetRfcommServicesAsync();
 var stream = service.Services[0].ConnectionHostName;

 using (DataWriter writer = new DataWriter(new MemoryStream().AsOutputStream())) {
 writer.WriteString("Hello, Bluetooth!");
 await writer.StoreAsync();
 }
 }
}

And just like that, we’re talking to Bluetooth devices without diving into raw sockets.

Blazor In a Nutshell

Thu, 14 Nov 2024 00:00:00 +0000

A Brief History of Blazor

Blazor started as an experimental project by Microsoft, and when people saw it actually worked, Microsoft was like, “Well, guess we gotta support this now!” Since then, it has evolved into a full-fledged framework with different hosting models:

Blazor WebAssembly (WASM): Runs completely in the browser using WebAssembly. No need for a server-side connection—just load the app and go!
Blazor Server: Renders everything on the server and sends updates to the client over SignalR. It’s fast and great for real-time apps, but requires a constant connection.
Blazor Hybrid: Use Blazor inside desktop and mobile apps with .NET MAUI or Electron. C# everywhere, baby!

Now that Blazor has matured, let’s look at some of the shiny new features that make it even more awesome.

New Features in Blazor

1. Blazor United (Blazor Server + WASM = ❤️)

One of the biggest new features in Blazor is Blazor United, which allows developers to mix and match Blazor Server and Blazor WASM in the same app.

Want some components to load instantly using Blazor Server but others to be client-side for offline support? Now you can!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


@page "/weather"

@if (IsWasmSupported)
{
 <WeatherWidgetWasm />
}
else
{
 <WeatherWidgetServer />
}

2. Rendering Improvements (Faster Blazor, Less Waiting)

Blazor’s rendering engine got some serious gains, like it’s been hitting the gym. Microsoft optimized the diffing algorithm, reducing unnecessary DOM updates and improving interactivity.

1
2
3
4
5
6
7
8


@code {
 private List<string> items = new();

 protected override void OnInitialized()
 {
 items = Enumerable.Range(1, 100).Select(i => $"Item {i}").ToList();
 }
}

3. Streaming Rendering (Because Nobody Likes Waiting)

With Streaming Rendering, Blazor can now send partial page updates as the content becomes available, improving perceived load times.

1
2
3
4
5


@page "/news"

<StreamRender>
 <NewsFeed />
</StreamRender>

This means users don’t have to stare at a blank screen while waiting for data to load. Instead, they get content as soon as it’s ready!

4. Enhanced JavaScript Interop (Yes, We Still Need JS Sometimes)

Look, we tried to get rid of JavaScript, but sometimes we still need it. The good news? JavaScript interop in Blazor is now smoother than ever.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


<button @onclick="ShowAlert">Click me!</button>

@code {
 [Inject] IJSRuntime JS { get; set; }

 private async Task ShowAlert()
 {
 await JS.InvokeVoidAsync("alert", "Hello from Blazor!");
 }
}

5. Auto-Reconnect for Blazor Server

Ever had a Blazor Server app lose connection and just… die? Well, not anymore! Blazor now includes automatic reconnection, so if the network blips, your app will try to reconnect on its own.

1
2
3


<CircuitHandler>
 <h3>Reconnecting...</h3>
</CircuitHandler>

The Future of Blazor

Blazor is evolving rapidly, and Microsoft has big plans. Some of the upcoming features include:

AOT Compilation for WebAssembly: Even faster Blazor WASM apps!
Better Mobile Support: Blazor + .NET MAUI = ❤️
More Interop with JavaScript Frameworks: If you can’t beat them, integrate with them.
Server-Side Rendering (SSR) with Blazor Components: Because why not borrow a good idea from React?

Key Ideas

Concept	Summary
Blazor WebAssembly	Runs in the browser using WebAssembly
Blazor Server	Uses SignalR to render UI from the server
Blazor United	Mixes Server & WASM for best performance
Streaming Rendering	Sends content progressively for faster UX
Enhanced JS Interop	Better ways to call JS from Blazor
Auto-Reconnect	Blazor Server can now recover from outages
Future of Blazor	Faster, better, and more features incoming

References

Parsing NCPDP & HIPAA X12

Wed, 14 Jun 2017 00:00:00 +0000

So, You Have to Parse NCPDP or HIPAA X12 EDI?

I’m Sorry.

If you’re here, you’ve probably been voluntold to deal with healthcare EDI transactions.

You’ve seen the cryptic format, wondered if someone spilled alphabet soup into your file, and now you need help.

No worries!

I got you.

Let’s talk about the best open-source frameworks in C#, Python, and Node.js to make your life less miserable when handling NCPDP and HIPAA X12 transactions like 277, 835, 837, 997, 999, and TA1.

C# Frameworks for EDI Parsing

1. EDI.Net

A solid open-source library for parsing and generating X12 EDI transactions in C#.

Great for dealing with HIPAA 837, 835, and other standard transactions.

Installation:

1

Install-Package Edi.Net

Example Usage:

1
2
3
4
5


using indice.Edi;
using System.IO;

var ediText = File.ReadAllText("sample.edi");
var transaction = EdiSerializer.Deserialize<MyEdiModel>(ediText);

2. X12Parser

This library helps process HIPAA X12 files and can convert them into JSON or XML.

Installation:

1

Install-Package X12Parser

Example Usage:

1
2
3


var parser = new X12Parser();
var transaction = parser.Parse("path/to/edi/file");
Console.WriteLine(transaction.ToJson());

Python Frameworks for EDI Parsing

1. PyX12

A veteran library for parsing and generating HIPAA X12 transactions.

It includes validation tools, which is great because EDI errors are the worst.

Installation:

1

pip install pyx12

Example Usage:

1
2
3
4
5
6


from pyx12.x12file import X12Reader

with open("sample.edi", "r") as edi_file:
reader = X12Reader(edi_file)
for segment in reader:
print(segment)

2. edi-parser

A lightweight library for parsing X12 files in Python, with support for HIPAA transactions.

Installation:

1

pip install edi-parser

Example Usage:

1
2
3
4
5


from edi_parser import parse

with open("sample.edi", "r") as f:
transaction = parse(f.read())
print(transaction)

Node.js Frameworks for EDI Parsing

1. node-x12

This library provides an easy way to parse and generate X12 EDI files.

It’s simple and effective.

Installation:

1

npm install node-x12

Example Usage:

1
2
3
4
5
6


const { X12Parser } = require("node-x12");
const parser = new X12Parser();

const ediText = "ISA*00*..."; // Replace with actual EDI content
const transaction = parser.parse(ediText);
console.log(transaction);

2. edi-parser-js

A minimalistic but powerful X12 parser for Node.js.

Installation:

1

npm install edi-parser-js

Example Usage:

1
2
3
4
5


const { parseEDI } = require("edi-parser-js");

const ediData = "ISA*00*..."; // Your EDI file content
const result = parseEDI(ediData);
console.log(result);

Wrapping It Up

You don’t have to suffer alone in the abyss of EDI.

Whether you’re coding in C#, Python, or Node.js, these open-source frameworks will save you time, headaches, and possibly your sanity.

If you’re working with NCPDP transactions, unfortunately, open-source support is sparse.

Most solutions are proprietary, but you might find limited parsing capability in the libraries above.

Happy coding (or at least, less painful debugging)!

Key Ideas

Topic	Summary
EDI Parsing in C#	Use `EDI.Net` or `X12Parser` to process HIPAA X12 transactions.
EDI Parsing in Python	`pyx12` and `edi-parser` are solid choices for handling HIPAA X12 files.
EDI Parsing in Node.js	`node-x12` and `edi-parser-js` are the best libraries for working with EDI in JavaScript.
Common Transactions	The libraries above support 277, 835, 837, 997, 999, and TA1 transactions.
NCPDP Support	Open-source options for NCPDP transactions are limited.

References

Graph API Snippets -Python and C#

Tue, 17 Oct 2023 00:00:00 +0000

1️⃣ Authenticate with Microsoft Graph API (OAuth 2.0)

🔹 Python Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


import msal

client_id = "your-client-id"
client_secret = "your-client-secret"
tenant_id = "your-tenant-id"

authority = f"https://login.microsoftonline.com/{tenant_id}"
app = msal.ConfidentialClientApplication(client_id, client_secret, authority=authority)

token = app.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])

if token:
 print("Access Token:", token["access_token"])

🔹 C# Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


using Microsoft.Identity.Client;

var clientId = "your-client-id";
var clientSecret = "your-client-secret";
var tenantId = "your-tenant-id";

var confidentialClient = ConfidentialClientApplicationBuilder
 .Create(clientId)
 .WithClientSecret(clientSecret)
 .WithAuthority($"https://login.microsoftonline.com/{tenantId}")
 .Build();

var authResult = await confidentialClient.AcquireTokenForClient(new[] { "https://graph.microsoft.com/.default" }).ExecuteAsync();

Console.WriteLine($"Access Token: {authResult.AccessToken}");

2️⃣ Retrieve User Information

🔹 Python Example

1
2
3
4
5


import requests

headers = {"Authorization": f"Bearer {token['access_token']}"}
response = requests.get("https://graph.microsoft.com/v1.0/me", headers=headers)
print(response.json())

🔹 C# Example

1
2
3
4
5
6
7
8
9


using System.Net.Http;
using System.Net.Http.Headers;

var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", authResult.AccessToken);

var response = await httpClient.GetAsync("https://graph.microsoft.com/v1.0/me");
var userData = await response.Content.ReadAsStringAsync();
Console.WriteLine(userData);

List User Emails

Python Example

1
2


response = requests.get("https://graph.microsoft.com/v1.0/me/messages", headers=headers)
print(response.json())

C# Example

1
2


var response = await httpClient.GetAsync("https://graph.microsoft.com/v1.0/me/messages");
Console.WriteLine(await response.Content.ReadAsStringAsync());

Send an Email via Microsoft Graph

Python Example

1
2
3
4
5
6
7
8
9


email_data = {
 "message": {
 "subject": "Hello from Graph API",
 "body": {"contentType": "Text", "content": "This is a test email."},
 "toRecipients": [{"emailAddress": {"address": "recipient@example.com"}}]
 }
}

requests.post("https://graph.microsoft.com/v1.0/me/sendMail", headers=headers, json=email_data)

C# Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


var emailContent = new
{
 message = new
 {
 subject = "Hello from Graph API",
 body = new { contentType = "Text", content = "This is a test email." },
 toRecipients = new[]
 {
 new { emailAddress = new { address = "recipient@example.com" } }
 }
 }
};

var content = new StringContent(JsonConvert.SerializeObject(emailContent), Encoding.UTF8, "application/json");
await httpClient.PostAsync("https://graph.microsoft.com/v1.0/me/sendMail", content);

Upload a File to OneDrive

🔹 Python Example

1
2
3
4


file_path = "test.txt"
with open(file_path, "rb") as file:
 requests.put(f"https://graph.microsoft.com/v1.0/me/drive/root:/{file_path}:/content",
 headers=headers, data=file)

🔹 C# Example

1
2
3


var fileContent = File.ReadAllBytes("test.txt");
var byteContent = new ByteArrayContent(fileContent);
await httpClient.PutAsync("https://graph.microsoft.com/v1.0/me/drive/root:/test.txt:/content", byteContent);

Get a List of SharePoint Files

1

requests.get("https://graph.microsoft.com/v1.0/sites/{site-id}/drive/root/children", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/sites/{site-id}/drive/root/children");

Manage Calendar Events

1

requests.get("https://graph.microsoft.com/v1.0/me/calendar/events", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/me/calendar/events");

Get Teams Information

1

requests.get("https://graph.microsoft.com/v1.0/me/joinedTeams", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/me/joinedTeams");

Manage SharePoint Lists

1

requests.get("https://graph.microsoft.com/v1.0/sites/{site-id}/lists", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/sites/{site-id}/lists");

Get Organization Users

1

requests.get("https://graph.microsoft.com/v1.0/users", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/users");

Manage Microsoft 365 Groups

Groups are essential for managing users in Teams, SharePoint, and Outlook.

🔹 Python Example: List Groups

1
2


response = requests.get("https://graph.microsoft.com/v1.0/groups", headers=headers)
print(response.json())

🔹 C# Example: List Groups

1
2


var response = await httpClient.GetAsync("https://graph.microsoft.com/v1.0/groups");
Console.WriteLine(await response.Content.ReadAsStringAsync());

Add a User to a Group

🔹 Python Example

1
2
3
4
5


group_id = "your-group-id"
user_id = "user-id"

requests.post(f"https://graph.microsoft.com/v1.0/groups/{group_id}/members/$ref",
 headers=headers, json={"@odata.id": f"https://graph.microsoft.com/v1.0/users/{user_id}"})

🔹 C# Example

1
2
3
4
5
6
7
8


var groupId = "your-group-id";
var userId = "user-id";

var content = new StringContent(
 $"{{ "@odata.id": "https://graph.microsoft.com/v1.0/users/{userId}" }}",
 Encoding.UTF8, "application/json");

await httpClient.PostAsync($"https://graph.microsoft.com/v1.0/groups/{groupId}/members/$ref", content);

Remove a User from a Group

1

requests.delete(f"https://graph.microsoft.com/v1.0/groups/{group_id}/members/{user_id}/$ref", headers=headers)

1

await httpClient.DeleteAsync($"https://graph.microsoft.com/v1.0/groups/{groupId}/members/{userId}/$ref");

Create a New Team in Microsoft Teams

🔹 Python Example

1
2
3
4
5
6
7


team_data = {
 "template@odata.bind": "https://graph.microsoft.com/v1.0/teamsTemplates('standard')",
 "displayName": "New Dev Team",
 "description": "Development team workspace"
}

requests.post("https://graph.microsoft.com/v1.0/teams", headers=headers, json=team_data)

🔹 C# Example

1
2
3
4
5
6
7
8
9


var teamData = new
{
 template = new { "@odata.bind" = "https://graph.microsoft.com/v1.0/teamsTemplates('standard')" },
 displayName = "New Dev Team",
 description = "Development team workspace"
};

var content = new StringContent(JsonConvert.SerializeObject(teamData), Encoding.UTF8, "application/json");
await httpClient.PostAsync("https://graph.microsoft.com/v1.0/teams", content);

Create a Task in Microsoft Planner

1
2
3
4
5
6
7


task_data = {
 "planId": "your-plan-id",
 "title": "Finish Graph API Integration",
 "assignments": {}
}

requests.post("https://graph.microsoft.com/v1.0/planner/tasks", headers=headers, json=task_data)

1
2
3
4
5
6
7
8
9


var taskData = new
{
 planId = "your-plan-id",
 title = "Finish Graph API Integration",
 assignments = new { }
};

var content = new StringContent(JsonConvert.SerializeObject(taskData), Encoding.UTF8, "application/json");
await httpClient.PostAsync("https://graph.microsoft.com/v1.0/planner/tasks", content);

Get All OneDrive Shared Links

1

requests.get("https://graph.microsoft.com/v1.0/me/drive/sharedWithMe", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/me/drive/sharedWithMe");

Create a SharePoint Site

1
2
3
4
5
6


site_data = {
 "displayName": "New SharePoint Site",
 "template": "STS#3"
}

requests.post("https://graph.microsoft.com/v1.0/sites", headers=headers, json=site_data)

1
2
3
4
5
6
7
8


var siteData = new
{
 displayName = "New SharePoint Site",
 template = "STS#3"
};

var content = new StringContent(JsonConvert.SerializeObject(siteData), Encoding.UTF8, "application/json");
await httpClient.PostAsync("https://graph.microsoft.com/v1.0/sites", content);

Retrieve User Presence in Microsoft Teams

1

requests.get("https://graph.microsoft.com/v1.0/me/presence", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/me/presence");

Manage OneNote Notebooks

1

requests.get("https://graph.microsoft.com/v1.0/me/onenote/notebooks", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/me/onenote/notebooks");

Send a Teams Channel Message

1
2
3
4
5
6


message_data = {
 "body": {"content": "Hello from Graph API!"}
}

requests.post("https://graph.microsoft.com/v1.0/teams/{team-id}/channels/{channel-id}/messages",
 headers=headers, json=message_data)

1
2
3
4
5
6
7


var messageData = new
{
 body = new { content = "Hello from Graph API!" }
};

var content = new StringContent(JsonConvert.SerializeObject(messageData), Encoding.UTF8, "application/json");
await httpClient.PostAsync($"https://graph.microsoft.com/v1.0/teams/{teamId}/channels/{channelId}/messages", content);

Retrieve Audit Logs from Microsoft 365

Microsoft Graph provides access to security logs for compliance and monitoring.

🔹 Python Example

1

requests.get("https://graph.microsoft.com/v1.0/security/alerts", headers=headers)

🔹 C# Example

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/security/alerts");

Manage Conditional Access Policies

Control security policies programmatically.

1

requests.get("https://graph.microsoft.com/v1.0/identity/conditionalAccess/policies", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/identity/conditionalAccess/policies");

Send Notifications to Users via Microsoft Graph

1
2
3
4
5
6
7


notification_data = {
 "targetHostName": "outlook.office.com",
 "payload": {"message": "Security update required!"},
 "userId": "user-id"
}

requests.post("https://graph.microsoft.com/v1.0/me/sendActivityNotification", headers=headers, json=notification_data)

1
2
3
4
5
6
7
8
9


var notificationData = new
{
 targetHostName = "outlook.office.com",
 payload = new { message = "Security update required!" },
 userId = "user-id"
};

var content = new StringContent(JsonConvert.SerializeObject(notificationData), Encoding.UTF8, "application/json");
await httpClient.PostAsync("https://graph.microsoft.com/v1.0/me/sendActivityNotification", content);

Manage User Licenses in Microsoft 365

1

requests.get("https://graph.microsoft.com/v1.0/users/{user-id}/licenseDetails", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/users/{user-id}/licenseDetails");

Create an Azure AD Application Programmatically

1
2
3
4
5
6


app_data = {
 "displayName": "My New App",
 "signInAudience": "AzureADMyOrg"
}

requests.post("https://graph.microsoft.com/v1.0/applications", headers=headers, json=app_data)

1
2
3


var appData = new { displayName = "My New App", signInAudience = "AzureADMyOrg" };
var content = new StringContent(JsonConvert.SerializeObject(appData), Encoding.UTF8, "application/json");
await httpClient.PostAsync("https://graph.microsoft.com/v1.0/applications", content);

Automate Role Assignments for Users

1

requests.post(f"https://graph.microsoft.com/v1.0/users/{user_id}/assignLicense", headers=headers, json=license_data)

1

await httpClient.PostAsync($"https://graph.microsoft.com/v1.0/users/{userId}/assignLicense", content);

Get Microsoft 365 Service Health Reports

1

requests.get("https://graph.microsoft.com/v1.0/admin/serviceAnnouncement/healthOverviews", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/admin/serviceAnnouncement/healthOverviews");

Automate Meeting Room Booking

1
2
3
4
5
6
7
8


event_data = {
 "subject": "Team Sync",
 "start": {"dateTime": "2025-02-20T10:00:00", "timeZone": "UTC"},
 "end": {"dateTime": "2025-02-20T11:00:00", "timeZone": "UTC"},
 "location": {"displayName": "Meeting Room 101"}
}

requests.post("https://graph.microsoft.com/v1.0/me/calendar/events", headers=headers, json=event_data)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


var eventData = new
{
 subject = "Team Sync",
 start = new { dateTime = "2025-02-20T10:00:00", timeZone = "UTC" },
 end = new { dateTime = "2025-02-20T11:00:00", timeZone = "UTC" },
 location = new { displayName = "Meeting Room 101" }
};

var content = new StringContent(JsonConvert.SerializeObject(eventData), Encoding.UTF8, "application/json");
await httpClient.PostAsync("https://graph.microsoft.com/v1.0/me/calendar/events", content);

Archive a Microsoft Team

1

requests.post("https://graph.microsoft.com/v1.0/teams/{team-id}/archive", headers=headers)

1

await httpClient.PostAsync($"https://graph.microsoft.com/v1.0/teams/{teamId}/archive", null);

Automate Data Retention Policies

1

requests.get("https://graph.microsoft.com/v1.0/security/dataLossPreventionPolicies", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/security/dataLossPreventionPolicies");

Azure AD logs are crucial for security monitoring.

🔹 Python Example

1

requests.get("https://graph.microsoft.com/v1.0/auditLogs/signIns", headers=headers)

🔹 C# Example

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/auditLogs/signIns");

Manage Device Compliance Policies

1

requests.get("https://graph.microsoft.com/v1.0/deviceManagement/deviceCompliancePolicies", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/deviceManagement/deviceCompliancePolicies");

Reset a User’s Password

1
2
3


reset_data = {"passwordProfile": {"forceChangePasswordNextSignIn": True, "password": "NewSecurePass123!"}}

requests.patch("https://graph.microsoft.com/v1.0/users/{user-id}", headers=headers, json=reset_data)

1
2
3
4
5
6
7


var resetData = new
{
 passwordProfile = new { forceChangePasswordNextSignIn = true, password = "NewSecurePass123!" }
};

var content = new StringContent(JsonConvert.SerializeObject(resetData), Encoding.UTF8, "application/json");
await httpClient.PatchAsync("https://graph.microsoft.com/v1.0/users/{user-id}", content);

Manage Microsoft Defender Alerts

1

requests.get("https://graph.microsoft.com/v1.0/security/alerts_v2", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/security/alerts_v2");

Create a Guest User in Azure AD

1
2
3
4
5
6
7
8
9


guest_data = {
 "accountEnabled": True,
 "displayName": "John Doe (Guest)",
 "mailNickname": "johndoe",
 "userPrincipalName": "johndoe@example.com",
 "userType": "Guest"
}

requests.post("https://graph.microsoft.com/v1.0/users", headers=headers, json=guest_data)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


var guestData = new
{
 accountEnabled = true,
 displayName = "John Doe (Guest)",
 mailNickname = "johndoe",
 userPrincipalName = "johndoe@example.com",
 userType = "Guest"
};

var content = new StringContent(JsonConvert.SerializeObject(guestData), Encoding.UTF8, "application/json");
await httpClient.PostAsync("https://graph.microsoft.com/v1.0/users", content);

Retrieve Microsoft 365 Usage Reports

1

requests.get("https://graph.microsoft.com/v1.0/reports/getOffice365ActiveUserDetail(period='D30')", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/reports/getOffice365ActiveUserDetail(period='D30')");

Retrieve an Employee’s Manager Information

1

requests.get("https://graph.microsoft.com/v1.0/users/{user-id}/manager", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/users/{user-id}/manager");

Manage Meeting Room Reservations

1
2


room_list = requests.get("https://graph.microsoft.com/v1.0/me/findRooms", headers=headers)
print(room_list.json())

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/me/findRooms");

Enable Multi-Factor Authentication (MFA) for a User

1
2
3


mfa_data = {"strongAuthenticationMethods": [{"methodType": "PhoneAppNotification"}]}

requests.patch("https://graph.microsoft.com/v1.0/users/{user-id}", headers=headers, json=mfa_data)

1
2
3
4


var mfaData = new { strongAuthenticationMethods = new[] { new { methodType = "PhoneAppNotification" } } };

var content = new StringContent(JsonConvert.SerializeObject(mfaData), Encoding.UTF8, "application/json");
await httpClient.PatchAsync("https://graph.microsoft.com/v1.0/users/{user-id}", content);

Get a List of Recently Accessed Documents

1

requests.get("https://graph.microsoft.com/v1.0/me/insights/used", headers=headers)

1

await httpClient.GetAsync("https://graph.microsoft.com/v1.0/me/insights/used");

Dapper in a Nutshell

Sun, 14 Aug 2016 00:00:00 +0000

Dapper in a Nutshell

What the Heck is Dapper, and Why Should You Care?

So, you’ve been using Entity Framework (EF) and loving its sweet, sweet LINQ queries. But one day, your database starts crying because EF is making a bazillion queries and your app is moving slower than a snail in molasses.

Enter Dapper—the lightweight, super-fast micro ORM (Object-Relational Mapper) that lets you talk to your database with the speed of a caffeinated squirrel.

A Brief History of Dapper (With Minimal Boredom)

Back in 2011, the team at Stack Overflow (yes, the very people who save our butts daily) needed something faster than Entity Framework but still easy to use. They wanted raw SQL speed without the boilerplate nonsense of ADO.NET.

So, they built Dapper.

Dapper basically wraps ADO.NET but makes it ridiculously easy to execute queries and map results to C# objects. Think of it as ADO.NET with a personal assistant who takes care of all the tedious work.

Why Use Dapper? (Or: Why You Should Break Up With EF—Sometimes)

Speed Demon: Dapper is almost as fast as raw ADO.NET because it avoids all the fancy ORM magic.
Lightweight: No baggage, no unnecessary abstraction—just SQL with some mapping awesomeness.
SQL-Friendly: You write SQL directly, which means no weird query translation problems.
Control: You have full control over what gets executed, how it performs, and how data is shaped.
Flexible: Works with any database (SQL Server, PostgreSQL, MySQL, SQLite—you name it!).

Dapper vs Entity Framework: The Ultimate Showdown

Feature	Dapper	Entity Framework
Performance	Insanely fast 🚀	Can be slow on large queries 🐢
Ease of Use	Simple and direct SQL	LINQ queries, auto-mapping
Control	Full control over SQL	Abstraction layer hides SQL
Learning Curve	Very easy if you know SQL	Slightly steeper with LINQ
Database Support	Works with everything	Mostly SQL Server, others need tweaking
Best For	Read-heavy apps, APIs	Complex domain models

Dapper in Action

1. Install Dapper

1
2


// Install via NuGet
Install-Package Dapper

2. Setting Up a Database Connection

1
2
3
4
5
6
7
8
9


using System.Data;
using System.Data.SqlClient;

var connectionString = "YourConnectionStringHere";
using (var db = new SqlConnection(connectionString))
{
 db.Open();
 Console.WriteLine("Database connected!");
}

3. Fetching a Single Record

1

var user = db.QueryFirstOrDefault<User>("SELECT * FROM Users WHERE Id = @Id", new { Id = 1 });

4. Fetching Multiple Records

1

var users = db.Query<User>("SELECT * FROM Users").ToList();

5. Insert Data

1
2


var rowsAffected = db.Execute("INSERT INTO Users (Name, Age) VALUES (@Name, @Age)",
 new { Name = "Alice", Age = 25 });

6. Update Data

1
2


var rowsAffected = db.Execute("UPDATE Users SET Age = @Age WHERE Name = @Name",
 new { Name = "Alice", Age = 26 });

7. Delete Data

1
2


var rowsAffected = db.Execute("DELETE FROM Users WHERE Name = @Name",
 new { Name = "Alice" });

8. Handling Transactions

1
2
3
4
5
6
7


using (var transaction = db.BeginTransaction())
{
 db.Execute("INSERT INTO Orders (UserId, Amount) VALUES (@UserId, @Amount)",
 new { UserId = 1, Amount = 99.99 }, transaction);

 transaction.Commit();
}

9. Stored Procedure Calls

1

var orders = db.Query<Order>("sp_GetUserOrders", new { UserId = 1 }, commandType: CommandType.StoredProcedure);

10. Mapping Complex Relationships

1
2
3
4
5
6


var sql = "SELECT * FROM Users u INNER JOIN Orders o ON u.Id = o.UserId";
var userOrders = db.Query<User, Order, User>(sql, (user, order) =>
{
 user.Orders.Add(order);
 return user;
}, splitOn: "Id").ToList();

Final Thoughts

Dapper is like that reliable, no-nonsense friend who gets things done—fast and efficiently. If you need high performance and love writing SQL, Dapper is your best bet.

Of course, EF still has its place, especially when dealing with complex domain models. But for pure speed and control, Dapper wipes the floor with EF.

Give it a shot, and enjoy blazing-fast database queries without the overhead!

Key Ideas

Concept	Summary
Dapper	Lightweight, fast micro ORM for C#
History	Created by Stack Overflow for speed
Performance	Almost as fast as raw ADO.NET
SQL-Friendly	Works directly with SQL queries
Comparison	Faster than EF but less automated
Best Use Case	APIs, read-heavy apps, high performance

C# on Brian Braatz Blog

Graph API in a Nutshell

🏛 The Early Days: APIs Before Graph API

🚀 The Birth of Microsoft Graph API (2015)

🏢 How Microsoft Graph API Relates to Office 365

🔐 How Microsoft Graph API Integrates with Azure Active Directory

How Graph API Works with Azure AD:

Example: Retrieving User Details from Azure AD

Example: Managing Groups in Azure AD

📅 Key Milestones in the Evolution of Graph API

🔄 Transition from Legacy APIs to Graph API

Azure AD Graph API vs. Microsoft Graph API

Exchange Web Services (EWS) vs. Graph API

Understanding Deadlocks and Race Conditions in C++ and C#

Understanding Deadlocks and Race Conditions in C++ and C#

What is a Deadlock? 🤯

Example 1: Classic Deadlock in C#

Example 2: Classic Deadlock in C++

What is a Race Condition? 🏎️💨

Example 3: Race Condition in C#

Example 4: Race Condition in C++

Summary Table

References

SharePoint in a Nutshell - For Software Developers

📜 History of SharePoint

📅 Table of Releases

🎯 Why Use SharePoint? (Motivation)

🔑 Key Features in Different SharePoint Versions

🆚 Comparing SharePoint to Alternatives

🔍 The Microsoft Graph API

Example: Retrieving SharePoint Files Using Graph API

✅ Examples Where SharePoint is a Good Solution

❌ 10 Examples Where SharePoint is NOT the Best Choice

🔐 Security & Authentication in SharePoint

Authentication Options

Can You Use OAuth with SharePoint?

Example: Authenticating via OAuth 2.0

So what does this have to do with Asp.net?

Exploring the RAII Pattern

1. RAII in C++

Example: File Management in C++

2. RAII in C#

Example: File Management in C#

3. RAII in Python

Example: File Management in Python

4. RAII in Go

Example: File Management in Go

5. RAII in Rust

Example: File Management in Rust

6. RAII in JavaScript and TypeScript

Example: File Management in Node.js (JavaScript/TypeScript)

Conclusion

Key Ideas

Understanding Event-Driven Microservices

Understanding Event-Driven Microservices with C# and Python

What the Heck Are Event-Driven Microservices? 🤔

The Event-Driven Architecture Components 🏗️

Implementing Event-Driven Microservices in C# 🚀

Step 1: Install RabbitMQ Client

Step 2: Publish an Event (Producer)

Step 3: Consume the Event (Listener)

Implementing Event-Driven Microservices in Python 🐍

Step 1: Install Pika (RabbitMQ Client for Python)

Step 2: Publish an Event (Producer)

Step 3: Consume the Event (Listener)

Why You Should Care 🧐

Key Ideas 📝

References 🔗

WCF in a Nutshell

WCF in a Nutshell: A Wild Ride Through Windows Communication Foundation

A Brief History of WCF

How WCF Works (In Plain English)

Writing a Basic WCF Service

1. Define the Service Contract

2. Implement the Service

3. Configure the Service in Web.config

4. Hosting the Service

5. Consuming the Service

Key Ideas

Buffer Overrun Attacks and How to Prevent Them

3. Configure the Service in `Web.config`