European ASP.NET 4.5 Hosting BLOG

BLOG about ASP.NET 4, ASP.NET 4.5 Hosting and Its Technology - Dedicated to European Windows Hosting Customer

European ASP.NET Core Hosting - HostForLIFE :: Various Methods in the.NET Entity Framework

clock January 26, 2024 05:37 by author Peter

Overview of the Entity Framework
A strong and adaptable Object-Relational Mapping (ORM) framework that makes database interactions in.NET applications easier is called Entity Framework (EF). We'll explore several Entity Framework techniques in this extensive tutorial, with examples to help even.NET novices understand the ideas.

Entity Framework removes the requirement for developers to write raw SQL queries by enabling them to communicate with databases using.NET objects. It supports various strategies, each having benefits and applications of its own.

1. A database-first strategy
The Database-First method entails building the database first, then using it to generate the model.
Actions

  • Build Database: Using SQL Server Management Studio or another database tool, design and build the database.
  • Create Model: To create the model from the current database, use the Entity Data Model Wizard.
  • Employ Created Classes For database activities, make use of the automatically produced classes.

// Auto-generated class representing a table in the database
public partial class Product
{
    public int ProductID { get; set; }
    public string ProductName { get; set; }
    // Other properties
}

// Usage in code
using (var context = new YourDbContext())
{
    var products = context.Products.ToList();
    // Perform operations on products
}


2. Code-First Approach

The Code-First method starts with the creation of the domain classes, from which the database is then generated.
Actions

  • Establish domain classes that represent entities by using define classes.
  • Establish Relationships: To establish relationships between entities, use Data Annotations or Fluent API.
  • Create Database: Based on the model, create and update the database using migrations.

public class Product
{
    public int ProductID { get; set; }
    public string ProductName { get; set; }
    // Other properties
}

public class YourDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }
    // Other DbSets

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        // Fluent API configuration for relationships
    }
}

3. Model-First Method
Using the Entity Data Model Designer, the Entity Data Model (EDM) is created, and the database is subsequently generated from it via the Model-First approach.
Actions

  • To develop an Entity Data Model, use the Entity Data Model Designer.
  • Generate Database: Select the Generate Database from Model option to generate the database from the EDM.

As an illustration
With Entity Data Model Designer, the model-first approach frequently incorporates visual design, which makes it less code-oriented.

4. Context of Databases and LINQ Queries
Whichever strategy is used, after the model is created developers use a database context to communicate with the database via LINQ queries.

using (var context = new YourDbContext())
{
    var products = from p in context.Products
                   where p.ProductName.Contains("Shoes")
                   select p;

    // Perform operations on products
}


Comprehending the various methodologies in Entity Framework enables.NET developers to select the most appropriate technique for their project needs. Entity Framework offers flexibility and abstraction for effective database interactions in.NET applications, regardless of your preference for building databases first, writing classes, or using visual modeling.

Have fun with coding!

HostForLIFE ASP.NET Core Hosting

European best, cheap and reliable ASP.NET hosting with instant activation. HostForLIFE.eu is #1 Recommended Windows and ASP.NET hosting in European Continent. With 99.99% Uptime Guaranteed of Relibility, Stability and Performace. HostForLIFE.eu security team is constantly monitoring the entire network for unusual behaviour. We deliver hosting solution including Shared hosting, Cloud hosting, Reseller hosting, Dedicated Servers, and IT as Service for companies of all size.



European ASP.NET Core Hosting - HostForLIFE :: Working with Asp.NET Core Web API's SQL Lite Database

clock January 22, 2024 06:21 by author Peter

To start a new ASP.NET Core Web API project, use the command line or Visual Studio.
dotnet new webapi -n WorkingwithSQLLiteinAsp.NETCoreWebAPI
cd WorkingwithSQLLiteinAsp.NETCoreWebAPI

Install SQLite NuGet Package
Install the SQLite NuGet package to enable SQLite support in your project.
dotnet add package Microsoft.EntityFrameworkCore.Sqlite

Now Create SQLite Database File in your Project
SQLLiteDatabase.db

Create Model
namespace WorkingwithSQLLiteinAsp.NETCoreWebAPI.Models
{
    // Models/TodoItem.cs
    public class TodoItem
    {
        public long Id { get; set; }
        public string Name { get; set; }
        public bool IsComplete { get; set; }
    }

}


Now Crete Application Database Context
using Microsoft.EntityFrameworkCore;
using WorkingwithSQLLiteinAsp.NETCoreWebAPI.Models;

namespace WorkingwithSQLLiteinAsp.NETCoreWebAPI.ApplicationDbContext
{
    public class AppDbContext : DbContext
    {
        public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

        public DbSet<TodoItem> TodoItems { get; set; }
    }
}

Add Connection string in AppSetting.JSON File
// appsettings.json
{
  "ConnectionStrings": {
    "DefaultConnection": "Data Source=SQLLiteDatabase.db"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}

Register the Dependancy in Program.cs File
using Microsoft.EntityFrameworkCore;
using Microsoft.OpenApi.Models;
using WorkingwithSQLLiteinAsp.NETCoreWebAPI.ApplicationDbContext;

var builder = WebApplication.CreateBuilder(args);
var configuration = builder.Configuration;

// Add services to the container.
builder.Services.AddDbContext<AppDbContext>(options =>
        options.UseSqlite(configuration.GetConnectionString("DefaultConnection")));
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "Working with SQLLite In Asp.net Core Web API", Version = "v1" });

});

var app = builder.Build();

