DEV Community: Syed Mohamed

What is an Azure DevOps Agent?

Syed Mohamed — Sun, 12 Apr 2026 09:54:58 +0000

𝗔𝘇𝘂𝗿𝗲 𝗗𝗲𝘃𝗢𝗽𝘀 𝗔𝗴𝗲𝗻𝘁 𝗮𝗻𝗱 𝗜𝘁𝘀 𝗧𝘆𝗽𝗲𝘀
Ever wondered what actually runs your 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲𝘀 𝗶𝗻 𝗔𝘇𝘂𝗿𝗲 𝗗𝗲𝘃𝗢𝗽𝘀?

That’s where 𝗔𝘇𝘂𝗿𝗲 𝗗𝗲𝘃𝗢𝗽𝘀 𝗔𝗴𝗲𝗻𝘁𝘀 come in.

Think of an agent as the worker behind the scenes — the one that picks up your pipeline job, executes the steps, installs dependencies, builds your code, runs tests, and pushes deployments.

Now, not all agents are the same. There are 𝗺𝗮𝗶𝗻𝗹𝘆 𝘁𝘄𝗼 𝘁𝘆𝗽𝗲𝘀:
🔹 𝗠𝗶𝗰𝗿𝗼𝘀𝗼𝗳𝘁-𝗵𝗼𝘀𝘁𝗲𝗱 𝗮𝗴𝗲𝗻𝘁𝘀
These are managed by Microsoft. You don’t need to set up anything — just select an image and run your pipeline. Perfect when you want simplicity and quick setup.

🔹 𝗦𝗲𝗹𝗳-𝗵𝗼𝘀𝘁𝗲𝗱 𝗮𝗴𝗲𝗻𝘁𝘀
These run on your own machines (VMs, servers, or even your local system). You have full control over configurations, installed tools, and network access. Ideal for custom requirements or secure environments.

𝗖𝗵𝗼𝗼𝘀𝗶𝗻𝗴 𝗯𝗲𝘁𝘄𝗲𝗲𝗻 𝘁𝗵𝗲𝗺 𝗱𝗲𝗽𝗲𝗻𝗱𝘀 𝗼𝗻 𝘆𝗼𝘂𝗿 𝗻𝗲𝗲𝗱:
• 𝗪𝗮𝗻𝘁 𝘇𝗲𝗿𝗼 𝗺𝗮𝗶𝗻𝘁𝗲𝗻𝗮𝗻𝗰𝗲? 𝗚𝗼 𝘄𝗶𝘁𝗵 𝗠𝗶𝗰𝗿𝗼𝘀𝗼𝗳𝘁-𝗵𝗼𝘀𝘁𝗲𝗱
• 𝗡𝗲𝗲𝗱 𝗰𝗼𝗻𝘁𝗿𝗼𝗹 𝗼𝗿 𝗮𝗰𝗰𝗲𝘀𝘀 𝘁𝗼 𝗽𝗿𝗶𝘃𝗮𝘁𝗲 𝗿𝗲𝘀𝗼𝘂𝗿𝗰𝗲𝘀? 𝗦𝗲𝗹𝗳-𝗵𝗼𝘀𝘁𝗲𝗱 𝗶𝘀 𝘁𝗵𝗲 𝘄𝗮𝘆

At the end of the day, no agent = no pipeline execution.

If you're learning Azure DevOps, understanding agents is a game changer

𝗧𝗵𝗲 𝗰𝗼𝗺𝗽𝗹𝗲𝘁𝗲 𝗮𝗿𝘁𝗶𝗰𝗹𝗲 𝗶𝘀 𝗮𝘃𝗮𝗶𝗹𝗮𝗯𝗹𝗲 𝗶𝗻 𝗺𝘆 𝗣𝗼𝗿𝘁𝗳𝗼𝗹𝗶𝗼 𝘂𝗻𝗱𝗲𝗿 𝘁𝗵𝗲 𝗔𝗿𝘁𝗶𝗰𝗹𝗲𝘀 𝘀𝗲𝗰𝘁𝗶𝗼𝗻:https://www.youtube.com/watch?v=2fPgEK_anlo

Upload & Download Files in Azure Blob Storage using C# (Full Tutorial) | Syed Cloud Tech

Syed Mohamed — Sat, 04 Apr 2026 02:45:00 +0000

