Best, Cheap and Recommended Windows Hosting

Tuesday 22 October 2024

Using WebForms Core Technology to Cache HTML Tags

Websites and web apps typically have static sections that are continuously downloaded from the server. Typically, attempting to cache these tags is challenging. The purpose of this article is to explain how to use WebForms Core technology to cache static tags. WebForms Core makes extensive use of cache. In order to obtain the static tags of a webpage from the server only once, we wish to cache them entirely in the user's browser in this tutorial. Static tag caching drastically cuts down on bandwidth.

Layout page setting

Layout pages are a special type of page that can be used as a template for other pages. They are used to define a common layout that can be shared across multiple pages.

The following codes are related to a layout page that includes a header and footer and right and left menus. Also, on this page, the style tag has been added in the head section.

Global layout (layout.aspx)

@page
@islayout
<!DOCTYPE html>
<html>
<head>
    <title>CodeBehind Framework - @ViewData.GetValue("title")</title>
    <script type="text/javascript" src="/script/web-forms.js"></script>
    <meta charset="utf-8" />
    <style>
        /*
            ...
        */
    </style>
</head>
<body>

    @LoadPage("/header.aspx")
    @LoadPage("/left_menu.aspx")

    <main>
        @PageReturnValue
    </main>

    @LoadPage("/right_menu.aspx")
    @LoadPage("/footer.aspx")

</body>
</html>

In the above situation, every time a request arrives at the server, the server sends the entire page to the client. Header and footer tags and right and left menus, along with styles, take up a lot of bandwidth and also put some pressure on processing and memory on the server.

The screenshot below is an HTML page that uses the layout.aspx.

If you look closely at the image above, you will notice that only the contents of the white section change for each page, and the other sections are static.

Note. In WebForms Core technology, an HTML page needs to be fully loaded only for the first request in the browser. After the initial load, requests are automatically placed by Ajax in the body tag (which can be changed). Therefore, if you do not want to change fixed elements such as header and footer tags and menus after new requests, you should change the default tag option in the web-forms.js file as follows.

WebFormsJS library (web-forms.js)

function cb_GetResponseLocation() {
    // Return the first main element instead of the body
    return document.getElementsByTagName("main")[0];
}

According to the above codes, server responses (not Action Controls) are placed in the main tag. If you do not do this setting, the page that is made through WebFormsJS requests the contents of the body tag, such as the header, footer, and fixed menus, will be deleted.

Note. When you add the WebFormsJS library to the HTML page, the automatic form submission is done in Ajax mode; if the server response is Action Controls, the Action Controls codes are rendered by WebFormsJS. Otherwise, the server response is placed in the body tag.

From here on, the work starts, and we want to change this situation. First, we changed the above layout page.

Global layout after change (layout.aspx)

@page
@islayout
<!DOCTYPE html>
<html>
<head>
    <title>CodeBehind Framework - @ViewData.GetValue("title")</title>
    <script type="text/javascript" src="/script/web-forms.js"></script>
    <meta charset="utf-8" />
</head>
<body onload="GetBack('/set_static_tags')">

    <main>
        @PageReturnValue
    </main>

</body>
</html>

The changes we applied to the layout page are as follows.

Header and footer, right and left menus, and style tag have been removed
In the body tag, the onload attribute is added with the value GetBack('/set_static_tags')

We create a new View page named style.aspx and insert the removed style tag. We create a page called set_static_tags.aspx, and by using the WebForms class, we set the header and footer pages and the right and left menus along with the style page in the example created in the WebForms class.

View (set_static_tags.aspx)

@page
@{
    WebForms form = new WebForms();

    form.AddText("<body>", LoadPage("/style.aspx"));
    form.AddTextToUp("<body>", LoadPage("/left_menu.aspx"));
    form.AddTextToUp("<body>", LoadPage("/header.aspx"));
    form.AddText("<body>", LoadPage("/right_menu.aspx"));
    form.AddText("<body>", LoadPage("/footer.aspx"));

    form.SetCache(34164000); // One Year
}
@form.Response(context)