// Configure the HTTP request pipeline.
if(app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();


Create and Apply Migrations
Run the following commands to create and apply migrations to create the SQLite database.
dotnet ef migrations add InitialCreate
dotnet ef database update


CRUD Operations
Implement CRUD operations in your controller.
// Controllers/TodoController.cs
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using WorkingwithSQLLiteinAsp.NETCoreWebAPI.ApplicationDbContext;
using WorkingwithSQLLiteinAsp.NETCoreWebAPI.Models;

[ApiController]
[Route("api/[controller]/[Action]")]
public class TodoController : ControllerBase
{
    private readonly AppDbContext _context;

    public TodoController(AppDbContext context)
    {
        _context = context;
    }

    // GET: api/Todo
    [HttpGet]
    public async Task<ActionResult<IEnumerable<TodoItem>>> GetTodoItems()
    {
        return await _context.TodoItems.ToListAsync();
    }

    // GET: api/Todo/5
    [HttpGet("{id}")]
    public async Task<ActionResult<TodoItem>> GetTodoItem(long id)
    {
        var todoItem = await _context.TodoItems.FindAsync(id);

        if(todoItem == null)
        {
            return NotFound();
        }

        return todoItem;
    }

    // POST: api/Todo
    [HttpPost]
    public async Task<ActionResult<TodoItem>> PostTodoItem(TodoItem todoItem)
    {
        _context.TodoItems.Add(todoItem);
        await _context.SaveChangesAsync();

        return CreatedAtAction(nameof(GetTodoItem), new { id = todoItem.Id }, todoItem);
    }

    // PUT: api/Todo/5
    [HttpPut("{id}")]
    public async Task<IActionResult> PutTodoItem(long id, TodoItem todoItem)
    {
        if(id != todoItem.Id)
        {
            return BadRequest();
        }

        _context.Entry(todoItem).State = EntityState.Modified;

        try
        {
            await _context.SaveChangesAsync();
        }
        catch(DbUpdateConcurrencyException)
        {
            if(!TodoItemExists(id))
            {
                return NotFound();
            }
            else
            {
                throw;
            }
        }

        return NoContent();
    }

    // DELETE: api/Todo/5
    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteTodoItem(long id)
    {
        var todoItem = await _context.TodoItems.FindAsync(id);
        if(todoItem == null)
        {
            return NotFound();
        }

        _context.TodoItems.Remove(todoItem);
        await _context.SaveChangesAsync();

        return NoContent();
    }

    private bool TodoItemExists(long id)
    {
        return _context.TodoItems.Any(e => e.Id == id);
    }
}


Output

Conclusion
SQLite is a relational database management system (RDBMS) that is self-contained, serverless, and requires no configuration. It is an embedded database engine that is lightweight, open-source, and runs directly on the client device, eliminating the need for a separate server process. Some of SQLite's key features are.

  • Self-contained: It is simple to install and maintain because the whole database system is housed in a single library.
  • Serverless: SQLite does not function as a separate server process, in contrast to conventional database management systems. Rather, it is incorporated straight into the program.
  • Zero-configuration: Complex setup or administration are not necessary for SQLite. The database is a single, straightforward file that often has a.db extension; no server setup or upkeep is required.
  • Cross-platform: SQLite is compatible with a number of operating systems and mobile platforms, including iOS and Android, as well as Windows, macOS, and Linux.
  • Single-user: Because SQLite is optimized for single-user applications, embedded systems, mobile apps, and lightweight desktop programs can all benefit from its use.
  • ACID-compliant: SQLite preserves the ACID (Atomicity, Consistency, Isolation, Durability) qualities, guaranteeing data reliability and integrity, even with its lightweight design.
  • Dynamic typing: SQLite stores data using dynamic typing, which enables users to store several kinds of data in the same column.
  • Broad language support: SQLite is adaptable to a variety of development contexts since it supports a wide range of programming languages, including C, C++, Java, Python, and.NET.

SQLite is often utilized in situations where a lightweight and integrated database solution is needed, such as mobile applications, desktop software, and embedded systems, because of its simplicity, portability, and ease of integration.

HostForLIFE ASP.NET Core Hosting

European best, cheap and reliable ASP.NET hosting with instant activation. HostForLIFE.eu is #1 Recommended Windows and ASP.NET hosting in European Continent. With 99.99% Uptime Guaranteed of Relibility, Stability and Performace. HostForLIFE.eu security team is constantly monitoring the entire network for unusual behaviour. We deliver hosting solution including Shared hosting, Cloud hosting, Reseller hosting, Dedicated Servers, and IT as Service for companies of all size.

 



European ASP.NET Core Hosting - HostForLIFE :: FluentValidation in .NET 8

clock January 16, 2024 06:25 by author Peter

FluentValidation: What Is It?
An open-source validation toolkit for.NET called FluentValidation offers a fluid interface for creating and implementing validation rules. It makes validation logic easy to comprehend, write, and maintain by enabling developers to describe it succinctly and clearly.

.NET 8's FluentValidation

Installing the FluentValidation NuGet package is required in order to use FluentValidation in.NET 8. The following command can be used to accomplish this in the.NET CLI or Package Manager Console:

dotnet add package FluentValidation

Verifying a Basic User Model
Let's construct a straightforward example in which we wish to validate a User class. To make sure the user's email address is legitimate and their name is not empty, we will use FluentValidation.

using FluentValidation;

public class User
{
    public string Name { get; set; }
    public string Email { get; set; }
}

public class UserValidator : AbstractValidator<User>
{
    public UserValidator()
    {
        RuleFor(user => user.Name).NotEmpty().WithMessage("Name cannot be empty");
        RuleFor(user => user.Email).NotEmpty().EmailAddress().WithMessage("Invalid email address");
    }
}

In this instance:

  • We provide properties for Name and Email in our User class definition.
  • We construct a class called UserValidator, which is derived from AbstractValidator<User>.
  • We define validation rules for the Name and Email properties inside the UserValidator constructor using the RuleFor method.

Applying FluentValidation to Your Software
Let's look at how we can utilize FluentValidation in our application now that we have our User class and matching validator:

class Program
{
    static void Main()
    {
        var user = new User { Name = "Mahesh Chand", Email = "[email protected]" };
        var validator = new UserValidator();

        var validationResult = validator.Validate(user);

        if (validationResult.IsValid)
        {
            Console.WriteLine("User is valid");
        }
        else
        {
            foreach (var error in validationResult.Errors)
            {
                Console.WriteLine($"Validation Error: {error.ErrorMessage}");
            }
        }
    }
}

In this instance:

  • We construct an instance of the User class and set its properties.
  • We instantiate a UserValidator object.
  • By handing in the User instance, we invoke the Validate method on the validator.
  • We verify the validity of the validation result. We print a success message if it is. If not, we repeat the mistakes and print them.

.NET 8's FluentValidation offers a tidy and expressive approach to handling validation in your applications. You can confidently design and run validation rules thanks to its fluid interface and simple syntax. Using FluentValidation makes it possible to isolate your validation logic apart from your business logic, as seen in our example, which makes your codebase easier to read and manage.

HostForLIFE ASP.NET Core Hosting

European best, cheap and reliable ASP.NET hosting with instant activation. HostForLIFE.eu is #1 Recommended Windows and ASP.NET hosting in European Continent. With 99.99% Uptime Guaranteed of Relibility, Stability and Performace. HostForLIFE.eu security team is constantly monitoring the entire network for unusual behaviour. We deliver hosting solution including Shared hosting, Cloud hosting, Reseller hosting, Dedicated Servers, and IT as Service for companies of all size.



European ASP.NET Core Hosting - HostForLIFE :: Implementing CORS in Your ASP.NET Core Project

clock January 9, 2024 06:24 by author Peter

Cross-Origin Resource Sharing (CORS) is a vital security feature that controls how resources on a web page can be accessed by web applications from different domains. In an ASP.NET Core project, enabling CORS involves configuring the server to allow or restrict access to its resources from different origins. Here's a step-by-step guide on establishing CORS in your ASP.NET Core application.

Step 1. Set up the middleware for CORS

Installing the Microsoft.AspNetCore.Cors package is the first step. Using the NuGet Package Manager Console, you may accomplish this.

Install-Package Microsoft.AspNetCore.Cors

Alternatively, you can add it to your project's .csproj file:
<PackageReference Include="Microsoft.AspNetCore.Cors" Version="x.x.x" />


Replace x.x.x with the latest version available.

Step 2. Configure CORS in Startup.cs

Open your Startup.cs file and locate the ConfigureServices method. Add the CORS service by calling AddCors in the ConfigureServices method.
public void ConfigureServices(IServiceCollection services)
{
    // Other configurations

    services.AddCors(options =>
    {
        options.AddPolicy("AllowSpecificOrigin",
            builder =>
            {
                builder.WithOrigins("https://example.com")
                       .AllowAnyHeader()
                       .AllowAnyMethod();
            });
    });

    // Other configurations
}


In the code snippet above:

  • The CORS services are added to the application's service container via AddCors.
  • AddPolicy generates a specified CORS policy that identifies permitted origins, headers, and methods ("AllowSpecificOrigin" in this example).

To designate which domains are permitted to access your resources, modify WithOrigins. To accept requests from any origin, use a "*".

Step 3. Turn on the CORS middleware

Add the CORS middleware to Startup.cs's Configure function.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Other configurations

    app.UseCors("AllowSpecificOrigin");

    // Other configurations
}


