ASP.NET Core request processing ViewData vs ViewBag vs TempData Minimal APIs in .NET Core Razor Pages vs MVC vs Minimal APIs in ASP.NET Core ASP.NET Core Web API Setup Middleware in ASP.NET Core ActionResult vs IActionResult Filters in ASP.NET Core Routing in ASP.NET Core Model Binding in NET Core Kestrel In .NET Core Model Binding and Validation in ASP.NET Core ControllerBase vs Controller in ASP.NET Core Global Exception Handling in ASP.NET Core

REST-vs-SOAP API Gateway Security Versioning in REST APIs HTTP Essentials REST principles and API Design Versioning WEB API in .net core Swagger-OpenAPI-Documentation REST vs gRPC vs Message Brokers HTTP Verbs in ASP.NET Core OCR In ASP.NET gRPC APIs in .NET Core GraphQL APIs in .NET Core REST-vs-GraphQL API Error Handling Best Practices

Authentication-and-Authorization RBAC vs Claim Based in ASPNET CORS-and-CSRF Session vs Token-Based Authentication JWT Structure and Signature Validation Redirect URIs and Open Redirect Attacks All about JWT token Security in ASP.NET Core Encryption and Decryption in NET What is OWASP XSS-Prevention CQRS Distributed Denial-of-Service (DDoS)Access Token Pattern JWT Authentication in ASP.NET Core Securing ASP.NET Core Web API Secure API with HTTPS in .NET Core IdentityServer and OAuth2

Unit-Testing-in-ASP-NET-Core Unit Testing in .NET core Mocking with Moq in C#Integration and Load Testing Test-Driven Development (TDD)

MSBuild-Index MSBuild-1 MSBuild-2 MSBuild-3 MSBuild-4 MSBuild-5 MSBuild-6 MSBuild-7 MSBuild With AI

MSBuild-4 :👈

👉:MSBuild-6

MSBuild Day 5 – Advanced Concepts

Back to Index

Day 5 – Advanced MSBuild: Property Functions, Conditions, Incremental Builds, Inputs/Outputs, Diagnostics

Today you will learn the advanced features of MSBuild that make automation powerful: Property Functions, Conditions, Incremental Builds, Inputs and Outputs, Build Graphs, and Diagnostic Logging. These are essential for writing efficient, maintainable build logic.

1. Property Functions

Property functions allow you to use .NET-like methods inside MSBuild properties. They work inside $() expressions.

Examples:


$(ProjectName.ToUpper())
$(Configuration.StartsWith('D'))
$([System.DateTime]::Now.ToString())
$([System.Guid]::NewGuid())

Combine strings:


$(BasePath)\bin\$(Configuration)

Create numbers:


$([MSBuild]::Add(3, 5))
$([MSBuild]::Multiply(4, 10))

Property functions are extremely powerful for dynamic build logic.

2. Conditions in MSBuild

Conditions exist on almost every MSBuild element: properties, items, targets, tasks. They use simple string comparison or numeric comparison.

Property example:


<PropertyGroup>
  <IsDebug Condition=" '$(Configuration)' == 'Debug' ">true</IsDebug>
</PropertyGroup>

Item example:


<ItemGroup>
  <LogFiles Include="logs\*.txt" Condition="Exists('logs')" />
</ItemGroup>

Target example:


<Target Name="OnlyRunInRelease" Condition=" '$(Configuration)'=='Release' ">
    <Message Text="Running Release only logic..." />
</Target>

3. Incremental Builds

MSBuild supports incremental builds — tasks only run if needed. A target becomes incremental when you define:

Inputs – files or values checked for changes
Outputs – files produced

If all outputs are newer than inputs, MSBuild skips the target.

Example:


<Target Name="ProcessImages"
        Inputs="@(Images)"
        Outputs="@(Images->'processed\%(Filename).png')">

    <Message Text="Processing %(Images.Identity)..." />

</Target>

If none of the source images changed, the target will not run again.

4. Inputs and Outputs Logic

MSBuild compares timestamps of Inputs and Outputs. If output exists and is newer → skip target. If output missing or older → execute target.

Example of timestamp behavior:


Source.txt  -> modified today
Output.txt  -> modified yesterday

MSBuild will rerun the target because output is older.

5. Build Graph and Parallel Builds

MSBuild can build multiple projects at once using its dependency graph. This happens automatically when you build a solution.

To force parallel builds:


dotnet build -m

To visualize project build graph:


dotnet msbuild -graph

6. Diagnostic Logging

Diagnostics are crucial for understanding what MSBuild is doing.

Common verbosity levels:

q – quiet
m – minimal
n – normal
d – detailed
diag – diagnostic (very large output)

Enable diagnostic logging:


dotnet build -v:diag

This prints every imported file, target, task, property, and item.

Write logs to a file:


dotnet build -v:diag -fl -flp:LogFile=msbuild.log

7. Inspect Final Project After Imports

Useful for debugging Directory.Build files, SDK imports, and props/targets:


dotnet msbuild -pp:expanded.xml

Open the file to see exactly what MSBuild sees after all imports.

8. Hands-On Exercise (15 minutes)

Step 1 — Add a transform


<ItemGroup>
    <TxtFiles Include="data\*.txt" />
</ItemGroup>

<ItemGroup>
    <ProcessedFiles Include="@(TxtFiles->'output\%(Filename).out')" />
</ItemGroup>

Step 2 — Create an incremental target


<Target Name="ProcessText"
        Inputs="@(TxtFiles)"
        Outputs="@(ProcessedFiles)">

    <Message Text="Processing: %(TxtFiles.Identity)" />

</Target>

Step 3 — Run


dotnet build -t:ProcessText

Edit one text file → run again → MSBuild processes only the changed file.

9. Summary

Property functions let you perform dynamic string and logic operations.
Conditions allow selective execution of MSBuild elements.
Incremental builds avoid unnecessary work.
Inputs/Outputs determine whether a target runs.
The build graph enables parallel builds.
Diagnostic logging is essential for troubleshooting.

10. Day 6 Preview

Tomorrow you will learn:

Creating and reusing custom .props and .targets files
Overriding targets and imports safely
Shared company-wide MSBuild logic
Extending MSBuild without modifying individual projects