10 Mind-Bending C# Hacks

.NET snippets and features not many know about.

Hey there, fellow coders!

I like to call these neat tricks ‘hacks’, not because they’re shortcuts or cheats, but because they’re clever, underused features in C# that offer some really creative solutions.

These ‘hacks’ showcase the versatility and depth of C# in ways you might not have explored before.

They’re all about thinking outside the box and using the language in inventive ways that go beyond the everyday code. Let’s dive in!

1. Reflection Emit for Dynamic Type Creation

Need to create a new type during runtime? Reflection Emit can do that. It’s a bit tricky, but once you get the hang of it, you’ll be able to create types dynamically whenever you need them.

var assemblyName = new AssemblyName("DynamicAssembly");
var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
var moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");
var typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public);
var dynamicType = typeBuilder.CreateType();
// Now you have a brand new type to play with!

2. Custom Async Stream Implementations

Dealing with data streams? Custom async streams can make this easier.

You can process data in chunks without blocking your app, which is especially helpful with large data sets.

public async IAsyncEnumerable<int> FetchLargeData()
{
    for (int i = 0; i < 1000; i++)
    {
        await Task.Delay(100); // Simulating data fetching
        yield return i;
    }
}

3. Harnessing Channels for Concurrency

When you’ve got data coming from one place and going to another, Channels help keep everything orderly. It’s a clean way to handle data in scenarios where you’ve got multiple tasks working together.

var channel = Channel.CreateUnbounded<string>();
await channel.Writer.WriteAsync("Hello, Channels!");
var message = await channel.Reader.ReadAsync();
Console.WriteLine(message); // No more traffic jams in your data flow!

4. Dynamic Expressions with Linq.Expressions

Ever need to build queries on the fly? Linq.Expressions lets you do just that. It’s a flexible way to create and run queries based on different conditions at runtime.

var parameter = Expression.Parameter(typeof(Person), "person");
var property = Expression.Property(parameter, "Name");
var constant = Expression.Constant("Alice");
var equal = Expression.Equal(property, constant);
var lambda = Expression.Lambda<Func<Person, bool>>(equal, parameter);
// Now you've got a dynamic expression to find all people named Alice!

5. Tapping into Runtime Compiled Expressions

Imagine compiling and running C# code while your app is running. With CSharpCodeProvider, you can do just that. It's like being able to change the engine of a car while it's still driving.

CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters { GenerateInMemory = true };
CompilerResults results = provider.CompileAssemblyFromSource(parameters, "public class RuntimeCode { public int Add(int a, int b) { return a + b; } }");
object runtimeInstance = results.CompiledAssembly.CreateInstance("RuntimeCode");
MethodInfo addMethod = runtimeInstance.GetType().GetMethod("Add");
int result = (int)addMethod.Invoke(runtimeInstance, new object[] { 1, 2 });
Console.WriteLine($"Dynamic addition result: {result}");

6. Efficient Object Pooling for Resource Management

Ever had issues with resource management, like running out of objects under heavy load?

Implementing an object pool is a neat trick. It allows you to reuse objects instead of creating new ones every time, which can significantly improve performance, especially in high-load scenarios.

ObjectPool<MyResource> pool = new DefaultObjectPool<MyResource>(new DefaultPooledObjectPolicy<MyResource>());
MyResource resource = pool.Get();
// Use the resource
pool.Return(resource);

7. Custom EventSource for High-Performance Logging

Need to log events in your application without slowing it down? Creating a custom EventSource is a great solution. This allows you to log important information efficiently, which is crucial for tracking down issues and monitoring performance.

[EventSource(Name = "MyCustomEventSource")]
public class MyEventSource : EventSource
{
    public void LogMyEvent(string message) => WriteEvent(1, message);
}
// Usage
var myEventSource = new MyEventSource();
myEventSource.LogMyEvent("This is a custom event log message.");

8. Exploiting ArrayPool for Efficient Array Management

Have you ever needed a big array for a short time and worried about wasting memory? ArrayPool is a neat solution. It lets you reuse large arrays without constantly creating new ones, which is great for keeping your app's memory usage down.

int[] pooledArray = ArrayPool<int>.Shared.Rent(1000);
// Use the array...
ArrayPool<int>.Shared.Return(pooledArray); // Return the array to the pool for reuse

9. Custom JIT Compiler Controls

Sometimes you want certain parts of your code to run really fast.

With RuntimeHelpers.PrepareMethod, you can have the JIT compiler pre-compile specific methods. This means they'll run quicker when you need them to.

var method = typeof(MyClass).GetMethod("MyMethod").MethodHandle;
RuntimeHelpers.PrepareMethod(method);
// The JIT compiler pre-compiles the specified method

10. Utilizing ConditionalAttribute for Flexible Debugging

Debugging code that shouldn’t run in production can be tricky.

ConditionalAttribute is super handy for this. It lets you include debug-only methods in your code without them getting in the way in the final product.

[Conditional("DEBUG")]
public void LogDebugInfo(string message)
{
    Console.WriteLine($"Debug: {message}");
}

public void ProcessData()
{
    LogDebugInfo("Processing data..."); // This call only happens in DEBUG mode
}

Finally

Thank you for reading! I hope you learned something new :) In my journey of programming, though not very often, I keep coming back to these “hacks”.

Follow and subscribe to my newsletter for weekly .NET tips and tricks.