DEV Community: Sharad Aade

Const vs Readonly in C#

Sharad Aade — Mon, 01 Dec 2025 09:35:11 +0000

const vs readonly

Const

** Const is compiled time constant**
Declaration and initialization at the same time
Can not be changed public const int cmToMeter = 100;

Readonnly

Readonly is runtime constant
Decalaration and initialization not mandatory in same time we can intialise later on
We can change the value

public static readonly double PI = 3.1; public static readonly double PI; PI = 3.14

🖼️ Mastering Image Tags in HTML (With Semantics)

Sharad Aade — Sat, 13 Sep 2025 05:35:17 +0000

🖼️ Mastering Image Tags in HTML (With Semantics)

Images make our websites engaging, but to make them accessible and meaningful, we need to use the right semantic HTML tags. Let’s break it down step by step.

🔹 1. The Basic `<img>` Tag

The simplest way to add an image:

<img src="sunset.jpg" alt="Sunset over the mountains">

src → file path of the image
alt → alternative text (important for accessibility & SEO)

🔹 2. Grouping Images With `<figure>`

Use <figure> when an image is self-contained and part of the content.

<figure>
  <img src="sunset.jpg" alt="Sunset over the mountains">
</figure>

👉 This tells the browser and screen readers: “This image is an independent piece of content.”

🔹 3. Adding Captions With `<figcaption>`

Captions explain the image. Place <figcaption> inside <figure>.

<figure>
  <img src="sunset.jpg" alt="Sunset over the mountains">
  <figcaption>A beautiful sunset view in the Himalayas.</figcaption>
</figure>

🔹 4. Responsive Images With `<picture>`

Sometimes, you want different images for mobile and desktop.

<figure>
  <picture>
    <source media="(min-width: 800px)" srcset="sunset-large.jpg">
    <source media="(min-width: 400px)" srcset="sunset-medium.jpg">
    <img src="sunset-small.jpg" alt="Sunset over the mountains">
  </picture>
  <figcaption>Sunset — shown in different sizes depending on screen.</figcaption>
</figure>

🔹 5. Clickable Areas With `usemap`

The usemap attribute allows you to define hotspots in an image that link to different places.

<figure>
  <img src="world-map.jpg" alt="World Map" usemap="#worldmap">

  <map name="worldmap">
    <!-- Rectangular area -->
    <area shape="rect" coords="50,50,200,150" href="https://en.wikipedia.org/wiki/India" alt="India">

    <!-- Circular area -->
    <area shape="circle" coords="400,200,50" href="https://en.wikipedia.org/wiki/Australia" alt="Australia">

    <!-- Polygonal area -->
    <area shape="poly" coords="600,100,650,150,700,120" href="https://en.wikipedia.org/wiki/Japan" alt="Japan">
  </map>

  <figcaption>Clickable world map — each area links to a different country.</figcaption>
</figure>

usemap="#id" → connects <img> to a <map>
<area> → defines clickable shapes (rect, circle, poly)
coords → pixel coordinates for the shape
alt → accessibility label

👉 This is useful for diagrams, maps, product images, etc.

🎯 Final Semantic Example

<article>
  <h2>Travel to the Himalayas</h2>
  <figure>
    <picture>
      <source srcset="himalaya.avif" type="image/avif">
      <source srcset="himalaya.webp" type="image/webp">
      <img src="himalaya.jpg" alt="Snow-covered Himalayan peaks" usemap="#himalaya-map">
    </picture>

    <map name="himalaya-map">
      <area shape="circle" coords="250,200,50" href="everest.html" alt="Mount Everest">
    </map>

    <figcaption>The Himalayan range with a clickable area linking to Everest.</figcaption>
  </figure>
</article>

✅ Best Practices

Always add alt text
Use <figure> + <figcaption> for meaning
Use <picture> for responsive images
Use usemap for interactive clickable regions
Test clickable areas on different screen sizes

🔥 HTML Refresher Series – Part 1: Getting Started with HTML

Sharad Aade — Thu, 11 Sep 2025 18:45:59 +0000

HTML is the foundation of every website.

In this series, we’ll go from basics → in-depth → best practices with code snippets and mini projects.

Let’s start with Part 1: Getting Started with HTML 🚀

📌 What is HTML?

HTML (HyperText Markup Language) is the skeleton of a webpage.

It tells the browser what content is on the page (text, images, links, forms).

CSS handles styling, and JavaScript handles interactivity.

Think of HTML as the structure of a house, CSS as the paint & design, and JavaScript as the electricity & movement.

📌 The Basic Structure

Every HTML document follows a common structure:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Hello World</title>
</head>
<body>
  <h1>Welcome to HTML!</h1>
  <p>This is my first web page.</p>
</body>
</html>

👉 Let’s break it down:

<!DOCTYPE html> → tells the browser this is an HTML5 document.
<html> → wraps everything on the page.
<head> → contains metadata (title, description, CSS/JS links).
<body> → contains visible content.

