DEV Community: Dotnettricks

Various methods in react lifecycle

Dotnettricks — Thu, 01 Jul 2021 07:10:00 +0000

The methods in React lifecycle can be considered as the series of events that take place right from the origin of a React component till its death. Each component in React passes through a lifecycle of events. You can consider them as passing through a cycle of birth, growth, and death. The mounting phase denotes the birth of your React component. The update phase highlights the growth of your component. The death of your component is highlighted by the unmounting phase.

React presents various methods that inform us whenever a certain stage of this process takes place. Such methods are known as the component’s lifecycle methods. Moreover, they are called upon in a predictable order. When you undergo Reactjs certification, you will be familiar with the various methods covered in the React lifecycle. Before getting into the details of the diverse methods in React lifecycle, let’s first understand the need for a lifecycle for React components:

Dependency of components on a lifecycle:

React components pass through a lifecycle irrespective of your code is familiar with it or not. Rendering is known to be one of the lifecycle events within a React component. For instance, there are lifecycle events specially dedicated for whenever the component is ready to be mounted in the DOM. Also, there are events after the component gets mounted to the DOM and when the component is updated, etc.

Since lifecycle events are another moving part, you need to keep them to a minimum. Certain components must respond to the lifecycle events to carry out initialization, deliver heuristics, or clearout after the component when it’s unmounted from the DOM.

When you go through the React tutorial, you can know why React components need a lifecycle. The details in the corresponding React learning path highlights the need for a lifecycle for the React components.

Frequently used React lifecycle methods:

render:

The render() method is the commonly used lifecycle method. This method can be found in all React classes. The reason is that render() is the only vital method in a class component within React.

Implied from the name, it manages the rendering of your component to the UI. Moreover, it takes place during the mounting and updating phase of your component. Keep in mind that a render() method needs to be pure, without side effects. React needs that your render() method is pure. Pure functions always return the same output whenever the same inputs are given. It suggests that you could not set State() inside a render() method. Also, keep in mind that you cannot change the component state inside the render(). When you keep your render() method pure and simple, without state updates, your app becomes maintainable. When you Learn Reactjs Step By Step, you will come to know the importance of this method.

componentDidMount():

After the render() method is executed, your component has now been mounted and ready. Now the another React lifecycle method i.e. componentDidMount() proves to be useful. This method is called the moment the component is mounted and is ready. At this moment, it is good to make API calls if you want to load data from a remote endpoint.

Contrasting the render() method, the componentDidMount() permits you to use setState(). When you call the setState() method, it updates state and leads to another rendering. However, it will take place before the browser updates the UI. The reason is it makes sure the user would not observe any UI updates having the double rendering.

It is possible to modify the component state inside the componentDidMount() but you should be careful.

componentDidUpdate():

This lifecycle method is called upon the moment the updating happens. Typically, this method is useful for updating the DOM in reply to prop or state modifications.

In this lifecycle method, you can call setState(). But remember that you have to wrap it inside a condition to analyze for state or prop modifications from the previous state. The inappropriate usage of setState() can create an infinite loop. It is possible to update the component state in the componentDidUpdate() method.

componentWillUnmount():

Suggested from the name itself, this lifecycle method is invoked just before the component is unmounted and ruined. This can be the right spot if there are any cleanup actions which you will have to do.

It is not allowed to update the component state in componentWillUnmount lifecycle. Keep in mind that this component is never re-rendered and therefore, we could not call setState() throughout this lifecycle method.

The frequently used cleanup activities in this method are canceling API calls, clearing timers, or clearing any caches within the storage.

Some other React lifecycle methods:

The methods described in this section are not frequently used. Let’s get into the details of such methods:

shouldComponentUpdate():

This lifecycle method can prove useful when you don’t want to render your state or prop changes through React. Whenever setState() is invoked, the component re-renders by default. The shouldComponentUpdate() method is useful to make sure React knows if a component is not influenced by the prop and state changes.