This middleware must be added before other middleware that may handle requests, such as MVC or static file middleware.

Step 4: Verify Your CORS Setup
Once set up, make queries to your ASP.NET Core APIs from various origins to test the CORS settings. Make that the methods, headers, and permitted origins meet the needs of your application.

In summary

For secure communication between your application and clients from different domains, and to control access to your resources, you must implement CORS in your ASP.NET Core project. You can increase the security of your application while enabling critical cross-origin communication by defining CORS policies, which allow you to control which origins can access your APIs.

Always keep in mind to properly set your CORS policies based on the security requirements of your application, keeping in mind the possible hazards related to cross-origin requests.

HostForLIFE ASP.NET Core Hosting

European best, cheap and reliable ASP.NET hosting with instant activation. HostForLIFE.eu is #1 Recommended Windows and ASP.NET hosting in European Continent. With 99.99% Uptime Guaranteed of Relibility, Stability and Performace. HostForLIFE.eu security team is constantly monitoring the entire network for unusual behaviour. We deliver hosting solution including Shared hosting, Cloud hosting, Reseller hosting, Dedicated Servers, and IT as Service for companies of all size.



European ASP.NET Core Hosting - HostForLIFE :: Recognizing and Handling Software Design Class Explosion

clock January 2, 2024 06:07 by author Peter

One of the most frequent problems that developers encounter in the intricate and ever-changing process of software creation is the "class explosion." This happens when a software system has a lot of classes—often more than what was planned or organized in the first place. We will examine the reasons behind the class explosion, how it affects software systems, and management and mitigation techniques in this post.

Reasons for the Explosion of Classes

Excessively Fine-Grained Design: An excessively fine-grained design is one of the main reasons for class explosion. The number of classes can grow rapidly when every task or feature is included within a distinct class without a clear and obvious goal in mind.

class UserManager { }

Inadequate Abstraction: An excessive number of classes may result from improper abstraction. Class fragmentation occurs when developers are unable to recognize and produce meaningful abstractions, leading to an abundance of tiny, specialized classes.

class User { }
class UserValidationHelper { }
class UserPersistenceManager { }

Insufficient Planning: In some cases, inadequate upfront planning can contribute to class explosion. If the design lacks a clear structure and roadmap, developers might introduce new classes in a reactionary manner, leading to an unmanageable number of classes.

class FeatureAProcessor { }
class FeatureBProcessor { }
class FeatureCProcessor { }

The effects of the class explosion

  • Complexity and Cognitive Load: The system's total complexity rises with the number of classes. The relationships and responsibilities of each class may be difficult for developers to understand, which will raise their cognitive load.
  • Maintenance Challenges: Having a lot of classes may make maintenance difficult. It becomes more difficult to make modifications or add new features since developers have to work their way through a complex class hierarchy.
  • Decreased Reusability: Decreased reusability may result from an excessive number of classes. It's possible that developers will have to start from scratch if they try to utilize tiny, specialized classes in other areas of the system.

Techniques to Control Class Explosion
Refactoring: Examine and reorganize the codebase on a regular basis to find and remove superfluous classes. Combine features into classes that are well-thought-out and integrated.

class UserManager { }

Abstraction and Encapsulation: Emphasize proper abstraction and encapsulation to ensure that classes have well-defined responsibilities. Avoid creating classes for every minor task and focus on creating meaningful, high-level abstractions.
    class User { }
    class UserManager { }


​​​Design Patterns: Utilize design patterns to manage class complexity. Patterns like the Singleton pattern, Factory pattern, and Strategy pattern can help organize and streamline class hierarchies.

class UserFactory { }

Modularization: Modularize the system into manageable modules or components. Divide the system into cohesive parts, each with a distinct responsibility, to prevent the proliferation of classes.
class AuthenticationModule { }

Guidelines and Code Reviews: Establish coding guidelines and conduct regular code reviews to ensure that the development team adheres to best practices. Enforce consistency in class design and encourage developers to think about the overall system architecture.

Example: Refactoring a Class Explosion
Consider a scenario where a class explosion has occurred in a system responsible for handling various geometric shapes:

class SquareValidator { }
class SquareCalculator { }
class CircleValidator { }
class CircleCalculator { }
class TriangleValidator { }
class TriangleCalculator { }

There are numerous classes as a result of this design's lack of abstraction. Let's rework this situation by adding an abstract and more unified design:

abstract class Shape { }
class Square extends Shape { }
class Circle extends Shape { }
class Triangle extends Shape { }

class ShapeValidator { }
class ShapeCalculator { }

We've added an abstract Shape class as part of this refactoring, which eliminates duplication and creates a more organized and manageable design.

In summary

Although class explosion is a typical problem in software design, it may be controlled and lessened with careful planning, frequent refactoring, and strict code standards. Developers can design systems that are not only scalable but also easier to understand and manage over time by placing a strong emphasis on appropriate abstraction, encapsulation, and modularization. Recall that a well-designed system prioritizes the classes' meaningful order and coherence over their quantity.

HostForLIFE ASP.NET Core Hosting

European best, cheap and reliable ASP.NET hosting with instant activation. HostForLIFE.eu is #1 Recommended Windows and ASP.NET hosting in European Continent. With 99.99% Uptime Guaranteed of Relibility, Stability and Performace. HostForLIFE.eu security team is constantly monitoring the entire network for unusual behaviour. We deliver hosting solution including Shared hosting, Cloud hosting, Reseller hosting, Dedicated Servers, and IT as Service for companies of all size.

 



European ASP.NET Core Hosting - HostForLIFE :: A Simple Web API Using.Net 8

clock December 19, 2023 06:38 by author Peter

REST API: What is it?
REpresentational State Transfer is what the acronym REST stands for. It's an architectural design that lays forth a set of guidelines for building Web services. REST recommends generating an object from the data a client requests and responding to the user with the object's values via a client-server conversation. For instance, you can construct an object on the server-side if the user requests a Bangalore taxi reservation at a specific location and time. You have an object over here, and you are transmitting the object's state. As a result, Representational State Transfer, or REST, is its name.

An application can be made more appropriate for the internet by utilizing the reduced bandwidth usage provided by the REST architectural style. It is entirely dependent on the resources and is frequently referred to as the "language of the internet."

REST API Fundamentals

The six REST guiding principles are listed below:

Without a state

The body of the request contains the current status of the resource, and the URL is used to identify the resource specifically. The client receives a response from the server via headers, body, or status once the request has been processed. All the necessary information is included in the requests that clients send to servers so that the servers can comprehend the requests. This may appear in the body, headers, query-string arguments, or even the URL. The server API does not cache any state, thus each request is independent of the others. Additionally helpful in scaling the API service in a cloud context is its RESTful characteristic.

Client-Server
The client-server architecture enables a uniform interface and separates clients from the servers. This enhances the portability across multiple platforms as well as the scalability of the server components.

Uniform Interface
To obtain the uniformity throughout the application, REST has the following four interface constraints:

  • Resource identification
  • Resource Manipulation using representations
  • Self-descriptive messages
  • Hypermedia as the engine of application state

Cacheable
To provide a better performance, the applications are often made cacheable. This is done by labeling the response from the server as cacheable or non-cacheable either implicitly or explicitly. If the response is denied as cacheable, then the client cache can reuse the response data for equivalent responses in the future.
Minimal APIs in .Net 8 or .Net 7

Minimal APIs are architected to create HTTP APIs with minimal dependencies. They are ideal for microservices and apps that want to include only the minimum files, features, and dependencies in ASP.NET Core.

Limitations of Minimal API

  • No support for filters: For example, no support for IAsyncAuthorizationFilter, IAsyncActionFilter, IAsyncExceptionFilter, IAsyncResultFilter, and IAsyncResourceFilter.
  • No support for model binding, i.e. IModelBinderProvider, IModelBinder. Support can be added with a custom binding shim.
  • No support for binding from forms. This includes binding IFormFile. We plan to add support for IFormFile in the future.
  • No built-in support for validation, i.e. IModelValidator
  • No support for application parts or the application model. There's no way to apply or build your own conventions.
  • No built-in view rendering support. We recommend using Razor Pages for rendering views.
  • No support for JsonPatch
  • No support for OData
  • No support for ApiVersioning. See this issue for more details.

With the following APIs,

REST APIs follow standard HTTP Verbs like GET, POST, PUT, DELETE, PATCH which are basically CRUD operation on an object. The APIs are arranged to form an internet resource. For example in the above example, we have resource as “todoitem” which can be created, modified, deleted using APIs, and URL format is formed accordingly.

using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddDbContext < TodoDb > (opt => opt.UseInMemoryDatabase("TodoList"));
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment()) {
    app.UseSwagger();
    app.UseSwaggerUI();
}
app.MapGet("/", () => "Hello World!");
app.MapGet("/todoitems", async (TodoDb db) => await db.Todos.ToListAsync());
app.MapGet("/todoitems/complete", async (TodoDb db) => await db.Todos.Where(t => t.IsComplete).ToListAsync());
app.MapGet("/todoitems/{id}", async (int id, TodoDb db) => await db.Todos.FindAsync(id)
    is Todo todo ? Results.Ok(todo) : Results.NotFound());
app.MapPost("/todoitems", async (Todo todo, TodoDb db) => {
    db.Todos.Add(todo);
    await db.SaveChangesAsync();
    return Results.Created($ "/todoitems/{todo.Id}", todo);
});
app.MapPut("/todoitems/{id}", async (int id, Todo inputTodo, TodoDb db) => {
    var todo = await db.Todos.FindAsync(id);
    if (todo is null) return Results.NotFound();
    todo.Name = inputTodo.Name;
    todo.IsComplete = inputTodo.IsComplete;
    await db.SaveChangesAsync();
    return Results.NoContent();
});
app.MapDelete("/todoitems/{id}", async (int id, TodoDb db) => {
    if (await db.Todos.FindAsync(id) is Todo todo) {
        db.Todos.Remove(todo);
        await db.SaveChangesAsync();
        return Results.Ok(todo);
    }
    return Results.NotFound();
});
app.Run();
class Todo {
    public int Id {
        get;
        set;
    }
    public string ? Name {
        get;
        set;
    }
    public bool IsComplete {
        get;
        set;
    }
}
class TodoDb: DbContext {
    public TodoDb(DbContextOptions < TodoDb > options): base(options) {}
    public DbSet < Todo > Todos => Set < Todo > ();
}

In summary
The REST architecture style offers a common method for clients to access and retrieve server data as well as a standard approach to arrange resources across the internet. Minimal APIs need to have the least amount of code possible and can be quickly and simply created without the need for authentication or with very little dependencies by sitting behind a gateway that does.

HostForLIFE ASP.NET Core Hosting

European best, cheap and reliable ASP.NET hosting with instant activation. HostForLIFE.eu is #1 Recommended Windows and ASP.NET hosting in European Continent. With 99.99% Uptime Guaranteed of Relibility, Stability and Performace. HostForLIFE.eu security team is constantly monitoring the entire network for unusual behaviour. We deliver hosting solution including Shared hosting, Cloud hosting, Reseller hosting, Dedicated Servers, and IT as Service for companies of all size.



European ASP.NET Core Hosting - HostForLIFE :: Using Serilog for Brilliant Logging in.NET Core

clock December 6, 2023 08:16 by author Peter

Logging: What Is It?
The technique of recording events in real time and adding details like execution time and infrastructure information is known as logging in software. It is essential to every software program, especially when debugging problems. Logs are useful for deciphering errors, locating performance snags, and assisting in issue solving.

Logs are commonly kept in files, databases, or consoles according to the convenience and severity of the application. Although logs can contain a variety of data, error and informational messages are frequently recorded. Informational messages record routine activities such as method calls, user logins, or product checkouts, whereas error messages offer detailed information for troubleshooting.

By offering a generic logging interface that is uniform throughout the framework and external libraries, ASP.NET Core streamlines logging. Problem diagnosis and log navigation are made easier by this standardization. Users can set log verbosity and route logs to various locations, including files, consoles, and databases, using the framework.

Logs are stored by logging providers in ASP.NET Core, and users can set up several providers for their apps. Logging providers like Console, Debug, EventSource, and EventLog (unique to Windows) are part of the standard ASP.NET Core configuration.

Recognizing the Difference: Software System Logging vs. Monitoring

ASP.NET Core has helpful tools for logging—a process of recording events in your applications. System events, user actions, performance indicators, and other events and processes are all recorded in detail through logging. This data, which is commonly kept in a database or log file, enables you to see problems and resolve them, enhance performance, and comprehend how your program is utilized.

Contrarily, monitoring entails keeping an eye on and gauging the performance of your application in real time. When specific criteria are met, such as when the program takes too long to react or experiences an error, it can send warnings or notifications. Monitoring offers important insights for performance optimization and assists in identifying and resolving issues before they affect users.

There are well-known tools in ASP.NET Core, such as Microsoft.Extensions.Helping with logging include Serilog, NLog, and logging. These tools assist you in maintaining a robust and effective software system by making it simpler to handle and analyze the data that your application generates.

Additional Information
Logging in.NET Core allows you to monitor activity within your application. It aids in behavior monitoring, problem solving, and performance analysis. Logging is made organized and efficient with the help of the ILogger API. You can store logs in several locations using different logging providers; built-in and third-party choices are available.

Let's now discuss the distinctions between tracing and logging. The goal of logging is to capture important events in your program and produce a sort of summary. However, tracing goes beyond by providing you with an in-depth overview of all the actions taking place within your application, providing a comprehensive history of its operations.

The six main logging levels in .NET

  • Critical: This is for really serious issues that could make your app stop working, like running out of memory or space on the disk.
  • Error: Use this when something goes wrong, like a database error preventing data from being saved. The app can still work for other things despite encountering errors.
  • Warning: Not as severe as errors, but it indicates a potential problem that might lead to more serious errors. It's a heads-up for administrators.
  • Information: Gives details about what's happening in the app. Helpful for understanding the steps leading to an error.
  • Debug: Useful during development for tracking detailed information. It's not typically used in a live/production environment.
  • Trace: Similar to Debug but may include sensitive info. Rarely used and not utilized by framework libraries.

Implement the External Logging Source to Logging Information of API  and Windows Service - Serilog

Packages need: Serilog.AspNetCore

  • Dot Net CLI - dotnet add package Serilog.AspNetCore --version 8.0.0
  • Package Manager - Install-Package Serilog.AspNetCore -Version 8.0.0

Confiuration of Serilog in API
Settings File

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "Serilog": {
    "Using": [ "Serilog.Sinks.File" ],
    "MinimumLevel": {
      "Default": "Information",
      "Override": {
        "Microsoft": "Warning",
        "System": "Warning"
      }
    },
    "WriteTo": [
      {
        "Name": "File",
        "Args": {
          "path": "C:/Log001/log_.log",
          "rollOnFileSizeLimit": true,
          "rollingInterval": "Day"
        }
      }
    ]
  }
}

Application Startup updates for Logging
using Serilog;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

/// Step 1
builder.Host.UseSerilog((context, configuration) =>
{
    configuration.ReadFrom.Configuration(context.Configuration);
}
);

var app = builder.Build();


/// Step 2
app.UseSerilogRequestLogging();

app.Run();


Using the setup to Log actions.
In this setup, we employ the "Assembly - Microsoft.Extensions.Logging.Abstractions, Version=8.0.0.0" for logging actions, and we utilize Serilog to write these logs into files. The ILogger interface is injected into the constructor to facilitate logging functionality.
private readonly ILogger<WeatherForecastController> _logger;

public WeatherForecastController(ILogger<WeatherForecastController> logger)
{
    _logger = logger;
}


[HttpGet(Name = "GetWeatherForecast")]
public IEnumerable<WeatherForecast> Get()
{
    _logger.LogInformation("Method Entered");

    var list = Enumerable.Range(1, 5).Select(index => new WeatherForecast
    {
        Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
        TemperatureC = Random.Shared.Next(-20, 55),
        Summary = Summaries[Random.Shared.Next(Summaries.Length)]
    })
    .ToArray();

    string message = $"WeatherForecast Count {list.Length}";

    _logger.LogInformation(message);

    _logger.LogInformation("Method Exit");
    return list;
}


Now, to test the logging functionality, run the application and inspect the specified path. Refer to the image below for guidance.

Application Startup updates for Logging
using Serilog;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

/// Step 1
builder.Host.UseSerilog((context, configuration) =>
{
    configuration.ReadFrom.Configuration(context.Configuration);
}
);

var app = builder.Build();


/// Step 2
app.UseSerilogRequestLogging();

app.Run();


Using the setup to Log actions.

In this setup, we employ the "Assembly - Microsoft.Extensions.Logging.Abstractions, Version=8.0.0.0" for logging actions, and we utilize Serilog to write these logs into files. The ILogger interface is injected into the constructor to facilitate logging functionality.
private readonly ILogger<WeatherForecastController> _logger;

public WeatherForecastController(ILogger<WeatherForecastController> logger)
{
    _logger = logger;
}

[HttpGet(Name = "GetWeatherForecast")]
public IEnumerable<WeatherForecast> Get()
{
    _logger.LogInformation("Method Entered");

    var list = Enumerable.Range(1, 5).Select(index => new WeatherForecast
    {
        Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
        TemperatureC = Random.Shared.Next(-20, 55),
        Summary = Summaries[Random.Shared.Next(Summaries.Length)]
    })
    .ToArray();

    string message = $"WeatherForecast Count {list.Length}";

    _logger.LogInformation(message);

    _logger.LogInformation("Method Exit");
    return list;
}

Now, to test the logging functionality, run the application and inspect the specified path. Refer to the image below for guidance.

HostForLIFE ASP.NET Core Hosting

European best, cheap and reliable ASP.NET hosting with instant activation. HostForLIFE.eu is #1 Recommended Windows and ASP.NET hosting in European Continent. With 99.99% Uptime Guaranteed of Relibility, Stability and Performace. HostForLIFE.eu security team is constantly monitoring the entire network for unusual behaviour. We deliver hosting solution including Shared hosting, Cloud hosting, Reseller hosting, Dedicated Servers, and IT as Service for companies of all size.



European ASP.NET Core Hosting - HostForLIFE :: Using the Splash Screen in.NET MAUI

clock November 27, 2023 06:53 by author Peter

We will learn how to construct and configure the splash screen in.NET MAUI in this tutorial. If you are new to.NET MAUI, I recommend that you read the articles in this series listed below. When you launch the program, a splash screen appears till the application initialization procedure is complete. The Splash screen is removed once the application is ready for usage.

Let's start by making a new.NET MAUI project to learn how to design or edit the Splash Screen. I've started a new project called SplashScreenExample.

When you run the program on an Android device, you will see the default Splash Screen, as shown in the image below.

A splash screen in.NET MAUI can be provided in a single location within the application. In the "ResourcesSplash folder," you will find a scalable vector graphic, splash.svg, with a build action of MauiSplashScreen in the settings box.

Scalable vector graphics have the advantage of being able to be adjusted to the suitable resolution for the target application. Let's swap out the splash screen icon for something new. I already have a medical icon that I will display on the Splash Screen. I removed the splash.svg icon and replaced it with the medical.svg image, with the build action MauiSplashScreen. Make sure the name of the icon you're adding to the Splash screen is lowercase, begins and finishes with a letter character, and only contains alphanumeric characters or underscore.

Now edit the .csproj file of the project as shown in the below image.


Add the BaseSize of a splash screen, which represents the image's baseline density. If no base size is supplied for the vector picture, the dimensions specified in the image are utilized as the base size. BaseSize is supplied using the BaseSize="W,H" syntax, where W is the image's width and H is its height. The BaseSize value supplied must be divisible by 8. In my case, BaseSize="128,128" is divisible by 8.

Use the TintColor property to modify the color of the SVG icon, and the Color property to adjust the backdrop color.

<!-- Images -->
<MauiSplashScreen Include="Resources\Splash\medical.svg" BaseSize="128,128" Color="#F5F7F8" TintColor="#BE3144"/>

Let's create and execute the app in the Android emulator now. You will notice that the Splash Screen with the medical.svg icon is displayed as per the MauiSplashScreen setup.

HostForLIFE ASP.NET Core Hosting

European best, cheap and reliable ASP.NET hosting with instant activation. HostForLIFE.eu is #1 Recommended Windows and ASP.NET hosting in European Continent. With 99.99% Uptime Guaranteed of Relibility, Stability and Performace. HostForLIFE.eu security team is constantly monitoring the entire network for unusual behaviour. We deliver hosting solution including Shared hosting, Cloud hosting, Reseller hosting, Dedicated Servers, and IT as Service for companies of all size.

 



European ASP.NET Core Hosting - HostForLIFE :: How to Create Your Own Middleware in ASP.NET Core?

clock November 22, 2023 07:34 by author Peter

ASP.NET Core is a strong platform for building robust and scalable web applications. Middleware, which is essential in managing HTTP requests and responses, is one of its important characteristics. Middleware is a software component that lies between the client and the server, allowing developers to add additional logic to the request processing pipeline.

What exactly is middleware?
In the context of ASP.NET Core, middleware refers to a collection of components that are triggered in the request pipeline to handle requests and responses. Each middleware component receives an HTTP request, performs particular duties, and then either forwards the request or provides a response.

The Request Pipeline's Middleware
In ASP.NET Core, the request pipeline is made up of a series of middleware components. When the server receives a request, it passes it through this pipeline, and each middleware component can.

  • Respond to the Request: Execute tasks such as logging, authentication, and authorization, among others.
  • Process the Response: Make changes to the response before returning it to the client.

Developing Custom Middleware
ASP.NET Core custom middleware allows developers to add their own logic to the request processing pipeline. Here's a step-by-step tutorial on developing bespoke middleware.
using Microsoft.AspNetCore.Http;
using System.Threading.Tasks;

public class CustomMiddleware
{
    private readonly RequestDelegate _next;

    public CustomMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // Logic before the next middleware
        await _next(context);
        // Logic after the next middleware
    }
}

Step 2: In Startup.cs, configure the Middleware
Add your custom middleware to Startup.cs's Configure function using the UseMiddleware extension method

public void Configure(IApplicationBuilder app)
{
    app.UseMiddleware<CustomMiddleware>();
    // Other middleware configurations
}

Step 3: Put Middleware Logic in Place
You can implement your required logic before and after invoking the next middleware in your custom middleware's InvokeAsync method. This can include authentication, logging, and altering requests/responses, among other things.

Custom Middleware Use Cases
Custom middleware can be used for a variety of applications, including.

  • Authentication: Before forwarding the request to the application, implement custom authentication logic.
  • Logging: For debugging purposes, log request details or errors.
  • Caching: To boost application performance, use caching methods.
  • Response Modification: Make changes to the response before returning it to the client.

Conclusion
In ASP.NET Core, middleware is a sophisticated framework that allows developers to alter the request pipeline. Creating custom middleware gives flexibility in processing requests and answers, allowing developers to smoothly integrate their own logic into the application flow. Developers may improve the functionality, performance, and security of their ASP.NET Core apps by understanding and exploiting middleware.

HostForLIFE ASP.NET Core Hosting

European best, cheap and reliable ASP.NET hosting with instant activation. HostForLIFE.eu is #1 Recommended Windows and ASP.NET hosting in European Continent. With 99.99% Uptime Guaranteed of Relibility, Stability and Performace. HostForLIFE.eu security team is constantly monitoring the entire network for unusual behaviour. We deliver hosting solution including Shared hosting, Cloud hosting, Reseller hosting, Dedicated Servers, and IT as Service for companies of all size.



European ASP.NET Core Hosting - HostForLIFE :: .Net Core gRPC Implementation

clock November 16, 2023 07:29 by author Peter

As the world of microservices evolved, so did the strategy and technologies that surrounded it. Communication across multiple services is one of the most critical components of microservices. Remote procedure calls are one method of communication that is employed, and gRPC provides a complex framework for it.

As the acronym suggests, gRPC stands for Google remote procedure call. It was the framework that Google utilized before opening it out to the open-source community. It employs the HTTP2 protocol.

It has a few advantages, such as.

  • Messages that are brief
  • It is quick
  • It supports full-duplex communication

gRPC is generally used for internal service communication, however it does support web gRPC, which may be accessed via browsers.

Unlike RESTful services, the service signature and message property must be known by both the client and the server.

It offers versatility. Both the client and the server can be constructed in various technology stacks and still communicate effectively.

Now, begin building gRPC in.Net Core, but note that the.Net API project can have both Rest API and gRPC services, and in this tutorial, we will add gRPC to the already existing

RestFull API Project
For Rest API, I use Mediator and CQRS architecture, but you can use any technique.

Step 1: Make a Prototype file.

Now, define the RPC Service structure.

service EventCatalogService {
      rpc GetAllCategories(GetCategoriesRequest) returns (CategoriesResponse);
}


As we can see, the Name is GetAllCategories, the request it is taking is GetCategoriesRequest, and the Response is sending CategoriesResponse.

Now, Create the request and response messages for services.

message GetCategoriesRequest
{
}

message CategoriesResponse {
    repeated CategoryItem Categories = 1;
}

message CategoryItem {
    string CategoryId = 1;
    string Name = 2;
}

The repeated is defining the collection here.

You can see the number against each attribute defining the position of the attribute in the message. We can also reserve some position for future use.
syntax = "proto3";
option csharp_namespace = "EventCatalog.gRPC";

import "google/protobuf/timestamp.proto";

service EventCatalogService {
    rpc GetAllCategories(GetCategoriesRequest) returns (CategoriesResponse);
}

message GetCategoriesRequest {}

message EventByCategoryIdRequest {
    string CategoryId = 1;
}

message EventByEventIdRequest {
    string EventId = 1;
}

message EventByCategoryIdResponse {
    string EventId = 1;
    string Name = 2;
    int32 Price = 3;
    string Artist = 4;
    google.protobuf.Timestamp Date = 5;
    string Description = 6;
    string ImageUrl = 7;
    string CategoryId = 8;
    string CategoryName = 9;
}

message EventByEventIdResponse {
    string EventId = 1;
    string Name = 2;
    int32 Price = 3;
    string Artist = 4;
    google.protobuf.Timestamp Date = 5;
    string Description = 6;
    string ImageUrl = 7;
    string CategoryId = 8;
    string CategoryName = 9;
}

message CategoriesResponse {
    repeated CategoryItem Categories = 1;
}

message CategoryItem {
    string CategoryId = 1;
    string Name = 2;
}

The proto file is ready.

Step 2. Add gRPC to your .Net project
Add the proto file as a connected service.

Click on project connected service.

Now, create the grpc server by giving the proto file path.

It will include the proto file as well as other necessary Nuget packages in the project.

Step 3: Add the gRPC to your service layer

First, establish the gRPC service that will inherit the basic class of gRPC service, and then integrate your business layer into it. Because I'm using mediatr, I'll get the message from the gRPC service, pass it to my application layer, and then provide a response.

using EventCatalog.gRPC;

using FOA.Application.Mapper;

using Grpc.Core;

using MediatR;

using TicketManagement.Services.EventCatalog.Application.Feature.Category.Queries;

using static EventCatalog.gRPC.EventCatalogService;

namespace TicketManagement.Services.EventCatalog.RPCServices;

public class EventCatalogRPCService : EventCatalogServiceBase

{
    private readonly IMediator _mediator;
    public EventCatalogRPCService(IMediator mediator)
    {
        _mediator = mediator;
    }
    public override async Task<CategoriesResponse> GetAllCategories(GetCategoriesRequest request,ServerCallContext context)

    {
        var serviceResult = await _mediator.Send(new GetAllCategoriesRequest());
        var result =  gRPCMappers.Mapper.Map<List<CategoryItem>>(serviceResult);
        var response = new CategoriesResponse();
        response.Categories.AddRange(result);
        return response;

    }

}


Step 5. Add gRPC to your program.cs
// adding grpc

builder.Services.AddGrpc(cfg => cfg.EnableDetailedErrors = true);


After build, add the following line.
app.MapGrpcService<EventCatalogRPCService>();

Now the server is ready, we need a client to test it.

Step 6. Create gRPC Client

Create a new .Net API project and the Client gRPC through the connected service, but this time, instead of the server, select client.
As the client is only going to send and receive messages from the server, there will be not much code other than basic communication.
var channel = GrpcChannel.ForAddress(_serviceURL);
var client = new EventCatalogServiceClient(channel);
var request = new GetCategoriesRequest();
var response = client.GetAllCategories(request);


It is creating a channel through the service URL, which is the URL of our gRPC Server, and then creating a client through that channel and calling the service through that client.

Step 7. Add authorization to your service
So, adding security to your gRPC service is very easy. As the gRPC is added as a middleware to your application, the already implemented authentication or Authorization is already available to you.

You just need to add an Authorization tag to your service.
[Authorize]
public override async Task<CategoriesResponse> GetAllCategories(GetCategoriesRequest request,ServerCallContext context)
{
        var serviceResult = await _mediator.Send(new GetAllCategoriesRequest());
        var result =  gRPCMappers.Mapper.Map<List<CategoryItem>>(serviceResult);
        var response = new CategoriesResponse();
        response.Categories.AddRange(result);
        return response;

}

HostForLIFE ASP.NET Core Hosting

European best, cheap and reliable ASP.NET hosting with instant activation. HostForLIFE.eu is #1 Recommended Windows and ASP.NET hosting in European Continent. With 99.99% Uptime Guaranteed of Relibility, Stability and Performace. HostForLIFE.eu security team is constantly monitoring the entire network for unusual behaviour. We deliver hosting solution including Shared hosting, Cloud hosting, Reseller hosting, Dedicated Servers, and IT as Service for companies of all size.

 



About HostForLIFE

HostForLIFE is European Windows Hosting Provider which focuses on Windows Platform only. We deliver on-demand hosting solutions including Shared hosting, Reseller Hosting, Cloud Hosting, Dedicated Servers, and IT as a Service for companies of all sizes.

We have offered the latest Windows 2019 Hosting, ASP.NET 5 Hosting, ASP.NET MVC 6 Hosting and SQL 2019 Hosting.


Month List

Tag cloud

Sign in