Forem: Zafar Urakov

C# OOP

Zafar Urakov — Sat, 07 Oct 2023 18:20:32 +0000

Introdaction to OOP

OOP stands for "Object-Oriented Programming." It is an approach to writing programs that is based on objects rather than functions and procedures. This model focuses on objects, not actions, and data, not logic. An object is an instance of a class. All implementations of the same class are similar to each other but can have different parameters and values. Objects can utilize methods that are specific to them.

OOP greatly simplifies the process of organizing and creating the structure of a program. Separate objects that can be modified without affecting other parts of the program also simplify making changes to the program. As programs become larger over time and their maintenance becomes more challenging, these two aspects of OOP become increasingly relevant.

What are the principles of OOP?

Abstraction

Abstraction is the first and perhaps the most important principle of Object-Oriented Programming (OOP). It allows us to hide the implementation details of an object and provide only the necessary interface for working with it. In other words, abstraction enables us to focus on what an object does rather than how it does it.
For example:

abstract class Bird
{
    public abstract void MakeSound();

    public void sleep() => 
      Console.WriteLine("Zzz");
}

class Sparrow : Bird
{
    public override void MakeSound()
    {
        Console.WriteLine("Chirp chirp!");
    }
}

class Program
{
  static void Main(string[] args)
  {
    Sparrow sparrow = new Sparrow();
    sparrow.MakeSound();
    sparrow.sleep(); 
  }
}

Encapsulation

Encapsulation is a principle that allows hiding the internal details of an object's implementation and providing limited access to them. This makes the code more secure and maintainable.
For example:

class BankAccount
{
    private decimal balance;

    public void Deposit(decimal amount)
    {
        if (amount > 0)
            balance += amount;
    }

    public decimal GetBalance()
    {
        return balance;
    }
}

In this example, balance is a private field, and access to it is managed through the methods Deposit and GetBalance. This allows for controlling changes to the account balance and ensuring safe access to its value.

Polymorphism

Polymorphism is the ability of objects from different classes to respond to the same methods. This allows us to write flexible and versatile code that can work with different types of objects.
For example:

class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape");
    }
}

class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }
}

class Rectangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a rectangle");
    }
}

In this example, Shape is the base class, and Circle and Rectangle are its derived classes. When the Draw() method is called on objects of different types, the corresponding method from each class will be invoked.

Inheritance

Inheritance is the ability to create a new class based on an existing class, inheriting its properties and methods. This allows for code reuse and the creation of class hierarchies.
For example:

using System;

class Animal
{
    public void Eat()
    {
        Console.WriteLine("The animal is eating.");
    }

    public void Sleep()
    {
        Console.WriteLine("The animal is sleeping.");
    }
}

class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine("The dog is barking.");
    }
}

class Program
{
    static void Main()
    {
        Dog myDog = new Dog();

        myDog.Eat();    // Inherited from Animal
        myDog.Sleep();  // Inherited from Animal

        myDog.Bark();   // Defined in Dog

    }
}

In this example, we have two classes: Animal and Dog. Dog is a subclass of Animal, which means it inherits the Eat and Sleep methods from the Animal class. Additionally, it has its own method, Bark.

In the Main method, we create an instance of the Dog class (myDog) and demonstrate how we can call methods from both the base class (Animal) and the derived class (Dog). This illustrates the concept of inheritance in C#.

Conclusion

The principles of object-oriented programming are a powerful tool for creating clean, flexible, and understandable code. Abstraction, encapsulation, polymorphism, and inheritance help in developing programs that are easy to maintain and extend. I hope this article has helped you better understand these principles and how they are applied in C#.

I have a lot of interesting code on GitHun

C# Access Modifiers

Zafar Urakov — Thu, 05 Oct 2023 11:17:45 +0000

Well, since we started talking about classes in C#, we can't escape access modifiers.

What is access modifiers?

In C#, access modifiers specify the accessibility of types (classes, interfaces, etc) and type members (fields, methods, etc). For example:

class Student
{
   private int age = 12;
   public string name = "Bob";
}

age - private field can only be accessed within the Student class
name - public field that can be accessed from anywhere.

Types of Access Modifiers

In C#, there are 4 basic types of access modifiers.

public
private
protected
internal

1. Public Access Modifier

When we declare a type or type member public, it can be accessed from anywhere. For example:

using System;

namespace AccessModifiers 
{
  class Student 
  {
    public string name = "Bob";

    public void SayHello() =>
      Console.WriteLine("Hello from Student class");
  }

  class Program 
  {
    static void Main(string[] args) 
    {

      // creating object of Student class
      Student student = new Student();

      // accessing name field and printing it
      Console.WriteLine("Name: " + student.name);

      // accessing SayHello method from Student
      student.SayHello();
     }
  }
}

Output

Name: Bob
Hello from Student class

In the above example, we have created a class named Student with a field name and a method SayHello().

      // accessing name field and printing it
      Console.WriteLine("Name: " + student.name);

      // accessing SayHello method from Student
      student.SayHello();