Don’t forget that this is an infrequently used lifecycle method. It exists merely for some performance optimizations. It is not allowed to update component state in shouldComponentUpdate() lifecycle. Many training courses on React incorporate learning on such infrequently used React lifecycle methods. This is because it may help you to succeed in React Interview Questions and Answers.

static getDerivedStateFromProps():

This method is recently introduced by the React team. It is considered a safer option than the earlier lifecycle method known as componentWillReceiveProps(). It is invoked just before calling the render() method.

When getDerivedStateFromProps() is executed, it returns an object to update the state according to prop changes. If there is no modification to state, it returns a null. Keep in mind that this method is applicable only for rare use cases in which the state relies on modifications in props in a React component. With every render() execution, this lifecycle method is executed.

getSnapshotBeforeUpdate():

getSnapshotBeforeUpdate() is also a latest lifecycle method recently introduced by React. It is considered as a safer option than the previous lifecycle method i.e. componentWillUpdate(). It is called immediately before the DOM gets updated. The value returned from getSnapshotBeforeUpdate() gets passed over to componentDidUpdate().

One of the best examples where getSnapshotBeforeUpdate can be used is resizing the window when performing an async rendering.

Angular Version 10 with New Features is Now Available

Dotnettricks — Mon, 02 Nov 2020 10:07:11 +0000

One of the major releases of Angular that spans the entire platform including Angular Material framework as well as the CLI is Version 10.0.0 of Angular. This release can be said as smaller than the typical but after the release of Angular 9, it is only 4 months that Angular 10 has been released.
We saw that at least 2 major versions are releasing every year to keep Angular synchronized with the rest of the JavaScript ecosystem and to have a predictable schedule. So, it is always suggested to go for an
Angular online course training
session to keep you updated.

What is new in this Angular 10 Release?

New date Range Picker:

Angular Material in Version 10 now includes a new date range picker.
To avail the new date range picker, what you can do is that you can use the mat-date-range-picker and mat-date-range-input components.
Optional Stricter Settings:

Version 10 offers a stricter project setup while you will create a new workspace with ng new.
Ng new –strict
By enabling this flag, it will initialize your new project with some new settings that can improve the maintainability and help you to catch bugs ahead of time and allow the CLI to perform advanced optimizations on the map. Mainly the ‘strict’

the flag will o the following activities:

Turns template type checking to Strict
Enables strict mode in TypeScript
75% have been decreased from Default bundle budgets
You can configure your app as side-effect free so that it could get more advanced tree shaking
Configures the linting rules to avoid any declarations of type

Get Warnings on CommonJS imports:

While using a dependency that is packaged with CommonJS, it can be providing you as a result in larger yet slower applications.
Now, start with the latest version 10, you will get a warning message when you build pills in one of these bundles. If you have already observed such kind of warning for your dependencies, you also need to let your dependency know that you would prefer an ECMAScript module (ESM) bundle.

Keeping Updated with the Ecosystem:

Some new updates have been made to the dependencies of Angular to stay synchronized with the JavaScript ecosystem.
TSLib has been updated to v2.0
TypeScript bumped to TypeScript 3.9
TSLint has been updated to v6
You will also found that project layout has also been updated in version 10. With this version 10, you will see a new tsconfig.base.json. This additional tsconfig.json file can support the way in which IdEs and build tooling resolve type and package configurations.
Angular Team Fixit:
Angular team has already increased its investment in working with the community. Even, from the last few weeks, open issues count has been decreased by over 700 issues throughout the tooling, framework and components.
New default Browser Configuration:
We have updated the browser configuration for new projects to remove the older and less used browsers.
V9 defaults:
[Thomas@Jefferson v9-test]$ npx browserslist
and_chr 81
and_ff 68
and_qq 10.4
and_us 12.12
android 81
baidu 7.12
chrome 80
chrome 81
chrome 83
edge 18
edge 81
edge 83
firefox 68
firefox 75
firefox 76
ios_saf 12.2-12.4
ios_saf 13.3
ios_saf 13.4 – 13.5
kaios 2.5
op_mob 46
op_mini all
opera 67
opera 68
safari 13
safari 13.1
Samsung 10.1
Samsung 11.1 – 11.2

