Uri.Isbaseof(Uri) Method In C#

The Uri.IsBaseOf(Uri) function belongs to the System.Uri class in C#. This particular method serves the purpose of verifying if the provided Uri acts as the foundation for the specified Uri object. Essentially, it assesses whether the current Uri includes or serves as a beginning segment of the given Uri.

Syntax:

It has the following syntax:

public bool IsBaseOf(Uri uri);

The method parameter is 'uri', representing an instance of Uri for comparison with the current Uri. The return type is a Boolean value. It will return true if the current Uri serves as the base for the specified 'Uri'; otherwise, it will return false.

Example:

Let's consider a C# code example to showcase the Uri.IsBaseOf(Uri) Method.

using System;
class FileManagementSystem
{
    static void Main()
    {
        // file management system with hierarchical URLs
        Uri adminFolder = new Uri("https://www.filesystem.com/admin/");
        Uri userFolder = new Uri("https://www.filesystem.com/user/");
        Uri specificFile = new Uri("https://www.filesystem.com/user/documents/report.pdf");
        // Using IsBaseOf() method to check relationships
        bool isAdminBase = adminFolder.IsBaseOf(userFolder);
        bool isUserBase = userFolder.IsBaseOf(specificFile);
        Console.WriteLine("In the file management system:");
        Console.WriteLine($"- Admin folder is {(isAdminBase ? "" : "not ")}a base of the User folder.");
        Console.WriteLine($"- User folder is {(isUserBase ? "" : "not ")}a base of the specific file.");
        // Additional Example: Checking if the admin folder is a base for the specific file
        bool isAdminBaseForFile = adminFolder.IsBaseOf(specificFile);
        Console.WriteLine($"- Admin folder is {(isAdminBaseForFile ? "" : "not ")}a base of the specific file.");
    }
}

Output:

The given CSS code snippet defines a CSS class named "placeholder-diagram" with specific styling properties. This class sets a background color using a linear gradient, adds border-radius, padding, margin, and centers the content. Inside this class, there are two nested classes: "placeholder-icon" for setting the font size and margin of an icon, and "placeholder-text" for defining the color and font size of the text content.

Explanation:

In this C# program that simulates a file management system, hierarchical URLs are emulated through instances of the System.Uri class. The code makes use of the IsBaseOf method to verify the relationships between different levels in the system. Initially, the program compares if the admin folder URL acts as a base for the user folder URL, and whether the user folder URL serves as a base for a particular file URL. Subsequently, the outcomes are exhibited, offering clear insights into the hierarchical connections. Furthermore, an additional scenario is examined to determine if the admin folder URL functions as a base for the specified file URL. This program serves as a proficient illustration of how the Uri.IsBaseOf(Uri) method is employed to assess URL hierarchy in the context of a file management system.

Example 2:

Let's consider a C# code example to demonstrate the functionality of the Uri.IsBaseOf(Uri) Method.

using System;
class WebsiteComparison
{
    static void Main()
    {
        // Checking if two URLs belong to the same domain
        CheckDomain(new Uri("https://www.example.com"), new Uri("https://www.example.com/about"));
        // Checking if one URL is a base for another in terms of subdomains
        CheckSubdomain(new Uri("https://blog.example.com"), new Uri("https://www.blog.example.com/archive"));
    }
    public static void CheckDomain(Uri url1, Uri url2)
    {
        bool sameDomain = url1.IsBaseOf(url2);
        Console.WriteLine($"For domain comparison:");
        Console.WriteLine($"- URL1 ({url1}) is {(sameDomain ? "" : "not ")}a base of URL2 ({url2}).");
        Console.WriteLine();
    }
    // Method to check if one URL is a base for another in terms of subdomains
    public static void CheckSubdomain(Uri url1, Uri url2)
    {
        bool isBase = url1.IsBaseOf(url2);
        Console.WriteLine($"For subdomain comparison:");
        Console.WriteLine($"- URL1 ({url1}) is {(isBase ? "" : "not ")}a base of URL2 ({url2}).");
    }
}

Output:

Styling for a placeholder element is defined in the following code snippet:

.placeholder-diagram { background: linear-gradient(135deg, #374151 0%, #1f2937 100%); border-radius: 12px; padding: 40px; margin: 20px 0; text-align: center; }
.placeholder-diagram .placeholder-icon { font-size: 3rem; margin-bottom: 10px; }
.placeholder-diagram .placeholder-text { color: #9ca3af; font-size: 1rem; }

Explanation:

This C# code showcases the functionality of the Uri.IsBaseOf(Uri) method by performing two distinct comparisons. One comparison assesses whether two URLs share the same domain, while the other identifies if one URL serves as a base for another in relation to subdomains. The CheckDomain function analyzes domain associations, while the CheckSubdomain function concentrates on subdomain structures, delivering precise outcomes for each evaluation. This program effectively illustrates the versatility and utility of the Uri.IsBaseOf(Uri) method in examining various attributes of URLs.

Applications of Uri.IsBaseOf(Uri) method:

Some key real-world implementations of this technique include:

URL Hierarchy Navigation:

When developing web applications, the Uri.IsBaseOf(Uri) function proves useful for traversing hierarchical URL arrangements. This can involve tasks such as verifying whether a given page URL resides within a larger category.

Security Checks:

In security applications, this technique can be utilized to verify that specific URLs belong to an anticipated domain or subdomain, thereby thwarting unauthorized entry.

Link Categorization:

When classifying hyperlinks or URLs within a web application, programmers can employ this technique to define connections between various parts of a website.

Example:

Let's consider a C# code example to illustrate the aforementioned use cases.

using System;
class WebApplication
{
    static void Main()
    {
        // Simulating URLs in a web application
        Uri categoryPage = new Uri("https://www.example.com/categories/");
        Uri specificPage = new Uri("https://www.example.com/categories/product123");
        Uri adminPage = new Uri("https://www.example.com/admin/dashboard");
        CheckHierarchyNavigation(categoryPage, specificPage);
        CheckSecurity(adminPage, "admin");
       CategorizeLink(categoryPage, specificPage);
    }
    // Application 1: URL Hierarchy Navigation
    public static void CheckHierarchyNavigation(Uri basePage, Uri subPage)
    {
        bool isBase = basePage.IsBaseOf(subPage);

        Console.WriteLine("Application 1: URL Hierarchy Navigation");
        Console.WriteLine($"- {basePage} is {(isBase ? "" : "not ")}a base of {subPage}.");
        Console.WriteLine();
    }
    // Application 2: Security Checks
    public static void CheckSecurity(Uri allowedDomain, string userInput)
    {
        Uri userInputUri = new Uri($"https://{userInput}.example.com");

        bool isValid = allowedDomain.IsBaseOf(userInputUri);

        Console.WriteLine("Application 2: Security Checks");
        Console.WriteLine($"- {userInputUri} is {(isValid ? "" : "not ")}valid within the expected domain.");
        Console.WriteLine();
    }
    // Application 3: Link Categorization
    public static void CategorizeLink(Uri category, Uri specificPage)
    {
        bool isCategoryLink = category.IsBaseOf(specificPage);

        Console.WriteLine("Application 3: Link Categorization");
        Console.WriteLine($"- {specificPage} is {(isCategoryLink ? "" : "not ")}categorized under {category}.");
    }
}

Output:

The <style> section defines the styling for a placeholder diagram element. This includes setting a background with a linear gradient, border radius, padding, margin, and alignment. Inside the diagram, there is an icon with a specific font size and margin, as well as text with a designated color and font size. The overall design aims to create visually appealing placeholders for various elements.

Explanation:

This C# code showcases a web application scenario involving three separate applications that leverage the Uri.IsBaseOf(Uri) method. Initially, it verifies the hierarchical structure of URLs to establish if a base page is contained within a subpage. The second application focuses on security validations, ensuring that user-inputted URLs are legitimate within an anticipated domain. Lastly, the third application classifies links to determine if a particular page falls under a broader category page. Through these examples, the program illustrates the versatility of the Uri.IsBaseOf(Uri) method across various web application contexts.