DEV Community: Ganesh Gurav

How GitHub Copilot Can Supercharge Your Productivity in Visual Studio 2022

Ganesh Gurav — Sun, 09 Mar 2025 17:20:46 +0000

If you’re a developer using Visual Studio 2022, you’ve probably heard about GitHub Copilot. It’s an AI-powered coding assistant that helps you write code faster, minimize repetitive tasks, and even suggest solutions to complex problems. But how exactly can it improve your productivity?

In this article, we’ll explore the top ways GitHub Copilot can enhance your workflow in Visual Studio 2022, helping you write better code in less time.

1. Faster Code Completion and Suggestions

One of the most obvious benefits of GitHub Copilot is its autocomplete capabilities. Instead of typing out entire functions or classes, Copilot can predict what you’re about to write and offer real-time suggestions.

How it helps:

Reduces keystrokes by suggesting entire lines or blocks of code.
Understands context, predicting variable names and function structures based on your existing code.
Speeds up repetitive tasks, such as writing boilerplate code, getter/setter methods, or database queries.

For example, if you’re writing a function to fetch data from an API, Copilot might generate:

public async Task<List<User>> GetUsersAsync()
{
    using (HttpClient client = new HttpClient())
    {
        HttpResponseMessage response = await client.GetAsync("https://microsoft.graphapi.example/users");
        response.EnsureSuccessStatusCode();
        string responseBody = await response.Content.ReadAsStringAsync();
        return JsonConvert.DeserializeObject<List<User>>(responseBody);
    }
}

Instead of writing all of this from scratch, Copilot suggests it based on your method name and context. That’s a huge time saver!

2. Helps with Learning and Exploring New APIs

Whether you’re working with a new framework, library, or API, Copilot can help you discover best practices and learn how to use unfamiliar code structures.

How it helps:

Auto-generates API calls based on method names.
Suggests the correct syntax for new libraries.
Reduces time spent searching Stack Overflow for examples.

Let’s say you’re new to Entity Framework Core and need to fetch data from a database. Instead of Googling examples, just start typing, and Copilot will generate:

public async Task<List<Customer>> GetActorsAsync()
{
    using (var context = new AppDbContext())
    {
        return await context.Actors.ToListAsync();
    }
}

This is especially helpful for junior developers or when learning new technologies on the go.

3. Automates Boilerplate and Repetitive Code

We all hate writing the same repetitive code — whether it’s logging, exception handling, or writing test cases. GitHub Copilot takes care of that by automatically generating common patterns.

How it helps:

Speeds up unit test writing, suggesting test cases based on existing methods.
Generates logging and exception handling blocks.
Handles repetitive tasks like constructors and DTOs.

For instance, if you have a method that needs structured logging:

public async Task ProcessOrderAsync(Order order)
{
    // Business logic here
}

//Log order Id and add error handling.
public async Task ProcessOrderAsync(Order order)
{
    try
    {
        _logger.LogInformation("Processing order {OrderId}", order.Id);
        // Business logic here
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error processing order {OrderId}", order.Id);
        throw;
    }
}

Copilot can auto-generate logging and error handling, saving you from writing it manually.

4. Enhances Code Readability and Best Practices

Writing readable, maintainable code is crucial, but we often fall into bad habits — using poor variable names, skipping comments, or not following best practices.

How it helps:

Suggests meaningful variable and function names.
Adds comments automatically for better readability.
Follows coding standards based on context and existing code.

For example, if you write a complex function, Copilot may suggest meaningful inline comments, improving readability for your future self and teammates.

5. Assists in Writing Unit Tests Faster

Testing is essential, but writing unit tests can be time-consuming. Copilot can generate test cases based on your existing functions, reducing the manual effort needed.

How it helps:

Creates unit test templates for methods automatically.
Suggests assertions based on function outputs.
Speeds up Test-Driven Development (TDD).

For example, if you have a method:

public int Add(int a, int b)
{
    return a + b;
}

Copilot can generate the corresponding unit test:

[Test]
public void Add_ShouldReturnCorrectSum()
{
    var result = Add(2, 3);
    Assert.AreEqual(5, result);
}