According to the View code above, after a new instance of the WebForms class is created, the following Action Controls are created in order to be applied to the client:

The style page is added inside the body tag (the order does not matter)
The left menu page is added above the internal content of the body tag
The header page is added above the internal content of the body tag
The left menu page is added at the bottom of the internal content of the body tag
The footer page is added below the internal content of the body tag
Action Controls commands are cached for one year (34164000 seconds) (the order does not matter)
Finally, calling @form.Response(context) causes the Action Controls to be written on the page

The order of calling the header and footer and the right and left menus is important and should be done in the order of the above codes.

The GetBack method is one of the important methods of WebForms Core technology, which is present in the WebFormsJS library. The methods that are added to the onload attribute of the body tag are executed after the HTML page is called, so calling the GetBack('/set_static_tags') method causes the set_static_tags.aspx page to be called.

Note. In the settings of the options file in the CodeBehind framework, you must enable the ability to rewrite views to the directory ("rewrite_aspx_file_to_directory=true"). Otherwise, you must set the GetBack method as follows.

GetBack('/set_static_tags.aspx');

The SetCache method is stored in the user's browser for a long time. You can use the SetSessionCache method when the user logs into your system. The SetSessionCache method keeps the data as long as the browser and after exiting the browser, the data is automatically lost.

Now, if you run the project and see the HTML source of the executed page, the header, footer, right and left menus, and style tag are not sent from the server. Also, the set_static_tags.aspx page is executed only once, and even after refreshing the page in the browser, this page is no longer requested.

Conclusion

In this article, we learned how to cache static tags in HTML using WebForms Core technology. Caching static HTML tags is a modern technique on the web, and using that leads to a decrease in bandwidth.

ASP.NET Core 9.0 Hosting Recommendation

One of the most important things when choosing a good ASP.NET Core 9.0 hosting is the feature and reliability. HostForLIFE is the leading provider of Windows hosting and affordable ASP.NET Core, their servers are optimized for PHP web applications. The performance and the uptime of the hosting service are excellent and the features of the web hosting plan are even greater than what many hosting providers ask you to pay for.

At HostForLIFE.eu, customers can also experience fast ASP.NET Core hosting. The company invested a lot of money to ensure the best and fastest performance of the datacenters, servers, network and other facilities. Its datacenters are equipped with the top equipments like cooling system, fire detection, high speed Internet connection, and so on. That is why HostForLIFEASP.NET guarantees 99.9% uptime for ASP.NET Core. And the engineers do regular maintenance and monitoring works to assure its Orchard hosting are security and always up.

Tuesday 15 October 2024

SharePoint 2013 Tutorial: Invoke-SPOSiteDesign Not Working

By Friedrich best SharePoint 2013 Hosting, cheap sharepoint 2013 hosting, recommended SharePoint 2013 Hosting, SharePoint 2013 Hosting Leave a Comment

Invoke-SPOSiteDesign will apply the site designs and related site scripts to the current SharePoint online modern sites, per MSFT documentation. Consider a scenario where you need to create custom solutions, libraries, and lists for a specific business use case. Instead of going through the same process over and over again, you could create a site design that could be saved and then applied to new or existing SharePoint online modern sites. See the references section for additional information about the site designs and site scripts.

I want to talk about the Invoke-SPOSiteDesign action's limitations in this blog article. A SharePoint Online PowerShell module function called Invoke-SPOSiteDesign will apply pre-existing Site Design to SharePoint online sites. Although no errors are raised when executing this command, the Site Design is not being implemented. The command that was used in my scenario is shown below.

# replace the Identity and WebUrl that are associated with your parameters.

Invoke-SPOSiteDesign -Identity “gerwtyru-g9cy-12we-123edefrty” -WebUrl “https://tailspin.sharepoint.com/sites/mycsutomsite”

Reason

Invoke-SPOSiteDesign has a limitation: it can only run up to 30 actions. In my case, I have more than 30 actions which is why the Invoke-SPOSiteDesign is not working.

Alternatives

