DEV Community: Marmik soni

New Blog Alert!

Marmik soni — Thu, 17 Oct 2024 06:57:24 +0000

Yeah, that’s not a movie plot—it actually happened!

Dan Saunders wasn’t a hacker or a criminal mastermind. He was just a regular guy who found an ATM loophole and ended up spending nearly $1.6 million (yes, MILLION) on luxury hotels, private jets, and wild parties, all with money he didn’t really have.

It’s a crazy story that involves everything from outdated banking systems to a once-in-a-lifetime glitch. And guess what? I’ve just dropped a new blog about how it all went down!

Go read my latest blog: Dan Saunders: The ATM Glitch That Defied Financial Systems

In it, I break down:

How Dan discovered the glitch
The insane things he did with all that money
How the financial system got played (and eventually caught up with him)
And of course, the lessons for us as developers to avoid this kind of glitch in the systems we build!

🔗 Read the full blog here

Trust me, this one’s a wild ride you don’t want to miss!

Let me know what you think of Dan’s story in the comments. Could YOU resist the temptation? 👇

Hidden Gems: Lesser-Known .NET Libraries Every Developer Should Know About

Marmik soni — Tue, 10 Sep 2024 19:25:26 +0000

The .NET ecosystem is vast, with countless libraries designed to make development easier, faster, and more efficient. While popular ones like Newtonsoft.Json or Entity Framework are well-known, there are several underrated libraries that can significantly enhance your projects. In this post, I’ll highlight some of these hidden gems that you might not have heard of but are definitely worth exploring.

1. SmartFormat

SmartFormat is a powerful and lightweight library for formatting strings in a much cleaner way than traditional string interpolation or concatenation. It’s particularly useful when dealing with complex formatting scenarios, such as conditional formatting, list handling, and nested structures.

Why It’s Awesome:

Supports advanced formatting like pluralization and conditional formatting.
Works seamlessly with localization, making it perfect for international applications.

Usage Example:

using SmartFormat;

string formatted = Smart.Format("Hello {0}, today is {1:dddd}.", "Marmik", DateTime.Now);
Console.WriteLine(formatted);

2. FluentValidation

FluentValidation is a library for building strongly-typed validation rules for your .NET objects. It allows you to keep your validation logic separate from your models, making your code more readable and maintainable.

Why It’s Awesome:

Provides a fluent interface to define validation rules.
Easily integrates with ASP.NET Core for request validation.

Usage Example:

using FluentValidation;

public class UserValidator : AbstractValidator<User>
{
    public UserValidator()
    {
        RuleFor(user => user.Name).NotEmpty();
        RuleFor(user => user.Email).EmailAddress();
    }
}

3. Polly

Polly is a resilience and transient fault-handling library that allows you to easily add retry, circuit breaker, timeout, and other fault-handling policies to your applications.

Why It’s Awesome:

Helps handle transient errors gracefully, especially in distributed systems.
Provides out-of-the-box policies that are highly customizable.

Usage Example:

using Polly;
using System.Net.Http;

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .Retry(3);

retryPolicy.Execute(() => {
    // Your HTTP call here
});

4. Humanizer

Humanizer is a small but powerful library that helps make your application’s text more readable by humanizing dates, times, numbers, and more. It’s perfect for making output user-friendly.

Why It’s Awesome:

Converts C# enums to human-readable strings.
Humanizes time spans, like converting "1 day ago" from DateTime.

Usage Example:

using Humanizer;

TimeSpan timeSpan = TimeSpan.FromDays(1);
Console.WriteLine(timeSpan.Humanize()); // Output: "one day"

5. Scrutor

Scrutor provides assembly scanning and registration for the .NET Core DI container. It allows you to register your services easily without manually adding every single class, making your dependency injection setup much cleaner.

Why It’s Awesome:

Automates the registration process, reducing boilerplate code.
Provides flexible filtering and lifetime options.

Usage Example:

services.Scan(scan => scan
    .FromAssemblyOf<SomeType>()
    .AddClasses()
    .AsImplementedInterfaces()
    .WithScopedLifetime());

6. Mapster

Mapster is a fast, flexible, and lightweight object-to-object mapper that can replace AutoMapper. It’s highly performant and requires minimal configuration compared to other mappers.

Why It’s Awesome:

No need for extensive profiles or configurations.
Offers powerful customization features with minimal setup.

Usage Example:

using Mapster;

var dto = source.Adapt<DestinationType>();

Conclusion

Exploring lesser-known libraries can greatly enhance your development workflow, providing new ways to tackle common challenges. These hidden gems offer powerful functionality with minimal overhead, making them valuable additions to any .NET developer’s toolkit.

Have a favorite hidden .NET library? Share it in the comments, and let’s spread the word about these underappreciated tools!

Debugging C# in .NET: A Step-by-Step Guide to Solving Common Issues

Marmik soni — Sat, 07 Sep 2024 17:10:38 +0000

Debugging is an essential skill for any developer, and when working with C# in .NET, it can sometimes feel like navigating a labyrinth. In this guide, I’ll walk you through the most common issues you might face and provide practical tips for solving them effectively. Whether you're a seasoned developer or just starting, this post aims to arm you with the knowledge to conquer your debugging challenges.

Common Debugging Tools in .NET

Before diving into specific issues, let’s take a look at the debugging tools you’ll be using most frequently:

Visual Studio Debugger: Your best friend in the debugging journey. With breakpoints, step into/over functionalities, and variable inspection, it’s the cornerstone of .NET debugging.
dotnet-trace and dotnet-dump: Great for diagnosing performance and memory-related issues. These tools help you understand what’s happening under the hood of your application.
Debugging with LINQPad: Perfect for testing C# snippets quickly and seeing the immediate output, making it a handy tool for smaller debugging tasks.

Step-by-Step Guide to Debugging Common Issues

1. NullReferenceException

One of the most common and dreaded exceptions! This usually occurs when you try to access an object that hasn’t been instantiated.

How to Spot It:

The error message will point to the line causing the exception, but identifying the root cause requires inspecting variable states.

Tips:

Use null-conditional operators (?.) to safely handle potentially null objects.
Inspect the call stack in Visual Studio to trace where the problem originates.

string name = null;
Console.WriteLine(name.Length); // Causes NullReferenceException

2. Incorrect Output or Calculations

Sometimes your code runs without exceptions but still produces incorrect results. This often involves logical errors.

How to Spot It:

Set breakpoints before the section of code in question and inspect the variable values step-by-step.

Tips:

Use the Immediate Window to test variable changes and potential fixes on the fly without rerunning the entire application.

int result = CalculateSum(2, 3); // Should be 5 but check the implementation.
Console.WriteLine(result);

3. Unhandled Exceptions

Unhandled exceptions can crash your application unexpectedly, leading to a poor user experience.

How to Spot It:

They typically show up during runtime and halt the application.

Tips:

Use try-catch blocks strategically and configure Exception Settings in Visual Studio to catch specific exceptions as they occur.

try
{
    int x = int.Parse("notAnInt");
}
catch (FormatException ex)
{
    Console.WriteLine($"Handled Exception: {ex.Message}");
}

4. Performance Bottlenecks

Sluggish performance is another common issue that can degrade user experience.

How to Spot It:

Use the Performance Profiler in Visual Studio to identify which methods are taking the most time.

Tips:

Consider using asynchronous programming (async/await) to keep the UI responsive, but understand when it’s appropriate to use.

public async Task<string> GetDataAsync()
{
    await Task.Delay(2000); // Simulates a delay, not optimal in real scenarios.
    return "Data fetched!";
}

Pro Tips for Effective Debugging

Use Watch and QuickWatch Windows: These are powerful tools for monitoring variable states during execution.
Log Effectively: Logging isn’t just for production environments; it’s invaluable during development as well. Use tools like Serilog or NLog to make your logs more readable.
Automate Testing: Unit tests can catch errors before they make it to runtime. Incorporate tests to validate the expected behavior of your code.

Common Mistakes to Avoid

Relying Too Much on Console.WriteLine: While quick and easy, it’s not a substitute for proper debugging techniques.
Ignoring Warnings: Compiler warnings are often overlooked but can point to potential bugs or performance issues.

Conclusion

Debugging is more than just a necessary evil—it’s a skill that can greatly improve your coding efficiency and the quality of your applications. By familiarizing yourself with these common issues and the tools available, you can turn debugging from a dreaded task into a rewarding part of your development process.

Have a favorite debugging tip? Drop it in the comments below, and let’s learn from each other!

Welcome to My Dev.to Journey: Exploring .NET, DevOps, and More!

Marmik soni — Tue, 03 Sep 2024 13:23:38 +0000

Hello Dev.to community!

I’m Marmik Soni, a back-end developer specializing in C# and .NET. As I dive deeper into the world of software development and DevOps, I’m excited to share my journey and insights with you all.

A Bit About Me:

Currently, I’m in my third semester pursuing a Master’s in Computer Applications, and I’ve been focusing on .NET frameworks and DevOps. My experience so far includes fixing and debugging C# code, and recently, I’ve started exploring DevOps practices to streamline development processes.

What You Can Expect

On this blog, I’ll be covering a range of topics, including:

.NET and C# Development: Tips, tricks, and best practices for working with .NET technologies.
DevOps Insights: From CI/CD pipelines to containerization, I’ll share my learnings and experiences.
Tech Stories: I’ll also dive into some fascinating tech stories and historical events, bringing a touch of humor to make the read enjoyable.

Why Dev.to?

My friend once told me about how great Dev.to is—how it's full of supportive and collaborative people. They said it's a fantastic platform for learning, sharing, and connecting with other developers. I’m really looking forward to jumping in, learning from everyone, and contributing to the conversations!

Feel free to reach out if you have any questions or topics you’d like me to cover. I’m here to learn and grow alongside you!

Stay tuned for more posts, and thank you for reading!

Happy coding!

Marmik Soni