Fernando's Blog

Introduction

Mon, 08 Jun 2020 08:06:25 +0600

Greeting! This is an introduction post. This post tests the followings:

Hero image is in the same directory as the post.
This post should be at top of the sidebar.
Post author should be the same as specified in author.yaml file.

Markdown Samples

Mon, 08 Jun 2020 08:06:25 +0600

This is a sample post intended to test the followings:

A different post author.
Table of contents.
Markdown content rendering.
Math rendering.
Emoji rendering.

Markdown Syntax Rendering

Headings

The following HTML <h1>—<h6> elements represent six levels of section headings. <h1> is the highest section level while <h6> is the lowest.

H1

H2

H3

H4

H5

H6

Paragraph

Xerum, quo qui aut unt expliquam qui dolut labo. Aque venitatiusda cum, voluptionse latur sitiae dolessi aut parist aut dollo enim qui voluptate ma dolestendit peritin re plis aut quas inctum laceat est volestemque commosa as cus endigna tectur, offic to cor sequas etum rerum idem sintibus eiur? Quianimin porecus evelectur, cum que nis nust voloribus ratem aut omnimi, sitatur? Quiatem. Nam, omnis sum am facea corem alique molestrunt et eos evelece arcillit ut aut eos eos nus, sin conecerem erum fuga. Ri oditatquam, ad quibus unda veliamenimin cusam et facea ipsamus es exerum sitate dolores editium rerore eost, temped molorro ratiae volorro te reribus dolorer sperchicium faceata tiustia prat.

Rich Content

Mon, 08 Jun 2020 08:06:25 +0600

This sample post tests the followings:

Category, sub-category nesting in the sidebar.
Hero image and other images are in images folder inside this post directory.
Different media rendering like image, tweet, YouTube video, Vimeo video etc.

Image Sample

Tweet Sample

Owl bet you'll lose this staring contest 🦉 pic.twitter.com/eJh4f2zncC
— San Diego Zoo Wildlife Alliance (@sandiegozoo) October 26, 2021

YouTube Video Sample

Vimeo Video Sample

Shortcodes Samples

Mon, 08 Jun 2020 08:06:25 +0600

This is a sample post intended to test the followings:

Default hero image.
Different shortcodes.

Alert

The following alerts are available in this theme.

This is sample alert with type="success".

This is sample alert with type="danger".

This is sample alert with type="warning".

This is sample alert with type="info".

This is sample alert with type="dark".

This is sample alert with type="primary".

This is sample alert with type="secondary".

Image

A sample image without any attribute.

A sample image with `height` and `width` attributes.

A center aligned image with `height` and `width` attributes.

A image with `float` attribute.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras egestas lectus sed leo ultricies ultricies. Praesent tellus risus, eleifend vel efficitur ac, venenatis sit amet sem. Ut ut egestas erat. Fusce ut leo turpis. Morbi consectetur sed lacus vitae vehicula. Cras gravida turpis id eleifend volutpat. Suspendisse nec ipsum eu erat finibus dictum. Morbi volutpat nulla purus, vel maximus ex molestie id. Nullam posuere est urna, at fringilla eros venenatis quis.

Resultados de Búsqueda

Tue, 08 Jun 2010 08:06:25 +0600

Este archivo existe únicamente para responder a la URL /search con la plantilla de diseño search relacionada.

No se muestra ningún contenido aquí, todo el contenido se basa en la plantilla layouts/page/search.html

Establecer una prioridad muy baja en el mapa del sitio le dirá a los motores de búsqueda que éste no es un contenido importante.

Esta implementación utiliza Fusejs, jquery y mark.js

Configuración inicial

La búsqueda depende del tipo de contenido de salida adicional de JSON en config.toml

Resultados de Búsqueda

Tue, 08 Jun 2010 08:06:25 +0600

Este archivo existe únicamente para responder a la URL /search con la plantilla de diseño search relacionada.

No se muestra ningún contenido aquí, todo el contenido se basa en la plantilla layouts/page/search.html

Establecer una prioridad muy baja en el mapa del sitio le dirá a los motores de búsqueda que éste no es un contenido importante.

Esta implementación utiliza Fusejs, jquery y mark.js

Configuración inicial

La búsqueda depende del tipo de contenido de salida adicional de JSON en config.toml

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Search Results

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Suchergebnisse

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

অনুসন্ধানের ফলাফল

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

অনুসন্ধানের ফলাফল

Tue, 08 Jun 2010 08:06:25 +0600

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Roadmap

Mon, 01 Jan 0001 00:00:00 +0000

(1) CSharp Fundamentals

Topics

Variables and data types
Control structures: if, switch, for, while
Methods and functions
Data Formatting
String Methods
Classes and objects
Abstract classes
Records
Interfaces
Generic
Anonymous Types

Resources:

C# Basics - Microsoft Learn
Free course: C# Programming for Beginners (FreeCodeCamp)

(2) CSharp Advanced

Topics

List Collections
Arrays
Language Integrated Query (LINQ)
Delegates and events
Custom exceptions
Nullable reference types

Resources

C# Tutorials - List Collections - Microsoft Learn

Paper “Design Principles and Design Patterns” by Robert C. Martin
Book: “Design Patterns in C#” by Vaskaran Sarcar
Design Patterns in C# – Refactoring.guru
C# Clean Code: SOLID Principles – Dev.to
Object-oriented programming
Apress/design-patterns-csharp-2e – Github.com

