Forem: RecurPixel

Why .NET Deserves Serious Consideration for Your Next Backend Project

RecurPixel — Sat, 14 Mar 2026 12:15:09 +0000

An observation from someone who has worked with both — not a sponsored opinion, not a framework war, just honest experience.

First of all, why am I even writing this?

No genuine reason. Just an observation from someone who has worked with both PHP/Laravel and C#/ASP.NET Core and has thoughts about it.

If you are like me — someone who instead of getting comfortable with one tech and doing repetitive work keeps exploring options — you will understand where I am coming from.

I have heavily worked with PHP/Laravel. Projects like e-commerce, healthcare, social media — from backend APIs to full stack monolithic applications. And if you have done the same, you will know how frustrating it can get sometimes.

Let me give you a few examples.

The Midnight Cron Call

Suppose you want to add queues for notifications or process jobs like file exports, data processing, or backups.

Or suppose a client wants to export a large dataset. We all know PHP does not have native asynchronous features. We have all faced timeouts. We have all been there.

Yes, Laravel handles this with jobs and queues — but let's be honest, we are looking at patchwork here.

Another example: you set up a scheduled job to clean or back up data at a specific time. You create the job, configure the cron, set up Supervisor, and you are done.

Until you get a call from your PM at midnight.

The job is not running. You debug. Maybe the code had an issue. Maybe the cron stopped. Maybe Supervisor failed silently. You will never know until it already failed — in production — at the worst possible time.

You might think: maybe the developer (me, or you) was just dumb and did not test properly?

Maybe. But I have a better answer. I will come back to that.

Laravel Is Genuinely Beautiful — That Is Not the Point

I have a lot of respect for Laravel. The framework changed the landscape. For developers who came from raw PHP or CodeIgniter, Laravel looks like a masterpiece — and honestly, it is.

But here is the thing about perspective.

If someone has driven a broken Honda Civic their whole life and they get a BMW M5 — they will find it absolutely amazing. Smooth, fast, comfortable. Best car they have ever driven.

But if someone has test driven a Ferrari, it will never be the same.

Well — .NET is that Ferrari.

Wait. I will prove it to you.

Like I was saying, Laravel does things beautifully. Routing, ORM, Queuing, Authentication, CSRF protection, rate limiting — it handles all of it well. The developer experience is polished. The community is passionate.

But after years working in PHP/Laravel and then deeply in .NET, I have come to a conclusion that might be uncomfortable for some:

Laravel is the best possible version of something built on a shaky foundation.

And in 2026, that matters more than ever.

The Foundation Problem

PHP was never designed to be an enterprise application language.

It was designed in 1994 to add dynamic content to web pages. Everything since — namespaces, type hints, OOP, async workarounds — has been retrofitted onto that original scripting DNA.

Laravel does an extraordinary job of hiding this. But you cannot fully escape the foundation.

Remember that midnight cron call?

Here is your answer.

When your background job fails silently in Laravel, there is often no crash, no exception bubbling up, no loud failure. It just stops. Because PHP's execution model was never designed for long-running processes. Supervisor, Horizon, queue workers — these are all tools we use to work around a language that was not built for this.

In .NET, background services are first-class citizens. IHostedService, BackgroundService — built into the framework. They run, they restart, they report health. The runtime manages them. Not a workaround — the actual design.

That midnight call? Far less likely.

Proving the Ferrari Analogy — Performance

Let me back up the Ferrari claim with actual numbers.

ASP.NET Core is by far the fastest web framework available today. Not just compared to Laravel — Java Spring and Node.js do not come close either. Node Express? Not even in the conversation.

The TechEmpower Framework Benchmarks — the industry standard for web framework performance comparison — consistently rank ASP.NET Core in the top 3 globally across raw throughput, database query handling, and concurrent request processing.

We are talking 10 to 20 times faster than Laravel in raw throughput.

For most small applications this does not matter much. But consider high-traffic e-commerce during a sale. Payment processing under load. Mobile APIs serving thousands of concurrent users. Multi-tenant SaaS platforms scaling with their customers.

At scale, performance differences translate directly into infrastructure costs. Fewer servers. Lower cloud bills. Headroom to grow without emergency re-architecture at 2am.

This is not opinion. The benchmarks are public. Go check them yourself.

"But My Code Works on Dev and Staging — Why Is It Failing in Production?"

Raise your hand if you have said this.

I have. More than once.

Guess what — dynamic language at play.

PHP's type system is opt-in. You can add type hints, you can use $casts in your Eloquent models, you can be disciplined about it. But the language will not stop you from passing a string where an integer was expected. It will not catch a null sneaking through where an object was required. It will let your code run — and fail silently — in ways that only surface under specific production conditions, specific data, specific load.

C# is statically typed. The compiler checks every type, every contract, every null reference across your entire codebase before a single line executes. That entire class of bugs simply does not reach production. Not because developers are more careful — because the language physically will not allow it.

That "works on my machine" problem? Still possible in .NET, but a large chunk of the reasons it happens in PHP are eliminated before you even run the code.

"Okay But .NET Is Overkill for Small Projects"

I hear this one a lot.

People say .NET is better for large-scale systems and for small systems Laravel will do just fine.

Are you sure about that?

Think about where we are in 2026. AI tools generate boilerplate in seconds. The cost of setting up a well-structured project is basically zero now. When an AI is helping you write code, a statically typed, well-structured language like C# gives it far less room to make mistakes. Types are explicit. Contracts are clear. Results are predictable. AI-generated code in C# is easier to validate than AI-generated PHP because the compiler immediately tells you what is wrong.

Static types also mean fast, reliable test generation. When the types are known and the behaviour is predictable, writing and generating tests becomes dramatically easier.

And if you are worried about overhead for small projects — .NET has Minimal APIs. Literally a few lines to spin up a lightweight HTTP endpoint. No ceremony, no boilerplate, just a fast and clean API.

var app = WebApplication.Create();
app.MapGet("/hello", () => "Hello World");
app.Run();

That is it. Small project? Covered. Large enterprise system? Same framework scales to handle it.

But Laravel has Blade for frontend you say? .NET has Razor Pages and Blazor. Want server-side rendering? Done. Want a full SPA-like experience without leaving C#? Blazor has you covered. Want to go pure API? Minimal APIs. The framework adapts to what you are building.

Static Typing — The Real Answer to "Why Did This Break in Production"

PHP is dynamically typed.

This sounds academic until it bites you. A function returns a string where you expected an integer. A null sneaks through where an object was expected. A model attribute comes back as "1" instead of true. These errors do not exist until runtime — often in production, often under load.

Yes, Laravel's $casts helps at the model layer. You can define 'is_active' => 'boolean' and Eloquent will handle the conversion. That is real and useful.

But it is opt-in. Manual. It covers your models — not your service classes, not your controllers, not your helper functions. Forget a cast somewhere and you get a silent type mismatch with no warning.

C# is statically typed across your entire codebase. Every type, every contract, every null reference — verified at compile time. Not at runtime. Not in production. Before it runs.

This is not a minor convenience. For payment systems, healthcare APIs, logistics platforms — a runtime type error has real consequences. The compiler is your first line of defence and it never sleeps.

Built for the Architecture You Actually Want

Modern backend development has moved toward microservices, event-driven systems, message queues, and distributed architecture. These patterns require framework-level support — not add-ons.

ASP.NET Core was designed for this world.

Dependency Injection is built in. Not a package. Not a pattern you implement on top. It is how the framework works from day one.

Async/Await is native and deeply integrated. Writing non-blocking I/O in C# is natural and consistent. PHP's async story remains fragmented and feels unnatural by comparison.

Middleware Pipeline is explicit, composable, and testable. Every request flows through a defined pipeline you control completely.

Background Services, gRPC, SignalR, Worker Services — all first-class citizens. Real-time features, microservice communication, long-running jobs — built in, not bolted on.

LINQ — Data Manipulation That Actually Makes Sense

If you work with data-heavy applications, let me introduce you to something that will ruin PHP arrays for you forever.

LINQ — Language Integrated Query — lets you query, filter, transform, and aggregate data collections using a clean, readable, strongly-typed syntax that works directly in C#. No raw SQL string building. No messy array functions. Just expressive, composable queries that the compiler validates.

var highValueOrders = orders
    .Where(o => o.Total > 10000 && o.Status == OrderStatus.Completed)
    .OrderByDescending(o => o.CreatedAt)
    .Select(o => new { o.Id, o.Total, o.CustomerName })
    .Take(50);

That is readable. That is type-safe. That works on in-memory collections and translates directly to SQL through Entity Framework Core.

Data-driven application? LINQ has you covered in a way that PHP arrays simply cannot match.

Multiple Databases — SQL and NoSQL, No Problem

Want to work with SQL Server? Done. PostgreSQL? Done. MySQL? Done. MongoDB? Done. Redis? Done. CosmosDB? Done.

.NET has mature, well-maintained drivers and ORMs for practically every database that exists — relational or document, SQL or NoSQL. Entity Framework Core handles your relational data. MongoDB.Driver handles documents. StackExchange.Redis handles caching. All in the same codebase, all with the same strongly-typed C# code.

Switching databases or using multiple databases in one system is straightforward. The abstraction patterns that .NET naturally encourages — repository pattern, dependency injection, interface-based design — make swapping or combining data sources clean and testable.

AI Integration and MCP — .NET Is Ready for the Modern Stack

Here is something worth thinking about seriously in 2026.

AI integrations are no longer add-ons. They are essential. And .NET is genuinely well-positioned for this world.

The Microsoft ecosystem — Azure OpenAI, Semantic Kernel, the official OpenAI .NET SDK — means first-class AI integration without third-party hacks. If you are building applications that talk to language models, process embeddings, or implement retrieval-augmented generation, .NET has mature, well-supported tooling for all of it.

MCP — Model Context Protocol — the emerging standard for AI tool integration? .NET has community and official support growing fast.

And before you say it — yes, Python dominates data science and ML research. That is true and I am not disputing it.

But .NET has ML.NET.

Training models, running inference, integrating machine learning pipelines directly into your .NET application — without leaving the ecosystem, without spinning up a Python service, without managing two runtimes.

So in the modern world where your application needs to process data intelligently, integrate with AI services, and potentially run its own ML models — .NET covers all of it.

Still think Python wins? For pure research and data science notebooks — yes. For production backend systems with AI integration built in — .NET is right there.

The Market Nobody Talks About

Banking. Financial services. Healthcare systems. Government platforms. Insurance. Logistics at scale. Enterprise ERP.

These sectors run on Microsoft technology stacks. They have internal .NET expertise, existing infrastructure, compliance frameworks built around Azure, and procurement relationships with Microsoft. When these organisations need custom development, integrations, or modernisation projects — they look for .NET developers.

This market is enormous. The contracts are stable. The budgets are real. And PHP shops largely cannot access it.

For agencies and consultancies evaluating their technology direction — having strong .NET capability opens enterprise doors that simply stay closed to PHP-only teams.

The Honest Counterargument

I am not here to pretend PHP/Laravel has no advantages. That would be dishonest.

Lower barrier to entry. True. Junior developers can be productive in PHP faster.

Laravel's commercial ecosystem is excellent. Forge, Vapor, Nova, Cashier — polished tools.

Hosting is cheaper and more widely available. For simple shared hosting deployments, PHP wins on cost.

Large talent pool. Finding PHP developers is easier in many markets.

For small projects, rapid prototyping, budget-constrained teams, or organisations with deep existing PHP expertise — these are real advantages.

I am not saying PHP/Laravel is wrong for every situation. I am saying that for teams building systems that need to scale, handle real transaction volumes, integrate with AI and enterprise infrastructure, and grow over years — the .NET advantages compound significantly.

If You Are Considering the Switch

The good news: if you have Laravel experience, the concepts map cleanly.

Laravel	.NET Equivalent
Eloquent ORM	Entity Framework Core
Artisan CLI	.NET CLI
Middleware	ASP.NET Core Middleware
Service Container	Built-in Dependency Injection
Jobs & Queues	Background Services + MassTransit
Composer	NuGet
.env files	appsettings.json
Blade templates	Razor Pages / Blazor
API Resources	DTOs + AutoMapper

Your backend knowledge transfers. Your understanding of databases, REST APIs, authentication, deployment — all of it carries over. You are not starting from scratch. You are switching tools.

The Conclusion

Laravel is genuinely impressive. It is the best framework PHP has ever produced and probably the best framework any scripting-language ecosystem has ever produced.

But you are still building on a 1994 scripting language.

.NET gives you a modern, statically typed, enterprise-grade platform. World-class performance. First-class async and background processing. Native AI integration. LINQ. Cross-platform. 500,000+ NuGet packages. A clear long-term future backed by one of the largest technology companies in the world.

For someone who has always driven a broken Honda Civic, a BMW M5 feels like the pinnacle.

But once you have driven the Ferrari —

You will never look at the BMW the same way again.

I am a backend .NET developer and open-source contributor. I have published 37 NuGet packages including RecurPixel.Notify — a multi-channel notification framework with 30+ adapters and 5,500+ downloads. Find my work at recurpixel.io

Have you made the switch from PHP to .NET? Or are you firmly in the Laravel camp? Drop your experience in the comments — I would genuinely love to hear both sides.

P.S. — I want to start a war here. An opinion war. Drop your thoughts in the comments, Laravel devs I know you are already typing.

But honestly? Between us?

PHP is not that bad.

Think about it this way. More PHP bugs means more PHP jobs. More midnight cron failures means more midnight overtime pay. More "works on my machine" moments means more billable debugging hours.

Laravel developers are out here getting paid to fix the foundation while .NET developers are sitting on solid ground wondering why the phone is not ringing at 2am.

Maybe PHP devs are the real winners here.

Maybe.

Or maybe I am just trying to make myself feel better about the years I spent debugging queue workers at midnight.

You decide.

I Used AI to Help Build My Open Source Project and People Lost Their Minds — Here's Why They're Wrong

RecurPixel — Sun, 08 Mar 2026 09:22:27 +0000

Last week I posted my first open source project on Reddit. Within hours, someone accused me of writing "AI slop." Another said my reasoning was "stupid." A third said they were considering quitting Reddit altogether because of people like me.

All because I used AI in my workflow.

Let me tell you what actually happened — and why the backlash reveals a much bigger problem with how developers think about tools.

What I Built

I'm a solo developer from India. I spent months building ShopCore — a dual-purpose e-commerce and subscription delivery platform designed for the Indian market.

The problem I was solving is real: daily essential services like milk, newspaper, water jars, and bread delivery still run on handwritten khatas, verbal agreements, and pure trust in most of India. No app, no tracking, no proper billing. Vendors lose money. Customers have no receipts. Everything runs on paper.

ShopCore is an open backend infrastructure — think of it like UPI. NPCI built the open infrastructure, then Google Pay, PhonePe, and Paytm built businesses on top of it. ShopCore works the same way — any developer or startup can take the backend, build a simple frontend, and offer it to local vendors.

The scale of the MVP:

120+ REST API endpoints
40+ entities, 30+ database tables
Razorpay + Stripe payment integration
Multi-vendor with location-based discovery
Flexible subscription engine with daily delivery and monthly billing
Optional deposit and smart settlement system
Built with ASP.NET Core 10, Entity Framework Core, MediatR, FluentValidation, SQL Server

I built all of this alone, without funding, and open sourced it for free.

Then I Posted on Reddit

I used AI to help me write the Reddit post. I wanted it to be clear, well-structured, and reach a general audience — so I used AI as a writing assistant.

The comment that stung the most: "such a long response, probably AI written."

And here's the thing — they were partially right. AI did help me write the post.

But does that invalidate the 120+ API endpoints I designed? The subscription logic I architected? The deposit settlement system I thought through at 2am? The months of actual engineering work?

The Power Drill Analogy

Let me ask you something.

When a carpenter uses a power drill instead of a hand drill, do you say the furniture isn't really theirs? When an architect uses AutoCAD instead of drawing by hand, is the building design less valid? When a writer uses Grammarly, did they not really write the article?

Of course not. Tools exist to help people work faster and better. The judgment, the intent, the creative decisions — those still come from the person.

AI is no different.

Here's exactly what AI helped me with on the ShopCore project:

Writing the Reddit post — I had the idea and the story, AI helped structure it clearly
Drafting variable names — boring, repetitive work that AI handles in seconds
Rubber duck debugging at 2am — when no one else was around to talk through a problem
Boilerplate code — scaffolding I would have written anyway, just faster

Here's what AI did NOT do:

Identify the gap in India's daily delivery market
Design the dual-purpose architecture
Figure out how the deposit settlement system should work
Decide to use MediatR and CQRS pattern
Choose to open source it instead of letting it sit on my hard drive
Write 120+ API endpoints with actual business logic

The idea was mine. The problem was mine. The architecture was mine. The judgment calls were mine. AI just helped me move faster.

We Already Accept AI Tools — We Just Don't Call Them That

Here's what's funny: developers who criticize AI assistance use "AI tools" every single day without thinking twice.

IDE autocomplete — IntelliSense, Copilot suggestions, tab completion. That's AI finishing your sentences in code form.

Stack Overflow — You didn't invent that solution. Someone else did. You copy-pasted it. Is that cheating?

Documentation and tutorials — Nobody memorizes everything. We look things up constantly.

Linters and formatters — Tools that automatically improve your code quality without you thinking about it.

Google — Every time you search "how to do X in Y framework," you're outsourcing memory to a tool.

The only difference with modern AI is that it's more capable and more visible. The principle is exactly the same: use tools to move faster so you can focus on what actually requires your judgment.

Where the Line Actually Is

I want to be honest here — AI assistance can absolutely go wrong. There is a real version of "AI slop" that deserves criticism.

The line, as I see it:

You	AI
The idea	The boilerplate
The problem you're solving	The repetitive writing
The architecture decisions	The variable naming
The judgment calls	The formatting
The intent	The speed

If you use AI to generate an entire codebase you don't understand and ship it as your own without review — that's a problem. Not because you used AI, but because you shipped something you can't maintain or defend.

But if you use AI to move faster on work you fully understand and own? That's just being a smart developer.

The Irony of the Criticism

The person who called my post "AI slop" spent more time writing angry Reddit comments than I spent using AI to write the post.

Meanwhile I shipped 120+ API endpoints.

I'm not saying this to be dismissive. The criticism about post clarity was actually valid and I updated the post based on it. Feedback that helps you improve is valuable regardless of how it's delivered.

But the blanket "AI = bad" argument? That's not a technical opinion. That's a feeling. And feelings aren't a good reason to dismiss real work.

To Solo Developers Reading This

If you're building something alone, without a team, without funding, without someone to review your code or rubber duck debug with — use every tool available to you.

Use AI. Use Stack Overflow. Use documentation. Use every shortcut that lets you spend more time on the things only you can do: the thinking, the judgment, the problem identification, the architecture.

The goal is to ship something valuable. Not to prove you can suffer through building it the hardest possible way.

I open sourced ShopCore because I don't have the capital to launch it as a startup. Maybe someone will build on top of it. Maybe it'll help a developer somewhere skip months of backend work. Maybe it'll eventually reach the vendors it was designed for.

That outcome matters. The tools I used to get there don't.

ShopCore is open source at github.com/RecurPixel/ShopCore. Stars, issues, and PRs are very welcome.

If you're a developer building for the Indian market or interested in subscription-based delivery systems, I'd love to connect.

I Got Tired of Wiring Up Notifications From Scratch — So I Built a Library

RecurPixel — Tue, 24 Feb 2026 17:17:36 +0000

Every time I start a new project, there's always that moment.

The feature list is done, the architecture is clean, the database schema makes sense — and then someone says "we need to send notifications."

And just like that, the clean project gets messy.

The Problem I Kept Running Into

On one of my recent projects, I had to integrate:

