Getting Started with PathBase in ASP.NET Core: A Comprehensive Guide


Asp.Net Core is a vital skill that clients always desire for their software projects. This is due to the platform’s improved features, which enable speedier development with less effort. Pathbase expertise is one of the crucial skills that drive firms to hire Asp.Net Core developers.

What is PathBase?

PathBase is an innovative and cutting-edge open-source project that aims to revolutionize the way websites are created, edited, and published. With its powerful single HTTP endpoint, it seamlessly manages all the intricate paths within your site, catering to both static and dynamic content.

The robust PathBase API empowers you to effortlessly perform a multitude of operations, including the creation of new directories, the seamless upload, modification, and deletion of files, comprehensive listing and copying of directory contents, efficient deletion of directories, and seamless publication or unpublishing of your entire site.

As if that wasn’t impressive enough, PathBase also provides a versatile client API that allows you to effortlessly query paths and effortlessly download files.

How PathBase simplifies the system paths of an application?

PathBase serves as an invaluable library specifically designed to simplify the management of file system paths within ASP.NET Core web applications. Originally conceptualized to provide developers with a streamlined approach to handling Web forms, PathBase goes above and beyond, offering an abstract representation of physical paths and establishing a standardized means of accessing files and directories within the file system.

By employing PathBase, you can seamlessly navigate the complexities of your web application, while enjoying the convenience and reliability of a unified and intuitive system.

Look at the following example depicting how to set Pathbase.


These are some common use cases of PathBase with ASP.NET Core:

  1. You have a directory with dynamic content where you need a new route for the index page
  2. You have an existing directory where you want to copy static content from another directory

Created on .NET Core and written in languages supporting .NET Core – C#, F# or VB.’PathBoader’ class lets you operate one directory level above the current directory: add, delete, or rename a subdirectory.

PathReflection will also allow any path object to be constructed from underlying paths so you could construct it without building or finding the one for your application.

PathBase Example

public void Configure(IApplicationBuilder app)



    // Make a “side branch” that, when executed, always prints the path information.

    app.Map(“/demoApp1”, demoApp => demoApp

        .Run(ctx => ctx.Response.WriteAsync(

            $” DemoApp: PathBase: {ctx.Request.PathBase} Path: {ctx.Request.Path}”)));

    // Print the path information if the side branch is not run.

    app.Run(ctx => ctx.Response.WriteAsync(

        $” DemoApp: PathBase: {ctx.Request.PathBase} Path: {ctx.Request.Path}”));


The illustration below makes an effort to visualise it and tracks the development of two requests:


Two rules that are essential for Pathbase

  1. If the request contains the prefix, the PathBaseMiddleware transfers it from Path to PathBase. The PathBaseMiddleware does nothing if the prefix is missing from the request.
  2. The prefix is changed from Path to PathBase when a request enters the pipeline’s Map() branch.

Why use PathBase?

The situation that can be considered, is when you deploy applications behind a proxy of some kind. There are many situations in which this may be relevant, but let’s take the example of when you’re deploying your application to Kubernetes and have an ingress. Ones that begin with /demoapplication1 are forwarded to your application, whereas requests that begin with /demoapplication2 are forwarded to another application.

With that configuration, your application will receive requests with the /demoapplication1 prefix. The /demoapplication1 prefix should not, however, be included to each and every link in your application. Why host your application behind /some-other-path if the proxy configuration changes? You wouldn’t want any of your links to break.

PathBase offers a method to accomplish this for your entire app in one location. Link Generator considers the PathBase for creating links, but only considers the Path portion when routing traffic.

How to use PathBase?

Consider the following simple API setup as an illustration. This produces two endpoints.

/demoapi1, which is referred to as api1, prints the path details and a link to demo api2.

/demoapi2, which is referred to as api2, prints the path details and a link to demo api1


Putting UsePathBase() in the appropriate place


You should take note of the fact that I called UseRouting() in the example above after calling UsePathBase (). That was crucial. The behavior changes drastically if we switch those two calls in the middleware chain. In order to show that I’m going to create a fallback endpoint that is called if no other endpoint runs, let’s look at an example


The first two queries, in which the /demoapplication prefix is omitted, are forwarded to the proper destination as before. This is expected because if the UsePathBase() prefix isn’t provided, it’s a loop.


Requests that do contain the PathBase prefix, however, are not routed correctly. Both of them are reverting to the fallback endpoint. However, the PathBase and Path values in the fallback answer can be shown to be what we would anticipate. Why isn’t it routing appropriately if they are the same as in the prior instance when UseRouting() was put after UsePathBase()?

The issue is that the request tries to match a route based on the complete path when it reaches the UseRouting() endpoint. We don’t remove the /demoapplication prefix when we call UseRouting() first, thus we try to route using the complete /demoapplication/demoapi1 path, which fails.

 The PathBaseMiddleware, which inserts the /demoapplication prefix into PathBase, is encountered by the request as it progresses through the middleware pipeline. But by then, the routing has already been lost!

Based on these illustrations, you should often call UsePathBase() before calling UseRouting (). When using the new web application builder in.NET 6 with limited hosting, that is when things get complicated. You must be careful when calling UsePathBase because WebApplication adds an implicit call to UseRouting()


PathBase sounds like a valuable tool for web developers, as it simplifies the creation, editing, and publishing of websites. With its single HTTP endpoint and support for static and dynamic content, developers can easily manage paths, upload, and modify files, and perform various directory operations.

The PathBase API and client API make it convenient to interact with the file system paths in ASP.NET Core web applications and hire Asp.Net Core developers. It’s a useful library for accessing files and directories in a standardized way.

Leave a Reply

Your email address will not be published. Required fields are marked *