𝗨𝗽𝗹𝗼𝗮𝗱 & 𝗗𝗼𝘄𝗻𝗹𝗼𝗮𝗱 𝗙𝗶𝗹𝗲𝘀 𝗶𝗻 𝗔𝘇𝘂𝗿𝗲 𝗕𝗹𝗼𝗯 𝗦𝘁𝗼𝗿𝗮𝗴𝗲 𝘂𝘀𝗶𝗻𝗴 𝗖#
Working with files in the cloud is something every developer eventually needs to master—and 𝗔𝘇𝘂𝗿𝗲 𝗕𝗹𝗼𝗯 𝗦𝘁𝗼𝗿𝗮𝗴𝗲 makes it incredibly powerful and scalable.

Recently, I explored how to 𝘂𝗽𝗹𝗼𝗮𝗱 𝗮𝗻𝗱 𝗱𝗼𝘄𝗻𝗹𝗼𝗮𝗱 𝗳𝗶𝗹𝗲𝘀 𝘂𝘀𝗶𝗻𝗴 𝗖# 𝘄𝗶𝘁𝗵 𝗔𝘇𝘂𝗿𝗲 𝗕𝗹𝗼𝗯 𝗦𝘁𝗼𝗿𝗮𝗴𝗲, and it’s surprisingly straightforward once you understand the flow.

You basically:
• 𝗖𝗼𝗻𝗻𝗲𝗰𝘁 𝘂𝘀𝗶𝗻𝗴 𝘁𝗵𝗲 𝘀𝘁𝗼𝗿𝗮𝗴𝗲 𝗮𝗰𝗰𝗼𝘂𝗻𝘁 𝗰𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻 𝘀𝘁𝗿𝗶𝗻𝗴
• 𝗪𝗼𝗿𝗸 𝘄𝗶𝘁𝗵 𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿𝘀 𝗮𝗻𝗱 𝗯𝗹𝗼𝗯𝘀
• 𝗨𝘀𝗲 𝘁𝗵𝗲 𝗔𝘇𝘂𝗿𝗲 𝗦𝗗𝗞 𝘁𝗼 𝘂𝗽𝗹𝗼𝗮𝗱 𝗮𝗻𝗱 𝗱𝗼𝘄𝗻𝗹𝗼𝗮𝗱 𝗳𝗶𝗹𝗲𝘀 𝘀𝗲𝗮𝗺𝗹𝗲𝘀𝘀𝗹𝘆

What I found interesting is how clean the .NET SDK is—you can handle large files, manage storage efficiently, and integrate it easily into real-world applications.

If you're a .𝗡𝗘𝗧 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 or getting started with 𝗔𝘇𝘂𝗿𝗲, this is definitely a must-learn skill. It’s widely used in real-time applications like document storage, media handling, backups, and more.

I’ve put together a full tutorial where I walk through everything step by step with practical examples.

🎥 You can check out the complete video on my YouTube channel 𝗦𝘆𝗲𝗱 𝗖𝗹𝗼𝘂𝗱 𝗧𝗲𝗰𝗵 for a detailed explanation.

𝗘𝘅𝗽𝗹𝗼𝗿𝗲 𝘁𝗵𝗲 𝗙𝘂𝗹𝗹 𝗩𝗶𝗱𝗲𝗼:https://youtu.be/0HWaJsHf8v0

Azure #AzureBlobStorage #CSharp #DotNet #CloudComputing #AzureStorage #Programming #Developers #TechLearning #SoftwareDevelopment #MicrosoftAzure

Azure Key Vault Explained | Secure Secrets, Keys & Certificates

Syed Mohamed — Fri, 03 Apr 2026 07:13:01 +0000

When working with applications in Azure, one of the biggest challenges is managing sensitive data like API keys, connection strings, certificates, and passwords. Storing them directly in code or config files? Risky.

That’s where Azure Key Vault comes in.

It provides a centralized and secure way to store and control access to:

Secrets (passwords, connection strings)
Keys (encryption keys)
Certificates (SSL/TLS)

What I really like about Key Vault:
✔ Tight integration with Azure services
✔ Role-based access control (RBAC)
✔ Managed Identity support (no hardcoding credentials!)
✔ Audit logs for better security tracking

Instead of worrying about "where to store secrets", you can focus on building your application while Azure takes care of securing them.

If you're building cloud applications, learning Key Vault is a must-have skill — not just for developers, but also for DevOps engineers.

👉 I’ve explained Azure Key Vault in a simple way in my latest video on my YouTube channel Syed Cloud Tech. Feel free to check it out here.
https://www.youtube.com/watch?v=FV8ZyfUpMjM