SendGrid for transactional email
Twilio for SMS OTPs
FCM for Android push notifications
Slack for internal alerts
WhatsApp for order updates

Five different SDKs. Five different configuration patterns. Five different error handling styles. Five sets of retry logic written from scratch because each provider fails differently.

And the worst part? I'd solved this before. On a different project. With slightly different providers. And I'd have to solve it again on the next one.

There was no clean .NET library that handled all of this with a consistent interface. The SaaS options (Novu, Courier, Knock) meant sending user data to an external platform and paying per notification. FluentEmail only covers email. Everything else was either abandoned, Node.js only, or built for a single provider.

So I built one.

Introducing RecurPixel.Notify

A modular, DI-native notification library for ASP.NET Core.

No external platform. No account sign-up. No per-notification billing. Drop the NuGet package in, bring your own API keys, own your data completely.

dotnet add package RecurPixel.Notify.Sdk

One interface for everything:

// Send an email
await notify.Email.SendAsync(new NotificationPayload
{
    To      = user.Email,
    Subject = "Order Confirmed",
    Body    = emailHtml
});

// Send an SMS
await notify.Sms.SendAsync(new NotificationPayload
{
    To   = user.Phone,
    Body = $"Your OTP is {otp}. Valid for 5 minutes."
});

// Trigger a multi-channel event — email + SMS + push, in parallel
await notify.TriggerAsync("order.placed", new NotifyContext
{
    User     = notifyUser,
    Channels = new()
    {
        ["email"] = new() { Subject = "Order Confirmed", Body = emailHtml },
        ["sms"]   = new() { Body = $"Order #{order.Id} confirmed." },
        ["push"]  = new() { Subject = "Order Confirmed", Body = "Tap to view." }
    }
});

Swap SendGrid for Postmark? One config line. Switch from Twilio to Vonage? Same. Your application code never changes.

What's Supported Right Now (Beta)

The library just hit v0.1.0-beta.1 with 20+ adapters across 5 channel categories:

Channel	Providers
📧 Email	SendGrid, SMTP
💬 SMS	Twilio
🔔 Push	Firebase (FCM), Apple (APNs)
📱 WhatsApp	Twilio, Meta Cloud API
🤝 Team Chat	Slack, Discord, Microsoft Teams

And it's not just single sends. Providers with native batch APIs use them automatically:

// FCM multicast — 500 device tokens per API call under the hood
var result = await notify.Push.SendBulkAsync(devicePayloads);

Console.WriteLine($"{result.SuccessCount}/{result.Total} delivered");
foreach (var failure in result.Failures)
    logger.LogWarning("Failed: {Recipient} — {Error}", failure.Recipient, failure.Error);

Features I'm Proud Of

Retry with exponential backoff — configure globally or per event. Providers fail. The library handles it.

Cross-channel fallback chains — WhatsApp fails, try SMS, fail again, try email. All automatic.

Conditions — don't send SMS to unverified numbers, don't send push to users who opted out. Evaluated at runtime from your own data.

Parallel dispatch — multi-channel events fire all channels simultaneously via Task.WhenAll.

Delivery hooks — a single callback gives you every result. You write to your own log table in your own schema.

Named provider routing — route transactional email to Postmark, marketing email to AWS SES, from the same notify.Email.SendAsync call.

// Goes to Postmark
new NotificationPayload { ..., Metadata = new() { ["provider"] = "transactional" } }

// Goes to AWS SES
new NotificationPayload { ..., Metadata = new() { ["provider"] = "marketing" } }

Three Ways to Use It

The library is modular by design. Install only what you need.

Tier 1 — Single channel, no orchestrator:

dotnet add package RecurPixel.Notify.Email.SendGrid

Tier 2 — Core + Orchestrator + your providers:

dotnet add package RecurPixel.Notify.Core
dotnet add package RecurPixel.Notify.Orchestrator
dotnet add package RecurPixel.Notify.Email.SendGrid
dotnet add package RecurPixel.Notify.Sms.Twilio

Full event system, conditions, retry, fallback — only the providers you configure.

Tier 3 — Full SDK:

dotnet add package RecurPixel.Notify.Sdk

Everything pre-packaged. Configure what you use in appsettings.json. Everything else stays dormant.

What I'd Love to See You Build With It

This is the part that actually excites me.

A SaaS marketing platform — RecurPixel.Notify handles all the delivery mechanics. You focus on audience segmentation, templates, and scheduling. The multi-channel bulk send and delivery hooks give you everything you need to build a proper notification pipeline.

An open-source desktop notification app — imagine a cross-platform Electron/Avalonia app that lets non-technical users configure and send notifications across all these providers without writing a line of code. The library is already doing the hard part.

A self-hosted notification service — wrap it in a minimal API, add a queue, expose a REST endpoint. You now have your own private alternative to Courier or Novu with no external data dependency.

Internal developer tools — Slack + Teams + Discord alerts for deployments, errors, and monitoring, all wired through a single service with retry and fallback.

If you build something with it, I genuinely want to hear about it.

What's Coming Next

This is 0.1.0-beta.1 — the foundation is solid, the adapter pattern is proven, and the core features are all there. Here's what I'm building toward:

v0.2.0 — Telegram, Facebook Messenger, LINE, Viber, and the in-app inbox channel.

v0.3.0 — Remaining providers: Mailgun, Resend, Postmark, AWS SES, Vonage, Sinch, OneSignal, Expo Push. That takes the total to 27+ providers.

v1.0.0 — Stable API, full integration test coverage, community-approved adapters. This is the production-ready milestone.

Beyond that — performance profiling on large bulk sends, possible source generator for compile-time event validation, and who knows — maybe that open-source desktop app. Happy to explore it with anyone interested.

Try It, Break It, Tell Me

dotnet add package RecurPixel.Notify.Sdk --version 0.1.0-beta.1 --prerelease

This is a beta. Some adapters are thoroughly tested. Some are implemented but not yet integration-tested against real provider sandboxes. The architecture is solid — individual adapter bugs are absolutely possible and that's what beta is for.

If you hit an issue, open a GitHub issue. If something works beautifully, even better — let me know.

GitHub: github.com/recurpixel/notify

NuGet: nuget.org/packages/RecurPixel.Notify.Sdk

Docs: recurpixel.io/Notify/

Built because I got tired of writing the same notification wiring code on every project. Hope it saves you some of that time too.

Tags: #dotnet #aspnetcore #csharp #nuget #notifications #openSource #programming

How I Built My First .NET Package (and Got 500+ Downloads)

RecurPixel — Wed, 21 Jan 2026 07:46:23 +0000

The Problem That Wouldn't Go Away

Let me paint you a familiar picture. You're deep in code, building out your API endpoints, and you write:

return Ok("User created successfully");

Simple enough, right?

But then QA comes back: "Hey, the /users endpoint says 'User created' but the /products endpoint says 'Product added successfully'. Can we be consistent?"

So you fix it. Then another bug report: "The error message for duplicate emails is different from duplicate usernames."

You fix that too. Then: "Can we add status codes to all error messages?"

At this point, you've spent more time fixing inconsistent messages than actually building features. Sound familiar?

I got tired of this. Every project, same problem. Scattered messages, inconsistent formats, forgotten logging, missing correlation IDs. There had to be a better way.

The Simple Idea

It started with a simple thought: "Why not create a helper class with pre-defined messages?"

// Instead of this everywhere:
return BadRequest("User not found");
return Ok("Success");
return StatusCode(500, "Error occurred");

// What if I could just write:
return Msg.Crud.Created("User").ToApiResponse();
return Msg.Crud.NotFound("User").ToApiResponse();

Clean. Discoverable. Consistent.

I thought: "I'll whip this up in a weekend."

Narrator: He did not whip it up in a weekend.

Scope Creep (The Good Kind)

As I started gathering industry-standard messages, something happened. What began as "CRUD messages" kept expanding:

Week 1: CRUD messages (Create, Read, Update, Delete)

Msg.Crud.Created("User")
Msg.Crud.NotFound("Product")

Week 2: Validation messages

Msg.Validation.RequiredField("Email")
Msg.Validation.InvalidFormat("Phone")

Week 3: Authentication messages

Msg.Auth.LoginFailed()
Msg.Auth.SessionExpired()

By Week 4, I had 13 different message categories:

Msg.Auth.*         // Authentication
Msg.Crud.*         // CRUD operations
Msg.Validation.*   // Input validation
Msg.System.*       // System errors
Msg.Database.*     // Database errors
Msg.File.*         // File operations
Msg.Network.*      // Network issues
Msg.Payment.*      // Payment processing
Msg.Email.*        // Email operations
Msg.Search.*       // Search results
Msg.Import.*       // Import operations
Msg.Export.*       // Export operations
Msg.Custom(code)   // Your custom messages

I realized: This isn't just a helper class anymore. This is a library.

The Questions That Changed Everything

At this point, I had a decision to make. I could release what I had—a simple collection of messages—and call it done. Or I could ask harder questions:

Question 1: "Where will this actually be used?"

Console apps? Sure. But mostly? ASP.NET Core APIs.

That meant I needed:

Proper HTTP status codes (not just strings)
Integration with IActionResult
Support for Minimal APIs
JSON serialization

Question 2: "How will developers actually use it?"

They need IntelliSense. They need discoverability. They need fluent APIs:

return Msg.Crud.Created("User")
    .WithData(user)
    .WithMetadata("source", "API")
    .WithCorrelationId(traceId)
    .Log(_logger)
    .ToApiResponse();

Each method returns a new immutable instance. Chainable. Type-safe. Beautiful.

Question 3: "What about the output?"

APIs need JSON. Console apps need colored output. Legacy systems need XML. So:

var message = Msg.Crud.Created("User");

// Different outputs, same message
var json = message.ToJson();
var xml = message.ToXml();
message.ToConsole(useColors: true);
var result = message.ToApiResponse();

Question 4: "What about customization?"

Not everyone needs the same fields. Development needs verbose logging. Production needs minimal, privacy-safe responses:

// Development: Everything for debugging
builder.Services.AddEasyMessages(
    config, 
    EasyMessagesPresets.Development
);

// Production: Minimal, fast, private
builder.Services.AddEasyMessages(
    config, 
    EasyMessagesPresets.Production
);

The Architecture Emerged

Once I started asking these questions, the architecture fell into place:

1. Message Registry - Static, thread-safe storage of all message templates
2. Facades - Msg.Auth.*, Msg.Crud.* for discoverability
3. Fluent API - Chainable extension methods
4. Formatters - JSON, XML, Console, PlainText
5. Interceptors - Auto-add correlation IDs, log automatically
6. ASP.NET Core Integration - First-class DI and middleware support

The library structure became:

Core library: Message primitives, formatters, registry
AspNetCore library: DI, interceptors, presets

This kept it modular. Want just the core? Install one package. Need full ASP.NET Core integration? Install both.

The AI-Powered Testing Revolution

Here's where it got interesting. I had built this entire library, but writing tests? That's the boring part everyone hates.

Then I thought: "What if I use AI to help write tests?"

I fed Claude (yes, I integrated AI in my workflow) my code and said: "Write comprehensive tests for this."

The result? 108 tests across 9 test files:

Unit tests for all configuration classes
Integration tests for DI
Validation tests for all edge cases
Backward compatibility tests
Theory tests for multiple scenarios

The AI didn't just write tests—it found edge cases I hadn't considered:

"What if someone passes an empty locale string?"
"What if multiple validation errors occur?"
"What if the config file doesn't exist?"

I reviewed every test, fixed what needed fixing, and ended up with better test coverage than I would have written manually. And it took hours instead of days.

The Performance Obsession

Once the library worked, I obsessed over performance. Every allocation mattered. Every string operation counted.

Optimization 1: String Caching

Before:

message.Type.ToString().ToLowerInvariant() // Called every time

After:

private static readonly Dictionary<MessageType, string> Cache = new()
{
    [MessageType.Success] = "success",
    [MessageType.Error] = "error",
    // ...
};

Result: 5-10% throughput increase, 24 bytes saved per call.

Optimization 2: Smart Metadata Handling

Before:

// Always included, even when empty
Metadata = message.Metadata

After:

// Only include if non-empty
Metadata = message.Metadata?.Count > 0 ? message.Metadata : null

Result: Smaller JSON payloads, ~96 bytes saved per message.

Optimization 3: Conditional String Replacement

Before:

// Always replaced, even if placeholder doesn't exist
title = title.Replace(placeholder, value);

After:

// Only replace if placeholder exists
if (title.Contains(placeholder, StringComparison.OrdinalIgnoreCase))
{
    title = title.Replace(placeholder, value, StringComparison.OrdinalIgnoreCase);
}

Result: 10-15% faster for parameterized messages.

Combined Impact

Under load (10,000 requests/sec):

Before: ~2.1 MB/sec allocations
After: ~1.5 MB/sec allocations
Improvement: 28% reduction in GC pressure, 18-30% throughput increase

I documented every optimization in PERFORMANCE_OPTIMIZATIONS.md.

Make It Work, Make It Fast, Make It Clean

I followed this mantra religiously:

Phase 1: Make It Work

Build the core functionality. Get it working end-to-end. Don't optimize yet.

Duration: 2 weeks

Phase 2: Make It Fast

Profile. Benchmark. Optimize hot paths. Reduce allocations.

Duration: 1 week

Phase 3: Make It Clean

Refactor. Document. Write guides. Polish the API.

Duration: 2 weeks

Total: ~5 weeks from idea to v0.1.0-beta.1

The Documentation Philosophy

I wanted the docs to be amazing. Not just "here's the API reference" but actually helpful.

So I wrote:

15 comprehensive guides (30,000+ lines)
200+ working code examples
How-to guides for common scenarios
Troubleshooting sections for every feature
Architecture deep-dive for contributors

Every feature has:

What it is - Clear explanation
Why it exists - The problem it solves
How to use it - Working examples
When to use it - Best practices
When NOT to use it - Common pitfalls

Let me tell you a secret between you and me. Even though I documented all the process, code, architecture it was a mess so I decided to first gather all stuff and then make use of AI to organize it. You can checkout my repo to understand more. Yea, I am not a real dev but just an imposter like you no shame “Zehaha”

Example from the docs:

### [✓] DO:

Use facades instead of message codes:
// Good
Msg.Auth.LoginFailed()

// Bad
MessageRegistry.Get("AUTH_001")

### [❌] DON'T:

Don't expose sensitive data in production:
// Bad
return Msg.Auth.LoginFailed()
    .WithMetadata("password", password) // Security risk!

The Launch

I published v0.1.0-beta.1 to NuGet. No fanfare. No marketing. Just:

GitHub repo
Comprehensive docs
A Reddit post

Week 1: 50 downloads
Week 2: 150 downloads
Week 3: 300 downloads
Month 1: 500+ downloads

Not viral by any means, but actual developers using it in real projects. That felt amazing.

What I Learned

1. Scope Management Is Hard

What started as a weekend project became 5 weeks of work. But the expanded scope made it actually useful instead of just "neat."

2. AI Is a Superpower for Testing

I'm not embarrassed to say AI wrote most of my tests. I reviewed them all, but it saved me days of work and found edge cases I missed.

3. Performance Matters, Even for Libraries

Nobody wants a library that slows down their API. Every allocation counts. Profile. Optimize. Document.

4. Documentation Is Your Product

Code is for computers. Docs are for humans. I spent as much time on docs as code. Worth it.

5. Open Source Is Scary and Rewarding

Putting your code out there is terrifying. What if it's bad? What if no one uses it? What if someone finds a bug?

But then someone opens an issue. Someone submits a PR. Someone says "this solved my problem."

That's why we do this.

What's Next?

The library is in beta. It works. It's fast. It's documented.

What comes next depends on you.

If developers use it, I'll keep improving it:

More message codes based on feedback
Additional ASP.NET Core middleware
Better localization support
Performance benchmarks
More presets

But if no one uses it? That's okay too. I learned a ton. I built something I'm proud of. I contributed to the ecosystem.

Try It Yourself

dotnet add package RecurPixel.EasyMessages.AspNetCore --version 0.1.0-beta.1

Then in your API:

// Program.cs
builder.Services.AddEasyMessages(builder.Configuration);

// Controller
[HttpPost]
public IActionResult Create(CreateUserDto dto)
{
    if (!ModelState.IsValid)
        return Msg.Validation.Failed()
            .WithData(new { errors = ModelState })
            .ToApiResponse();

    var user = _service.Create(dto);

    return Msg.Crud.Created("User")
        .WithData(user)
        .Log(_logger)
        .ToCreated($"/api/users/{user.Id}");
}

That's it. Consistent messages. Automatic logging. Standard responses.

Final Thoughts

Building my first .NET package taught me:

Start simple, but ask hard questions
Scope creep can be good (if intentional)
AI is a tool, not a replacement
Performance matters
Docs are as important as code
Open source is scary but worth it

If you're thinking about building a library, just start. It won't be perfect. It might take longer than expected. But you'll learn more than any tutorial could teach you.

And who knows? Maybe your "weekend project" becomes something developers actually use.

What's your "simple idea that got complicated"? Let me know in the comments!

P.S. If you use EasyMessages and it helps you, ⭐ the repo on GitHub. It makes a huge difference for discoverability.

P.P.S. Found a bug? Open an issue. I promise I won't cry. (Much.)

🎯 DSA Master Learning Plan - Pattern by Pattern

RecurPixel — Sun, 07 Dec 2025 07:42:36 +0000

📖 My Story

Like many developers, I've been putting off learning DSA for months. The truth? I don't have endless hours to dedicate, and honestly, the traditional "solve 1000 problems" approach felt overwhelming.

So I did something different - I used AI to build a custom learning plan that fits MY schedule and learning style. This isn't another generic DSA roadmap. This is a stress-free, pattern-focused approach that prioritizes depth over breadth.

Important: I'm posting this publicly before I even start. Why? Because having this here means it'll be waiting for me whenever I'm ready to begin. Maybe it'll help you too.

🎨 How I Built This Plan

I spent time with Claude AI to:

Break down DSA into digestible patterns
Order them from foundational to advanced
Select 10-15 problems per pattern (not 100!)
Build in revision cycles so I don't forget
Make it flexible - no rigid daily schedules

The philosophy is simple: Master one pattern deeply before moving to the next.

My Philosophy: Master one pattern at a time. Solve 10+ problems per pattern before moving on.

Timeline: 1 year to become a DSA master (stress-free!)

Revision: Every fortnight, solve 2-3 problems from already mastered patterns

📚 Learning Order (Beginner → Advanced)

Phase 1: Foundation (Weeks 1-8)

Start here. These patterns build your fundamental problem-solving skills.

✅ Pattern 1: Array Basics

Goal: Understand array traversal, basic operations

Problems to Master: 10-12 problems

Core Concepts:

Index manipulation
In-place modifications
Frequency counting

Problem Set (Start with these):

217. Contains Duplicate - Easy warmup
169. Majority Element - Boyer-Moore voting
189. Rotate Array - Reversal technique
41. First Missing Positive - Index as hash
442. Find All Duplicates in an Array
448. Find All Numbers Disappeared in an Array
287. Find the Duplicate Number
243. Shortest Word Distance
849. Maximize Distance to Closest Person
384. Shuffle an Array - Fisher-Yates

C# Data Structures Used: int[], List<int>, HashSet<int>

✅ Pattern 2: Two Pointers - Same Direction

Goal: Learn to use two pointers moving in same direction

Problems to Master: 10-12 problems

Core Concepts:

Slow-fast pointer
Remove duplicates
In-place array modification

Problem Set:

283. Move Zeroes - Classic starter
27. Remove Element
26. Remove Duplicates from Sorted Array
80. Remove Duplicates from Sorted Array II
75. Sort Colors - Dutch National Flag
121. Best Time to Buy and Sell Stock
122. Best Time to Buy and Sell Stock II
31. Next Permutation
556. Next Greater Element III
165. Compare Version Numbers
1574. Shortest Subarray to be Removed to Make Array Sorted

C# Skills: Index manipulation, while loops with two indices

✅ Pattern 3: Two Pointers - Opposite Direction

Goal: Pointers moving from both ends toward center

Problems to Master: 10-12 problems

Core Concepts:

Left-right convergence
Palindrome checks
Two Sum variants

Problem Set:

125. Valid Palindrome - Start here
344. Reverse String
680. Valid Palindrome II
167. Two Sum II - Input Array Is Sorted
15. 3Sum - Important pattern
16. 3Sum Closest
18. 4Sum
977. Squares of a Sorted Array
11. Container With Most Water - Classic
42. Trapping Rain Water - Must master
5. Longest Palindromic Substring

Key Algorithm: Expand around center technique

✅ Pattern 4: Sliding Window - Fixed Size

Goal: Maintain a window of fixed size

Problems to Master: 6-8 problems

Core Concepts:

Add right, remove left
Running sum/count

Problem Set:

C# Data Structures: Queue<int>, Dictionary<char, int>

✅ Pattern 5: Sliding Window - Variable Size

Goal: Shrink/expand window based on condition

Problems to Master: 10-12 problems

Core Concepts:

While loop to shrink window
Expand on every iteration
Track min/max window

Problem Set:

This is THE most important pattern for interviews!

✅ Pattern 6: HashMap / HashSet

Goal: O(1) lookups for efficiency

Problems to Master: 12-15 problems

Core Concepts:

Frequency maps
Index storage
Set operations

Problem Set:

C# Data Structures: Dictionary<TKey, TValue>, HashSet<T>

Phase 2: Intermediate Patterns (Weeks 9-20)

✅ Pattern 7: Prefix Sum

Goal: Precompute cumulative sums for range queries

Problems to Master: 10-12 problems

Core Concepts:

Running sum array
Range sum = prefix[j] - prefix[i-1]
HashMap for subarray sums

Problem Set:

Key Technique: Use HashMap to store prefix sums

✅ Pattern 8: Stack / Queue

Goal: LIFO and FIFO operations

Problems to Master: 10-12 problems

Core Concepts:

Valid parentheses
Expression evaluation
Nested structures

Problem Set:

C# Data Structures: Stack<T>, Queue<T>

✅ Pattern 9: Monotonic Stack/Queue

Goal: Maintain increasing/decreasing order

Problems to Master: 8-10 problems

Core Concepts:

Next greater/smaller element
Maintain stack invariant
O(n) solutions

Problem Set:

This pattern is a game-changer for optimization!

✅ Pattern 10: Binary Search

Goal: O(log n) search in sorted spaces

Problems to Master: 12-15 problems

Core Concepts:

Template: while (left <= right)
Binary search on answer
Rotated arrays

Problem Set:

704. Binary Search - Template
35. Search Insert Position
34. Find First and Last Position of Element in Sorted Array
74. Search a 2D Matrix
33. Search in Rotated Sorted Array
153. Find Minimum in Rotated Sorted Array
162. Find Peak Element
278. First Bad Version
875. Koko Eating Bananas - Binary search on answer
1011. Capacity To Ship Packages Within D Days
4. Median of Two Sorted Arrays - Hard
981. Time Based Key-Value Store

Learn the template pattern FIRST!

✅ Pattern 11: Intervals / Line Sweep

Goal: Merge, intersect, and manage intervals

Problems to Master: 10-12 problems

Core Concepts:

Sort by start time
Merge overlapping intervals
Event-based processing

Problem Set:

252. Meeting Rooms - Easy start
56. Merge Intervals - Must know
57. Insert Interval
435. Non-overlapping Intervals
986. Interval List Intersections
253. Meeting Rooms II - Use heap
452. Minimum Number of Arrows to Burst Balloons
1288. Remove Covered Intervals
1229. Meeting Scheduler
1272. Remove Interval

C# Technique: Sort with custom comparator: Array.Sort(intervals, (a, b) => a[0].CompareTo(b[0]))

Phase 3: Advanced Patterns (Weeks 21-35)

✅ Pattern 12: Linked List

Goal: Master pointer manipulation

Problems to Master: 12-15 problems

Core Concepts:

Dummy node technique
Fast-slow pointers
Reversal

Problem Set:

C# Note: Use LinkedListNode<T> or create custom ListNode class

✅ Pattern 13: Tree Traversals (DFS)

Goal: Preorder, Inorder, Postorder

Problems to Master: 15-20 problems

Core Concepts:

Recursive vs iterative
When to process node (pre/in/post)
Divide and conquer

Problem Set (Preorder):

Problem Set (Inorder):

Problem Set (Postorder):

Problem Set (Divide & Conquer):

Master tree recursion - it's everywhere!

✅ Pattern 14: Tree BFS (Level Order)

Goal: Process trees level by level

Problems to Master: 8-10 problems

Core Concepts:

Queue-based traversal
Track level size
Right side view

Problem Set:

✅ Pattern 15: Heap / Priority Queue

Goal: Top K, merge K, sliding window median

Problems to Master: 10-12 problems

Core Concepts:

Min heap / Max heap
Maintain top K elements
Two heaps technique

Problem Set:

C# Data Structure: PriorityQueue<TElement, TPriority> (.NET 6+)

✅ Pattern 16: Recursion & Backtracking

Goal: Generate all possibilities

Problems to Master: 12-15 problems

Core Concepts:

Decision tree
Choose → Explore → Unchoose
Base case

Problem Set (coming from repo - will extract from [J]recursion section)

Focus on: Subsets, Permutations, Combinations, N-Queens, Sudoku Solver

This is the most challenging pattern - take your time!

Phase 4: Expert Level (Weeks 36-52)

✅ Pattern 17: Dynamic Programming

Goal: Optimize recursive solutions

Problems to Master: 20+ problems (this is huge!)

Sub-patterns:

1D DP (Climbing stairs, House Robber)
2D DP (Grid paths, LCS, Edit Distance)
Knapsack variants
DP on strings

Dedicate 2-3 months to this pattern alone!

✅ Pattern 18: Graph (BFS/DFS)

Goal: Traverse graphs, find paths

Problems to Master: 15+ problems

Core Concepts:

Adjacency list representation
Visited set
Connected components
Cycle detection

✅ Pattern 19: Trie

Goal: Prefix-based operations

Problems to Master: 8-10 problems

✅ Pattern 20: Union Find

Goal: Connected components, cycle detection

Problems to Master: 8-10 problems

🔄 Biweekly Revision Schedule

Every 2 weeks, solve:

2 problems from oldest mastered pattern
1 problem from second oldest mastered pattern

Example (Week 10):

You've mastered: Array Basics, Two Pointers (Same), Two Pointers (Opposite)
This weekend: Solve 2 Array problems + 1 Two Pointer (Same) problem

🎯 Success Metrics

After 1 year:

✅ Mastered 15-18 core patterns
✅ Solved 300-400 problems total
✅ Can identify pattern in 80% of new problems
✅ Confident in Medium problems, can attempt Hard
✅ Ready for any coding interview

💡 Pro Tips

Don't rush - 10 problems per pattern minimum
Understand, don't memorize - Can you explain the approach?
Code in C# without looking - True mastery test
Time yourself - 30 min for Easy, 45 for Medium
Review mistakes - Keep a "mistakes journal"
Teach someone - Best way to solidify learning

🤝 Join Me on This Journey

I haven't started yet, but I will. And when I do, I'll update this post with:

My progress updates
Problems that really helped me "click"
Pitfalls to avoid
Time estimates for each pattern

If you're using this plan, drop a comment! Let's learn together.

🙏 Credits