(3) Dotnet and ASP Dotnet Core

Topics

Lifecycle of a .NET application
Project structure (Program.cs, Startup.cs, or builder)
Routing and controllers (Controller, Route, HttpGet/Post/etc.)
Dependency Injection
Middleware

Resources

Microsoft Learn: ASP.NET Core
Spanish course: Complete ASP.NET Core MVC Course (YouTube - Luis Beltrán)

Core –>

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Getting Started

What’s CSharp?

C# is a high-level, general-purpose programming language developed by Microsoft as part of the .NET framework. It’s an object-oriented language, meaning it uses objects to structure code and data, and is used to build a variety of applications. C# is known for its ease of learning, strong community support, and ability to produce highly performant code.

.NET SDK Instalation

The easiest way to have the .NET SDK installed in your personal computer is to download Visual Studio. You can also use other IDE, but you will need to install the SDK manually.

Data Types

Mon, 01 Jan 0001 00:00:00 +0000

Data Types

There are two different data types in C#:

Value Types: Directly store the data. Once you assign a value, it holds that data
- int, char, float are just a few examples.
Reference Types: Store a memory address. They point to the address of the value.
- string, class, array are commonly used.

Integer

Math operations:

int sum = 7 + 5;
int difference = 7 - 5;
int product = 7 * 5;
int quotient = 7 / 5;
int modulus = 7 % 5;

Console.WriteLine("Sum: " + sum); // Sum: 12
Console.WriteLine("Difference: " + difference); // Difference: 2
Console.WriteLine("Product: " + product); // Product: 35
Console.WriteLine("Quotient: " + quotient); // Quotient: 1
Console.WriteLine($"Modulus: {7 % 5}"); // Modulus: 2

Order of operations

Methods

Mon, 01 Jan 0001 00:00:00 +0000

Methods

No params:

Console.WriteLine("Generating random numbers:");
DisplayRandomNumbers(); // 17 29 46 36 3 

void DisplayRandomNumbers()
{
 Random random = new Random();

 for (int i = 0; i < 5; i++)
 {
 Console.Write($"{random.Next(1, 100)} ");
 }

 Console.WriteLine();
}

Using parameters:

CountTo(5);

void CountTo(int max)
{
 for (int i = 0; i < max; i++)
 {
 Console.Write($"{i}, "); // 0, 1, 2, 3, 4
 }
}

Optional parameters:

Flow Control

Mon, 01 Jan 0001 00:00:00 +0000

Condition

if-else operator

string color = "black";

if (color == "black")
{
 Console.WriteLine("It's black.");
}
else if (color == "white")
{
 Console.WriteLine("It's white.");
}
else {
 Console.WriteLine("It's other color.");
}

Conditional Operator

int saleAmount = 1001;
int discount = saleAmount > 1000 ? 100 : 50;
Console.WriteLine($"Discount: {discount}");

Scope

bool flag = true;
if (flag)
{
 int value = 10;
 Console.WriteLine($"Inside the code block: {value}"); // Prints value.
}
Console.WriteLine($"Outside the code block: {value}"); // Gives error because value is declared inside the if code block.

Switch

string fruit = "apple";

switch (fruit)
{
 case "apple":
 Console.WriteLine($"App will display information for apple.");
 break;
 case "banana":
 Console.WriteLine($"App will display information for banana.");
 break;
 case "cherry":
 Console.WriteLine($"App will display information for cherry.");
 break;
 default:
 Console.WriteLine($"App will not display information about any fruit.");
 break;
}

Loop

Foreach

Data Type Conversion

Mon, 01 Jan 0001 00:00:00 +0000

Casting

Casting truncates the value.

decimal myDecimal = 3.14m;
Console.WriteLine($"decimal: {myDecimal}"); // decimal: 3.14

int myInt = (int)myDecimal;
Console.WriteLine($"int: {myInt}"); // int: 3

To String

int first = 5;
int second = 7;
string message = first.ToString() + second.ToString();
Console.WriteLine(message); // 57

Parse

string first = "5";
string second = "7";
int sum = int.Parse(first) + int.Parse(second);
Console.WriteLine(sum); // 12

Parse

string value = "102";
int result = 0;
if (int.TryParse(value, out result))
{
 Console.WriteLine($"Measurement: {result}");
}
else
{
 Console.WriteLine("Unable to report the measurement.");
}

Convert

Convert rounds the value.

Methods on Arrays

Mon, 01 Jan 0001 00:00:00 +0000

Sort

string[] pallets = [ "B14", "A11", "B12", "A13" ];

Console.WriteLine("Sorted...");
Array.Sort(pallets);
foreach (var pallet in pallets)
{
 Console.WriteLine($"-- {pallet}"); // A11, A13, B12, B14
}

Reverse

string[] pallets = [ "A11", "A13", "B12", "B14" ];

Console.WriteLine("Reversed...");
Array.Reverse(pallets);
foreach (var pallet in pallets)
{
 Console.WriteLine($"-- {pallet}"); // B14, B12, A13, A11
}

Clear

string[] pallets = [ "B14", "A11", "B12", "A13" ];
Console.WriteLine("");