Azure #CloudSecurity #AzureKeyVault #DevOps #CloudComputing #MicrosoftAzure #Security #Developers #Learning #Tech

File Access Modifier in C# with Examples (C# 11 Guide)

Syed Mohamed — Thu, 26 Mar 2026 08:43:43 +0000

More .NET related Articles: https://jntech.in/Articles

File Access Modifier in C# – Why It Exists and When to Use It
The Problem
In real projects, we often create helper classes that are only needed inside one file.

If we use internal, those classes become accessible across the entire project. This can lead to:

Accidental usage
Poor code organization
Tight coupling between files
So the question is:
How do we restrict a class to just one file?

The Solution
C# introduced the file access modifier.
It allows you to define a class that is:

Accessible only within the same file
Completely hidden from other files
This gives better control over your code and improves encapsulation.

file class DataFormatter
{
    public string Format(string data)
    {
        return data.Trim();
    }
}

public class DataService
{
    public void Execute()
    {
        var formatter = new DataFormatter();
        Console.WriteLine(formatter.Format("  sample  "));
    }
}

Note: The file access modifier restricts a class so that it is accessible only within the same source file. Multiple classes inside the same file can use it, but it cannot be accessed from another file, even within the same project. It is mainly used for helper classes and provides better encapsulation than internal.

Can we use file inside another class?

No. We cannot use file for nested classes

public class Outer
{
    file class Inner  // Not allowed
    {
    }
}

Key Points about file Access Modifier in C#

General Rules
file restricts a type to only the same source file
Introduced in C# 11
Works only with top-level types
Cannot be used inside another class (no nested file types)
Supported Types
You can use file with:

file class
file struct
file interface
file record
Example:

file struct MyStruct { }
file interface IHelper { }

Inheritance Rules
A file class can inherit from another class (if accessible)
file class Base { }

file class Derived : Base // Allowed (same file)
{
}
Cannot inherit a file class from another file. Because it is not visible

Interface Implementation
file classes can implement interfaces

file interface IHelper
{
    void DoWork();
}

file class Helper : IHelper
{
    public void DoWork() { }
}

Works only within the same file

Real Usage Scenarios
Helper classes used only in one file
Utility logic tightly coupled to a feature
Avoiding accidental usage across project

Limitations
Cannot be used for:
Nested classes
Members (methods, properties, fields)
Only applies to types, not methods or variables

Best Practice
Use file when:
The class is not reusable
Logic should stay in one file
You want strong encapsulation

Conclusion
The file access modifier is a simple but powerful feature in C# that helps you control how your code is used. By restricting a class, struct, or interface to a single file, it ensures that internal logic stays exactly where it belongs.

It is especially useful when you are working with helper classes or feature-specific logic that should not be exposed to the rest of the project. Compared to internal, it provides a stricter level of encapsulation, which helps avoid accidental usage and keeps your codebase clean.

From a design perspective, using file encourages better organization and makes your intent clear to other developers. When someone reads your code, they immediately understand that certain types are meant to be used only within that file.

In short, the file modifier is a great tool for writing more maintainable, readable, and well-structured applications.

More .NET related Articles: https://jntech.in/Articles

What’s New in C# 14: Exploring the Latest Features in .NET 10

Syed Mohamed — Wed, 11 Mar 2026 05:25:08 +0000

🔗 𝗙𝘂𝗹𝗹 𝗮𝗿𝘁𝗶𝗰𝗹𝗲 𝗿𝗲𝗹𝗮𝘁𝗲𝗱 𝘁𝗼 𝘁𝗵𝗶𝘀 𝗽𝗼𝘀𝘁: https://jntech.in/view/whats-new-in-csharp-14-exploring-the-latest-features-in-net-10

C# continues to evolve with every .NET release, and 𝗖# 𝟭𝟰 (𝘄𝗶𝘁𝗵 .𝗡𝗘𝗧 𝟭𝟬) introduces several improvements that make the language cleaner, more flexible, and easier for developers to work with.

Here are some of the 𝗻𝗲𝘄 𝗳𝗲𝗮𝘁𝘂𝗿𝗲𝘀 𝗶𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗲𝗱 𝗶𝗻 𝗖# 𝟭𝟰:
• 𝗘𝘅𝘁𝗲𝗻𝘀𝗶𝗼𝗻 𝗠𝗲𝗺𝗯𝗲𝗿𝘀 (𝗘𝘅𝘁𝗲𝗻𝘀𝗶𝗼𝗻 𝗕𝗹𝗼𝗰𝗸𝘀) — Allows grouping multiple extension methods and properties together for a specific type, improving code organization.