📌 Headings & Paragraphs

Headings define content hierarchy.

<h1>Main Title</h1>
<h2>Subtitle</h2>
<h3>Smaller Heading</h3>
<p>This is a paragraph of text.</p>

Text Formatting:

<p>I love <strong>coding</strong> and <em>coffee</em>.</p>
<p>This is <mark>important</mark> text.</p>

<strong> → bold + importance
<em> → italics + emphasis
<mark> → highlighted text

📌 Links:

<a href="https://dev.to" target="_blank">Visit Dev.to</a>

href → destination URL
target="_blank" → opens in new tab

📌 Images:

<img src="cat.jpg" alt="Cute cat smiling">

src → path of image
alt → description (important for accessibility & SEO)

📌 Mini Project: “Hello World” Page:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Hello World</title>
</head>
<body>
  <h1>Hello, World!</h1>
  <h2>About Me</h2>
  <p>My name is Sharad and I love <strong>coding</strong> + <em>coffee</em>.</p>

  <h2>Find Me Online</h2>
  <p>
    <a href="https://dev.to" target="_blank">Follow me on Dev.to</a>
  </p>

  <h2>My Cat</h2>
  <img src="cat.jpg" alt="A cute cat sitting on the sofa">
</body>
</html>

SwaggerUI setup ASP.NET Core Web API

Sharad Aade — Thu, 07 Aug 2025 03:45:36 +0000

1) Select the ASP.NET Core Web API project template

2) Enable OpenAPI support

3) Install Swashbuckle.AspNetCore.SwaggerUI package from NuGet Package Manager

4) In the Properties > launchsettings.json file, enable and add
"launchBrowser": true, "launchUrl": "swagger",

5) Configure in the program.cs
app.UseSwaggerUI(options => { options.SwaggerEndpoint("/openapi/v1.json", "api"); });

6) That's all, run the project.

Thank you! (This is not a step you need to follow.)

Inheritance in C#

Sharad Aade — Thu, 24 Jul 2025 17:54:25 +0000

Inheritance

It is a way to pass the properties and functionality of the parent to the child is called as inheritance.

It helps us achieve code re-usability.

NOTE:- Without a constructor, we can not achieve inheritance because with the help of the parent instance, we can access the parent properties and functionalities.
If you do not provide an explicitly constructor, then the compiler provides an implicitly.

Types of inheritance-