Since the field and method are public, we are able to access them from the Program class.

Note: We have used the object student of the Student class to access its members. To learn more, visit the C# class and objects.

2. Private Access Modifier

When we declare a type member with the private access modifier, it can only be accessed within the same class or struct. For example:

using System;

namespace AccessModifiers 
{
  class Student 
  {
    private string name = "Bob";

    private void SayHello() =>
      Console.WriteLine("Hello from Student class");
  }

  class Program 
  {
    static void Main(string[] args) 
    {

      // creating object of Student class
      Student student = new Student();

      // accessing name field and printing it
      Console.WriteLine("Name: " + student.name);

      // accessing SayHello method from Student
      student.SayHello();
    }
  }
}

In the above example, we have created a class named Student with a field name and a method SayHello().

      // accessing name field and printing it
      Console.WriteLine("Name: " + student.name);

      // accessing SayHello method from Student
      student.SayHello();

Since the field and method are private, we are not able to access them from the Program class. Here, the code will generate the following error.

Error    CS0122    'Student.name' is inaccessible due to its protection level    
Error    CS0122    'Student.SayHello()' is inaccessible due to its protection level

3.Protected Access Modifier

When we declare a type member as protected, it can only be accessed from the same class and its derived classes. For example:

using System;

namespace AccessModifiers 
{
  class Student 
  {
    protected string name = "Bob";
  }

  class Program 
  {
    static void Main(string[] args) 
    {
      // creating object of student class
      Student student = new Student();

      // accessing name field and printing it
      Console.WriteLine("Name: " + student.name);
    }
  }
}

In the above example, we have created a class named Student with a field name. Since the field is protected, we are not able to access it from the Program class.

Here, the code will generate the following error:

Error    CS0122    'Student.name' is inaccessible due to its protection level

Now, let's try to access the protected member from a derived class:

using System;

namespace AccessModifiers 
{
  class Student 
  {
    protected string name = "Bob";
  }

  // derived class
  class Program : Student 
  {
    static void Main(string[] args) 
    {

      // creating object of derived class
      Program program = new Program();

      // accessing name field and printing it
      Console.WriteLine("Name: " + program.name);
    }
  }
}

Output

Name: Bob

In the above example, we have created a class Student with a protected field name. Notice that we have inherited the Program class from the Student class.

// accessing name field and printing it
      Console.WriteLine("Name: " + program.name);
    }

Since the protected member can be accessed from derived classes, we are able to access name from the Program class.

4.Internal Access Modifier

When we declare a type or type member as internal, it can be accessed only within the same assembly, that is, we cannot call internal from another project in our Solutions.

An assembly is a collection of types (classes, interfaces, etc) and resources (data). They are built to work together and form a logical unit of functionality.

That's why when we run an assembly all classes and interfaces inside the assembly run together.

Call in our project. For example:

using System;

namespace AccessModifiers 
{
  class Student 
  {
   internal string name = "Bob";
  }

  class Program 
  {
    static void Main(string[] args) 
    {
      // creating object of Student class
      Student student = new Student();

      // accessing name field and printing it
      Console.WriteLine("Name: " + student.name);
    }
  }
}

Output

Name: Bob

Call in another project. For example:

using System;

namespace SecondAccessModifiers 
{
  class Program 
  {
    static void Main(string[] args) 
    {
      // creating object of Student class
      Student student = new Student();

      // accessing name field and printing it
      Console.WriteLine("Name: " + student.name);
    }
  }
}

Note: Pay attention to the namespace, it is different from the first project.
Output

Error    CS0122    'student.name' is inaccessible due to its protection level

Conclusion

In general, access modifiers allow you to specify the allowed scope for class components. That is, access modifiers determine the context in which a given variable or method can be used.

I have a lot of interesting code on GitHub

C# Classes

Zafar Urakov — Tue, 03 Oct 2023 06:19:49 +0000

Introduction to Classes in C

Classes are one of the fundamental concepts in the C# programming language. They serve as a means of creating user-defined data types that can contain both data and methods for working with that data. Classes are an important tool for structuring and organizing code in C#.

What is a Class?

In programming, a class can be thought of as a template or blueprint for creating objects. It defines the structure and behavior of an object. A class specifies what data (fields) and methods (functions) can be associated with objects of that class.

Example of a simple class in C#:

public class Person
{
    // Class fields
    public string name;
    public int age;

    // Class method
    public void SayHello()
    {
        Console.WriteLine($"Hello, my name is {name}, and I am {age} years old.");
    }
}

1. Data Organization

Classes allow you to logically group data related to a specific object or concept. This makes the code more organized and easier to understand.

2. Abstraction

Classes enable you to create abstract models of objects or processes that are easier to understand and model. They help to hide implementation details and focus on important aspects.

3. Code Reusability

Classes facilitate the creation of objects based on a specific template, making it easier to reuse code. You can create multiple objects of the same class with different data and perform the same methods.

4. Modularity

Classes contribute to code modularity, meaning you can divide code into small, independent components (classes), which simplifies development, testing, and maintenance.