Array.Clear(pallets, 0, 2);
Console.WriteLine($"Clearing 2 ... count: {pallets.Length}");
foreach (var pallet in pallets)
{
 Console.WriteLine($"-- {pallet}"); // null, null, B12, A13
}

Resize

string[] pallets = ["B14", "A11", "B12", "A13" ];
Console.WriteLine("");

Array.Resize(ref pallets, 6);
Console.WriteLine($"Resizing 6 ... count: {pallets.Length}");

pallets[4] = "C01";
pallets[5] = "C02";

foreach (var pallet in pallets)
{
 Console.WriteLine($"-- {pallet}"); // B14, A11, B12, A13, C01, C02
}

Join

char[] valueArray = ['a', 'b', 'c']
Array.Reverse(valueArray);
// string result = new string(valueArray);
string result = String.Join("|", valueArray); // a|b|c
Console.WriteLine(result);

Split

string result = "123|456|789";
string[] items = result.Split('|');
foreach (string item in items)
{
 Console.WriteLine(item); // 123, 456, 789
}

Data Formatting

Mon, 01 Jan 0001 00:00:00 +0000

Composite Formatting

string first = "Hello";
string second = "World";
string result = string.Format("{0} {1}!", first, second);
Console.WriteLine(result); // Hello World!

Formatting Currency

decimal price = 123.45m;
int discount = 50;
Console.WriteLine($"Price: {price:C} (Save {discount:C})"); // Price: $123.45 (Save $50.00)

Formatting Numbers

decimal measurement = 123456.78912m;
Console.WriteLine($"Measurement: {measurement:N} units"); // Measurement: 123,456.79 units
Console.WriteLine($"Measurement: {measurement:N4} units"); // Measurement: 123,456.7891 units

Formatting Percentage

decimal tax = .36785m;
Console.WriteLine($"Tax rate: {tax:P2}"); // Tax rate: 36.79%

Padding

string input = "Pad this";
Console.WriteLine(input.PadLeft(12)); // " Pad this"
Console.WriteLine(input.PadLeft(12, '*')); // "****Pad this"
Console.WriteLine(input.PadRight(12, '*')); // "Pad this****"

String Methods

Mon, 01 Jan 0001 00:00:00 +0000

Length

string message = "Find what is (inside the parentheses)";

Console.WriteLine(message.Length ); // 37

IndexOf

string message = "Find what is (inside the parentheses)";

int openingPosition = message.IndexOf('(');
int closingPosition = message.IndexOf(')');

Console.WriteLine(openingPosition); // 13
Console.WriteLine(closingPosition); // 36

Substring

string message = "What is the value <span>between the tags</span>?";

const string openSpan = "<span>";
const string closeSpan = "</span>";

int openingPosition = message.IndexOf(openSpan);
int closingPosition = message.IndexOf(closeSpan);

openingPosition += openSpan.Length;
int length = closingPosition - openingPosition;
Console.WriteLine(message.Substring(openingPosition, length)); // between the tags

LastIndexOf

string message = "hello there!";

int first_h = message.IndexOf('h');
int last_h = message.LastIndexOf('h');
Console.WriteLine($"For the message: '{message}', the first 'h' is at position {first_h} and the last 'h' is at position {last_h}.");
// For the message: 'hello there!', the first 'h' is at position 0 and the last 'h' is at position 7.

IndexOfAny

string message = "Hello, world!";
char[] charsToFind = { 'a', 'e', 'i' };

int index = message.IndexOfAny(charsToFind);

Console.WriteLine($"Found '{message[index]}' in '{message}' at index: {index}."); // Found 'e' in 'Hello, world!' at index: 1.

Remove

string data = "12345John Smith 5000 3 ";
string updatedData = data.Remove(5, 20);
Console.WriteLine(updatedData); // 123455000 3

Replace

string message = "This--is--ex-amp-le--da-ta";
message = message.Replace("--", " ");
message = message.Replace("-", "");
Console.WriteLine(message); // This is example data

Trim

string greeting = " Hello World! ";
Console.WriteLine($"[{greeting}]"); // " Hello World! "

string trimmedGreeting = greeting.TrimStart();
Console.WriteLine($"[{trimmedGreeting}]"); // "Hello World! "

trimmedGreeting = greeting.TrimEnd();
Console.WriteLine($"[{trimmedGreeting}]"); // " Hello World!"

trimmedGreeting = greeting.Trim();
Console.WriteLine($"[{trimmedGreeting}]"); // "Hello World!"

Case

string songLyrics = "You say goodbye, and I say hello";
Console.WriteLine(songLyrics.ToUpper()); // YOU SAY GOODBYE, AND I SAY HELLO
Console.WriteLine(songLyrics.ToLower()); // you say goodbay, and i say hello

Contains

string songLyrics = "You say goodbye, and I say hello";
Console.WriteLine(songLyrics.Contains("goodbye")); // True
Console.WriteLine(songLyrics.Contains("greetings")); // False

StartsWith and EndsWith

string message = "You say goodbye, and I say hello";
Console.WriteLine(message.StartsWith("You")); // true
Console.WriteLine(message.EndsWith("hello")); // true

Classes

Mon, 01 Jan 0001 00:00:00 +0000

Declaring Classes

// A type that is defined as a class is a reference type.

//[access modifier] - [class] - [identifier]
public class Customer
{
 // Fields, properties, methods and events go here...
}

Creating Objects

