Category: Nutshell Series

The Unit of Work Pattern is used to save multiple database changes as one single transaction.

It makes sure that either all changes are saved or none of them are saved.

Simple Example

When placing an order, the system may need to:

• Create an order
• Reduce product stock
• Save payment details

If one step fails, the other changes should not be saved. Unit of Work helps manage this safely.

Key Idea

Do multiple operations
Save everything once

C# Example

public interface IUnitOfWork
{
    Task SaveChangesAsync();
}

public class UnitOfWork : IUnitOfWork
{
    private readonly AppDbContext _context;

    public UnitOfWork(AppDbContext context)
    {
        _context = context;
    }

    public async Task SaveChangesAsync()
    {
        await _context.SaveChangesAsync();
    }
}

Usage

product.Stock -= 1;

orderRepository.Add(order);

await unitOfWork.SaveChangesAsync();

In EF Core

In Entity Framework Core, DbContext already works like a Unit of Work because it tracks changes and saves them together using:

await dbContext.SaveChangesAsync();

Conclusion

Unit of Work means collect all changes first, then save them together once.

GitHub Copilot usage started draining faster for many users after the June 2026 billing changes. The main reason is that Copilot moved toward usage-based billing with GitHub AI Credits.

In simple terms: your usage now depends more on the model you choose, the amount of context, and whether you use features like Chat, Agent Mode, Code Review, CLI, Spaces, Spark, or cloud agents.

What Changed?

• Copilot now uses AI Credits for many advanced features.
• Normal code completions and next edit suggestions are still included in paid plans.
• Premium models consume more credits.
• Agent mode and code review can drain usage quickly.
• Claude Sonnet 4.6 can be much more expensive than older models in some plans.

Why Usage Drains Fast

Copilot can consume more credits when it receives large context, scans multiple files, generates long answers, or uses premium models. Agent mode is especially expensive because it may perform multiple steps, inspect files, edit code, and retry.

How to Reduce Copilot Usage

1. Do Not Use Premium Models for Everything

Use cheaper/default models for normal coding, explanations, small refactors, and unit test skeletons. Save premium models for hard debugging, architecture, and complex multi-file issues.

2. Avoid Agent Mode for Small Changes

Do not use agent mode for simple fixes. Use normal chat with selected code instead.

Use only the selected code.
Find the bug.
Show only the minimal fix.
Do not scan the full workspace.

3. Keep Context Small

Select only the method, class, or error message Copilot needs. Avoid asking it to inspect the whole project unless required.

4. Limit Output

Ask Copilot to keep answers short.

Show only changed lines.
Do not rewrite the full file.
Keep the answer under 10 lines.

5. Use Autocomplete More

For daily coding, rely more on Copilot autocomplete and next edit suggestions. Use Chat only when you need reasoning or explanation.

6. Use Code Review Carefully

Copilot code review can consume significant usage. Use it for important PRs, not every small change.

7. Set a Budget

Check your Copilot billing settings and set a small overage limit. Start with a low cap before allowing extra usage.

Recommended Workflow

Autocomplete → daily coding
Default model → small questions
Premium model → hard debugging
Agent mode → only for real multi-file work
Code review → only for important PRs

Final Takeaway

GitHub Copilot is still powerful, but after the June 2026 changes, it should be used more intentionally. Keep prompts small, avoid premium models by default, and reserve agent mode for complex tasks.

Best rule: use the cheapest useful mode first, then move to premium models only when needed.

The Strategy Pattern is a way to keep different behaviours separate instead of putting everything inside one big if/else block.

In simple words:

Strategy Pattern means choosing the right way to do something at runtime.

Layman Example

Imagine you want to travel to office.

You have different options:

• Walk
• Take a bus
• Drive a car
• Take a train

The goal is the same: reach the office.

But the method, or strategy, is different.

Software Example

Suppose an application needs to calculate delivery charges.

• Standard delivery has one rule
• Express delivery has another rule
• Free delivery has another rule

Without Strategy Pattern, we may write everything in one method using many conditions.

if (deliveryType == "Standard")
{
    // standard delivery logic
}
else if (deliveryType == "Express")
{
    // express delivery logic
}
else if (deliveryType == "Free")
{
    // free delivery logic
}

This works, but as the rules grow, the code becomes harder to read and maintain.

How Strategy Pattern Helps

With Strategy Pattern, each rule is moved into its own class.

• StandardDeliveryStrategy
• ExpressDeliveryStrategy
• FreeDeliveryStrategy

Each class handles only one behaviour.

The main code simply chooses the correct strategy and uses it.

Implementation Example

First, create a common interface for all delivery charge strategies.

public interface IDeliveryChargeStrategy
{
    decimal Calculate();
}

Now create separate classes for each strategy.

public class StandardDeliveryStrategy : IDeliveryChargeStrategy
{
    public decimal Calculate()
    {
        return 5;
    }
}

public class ExpressDeliveryStrategy : IDeliveryChargeStrategy
{
    public decimal Calculate()
    {
        return 15;
    }
}

public class FreeDeliveryStrategy : IDeliveryChargeStrategy
{
    public decimal Calculate()
    {
        return 0;
    }
}

Now choose the correct strategy based on the delivery type.

public class DeliveryChargeCalculator
{
    public decimal Calculate(string deliveryType)
    {
        IDeliveryChargeStrategy strategy = deliveryType switch
        {
            "Standard" => new StandardDeliveryStrategy(),
            "Express" => new ExpressDeliveryStrategy(),
            "Free" => new FreeDeliveryStrategy(),
            _ => throw new ArgumentException("Invalid delivery type")
        };

        return strategy.Calculate();
    }
}

Usage:

var calculator = new DeliveryChargeCalculator();

var charge = calculator.Calculate("Express");

Console.WriteLine(charge); // 15

Why Use It?

• Code becomes cleaner
• Large if/else blocks are reduced
• Each behaviour is easier to change
• Each rule can be tested separately
• New behaviours can be added without disturbing old ones

When to Use It?

Use Strategy Pattern when the same action can be done in different ways.

Common examples:

• Payment methods
• Discount calculation
• Delivery charge calculation
• File export formats
• Notification sending
• Data update rules

In a Nutshell

The Strategy Pattern helps us separate different ways of doing the same thing.

Instead of writing one large method with many conditions, we create separate classes for each behaviour and choose the right one when needed.