The alternative action that can be used in this case is to use Add-SPOSiteDesignTask. This action will schedule the site design task to run in the next couple of minutes. Most probably within 5 minutes, the actions are applied, and the site design is reflected in respective SharePoint online modern sites. Replace the parameters -SiteDesignId and -WebUrl with respect to your scenario.

Add-SPOSiteDesignTask -SiteDesignId "gerwtyru-g9cy-12we-9aa3-123edefrty" -WebUrl "
https://hostforlife.sharepoint.com/teams/CustomTemplateDemo"

If you are using the PnP PowerShell module, then use the command Add-PnPSiteDesignTask.

Add-PnPSiteDesignTask -SiteDesignId "gerwtyru-g9cy-12we-9aa3-123edefrty" -WebUrl "
https://hostforlife.sharepoint.com/teams/CustomTemplateDemo"

Note. For PnP modules, you need to save the current connection to the site in a variable and use that as a connection parameter. For more information on how to connect to the SPO site using PnP Modules, please visit the references section.

Best SharePoint Hosting Recommendation

One of the most important things when choosing a good SharePoint hosting is the feature and reliability. HostForLIFE is the leading provider of Windows hosting and affordable SharePoint, their servers are optimized for PHP web applications such as the latest SharePoint version. The performance and the uptime of the hosting service are excellent and the features of the web hosting plan are even greater than what many hosting providers ask you to pay for.

At HostForLIFE.eu, customers can also experience fast SharePoint hosting. The company invested a lot of money to ensure the best and fastest performance of the datacenters, servers, network and other facilities. Its datacenters are equipped with the top equipments like cooling system, fire detection, high speed Internet connection, and so on. That is why HostForLIFE.eu guarantees 99.9% uptime for SharePoint. And the engineers do regular maintenance and monitoring works to assure its SharePoint hosting are security and always up.

Tuesday 8 October 2024

Solr Search in Sitecore

By Friedrich ASP.NET Core 9.0 Hosting, best ASP.NET Core 9.0 Hosting, cheap ASP.NET Core 9.0 Hosting, top ASP.NET Core 9.0 Hosting Leave a Comment

An extensive search is necessary when working on Sitecore components that call for listing or looking for certain things. We will use Solr Search, which has strong indexing and search capabilities suited to our requirements, to do this.

General search with Solr
We may construct an instance of SitecoreIndexableItem, run a query, and get the anticipated results of that search by taking into consideration the path of the item from which we want to execute the search, whether it is the homepage, a folder, or any specific page.

var rootItem = database.GetItem("ITEM_PATH");
var indexable = new SitecoreIndexableItem(rootItem);

using (var context = ContentSearchManager.GetIndex(indexable).CreateSearchContext())
{
    var query = context.GetQueryable<SearchResultItem>()
        .Filter(x => x.TemplateId == new ID("TEMPLATE_ID_FOR_SEARCH"));

    var resultItems = query?.Select(s => s.GetItem()).ToList() ?? new List<Item>();

    // YOUR LOGIC WITH THE RESULTS
}

Now, let's look at scenarios where additional attributes need to be analyzed in the query conditional.

Solr Search with specific attributes

To search for items using a specific field, we can create a BaseSearchResultItem inheritance to define the solr attributes we want to use to establish the search query.

For example, below we will see an example where we have items from authors, and we want to search for a particular one according to its ID.

public class AuthorSearchResultItem : BaseSearchResultItem
{
    [IndexField("author_id_s")]
    public string AuthorId { get; set; }

    [IndexField("author_name_s")]
    public string AuthorName { get; set; }
}

This is an example of a search.

var db = Sitecore.Context.Database;
var locationRoot = db.GetItem("ITEM_PATH");

var indexable = new SitecoreIndexableItem(locationRoot);

using (var context = ContentSearchManager.GetIndex(indexable).CreateSearchContext())
{
    var query = context.GetQueryable<AuthorSearchResultItem>()
        .Filter(x => x.TemplateId == new ID("TEMPLATE_ID_FOR_SEARCH"))
        .Filter(x => x.AuthorId == authorId);

    var authorResult = query.FirstOrDefault();
    var authorItem = author.GetItem();
}