Customer object1 = new Customer(); // object1 is a reference to an allocated space that will know where the object exists.
Customer object2; // Reference to null

Customer object3 = new Customer();
Customer object4 = object3; // object4 has the same reference as object3. If any of both instances changes, the other one does as well. Not recommended to do that.

Constructors and initialization

Accept default values

Abstract Classes

Mon, 01 Jan 0001 00:00:00 +0000

Example 1

abstract class Shape
{
 public abstract int GetArea();
}

class Square : Shape
{
 private int _side;

 public Square(int n) => _side = n;

 // GetArea method is required to avoid a compile-time error.
 public override int GetArea() => _side * _side;

 static void Main()
 {
 var sq = new Square(12);
 Console.WriteLine($"Area of the square = {sq.GetArea()}");
 }
}
// Output: Area of the square = 144

Example 2

// Abstract class
abstract class BaseClass
{
 protected int _x = 100;
 protected int _y = 150;

 // Abstract method
 public abstract void AbstractMethod();

 // Abstract properties
 public abstract int X { get; }
 public abstract int Y { get; }
}

class DerivedClass : BaseClass
{
 public override void AbstractMethod()
 {
 _x++;
 _y++;
 }

 public override int X // overriding property
 {
 get
 {
 return _x + 10;
 }
 }

 public override int Y // overriding property
 {
 get
 {
 return _y + 10;
 }
 }

 static void Main()
 {
 var o = new DerivedClass();
 o.AbstractMethod();
 Console.WriteLine($"x = {o.X}, y = {o.Y}");
 }
}
// Output: x = 111, y = 161

Example 3

public abstract class Shape
{
 public string Color { get; set; }

 // Constructor of the abstract class
 protected Shape(string color)
 {
 Color = color;
 Console.WriteLine($"Created a shape with color {color}.");
 }

 // Abstract method that must be implemented by derived classes
 public abstract double CalculateArea();
}

public class Square : Shape
{
 public double Side { get; set; }

 // Constructor of the derived class calling the base class constructor
 public Square(string color, double side) : base(color)
 {
 Side = side;
 }

 public override double CalculateArea()
 {
 return Side * Side;
 }
}

public class Program
{
 public static void Main(string[] args)
 {
 Square square = new Square("red", 5);
 Console.WriteLine($"Area of the square: {square.CalculateArea()}");
 }
}

Resources

Abstract keyword

Records

Mon, 01 Jan 0001 00:00:00 +0000

Definition

A record in C# is a class or struct that provides special syntax and behavior for working with data models. The record modifier instructs the compiler to synthesize members that are useful for types whose primary role is storing data. These members include an overload of ToString() and members that support value equality.

When to use

Consider using a record in place of a class or struct in the following scenarios:

Interfaces

Mon, 01 Jan 0001 00:00:00 +0000

Declaration

interface IEquatable<T>
{
 bool Equals(T obj);
}

public class Car : IEquatable<Car>
{
 public string? Make { get; set; }
 public string? Model { get; set; }
 public string? Year { get; set; }

 // Implementation of IEquatable<T> interface
 public bool Equals(Car? car)
 {
 return (this.Make, this.Model, this.Year) ==
 (car?.Make, car?.Model, car?.Year);
 }
}

Generics

Mon, 01 Jan 0001 00:00:00 +0000

Declaration

// Declare the generic class.
public class GenericList<T>
{
 public void Add(T item) { }
}

public class ExampleClass { }

class TestGenericList
{
 static void Main()
 {
 // Create a list of type int.
 GenericList<int> list1 = new();
 list1.Add(1);

 // Create a list of type string.
 GenericList<string> list2 = new();
 list2.Add("");

 // Create a list of type ExampleClass.
 GenericList<ExampleClass> list3 = new();
 list3.Add(new ExampleClass());
 }
}

Anonymous Types

Mon, 01 Jan 0001 00:00:00 +0000

Declaration

var v = new { Amount = 108, Message = "Hello" };

// Rest the mouse pointer over v.Amount and v.Message in the following
// statement to verify that their inferred types are int and string.
Console.WriteLine(v.Amount + v.Message);

List Collections

Mon, 01 Jan 0001 00:00:00 +0000

Using a List

List<string> names1 = ["Fernando", "Ana", "Felipe"];
// Or 
var names2 = new List<string> {"Fernando", "Ana", "Felipe"};

foreach (var name in names1)
{
 // Prints three items in the list
 Console.WriteLine($"Hello {name.ToUpper()}!");
}

for (int i = 0; i < names2.Count; i++)
{
 // Prints three items in the list
 Console.WriteLine($"Hello {names2[0].ToUpper()}!");
}

Modifying list contents

List<string> names = ["Fernando", "Ana", "Felipe"];

names.Add("Maria");
names.Add("Bill");
names.Remove("Ana");

foreach (var name in names)
{
 // Prints four items in the list, adding the new two ones and removing one of them.
 Console.WriteLine($"Hello {name.ToUpper()}!");
}

Ranges in Lists

List<string> names = ["Fernando", "Ana", "Felipe", "Maria", "Bill"];

// Prints names from the index 2 to index 3 (the right side of the range is not inclusive)
foreach (var name in names[2..4])
{
 // Prints four items in the list, adding the new two ones and removing one of them.
 Console.WriteLine($"Hello {name.ToUpper()}!");
}