• 𝗘𝘅𝘁𝗲𝗻𝘀𝗶𝗼𝗻 𝗣𝗿𝗼𝗽𝗲𝗿𝘁𝗶𝗲𝘀 — Enables adding property-like members to existing types without modifying the original class.

• 𝗦𝘁𝗮𝘁𝗶𝗰 𝗘𝘅𝘁𝗲𝗻𝘀𝗶𝗼𝗻 𝗠𝗲𝗺𝗯𝗲𝗿𝘀 — Allows developers to extend static functionality of existing types using extensions.

• 𝗣𝗿𝗶𝘃𝗮𝘁𝗲 𝗙𝗶𝗲𝗹𝗱𝘀 𝗶𝗻𝘀𝗶𝗱𝗲 𝗘𝘅𝘁𝗲𝗻𝘀𝗶𝗼𝗻 𝗕𝗹𝗼𝗰𝗸𝘀 — Extension blocks can now contain private fields used internally by extension members.

• 𝗙𝗶𝗲𝗹𝗱-𝗯𝗮𝗰𝗸𝗲𝗱 𝗣𝗿𝗼𝗽𝗲𝗿𝘁𝗶𝗲𝘀 (field 𝗸𝗲𝘆𝘄𝗼𝗿𝗱) — Provides direct access to the compiler-generated backing field in auto-properties.

• 𝗡𝘂𝗹𝗹-𝗰𝗼𝗻𝗱𝗶𝘁𝗶𝗼𝗻𝗮𝗹 𝗔𝘀𝘀𝗶𝗴𝗻𝗺𝗲𝗻𝘁 (?.= 𝗮𝗻𝗱 ?[]=) — Allows assignments to occur only when the object is not null, reducing repetitive null checks.

• nameof 𝗦𝘂𝗽𝗽𝗼𝗿𝘁 𝗳𝗼𝗿 𝗨𝗻𝗯𝗼𝘂𝗻𝗱 𝗚𝗲𝗻𝗲𝗿𝗶𝗰 𝗧𝘆𝗽𝗲𝘀 — Enables using nameof with generic types without specifying type parameters.

• 𝗜𝗺𝗽𝗹𝗶𝗰𝗶𝘁 𝗖𝗼𝗻𝘃𝗲𝗿𝘀𝗶𝗼𝗻𝘀 𝗳𝗼𝗿 Span 𝗮𝗻𝗱 ReadOnlySpan — Simplifies working with spans by allowing more automatic conversions.

• 𝗣𝗮𝗿𝗮𝗺𝗲𝘁𝗲𝗿 𝗠𝗼𝗱𝗶𝗳𝗶𝗲𝗿𝘀 𝗶𝗻 𝗟𝗮𝗺𝗯𝗱𝗮 𝗘𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻𝘀 — Lambdas now support modifiers like ref, in, and out.

• 𝗨𝘀𝗲𝗿-𝗱𝗲𝗳𝗶𝗻𝗲𝗱 𝗖𝗼𝗺𝗽𝗼𝘂𝗻𝗱 𝗔𝘀𝘀𝗶𝗴𝗻𝗺𝗲𝗻𝘁 𝗢𝗽𝗲𝗿𝗮𝘁𝗼𝗿𝘀 — Custom types can now define operators such as +=, -=, etc.

• 𝗣𝗮𝗿𝘁𝗶𝗮𝗹 𝗖𝗼𝗻𝘀𝘁𝗿𝘂𝗰𝘁𝗼𝗿𝘀 𝗮𝗻𝗱 𝗣𝗮𝗿𝘁𝗶𝗮𝗹 𝗘𝘃𝗲𝗻𝘁𝘀 — Extends partial member support to constructors and events.

🔗 𝗙𝘂𝗹𝗹 𝗮𝗿𝘁𝗶𝗰𝗹𝗲 𝗿𝗲𝗹𝗮𝘁𝗲𝗱 𝘁𝗼 𝘁𝗵𝗶𝘀 𝗽𝗼𝘀𝘁: https://jntech.in/articles/view/whats-new-in-csharp-14-exploring-the-latest-features-in-net-10

📚 𝗠𝗼𝗿𝗲 .𝗡𝗘𝗧, 𝗖#, 𝗦𝗤𝗟 𝗔𝗿𝘁𝗶𝗰𝗹𝗲𝘀: https://jntech.in/Articles