Single
Multi-level
Hierarchical
Hybrid
Multiple(We can achieve with Interface in C#)

1. Single

In this inheritance, one parent class has only one child class.

2. Multi-level

In this inheritance, the chaining of the parent and child classes occurs.

3. Hierarchical

In this inheritance, one parent class has two or more child classes.
(Simply, Multiple derived classes inherit from a single base class.)

4. Hybrid

This is a combination of two or more types of inheritance.

5. Multiple(We can achieve this with an Interface in C#)

C# does not support multiple inheritance of classes (a class cannot directly inherit from two or more classes). However, it achieves a form of multiple inheritance through interfaces

NOTE:- We will discuss the Interface in another post.
Link:- Coming soon... or check my profile.

Access specifiers/modifiers in C#

Sharad Aade — Tue, 22 Jul 2025 15:31:06 +0000

Access specifiers define the visibility and accessibility of classes, methods, properties, fields, and other members within a program or project.
They control where members can be accessed.

public
Accessible from anywhere within the same assembly or another assembly.
private
Accessible only within the same class.
Note:- Default access modifiers for class members.
protected
Accessible within the same class and derived classes(means inherited classes)
internal
Accessible only within the assembly (project) but not outside the assembly or project.
Note:- Default for classes and structures(structs).
protected internal
Accessible within the same assembly/project, like internalor in a derived class in another assembly/project, like protected

Static vs Non-Static Constructor in C#

Sharad Aade — Wed, 16 Jul 2025 19:22:06 +0000

NOTE:- Constructors do not have a return type, even void.

Why do we need a constructor?
Ans: - To initialise the memory of a variable or field.

Every non-static class contains an implicit constructor if not defined explicitly.
If we define an explicit constructor with static modifiers, it is referred to as a static constructor, whereas others are non-static constructors.
Non-static constructors may be implicitly or explicitly provided.
If you do not provide an explicit one, then the compiler provides an implicit constructor.
Static field/variable initialised by static constructor.
Static constructors are implicitly called, but non-static constructors are explicitly called.
Static constructor executes immediately once the execution of the class starts.
Static constructor executes only once, but non-static constructor executes zero times if no instance is created and n times if n instance is created.
Non-static constructors may be parameterised, but static constructors are parameterless because they are implicitly called and it is the first block of code run under the class.
Non-static constructors may be overloaded, but a static constructor can not be overloaded.

✍️Thank you!✍️

Types of constructors in C#

Sharad Aade — Mon, 07 Jul 2025 08:47:32 +0000

There are four types of constructors -

Default constructor
Parameterised constructor
Copy constructor
Static constructor

1. Default constructor -
The constructor, which is created by the compiler, is called the default constructor.
It is always a parameterless constructor.

// Default constructor
using System;

class CallOfCode
{
    //Initialise with default value
    int num = 0;

    public CallOfCode()
    {
        Console.WriteLine("Constructor Called");
    }

    public static void Main()
    {
        // Invoke default constructor
        Geeks geek1 = new Geeks();
    }
}

2. Parameterised constructor -
The constructor that takes one or more parameters is called a parameterised constructor.

It is created by a programmer, NOT provided by the compiler.

// Parameterized Constructor
using System;
class CallOfCode {
    // store name value
    String n;

    // store Id
    int i;

    CallOfCode(String n, int i)
    {
        this.n = n;
        this.i = i;
    }

    public static void Main()
    {
        // It will invoke parameterised
        CallOfCode o = new CallOfCode("COC", 11);
        Console.WriteLine("Name = " + o.n + " Id = " + o.i);
    }
}

3. Copy constructor -
The copy constructor is a special type of constructor in C# that is used to create a new object by copying the contents of an existing object of the same class. It takes an object of the same class as its parameter and initialises the new object with the values of the existing object.

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    // Copy constructor
    public Person(Person other)
    {
        Name = other.Name;
        Age = other.Age;
    }
}

// Usage
Person person1 = new Person("John", 30);
Person person2 = new Person(person1); // Calls the copy constructor

4. Static constructor -
A static constructor is a special type of constructor in C# that is used to initialize static fields of a class. Static fields are variables that belong to the class itself.

It is executed before the Main() method.

A static constructor is called automatically by the runtime when the class is initialized. This means that it is called only once, when the class is first loaded into memory.

A static constructor can initialize static fields with default values or perform any necessary setup or initialization of static fields.

We would use a static constructor when we need to initialize static fields with default values.

namespace Program
{
    internal class StaticConstructor
    {
        //Static Constructor
        static StaticConstructor()
        {
            Console.WriteLine("Static constructor called");
        }
        static void Main(string[] args)
        {
            Console.WriteLine("Main method is called");
        }
    }
}

Output -

.NET C#

Sharad Aade — Sun, 06 Jul 2025 10:22:02 +0000

Sharad Aade

Jul 6 '25

Constructor in C#🟪

#dotnet #csharp #programming #dotnetcore

Comments

1 min read

Constructor in C#🟪

Sharad Aade — Sun, 06 Jul 2025 10:21:01 +0000

*A constructor is a method in a class named similarly to the class.
which is executed when we create an instance of the class.
*

NOTE -

No return type (not even void)
It doesn't return anything.
This makes it different from other methods.
To initialize class fields(variables) or properties when an object is created means assigning a value to the variables.

Points -

1. Automatically invoked or called when we use the 'new' keyword.

Student s = new Student();

1. You can have multiple constructors in a class with different parameters(Constructor Overloading).
1. A constructor with no parameters is called the default constructor
1. If we not create a manually constructor, then the compiler provides/initialize implicit constructor.

Hello World in C#

Sharad Aade — Sat, 28 Jun 2025 16:26:41 +0000

using System;

namespace FirstProgram
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World");
        }
    }
}

The System namespace contains fundamental classes and base classes that define commonly used types, events, interfaces, and more.

Namespace => A namespace is a way to organise classes, structs, interfaces, enums, and delegates to avoid naming conflicts and improve code readability.

It acts like a container that helps distinguish between classes with the same name (e.g., if two libraries define an Animal class, namespaces prevent confusion).

Main => The Main method is the entry point of the program.

Console is a class that has a WriteLine() method.

DEV Community: Sharad Aade

Const vs Readonly in C#

const vs readonly

Const

Readonnly

🖼️ Mastering Image Tags in HTML (With Semantics)

🖼️ Mastering Image Tags in HTML (With Semantics)

🔹 1. The Basic <img> Tag

🔹 2. Grouping Images With <figure>

🔹 3. Adding Captions With <figcaption>

🔹 4. Responsive Images With <picture>

🔹 5. Clickable Areas With usemap

🎯 Final Semantic Example

✅ Best Practices

🔥 HTML Refresher Series – Part 1: Getting Started with HTML

SwaggerUI setup ASP.NET Core Web API

Inheritance in C#

Inheritance

1. Single

2. Multi-level

3. Hierarchical

4. Hybrid

5. Multiple(We can achieve this with an Interface in C#)

Access specifiers/modifiers in C#

Static vs Non-Static Constructor in C#

Types of constructors in C#

.NET C#

Constructor in C#🟪

Constructor in C#🟪

Hello World in C#

🔹 1. The Basic `<img>` Tag

🔹 2. Grouping Images With `<figure>`

🔹 3. Adding Captions With `<figcaption>`

🔹 4. Responsive Images With `<picture>`

🔹 5. Clickable Areas With `usemap`