DEV Community: Jason Archer

A Beginners Guide to GraphQL Dotnet CancellationToken

Jason Archer — Fri, 14 Oct 2022 15:26:16 +0000

In the early 2000s, the REST API gained much fame in the technology sector due to its multipurpose functionality and responsiveness. However, despite the increased usage, the developer community encountered an issue of over-fetching data points. The data holds core importance in any web or mobile application. Apart from it, the excessive retrieval of data can slow the process and may further lead to an unresponsive server as well.

In order to tackle the growing concern, the Graph Query Language was developed by Facebook to make its app more responsive and reliable. GraphQL is an API standard, particularly an alternative to REST APIs. Unlike the traditional REST API, this solution grants the control to the client to directly request the specified data rather than irrelevant data.

The goal of GraphQL is to make APIs quick, adaptable, and developer-friendly. In contrast to REST, GraphQL APIs allow data to be retrieved and delivered from different sources while accepting all incoming requests at a single endpoint.

- GraphQL Dotnet
GraphQL is not only bounded to specific backend languages but can also be used to develop projects in Dotnet. There are numerous platforms and languages in the GraphQL ecosystem. Despite the fact that .NET was slow to implement support, several widely used client and server solutions are available now.

A basic example of GraphQL.NET using the System.Text.Json serialization engine.

using System;
using System.Threading.Tasks;
using GraphQL;
using GraphQL.Types;
using GraphQL.SystemTextJson;
public class Program
{
    public static async Task Main(string[] args)
    {
        var schema = Schema.For(@"
            type Query {
                hello: String
            }
        ");
        var json = await schema.ExecuteAsync(_ =>
        {
            _.Query = "{ hello }";
            _.Root = new { Hello = "Hello World!" };
        });
        Console.WriteLine(json);
    }
}

Output:

{
   "data":{
      "hello":"Hello World!"
   }
}

- Defining Schema in GraphQL
As GraphQL is a structured Graph Query Language, it must have its schema defined. In order to design its schema, two approaches can be utilized:

- Schema First Approach (Using GraphQL)
This approach is believed to be the simplest one to get started with, and it has limitations for advanced implementations and scenarios. This methodology’s practical procedure lies upon the GraphQL schema language and syntaxes, resulting in a minimal syntax approach.

- GraphType (Code First Approach)
Although the GraphType technique can be more expansive and has a higher Line of Code (LOC). Furthermore, GraphType implementation allows the developers access to every property that GraphType and Schema provide. To use this methodology, Object Oriented Programming (OOP) paradigm is opted for, and Inheritance is used to leverage this functionality.

- CancellationToken in Dotnet
In a web-based application, the request from the client and the reposne from the server sides are standard ways of communication between stakeholders. However, such scenarios exist too, where a client-server interaction is interrupted, and the client-side becomes unresponsive.

Once a user gets disconnected due to a network interruption, navigating between multiple browser tabs, or closing the browser, the request becomes an orphan. Whereas an orphan request cannot deliver a response to the client, it will still communicate with the server, resulting in a recursive process and further leading to excessive memory usage by the particular process.

To prevent a process from making irregular and consistent calls to the server side, the CancellationToken is used. It terminates the request execution at the server immediately.

Canceling tasks in Dotnet/C# is not tricky. However, there are several ways to do so. The three commonly used methods include:

Polling
Registering a Callback
Wait Handle

Additionally, multiple tokens can be canceled at once as the polling strategy is designed for situations where there are lengthy computations that loop or recurse.

The typical procedure followed when canceling a task using CancellationToken:

Instantiate a CancellationTokenSource object. This object manages and sends the cancellation notification to the individual cancellation tokens.
Passing the token returned by the CancellationTokenSource. Token property to each task or thread that listens for cancellation.
Providing a mechanism for the thread to respond to cancellation. The token cannot be used to initiate a cancellation
Calling the CancellationTokenSource.
When the owning object calls CancellationTokenSource.Cancel, the IsCancellationRequested property on every copy of the cancellation token is set.
Canceling method to provide notification of cancellation.

- GraphQL Dotnet CancellationToken
When GraphQL.NET is used, the query fetches results, and the conditions exist where the proper process synchronization needs to be done by canceling excessive tasks at once. The CancellationToken may be used to prevent an application failure or unresponsive behavior as cooperative cancellation between threads or Task objects is made possible through a CancellationToken.

- ClearInsights Application Logging & Monitoring
To prevent your application from failing at runtime or crashing, use ClearInsights application performance and uptime monitoring for your deployed systems. Furthermore, with our extensive integrated monitoring for applications & services in any environment, you can keep developers, product teams, and stakeholders informed.

The Best Practices for Exception Handling in C#

Jason Archer — Sat, 24 Sep 2022 04:17:25 +0000

No matter how efficient your software application runs, one exception due to bad code can crash the application and make it unavailable for even millions of users. That is simply why exception handling is a critical requirement for any code. This article explains the best practices you should follow when handling exceptions in C#.

What is Exception Handling?

An exception is an error that occurs during the execution of a program that disrupts its normal control flow or execution. Examples include invalid user input, unavailable resources like files and folders, and trying to access elements of arrays in a non-existent index. Exception handling is handling possible error conditions to allow the program to continue without disruption.

What are the best practices for exception handling in C#?

C# provides several ways to handle exceptions like try-catch-blocks, multiple try-catch-blocks, and user-defined custom exceptions. Here are some best practices you should follow for you to build a well-designed application.

1. If you can handle the error, do not throw exceptions

There can be error conditions that are very common or likely to occur in many applications. For example, suppose you have a division operation in your code. The 'divide by zero' is a common exception for such operations.

int num1 = 100;
int num2  = 0;

try {
   Console.WriteLine(num1 / num2);
}
catch (DivideByZeroException) {
   Console.WriteLine("Divide by zero exception occured .");
}

But, you do not have to throw exceptions for such common errors in the first place. Simply check if the numbers contain 0 so you can set it to a non-zero default value.

int num1 = 100;
int num2 = 0;

if (num2 == 0) {
    num2 = 1; //setting a default value
}

Another example is the "NullReferenceException," which can occur if an object or a variable becomes null. Instead of throwing an exception, check if the object or variable is null before doing any operation. Here is how you can do it in C#,

User user = null;

var name = user?.Name;

Appending the '?' symbol C# automatically checks that the object is null.

2. Logging exceptions

Logging is very important in exception handling with any programming language. As a best practice, ensure you log the exception object without just logging an error message. The exception object has a lot of information, including stack trace and exception type, which are crucial to troubleshooting the issue. Also, do not forget to provide a meaningful and grammatically correct error message for you to make the troubleshooting hassle-free

try {
   //divide by zero
}
catch (DivideByZeroException exception)
{ 
   Logger.LogError(exception, "Divide By Zero Exception");
}

Using ClearInsights Exception Handling is an easy way to log exceptions and automatically push the exception into your backlog to work on. Email notifications will also be sent out to team members based on configured settings. Create a free ClearInsights account to try.

Integrate ClearInsights Logging with the code below

builder.Logging.AddClearInsightsLogger(configuration =>
{
    configuration.ApiKey = "{ApiKey}";
    configuration.Secret = "{Environment Client Secret}";
    configuration.ApplicationName = "{Application Name}";
});

However, you do not need to log every exception manually like this. You can make logging even more informative and advanced if you have an automated way to log exceptions. Logging tools help you to achieve that. ClearInsights centralized logging, for example, is a simple but intuitive logging tool that you can integrate into your application for automatic logging.

Using this tool, you can record not only the exception message but also other information like the product, environment, source, and stack trace of each log. You can also get logging reports to see an overview of the different log types like Critical, error, warning, informational, and trace that provide different levels of logs. Another best thing about using this tool is you can filter them to get insight into the exceptions that frequently occur in your system. Thus, as a best practice, ensure that you use a good logging tool that provides you with an easy application logging experience.

3. Use throw statements to preserve the stack trace

In some C# applications, developers use the "throw ex" statement instead of the " throw " statement in exceptions. This will not be helpful if you want to get the complete stack trace from the beginning. Because the "throw ex" statement does not keep the stack traces so that it is difficult to track down where the error first occurred. But the "throw" statement does log the stack trace. Thus, do not forget to use the throw statement as follows instead of using the 'throw ex' statement in exceptions for better exception handling.

catch(Exception ex)
{
throw;
}

4. Create custom exceptions using the Exception keyword

Create custom exceptions to provide explicit exception handling for your application. Use the "Exception" keyword like in the following example when you declare one.

public class MyCustomException: Exception{}

You can define your own exception handling behavior and exceptions common across your application classes using custom exceptions. Also, it is a good practice to include three common constructors for custom exception classes, which are: Exception(), which sets the default values; exception (String) which you can pass a message; and Exception(String, Exception), for setting an inner exception. When you define the custom exception, do not forget to include logging for every exception you declare there. In addition, use additional properties to provide additional information about the exception.

5. Use already existing exceptions as much as possible

The fifth best practice of C# exception handling is using the pre-defined exceptions whenever possible in your code. This can be quite contradictive to the 4th best practice. But creating custom exceptions is best if your application code has more specific error cases. Following are some of the predefined exceptions available in C# and when they are used:

FileNotFoundException - Throws when the program cannot locate a file.
DivideByZeroException - Divide a number by Zero
ArgumentNullException - When an argument value is null
InvalidOperationException - When an operation is invalid. For example, trying to close a connection that is already closed.
ArrayIndexOutOfBoundException - When you try to access an element of an array that is at an index outside its maximum index.

Summary

From this article, you learned the following five best practices of exception handling in C#.

Handling common errors rather than throwing exceptions
Using already existing exceptions as much as possible
Using custom exceptions
Using application logging
Using throw statements

One of the most important practices is logging your exceptions to better support the troubleshooting process.

ClearInsights is the perfect logging and monitoring tool provider for C# applications. Integrate ClearInsights tools into your application and make debugging your application an easy process.