C# Hashtable with example – How to use and when to use?

In this blog post, we will take a deep dive into C# hashtables, explaining what they are, how they work, and how to use them effectively in our C# code.

We will also cover some common scenarios where hashtables can be particularly useful, as well as some tips and best practices for working with them. By the end of this post, you should have a solid understanding of hashtables and how to leverage their power in your C# projects.



Understanding C# Queue Class With Examples

C# Queue is a linear data structure that follows the First-In-First-Out (FIFO) principle. In other words, the first element added to the queue will be the first one to be removed. This makes queues useful for storing data that needs to be processed in a specific order. The queue is the opposite of the Stack<T> collection.

In C#, the Queue class is a generic collection that implements the IEnumerable interface and provides a variety of methods for adding, accessing, and removing elements in the queue.

C# Queue


C# Polymorphism: Different types of polymorphism in C# with examples

Polymorphism is a Greek word that means “many-shaped” or multiple forms of an object. You can use polymorphism in case you want to have multiple forms of one or more methods of a class with the same name.

Polymorphism is one of the main key concepts of object-oriented programming after encapsulation and inheritance.

In this article, we are going to learn about the different types of polymorphism in C#, how they work, how to implement them, and how to use polymorphism in our program code.

Types of polymorphism in C#


Params Keyword in C# With Examples

The params keyword in C# is used to specify a method parameter that can take a variable number of arguments. Generally, params work as a single-dimensional array of objects.

C# params are useful when you declare a method and don’t know how many arguments will be passed as parameters.

Params keyword in CSharp


C# Stack Class With Push And Pop Examples

Stack in C# represents a last-in, first-out (LIFO) collection of objects. It is useful when you need last-in, first-out access to elements. Adding an element to the stack is called a push operation, and removing an element from the stack is called a pop operation.

A Stack is a collection that can be both generic and non-generic. The generic stack is defined in the System.Collections.Generic namespace. A non-generic stack, on the other hand, is defined under System.Collections namespace. In this post, we will discuss a non-generic type stack.

C# Stack with Push and Pop Examples
C# Stack with Push and Pop operation


C# Tuple: How to work with a Tuple in C#?

A tuple in C# is a data structure that allows us to store elements of different data types. It was first introduced with .NET Framework 4.0 and allowed a maximum of 8 elements to be stored. Any attempt to store more than eight elements will result in a compiler error.


Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>
C# Tuple
C# Tuple


What Is Node.js and Why Should You Use It?

What Is Node.js?

Node.js is an open-source, cross-platform runtime environment and library for executing JavaScript code outside of a browser. It uses an event-driven, asynchronous, non-blocking I/O architecture, making it lightweight and efficient for data-intensive real-time applications running across distributed devices.

Node.js is neither a framework nor a programming language but a runtime environment. It was written and introduced by Ryan Dahl in 2009.
Node.js was built on top of chrome V8 JavaScript Engine that is written in C++ language. All the JavaScript code is executed by the V8 JavaScript engine; which converts the code into Assembly code, which is then converted into machine code. Machine code is something that a computer processor understands.

what is node js


C# Dynamic Type: Var vs dynamic keywords in C#

The dynamic keyword is used to define dynamic types. Dynamic type is used to avoid compile-time type checking. The compiler does not type-check dynamic type variables at compile time, instead, the compiler check the type at the run time. If the syntax of the statement is invalid, an error will be thrown at runtime.

Dynamic types are similar to object types, despite the fact that type checking for object type variables occurs at compile time rather than at runtime for dynamic type variables.

csharp dynamic type
C# dynamic type