Let's look at an additional case.

Solr Search with predicates

To establish specific conditionals of type AND or OR, we can use predicates when establishing the query to obtain the search results.

var predicateOr = PredicateBuilder.True<SearchResultItem>();
var predicateAnd = PredicateBuilder.True<SearchResultItem>();

predicateAnd = predicateAnd.And(s => s.AuthorId == authorId);

using (var context = ContentSearchManager.GetIndex(indexable).CreateSearchContext())
{
    var query = context.GetQueryable<SearchResultItem>()
        .Where(predicateAnd)
        .Where(predicateOr)
        .Take(10);

    var results = query.GetResults();
}

And that's it! With the previous examples, we can perform a Solr search in Sitecore to obtain a list of items or a particular item, considering conditionals and additional parameters in a query.

Thanks for reading!

If you have any questions or ideas in mind, it'll be a pleasure to be able to be in communication with you, and together exchange knowledge with each other.

ASP.NET Core 9.0 Hosting Recommendation

Monday 30 September 2024

Best and Cheap Joomla 5.1.4 Hosting in UK

By Friedrich best Joomla 5.1.4 Hosting in UK, cheap Joomla 5.1.4 Hosting in UK, Joomla 5.1.4 Hosting in UK, recommended Joomla 5.1.4 Hosting in UK Leave a Comment

To choose the Joomla 5.1.4 Hosting in UK for your site, we recommend you going with the following Best & Cheap Joomla 5.1.4 Hosting company that are proved reliable and sure by our editors. Meet Joomla 5.1.4, a powerful new suite of tools, and the strongest link in your new content supply chain. Interact with countless applications, thanks to REST-first native web services. Use progressive decoupling to break free from back-end restrictions without sacrificing security and accessibility. Deliver faster, with enhanced entity caching and better integration with CDNs and reverse proxies. With Joomla 5.1.4, you can build almost any integrated experience you can imagine.

Best and Cheap Joomla 5.1.4 Hosting in UK

UKWindowsHostASP.NET review is based on their industry reputation, web hosting features, performance, reliability, customer service and price, coming from our real hosting experience with them and the approximately 100 reviews from their real customers.UKWindowsHostASP.NET offers a variety of cheap and affordable UK Joomla 5.1.4 Hosting Plans with unlimited disk space for your website hosting needs.

UKWindowsHostASP.NET revolutionized hosting with Plesk Control Panel, a Web-based interface that provides customers with 24x7 access to their server and site configuration tools. Some other hosting providers manually execute configuration requests, which can take days. Plesk completes requests in seconds. It is included free with each hosting account. Renowned for its comprehensive functionality - beyond other hosting control panels - and ease of use, Plesk Control Panel is available only to UKWindowsHostASP.NET's customers.

https://ukwindowshostasp.net/UK-Joomla-Web-Hosting

UKWindowsHostASP.NET is the best UK Windows Hosting provider that offers the most affordable world class windows hosting solutions for their customers. They provide shared, reseller, cloud, and dedicated web hosting. They currently operate servers in four prestiguous cities in Europe, namely: London (UK), Amsterdam (Netherlands), Frankfurt (Germany), Washington DC (US), Paris (France), Singapore and Chennai (India). Their target is to provide a versatile and dependable one-stop online hosting and marketing shop for the small business entrepreneur, and eliminate the need for you to deal with a host of different online vendors. They offer high quality web hosting, dedicated servers, web design, domain name registration, and online marketing to help lead your business to online success.

Leveraging a strong market position within the domain name registration industry, UKWindowsHostASP.NET has carefully nurtured relationships with its customer base and built a feature-rich line of value-added services around its core domain name product offering. By bundling services and providing one-stop shopping, UKWindowsHostASP.NET has successfully grown and enjoyed increased breadth and loyalty of its customer base.

The Reason Why Choosing UKWindowsHostASP.NET?

24/7-based Support -They never fall asleep and they run a service that is operating 24/7 a year. Even everyone is on holiday during Easter or Christmas/New Year, they are always behind their desk serving their customers.
Excellent Uptime Rate - Their key strength in delivering the service to you is to maintain their server uptime rate. They never ever happy to see your site goes down and they truly understand that it will hurt your onlines business.
High Performance and Reliable Server - They never ever overload their server with tons of clients. They always load balance their server to make sure they can deliver an excellent service, coupling with the high performance and reliable server.
Experts in Web Hosting - Given the scale of their environment, they have recruited and developed some of the best talent in the hosting technology that you are using.
Daily Backup Service - They realise that your website is very important to your business and hence, they never ever forget to create a daily backup. Your database and website are backup every night into a permanent remote tape drive.
Easy Site Administration - With their powerful control panel, you can always administer most of your site features easily without even needing to contact for their Support Team.

Wednesday 11 September 2024

Keyed Dependency Injection for Services in.NET

By Friedrich ASP.NET Core 9.0 Hosting, best ASP.NET Core 9.0 Hosting, cheap ASP.NET Core 9.0 Hosting Leave a Comment

Dependency Injection (DI) is a potent pattern in.NET that facilitates unit testing, enhances code modularity, and manages dependencies between components. Sometimes, though, you have to deal with several implementations of the same interface or service. Keyed Service Dependency Injection is useful in this situation.

With Keyed Service DI, you can register several services with the same interface, each identified by a different key, and then resolve the services using that key. When you wish to manage which of multiple implementations of the same interface is injected at runtime, this method works well.

This post will explore the features, advantages, and real-world use of Keyed Service DI in.NET.

By using Keyed Service DI, you can achieve,

Cleaner Code: Avoids cluttering the business logic with conditional statements.
Decoupling: Keeps implementations independent, making them easier to maintain and test.
Flexibility: Offers runtime flexibility to decide which implementation to use based on application logic or configuration.

Implementing Keyed Service DI in .NET

Step 1. Open Visual Studio.

Open Visual Studio.
Click on "Create a new project".

Step 2. Create a New .NET Core Console Application.

In the "Create a new project" window, search for "Console App" and select "Console App (.NET Core)".
Click Next.
Set the project name (e.g., KeyedServiceDemo).
Choose a location to save the project and click Create.

Step 3. Install Required NuGet Packages (Optional).

If you're working with a web application, you may need additional packages like ASP.NET Core. But for this console app, we’ll stick with the default libraries.

Right-click on the Solution in the Solution Explorer.
Select Manage NuGet Packages.
Search for Microsoft.Extensions.DependencyInjection (should be installed by default in .NET Core projects).
Install it if necessary.

Step 4. Create the Interface.

In Solution Explorer, right-click on the project.
Select Add > New Folder and name it "Services".
Right-click on the Services folder, then select Add > Class.
Name the class IOperationService.cs and click Add.

Inside IOperationService.cs, add.

public interface IOperationService
{
    string PerformOperation();
}

Step 5. Implement the Services.

Now, you need to create two classes that implement the IOperationService.

5.1. Create AdditionService.

Right-click on the Services folder.
Select Add > Class and name it AdditionService.cs.
Add the following code.

public class AdditionService : IOperationService
{
    public string PerformOperation()
    {
        return "Performing Addition Operation";
    }
}

5.2. Create SubtractionService.

Right-click on the Services folder again.
Select Add > Class and name it SubtractionService.cs.
Add the following code.

public class SubtractionService : IOperationService
{
    public string PerformOperation()
    {
        return "Performing Subtraction Operation";
    }
}

Step 6. Create Enum for Keys.

Right-click on the Services folder.
Select Add > Class and name it OperationType.cs.
Add the following code.

public enum OperationType
{
    Addition,
    Subtraction
}

Step 7. Create the Factory.

Right-click on the Services folder.
Select Add > Class and name it OperationServiceFactory.cs.
Add the following code.

public interface IOperationServiceFactory
{
    IOperationService GetService(OperationType operationType);
}

public class OperationServiceFactory : IOperationServiceFactory
{
    private readonly IServiceProvider _serviceProvider;
    private readonly IDictionary<OperationType, Type> _serviceMapping;

    public OperationServiceFactory(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
        _serviceMapping = new Dictionary<OperationType, Type>
        {
            { OperationType.Addition, typeof(AdditionService) },
            { OperationType.Subtraction, typeof(SubtractionService) }
        };
    }

    public IOperationService GetService(OperationType operationType)
    {
        var serviceType = _serviceMapping[operationType];
        return (IOperationService)_serviceProvider.GetRequiredService(serviceType);
    }
}

Step 8. Register Services in Program.cs.

Open Program.cs from Solution Explorer.
Replace the default code with the following.

using Microsoft.Extensions.DependencyInjection;
using System;

namespace KeyedServiceDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Setup Dependency Injection
            var serviceProvider = new ServiceCollection()
                .AddTransient<AdditionService>()
                .AddTransient<SubtractionService>()
                .AddSingleton<IOperationServiceFactory, OperationServiceFactory>()
                .BuildServiceProvider();

            // Resolve Calculator and Execute Operation
            var calculator = new Calculator(serviceProvider.GetRequiredService<IOperationServiceFactory>());
            calculator.ExecuteOperation(OperationType.Addition);
            calculator.ExecuteOperation(OperationType.Subtraction);
        }
    }

    public class Calculator
    {
        private readonly IOperationServiceFactory _operationServiceFactory;

        public Calculator(IOperationServiceFactory operationServiceFactory)
        {
            _operationServiceFactory = operationServiceFactory;
        }

        public void ExecuteOperation(OperationType operationType)
        {
            var service = _operationServiceFactory.GetService(operationType);
            Console.WriteLine(service.PerformOperation());
        }
    }
}

Step 9. Build and Run the Application.

Save all files.
Press Ctrl+Shift+B to build the solution, or click Build > Build Solution.
After building, press F5 to run the application or click the Start button.

Expected Output

You should see the following output in the Console Window.

Benefits of Keyed Service DI

Simplifies Logic: Keyed DI reduces the need for if or switch statements to determine which service to use. Instead, it encapsulates this logic in the DI container.
Improves Maintainability: By having different service implementations registered by key, it becomes easier to maintain and extend the application. You can add more services without modifying the core business logic.
Runtime Flexibility: This approach allows for greater flexibility at runtime. Based on user inputs, configurations, or external conditions, the appropriate service implementation can be resolved dynamically.
Better Testing: It’s easier to test different implementations without coupling the test logic to specific conditions or requiring complex mocking.

Real-World Use Cases

Here are some real-world use cases where Keyed Service DI can make a big difference.

Notification Systems: Different notification channels like Email, SMS, or Push notifications can be keyed and injected as needed.
Payment Gateways: Multiple payment processors (e.g., PayPal, Stripe) could be registered as different services and resolved dynamically.
Data Providers: You may want to switch between different data providers (e.g., SQL, NoSQL) depending on the context, environment, or user preferences.

Conclusion

Dependency on Keyed Services .NET's powerful injection mechanism provides scalability and flexibility, particularly when handling several service implementations for the same interface. It guarantees more readable and maintainable code and improves runtime flexibility.

Developers can improve the separation of concerns, prevent crowded code, and create more dynamic and testable apps by utilizing this strategy. Thus, to simplify your approach the next time you find yourself in need of numerous implementations of the same service, think about utilizing Keyed Service DI.

ASP.NET Core 9.0 Hosting Recommendation

Tuesday 3 September 2024

Regular Expressions (Regex) in Depth

By Friedrich ASP.NET Core 9.0 Hosting, best ASP.NET Core 9.0 Hosting, cheap ASP.NET Core 9.0 Hosting Leave a Comment

Hello everyone, We are going to delve into the amazing realm of Regular Expressions, or Regex, today. Regular expressions (Regex) are a powerful tool for processing text. They allow you to specify a pattern to search for in a string, making them incredibly useful for validation, parsing, and extracting data from text. In this article, we'll explore the basics of regular expressions and see how they can be applied in C# to handle various common tasks.

What is a Regex?

A regular expression is a sequence of characters that forms a search pattern. It can be used to check if a string contains the specified search pattern or to find those matches within the string. Regex patterns can range from simple, such as finding specific words, to complex patterns for identifying sequences like email addresses or phone numbers.

Basic Components of Regex
1. Literals

Literals are the simplest form of pattern matching in regex. They match the exact characters in the text.

Example

Regex: cat
Matches: "The cat is cute."

2. Metacharacters

Metacharacters are characters with special meanings in regex. They are essential for creating flexible and dynamic patterns.

.(Dot): Matches any single character except newline characters.
- Regex: h.t
- Matches: "hat", "hot", "hit", etc.
^ (Caret): Asserts the position at the start of the string.
- Regex: ^hello
- Matches: "hello world", but not "say hello"
$ (Dollar): Asserts the position at the end of the string.
- Regex: world$
- Matches: "hello world**"**, but not "world hello"
* (Asterisk): Matches zero or more of the preceding element.
- Regex: ho*
- Matches: "h", "ho", "hoo", "hoooo", etc.
+ (Plus): Matches one or more of the preceding elements.
- Regex: ho+
- Matches: "ho", "hoo", "hoooo", but not "h"
? (Question Mark): Matches zero or one of the preceding elements, making it optional.
- Regex: color?r
- Matches: "color", "colour"

3. Character Classes

Character classes or character sets match any one of several characters.

[abc]: Matches any one character out of 'a', 'b', or 'c'.
- Regex: [abc]
- Matches: "a", "b", "c" in "cab"
[^abc]: Matches any one character except 'a', 'b', or 'c'.
- Regex: [^abc]
- Matches: "d", "e", "f" in "defibs"
[a-z]: Matches any one lowercase letter.
- Regex: [a-z]
- Matches: Any lowercase letter.
[A-Z]: Matches any one uppercase letter.
- Regex: [A-Z]
- Matches: Any uppercase letter.
[0-9]: Matches any one digit.
- Regex: [0-9]
- Matches: Any digit.

4. Quantifiers

Quantifiers specify how many instances of a character, group, or character class must be present in the input for a match to be found.

{n}: Matches exactly 'n' occurrences of the preceding element.
- Regex: a{3}
- Matches: "aaa" in "caaaat"
{n,}: Matches 'n' or more occurrences of the preceding element.
- Regex: a{2,}
- Matches: "aa", "aaa", "aaaa", etc.
{n,m}: Matches from 'n' to 'm' occurrences of the preceding element.
- Regex: a{2,4}
- Matches: "aa", "aaa", "aaaa"

5. Escape Characters

The backslash \ is used to escape special characters in regex, allowing them to be treated as literals.

Regex: \.
Matches: "." in "Mr. Smith"

Common Patterns

Here are some common regex patterns and their meanings.

Emails: ^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$
URLs: ^(http|https)://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,3}(/S*)?$
Phone Numbers: ^\d{3}-\d{3}-\d{4}$
Dates (MM/DD/YYYY): ^(0[1-9]|1[0-2])/(0[1-9]|1\d|2\d|3[01])/\d{4}$

Regex Example in C#

C# provides robust support for regular expressions through the System.Text.RegularExpressions namespace. Here’s how you can use some of the common patterns in C#.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        // Email validation
        string emailPattern = @"^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$";
        string email = "[email protected]";
        Console.WriteLine("Email is valid: " + Regex.IsMatch(email, emailPattern));

        // URL validation
        string urlPattern = @"^(http|https)://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,3}(/S*)?$";
        string url = "https://www.example.com";
        Console.WriteLine("URL is valid: " + Regex.IsMatch(url, urlPattern));

        // Phone number validation
        string phonePattern = @"^\d{3}-\d{3}-\d{4}$";
        string phone = "123-456-7890";
        Console.WriteLine("Phone number is valid: " + Regex.IsMatch(phone, phonePattern));

        // Date validation
        string datePattern = @"^(0[1-9]|1[0-2])/(0[1-9]|1\d|2\d|3[01])/\d{4}$";
        string date = "12/15/2020";
        Console.WriteLine("Date is valid: " + Regex.IsMatch(date, datePattern));
    }
}

Conclusion

Regular expressions are an essential skill for developers and IT professionals. They enhance your ability to work with text data, making your applications more robust and your workflows more efficient. Whether you are building data validation routines, developing parsing solutions, or automating text manipulation tasks, regex is an indispensable tool that can help you achieve your objectives with greater effectiveness.

ASP.NET Core 9.0 Hosting Recommendation

Tuesday 27 August 2024

Best & Cheap WordPress 6.6.1 Hosting in UK

By Friedrich best WordPress 6.6.1 Hosting in UK, cheap WordPress 6.6.1 Hosting in UK, top WordPress 6.6.1 Hosting in UK, WordPress 6.6.1 Hosting in UK Leave a Comment

To choose the WordPress 6.6.1 Hosting in UK for your site, we recommend you going with the following Best & Cheap WordPress 6.6.1 Hosting company that are proved reliable and sure by our editors. With WordPress, you can create any type of website you want: a personal blog or website, a photoblog, a business website, a professional portfolio, a government website, a magazine or news website, an online community, even a network of websites. You can make your website beautiful with themes, and extend it with plugins. You can even build your very own application.

Best & Cheap WordPress 6.6.1 Hosting in UK

UKWindowsHostASP.NET review is based on their industry reputation, web hosting features, performance, reliability, customer service and price, coming from our real hosting experience with them and the approximately 100 reviews from their real customers.UKWindowsHostASP.NET offers a variety of cheap and affordable UK WordPress 6.6.1 Hosting Plans with unlimited disk space for your website hosting needs.

https://ukwindowshostasp.net/UK-Wordpress-Web-Hosting

Why You Choose UKWindowsHostASP.NET for WordPress 6.6.1

Hosting in UK?

24/7-based Support -They never fall asleep and they run a service that is operating 24/7 a year. Even everyone is on holiday during Easter or Christmas/New Year, they are always behind their desk serving their customers.
Excellent Uptime Rate - Their key strength in delivering the service to you is to maintain their server uptime rate. They never ever happy to see your site goes down and they truly understand that it will hurt your onlines business.
High Performance and Reliable Server - They never ever overload their server with tons of clients. They always load balance their server to make sure they can deliver an excellent service, coupling with the high performance and reliable server.
Experts in Web Hosting - Given the scale of their environment, they have recruited and developed some of the best talent in the hosting technology that you are using.
Daily Backup Service - They realise that your website is very important to your business and hence, they never ever forget to create a daily backup. Your database and website are backup every night into a permanent remote tape drive.
Easy Site Administration - With their powerful control panel, you can always administer most of your site features easily without even needing to contact for their Support Team.

Best, Cheap and Recommended Windows Hosting

Tuesday 22 October 2024

Using WebForms Core Technology to Cache HTML Tags

ASP.NET Core 9.0 Hosting Recommendation

Tuesday 15 October 2024

SharePoint 2013 Tutorial: Invoke-SPOSiteDesign Not Working

Tuesday 8 October 2024

Solr Search in Sitecore

ASP.NET Core 9.0 Hosting Recommendation

Monday 30 September 2024

Best and Cheap Joomla 5.1.4 Hosting in UK

Best and Cheap Joomla 5.1.4 Hosting in UK

The Reason Why Choosing UKWindowsHostASP.NET?

Wednesday 11 September 2024

Keyed Dependency Injection for Services in.NET

Tuesday 3 September 2024

Regular Expressions (Regex) in Depth

Conclusion

ASP.NET Core 9.0 Hosting Recommendation

Tuesday 27 August 2024

Best & Cheap WordPress 6.6.1 Hosting in UK

Best & Cheap WordPress 6.6.1 Hosting in UK

Why You Choose UKWindowsHostASP.NET for WordPress 6.6.1

Hosting in UK?

Best Windows Hosting

Popular Posts

Other Important Blogs