Advantages of Using Classes for Programmers

Code Clarity: Classes help create more readable and understandable code, making it easier to collaborate with other programmers and maintain the application.

Modularity and Reusability: Classes allow the creation of independent modules that can be easily reused in different parts of the application.

Abstraction: Classes enable programmers to abstract away implementation details and focus on the core functionality.

Security: Classes provide control over access to data and methods, enhancing application security.

Extensibility: You can easily add new features and methods by extending classes without changing existing code.

Classes are a fundamental tool in C# programming and are widely used in software development. Understanding their principles and advantages will help you become a more effective programmer and create higher-quality software.

I have a lot of interesting code on GitHub

C# Methods

Zafar Urakov — Mon, 25 Sep 2023 03:32:25 +0000

While variables store certain values, methods contain a set of instructions that perform certain actions. Essentially, a method is a named block of code that performs some action.

The general definition of methods is as follows:

[modifiers] return_value_type method_name ([parameters])
{
    // method body
}

Modifiers and parameters are optional.

We have previously used at least one method - Console.WriteLine(), which prints information to the console. Now let's look at how we can create our own methods.

Method Definition

Let's define one method:

void SayHello()
{
    Console.WriteLine("Hello");
}

The SayHello method is defined here, which prints some message. In principle, the same requirements apply to method names as to variable names. However, as a rule, method names begin with a capital letter.

The method name is preceded by the return data type. Here it's a void type, which indicates that it doesn't actually return anything, it just does some things.

After the name of the method, the parameters are listed in parentheses. But in this case, the brackets are empty, which means that the method does not take any parameters.

Following the list of parameters in parentheses is a block of code that represents the set of instructions the method executes. In this case, the SayHello method block contains only one instruction, which prints the line to the console:

Console.WriteLine("Hello");

But if we run this project, we will not see any line that the SayHello method should output. Because after definition, the method still needs to be called in order for it to do its job.

Calling Methods

To use the SayHello method, we need to call it. To call a method, indicate its name, followed by the values for its parameters in parentheses (if the method accepts parameters).

method_name (values_for_method_parameters);

For example, calling the SayHello method would look like this:

SayHello();

Since the method does not take any parameters, the method name is followed by empty parentheses.

Let's combine the definition and method call:

void SayHello()
{
    Console.WriteLine("Hello");
}

SayHello(); // Hello
SayHello(); // Hello

Console output of the program:

Hello
Hello

The advantage of methods is that they can be called repeatedly and repeatedly in different parts of the program. For example, in the example above, the SayHello method is called twice.

In this case, there is no difference whether the method is first defined and then called, or vice versa. For example, we could write like this:

SayHello(); // Hello
SayHello(); // Hello

void SayHello()
{
    Console.WriteLine("Hello");
}

Let's define and call a few more methods:

void SayHelloRu()
{
    Console.WriteLine("Привет");
}
void SayHelloEn()
{
    Console.WriteLine("Hello");
}
void SayHelloUz()
{
    Console.WriteLine("Assalomu Aleykum");
}


string language = "uz";

switch (language)
{
    case "en": 
        SayHelloEn();
        break;
    case "ru":
        SayHelloRu();
        break;
    case "uz":
        SayHelloUz();
        break;
}

Three methods are defined here: SayHelloRu(), SayHelloEn() and SayHelloUz(), which are also of type void, do not take any parameters and also output some string to the console. Relatively speaking, they display a greeting in a specific language.

The switch construct checks the value of the language variable, which conditionally stores the language code, and depending on its value, a specific method is called. So, in this case, the console will display:

Assalomu Aleykum

Shorthand for methods

If a method body defines only one instruction, then we can shorten the method definition. For example, let's say we have a method:

void SayHello()
{
    Console.WriteLine("Hello");
}

We can shorten it like this:

void SayHello() => Console.WriteLine("Hello");

This is called "Syntactic Sugar", that is, after the list of parameters there is an => operator, followed by the instruction to be executed.

I have a lot of interesting code on GitHub

C# List

Zafar Urakov — Thu, 21 Sep 2023 17:07:03 +0000

Introduction

List is a dynamic array in C# that provides a collection of elements of the same type. List offers a variety of convenient methods for adding, removing, and accessing elements in the collection. It is a commonly used data structure when working with collections of objects.

Creating a List

To create a new List in C#, you need to use the 'List<>' class, where 'T' is the type of elements you want to store in the list. For example:

List<int> numbers = new List<int>(); // Creating an empty list of integers

Adding Elements

You can add an element to the list using the 'Add()' method. For example:

numbers.Add(10); // Adding the number 10 to the list
numbers.Add(20); // Adding the number 20 to the list

Accessing Elements

To access elements of the list, you can use indexing starting from zero. For example:

int firstNumber = numbers[0]; // Accessing the first element (10)
int secondNumber = numbers[1]; // Accessing the second element (20)

Removing Elements
To remove an element from the list, you can use the 'Remove()' method. For example:

numbers.Remove(10); // Removing the number 10 from the list

Checking for Element Existence

To check if the list contains a specific element, use the 'Contains()' method. For example:

bool containsTwenty = numbers.Contains(20); // Checking if the list contains the number 20

Iterating through the List

To iterate through all elements in the list, use a foreach loop. For example:

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

And so, here is another example to make it clear what 'List' is understood:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Create a List of strings
        List<string> fruits = new List<string>();

        // Add elements to the List
        fruits.Add("Apple");
        fruits.Add("Banana");
        fruits.Add("Orange");

        // Access elements by index
        string firstFruit = fruits[0]; // "Apple"
        string secondFruit = fruits[1]; // "Banana"

        // Modify an element
        fruits[0] = "Cherry"; // Replace "Apple" with "Cherry"

        // Get the number of elements in the List
        int count = fruits.Count; // 3

        // Check if an element exists in the List
        bool containsBanana = fruits.Contains("Banana"); // true

        // Remove an element
        fruits.Remove("Orange"); // Remove "Orange" from the List

        // Iterate through the List using a foreach loop
        foreach (string fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
        // Output: Cherry, Banana
    }
}

Conclusion

List in C# is a powerful and convenient data structure that allows you to store and manage a collection of elements of the same type. In this documentation, we have covered the fundamental operations with List that will enable you to efficiently work with your data:

Creating a list using the 'List<>' class.
Adding elements to the list using the 'Add()' method.
Accessing elements of the list through indexing.
Removing elements from the list using the 'Remove()' method.
Checking for the existence of elements using the 'Contains()' method.
Iterating through the list using a foreach loop.
With this knowledge, you will be able to create and manage lists in C# with ease, which will be valuable in application development and data processing. I hope that this documentation and examples have helped you better understand how to use List in C#.

I have a lot of interesting code on GitHub

C# Arrays

Zafar Urakov — Thu, 14 Sep 2023 07:23:45 +0000

Introduction

Arrays are an essential data structure in C# that allow you to store and manipulate collections of elements of the same data type. Arrays provide a convenient way to work with multiple values under a single variable name.

In C#, arrays can be of various types, including one-dimensional, multi-dimensional, and jagged arrays. This documentation will explore each type and provide clear examples to help you understand their usage.

One-Dimensional Arrays

Declaration and Initialization
One-dimensional arrays in C# are declared and initialized using square brackets "[]". Here's an example of declaring and initializing an integer array:

int[] numbers = new int[5]; // Creates an integer array with 5 elements

Accessing Elements
You can access elements in a one-dimensional array using their index, starting from 0. For example:

int thirdNumber = numbers[2]; // Accesses the third element (index 2)

Example: Sum of Elements
Let's calculate the sum of elements in an integer array:

int[] numbers = { 1, 2, 3, 4, 5 };
int sum = 0;

foreach (int num in numbers)
{
    sum += num;
}

Console.WriteLine("Sum of elements: " + sum);

Sum of elements: 15

Multi-Dimensional Arrays

Declaration and Initialization
Multi-dimensional arrays have multiple dimensions, typically represented as a matrix. You can declare and initialize them like this:

int[,] matrix = new int[3, 3]; // Creates a 3x3 integer matrix

Accessing Elements
Accessing elements in a multi-dimensional array requires specifying indices for each dimension:

matrix[0, 0] = 1; // Accesses the element in the first row and first column

Example: Matrix Multiplication
Let's perform matrix multiplication using multi-dimensional arrays:

int[,] matrixA = { { 1, 2 }, { 3, 4 } };
int[,] matrixB = { { 5, 6 }, { 7, 8 } };
int[,] result = new int[2, 2];

for (int i = 0; i < 2; i++)
{
    for (int j = 0; j < 2; j++)
    {
        for (int k = 0; k < 2; k++)
        {
            result[i, j] += matrixA[i, k] * matrixB[k, j];
        }
    }
}

Console.WriteLine("Matrix Multiplication Result:");
for (int i = 0; i < 2; i++)
{
    for (int j = 0; j < 2; j++)
    {
        Console.Write(result[i, j] + " ");
    }
    Console.WriteLine();
}

Matrix Multiplication Result:
19 22
43 50

Jagged Arrays

Jagged arrays are arrays of arrays, where each sub-array can have a different length. They are declared and initialized as follows:

int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[] { 1, 2 };
jaggedArray[1] = new int[] { 3, 4, 5 };
jaggedArray[2] = new int[] { 6, 7, 8, 9 };

Accessing Elements
To access elements in a jagged array, you need to specify both the outer and inner indices:

int value = jaggedArray[1][2]; // Accesses the third element of the second sub-array

Example: Sum of Elements in Jagged Array
Let's calculate the sum of elements in a jagged integer array:

int[][] jaggedArray = new int[][] {
    new int[] { 1, 2 },
    new int[] { 3, 4, 5 },
    new int[] { 6, 7, 8, 9 }
};

int sum = 0;