This plan was created with assistance from Claude AI. I provided my constraints (limited time, need for structure, C# preference), and together we crafted something that actually feels doable.

The lesson? Don't be afraid to use AI as your learning companion. It won't solve problems for you, but it can help you create a roadmap that respects your reality.

Tags: #dsa #datastructures #algorithms #leetcode #learning #csharp #career

Bookmark this if you're also planning to start "someday" 📚✨

A C# File I/O Quick Reference For professionals

RecurPixel — Wed, 26 Nov 2025 07:13:49 +0000

This C# File I/O Quick Reference Guide explores the core classes for handling files and directories.
Learn the difference between static utility classes (like File and Directory for simple, one-time operations) and instance classes (like FileInfoand DirectoryInfofor object-oriented access and metadata). The guide also covers Stream classes (StreamReader, StreamWriter, FileStream, etc.) for efficient data handling, along with utilities for path manipulation (Path) and monitoring (FileSystemWatcher).
Discover best practices and when to use each class for maximum performance.

File (Static Class)

What it is: Static utility class for quick file operations without creating objects.

Use: Best for simple, one-time file operations.

Key Methods

ReadAllText(path) - Read entire file as string
WriteAllText(path, content) - Write string to file (overwrites)
AppendAllText(path, content) - Add text to end of file
ReadAllLines(path) - Read file as string array (line by line)
WriteAllLines(path, lines) - Write array of strings as lines
ReadAllBytes(path) - Read file as byte array
WriteAllBytes(path, bytes) - Write byte array to file
Copy(source, dest) - Copy file to new location
Move(source, dest) - Move/rename file
Delete(path) - Delete file
Exists(path) - Check if file exists
Create(path) - Create new file (returns FileStream)

FileInfo (Instance Class)

What it is: Object-oriented approach to file operations with metadata.

Use: When you need file properties or multiple operations on same file.

Key Properties

Name - File name with extension
FullName - Complete path
Extension - File extension (e.g., ".txt")
DirectoryName - Parent directory path
Directory - Parent DirectoryInfo object
Length - File size in bytes
CreationTime - When file was created
LastWriteTime - When last modified
LastAccessTime - When last accessed
Exists - Boolean if file exists
IsReadOnly - Boolean if read-only

Key Methods

Create() - Create file (returns FileStream)
Open(FileMode) - Open with specified mode
OpenRead() - Open for reading
OpenWrite() - Open for writing
Delete() - Delete file
CopyTo(dest) - Copy to destination
MoveTo(dest) - Move to destination
Refresh() - Update cached info

Directory (Static Class)

What it is: Static utility for directory operations.

Use: Quick directory tasks without creating objects.

Key Methods

Exists(path) - Check if directory exists
Create(path) - Create directory (creates parent dirs too)
Delete(path, recursive) - Delete directory
Move(source, dest) - Move/rename directory
GetFiles(path) - Get file paths in directory
GetFiles(path, pattern) - Get matching files (e.g., "*.txt")
GetDirectories(path) - Get subdirectory paths
GetFileSystemEntries(path) - Get both files and dirs
GetCurrentDirectory() - Get current working directory
SetCurrentDirectory(path) - Change working directory
GetParent(path) - Get parent directory info
EnumerateFiles(path) - Lazy enumeration of files (memory efficient)

DirectoryInfo (Instance Class)

What it is: Object-oriented directory operations with metadata.

Use: When you need directory properties or multiple operations.

Key Properties

Name - Directory name
FullName - Complete path
Parent - Parent DirectoryInfo object
Root - Root DirectoryInfo (e.g., C:)
Exists - Boolean if directory exists
CreationTime - When created
LastWriteTime - When last modified
LastAccessTime - When last accessed

Key Methods

Create() - Create directory
CreateSubdirectory(name) - Create subdirectory
Delete() / Delete(recursive) - Delete directory
MoveTo(dest) - Move directory
GetFiles() - Get FileInfo array
GetFiles(pattern) - Get matching FileInfo objects
GetDirectories() - Get subdirectory array
GetFileSystemInfos() - Get both files and dirs
EnumerateFiles() - Lazy enumeration

StreamReader

What it is: Reads text files efficiently line-by-line or character-by-character.

Use: Reading large text files without loading entire file into memory.

Key Properties

EndOfStream - Boolean if reached end of file

Key Methods

Read() - Read single character (returns int, -1 at end)
ReadLine() - Read one line as string (null at end)
ReadToEnd() - Read rest of file as string
ReadBlock(buffer, index, count) - Read into char array
Close() - Close stream
Dispose() - Release resources (use with using)

Usage Example

using (StreamReader sr = new StreamReader("file.txt"))
{
    while (!sr.EndOfStream)
    {
        string line = sr.ReadLine();
    }
}

StreamWriter

What it is: Writes text to files efficiently.

Use: Writing large amounts of text incrementally.

Key Properties

AutoFlush - Boolean, if true writes immediately (default false)

Key Methods

Write(value) - Write without newline
WriteLine(value) - Write with newline
Flush() - Force write buffered data to file
Close() - Close stream
Dispose() - Release resources

Usage Example

using (StreamWriter sw = new StreamWriter("file.txt"))
{
    sw.WriteLine("First line");
    sw.WriteLine("Second line");
}

BinaryReader

What it is: Reads primitive data types in binary format.

Use: Reading binary files or serialized data.

Key Methods

ReadBoolean() - Read bool
ReadByte() - Read single byte
ReadBytes(count) - Read byte array
ReadInt32() - Read 4-byte integer
ReadInt64() - Read 8-byte long
ReadDouble() - Read 8-byte double
ReadString() - Read length-prefixed string
ReadChar() - Read single character
Close() / Dispose() - Release resources

BinaryWriter

What it is: Writes primitive data types in binary format.

Use: Writing binary data or serialization.

Key Methods

Write(bool) - Write boolean
Write(byte) - Write single byte
Write(byte[]) - Write byte array
Write(int) - Write 4-byte integer
Write(long) - Write 8-byte long
Write(double) - Write 8-byte double
Write(string) - Write length-prefixed string
Flush() - Force write buffered data
Close() / Dispose() - Release resources

FileStream

What it is: Low-level stream for reading/writing bytes to files.

Use: Maximum control over file operations, binary data, or as base for other streams.

Key Properties

Length - File size in bytes
Position - Current position in stream
CanRead - Boolean if can read
CanWrite - Boolean if can write
CanSeek - Boolean if can seek (change position)

Key Methods

Read(buffer, offset, count) - Read bytes into array
Write(buffer, offset, count) - Write bytes from array
ReadByte() - Read single byte
WriteByte(byte) - Write single byte
Seek(offset, origin) - Change position in stream
Flush() - Write buffered data to disk
SetLength(length) - Truncate or extend file
Close() / Dispose() - Release resources

Constructor

FileStream fs = new FileStream(path, FileMode, FileAccess, FileShare);

FileMode (Enum)

What it is: Specifies how to open a file.

Use: Pass to FileStream constructor or File.Open().

Values

CreateNew - Create new file (error if exists)
Create - Create new file (overwrites if exists)
Open - Open existing file (error if doesn't exist)
OpenOrCreate - Open if exists, create if doesn't
Truncate - Open and clear contents (error if doesn't exist)
Append - Open and seek to end (creates if doesn't exist)

FileAccess (Enum)

What it is: Defines read/write permissions.

Use: Control access level when opening files.

Values

Read - Read-only access
Write - Write-only access
ReadWrite - Both read and write

FileShare (Enum)

What it is: Controls how other processes can access the file while you have it open.

Use: Allow/prevent concurrent access.

Values

None - No sharing (exclusive access)
Read - Others can read
Write - Others can write
ReadWrite - Others can read and write
Delete - Others can delete
Inheritable - Handle can be inherited by child processes

BufferedStream

What it is: Wraps another stream to add buffering for better performance.

Use: Improve performance when doing many small reads/writes.

Key Methods

Read(buffer, offset, count) - Read bytes
Write(buffer, offset, count) - Write bytes
Flush() - Write buffer to underlying stream
Close() / Dispose() - Release resources

Usage Example

using (FileStream fs = new FileStream("file.bin", FileMode.Open))
using (BufferedStream bs = new BufferedStream(fs))
{
    // Faster reads/writes due to buffering
}

DriveInfo (Instance Class)

What it is: Information about disk drives.

Use: Get drive capacity, type, and availability.

Key Properties

Name - Drive letter (e.g., "C:\")
DriveType - Type (Fixed, Removable, Network, CDRom, etc.)
DriveFormat - File system (e.g., "NTFS", "FAT32")
TotalSize - Total space in bytes
TotalFreeSpace - Available free space in bytes
AvailableFreeSpace - Free space available to current user
VolumeLabel - Drive label (can be set)
IsReady - Boolean if drive is ready/available
RootDirectory - Root DirectoryInfo

Static Method

GetDrives() - Returns array of all drives

Usage Example

DriveInfo[] drives = DriveInfo.GetDrives();
foreach (DriveInfo d in drives)
{
    if (d.IsReady)
        Console.WriteLine($"{d.Name}: {d.TotalFreeSpace} bytes free");
}

MemoryStream

What it is: Stream that uses memory (RAM) instead of a file.

Use: In-memory buffer for temporary data or converting between streams and byte arrays.

Key Properties

Length - Number of bytes
Capacity - Allocated memory size
Position - Current position

Key Methods

Read(buffer, offset, count) - Read bytes
Write(buffer, offset, count) - Write bytes
ToArray() - Get contents as byte array
WriteTo(stream) - Copy to another stream
GetBuffer() - Get underlying byte array (faster but unsafe)
SetLength(length) - Change length
Close() / Dispose() - Release resources

Usage Example

using (MemoryStream ms = new MemoryStream())
{
    byte[] data = { 1, 2, 3, 4 };
    ms.Write(data, 0, data.Length);
    byte[] result = ms.ToArray();
}

Path (Static Class)

What it is: Utility for working with file and directory path strings.

Use: Safely combine, parse, and manipulate paths.

Key Methods

Combine(path1, path2) - Join paths with correct separator
GetFileName(path) - Get file name with extension
GetFileNameWithoutExtension(path) - Get file name only
GetExtension(path) - Get extension (e.g., ".txt")
GetDirectoryName(path) - Get directory portion
GetFullPath(path) - Convert relative to absolute path
GetPathRoot(path) - Get root (e.g., "C:\")
GetTempPath() - Get system temp directory
GetTempFileName() - Create unique temp file name
GetRandomFileName() - Generate random file name
HasExtension(path) - Check if path has extension
IsPathRooted(path) - Check if absolute path
ChangeExtension(path, ext) - Replace extension

Key Fields

DirectorySeparatorChar - '\' on Windows, '/' on Unix
AltDirectorySeparatorChar - Alternate separator
PathSeparator - ';' on Windows, ':' on Unix (for PATH env variable)

StringReader

What it is: Reads from a string as if it were a stream.

Use: Parse strings line-by-line using stream methods.

Key Methods

Read() - Read single character
ReadLine() - Read line from string
ReadToEnd() - Read rest of string
Close() / Dispose() - Release resources

Usage Example

string data = "Line 1\nLine 2\nLine 3";
using (StringReader sr = new StringReader(data))
{
    string line;
    while ((line = sr.ReadLine()) != null)
    {
        Console.WriteLine(line);
    }
}

StringWriter

What it is: Writes to a StringBuilder as if it were a stream.

Use: Build strings using stream writing methods.

Key Methods

Write(value) - Write without newline
WriteLine(value) - Write with newline
ToString() - Get resulting string
Close() / Dispose() - Release resources

Usage Example

using (StringWriter sw = new StringWriter())
{
    sw.WriteLine("Line 1");
    sw.WriteLine("Line 2");
    string result = sw.ToString();
}

Additional Important Classes

FileSystemWatcher

What it is: Monitors file system for changes.

Use: Detect when files/directories are created, changed, renamed, or deleted.

Key Properties

Path - Directory to watch
Filter - File filter (e.g., "*.txt")
NotifyFilter - What changes to watch (FileName, Size, LastWrite, etc.)
IncludeSubdirectories - Watch subdirectories too
EnableRaisingEvents - Start/stop watching

Key Events

Created - File/directory created
Changed - File/directory changed
Deleted - File/directory deleted
Renamed - File/directory renamed
Error - Error occurred

StreamReader/StreamWriter with Encoding

Tip: Both classes support encoding for different character sets.

// UTF-8 with BOM
new StreamReader("file.txt", Encoding.UTF8);

// ASCII
new StreamWriter("file.txt", false, Encoding.ASCII);

Quick Comparison Guide

File vs FileInfo

File: Static, one-liner operations, no object creation
FileInfo: Instance-based, reusable, has properties, better for multiple ops

Directory vs DirectoryInfo

Directory: Static, quick operations
DirectoryInfo: Instance-based, has properties, better for multiple ops

When to Use What

Simple text read/write: File.ReadAllText() / File.WriteAllText()
Large text files line-by-line: StreamReader / StreamWriter
Binary data: BinaryReader / BinaryWriter
Maximum control: FileStream
In-memory data: MemoryStream
String parsing: StringReader / StringWriter
Performance for small ops: BufferedStream
Path manipulation: Path class
File monitoring: FileSystemWatcher

Best Practices

Always use using statements for streams to ensure proper disposal
Use Path.Combine() instead of string concatenation
Check File.Exists() or Directory.Exists() before operations
Handle exceptions (IOException, UnauthorizedAccessException, etc.)
Use async methods (.NET 4.5+) for better performance: ReadAsync(), WriteAsync()
StreamReader/Writer for text, BinaryReader/Writer for binary
Prefer File/Directory static methods for simple operations
Use FileInfo/DirectoryInfo when you need properties or multiple operations

A No-Nonsense C# Async, Threading & Concurrency Guide

RecurPixel — Tue, 25 Nov 2025 08:19:33 +0000

Master modern C# concurrency by understanding the differences between Concurrency (overlapping time periods) and Parallelism (simultaneous execution on multiple cores).
Learn to leverage the Task-based Asynchronous Pattern (TAP) with async/await for non-blocking I/O-bound work, and use the Parallel class and PLINQ for CPU-bound computations.
The guide also details thread safety with lock, Interlocked, and Concurrent Collections, and explores advanced topics like CancellationTokenand Async Streams (IAsyncEnumerable), complete with best practices and common pitfalls.

🎯 The Big Picture: How Everything Connects

┌─────────────────────────────────────────────────────────┐
│                    CONCURRENCY                          │
│  (Doing multiple things in overlapping time periods)    │
│                                                         │
│  ┌──────────────────────┐  ┌──────────────────────┐     │
│  │  PARALLELISM         │  │  ASYNCHRONOUS        │     │
│  │  (True simultaneous  │  │  (Non-blocking,      │     │
│  │   execution on       │  │   waiting without    │     │
│  │   multiple cores)    │  │   blocking threads)  │     │
│  │                      │  │                      │     │
│  │  • Parallel class    │  │  • async/await       │     │
│  │  • PLINQ             │  │  • Task (I/O bound)  │     │
│  │  • Task (CPU bound)  │  │  • TAP pattern       │     │
│  └──────────────────────┘  └──────────────────────┘     │
│                                                         │
│              BOTH Built on: Thread & Task               │
└─────────────────────────────────────────────────────────┘

Key Relationships

Thread: OS-level execution unit (expensive, limited)
Task: High-level abstraction over threads (cheap, efficient)
async/await: Language feature to write asynchronous code that looks synchronous
Parallel: For CPU-intensive work across multiple cores
Concurrency: Umbrella term for all of the above

📚 Core Concepts Explained

Synchronous vs Asynchronous

Synchronous: Code executes line-by-line, blocking until each operation completes.

string data = DownloadData(); // Waits here, blocks thread
ProcessData(data);

Asynchronous: Code can continue without waiting for operation to complete.

Task<string> dataTask = DownloadDataAsync(); // Starts and returns immediately
// Do other work here
string data = await dataTask; // Wait only when you need the result
ProcessData(data);

Blocking vs Non-Blocking

Blocking: Thread sits idle, waiting for operation (wasteful).

Example: Thread.Sleep(), Task.Wait(), Task.Result

Non-Blocking: Thread is released to do other work while waiting.

Example: await, ContinueWith()

CPU-Bound vs I/O-Bound

CPU-Bound: Work that requires computation (math, processing, encryption).

Use: Task.Run(), Parallel.For(), multi-threading

I/O-Bound: Work that waits for external resources (file, network, database).

Use: async/await, asynchronous methods

Thread (Legacy Approach)

What it is: Low-level OS thread for executing code concurrently.

Use: Legacy code or when you need absolute control (rare in modern C#).

Modern alternative: Use Task instead.

Key Properties

IsAlive - Boolean if thread is running
IsBackground - If true, doesn't prevent app from terminating
Name - Thread name for debugging
Priority - ThreadPriority enum (Lowest to Highest)
ThreadState - Current state (Running, Stopped, etc.)
ManagedThreadId - Unique ID

Key Methods

Start() - Begin execution
Join() - Block until thread completes
Join(timeout) - Wait with timeout
Abort() - ⚠️ DEPRECATED: Force stop (dangerous!)
Sleep(ms) - Pause current thread
Interrupt() - Interrupt waiting thread

Static Methods

Thread.CurrentThread - Get current thread
Thread.Sleep(ms) - Pause current thread
Thread.Yield() - Give up CPU to other threads

Example (Legacy)

Thread thread = new Thread(() => {
    Console.WriteLine("Running in background");
});
thread.IsBackground = true;
thread.Start();
thread.Join(); // Wait for completion

⚠️ Problems with Threads

Expensive (1MB stack per thread)
Limited number available
Hard to manage
No easy way to get return values
No built-in error handling

Task (Modern Approach)

What it is: High-level abstraction representing an asynchronous operation.

Use: Default choice for all async/concurrent work in modern C#.

Benefit: Lightweight, composable, better error handling, works with async/await.

Key Properties

Status - Current state (Running, RanToCompletion, Faulted, Canceled)
IsCompleted - Boolean if finished (success, fault, or cancel)
IsCompletedSuccessfully - Boolean if finished successfully
IsFaulted - Boolean if threw exception
IsCanceled - Boolean if was canceled
Exception - AggregateException if faulted
Result - Return value (⚠️ blocks until complete)
Id - Unique identifier

Key Methods

Wait() - ⚠️ Block until complete (avoid, use await)
Wait(timeout) - Block with timeout
ContinueWith(action) - Chain another task
GetAwaiter() - Get awaiter (used by await keyword)
ConfigureAwait(false) - Don't capture context

Static Methods

Task.Run(action) - Run code on thread pool
Task.Delay(ms) - Async delay (like async Sleep)
Task.WhenAll(tasks) - Wait for all tasks
Task.WhenAny(tasks) - Wait for first task
Task.FromResult(value) - Create completed task
Task.FromException(ex) - Create faulted task
Task.FromCanceled(token) - Create canceled task
Task.CompletedTask - Pre-completed task

Task vs Task<T>

Task - No return value (like void)
Task<T> - Returns value of type T

Example

// Start CPU-bound work
Task<int> task = Task.Run(() => {
    // Heavy computation
    return 42;
});

// Do other work...

// Get result when needed
int result = await task;

async / await (The Game Changer)

What it is: C# language keywords that make asynchronous code look synchronous.

Use: Any I/O-bound operation (file, network, database).

Benefit: Non-blocking, easy to read, automatic error handling.

Rules & Syntax

// Method signature
public async Task<string> DownloadDataAsync()
{
    string data = await httpClient.GetStringAsync(url);
    return data; // Returns Task<string> automatically
}

// Calling async method
string result = await DownloadDataAsync();

Key Rules

Methods with await must be marked async
Async methods should return Task or Task<T> (or ValueTask<T>)
By convention, name async methods with "Async" suffix
Cannot use await in:
- Synchronous methods
- catch/finally blocks (pre-C# 6)
- Lock statements
- Unsafe code

Return Types

Task - Async method with no return value
Task<T> - Async method returning T
ValueTask<T> - Performance optimization (avoid allocations)
void - ⚠️ Only for event handlers (no error handling!)
IAsyncEnumerable<T> - Async streams (C# 8.0+)

Example: Async vs Sync

// ❌ Synchronous (blocks thread)
public string GetData()
{
    Thread.Sleep(1000); // Thread sits idle
    return "data";
}

// ✅ Asynchronous (releases thread)
public async Task<string> GetDataAsync()
{
    await Task.Delay(1000); // Thread does other work
    return "data";
}

ConfigureAwait

// Capture context (default) - for UI apps
await SomeMethodAsync();

// Don't capture context - for libraries, better performance
await SomeMethodAsync().ConfigureAwait(false);

TAP (Task-based Asynchronous Pattern) ⭐ Modern Standard

What it is: The recommended pattern for async programming in .NET.

Use: All new asynchronous APIs should follow this pattern.

TAP Rules

Method returns Task or Task<T>
Method name ends with "Async"
Method should have an overload accepting CancellationToken
Should be truly asynchronous (not just wrapping sync code)

Example

public async Task<string> ReadFileAsync(string path, 
    CancellationToken cancellationToken = default)
{
    using (StreamReader reader = new StreamReader(path))
    {
        return await reader.ReadToEndAsync(cancellationToken);
    }
}

TAP vs Other Patterns

Pattern	Era	Example
TAP ⭐	Modern (.NET 4.5+)	`Task<T> MethodAsync()`
APM	Legacy (.NET 1.0)	`IAsyncResult BeginMethod()` + `EndMethod()`
EAP	Legacy (.NET 2.0)	`MethodAsync()` + `MethodCompleted` event

Always use TAP for new code.

Parallel Programming (CPU-Bound Work)

What it is: Execute CPU-intensive work across multiple cores simultaneously.

Use: When you have work that can be divided and processed independently.

Don't use for: I/O-bound work (use async/await instead).

Parallel Class

What it is: Static class for parallel loops and invocations.

Use: Process collections in parallel.

Key Methods

Parallel.For(from, to, action) - Parallel for loop
Parallel.ForEach(collection, action) - Parallel foreach
Parallel.Invoke(actions) - Execute multiple actions in parallel

Example

// Sequential (slow)
for (int i = 0; i < 1000; i++)
{
    ProcessItem(i);
}

// Parallel (fast)
Parallel.For(0, 1000, i => {
    ProcessItem(i);
});

// Parallel ForEach
Parallel.ForEach(items, item => {
    ProcessItem(item);
});

// Execute multiple methods in parallel
Parallel.Invoke(
    () => Method1(),
    () => Method2(),
    () => Method3()
);

ParallelOptions

var options = new ParallelOptions
{
    MaxDegreeOfParallelism = 4, // Limit to 4 threads
    CancellationToken = cancellationToken
};

Parallel.ForEach(items, options, item => {
    ProcessItem(item);
});

PLINQ (Parallel LINQ)

What it is: Parallel version of LINQ for query processing.

Use: Parallelize LINQ queries on large datasets.

Key Methods

.AsParallel() - Convert to parallel query
.AsOrdered() - Maintain order (slower)
.WithDegreeOfParallelism(n) - Limit parallelism
.WithCancellation(token) - Enable cancellation
.ForAll(action) - Parallel action on results

Example

// Sequential LINQ
var results = items
    .Where(x => x.IsValid)
    .Select(x => ProcessItem(x))
    .ToList();

// Parallel LINQ
var results = items
    .AsParallel()
    .Where(x => x.IsValid)
    .Select(x => ProcessItem(x))
    .ToList();

// With options
var results = items
    .AsParallel()
    .WithDegreeOfParallelism(4)
    .WithCancellation(cancellationToken)
    .Where(x => x.IsValid)
    .Select(x => ProcessItem(x))
    .ToList();

Partitioner

What it is: Controls how work is divided among threads.

Use: Optimize parallel performance for specific scenarios.

var partitioner = Partitioner.Create(0, items.Length, 100);
Parallel.ForEach(partitioner, range => {
    for (int i = range.Item1; i < range.Item2; i++)
    {
        ProcessItem(items[i]);
    }
});

CancellationToken & CancellationTokenSource

What it is: Cooperative cancellation mechanism for async operations.

Use: Allow users to cancel long-running operations.

CancellationTokenSource

What it is: Creates and controls cancellation tokens.

Key Properties

Token - Get CancellationToken
IsCancellationRequested - Boolean if cancellation requested

Key Methods

Cancel() - Request cancellation
CancelAfter(ms) - Auto-cancel after timeout
Dispose() - Release resources

CancellationToken

What it is: Token passed to async methods to check for cancellation.

Key Properties

IsCancellationRequested - Boolean if canceled
CanBeCanceled - Boolean if can be canceled

Key Methods

ThrowIfCancellationRequested() - Throw if canceled
Register(callback) - Execute callback on cancellation

Example

CancellationTokenSource cts = new CancellationTokenSource();

// Pass token to async method
Task task = LongRunningOperationAsync(cts.Token);

// Cancel after 5 seconds
cts.CancelAfter(5000);

// Or cancel immediately
// cts.Cancel();

try
{
    await task;
}
catch (OperationCanceledException)
{
    Console.WriteLine("Operation canceled");
}

// In the async method
async Task LongRunningOperationAsync(CancellationToken token)
{
    for (int i = 0; i < 1000; i++)
    {
        token.ThrowIfCancellationRequested();
        await Task.Delay(100, token);
    }
}

ThreadPool

What it is: Managed pool of worker threads reused for tasks.

Use: Understanding what's under the hood (Task uses this internally).

Direct use: Rarely needed in modern C#.

Key Static Methods

QueueUserWorkItem(callback) - Queue work
GetMaxThreads(out worker, out io) - Get thread limits
SetMaxThreads(worker, io) - Set thread limits
GetAvailableThreads(out worker, out io) - Get available threads

Example (Legacy)

// Legacy approach
ThreadPool.QueueUserWorkItem(state => {
    Console.WriteLine("Work item");
});

// Modern approach (same thing)
Task.Run(() => {
    Console.WriteLine("Work item");
});

SynchronizationContext

What it is: Abstraction for scheduling work back to original context (UI thread).

Use: Understanding how async/await works with UI frameworks.

Direct use: Rare, handled automatically by async/await.

Key Scenarios

UI apps (WPF, WinForms): Await resumes on UI thread
ASP.NET (legacy): Await resumes on request context
ASP.NET Core: No context (better performance)
Console apps: No context

ConfigureAwait Explained

// Capture context (default)
await SomeMethodAsync(); // Resumes on original context (UI thread)

// Don't capture context
await SomeMethodAsync().ConfigureAwait(false); // Can resume on any thread

Rule of thumb:

UI code: Use default (capture context)
Library code: Use ConfigureAwait(false) (better performance)

Event-Driven Programming

What it is: Respond to events/notifications rather than polling.

Use: UI interactions, file system monitoring, message queues.

Events and Delegates

Delegate

public delegate void NotificationHandler(string message);

Event

public class Publisher
{
    public event NotificationHandler OnNotification;

    public void Notify(string message)
    {
        OnNotification?.Invoke(message);
    }
}

// Usage
Publisher pub = new Publisher();
pub.OnNotification += (msg) => Console.WriteLine(msg);
pub.Notify("Hello!");

Async Event Handlers

public event Func<string, Task> OnNotificationAsync;

public async Task NotifyAsync(string message)
{
    if (OnNotificationAsync != null)
    {
        await OnNotificationAsync(message);
    }
}

// Usage
pub.OnNotificationAsync += async (msg) => {
    await Task.Delay(100);
    Console.WriteLine(msg);
};

Built-in Event Pattern

public class Publisher
{
    public event EventHandler<MessageEventArgs> MessageReceived;

    protected virtual void OnMessageReceived(MessageEventArgs e)
    {
        MessageReceived?.Invoke(this, e);
    }
}

public class MessageEventArgs : EventArgs
{
    public string Message { get; set; }
}

Thread Safety & Synchronization

The Problem: Race Conditions

int counter = 0;

// ❌ NOT thread-safe
Parallel.For(0, 1000, i => {
    counter++; // Race condition!
});

Solution 1: lock (Monitor)

What it is: Ensures only one thread can execute code block at a time.

Use: Protect shared state in multi-threaded code.

object lockObj = new object();
int counter = 0;

Parallel.For(0, 1000, i => {
    lock (lockObj)
    {
        counter++; // Safe
    }
});

Key Points

Lock on private object, never public
Keep locked sections small
Never lock on this, typeof(MyClass), or strings
Can cause deadlocks if not careful

Solution 2: Interlocked

What it is: Atomic operations for simple types.

Use: When you only need to increment/decrement/compare-exchange.

Key Methods

Interlocked.Increment(ref value) - Atomic increment
Interlocked.Decrement(ref value) - Atomic decrement
Interlocked.Add(ref location, value) - Atomic add
Interlocked.Exchange(ref location, value) - Atomic set
Interlocked.CompareExchange(ref location, value, comparand) - Atomic compare and set

int counter = 0;

Parallel.For(0, 1000, i => {
    Interlocked.Increment(ref counter); // Safe and fast
});

Solution 3: Concurrent Collections

What it is: Thread-safe collection classes.

Use: Shared collections in multi-threaded code.

Available Collections

ConcurrentBag<T> - Unordered collection
ConcurrentQueue<T> - FIFO queue
ConcurrentStack<T> - LIFO stack
ConcurrentDictionary<TKey, TValue> - Thread-safe dictionary
BlockingCollection<T> - Blocking producer-consumer

ConcurrentBag<int> bag = new ConcurrentBag<int>();

Parallel.For(0, 1000, i => {
    bag.Add(i); // Safe
});

// ConcurrentDictionary
ConcurrentDictionary<int, string> dict = new();
dict.TryAdd(1, "one");
dict.TryGetValue(1, out string value);
dict.AddOrUpdate(1, "one", (key, old) => "ONE");

Solution 4: SemaphoreSlim

What it is: Limits number of threads accessing a resource.

Use: Rate limiting, connection pooling.

Key Methods

Wait() / WaitAsync() - Acquire permit (block if none available)
Release() - Release permit

SemaphoreSlim semaphore = new SemaphoreSlim(3); // Max 3 concurrent

await semaphore.WaitAsync(); // Acquire
try
{
    // Do work (max 3 threads here at once)
}
finally
{
    semaphore.Release(); // Always release
}

Solution 5: ReaderWriterLockSlim

What it is: Allows multiple readers or one writer.

Use: When reads are common, writes are rare.

ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();

// Reading
rwLock.EnterReadLock();
try
{
    // Multiple readers can be here simultaneously
}
finally
{
    rwLock.ExitReadLock();
}

// Writing
rwLock.EnterWriteLock();
try
{
    // Only one writer, blocks all readers
}
finally
{
    rwLock.ExitWriteLock();
}

Async Coordination Primitives

SemaphoreSlim (Async)

See above - preferred for async scenarios.

ManualResetEventSlim / AutoResetEvent

What it is: Signal between threads.

Use: Rarely needed with async/await.

ManualResetEventSlim mre = new ManualResetEventSlim(false);

// Thread 1: Wait for signal
Task.Run(() => {
    mre.Wait(); // Blocks until signaled
    Console.WriteLine("Signaled!");
});

// Thread 2: Send signal
Task.Run(() => {
    Thread.Sleep(1000);
    mre.Set(); // Signal waiting threads
});

TaskCompletionSource<T>

What it is: Manually control Task completion.

Use: Wrap callbacks or events into Task.

TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();

// Simulate async operation
Task.Run(async () => {
    await Task.Delay(1000);
    tcs.SetResult(42); // Complete the task
});

// Wait for result
int result = await tcs.Task;

Key Methods

SetResult(result) - Complete successfully
SetException(exception) - Complete with error
SetCanceled() - Complete as canceled
TrySetResult() / TrySetException() / TrySetCanceled() - Try variants

Common Patterns & Best Practices

Pattern 1: Async All The Way

// ✅ Good: Async all the way
public async Task<string> ControllerActionAsync()
{
    var data = await _service.GetDataAsync();
    return await _service.ProcessDataAsync(data);
}

// ❌ Bad: Mixing sync and async
public string ControllerAction()
{
    var data = _service.GetDataAsync().Result; // DEADLOCK RISK!
    return _service.ProcessDataAsync(data).Result;
}

Pattern 2: Fire and Forget (Careful!)

// ❌ Bad: Exceptions are lost
public void StartWork()
{
    _ = DoWorkAsync(); // Fire and forget
}

// ✅ Better: Handle exceptions
public void StartWork()
{
    _ = Task.Run(async () => {
        try
        {
            await DoWorkAsync();
        }
        catch (Exception ex)
        {
            // Log exception
        }
    });
}

Pattern 3: Lazy Initialization (Thread-Safe)

private readonly Lazy<ExpensiveObject> _lazyObj = 
    new Lazy<ExpensiveObject>(() => new ExpensiveObject());

public ExpensiveObject Instance => _lazyObj.Value;

Pattern 4: Async Lazy

private readonly AsyncLazy<ExpensiveObject> _asyncLazy = 
    new AsyncLazy<ExpensiveObject>(async () => 
    {
        await Task.Delay(100);
        return new ExpensiveObject();
    });

public Task<ExpensiveObject> GetInstanceAsync() => _asyncLazy.Value;

// Helper class
public class AsyncLazy<T>
{
    private readonly Lazy<Task<T>> _lazy;
    public AsyncLazy(Func<Task<T>> factory)
    {
        _lazy = new Lazy<Task<T>>(() => Task.Run(factory));
    }
    public Task<T> Value => _lazy.Value;
}

Pattern 5: Progress Reporting

public async Task ProcessDataAsync(IProgress<int> progress)
{
    for (int i = 0; i < 100; i++)
    {
        await Task.Delay(10);
        progress?.Report(i + 1); // Report progress
    }
}

// Usage
var progress = new Progress<int>(percent => {
    Console.WriteLine($"Progress: {percent}%");
});
await ProcessDataAsync(progress);

Pattern 6: Timeout Pattern

public async Task<string> GetDataWithTimeoutAsync(int timeoutMs)
{
    using (var cts = new CancellationTokenSource(timeoutMs))
    {
        try
        {
            return await GetDataAsync(cts.Token);
        }
        catch (OperationCanceledException)
        {
            throw new TimeoutException();
        }
    }
}

// Or using Task.WhenAny
public async Task<string> GetDataWithTimeoutAsync2(int timeoutMs)
{
    var dataTask = GetDataAsync();
    var timeoutTask = Task.Delay(timeoutMs);

    var completedTask = await Task.WhenAny(dataTask, timeoutTask);

    if (completedTask == timeoutTask)
        throw new TimeoutException();

    return await dataTask;
}

Pattern 7: Retry Logic

public async Task<T> RetryAsync<T>(
    Func<Task<T>> operation, 
    int maxAttempts = 3, 
    int delayMs = 1000)
{
    for (int i = 0; i < maxAttempts; i++)
    {
        try
        {
            return await operation();
        }
        catch (Exception) when (i < maxAttempts - 1)
        {
            await Task.Delay(delayMs);
        }
    }
    throw new Exception("Max retry attempts reached");
}

// Usage
var result = await RetryAsync(() => DownloadDataAsync());

Real-World Applications

1. Web API Calls (I/O-Bound)

public async Task<string> GetWeatherAsync(string city)
{
    using (var client = new HttpClient())
    {
        string url = $"https://api.weather.com/{city}";
        return await client.GetStringAsync(url);
    }
}

2. Database Operations (I/O-Bound)

public async Task<List<User>> GetUsersAsync()
{
    using (var context = new MyDbContext())
    {
        return await context.Users.ToListAsync();
    }
}

3. File Processing (I/O-Bound)

public async Task<string> ReadFileAsync(string path)
{
    using (var reader = new StreamReader(path))
    {
        return await reader.ReadToEndAsync();
    }
}

4. Image Processing (CPU-Bound)

public void ProcessImages(List<string> imagePaths)
{
    Parallel.ForEach(imagePaths, imagePath => {
        var image = LoadImage(imagePath);
        var processed = ApplyFilters(image);
        SaveImage(processed);
    });
}

5. Data Analysis (CPU-Bound)

public double[] AnalyzeData(double[] data)
{
    return data
        .AsParallel()
        .Select(x => ComplexCalculation(x))
        .ToArray();
}

6. Responsive UI

private async void Button_Click(object sender, EventArgs e)
{
    // UI remains responsive
    var data = await LoadDataAsync();
    DisplayData(data);
}

7. Background Worker

public class BackgroundWorker
{
    private readonly Timer _timer;

    public BackgroundWorker()
    {
        _timer = new Timer(async _ => await DoWorkAsync(), 
            null, TimeSpan.Zero, TimeSpan.FromMinutes(5));
    }

    private async Task DoWorkAsync()
    {
        // Background work every 5 minutes
    }
}

8. Producer-Consumer Pattern

BlockingCollection<string> queue = new BlockingCollection<string>();

// Producer
Task.Run(() => {
    for (int i = 0; i < 100; i++)
    {
        queue.Add($"Item {i}");
        Thread.Sleep(10);
    }
    queue.CompleteAdding();
});

// Consumer
Task.Run(() => {
    foreach (var item in queue.GetConsumingEnumerable())
    {
        Console.WriteLine($"Processing {item}");
    }
});

⚠️ Common Pitfalls & How to Avoid

1. Deadlock with .Result or .Wait()

// ❌ DEADLOCK in UI or ASP.NET (legacy)
public void Method()
{
    var result = GetDataAsync().Result; // BLOCKS!
}

// ✅ Solution: Use async all the way
public async Task MethodAsync()
{
    var result = await GetDataAsync();
}

2. Async Void

// ❌ Bad: Can't catch exceptions
public async void ProcessDataAsync()
{
    await Task.Delay(1000);
    throw new Exception(); // Lost!
}

// ✅ Good: Return Task
public async Task ProcessDataAsync()
{
    await Task.Delay(1000);
    throw new Exception(); // Can be caught
}

// ⚠️ Exception: Event handlers (only place for async void)
private async void Button_Click(object sender, EventArgs e)
{
    await ProcessDataAsync();
}

3. Not Disposing Resources

// ❌ Bad: Resource leak
var stream = new FileStream("file.txt", FileMode.Open);
await stream.ReadAsync(buffer, 0, buffer.Length);

// ✅ Good: Always dispose
using (var stream = new FileStream("file.txt", FileMode.Open))
{
    await stream.ReadAsync(buffer, 0, buffer.Length);
}

// ✅ C# 8.0+: Using declaration
await using var stream = new FileStream("file.txt", FileMode.Open);
await stream.ReadAsync(buffer, 0, buffer.Length);

4. Capturing Loop Variables

// ❌ Bad: All tasks capture same variable
for (int i = 0; i < 10; i++)
{
    Task.Run(() => Console.WriteLine(i)); // Prints 10 ten times!
}

// ✅ Good: Capture local copy
for (int i = 0; i < 10; i++)
{
    int local = i;
    Task.Run(() => Console.WriteLine(local)); // Prints 0-9
}

// ✅ C# 5.0+: foreach is safe
foreach (var item in items)
{
    Task.Run(() => Console.WriteLine(item)); // Safe
}

5. Parallel.ForEach on UI Collections

// ❌ Bad: UI collections aren't thread-safe
Parallel.ForEach(listBox.Items, item => {
    ProcessItem(item); // CRASH!
});

// ✅ Good: Copy to array first
var items = listBox.Items.Cast<string>().ToArray();
Parallel.ForEach(items, item => {
    ProcessItem(item);
});

6. Starting Too Many Tasks

// ❌ Bad: Creates 1 million tasks!
var tasks = Enumerable.Range(0, 1000000)
    .Select(i => Task.Run(() => DoWork(i)))
    .ToArray();
await Task.WhenAll(tasks);

// ✅ Good: Use Parallel.ForEach (manages thread pool)
Parallel.ForEach(Enumerable.Range(0, 1000000), i => {
    DoWork(i);
});

// ✅ Good: Batch tasks with SemaphoreSlim
var semaphore = new SemaphoreSlim(10); // Max 10 concurrent
var tasks = Enumerable.Range(0, 1000000)
    .Select(async i => {
        await semaphore.WaitAsync();
        try
        {
            await DoWorkAsync(i);
        }
        finally
        {
            semaphore.Release();
        }
    })
    .ToArray();
await Task.WhenAll(tasks);

7. Mixing CPU and I/O Work

// ❌ Bad: Using async for CPU-bound work
public async Task<int> CalculateAsync(int n)
{
    await Task.Delay(1); // Pointless
    return HeavyCalculation(n); // Blocks thread anyway
}

// ✅ Good: Use Task.Run for CPU-bound
public Task<int> CalculateAsync(int n)
{
    return Task.Run(() => HeavyCalculation(n));
}

// ❌ Bad: Using Parallel for I/O-bound
Parallel.ForEach(urls, url => {
    DownloadFile(url).Wait(); // Wastes threads
});

// ✅ Good: Use async for I/O-bound
var tasks = urls.Select(url => DownloadFileAsync(url));
await Task.WhenAll(tasks);

Decision Tree: What to Use When?

Is the work I/O-bound (network, file, database)?
│
├─ YES: Use async/await
│   ├─ Single operation: await SomeMethodAsync()
│   ├─ Multiple operations (sequential): await one, then await another
│   ├─ Multiple operations (parallel): await Task.WhenAll(tasks)
│   └─ Need cancellation: Pass CancellationToken
│
└─ NO: Is it CPU-bound (computation, processing)?
    │
    ├─ YES: Can the work be parallelized?
    │   ├─ YES: Loop over collection?
    │   │   ├─ YES: Use Parallel.ForEach or Parallel.For
    │   │   └─ NO: Use Parallel.Invoke
    │   │
    │   └─ NO: Use Task.Run() to offload to thread pool
    │
    └─ NO: Use synchronous code (normal method)

Special cases:
- Event handling: Event-driven programming
- Rate limiting: SemaphoreSlim
- Shared state: lock, Interlocked, or Concurrent collections
- Background work: Timer + async Task
- Producer-Consumer: BlockingCollection

Performance Comparison

Task Creation Cost

Method	Relative Cost	Use Case
`await` existing Task	1x (baseline)	Always prefer
`Task.CompletedTask`	~1x	Synchronous async methods
`Task.FromResult()`	~5x	Return cached result
`new Task()` + `Start()`	~50x	Legacy, avoid
`new Thread()`	~500x	Legacy, avoid

Async vs Sync File I/O (1000 files)

Synchronous: ~30 seconds (one at a time)
Asynchronous: ~3 seconds (parallel I/O operations)

Parallel.ForEach vs Sequential (CPU-bound, 4 cores)

Sequential: 10 seconds
Parallel: ~2.5 seconds (4x faster)

Async Streams (C# 8.0+)

What it is: Asynchronously iterate over data as it arrives.

Use: Large datasets, real-time data, pagination.

IAsyncEnumerable<T>

// Producer
public async IAsyncEnumerable<int> GetNumbersAsync()
{
    for (int i = 0; i < 10; i++)
    {
        await Task.Delay(100); // Simulate async work
        yield return i;
    }
}

// Consumer
await foreach (var number in GetNumbersAsync())
{
    Console.WriteLine(number); // Process as they arrive
}

// With cancellation
public async IAsyncEnumerable<int> GetNumbersAsync(
    [EnumeratorCancellation] CancellationToken token = default)
{
    for (int i = 0; i < 10; i++)
    {
        token.ThrowIfCancellationRequested();
        await Task.Delay(100, token);
        yield return i;
    }
}

Real-World Example: Paginated API

public async IAsyncEnumerable<User> GetAllUsersAsync()
{
    int page = 1;
    while (true)
    {
        var users = await GetUserPageAsync(page);
        if (users.Count == 0) break;

        foreach (var user in users)
            yield return user;

        page++;
    }
}

// Usage
await foreach (var user in GetAllUsersAsync())
{
    Console.WriteLine(user.Name); // Process one at a time
}

ValueTask<T> (Performance Optimization)

What it is: Struct-based Task alternative to avoid allocations.

Use: High-performance scenarios where result is often available synchronously.

Caution: More restrictions than Task.

When to Use

// ❌ Use Task<T>: Usually async
public async Task<string> DownloadAsync(string url)
{
    return await httpClient.GetStringAsync(url);
}

// ✅ Use ValueTask<T>: Often cached/synchronous
public ValueTask<User> GetUserAsync(int id)
{
    if (_cache.TryGetValue(id, out var user))
        return new ValueTask<User>(user); // No allocation

    return new ValueTask<User>(LoadUserAsync(id));
}

Restrictions

Can only await once
Cannot use .Result or .Wait()
Cannot await simultaneously from multiple threads
If in doubt, use Task<T>

ConfigureAwait Deep Dive

What It Does

// Default: ConfigureAwait(true)
await SomeMethodAsync();
// After await, execution resumes on captured context (UI thread)

// ConfigureAwait(false)
await SomeMethodAsync().ConfigureAwait(false);
// After await, execution resumes on any available thread

When to Use ConfigureAwait(false)

✅ Library code (never touches UI)
✅ ASP.NET Core (no synchronization context)
✅ Background services
✅ Performance-critical code

When NOT to Use ConfigureAwait(false)

❌ UI code (WPF, WinForms, Xamarin)
❌ Code that accesses UI elements after await
❌ ASP.NET Framework (before Core)

Example

// Library code - always use ConfigureAwait(false)
public async Task<string> GetDataAsync()
{
    var response = await httpClient
        .GetAsync(url)
        .ConfigureAwait(false);

    var content = await response.Content
        .ReadAsStringAsync()
        .ConfigureAwait(false);

    return content;
}

// UI code - don't use ConfigureAwait(false)
private async void Button_Click(object sender, EventArgs e)
{
    var data = await GetDataAsync(); // Default: stays on UI thread
    textBox.Text = data; // Safe to access UI
}

Advanced: Custom Awaiter

What it is: Make any type awaitable.

Use: Rare, but shows how await works under the hood.

public static class IntExtensions
{
    public static TaskAwaiter GetAwaiter(this int milliseconds)
    {
        return Task.Delay(milliseconds).GetAwaiter();
    }
}

// Usage
await 1000; // Wait 1 second!

Channels (System.Threading.Channels)

What it is: Modern producer-consumer queue for async scenarios.

Use: Better alternative to BlockingCollection for async code.

Channel Types

Channel.CreateUnbounded<T>() - No capacity limit
Channel.CreateBounded<T>(capacity) - Limited capacity

Example

var channel = Channel.CreateUnbounded<int>();

// Producer
var writer = channel.Writer;
_ = Task.Run(async () => {
    for (int i = 0; i < 100; i++)
    {
        await writer.WriteAsync(i);
        await Task.Delay(10);
    }
    writer.Complete();
});

// Consumer
var reader = channel.Reader;
await foreach (var item in reader.ReadAllAsync())
{
    Console.WriteLine(item);
}

// Or manual consumption
while (await reader.WaitToReadAsync())
{
    while (reader.TryRead(out var item))
    {
        Console.WriteLine(item);
    }
}

Testing Async Code

Basic Test

[Test]
public async Task TestAsyncMethod()
{
    var result = await GetDataAsync();
    Assert.AreEqual("expected", result);
}

Testing with Timeout

[Test, Timeout(5000)] // 5 second timeout
public async Task TestWithTimeout()
{
    await LongRunningOperationAsync();
}

Testing Cancellation

[Test]
public async Task TestCancellation()
{
    var cts = new CancellationTokenSource();
    var task = LongRunningOperationAsync(cts.Token);

    cts.Cancel();

    await Assert.ThrowsAsync<OperationCanceledException>(
        async () => await task);
}

Testing Parallel Code

[Test]
public void TestThreadSafety()
{
    int counter = 0;
    object lockObj = new object();

    Parallel.For(0, 1000, i => {
        lock (lockObj)
        {
            counter++;
        }
    });

    Assert.AreEqual(1000, counter);
}

Quick Reference Summary

Legacy (Pre-.NET 4.5) ❌

Thread - Manual thread management
BackgroundWorker - UI threading helper
ThreadPool.QueueUserWorkItem - Queue work items
APM (Begin/End) - IAsyncResult pattern
EAP (Events) - MethodAsync + Completed event

Modern (.NET 4.5+) ✅

async/await - Write async code naturally
Task/Task<T> - Represent async operations
Task.Run() - Offload CPU work
Task.WhenAll/WhenAny - Coordinate tasks
CancellationToken - Cooperative cancellation
Parallel.ForEach/For - Data parallelism
PLINQ - Parallel LINQ
SemaphoreSlim - Async coordination
IProgress<T> - Progress reporting

Cutting Edge (.NET Core 3.0+) 🚀

IAsyncEnumerable<T> - Async streams
Channels - Modern producer-consumer
ValueTask<T> - Zero-allocation async
IAsyncDisposable - Async resource disposal

Cheat Sheet: Syntax Quick Look

// Async method signatures
public async Task MethodAsync() { }
public async Task<int> MethodAsync() { }
public async ValueTask<int> MethodAsync() { }
public async IAsyncEnumerable<int> MethodAsync() { }

// Awaiting
var result = await SomeMethodAsync();
await Task.Delay(1000);
await Task.WhenAll(task1, task2);
var first = await Task.WhenAny(task1, task2);

// Fire and forget (avoid!)
_ = SomeMethodAsync();

// Parallel loops
Parallel.For(0, 100, i => { });
Parallel.ForEach(items, item => { });
Parallel.Invoke(() => Method1(), () => Method2());

// PLINQ
var results = items.AsParallel()
    .Where(x => x.IsValid)
    .Select(x => Process(x))
    .ToList();

// Cancellation
var cts = new CancellationTokenSource();
cts.CancelAfter(5000);
await MethodAsync(cts.Token);

// Thread safety
lock (lockObj) { counter++; }
Interlocked.Increment(ref counter);
var dict = new ConcurrentDictionary<int, string>();

// Semaphore
await semaphore.WaitAsync();
try { } finally { semaphore.Release(); }

// Async streams
await foreach (var item in GetItemsAsync()) { }

// Progress
var progress = new Progress<int>(p => Console.WriteLine(p));
await ProcessAsync(progress);

Mental Model: The Right Tool for the Job

Scenario	Use This	Why
Web API call	`async/await`	I/O-bound, non-blocking
Database query	`async/await`	I/O-bound, non-blocking
File reading	`async/await`	I/O-bound, non-blocking
Image processing	`Parallel.ForEach`	CPU-bound, data parallel
Heavy calculation	`Task.Run()`	CPU-bound, offload from UI
Data analysis	`PLINQ`	CPU-bound, query processing
Rate limiting	`SemaphoreSlim`	Control concurrency
Shared counter	`Interlocked`	Simple atomic operations
Shared dictionary	`ConcurrentDictionary`	Complex shared state
Background timer	`Timer` + `async Task`	Periodic work
Producer-consumer	`Channel`	Modern async queue
Event handling	`event` + `async void`	UI interactions
Streaming data	`IAsyncEnumerable`	Process as data arrives

Final Tips

Start with async/await - It's the right default for most scenarios
Use Task.Run only for CPU-bound work - Don't wrap I/O operations
Async all the way - Don't block on async code with .Result or .Wait()
Avoid async void - Except for event handlers
Always dispose - Use using for disposable resources
Configure await in libraries - Use .ConfigureAwait(false) in library code
Cancellation tokens everywhere - Support cancellation in async methods
Handle exceptions - Always try-catch in fire-and-forget scenarios
Test thread safety - Use concurrent collections or locks
Profile before parallel - Parallelism has overhead; measure actual gains

Remember: Async doesn't mean parallel, and parallel doesn't mean async!

Async = Non-blocking (I/O-bound)
Parallel = Simultaneous execution (CPU-bound)

Introducing EasyMessages: Stop Wasting Time on Message Wording in .NET (Alpha Release)

RecurPixel — Mon, 24 Nov 2025 16:14:24 +0000

I'm excited to share EasyMessages - a lightweight .NET library that provides standardized, reusable messages for all scenarios.

The Real Problem

How many times has this happened to you?

// You write this
return BadRequest(new { message = "Invalid credentials" });

// QA flags it: "Can you make it more descriptive?"
// You change it
// QA flags it again: "Should match our other auth messages"
// Repeat...

Message wording is the most time-consuming and cumbersome part of development. QA will always have feedback. So I decided to standardize it.

The Solution

using RecurPixel.EasyMessages;

// Pre-built, standardized messages
Msg.Auth.LoginFailed().ToJson();
Msg.Crud.Created("User").ToConsole();
Msg.Validation.RequiredField("Email").ToJson();

Standardized. Clear. No more back-and-forth.

Why I Built This

As developers, we shouldn't waste mental energy on:

"How should I word this error?"
"What message should I show for successful creation?"
"Is this validation message clear enough?"

Let the library handle it. Focus on your business logic.

Key Features

✅ 100+ pre-built messages (success, error, validation, info, warnings)
✅ Zero configuration
✅ IntelliSense-friendly
✅ All message types covered
✅ Multiple output formats
✅ Extensible

Message Categories

Authentication - Login, logout, tokens, permissions
CRUD Operations - Created, updated, deleted, not found
Validation - Required fields, formats, ranges
System - Errors, processing, maintenance
Database - Connection, queries, transactions
Files - Upload, download, validation
Network - Timeouts, service issues

Quick Start

dotnet add package RecurPixel.EasyMessages --version 0.1.0-alpha.1

// Your first message in 5 seconds
Msg.Auth.LoginFailed().ToConsole(useColors: true);

// Success messages
Msg.Crud.Updated("Profile").ToJson();

// Validation messages
Msg.Validation.InvalidFormat("Email").ToConsole();

What's Coming

This is an alpha release. Here's the roadmap:

Beta (2 weeks): ASP.NET Core integration, .ToApiResponse(), DI support
v1.0 (6 weeks): Production-ready, 200+ messages, full docs

I Need Your Help!

This is an early preview. I'm looking for:

Feedback on the API design
Bug reports
Feature suggestions
What messages do YOU write over and over?

Try it out and let me know what you think!

🔗 Links:

dotnet #csharp #opensource #nuget

🏷️ C# Attributes and Reflection: The Metadata System

RecurPixel — Thu, 20 Nov 2025 11:32:33 +0000

C# Attributes allow developers to add descriptive metadata (tags) to code elements (classes, methods, properties) without changing their logic.

They function like "sticky notes" that provide instructions or context to frameworks. Reflection is the process used by your code or a framework (like ASP.NET, Entity Framework) to read and inspect this metadata at runtime, enabling advanced features like automatic validation, routing, ORM mapping, and dependency injection.
The most common mistake is forgetting to use the generic method GetCustomAttributes<T>() or casting the result when reading multiple attributes, which is essential for most complex filtering and framework development.

🎯 The Big Picture

┌─────────────────────────────────────────────────────┐
│              METADATA SYSTEM                        │
│                                                     │
│  ┌──────────────┐         ┌──────────────┐          │
│  │  ATTRIBUTES  │────────>│  REFLECTION  │          │
│  │  (Add data)  │         │  (Read data) │          │
│  └──────────────┘         └──────────────┘          │
│         │                        │                  │
│         │                        │                  │
│         v                        v                  │
│    [Validation]            GetCustomAttribute()     │
│    [Route("api")]          GetProperties()          │
│    [Obsolete]              GetMethods()             │
│    [Serializable]          Activator.CreateInstance │
│                                                     │
└─────────────────────────────────────────────────────┘

Common Use Cases:
• Validation (ASP.NET, Entity Framework)
• Serialization (JSON, XML)
• Routing (ASP.NET MVC/Web API)
• Testing (NUnit, xUnit)
• Dependency Injection
• ORM Mapping (Entity Framework)

🔍 Attribute Filtering Patterns (Common Scenarios)

Pattern 1: Find All Classes with Specific Attribute

// Find all classes decorated with [Developer] attribute
Assembly assembly = Assembly.GetExecutingAssembly();

var classesWithAttr = assembly.GetTypes()
    .Where(t => t.IsClass && 
                !t.IsAbstract && 
                t.IsDefined(typeof(Developer), false));

foreach (var type in classesWithAttr)
{
    Console.WriteLine(type.Name);
}

Pattern 2: Find Classes Where Attribute Matches Condition

// Find classes developed by specific person
string targetDeveloper = "Arthor";

var matchingClasses = assembly.GetTypes()
    .Where(t => t.IsClass && !t.IsAbstract)
    .Where(t => t.GetCustomAttributes<Developer>()
                 .Any(d => d.Name == targetDeveloper));

Pattern 3: Get All Attribute Values Across All Classes

// Get all unique developer names
var allDevelopers = assembly.GetTypes()
    .Where(t => t.IsClass && !t.IsAbstract)
    .SelectMany(t => t.GetCustomAttributes<Developer>())
    .Select(d => d.Name)
    .Distinct();

foreach (var name in allDevelopers)
{
    Console.WriteLine(name);
}

Pattern 4: Group Classes by Attribute Value

// Group classes by developer
var grouped = assembly.GetTypes()
    .Where(t => t.IsClass && !t.IsAbstract)
    .SelectMany(t => t.GetCustomAttributes<Developer>()
                      .Select(d => new { Type = t, Developer = d }))
    .GroupBy(x => x.Developer.Name);

foreach (var group in grouped)
{
    Console.WriteLine($"\nDeveloper: {group.Key}");
    foreach (var item in group)
    {
        Console.WriteLine($"  - {item.Type.Name} v{item.Developer.Version}");
    }
}

Pattern 5: Find Classes with Multiple Specific Attributes

// Find classes that have BOTH [Obsolete] AND [Serializable]
var classesWithBoth = assembly.GetTypes()
    .Where(t => t.IsClass &&
                t.IsDefined(typeof(ObsoleteAttribute), false) &&
                t.IsDefined(typeof(SerializableAttribute), false));

Pattern 6: Complex Filtering (Version Range)

// Find classes with version between 2.0 and 4.0
var versionRange = assembly.GetTypes()
    .Where(t => t.IsClass && !t.IsAbstract)
    .Where(t => t.GetCustomAttributes<Developer>()
                 .Any(d => d.Version >= 2.0 && d.Version <= 4.0));

🎓 Key Takeaways: Avoiding Common Mistakes

❌ Mistake 1: Forgetting to Cast (Legacy Method)

// WRONG
object[] attrs = type.GetCustomAttributes(typeof(Developer), false);
Console.WriteLine(attrs[0].Name);  // ❌ Error! object doesn't have Name

// RIGHT
Developer dev = (Developer)attrs[0];  // ✅ Cast first
Console.WriteLine(dev.Name);

❌ Mistake 2: Using Singular Method for Multiple Attributes

// WRONG (only gets first attribute)
var attr = type.GetCustomAttribute<Developer>();  // ❌ Loses other attributes

// RIGHT
var attrs = type.GetCustomAttributes<Developer>();  // ✅ Gets all

❌ Mistake 3: Not Checking for Null/Empty

// WRONG
var attr = type.GetCustomAttribute<Developer>();
Console.WriteLine(attr.Name);  // ❌ NullReferenceException if not found

// RIGHT
var attr = type.GetCustomAttribute<Developer>();
if (attr != null)  // ✅ Check first
{
    Console.WriteLine(attr.Name);
}

// OR use null-conditional operator
Console.WriteLine(attr?.Name ?? "No developer");  // ✅

❌ Mistake 4: Using GetCustomAttributes in LINQ Without Cast

// WRONG
var result = types.Where(t => 
    t.GetCustomAttributes(typeof(Developer), false).Any(a => a.Name == "Arthor"));
    // ❌ object doesn't have Name property

// RIGHT - Option 1: Cast
var result = types.Where(t => 
    t.GetCustomAttributes(typeof(Developer), false)
     .Cast<Developer>()  // ✅ Cast to Developer
     .Any(d => d.Name == "Arthor"));

// RIGHT - Option 2: Use generic (better)
var result = types.Where(t => 
    t.GetCustomAttributes<Developer>()  // ✅ Already typed
     .Any(d => d.Name == "Arthor"));

✅ Best Practice: Use Generic Methods

// ❌ Old way (verbose, requires casting)
object[] attrs = type.GetCustomAttributes(typeof(Developer), false);
foreach (object attr in attrs)
{
    Developer dev = (Developer)attr;
    Console.WriteLine(dev.Name);
}

// ✅ Modern way (clean, type-safe)
foreach (Developer dev in type.GetCustomAttributes<Developer>())
{
    Console.WriteLine(dev.Name);
}

What Are Attributes?

Simple Definition: Attributes are tags you put on code (classes, methods, properties) to add metadata.

Think of it like: Sticky notes on code that frameworks can read later.

[Obsolete("Use NewMethod instead")]  // ← Attribute (sticky note)
public void OldMethod() { }           // ← Your code

[Required]                            // ← Attribute
public string Name { get; set; }      // ← Your property

Key Point: Attributes do NOTHING by themselves. Something else (framework or your code) must READ them using Reflection.

Built-in Attributes (Most Common)

1. [Obsolete] - Mark Old Code

[Obsolete]  // Warning
public void OldMethod() { }

[Obsolete("Use NewMethod instead")]  // Warning with message
public void OldMethod() { }

[Obsolete("Don't use this!", true)]  // Compiler ERROR
public void OldMethod() { }

2. [Serializable] - Allow Serialization

[Serializable]
public class Person
{
    public string Name { get; set; }
}

3. [DllImport] - Call Native Code

[DllImport("user32.dll")]
public static extern int MessageBox(IntPtr hWnd, string text, string caption, uint type);

4. [CallerMemberName] - Get Caller Info (Debugging)

public void Log(string message, 
    [CallerMemberName] string caller = "")
{
    Console.WriteLine($"{caller}: {message}");
}

// Usage: Log("Something happened");
// Output: MyMethod: Something happened

5. [Flags] - Enum as Bit Flags

[Flags]
public enum FileAccess
{
    Read = 1,    // 001
    Write = 2,   // 010
    Execute = 4  // 100
}

var access = FileAccess.Read | FileAccess.Write; // 011 (3)

6. [Conditional] - Conditional Compilation

[Conditional("DEBUG")]
public void DebugLog(string message)
{
    Console.WriteLine(message);  // Only runs in DEBUG mode
}

Creating Custom Attributes

Step 1: Define Attribute Class

Rules:

Must inherit from System.Attribute
Name should end with "Attribute" (optional but convention)
Add [AttributeUsage] to specify where it can be used

// Simple attribute (no parameters)
public class MyAttribute : Attribute
{
}

// Attribute with parameters
public class DescriptionAttribute : Attribute
{
    public string Text { get; }

    public DescriptionAttribute(string text)
    {
        Text = text;
    }
}

// Attribute with named parameters
public class ValidationAttribute : Attribute
{
    public string ErrorMessage { get; set; }
    public int MinLength { get; set; }
    public int MaxLength { get; set; }
}

Step 2: Control Where Attribute Can Be Used

[AttributeUsage(AttributeTargets.Class)]  // Only on classes
public class TableAttribute : Attribute
{
    public string Name { get; }
    public TableAttribute(string name) => Name = name;
}

[AttributeUsage(AttributeTargets.Property)]  // Only on properties
public class ColumnAttribute : Attribute
{
    public string Name { get; }
    public ColumnAttribute(string name) => Name = name;
}

// Multiple targets
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class LogAttribute : Attribute { }

// Allow multiple instances
[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public class RouteAttribute : Attribute
{
    public string Path { get; }
    public RouteAttribute(string path) => Path = path;
}

AttributeTargets Options

Assembly        // [assembly: AssemblyVersion("1.0")]
Module          // Rarely used
Class           // [Table("Users")]
Struct          // [Serializable]
Enum            // [Flags]
Constructor     // [Obsolete]
Method          // [Route("api/users")]
Property        // [Required]
Field           // [NonSerialized]
Event           // [Description("Fired when...")]
Interface       // [ServiceContract]
Parameter       // void Method([FromBody] string data)
Delegate        // Rarely used
ReturnValue     // [return: MarshalAs(...)]
GenericParameter// class MyClass<[SomeAttribute] T>
All             // Any of the above

Using Custom Attributes

// Usage (Note: "Attribute" suffix is optional)
[Description("This is a user")]
public class User { }

// Same as:
[DescriptionAttribute("This is a user")]
public class User { }

// With named parameters
[Validation(ErrorMessage = "Invalid", MinLength = 5, MaxLength = 50)]
public string Username { get; set; }

// Multiple attributes
[Table("Users")]
[Description("User entity")]
[Serializable]
public class User { }

// Multiple instances (if AllowMultiple = true)
[Route("api/users")]
[Route("api/v1/users")]
public class UserController { }

Reflection Basics

What is Reflection?: Examining and manipulating code at runtime.

Common Uses:

Read attributes
Get type information
Create instances dynamically
Invoke methods dynamically
Access private members (testing)

Key Reflection Classes

Type            // Represents a type (class, interface, etc.)
Assembly        // Represents a .dll or .exe
MemberInfo      // Base for all members
PropertyInfo    // Property information
MethodInfo      // Method information
FieldInfo       // Field information
ConstructorInfo // Constructor information

Getting Type Information

// Three ways to get Type
Type type1 = typeof(User);                    // Compile-time
Type type2 = user.GetType();                  // Runtime (from instance)
Type type3 = Type.GetType("MyNamespace.User"); // From string

// Basic type info
string name = type.Name;              // "User"
string fullName = type.FullName;      // "MyNamespace.User"
string namespaceName = type.Namespace; // "MyNamespace"
bool isClass = type.IsClass;          // true
bool isInterface = type.IsInterface;  // false
bool isAbstract = type.IsAbstract;    // false
bool isSealed = type.IsSealed;        // false
bool isPublic = type.IsPublic;        // true

Reading Attributes (The Important Part!)

⚠️ Understanding Attribute Retrieval Methods

There are THREE main ways to get attributes, and choosing the wrong one causes confusion:

Method	Returns	Use When
`GetCustomAttribute<T>()`	Single `T` or `null`	You expect ONE attribute
`GetCustomAttributes<T>()`	`IEnumerable<T>`	You expect MULTIPLE attributes
`GetCustomAttributes(type, inherit)`	`object[]`	Legacy, need casting

Single Attribute on Class

// Define
[Table("Users")]
public class User { }

// Read - Modern way (Generic)
Type type = typeof(User);
TableAttribute attr = type.GetCustomAttribute<TableAttribute>();

if (attr != null)
{
    Console.WriteLine(attr.Name);  // "Users"
}

// Read - Legacy way (Non-generic, requires cast)
object[] attrs = type.GetCustomAttributes(typeof(TableAttribute), false);
if (attrs.Length > 0)
{
    TableAttribute attr = (TableAttribute)attrs[0];  // Must cast!
    Console.WriteLine(attr.Name);
}

// Or just check if exists
bool hasTable = type.IsDefined(typeof(TableAttribute), false);

Multiple Attributes on Class

// Define
[Route("api/users")]
[Route("api/v1/users")]
public class UserController { }

// ✅ Method 1: Modern Generic (PREFERRED)
Type type = typeof(UserController);
IEnumerable<RouteAttribute> routes = type.GetCustomAttributes<RouteAttribute>();

foreach (var route in routes)
{
    Console.WriteLine(route.Path);
}

// ✅ Method 2: Legacy Non-Generic (Requires casting)
object[] routesArray = type.GetCustomAttributes(typeof(RouteAttribute), false);

foreach (object attr in routesArray)
{
    RouteAttribute route = (RouteAttribute)attr;  // Must cast each one!
    Console.WriteLine(route.Path);
}

// ❌ WRONG: Using GetCustomAttribute (singular) for multiple
// This only returns the FIRST attribute, you'll miss others!
var route = type.GetCustomAttribute<RouteAttribute>();  // Only gets first one!

🎯 Common Confusion: Accessing Properties After GetCustomAttributes

This is the #1 confusion point when working with multiple attributes:

[Developer("Arthor", 1.0)]
[Developer("Alice", 1.1)]
class MyClass { }

// ❌ WRONG: Trying to access properties directly on object[]
object[] attrs = type.GetCustomAttributes(typeof(Developer), false);
// Can't do: attrs[0].Name ❌ (object doesn't have Name property)

// ✅ CORRECT: Must cast first
foreach (object attr in attrs)
{
    Developer dev = (Developer)attr;  // Cast first!
    Console.WriteLine(dev.Name);       // Now can access properties
}

// ✅ BETTER: Use generic version (no casting needed)
foreach (Developer dev in type.GetCustomAttributes<Developer>())
{
    Console.WriteLine(dev.Name);  // Direct access, no cast!
}

// ✅ BEST: Use LINQ for filtering
var arthorClasses = type.GetCustomAttributes<Developer>()
    .Where(d => d.Name == "Arthor");

Real Example: Filtering Classes by Developer Name

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
class Developer : Attribute
{
    public string Name { get; init; }
    public double Version { get; init; }
    public Developer(string name, double version)
    {
        Name = name;
        Version = version;
    }
}

[Developer("Arthor", 1.0)]
[Developer("Alice", 1.1)]
class Class1 { }

[Developer("Alex", 2.0)]
class Class2 { }

[Developer("Arthor", 4.0)]
class Class3 { }

// Get all classes with Developer attribute
Assembly assembly = Assembly.GetExecutingAssembly();
Type[] allTypes = assembly.GetTypes();

// Filter 1: Classes that have the attribute
var classesWithDevAttr = allTypes.Where(t =>
    t.IsClass &&
    !t.IsAbstract &&
    Attribute.IsDefined(t, typeof(Developer))
);

// Filter 2: Classes by specific developer
string targetDev = "Arthor";

// ❌ WRONG: Trying to filter without proper casting
// var wrong = allTypes.Where(t => 
//     t.GetCustomAttributes(typeof(Developer), false)[0].Name == targetDev);
//     ↑ This fails! object[] doesn't have Name property

// ✅ CORRECT Method 1: Legacy way with casting
var classesByDev1 = allTypes.Where(t =>
    t.IsClass &&
    !t.IsAbstract &&
    t.GetCustomAttributes(typeof(Developer), false)  // Returns object[]
        .Cast<Developer>()                            // Convert to Developer
        .Any(d => d.Name == targetDev)                // Now can access Name
);

// ✅ CORRECT Method 2: Modern generic way (PREFERRED)
var classesByDev2 = allTypes.Where(t =>
    t.IsClass &&
    !t.IsAbstract &&
    t.GetCustomAttributes<Developer>()     // Already typed!
        .Any(d => d.Name == targetDev)     // Direct property access
);

// Display results
Console.WriteLine($"Classes by {targetDev}:");
foreach (var type in classesByDev2)
{
    Console.WriteLine($"\nClass: {type.Name}");

    // Get all Developer attributes for this class
    var devAttrs = type.GetCustomAttributes<Developer>();

    foreach (var dev in devAttrs)
    {
        Console.WriteLine($"  -> Developer: {dev.Name}, Version: {dev.Version:F1}");
    }
}

// Output:
// Classes by Arthor:
// 
// Class: Class1
//   -> Developer: Arthor, Version: 1.0
//   -> Developer: Alice, Version: 1.1
// 
// Class: Class3
//   -> Developer: Arthor, Version: 4.0

Attributes on Properties

// Define
public class User
{
    [Required]
    [StringLength(50)]
    public string Name { get; set; }

    [Column("email_address")]
    public string Email { get; set; }
}

// Read from single property
PropertyInfo prop = typeof(User).GetProperty("Name");
var required = prop.GetCustomAttribute<RequiredAttribute>();
var stringLength = prop.GetCustomAttribute<StringLengthAttribute>();

// Read from all properties
Type type = typeof(User);
foreach (PropertyInfo prop in type.GetProperties())
{
    var columnAttr = prop.GetCustomAttribute<ColumnAttribute>();
    if (columnAttr != null)
    {
        Console.WriteLine($"{prop.Name} -> {columnAttr.Name}");
    }
}

Attributes on Methods

// Define
public class UserService
{
    [Obsolete("Use GetUserByIdAsync instead")]
    public User GetUser(int id) => null;

    [HttpGet("api/users/{id}")]
    public async Task<User> GetUserByIdAsync(int id) => null;
}

// Read
MethodInfo method = typeof(UserService).GetMethod("GetUser");
var obsolete = method.GetCustomAttribute<ObsoleteAttribute>();

if (obsolete != null)
{
    Console.WriteLine(obsolete.Message);
}

Attributes on Parameters

// Define
public void UpdateUser([FromBody] User user, [FromQuery] int id) { }

// Read
MethodInfo method = typeof(MyController).GetMethod("UpdateUser");
ParameterInfo[] parameters = method.GetParameters();

foreach (var param in parameters)
{
    var fromBody = param.GetCustomAttribute<FromBodyAttribute>();
    if (fromBody != null)
    {
        Console.WriteLine($"{param.Name} is from body");
    }
}

Real-World Pattern #1: Validation Framework

// 1. Define validation attributes
public class RequiredAttribute : Attribute { }

public class RangeAttribute : Attribute
{
    public int Min { get; }
    public int Max { get; }
    public RangeAttribute(int min, int max)
    {
        Min = min;
        Max = max;
    }
}

public class EmailAttribute : Attribute { }

// 2. Use on model
public class User
{
    [Required]
    public string Name { get; set; }

    [Required]
    [Email]
    public string Email { get; set; }

    [Range(18, 100)]
    public int Age { get; set; }
}

// 3. Create validator
public static class Validator
{
    public static List<string> Validate(object obj)
    {
        var errors = new List<string>();
        Type type = obj.GetType();

        foreach (PropertyInfo prop in type.GetProperties())
        {
            object value = prop.GetValue(obj);

            // Check Required
            if (prop.IsDefined(typeof(RequiredAttribute)))
            {
                if (value == null || string.IsNullOrWhiteSpace(value.ToString()))
                {
                    errors.Add($"{prop.Name} is required");
                }
            }

            // Check Range
            var rangeAttr = prop.GetCustomAttribute<RangeAttribute>();
            if (rangeAttr != null && value is int intValue)
            {
                if (intValue < rangeAttr.Min || intValue > rangeAttr.Max)
                {
                    errors.Add($"{prop.Name} must be between {rangeAttr.Min} and {rangeAttr.Max}");
                }
            }

            // Check Email
            if (prop.IsDefined(typeof(EmailAttribute)))
            {
                if (value != null && !value.ToString().Contains("@"))
                {
                    errors.Add($"{prop.Name} must be a valid email");
                }
            }
        }

        return errors;
    }
}

// 4. Usage
var user = new User { Name = "", Email = "invalid", Age = 15 };
var errors = Validator.Validate(user);

foreach (var error in errors)
{
    Console.WriteLine(error);
}
// Output:
// Name is required
// Email must be a valid email
// Age must be between 18 and 100

Real-World Pattern #2: Simple ORM (Object-Relational Mapping)

// 1. Define attributes
[AttributeUsage(AttributeTargets.Class)]
public class TableAttribute : Attribute
{
    public string Name { get; }
    public TableAttribute(string name) => Name = name;
}

[AttributeUsage(AttributeTargets.Property)]
public class ColumnAttribute : Attribute
{
    public string Name { get; }
    public ColumnAttribute(string name) => Name = name;
}

[AttributeUsage(AttributeTargets.Property)]
public class PrimaryKeyAttribute : Attribute { }

// 2. Use on model
[Table("users")]
public class User
{
    [PrimaryKey]
    [Column("user_id")]
    public int Id { get; set; }

    [Column("user_name")]
    public string Name { get; set; }

    [Column("email_address")]
    public string Email { get; set; }

    public int Age { get; set; }  // No attribute = ignored
}

// 3. Create SQL generator
public static class SqlGenerator
{
    public static string GenerateInsert<T>(T obj)
    {
        Type type = typeof(T);

        // Get table name
        var tableAttr = type.GetCustomAttribute<TableAttribute>();
        string tableName = tableAttr?.Name ?? type.Name;

        var columns = new List<string>();
        var values = new List<string>();

        foreach (PropertyInfo prop in type.GetProperties())
        {
            // Skip if no Column attribute
            var columnAttr = prop.GetCustomAttribute<ColumnAttribute>();
            if (columnAttr == null) continue;

            // Skip primary key (usually auto-increment)
            if (prop.IsDefined(typeof(PrimaryKeyAttribute))) continue;

            columns.Add(columnAttr.Name);

            object value = prop.GetValue(obj);
            string valueStr = value is string ? $"'{value}'" : value.ToString();
            values.Add(valueStr);
        }

        return $"INSERT INTO {tableName} ({string.Join(", ", columns)}) " +
               $"VALUES ({string.Join(", ", values)})";
    }

    public static string GenerateSelect<T>()
    {
        Type type = typeof(T);
        var tableAttr = type.GetCustomAttribute<TableAttribute>();
        string tableName = tableAttr?.Name ?? type.Name;

        var columns = new List<string>();

        foreach (PropertyInfo prop in type.GetProperties())
        {
            var columnAttr = prop.GetCustomAttribute<ColumnAttribute>();
            if (columnAttr != null)
            {
                columns.Add(columnAttr.Name);
            }
        }

        return $"SELECT {string.Join(", ", columns)} FROM {tableName}";
    }
}

// 4. Usage
var user = new User 
{ 
    Name = "John", 
    Email = "john@example.com", 
    Age = 30 
};

string insertSql = SqlGenerator.GenerateInsert(user);
Console.WriteLine(insertSql);
// INSERT INTO users (user_name, email_address) VALUES ('John', 'john@example.com')

string selectSql = SqlGenerator.GenerateSelect<User>();
Console.WriteLine(selectSql);
// SELECT user_id, user_name, email_address FROM users

Real-World Pattern #3: API Route Registration

// 1. Define route attribute
[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public class RouteAttribute : Attribute
{
    public string Method { get; }  // GET, POST, etc.
    public string Path { get; }

    public RouteAttribute(string method, string path)
    {
        Method = method;
        Path = path;
    }
}

// 2. Use on controller
public class UserController
{
    [Route("GET", "/api/users")]
    public List<User> GetAllUsers()
    {
        return new List<User>();
    }

    [Route("GET", "/api/users/{id}")]
    public User GetUser(int id)
    {
        return null;
    }

    [Route("POST", "/api/users")]
    public void CreateUser(User user)
    {
    }
}

// 3. Create route scanner
public class RouteScanner
{
    public static void RegisterRoutes(Type controllerType)
    {
        foreach (MethodInfo method in controllerType.GetMethods())
        {
            var routes = method.GetCustomAttributes<RouteAttribute>();

            foreach (var route in routes)
            {
                Console.WriteLine($"{route.Method} {route.Path} -> {method.Name}");
            }
        }
    }
}

// 4. Usage
RouteScanner.RegisterRoutes(typeof(UserController));
// Output:
// GET /api/users -> GetAllUsers
// GET /api/users/{id} -> GetUser
// POST /api/users -> CreateUser

Real-World Pattern #4: Dependency Injection Container

// 1. Define attributes
[AttributeUsage(AttributeTargets.Class)]
public class ServiceAttribute : Attribute
{
    public ServiceLifetime Lifetime { get; }
    public ServiceAttribute(ServiceLifetime lifetime = ServiceLifetime.Transient)
    {
        Lifetime = lifetime;
    }
}

public enum ServiceLifetime { Transient, Singleton }

// 2. Use on services
[Service(ServiceLifetime.Singleton)]
public class Logger
{
    public void Log(string message) => Console.WriteLine(message);
}

[Service(ServiceLifetime.Transient)]
public class UserService
{
    private readonly Logger _logger;

    public UserService(Logger logger)
    {
        _logger = logger;
    }
}

// 3. Create simple container
public class SimpleContainer
{
    private readonly Dictionary<Type, object> _singletons = new();
    private readonly Dictionary<Type, Type> _registrations = new();

    public void AutoRegister(Assembly assembly)
    {
        var types = assembly.GetTypes()
            .Where(t => t.IsDefined(typeof(ServiceAttribute)));

        foreach (var type in types)
        {
            _registrations[type] = type;
        }
    }

    public T Resolve<T>()
    {
        Type type = typeof(T);
        var serviceAttr = type.GetCustomAttribute<ServiceAttribute>();

        // Singleton: return cached instance
        if (serviceAttr?.Lifetime == ServiceLifetime.Singleton)
        {
            if (_singletons.TryGetValue(type, out var singleton))
                return (T)singleton;

            var instance = CreateInstance(type);
            _singletons[type] = instance;
            return (T)instance;
        }

        // Transient: create new instance
        return (T)CreateInstance(type);
    }

    private object CreateInstance(Type type)
    {
        // Get constructor
        var constructor = type.GetConstructors().First();

        // Resolve dependencies
        var parameters = constructor.GetParameters()
            .Select(p => Resolve(p.ParameterType))
            .ToArray();

        // Create instance
        return Activator.CreateInstance(type, parameters);
    }

    private object Resolve(Type type)
    {
        var method = GetType().GetMethod("Resolve").MakeGenericMethod(type);
        return method.Invoke(this, null);
    }
}

// 4. Usage
var container = new SimpleContainer();
container.AutoRegister(Assembly.GetExecutingAssembly());

var service1 = container.Resolve<UserService>();
var service2 = container.Resolve<UserService>();

var logger1 = container.Resolve<Logger>();
var logger2 = container.Resolve<Logger>();

// logger1 == logger2 (Singleton)
// service1 != service2 (Transient)

Real-World Pattern #5: Test Data Builder

// 1. Define attribute
[AttributeUsage(AttributeTargets.Property)]
public class TestDataAttribute : Attribute
{
    public object DefaultValue { get; }
    public TestDataAttribute(object defaultValue)
    {
        DefaultValue = defaultValue;
    }
}

// 2. Use on model
public class User
{
    [TestData("John Doe")]
    public string Name { get; set; }

    [TestData("john@example.com")]
    public string Email { get; set; }

    [TestData(25)]
    public int Age { get; set; }
}

// 3. Create builder
public static class TestDataBuilder
{
    public static T Build<T>() where T : new()
    {
        T obj = new T();
        Type type = typeof(T);

        foreach (PropertyInfo prop in type.GetProperties())
        {
            var attr = prop.GetCustomAttribute<TestDataAttribute>();
            if (attr != null)
            {
                prop.SetValue(obj, attr.DefaultValue);
            }
        }

        return obj;
    }
}

// 4. Usage (in tests)
var testUser = TestDataBuilder.Build<User>();
Console.WriteLine(testUser.Name);   // John Doe
Console.WriteLine(testUser.Email);  // john@example.com
Console.WriteLine(testUser.Age);    // 25

Working with Generic Types

// Define generic class
public class Repository<T> where T : class
{
    public void Save(T entity) { }
}

// Get generic type info
Type genericType = typeof(Repository<>);  // Open generic
Type closedType = typeof(Repository<User>);  // Closed generic

Console.WriteLine(genericType.IsGenericType);           // true
Console.WriteLine(genericType.IsGenericTypeDefinition); // true
Console.WriteLine(closedType.IsGenericType);            // true
Console.WriteLine(closedType.IsGenericTypeDefinition);  // false

// Get generic arguments
Type[] typeArgs = closedType.GetGenericArguments();
Console.WriteLine(typeArgs[0].Name);  // "User"

// Create instance of generic type
Type repoType = typeof(Repository<>).MakeGenericType(typeof(User));
object repo = Activator.CreateInstance(repoType);

Working with Interfaces

// Check if type implements interface
Type type = typeof(User);
bool implementsIComparable = type.GetInterfaces().Contains(typeof(IComparable));

// Or
bool implements = typeof(IComparable).IsAssignableFrom(type);

// Get all types implementing interface
var implementations = Assembly.GetExecutingAssembly()
    .GetTypes()
    .Where(t => typeof(IMyInterface).IsAssignableFrom(t) && !t.IsInterface);

Creating Instances Dynamically

// Method 1: Activator.CreateInstance (simple)
User user1 = (User)Activator.CreateInstance(typeof(User));

// Method 2: Activator.CreateInstance with parameters
var user2 = (User)Activator.CreateInstance(
    typeof(User), 
    new object[] { "John", 25 }  // Constructor params
);

// Method 3: Using ConstructorInfo
Type type = typeof(User);
ConstructorInfo ctor = type.GetConstructor(new[] { typeof(string), typeof(int) });
var user3 = (User)ctor.Invoke(new object[] { "John", 25 });

// Method 4: Generic
T CreateInstance<T>() where T : new()
{
    return new T();  // Requires parameterless constructor
}

// Method 5: Using expression trees (fastest for repeated use)
var ctor = typeof(User).GetConstructor(Type.EmptyTypes);
var newExp = Expression.New(ctor);
var lambda = Expression.Lambda<Func<User>>(newExp);
var factory = lambda.Compile();
var user4 = factory();  // Very fast after compilation

Invoking Methods Dynamically

public class Calculator
{
    public int Add(int a, int b) => a + b;
    public int Multiply(int a, int b) => a * b;
}

// Get method
Type type = typeof(Calculator);
MethodInfo method = type.GetMethod("Add");

// Invoke
Calculator calc = new Calculator();
object result = method.Invoke(calc, new object[] { 5, 3 });
Console.WriteLine(result);  // 8

// Invoke static method
// MethodInfo staticMethod = type.GetMethod("StaticMethod");
// object result = staticMethod.Invoke(null, parameters);

Getting/Setting Properties Dynamically

public class User
{
    public string Name { get; set; }
    public int Age { get; set; }
}

User user = new User();
PropertyInfo nameProp = typeof(User).GetProperty("Name");

// Set value
nameProp.SetValue(user, "John");

// Get value
object value = nameProp.GetValue(user);
Console.WriteLine(value);  // John

Performance Tips

⚠️ Reflection is SLOW

// Slow: Reflection in loop
for (int i = 0; i < 1000000; i++)
{
    var method = typeof(MyClass).GetMethod("MyMethod");
    method.Invoke(instance, null);
}

// Fast: Cache reflection results
var method = typeof(MyClass).GetMethod("MyMethod");
for (int i = 0; i < 1000000; i++)
{
    method.Invoke(instance, null);
}

// Faster: Compile to delegate
var method = typeof(MyClass).GetMethod("MyMethod");
var action = (Action)Delegate.CreateDelegate(typeof(Action), instance, method);
for (int i = 0; i < 1000000; i++)
{
    action();  // Much faster
}

Caching Pattern

public static class AttributeCache
{
    private static readonly ConcurrentDictionary<Type, object> _cache = new();

    public static T GetAttribute<T>(Type type) where T : Attribute
    {
        return (T)_cache.GetOrAdd(type, t => t.GetCustomAttribute<T>());
    }
}

Common Reflection Methods Cheat Sheet

// TYPE INFO
Type type = typeof(User);
type.Name                    // "User"
type.FullName                // "MyNamespace.User"
type.IsClass                 // true
type.IsInterface             // false
type.IsAbstract              // false
type.IsSealed                // false
type.BaseType                // typeof(object)
type.GetInterfaces()         // All interfaces

// ATTRIBUTES
type.GetCustomAttribute<T>()           // Single attribute
type.GetCustomAttributes<T>()          // Multiple attributes
type.IsDefined(typeof(T))              // Check if has attribute

// CONSTRUCTORS
type.GetConstructor(Type[])            // Specific constructor
type.GetConstructors()                 // All public constructors

// PROPERTIES
type.GetProperty("Name")               // Specific property
type.GetProperties()                   // All public properties
prop.GetValue(obj)                     // Get property value
prop.SetValue(obj, value)              // Set property value
prop.GetCustomAttribute<T>()           // Property attribute

// METHODS
type.GetMethod("MethodName")           // Specific method
type.GetMethods()                      // All public methods
method.Invoke(instance, parameters)    // Invoke method
method.GetCustomAttribute<T>()         // Method attribute

// FIELDS
type.GetField("fieldName")             // Specific field
type.GetFields()                       // All public fields

// CREATING INSTANCES
Activator.CreateInstance(type)         // Create instance
Activator.CreateInstance(type, args)   // With constructor params

// ASSEMBLIES
Assembly.GetExecutingAssembly()        // Current assembly
Assembly.GetTypes()                    // All types in assembly

Quick Decision Guide

When to Use Attributes?

✅ Validation rules
✅ API routing
✅ Database mapping
✅ Serialization control
✅ Testing metadata
✅ Configuration
❌ Business logic (use methods)
❌ Performance-critical paths

When to Use Reflection?

✅ Framework/library code
✅ Plugin systems
✅ ORM implementation
✅ Dependency injection
✅ Test frameworks
✅ Code generation tools
❌ Application code (usually)
❌ Tight loops (cache results)

Summary: How Frameworks Use This

ASP.NET Core

[HttpGet("api/users/{id}")]  // Routing
public User GetUser(int id) { }

Framework reads HttpGet attribute to register route.

Entity Framework

[Table("users")]
public class User
{
    [Key]
    public int Id { get; set; }
}

EF reads attributes to generate SQL.

Data Annotations

[Required]
[StringLength(50)]
public string Name { get; set; }

ASP.NET reads these to validate form data.

Dependency Injection

services.AddTransient<IUserService, UserService>();

DI container uses reflection to create instances and inject dependencies.

Final Tips

Attributes are metadata - They describe code, they don't execute
Reflection reads metadata - At runtime, using Type, PropertyInfo, etc.
Cache reflection results - Reflection is slow, cache what you find
Convention: End attribute names with "Attribute" - But you can omit it in code
Use AttributeUsage - Control where attributes can be applied
GetCustomAttribute vs IsDefined - Use IsDefined when you only need to check existence
Performance matters - Avoid reflection in hot paths
Most developers use - Existing framework attributes, rarely create custom ones

Remember: You'll use existing attributes (from frameworks) 90% of the time. Creating custom attributes is mainly for building your own frameworks or tools.

C# Collections Quick Reference

RecurPixel — Wed, 19 Nov 2025 06:33:33 +0000

This guide provides a concise, side-by-side comparison of 13 fundamental C# collection types, from fixed-size Arrays to dynamic Lists and key-value Dictionaries. No need to search docs; Quickly review their core type, creation, access methods, key properties, and static vs. instance member patterns to choose the right structure for your data.

1. Array Class

Type: Fixed-size, indexed, immutable length

Creation

int[] arr1 = new int[5];                    // default values
int[] arr2 = {1, 2, 3, 4, 5};              // initializer
int[] arr3 = new int[] {1, 2, 3};          // explicit

Access

Index: arr[0], arr[^1] (last element)
for loop: for(int i=0; i<arr.Length; i++)
foreach: foreach(int x in arr)

Add/Remove

❌ Cannot add/remove (fixed size)
Use Array.Resize(ref arr, newSize) to create new array

Key Methods & Properties

INSTANCE (called on object: myArray.Property):

Length - number of elements
Rank - number of dimensions (1 for single-dimensional)
GetLength(dimension) - length of specific dimension
Clone() - shallow copy
IsFixedSize - always true
IsReadOnly - usually false
IsSynchronized - false (not thread-safe)
SyncRoot - object for thread synchronization

STATIC (called on type: Array.Method()):

Sort(array) - sorts array
Reverse(array) - reverses order
IndexOf(array, value) - find element index
Clear(array, index, length) - sets elements to default
Copy(source, dest, length) - copy elements
Resize(ref array, newSize) - resize array
Find(array, predicate) - find first match
FindAll(array, predicate) - find all matches
Exists(array, predicate) - check if any match

2. List

Type: Dynamic array, indexed, mutable, generic

Creation

List<int> list1 = new List<int>();              // empty
List<int> list2 = new List<int>(10);            // capacity
List<int> list3 = new List<int> {1, 2, 3};      // initializer
List<int> list4 = new List<int>(array);         // from collection

Access

Index: list[0]
for loop: for(int i=0; i<list.Count; i++)
foreach: foreach(int x in list)

Add/Remove

Add: Add(), AddRange(), Insert()
Remove: Remove(), RemoveAt(), RemoveAll(), RemoveRange(), Clear()

Key Methods & Properties

ALL INSTANCE (called on object: myList.Method()):

Count - number of elements
Capacity - allocated size
Add(item) - add element
AddRange(collection) - add multiple
Insert(index, item) - insert at position
Remove(item) - remove first occurrence
RemoveAt(index) - remove at index
RemoveAll(predicate) - remove matching
Clear() - remove all
Contains(item) - check if exists
IndexOf(item) - find index
Sort() - sort list
Reverse() - reverse order
Find(predicate) - find first match
FindAll(predicate) - find all matches
ToArray() - convert to array
IsReadOnly - always false

NO STATIC methods - List has only instance members

3. ArrayList

Type: Dynamic array, indexed, mutable, non-generic (stores objects)

Creation

ArrayList arr1 = new ArrayList();               // empty
ArrayList arr2 = new ArrayList(10);             // capacity
ArrayList arr3 = new ArrayList {1, "two", 3.0}; // mixed types

Access

Index: arr[0] (returns object, needs casting)
for loop: for(int i=0; i<arr.Count; i++)
foreach: foreach(object x in arr)

Add/Remove

Add: Add(), AddRange(), Insert(), InsertRange()
Remove: Remove(), RemoveAt(), RemoveRange(), Clear()

Key Methods & Properties

ALL INSTANCE (called on object: myArrayList.Method()):

Count - number of elements
Capacity - allocated size
Add(item) - add element
AddRange(collection) - add multiple
Insert(index, item) - insert at position
InsertRange(index, collection) - insert multiple
Remove(item) - remove first occurrence
RemoveAt(index) - remove at index
RemoveRange(index, count) - remove range
Clear() - remove all
Contains(item) - check if exists
IndexOf(item) - find index
Sort() - sort elements
Reverse() - reverse order
IsFixedSize - false (dynamic)
IsReadOnly - false
IsSynchronized - false (not thread-safe)
SyncRoot - object for thread synchronization

NO STATIC methods
⚠️ Boxing/Unboxing overhead - prefer List<T>

4. SortedList

Type: Key-value pairs, automatically sorted by key, indexed

Creation

SortedList<int, string> sl1 = new SortedList<int, string>();
SortedList<int, string> sl2 = new SortedList<int, string> 
{
    {1, "one"}, {2, "two"}
};

Access

By key: sl[1]
By index: sl.Keys[0], sl.Values[0]
foreach: foreach(KeyValuePair<int,string> kvp in sl)

Add/Remove

Add: Add(key, value), throws if key exists
Remove: Remove(key), RemoveAt(index), Clear()

Key Methods & Properties

ALL INSTANCE (called on object: mySortedList.Method()):

Count - number of pairs
Keys - collection of keys
Values - collection of values
Add(key, value) - add pair
Remove(key) - remove by key
RemoveAt(index) - remove by index
Clear() - remove all
ContainsKey(key) - check key exists
ContainsValue(value) - check value exists
TryGetValue(key, out value) - safe retrieval
IndexOfKey(key) - get index of key
IndexOfValue(value) - get index of value

NO STATIC methods

5. HashSet

Type: Unordered, unique elements, no indexing, fast lookups

Creation

HashSet<int> hs1 = new HashSet<int>();
HashSet<int> hs2 = new HashSet<int> {1, 2, 3};
HashSet<int> hs3 = new HashSet<int>(array);

Access

❌ No index access
foreach only: foreach(int x in hs)
Use Contains() for membership test

Add/Remove

Add: Add() (returns false if exists), UnionWith()
Remove: Remove(), RemoveWhere(), Clear()

Key Methods & Properties

ALL INSTANCE (called on object: myHashSet.Method()):

Count - number of elements
Add(item) - add element (returns bool)
Remove(item) - remove element
RemoveWhere(predicate) - remove matching
Clear() - remove all
Contains(item) - O(1) lookup
Set operations:
- UnionWith(other) - add all from other
- IntersectWith(other) - keep only common
- ExceptWith(other) - remove all in other
- SymmetricExceptWith(other) - keep non-common
- IsSubsetOf(other) - check subset
- IsSupersetOf(other) - check superset
- Overlaps(other) - check any common
- SetEquals(other) - check same elements

NO STATIC methods

6. SortedSet

Type: Sorted order, unique elements, no indexing

Creation

SortedSet<int> ss1 = new SortedSet<int>();
SortedSet<int> ss2 = new SortedSet<int> {3, 1, 2}; // auto-sorted

Access

❌ No index access
foreach (in sorted order): foreach(int x in ss)
Min, Max properties

Add/Remove

Add: Add() (returns false if exists)
Remove: Remove(), RemoveWhere(), Clear()

Key Methods & Properties

ALL INSTANCE (called on object: mySortedSet.Method()):

Count - number of elements
Min - smallest element
Max - largest element
Add(item) - add element (returns bool)
Remove(item) - remove element
RemoveWhere(predicate) - remove matching
Clear() - remove all
Contains(item) - check membership
Set operations: (same as HashSet)
- UnionWith(other), IntersectWith(other), ExceptWith(other)
- IsSubsetOf(other), IsSupersetOf(other), Overlaps(other)
GetViewBetween(min, max) - subset in range
Reverse() - iterate in reverse order

NO STATIC methods

7. Dictionary

Type: Key-value pairs, unordered, unique keys, fast lookups

Creation

Dictionary<int, string> dict1 = new Dictionary<int, string>();
Dictionary<int, string> dict2 = new Dictionary<int, string>
{
    {1, "one"}, {2, "two"}
};
// Modern syntax:
Dictionary<int, string> dict3 = new Dictionary<int, string>
{
    [1] = "one", [2] = "two"
};

Access

By key: dict[1] (throws if not found)
foreach: foreach(KeyValuePair<int,string> kvp in dict)
foreach keys: foreach(int key in dict.Keys)
foreach values: foreach(string val in dict.Values)

Add/Remove

Add: Add(key, value) (throws if exists), dict[key] = value (upsert)
Remove: Remove(key), Clear()

Key Methods & Properties

ALL INSTANCE (called on object: myDict.Method()):

Count - number of pairs
Keys - collection of keys
Values - collection of values
Add(key, value) - add pair (throws if exists)
Remove(key) - remove by key
Clear() - remove all
ContainsKey(key) - O(1) check
ContainsValue(value) - O(n) check
TryGetValue(key, out value) - safe retrieval
TryAdd(key, value) - safe add (C# 10+)

NO STATIC methods

8. SortedDictionary

Type: Key-value pairs, sorted by key, slower than Dictionary

Creation

SortedDictionary<int, string> sd1 = new SortedDictionary<int, string>();
SortedDictionary<int, string> sd2 = new SortedDictionary<int, string>
{
    {1, "one"}, {2, "two"}
};

Access

By key: sd[1]
foreach (sorted order): foreach(KeyValuePair<int,string> kvp in sd)

Add/Remove

Add: Add(key, value), sd[key] = value
Remove: Remove(key), Clear()

Key Methods & Properties

ALL INSTANCE (called on object: mySortedDict.Method()):

Count - number of pairs
Keys - sorted keys collection
Values - values in key order
Add(key, value) - add pair
Remove(key) - remove by key
Clear() - remove all
ContainsKey(key) - check key
ContainsValue(value) - check value
TryGetValue(key, out value) - safe retrieval

NO STATIC methods

9. Hashtable

Type: Key-value pairs, non-generic, stores objects, legacy

Creation

Hashtable ht1 = new Hashtable();
Hashtable ht2 = new Hashtable 
{
    {1, "one"}, {"key", 123}  // mixed types
};

Access

By key: ht[1] (returns object, needs casting)
foreach: foreach(DictionaryEntry de in ht)

Add/Remove

Add: Add(key, value), ht[key] = value
Remove: Remove(key), Clear()

Key Methods & Properties

Count - number of pairs
Keys - collection of keys
Values - collection of values
Contains() - check key exists
ContainsKey() - check key
ContainsValue() - check value
TryGetValue() - safe retrieval
IsFixedSize - false
IsReadOnly - false
IsSynchronized - false
SyncRoot - object for synchronization
⚠️ Use Dictionary instead

10. Stack

Type: LIFO (Last In, First Out), no indexing

Creation

Stack<int> stack1 = new Stack<int>();
Stack<int> stack2 = new Stack<int>(array);

Access

❌ No index access
Peek: Peek() - view top without removing
foreach: foreach(int x in stack) (top to bottom)

Add/Remove

Add: Push(item) - add to top
Remove: Pop() - remove and return top

Key Methods & Properties

ALL INSTANCE (called on object: myStack.Method()):

Count - number of elements
Push(item) - add to top
Pop() - remove and return top
Peek() - view top without removing
Contains(item) - check if exists
Clear() - remove all
ToArray() - convert to array

NO STATIC methods

11. Queue

Type: FIFO (First In, First Out), no indexing

Creation

Queue<int> queue1 = new Queue<int>();
Queue<int> queue2 = new Queue<int>(array);

Access

❌ No index access
Peek: Peek() - view front without removing
foreach: foreach(int x in queue) (front to back)

Add/Remove

Add: Enqueue(item) - add to back
Remove: Dequeue() - remove from front

Key Methods & Properties

ALL INSTANCE (called on object: myQueue.Method()):

Count - number of elements
Enqueue(item) - add to back
Dequeue() - remove and return from front
Peek() - view front without removing
Contains(item) - check if exists
Clear() - remove all
ToArray() - convert to array

NO STATIC methods

12. LinkedList

Type: Doubly-linked list, no indexing, efficient insertion/removal

Creation

LinkedList<int> ll1 = new LinkedList<int>();
LinkedList<int> ll2 = new LinkedList<int>(array);

Access

❌ No index access
Navigate: First, Last properties return LinkedListNode<T>
foreach: foreach(int x in ll)
Node navigation: node.Next, node.Previous

Add/Remove

Add:
- AddFirst(), AddLast() - add at ends
- AddBefore(node), AddAfter(node) - add relative to node
Remove:
- Remove(value), Remove(node)
- RemoveFirst(), RemoveLast()
- Clear()

Key Methods & Properties

ALL INSTANCE (called on object: myLinkedList.Method()):

Count - number of elements
First - get first node (LinkedListNode)
Last - get last node (LinkedListNode)
AddFirst(value) - add at start
AddLast(value) - add at end
AddBefore(node, value) - add before node
AddAfter(node, value) - add after node
Remove(value) - remove first occurrence
Remove(node) - remove specific node
RemoveFirst() - remove from start
RemoveLast() - remove from end
Clear() - remove all
Find(value) - find node by value
Contains(value) - check if exists

Node properties (LinkedListNode):

Value - the data
Next - next node
Previous - previous node

NO STATIC methods

13. BitArray

Type: Array of boolean values stored as bits, mutable

Creation

BitArray ba1 = new BitArray(8);              // 8 bits, all false
BitArray ba2 = new BitArray(8, true);        // 8 bits, all true
BitArray ba3 = new BitArray(new bool[] {true, false, true});

Access

Index: ba[0] (returns bool)
for loop: for(int i=0; i<ba.Length; i++)
foreach: foreach(bool b in ba)

Add/Remove

❌ Fixed length (use constructor for size)
Modify: ba[0] = true, Set(), SetAll()

Key Methods & Properties

ALL INSTANCE (called on object: myBitArray.Method()):

Length - number of bits
Count - same as Length
Get(index) - get bit value (bool)
Set(index, value) - set bit value
SetAll(value) - set all bits to value
Bitwise operations:
- And(other) - bitwise AND
- Or(other) - bitwise OR
- Xor(other) - bitwise XOR
- Not() - bitwise NOT (flip all bits)

NO STATIC methods

Quick Comparison Table

Collection	Ordered	Unique	Indexed	Add/Remove Methods	Use Case
Array	Yes	No	Yes	❌ (fixed)	Fixed-size data
List	Yes	No	Yes	Add, Remove	Dynamic arrays
ArrayList	Yes	No	Yes	Add, Remove	Legacy (avoid)
SortedList	Sorted	Keys only	Yes	Add, Remove	Small sorted key-values
HashSet	No	Yes	No	Add, Remove	Unique items, fast lookup
SortedSet	Sorted	Yes	No	Add, Remove	Unique + sorted
Dictionary	No	Keys only	By key	Add, Remove	Fast key-value lookup
SortedDictionary	Sorted	Keys only	By key	Add, Remove	Sorted key-values
Hashtable	No	Keys only	By key	Add, Remove	Legacy (avoid)
Stack	LIFO	No	No	Push, Pop	LIFO operations
Queue	FIFO	No	No	Enqueue, Dequeue	FIFO operations
LinkedList	Yes	No	No	AddFirst/Last	Frequent insert/remove
BitArray	Yes	No	Yes	Set	Boolean flags

How to Identify Static vs Instance Members On-The-Fly

Visual Studio / Rider / IDE Clues

IntelliSense Icons:

Static members: Purple/magenta box 📦 or "S" marker
Instance members: Blue cube 🔷 or standard method/property icons
Properties: Wrench icon 🔧
Methods: Purple box/cube

Quick Test Method:

// Type the CLASS NAME + dot
Array.   // Shows ONLY static members

// Type your VARIABLE NAME + dot  
myArray.   // Shows ONLY instance members

Syntax Rules

Static: ClassName.Member()

Array.Sort(myArray);           // static method
Array.IndexOf(myArray, 5);     // static method
Array.Resize(ref myArray, 10); // static method

Instance: variableName.Member()

myArray.Length;      // instance property
myList.Add(10);      // instance method
myDict.Count;        // instance property

Collection-Specific Patterns

Array - THE ONLY ONE with common static methods:

Static: Array.Sort(), Array.Reverse(), Array.Copy(), Array.IndexOf(), Array.Clear(), Array.Resize()
Instance: Length, Rank, GetLength(), Clone()
Why? Array is a special class, methods operate on any array type

ALL Generic Collections (List<T>, Dictionary, HashSet, etc.):

✅ ALL instance members only
❌ NO static methods
Why? Modern design - everything works on the object itself

Legacy Collections (ArrayList, Hashtable):

✅ ALL instance members only
❌ NO static methods
Have extra instance properties: IsSynchronized, SyncRoot

Memory Trick: "Array is Special"

Simple Rule:

Array: Mix of static + instance (only collection with static methods)
Everything else: Instance only

Examples:

// Array - uses STATIC methods
int[] arr = {3, 1, 2};
Array.Sort(arr);              // ✓ Static
Array.Reverse(arr);           // ✓ Static
int len = arr.Length;         // ✓ Instance

// List - uses INSTANCE methods
List<int> list = new List<int> {3, 1, 2};
list.Sort();                  // ✓ Instance
list.Reverse();               // ✓ Instance
int count = list.Count;       // ✓ Instance

// Dictionary - ALL instance
Dictionary<int, string> dict = new Dictionary<int, string>();
dict.Add(1, "one");          // ✓ Instance
dict.ContainsKey(1);         // ✓ Instance
int count = dict.Count;      // ✓ Instance

Why Array Has Static Methods?

Historical reason:

Array existed before generics
Static methods work on ALL array types: int[], string[], MyClass[]
Array.Sort() can sort any array without duplicating code

Modern collections:

Generic methods built into each class
list.Sort() is type-specific for List<T>
Cleaner design - methods belong to the object

Documentation Clue

When reading docs or hover tooltips:

// Static - shows class name in signature
public static void Sort(Array array)

// Instance - no class name, just method
public void Add(T item)

Special Properties Explained

Which Collections Have Special Properties?

Legacy/Non-Generic Collections ONLY:

Array - has Rank, IsFixedSize, IsReadOnly, IsSynchronized, SyncRoot
ArrayList - has IsFixedSize, IsReadOnly, IsSynchronized, SyncRoot
Hashtable - has IsFixedSize, IsReadOnly, IsSynchronized, SyncRoot
Queue (non-generic) - has IsSynchronized, SyncRoot
Stack (non-generic) - has IsSynchronized, SyncRoot

Modern/Generic Collections DO NOT have these:

List<T>, Dictionary<TKey,TValue>, HashSet<T>, SortedSet<T>, Queue<T>, Stack<T>, LinkedList<T> - NONE of these special properties

Why the Difference?

Legacy Collections (pre-.NET 2.0):

Built when multithreading was handled differently
Implement ICollection interface (non-generic) which requires:
- IsSynchronized - is collection thread-safe?
- SyncRoot - object to lock on for thread safety
- IsFixedSize - can size change?
- IsReadOnly - can items be modified?

Modern Generic Collections (.NET 2.0+):

Built with better design principles
Thread safety handled externally (use ConcurrentDictionary<TKey,TValue>, ConcurrentQueue<T>, etc.)
Don't clutter API with rarely-used properties
Simpler, cleaner interfaces

Property Meanings:

Rank (Array only)

Number of dimensions
int[] arr has Rank = 1
int[,] arr has Rank = 2
Use GetLength(dimension) to get size of each dimension

IsFixedSize

true = cannot add/remove elements (Array)
false = can grow/shrink (ArrayList, Hashtable)

IsReadOnly

true = cannot modify elements
Usually false for standard collections

IsSynchronized

true = thread-safe (rarely true by default)
false = NOT thread-safe (most collections)
Legacy property, modern code uses Concurrent* collections

SyncRoot

Object to use with lock() statement for thread safety
Modern code: use Concurrent* collections instead of locking
Example (legacy pattern - avoid):

lock(myArrayList.SyncRoot) 
{
    // thread-safe operations
}

Quick Rule:

Using generics (<T>)? No special properties.
Using old non-generic? Has special properties.
Need thread safety? Use System.Collections.Concurrent namespace (ConcurrentDictionary, ConcurrentQueue, ConcurrentBag, etc.)

Key Terminology

Immutable Length: Size cannot change (Array)
Mutable: Can add/remove elements
Generic: Type-safe (List, Dictionary)
Non-Generic: Stores objects, requires casting (ArrayList, Hashtable)
LIFO: Last In, First Out (Stack)
FIFO: First In, First Out (Queue)
Ordered: Maintains insertion order
Sorted: Automatically sorted by key/value
Indexed: Can access by numeric index
O(1): Constant time operation (very fast)
O(n): Linear time operation (slower with more items)