v10 defaults:
[Thomas@Jefferson latest –test]$ npx browserslist
Chrome 83
edge 81
edge 83
firefox 68
firefox 76
ios_saf 12.0 – 12.1
ios_saf 12.2. – 12.4
ios_saf 13.0 – 13.1
ios_saf 13.2
ios_saf 13.3
ios_saf 13.4 -13.5
safari 12
safari 12.1
safari 13
safari 13.1
So, we can see that it has the side effects of disabling ES5 builds by default for new projects. To enable theES5 builds and differential loading for browsers that need it including IE or UC Browser, you just simply need to add the browsers that you support in the .browserslistrc file.
Deprecations and Removals:
Angular Team has already made several new deprecations and removals from Angular.

The Angular Package Format is now no longer include FESM5 and ESM5 bundles that will ultimately save you 119MB of download and install time while running yarn or npm install for Angular libraries and packages.

So, with this high demand for Angular, the developer can take
Angular JS Training in Hyderabad
or any other places of India and the world to gain in-depth knowledge in Angular 10 as well as other versions of Angular.

Details of Kubernetes and Relation between Docker and Kubernetes

Dotnettricks — Tue, 13 Oct 2020 09:54:14 +0000

Kubernetes is an extensible, portable, open-source platform for managing containerized workloads and services to facilitate both declarative configuration and automation. The word Kubernetes mainly originates from Greek, meaning helmsman or pilot.

How does Kubernetes work?

It is easy to get lost in the details of Kubernetes but at the end of the day, Kubernetes is working in a pretty simple way. However, Cheryl Hung from the CNCF describes Kubernetes as a control loop. Kubernetes compares the desired state to the actual state and if they will not be the same, the steps need to be taken to make it correct.

Kubernetes architecture and components:

Kubernetes is made up of various components that do not know are care about each other. The components are able to talk to each other through the API server. Each of these components operates its own function and then exposes metrics that we can collect for monitoring later on. Kubernetes can break down the components into three main parts:
The Control Plane – The Master Node
Pods – Holds Container
Nodes – Where pods get scheduled

The Control Plane – The Master Node: the Control plane is mainly the orchestrator of Kubernetes. Kubernetes is an orchestration platform and control plane mainly facilitates that orchestration. There are several components in the control plane which can help to facilitate that orchestration, the API server for communication between components, the Etcd for storage, the scheduler which decides what nodes pods should run on, responsible to check the current state against the desired state and the controller manager.

Pods: Pods are the lowest level resource in the Kubernetes cluster. A pod can be a build-up of one or more than one container, but mostly just a single container. While defining the cluster, limits are set for pods that define what resources, CPU and memory need to run smoothly. The scheduler uses this definition to decide on which nodes to place the pods. If there will be more than one container in a pod, then it is difficult to estimate the requirement of the resources and the scheduler will also not be able to place the pods appropriately.

Nodes: Nodes make up the collective compute power of the Kubernetes cluster. This is where containers are actually get deployed to run. Nodes are the physical infrastructure that your application runs on, the server of the VMs in your environment.

Relationship between Docker and Kubernetes:

Kubernetes and Docker both are comprehensive and effective solutions to intelligently manage containerized applications and provide powerful capabilities. However, from this, some confusion has also arisen. Kubernetes are sometimes used as a shorthand for the entire container environment which is based on the Kubernetes. But in reality, they are not directly comparable and have different roots and solve for different things.