// Get's the first one in the list.
Console.WriteLine($"Hello {names[0].ToUpper()}!");

// Get's the first one in the list from the back.
Console.WriteLine($"Hello {names[^1].ToUpper()}!");

Sorting Lists

List<string> names = ["Fernando", "Ana", "Felipe", "Maria", "Bill"];

names.Sort();

foreach (var name in names)
{
 // Prints five items sorted in the list.
 Console.WriteLine($"Hello {name.ToUpper()}!");
}

Searching in List

List<string> names = ["Fernando", "Ana", "Felipe", "Maria", "Bill"];

// Prints the index of the searching name.
 Console.WriteLine($"I found Fernando at index {names.IndexOf("Fernando")}");

Resources

OOP Principles

Mon, 01 Jan 0001 00:00:00 +0000

Principles

C# is an object-oriented programming language. The four basic principles of object-oriented programming are:

Encapsulation: Hiding the internal state and functionality of an object and only allowing access through a public set of functions.
Inheritance: Ability to create new abstractions based on existing abstractions.
Polymorphism: Ability to implement inherited properties or methods in different ways across multiple abstractions.
Abstraction: Modeling the relevant attributes and interactions of entities as classes to define an abstract representation of a system.

Encapsulation

Definition

Encapsulation is sometimes referred to as the first pillar or principle of object-oriented programming. A class or struct can specify how accessible each of its members is to code outside of the class or struct. Members not intended for consumers outside of the class or assembly are hidden to limit the potential for coding errors or malicious exploits.

Structured Programming

Mon, 01 Jan 0001 00:00:00 +0000

Content

Overview

Overview

The first paradigm to be adopted (but not the first to be invented) was structured programming, which was discovered by Edsger Wybe Dijkstra in 1968. Dijkstra showed that the use of unrestrained jumps (goto statements) is harmful to program structure. As we’ll see in the chapters that follow, he replaced those jumps with the more familiar if/then/else and do/while/until constructs.

We can summarize the structured programming paradigm as follows:

Arrays

Mon, 01 Jan 0001 00:00:00 +0000

Using an Array

// Arrays have fixed size.
string[] names1 = ["Fernando", "Ana", "Felipe"];
// Or 
var names2 = new string[] {"Fernando", "Ana", "Felipe"};

foreach (var name in names1)
{
 // Prints three items in the list
 Console.WriteLine($"Hello {name.ToUpper()}!");
}

for (int i = 0; i < names2.Length; i++)
{
 // Prints three items in the list
 Console.WriteLine($"Hello {names2[i].ToUpper()}!");
}

Adding items to array

string[] names = ["Fernando", "Ana", "Felipe"];

// Adding new elements.
names = [..names, "Maria"];

foreach (var name in names)
{
 // Prints four items in the list, adding the new two ones and removing one of them.
 Console.WriteLine($"Hello {name.ToUpper()}!");
}

Ranges in Lists

string[] names = ["Fernando", "Ana", "Felipe", "Maria", "Bill"];

// Prints names from the index 2 to index 3 (the right side of the range is not inclusive)
foreach (var name in names[2..4])
{
 // Prints four items in the list, adding the new two ones and removing one of them.
 Console.WriteLine($"Hello {name.ToUpper()}!");
}

// Get's the first one in the list.
Console.WriteLine($"Hello {names[0].ToUpper()}!");

// Get's the first one in the list from the back.
Console.WriteLine($"Hello {names[^1].ToUpper()}!");

Resources

Arrays, Lists, Indexing, and Foreach [Pt 13] | C# for Beginners - YouTube

Object-oriented Programming

Mon, 01 Jan 0001 00:00:00 +0000

Content

Use Intention-Revealing Names

Overview

The second paradigm to be adopted was actually discovered two years earlier, in 1966, by Ole Johan Dahl and Kristen Nygaard. These two programmers noticed that the function call stack frame in the ALGOL language could be moved to a heap, thereby allowing local variables declared by a function to exist long after the function returned. The function became a constructor for a class, the local variables became instance variables, and the nested functions became methods. This led inevitably to the discovery of polymorphism through the disciplined use of function pointers.

SOLID Principles

Mon, 01 Jan 0001 00:00:00 +0000

SOLID

Definition

SOLID is a set of five design principles that aim to make object-oriented software easier to understand, maintain, and extend. These principles were popularized by Robert C. Martin (Uncle Bob) in his 2000 paper “Design Principles and Design Patterns” and the acronym SOLID was coined a few years later.

The five SOLID principles are:

Single Responsibility Principle (SRP)
Open-Closed Principle (OCP)
Liskov Substitution Principle (LSP)
Interface Segregation Principle (ISP)
Dependency Inversion Principle (DIP)

I’ll be using the same example from C# Clean Code: SOLID Principles – Dev.to, so as the initial code we have the following:

Functional Programming

Mon, 01 Jan 0001 00:00:00 +0000

Content

Use Intention-Revealing Names
Resources

Overview

The third paradigm, which has only recently begun to be adopted, was the first to be invented. Indeed, its invention predates computer programming itself. Functional programming is the direct result of the work of Alonzo Church, who in 1936 invented l-calculus while pursuing the same mathematical problem that was motivating Alan Turing at the same time. His l-calculus is the foundation of the LISP language, invented in 1958 by John McCarthy. A foundational notion of l-calculus is immutability—that is, the notion that the values of symbols do not change. This effectively means that a functional language has no assignment statement. Most functional languages do, in fact, have some means to alter the value of a variable, but only under very strict discipline.