foreach (int[] subArray in jaggedArray)
{
    foreach (int num in subArray)
    {
        sum += num;
    }
}

Console.WriteLine("Sum of elements in jagged array: " + sum);

Sum of elements in jagged array: 45

Conclusion

Arrays are versatile and fundamental data structures in C#. Understanding how to declare, initialize, and manipulate different types of arrays will greatly enhance your programming skills. Feel free to experiment with the provided examples and explore more complex scenarios to become proficient in working with arrays in C#.

I have a lot of interesting code on GitHub

Loops in C#

Zafar Urakov — Tue, 05 Sep 2023 03:43:57 +0000

Loops are control structures, allowing you to perform some action many times, depending on certain conditions. C# has the following types of loops:

for
foreach
while
do…while

for loop

The for loop has the following formal definition:

for ([actions_before loop execution]; [condition]; [actions after execution])
{ 
// actions
}

The for loop declaration has three parts. The first part of the loop declaration is some actions that are performed once before the loop is executed. This is usually where the variables to be used in the loop are defined.

The second part is the condition under which the loop will be executed. As long as the condition is true, the loop will run.

And the third part - some actions that are performed after the completion of the loop block. These actions are executed each time the loop block ends.

After the declaration of the cycle, the actions of the cycle are placed in curly braces.

Consider a standard for loop:

for (int i = 1; i < 4; i++)
{
    Console.WriteLine(i);
}

Here the first part of the loop declaration - int i = 1 - creates and initializes the variable i.

The second part is the condition i < 4. That is, as long as the variable i is less than 4, the loop will be executed.

And the third part - the actions performed after the completion of the actions from the cycle block - increasing the variable i by one.

The whole process of the cycle can be represented as follows:

The variable int i = 1 is defined

The condition i < 4 is checked. It is true (since 1 is less than 4), so the loop block is executed, namely the Console.WriteLine(i) statement, which prints the value of the variable i to the console

The loop block has finished executing, so the third part of the loop declaration, i++, is executed. After that, the variable i will be equal to 2.

The condition i < 4 is checked again. It is true (because 2 is less than 4), so the loop block is executed again - Console.WriteLine(i)

The loop block has finished executing, so the i++ expression is executed again. After that, the variable i will be equal to 3.

The condition i < 4 is checked again. It is true (since 3 is less than 4), so the loop block is executed again - Console.WriteLine(i)

The loop block has finished executing, so the i++ expression is executed again. After that, the variable i will be equal to 4.

The condition i < 4 is tested again. Now it returns false because i is NOT less than 4, so the loop terminates. Then the rest of the program is already executed, which comes after the loop

As a result, the loop block will run 3 times until the value of i becomes equal to 4. And each time this value will increase by 1. Executing the loop block once is called an iteration. So here the loop will execute three iterations. The result of the program:

1
2
3

If the for loop block contains one statement, then we can shorten it by removing the curly frees:

for (int i = 1; i < 4; i++)
    Console.WriteLine(i);

// or so
for (int i = 1; i < 4; i++) Console.WriteLine(i);

At the same time, it is not necessary to declare a variable in the first part of the loop, and change its value in the third part - these can be any actions. For example:

var i = 1;

for (Console.WriteLine("Begin loop"); i < 4; Console.WriteLine($"i = {i}"))
{
    i++;
}

Here again, the loop runs while the variable i is less than 4, only the increment of the variable i occurs in the loop block. Console output of this program:

Starting a loop
i = 2
i = 3
i = 4

We don't have to specify all conditions when declaring a loop. For example, we can write like this:

int i = 1;
for (; ;)
{
    Console.WriteLine($"i = {i}");
    i++;
}

Formally, the definition of the cycle remains the same, only now the blocks in the definition are empty: for (; ;). We don't have an initialized variable, no condition, so the loop will run forever - an infinite loop.

We can also omit a number of blocks:

int i = 1;
for (; i<4;)
{
    Console.WriteLine($"i = {i}");
    i++;
}

This example is essentially equivalent to the first example: we also have a counter variable, only it is defined outside the loop. We have a loop execution condition. And there is an increment of the variable already in the for block itself.
It's also worth noting that you can define multiple variables in a loop declaration:

for (int i = 1, j = 1; i < 10; i++, j++)
    Console.WriteLine($"{i * j}");

Here, in the first part of the loop declaration, two variables are defined: i and j. The loop is executed until i equals 10. After each iteration, the variables i and j are incremented by one. Console output of the program:

do..while loop

In a do loop, the loop code is executed first, and then the condition in the while statement is checked. And while this condition is true, the cycle repeats.

do
{
    cycle actions
}
while (condition)

For example:

int i = 6;
do
{
    Console.WriteLine(i);
    i--;
}
while (i > 0);

Here the loop code will run 6 times until i becomes zero. But it is important to note that the do loop guarantees that the actions will be performed at least once, even if the condition in the while statement is not true. That is, we can write:

int i = -1;
do
{
    Console.WriteLine(i);
    i--;
}
while (i > 0);

Although we have a variable i less than 0, the loop will still be executed once.

