{"componentChunkName":"component---src-templates-blog-list-template-js","path":"/121","result":{"data":{"allMarkdownRemark":{"edges":[{"node":{"excerpt":"The GitHub CLI is a recent GitHub released tool that takes tasks of issue / PR management to the terminal. It will be a useful tool that…","fields":{"slug":"/engineering/github-cli-tool/"},"html":"

The GitHub CLI is a recent GitHub released tool that takes tasks of issue / PR management to the terminal. It will be a useful tool that will put more of our workflow for software creation into the textual domain rather than the visual domain. It’s just called gh.

\n

**Installation of GitHub CLI 💡**

\n

GitHub CLI has releases with significant operating systems, visit the installation page and find instructions on how to install GitHub CLI for your operating system.

\n

For [Windows] and [macOS], you will use the package managers to update and maintain GitHub CLI, and for Linux users, you may need to grab the software from the latest release website.

\n

Here are examples of the installation instructions for each compatible platform:

\n

→ Windows

\n
scoop bucket add github-gh https://github.com/cli/scoop-gh.gitscoop install gh
\n

→ macOS

\n
brew install github
\n

→ Debian/Ubuntu Linux

\n
sudo apt install git && sudo dpkg -i gh_*_linux_amd64.deb
\n

→ Fedora/Centos Linux

\n
sudo yum localinstall gh_*_linux_amd64.rpm
\n

→ Arch Linux

\n
yay -S github-cli
\n

You’ll need to authenticate your account after you install GitHub CLI. Running any command would activate this process of authentication(via OAuth). Well, you can use Git CLI.\n\"Auhtorize\"

\n

**What is CLI really doing? 🤔**

\n

The GitHub CLI lets you handle issues/ PRs / repositories from inside your console. Let’s have a look at it:

\n
gh issue [status, list, view, create]\ngh pr [status, list, view, checkout, create]\ngh repo [view, create, clone, fork]\ngh help
\n

\"gh

\n

It should be said that gh is not the same stuff as git. It’s because gh just adds GitHub tools to the terminal. Version management is yet to be managed with git.

\n

**CLI Commands ➫**

\n

We’re going to cover a bunch of exciting commands. Let’s use the official Angular.js repo to run gh commands

\n

Clone the Angular repo, and navigate to the repository. You can either clone the repo through HTTPS/ ssh/ Git CLI. I’m going to clone the repo through git CLI since we are working on GIT CLI.

\n

Let’s execute the $gh issue --help see what commands are available.

\n
gh issue --help  \nWork with GitHub issues\nUSAGE\n  gh issue <command> [flags]\nCORE COMMANDS\n  close:      Close issue\n  create:     Create a new issue\n  list:       List and filter issues in this repository\n  reopen:     Reopen issue\n  status:     Show the status of relevant issues\n  view:       View an issue\nFLAGS\n  -R, --repo OWNER/REPO   Select another repository using the OWNER/REPO format\nINHERITED FLAGS\n  --help   Show help for command\nARGUMENTS\n  An issue can be supplied as an argument in any of the following \n  formats:\n  - by number, e.g. "123"; or\n  - by URL, e.g. "https://github.com/OWNER/REPO/issues/123".\nEXAMPLES\n  $ gh issue list\n  $ gh issue create --label bug\n  $ gh issue view --web\nLEARN MORE\n  Use 'gh <command> <subcommand> --help' for more information about a command.\n  Read the manual at https://cli.github.com/manual
\n

It’s Time to view Problems/issues in the angular repo.😁

\n
gh issue list
\n

\"Angular

\n

**Pull Requests 🤖**

\n

It is now possible to build a Pull Request (PR) on the terminal. You will perform $gh pr create right after you have committed a feature or bug branch. This interactively creates the pull request.😉

\n

Let’s execute the $gh pr --help see what commands are available.

\n
Work with GitHub pull requests\nUSAGE\n  gh pr <command> [flags]\nCORE COMMANDS\n  checkout:   Check out a pull request in git\n  checks:     Show CI status for a single pull request\n  close:      Close a pull request\n  create:     Create a pull request\n  diff:       View changes in a pull request\n  list:       List and filter pull requests in this repository\n  merge:      Merge a pull request\n  ready:      Mark a pull request as ready for review\n  reopen:     Reopen a pull request\n  review:     Add a review to a pull request\n  status:     Show status of relevant pull requests\n  view:       View a pull request\nFLAGS\n  -R, --repo OWNER/REPO   Select another repository using the OWNER/REPO format\nINHERITED FLAGS\n  --help   Show help for command\nARGUMENTS\n  A pull request can be supplied as an argument in any of the following formats:\n  - by number, e.g. "123";\n  - by URL, e.g. "https://github.com/OWNER/REPO/pull/123"; or\n  - by the name of its head branch, e.g. "patch-1" or "OWNER:patch-1".\nEXAMPLES\n  $ gh pr checkout 353\n  $ gh pr create --fill\n  $ gh pr view --web\nLEARN MORE\n  Use 'gh <command> <subcommand> --help' for more information about a command.\n  Read the manual at https://cli.github.com/manual
\n

**Let’s view some of it:👀**

\n

current PR’s in the repo:

\n

$ gh pr list\n\"Angular

\n

*Let’s view an individual pr:*

\n

I’m going with the first pull request #38899. Through gh cmd $ gh pr view 38899.

\n
refactor(compiler): simplify visitor logic for attributes\nDraft • atscott wants to merge 1 commit into master from testrefactor\nLabels: cla: yes, comp: compiler, state: WIP, target: patch\nMilestone: needsTriage\nThe logic for computing identifiers, specifically for bound attributes can  \n  be simplified by using the value span of the binding rather than the source span.\nView this pull request on GitHub: https://github.com/angular/angular/pull/38899
\n

**Repository 🤖**

\n

Let’s execute the $gh repo --help see what commands are available

\n
Work with GitHub repositories\nUSAGE\n  gh repo <command> [flags]\nCORE COMMANDS\n  clone:      Clone a repository locally\n  create:     Create a new repository\n  fork:       Create a fork of a repository\n  view:       View a repository\nINHERITED FLAGS\n  --help   Show help for command\nARGUMENTS\n  A repository can be supplied as an argument in any of the following formats:\n  - "OWNER/REPO"\n  - by URL, e.g. "https://github.com/OWNER/REPO"\nEXAMPLES\n  $ gh repo create\n  $ gh repo clone cli/cli\n  $ gh repo view --web\nLEARN MORE\n  Use 'gh <command> <subcommand> --help' for more information about a command.\n  Read the manual at https://cli.github.com/manual
\n

It is better to clone a repository using the gh command than with the git command. I have done this above. Only through gh cmd, I have cloned angular repo.

\n
$ gh repo clone angular/angular\n$ gh repo fork\n- Forking angular/angular...
\n

Start functioning. You should create a new PR after this ($gh pr create)! It’s sort of remarkable that all of that element is now available in the terminal!😍

\n

**Gist 🐱‍🚀**

\n

It is now simple to create a gist on GitHub from the terminal using the CLI cmd.

\n
gh gist create < file >
\n

**Conclusion🙀**

\n

Git CLI's primary objective is to \"minimize context switching\" by allowing you to continue inside your terminal/console, rather than opening your browser to access GitHub. For additional functionality and knowledge on using the current resources, you may link to the manual.

\n","frontmatter":{"date":"October 05, 2020","updated_date":null,"description":"Learn about GitHub CLI tool and how/when to use it","title":"GitHub CLI Tool ⚒","tags":["Cloud","GIT","Version control"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5384615384615385,"src":"/static/67f9c8247a3c5142d5ef1f220d1e512a/89989/GitHub%20CLI%20Tool.webp","srcSet":"/static/67f9c8247a3c5142d5ef1f220d1e512a/61e93/GitHub%20CLI%20Tool.webp 200w,\n/static/67f9c8247a3c5142d5ef1f220d1e512a/1f5c5/GitHub%20CLI%20Tool.webp 400w,\n/static/67f9c8247a3c5142d5ef1f220d1e512a/89989/GitHub%20CLI%20Tool.webp 757w","sizes":"(max-width: 757px) 100vw, 757px"}}},"author":{"id":"Saravanan Vijayamuthu","github":"SaravananVijayamuthu","avatar":null}}}},{"node":{"excerpt":"Overview You may have come across the term- “lazy loading in React”, but most of you won’t be familiar with exactly what is lazy loading in…","fields":{"slug":"/engineering/lazy-loading-in-react/"},"html":"

Overview

\n

You may have come across the term- “lazy loading in React”, but most of you won’t be familiar with exactly what is lazy loading in React. Lazy loading is not a new concept. It has been available for quite some time. In essence, lazy loading means that a component or a part of code must get loaded when it is required. It is also referred to as code splitting and data fetching. Now, the next question is, how to do lazy loading in react​?

\n

Talking about React specifically, it bundles the complete code and deploys all of it at the same time. Now, usually, that's not a bad idea, since React SPAs (Single page application) are quite small and do not affect the performance. But what if we have a gigantic application, like a content management system with a customer portal, admin portal etc. In such a case, it does not seem like a smart idea to load the complete application.

\n\n

In this post, I will try to explain the advantages of lazy loading in react and how to implement it in React.

\n

Advantages

\n

In situations where we know that certain code/features will not be accessible to all the users or the user does not access it frequently, it is best to load them when the user requests for it. This improves user experience as well as initial loading time.

\n

For example, let's consider that our application has two sections, A and B. Size of A is 1 MB and its loading time is approximately 1 second. Size of B is also 1 MB and so its loading time is also 1 second. And we know that a user will access either of the sections, or a user accessing section A will rarely access section B and vice versa. If we were to load the complete application at the starting of our application, it would cost the user 2 MB of data and the loading time will also be 2 seconds. The user might not like to wait for 2 seconds or won't be happy that a site is costing them a lot of data. This can be improved and halved with proper lazy loading through lazy load react components.

\n
\n

Note: This is not the general case. Small single-page applications are usually in kbs.

\n
\n

Prerequisites

\n

To follow this tutorial, you’ll need the following:

\n\n

General instructions

\n
    \n
  1. We will perform lazy loading in React with react suspense and without it.
    2. \n
  2. \n

    First of all, create the app using npm create-react-app

    \n
    npm create-react-app my-app
    \n
    3. \n
  3. \n

    Now run the app by running following command in the project directory root

    \n
    npm start
    \n
    4. \n
  4. The default react app will run in http://localhost:3000
    5. \n
  5. \n

    Let the directory structure be

    \n
    |\n|-src\n|\t|-components\n|\t|\t|-Admin.js\n|\t|\t|-Customer.js\n|\t|\t|-Home.js\n|\t|-app.js\n|-index.js
    \n
    6. \n
  6. Application will first render app.js which will have an input field. We will pass the input received as props to Home, and render Home.js. Based on props received, we will either render Admin or Customer.
    7. \n
\n

Using React Suspense (React 16.6+)

\n

From React 16.6+, react added React Suspense which performs lazy loading.

\n
    \n
  1. \n

    In our Home.js, we will lazy load Admin and Customer

    \n
    import React, { Suspense } from "react";\nconst Customer = React.lazy(() => import("./Customer.js"));\nconst Admin = React.lazy(() => import("./Admin.js"));\n\n//Instead of regular import statements, we will use the above approach for lazy loading\n\nexport default (props) => {\n\tif (props.user === "admin") {\n\t\treturn (\n\t\t\t// fallback component is rendered until our main component is loaded\n\t\t\t<Suspense fallback={<div>Loading</div>}>\n\t\t\t\t<Admin />\n\t\t\t</Suspense>\n\t\t);\n\t} else if (props.user === "customer") {\n\t\treturn (\n\t\t\t<Suspense fallback={<div>Loading</div>}>\n\t\t\t\t<Customer />\n\t\t\t</Suspense>\n\t\t);\n\t} else {\n\t\treturn <div> Invalid User </div>;\n\t}\n};
    \n
    2. \n
\n

Without React Suspense

\n

When talking about react lazy loading, if you are working with React version prior to 16.6, you won't have the Suspense component. It is best to upgrade to the latest version and use Suspense. If you're not able to upgrade and still want this feature, it is still possible to create your own React Suspense component. I will be using Higher Order Component(HOC).

\n\n","frontmatter":{"date":"October 05, 2020","updated_date":null,"description":"Learn about lazy loading in React and how/when to use it","title":"Lazy loading in React","tags":["React","Lazy loading","React Suspense"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/9413be85c5c5c59674b56bdb292753b4/58556/react.webp","srcSet":"/static/9413be85c5c5c59674b56bdb292753b4/61e93/react.webp 200w,\n/static/9413be85c5c5c59674b56bdb292753b4/1f5c5/react.webp 400w,\n/static/9413be85c5c5c59674b56bdb292753b4/58556/react.webp 800w,\n/static/9413be85c5c5c59674b56bdb292753b4/210c1/react.webp 900w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Akshay Avinash","github":"akshay11298","avatar":null}}}},{"node":{"excerpt":"GraphQL's popularity has skyrocketed since its release in 2015. It is the modern way of developing and querying APIs. GraphQL is an…","fields":{"slug":"/engineering/what-is-graphql/"},"html":"

GraphQL's popularity has skyrocketed since its release in 2015. It is the modern way of developing and querying APIs. GraphQL is an application programming interface (API) query language and server-side runtime that prioritises giving customers precisely the data they request.

\n

GraphQL is designed to make fast, scalable, and developer-friendly APIs. GraphQL allows developers to build requests that pull data from multiple data sources in a single API call as an alternative to REST.

\n

Foundation of GraphQL

\n

It was developed internally by Facebook in 2012 before being publicly released in 2015. \"On 7 November 2018, the GraphQL project was moved from Facebook to the newly-established GraphQL Foundation, hosted by the non-profit Linux Foundation.\"

\n

What is GraphQL?

\n

GraphQL is an application-level query language that helps data fetching and serving between client and server runtime by providing a standard protocol for queries. Its strength lies in the fact that it offers a modern, simpler, and efficient way to query and develop APIs. The real deal is its flexible data fetching -- the application only loads relevant data from the server. Also, GraphQL is hierarchical in nature; it structures relationships in a simple hierarchical manner to avoid complex queries while fetching data.

\n

Why to use GraphQL?

\n

GraphQL offers much power and flexibility over Traditional APIs. One of the few things GraphQL was designed, was to solve Data Fetching/Loading problems.

\n

Data fetching is one of the most critical factors responsible for the performance of the application. Most of the time, the data provided by the API isn't required to run the application. This problem is termed as \"Over fetching\", which can be a more significant issue in mobile devices. Since devices with slower network connection are bound to take more load time, it creates a negative impact on end-users.

\n

In the current scenario, traditional REST APIs offer no clean way to solve this problem; GraphQL comes to the rescue. It allows clients to define the structure of the data required, and the same structure of the data is returned from the server. Therefore preventing fetching loads and loads of data, ultimately increasing performance.

\n

API endpoints generally fetch specific data, hence to load a certain data-rich application, there have to be multiple requests to the server. But, applications should fetch relevant data in one round trip to avoid degrading performance. The flexibility and richness of the GraphQL, allows us to define all the data to fetch in a single request, avoiding multiple Round trips

\n

\"Wrapping\nWrapping REST API in graphQL - Source - Joey Ng'ethe | TwigaTech

\n

Fundamentals of GraphQL

\n\n\n\n\n\n\n\n\n\n\n\n
Server ->GraphQL Server ->Graphql Client ->Client
\n
\n

Schema - GraphQL follows a type system to define the schema of an API. The syntax for writing schemas is called Schema Definition Language (SDL).

\n
# A simple example to define schema\ntype Person {\n  name: String!\n  age: Int!\n}
\n

Query - The data or information that a client needs from a server can be fetched in a request using queries.

\n
# This query fetches all specifically names of all users\n{\n  users {\n    name\n  }\n}\n# This query fetches all names of all friends of user "Anup".\n{\n  user(name: "Anup") {\n    name\n    friend {\n      name\n    }\n  }\n}
\n

Mutation - Mutations are the way to modify data to the server; these include creating/updating/deleting data. They have similar syntax as queries, with special keywords ahead of them.

\n
# This mutation adds a user with name "Anup" and age 20.\nmutation {\n  addUser( name : "Anup", age: 20) {\n    name\n    age\n  }\n}
\n

Despite its powers, you might not need graphQL in your applications -

\n\n

Conclusion

\n

GraphQL is a step forward in the world of applications by providing a significant boost in performance. Another plus point of GraphQL is that it is not meant to replace any existing solution but enhance and co-exist with REST APIs. Simply put, the future of GraphQL looks bright.

\n","frontmatter":{"date":"October 01, 2020","updated_date":null,"description":"GraphQL is a syntax that specifies how data can be requested and is usually used to load data to a client from a server. Find out why to use it and any other advantages.","title":"What is GraphQL? - A Basic Guide","tags":["Engineering","API","GraphQL","Performance"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/4674ea0950b63a1ff2d08638af559bc0/58556/graph.webp","srcSet":"/static/4674ea0950b63a1ff2d08638af559bc0/61e93/graph.webp 200w,\n/static/4674ea0950b63a1ff2d08638af559bc0/1f5c5/graph.webp 400w,\n/static/4674ea0950b63a1ff2d08638af559bc0/58556/graph.webp 800w,\n/static/4674ea0950b63a1ff2d08638af559bc0/210c1/graph.webp 900w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Anup Aglawe","github":"anup-a","avatar":null}}}},{"node":{"excerpt":"Determining how consumers are introduced to a brand is as important as managing their subsequent journey. With LoginRadius’ recently…","fields":{"slug":"/identity/loginradius-announces-user-management/"},"html":"

Determining how consumers are introduced to a brand is as important as managing their subsequent journey. With LoginRadius’ recently launched User Management feature, businesses can enjoy streamlined access control and adjustable privileges for their consumers. 

\n

Intent Behind the Launch

\n

Simply put, the LoginRadius User Management feature solves the problem of managing the multiple operations that revolve around consumer data. 

\n

It also has been designed to help your business in the following ways: 

\n\n

\"loginradius

\n

Key Capabilities of LoginRadius User Management

\n

1. User management process: LoginRadius offers complete consumer management features, including: 

\n\n

2. Multiple operations of user data: LoginRadius allows the following actions to be performed on consumers’ data:

\n\n

A Final Word

\n

The User Management feature by LoginRadius is unique in that it monitors and manages the entire consumer journey through automated access permissions, data migration, API support, and other consumer-centric solutions. Now, blend it with creating meaningful relationships with your consumers—that’s what we offer. 

\n

\"Book-a-demo-loginradius\"

\n","frontmatter":{"date":"September 30, 2020","updated_date":null,"description":"Businesses will enjoy simplified access control and flexible rights for their customers with the newly added User Management functionality of LoginRadius.","title":"Announcement – LoginRadius Announces the Availability of User Management","tags":["user management","identity management","password management"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.408450704225352,"src":"/static/22595533068957863c04b02f3ec0541a/7f8e9/image1.webp","srcSet":"/static/22595533068957863c04b02f3ec0541a/61e93/image1.webp 200w,\n/static/22595533068957863c04b02f3ec0541a/1f5c5/image1.webp 400w,\n/static/22595533068957863c04b02f3ec0541a/7f8e9/image1.webp 768w","sizes":"(max-width: 768px) 100vw, 768px"}}},"author":{"id":"Kundan Singh","github":null,"avatar":null}}}},{"node":{"excerpt":"C# and the .NET CLR use exceptions to show that an error condition has arisen during program execution. C# programs are under constant…","fields":{"slug":"/engineering/exception-handling-in-csharp/"},"html":"

C# and the .NET CLR use exceptions to show that an error condition has arisen during program execution. C# programs are under constant threat of running into some sort of problem. As a program’s complexity grows, the probability that something odd would happen during its execution also gets higher.

\n

In this blog, we will go through the basics of Exception and Exception handling. We will also look at how we can achieve exception handling using try, catch, and finally blocks and how to create your own custom exceptions.

\n

Exception

\n

The errors which we are getting at the run time of the application is called an exception.

\n

If any exception is coming into our application then the application is abnormally terminated. The Application is not considered as a good application if any exception is coming and it is not handled.

\n

Every time when we are developing an application and it got successfully build without any errors. Then this happens

\n

\"Exception\"

\n

For that, it is good practice to use exception handling.

\n

Common .NET Exceptions :

\n

Below are the common .NET exceptions which we can see on a regular basis of coding.

\n

System.NullReferenceException – Occurs when calling a method on a null object reference

\n

System.IndexOutOfRangeException – Occurs attempting to access an array element that does not exist

\n

System.IO.IOException – Used around many file I/O type operations

\n

System.OutOfMemoryException – Occurs when the app runs out of memory

\n

System.InvalidCastException – Occurs when you try to cast an object to a type that it can’t be cast to

\n

System.InvalidOperationException - Occurs when a method call is invalid for the object's current state

\n

System.ArgumentException - Occurs when one of the arguments provided to a method is not valid

\n

Exception Handling

\n

The process of handling any run time error is called exception handling. The exception handling is performed to maintain the normal flow of the application.

\n

In C# we can achieve this using the below techniques:

\n

Try,Catch & Finally blocks

\n

This is a very basic Exception handling technique in which try, catch, and finally, blocks are used.

\n

try block: In this block the code is written which may cause the exception. If any exception is thrown then the corresponding catch block is executed.

\n

catch block: In this block the exception is caught which means if an exception is thrown from the try block then we write the code to handle or log it.

\n

finally block: In this block we write the certain code which we want to execute if an exception is thrown or not. For example: disposing of an object or closing the database connection.

\n

Exception Handling after using try, catch blocks

\n

\"Exception

\n

Note: Multiple finally blocks are not allowed. Also, the finally block cannot have the return, continue, or break keywords. It doesn't let control leave the finally block.

\n

In C#, both catch and finally blocks are optional. The try block can exist either with one or more catch blocks or a finally block or with both catch and finally blocks. The try block without a catch or finally block will give a compile-time error.

\n

If there is no exception occurred inside the try block, the control directly transfers to the finally block. We can say that the statements inside the finally block are executed always.

\n
try\n{\n// Code which can cause an exception.\n}\ncatch(Type x)\n{\n// Code for handling the exception\n}\nfinally\n{\n//Any cleanup code\n}
\n

Multiple Catch blocks

\n

We can use the multiple catch blocks when we are not sure which type of exception will be thrown by the code. So that will help to catch the multiple types of exceptions.

\n
try{\n// Code which can cause an exception.\n}\ncatch(ArithmeticException ex)\n{\n// Code for handling the exception\n}\ncatch(IndexOutOfRangeException ex)\n{\n// Code for handling the exception\n}\nfinally{\n//Any cleanup code\n}
\n

Catch multiple exceptions in the single catch block

\n

We can use the generic exception class as well to catch all types of exception in that case we have to write the catch block as below:

\n
try{\n// Code which can cause an exception.\n}\ncatch(Exception ex)\n{\n// Code for handling the exception\n}\nfinally{\n//Any cleanup code\n}
\n

Note: Multiple catch blocks with the same exception type are not allowed. A catch block with the base Exception type must be the last block.

\n

Exception Filters

\n

In C# 6.0 a new feature is introduced to handle the exception which is called the Exception Filters. This feature will allow you to handle more specific exceptions in catch blocks so that you can write the code specific to the exception condition.

\n

Like before C# 6.0 We had to catch any exception and handle it. Now in C# 6.0, we can handle the exception specific to the condition.

\n
try\n{\n// Code which can cause an exception.\n}\ncatch(Type x) when(\n    //some condition\n)\n{\n// Code for handling the exception\n}\ncatch(Type x) when (\n    //some condition\n)\n{\n \n}\nfinally\n{\n//Any cleanup code\n}\n
\n

Nested try-catch

\n

C# allows nested try-catch blocks. When using nested try-catch blocks, an exception will be caught in the first matching catch block that follows the try block where an exception occurred.

\n
static void Main(string[] args)\n{\n    int divider = 0;\n \n    try\n    {\n        try\n        {\n            var result = 1/divider;\n        }\n        catch(Exception ex)\n        {\n            Console.WriteLine("Inner catch block");\n        }\n    }\n    catch(Exception ex)\n    {\n        Console.WriteLine("Outer catch block");\n    }\n    \n}
\n

An inner catch block will be executed in the above example because it is the first catch block that handles all exception types.

\n

If there is not an inner catch block that matches with raised exception type, then the control will flow to the outer catch block until it finds an appropriate exception filter.

\n

Throw an Exception

\n

C# allows throwing an exception. The throw keyword is used for that purpose. One of the benefits of throwing an exception can be when a problem occurs in the middle of the complicated method execution because handling that situation in that complicated method would make that method even more complex. Then we should throw an exception and let the catch block to handle it.

\n

The throw keyword can only be used with the Exception object except for the catch block. It will be discussed in the next section.

\n
try\n{\n    //throw exception\n    throw new Exception();\n}\ncatch (Exception ex)\n{\n    //some code to hadle the exception\n}
\n

Note: The throw keyword is used to throw or create the new exception. If the throw keyword is used and if there is any catch block then the catch block will be executed next.

\n

Rethrow an Exception

\n

When an exception is caught in the catch block, we can do some operations and then re-throw the exception. Rethrow an exception means calling the throw keyword without an exception object inside a catch block.

\n

Here is the point to note that if we follow the below approach to rethrow the exception then the proper stack trace will not be maintained means it will not point out that actually where the exception occurred it will show in the stack trace the line number from which the exception is rethrown.

\n
try\n{\n    // Code which can cause an exception.\n}\ncatch (Exception ex)\n{\n    throw ex;//Exception is rethrown with the exception object\n}
\n

Now if we follow the below approach then the proper stack trace will be maintained with maintaining the exact line number where the exception actually occurred.

\n
try\n{\n    // Code which can cause an exception.\n}\ncatch (Exception ex)\n{\n    throw;//Exception is rethrown with the exception object\n}
\n

User-defined Exceptions

\n

User-defined exceptions are those exceptions that are not defined by the programming language. In C# we can create our own custom exceptions(User-defined exceptions)

\n

C# exceptions are defined as classes, just like any other C# object. All exceptions are inherited from a base System.Exception class. There are many common exceptions that you can use within your own code.

\n

Creating your own C# custom exceptions is helpful only when you are going to catch that specific type of exception and handle it differently.

\n
    class Program\n    {\n        static void Main(string[] args)\n        {\n            try\n            {\n                //throw user defined exception\n                throw new CustomException("Custom exception thrown");\n            }\n            catch (Exception ex)\n            {\n                Console.WriteLine("Exception caught here" + ex.ToString());\n            }\n        }\n    }\n    class CustomException : Exception\n    {\n        //User-defined exception which inherits base class Exception\n        public CustomException(string message)\n        {\n            Console.WriteLine("User defined exception");\n        }\n    }
\n

Exception Handling Best Practices

\n

Log Exception

\n

It is considered a good practice to log all the exception which are coming into our application. The main benefit of logging exceptions that we can know exactly what are the conditions on which the code is failing instead of asking from the user that what inputs he has provided we can log all the required information and use that data to solve the error.

\n

In many cases, we just ignore the catch block by writing nothing in it. There are some .NET libraries available for logging purposes like NLog, Serilog, etc.

\n

We can log exception into the catch block. Every exception is coming into our application is crucial as they are critical to finding the problems in the code.

\n
try\n{\n   //Some code\n}\ncatch (Exception ex)\n{\n   //Log Exception here!!!\n   Log.Error(ex); // log the inputs provided by the user or any specific condition\n}
\n

First Chance & Second Chance Exception

\n

The first chance exception is mainly designed for debugging purposes. Like whenever an exception occurs it first goes to the debugger giving the first chance to you and then to the program/application. If that exception is unhandled in the program/application then it gets back to the debugger giving a second chance to you to do something with your code before and after the application itself decides to do.

\n

It gives you visibility into every .NET exception being thrown.

\n

We can enable the first chance exception in the Visual Studio by going into the\nDebug > Windows > Exception Settings > check next to \"Common Language Runtime Exceptions\"

\n

You can also select the exceptions you want the debugger to break automatically in the above setting.

\n

Conclusion

\n

In this blog, we learned about the basics of Exception, Exception Handling, and some best practices of exception handling. Use of the exception handling with its best practices in the application will help the application to run smoother and without any bad user experience.

\n","frontmatter":{"date":"September 29, 2020","updated_date":null,"description":null,"title":"Exceptions and Exception Handling in C#","tags":["C#","Exception","Exception Handling",".NET","Exception Handling Best Practices"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5748031496062993,"src":"/static/08a77b05a9e3c87430c53bdc17497fe6/58556/csharplogo.webp","srcSet":"/static/08a77b05a9e3c87430c53bdc17497fe6/61e93/csharplogo.webp 200w,\n/static/08a77b05a9e3c87430c53bdc17497fe6/1f5c5/csharplogo.webp 400w,\n/static/08a77b05a9e3c87430c53bdc17497fe6/58556/csharplogo.webp 800w,\n/static/08a77b05a9e3c87430c53bdc17497fe6/99238/csharplogo.webp 1200w,\n/static/08a77b05a9e3c87430c53bdc17497fe6/7c22d/csharplogo.webp 1600w,\n/static/08a77b05a9e3c87430c53bdc17497fe6/36d36/csharplogo.webp 1650w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Hemant Manwani","github":"hemant404","avatar":null}}}},{"node":{"excerpt":"A lot has been written and talked about Unit Testing in the IT industry for the last couple of years. I have heard and discussed the same…","fields":{"slug":"/engineering/unit-testing/"},"html":"

A lot has been written and talked about Unit Testing in the IT industry for the last couple of years. I have heard and discussed the same over the previous 2.5 decades of my IT career.

\n

Even though a lot is talked about and is done in this field but still today, every company is struggling with this. But before we proceed with the above situation, let us first understand its importance.

\n

A strong foundation is the basis of a strong building in the same way a proper unit testing is the foundation of high-quality software.

\n

Unit Testing, if done correctly, ensures that each of the building blocks of the software product is robust and will make high-quality software when put together.

\n

Unit testing is an essential tool in any serious software developer's toolbox. However, writing a good unit test for a specific piece of code can often be very hard.

\n

Developers frequently believe that their struggles are triggered by a lack of essential testing expertise or hidden unit testing techniques after experiencing trouble testing their own or someone else's code.

\n

What is Unit Testing?

\n

Testing of the unit requires testing individual components of the programme or application software. The primary objective behind this is to verify that all the individual components function as expected.

\n

As the smallest possible part of the software that can be evaluated, a unit is known. It usually has a couple of inputs and a single output.

\n

Both testers and developers can isolate each module, detect and repair device defects at a very early stage of the life cycle of software development with this testing method (SDLC).

\n

Why Unit Testing is essential?

\n

By considering stubs, mock artifacts, drivers, and unit testing frameworks, this methodology effectively helps validate the consistency of a section of code.

\n

Because it is practiced at the initial testing level, this testing methodology ensures that the vulnerabilities are detected and corrected at the early stage of SDLC, even before they become costly for businesses to repair when they are later identified.

\n

The developers and testers can help save time with a suitable unit testing practice as bugs can be found early in the process as it is the initial testing step. Skipping or restricting the unit testing practice will adversely increase the defects, and repairing them later becomes difficult.

\n

Therefore before preparing for the integration testing, it is essential to practice unit testing at the initial stage of the software testing process.

\n

Why is it difficult to run a smooth unit testing procedure?

\n

Well, it is not that a developer loves to find bugs in his/her coded code. Still, when it comes to unit testing, they at times(most of the time) see it has an additional overhead on them, especially when one has to follow and stick to a lot of protocols, frameworks, and documentation, etc.

\n

Also, it is commonly misunderstood that finding issues is the QC team's problem. We have to code. In my view, it is incorrect thinking as Quality Software is standard or combines commitment from a company and it's the team.

\n

What are the benefits of Unit Testing?

\n

Here are a few benefits of unit testing:

\n

1. Agile process

\n

The most significant advantage of unit testing is this. You would need to make improvements to the old design and code when you add more functionality to any programme, which can be costly and risky. If you use the technique of unit testing, this will save a lot of time and can make the whole process much quicker and simpler.

\n

2. Enhance the Code Quality

\n

Unit testing increases code consistency dramatically. It allows designers to recognize the smallest faults present in the units before they go for integration testing.

\n

3. Fix Software Bugs

\n

At a very early point, unit testing helps detect all sorts of problems with the programme. Until going any further, software developers should then focus on those problems first.

\n

This is the primary benefit of this because no other program component is compromised as the issues are fixed at an early stage. This results in improved performance, decreased downtime, and lower costs that would otherwise occur due to the entire design process's stalling.

\n

4. Facilitates Change

\n

When you test each part of the program individually, refactoring the code or upgrading the device library becomes much simpler. If there are any issues, they are found early on, and it thus becomes much easier to make improvements to the system.

\n

Before it goes on to the next level, the accuracy of each unit is checked. This implies that until it's incorporated with other companies, the device is proven to be in good working order.

\n

5. Provides Documentation

\n

Unit verification considers the whole system's documentation. By reading each module's documentation, developers who want to learn about the features of a specific programme or framework will quickly learn about the device.

\n

It makes it possible for them to have a detailed understanding of the system and what each part does.

\n

6. Seamless Debugging

\n

To a great degree, unit testing will simplify the debugging process. If a particular test fails, it is essential to debug only the most recent improvements made to the code.

\n

7. Reduce Costs

\n

In the early stages, any problems or glitches in the system are detected by unit testing, and the cost of bug fixes is significantly reduced because of this. If these vulnerabilities are found later, so repairing them would be even more costly.

\n

How to do Unit Testing?

\n

It is important for the unit testers to get a step-by-step instructional document in order to practice unit testing with the manual testing process.

\n

However, automated unit testing is often chosen by most companies, taking into account the efforts necessary for manual testing.

\n
    \n
  1. Is my written code fulfilling the business requirement for which I have written the code?
    2. \n
  2. How many other application areas is my code impacting? Are the values passed from the new block causing an impact on existing areas? Here I would like to state that one has to focus more on the behavior of the existing code with new values. The earlier we do it in the coding cycle the better it is in terms of rework at the developer's end.
    3. \n
  3. If you can follow a specific framework like Junit or Nunit etc, for conducting the unit testing is fine, but if not, you are not able to do that it does not matter as I can always pass a set of values(both positive or negative) to my written code.
    4. \n
  4. If there is no Test case management tool for trapping the unit test values, do not worry; just make a .txt file, put the values, and outcomes in that and you can see the same on a shared drive.
    5. \n
  5. Can I write a few automated scripts to execute the repetitive code to save time?
    6. \n
  6. Can I show my code to my next neighboring coder to have a quick look into the same?
    7. \n
  7. If my code involves a UI can I have a quick run-through by a BA or PM or Tester from a usability point of view?
    8. \n
\n

In the end, remember that I am the first and the most basic foundation in a big building of Quality and have to always keep the same in mind whenever I code since no one is interested in buying a well-packaged product if its ingredients are not of high quality.

\n

By doing the above I am not only contributing to high-quality software but I can devote later high bug-fixing time to things like improving the performance/security of my code and avoiding going back to the drawing board for issues related to performance or security etc.

\n

Always remember in the software development unit testing serves as \"A stitch in time saves nine\".

\n","frontmatter":{"date":"September 29, 2020","updated_date":null,"description":"Unit testing is one of the types of software testing that requires an initial phase of testing. Find out the benefits and why its important for developers.","title":"Unit Testing: What is it and why do you need it?","tags":["Unit Testing","QA","Testing"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/6327467722c4e2f8951e626f58fbf29f/58556/unit-testing.webp","srcSet":"/static/6327467722c4e2f8951e626f58fbf29f/61e93/unit-testing.webp 200w,\n/static/6327467722c4e2f8951e626f58fbf29f/1f5c5/unit-testing.webp 400w,\n/static/6327467722c4e2f8951e626f58fbf29f/58556/unit-testing.webp 800w,\n/static/6327467722c4e2f8951e626f58fbf29f/99238/unit-testing.webp 1200w,\n/static/6327467722c4e2f8951e626f58fbf29f/7c22d/unit-testing.webp 1600w,\n/static/6327467722c4e2f8951e626f58fbf29f/f8fd9/unit-testing.webp 5472w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Sudhanshu Pandey","github":null,"avatar":null}}}}]},"markdownRemark":{"excerpt":"Identity is evolving, and developers are at the forefront of this transformation. Every day brings a new learning—adapting to new standards…","fields":{"slug":"/identity/developer-first-identity-provider-loginradius/"},"html":"

Identity is evolving, and developers are at the forefront of this transformation. Every day brings a new learning—adapting to new standards and refining approaches to building secure, seamless experiences.

\n

We’re here to support developers on that journey. We know how important simplicity, efficiency, and well-structured documentation are when working with identity and access management solutions. That’s why we’ve redesigned the LoginRadius website—to be faster, more intuitive, and developer-first in every way.

\n

The goal? Having them spend less time searching and more time building.

\n

What’s New and Improved on the LoginRadius Website?

\n

LoginRadius’ vision is to give developers a product that simplifies identity management so they can focus on building, deploying, and scaling their applications. To enhance this experience, we’ve spent the last few months redesigning our interface— making navigation more intuitive and reassuring that essential resources are easily accessible.

\n

Here’s a closer look at what’s new and why it’s important:

\n

A Developer-Friendly Dark Theme

\n

\"This

\n

Developers spend long hours working in dark-themed IDEs and terminals, so we’ve designed the LoginRadius experience to be developer-friendly and align with that preference.

\n

The new dark mode reduces eye strain, enhances readability, and provides a seamless transition between a coding environment and our platform. Our new design features a clean, modern aesthetic with a consistent color scheme and Barlow typography, ensuring better readability. High-quality graphics and icons are thoughtfully placed to enhance the content without adding visual clutter.

\n

So, whether you’re navigating our API docs or configuring authentication into your system, our improved interface will make those extended development hours more comfortable and efficient.

\n

Clear Categorization for LoginRadius Capabilities

\n

\"This

\n

We’ve restructured our website to provide a straightforward breakdown of our customer identity and access management platform capabilities, helping you quickly find what you need:

\n\n

This structured layout ensures you can quickly understand each capability and how it integrates into your identity ecosystem.

\n

Developer-First Navigation

\n

\"This

\n

We’ve been analyzing developer workflows to identify how you access key resources. That’s why we redesigned our navigation with one goal in mind: to reduce clicks and make essential resources readily available.

\n

The new LoginRadius structure puts APIs, SDKs, and integration guides right at the menu bar under the Developers dropdown so you can get started faster. Our Products, Solutions, and Customer Services are also clearly categorized, helping development teams quickly find the right tools and make informed decisions.

\n

Quick Understanding of Integration Benefits

\n

\"This

\n

Developers now have a clear view of the tech stack available with LoginRadius, designed to support diverse business needs.

\n

Our platform offers pre-built SDKs for Node.js, Python, Java, and more, making CIAM integration seamless across popular programming languages and frameworks.

\n

Over to You Now!

\n

Check out our revamped LoginRadius website and see how the improved experience makes it easier to build, scale, and secure your applications.

\n

Do not forget to explore the improved navigation and API documentation, and get started with our free trial today. We’re excited to see what you’ll build with LoginRadius!

\n","frontmatter":{"date":"February 21, 2025","updated_date":null,"description":"LoginRadius’ vision is to give developers a product that simplifies identity management so they can focus on building, deploying, and scaling their applications. To enhance this experience, we’ve redesigned our website interface, making navigation more intuitive and reassuring that essential resources are easily accessible.","title":"Revamped & Ready: Introducing the New Developer-First LoginRadius Website","tags":["Developer tools","API","Identity Management","User Authentication"],"pinned":true,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7857142857142858,"src":"/static/80b4e4fbe176a10a327d273504607f32/58556/hero-section.webp","srcSet":"/static/80b4e4fbe176a10a327d273504607f32/61e93/hero-section.webp 200w,\n/static/80b4e4fbe176a10a327d273504607f32/1f5c5/hero-section.webp 400w,\n/static/80b4e4fbe176a10a327d273504607f32/58556/hero-section.webp 800w,\n/static/80b4e4fbe176a10a327d273504607f32/99238/hero-section.webp 1200w,\n/static/80b4e4fbe176a10a327d273504607f32/7c22d/hero-section.webp 1600w,\n/static/80b4e4fbe176a10a327d273504607f32/1258b/hero-section.webp 2732w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Rakesh Soni","github":"oyesoni","avatar":"rakesh-soni.webp"}}}},"pageContext":{"limit":6,"skip":720,"currentPage":121,"type":"///","numPages":164,"pinned":"ee8a4479-3471-53b1-bf62-d0d8dc3faaeb"}},"staticQueryHashes":["1171199041","1384082988","2100481360","23180105","528864852"]}