Language Integrated Query (LINQ)

Mon, 01 Jan 0001 00:00:00 +0000

Using LINQ

// Specify the data source.
List<int> scores = [97, 92, 81, 60];
// Or
// int[] scores = [97, 92, 81, 60];

// Define the QUERY SYNTAX expression.
IEnumerable<int> scoreQuery1 =
 from score in scores // required
 where score > 80 // optional
 orderby score descending // optional
 select score; // must end with select or group

// Or METHOD SYNTAX
IEnumerable<int> scoreQuery2 = scores
 .Where(s => s > 80) // lambda expression
 .OrderByDescending(s => s); // lambda expression

// Note: Query and method syntaxes can be used together.
var scoreQuery2 = (
 from score in scores
 where score > 80
 orderby score descending
 select score
).Count();

// Execute the query.
foreach (var i in scoreQuery)
{
 Console.Write(i + " ");
}

// Output: 97 92 81

In-memory vs Remote data

List<int> scores = [97, 92, 81, 60];

// In-memory
IEnumerable<int> scoreQuery1 =
 from score in scores
 where score > 80
 orderby score descending
 select score;

// Remote - It can be integrated with libraries like Entity Framework.
// You first create an object-relational mapping between C# classes and your database schema.
// Then you write your queries against the objects
// At run-time EntityFramework handles the communication with the database.
// It will even be able to build the SQL query and execute it in the database side.
IQueryable<int> scoreQuery1 =
 from score in scores
 where score > 80
 orderby score descending
 select score;

Parts of Query Operation

// The Three Parts of a LINQ Query:
// 1. Data source.
int[] numbers = [ 0, 1, 2, 3, 4, 5, 6 ];

// 2. Query creation.
// numQuery is an IEnumerable<int>
var numQuery = from num in numbers
 where (num % 2) == 0
 select num;

// 3. Query execution.
foreach (int num in numQuery)
{
 Console.Write("{0,1} ", num);
}

Ending a query expression

// GROUP CLAUSE
// Use the group clause to produce a sequence of groups organized by a key that you specify.
var queryCountryGroups =
 from country in countries
 group country by country.Name[0];

// SELECT CLAUSE
// Use the select clause to produce all other types of sequences.
IEnumerable<Country> sortedQuery =
 from country in countries
 orderby country.Area
 select country;
// The select clause can be used to transform source data into sequences of new types. 
var queryNameAndPop =
 from country in countries
 select new
 {
 Name = country.Name,
 Pop = country.Population
 };

// CONTINUATIONS WITH INTO
// You can use the into keyword in a select or group clause to create a temporary identifier that stores a query. 
// percentileQuery is an IEnumerable<IGrouping<int, Country>>
var percentileQuery =
 from country in countries
 let percentile = (int)country.Population / 1_000
 group country by percentile into countryGroup
 where countryGroup.Key >= 20
 orderby countryGroup.Key
 select countryGroup;

// grouping is an IGrouping<int, Country>
foreach (var grouping in percentileQuery)
{
 Console.WriteLine(grouping.Key);
 foreach (var country in grouping)
 {
 Console.WriteLine(country.Name + ":" + country.Population);
 }
}

Filtering, ordering, and joining

// WHERE CLAUSE
// Use the where clause to filter out elements from the source data based on one or more predicate expressions. 
IEnumerable<City> queryCityPop =
 from city in cities
 where city.Population is < 15_000_000 and > 10_000_000
 select city;

// ORDERBY CLAUSE 
// Use the orderby clause to sort the results in either ascending or descending order. 
IEnumerable<Country> querySortedCountries =
 from country in countries
 orderby country.Area, country.Population descending
 select country;

// JOIN CLAUSE
// Use the join clause to associate and/or combine elements from one data source with elements from another data source based on an equality comparison between specified keys in each element. 
var categoryQuery =
 from cat in categories
 join prod in products on cat equals prod.Category
 select new
 {
 Category = cat,
 Name = prod.Name
 };

// LET CLAUSE
// Use the let clause to store the result of an expression, such as a method call, in a new range variable.
string[] names = ["Svetlana Omelchenko", "Claire O'Donnell", "Sven Mortensen", "Cesar Garcia"];
IEnumerable<string> queryFirstNames =
 from name in names
 let firstName = name.Split(' ')[0]
 select firstName;

foreach (var s in queryFirstNames)
{
 Console.Write(s + " ");
}

//Output: Svetlana Claire Sven Cesar

// SUBQUERIES IN A QUERY EXPRESSION
// A query clause might itself contain a query expression, which is sometimes referred to as a subquery.
var queryGroupMax =
 from student in students
 group student by student.Year into studentGroup
 select new
 {
 Level = studentGroup.Key,
 HighestScore = (
 from student2 in studentGroup
 select student2.ExamScores.Average()
 ).Max()
 };

Resources

Delegates and events

Mon, 01 Jan 0001 00:00:00 +0000

Delegates

Delegates provide a late binding mechanism in .NET. Late Binding means that you create an algorithm where the caller also supplies at least one method that implements part of the algorithm.

using System.Delegate;

// From the .NET Core library

// Define the delegate type:
public delegate int Comparison<in T>(T left, T right);

// inside a class definition:

// Declare an instance of that type:
public Comparison<T> comparator;

// Invoke the delegate:
int result = comparator(left, right);

The compiler also generates add and remove handlers for this new type so that clients of this class can add and remove methods from an instance’s invocation list. The compiler will enforce that the signature of the method being added or removed matches the signature used when declaring the method.

Error Handling

Mon, 01 Jan 0001 00:00:00 +0000

Error Handling

try
{
 // try code block - code that may generate an exception
}
catch (Exception ex)
{
 // catch code block - code to handle an exception
}
finally
{
 // finally code block - code to clean up resources
}

Throwing Exceptions

throw new FormatException("FormatException: Calculations in process XYZ have been cancelled due to invalid data format.");

Roadmap

Mon, 01 Jan 0001 00:00:00 +0000

Software Design and Architecture Roadmap

Topics

Clean Code
Programming Paradigms

Resources:

How to Learn Software Design and Architecture | The Full-stack Software Design & Architecture Map
Software Design and Architecture Roadmap
Clean Code: A Handbook of Agile Software Craftsmanship, by Robert C. Martin
Refactoring, by Martin Fowler (2nd edition)
The Pragmatic Programmer, by Andy Hunt and Dave Thomas
The Design of Everyday Things, by Don Norman

Meaningful Names

Mon, 01 Jan 0001 00:00:00 +0000

Content

Use Intention-Revealing Names
Avoid Disinformation
Make Meaningful Distinctions
Use Pronounceable Names
Use Searchable Names
Avoid Encodings
Avoid Mental Mapping
Class Names
Method Names
Don’t Be Cute
Pick One Word per Concept
Don’t Pun
Use Solution Domain Names
Use Problem Domain Names
Don’t Add Gratuitous Context
Resources

Use Intention-Revealing Names

The name of a variable, function, or class, should answer all the big questions. It should tell you why it exists, what it does, and how it is used. If a name requires a comment, then the name does not reveal its intent.

Functions

Mon, 01 Jan 0001 00:00:00 +0000

Content

Small
Do One Thing
One Level of Abstraction per Function
Switch Statements
Use Descriptive Names
Function Arguments
Have No Side Effects
Command Query Separation
Prefer Exceptions to Returning Error Codes
Don’t Repeat Yourself
Structured Programming
Resources

Rules of functions

It’s importance to create small, focused, and single-responsibility functions that are easy to understand, test, and maintain.

Small

The first rule of functions is that they should be small. They should hardly ever be 20 lines long.
This implies that the blocks within if statements, else statements, while statements, and so on should be one line long. Probably that line should be a function call.
This also implies that functions should not be large enough to hold nested structures. Therefore, the indent level of a function should not be greater than one or two.

Do One Thing

Functions should do one thing, should do it well, and should do it only.
Functions should not be able to be divided into more sections/functions.

One Level of Abstraction per Function

To make sure the functions are doing “one thing”, we need to make sure that the statements within the function are all at the same level of abstraction.
We can follow the “The Stepdown Rule”. It’s all about reading code from top to bottom. This way each function introduces the next and make the code readable from top to bottom.

Switch Statements

It’s hard to make a small switch statement.
It violates the Single Responsibility Principle (SRP) because there is more than one reason for it to change.
It violates the Open Closed Principle8 (OCP) because it must change whenever new cases are added.
They can be tolerated if they appear only once, are used to create polymorphic objects, and are hidden behind an inheritance

Use Descriptive Names

Function name should describes what the function does.
The smaller and more focused a function is, the easier it is to choose a descriptive name.
Don’t be afraid to make a name long. A long descriptive name is better than a short enigmatic name.

Function Arguments

The ideal number of arguments for a function is zero.
Three arguments should be avoided where possible.
Arguments should make sense with the function name. There are two very common reasons to pass a single argument into a function.
- You may be asking a question about that argument.
- Or you may be operating on that argument, transforming it into something else and returning it.
Avoid using Flag Arguments.
Use object arguments.

// In this case, the first two arguments seem to be related.
Circle MakeCircle(double x, double y, double radius);

// We can abstract x and y into Point class, and have one instance instead.
Circle MakeCircle(Point center, double radius);

Function and arguments should form a very nice verb/noun pair.

Have No Side Effects

Your function promises to do one thing, so it should not do other hidden things.

Command Query Separation

Functions should either do something or answer something, but not both.

Prefer Exceptions to Returning Error Codes

Use try/catch to handle error instead of returning error codes as exceptions can be added without forcing any recompilation or redeployment.

// Returning error codes from specific actions.
if (DeletePage(page) == StatusOk)
{
 if (registry.DeleteReference(page.name) == StatusOk)
 {
 if (configKeys.DeleteKey(page.name.makeKey()) == StatusOk)
 {
 Console.WriteLine("page deleted");
 }
 else
 {
 Console.WriteLine("configKey not deleted");
 }
 }
 else
 {
 Console.WriteLine("deleteReference from registry failed");
 }
}
else
{
 Console.WriteLine("delete failed");
 return E_ERROR;
}

// We can replace the nested if statements with using try/catch.
try {
 DeletePage(page);
 registry.DeleteReference(page.name);
 configKeys.DeleteKey(page.name.makeKey());
}
catch (Exception e)
{
 Console.WriteLine(e.Message);
}

