Full Trust European Hosting

BLOG about Full Trust Hosting and Its Technology - Dedicated to European Windows Hosting Customer

European Entity Framework Hosting - HostForLIFE :: Filtering Data with Entity Framework Global Query Filters Step 1. Define Model

clock May 26, 2023 07:41 by author Peter

Step 1. Define Model
Create your entity models as usual to begin. These models should represent your entities and contain all of the necessary properties. Suppose, for instance, we have a "Product" entity:
public class Product
    public int Id { get; set; }
    public string Name { get; set; }
    public bool IsDeleted {get; set; }

Configure the Global Query Filter
Implement an override for the OnModelCreating method in your DbContext class. Using the Entity and HasQueryFilter methods, you can configure global query filters within this method. Here's an example of excluding soft-deleted products using a global query filter:

protected override void OnModelCreating(ModelBuilder modelBuilder)
    modelBuilder.Entity<Product>().HasQueryFilter(p => !p.IsDeleted);

3. Execute Filtered Queries
Once the global query filter is configured, it will be automatically applied to any query involving the Product entity. For instance, soft-deleted products will be excluded by default when retrieving products.
activeProducts is equal to dbContext.Products.ToList();

Advantages of Global Query Filters in C#
    Data Integrity: Ensure that all queries involving the entity adhere to the desired filtering conditions, thereby fostering the consistency and integrity of the data.
    By using global query filters, you can centralize the filtering logic, making your code simpler and easier to maintain.
    Global query filters enable the exclusion of superfluous data at the database level, resulting in improved query performance and resource utilization.

Implementing global query filters in Entity Framework provides a potent tool for consistently applying filtering conditions to your entities. By configuring global query filters during the OnModelCreating method, you can ensure that the filters are applied automatically to all queries involving the specified entity, resulting in clearer code and enhanced data integrity. Test it out!

AngularJS Hosting Europe - HostForLIFE :: Improving Performance through Angular Change Detection Techniques

clock May 19, 2023 08:27 by author Peter

Change detection is an integral component of Angular that ensures the user interface is in alignment with the state of the application. ChangeDetectionStrategy is Angular's default detection strategy.Standard, which examines for modifications to all components and their templates on each JavaScript event or timer tick.

Nevertheless, this default strategy may result in superfluous and expensive change detection cycles, particularly in large-scale applications. Alternative strategies, such as OnPush, enter into play at this point. The OnPush strategy optimizes change detection by focusing solely on a component's inputs and references.

Using the OnPush strategy, Angular determines if a component's input properties have changed. If the input values remain the same, Angular assumes that the component's state hasn't changed and skips its change detection entirely. This optimization can significantly improve the performance of your Angular application, especially when used strategically.

import { Component, Input, ChangeDetectionStrategy } from '@angular/core';

  selector: 'app-user',
  template: `
    <h2>{{ user.name }}</h2>
    <p>{{ user.email }}</p>
  changeDetection: ChangeDetectionStrategy.OnPush
export class UserComponent {
  @Input() user: User;

In this example, the UserComponent has the OnPush change detection strategy defined. By doing so, we instruct Angular to only perform change detection if the user input property changes.

When using the OnPush strategy, it is essential to ensure that the user input property is immutable. If you update the user object's properties, Angular won't detect the changes, as it relies on reference comparison.

To optimize performance further, you can utilize the ChangeDetectorRef to manually trigger change detection when necessary:

import { Component, Input, ChangeDetectionStrategy, ChangeDetectorRef } from '@angular/core';

  selector: 'app-user',
  template: `
    <h2>{{ user.name }}</h2>
    <p>{{ user.email }}</p>
    <button (click)="updateUser()">Update</button>
  changeDetection: ChangeDetectionStrategy.OnPush
export class UserComponent {
  @Input() user: User;

  constructor(private cdr: ChangeDetectorRef) {}

  updateUser() {
    // Update the user object
    this.cdr.markForCheck(); // Trigger change detection

In the above example, we inject the ChangeDetectorRef and call its markForCheck() method to manually trigger change detection when the user clicks the "Update" button.

By understanding and utilizing Angular's change detection strategies, especially the OnPush strategy, you can significantly enhance the performance of your Angular applications. By minimizing unnecessary change detection cycles, your app will run more efficiently and provide a smoother user experience.

Remember to carefully analyze your application's requirements and components' state before choosing a change detection strategy. Applying the OnPush strategy to components that rarely change or have immutable input properties can lead to noticeable performance improvements.

AngularJS Hosting Europe - HostForLIFE :: An Introduction to Angular and Storybook

clock May 15, 2023 10:00 by author Peter

In modern web development, creating reusable and visually appealing UI components is essential. Angular, a popular JavaScript framework, provides a robust framework for building scalable web applications. Storybook, however, is a powerful tool for developing and showcasing UI components in isolation. This article will explore the combination of Angular and Storybook to create beautiful and reusable component libraries.

Getting Started
First, let's create a new Angular project and set up Storybook within it. Open your terminal and follow the steps below.

Step 1. Create a new Angular project using the Angular CLI.
ng new my-component-library

Step 2. Change into the project directory.
cd my-component-library

Step 3. Install Storybook using the following command.
npx storybook@latest init

This will set up Storybook within your Angular project.

Step 4. Start Storybook.
npm run storybook

If everything is set up correctly, you should see the Storybook interface running at http://localhost:6006.

How to create your first Angular Component?
Now that we have our Angular project with Storybook let's create our first Angular component and showcase it in Storybook.

Step 1. Generate a new Angular component using the Angular CLI.
ng generate component button

Step 2. Open the newly created button.component.ts file in your favorite code editor and modify it as follows,
import { Component, Input } from '@angular/core';

  selector: 'app-button',
  template: `
    <button [ngClass]="buttonClass">{{ label }}</button>
  styleUrls: ['./button.component.css']
export class ButtonComponent {
  @Input() label: string;
  @Input() buttonClass: string;

In this code, we have defined an Angular component called ButtonComponent. It accepts two inputs: label For the button text and buttonClass For applying custom CSS classes to the button element. The component's template consists of a simple button element that utilizes Angular's data binding and class binding.

Step 3. Open the button.component.css file and add some basic styling to the button.
button {
  padding: 8px 16px;
  font-size: 14px;
  border-radius: 4px;

Step 4. Open the button.stories.ts file in the src/app directory and modify it.

import { Meta, Story } from '@storybook/angular';
import { ButtonComponent } from './button.component';

export default {
  title: 'Components/Button',
  component: ButtonComponent,
} as Meta;

const Template: Story<ButtonComponent> = (args: ButtonComponent) => ({
  props: args,

export const Primary = Template.bind({});
Primary.args = {
  label: 'Primary Button',
  buttonClass: 'primary',

export const Secondary = Template.bind({});
Secondary.args = {
  label: 'Secondary Button',
  buttonClass: 'secondary',


In this code, we import the necessary dependencies from @storybook/angular and import our ButtonComponent. We define a Meta as an object that includes the title of our component and the component itself.

Next, we define a Template function that takes args as input and returns an object with props set to args. This function acts as a template for rendering our component in Storybook.

Finally, we create two stories: Primary and Secondary. Each story represents a different variation of our ButtonComponent. We provide the necessary arguments (label and buttonClass) for each story and bind them to the respective inputs of ButtonComponent.

Step 5. Open your browser and navigate to http://localhost:6006 (or the URL specified in your terminal) to view the Storybook interface. You should see the Button component listed under the Components category, with the Primary and Secondary variations available for selection.

Step 6. Click on the Primary or Secondary story to see the rendered ButtonComponent in the Storybook. You can interact with the component, view its properties, and observe how it looks in different states.

Congratulations! You have successfully created your first Angular component and showcased it in Storybook.

Angular and Storybook complement each other perfectly when building reusable and visually appealing component libraries. Angular provides a robust framework for creating components, while Storybook allows you to develop and showcase those components in isolation, making it easier to iterate and test different variations.

In this article, we covered the basic setup of Angular and Storybook and walked through creating a simple ButtonComponent and showcasing it in Storybook. This is just the tip of the iceberg, and there's much more you can do with Angular and Storybook to build comprehensive component libraries.

Remember to experiment, explore the various features and capabilities of Angular and Storybook, and leverage the power of both tools to create stunning UI components for your projects. Happy coding!

AngularJS Hosting Europe - HostForLIFE :: Export To Excel In Angular Using ExcelJS

clock May 12, 2023 07:57 by author Peter

This article describes how to export to Excel using excelJS in Angular. In our assignment, I will describe how to export to Excel using excelJS in angular.

What exactly is ExcelJS?

ExcelJS is a well-known JavaScript library that generates Excel spreadsheets in the browser. This section will discuss how to export data from an Angular application to an Excel file using ExcelJS.

For this article, I developed an Angular application. To create an Angular project, the following actions must be taken:

Create Project

Using the following command in the Command Prompt, I created a project.

ng new ExcelJSExample

Open a project in Visual Studio Code using the following commands.
cd ExcelJSExample
Code .

Now in Visual Studio, your project looks as below.

You need to install the ExcelJS package using npm:
npm install exceljs --save

Also, you need to install the FileSaver.js library, which provides the saveAs() method used to download the Excel file to the user's computer.
npm install file-saver --save

Now create a service file name ExcelService using the following command.
ng g c excelService

You need to import the ExcelJS library in the service file where you want to generate the Excel file.
import * as ExcelJS from 'exceljs';

After installing FileSaver.js, you can import it into the service file as follows
import { saveAs } from 'file-saver';

Then, you need to create a new Excel workbook and worksheet instance.
const workbook = new ExcelJS.Workbook();
const worksheet = workbook.addWorksheet('My Sheet');

Next, you need to add the data to the worksheet. You can do this by iterating over the data and adding it to the worksheet using the worksheet.addRow() method
// Add headers
       const headers = Object.keys(data[0]);

// Add data
       data.forEach((item) => {
         const row:any = [];
         headers.forEach((header) => {


After adding the data, you can format the worksheet using the ExcelJS API. For example, you can set the column widths using the worksheet.getColumn(colIndex).width property.

worksheet.getColumn(1).width = 15;
worksheet.getColumn(2).width = 20;

Finally, you can save the workbook to an Excel file using the workbook.xlsx.writeBuffer() method.
// Generate Excel file
        workbook.xlsx.writeBuffer().then((buffer: any) => {
          const blob = new Blob([buffer], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' });
          saveAs(blob, `${fileName}.xlsx`);

ExcelService File Code.
import { Injectable } from "@angular/core";
import * as ExcelJS from 'exceljs';
import { saveAs } from 'file-saver';

export class ExportService{

    exportToExcel(data: any[], fileName: string) {
        const workbook = new ExcelJS.Workbook();
        const worksheet = workbook.addWorksheet('My Sheet');

        // Add headers
        const headers = Object.keys(data[0]);

        // Add data
        data.forEach((item) => {
          const row:any = [];
          headers.forEach((header) => {

        worksheet.getColumn(1).width = 15;
        worksheet.getColumn(2).width = 20;

        // Generate Excel file
        workbook.xlsx.writeBuffer().then((buffer: any) => {
          const blob = new Blob([buffer], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' });
          saveAs(blob, `${fileName}.xlsx`);

Here's an example of how you can create a button to trigger the export functionality.

In html file
<button (click)="generateExcel()">Export to Excel</button>

In ts file
  const data:any[] = [
    { name: 'John', age: 30 },
    { name: 'Jane', age: 25 },
    { name: 'Bob', age: 40 }
  this.exportService.exportToExcel(data, 'my-data');

With these steps, you should now be able to generate an Excel file with sample data in your Angular project using ExcelJS.

Overall, ExcelJS provides a powerful and flexible API for generating Excel spreadsheets in the browser, and can be easily integrated into Angular applications for exporting data to Excel.

Europe mySQL Hosting - HostForLIFEASP.NET :: How to use IN Operator in MySQL

clock May 11, 2023 08:16 by author Peter

When filtering data based on a particular set of values, MySQL's IN operator is a potent tool. You may use it to supply a list of values to check if a column's value is present in that list. This article will examine the syntax and application of MySQL's IN operator and offer examples of its use in various contexts.

What is IN operator in MySQL?
In MySQL, the IN operator enables you to provide several values in a WHERE clause, which is shorter than using multiple OR conditions. In your database queries, you can quickly and simply specify a set of values to match against a specific column by using IN.

SELECT columnName(s)
FROM tableName
WHERE columnName IN (value1, value2, ...);

SELECT columnName(s)
FROM tableName

Create a table named StudentData.
CREATE TABLE StudentData (
studentName VARCHAR(50) NOT NULL,
Country VARCHAR(50) NOt NULL,

Now, examining the StudentData table
select * from StudentData;

Using IN operator with a list of values in MySQL

In MySQL, you may define a list of values to search for in a column by using the IN operator. Instead of creating separate OR conditions for each value, you can use this to search for many values at once.

SELECT * FROM StudentData
WHERE City IN ('
London', 'UK');

Example shows how to filter data from MySQL's "StudentData" table using the IN operator. In this instance, the query is choosing all rows where either "Noida" or "Delhi" is the value of the "City" column.
Using the NOT IN operator with a list of values in MySQL

The NOT IN operator in MySQL is used to exclude results that match a list of given values. When you wish to exclude particular values from the results of your query, this is helpful.

SELECT * FROM StudentData
'London', 'UK');

The SQL query shown above makes use of MySQL's NOT IN operator. It chooses every row from the "StudentData" table that has neither "Noida" nor "Delhi" in the "City" column.
Using IN operator with a subquery in MySQL

To compare data returned by a subquery to a column in a table, the IN operator can also be used with a subquery. Parentheses surround the subquery, which is then put within the IN operator.

SELECT * FROM StudentData
WHERE City IN (SELECT City FROM OtherStudentData WHERE Enrolled = 'Yes');

In this example, the subquery (SELECT City FROM OtherStudentData WHERE Enrolled = 'Yes') returns a list of all cities where students are enrolled in some other data table. This list of cities is then used in the WHERE clause with the IN operator to select all records from StudentData where the city matches any of the cities returned by the subquery.

Performance Considerations of IN Operator in MySQL
When using the IN operator in MySQL, there are some performance considerations to remember. Using IN with a large list of values can slow down the query, especially if the list is not indexed.

To optimize queries that use IN, you can consider the following strategies:
Use indexes: Indexes can greatly improve the performance of queries that use IN. Make sure to create indexes on the columns used in the IN condition.
Use EXISTS: In some cases, using EXISTS instead of IN can be more efficient. EXISTS returns true if a subquery returns at least one row, whereas IN returns true if a value matches any value in a list. EXISTS can be faster than IN because it stops evaluating the subquery when it finds a match.
Use JOINs: Another way to optimize queries that use IN is to use JOINs instead. This can be especially useful if the list of values is obtained from another table.
Limit the list of values: If possible, limit the list of values used in the IN condition. This can be done by adding additional conditions to the WHERE clause or by filtering the data before it is passed to the query.

Using these strategies, you can optimize your queries and improve the performance of your MySQL database.

To sum it up, the IN operator in MySQL is a strong tool that lets you select query results based on a set of values or a subquery. However, it's important to take into account any possible effects on query speed, especially when working with huge datasets. You may make effective and efficient use of the IN operator by following best practises.

Thanks for reading this article. I hope this helped you to grasp the topic of Use In in MySQL.


Q. What is the difference between IN and EXISTS in MySQL?

A. The IN operator matches a column value to a list of possible values, while the EXISTS operator checks if a subquery returns any rows. IN is used to filter data based on a set of possible values, while EXISTS is used to check if data exists in another table.

Q. Can I use IN with a subquery in MySQL?
A. Yes, you can use IN with a subquery in MySQL. The subquery must return a set of values that can be matched with the column being filtered.

Q. How can I optimize queries that use the IN operator in MySQL?
A. One way to optimize queries that use IN is to ensure that the column being filtered is indexed. This can significantly improve query performance. Another strategy is to use EXISTS instead of IN if possible, as EXISTS may perform better in some cases. Additionally, it's important to use the most specific data type possible for the values being compared, as this can also improve performance.

AngularJS Hosting Europe - HostForLIFE :: Angular Reactive Form

clock May 8, 2023 10:43 by author Peter

Angular Forms is a powerful feature of the Angular framework that allows you to create complex forms that handle user input and perform validations. There are two types of forms in Angular: Template-driven forms and Reactive forms. In this answer, I will describe Reactive forms with an example.

Reactive Forms  
Reactive forms use a model-driven approach to handle form inputs. You create a form model in your component that maps to the form controls in your template. This gives you more control over the form and allows you to create dynamic forms that can change based on user input.

Here is an example of how to create a Reactive form in Angular.

First, you need to import the necessary modules into your component.
import { Component } from '@angular/core';
import { FormGroup, FormControl, Validators } from '@angular/forms';

  selector: 'app-example',
  template: `
    <form [formGroup]="myForm" (ngSubmit)="onSubmit()">
        <input type="text" formControlName="name">
        <input type="email" formControlName="email">
      <button type="submit">Submit</button>
export class ExampleComponent {
  myForm: FormGroup;

  constructor() {
    this.myForm = new FormGroup({
      name: new FormControl('', Validators.required),
      email: new FormControl('', [Validators.required, Validators.email]),

  onSubmit() {
    // Do something with the form data

In this example, we created a Reactive form with two form controls: name and email. The form model is defined in the ExampleComponent class using the FormGroup and FormControl classes. The Validators class defines the validation rules for each form control.

And must include FormsModule and ReactiveFormsModule in your Module.

In the template, we bind the form model to the formGroup directive and each form control to the formControlName directive.

When the user submits the form, the onSubmit method is called. You can access the form data using the value property of the form model.

Reactive forms give you more control over your form and allow you to create complex forms with dynamic validation rules. While they require more code to set up, they are more powerful and flexible than Template-driven forms.

Thanks For Reading.

AngularJS Hosting Europe - HostForLIFE :: What Are Angular Portals and How Do You Use Them?

clock May 4, 2023 09:48 by author Peter

If you've used Angular, you've probably run into the problem of rendering content in a situation other than the one in which it was defined. For instance, you might not want to include the dialog markup in the main component's design but still want to display a dialog or popover that covers a portion of the page. In the past, this needed laborious and error-prone workarounds, but now that Angular gateways are available, it's simpler than ever.

You can render a portion of your application in a different location in the DOM tree than where it is defined using Angular portals, also referred to as portal components. When you need to display content in a new context, this can help you design more adaptable and reusable components.

In this post, we'll define Angular portals, describe how they operate, and give usage examples.

An Angular portal can render content in a location other than the one where it was defined, in theory. To do this, a portal component that acts as a placeholder for the content must be created, and it must then be attached to the desired spot in the DOM tree using a portal outlet.

The portal component defines the syntax and behavior of the content you want to render and is a typical Angular component. The main distinction is that the portal component offers a place where the content will be added rather than rendering the material directly. The ng-content directive is used to define this slot.

A directive known as the portal outlet specifies where the portal will be presented. An Angular component or DOM element can serve as the outlet. One of the main advantages of using a portal outlet is that you can render the content in a different place in the DOM tree than where the portal component was declared. This can be helpful in situations where UI elements such as tooltips, modals, and others need to be rendered in a different context than where they were created.

How Do Angular Portals Work?
You must adhere to a few steps in order to use Angular portals,

Define the portal component in Step 1
The portal component that will act as a placeholder for the material you wish to render must first be created. Although it shouldn't render the content itself, this component should specify the markup and behavior of the content. Instead, it ought to have a space where the content can be added.

Here is an illustration of a straightforward message-display portal component.

import { Component } from '@angular/core';

  selector: 'app-message-portal',
  template: `
    <div class="message">
export class MessagePortalComponent {}

The MessagePortalComponent uses the ng-content directive in this example to define a slot for the content. The content will be rendered inside this slot when the portal is connected to a portal output.

Step 2: Construct the Portal

The following step is to create an instance of the portal component that will be rendered. Typically, this is done in the component that will host the portal.

The ComponentPortal class from the @angular/cdk/portal package can be used to generate the portal instance. The portal component type is passed as an input to this class.

The following is an example of how to build a portal instance.

import { ComponentPortal } from '@angular/cdk/portal';
import { MessagePortalComponent } from './message-portal.component';

export class MyComponent {
  private portal = new ComponentPortal(MessagePortalComponent);

In this example, the MyComponent component creates a MessagePortalComponent portal instance.

Step 3: Connect the Portal to the Portal Outlet

Once you've created a portal instance, you must connect it to a portal outlet in the desired DOM tree location. This may be accomplished by utilizing the PortalOutlet class from the @angular/cdk/portal package.


Here's an illustration of how to make a gateway outlet.

import { Component, ViewChild, AfterViewInit } from '@angular/core';
import { CdkPortalOutlet } from '@angular/cdk/portal';

  selector: 'app-my-component',
  template: `
      <h1>Welcome to my app</h1>
      <ng-container #portalOutlet></ng-container>
export class MyComponent implements AfterViewInit {
  portalOutlet: CdkPortalOutlet;

  ngAfterViewInit() {

In this example, the CdkPortalOutlet directive is used by the MyComponent component to specify a portal outlet. This directive produces a placeholder for the portal's rendering.

The portal is associated with the portal output using the attach method in the ngAfterViewInit lifecycle hook. This method accepts as an argument the gateway instance established in step 2.

Step 4: Utilize the Portal
Finally, you can use the portal by populating it with content. This is accomplished by including the content to be rendered within the portal component tags.

Here's an example of how to show a message using the gateway.
    Hello, world!

In this example, the app-my-component component hosts the portal, and the material to be rendered is contained within the app-message-portal tags.

Advantages of Using Angular Portals
Using Angular portals has various advantages.
Separation of concerns: You may isolate the markup and behavior of the content from the area where it will be rendered by building a portal component that provides a slot for the content.

Portals can be utilized in numerous situations, allowing you to create more flexible and reusable components.

Improved performance: Portals leverage the Angular Change Detection system to efficiently update content when it changes, resulting in better performance when compared to other approaches.

Improved accessibility- By incorporating a portal component that defines the semantics and accessibility of the material, you can ensure that the rendered content is accessible and adheres to best practices.

Use of Angular Portals Examples
Here are some examples of how Angular portals can be used in your applications:
Modals- Use a portal to display a modal dialog that overlays a portion of the page.
Tooltips- Use a portal to display a tooltip when the user hovers over an element.
Popovers- Render a popover that displays additional information when the user clicks on an element using a portal.

Use a gateway to render form fields based on user input or other conditions.

This article has discussed what Angular portals are, how they work, and provided examples of how to use them. You may increase the efficiency and accessibility of your applications by leveraging portals to create more flexible and reusable components. With these advantages, it's evident that Angular portals are a valuable tool that every Angular developer should have in their toolbox.

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.

Tag cloud

Sign in