while loop

Unlike the do loop, the while loop immediately checks the truth of some condition, and if the condition is true, then the loop code is executed:

while (condition)
{
    cycle actions
}

For example:

int i = 6;
while (i > 0)
{
    Console.WriteLine(i);
    i--;
}

foreach loop

The foreach loop is designed to iterate over a set or collection of elements. Its general definition is:

foreach(datatype variable in collection)
{
    // cycle actions
}

After the foreach statement in parentheses, the variable definition comes first. Then the keyword in and then the collection, the elements of which must be iterated.

When executed, the loop sequentially iterates through the elements of the collection and places them in a variable, and thus in the loop block we can perform some actions with them.

For example, let's take a string. A string is essentially a collection of characters. And .NET allows you to loop through all the elements of a string - its characters with a foreach loop.

foreach(char c in "Tom")
{
    Console.WriteLine(c);
}

Here the foreach loop iterates through all the characters in the string "Tom" and puts each character into the character variable c. In the loop block, the value of the variable c is printed to the console. Since there are three characters in the string "Tom", the loop will be executed three times. Console output of the program:

T
O
M

It is worth noting that the variable that is defined in the loop declaration must match the type of the elements of the collection being iterated. So, the elements of a string are values of type char - characters. So the variable c is of type char. However, in reality it is not always obvious what type the elements of a collection represent. In this case, we can define a variable using the var statement:

foreach(var c in "Tom")
{
    Console.WriteLine(c);
}

In the following, we will take a closer look at what collections are in .NET and which collections can be iterated with a foreach loop.

continue and break statements

Sometimes a situation arises when you want to exit the loop without waiting for it to complete. In this case, we can use the break statement.

For example:

for (int i = 0; i < 9; i++)
{
    if (i == 5)
        break;
    Console.WriteLine(i);
}

Although the loop condition says that the loop will run until counter i reaches 9, in reality the loop will run 5 times. Since when the counter i reaches the value 5, the break statement will work, and the loop will end.

Now let's set ourselves another task. But what if we want the loop to not end when checking, but simply skip the current iteration. To do this, we can use the continue statement:

for (int i = 0; i < 9; i++)
{
    if (i == 5)
        continue;
    Console.WriteLine(i);
}

In this case, the loop, when it reaches the number 5, which does not satisfy the test condition, will simply skip this number and move on to the next iteration:

It is worth noting that the break and continue statements can be used in any type of loop.

Nested Loops

Some loops can be nested within others. For example:

for (int i = 1; i < 10; i++)
{
    for (int j = 1; j < 10; j++)
    {
        Console.Write($"{i * j} \t");
    }
    Console.WriteLine();
}

In this case, the for (int i = 1; i < 10; i++) loop is executed 9 times, that is, it has 9 iterations. But within each iteration, the nested for loop (int j = 1; j < 10; j++) is executed nine times. As a result, this program will display the multiplication table.

My GitHub

References:
1.metanit

if-else construct and ternary operation C#

Zafar Urakov — Sat, 26 Aug 2023 07:16:09 +0000

Conditional constructs are one of the basic components of many programming languages, which direct the work of the program along one of the paths depending on certain conditions. One such construct in the C# programming language is the if..else construct.

The if/else construct checks the truth of a certain condition and, depending on the results of the check, executes a certain code.

Ее простейшая форма состоит из блока if:

if(condition)
{
   executable instructions
}

The if keyword is followed by a condition. The condition must represent a bool value. This can be a bool value itself, or the result of a conditional expression or another expression that returns a bool value. And if this condition is true (equal to true), then the code that is placed further after the condition inside curly braces works.

For example:

int firstNumber = 8;
int secondNumber = 6;

if(firstNumber > secondNumber)
{
   Console.WriteLine($”The number {firstNumber} is greater than the number {secondNumber}”);
}

In this case, we have the first number greater than the second, so the expression firstNumber > secondNumber is true and returns true, therefore, control passes to the line Console.WriteLine("The number {firstNumber} is greater than the number {secondNumber}");

If the if block contains a single statement, then we can shorten it by removing the curly braces:

int firstNumber = 8;
int secondNumber = 6;
if (firstNumber > secondNumber)
    Console.WriteLine($"The number {firstNumber} is greater than the number {secondNumber}");

// or so
if (firstNumber > secondNumber) Console.WriteLine($"The number {firstNumber} is greater than the number {secondNumber}");

We can also connect several conditions at once using logical operators:

int firstNumber = 8;
int secondNumber = 6;
if(firstNumber > secondNumber && firstNumber == 8)
{
    Console.WriteLine($"The number {firstNumber} is greater than the number {secondNumber}");
}

In this case, the if block will be executed if firstNumber > secondNumber is true and firstNumber == 8 is true.

else expression

But what if we want something to be done if the condition is not met? In this case, we can add an else block:

int firstNumber = 8;
int secondNumber = 6;
if(firstNumber > secondNumber)
{
    Console.WriteLine($"The number {firstNumber} is greater than the number {secondNumber}");
}
else
{
    Console.WriteLine($"The number {firstNumber} is less than the number {secondNumber}");
}