Functions should do one thing. Error handing is one thing.

Don’t Repeat Yourself

In case you find some code that is being used, try to separate it into a reusable function.

Structured Programming

Edsger Dijkstra’s rule says “every function and every block within a function should have one entry and one exit”.
Following these rules means that there should only be one return statement in a function, no break or continue statements in a loop, and never, ever, any goto statements.
This rule provides significant benefit in large functions only.

Resources

Clean Code: A Handbook of Agile Software Craftsmanship, by Robert C. Martin
Clean Code in C# Part 2 Methods - DEV Community

Comments

Mon, 01 Jan 0001 00:00:00 +0000

Content

Rules of comments
Good comments
Bad comments
Resources

Rules of comments

Truth can only be found in one place: the code. Only the code can truly tell you what it does. It is the only source of truly accurate information. Therefore, though comments are sometimes necessary, we will expend significant energy to minimize them.

One of the more common motivations for writing comments is bad code.

Clear and expressive code with few comments is far superior to cluttered and complex code with lots of comments.

Formatting

Mon, 01 Jan 0001 00:00:00 +0000

Content

Rules of formatting
Vertical Formatting
Horizontal Formatting
Resources

Rules of formatting

The Purpose of Formatting

Code formatting is about communication, and communication is the professional developer’s first order of business.

Vertical Formatting

According to Robert C. Martin example, files long preferred to be 200 lines with an upper limit of 500 lines long.

Although this should not be a hard and fast rule, it should be considered very desirable. Small files are usually easier to understand than large files are.

Objects and Data Structure

Mon, 01 Jan 0001 00:00:00 +0000

Content

Rules of functions
Resources

Objects and Data Structures

Data Abstraction

Abstraction is the process of hiding implementation details and exposing only the essential features of a system or component. As well, using proper names that don’t expose the implementation details.

Data/Object Anti-Symmetry

Objects hide their data behind abstractions and expose functions that operate on that data.
Data structure expose their data and have no meaningful functions.

// Shared class
public class Point {
 public double x;
 public double y;
}

// Procedural Code
public class Square {
 public Point topLeft;
 public double side;
}
public class Rectangle {
 public Point topLeft;
 public double height;
 public double width;
}
public class Circle {
 public Point center;
 public double radius;
}
public class Geometry {
 public double PI = 3.141592653589793;
 public double area(Object shape)
 {
 if (shape is Square) {
 Square s = (Square)shape;
 return s.side * s.side;
 }
 else if (shape is Rectangle) {
 Rectangle r = (Rectangle)shape;
 return r.height * r.width;
 }
 else if (shape is Circle) {
 Circle c = (Circle)shape;
 return PI * c.radius * c.radius;
 }
 else
 {
 return 0;
 }
 }
}

// OO Code
public interface Shape
{
 double area();
}

public class Square : Shape {
 private Point topLeft;
 private double side;
 public double area() {
 return side*side;
 }
}
public class Rectangle : Shape {
 private Point topLeft;
 private double height;
 private double width;
 public double area() {
 return height * width;
 }
}
public class Circle : Shape {
 private Point center;
 private double radius;
 public double PI = 3.141592653589793;
 public double area() {
 return PI * radius * radius;
 }
}

Procedural code (code using data structures) makes it easy to add new functions without changing the existing data structures. OO code, on the other hand, makes it easy to add new classes without changing existing functions.
Procedural code makes it hard to add new data structures because all the functions must change. OO code makes it hard to add new functions because all the classes must change.

The Law of Demeter

There is a well-known heuristic called the Law of Demeter that says a module should not know about the innards of the objects it manipulates.

Search Results

Mon, 01 Jan 0001 00:00:00 +0000

This file exists solely to respond to /search URL with the related search layout template.

No content shown here is rendered, all content is based in the template layouts/page/search.html

Setting a very low sitemap priority will tell search engines this is not important content.

This implementation uses Fusejs and mark.js

Initial setup

Search depends on additional output content type of JSON in config.toml ``` [outputs] home = [“HTML”, “JSON”] ```

Sub-Category

Mon, 01 Jan 0001 00:00:00 +0000

Top Category Sample

Mon, 01 Jan 0001 00:00:00 +0000

পোস্ট সমূহ

Mon, 01 Jan 0001 00:00:00 +0000

Fernando's Blog

Introduction

Markdown Samples

Markdown Syntax Rendering

Headings

H1

H2

H3

H4

H5

H6

Paragraph

Rich Content

Image Sample

Tweet Sample

YouTube Video Sample

Vimeo Video Sample

Shortcodes Samples

Alert

Image

A sample image without any attribute.

A sample image with height and width attributes.

A center aligned image with height and width attributes.

A image with float attribute.

Resultados de Búsqueda

Configuración inicial

Resultados de Búsqueda

Configuración inicial

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Search Results

Initial setup

Suchergebnisse

Initial setup

অনুসন্ধানের ফলাফল

Initial setup

অনুসন্ধানের ফলাফল

Initial setup

Roadmap

(1) CSharp Fundamentals

Topics

(2) CSharp Advanced

Topics

Resources

A sample image with `height` and `width` attributes.

A center aligned image with `height` and `width` attributes.

A image with `float` attribute.