Docker is a platform and tool for building, running and distributing Docker containers. Docker has its own native clustering tool that can be offered to orchestrate and schedule containers on machine clusters. Kubernetes is mainly a container orchestration system for the Docker Containers which is more widespread than Docker Swarm and also works for coordinating clusters of pods that are scheduling units in the Kubernetes ecosystem.

They are also distributed among nodes to provide high availability. One can run a docker build on a Kubernetes cluster easily but Kubernetes itself is not the complete solution and is meant to include custom plugins.
So, Kubernetes and Docker both are fundamentally different technologies but they can work very well together, and thus they are very meaningful in the technology market. So, getting Docker and Kubernetes online training is a necessary part for the developer today to become stable in the technical world. So, do Docker, Kubernetes, and
DevOps courses in Hyderabad to become an expert in this field.

What is MVC? Why use MVC?

Dotnettricks — Tue, 06 Oct 2020 06:08:07 +0000

It's a vast topic to cover. Explain what MVC is. It's just a three-tier architecture, where M stands for model, and V stands for view, and the most essential part of this architecture, like any other movie hero, is the controller. Therefore, each layer of MVC has its own responsibility. Therefore, views are intended for both appearance and placement of what the end-user sees.

The model provides the data and business logic. Thus, the model is just a class like employees, students, and so on. The model can interact with the data access layer, which is a service, such as a WCF service or web service that provides data. The controller is the heart of the MVC course, and as mentioned earlier, as a movie hero, it handles both layers. Therefore, the controller is also called the coordinator between the model and the view.

In MVC, when a user submits a request from a web browser, the controller is reached first. The controller sends it to the corresponding view. As mentioned earlier, the model always carries data, so the data request is sent by the user, and the controller is sent to the model class. If you change one layer, all the other layers remain the same. This is the main advantage of perfecting MVC. Here, the second figure illustrates a controller folder with a controller file extension. This folder also contains a model folder with the client-vendor class.

Here, it is the controller's responsibility to send the information from the model sent to the view. Now let's talk about the reasons why to use MVC. Why is MVC as reliable as a web form? Let's explain why MVC alone doesn't have web forms. Let's take a look at some background approaches to ASP.NET. This image illustrates more scenarios of the
differences between MVC forms and web forms.

Let's start with Microsoft in the background of Windows. These languages have no visual effect, so if you want to modify a button in C ++, you need to actually write the code. So Microsoft challenged what was called visual programming or RAD programming and set it up instead of the programmer code. To create the window, Microsoft introduced the following box: tool. They released Visual Studio and again in the programming language, and Microsoft was successful.
MVC training has the best scope shortly.
RAD programming is excellent, but it does cause some problems. The problem is in the backend of the code. That is, when the programmer drags and drops, the code is generated in subclasses. Let's analyze some of the shortcomings of this RAD programming.

Issue # 1: View-based architecture for action-based requirements.

When a user submits an action, what happens in the page lifecycle is that the lifecycle simply calls a complex structure, and you can see that the page is loading and other types of life cycles are in progress. It's a complicated method now. This is a mandatory event, not an event that runs any other occasion. Therefore, when an end-user submits a request as an action in this scenario, they first go to the view and then go through the complex life cycle again. In other words, you experience a complex life cycle, but the logical approach is to go to the stock directory. When a user submits an action request, it is mapped to a method in the program, the process is called, all the logic needed for the action is executed, then the required view is called, which is what happens in MVC.

Problem 2: Behind code cannot be reused.

So the related problem in choosing a lousy architecture was that the RAD architecture couldn't be used because the underlying code couldn't be reused. Still, MVC allows you to code reusable code over and over again.

Problem 3: Flexible combination of views and data

In short, web forms are a view-based architecture. The view is always determined, but in MVC, it hits the controller first, so it's more likely to join in MVC, but not in web forms. This is because the view is always fixed.

Problem 4: Behind the code

There is an easy way to unit test in MVC, an option for unit testing after creating a new project, but it's very difficult to handle on the web.

Get Trained into Azure IoT (Internet of Things)

Dotnettricks — Thu, 27 Aug 2020 09:23:17 +0000

IOT or Internet of Things is an exciting and quickly growing technology which already brings significant change to lots of important elements of modern life. However, as per other newly minted terms, the definition of IoT can also vary according to the person who is speaking. So, if you want to become a professional one, then you must need to take Azure DevOps Online Training along with IoT training from a good organization or institute.

What is IoT?

According to the reference from Wikipedia, The Internet of Things (IoT) is the network of devices, vehicles and home appliances which are mainly containing electronics, actuators, software and connectivity to allow these things to connect, interact as well as to exchange the data.

IoT mainly working on expanding internet connection further than some devices including laptops, desktops, tablets and Smartphones to any range of traditional, non-internet physical devices and everyday objects. The devices are surrounded by the latest technology and able to communicate over the Internet and can be remotely monitored and controlled. So, in a short, we can say that PC is not an IoT device but an Internet-connected tracking unit that sends the location and status data to a hub.

What is Azure IoT?

Azure IoT provides a flexible, easy and faster path to deliver differentiate connected products to gain a competitive advantage over the digital transformation with Microsoft Azure.

Azure mainly offers two primary solutions to built IoT platforms:

Azure IoT Central – It is a fully managed, SaaS platform to enable the creation of IoT solutions with built-in management and operational tools (IoT Central can automatically integrate with Azure IoT Hub and Time Series Insights).
Azure IoT Hub – It is a managed connectivity service that provides you with the ability to create a network of your IoT devices (Azure can incorporate with Azure Event Grid, Azure Machine Learning, Azure Logic Apps an Azure Stream Analytics).

So, one example of IoT configuration among so many others is - an IoT solution which has been built using IoT Central also includes IoT Hub as the interface point for all the connected items. The Stream Analytics works like the real time analysis ingestion engine and data source for the services including dashboards, databases and reports. Azure IoT toolkit offers huge flexibility along with the ability to create PaaS and SaaS IoT solutions that will either turnkey using IoT Central or highly customize, built using IoT Hub.

Azure IoT Central vs. IoT Hub:

For an example, IoT Central SaaS is a fully furnished, ready-to-move house which includes everything that you require from the start (accelerating adoption) whereas IoT Hub PaaS provides the glue for the solution that you build by using preferred tools.
According to Microsoft, IoT Central is a fully managed SaaS (Software-as-a-Service) solution which makes it easy to connect, manage and monitor the IoT assets at scale. Azure IoT Central can simply the initial process of your IoT solution and decrease the management burden, operational costs and overhead of a typical IoT project.

On the other hand, if your requirements are more specific or if you are pointing to existing IoT solutions to Azure, IoT Hub can be the best fit for your needs.

According to Microsoft, IoT Hub is a managed service which is hosted in the cloud an act as a central message hub for bi-directional communication between the IoT solutions and the devices it manages. A person can use IoT Hub to build IoT solutions with reliable and secure communications between several IoT devices and a cloud-hosted solution blackened. It is possible to connect any device to IoT Hub.

Companies having knowledge and experience of building IoT applications or whose requirements are not met by IoT Central’s catalogue of pre-created options can able to use IoT Hub as the interacting and communication source for the things their app interfaces with.

Azure IoT Solution Accelerators:
Microsoft provides a helpful collection designed to show the capabilities of Azure IoT solutions and get you acquainted with IoT Technology which includes –
Cloud-based Remote Monitoring
Cloud-based Connected Factory
Cloud-based Predictive Maintenance
Cloud-based device Simulation

Training in Azure IoT:

Azure IoT is a powerful platform to enable organizations of all sizes to deploy, manage, and scale IoT solutions. Getting Azure DevOps online training in Hyderabad or any part of India will make you able to take full advantage of cloud-native techniques to build a robust IoT application.