else if

But in the example above, when comparing numbers, we can count three states: the first number is greater than the second, the first number is less than the second, and the numbers are equal. Using the else if construct, we can handle additional conditions:

int firstNumber = 8;
int secondNumber = 6;
if(firstNumber > secondNumber)
{
    Console.WriteLine($"The number {firstNumber} is greater than the number {secondNumber}");
}
else if (firstNumber < secondNumber)
{
    Console.WriteLine($"The number {firstNumber} is less than the number {secondNumber}");
}
else
{
    Console.WriteLine("The number firstNumber is equal to the number secondNumber");
}

Ternary operation

The ternary operation also allows you to check a certain condition and, depending on its truth, perform some actions. It has the following syntax:

[first operand - condition] ? [second operand] : [third operand]

There are three operands here. Depending on the condition, the ternary operation returns the second or third operand: if the condition is true, then the second operand is returned; if the condition is false, then the third one. For example:

int firstNumber = 3;
int secondNumber = 2;

int result = firstNumber < secondNumber ? (firstNumber + secondNumber) : (firstNumber - secondNumber);
Console.WriteLine(result); // 1

Here, the first operand (that is, the condition) represents the expression firstNumber < secondNumber. If it is true, then the second operand is returned - (firstNumber + secondNumber), that is, the result of the addition operation. If the condition is false, then the third operand is returned - (firstNumber - secondNumber).

The result of the ternary operation (that is, the second or third operand depending on the condition) is assigned to the variable result.

My GitHub

References:
1.Microsoft

Conditional expressions C#

Zafar Urakov — Thu, 24 Aug 2023 09:51:37 +0000

A separate set of operations represents conditional expressions. Such operations return a boolean value, that is, a value of type bool: true if the expression is true, and false if the expression is false. These operations include comparison operations and logical operations.

Comparison operations

Comparison operators compare two operands and return a bool - true if the expression is true and false if the expression is false.

Compares two operands for equality. If they are equal, then the operation returns true, if not equal, then false is returned:

int firstNumber = 10;
int secondNumber = 4;
bool thirdNumber = firstNumber == secondNumber; // false

Compares two operands and returns true if the operands are not equal and false if they are equal.

int firstNumber  = 10;
int secondNumber = 4;
bool thirdNumber = firstNumber != secondNumber; // true
bool fourthNumber = firstNumber != 10; // false

Operation "less than". Return true the first operand is less than second, and false if the first operand is greater than the second:

int firstNumber  = 10;
int SecondNumber = 4;
bool thirdNumber = firstNumber < SecondNumber; // false

Operation "more than". Compares two operands and returns true if the first operands is greater than the second, otherwise returns false:

int firstNumber = 10;
int secondNumber = 4;
bool thirdNumber = firstNumber > secondNumber; // true

Operation "greater than or equal to." Compares two operands and returns true if the first operand is greater than or equal to the second, otherwise false is returned:

int firstNumber = 10;
int secondNumber = 4;
bool thirdNumber = firstNumber <= secondNumber; // false
bool fourthNumber = firstNumber <= 10; // true

Operation "greater than or equal to." Compares two operands and returns true if the first operand is greater than or equal to the second, otherwise false is returned:

int firstNumber = 10;
int secondNumber = 10;
bool thirdNumber = firstNumber >= secondNumber;     // true
bool fourthNumber = firstNumber >= 25;    // false

Logical operators

&& - Logical operator AND
|| - Logical OR operator
! - Unary logical negation

bool firstCondition = true;
bool secondCondition = false;

bool firstResult = firstCondition && secondCondition // false
bool secondResult = firstCondition || secondCondition // true
bool thirdResult = !firstCondition // false

My GitHub

References:
1.Microsoft

C# data types

Zafar Urakov — Sun, 20 Aug 2023 18:43:51 +0000

Like many programming languages, C# has its own data type system that is used to create variables. The data type defines the internal representation of the data, the set of values that an object can take, and the allowed actions that can be performed on the object.

The C# language has the following basic data types:

bool: stores true or false (boolean literals). Represented by the system type System.Boolean
byte: stores an integer from 0 to 255 and occupies 1 byte. Represented by the system type System.Byte
sbyte: stores an integer from -128 to 127 and occupies 1 byte. Represented by the system type System.SByte
short: stores an integer from -32768 to 32767 and occupies 2 bytes. Represented by the system type System.Int16
ushort: stores an integer from 0 to 65535 and occupies 2 bytes. Represented by the system type System.UInt16
int: stores an integer from -2147483648 to 2147483647 and occupies 4 bytes. Represented by the System.Int32 system type. All integer literals represent values of type int by default:
uint: stores an integer from 0 to 4294967295 and occupies 4 bytes. Represented by the system type System.UInt32
long: stores an integer from -9 223 372 036 854 775 808 to 9 223 372 036 854 775 807 and occupies 8 bytes. Represented by the system type System.Int64
ulong: stores an integer from 0 to 18446744073709551615 and occupies 8 bytes. Represented by the system type System.UInt64
float: stores a floating point number from -3.4*1038 to 3.4*1038 and takes 4 bytes. Represented by the system type System.Single
double: Stores a floating Point number from ±5.0*10-324 to ±1.7*10308 and occupies 8 bytes. Represented by the system type System.Double
decimal: stores a decimal fractional number. If used without a decimal point, it has a value of ±1.0*10-28 to ±7.9228*1028, can store 28 decimal places, and occupies 16 bytes. Represented by the system type System.Decimal
char: Stores a single Unicode character and occupies 2 bytes. Represented by the System.Char system type. Character literals correspond to this type:
string: stores a set of Unicode characters. Represented by the System.String system type. This type corresponds to string literals.
object: can store a value of any data type and takes up 4 bytes on a 32-bit platform and 8 bytes on a 64-bit platform. Represented by the System.Object system type, which is the base type for all other .NET types and classes.

References:
1.Microsoft

What is .NET?

Zafar Urakov — Wed, 16 Aug 2023 14:13:29 +0000

.NET is an open source platform for building desktop, mobile and web applications that can run on any operating system. The .NET system includes tools, libraries, and languages that support modern, scalable, and high-performance software development. The .NET platform is supported and maintained by an active developer community.
Simply put, the .NET platform is software that can perform the following tasks:

Translate .NET programming language code into instructions that a computing device can process.
Provide utilities for efficient software development. With their help, you can, for example, determine the current time or print text on the screen.
Define a set of data types for storing information such as text, numbers, and dates on a computer.

What are .NET implementations?
Various .NET implementations allow .NET code to run on different operating systems such as Linux, macOS, Windows, iOS, Android, and many more.

.NET Platform
The .NET platform is the original implementation of .NET. It supports running websites, services, desktop apps and more on Windows. Microsoft released the .NET platform in the early 1990s.

.NET Core
Microsoft launched .NET Core in late 2014 to provide cross-platform support for .NET developers. The company released the latest version of .NET Core 5.0 in November 2020 and renamed it .NET.
.NET Core is open source on GitHub.

.NET Standart
The .NET Standard is a formal specification for various features (called APIs). Different .NET implementations can reuse the same code and libraries. Each implementation uses both standard .NET APIs and unique APIs specific to the operating systems on which it runs.

Advantages and disadvantages of .NET

Advantages

Language independence. Thanks to the Common Language Runtime (CLR), all languages supported by .Net are compiled into an intermediate level language. This allows you to embed libraries that are written in other languages.
Development environment. Visual Studio (VS) is one of the best IDEs (Integrated Development Environment) today. Easy to use, a large number of settings allow you to customize the environment for yourself.
The power of C#. Object-oriented language. It is the main one in the development of .Net projects.
Libraries. Integration of libraries is simplified as much as possible thanks to the Nuget manager (a tool for working with libraries). A huge number of libraries for various types of projects.

Disadvantages

Distribution kits for applications. For .Net applications to work on Windows, special distributions must be installed. Each new version of .Net distributions must be installed separately. If you go to the application manager, you might be surprised how many are installed.
More code means more responsibility. Each technology is constantly improving, the dependencies in them are changing. Sometimes a situation arises where you need to use an old version of some library. Due to version dependencies, you have to change versions of other libraries, and it is often found that something does not work correctly.

What are the programming languages in .NET?

C#
C# is a simple, modern and object-oriented programming language. With a syntax similar to the C family of languages, C# is familiar to C, C , Java, and JavaScript programmers.
F#
F# has a lightweight syntax and requires very little code to build software. It is an open source language that makes it easy to write concise, robust, and high performance code. It also has a powerful system of programming rules and a handy standard library for creating critical, correct, fast, and reliable software.
Visual Basic
Visual Basic is an object-oriented programming language developed by Microsoft. Using Visual Basic makes it quick and easy to create type-safe .NET applications. Type safety is the extent to which a programming language prevents or prevents logical coding errors.

What is the .NET environment?
The CLR is a kind of "virtual machine" that actually manages our applications written for .net.
It has such an interesting thing as a garbage collector (Garbage collector). It cleans up everything unnecessary left by the program in RAM during the execution of the program itself. That is, if we used, for example, a variable only once in a program, then after accessing this variable, if it is not used anywhere else, the automatic garbage collector deletes it from RAM. It is absolutely safe, and most importantly, it gives a huge increase in the performance of large-scale and resource-intensive applications.

How does it all work?
Recall that the process of compilation is the translation of your human-readable code into binary code that a computer understands.

In .net programming, compiling and running applications is as follows:
Code from any language is converted to code written in a common language (Common intermediate language or CIL). This language is a lower-level language similar in syntax to assembly language.
After, this code is passed to the so-called execution environment (Common language runtime or CLR), which takes functions and methods from the .net Framework
After that, the final result is transferred to the processor and the program is executed.

References: