ASP.NET Hosting Tutorial: Knowing SQL System-Versioned Tables

One aspect of SQL that enables automatic tracking of data changes over time is system-versioned tables. In order to facilitate auditing changes and retrieving historical data, these tables aid in maintaining history versions of records.

How Do Tables With System Versions Operate?
The components of a system-versioned table are

Current data is stored in the main table.
History table: Maintains records from the past automatically.

Making a Table with System Versions
The SQL script that follows generates a history table and a system-versioned table called Employees.

CREATE TABLE Employees (
    EmployeeID INT PRIMARY KEY,
    Name NVARCHAR(100),
    Position NVARCHAR(100),
    Salary DECIMAL(10, 2),
    ValidFrom DATETIME2 GENERATED ALWAYS AS ROW START HIDDEN NOT NULL,
    ValidTo DATETIME2 GENERATED ALWAYS AS ROW END HIDDEN NOT NULL,
    PERIOD FOR SYSTEM_TIME (ValidFrom, ValidTo)
)
WITH (
    SYSTEM_VERSIONING = ON (
        HISTORY_TABLE = dbo.EmployeesHistory
    )
);

Querying System-Versioned Tables

Get Current Data

SELECT *
FROM Employees;

Get Historical Data

SELECT *
FROM EmployeesHistory;

Retrieve Data at a Specific Time

SELECT *
FROM Employees
FOR SYSTEM_TIME AS OF '2024-03-01T10:00:00';

Advantages of System-Versioned Tables

• Automatically tracks data changes.
• Provides historical auditing without manual tracking.
• Allows time-travel queries to retrieve past data states.
• Ensures data integrity and compliance with regulatory requirements.

System-versioned tables are highly beneficial for applications that require auditing, data recovery, and change tracking. 

Best ASP.NET Core 9 Hosting Recommendation

One of the most important things when choosing a good ASP.NET Core 9 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 HostForLIFEASP.NET, 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.

 

Read More...

The Object Oriented Programming in ASP.NET

The scalability and reusability of the code are enhanced by object-oriented programming, or OOP. Class and objects make up this. This is an example of object-oriented programming utilizing the C# language for traffic management.

 

Object

Any entity that has a state and behavior is known as an object. It can be defined as the Instance of the Class.

Class

The collection of objects is known as Class. It can also be defined as Blue Print from which you can Create the Objects.

The Object Oriented Programming contains the following four concepts.

• Encapsulation
• Abstraction
• Inheritance
• Polymorphism

1. Encapsulation

Wrapping of code and data in to signle unit is known as Encapsulation. Here in the Traffic Signal Management Concept the Encapsulation is used for Managing Traffic Signal State.

Encapsulation ensures traffic signals change safely without external interference.

Example

public class TrafficSignal
{
    private string signalColor;

    public void ChangeSignal(string color)
    {
        if (color == "Red" || color == "Green" || color == "Yellow")
        {
            signalColor = color;
            Console.WriteLine($"Signal changed to {signalColor}");
        }
        else
        {
            Console.WriteLine("Invalid signal color.");
        }
    }

    public string GetSignalColor()
    {
        return signalColor;
    }
}

2. Abstraction

Here in the Traffic Signal Management Concept the Abstraction is used for Controlling Road Barriers.

Abstraction hides complex logic behind simplified interfaces.

Example

public abstract class RoadBarrier
{
    public abstract void Operate();
}

public class TollGate : RoadBarrier
{
    public override void Operate()
    {
        Console.WriteLine("Toll gate is opening for the vehicle.");
    }
}

3. Inheritance

Here in the Traffic Signal Management Concept, the Inheritance is used for Specialized Traffic Lanes.

Inheritance helps define specialized behavior for different vehicle types.

Example

public class TrafficLane
{
    public void AllowVehicles()
    {
        Console.WriteLine("General vehicles are allowed.");
    }
}

public class EmergencyLane : TrafficLane
{
    public void AllowAmbulance()
    {
        Console.WriteLine("Ambulance is given priority in the emergency lane.");
    }
}

4. Polymorphism

Here in Traffic Signal Management Concept Polymorphism is used for Dynamic Traffic Control.

Polymorphism enables dynamic behavior changes.

Example

public class TrafficController
{
    public virtual void ControlTraffic()
    {
        Console.WriteLine("Managing normal traffic flow.");
    }
}

public class SmartTrafficController : TrafficController
{
    public override void ControlTraffic()
    {
        Console.WriteLine("Adjusting traffic lights dynamically based on congestion.");
    }
}

5. Main Program Execution

Below, we can see the usage of All OOp Concept.

Example

class Program
{
    static void Main()
    {
        // Calling of Encapsulation Example.
        TrafficSignal signal = new TrafficSignal();
        signal.ChangeSignal("Green");
        Console.WriteLine($"Current Signal: {signal.GetSignalColor()}");

        // Calling of Abstraction Example
        RoadBarrier toll = new TollGate();
        toll.Operate();

        // Calling of Inheritance Example
        EmergencyLane lane = new EmergencyLane();
        lane.AllowVehicles();
        lane.AllowAmbulance();

        // Calling of Polymorphism Example
        TrafficController controller = new SmartTrafficController();
        controller.ControlTraffic();
    }
}

Sample Output for Traffic Management System.

• Signal changed to Green
• Current Signal: Green
• A toll gate is opened for the vehicle.
• General vehicles are allowed.
• Ambulance is given priority in the emergency lane.
• Adjusting traffic lights dynamically based on congestion.

Conclusion

• This Traffic Management System uniquely showcases OOP principles in C#. Encapsulation secures signal data, abstraction simplifies road barriers, inheritance enables specialized lanes, and polymorphism allows adaptive traffic control.
• Using OOP effectively leads to well-structured, scalable applications in real-world scenarios.

Best ASP.NET Core 8.0 Hosting Recommendation

One of the most important things when choosing a good ASP.NET Core 8.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 HostForLIFEASP.NET, 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.

Read More...

Filter Auto Suggestion Feature in ASP.NET Dropdown List View

This post will describe how to use ASP.Net's filtering feature to receive auto suggestions from a dropdown list view. The data will be loaded from the script side and the Dropdown view asp:DropDownList tag will be used. The client-side dropdown view suggestion will be obtained with the aid of JavaScript's 'onkeyup' events. The following is an example markup page using javascript code.

Markup page

<asp:Content ID="BodyContent" ContentPlaceHolderID="MainContent" runat="server"><main>
    <script type="text/javascript">
        function filterDropdown() {
            var input, filter, dropdown, options, i;
            input = document.getElementById("txtSearch");
            filter = input.value.toUpperCase();
            dropdown = document.getElementById("<%= ddlOptions.ClientID %>");
             options = dropdown.getElementsByTagName("option");
             for (i = 0; i < options.length; i++) {
                 if (options[i].textContent.toUpperCase().indexOf(filter) > -1) {
                     options[i].style.display = "";
                 } else {
                     options[i].style.display = "none";
                 }
             }
         }
    </script>
            <div>
            <label for="txtSearch">Search:</label>
                <input type="text" id="txtSearch" onkeyup="filterDropdown()" placeholder="Search options..." />
            <asp:DropDownList ID="ddlOptions" runat="server">
                <asp:ListItem Text="Option" Value="Select"></asp:ListItem>
                <asp:ListItem Text="Option 1" Value="1"></asp:ListItem>
                <asp:ListItem Text="Option 2" Value="2"></asp:ListItem>
                <asp:ListItem Text="Option 3" Value="3"></asp:ListItem>
                <asp:ListItem Text="Option 4" Value="4"></asp:ListItem>


            </asp:DropDownList></div>

    </main>
</asp:Content>

Server end page

Protected Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs) Handles Me.Load
    ' No server-side logic needed for this example.
    If Not IsPostBack Then
        ddlOptions.Items.Clear()
        ddlOptions.Items.Add(New ListItem("aaa", "1"))
        ddlOptions.Items.Add(New ListItem("bbb 2", "2"))
        ddlOptions.Items.Add(New ListItem("ccc 3", "3"))
        ddlOptions.Items.Add(New ListItem("dd 4", "4"))
    End If
End Sub

Output

Best ASP.NET Core 8.0.11 Hosting Recommendation

One of the most important things when choosing a good ASP.NET Core 8.0.11 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.

Read More...

.NET Controllers or Minimal API’s ?

Both Controllers and Minimal APIs are ways to build web APIs in .NET, but they represent different approaches with distinct advantages and use cases.

Controllers

• Traditional Approach: Controllers are the cornerstone of ASP.NET MVC and Web API development. They are classes with methods (actions) that handle incoming requests and return responses.
• Structure: Controllers typically follow a Model-View-Controller (MVC) pattern, providing a clear separation of concerns.

Features

Controllers offer a wide range of features, including:

1. Action Filters: Attributes that modify the behavior of actions (e.g., authorization, caching).

Understanding Action Filters (C#)
The goal of this tutorial is to explain action filters. An action filter is an attribute that you can apply to a… 

learn.microsoft.com

2. Model Binding: Automatic conversion of request data into .NET objects.

Model Binding in ASP.NET Core

Learn how model binding in ASP.NET Core works and how to customize its behavior.

learn.microsoft.com

3. Dependency Injection: Seamless integration with the .NET dependency injection system.

4. Routing: Flexible routing options to define how requests are mapped to actions.

Example:

[ApiController]
[Route("[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IProductService _productService;

    public ProductsController(IProductService productService)
    {
        _productService = productService;
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetProduct(int id)
    {
        var product = await _productService.GetProductByIdAsync(id);
        if (product == null)
        {
            return NotFound();
        }
        return Ok(product);
    }
}

Minimal API’s

Minimal API is Microsoft’s attempt to response to JavaScript so-called “simple API”.

• Modern Approach: Minimal APIs are a streamlined way to build lightweight and fast APIs with minimal boilerplate code.

Minimal APIs overview

An introduction to the fastest and easiest way to create web API endpoints with ASP.NET Core.

learn.microsoft.com

• Focus: Prioritizes simplicity, performance, and a leaner development experience.
• Built on Top of: Leverage the underlying ASP.NET Core infrastructure but with a more concise syntax.

Key Features:

• Concise Syntax: Use lambda expressions to define endpoints directly.
• Lightweight: Reduced overhead compared to traditional controllers.
• Fast Startup: Faster application startup times.
• Ideal for: Microservices, small APIs, and scenarios where performance and simplicity are paramount.

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/products/{id}", async (int id, IProductService productService) =>
{
    var product = await productService.GetProductByIdAsync(id);
    if (product == null)
    {
        return Results.NotFound();
    }
    return Results.Ok(product);
});

app.Run();

Choosing Between Controllers and Minimal APIs

Use Controllers when:

• You need a full-featured framework with extensive features.
• You’re working on a larger application with complex logic.
• You prefer a more structured and maintainable approach.

Use Minimal APIs when:

• You need to build lightweight and high-performance APIs.
• You prioritize simplicity and conciseness.
• You’re working on small, focused APIs or microservices.

Consider these factors when making your decision:

• Project size and complexity: Larger projects may benefit from the structure and features of controllers, while smaller projects might be better suited for the simplicity of Minimal APIs.
• Performance requirements: If performance is critical, Minimal APIs can offer a slight edge.
• Team preferences and experience: Choose the approach that your team is most comfortable with and has the necessary skills for.

 

Best ASP.NET Core 8.0.11 Hosting Recommendation

One of the most important things when choosing a good ASP.NET Core 8.0.11 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.

Read More...

Swagger substitutes and open API documentation in.NET 9

For creating OpenAPI documents in ASP.NET Core applications, the Microsoft.AspNetCore.OpenApi package provides integrated support. It offers a number of essential features to improve API documentation. It first makes it possible for OpenAPI documents to be generated during runtime, which developers may then access via a specific application endpoint. Furthermore, it incorporates "transformer" APIs, which offer the ability to alter the produced documentation as necessary. Additionally, the package facilitates the generation of many OpenAPI documents from a single application, which facilitates the effective management and organization of API specifications. 

In this article, we will understand the following concepts in detail.

• Simple .Net Core Web API Project
• Understanding about Open API dcoumentation
• Swagger UI inclusion
• ReDoc Open API
• Scalar Open API

Simple .NET Core Web API Project

We will create a simple .Net core Web API project with the following steps in Visual Studio 2022.

Open Visual Studio 2022, Click on "Create new Project" then select the "ASP.NET Core Web API" option and click on "Next". 

Enter the project named "OpenAPIDocDemo" in the preferred location like below and click on "Next".

The Additional Information window is shown below. for this simple demo, we are keeping the info as-is and then clicking on the "Create" button.

After clicking on the "Create" button it shows the project like below.

We are done with a simple .Net Core Web API project.

Understanding about OpenAPI documentation

In the created project, we can observe the following referenced package "Microsoft.AspNetCore.OpenApi" provides built-in support of OpenAPI documentation.

 The Program.cs file has the following highlighted information about OpenAPI support.

Let's run the project and append the following "openapi/v1.json" in the browser localhost URL (Ex: localhost:7158/openapi/v1.json). We can observe the following screen.

It indicates without doing even a small line of code changes, The.NET9 Web API supports/generates JSON documents with the standard format of API documentation.

Swagger UI Inclusion

Let's make very minimal changes in this demo project to include Swagger UI (our very owned habituated API documentation.

Install the following package, "Swashbuckle.AspNetCore.SwaggerUI" from Nuget.

 

Add the following lines of code to the Program.cs file below to the existing code line "app.MapOpenApi();"

app.UseSwaggerUI(options =>
{
    options.SwaggerEndpoint("/openapi/v1.json", "v1");
});

That's it. We are done with Swagger UI inclusion in our .NET API project. Let's run the project again with the sample URL (https://localhost:7158/swagger/index.html). We can see the following page.

ReDoc UI Open API Document

Let's try to include ‘ReDoc” API documentation as well in our project.

Install the following Nuget package “Swashbuckle.AspNetCore.ReDoc”

 Add the following lines of code to the Program.cs file.

app.UseReDoc(options =>
{
    options.SpecUrl("/openapi/v1.json");
});

It's that simple..!!. We just included ReDoc API documentation in our .NET API project. Let's run the project again with the sample URL (https://localhost:7158/api-docs/index.html). We can see the following page.

Scalar UI Open API Document

Let's include ‘Scalar UI” Open API documentation in our project as well.

Add the following Nuget package “Scalar.AspNetCore” to our project.

 

Add the following simple line of code to our Program.cs file.

app.MapScalarApiReference();

So, After the inclusion of all aforesaid Open API document-related code inclusions in the Program.cs file, the code looks like below.

using Scalar.AspNetCore;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container
builder.Services.AddControllers();
builder.Services.AddOpenApi(); 
var app = builder.Build();
// Configure the HTTP request pipeline
if (app.Environment.IsDevelopment())
{
    app.MapOpenApi();

    app.UseSwaggerUI(options =>
    {
        options.SwaggerEndpoint("/openapi/v1.json", "v1");
    });
}
app.UseReDoc(options =>
{
    options.SpecUrl("/openapi/v1.json");
});

app.MapScalarApiReference();

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();

Let's run our project with the sample URL (https://localhost:7158/scalar/), and the screen looks like the one below.

The Scalar API provides more GUI-friendly features with the support of multiple programming languages of sample code if needed. These are really helpful whenever other development teams try to include/call our API in an easy way.

Let's try for a sample C# code for one of our existing Get methods in this sample project in the following way.

Best ASP.NET Core 8.0.11 Hosting Recommendation

One of the most important things when choosing a good ASP.NET Core 8.0.11 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.

Read More...

ASP.NET Core 6: Using Sessions to Create Dynamic Menus in Layout Pages

This article demonstrates how you leverage session management in ASP.NET Core 6. 1 to save and display dynamic menus on the layout page, allowing each user to have a personalized navigation experience. Session Enablement in Program.cs

Configuring the session in the Program.cs file in ASP.NET Core 6 requires adding the AddSession and UseSession methods to the pipeline. The following code will activate the session.

builder.Services.AddSession(options =>
{
    options.IdleTimeout = TimeSpan.FromMinutes(30);
    options.Cookie.HttpOnly = true;
});

builder.Services.AddSession();

2. Define the Menu Model

To show the menu's structure, you require a model. This is a simple model that includes Submodule and ModuleSubmoduleRolePermission.

public class ModuleSubmoduleRolePermission
{
    public int ModuleId { get; set; }
    public string ModuleName { get; set; }
    public string Action { get; set; }
    public bool IsChecked { get; set; }
    public List<SubmodulePermission> Submodules { get; set; }
}

public class SubmodulePermission
{
    public int? SubmoduleId { get; set; }
    public string SubmoduleName { get; set; }
    public string Controller { get; set; }
    public string subAction { get; set; }
    public string RoleName { get; set; }
    public int? RoleId { get; set; }
    public bool IsChecked { get; set; }
}

3. Store Menu Data in Session

Serialize the menu data in your controller and save it in the session. This is an example of an action method.

[HttpPost]
public async Task<ActionResult> Login(LoginModel model)
{
    if (ModelState.IsValid)
    {
        var response = await _authService.LoginAsync(model);
        if (response.Success == true) // Assuming "1" indicates success
        {
            var token = response.Token;
            Response.Cookies.Append("authToken", token, new CookieOptions
            {
                HttpOnly = true, // Prevent JavaScript access to the cookie
                Secure = true,   // Only send cookie over HTTPS
                SameSite = SameSiteMode.Strict // Prevent CSRF attacks

            });
            var handler = new JwtSecurityTokenHandler();
            var jsonToken = handler.ReadToken(token) as JwtSecurityToken;
            var userRole = jsonToken?.Claims.FirstOrDefault(c => c.Type == "role")?.Value;
            var Module = await _authService.GetModulesByRoleAsync(token,userRole);
            HttpContext.Session.SetString("Modules", JsonConvert.SerializeObject(Module));
            // If login is successful, redirect to another action (e.g., Dashboard)
            return RedirectToAction("Dashboard", "Dashboard");
        }
        else
        {
            // If login failed, show the error message from StatusDesc
            ViewBag.ErrorMessage= response.Message;
        }
    }

    // If we got this far, something failed; redisplay the form
    return View(model);
}

4. Retrieve and Display Menu in _Layout.cshtml

You can dynamically render the menu and access the session data on the layout page. To retrieve session values, use IHttpContextAccessor; to deserialize the data, use JsonConvert.

@inject IHttpContextAccessor HttpContextAccessor
@using ModelsLibrary.ADOModel
@using Newtonsoft.Json

@{
    var modulesJson = HttpContextAccessor.HttpContext?.Session.GetString("Modules");
    var UserName = HttpContextAccessor.HttpContext?.Session.GetString("username");
    List<ModuleSubmoduleRolePermission> modules = new();

    if (!string.IsNullOrEmpty(modulesJson))
    {
        modules = JsonConvert.DeserializeObject<List<ModuleSubmoduleRolePermission>>(modulesJson);
    }
}

5. Retrieve Menu Data

<div class="sidebar-nav">
    <!--navigation-->
   <ul class="hflmenu" id="sidenav">

        @if (modules != null)
        {
            @foreach (var module in modules)
            {
                <li>
                    <a href="@(string.IsNullOrEmpty(module.Action) ? "javascript:;" : GetUrl(module.Action))"
                       class="@(module.Submodules != null ? "has-arrow" : "")">
                        <div class="parent-icon">
                            <i class="material-icons-outlined">@GetIconForModule(module.ModuleName)</i>
                        </div>
                        <div class="menu-title">@module.ModuleName</div>
                    </a>

                    @if (module.Submodules != null)
                    {
                        <ul>
                            @foreach (var submodule in module.Submodules)
                            {
                                <li>
                                    <a href="@GetUrl(submodule.subAction)">
                                        <i class="material-icons-outlined">arrow_right</i>
                                        @submodule.SubmoduleName
                                    </a>
                                </li>
                            }
                        </ul>
                    }
                </li>
            }

        }
        else
        {
            <p>No modules available</p>

        }

    </ul>
    <!--end navigation-->
</div>

Output

Conclusion
The user experience in web applications can be enhanced by using this method to dynamically create a customized navigation menu based on session data in ASP.NET Core 6. You can do this by storing menu items in the session and using them in your layout to render dynamic menus that reflect the user's role or context.

Best ASP.NET Core 8.0.11 Hosting Recommendation

One of the most important things when choosing a good ASP.NET Core 8.0.11 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.

 

Read More...