This speeds up test coverage and ensures fewer bugs in production.

6. Boosts Collaboration with Teams

If you’re working on a team, Copilot helps by:

Providing consistent coding patterns across team members.
Encouraging best practices without extensive documentation.
Reducing the need for pair programming on simple tasks.

Instead of waiting for a senior developer to review and suggest improvements, Copilot helps you write cleaner code upfront, leading to fewer review cycles.

7. Supports Multiple Languages and Frameworks

If you switch between different programming languages (C#, JavaScript, Python, etc.), Copilot adapts to each language’s syntax and best practices.

How it helps:

Works across multiple frameworks like .NET, Angular, React, and Python.
Understands project context, whether frontend, backend, or full stack.
Saves time when switching between languages.

For example, if you’re building an ASP.NET API but need to write some JavaScript for the frontend, Copilot helps you transition smoothly without looking up syntax differences.

Final Thoughts: Is GitHub Copilot Worth Using?

Absolutely! GitHub Copilot is like having an AI-powered coding assistant that helps you write code faster, reduce errors, and automate tedious tasks.

While Copilot isn’t perfect (it sometimes suggests incorrect or inefficient code), when used wisely, it significantly boosts productivity. If you’re using Visual Studio 2022, integrating Copilot into your workflow is a game-changer!

Have you tried GitHub Copilot in Visual Studio 2022? What’s your experience? Let’s discuss in the comments!

Master These 7 JavaScript Array Functions and Instantly Level Up — PART 1

Ganesh Gurav — Sat, 08 Mar 2025 08:40:46 +0000

Let’s be real — most of us abuse .map(), .filter(), and .reduce() like they owe us money. But JavaScript arrays have way more tricks up their sleeves. If you’re only using the same three methods, you’re basically treating a Swiss Army knife like a butter knife.

So, let’s fix that. Here are 7 array functions that’ll make your code cleaner, smarter, and maybe even impress your boss (no guarantees).

1. .find() – The Detective 🕵️‍♂️

Need to locate the first item in an array that matches a condition? .find() is on the case.

Example: Find the first pizza in the list 🍕

const foods = ['🥦', '🍕', '🥬', '🍕', '🍔'];
const firstPizza = foods.find(food => food === '🍕');
console.log(firstPizza); // 🍕

Boom! First pizza found, case closed. If only .find() worked in my fridge…

2. .some() – The Optimist 🌞

Checks if at least one item in the array meets a condition. Great for when you just need a little hope.

Example: Is there any spicy food? 🌶️

const foods = [{ name: '🍔', spicy: false }, { name: '🌶️', spicy: true }];
const hasSpicy = foods.some(food => food.spicy);
console.log(hasSpicy); // true

All you need is one spicy dish to ignite hope (and your taste buds).

3. .every() – The Pessimist ☁️

This one isn’t happy unless everything matches the condition.

Example: Are all users above 18? 🚨

const users = [{ age: 21 }, { age: 25 }, { age: 16 }];
const allAdults = users.every(user => user.age >= 18);
console.log(allAdults); // false ❌

One minor ruins it for everyone. Just like that one friend who forgets their ID at the bar.

4. .flat() – The Pancake Maker 🥞

Tired of nested arrays? Flatten them like a pro!

Example: Flattening a deep array 📦
const messyArray = [1, [2, [3, 4], 5], 6];
const flatArray = messyArray.flat(2);
console.log(flatArray); // [1, 2, 3, 4, 5, 6]

5. .groupBy() — The Organizer 📂

Need to categorize items in an array? Object.groupBy() is your best friend! (Sadly it's a static method available in Object type and not in Array.prototype due to some conflicts)

Example: Group people by same age 😈

const people = [
  { name: 'Mia', age: 25 },
  { name: 'Dani', age: 25 },
  { name: 'Ava', age: 30 },
  { name: 'Johny', age: 30 }
];

const groupedByAge = Object.groupBy(people, (person) => person.age);

console.log(groupedByAge);

/* {
  25: [{ name: 'Mia', age: 25 }, { name: 'Dani', age: 25 }],
  30: [{ name: 'Ava', age: 30 }, { name: 'Johny', age: 30 }]
} */

Now, all people of the same age are neatly grouped together!

6. .fill() – The Rage-Quit Button 😡

Need to replace all values in an array? .fill() is your emergency reset button.

Example: Reset all scores to zero 🎮

const scores = [5, 10, 15];
scores.fill(0);
console.log(scores); // [0, 0, 0] 🔄

It’s like wiping your browser history before a tech support visit. 😉

7. .sort() – The Sneaky One 🤡

Sorting numbers? Don’t trust .sort() blindly—it has bad habits.

Example: Sorting numbers (the wrong way) 🚨

const numbers = [10, 2, 5, 1];
console.log(numbers.sort()); // [1, 10, 2, 5] 😱

Why? Because .sort() treats numbers as strings. Fix it like this:

console.log(numbers.sort((a, b) => a - b)); // [1, 2, 5, 10] ✅

Lesson learned: Never trust .sort() without a compare function.

Final Thoughts 💡

JavaScript arrays are way more powerful than most developers realize. Master these functions, and you’ll write cleaner, smarter code that actually makes sense.

Which function do you use the most? Drop a comment or just leave a like. 😃

Boost Your EF Core Query Performance by 4X with Just One Line of Code Change!

Ganesh Gurav — Fri, 07 Mar 2025 13:34:19 +0000

Background

We have a .NET 6 application with a search functionality that uses LINQ queries with .Include() that needs to join more than 30 tables to fetch data. The feature worked perfectly at the beginning, even after importing legacy data into the new system. But gradually, the feature has begun to slow down considerably because of the huge growth in data volume.

Cartesian Explosion 💥

The LINQ query was experiencing "Cartesian explosion". 😞

What is Cartesian explosion?
Cartesian Explosion is an Entity Framework performance problem arising when using the Include method in loading more than one level of related data. This can, in turn, multiply the count of records coming back, so it takes time and consumes additional memory.

The following query was pulling data in 30 secs. (Query changed for privacy purposes).

_context.SomeTableName
        .AsNoTracking()
        .Include(x => x.Tasks.OrderBy(y => y.Id))
            .ThenInclude(x => x.Owner)
        .Include(x => x.Tasks)
            .ThenInclude(x => x.TaskStatus)
        .Include(x => x.Tasks)
            .ThenInclude(x => x.TaskComments)
            .ThenInclude(x => x.CreatedBy)
            .OrderBy(x => x.CreatedOn)
        .Include(x => x.Participants.OrderBy(y => y.Id))
            .ThenInclude(x => x.User)
        .Include(x => x.Participants)
            .ThenInclude(x => x.Role)
        .Include(x => x.Regions)
            .ThenInclude(x => x.Region)
        .Include(x => x.Countries)
            .ThenInclude(x => x.Country)
        .Include(x => x.Product)
        .Include(x => x.Groups)
            .ThenInclude(x => x.Group)
        .Include(x => x.Businesses)
            .ThenInclude(x => x.Business)
        .Include(x => x.Tiers)
            .ThenInclude(x => x.Tier)
        .Include(x => x.Segments)
            .ThenInclude(x => x.Segment)
        .Include(x => x.Stocks)
            .ThenInclude(x => x.Stock)
        .Include(x => x.Types)
            .ThenInclude(x => x.Type)
        .Include(x => x.Policy)
        .Include(x => x.FinalOutcome)
        .Include(x => x.Status)
        .Include(x => x.Attachments)

.AsSplitQuery() to the Rescue

There are a number of ways to make a LINQ query more efficient, but applying this EF Core feature enhanced performance by 4X.
By adding .AsSplitQuery() to the LINQ query, the time it took to retrieve data was cut down to 7.5 seconds.

Before vs After

Below are the Before vs After results:

What's the Magic?

Rather than passing a single SQL query with join, EF Core when utilizing .AsSplitQuery() will pass several SQL queries without join, each retrieving smaller amounts of data and then merging the results, this aids in avoiding the risk of cartesian explosion.

Trade-offs

There are also few trade-offs linked to this approach:

Multiple Round-Trips: Increases the database round-trips, which may introduce latency, this can worst if the UI app and API are in different regions.
Consistency Issues: Data may get changed between the execution of split queries, which results in inconsistent data.
Smaller Data: This may not be helpful for smaller dataset.

Thank You!

If you enjoy the content then please leave a like. Thank you! 🙂

My Azure .NET App Was Burning Money — Until I Optimized CPU by 4x and Memory by 10x! 💸🔥

Ganesh Gurav — Fri, 07 Mar 2025 03:53:26 +0000

Background

We have a mission-critical application used across multiple locations. It is a legacy .NET MVC application that leverages Redis for caching and SQL Server for data storage. The application is hosted on Azure App Service Premium V2, running on the highest P3 plan, which costs approximately $580 per instance. During peak hours, it operates on three instances, while during off-peak hours, it scales down to two instances.

The application was initially developed by experienced developers, ensuring a solid foundation. However, over time, its maintenance was handed over to junior L4 developers and the L3 support team. With each new enhancement, performance gradually deteriorated, leading to inefficiencies and skyrocketing resource consumption — ultimately transforming it into a resource-hungry monster. 🚀💰🔥

Over the past month, the application became increasingly unstable, suffering from severe performance issues and multiple high-priority incidents. While adding more instances could have provided a quick fix, it would have significantly increased costs — pushing us beyond budget, which wasn’t an option. Instead, we needed a smarter, cost-effective optimization strategy to restore stability without overspending.

My manager initiated a stabilization project to tackle these performance issues and appointed me as the Lead to drive the effort. It was my responsibility to identify inefficiencies, optimize resource usage, and bring the application back to peak performance — all while keeping costs under control.

Identifying inefficiencies

I began by identifying the root causes of the performance issues, dividing my investigation into three key areas: Redis, the database, and the App Service. After thoroughly analyzing Redis and the database, I found both to be clean and functioning optimally, ruling them out as potential culprits. With those eliminated, my focus shifted entirely to the App Service, where the real issue seemed to lie.

Azure had a built-in code profiler, but due to restrictions on enabling it in the Production environment, I had to find an alternative approach.

I had two profiling options: Glimpse and MiniProfiler. While Glimpse was the more powerful choice, it had a major limitation — it only worked with _layout.cshtml, whereas our application had multiple layout pages. Due to this constraint, I opted for MiniProfiler, which provided the flexibility needed to effectively investigate performance bottlenecks across different layouts.

I used the following MiniProfiler packages and set up the basic configuration required to get it up and running:

MiniProfiler.Mvc4
MiniProfiler.EF6

I added the necessary settings to enable profiling across the application. This allowed me to track slow-running API calls, and rendering times, helping to pinpoint the exact performance bottlenecks.

The findings were shocking! 🚨

N+1 Query Problem: Several parts of the application suffered from the classic N+1 query issue, causing excessive database calls instead of efficient joins.
Inefficient Filtering & Searching: A significant amount of filtering was happening in memory rather than on the database side. The app was unnecessarily loading massive datasets from SQL views and then filtering them in memory before returning the results.
Broken Pagination: Pagination logic was also being handled in memory, instead of being executed efficiently at the database level using OFFSET and FETCH.
Client-Side Query Execution: Many LINQ queries were using .NET functions that forced query evaluation on the client-side, leading to unnecessary data transfers and heavy processing on the app server rather than leveraging SQL Server’s optimized execution plans.

It became clear that fixing these inefficiencies was crucial to stabilizing performance and reducing resource consumption.

The Results

All findings were thoroughly documented and addressed by the team. Once the optimizations were implemented, we migrated the changes to PROD, and the impact was immediate and drastic — CPU usage dropped by 4x, and memory consumption plummeted by 10x! 🚀

We closely monitored the application’s health for a month and, seeing sustained improvements, made further optimizations. We reduced the instance count even during peak hours to just two and also downgraded the App Service plan, significantly cutting costs while maintaining stability.

Key Takeaway:

This entire experience underscores why code reviews matter — not just for functionality but also for writing optimized, efficient code that prevents performance bottlenecks.

If you’re interested in a deep dive into the exact MiniProfiler configurations, the issues we discovered, and how we fixed them, drop a comment, and I’ll write a detailed follow-up article! 🚀🔥