csharp programming notes.txt

=============================
Introduction to Pointers
=============================
Pointers

Every variable is a memory location, which has its address defined.
That address can be accessed using the ampersand (&) operator (also called the address-of operator), which denotes an address in memory.

For example:
#include <iostream>
using namespace std;

int main()
{
    int score = 5;
    cout << &score << endl;

    return 0;
}
This outputs the memory address, which stores the variable score.

Pointers

A pointer is a variable, with the address of another variable as its value.
In C++, pointers help make certain tasks easier to perform. Other tasks, such as dynamic memory allocation, cannot be performed without using pointers.

All pointers share the same data type - a long hexadecimal number that represents a memory address.

The only difference between pointers of different data types is the data type of the variable that the pointer points to.

Pointers

A pointer is a variable, and like any other variable, it must be declared before you can work with it.
The asterisk sign is used to declare a pointer (the same asterisk that you use for multiplication), however, in this statement the asterisk is being used to designate a variable as a pointer.
Following are valid pointer declarations:
int *ip;  // pointer to an integer
double *dp;   // pointer to a double
float *fp;  // pointer to a float
char *ch;  // pointer to a character
CPP
Just like with variables, we give the pointers a name and define the type, to which the pointer points to.
The asterisk sign can be placed next to the data type, or the variable name, or in the middle.

Using Pointers

Here, we assign the address of a variable to the pointer.
#include <iostream>
using namespace std;

int main()
{
    int score = 5;
    int *scorePtr;
    scorePtr = &score;

    cout << scorePtr << endl;

    return 0;
}
The code above declares a pointer to an integer called scorePtr, and assigns to it the memory location of the score variable using the ampersand (address-of) operator.
Now, scorePtr's value is the memory location of score.

=============================
More on Pointers
=============================
Pointer Operations

There are two operators for pointers:
Address-of operator (&): returns the memory address of its operand.
Contents-of (or dereference) operator (*): returns the value of the variable located at the address specified by its operand.

For example:
#include <iostream>
using namespace std;

int main()
{
    int var = 50;
    int  *p;
    p = &var;

    cout << var << endl;
    // Outputs 50 (the value of var)

    cout << p << endl;
    // Outputs 0x29fee8 (var's memory location)

    cout << *p << endl;
    /* Outputs 50 (the value of the variable
     stored in the pointer p) */

    return 0;
}
The asterisk (*) is used in declaring a pointer for the simple purpose of indicating that it is a pointer (The asterisk is part of its type compound specifier). Don't confuse this with the dereference operator, which is used to obtain the value located at the specified address. They are simply two different things represented with the same sign.

Dereferencing


The dereference operator (*) is basically an alias for the variable the pointer points to.
For example:
int x = 5;
int *p = &x;

x = x + 4;
x = *p + 4;
*p = *p + 4;
CPP

All three of the preceding statements are equivalent, and return the same result. We can access the variable by dereferencing the variable's pointer.
As p is pointing to the variable x, dereferencing the pointer (*p) is representing exactly the same as the variable x.

=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

					TABLE OF CONTENTS:
::Basic Concepts::
1.1 What is C#?
2.1 Variables
3.1 Your First C# Program
4.1 Printing Text
5.1 Getting User Input
6.1 Comments
7.1 The var Keyword
8.1 Constants
9.1 Arithmetic Operators
10.1 Assignment & Increment Operators

::Conditionals and Loops::
13.1 The if-else Statement
14.1 The switch Statement
15.1 The while Loop
16.1 The for Loop
17.1 The do-while Loop
18.1 break and continue
19.1 Logical Operators
20.1 The Conditional Operator
21.1 Basic Calculator

::Methods::
24.1 Introduction to Methods
25.1 Method Parameters
26.1 Multiple Parameters
27.1 Optional & Named Arguments
28.1 Passing Arguments
29.1 Method Overloading
30.1 Recursion
31.1 Making a Pyramid

::Classes & Objects::
34.1 Classes & Objects
35.1 Value & Reference Types
36.1 Class Example
37.1 Encapsulation
38.1 Constructors
39.1 Properties

::Arrays and Strings::
42.1 Arrays
43.1 Using Arrays in Loops
44.1 Multidimensional Arrays
45.1 Jagged Arrays
46.1 Array Properties & Methods
47.1 Working with Strings

::More on Classes::
50.1 Destructors
51.1 Static Members
52.1 Static Classes
53.1 this & readonly
54.1 Indexers
55.1 Operator Overloading

::Inheritance & Polymorphism::
58.1 Inheritance
59.1 Protected Members
60.1 Derived Class Constructor & Destructor
61.1 Polymorphism
62.1 Abstract Classes
63.1 Interfaces
64.1 Nested Classes
65.1 Namespaces

::Structs, Enums, Exceptions & Files::
68.1 Structs
69.1 Enums
70.1 Exception Handling
71.1 Working with Files

::Generics::
74.1 Generic Methods
75.1 Generic Classes
76.1 Collections
77.1 Lists and BitArray
78.1 Stack & Queue
79.1 Dictionary & HashSet

Check for Try it yourself before Basic Concepts -> Printing Text. Delegates + -=Typecasting=- convert one datatype to another. -=Delegate=- function pointer; delegates contains the reference to several methods and call them when needed. So, you create numbers of methods as you need and attach it to delegates. At runtime, an event gets fired and delegates dynamically call the function and show the result. -=Callback Function=- call to another function await another function to finish & alert calling. -=Nested For Loop=- outer loop creates rectangle, inner loop fills it. -=index++ (postfix (increment afterwards))=- https://www.cprogramming.com/tutorial/function-pointers.html

=============================
=============================
C# Basics
=============================
=============================

=============================
1.1 What is C#?
=============================
Welcome to C#

C# is an elegant object-oriented language that enables developers to build a variety of secure and robust applications that run on the .NET Framework.
You can use C# to create Windows applications, Web services, mobile applications, client-server applications, database applications, and much, much more.

The .NET Framework


The .NET Framework consists of the Common Language Runtime (CLR) and the .NET Framework class library.
The CLR is the foundation of the .NET Framework. It manages code at execution time, providing core services such as memory management, code accuracy, and many other aspects of your code.
The class library is a collection of classes, interfaces, and value types that enable you to accomplish a range of common programming tasks, such as data collection, file access, and working with text.
C# programs use the .NET Framework class library extensively to do common tasks and provide various functionalities.
These concepts might seem complex, but for now just remember that applications written in C# use the .NET Framework and its components.

=============================
2.1 Variables
=============================

Programs typically use data to perform tasks.
Creating a variable reserves a memory location, or a space in memory, for storing values. It is called variable because the information stored in that location can be changed when the program is running.
To use a variable, it must first be declared by specifying the name and data type.
A variable name, also called an identifier, can contain letters, numbers and the underscore character (_) and must start with a letter or underscore.
Although the name of a variable can be any set of letters and numbers, the best identifier is descriptive of the data it will contain. This is very important in order to create clear, understandable and readable code!
For example, firstName and lastName are good descriptive variable names, while abc and xyz are not.

Variable Types


A data type defines the information that can be stored in a variable, the size of needed memory and the operations that can be performed with the variable.
For example, to store an integer value (a whole number) in a variable, use the int keyword:
int myAge;
CS
The code above declares a variable named myAge of type integer.
A line of code that completes an action is called a statement. Each statement in C# must end with a semicolon.
You can assign the value of a variable when you declare it:
int myAge = 18;
CS
or later in your code:
int myAge;
myAge = 18;
CS
Remember that you need to declare the variable before using it.

Built-in Data Types


There are a number of built-in data types in C#. The most common are:
int - integer.
float - floating point number.
double - double-precision version of float.
char - a single character.
bool - Boolean that can have only one of two values: True or False.
string - a sequence of characters.
The statements below use C# data types:
int x = 42;
double pi = 3.14;
char y = 'Z';
bool isOnline = true;
string firstName = "David";
CS
Note that char values are assigned using single quotes and string values require double quotes.
You will learn how to perform different operations with variables in the upcoming lessons!

=============================
3.1 Your First C# program
=============================

You can run, save, and share your C# codes on our Code Playground, without installing any additional software.
Reference this lesson if you need to install the software on your computer.
To create a C# program, you need to install an integrated development environment (IDE) with coding and debugging tools.
We will be using Visual Studio Community Edition, which is available to download for free.
After installing it, choose the default configuration.
Next, click File->New->Project and then choose Console Application as shown below:contentImageEnter a name for your Project and click OK.
Console application uses a text-only interface. We chose this type of application to focus on learning the fundamentals of C#.

Your First C# Program


Visual Studio will automatically generate some code for your project:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace SoloLearn
{
   class Program
   {
      static void Main(string[] args)
      {
      }
   }
}
CS
You will learn what each of the statements does in the upcoming lessons.
For now, remember that every C# console application must contain a method (a function) named Main. Main is the starting point of every application, i.e. the point where our program starts execution from.
We will learn about classes, methods, arguments, and namespaces in the upcoming lessons.

Your First C# Program

To run your program, press Ctrl+F5. You will see the following screen:contentImageThis is a console window. As we did not have any statements in our Main method, the program just produces a general message. Pressing any key will close the console.
Congratulations, you just created your first C# program.

=============================
4.1 Printing Text
=============================

Displaying Output

Most applications require some input from the user and give output as a result.
To display text to the console window you use the Console.Write or Console.WriteLine methods. The difference between these two is that Console.WriteLine is followed by a line terminator, which moves the cursor to the next line after the text output.
The program below will display Hello World! to the console window:
Note the parentheses after the WriteLine method. This is the way to pass data, or arguments, to methods. In our case WriteLine is the method and we pass "Hello World!" to it as an argument. String arguments must be enclosed in quotation marks.

Displaying Output


We can display variable values to the console window:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 89;
            Console.WriteLine(x);
        }
    }
}

To display a formatted string, use the following syntax:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 10;
            double y = 20;
            Console.WriteLine("x = {0}; y = {1}", x, y);
        }
    }
}

As you can see, the value of x replaced {0} and the value of y replaced {1}.
You can have as many variable placeholders as you need. (i.e.: {3}, {4}, etc.).
icon
Your First Program
C# is cool! Let everyone know about it!

=============================
5.1 Getting User Input
=============================

User Input


You can also prompt the user to enter data and then use the Console.ReadLine method to assign the input to a string variable.
The following example asks the user for a name and then displays a message that includes the input:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            string yourName;
            Console.WriteLine("What is your name?");
            yourName = Console.ReadLine();
 
            Console.WriteLine("Hello {0}", yourName);
        }
    }
}

The Console.ReadLine method waits for user input and then assigns it to the variable. The next statement displays a formatted string containing Hello with the user input. For example, if you enter David, the output will be Hello David.
Note the empty parentheses in the ReadLine method. This means that it does not take any arguments.

User Input


The Console.ReadLine() method returns a string value.
If you are expecting another type of value (such as int or double), the entered data must be converted to that type.
This can be done using the Convert.ToXXX methods, where XXX is the .NET name of the type that we want to convert to. For example, methods include Convert.ToDouble and Convert.ToBoolean.
For integer conversion, there are three alternatives available based on the bit size of the integer: Convert.ToInt16, Convert.ToInt32 and Convert.ToInt64. The default int type in C# is 32-bit.
Let’s create a program that takes an integer as input and displays it in a message:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int age = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("You are {0} years old", age);
        }
    }
}

If, in the program above, a non-integer value is entered (for example, letters), the Convert will fail and cause an error.

=============================
6.1 Comments
=============================

Comments are explanatory statements that you can include in a program to benefit the reader of your code.
The compiler ignores everything that appears in the comment, so none of that information affects the result.

A comment beginning with two slashes (//) is called a single-line comment. The slashes tell the compiler to ignore everything that follows, until the end of the line.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

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

When you run this code, Hello will be displayed to the screen. The // Prints Hello line is a comment and will not appear as output.

Multi-Line Comments


Comments that require multiple lines begin with /* and end with */ at the end of the comment block.
You can place them on the same line or insert one or more lines between them.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            /* Some long 
                comment text     
            */
            int x = 42;
            Console.WriteLine(x);
        }
    }
}

Adding comments to your code is good programming practice. It facilitates a clear understanding of the code for you and for others who read it.

=============================
7.1 The var Keyword
=============================

A variable can be explicitly declared with its type before it is used.
Alternatively, C# provides a handy function to enable the compiler to determine the type of the variable automatically based on the expression it is assigned to.
The var keyword is used for those scenarios:
var num = 15;
CS
The code above makes the compiler determine the type of the variable. Since the value assigned to the variable is an integer, the variable will be declared as an integer automatically.

The var Keyword


Variables declared using the var keyword are called implicitly typed variables.
Implicitly typed variables must be initialized with a value.
For example, the following program will cause an error:
var num;
num = 42;
CS
Although it is easy and convenient to declare variables using the var keyword, overuse can harm the readability of your code. Best practice is to explicitly declare variables.

=============================
8.1 Constants
=============================

Constants store a value that cannot be changed from their initial assignment.
To declare a constant, use the const modifier.
For example:
const double PI = 3.14; 
CS
The value of const PI cannot be changed during program execution.
For example, an assignment statement later in the program will cause an error:
const double PI = 3.14;
PI = 8; //error
CS
Constants must be initialized with a value when declared.

=============================
9.1 Arithmetic Operators
=============================

An operator is a symbol that performs mathematical or logical manipulations.

Arithmetic Operators

C# supports the following arithmetic operators:
Operator	Symbol		Form
Addition		+		x+y
Subtraction	-		x-y
Multiplication	*		x*y
Division		/		x/y
Modulus	%		x%y

Division

The division operator (/) divides the first operand by the second. If the operands are both integers, any remainder is dropped in order to return an integer value.
Example:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 10 / 4;
            Console.WriteLine(x);
        }
    }
}

Division by 0 is undefined and will crash your program.

Modulus

The modulus operator (%) is informally known as the remainder operator because it returns the remainder of an integer division.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 25 % 7;
            Console.WriteLine(x);
        }
    }
}

Operator Precedence

Operator precedence determines the grouping of terms in an expression, which affects how an expression is evaluated. Certain operators take higher precedence over others; for example, the multiplication operator has higher precedence than the addition operator.
For example:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 4+3*2;
            Console.WriteLine(x);
        }
    }
}

The program evaluates 3*2 first, and then adds the result to 4.
As in mathematics, using parentheses alters operator precedence.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = (4 + 3) *2;
            Console.WriteLine(x);
        }
    }
}

The operations within parentheses are performed first. If there are parenthetical expressions nested within one another, the expression within the innermost parentheses is evaluated first.
If none of the expressions are in parentheses, multiplicative (multiplication, division, modulus) operators will be evaluated before additive (addition, subtraction) operators. Operators of equal precedence are evaluated from left to right.

=============================
10.1 Assignment & Increment Operators
=============================

The = assignment operator assigns the value on the right side of the operator to the variable on the left side.

C# also provides compound assignment operators that perform an operation and an assignment in one statement.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 42;
            x += 2; // equivalent to x = x + 2
            Console.WriteLine(x);

            x -= 6; // equivalent to x = x - 6
            Console.WriteLine(x);
        }
    }
}

Assignment Operators


The same shorthand syntax applies to the multiplication, division, and modulus operators.
x *= 8; // equivalent to x = x * 8
x /= 5; // equivalent to x = x / 5
x %= 2; // equivalent to x = x % 2
CS
The same shorthand syntax applies to the multiplication, division, and modulus operators.

Increment Operator


The increment operator is used to increase an integer's value by one, and is a commonly used C# operator.
x++; //equivalent to x = x + 1
CS
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 10;
            x++;
            Console.WriteLine(x);
        }
    }
}
The increment operator is used to increase an integer's value by one.

Prefix & Postfix Forms


The increment operator has two forms, prefix and postfix
++x; //prefix
x++; //postfix
CS
Prefix increments the value, and then proceeds with the expression.
Postfix evaluates the expression and then performs the incrementing.

Prefix example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 3;
            int y = ++x;
            Console.WriteLine(x+" "+y);
        }
    }
}
Postfix example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 3;
            int y = x++;
            Console.WriteLine(x+" "+y);
        }
    }
}
The prefix example increments the value of x, and then assigns it to y.
The postfix example assigns the value of x to y, and then increments x.

Decrement Operator


The decrement operator (--) works in much the same way as the increment operator, but instead of increasing the value, it decreases it by one.
--x; // prefix
x--; // postfix
CS
The decrement operator (--) works in much the same way as the increment operator.

=============================
=============================
Conditionals and Loops
=============================
=============================

=============================
13.1 The if-else Statement
=============================

The if statement is a conditional statement that executes a block of code when a condition is true.
The general form of the if statement is:
if (condition)
{
    // Execute this code when condition is true
}
CS
The condition can be any expression that returns true or false.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 8;
            int y = 3;
            
            if (x > y)
            { 
                Console.WriteLine("x is greater than y");
            }
        }
    }
}
The code above will evaluate the condition x > y. If it is true, the code inside the if block will execute.
When only one line of code is in the if block, the curly braces can be omitted.
For example:
if (x > y)
Console.WriteLine("x is greater than y");

Relational Operators

Operator	Description	Example
>=	Greater than or equal to	7>=4 True
<=	Less than or equal to	7<=4 False
==	Equal to			7==4 False
!=	Not equal to		7!=4 True


Use relational operators to evaluate conditions. In addition to the less than (<) and greater than (>) operators, the following operators are available:contentImage Example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int a=7, b=7;
            if (a == b) {
                Console.WriteLine("Equal");
            }
        }
    }
}

The else Clause

An optional else clause can be specified to execute a block of code when the condition in the if statement evaluates to false.
Syntax:
if (condition) 
{
   //statements
}
else 
{
   //statements
}
CS
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int mark = 85;
            
            if (mark < 50) 
            {
                Console.WriteLine("You failed.");
            }
            else
            {
                Console.WriteLine("You passed.");
            }
        }
    }
}

Nested if Statements


You can also include, or nest, if statements within another if statement.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int mark = 100;
            
            if (mark >= 50) {
                Console.WriteLine("You passed.");
                if (mark == 100) {
                    Console.WriteLine("Perfect!");
                }
            }
            else {
                Console.WriteLine("You failed.");
            }
        }
    }
}
You can nest an unlimited number of if-else statements.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int age = 17;
            if (age > 14) {
                if(age > 18) {
                    Console.WriteLine("Adult");
                }
                else {
                    Console.WriteLine("Teenager");
                }
            }
            else {
                if (age > 0) {
                    Console.WriteLine("Child");
                }
                else {
                    Console.WriteLine("Something's wrong");
                }
            }
        }
    }
}
Remember that all else clauses must have corresponding if statements.

The if-else if Statement


The if-else if statement can be used to decide among three or more actions.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 33;
            
            if (x == 8) {
                Console.WriteLine("Value of x is 8");
            }
            else if (x == 18) {
                Console.WriteLine("Value of x is 18");
            }
            else if (x == 33) {
                Console.WriteLine("Value of x is 33");
            }
            else {
                Console.WriteLine("No match");
            }
        }
    }
}
Remember, that an if can have zero or more else if's and they must come before the last else, which is optional.
Once an else if succeeds, none of the remaining else if's or else clause will be tested.

=============================
14.1 The switch Statement
=============================

The switch statement provides a more elegant way to test a variable for equality against a list of values.
Each value is called a case, and the variable being switched on is checked for each switch case.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = 3;
            switch (num)
            {
                case 1:
                    Console.WriteLine("one");
                    break;
                case 2:
                    Console.WriteLine("two");
                    break;
                case 3:
                    Console.WriteLine("three");
                    break;
            }
        }
    }
}
Each case represents a value to be checked, followed by a colon, and the statements to get executed if that case is matched.
A switch statement can include any number of cases. However, no two case labels may contain the same constant value.
The break; statement that ends each case will be covered shortly.

The default Case


In a switch statement, the optional default case is executed when none of the previous cases match.
Example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int age = 88;
            switch (age) {
                case 16:
                    Console.WriteLine("Too young");
                    break;
                case 42:
                    Console.WriteLine("Adult");
                    break;
                case 70:
                    Console.WriteLine("Senior");
                    break;
                default:
                    Console.WriteLine("The default case");
                    break;
            }
        }
    }
}
The default code executes when none of the cases matches the switch expression.

The break Statement


The role of the break statement is to terminate the switch statement.
Without it, execution continues past the matching case statements and falls through to the next case statements, even when the case labels don’t match the switch variable.
This behavior is called fallthrough and modern C# compilers will not compile such code. All case and default code must end with a break statement.
The break statement can also be used to break out of a loop. You will learn about loops in the coming lessons.

=============================
15.1 The while Loop
=============================

A while loop repeatedly executes a block of code as long as a given condition is true.
For example, the following code displays the numbers 1 through 5:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = 1;
            while(num < 6) 
            {
                Console.WriteLine(num);
                num++;
            }
        }
    }
}
The example above declares a variable equal to 1 (int num = 1). The while loop checks the condition (num < 6) and, if true, executes the statements in its body, which increment the value of num by one, before checking the loop condition again.

After the 5th iteration, num equals 6, the condition evaluates to false, and the loop stops running.
The loop body is the block of statements within curly braces.

The while Loop

The compound arithmetic operators can be used to further control the number of times a loop runs.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = 1;
            while(num < 6) 
            {
                Console.WriteLine(num);
                num+=2;
            }
        }
    }
}
Without a statement that eventually evaluates the loop condition to false, the loop will continue indefinitely.

The while Loop


We can shorten the previous example, by incrementing the value of num right in the condition:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = 0;
            while(++num < 6) 
                Console.WriteLine(num);
        }
    }
}
What do you think, is there a difference between while(num++ < 6) and while(++num < 6)?
Yes! The loop while(++num < 6) will execute 5 times, because pre-increment increases the value of x before checking the num < 6 condition, while post-increment will check the condition before increasing the value of num, making while(num++ < 6) execute 6 times.

=============================
16.1 The for Loop
=============================

A for loop executes a set of statements a specific number of times, and has the syntax:
for ( init; condition; increment ) {
  statement(s);
}
CS
A counter is declared once in init.
Next, the condition evaluates the value of the counter and the body of the loop is executed if the condition is true.
After loop execution, the increment statement updates the counter, also called the loop control variable.
The condition is again evaluated, and the loop body repeats, only stopping when the condition becomes false.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int x = 10; x < 15; x++)
            {
                Console.WriteLine("Value of x: {0}", x);
            }
        }
    }
}
Note the semicolons in the syntax.


The for Loop


Compound arithmetic operators can be used to further control loop iterations.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int x = 0; x < 10; x+=3)
            {
                Console.WriteLine(x);
            }
        }
    }
}
You can also decrement the counter:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int x = 10; x > 0; x-=2)
            {
                Console.WriteLine(x);
            }
        }
    }
}

The for Loop


The init and increment statements may be left out, if not needed, but remember that the semicolons are mandatory.
For example, the init can be left out:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 10;
            for ( ; x > 0; x -= 3)
            {
                Console.WriteLine(x);
            }
        }
    }
}
You can have the increment statement in the for loop body:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 10;
            for ( ; x > 0 ; )
            {
                Console.WriteLine(x);
                x -= 3;
            }
        }
    }
}
for (; ;) {} is an infinite loop.

=============================
17.1 The do-while Loop
=============================

A do-while loop is similar to a while loop, except that a do-while loop is guaranteed to execute at least one time.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 0;
            do {
                Console.WriteLine(a);
                a++;
            } while(a < 5);
        }
    }
}
Note the semicolon after the while statement.

do-while vs. while

If the condition of the do-while loop evaluates to false, the statements in the do will still run once:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 42;
            do {
                Console.WriteLine(x);
                x++;
            } while(x < 10);
        }
    }
}
The do-while loop executes the statements at least once, and then tests the condition.
The while loop executes the statement only after testing condition.

=============================
18.1 break and continue
=============================

We saw the use of break in the switch statement.
Another use of break is in loops: When the break statement is encountered inside a loop, the loop is immediately terminated and the program execution moves on to the next statement following the loop body.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = 0;
            while (num < 20)
            {
                if (num == 5)
                    break;

                Console.WriteLine(num);
                num++;
            }
        }
    }
}
If you are using nested loops (i.e., one loop inside another loop), the break statement will stop the execution of the innermost loop and start executing the next line of code after the block.

continue

The continue statement is similar to the break statement, but instead of terminating the loop entirely, it skips the current iteration of the loop and continues with the next iteration.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 0; i < 10; i++) {
                if (i == 5)
                    continue;

                Console.WriteLine(i);
            }
        }
    }
}
As you can see, number 5 is not printed, as the continue statement skips the remaining statements of that iteration of the loop.

=============================
19.1 Logical Operators
=============================

Logical operators are used to join multiple expressions and return true or false.
Operator	Name of Operator	Form
&&		AND Operator		y && y
||		OR Operator		x || y
!		NOT Operator		! x

The AND operator (&&) works the following way:
Left Operand		Right Operand		Result
false			false			false
false			true			false
true			false			false
true			true			true

For example, if you wish to display text to the screen only if age is greater than 18 AND money is greater than 100:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int age = 42;
            double money = 540;
            if(age > 18 && money > 100) {
                Console.WriteLine("Welcome");
            }
        }
    }
}
The AND operator was used to combine the two expressions.
With the AND operator, both operands must be true for the entire expression to be true.

AND

You can join more than two conditions:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int age = 42;
            int grade = 75;
            if(age > 16 && age < 80 && grade > 50) 
                Console.WriteLine("Hey there");
        }
    }
}
The entire expression evaluates to true only if all of the conditions are true.

The OR Operator


The OR operator (||) returns true if any one of its operands is true.
Left Operand		Right Operand		Result
false			false			false
false			true			true
true			false			true
true			true			true

For Example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int age = 18;
            int score = 85;
            if (age > 20 || score > 50) {
                Console.WriteLine("Welcome");
            }
        }
    }
}
You can join any number of logical OR statements you want.
In addition, multiple OR and AND statements may be joined together.

Logical NOT


The logical NOT (!) operator works with just a single operand, reversing its logical state. Thus, if a condition is true, the NOT operator makes it false, and vice versa.
Right Operand		Result
true			false
false			true

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int age = 8;
            if ( !(age > 16) ) {
                Console.Write("Your age is less than 16");
            }
        }
    }
}

=============================
20.1 The Conditional ? : Operator
=============================

Consider the following example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int age = 42;
            string msg;
            if(age >= 18)
                msg = "Welcome";
            else
                msg = "Sorry";

            Console.WriteLine(msg);
        }
    }
}
The code above checks the value of the age variable and displays the corresponding message to the screen.
This can be done in a more elegant and shorter way by using the ?: operator, which has the following form:
Exp1 ? Exp2 : Exp3;
CS
The ?: operator works the following way: Exp1 is evaluated. If it is true, then Exp2 is evaluated and becomes the value of the entire expression. If Exp1 is false, then Exp3 is evaluated and its value becomes the value of the expression.
So, the example above can be replaced by the following:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int age = 42;
            string msg;
            msg = (age >= 18) ? "Welcome" : "Sorry";
            Console.WriteLine(msg);
        }
    }
}

=============================
21.1 Basic Calculator
=============================

Now let's create a simple project that repeatedly asks the user to enter two values and then displays their sum, until the user enters exit.
We start with a do-while loop that asks the user for input and calculates the sum:
do {
  Console.Write("x = ");
  int x = Convert.ToInt32(Console.ReadLine());

  Console.Write("y = ");
  int y = Convert.ToInt32(Console.ReadLine());

  int sum = x+y;
  Console.WriteLine("Result: {0}", sum);
}
while(true);
CS
This code will ask for user input infinitely. Now we need to handle the "exit".
If the user enters a non-integer value, the program will crash from a conversion error. We will learn how to handle errors like that in the coming modules.

Basic Calculator


If the user enters "exit" as the value of x, the program should quit the loop. To do this, we can use a break statement:
Console.Write("x = ");
string str = Console.ReadLine();
if (str == "exit")
  break;

int x = Convert.ToInt32(str);
CS
Here we compare the input with the value "exit" and break the loop.
So the whole program looks like:
 do {
  Console.Write("x = ");
  string str = Console.ReadLine();
  if (str == "exit")
    break;

  int x = Convert.ToInt32(str);

  Console.Write("y = ");
  int y = Convert.ToInt32(Console.ReadLine());

  int sum = x + y;
  Console.WriteLine("Result: {0}", sum);
}
while (true);
CS
If the user enters "exit" as the value of x, the program should quit the loop.

=============================
=============================
Methods
=============================
=============================

=============================
24.1 Introduction to Methods
=============================
What is a Method?


A method is a group of statements that perform a particular task.
In addition to the C# built-in methods, you may also define your own.

Methods have many advantages, including:
- Reusable code.
- Easy to test.
- Modifications to a method do not affect the calling program.
- One method can accept many different inputs.
Every valid C# program has at least one method, the Main method.

Declaring Methods


To use a method, you need to declare the method and then call it.
Each method declaration includes:
- the return type
- the method name
- an optional list of parameters.
<return type> name(type1 par1, type2 par2, … , typeN parN)
{
    List of statements
}
CS
For example, the following method has an int parameter and returns the number squared:
int Sqr(int x)
{
  int result = x*x;
  return result;
}
CS
The return type of a method is declared before its name. In the example above, the return type is int, which indicates that the method returns an integer value. When a method returns a value, it must include a return statement. Methods that return a value are often used in assignment statements.
Occasionally, a method performs the desired operations without returning a value. Such methods have a return type void. In this case, the method cannot be called as part of an assignment statement.
void is a basic data type that defines a valueless state.

Calling Methods


Parameters are optional; that is, you can have a method with no parameters.
As an example, let's define a method that does not return a value, and just prints a line of text to the screen.
static void SayHi()
{
  Console.WriteLine("Hello");
}
CS
Our method, entitled SayHi, returns void, and has no parameters.
To execute a method, you simply call the method by using the name and any required arguments in a statement.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void sayHi()
        {
            Console.WriteLine("Hello");
        }
        static void Main(string[] args)
        {
            sayHi();
        }
    }
}
The static keyword will be discussed later; it is used to make methods accessible in Main.

Calling Methods

You can call the same method multiple times:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

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

=============================
25.1 Method Parameters
=============================

Method declarations can define a list of parameters to work with.
Parameters are variables that accept the values passed into the method when called.
For example:
void Print(int x) 
{
  Console.WriteLine(x);
}
CS
This defines a method that takes one integer parameter and displays its value.
Parameters behave within the method similarly to other local variables. They are created upon entering the method and are destroyed upon exiting the method.

Parameters

Now you can call the method in Main and pass in the value for its parameters (also called arguments):
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Print(int x) 
        {
            Console.WriteLine(x);
        }
        static void Main(string[] args)
        {
            Print(42);
        }
    }
}
The value 42 is passed to the method as an argument and is assigned to the formal parameter x.

Parameters

You can pass different arguments to the same method as long as they are of the expected type.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Func(int x)
        {
            Console.WriteLine(x*2);
        }
        static void Main(string[] args)
        {
            Func(5);
  
            Func(12);

            Func(42);
        }
    }
}

=============================
26.1 Multiple Parameters
=============================

You can have as many parameters as needed for a method by separating them with commas in the definition.
Let's create a simple method that returns the sum of two parameters:
int Sum(int x, int y)
{
   return x+y;
}
CS
The Sum method takes two integers and returns their sum. This is why the return type of the method is int. Data type and name should be defined for each parameter.
Methods return values using the return statement.

Multiple Parameters


A method call with multiple parameters must separate arguments with commas.
For example, a call to Sum requires two arguments:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static int Sum(int x, int y)
        {
            return x+y;
        }
        static void Main(string[] args)
        {
            Console.WriteLine(Sum(8, 6));
        }
    }
}
In the call above, the return value was displayed to the console window. Alternatively, we can assign the return value to a variable, as in the code below:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static int Sum(int x, int y)
        {
            return x+y;
        }
        static void Main(string[] args)
        {
            int res = Sum(11, 42);
            Console.WriteLine(res);
        }
    }
}
You can add as many parameters to a single method as you want. If you have multiple parameters, remember to separate them with commas, both when declaring them and when calling the method.

=============================
27.1 Optional and Named Arguments
=============================


When defining a method, you can specify a default value for optional parameters. Note that optional parameters must be defined after required parameters. If corresponding arguments are missing when the method is called, the method uses the default values.
To do this, assign values to the parameters in the method definition, as shown in this example.
static int Pow(int x, int y=2)
{
  int result = 1;
  for (int i = 0; i < y; i++)
  {
    result *= x;
  }
 
  return result;
}
CS
The Pow method assigns a default value of 2 to the y parameter. If we call the method without passing the value for the y parameter, the default value will be used.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static int Pow(int x, int y=2)
        {
            int result = 1;
            for (int i = 0; i < y; i++)
            {
                result *= x;
            }
            return result;
        }
        static void Main(string[] args)
        {
            Console.WriteLine(Pow(6));

            Console.WriteLine(Pow(3, 4));
        }
    }
}
As you can see, default parameter values can be used for calling the same method in different situations without requiring arguments for every parameter.
Just remember, that you must have the parameters with default values at the end of the parameter list when defining the method.

Named Arguments


Named arguments free you from the need to remember the order of the parameters in a method call. Each argument can be specified by the matching parameter name.
For example, the following method calculates the area of a rectangle by its height and width:
static int Area(int h, int w)
{
  return h * w;
}
CS
When calling the method, you can use the parameter names to provide the arguments in any order you like:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static int Area(int h, int w)
        {
            return h * w;
        }
        static void Main(string[] args)
        {
            int res = Area(w: 5, h: 8);
            Console.WriteLine(res);
        }
    }
}
Named arguments use the name of the parameter followed by a colon and the value.

=============================
28.1 Passing Arguments
=============================

There are three ways to pass arguments to a method when the method is called: By value, By reference, and as Output.

By value copies the argument's value into the method's formal parameter. Here, we can make changes to the parameter within the method without having any effect on the argument.
By default, C# uses call by value to pass arguments.
The following example demonstrates by value:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Sqr(int x)
        {
            x = x * x;
        }
        static void Main(string[] args)
        {
            int a = 3;
            Sqr(a);
            
            Console.WriteLine(a);
        }
    }
}
In this case, x is the parameter of the Sqr method and a is the actual argument passed into the method.
As you can see, the Sqr method does not change the original value of the variable, as it is passed by value, meaning that it operates on the value, not the actual variable.

Passing by Reference


Pass by reference copies an argument's memory address into the formal parameter. Inside the method, the address is used to access the actual argument used in the call. This means that changes made to the parameter affect the argument.
To pass the value by reference, the ref keyword is used in both the call and the method definition:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Sqr(ref int x)
        {
            x = x * x;
        }
        static void Main(string[] args)
        {
            int a = 3;
            Sqr(ref a);
            
            Console.WriteLine(a);
        }
    }
}
The ref keyword passes the memory address to the method parameter, which allows the method to operate on the actual variable.
The ref keyword is used both when defining the method and when calling it.

Passing by Output


Output parameters are similar to reference parameters, except that they transfer data out of the method rather than accept data in. They are defined using the out keyword.
The variable supplied for the output parameter need not be initialized since that value will not be used. Output parameters are particularly useful when you need to return multiple values from a method.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void GetValues(out int x, out int y)
        {
            x = 5;
            y = 42;
        }
        static void Main(string[] args)
        {
            int a, b;
            GetValues(out a, out b);
            Console.WriteLine(a+" "+b);
        }
    }
}
Unlike the previous reference type example, where the value 3 was referred to the method, which changed its value to 9, output parameters get their value from the method (5 and 42 in the above example).
Similar to the ref keyword, the out keyword is used both when defining the method and when calling it.

=============================
29.1 Method Overloading
=============================

Overloading


Method overloading is when multiple methods have the same name, but different parameters.
For example, you might have a Print method that outputs its parameter to the console window:
void Print(int a)
{
  Console.WriteLine("Value: "+a);
}
CS
The + operator is used to concatenate values. In this case, the value of a is joined to the text "Value: ".
This method accepts an integer argument only.
Overloading it will make it available for other types, such as double
void Print(double a)
{
  Console.WriteLine("Value: "+a);
}
CS
Now, the same Print method name will work for both integers and doubles.

Overloading


When overloading methods, the definitions of the methods must differ from each other by the types and/or number of parameters.
When there are overloaded methods, the method called is based on the arguments. An integer argument will call the method implementation that accepts an integer parameter. A double argument will call the implementation that accepts a double parameter. Multiple arguments will call the implementation that accepts the same number of arguments.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Print(int a) {
            Console.WriteLine("Value: " + a);
        }
        static void Print(double a) {
            Console.WriteLine("Value: " + a);
        }
        static void Print(string label, double a) {
            Console.WriteLine(label + a);
        }
        static void Main(string[] args)
        {
            Print(11);
            Print(4.13);
            Print("Average: ", 7.57);
        }
    }
}
You cannot overload method declarations that differ only by return type.
The following declaration results in an error.
int PrintName(int a) { }
float PrintName(int b) { }
double PrintName(int c) { }

=============================
30.1 Recursion
=============================
Recursion


A recursive method is a method that calls itself.
One of the classic tasks that can be solved easily by recursion is calculating the factorial of a number.
In mathematics, the term factorial refers to the product of all positive integers that are less than or equal to a specific non-negative integer (n). The factorial of n is denoted as n!
For example:
4! = 4 * 3 * 2 * 1 = 24
A recursive method is a method that calls itself.

Recursion


As you can see, a factorial can be thought of as repeatedly calculating num * num-1 until you reach 1.
Based on this solution, let's define our method:
static int Fact(int num) {
  if (num == 1) {
    return 1;
  }
  return num * Fact(num - 1);
}
CS
In the Fact recursive method, the if statement defines the exit condition, a base case that requires no recursion. In this case, when num equals one, the solution is simply to return 1 (the factorial of one is one).
The recursive call is placed after the exit condition and returns num multiplied by the factorial of n-1.
For example, if you call the Fact method with the argument 4, it will execute as follows:
return 4*Fact(3), which is 4*3*Fact(2), which is 4*3*2*Fact(1), which is 4*3*2*1.

Now we can call our Fact method from Main:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static int Fact(int num) {
            if (num == 1) {
                return 1;
            }
            return num * Fact(num - 1);
        }
        static void Main(string[] args)
        {
            Console.WriteLine(Fact(6));
        }
    }
}
The factorial method calls itself, and then continues to do so, until the argument equals 1. The exit condition prevents the method from calling itself indefinitely.

=============================
31.1 Making a Pyramid
=============================
Making a Pyramid


Now, let's create a method that will display a pyramid of any height to the console window using star (*) symbols.
Based on this description, a parameter will be defined to reflect the number of rows for the pyramid.

So, let's start by declaring the method:
static void DrawPyramid(int n)
{
   //some code will go here
}
CS
DrawPyramid does not need to return a value and takes an integer parameter n.
In programming, the step by step logic required for the solution to a problem is called an algorithm. The algorithm for MakePyramid is:
1. The first row should contain one star at the top center of the pyramid. The center is calculated based on the number of rows in the pyramid.
2. Each row after the first should contain an odd number of stars (1, 3, 5, etc.), until the number of rows is reached.

Based on the algorithm, the code will use for loops to display spaces and stars for each row:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
  class Program
  {
    static void DrawPyramid(int n)
    {
      for (int i=1; i<=n; i++)
      {
        for (int j=i; j<=n; j++)
        {
          Console.Write("  ");
        }
        for (int k=1; k<=2*i-1; k++)
        {
          Console.Write("*"+" ");
        }
        Console.WriteLine();
      }
    }
    static void Main(string[] args)
    {
      DrawPyramid(5);
    }
  }
}
The first for loop that iterates through each row of the pyramid contains two for loops.
The first inner loop displays the spaces needed before the first star symbol. The second inner loop displays the required number of stars for each row, which is calculated based on the formula (2*i-1) where i is the current row.
The final Console.WriteLine(); statement moves the cursor to the next row.
Now, if we call the DrawPyramid method, it will display a pyramid having the number of rows we pass to the method.

=============================
=============================
Classes & Objects
=============================
=============================

=============================
34.1 Classes & Objects
=============================

As we have seen in the previous modules, built-in data types are used to store a single value in a declared variable. For example, int x stores an integer value in a variable named x.
In object-oriented programming, a class is a data type that defines a set of variables and methods for a declared object.
For example, if you were to create a program that manages bank accounts, a BankAccount class could be used to declare an object that would have all the properties and methods needed for managing an individual bank account, such as a balance variable and Deposit and Withdrawal methods.

A class is like a blueprint. It defines the data and behavior for a type. A class definition starts with the keyword class followed by the class name. The class body contains the data and actions enclosed by curly braces.
class BankAccount
{
  //variables, methods, etc.
}
CS
The class defines a data type for objects, but it is not an object itself. An object is a concrete entity based on a class, and is sometimes referred to as an instance of a class.

Objects


Just as a built-in data type is used to declare multiple variables, a class can be used to declare multiple objects. As an analogy, in preparation for a new building, the architect designs a blueprint, which is used as a basis for actually building the structure. That same blueprint can be used to create multiple buildings.
Programming works in the same fashion. We define (design) a class that is the blueprint for creating objects.
In programming, the term type is used to refer to a class name: We're creating an object of a particular type.

Once we've written the class, we can create objects based on that class. Creating an object is called instantiation.
An object is called an instance of a class.

Objects


Each object has its own characteristics. Just as a person is distinguished by name, age, and gender, an object has its own set of values that differentiate it from another object of the same type.
The characteristics of an object are called properties.
Values of these properties describe the current state of an object. For example, a Person (an object of the class Person) can be 30 years old, male, and named Antonio.

Objects aren't always representative of just physical characteristics.
For example, a programming object can represent a date, a time, and a bank account. A bank account is not tangible; you can't see it or touch it, but it's still a well-defined object because it has its own properties.
Let's move on and see how to create your own custom classes and objects!

=============================
35.1 Value & Reference Types
=============================

C# has two ways of storing data: by reference and by value.
The built-in data types, such as int and double, are used to declare variables that are value types. Their value is stored in memory in a location called the stack.
For example, the declaration and assignment statement int x = 10; can be thought of as:contentImage
		Stack
		========
x -------------> 10	========
The value of the variable x is now stored on the stack.

Reference Types


Reference types are used for storing objects. For example, when you create an object of a class, it is stored as a reference type.
Reference types are stored in a part of the memory called the heap.
When you instantiate an object, the data for that object is stored on the heap, while its heap memory address is stored on the stack.
That is why it is called a reference type - it contains a reference (the memory address) to the actual object on the heap.
		Stack		Heap
		========	========
x -------------> 10	========	========
p1 --> 0x042b8	========  ---->	======== Person Object
As you can see, the p1 object of type Person on the stack stores the memory address of the heap where the actual object is stored.
Stack is used for static memory allocation, which includes all your value types, like x.
Heap is used for dynamic memory allocation, which includes custom objects, that might need additional memory during the runtime of your program.

=============================
36.1 Class Example
=============================
Example of a Class

Let’s create a Person class:
class Person
{
  int age;
  string name;
  public void SayHi()
  {
    Console.WriteLine("Hi");
  }
}
CS
The code above declares a class named Person, which has age and name fields as well as a SayHi method that displays a greeting to the screen.
You can include an access modifier for fields and methods (also called members) of a class. Access modifiers are keywords used to specify the accessibility of a member.
A member that has been defined public can be accessed from outside the class, as long as it's anywhere within the scope of the class object. That is why our SayHi method is declared public, as we are going to call it from outside of the class.
You can also designate class members as private or protected. This will be discussed in greater detail later in the course. If no access modifier is defined, the member is private by default.

Example of a Class


Now that we have our Person class defined, we can instantiate an object of that type in Main.
The new operator instantiates an object and returns a reference to its location:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Person {
            int age;
            string name;
            public void SayHi() {
                Console.WriteLine("Hi");
            }
        }
        static void Main(string[] args)
        {
            Person p1 = new Person();
            p1.SayHi();
        }
    }
}
The code above declares a Person object named p1 and then calls its public SayHi() method.
Notice the dot operator (.) that is used to access and call the method of the object.

Example of a Class


You can access all public members of a class using the dot operator.
Besides calling a method, you can use the dot operator to make an assignment when valid.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Dog
        {
            public string name;
            public int age;
        }
        static void Main(string[] args)
        {
            Dog bob = new Dog();
            bob.name = "Bobby";
            bob.age = 3;
            
            Console.WriteLine(bob.age);
        }
    }
}

=============================
37.1 Encapsulation
=============================

Encapsulation


Part of the meaning of the word encapsulation is the idea of "surrounding" an entity, not just to keep what's inside together, but also to protect it.
In programming, encapsulation means more than simply combining members together within a class; it also means restricting access to the inner workings of that class.
Encapsulation is implemented by using access modifiers. An access modifier defines the scope and visibility of a class member.
Encapsulation is also called information hiding.

Encapsulation

C# supports the following access modifiers: public, private, protected, internal, protected internal.
As seen in the previous examples, the public access modifier makes the member accessible from the outside of the class.
The private access modifier makes members accessible only from within the class and hides them from the outside.
protected will be discussed later in the course.

Encapsulation


To show encapsulation in action, let’s consider the following example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class BankAccount {
        private double balance=0;
        public void Deposit(double n) {
            balance += n;
        }
        public void Withdraw(double n) {
            balance -= n;
        }
        public double GetBalance() {
            return balance;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            BankAccount b = new BankAccount();
            b.Deposit(199);
            b.Withdraw(42);
            Console.WriteLine(b.GetBalance());
        }
    }
}
We used encapsulation to hide the balance member from the outside code. Then we provided restricted access to it using public methods. The class data can be read through the GetBalance method and modified only through the Deposit and Withdraw methods.
You cannot directly change the balance variable. You can only view its value using the public method. This helps maintain data integrity.
We could add different verification and checking mechanisms to the methods to provide additional security and prevent errors.
In summary, the benefits of encapsulation are:
- Control the way data is accessed or modified.
- Code is more flexible and easy to change with new requirements.
- Change one part of code without affecting other parts of code.

=============================
38.1 Constructors
=============================
Constructors


A class constructor is a special member method of a class that is executed whenever a new object of that class is created.
A constructor has exactly the same name as its class, is public, and does not have any return type.
For example:
class Person
{
  private int age;
  public Person()
  {
    Console.WriteLine("Hi there");
  }
}
CS
Now, upon the creation of an object of type Person, the constructor is automatically called.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Person
        {
            private int age;
            public Person()
            {
                Console.WriteLine("Hi there");
            }
        }
        static void Main(string[] args)
        {
            Person p = new Person();
        }
    }
}
This can be useful in a number of situations. For example, when creating an object of type BankAccount, you could send an email notification to the owner.
The same functionality could be achieved using a separate public method. The advantage of the constructor is that it is called automatically.

Constructors


Constructors can be very useful for setting initial values for certain member variables.
A default constructor has no parameters. However, when needed, parameters can be added to a constructor. This makes it possible to assign an initial value to an object when it's created, as shown in the following example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Person
        {
            private int age;
            private string name;
            public Person(string nm)
            {
                name = nm;
            }
            public string getName()
            {
                return name;
            }
        }
        static void Main(string[] args)
        {
            Person p = new Person("David");
            Console.WriteLine(p.getName());
        }
    }
}
Now, when the object is created, we can pass a parameter that will be assigned to the name variable.
Constructors can be overloaded like any method by using different numbers of parameters.

=============================
39.1 Properties
=============================

Properties


As we have seen in the previous lessons, it is a good practice to encapsulate members of a class and provide access to them only through public methods.
A property is a member that provides a flexible mechanism to read, write, or compute the value of a private field. Properties can be used as if they are public data members, but they actually include special methods called accessors.
The accessor of a property contains the executable statements that help in getting (reading or computing) or setting (writing) a corresponding field. Accessor declarations can include a get accessor, a set accessor, or both.
For example:
class Person
{
  private string name; //field

  public string Name //property
  {
    get { return name; }
    set { name = value; }
  }
}
CS
The Person class has a Name property that has both the set and the get accessors.
The set accessor is used to assign a value to the name variable; get is used to return its value.
value is a special keyword, which represents the value we assign to a property using the set accessor.
The name of the property can be anything you want, but coding conventions dictate properties have the same name as the private field with a capital letter.

Properties

Once the property is defined, we can use it to assign and read the private member:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Person
        {
            private string name;
            public string Name
            {
                get { return name; }
                set { name = value; }
            }
        }
        static void Main(string[] args)
        {
            Person p = new Person();
            p.Name = "Bob";
            Console.WriteLine(p.Name);
        }
    }
}
The property is accessed by its name, just like any other public member of the class.

=============================
=============================
Arrays and Strings
=============================
=============================

=============================
42.1 Arrays
=============================

C# provides numerous built-in classes to store and manipulate data.
One example of such a class is the Array class.
An array is a data structure that is used to store a collection of data. You can think of it as a collection of variables of the same type.
For example, consider a situation where you need to store 100 numbers. Rather than declare 100 different variables, you can just declare an array that stores 100 elements.
To declare an array, specify its element types with square brackets:
int[ ] myArray;
CS
This statement declares an array of integers.
Since arrays are objects, we need to instantiate them with the new keyword:
int[ ] myArray = new int[5]; 
CS
This instantiates an array named myArray that holds 5 integers.
Note the square brackets used to define the number of elements the array should hold.

Arrays

After creating the array, you can assign values to individual elements by using the index number:
int[ ] myArray = new int[5];
myArray[0] = 23;
CS
This will assign the value 23 to the first element of the array.
Arrays in C# are zero-indexed meaning the first member has index 0, the second has index 1, and so on.

Arrays


We can provide initial values to the array when it is declared by using curly brackets:
string[ ] names = new string[3] {"John", "Mary", "Jessica"};
double[ ] prices = new double[4] {3.6, 9.8, 6.4, 5.9};
CS
We can omit the size declaration when the number of elements are provided in the curly braces:
string[ ] names = new string[ ] {"John", "Mary", "Jessica"};
double[ ] prices = new double[ ] {3.6, 9.8, 6.4, 5.9};
CS
We can even omit the new operator. The following statements are identical to the ones above:
string[ ] names = {"John", "Mary", "Jessica"};
double[ ] prices = {3.6, 9.8, 6.4, 5.9};
CS
Array values should be provided in a comma separated list enclosed in {curly braces}.

Arrays


As mentioned, each element of an array has an index number.
For example, consider the following array:
int[ ] b = {11, 45, 62, 70, 88};
	11	45	62	70	88
	[0]	[1]	[2]	[3]	[4]
CS
The elements of b have the following indexes:contentImageTo access individual array elements, place the element's index number in square brackets following the array name.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int[ ] b = {11, 45, 62, 70, 88};

            Console.WriteLine(b[2]);
            Console.WriteLine(b[3]);
        }
    }
}
Remember that the first element has index 0.

=============================
43.1 Using Arrays in Loops
=============================

Arrays & Loops


It's occasionally necessary to iterate through the elements of an array, making element assignments based on certain calculations. This can be easily done using loops.
For example, you can declare an array of 10 integers and assign each element an even value with the following loop:
int[ ] a = new int[10];
for (int k = 0; k < 10; k++) {
  a[k] = k*2;
}
CS
We can also use a loop to read the values of an array.
For example, we can display the contents of the array we just created:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int[ ] a = new int[10];
            for (int k = 0; k < 10; k++) {
                a[k] = k*2;
            }
            for (int k = 0; k < 10; k++) {
                Console.WriteLine(a[k]);
            }
        }
    }
}
This will display the values of the elements of the array.
The variable k is used to access each array element.
The last index in the array is 9, so the for loop condition is k<10.

The foreach Loop


The foreach loop provides a shorter and easier way of accessing array elements.
The previous example of accessing the elements could be written using a foreach loop:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int[ ] a = new int[10];
            for (int k = 0; k < 10; k++) {
                a[k] = k*2;
            }
            foreach (int k in a) {
                Console.WriteLine(k);
            }
        }
    }
}
The foreach loop iterates through the array a and assigns the value of the current element to the variable k at each iteration of the loop. So, at the first iteration, k=a[0], at the second, k=a[1], etc.
The data type of the variable in the foreach loop should match the type of the array elements.
Often the keyword var is used as the type of the variable, as in: foreach (var k in a). The compiler determines the appropriate type for var.

Arrays


The following code uses a foreach loop to calculate the sum of all the elements of an array:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int[ ] arr = {11, 35, 62, 555, 989};
            int sum = 0; 
            
            foreach (int x in arr) {
                sum += x;
            }
            Console.WriteLine(sum);
        }
    }
}
To review, we declared an array and a variable sum that will hold the sum of the elements.
Next, we utilized a foreach loop to iterate through each element of the array, adding the corresponding element's value to the sum variable.
The Array class provides some useful methods that will be discussed in the coming lessons.

=============================
44.1 Multidimensional Arrays
=============================


An array can have multiple dimensions. A multidimensional array is declared as follows:
type[, , … ,] arrayName = new type[size1, size2, …, sizeN];
CS
For example, let's define a two-dimensional 3x4 integer array:
int[ , ] x = new int[3,4];
CS
Visualize this array as a table composed of 3 rows and 4 columns:
	Column1		Column2	Column3	Column4
Row1	x[0][0]		x[0][1]		x[0][2]		x[0][3]
Row2	x[1][0]		x[1][1]		x[1][2]		x[1][3]
Row3	x[2][0]		x[2][1]		x[2][2]		x[2][3]
Array indexing starts from 0.

Multidimensional Arrays


We can initialize multidimensional arrays in the same way as single-dimensional arrays.
For example:
int[ , ] someNums = { {2, 3}, {5, 6}, {4, 6} }; 
CS
This will create an array with three rows and two columns. Nested curly brackets are used to define values for each row.
To access an element of the array, provide both indexes. For example someNums[2, 0] will return the value 4, as it accesses the first column of the third row.
Let's create a program that will display the values of the array in the form of a table.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int[ , ] someNums = { {2, 3}, {5, 6}, {4, 6} }; 
            for (int k = 0; k < 3; k++) {
                for (int j = 0; j < 2; j++) {
                    Console.Write(someNums[k, j]+" ");
                }
                Console.WriteLine();
            }
        }
    }
}
We have used two nested for loops, one to iterate through the rows and one through the columns.
The Console.WriteLine(); statement moves the output to a new line after one row is printed.
Arrays can have any number of dimensions, but keep in mind that arrays with more than three dimensions are harder to manage.

=============================
45.1 Jagged Arrays
=============================
Jagged Arrays


A jagged array is an array whose elements are arrays. So it is basically an array of arrays.
The following is a declaration of a single-dimensional array that has three elements, each of which is a single-dimensional array of integers:
int[ ][ ] jaggedArr = new int[3][ ];
CS
Each dimension is an array, so you can also initialize the array upon declaration like this:
int[ ][ ] jaggedArr = new int[ ][ ] 
{
  new int[ ] {1,8,2,7,9},
  new int[ ] {2,4,6},
  new int[ ] {33,42}
};
CS
You can access individual array elements as shown in the example below:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int[ ][ ] jaggedArr = new int[ ][ ] 
            {
                new int[ ] {1,8,2,7,9},
                new int[ ] {2,4,6},
                new int[ ] {33,42}
            };
            int x = jaggedArr[2][1];
            Console.WriteLine(x);
        }
    }
}
This accesses the second element of the third array.
A jagged array is an array-of-arrays, so an int[ ][ ] is an array of int[ ], each of which can be of different lengths and occupy their own block in memory.
A multidimensional array (int[,]) is a single block of memory (essentially a matrix). It always has the same amount of columns for every row.

=============================
46.1 Array Properties & Methods
=============================

Arrays Properties


The Array class in C# provides various properties and methods to work with arrays.
For example, the Length and Rank properties return the number of elements and the number of dimensions of the array, respectively. You can access them using the dot syntax, just like any class members:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int[ ] arr = {2, 4, 7};
            
            Console.WriteLine(arr.Length); 
            
            Console.WriteLine(arr.Rank); 
        }
    }
}
The Length property can be useful in for loops where you need to specify the number of times the loop should run.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int[ ] arr = {2, 4, 7};
            for(int k=0; k<arr.Length; k++) {
                Console.WriteLine(arr[k]);
            }
        }
    }
}

Array Methods


There are a number of methods available for arrays.
Max returns the largest value.
Min returns the smallest value.
Sum returns the sum of all elements.

For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int[ ] arr = { 2, 4, 7, 1};
            Console.WriteLine(arr.Max());
            Console.WriteLine(arr.Min());
            Console.WriteLine(arr.Sum());
        }
    }
}
C# also provides a static Array class with additional methods. You will learn about those in the next module.

=============================
47.1 Working with Strings
=============================

Strings


It’s common to think of strings as arrays of characters. In reality, strings in C# are objects.
When you declare a string variable, you basically instantiate an object of type String.
String objects support a number of useful properties and methods:
Length returns the length of the string.
IndexOf(value) returns the index of the first occurrence of the value within the string.
Insert(index, value) inserts the value into the string starting from the specified index.
Remove(index) removes all characters in the string from the specified index.
Replace(oldValue, newValue) replaces the specified value in the string.
Substring(index, length) returns a substring of the specified length, starting from the specified index. If length is not specified, the operation continues to the end of the string.
Contains(value) returns true if the string contains the specified value.

The examples below demonstrate each of the String members:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            string a = "some text";
            Console.WriteLine(a.Length);
            //Outputs 9

            Console.WriteLine(a.IndexOf('t'));
            //Outputs 5

             a = a.Insert(0, "This is ");
            Console.WriteLine(a);
            //Outputs "This is some text"

            a = a.Replace("This is", "I am");
            Console.WriteLine(a);
            //Outputs "I am some text"

            if(a.Contains("some"))
                Console.WriteLine("found");
            //Outputs "found"

            a = a.Remove(4);
            Console.WriteLine(a);
            //Outputs "I am"

            a = a.Substring(2);
            Console.WriteLine(a);
            //Outputs "am"
        }
    }
}
You can also access characters of a string by its index, just like accessing elements of an array:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            string a = "some text";
            Console.WriteLine(a[2]);
        }
    }
}
Indexes in strings are similar to arrays, they start from 0.

Working with Strings


Let's create a program that will take a string, replace all occurrences of the word "dog" with "cat" and output the first sentence only.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            string text = "This is some text about a dog. The word dog appears in this text a number of times. This is the end.";
            text = text.Replace("dog", "cat");
            text = text.Substring(0, text.IndexOf(".")+1);
            
            Console.WriteLine(text);
        }
    }
}
The code above replaces all occurrences of "dog" with "cat". After that it takes a substring of the original string starting from the first index until the first occurrence of a period character.
We add one to the index of the period to include the period in the substring.
C# provides a solid collection of tools and methods to work and manipulate strings. You could, for example, find the number of times a specific word appears in a book with ease, using those methods.

=============================
=============================
More on Classes
=============================
=============================

=============================
50.1 Destructors
=============================

Destructors


As constructors are used when a class is instantiated, destructors are automatically invoked when an object is destroyed or deleted.
Destructors have the following attributes:
- A class can only have one destructor.
- Destructors cannot be called. They are invoked automatically.
- A destructor does not take modifiers or have parameters.
- The name of a destructor is exactly the same as the class prefixed with a tilde (~).
For Example:
class Dog
{
  ~Dog() 
  {
    // code statements
  }
}
CS
Destructors can be very useful for releasing resources before coming out of the program. This can include closing files, releasing memory, and so on.

Destructors


Let’s include WriteLine statements in the destructor and constructor of our class and see how the program behaves when an object of that class is created and when the program ends:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Dog
        {
            public Dog() {
                Console.WriteLine("Constructor");
            }
            ~Dog() {
                Console.WriteLine("Destructor");
            }
        }
        static void Main(string[] args)
        {
            Dog d = new Dog();
        }
    }
}
When the program runs, it first creates the object, which calls the constructor. The object is deleted at the end of the program and the destructor is invoked when the program's execution is complete.
This can be useful, for example, if your class is working with storage or files. The constructor would initialize and open the files. Then, when the program ends, the destructor would close the files.

=============================
51.1 Static Members
=============================

Static


Now it's time to discuss the static keyword.
You first noticed it in the Main method's declaration:
static void Main(string[] args)
CS
Class members (variables, properties, methods) can also be declared as static. This makes those members belong to the class itself, instead of belonging to individual objects. No matter how many objects of the class are created, there is only one copy of the static member.
For example:
class Cat {
  public static int count=0;
  public Cat() {
    count++;
  }
}
CS
In this case, we declared a public member variable count, which is static. The constructor of the class increments the count variable by one.
No matter how many Cat objects are instantiated, there is always only one count variable that belongs to the Cat class because it was declared static.

Static


Because of their global nature, static members can be accessed directly using the class name without an object.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Cat {
            public static int count=0;
            public Cat() {
                count++;
            }
        }
        static void Main(string[] args)
        {
            Cat c1 = new Cat();
            Cat c2 = new Cat();
            Console.WriteLine(Cat.count);
        }
    }
}
As you can see, we can access the static variable using the class name: Cat.count.
The count variable is shared between all Cat objects. For this class, each time an object is created, the static value is incremented. The program above demonstrates this when 2 is displayed after creating two objects of that class.
You must access static members using the class name. If you try to access them via an object of that class, you will generate an error.

Static Methods


The same concept applies to static methods.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Dog
        {
            public static void Bark() {
                Console.WriteLine("Woof");
            }
        }
        static void Main(string[] args)
        {
            Dog.Bark();
        }
    }
}
Static methods can access only static members.
The Main method is static, as it is the starting point of any program. Therefore any method called directly from Main had to be static.

Static


Constant members are static by definition.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class MathClass {
            public const int ONE = 1;
        }
        static void Main(string[] args)
        {
            Console.Write(MathClass.ONE);
        }
    }
}
As you can see, we access the property ONE using the name of the class, just like a static member. This is because all const members are static by default.

Static Constructors

Constructors can be declared static to initialize static members of the class.
The static constructor is automatically called once when we access a static member of the class.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class SomeClass {
            public static int X { get; set; }
            public static int Y { get; set; }
            
            static SomeClass() {
                X = 10;
                Y = 20;
            }
        }
        static void Main(string[] args)
        {
            Console.WriteLine(SomeClass.X);
        }
    }
}
The constructor will get called once when we try to access SomeClass.X or SomeClass.Y.

=============================
52.1 Static Classes
=============================

Static Classes


An entire class can be declared as static.
A static class can contain only static members.
You cannot instantiate an object of a static class, as only one instance of the static class can exist in a program.
Static classes are useful for combining logical properties and methods. A good example of this is the Math class.
It contains various useful properties and methods for mathematical operations.
For example, the Pow method raises a number to a power:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Math.Pow(2, 3));
        }
    }
}
You access all members of the Math class using the class name, without declaring an object.
Tap next to learn about the available methods of the Math class.

Static Classes


There are a number of useful static methods and properties available in C#:

Math

Math.PI the constant PI.
Math.E represents the natural logarithmic base e.
Math.Max() returns the larger of its two arguments.
Math.Min() returns the smaller of its two arguments.
Math.Abs() returns the absolute value of its argument.
Math.Sin() returns the sine of the specified angle.
Math.Cos() returns the cosine of the specified angle.
Math.Pow() returns a specified number raised to the specified power.
Math.Round() rounds the decimal number to its nearest integral value.
Math.Sqrt() returns the square root of a specified number.

Array

The Array class includes some static methods for manipulating arrays:
int[] arr = {1, 2, 3, 4};

Array.Reverse(arr);
//arr = {4, 3, 2, 1}

Array.Sort(arr);
//arr = {1, 2, 3, 4}
CS
String
string s1 = "some text";
string s2 = "another text";

String.Concat(s1, s2); // combines the two strings

String.Equals(s1, s2); // returns false
CS
DateTime

The DateTime structure allows you to work with dates.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(DateTime.Now);
            Console.WriteLine(DateTime.Today);
            
            Console.WriteLine(DateTime.DaysInMonth(2016, 2));
        }
    }
}
The Console class is also an example of a static class. We use its static WriteLine() method to output to the screen, or the static ReadLine() method to get user input.
The Convert class used to convert value types is also a static class.

=============================
53.1 this & readonly
=============================

The this Keyword


The this keyword is used inside the class and refers to the current instance of the class, meaning it refers to the current object.
One of the common uses of this is to distinguish class members from other data, such as local or formal parameters of a method, as shown in the following example:
class Person {
  private string name;
  public Person(string name) {
    this.name = name;
  }
}
CS
Here, this.name represents the member of the class, whereas name represents the parameter of the constructor.
Another common use of this is for passing the current instance to a method as parameter: ShowPersonInfo(this);

The readonly Modifier


The readonly modifier prevents a member of a class from being modified after construction. It means that the field declared as readonly can be modified only when you declare it or from within a constructor.
For example:
class Person {
  private readonly string name = "John"; 
  public Person(string name) {
    this.name = name; 
  }
}
CS
If we try to modify the name field anywhere else, we will get an error.
There are three major differences between readonly and const fields.
First, a constant field must be initialized when it is declared, whereas a readonly field can be declared without initialization, as in:
readonly string name; // OK
const double PI; // Error
CS
Second, a readonly field value can be changed in a constructor, but a constant value cannot.
Third, the readonly field can be assigned a value that is a result of a calculation, but constants cannot, as in:
readonly double a = Math.Sin(60); // OK
const double b = Math.Sin(60); // Error! 
CS
The readonly modifier prevents a member of a class from being modified after construction.

=============================
54.1 Indexers
=============================

Indexers


An indexer allows objects to be indexed like an array.
As discussed earlier, a string variable is actually an object of the String class. Further, the String class is actually an array of Char objects. In this way, the string class implements an indexer so we can access any character (Char object) by its index:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = "Hello World";
            char x = str[4];
            Console.WriteLine(x);
        }
    }
}
Arrays use integer indexes, but indexers can use any type of index, such as strings, characters, etc.

Indexers


Declaration of an indexer is to some extent similar to a property. The difference is that indexer accessors require an index.
Like a property, you use get and set accessors for defining an indexer. However, where properties return or set a specific data member, indexers return or set a particular value from the object instance.
Indexers are defined with the this keyword.
For example:
class Clients {
  private string[] names = new string[10];

  public string this[int index] {
    get {
      return names[index];
    }
    set {
      names[index] = value;
    }
  }
}
CS
As you can see, the indexer definition includes the this keyword and an index, which is used to get and set the appropriate value.
Now, when we declare an object of class Clients, we use an index to refer to specific objects like the elements of an array:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Clients {
            private string[] names = new string[10];
            public string this[int index] {
                get {
                    return names[index];
                }
                set {
                    names[index] = value;
                }
            }
        }
        static void Main(string[] args)
        {
            Clients c = new Clients();
            c[0] = "Dave";
            c[1] = "Bob";
            
            Console.WriteLine(c[1]);
        }
    }
}
You typically use an indexer if the class represents a list, collection, or array of objects.

=============================
55.1 Operator Overloading
=============================

Operator Overloading


Most operators in C# can be overloaded, meaning they can be redefined for custom actions.
For example, you can redefine the action of the plus (+) operator in a custom class.
Consider the Box class that has Height and Width properties:
class Box {
  public int Height {get; set;}
  public int Width {get; set;}
  public Box(int h, int w) {
    Height = h;
    Width = w;
  }
}
static void Main(string[] args) {
  Box b1 = new Box(14, 3);
  Box b2 = new Box(5, 7);
}
CS
We would like to add these two Box objects, which would result in a new, bigger Box.
So, basically, we would like the following code to work:
 Box b3 = b1 + b2;
CS
The Height and Width properties of object b3 should be equal to the sum of the corresponding properties of the b1 and b2 objects.
This is achieved through operator overloading. Tap next to learn more!

Operator Overloading


Overloaded operators are methods with special names, where the keyword operator is followed by the symbol for the operator being defined.
Similar to any other method, an overloaded operator has a return type and a parameter list.
For example, for our Box class, we overload the + operator:
public static Box operator+ (Box a, Box b) {
  int h = a.Height + b.Height;
  int w = a.Width + b.Width;
  Box res = new Box(h, w);
  return res;
}
CS
The method above defines an overloaded operator + with two Box object parameters and returning a new Box object whose Height and Width properties equal the sum of its parameter's corresponding properties.
Additionally, the overloaded operator must be static.
Putting it all together:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Box {
            public int Height { get; set; }
            public int Width { get; set; }
            public Box(int h, int w) {
                Height = h;
                Width = w;
            }
            public static Box operator+(Box a, Box b) {
                int h = a.Height + b.Height;
                int w = a.Width + b.Width;
                Box res = new Box(h, w);
                return res;
            }
        }
        static void Main(string[] args)
        {
            Box b1 = new Box(14, 3);
            Box b2 = new Box(5, 7);
            Box b3 = b1 + b2;
            
            Console.WriteLine(b3.Height);
            Console.WriteLine(b3.Width);
        }
    }
}
All arithmetic and comparison operators can be overloaded. For instance, you could define greater than and less than operators for the boxes that would compare the Boxes and return a boolean result. Just keep in mind that when overloading the greater than operator, the less than operator should also be defined.

=============================
=============================
Inheritance & Polymorphism
=============================
=============================

=============================
58.1 Inheritance
=============================

Inheritance allows us to define a class based on another class. This makes creating and maintaining an application easy.
The class whose properties are inherited by another class is called the Base class. The class which inherits the properties is called the Derived class.
For example, base class Animal can be used to derive Cat and Dog classes.
The derived class inherits all the features from the base class, and can have its own additional features.contentImage
Base Class::		Derived Class::
|| Base class		Base class features
|| features		================
			Derived class features
Inheritance allows us to define a class based on another class.

Inheritance


Let's define our base class Animal:
class Animal {
  public int Legs {get; set;}
  public int Age {get; set;}
}
CS
Now we can derive class Dog from it:
class Dog : Animal {
  public Dog() {
    Legs = 4;
  }
  public void Bark() {
    Console.Write("Woof");
  }
}
CS
Note the syntax for a derived class. A colon and the name of the base class follow the name of the derived class.
All public members of Animal become public members of Dog. That is why we can access the Legs member in the Dog constructor.
Now we can instantiate an object of type Dog and access the inherited members as well as call its own Bark method.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Animal {
            public int Legs {get; set;}
            public int Age {get; set;}
        }
        class Dog : Animal {
            public Dog() {
                Legs = 4;
            }
            public void Bark() {
                Console.Write("Woof");
            }
        }
        static void Main(string[] args)
        {
            Dog d = new Dog();
            Console.WriteLine(d.Legs);
            
            d.Bark();
        }
    }
}
A base class can have multiple derived classes. For example, a Cat class can inherit from Animal.
Inheritance allows the derived class to reuse the code in the base class without having to rewrite it. And the derived class can be customized by adding more members. In this manner, the derived class extends the functionality of the base class.

Inheritance


A derived class inherits all the members of the base class, including its methods.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Person {
            public void Speak() {
                Console.WriteLine("Hi there");
            }
        }
        class Student : Person {
            int number;
        }
        static void Main(string[] args)
        {
            Student s = new Student();
            s.Speak();
        }
    }
}
We created a Student object and called the Speak method, which was declared in the base class Person.
C# does not support multiple inheritance, so you cannot inherit from multiple classes.
However, you can use interfaces to implement multiple inheritance. You will learn more about interfaces in the coming lessons.

=============================
59.1 Protected Members
=============================

protected


Up to this point, we have worked exclusively with public and private access modifiers.
Public members may be accessed from anywhere outside of the class, while access to private members is limited to their class.
The protected access modifier is very similar to private with one difference; it can be accessed in the derived classes. So, a protected member is accessible only from derived classes.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Person {
            protected int Age {get; set;}
            protected string Name {get; set;}
        }
        class Student : Person {
            public Student(string nm) {
                Name = nm;
            }
            public void Speak() {
                Console.Write("Name: "+Name);
            }
        }
        static void Main(string[] args)
        {
            Student s = new Student("David");
            s.Speak();
        }
    }
}
As you can see, we can access and modify the Name property of the base class from the derived class.
But, if we try to access it from outside code, we will get an error:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Person {
            protected int Age {get; set;}
            protected string Name {get; set;}
        }
        class Student : Person {
            public Student(string nm) {
                Name = nm;
            }
            public void Speak() {
                Console.Write("Name: "+Name);
            }
        }
        static void Main(string[] args)
        {
            Student s = new Student("David");
            s.Name = "Bob"; 
        }
    }
}

sealed


A class can prevent other classes from inheriting it, or any of its members, by using the sealed modifier.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        sealed class Animal {
            //some code
        }
        class Dog : Animal { } //Error
        
        static void Main(string[] args)
        {
            
        }
    }
}
In this case, we cannot derive the Dog class from the Animal class because Animal is sealed.
The sealed keyword provides a level of protection to your class so that other classes cannot inherit from it.

=============================
60.1 Derived Class Constructor & Destructor
=============================

Inheritance


Constructors are called when objects of a class are created. With inheritance, the base class constructor and destructor are not inherited, so you should define constructors for the derived classes.
However, the base class constructor and destructor are being invoked automatically when an object of the derived class is created or deleted.
Consider the following example:
class Animal {
  public Animal() {
    Console.WriteLine("Animal created");
  }
  ~Animal() {
    Console.WriteLine("Animal deleted");
  }
}
class Dog: Animal {
  public Dog() {
    Console.WriteLine("Dog created");
  }
  ~Dog() {
    Console.WriteLine("Dog deleted");
  }
}
CS
We have defined the Animal class with a constructor and destructor and a derived Dog class with its own constructor and destructor.
So what will happen when we create an object of the derived class? Tap next to find out!

Inheritance


Let's create a Dog object:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Animal {
            public Animal() {
                Console.WriteLine("Animal created");
            }
            ~Animal() {
                Console.WriteLine("Animal deleted");
            }
        }
        class Dog: Animal {
            public Dog() {
                Console.WriteLine("Dog created");
            }
            ~Dog() {
                Console.WriteLine("Dog deleted");
            }
        }
        static void Main(string[] args)
        {
            Dog d = new Dog();
        }
    }
}
Note that the base class constructor is called first and the derived class constructor is called next.
When the object is destroyed, the derived class destructor is invoked and then the base class destructor is invoked.
You can think of it as the following: The derived class needs its base class in order to work, which is why the base class constructor is called first.

=============================
61.1 Polymorphism
=============================

Polymorphism


The word polymorphism means "having many forms".
Typically, polymorphism occurs when there is a hierarchy of classes and they are related through inheritance from a common base class.
Polymorphism means that a call to a member method will cause a different implementation to be executed depending on the type of object that invokes the method.
Simply, polymorphism means that a single method can have a number of different implementations.

Polymorphism


Consider having a program that allows users to draw different shapes. Each shape is drawn differently, and you do not know which shape the user will choose.
Here, polymorphism can be leveraged to invoke the appropriate Draw method of any derived class by overriding the same method in the base class. Such methods must be declared using the virtual keyword in the base class.
For example:
class Shape {
  public virtual void Draw() {
    Console.Write("Base Draw");
  }
}
CS
The virtual keyword allows methods to be overridden in derived classes.
Virtual methods enable you to work with groups of related objects in a uniform way.

Polymorphism


Now, we can derive different shape classes that define their own Draw methods using the override keyword:
class Circle : Shape {
  public override void Draw() {
    // draw a circle...
    Console.WriteLine("Circle Draw");
  }
}
class Rectangle : Shape {
  public override void Draw() {
    // draw a rectangle...
    Console.WriteLine("Rect Draw");
  }
}
CS
The virtual Draw method in the Shape base class can be overridden in the derived classes. In this case, Circle and Rectangle have their own Draw methods.
Now, we can create separate Shape objects for each derived type and then call their Draw methods:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Shape {
            public virtual void Draw() {
                Console.Write("Base Draw");
            }
        }
        class Circle : Shape {
            public override void Draw() {
                // draw a circle...
                Console.WriteLine("Circle Draw");
            }
        }
        class Rectangle : Shape {
            public override void Draw() {
                // draw a rectangle...
                Console.WriteLine("Rect Draw");
            }
        }
        static void Main(string[] args)
        {
            Shape c = new Circle();
            c.Draw();

            Shape r = new Rectangle();
            r.Draw();
        }
    }
}
As you can see, each object invoked its own Draw method, thanks to polymorphism.

Polymorphism


To summarize, polymorphism is a way to call the same method for different objects and generate different results based on the object type. This behavior is achieved through virtual methods in the base class.
To implement this, we create objects of the base type, but instantiate them as the derived type:
Shape c = new Circle();
CS
Shape is the base class. Circle is the derived class.
So why use polymorphism? We could just instantiate each object of its type and call its method, as in:
Circle c = new Circle();
c.Draw();
CS
The polymorphic approach allows us to treat each object the same way. As all objects are of type Shape, it is easier to maintain and work with them. You could, for example, have a list (or array) of objects of that type and work with them dynamically, without knowing the actual derived type of each object.
Polymorphism can be useful in many cases. For example, we could create a game where we would have different Player types with each Player having a separate behavior for the Attack method.
In this case, Attack would be a virtual method of the base class Player and each derived class would override it.

=============================
62.1 Abstract Classes
=============================
Abstract Classes


As described in the previous example, polymorphism is used when you have different derived classes with the same method, which has different implementations in each class. This behavior is achieved through virtual methods that are overridden in the derived classes.
In some situations there is no meaningful need for the virtual method to have a separate definition in the base class.
These methods are defined using the abstract keyword and specify that the derived classes must define that method on their own.
You cannot create objects of a class containing an abstract method, which is why the class itself should be abstract.
We could use an abstract method in the Shape class:
abstract class Shape {
   public abstract void Draw();
}
CS
As you can see, the Draw method is abstract and thus has no body. You do not even need the curly brackets; just end the statement with a semicolon.
The Shape class itself must be declared abstract because it contains an abstract method. Abstract method declarations are only permitted in abstract classes.
Remember, abstract method declarations are only permitted in abstract classes. Members marked as abstract, or included in an abstract class, must be implemented by classes that derive from the abstract class. An abstract class can have multiple abstract members.

Abstract Classes


An abstract class is intended to be a base class of other classes. It acts like a template for its derived classes.
Now, having the abstract class, we can derive the other classes and define their own Draw() methods:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        abstract class Shape {
            public abstract void Draw();
        }
        class Circle : Shape {
            public override void Draw() {
                Console.WriteLine("Circle Draw");
            }
        }
        class Rectangle : Shape {
            public override void Draw() {
                Console.WriteLine("Rect Draw");
            }
        }
        static void Main(string[] args)
        {
            Shape c = new Circle();
            c.Draw();
        }
    }
}
Abstract classes have the following features:
- An abstract class cannot be instantiated.
- An abstract class may contain abstract methods and accessors.
- A non-abstract class derived from an abstract class must include actual implementations of all inherited abstract methods and accessors.
It is not possible to modify an abstract class with the sealed modifier because the two modifiers have opposite meanings. The sealed modifier prevents a class from being inherited and the abstract modifier requires a class to be inherited.

=============================
63.1 Interfaces
=============================

An interface is a completely abstract class, which contains only abstract members.
It is declared using the interface keyword:
public interface IShape
{
  void Draw();
}
CS
All members of the interface are by default abstract, so no need to use the abstract keyword.

Interfaces can have public (by default), private and protected members.
It is common to use the capital letter I as the starting letter for an interface name.
Interfaces can contain properties, methods, etc. but cannot contain fields (variables).

Interfaces


When a class implements an interface, it must also implement, or define, all of its methods.
The term implementing an interface is used (opposed to the term "inheriting from") to describe the process of creating a class based on an interface. The interface simply describes what a class should do. The class implementing the interface must define how to accomplish the behaviors.
The syntax to implement an interface is the same as that to derive a class:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        public interface IShape {
            void Draw();
        }
        class Circle : IShape {
            public void Draw() {
                Console.WriteLine("Circle Draw");
            }
        }
        static void Main(string[] args)
        {
            IShape c = new Circle();
            c.Draw();
        }
    }
}
Note, that the override keyword is not needed when you implement an interface.
But why use interfaces rather than abstract classes?
A class can inherit from just one base class, but it can implement multiple interfaces!
Therefore, by using interfaces you can include behavior from multiple sources in a class.
To implement multiple interfaces, use a comma separated list of interfaces when creating the class: class A: IShape, IAnimal, etc.

Default Implementation


Default implementation in interfaces allows to write an implementation of any method. This is useful when there is a need to provide a single implementation for common functionality.

Let's suppose we need to add new common functionality to our already existing interface, which is implemented by many classes. Without default implementation (before C# 8), this operation would create errors, because the method we have added isn't implemented in the classes, and we would need to implement the same operation one by one in each class. Default implementation in interface solves this problem.

For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        public interface IShape {
            void Draw();
            void Finish(){
                Console.WriteLine("Done!");
            }
        }
        class Circle : IShape {
            public void Draw() {
                Console.WriteLine("Circle Draw");
            }
        }
        static void Main(string[] args)
        {
            IShape c = new Circle();
            c.Draw();
            c.Finish();
        }
    }
}
We added the Finish() method with default implementation to our IShape interface and called it without implementing it inside the Circle class.
Methods with default implementation can be freely overridden inside the class which implements that interface.

=============================
64.1 Nested Classes
=============================

C# supports nested classes: a class that is a member of another class.
For example:
class Car {
  string name;
  public Car(string nm) {
    name = nm;
    Motor m = new Motor();
  }
  public class Motor {
    // some code
  }
}
CS
The Motor class is nested in the Car class and can be used similar to other members of the class.
A nested class acts as a member of the class, so it can have the same access modifiers as other members (public, private, protected).
Just as in real life, objects can contain other objects. For example, a car, which has its own attributes (color, brand, etc.) contains a motor, which as a separate object, has its own attributes (volume, horsepower, etc.). Here, the Car class can have a nested Motor class as one of its members.

=============================
65.1 Namespaces
=============================
Namespaces

When you create a blank project, it has the following structure:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn {
  class Program {
    static void Main(string[] args) {
    }
  }
}
CS
Note, that our whole program is inside a namespace. So, what are namespaces?
Namespaces declare a scope that contains a set of related objects. You can use a namespace to organize code elements. You can define your own namespaces and use them in your program.
The using keyword states that the program is using a given namespace.
For example, we are using the System namespace in our programs, which is where the class Console is defined:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hi");
        }
    }
}
Without the using statement, we would have to specify the namespace wherever it is used:
namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            System.Console.WriteLine("Hi");
        }
    }
}
The .NET Framework uses namespaces to organize its many classes. System is one example of a .NET Framework namespace.
Declaring your own namespaces can help you group your class and method names in larger programming projects.

=============================
=============================
Structs, Enums, Exceptions & Files
=============================
=============================

=============================
68.1 Structs
=============================
Structs

A struct type is a value type that is typically used to encapsulate small groups of related variables, such as the coordinates of a rectangle or the characteristics of an item in an inventory. The following example shows a simple struct declaration:
struct Book {
  public string title;  
  public double price;
  public string author;
}
CS
Structs share most of the same syntax as classes, but are more limited than classes.
Unlike classes, structs can be instantiated without using a new operator.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        struct Book {
            public string title;  
            public double price;
            public string author;
        }
        static void Main(string[] args)
        {
            Book b;
            b.title = "Test";
            b.price = 5.99;
            b.author = "David";
            
            Console.WriteLine(b.title);
        }
    }
}
Structs do not support inheritance and cannot contain virtual methods.

=============================
69.1 Enums
=============================
Enums

The enum keyword is used to declare an enumeration: a type that consists of a set of named constants called the enumerator list.
By default, the first enumerator has the value 0, and the value of each successive enumerator is increased by 1.
For example, in the following enumeration, Sun is 0, Mon is 1, Tue is 2, and so on:
enum Days {Sun, Mon, Tue, Wed, Thu, Fri, Sat}; 
CS
You can also assign your own enumerator values:
enum Days {Sun, Mon, Tue=4, Wed, Thu, Fri, Sat}; 
CS
In the example above, the enumeration will start from 0, then Mon is 1, Tue is 4, Wed is 5, and so on. The value of the next item in an Enum is one increment of the previous value.
Note that the values are comma separated.
You can refer to the values in the Enum with the dot syntax.
In order to assign Enum values to int variables, you have to specify the type in parentheses:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        enum Days { Sun, Mon, Tue, Wed, Thu, Fri, Sat }; 
        static void Main(string[] args)
        {
            int x = (int)Days.Tue;
            Console.WriteLine(x);
        }
    }
}
Basically, Enums define variables that represent members of a fixed set.
Some sample Enum uses include month names, days of the week, cards in a deck, etc.

Enums


Enums are often used with switch statements.
For example:
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        enum TrafficLights { Green, Red, Yellow };
        static void Main(string[] args)
        {
            TrafficLights x = TrafficLights.Red;
            switch (x) {
                case TrafficLights.Green:
                    Console.WriteLine("Go!");
                    break;
                case TrafficLights.Red:
                    Console.WriteLine("Stop!");
                    break;
                case TrafficLights.Yellow:
                    Console.WriteLine("Caution!");
                    break;
            }
        }
    }
}

=============================
70.1 Exception Handling
=============================

An exception is a problem that occurs during program execution. Exceptions cause abnormal termination of the program.
An exception can occur for many different reasons. Some examples:
- A user has entered invalid data.
- A file that needs to be opened cannot be found.
- A network connection has been lost in the middle of communications.
- Insufficient memory and other issues related to physical resources.

For example, the following code will produce an exception when run because we request an index which does not exist:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = new int[] { 4, 5, 8 };
            Console.Write(arr[8]);
        }
    }
}
As you can see, exceptions are caused by user error, programmer error, or physical resource issues. However, a well-written program should handle all possible exceptions.

Handling Exceptions


C# provides a flexible mechanism called the try-catch statement to handle exceptions so that a program won't crash when an error occurs.
The try and catch blocks are used similar to:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            try {
                int[] arr = new int[] { 4, 5, 8 };
                Console.Write(arr[8]);
            }
            catch(Exception e) {
                Console.WriteLine("An error occurred");
            }
        }
    }
}
The code that might generate an exception is placed in the try block. If an exception occurs, the catch blocks is executed without stopping the program.
The type of exception you want to catch appears in parentheses following the keyword catch.
We use the general Exception type to handle all kinds of exceptions. We can also use the exception object e to access the exception details, such as the original error message (e.Message):
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            try {
                int[] arr = new int[] { 4, 5, 8 };
                Console.Write(arr[8]);
            }
            catch(Exception e) {
                Console.WriteLine(e.Message);
            }
        }
    }
}
You can also catch and handle different exceptions separately. Tap next to learn more!

Handling Multiple Exceptions


A single try block can contain multiple catch blocks that handle different exceptions separately.
Exception handling is particularly useful when dealing with user input.
For example, for a program that requests user input of two numbers and then outputs their quotient, be sure that you handle division by zero, in case your user enters 0 as the second number.
int x, y;
try {
  x = Convert.ToInt32(Console.Read());
  y = Convert.ToInt32(Console.Read());
  Console.WriteLine(x / y);
}
catch (DivideByZeroException e) {
  Console.WriteLine("Cannot divide by 0");
}
catch(Exception e) {
  Console.WriteLine("An error occurred");
}
CS
The above code handles the DivideByZeroException separately. The last catch handles all the other exceptions that might occur. If multiple exceptions are handled, the Exception type must be defined last.
Now, if the user enters 0 for the second number, "Cannot divide by 0" will be displayed.
If, for example, the user enters non-integer values, "An error occurred" will be displayed.
The following exception types are some of the most commonly used: FileNotFoundException, FormatException, IndexOutOfRangeException, InvalidOperationException, OutOfMemoryException.

finally


An optional finally block can be used after the catch blocks. The finally block is used to execute a given set of statements, whether an exception is thrown or not.
For example:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            int result=0;
            int num1 = 8;
            int num2 = 4;
            try {
                result = num1 / num2;
            }
            catch (DivideByZeroException e) {
                Console.WriteLine("Error");
            }
            finally {
                Console.WriteLine(result);
            }
        }
    }
}
The finally block can be used, for example, when you work with files or other resources. These should be closed or released in the finally block, whether an exception is raised or not.

=============================
71.1 Working with Files
=============================

Writing to Files


The System.IO namespace has various classes that are used for performing numerous operations with files, such as creating and deleting files, reading from or writing to a file, closing a file, and more.
The File class is one of them.
For example:
string str = "Some text";
File.WriteAllText("test.txt", str);
CS
The WriteAllText() method creates a file with the specified path and writes the content to it. If the file already exists, it is overwritten.
The code above creates a file test.txt and writes the contents of the str string into it.
To use the File class you need to use the System.IO namespace: using System.IO;

Reading from Files


You can read the content of a file using the ReadAllText method of the File class:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace SoloLearn
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = "Some text";
            File.WriteAllText("test.txt", str);
            
            string txt = File.ReadAllText("test.txt");
            Console.WriteLine(txt); 
        }
    }
}
This will output the content of the test.txt file.
The following methods are available in the File class:
AppendAllText() - appends text to the end of the file.
Create() - creates a file in the specified location.
Delete() - deletes the specified file.
Exists() - determines whether the specified file exists.
Copy() - copies a file to a new location.
Move() - moves a specified file to a new location
All methods automatically close the file after performing the operation.

=============================
=============================
Generics
=============================
=============================

=============================
74.1 Generic Methods
=============================

Generics allow the reuse of code across different types.
For example, let's declare a method that swaps the values of its two parameters:
static void Swap(ref int a, ref int b) {
  int temp = a;
  a = b;
  b = temp;
}
CS
Our Swap method will work only for integer parameters. If we want to use it for other types, for example, doubles or strings, we have to overload it for all the types we want to use it with. Besides a lot of code repetition, it becomes harder to manage the code because changes in one method mean changes to all of the overloaded methods.
Generics provide a flexible mechanism to define a generic type.
static void Swap<T>(ref T a, ref T b) {
  T temp = a;
  a = b;
  b = temp;
}
CS
In the code above, T is the name of our generic type. We can name it anything we want, but T is a commonly used name. Our Swap method now takes two parameters of type T. We also use the T type for our temp variable that is used to swap the values.
Note the brackets in the syntax <T>, which are used to define a generic type.

Generic Methods


Now, we can use our Swap method with different types, as in:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        static void Swap<T>(ref T a, ref T b) {
            T temp = a;
            a = b;
            b = temp;
        }
        static void Main(string[] args)
        {
            int a = 4, b = 9;
            Swap<int>(ref a, ref b);
            Console.WriteLine(a+" "+b);
            
            string x = "Hello";
            string y = "World";
            Swap<string>(ref x, ref y);
            Console.WriteLine(x+" "+y);
        }
    }
}
When calling a generic method, we need to specify the type it will work with by using brackets. So, when Swap<int> is called, the T type is replaced by int. For Swap<string>, T is replaced by string.
If you omit specifying the type when calling a generic method, the compiler will use the type based on the arguments passed to the method.
Multiple generic parameters can be used with a single method.
For example: Func<T, U> takes two different generic types.

=============================
75.1 Generic C;asses
=============================

Generic Classes


Generic types can also be used with classes.
The most common use for generic classes is with collections of items, where operations such as adding and removing items from the collection are performed in basically the same way regardless of the type of data being stored. One type of collection is called a stack. Items are "pushed", or added to the collection, and "popped", or removed from the collection. A stack is sometimes called a Last In First Out (LIFO) data structure.
For example:
class Stack<T> {
  int index=0;
  T[] innerArray = new T[100];
  public void Push(T item) {
    innerArray[index++] = item; 
  }
  public T Pop() {
    return innerArray[--index]; 
  }
  public T Get(int k) { return innerArray[k]; }
}
CS
The generic class stores elements in an array. As you can see, the generic type T is used as the type of the array, the parameter type for the Push method, and the return type for the Pop and Get methods.
Now we can create objects of our generic class:
Stack<int> intStack = new Stack<int>();
Stack<string> strStack = new Stack<string>();
Stack<Person> PersonStack = new Stack<Person>();
CS
We can also use the generic class with custom types, such as the custom defined Person type.
In a generic class we do not need to define the generic type for its methods, because the generic type is already defined on the class level.

Generic Classes


Generic class methods are called the same as for any other object:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
{
    class Program
    {
        class Stack<T> {
            int index=0;
            T[] innerArray = new T[100];
            public void Push(T item) {
                innerArray[index++] = item; 
            }
            public T Pop() {
                return innerArray[--index]; 
            }
            public T Get(int k) { return innerArray[k]; }
        }
        static void Main(string[] args)
        {
            Stack<int> intStack = new Stack<int>();
            intStack.Push(3);
            intStack.Push(6);
            intStack.Push(7);
            
            Console.WriteLine(intStack.Get(1));
        }
    }
}

=============================
76.1 Collections
=============================
C# Collections


A collection is used to group related objects. Unlike an array, it is dynamic and can also group objects. A collection can grow and shrink to accommodate any number of objects. Collection classes are organized into namespaces and contain built in methods for processing elements within the collection.

A collection organizes related data in a computer so that it can be used efficiently.
Different kinds of collections are suited to different kinds of applications, and some are highly specialized to specific tasks. For example, Dictionaries are used to represent connections on social websites (such as Twitter, Facebook), queues can be used to create task schedulers, HashSets are used in searching algorithms, etc.

A collection typically includes methods to add, remove, and count objects. The for statement and the foreach statement are used to iterate through collections. Since a collection is a class you must first declare an instance of the class before you can add elements to that collection.
For example:
List<int> li = new List<int>(); 
CS
Collections provide a more flexible way to work with groups of objects. Unlike arrays, the group of objects you work with can grow and shrink dynamically as the needs of the application change.

Generic Collections


Generic collections are the preferred type to use as long as every element in the collection is of the same data type. Only desired data types can be added to a generic collection and this is enforced by using strong typing which reduces the possibility of errors.
The .NET Framework provides a number of generic collection classes, useful for storing and manipulating data.
The System.Collections.Generic namespace includes the following generic collections:
- List<T>
- Dictionary<TKey, TValue>
- SortedList<TKey, TValue>
- Stack<T>
- Queue<T>
- Hashset<T>

To access a generic collection in your code, you will need to include the statement: using Systems.Collections.Generic;

Non-Generic Collections

Non-generic collections can store items that are of type Object. Since an Object data type can refer to any data type, you run the risk of unexpected outcomes. Non-generic collections may also be slower to access as well as execute.
The System.Collections namespace includes the following non-generic collections:
- ArrayList
- SortedList
- Stack
- Queue
- Hashtable
- BitArray
Because non-generic collections are error prone and less performant, it is recommended to always use generic collections from the System.Collections.Generic namespace if available and to avoid using legacy collections from the System.Collections namespace.

=============================
77.1 Lists and BitArray
=============================
List<T>


A list is similar to an array, but the elements in a list can be inserted and removed dynamically.
The C# generic collection List<T> class requires all elements be of the same type T.

List<T> properties and methods include:
Count A property that gets the number of elements contained in the list.
Item[int i] Gets or sets the element in the list at the index i. Item is the indexer and is not required when accessing an element. You only need to use the brackets [] and the index value inside the brackets.
Add(T t) Adds an element t to the end of the list.
RemoveAt(int index) Removes the element at the specified position (index) from the list.
Sort() Sorts elements in the list.

Now let's try List<T>:
using System;
using System.Collections.Generic;

namespace SoloLearn
{
	class Program
	{
		static void Main(string[] args)
		{
		    List<int> li = new List<int>();
            li.Add(59);
            li.Add(72);
            li.Add(95);
            li.Add(5);
            li.Add(9);
            li.RemoveAt(1); // remove 72
            
            Console.Write("\nList: ");
            for (int x = 0; x < li.Count; x++)
                Console.Write(li[x] + " "); // 59  95  5  9
            li.Sort();
            Console.Write("\nSorted: ");
            for (int x = 0; x < li.Count; x++)
                Console.Write(li[x] + " "); // 5  9  59  95
		}
	}
}

Additional List<T> properties and methods are listed below. Try them out by adding them to the List<T> example code above.

Capacity - A property that gets the number of elements the list can hold before needing to be resized.

Clear() - Removes all the elements from the list.

TrimExcess() - Sets the capacity to the actual number of elements in the list. This is useful when trying to reduce memory overhead.

AddRange(IEnumerable coll) - Adds the elements of collection coll with elements of the same type as List<T> to the end of the list. IEnumerable is the collections interface that supports simple iteration over the collection.

Insert(int i, T t) - Inserts an element t at a specific index i in the list.

InsertRange(int i, IEnumerable coll) - Inserts the elements of a collection coll at a specified index i in the list. IEnumerable is the collections interface that supports simple iteration over the collection.

Remove(T t) - Removes the first occurrence of the object t from the list.

RemoveRange(int i, int count) - Removes a specified number of elements count from the list starting at a specified index i.

Contains(T t) - Returns true if the specified element t is present in the list.

IndexOf(T t) - Returns the index of the first occurrence of the element t in the list.

Reverse() - Reverses the order of the elements in the list.

ToArray() - Copies the elements of the list into a new array.

SortedList<K, V>


A sorted list is a collection of key/value pairs that are sorted by key. A key can be used to access its corresponding value in the sorted list.

The C# generic collection SortedList<K, V> class requires all element key/value pairs to be of the same type K, V. Duplicate keys are not permitted, which ensures that every key/value pair is unique.

SortedList<K, V> properties include:
Count - Gets the number of key/value pairs contained in the sorted list.
Item[K key] - Gets or sets the value associated the specified key contained in the sorted list. Item is the indexer and is not required when accessing an element. You only need to use the brackets [] and the key, value.
Keys - Gets a sorted and indexed collection containing only the keys in the sorted list.

SortedList<K, V> methods include:
Add(K key, V value) - Adds an element with a specific key, value pair into the sorted list.
Remove(K key) - Removes the element with the specific key, value pair associated with the specified key from the sorted list.

Now let's try SortedList<K, V>:
using System;
using System.Collections.Generic;

namespace SoloLearn
{
	class Program
	{
		static void Main(string[] args)
		{
		    SortedList<string, int> sl = new SortedList<string, int>();

		    sl.Add("Solo", 59);
		    sl.Add("A", 95);
		    sl.Add("Learn", 72);
		    sl.Remove("A");
            
		    Console.WriteLine("Sorted List: ");
		    foreach (string s in sl.Keys)
		        Console.WriteLine(s + ": " + sl[s]);  // Learn: 72  Solo: 59
		    Console.WriteLine("\nCount: " + sl.Count);  // 2
		}
	}
}

Here are additional SortedList<K, V> properties and methods:
Values - Gets a sorted and indexed collection of the values in the sorted list.
Clear() - Removes all the elements from the sorted list.
ContainsKey(K key) - Returns true when the specified key is present in the sorted list.
ContainsValue(V value) - Returns true when a specified value is present in the sorted list.
IndexOfKey(K key) - Returns the index of the specified key within the sorted list.
IndexOfValue(V value) - Returns the index of the specified value within the sorted list.

BitArray


A bit array is a collection of bits. The value of a bit can be either 0 (off/false) or 1 (on/true).
Bit arrays compactly store bits. Most commonly, they are used to represent a simple group of boolean flags or an ordered sequence of boolean values.

BitArray properties include:
Count - Gets the number of bits in the bit array.
IsReadOnly - Gets a value indicating if the bit array is read only or not.

BitArray methods include:
Get(int i) - Gets the value of the bit at a specified position i in the bit array.
Set(int i, bool value) - Sets the bit at a specified position i to a specified value in the bit array.
SetAll(bool value) - Sets all the bits to a specified value in the bit array.
And(BitArray ba) - Performs the bitwise AND operation on the elements of the bit array object with a specified bit array ba.
Or(BitArray ba) - Performs the bitwise OR operation on the elements of the bit array and the specified bit array ba.
Not() - Inverts the bit values of the bit array.
Xor(BitArray ba) - Performs the bitwise XOR operation on the elements of the current bit array object and the elements in the specified bit array ba.

This example demonstrates some properties and methods of the BitArray class:
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SoloLearn
 {
    class Program
    {
        // Printing BitArray
        public static void PrintBarr(string name, BitArray ba)
        {
            Console.Write(name + " : ");
            for (int x = 0; x < ba.Length; x++)
                Console.Write(ba.Get(x) + " ");
            Console.WriteLine();
        }
        
        public static void Main(string[] args)
        {
            BitArray ba1 = new BitArray(4);
            BitArray ba2 = new BitArray(4);
            
            ba1.SetAll(true);
            ba2.SetAll(false);
            
            ba1.Set(2, false);
            ba2.Set(3, true);
            
            PrintBarr("ba1", ba1);
            PrintBarr("ba2", ba2);
            Console.WriteLine();
            
            PrintBarr("ba1 AND ba2", ba1.And(ba2));
            PrintBarr("    NOT ba2", ba2.Not());
        }
    }
}
For example, BitArrays can be used in image processing to store the individual bits of a gray-scale image.

=============================
78.1 Stack & Queue
=============================

Stack<T>


A stack is a Last In, First Out (LIFO) collection of elements where the last element that goes into the stack will be the first element that comes out.

Inserting an element onto a stack is called pushing. Deleting an element from a stack is called popping. Pushing and popping can be performed only at the top of the stack.
Stacks can be used to create undo-redo functionalities, parsing expressions (infix to postfix/prefix conversion), and much more.
The C# generic collection Stack<T> class requires all elements to be of the same type T.

Stack<T> properties include:
Count - Returns the number of elements in the stack.

Stack<T> methods include:
Peek() - Returns the element at the top of the stack without removing it.
Pop() - Returns the element at the top of the stack and removes it from the stack.
Push(T t) - Inserts an element t at the top of the stack.

Now let's try Stack<T>:
using System;
using System.Collections.Generic;

namespace SoloLearn
{
	class Program
	{
		static void Main(string[] args)
		{
		    Stack<int> s = new Stack<int>();
            
		    s.Push(59);
		    s.Push(72);
		    s.Push(65);

		    Console.Write("Stack: ");
		    foreach (int i in s)
		        Console.Write(i + " ");  // 65  72  59
		    Console.Write("\nCount: " + s.Count);  // 3
            
		    Console.Write("\nTop: " + s.Peek());  // 65
		    Console.Write("\nPop: " + s.Pop());  // 65
            
		    Console.Write("\nStack: ");
		    foreach (int i in s)
		        Console.Write(i + " ");  // 72  59
		    Console.Write("\nCount: " + s.Count);  // 2
		}
	}
}

Here are additional Stack<T> methods:
Clear() - Removes all the elements from the stack.
Contains(T t) - Returns true when the element t is present in the stack.
ToArray() - Copies the stack into a new array.

Queue<T>


A queue is a First In, First Out (FIFO) collection of elements where the first element that goes into a queue is also the first element that comes out.

Inserting an element into a queue is referred to as Enqueue. Deleting an element from a queue is referred to as Dequeue.
Queues are used whenever we need to manage objects in order starting with the first one in.
Scenarios include printing documents on a printer, call center systems answering people on hold people, and so on.
The C# generic collection Queue<T> class requires that all elements be of the same type T.

Queue<T> properties include:
Count - Gets the number of elements in the queue.

And methods include:
Dequeue() - Returns the object at the beginning of the queue and also removes it.
Enqueue(T t) - Adds the object t to the end of the queue.

Now let's try Queue<T>:
using System;
using System.Collections.Generic;

namespace SoloLearn
{
	class Program
	{
		static void Main(string[] args)
		{
            Queue<int> q = new Queue<int>();
            
            q.Enqueue(5);
            q.Enqueue(10);
            q.Enqueue(15);
            Console.Write("Queue: ");
            foreach (int i in q)
                Console.Write(i + " ");  // 5  10  15
            Console.Write("\nCount: " + q.Count);  // 3
            
            Console.Write("\nDequeue: " + q.Dequeue()); // 5
            
            Console.Write("\nQueue: ");
            foreach (int i in q)
                Console.Write(i + " ");  // 10  15
            Console.Write("\nCount: " + q.Count);  // 2
		}
	}
}

Here are additional Queue<T> methods:
Clear() - Removes all objects from the queue.
Contains(T t) - Returns true when the element t is present in the queue.
Peek() - Returns the object at the beginning of the queue without removing it.
ToArray() - Copies the queue into a new array.

=============================
79.1 Dictionary & HashSet
=============================

Dictionary<U, V>


A dictionary is a collection of unique key/value pairs where a key is used to access the corresponding value. Dictionaries are used in database indexing, cache implementations, and so on.

The C# generic collection Dictionary<K, V> class requires all key/value pairs be of the same type K, V. Duplicate keys are not permitted to ensure that every key/value pair is unique.

Dictionary<K, V> properties include:
Count - Gets the number of key/value pairs contained in the dictionary.
Item[K key] - Gets the value associated with the specified key in the dictionary. Item is the indexer and is not required when accessing an element. You only need to use the brackets [] and key value.
Keys - Gets an indexed collection containing only the keys contained in the dictionary.

Dictionary<K, V> methods include:
Add(K key, V value) - Adds the key, value pair to the dictionary.
Remove(K key) - Removes the key/value pair related to the specified key from the dictionary.

Now let's try Dictionary<K, V>:
using System;
using System.Collections.Generic;

namespace SoloLearn
{
	class Program
	{
		static void Main(string[] args)
		{
		    Dictionary<string, int> d = new Dictionary<string, int>();
            d.Add("Uno", 1);
            d.Add("One", 1);
            d.Add("Dos", 2);
            d.Add("Deux", 2);
            d.Remove("One");  // Remove key-value pair One, 1
            d.Remove("Dos");  // Remove key-value pair Dos, 2
            
            Console.WriteLine("Dictionary: ");
            foreach (string s in d.Keys)
                Console.WriteLine(s + ": " + d[s]);  // Uno: 1  Deux: 2
            Console.WriteLine("\nCount: {0}", d.Count); // 2 
		}
	}
}

In the above example, the dictionary d uses strings as it's keys and integers as the values.

Here are the additional Dictionary<K, V> properties and methods:
Values - Gets an indexed collection containing only the values in the dictionary.
Clear() - Removes all the key/value pairs from the dictionary.
ContainsKey(K key) - Returns true if the specified key is present in the dictionary.
ContainsValue(V value) - Returns true if the specified value is present in the dictionary.

HashSet<T>


A hash set is a set of unique values where duplicates are not allowed.

C# includes the HashSet<T> class in the generic collections namespace. All HashSet<T> elements are required to be of the same type T.
Hash sets are different from other collections because they are simply a set of values. They do not have index positions and elements cannot be ordered.
The HashSet<T> class provides high-performance set operations. HashSets allow fast lookup, addition, and removal of items, and can be used to implement either dynamic sets of items or lookup tables that allow finding an item by its key (e.g., finding the phone number of a person by the last name).
HashSet<T> properties include:
Count Returns the number of values in the hash set.

And methods include:
Add(T t) Adds a value (t) to the hash set.
IsSubsetOf(ICollection c) Returns true if the hash set is a subset of the specified collection (c).

Now let's try HashSet<T>:
using System;
using System.Collections.Generic;

namespace SoloLearn
{
	class Program
	{
		static void Main(string[] args)
		{
            HashSet<int> hs = new HashSet<int>();
            
            hs.Add(5);
            hs.Add(10);
            hs.Add(15);
            hs.Add(20);
            Console.Write("\nHashSet: ");
            foreach (int i in hs)
                Console.Write(i + " ");  // 5  10  15  20  *elements may be in any order
            Console.Write("\nCount: " + hs.Count);  // 4
            
            HashSet<int> hs2 = new HashSet<int>();
            hs2.Add(15);
            hs2.Add(20);
            Console.Write("\n{15, 20} is a subset of {5, 10, 15, 20}: " + hs2.IsSubsetOf(hs)); // True 
		}
	}
}

Here are additional HashSet<T> methods:
Remove(T t) Removes the value (t) from the hash set.
Clear() Removes all the elements form the hash set.
Contains(T t) Returns true when a value (t) is present in the hash set.
ToString() Creates a string from the hash set.
IsSupersetOf(ICollection c) Returns true if the hash set is a superset of the specified collection.
UnionWith(ICollection c) Applies set union operation on the hash set and the specified collection (c).
IntersectWith(ICollection c) Applies set intersection operation on the hash set and the specified collection (c).
ExceptWith(ICollection c) Applies set difference operation on the hash set and the specified collection (c).

					THE END.

=============================
Dynamic Memory
=============================
Static & Dynamic Memory


To be successful as a C++ programmer, it's essential to have a good understanding of how dynamic memory works.
In a C++ program, memory is divided into two parts:
The stack: All of your local variables take up memory from the stack.
The heap: Unused program memory that can be used when the program runs to dynamically allocate the memory.

Many times, you are not aware in advance how much memory you will need to store particular information in a defined variable and the size of required memory can be determined at run time.
You can allocate memory at run time within the heap for the variable of a given type using the new operator, which returns the address of the space allocated.
new int;
CPP
This allocates the memory size necessary for storing an integer on the heap, and returns that address.

Dynamic Memory


The allocated address can be stored in a pointer, which can then be dereferenced to access the variable.
Example:
int *p = new int;
*p = 5;
CPP
We have dynamically allocated memory for an integer, and assigned it a value of 5.
The pointer p is stored in the stack as a local variable, and holds the heap's allocated address as its value. The value of 5 is stored at that address in the heap.

Dynamic Memory


For local variables on the stack, managing memory is carried out automatically.
On the heap, it's necessary to manually handle the dynamically allocated memory, and use the delete operator to free up the memory when it's no longer needed.
delete pointer;
CPP
This statement releases the memory pointed to by pointer.

For example:
#include <iostream>
using namespace std;

int main()
{
    int *p = new int; // request memory
    *p = 5; // store value

    cout << *p << endl; // use value

    delete p; // free up the memory

    return 0;
}
Forgetting to free up memory that has been allocated with the new keyword will result in memory leaks, because that memory will stay allocated until the program shuts down.

Dangling Pointers


The delete operator frees up the memory allocated for the variable, but does not delete the pointer itself, as the pointer is stored on the stack.

Pointers that are left pointing to non-existent memory locations are called dangling pointers.
For example:
#include <iostream>
using namespace std;

int main()
{
    int *p = new int; // request memory
    *p = 5; // store value

    delete p; // free up the memory
    // now p is a dangling pointer

    p = new int; // reuse for a new address

    return 0;
}
The NULL pointer is a constant with a value of zero that is defined in several of the standard libraries, including iostream.
It's a good practice to assign NULL to a pointer variable when you declare it, in case you do not have exact address to be assigned. A pointer assigned NULL is called a null pointer. For example: int *ptr = NULL;

Dynamic Memory


Dynamic memory can also be allocated for arrays.
For example:
#include <iostream>
using namespace std;

int main()
{
    int *p = NULL; // Pointer initialized with null
    p = new int[20]; // Request memory
    delete [] p; // Delete array pointed to by p

    return 0;
}
Note the brackets in the syntax.
Dynamic memory allocation is useful in many situations, such as when your program depends on input. As an example, when your program needs to read an image file, it doesn't know in advance the size of the image file and the memory necessary to store the image.

=============================
The sizeof() Operator
=============================

sizeof


While the size allocated for varying data types depends on the architecture of the computer you use to run your programs, C++ does guarantee a minimum size for the basic data types:
Category		Type		Minimum size
boolean			bool		1 byte
character		char		1 byte
integer			short		2 bytes
			int		2 bytes
			long		4 bytes
			long long	8bytes
floating point		float		4 bytes
			doubl		8 bytese
			longdouble	8 bytes

Floating Point
The sizeof operator can be used to get a variable or data type's size, in bytes.
Syntax:
sizeof (data type)
CPP
The sizeof operator determines and returns the size of either a type or a variable in bytes.
For example:
#include <iostream>
using namespace std;

int main()
{
    cout << "char: " << sizeof(char) << endl;
    cout << "int: " << sizeof(int) << endl;
    cout << "float: " << sizeof(float) << endl;
    cout << "double: " << sizeof(double) << endl;
    int var = 50;
    cout << "var: " << sizeof(var) << endl;

    return 0;
}
Output values may vary, according to the computer and compiler used.

Size of an Array


The C++ sizeof operator is also used to determine the size of an array.
For example:
#include <iostream>
using namespace std;

int main()
{
    double myArr[10];
    cout << sizeof(myArr) << endl;

    return 0;
}
On our machine, double takes 8 bytes. The array stores 10 doubles, so the entire array occupies 80 (8*10) bytes in the memory.

In addition, divide the total number of bytes in the array by the number of bytes in a single element to learn how many elements you have in the array.
For example:
#include <iostream>
using namespace std;

int main()
{
    int numbers[100];
    cout << sizeof(numbers) / sizeof(numbers[0]);

    return 0;
}

=============================
Composition, Part 1
=============================

Composition


In the real world, complex objects are typically built using smaller, simpler objects. For example, a car is assembled using a metal frame, an engine, tires, and a large number of other parts. This process is called composition.

In C++, object composition involves using classes as member variables in other classes.
This sample program demonstrates composition in action. It contains Person and Birthday classes, and each Person will have a Birthday object as its member.
Birthday:
class Birthday {
 public:
  Birthday(int m, int d, int y)
  : month(m), day(d), year(y)
  { 
  }
 private:
   int month;
   int day;
   int year;
};
CPP
Our Birthday class has three member variables. It also has a constructor that initializes the members using a member initialization list.
The class was declared in a single file for the sake of simplicity. Alternatively, you could use header and source files.

Composition


Let's also add a printDate() function to our Birthday class:
class Birthday {
 public:
  Birthday(int m, int d, int y)
  : month(m), day(d), year(y)
  {
  }
  void printDate()
  {
   cout<<month<<"/"<<day
   <<"/"<<year<<endl;
  }
 private:
  int month;
  int day;
  int year;
};
CPP
Add a printDate() function to our Birthday class.

Composition


Next, we can create the Person class, which includes the Birthday class.
#include <string>
#include "Birthday.h"

class Person {
 public:
  Person(string n, Birthday b)
  : name(n),
   bd(b)
  {
  }
 private:
  string name;
  Birthday bd;
};
CPP
The Person class has a name and a Birthday member, and a constructor to initialize them.
Ensure that the corresponding header files are included.
More on Composition coming up in the next lesson!

=============================
Composition, Part 2
=============================
Composition


Now, our Person class has a member of type Birthday
class Person {
 public:
  Person(string n, Birthday b)
  : name(n),
    bd(b)
  {
  }
 private:
  string name;
  Birthday bd;
};
CPP
Composition is used for objects that share a has-a relationship, as in "A Person has a Birthday".

Composition


Let's add a printInfo() function to our Person class, that prints the data of the object:
class Person {
 public:
  Person(string n, Birthday b)
  : name(n),
  bd(b)
  {
  }
  void printInfo()
  {
   cout << name << endl;
   bd.printDate();
  }
 private:
  string name;
  Birthday bd;
};
CPP
Notice that we can call the bd member's printDate() function, since it's of type Birthday, which has that function defined.

Composition


Now that we've defined our Birthday and Person classes, we can go to our main, create a Birthday object, and then pass it to a Person object.
We've created a Birthday object for the date of 2/21/1985. Next, we created a Person object and passed the Birthday object to its constructor. Finally, we used the Person object's printInfo() function to print its data.
In general, composition serves to keep each individual class relatively simple, straightforward, and focused on performing one task. It also enables each sub-object to be self-contained, allowing for reusability (we can use the Birthday class within various other classes).

=============================
Function Templates
=============================
Function Templates


Functions and classes help to make programs easier to write, safer, and more maintainable.
However, while functions and classes do have all of those advantages, in certain cases they can also be somewhat limited by C++'s requirement that you specify types for all of your parameters.

For example, you might want to write a function that calculates the sum of two numbers, similar to this:
#include <iostream>
using namespace std;

int sum(int a, int b) {
    return a+b;
}

int main () {
    int x=7, y=15;
    cout << sum(x, y) << endl;
}
CPP
You can use templates to define functions as well as classes. Let's see how they work.

Function Templates


We can now call the function for two integers in our main.
#include <iostream>
using namespace std;

int sum(int a, int b) {
    return a+b;
}

int main () {
    int x=7, y=15;
    cout << sum(x, y) << endl;
}
The function works as expected, but is limited solely to integers.

Function Templates


It becomes necessary to write a new function for each new type, such as doubles.
double sum(double a, double b) {
  return a+b;
}
CPP
Wouldn't it be much more efficient to be able to write one version of sum() to work with parameters of any type?
Function templates give us the ability to do that!
With function templates, the basic idea is to avoid the necessity of specifying an exact type for each variable. Instead, C++ provides us with the capability of defining functions using placeholder types, called template type parameters.

To define a function template, use the keyword template, followed by the template type definition:
template <class T> 
CPP
We named our template type T, which is a generic data type.
Tap Continue to learn more!

Function Templates


Now we can use our generic data type T in the function:
#include <iostream>
using namespace std;

template <class T>
T sum(T a, T b) {
    return a+b;
}

int main () {
    int x=7, y=15;
    cout << sum(x, y) << endl;
}
The function returns a value of the generic type T, taking two parameters, also of type T.
Our new function worked exactly as the previous one for integer values did.

Function Templates


The same function can be used with other data types, for example doubles:
#include <iostream>
using namespace std;

template <class T>
T sum(T a, T b) {
    return a+b;
}

int main () {
    double x=7.15, y=15.54;
    cout << sum(x, y) << endl;
}
The compiler automatically calls the function for the corresponding type.
When creating a template type parameter, the keyword typename may be used as an alternative to the keyword class: template <typename T>.
In this context, the keywords are identical, but throughout this course, we'll use the keyword class.

Function Templates


Template functions can save a lot of time, because they are written only once, and work with different types.
Template functions reduce code maintenance, because duplicate code is reduced significantly.
Enhanced safety is another advantage in using template functions, since it's not necessary to manually copy functions and change types.

=============================
Function Templates with Multiple Parameters
=============================
Function Templates


Function templates also make it possible to work with multiple generic data types. Define the data types using a comma-separated list.
Let's create a function that compares arguments of varying data types (an int and a double), and prints the smaller one.
template <class T, class U>
CPP
As you can see, this template declares two different generic data types, T and U.

Function Templates


Now we can continue with our function declaration:
template <class T, class U>
T smaller(T a, U b) {
  return (a < b ? a : b);
}
CPP
The ternary operator checks the a<b condition and returns the corresponding result. The expression (a < b ? a : b) is equivalent to the expression if a is smaller than b, return a, else, return b.

Function Templates


In our main, we can use the function for different data types:
#include <iostream>
using namespace std;

template <class T, class U>
T smaller(T a, U b) {
    return (a < b ? a : b);
}

int main () {
    int x=72;
    double y=15.34;
    cout << smaller(x, y) << endl;
}
The output converts to an integer, because we specified the function template's return type to be of the same type as the first parameter (T), which is an integer.

Function Templates


T is short for Type, and is a widely used name for type parameters.
It's not necessary to use T, however; you can declare your type parameters using any identifiers that work for you. The only terms you need to avoid are C++ keywords.
Remember that when you declare a template parameter, you absolutely must use it in your function definition. Otherwise, the compiler will complain!

=============================
Class Templates
=============================
Class Templates

Just as we can define function templates, we can also define class templates, allowing classes to have members that use template parameters as types.
The same syntax is used to define the class template:
template <class T>
class MyClass {

};
CPP
Just as with function templates, you can define more than one generic data type by using a comma-separated list.

Class Templates


As an example, let's create a class Pair, that will be holding a pair of values of a generic type.
template <class T>
class Pair {
 private:
  T first, second;
 public:
  Pair (T a, T b):
   first(a), second(b) {
  }
};
CPP
The code above declares a class template Pair, with two private variables of a generic type, and one constructor to initialize the variables.

Class Templates


A specific syntax is required in case you define your member functions outside of your class - for example in a separate source file.
You need to specify the generic type in angle brackets after the class name.
For example, to have a member function bigger() defined outside of the class, the following syntax is used:
template <class T>
class Pair {
 private:
  T first, second;
 public:
  Pair (T a, T b):
   first(a), second(b){
  }
  T bigger();
};

template <class T>
T Pair<T>::bigger() {
  // some code
}
CPP
A specific syntax is required in case you define your member functions outside of your class.

Class Templates


The bigger function returns the greater value of the two member variables.
template <class T>
class Pair {
 private:
  T first, second;
 public:
  Pair (T a, T b):
   first(a), second(b){
  }
  T bigger();
};

template <class T>
T Pair<T>::bigger() {
  return (first>second ? first : second);
}
CPP
The ternary operator compares the two variables, returning the greater one.

Class Templates


To create objects of the template class for different types, specify the data type in angle brackets, as we did when defining the function outside of the class.
Here, we create a Pair object for integers.
#include <iostream>
using namespace std;

template <class T>
class Pair {
    private:
        T first, second;
    public:
        Pair (T a, T b):
        first(a), second(b) { }
        T bigger();
};

template <class T>
T Pair<T>::bigger() {
    return (first>second ? first : second);
}

int main()
{
    Pair <int> obj(11, 22);
    cout << obj.bigger();

    return 0;
}
We can use the same class to create an object that stores any other type.
#include <iostream>
using namespace std;

template <class T>
class Pair {
    private:
        T first, second;
    public:
        Pair (T a, T b):
        first(a), second(b) { }
        T bigger();
};

template <class T>
T Pair<T>::bigger() {
    return (first>second ? first : second);
}

int main()
{
    Pair <double> obj(23.43, 5.68);
    cout << obj.bigger();

    return 0;
}

=============================
Template Specialization
=============================
Template Specialization


In case of regular class templates, the way the class handles different data types is the same; the same code runs for all data types.
Template specialization allows for the definition of a different implementation of a template when a specific type is passed as a template argument.

For example, we might need to handle the character data type in a different manner than we do numeric data types.
To demonstrate how this works, we can first create a regular template.
template <class T>
class MyClass {
 public:
  MyClass (T x) {
   cout <<x<<" -  not a char"<<endl;
  }
};
CPP
As a regular class template, MyClass treats all of the various data types in the same way.

Template Specialization


To specify different behavior for the data type char, we would create a template specialization.
template <class T>
class MyClass {
 public:
  MyClass (T x) {
   cout <<x<<" -  not a char"<<endl;
  }
};

template < >
class MyClass<char> {
 public:
  MyClass (char x) {
   cout <<x<<" is a char!"<<endl;
  }
};
CPP
First of all, notice that we precede the class name with template<>, including an empty parameter list. This is because all types are known and no template arguments are required for this specialization, but still, it is the specialization of a class template, and thus it requires to be noted as such.

But more important than this prefix, is the <char> specialization parameter after the class template name. This specialization parameter itself identifies the type for which the template class is being specialized (char).
In the example above, the first class is the generic template, while the second is the specialization.
If necessary, your specialization can indicate a completely different behavior from the behavior of the generic template.

Template Specialization


The next step is to declare objects of different types and check the result:
#include <iostream>
using namespace std;

template <class T>
class MyClass {
    public:
        MyClass (T x) {
            cout <<x<<" -  not a char"<<endl;
        }
};

template < >
class MyClass<char> {
    public:
        MyClass (char x) {
            cout <<x<<" is a char!"<<endl;
        }
};

int main () {
    MyClass<int> ob1(42);
    MyClass<double> ob2(5.47);
    MyClass<char> ob3('s');
}
As you can see, the generic template worked for int and double. However, our template specialization was invoked for the char data type.
Keep in mind that there is no member "inheritance" from the generic template to the specialization, so all members of the template class specializations must be defined on their own.

=============================
C# Type Casting
=============================
https://www.w3schools.com/cs/cs_type_casting.php

Type casting is when you assign a value of one data type to another type.

In C#, there are two types of casting:

Implicit Casting (automatically) - converting a smaller type to a larger type size
char -> int -> long -> float -> double

Explicit Casting (manually) - converting a larger type to a smaller size type
double -> float -> long -> int -> char
Implicit Casting
Implicit casting is done automatically when passing a smaller size type to a larger size type:

Example
int myInt = 9;
double myDouble = myInt;       // Automatic casting: int to double

Console.WriteLine(myInt);      // Outputs 9
Console.WriteLine(myDouble);   // Outputs 9

Explicit Casting
Explicit casting must be done manually by placing the type in parentheses in front of the value:

Example
double myDouble = 9.78;
int myInt = (int) myDouble;    // Manual casting: double to int

Console.WriteLine(myDouble);   // Outputs 9.78
Console.WriteLine(myInt);      // Outputs 9

Type Conversion Methods
It is also possible to convert data types explicitly by using built-in methods, such as Convert.ToBoolean, Convert.ToDouble, Convert.ToString, Convert.ToInt32 (int) and Convert.ToInt64 (long):

Example
int myInt = 10;
double myDouble = 5.25;
bool myBool = true;

Console.WriteLine(Convert.ToString(myInt));    // convert int to string
Console.WriteLine(Convert.ToDouble(myInt));    // convert int to double
Console.WriteLine(Convert.ToInt32(myDouble));  // convert double to int
Console.WriteLine(Convert.ToString(myBool));   // convert bool to string

Why Conversion?
Many times, there's no need for type conversion. But sometimes you have to. Take a look at the next chapter, when working with user input, to see an example of this.

=============================
C# .NET Delegates and Events
=============================
https://www.c-sharpcorner.com/UploadFile/puranindia/C-Sharp-net-delegates-and-events/

In this tutorial, learn what is a delegate in C# and how delegates are implemented in C#. A delegate in C# is type that is used to invoke a method. In this tutorial, you will learn the following.
What is a delegate in C#?
Why do we need delegates in C#?
What are the benefits of delegates in C# and .NET?
What are different types of delegates in C#?
How delefates are related to events in C#?
What are singlecast and multicast delegates in C#?
What is an anonmous delegate in C#?
C# delegate code examples
 
1. What is a Delegate in C#?
 
Delegate is one of the base types in .NET. Delegate is a class, which is used to create and invoke delegates at runtime.
 
C# Delegates
 
A delegate in C# is similar to a function pointer in C or C++. It's a new type of object in C#. Delegate is very special type of object as earlier the entire the object we used to defined contained data but delegate just contains the details of a method.
 
2. Why do we need delegates in C#?
 
Programmers often needs to pass a method as a parameter of other methods. For this purpose we create and use delegates.
A delegate is a class that encapsulates a method signature. Although it can be used in any context, it often serves as the basis for the event-handling model in C# and .NET.
 
One good way of understanding delegates is by thinking of a delegate as something that gives a name to a method signature.
 
Example:
public delegate int DelegateMethod(int x, int y);  
Any method that matches the delegate's signature, which consists of the return type and parameters, can be assigned to the delegate.
 
This makes is possible to programmatically change method calls, and also plug new code into existing classes. As long as you know the delegate's signature, you can assign your own-delegated method.
 
This ability to refer to a method as a parameter makes delegates ideal for defining callback methods.
 
Delegate magic
 
In class we create its object, which is instance, but in delegate when we create instance that is also referred as delegate (means whatever you do you will get delegate).
 
Delegate does not know or care about the class of the object that it references. Any object will do; all that matters is that the method's argument types and return type match the delegate's. This makes delegates perfectly suited for "anonymous" invocation.
 
3. What are the benefits of delegates?
 
In simple words delegates are object oriented and type-safe and very secure as they ensure that the signature of the method being called is correct. Delegates makes event handling simple and easy.
 
4. What are types of delegates in C#?
 
There are two types of delegates, singlecast delegates, and multiplecast delegates.
 
Singlecast delegate
 
Singlecast delegate point to single method at a time. In this the delegate is assigned to a single method at a time. They are derived from System.Delegate class.
 
Multicast Delegate
 
When a delegate is wrapped with more than one method that is known as a multicast delegate.
 
In C#, delegates are multicast, which means that they can point to more than one function at a time. They are derived from System.MulticastDelegate class.
 
5. How to define a delegates in C#?
 
 
There are three steps in defining and using delegates:
 
1. Declaration
 
To create a delegate, you use the delegate keyword.
[attributes] [modifiers] delegate ReturnType Name ([formal-parameters]);  
The attributes factor can be a normal C# attribute.
The modifier can be one or an appropriate combination of the following keywords: new, public, private, protected, or internal.
 The ReturnType can be any of the data types we have used so far. It can also be a type void or the name of a class.
 The Name must be a valid C# name. 
Because a delegate is a definituon for a method, you must use parentheses, required for every method. If this method will not take any argument, leave the parentheses empty.
 
Example:
public delegate void DelegateExample();  
The above code is how a delegate with no papameters is defined.
 
2. Instantiation
DelegateExample d1 = new DelegateExample(Display);  
The above code shows how a delegate is initiated.
 
3. Invocation 
d1();  
The above code piece invokes a delegate d1().
 
6. What is a Singlecast delegate in C#?
 
Here is a sample code that demonstrates how to create and use a singlecast delegate.
using System;    
namespace ConsoleApplication5    
{    
class Program    
{    
public delegate void delmethod();    
  
public class P    
{  
  
public static void display()    
{    
Console.WriteLine("Hello!");    
}    
  
public static void show()    
{    
Console.WriteLine("Hi!");    
}    
  
public void print()
{
Console.WriteLine("Print");
}

}
  
static void Main(string[] args)
{
// here we have assigned static method show() of class P to delegate delmethod()
delmethod del1 = P.show;
  
// here we have assigned static method display() of class P to delegate delmethod() using new operator
// you can use both ways to assign the delagate
delmethod del2 = new delmethod(P.display);
P obj = new P();
  
// here first we have create instance of class P and assigned the method print() to the delegate i.e. delegate with class    
delmethod del3 = obj.print;
  
del1();
del2();
del3();
Console.ReadLine();
}
}
}
7. What is a Multicast delegate in C#?
 
Here is sample code that demonstrates how to create and use a multicast delegate.
using System;  
namespace delegate_Example4  
{  
  
class Program  
{  
public delegate void delmethod(int x, int y);  
  
public class TestMultipleDelegate  
{  
public void plus_Method1(int x, int y)  
{  
Console.Write("You are in plus_Method");  
Console.WriteLine(x + y);  
}  
  
public void subtract_Method2(int x, int y)  
{  
Console.Write("You are in subtract_Method");  
Console.WriteLine(x - y);  
}  
}  
  
static void Main(string[] args)  
{  
  
TestMultipleDelegate obj = new TestMultipleDelegate();  
delmethod del = new delmethod(obj.plus_Method1);  
  
// Here we have multicast  
del += new delmethod(obj.subtract_Method2);  
// plus_Method1 and subtract_Method2 are called  
del(50, 10);  
Console.WriteLine();  
//Here again we have multicast  
del -= new delmethod(obj.plus_Method1);  
//Only subtract_Method2 is called  
del(20, 10);  
Console.ReadLine();  
}  
}  
}  
Point to remember about Delegates:
Delegates are similar to C++ function pointers, but are type safe.
Delegate gives a name to a method signature.
Delegates allow methods to be passed as parameters.
Delegates can be used to define callback methods.
Delegates can be chained together; for example, multiple methods can be called on a single event.
C# version 2.0 introduces the concept of Anonymous Methods, which permit code blocks to be passed as parameters in place of a separately defined method.
Delegate helps in code optimization.
Usage areas of delegates
The most common example of using delegates is in events. 
They are extensively used in threading
Delegates are also used for generic class libraries, which have generic functionality, defined.
8. What are Anonymous Delegates in C#?
 
You can create a delegate, but there is no need to declare the method associated with it. You do not have to explicitly define a method prior to using the delegate. Such a method is referred to as anonymous. In other words, if a delegate itself contains its method definition it is known as anonymous method.
 
The code is an example of using an anonymous delegate.
using System;  
  
public delegate void Test();  
  
public class Program  
{  
static int Main()  
{  
Test Display = delegate()  
{  
Console.WriteLine("Anonymous Delegate method");  
};  
  
Display();  
return 0;  
}  
}  
Note: You can also handle event in anonymous method.
 
9. How Delegates are Related to Events in C#?
 
Events and delegate work together. An event is a reference to a delegate i.e. when an event is raised, a delegate is called. In C# terms, events are a special form of delegates. 
 
Events play an important part in user interfaces and programming notifications. Events and delegates work hand-in-hand to provide a communication between code from one class to other class. When something happens in one class or one part of the code and other part of the code needs a notification, events are used. 
 
A C# event is a class member that is activated whenever the event it was designed for occurs. It starts with a class that declares an event. Any class, including the same class that the event is declared in, may register one of its methods for the event. This occurs through a delegate, which specifies the signature of the method that is registered for the event. The event keyword is a delegate modifier. It must always be used in connection with a delegate.
 
The delegate may be one of the pre-defined .NET delegates or one you declare yourself. Whichever is appropriate, you assign the delegate to the event, which effectively registers the method that will be called when the event fires.
 
10. How to Use Events and Delegates in C#?
 
Once an event is declared, it must be associated with one or more event handlers before it can be raised. An event handler is nothing but a method that is called using a delegate. Use the += operator to associate an event with an instance of a delegate that already exists.
 
Example:
obj.MyEvent += new MyDelegate(obj.Display);  
An event has the value null if it has no registered listeners.
 
Although events are mostly used in Windows controls programming, they can also be implemented in console, web and other applications.
 
Program for creating a custom Singlecast delegate and event
using System;  
namespace delegate_custom  
{  
class Program  
{  
public delegate void MyDelegate(int a);  
  
public class XX  
{  
public event MyDelegate MyEvent;  
  
public void RaiseEvent()  
{  
MyEvent(20);  
Console.WriteLine("Event Raised");  
}  
  
public void Display(int x)  
{  
Console.WriteLine("Display Method {0}", x);  
}  
}  
  
static void Main(string[] args)  
{  
  
XX obj = new XX();  
obj.MyEvent += new MyDelegate(obj.Display);  
  
obj.RaiseEvent();  
Console.ReadLine();  
}  
}  
}  
Program for creating custom a multiplecast delegate and event
using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace delegate_custom_multicast  
{  
class Program  
{  
public delegate void MyDelegate(int a, int b);  
  
public class XX  
{  
public event MyDelegate MyEvent;  
  
public void RaiseEvent(int a, int b)  
{  
MyEvent(a, b);  
Console.WriteLine("Event Raised");  
}  
  
public void Add(int x, int y)  
{  
Console.WriteLine("Add Method {0}", x + y);  
}  
  
public void Subtract(int x, int y)  
{  
Console.WriteLine("Subtract Method {0}", x - y);  
}  
}  
  
static void Main(string[] args)  
{  
  
XX obj = new XX();  
obj.MyEvent += new MyDelegate(obj.Add);  
obj.MyEvent += new MyDelegate(obj.Subtract);  
obj.RaiseEvent(20, 10);  
Console.ReadLine();  
}  
}  
}  
Conclusion
 
Hope the article would have helped you in understanding delegates and events.

=============================
C# | Delegates
=============================
https://www.c-sharpcorner.com/UploadFile/1c8574/delegate-used-for-callback-operation/

A delegate is an object which refers to a method or you can say it is a reference type variable that can hold a reference to the methods. Delegates in C# are similar to the function pointer in C/C++. It provides a way which tells which method is to be called when an event is triggered. 
For example, if you click on a Button on a form (Windows Form application), the program would call a specific method. In simple words, it is a type that represents references to methods with a particular parameter list and return type and then calls the method in a program for execution when it is needed.
Important Points About Delegates: 
 

Provides a good way to encapsulate the methods.
Delegates are the library class in System namespace.
These are the type-safe pointer of any method.
Delegates are mainly used in implementing the call-back methods and events.
Delegates can be chained together as two or more methods can be called on a single event.
It doesn’t care about the class of the object that it references.
Delegates can also be used in “anonymous methods” invocation.
Anonymous Methods(C# 2.0) and Lambda expressions(C# 3.0) are compiled to delegate types in certain contexts. Sometimes, these features together are known as anonymous functions.
 

Declaration of Delegates
Delegate type can be declared using the delegate keyword. Once a delegate is declared, delegate instance will refer and call those methods whose return type and parameter-list matches with the delegate declaration.
Syntax: 
 

[modifier] delegate [return_type] [delegate_name] ([parameter_list]);
 

modifier: It is the required modifier which defines the access of delegate and it is optional to use.
delegate: It is the keyword which is used to define the delegate.
return_type: It is the type of value returned by the methods which the delegate will be going to call. It can be void. A method must have the same return type as the delegate.
delegate_name: It is the user-defined name or identifier for the delegate.
parameter_list: This contains the parameters which are required by the method when called through the delegate. 

Example: 
 

// "public" is the modifier
// "int" is return type
// "GeeksForGeeks" is delegate name
// "(int G, int F, int G)" are the parameters
public delegate int GeeksForGeeks(int G, int F, int G);
Note: A delegate will call only a method which agrees with its signature and return type. A method can be a static method associated with a class or can be an instance method associated with an object, it doesn’t matter. 
 

Instantiation & Invocation of Delegates
After declaring a delegate, a delegate object is created with the help of new keyword. Once a delegate is instantiated, a method call made to the delegate is pass by the delegate to that method. The parameters passed to the delegate by the caller are passed to the method, and the return value, if any, from the method, is returned to the caller by the delegate. This is known as invoking the delegate. 
Syntax:
 

[delegate_name]  [instance_name] = new [delegate_name](calling_method_name);
Example: 
 

GeeksForGeeks GFG = new GeeksForGeeks (Geeks);
       // here,
       // "GeeksForGeeks" is delegate name. 
       // "GFG" is instance_name
       // "Geeks" is the calling method.
Below program illustrate the use of Delegate:
 

// C# program to illustrate the use of Delegates
using System;
namespace GeeksForGeeks {
     
// declare class "Geeks"
class Geeks {
     
// Declaring the delegates
// Here return type and parameter type should
// be same as the return type and parameter type
// of the two methods
// "addnum" and "subnum" are two delegate names
public delegate void addnum(int a, int b);
public delegate void subnum(int a, int b);
     
    // method "sum"
    public void sum(int a, int b)
    {
        Console.WriteLine("(100 + 40) = {0}", a + b);
    }
 
    // method "subtract"
    public void subtract(int a, int b)
    {
        Console.WriteLine("(100 - 60) = {0}", a - b);
    }
 
// Main Method
public static void Main(String []args)
{
     
    // creating object "obj" of class "Geeks"
    Geeks obj = new Geeks();
 
    // creating object of delegate, name as "del_obj1"
    // for method "sum" and "del_obj2" for method "subtract" &
    // pass the parameter as the two methods by class object "obj"
    // instantiating the delegates
    addnum del_obj1 = new addnum(obj.sum);
    subnum del_obj2 = new subnum(obj.subtract);
 
    // pass the values to the methods by delegate object
    del_obj1(100, 40);
    del_obj2(100, 60);
 
    // These can be written as using
    // "Invoke" method
    // del_obj1.Invoke(100, 40);
    // del_obj2.Invoke(100, 60);
}
}
}
Output: 
 

(100 + 40) = 140
(100 - 60) = 40
Explanation: In the above program, there are two delegates addnum and subnum. We are creating the object obj of the class Geeks because both the methods(addnum and subnum) are instance methods. So they need an object to call. If methods are static then there is no need to create the object of the class.
 

Multicasting of a Delegate
Multicasting of delegate is an extension of the normal delegate(sometimes termed as Single Cast Delegate). It helps the user to point more than one method in a single call.
Properties: 
 

Delegates are combined and when you call a delegate then a complete list of methods is called.
All methods are called in First in First Out(FIFO) order.
‘+’ or ‘+=’ Operator is used to add the methods to delegates.
‘–’ or ‘-=’ Operator is used to remove the methods from the delegates list.
Note: Remember, multicasting of delegate should have a return type of Void otherwise it will throw a runtime exception. Also, the multicasting of delegate will return the value only from the last method added in the multicast. Although, the other methods will be executed successfully.
Below program demonstrates the use of Multicasting of a delegate:
 

// C# program to illustrate the
// Multicasting of Delegates
using System;
 
class rectangle {
     
// declaring delegate
public delegate void rectDelegate(double height,
                                  double width);
 
    // "area" method
    public void area(double height, double width)
    {
        Console.WriteLine("Area is: {0}", (width * height));
    }
  
    // "perimeter" method
    public void perimeter(double height, double width)
    {
        Console.WriteLine("Perimeter is: {0} ", 2 * (width + height));
    }
  
  
// Main Method
public static void Main(String []args)
{
     
    // creating object of class
    // "rectangle", named as "rect"
    rectangle rect = new rectangle();
 
    // these two lines are normal calling
    // of that two methods
    // rect.area(6.3, 4.2);
    // rect.perimeter(6.3, 4.2);
 
    // creating delegate object, name as "rectdele"
    // and pass the method as parameter by
    // class object "rect"
    rectDelegate rectdele = new rectDelegate(rect.area);
     
    // also can be written as
    // rectDelegate rectdele = rect.area;
 
    // call 2nd method "perimeter"
    // Multicasting
    rectdele += rect.perimeter;
 
    // pass the values in two method
    // by using "Invoke" method
    rectdele.Invoke(6.3, 4.2);
    Console.WriteLine();
     
    // call the methods with
    // different values
    rectdele.Invoke(16.3, 10.3);
}
}
Output: 
 

Area is: 26.46
Perimeter is: 21 

Area is: 167.89
Perimeter is: 53.2
 
Here is another recommended article on Delegates in C#.

=============================
Callback Operation By Delegate Or Interface
=============================
https://www.c-sharpcorner.com/UploadFile/1c8574/delegate-used-for-callback-operation/

Introduction
A "callback" is a term that refers to a coding design pattern. In this design pattern executable code is passed as an argument to other code and it is expected to call back at some time. This callback can be synchronous or asynchronous. So, in this way large piece of the internal behavior of a method from the outside of a method can be controlled. It is basically a function pointer that is being passed into another function.

Delegate is a famous way to implement Callback in C#.  But, it can also be implemented by Interface. I will explain Callback by Delegate and Interface one by one. 

Callback by Delegate 
Delegate provides a way to pass a method as argument to other method. To create a Callback in C#, function address will be passed inside a variable. So, this can be achieved by using Delegate.

The following is an example of Callback by Delegate

public delegate void TaskCompletedCallBack(string taskResult);
public class CallBack
{
    public void StartNewTask(TaskCompletedCallBack taskCompletedCallBack)
    {
        Console.WriteLine("I have started new Task.");
        if (taskCompletedCallBack != null)
            taskCompletedCallBack("I have completed Task.");
    }
}
C#
public class CallBackTest
{
    public void Test()
    {
        TaskCompletedCallBack callback = TestCallBack;
        CallBack testCallBack = new CallBack();
        testCallBack.StartNewTask(callback);
    }
    public void TestCallBack(string result)
    {
        Console.WriteLine(result);
    }
}
C#
static void Main(string[] args)
{
    CallBackTest callBackTest = new CallBackTest();
    callBackTest.Test();
    Console.ReadLine();
}
C#
Output

I have started new Task.

I have completed Task.

Delegate is a good way to implement Callback. But, you could use Interface for this. Because, suppose you have two methods - one for the success and another for the error and these methods will use Callback, so if you will use Delegate you will have to take two Delegates. 

If you need more than one Callback method then Callback mechanism with the use of Delegate doesn't makes sense. So, the use of Interface provides flexible and well-performing Callback mechanism for this scenario. 

Callback by Interface
Use an Interface to provide Callback mechanism. It provides flexible and well-performing Callback mechanism. The following code example will elaborate the Callback mechanism with the help of Interface:

public interface IMeeting
{
    void ShowAgenda(string agenda);
    void EmployeeAttendedMeeting(string employee);
    void EmployeeLeftMeeting(string employee);
}
C#
public class Meeting : IMeeting
{
    public void ShowAgenda(string agenda)
    {
        Console.WriteLine("Agenda Details: " + agenda);
    }

    public void EmployeeAttendedMeeting(string employee)
    {
        Console.WriteLine("Employee Attended Meeting: " + employee);
    }

    public void EmployeeLeftMeeting(string employee)
    {
        Console.WriteLine("Employee Left Meeting: " + employee);
    }
}
C#
public class MeetingRoom
{
    private string message;
    public MeetingRoom(string message)
    {
        this.message = message;
    }

    public void StartMeeting(IMeeting meeting)
    {
        // Its a callback
        if (meeting != null) meeting.ShowAgenda(message);

    }
}
C#
public class MeetingExecution
{
    public void PerformMeeting()
    {
        IMeeting meeging = new Meeting();
        MeetingRoom meetingStarted = new MeetingRoom("Code Quality Improvement.");
        meetingStarted.StartMeeting(meeging);
    }
}
C#
static void Main(string[] args)
{
    MeetingExecution meetingExecution = new MeetingExecution();
    meetingExecution.PerformMeeting();

    Console.ReadLine();
}
C#
Output

Agenda Details: Code Quality Improvement.

Conclusion
Delegate is a great way to implement Callback operation. But, interface is good for the implementation of Callback in different scenario which I have mentioned above. Please read carefully and understand the code snippets. I have also attached code files. Writing code is good but code with proper design approach increases the quality of code. So, before writing any code always try to follow some design approach. Your code will be awesome.

=============================
C# Delegate Tutorial With Easy Example
=============================
https://www.completecsharptutorial.com/basic/c-delegate-tutorial-with-easy-example.php

This article explains how to create and manipulate Delegates in c#. Before starting delegates you must understand what delegate is?

WHAT IS DELEGATE?
You may get numbers of complex reasons of using delegates on different site. I am not going to put a complex paragraph here. In simple word delegates contains the reference to several methods and call them when needed. So, you create numbers of methods as you need and attach it to delegates. At runtime, an event gets fired and delegates dynamically call the function and show the result.

REAL WORLD EXAMPLE
Let me draw a picture for you. For example, what will you do when you are in a railway station and suddenly hear a fire alarm. What would you do? You will run immediately outside of the campus. So, let me put this scenario in delegates.

When you hear fire alarm it is actually an event. As you hear fire alarm you initiate to run() function to escape.
But if you hear an announcement about your train you don't escape and go to the suitable platform to catch the train.
If you hear your name in the announcement that someone is on phone-line and want to talk to you; you go to inquiry counter to attend the phone.
If you hear that train is 6 hours late you may think of a movie meanwhile the time.
So, in real-world example we also react differently based on event or situation. In programming, delegate does the same thing. We create numbers of suitable function and execute them based on Event.fig-delegate 

Delegate figure
*function()*--------l
function()---------->v^  Delegate ---generate an event--- ++(Publisher (event generator))++
function()-----------l

SOME FACTS ABOUT DELEGATES
Delegates are reference type but instead of referencing objects it reference methods.
Delegates have no method body.
Delegates are type-safe, object-oriented and secure.
A Delegate is a function pointer that allows you to reference a method.
Delegates encapsulate methods.
A Function that is added to delegates must have same return type and same signature as delegate.
A Delegate can be created using delegate keyword.
Delegates with no parameter and no return type
Public delegate TestDelegate();

Delegates with a parameter but no return type
Public delegate TestDelegate(object obj1, object obj2);

Or,
Public delegate TestDelegate(String message)

Delegates with parameters and return type
public delegate int TestDelegate(object obj1, object obj2);

A delegate has 3 steps
Declaration
Instantiation
Invocation
PROGRAMMING EXAMPLE
Here, I am showing you very basic delegates programming. Once you understand how delegates work you will be able to crack complex delegates codes.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication2
{
    public class TestDelegate
    {
        //Declaration
        //Creating Delegates with no parameters and no return type.
        public delegate void FirstDelegate();
 
        public void fun1()
        {
            Console.WriteLine("I am Function 1");
        }
        public void fun2()
        {
            Console.WriteLine("I am Function 2");
        }
        public void fun3()
        {
            Console.WriteLine("I am Function 3");
        }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            TestDelegate testdelegate = new TestDelegate();
//Instantiation
            TestDelegate.FirstDelegate fd1 = new TestDelegate.FirstDelegate(testdelegate.fun1);
            TestDelegate.FirstDelegate fd2 = new TestDelegate.FirstDelegate(testdelegate.fun2);
            TestDelegate.FirstDelegate fd3 = new TestDelegate.FirstDelegate(testdelegate.fun3);
 
//Invocation 
           fd1();
            fd2();
            fd3();
 
            Console.ReadKey();
        }
    }
}

Output
I am Function 1

I am Function 2

I am Function 3

_
EXPLANATION
In this programming Example, I have created a delegate
 public delegate void FirstDelegate();

I have also created 3 functions
public void fun1()
public void fun2()
public void fun3()

In the main function creates an object of delegates. You must remember that a delegate always requires a function while initialized.
TestDelegate.FirstDelegate fd1 = new TestDelegate.FirstDelegate(testdelegate.fun1);
TestDelegate.FirstDelegate fd2 = new TestDelegate.FirstDelegate(testdelegate.fun2);
TestDelegate.FirstDelegate fd3 = new TestDelegate.FirstDelegate(testdelegate.fun3);

Finally call the delegates to execute the function.
fd1();
fd2();
fd3();

EXAMPLE 2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace DelegateExample
{
    class Program
    {
        public delegate int calculator(int x, int y);
 
        static int Addition(int a, int b)
        {
            return a + b;
        }
        static int Subtraction(int a, int b)
        {
            return a - b;
        }
        static void Main(string[] args)
        {
            calculator c = new calculator(Program.Addition);
            Console.WriteLine("Addition of 5 and 10 is : {0}", c(5, 10));
 
            calculator d = new calculator(Program.Subtraction);
            Console.WriteLine("Subtraction of 5 and 10 is : {0}", d(5, 10));
 
            Console.ReadKey();
        }
    }
}

Output
Addition of 5 and 10 is : 15


Subtraction of 5 and 10 is : -5
SUMMARY
In this chapter, you learned what is delegates and how to use it in programming. In the next chapter, you will learn about multicast delegates with example.

=============================
Nested C# loops: programming loops inside each other
=============================
https://kodify.net/csharp/loop/nested-loop/

Most of the time, our C# loops process a collection or count from one value to the next. But sometimes we have to do complex calculations or handle nested collections. In those cases we need the more advanced nested loops. Let’s see how those work.

IN THIS ARTICLE:

Understand nested loops in C#
Quick example: nested for loop in C#
Code a foreach nested loop in C#
Example: code a nested foreach loop in C#
Creating nested loops with C#’s for loop
Example: program a nested for loop in C#
Make nested loops with C#’s while loop
Example: make a nested loop with the while loop
Summary
# Understand nested loops in C#
A nested loop is a construction of two or more loops that are placed inside each other (Liberty & MacDonald, 2009; Sempf, Sphar, & Davis, 2010). This makes elaborate calculations possible, as well as looping through nested arrays, lists, and dictionaries.

With a nested loop, the inner loop runs to completion for each iteration of the outer loop (Liberty & MacDonald, 2009; Sempf et al., 2010). This behaviour adds an extra dimension to our loop. Now instead of simply going through a list’s length, we can also loop through its depth.

To clarify, the inner and outer loop terms refer to different parts of a nested loop:

Terminology of nested loops in C#
Sometimes when we have a lot of loops inside each other, the first loop is called the outermost loop. And the most deeply embedded one the innermost loop.

# Quick example: nested for loop in C#
Here’s a quick nested loop example:

int rows = 2, columns = 4;

// Make a rectangular array
int[,] recArray = new int[rows, columns];

// Loop over each row and column
for (int i = 0; i < rows; i++)
{
    for (int j = 0; j < columns; j++)
    {
        recArray[i, j] = i + j;
    }
}
Here we have a nested for loop. The outer for loop goes from 0 up to 2 (the value of the rows variable). For each of those loop cycles, the inner loop goes from 0 to (but not including) 4 (columns). This fills a 2x4 array. That is, each cycle of the outer loop creates a row, and inner loop then fills the columns of that row.

Note that outer loops cannot access the loop variables of inner loops. In our example above, the outer loop – which uses the i variable – cannot look up the j variable. The other way around does work: the inner loop can access the outer loop’s i variable.

Now that we know what nested loops are, let’s look at some more C# examples.

# Code a foreach nested loop in C#
A foreach loop easily loops through all values that a collection has. With this loop we don’t handle loop indexes, and neither have to update the loop variable.

The default pattern of a nested foreach loop is:

foreach (var collection in nestedCollections)  // Outer loop
{
    // Code that should run for each collection

    foreach (var item in collection)  // Inner loop
    {
        // Code that should run for each item
    }
}
There are two foreach loops here. The outer loop goes through each collection in our list of nested collection (nestedCollections). During each of those loop cycles, the collection variable refers to a single one of those nested collections.

The inner foreach loop then processes each item for every collection in that nested collection. That handle each single item that nestedCollections has.

We can use the same pattern to run through two separate collections. That way for each loop cycle of the first collection, we process another collection in its entirety. This is how we for instance match the value of one list with the value in another list:

foreach (var itemA in mainCollection)  // Outer loop
{
    // Code that should run for each item in the main collection

    foreach (var itemB in otherCollection)  // Inner loop
    {
        // Code that can compare every single
        // `itemA` value against all values in `otherCollection`
    }
}
# Example: code a nested foreach loop in C#
The program below shows how a nested foreach loop works in practice. The program first goes through a list of domain extensions (like .net and .com). An inner loop then matches each extension against a domain name. The result is a table with domain extensions and example domains.

The program’s full code is:

using System;

class Kodify_Example
{
    static void Main()
    {
        string[] extensions = { ".com", ".org", ".net"};
        string[] domains = { "github.com", "twitter.com", "bitbucket.org",
            "signal.org", "windows.net", "ghacks.net"  };

        // Loop through all extensions
        foreach (string extension in extensions)
        {
            Console.Write("{0} | \t", extension);

            // Print domains that match the web extension
            foreach (string domain in domains)
            {
                if (domain.EndsWith(extension))
                {
                    Console.Write(domain + "\t");
                }
            }

            Console.Write("\n");
        }
    }
}
The Main() method we make two arrays with string values. The first, extensions, has three different top-level domain names. The other, domains, contains 6 example websites.

Then we make a nested loop. The outer foreach loop goes through the extensions array. With the extension loop variable we fetch a single element from that array with each pass through the loop.

Inside this loop we first print the domain extension with the Console.Write() method. Then we make a second, nested loop. This foreach loop goes through each domain in the domains array. The loop’s domain string variable represents one website domain.

Because our nested loop goes through all websites for each domain extension, we can match a particular top-level domain (like .net) with an example website (windows.net). That’s exactly what the if statement does inside the inner loop.

There we check if the domain we loop over (domain) ends with (EndsWith()) the top-level domain extension (the outer loop’s extension variable). When it does, the if statement’s code outputs that domain with Console.Write().

Here’s how that generated output looks:

.com |  github.com      twitter.com
.org |  bitbucket.org   signal.org
.net |  windows.net     ghacks.net
# Creating nested loops with C#’s for loop
A for loop easily counts from one value to another. This way we loop over collections (like arrays and lists) and perform calculations. With for loops inside each other, even more program behaviour is possible.

Here’s how nested for loops look like:

for (int i = 0; i < 10; i++)  // Outer loop
{
    // Code here executes once
    // for each outer loop cycle

    for (int j = 0; j < 10; j++)  // Inner loop
    {
        // The inner loop runs to completion
        // for each loop cycle of the outer loop
    }
}
The outer for loop has the i variable go from 0 to 10. During each of those loop cycles we run another for loop. This one has a j variable that also goes from 0 up to 10. For each cycle of the outer loop, the inner loop repeats 10 times.

# Example: program a nested for loop in C#
Let’s see how a nested for loop works in practice. The console application below has a nested loop go through two arrays. One contains domain extensions (like .com). The other has domain names (github.com). Inside the loop we match each extension with its domain names.

The program’s code is:

using System;

class Kodify_Example
{
    static void Main()
    {
        string[] extensions = { ".com", ".org", ".net"};
        string[] websites = { "github.com", "twitter.com", "bitbucket.org",
            "signal.org", "windows.net", "ghacks.net"  };

        // Go through all extensions
        for (int i = 0; i < extensions.Length; i++)
        {
            Console.Write("{0} | \t", extensions[i]);

            // And print those domains that match the extension
            for (int j = 0; j < websites.Length; j++)
            {
                if (websites[j].EndsWith(extensions[i]))
                {
                    Console.Write(websites[j] + "\t");
                }
            }

            Console.Write("\n");
        }
    }
}
We make two arrays in Main(). The first, extensions, has three domain name extensions. The other, websites, has six domain names.

To process those values we make a nested loop. The outer loop is a for loop that iterates from 0 until the number of elements in our first array (extensions.Length). After each loop cycle we increase that i loop variable with one (i++). Inside this loop the Console.Write() method outputs the current domain extension.

There we also make another for loop. This inner loop goes through each element in the websites array. For that we make the j variable, and continue for as long as that variable is less than the array’s length (websites.Length). After each loop cycle we increase that variable with one (j++).

That inner loop has an if statement. This checks if the current website we loop over (websites[j]) ends with (EndsWith()) the domain extension that the outer loop iterates over (extensions[i]). When that’s the case, we print the current website with Console.Write(). This way we match the domain names and their extension.

Here’s how that output looks:

.com |  github.com      twitter.com
.org |  bitbucket.org   signal.org
.net |  windows.net     ghacks.net
# Make nested loops with C#’s while loop
With a while loop we repeat code as long as a condition remains true. We can also translate that behaviour to nested loops. That way we can handle data and advanced calculations.

Here’s how a nested while loop can look:

while (conditionA)
{
    // Code here executes for each outer loop cycle

    while (conditionB)
    {
        // The inner loop's code runs till
        // completion for each outer loop cycle

        conditionB = ...
    }

    // Change loop condition at some point
    conditionA = ...
}
The outer while loop goes on for as long as conditionA tests true. Each time it does, the loop’s code executes. There we have another while loop. That inner loop runs based on conditionB.

When that condition is true, the inner loop executes. When it becomes false, the inner loop ends and the outer loop continues. Then with the next outer loop cycle the inner loop starts again.

# Example: make a nested loop with the while loop
The example program below has a nested while loop process two arrays. The first contains domain extensions. The second has domain names. The program’s goal is to match domain extensions (like .org) with website domains (bitbucket.org).

The code of this console application is:

using System;

class Kodify_Example
{
    static void Main()
    {
        string[] extensions = { ".com", ".org", ".net"};
        string[] websites = { "github.com", "twitter.com", "bitbucket.org",
            "signal.org", "windows.net", "ghacks.net"  };

        int i = 0;

        // Match website extensions with their domain names
        // Loop through the domain extensions
        while (i < extensions.Length)
        {
            Console.Write("{0} | \t", extensions[i]);

            // Then only print those domains with a matching extension
            int j = 0;
            while (j < websites.Length)
            {
                if (websites[j].EndsWith(extensions[i]))
                {
                    Console.Write(websites[j] + "\t");
                }
                j++;
            }

            Console.Write("\n");
            i++;
        }
    }
}
In Main() we first make two string arrays. The first, extensions, has top-level domain extensions. The other, websites, has domains for technology-related websites.

Then we declare and initialise the i variable. We use this one to control the outer loop. That while loop is what we make next. We have that loop continue for as long as i is less than (<) the length of the extensions array. That processes each of the three domain extensions.

Inside the loop we first output the top-level domain with Console.Write(). Then we look for websites that match that domain extension.

For that we first declare the j variable. With this variable we control the nested while loop, which we make next. This loop runs when that variable is less than the length of the websites array (websites.Length). For each outer loop cycle (the domain extension), this inner loop (with websites names) runs to completion.

The inner loop has an if statement. This one sees if the website we loop over (websites[j]) ends with (EndsWith()) the same domain extension as the outer loop’s variable (extensions[i]). When the current website indeed matches that domain, code inside the if statement outputs the website with the Console.Write() method. This way we match the domain extension output with the example websites.

After the if statement we’re still inside the inner loop. There we increase the j variable with one (j++). That makes the inner loop go through all array elements.

When the inner loop finishes, there are two statements left in the outer loop. We first have Console.Write() make a new line ("\n"). That ensures a proper output of all values. Then we increase the i loop variable with one (i++). That way the outer loop goes through all website extensions.

This is what the above example program outputs:

.com |  github.com      twitter.com
.org |  bitbucket.org   signal.org
.net |  windows.net     ghacks.net
LEARN MORE
Break out of nested C# loops
Skip loop cycles of nested C# loops
# Summary
Regular loops can handle a lot of situations. But with multiple collections, complex calculations, or nested collections, we need a nested loop.

A nested loop are one or more loops placed inside each other. That way the inner loop runs to completion for each loop cycle of the outer loop.

We can make a nested loop with loops of the same kind (like two for loops) or use different types. The most common are, however, two for or two foreach loops inside each other.

=============================
Nested For Loops -Bro Code
=============================
https://youtu.be/WFzLcZk137s

{{ Once we enter our Outer-for-loop we will immediately enter our Inner-for-loop in order to complete 1 iteration of the Outer-for-loop we have to finish all iterations of the Inner-for-loop & once we finish all iterations of the Inner-for-loop we can complete one iteration of the Outer-for-loop & during the next iteration we have to do it all over again So on the next iteration we have to complete all the iterations for the Inner-for-loop so this will display a rectangle made out of a certain symbol However there's one thing missing & I'll show you 4rows,5columns,@symbol So this ended up in 1 long row So after we complete our iterations for the Inner-for-loop we should probably move on to the next row kind of like a typewriter we finish one line then we move on to the next row So let's use an empty WriteLine statement just to move down to the next line Nested loop is really a loop inside another loop When you'll encounter it it really varies but they're used a lot in Sorting algorithms —Bro Code }} first iteration of outerloop then all iterations of innerloop then back to outerloop rinse repeat.
using System;
	
public class Program
{
	public static void Main()
	{
		Console.Write("How many rows?: ");
		int rows = Convert.ToInt32(Console.ReadLine());
		Console.Write("How many columns?: ");
		int columns = Convert.ToInt32(Console.ReadLine());
		Console.Write("What symbol?: ");
		string symbol = Console.ReadLine();
		for (int i = 0; i < rows; i++)
		{
			for (int j = 0; j < columns; j++)
			{
				Console.Write(symbol);
			}

			Console.WriteLine();
		}

		Console.ReadKey();
	}
}

=============================
Delegates -Wikiversity
=============================
https://en.wikiversity.org/wiki/C_Sharp

As the word suggests it delegates. It delegates the job to do an operation. In OOPS operations are called methods. So delegate is a type in c# which points to a method with a particular parameter list and return type. One can instantiate a delegate and associate it to a method/methods of similar signature and return type.

Delegates are best used as callbacks. Used to pass methods as arguments to other methods.

How to declare a delegate
    Delegates are declared with "delegate" keyword followed by return type and method signature.
    e.g: public delegate int MathOperation (int,int);

=============================
Lambda Expressions -Wikiversity
=============================
https://en.wikiversity.org/wiki/C_Sharp/Lambda

Introduction
Lambda expressions are one of the forms of anonymous methods in .Net, which can be used for passing as inputs for local functions or as an expression to execute inline. Lambda expressions are particularly helpful for writing LINQ query expressions.

Lambda expressions helps in simplifying the logical statements and looping statements. This is possible for enumerable types where we can use Lambda expressions instead of writing looping statements or logical statements in multiple execution lines making code look cleaner and simple.

Example
using System;
using System.Linq;

namespace Program
{
  class Program
  {
    public static void Main(string [] args) 
    {
      int[] myInteger = new int[] {1,2,3,4,5}; //Creates an integer array named myInteger and initializes it with 5 values(1, 2, 3, 4, 5). 1 is in index 0, 2 is in index 1, etc
      var getNumbers = from num in myInteger  where num > 1 select num;//similar to a SQL query. Return a collection of all numbers greater than one
     
       foreach(int number in getNumbers)//loop through that collection we just made.
       {
          Console.WriteLine(number);//2, 3, 4, 5
       }
       Console.ReadKey();
     }
  }
}
=============================
Loops -Wikiversity
=============================
https://en.wikiversity.org/wiki/C_Sharp/Loops

Lesson Goals
This lesson will focus on all types of loops in the flow of programming in C# via the console. At the end of this lesson you should be able to:
Understand how to use loops.
Understand the prerequisite condition of looping.
Explain the different types of loops and their specific use.
Understand the difference in various loops.
progammatically create collections that can be looped through.
Introduction
Probably in every programming language loops are there to run a specific block of code repetatively based on a specific exit condition. The exit conditon, which is nothing but a boolean expression, is checked every time before a new loop executes and it exits the loop if the condition returns false. In C# these are also present. Loops are productive, smart and clean way of writing code. In a garment factory there is only one person or machine who attach the labels to the garments one after another. You would not find as many labeler as the number of garments in the factory. The condition is, the labeler will work till there are no longer any garments available for labeling. This is a real life example of looping in action.
Types of Loops
There are mainly 4 types of loops in C#.
while loop
do loop
for loop
foreach loop
Loops can be nested as well.
While Loop
Here is the basic structure of While loop.
while(<boolean condition>)
{
 <execution step1>
 <execution step2>
 ...
 <execution stepn>
}
While loop executes a block of code (here execution step1 through execution stepn) repetatively as long as the given boolean condition returns true. Before each new run it checks the condition first and if true then only a new run begins else code flow moves below the loop. Here is an example,-
using System;
namespace WhileLoopApp
{
    class Program
    {
        static void Main()
        {
            int number = 0;
            while(number < 3)
            {
                Console.WriteLine(number);
                number ++;
            }
            Console.ReadLine();
        }
    }
}
Output
0
1
2
In the given example, while loop first checks if variable number is less than 3, which is the case here as number is initialized with 0. Code-flow moves into the while block and executes the first line and prints 0. On second line number value increments with 1. The new value is 1. On next run as number is still less than 3, again it prints number as 1. Similarly, third time it prints 2. Now after increment number value is 3. This makes the while condition false and flows out of the loop without executing the inner block of code.
Do Loop
Do loop or in other words Do-while loop is similar to while loop but the difference is it checks the boolean condition at the end of the execution block. That way, it is guaranteed to run at least once. On the other hand, since while loop validates the boolean condition at the begining of the execution block, there is no guarantee that the inner block of code will run, unless you programmatically do so. Here is the structure of do loop, -
do
{
 <execution step1>
 <execution step2>
 ...
 <execution stepn>
} while(<boolean condition>);
Please note, unlike while loop here you need to put that semi-colon at the end of the while statement.
The typical use of do loop is when you want to show some message or menu to the user and want some input after that. So that it runs at least once and based on the input the loop may or may not run again. Here is an example, -
using System;
namespace DoLoopApp
{
 class Program
 {
    public static void Main()
    {
        string myChoice;
        do
       {
            // Print A Menu
            Console.WriteLine("My Address Book\n");
            Console.WriteLine("A - Add New Address");
            Console.WriteLine("D - Delete Address");
            Console.WriteLine("M - Modify Address");
            Console.WriteLine("Q - Quit\n");
            Console.WriteLine("Choice (A,D,M or Q): ");
            // Retrieve the user's choice
            myChoice = Console.ReadLine();
            // Make a decision based on the user's choice
            switch(myChoice)
            {
                case "A":
                case "a":
                    Console.WriteLine("You want to add an address.");
                    // Put Address adding code here.
                    break;
                case "D":
                case "d":
                    Console.WriteLine("You want to delete an address.");
                    // Put Address deleting code here.
                    break;
                case "M":
                case "m":
                    Console.WriteLine("You want to modify an address.");
                    // Put Address modifying code here.
                    break;
                case "Q":
                case "q":
                    Console.WriteLine("Bye.");
                    break;
                default:
                    Console.WriteLine("{0} is not a valid choice", myChoice);
                    break;
            }
            // Pause to allow the user to see the results
            Console.Write("press Enter key to continue...");
            Console.ReadLine();
            Console.WriteLine();
        } while (myChoice != "Q" && myChoice != "q"); // Keep looping until the user wants to quit
    }
 }
}
It is a typical example of do loop.
For loop
First let us have a look at the structure of the for loop.
for (counter-initialization; counter-bound; counter-increment)
{
  <execution step1>
  <execution step2>
  ...
  <execution stepn>
}
Here are the steps of for loop,-
First counter-initialization happens. This is an one time operation for the life of the loop.
Then counter-bound gets checked. This is another boolean condition and as long as it evaluates to true code-flow moves to the next step. Else it will move out of the loop.
Now execution step1 through execution stepn gets performed.
Next counter-increment happens.
Again step-2 executes.
As you can see, for loops are useful when you know exactly how many times the looping should occur. Also, you must have noticed that the counter-bound gets checked before the execution steps gets executed. so, like while loop, for loop also executes zero or more times. Also note, all the expressions of the for loop are optional. Below is an infinite for loop example.
for (; ; )
{
    // ...
}
Now lets see a for loop in action, -
using System;
namespace ForLoopApp
{
 class Program
 {
    public static void Main()
    {
        for (int i=0; i < 20; i++)
        {
            if (i == 10)
                break;
            if (i % 2 == 0)
                continue;
            Console.Write("{0} ", i);
        }
        Console.ReadLine();
    }
 }
}
Output
1 3 5 7 9
The above example has one special thing. It has two disruptions in the otherwise smooth run of for loop execution block. As you have already learned about the branching statements the two if sections uses break and continue to breakaway from the execution block.
Foreach loop
This type of loop is typically used to iterate through a collection of objects. There are many .NET provided collection objects available for use, such as, Arraylist. The major difference between a for loop and a foreach loop is that, for loop repeats a block of code for a number of times, where as foreach loop repeats a block of code for each item in a collection of objects. Here is a structure of foreach, -
foreach (<''type''> <''iteration variable''> in <''list''>)
 {
    <''execution step 1''>
    <''execution step 2''>
    ...
    <''execution step n''>
 }
Here type is the datatype of each element that is there in the collection. The iteration variable is the meaningful name for each element. The list is the collection on which the iteration will happen. And there is these repeatable block of code from execution step 1 through execution step n.
Points to Remember: -
Not all collections can be iterated using foreach. In fact a collection has to have implementation of System.Collections.IEnumerable or System.Collections.Generic.IEnumerable(T) interface.
The in keyword and type definition is required.
While iterating through a collection using foreach, the collection is read only. This means any items in that collection can not be modified in the foreach execution block. However, if you are using custom types like collection class or structs then you can modify individual fields in that. More on this in later lessons.
Foreach in System Collections
Let's have a look at a simple example of a foreach loop using system defined collection object, an array.
using System;
namespace ForEachLoopApp
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] fibArray = new int[] { 0, 1, 1, 2, 3, 5, 8, 13 };
            foreach (int ele in fibArray)
            {
                System.Console.WriteLine(ele);
            }
            System.Console.ReadLine();
        }
    }
}
Output
0
1
1
2
3
5
8
13
Here we have an integer array populated with the first 8 numbers of Fibonacci Series. Then in the foreach loop we printed each element in each line. Here the looping is possible as the system defined collection array by default implements System.Collections.IEnumerable.
Foreach in Custom Collections
Usually custom collections do not support looping through foreach. Trying so will throw compile time error. So to enable foreach looping for a class we need to implement System.Collections.IEnumerable. Our class in initial form,-
using System;
namespace ForEachLoopApp
{
    class Splitter//:IEnumerable
    {
        private string[] elements;
        Splitter(string source, char[] delimiters)
        {
            // Parse the string into tokens:
            elements = source.Split(delimiters);
        }
        
        static void Main()
        {
            // Testing Tokens by breaking the string into tokens:
            Splitter f = new Splitter("This is C# Learning Lesson 8-Loops.", new char[] { ' ', '-' });
            foreach (string item in f)
            {
                System.Console.WriteLine(item);
            }
        }
    }
}
This throws compile time error, -
foreach statement cannot operate on variables of type 'ForEachLoopApp.Splitter' because 'ForEachLoopApp.Splitter' does not contain a public definition for 'GetEnumerator'
So now we need to implement System.Collections.IEnumerable.
using System.Collections;
namespace ForEachLoopApp
{
    class Splitter:IEnumerable
    {
        private string[] elements;
        Splitter(string source, char[] delimiters)
        {
            // Parse the string into Splitter:
            elements = source.Split(delimiters);
        }
        
        static void Main()
        {
            // Testing Tokens by breaking the string into Splitter:
            Splitter f = new Splitter("This is C# Learning Lesson 8-Loops.", new char[] { ' ', '-' });
            foreach (string item in f)
            {
                System.Console.WriteLine(item);
            }
            System.Console.ReadLine();
        }
        #region IEnumerable Members
        public IEnumerator GetEnumerator()
        {
            return new SplitterEnumerator(this);
        }
        #endregion
        // Inner class implements IEnumerator interface:
        private class SplitterEnumerator : IEnumerator
        {
            private int position = -1;
            private Splitter t;
            public SplitterEnumerator(Splitter t)
            {
                this.t = t;
            }
            #region IEnumerator Members
            public object Current
            {
                get
                {
                    return t.elements[position];
                }
            }
            public bool MoveNext()
            {
                if (position < t.elements.Length - 1)
                {
                    position++;
                    return true;
                }
                else
                {
                    return false;
                }
            }
            public void Reset()
            {
                position = -1;
            }
            #endregion
        }
    }
}
Output
This
is
C#
Learning
Lesson
8
Loops.
Here both the interfaces IEnumerable and IEnumerator are implemented. To avoid this hassle you can use of Generic Classes. There by default System.Collections.Generic.IEnumerable(T) is implemented and it will directly iterate through foreach loop.
Performance Tips
Since foreach iterates through objects of a collection, it is slower than for loop, which is looping based on counter. [1] Still sometimes you would have to use foreach over for.

{ C# Delegates (US YT):: https://youtu.be/EyR2AfLkwcA ervistrupja https://youtu.be/3ZfwqWl-YI0 codemonkey https://youtu.be/vOlLd2SsKM4 simplilearn https://youtu.be/KaxNwGA9fiY rawcoding https://youtu.be/R8Blt5c-Vi4?t=723 *iamtimcorey } threadsafe {{ The 4 types of Programming Language that are classified are: Procedural Programming Language. Functional Programming Language. Scripting Programming Language. Logic Programming Language. Object-Oriented Programming Language. }} {{ The seven steps of programming. Step 1: Define the Program Objectives. ... Step 2: Design the Program. ... Step 3: Write the Code. ... Step 4: Compile. ... Step 5: Run the Program. ... Step 6: Test and Debug the Program. ... Step 7: Maintain and Modify the Program. }} {{ Coder. Programmer. Developer. Codaholic. }} {{ -=crowdsourcing=- Getting help from a large group of people to finish something faster. -=cyberbullying=- Doing something on the internet, usually again and again, to make another personal feel angry, sad, or scared. -=digital citizen=- Someone who acts safely, responsibly, and respectfully online. -=decompose=- Break a problem down into smaller pieces. -=digital footprint=- The information about someone on the Internet. -=F.A.I.L=- First Attempt In Learning -=iteration=- A repetitive action or command typically created with programming loops. -=pixel=- Short for "picture element", the fundamental unit of a digital image, typically a tiny square or dot that contains a single point of color of a larger image. -=Object-oriented programming=- is centered around digital objects that contain functions and data. Data and code are representations of an object’s properties. This data structure allows for unique variables within the program. || OOP is a programming paradigm that allows for the independent modeling of data. Objects consist of both protocols and values. An example of an object-oriented language is JavaScript, C++, or Python. -=Class=- A class is one of the basic building blocks of a computer program. Programmers define classes that act as blueprints for creating objects in the code. The idea of a class is to group together related values and behavior. For example, in a social media app, there could be a class for a User. The User class holds reusable code and properties, such as name, picture, hobbies, and more. -=Agile software development=- is a set of practices that governs the way a team creates software programs. Agile development involves collaboration among cross-functional teams to build software efficiently. Each team within the Agile framework will work on its own piece of code that will become part of the final project. || Why Programmers Should Know About Agile Software Development Agile software development is a common software creation approach that’s used by many major tech firms. By dividing a project into smaller chunks, each programming team can write code more efficiently. Sprints provide developers with concise workloads and allows them to conduct a proper code review to ensure that each component is perfect. -=Asynchronous programming=- “out of sync” In simple terms is a technique that allows a program or application to continue its operation while waiting for other tasks to be completed. A typical example in web development is the ability of a website like Facebook to allow the user to, for example, read your post feed while the messenger chat is still loading. This technique is now widely used in modern websites and applications. -=Class (Object-oriented programming)=- In object-oriented programming, a class defines a structure for creating objects consisting of variables or attributes and functions or methods. Each of these objects is then called an “instance” of the class. -=Crawl=- Anything you look for you can find on Google, but how does Google know what each website contains? Well.. Google crawls each website from time to time to read its contents and store it in their databases so that you can later retrieve it. -=DevOps=- A set of practices, philosophies, and tools that combine software development (dev) and IT operations (ops) to increase the efficiency and speed at which teams and organizations can deliver applications and services. -=Event, Event Listener=- In certain situations, it is necessary to trigger actions after certain user or system interactions, e.g., the user moves the mouse, clicks on a button, the clock ticks a new second, etc. Those moments are called events, and an event listener is a connector that allows developers to plug custom logic or algorithms when one of these actions occurs. Note that different events will be available depending on the platform, software, tools, etc. -=Framework=- A framework is a set of tools, libraries, design, and structure that help developers build products. Not to be confused with a library (though it is quite common), a framework does not provide only functions and routines but also opinionates on how to solve certain problems. -=JWT=- JWT or JSON Web Token is a standard used to identify user identity between client and server. They contain information about the logged-in user, and it is transmitted between the FE and the BE, or even between different BE systems. The user information cannot be forged or altered as it is protected by encryption. Thus, it is a safe mechanism that enables it to become an industry standard. -=Kebab case=- Snake case is the practice of naming variables, functions, etc., by separating words with a dash (-). It is very common in URLs. E.g.: /gear-and-tools/. -=Pascal case=- Pascal case is the practice of naming variables, functions, etc., by capitalizing all words. It is very common to declare classes. E.g.: UserService. -=Snake case=- Snake case is the practice of naming variables, functions, etc., by separating words with an underscore (_). It is common in some programming languages like Python and JSON responses from APIs. E.g.: is_user_logged_in. -=Camel case=- Camel case is the practice of naming variables, functions, etc., by capitalizing all words except the first one. E.g.: isUserLoggedIn. -=NPM (Node package manager)=- NPM Is a CLI tool used by programmers to find and install tools, libraries, and frameworks to develop applications built in JavaScript / TypeScript. -=NPX=- Some NPM packages are not meant to be installed, for example, packages that allow you to set up a new project. We can use NPX to download the code and run the script without keeping it installed. -=Pair programming=- It is a technique in which two developers work together on one computer (or virtually, though it is not the same experience). It is common for junior developers to follow these practices with developers of higher seniority, but it is not the only case that can be fruitful. Senior developers can also benefit from this technique by sitting with other developers. I guess four eyes and two minds can really see and think better than the two individually. -=Parse=- It is the action of transforming data into a workable format. For example, when you retrieve data from an API, the data is transmitted as text (or string), even when the data represents a JSON object. If you want to work with that data, you must parse the string into an object. -=Plugin=- A plugin is a software, library, or module that can be added to another application, framework, or software with the end of increasing its functionality, security, or features. -=Repository (repo)=- Think of it as basically a folder that contains all the source files of a project (including its history of change), and it is stored in some location you can access to read those files. Very common when we talk about a git repository, meaning the allocated name for the project on a git server. -=Responsive Design=- When building applications or websites, we can’t ignore that nowadays, people will access them from different devices such as phones, tablets, or computers. Responsive design allows for developers to build software that adapts its contents to fit into the different screen sizes without building different applications for each. -=REST API=- Representational state transfer (REST) APIs are a way to transfer information over the HTTP protocol, following rules and conventions. -=SaaS (software as a service)=- It is a software licensing model in which software is licensed on a subscription and made available on the internet. -=Spaghetti code=- Spaghetti code is a term used to describe code that is very hard for humans to read and understand, mainly because of how the developer or developers wrote the code. It can be caused by different reasons, including changes in scope, the evolution of requirements, code written by multiple developers over long periods, lack of programming style rules, or developer experience. -=UX=- UX designs the user experience by thinking about how the user will interact with the software and making it pleasant and optimal for the target audience. -=Wireframe=- A website’s bare-bones structure can even be a sketch on a napkin. No fonts, colors, or images. This layout is the first step to testing the idea before content and design are added. -=Nested=- Functions or objects that are contained within another function or object. So, a function that exists entirely inside the directions of a separate function is nested. -=Client-Side=- Client-side is a popular term in web development. The Client-side refers to everything that an end user sees. It is quite literally the side that the clients get to see. On a web page, client-side refers to: Text Images Any other UI component visible/accessible to you Actions that your browser performs For example, the markup languages HTML and CSS are interpreted on the client side. This simply means your browser renders the web page. Opposition to the client-side is server-side. The server-side things happen remotely on a server and are inaccessible to the client. For example, when you log in to your favorite website, the authentication takes place server-side. }}

{{ Nested Loops
https://flylib.com/books/en/4.330.1.79/1/ http://www.cl72.org/070documents/C/c-primer.pdf http://spiro.fisica.unipd.it/~boschini/c/(Ebook)%20Sams%20-%20C%20%20Primer%20Plus%205Th%20Edition%202005.pdf https://zhjwpku.com/assets/pdf/books/C++.Primer.5th.Edition_2013.pdf

A nested loop is one loop inside another loop. A common use for nested loops is to display data in rows and columns. One loop can handle, say, all the columns in a row, and the second loop handles the rows. Listing 6.17 shows a simple example.

Listing 6.17. The rows1.c Program
/* rows1.c -- uses nested loops */
#include <stdio.h>
#define ROWS 6
#define CHARS 10
int main(void)
{
 int row;
 char ch;
 for (row = 0; row < ROWS; row++) /* line 10 */
 {
 for (ch = 'A'; ch < ('A' + CHARS); ch++) /* line 12 */
 printf("%c", ch);
 printf("\n");
 }
 return 0;
}

Running the program produces this output:
ABCDEFGHIJ
ABCDEFGHIJ
ABCDEFGHIJ
ABCDEFGHIJ
ABCDEFGHIJ
ABCDEFGHIJ

Program Discussion
The for loop beginning on line 10 is called an outer loop, and the loop beginning on line 12 is called an inner loop because it is inside the other loop. The outer loop starts with row having a value of 0 and terminates when row reaches 6. Therefore, the outer loop goes through six cycles, with row having the values 0 through 5. The first statement in each cycle is the inner for loop. This loop goes through 10 cycles, printing the characters A through J on the same line. The second statement of the outer loop is printf("\n");. This statement starts a new line so that the next time the inner loop is run, the output is on a new line.Note that, with a nested loop, the inner loop runs through its full range of iterations for each single iteration of the outer loop. In the last example, the inner loop prints 10 characters to a row, and the outer loop creates six rows.

A Nested Variation
In the preceding example, the inner loop did the same thing for each cycle of the outer loop. You can make the inner loop behave differently each cycle by making part of the inner loop depend on the outer loop. Listing 6.18, for example, alters the last program slightly by making the starting character of the inner loop depend on the cycle number of the outer loop. It also uses the new comment style and const instead of #define to help you get comfortable with both approaches.

Listing 6.18. The rows2.c Program
// rows2.c -- using dependent nested loops
#include <stdio.h>
int main(void)
{
 const int ROWS = 6;
 const int CHARS = 6;
 int row;
 char ch;
 for (row = 0; row < ROWS; row++)
 {
 for (ch = ('A' + row); ch < ('A' + CHARS); ch++)
 printf("%c", ch);
 printf("\n");
 }
 return 0;
}

Here's the output this time:
ABCDEF
BCDEF
CDEF
DEF
EF
F

Because row is added to 'A' during each cycle of the outer loop, ch is initialized in each row to one character later in the alphabet. The test condition, however, is unaltered, so each row still ends on F. This results in one fewer character being printed in each row. }}

{{
https://youtu.be/RRGa48KhRhw CarolineASMR A namespace is a region that provides a scope to the identifiers (the names of types, functions, variables, & so forth) inside it. Namespaces are usually for organizing code into logical groups & provide a method for preventing name collisions in large projects especially in cases where your codebase includes multiple libraries. || A container is a place where we store our objects. 5 Sequence Containers: array, vector, dequeue, forward_list & list. Other sequential containers include std list, a doubly linked list, std forward_list, a singly linked list, an std dequeue, a double-ended queue. Vectors can grow or shrink as we insert or delete elements It is only possible to insert an element at the end of a vector /w the vector memberfunction .push_back() There is no .push_front() Vectors are indexed the first element having an index of 0 Individual elements can be accessed via the subscript operator or a memberfunction called .at() A vecors size as a number of elements can be obtained through .size() memberfunction. There are a couple of  ways to erase an element in a vector. One thing to note is that b/c vectors use an array as their underlying storage erasing elements in positions other than the vector end causes the container to relocate all the elements after the segment erased to their new positions This is generally an inefficient operation compared to Lists Lists are sequential containers just like vectors but the memory where the elements are stored can be scattered all over memory whereas vector elements are stored as one block in memory So when you remove an element from the middle of a vector it needs to shift the following elements & therefore is less efficient Lists doesn't require relocating elements & is faster. Vector is faster than accessing element in a list, if you know the position of the element you can jump to it right away In a List you have to iterate through all the previous elements to find the element you are searching for. If you are unsure if an element exists in your vector you can search for it /w std find include the algorithm header. I'm going to use the auto keyword to declare a new variable called it When a declaration of the variable has an initializer we don't need to explicitly specify the type Instead we can let the variable have the type of its initializer So in this case std find returns an iterator that can be passed into .erase() An iterator is an object that can iterate over elements in a C++ Standard Library container & provides access to individual elements || Associative Containers these are implemented as binary trees They allow for quick search times & the data in these containers is sorted unlike Vectors These Associative Containers are std set & std map Sets hold unique sorted binary trees objects To insert an element into a set we use the set's .insert() memberfunction If your element is a pointer it'll order it by memory address if it's a character, by integer value according to ASCII table And sets have a memberfunction called .find() that returns an iterator to the element if it exists otherwise it returns an iterator /w the value of .end() In our program lets try searching for the integer 7 which exists in the set We need to dereference the iterator to get to its value so we need an asterisk in front of it. || Map is an Associative Container that holds key-value pairs the keys are sorted & unique There is also another group of Associative Containers that does allow for duplicate values Those are std multi_set & std multi_map  Sets memberfunction called .find() std multi_set and std_multi_map allow duplicate values

Sequence & Associative Containers in C++::
#include <iostream>
#include <vector>
int main() {
std::vector<int> v = { 1, 2, 3, 4, 5, };
size_t size = v.size();
std::cout << "Elements before erasing: ";
for (int i = 0; i < size; i++) {
	std::cout << v.at(i) << " ";
}
std::cout << '\n';
//Erase element #2
v.erase(v.begin() + 1);
std::cout << "Elements after erasing: ";
size = v.size();
for (int i = 0; i < size; i++) {
	std::cout << v.at(i) << " ";
}
std::cout << std::endl;
}

========================
#include <algorithm>
#include <iostream>
#include <vector>
int main() {
std::vector<int> v = { 1, 2, 3, 4, 5, };

size_t size = v.size();
std::cout << "Elements before erasing: ";
for (int i = 0; i < size; i++) {
	std::cout << v.at(i) << " ";
}
std::cout << '\n';

auto it = std::find(v.begin(), v.end(), 5);
if (it != v.end()) {
	v.erase(it);
}
std::cout << "Elements after erasing: ";
size = v.size();
for (int i = 0; i < size; i++) {
	std::cout << v.at(i) << " ";
}
}

===================
#include <iostream>
#include <set>
int main() {
	std::set<int> s = { 100, 7, 3, 90, 800 };
	s.insert(100);
	s.insert(500);
	s.insert(500);
	for (auto el : s) {
		std::cout << el << std::endl;
}
}

==========================
#include <iostream>
#include <set>
int main() {
	std::set<int> s = { 100, 7, 3, 90, 800 };
	auto it = s.find(7);
	if (it != s.end()) {
		std::cout << *it << " was found!" << std::endl;
	} else {
		std::cout << "7 not found." << std::endl;
}
}

===================
#include <iostream>
#include <map>
int main() {
std::map<int, char> mymap = { {3, 'a'}, {1, 'b'}, {7, 'z'} };
for (auto el : mymap) {
std::cout << "Key: " << el.first << ", Value: " << el.second << std::endl;
}
}

}}


 {{ https://flylib.com/books/en/4.330.1/ https://flylib.com/books/en/4.330.1.19/1/ https://www.computerhope.com/jargon/program.htm https://hackr.io/blog/programming-terms-definitions-for-beginners https://www.techgeekbuzz.com/blog/programming-terms/ https://onlinegrad.syracuse.edu/blog/coding-terms-for-beginners/ https://code.org/curriculum/docs/k-5/glossary https://careerkarma.com/blog/programming-terminology/ https://livecodestream.dev/post/programming-terms/ https://www.codingem.com/programming-glossary/ || https://dotnet.microsoft.com/en-us/learn/csharp https://www.learncs.org/ https://www.w3schools.com/cs/index.php https://www.codecademy.com/learn/learn-c-sharp https://www.tutorialsteacher.com/csharp https://www.javatpoint.com/c-sharp-tutorial https://www.programiz.com/csharp-programming https://www.tutorialspoint.com/csharp/index.htm https://www.youtube.com/watch?v=gfkTfcpWqAY c#1hr https://www.youtube.com/watch?v=GhQdlIFylQ8 c#4hrbeg https://www.youtube.com/watch?v=q_F4PyW8GTg c#7hr }}

{{ win32 api programming filetype:PDF:: https://ecs.syr.edu/faculty/fawcett/handouts/coretechnologies/win32SystemProgramming/presentations/Win32Programming.pdf https://learn.microsoft.com/en-us/windows/win32/learnwin32/learn-to-program-for-windows https://www.cs.binghamton.edu/~reckert/360/2_f08_win32api.pdf https://riptutorial.com/Download/win32-api.pdf http://slav0nic.org.ua/static/books/C_Cpp/theForger%27s_Win32APITutorial.pdf https://pages.mini.pw.edu.pl/~aszklarp/archiwum/2019/pige/Lecture2.pdf https://accu.org/conf-docs/PDFs_2019/roger_orr_-_windows_native_api.pdf ?https://9p.io/who/lorenz/papers/smlwin32.pdf xhttps://www.elpress.com/Win32%20Api%20Documentation/view?m=C6I7O3 xhttp://www.cl72.org/100winProg/dcap509_windows_programming.pdf https://learn.microsoft.com/en-us/windows/win32/learnwin32/your-first-windows-program hInstance hWindow hModile WndProc Message Pump COM WM_Destroy https://learn.microsoft.com/en-us/windows/win32/learnwin32/creating-a-window https://www.cs.binghamton.edu/~reckert/360/winapp1-cpp.html https://github.com/microsoft/Windows-classic-samples/tree/7cbd99ac1d2b4a0beffbaba29ea63d024ceff700/Samples/Win7Samples/begin/LearnWin32/HelloWorld/cpp }}


=============================

#How do you study a Win32 library function in C++ and how to use it with clearcut example
ChatGPT
Studying a Win32 library function in C++ involves understanding its purpose, parameters, return values, and any required supporting structures or constants. Here are the steps to study and use a Win32 library function with a clear example:

Identify the Win32 function: Determine the specific function you want to study and use from the Win32 library. For example, let's consider the function MessageBox, which displays a message box dialog.

Read the documentation: Consult the official Microsoft documentation for the Win32 function you are studying. The documentation provides information on the function's purpose, parameters, return value, and any specific requirements or considerations.

Understand the function signature: Examine the function's signature to understand its parameters and return value. The signature specifies the function name, the data types of its parameters, and the return type. For MessageBox, the signature looks like this:

cpp
Copy code
int MessageBox(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType);
HWND hWnd: Handle to the owner window or parent window of the message box.
LPCTSTR lpText: Text to be displayed in the message box.
LPCTSTR lpCaption: Text to be displayed in the title bar of the message box.
UINT uType: Flags specifying the type of the message box (e.g., buttons, icons, and default behavior).
Understand the return value: Check the documentation to understand the meaning of the return value. In the case of MessageBox, the return value indicates the button that was clicked by the user.

Include necessary headers: To use a Win32 library function, you need to include the appropriate header file. For MessageBox, you'll need to include <Windows.h>.

Call the function: Construct a code example that demonstrates how to call and use the Win32 function. For MessageBox, a simple example would be:

cpp
Copy code
#include <Windows.h>

int main()
{
    HWND hWnd = NULL; // Use NULL for a message box without an owner window
    LPCTSTR lpText = TEXT("Hello, World!");
    LPCTSTR lpCaption = TEXT("Message Box Example");
    UINT uType = MB_OK | MB_ICONINFORMATION;

    int result = MessageBox(hWnd, lpText, lpCaption, uType);

    return 0;
}
In this example, we call the MessageBox function with the specified parameters. The return value is stored in the result variable.

Compile and run the code: Compile the code using a C++ compiler, linking against the required Win32 libraries, and run the executable. The message box dialog will be displayed, and the return value will be printed to the console (in this example, it is not used).

By following these steps, you can study a Win32 library function, understand its usage, and create a clear example demonstrating how to use it in your C++ code. Remember to consult the official documentation for detailed information on the specific Win32 functions you are studying.

=================================================

#What are the processes in a OpenGL C++ game engine coding from scratch with tips on learning OpenGL & Math concepts.

ChatGPT
Developing an OpenGL-based game engine from scratch involves several key processes. Here's an overview of those processes, along with tips for learning OpenGL and math concepts:

Setting up the Environment:
Choose a programming language like C++ to implement your game engine.
Set up the development environment, including installing the necessary libraries and tools.

Creating a Window and Context:
Use a windowing library like GLFW or SDL to create a window for your game.
Set up an OpenGL context within the window to allow rendering.

Understanding the Graphics Pipeline:
Learn the basics of the OpenGL graphics pipeline, including vertex processing, primitive assembly, rasterization, and fragment processing.
Understand how to create and bind vertex buffers, vertex array objects, and shaders.

Working with Shaders:
Learn the OpenGL Shading Language (GLSL) to write vertex and fragment shaders.
Understand how to compile and link shaders and bind them to the rendering pipeline.

Loading and Rendering Models:
Implement techniques to load and store 3D models using formats like OBJ or FBX.
Write code to render the loaded models using vertex and fragment shaders.

Implementing Camera and View:
Learn about different camera models, such as perspective and orthographic projections.
Implement camera controls for navigating and viewing the 3D scene.

Handling User Input:
Capture user input through keyboard, mouse, or game controllers using libraries like GLFW or SDL.
Implement logic to respond to user input for player control, menus, and other interactions.

Managing Game Assets and Resources:
Develop systems to manage game assets like textures, materials, and sounds.
Load and unload resources efficiently to optimize performance.

Implementing Game Logic:
Design and implement game logic, including physics simulation, collision detection, AI, and game mechanics.
Combine the rendering pipeline with game logic to create an interactive experience.

Tips for Learning OpenGL and Math Concepts:
Start with the basics: Begin with understanding the fundamentals of computer graphics, including concepts like coordinate systems, transformations, and color spaces.
Study the OpenGL documentation: Read and study the official OpenGL documentation, including the OpenGL Programming Guide (known as the "Red Book") and the OpenGL Shading Language specification (known as the "Orange Book").
Follow tutorials and resources: Use online tutorials, books, and resources specifically tailored for learning OpenGL and game engine development.
Practice with small projects: Start with simple projects to gradually build your knowledge and skills. Experiment and iterate on your codebase as you progress.
Gain a solid foundation in math: Brush up on linear algebra, trigonometry, and geometry concepts. Understanding vectors, matrices, transformations, and coordinate systems is crucial for 3D graphics programming.
Implement small math libraries: Create your own small math libraries to reinforce your understanding of math concepts and their application in computer graphics.
Analyze and learn from existing codebases: Study open-source game engines and OpenGL projects to learn from their code structure, design patterns, and implementation techniques.
Remember, developing a game engine from scratch is a complex and time-consuming task. It requires a strong foundation in computer graphics, math, and programming. Be prepared for a learning curve and take an iterative approach, gradually building your skills and knowledge as you progress.

==============================================

#Win32 API cryptic names with brief explanations.
ChatGPT
The Win32 API has a long history and contains a variety of cryptic names for functions, constants, and data types. These names are often derived from historical reasons, backward compatibility, or internal Microsoft naming conventions. Here are some examples of cryptic Win32 API names along with brief explanations:

CreateWindowEx:
Explanation: Function used to create an extended window, allowing customization of window style, extended style, and other attributes.

SendMessage and PostMessage:
Explanation: Functions used to send messages to windows and queue messages for later processing, respectively.

GetClientRect and GetWindowRect:
Explanation: Functions used to retrieve the dimensions and position of a window's client area and its entire bounding rectangle, respectively.

SetLastError and GetLastError:
Explanation: Functions used to set and retrieve the last error code associated with a Win32 API function call.

HDC and HBITMAP:
Explanation: Handle data types representing a device context and a bitmap, respectively. These handles are used to interact with graphical resources.

WM_XXX:
Explanation: Window message constants prefixed with "WM_" (e.g., WM_PAINT, WM_KEYDOWN). These constants represent specific events or notifications that can be sent to windows.

LPCTSTR and LPTSTR:
Explanation: Pointer data types representing a long pointer to a constant or modifiable TCHAR string, respectively. These types are used for string manipulation and passing string data to functions.

HANDLE and HWND:
Explanation: Generic handle data types representing various Win32 resources. HANDLE is used for general-purpose handles, while HWND specifically represents a window handle.

GDI and USER:
Explanation: Abbreviations for "Graphics Device Interface" and "User," respectively. These terms are used to refer to different subsystems of the Windows operating system responsible for graphics and user interface functionality.

DWORD and UINT:
Explanation: Data types representing unsigned integer values of 32 bits (DWORD) and platform-specific unsigned integer values (UINT). These types are commonly used for parameters, flags, and return values in Win32 API functions.

These are just a few examples of cryptic names in the Win32 API. It's important to consult the official Microsoft documentation or programming references to get detailed explanations, usage guidelines, and examples for specific functions, constants, and data types. Over time, with experience and familiarity, these names become more recognizable and their meanings become clearer.

=======================================================

#List of all Win32 API naming convention constants with explanations.
ChatGPT
The Win32 API has a wide range of constants with different naming conventions. It is not possible to provide an exhaustive list of all the constants along with explanations in a single response. However, I can provide an overview of some common naming conventions used in the Win32 API:

Predefined Constants:
These constants are predefined values that have specific meanings in the API. They are often used as flags or parameters to control the behavior of functions. Examples include:

NULL: Represents a null pointer or invalid handle.
TRUE and FALSE: Boolean constants representing true and false values.
MAX_PATH: Maximum length of a file path in characters.
Error Codes:
Error codes are used to indicate various types of errors that can occur in API calls. They typically start with ERROR_ prefix and provide information about specific error conditions. Examples include:

ERROR_SUCCESS: The operation completed successfully.
ERROR_FILE_NOT_FOUND: The specified file was not found.
ERROR_ACCESS_DENIED: Access to the resource is denied.
Message Box Constants:
These constants are used in the MessageBox function to control the appearance and behavior of message box dialogs. Examples include:

MB_OK: Displays an OK button.
MB_YESNO: Displays Yes and No buttons.
MB_ICONINFORMATION: Displays an information icon.
Window Styles:
Window styles are used to define the appearance and behavior of windows. They often start with WS_ prefix. Examples include:

WS_OVERLAPPED: Creates an overlapped window.
WS_VISIBLE: Specifies that the window is initially visible.
WS_CHILD: Creates a child window.
Extended Window Styles:
Extended window styles provide additional options and features for windows. They often start with WS_EX_ prefix. Examples include:

WS_EX_CLIENTEDGE: Adds a three-dimensional border to a window.
WS_EX_TOPMOST: Places the window above all non-topmost windows.
WS_EX_TOOLWINDOW: Creates a tool window that does not appear in the taskbar.
These are just a few examples of the naming conventions used in the Win32 API. To explore the complete list of constants, it is recommended to refer to the official Microsoft documentation for the specific API you are working with. The documentation provides detailed explanations and examples for each constant, enabling you to understand their usage and purpose in the Win32 API.

===========================================

#List of all Win32 API naming convention constants for instance LPCTSTR with explanations.
ChatGPT
The LPCTSTR naming convention in the Win32 API stands for "Long Pointer to a Constant TCHAR String." It is used as a data type to represent a pointer to a null-terminated string of characters. Here are some common constants related to the LPCTSTR naming convention, along with brief explanations:

LPCTSTR:
Definition: Long Pointer to a Constant TCHAR String.
Explanation: LPCTSTR is a pointer type used to reference a constant string of characters. It is typically used for input parameters that expect string data.

TCHAR:
Definition: Generic character data type that resolves to either char or wchar_t based on compilation settings.
Explanation: TCHAR is a flexible data type that can represent characters as either single-byte characters (char) or wide characters (wchar_t) depending on the compilation settings.

LPTSTR:
Definition: Long Pointer to a TCHAR String.
Explanation: LPTSTR is a pointer type used to reference a modifiable string of characters. It can be used for output parameters that need to be modified or updated by a function.

LPCTSTR_NULL:
Definition: NULL pointer to a constant TCHAR string.
Explanation: LPCTSTR_NULL is a constant value representing a null pointer to a TCHAR string. It is often used as a sentinel value or to initialize variables.

TEXT():
Definition: Macro used to define string literals that are compatible with the TCHAR data type.
Explanation: The TEXT() macro is used to define string literals in a way that makes them compatible with the TCHAR data type. It ensures that the strings are correctly interpreted as either single-byte or wide characters based on the compilation settings.

These are some of the common naming conventions and constants related to the LPCTSTR naming convention in the Win32 API. It's important to note that the specific constants and naming conventions may vary depending on the particular API or function you are working with. To get a complete and comprehensive list of constants for a specific Win32 API function, it is best to consult the official Microsoft documentation, which provides detailed explanations and examples for each constant.

==================================================

#How to call an API in C++ with a working example.
ChatGPT
To call an API in C++, you typically need to follow these steps:

Include the necessary header file:

Before calling an API, include the appropriate header file that contains the API's declarations and definitions. The specific header file depends on the API you want to use.
Link against the required library:

Some APIs may require linking against a specific library file. You need to configure your project settings to link against the required library. Consult the API's documentation for information on the required libraries.
Call the API function:

Use the correct function name and provide the required arguments according to the API's documentation. Make sure to check the function's return type and any error handling requirements.
Here's a simple example demonstrating how to call the Win32 API function MessageBoxA to display a message box with a "Hello, World!" message:

cpp
Copy code
#include <Windows.h>

int main()
{
    const char* message = "Hello, World!";

    MessageBoxA(NULL, message, "Message", MB_OK);

    return 0;
}
In this example:

The Windows.h header file is included to access the Win32 API functions and types.
The MessageBoxA function is called with the following arguments:
NULL as the window handle, indicating that the message box is associated with the default desktop window.
message as the message text to display.
"Message" as the caption of the message box.
MB_OK as the set of buttons to display (in this case, an OK button).
The return value of the MessageBoxA function is not used in this example.
The program exits by returning 0.
Remember to compile and build your program, making sure to include the necessary project settings and library dependencies based on the specific API you are using.

Note: This example demonstrates calling a specific Win32 API function. The process may differ for other APIs, so consult the documentation of the API you wish to use for specific instructions and requirements.

===========================================ChatGPT Archives
what is a delegate in c# with example
In C#, a delegate is a type that represents a reference to a method. It allows you to pass methods as parameters to other methods, store them in variables, and call them dynamically at runtime.

Here's an example of how to declare and use a delegate in C#:

csharp
Copy code
// Define a delegate that takes two integers and returns an integer
delegate int MathOperation(int x, int y);

// Define some methods that match the delegate signature
int Add(int x, int y)
{
    return x + y;
}

int Subtract(int x, int y)
{
    return x - y;
}

// Create a delegate instance and assign it to a method
MathOperation op = Add;

// Call the delegate like a regular method
int result = op(3, 4);  // result = 7

// Assign the delegate to a different method
op = Subtract;

// Call the delegate again with the new method
result = op(3, 4);  // result = -1
In this example, we define a MathOperation delegate that takes two integers and returns an integer. We then define two methods, Add and Subtract, that match the delegate signature. We create a delegate instance named op and assign it to the Add method. We can then call the op delegate like a regular method and pass it two integer arguments. Later, we reassign the op delegate to the Subtract method and call it again with different arguments. This demonstrates the ability to dynamically change which method a delegate refers to, as well as the ability to pass methods as parameters to other methods.



=============================================
virtual versus friend versus abstract classes
In C#, virtual, friend, and abstract are different concepts that are used for different purposes in object-oriented programming.

virtual - A virtual method is a method that can be overridden by a derived class. When a method is marked as virtual, it allows the method to be replaced with a new implementation in a derived class using the override keyword. Here is an example:
csharp
Copy code
public class BaseClass
{
    public virtual void Method()
    {
        Console.WriteLine("BaseClass.Method");
    }
}

public class DerivedClass : BaseClass
{
    public override void Method()
    {
        Console.WriteLine("DerivedClass.Method");
    }
}
In this example, the BaseClass has a virtual method called Method, which is overridden in the DerivedClass with a new implementation.

friend - friend is not a keyword in C#, but it is a concept in other languages like C++. In C++, friend is used to give a non-member function or class access to the private and protected members of a class. In C#, the equivalent concept is internal access modifier, which allows access to members of a class within the same assembly.

abstract - An abstract class is a class that cannot be instantiated directly and requires a derived class to implement its abstract members. An abstract class can have both abstract and non-abstract members. Abstract classes are used to provide a common interface for a group of related classes. Here is an example:

csharp
Copy code
public abstract class BaseClass
{
    public void NonAbstractMethod()
    {
        Console.WriteLine("BaseClass.NonAbstractMethod");
    }
    public abstract void AbstractMethod();
}

public class DerivedClass : BaseClass
{
    public override void AbstractMethod()
    {
        Console.WriteLine("DerivedClass.AbstractMethod");
    }
}
In this example, the BaseClass is an abstract class that has a non-abstract method called NonAbstractMethod and an abstract method called AbstractMethod. The DerivedClass derives from the BaseClass and implements the AbstractMethod.

In summary, virtual is used to allow a method to be overridden in a derived class, friend is not a keyword in C#, but internal access modifier can be used to give access to members of a class within the same assembly, and abstract is used to create a base class that requires its derived classes to implement its abstract members.




======================================
linked list explanation include source
In computer science, a linked list is a data structure that consists of a sequence of nodes, each containing an element and a reference (or pointer) to the next node in the sequence. Linked lists are used to implement dynamic data structures like stacks, queues, and associative arrays.

Here's an example of a simple linked list implementation in C#:

csharp
Copy code
public class Node<T>
{
    public T Value { get; set; }
    public Node<T> Next { get; set; }
    
    public Node(T value)
    {
        Value = value;
        Next = null;
    }
}

public class LinkedList<T>
{
    private Node<T> head;
    
    public void Add(T value)
    {
        Node<T> newNode = new Node<T>(value);
        if (head == null)
        {
            head = newNode;
        }
        else
        {
            Node<T> current = head;
            while (current.Next != null)
            {
                current = current.Next;
            }
            current.Next = newNode;
        }
    }
    
    public void Print()
    {
        Node<T> current = head;
        while (current != null)
        {
            Console.Write(current.Value + " ");
            current = current.Next;
        }
        Console.WriteLine();
    }
}
In this implementation, the Node class represents a single node in the linked list, and the LinkedList class represents the entire list. The Node class has two properties: Value, which stores the value of the node, and Next, which stores a reference to the next node in the sequence. The LinkedList class has a single private field called head, which stores a reference to the first node in the list.

The Add method adds a new node to the end of the list by iterating through the list to find the last node, and then setting its Next property to the new node.

The Print method prints the values of all the nodes in the list by iterating through the list and writing each value to the console.

Here's an example of how to use the LinkedList class:

csharp
Copy code
LinkedList<int> list = new LinkedList<int>();
list.Add(1);
list.Add(2);
list.Add(3);
list.Print();  // output: 1 2 3
In this example, we create a new LinkedList<int> object, add three integers to the list using the Add method, and then print the contents of the list using the Print method. The output is 1 2 3.



===============================================
pointer to functions explanation include source
In C and C++, pointers to functions are a powerful feature that allow functions to be treated as first-class citizens, just like data. A pointer to a function is a variable that stores the memory address of a function. This memory address can be used to call the function or pass it as an argument to another function.

Here's an example of how to declare a function pointer in C:

c
Copy code
int (*func_ptr)(int, int);
This declares a function pointer named func_ptr that can point to a function that takes two integers as arguments and returns an integer.

Here's an example of how to use a function pointer in C:

c
Copy code
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int main() {
    int (*func_ptr)(int, int);
    func_ptr = add;
    printf("%d\n", func_ptr(2, 3));  // output: 5
    func_ptr = subtract;
    printf("%d\n", func_ptr(2, 3));  // output: -1
    return 0;
}
In this example, we define two functions add and subtract that take two integers as arguments and return the sum and difference of the arguments, respectively. We declare a function pointer func_ptr that can point to a function that takes two integers as arguments and returns an integer. We then assign the address of the add function to func_ptr and call it with the arguments 2 and 3, which returns 5. We then assign the address of the subtract function to func_ptr and call it with the arguments 2 and 3, which returns -1.

Here's an example of how to declare a function pointer in C++ using a typedef:

cpp
Copy code
typedef int (*FuncPtr)(int, int);
This declares a function pointer type FuncPtr that can point to a function that takes two integers as arguments and returns an integer.

Here's an example of how to use a function pointer in C++:

cpp
Copy code
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int main() {
    FuncPtr func_ptr = add;
    std::cout << func_ptr(2, 3) << std::endl;  // output: 5
    func_ptr = subtract;
    std::cout << func_ptr(2, 3) << std::endl;  // output: -1
    return 0;
}
In this example, we define two functions add and subtract that take two integers as arguments and return the sum and difference of the arguments, respectively. We declare a function pointer variable func_ptr of type FuncPtr and assign the address of the add function to it. We call func_ptr with the arguments 2 and 3, which returns 5. We then assign the address of the subtract function to func_ptr and call it with the arguments 2 and 3, which returns -1.

In summary, pointers to functions are a powerful feature of C and C++ that allow functions to be treated as first-class citizens. They provide flexibility and abstraction, and are often used in higher-level programming techniques such as callbacks and function templates.



==============================================================
what is a memory dc and mode x and how are 2d sprites rendered
A memory DC (Device Context) is a graphics object in the Windows operating system that provides a buffer for drawing operations. It allows you to draw and manipulate graphics in a memory buffer, rather than directly on the screen, which can provide benefits in terms of performance and visual fidelity.

Mode X is a display mode that was introduced on the IBM PC in the early 1990s. It allows for a screen resolution of 320x240 pixels with 256 colors, using a special video mode that sacrifices some of the vertical resolution in order to achieve a higher color depth. Mode X was particularly popular for PC games in the 1990s, because it provided a good balance between graphics quality and performance.

2D sprites are typically rendered using a combination of a memory DC and Mode X. Here's a brief overview of the rendering process:

Load sprite data: The image data for the sprite is loaded into memory.

Create memory DC: A memory DC is created in memory, with the same dimensions as the sprite.

Draw sprite: The sprite image data is then drawn onto the memory DC using a series of graphics operations, such as BitBlt or StretchBlt.

Blit to video memory: Once the sprite has been drawn onto the memory DC, it is then blitted (i.e., copied) to video memory, which is the portion of memory that is directly accessible by the video hardware.

Display on screen: Finally, the sprite is displayed on the screen by telling the video hardware to read the sprite data from video memory and render it on the screen.

This process is typically repeated for each sprite in a game or application, and can be optimized for performance by using techniques such as sprite batching and hardware acceleration.


===============================================================

Win32 API programming in C# explained
Win32 API programming refers to using the set of functions, data types, and constants that make up the Win32 application programming interface (API) to write Windows desktop applications. Although Win32 API programming is traditionally done in C and C++, it is also possible to use C# to access the Win32 API by using Platform Invocation Services (P/Invoke).

Here's a brief overview of how to use P/Invoke to access the Win32 API from C#:

Identify the Win32 function you want to call and its parameters. You can find this information in the Win32 API documentation, which is available online or as part of the Windows SDK.

Declare the function signature in your C# code using the DllImport attribute. This tells the .NET runtime to dynamically load the function from the appropriate Win32 library at runtime. Here's an example:

csharp
Copy code
[DllImport("user32.dll", SetLastError = true)]
public static extern int MessageBox(IntPtr hWnd, string text, string caption, uint type);
This declares a static method named MessageBox in your C# code that maps to the MessageBox function in the user32.dll library.

Call the function in your C# code. You can call the Win32 function just like any other method in C#. Here's an example:

python
Copy code
MessageBox(IntPtr.Zero, "Hello, world!", "Message", 0);
This calls the MessageBox function with the parameters specified.

Handle any error conditions that may arise. If the Win32 function returns an error code, you can use the Marshal.GetLastWin32Error() method to retrieve the error code and handle the error appropriately.

Using P/Invoke to access the Win32 API from C# can be a powerful way to write Windows desktop applications that have fine-grained control over the system resources. However, it can also be more complex than using managed .NET libraries, and it requires a good understanding of the underlying Win32 API functions and their parameters. As always, it's important to test your code thoroughly and to follow best practices for security and reliability.


=====================================
C++ Templates explanation
C++ templates are a powerful feature of the language that allow you to write generic code that can work with different data types. Templates enable you to define a template class or function that can be instantiated with different types at compile time. This allows you to write reusable code that works with a wide range of data types, without having to write separate implementations for each type.

Here is an example of a simple template function that can add two values of any type:

r
Copy code
template<typename T>
T add(T a, T b) {
    return a + b;
}
In this code, the template<typename T> line declares that we are defining a template function, with T as a type parameter. The function then takes two parameters of type T, and returns the result of adding them together. We can call this function with any type that supports the + operator:

scss
Copy code
int result1 = add(1, 2);          // result1 is 3
double result2 = add(2.5, 3.1);   // result2 is 5.6
Templates can also be used to define template classes, which are similar to regular classes but with one or more type parameters. Here is an example of a simple template class that defines a stack data structure:

cpp
Copy code
template<typename T>
class Stack {
private:
    T* data;
    int size;
    int capacity;
public:
    Stack(int capacity) {
        data = new T[capacity];
        size = 0;
        this->capacity = capacity;
    }
    void push(T item) {
        data[size] = item;
        size++;
    }
    T pop() {
        size--;
        return data[size];
    }
};
In this code, the template<typename T> line declares that we are defining a template class, with T as a type parameter. The class then defines a stack data structure with an array of type T, along with methods for adding and removing items from the stack. We can create instances of this class with any type that we want to use as the type of the stack:

scss
Copy code
Stack<int> intStack(10);
intStack.push(1);
intStack.push(2);
intStack.pop();     // returns 2
Templates are a powerful and flexible feature of C++, but they can also be complex to use and understand. It's important to be familiar with the syntax and behavior of templates, as well as the best practices for using them effectively in your code.


==========================================
C# Generics explanation
C# generics are a feature of the language that allow you to write code that can work with different data types. Generics enable you to define a generic class, struct, interface, or method that can be instantiated with different types at compile time. This allows you to write reusable code that works with a wide range of data types, without having to write separate implementations for each type.

Here is an example of a simple generic class that defines a stack data structure:

csharp
Copy code
public class Stack<T> {
    private T[] data;
    private int size;
    private int capacity;
    public Stack(int capacity) {
        data = new T[capacity];
        size = 0;
        this.capacity = capacity;
    }
    public void Push(T item) {
        data[size] = item;
        size++;
    }
    public T Pop() {
        size--;
        return data[size];
    }
}
In this code, the public class Stack<T> line declares that we are defining a generic class, with T as a type parameter. The class then defines a stack data structure with an array of type T, along with methods for adding and removing items from the stack. We can create instances of this class with any type that we want to use as the type of the stack:

scss
Copy code
Stack<int> intStack = new Stack<int>(10);
intStack.Push(1);
intStack.Push(2);
intStack.Pop();     // returns 2
The Stack<int> syntax indicates that we are creating an instance of the Stack class with type parameter int. This creates a stack that can only hold integers.

Generics can also be used to define generic methods, which are similar to regular methods but with one or more type parameters. Here is an example of a simple generic method that can compare two values of any type:

csharp
Copy code
public static bool AreEqual<T>(T a, T b) {
    return a.Equals(b);
}
In this code, the public static bool AreEqual<T> line declares that we are defining a generic method, with T as a type parameter. The method then takes two parameters of type T, and returns a boolean indicating whether the two values are equal. We can call this method with any type that supports the Equals method:

python
Copy code
bool result1 = AreEqual(1, 2);          // result1 is false
bool result2 = AreEqual("hello", "world");   // result2 is false
Generics are a powerful and flexible feature of C#, but they can also be complex to use and understand. It's important to be familiar with the syntax and behavior of generics, as well as the best practices for using them effectively in your code.

=====================Bing AI Chat=======================

#What is a memory DC?
A memory DC (Device Context) is a special device context for bitmap operations that enables applications to place output in memory rather than sending it to an actual device1. It is an array of bits in memory that an application can use temporarily to store the color data for bitmaps created on a normal drawing surface1.

An application can create a memory DC by calling the CreateCompatibleDC function23. The original bitmap in a memory DC is simply a placeholder2.

#What is protected mode in operating system?
Protected mode is an operational mode of x86-compatible central processing units (CPUs) that allows system software to use features such as virtual memory, paging and safe multi-tasking designed to increase an operating system’s control over application software1. It is also called protected virtual address mode1.

Protected mode was first introduced on Intel 80286 processors and provides access to addressing virtual memory, extended memory, and multitasking while protecting programs from overwriting one another in memory2.

How do Nested For Loops work in C++?
In C++, a nested for loop is a for loop inside another for loop. The inner loop will complete all of its iterations before the outer loop moves on to its next iteration. Here’s an example:

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 2; j++) {
        cout << "i: " << i << ", j: " << j << endl;
    }
}
This code will output:

i: 0, j: 0
i: 0, j: 1
i: 1, j: 0
i: 1, j: 1
i: 2, j: 0
i: 2, j: 1


#What is a delegate in C#?
In C#, a delegate is an object that refers to a method or a reference type variable that can hold a reference to methods1. It is similar to a function pointer in C/C++1. A delegate provides a way to specify which method is to be called when an event is triggered1.

A delegate is also considered as a type-safe function pointer that can point to one or more methods with compatible signatures2. The term “compatible signature” implies that the signature of the delegate and the method it points to are the same. A function signature consists of the function name, type and sequence of parameters, and return type2.

#What is a template in C++?
A template is a powerful tool in C++ that allows passing data types as parameters so that the same code can be used for different data types1. For example, instead of writing and maintaining multiple codes for sorting different data types, one can write a single sort function using templates and pass the data type as a parameter1.

Templates are parameterized by one or more template parameters of three kinds: type template parameters, non-type template parameters, and template template parameters2. When template arguments are provided or deduced (for function and class templates), they are substituted for the template parameters to obtain a specialization of the template - a specific type or function instance2.

#What is a Linked List in C++?
A linked list is a set of dynamically allocated nodes arranged in such a way that each node contains one value and one pointer. The pointer always points to the next member of the list. If the pointer is nullptr, then it is the last node in the list1. Is there anything else you would like to know about linked lists?

#Win32 API programming in C# explained
Win32 API programming in C# is the process of using the Windows API functions and structures in a C# program. The Windows API is a set of low-level interfaces that provide access to various features and services of the Windows operating system, such as graphics, networking, file system, user interface, etc. To use Win32 API in C#, you need to use platform invoke (P/Invoke) services1, which allow you to call unmanaged code from managed code. You also need to know how to declare and use function pointers, structures, constants, enums, and delegates that match the Win32 API definitions2. You can use tools like C#/Win322 or PInvoke.net1 to generate C# signatures for Win32 API functions automatically. Alternatively, you can refer to the official documentation of Win32 API on MSDN3 and manually write the corresponding C# code.

Some examples of Win32 API programming in C# are:

Creating a window using CreateWindowEx function
Drawing text on a window using DrawText function
Playing a sound using PlaySound function
Getting system information using GetSystemInfo function https://stackoverflow.com/questions/10054653/how-can-i-learn-about-the-win32-api https://blogs.msmvps.com/bsonnino/2021/04/25/using-the-win32-api-in-a-c-program-with-c-win32/ https://www.c-sharpcorner.com/article/working-with-win32-api-in-net/

===================Franklin Questions===================

Collision detection in a 2d game
<---- snip ---->
Collision detection in a 2d game is the process of detecting when two objects have interacted with each other. This can be done in a variety of ways, including pixel-perfect detection, bounding box detection, raycasting, and more. Each method has its own advantages and disadvantages, so it's important to choose the one that best fits the needs of your game.

What is NAND2Tetris?
<---- snip ---->
NAND2Tetris is a free online course that teaches the fundamentals of computer science and engineering. It is based on a self-study curriculum that starts from basic gate logic and builds up to a complete, working computer system. The course is composed of twelve projects that range from simple logic gates to a complete Turing-complete computer system. The projects are designed to complement the reading material, lecture videos, and discussion forums, and are intended to give students hands-on experience in building a computer.

#Memory DC
A memory DC, or Device Context, is a type of data structure used in the Windows operating system to store information about a device, such as a display, printer, or printer driver. It contains information such as the current settings of a device, the devices current state, and the devices capabilities. A memory DC is used to draw graphics and text, and to query the current settings of a device. It is also used to capture and manipulate the pixel data of a device or window.

#Symbols Table
A symbols table is a data structure used in computer programming that stores information about symbols. It is typically used to store information on variables, functions, classes, and other objects used in a program. The symbol table holds information such as the name of the symbol, its type, its scope, its value, and other related information. Symbol tables are used by compilers to keep track of variables and other objects used in the program. They can also be used by interpreters or other programs to quickly access information about symbols.

#The difference between heap memory and stack memory
Heap memory is a region of dynamic memory where memory can be allocated during program execution, while stack memory is a region of memory that is used for local variables and function call parameters. Heap memory is used for dynamic memory allocation, while stack memory is used for static memory allocation. Heap memory is shared between threads, while stack memory is specific to a thread. Heap memory is managed by the operating system, while stack memory is managed by the compiler. Heap memory is allocated more freely, while stack memory is allocated in a more structured and organized way. Heap memory is more expensive than stack memory.

#Call Stack
The call stack is a data structure used by a computer program to store information about its currently active subroutines, which includes the current instruction pointer (i.e., the address of the instruction being executed) and the parameters that were passed to the subroutine. It is typically used to store the return address when a subroutine is called, so that the program can return to the calling routine when the subroutine has finished executing. The call stack can also be used to store local variables and other information.

#Bit Manipulation
Bit manipulation is the process of manipulating bits or groups of bits in a string of binary code. It is used to perform operations on data such as setting, clearing, flipping, extracting, and rotating bits. It is a fundamental technique used in computer programming, computer engineering, and digital electronics. Bit manipulation is also used in cryptography and data compression.

#Difference between OR and XOR
OR (or inclusive OR) and XOR (exclusive OR) are two logical operators that are commonly used in Boolean logic.

The OR operator returns TRUE if either of its operands is TRUE, and FALSE if both of them are FALSE.

The XOR operator returns TRUE if only one of its operands is TRUE, and FALSE if both of them are TRUE or FALSE.

#CSharp Delegates
C# delegates are similar to function pointers in C++, but are type safe. They are a type that defines a method signature and can be used to pass methods as arguments to other methods. A delegate object encapsulates a reference to a method. Delegates are especially used in events and callbacks. Delegates are declared using the delegate keyword followed by a method signature.

#Subclass a Window in Windows 95
To create a subclassed window in Windows 95, you must use the Windows API. To do this, you must create a window procedure, a callback function that processes messages sent to the window. This procedure is then registered with Windows using the API call RegisterClass and the window is then created using the API call CreateWindow. The API call SetWindowLong is then used to set the address of the window procedure and the subclassed window is then ready to be used.

#CreateRemoteThread
Ex

#if _WIN32_WINNT >= 0x0500
	HANDLE WINAPI CreateRemoteThreadEx(
		_In_ HANDLE hProcess,
		_In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes,
		_In_ SIZE_T dwStackSize,
		_In_ LPTHREAD_START_ROUTINE lpStartAddress,
		_In_opt_ LPVOID lpParameter,
		_In_ DWORD dwCreationFlags,
		_Out_opt_ LPPROCESS_INFORMATION lpProcessInformation
	)
#endif

#endif // CREATEREMOTETHREADEX_H

#API Hooking
API hooking is a technique used to intercept calls to an applications programming interface (API). It is commonly used to alter or extend the behavior of an application in order to add new features, fix bugs, or work around limitations in the software. Hooking can be done at the operating system level, or within the application itself. It is achieved by placing a small piece of code, known as a "hook", between the application and the API. The hook can then modify the parameters passed to the API, or even replace the API call with another one entirely. It can also be used to monitor the calls made by the application, and log information about them.

#C++ Templates
C++ Templates are a powerful feature of the language that allow for code reuse and generic programming. Templates are a way of creating generic functions and classes that can work with any data type. A template is a blueprint or formula for creating a generic class or a function. Templates allow for the same code to be used for multiple types of data, thus eliminating the need to write separate code for each type.

Templates are often used for creating containers, such as vectors and lists, that can hold any type of data. This allows the programmer to create a container that is capable of holding any type of data without needing to write separate code for each type of data. This saves time and makes the code more efficient.

In addition to containers, templates can also be used to create generic algorithms and functions that can be used with any type of data. This allows the programmer to create algorithms that are capable of handling any type of data without needing to write separate code for

#C++ Abstract vs Friend vs Virtual
Abstract: An abstract class is a class that cannot be instantiated, but instead serves as a base class from which other classes may be derived. Abstract classes typically contain one or more abstract methods, which are methods that do not have an implementation and must be implemented by any class that derives from the abstract class.

Friend: A friend function or class is a function or class declared with the keyword friend. A friend function or class has access to the private and protected members of a class. This access is granted to the friend function because the class that declares it trusts the friend and believes that it will not misuse the access.

Virtual: A virtual function is a function in a base class that is declared using the keyword virtual. Virtual functions allow derived classes to override the behavior of a base class function. When a class contains virtual functions, it is known as a polymorphic class and is used in the context of object-oriented programming.

#C++ Friendship
C++ allows for friendship between classes and functions. Friendship grants the ability to access private members of the class to the friend class or function. This is done by declaring the friend class or function in the public section of the class, typically preceded by the keyword "friend".

For example:

class MyClass {
public:
friend void myFunction(MyClass obj)
private:
int x
}

void myFunction(MyClass obj) {
// Access the private x of MyClass:
obj.x = 10
}

#C++ Virtual Table
The C++ virtual table is a data structure that is used internally by the C++ compiler to support dynamic dispatch of virtual functions. The virtual table is also known as the vtable. It is an array of function pointers that is used to store a list of functions that can be called on an object. Each object created in C++ will have its own virtual table, which will contain a list of pointers to the virtual functions that are associated with that object. The virtual table is used by the compiler to determine which virtual function is called when a virtual member function is invoked.

#C++ Virtual Functions
C++ virtual functions are functions that can be overridden by derived classes. Virtual functions are declared with the virtual keyword and are used to provide polymorphic behavior. When a derived class overrides the virtual function of a base class, the derived classs implementation is called when the virtual function is invoked.

#Reparse Point and Sparse Point
A reparse point is a type of file system object that is a special type of file or folder that is used to store information about other files or folders. It is used by the operating system to associate one type of data with another. For example, a reparse point might be used to associate a symbolic link with its target file or folder. 

A sparse point is a type of disk space allocation method used in computer file systems to store data more efficiently. In this method, only the parts of a file that contain data are stored, and the rest of the space is left unused. This saves disk space by eliminating the need to store blank or zero-filled areas of a file. Sparse files are useful for applications that store very large files or files with large amounts of blank space, such as virtual machine images.

#What does the => do in C#?
The => operator is known as the lambda operator or lambda expression operator in C#. It is used to create expression-based lambda functions, which are functions that don't have a name and are used to pass expressions around.

#Explain CSharp Delegates like to a 6 year old
A CSharp delegate is like an invisible helper. When something happens, like a button is clicked, the invisible helper goes and does something for you, like opening a new window. It makes doing things easier and faster.

#Explain Delegates in C# with an example

Delegates in C# are a type of object that references a method, and can be used to invoke that method when needed. Delegates are similar to function pointers in C and C++, but are type-safe and secure. 

An example of a delegate in C# could be the following:

public delegate void MyDelegate(int x, int y);

public class MyClass
{
    public void MyMethod(int x, int y)
    {
        Console.WriteLine("MyMethod Called");
    }
}

MyClass myClass = new MyClass();
MyDelegate myDelegate = new MyDelegate(myClass.MyMethod);
myDelegate(5, 10); // This will call MyMethod with the parameters 5 and 10

=====================end FranlinQuestions==================

#What is an ASM Length Disassembler Engine?
An ASM Length Disassembler Engine (LDE) is a tool that outputs the number of bytes taken by a parsed instruction given a sequence of bytes (instructions)1. Notable open-source projects for the x86 architecture include ldisasm1, Tiny x86 Length Disassembler1, and Extended Length Disassembler Engine for x86-641. https://en.wikipedia.org/wiki/Disassembler https://stackoverflow.com/questions/66072797/length-disassembler-and-missing-extensions https://github.com/greenbender/lend

#C++ code to read a textfile & ignore all 0's.

#include <iostream>
#include <fstream>
#include <string>
 
using namespace std;
 
int main()
{
    string line;
    ifstream myfile("textfile.txt");
    if (myfile.is_open())
    {
        while (getline(myfile, line))
        {
            if (line != "0")
            {
                cout << line << '\n';
            }
        }
        myfile.close();
    }
    else cout << "Unable to open file";
    return 0;
}

#C++ String Manipulation methods examples.
1. length(): This method takes a string as an argument and returns the length of the string.

Example: 

std::string str = "Hello World!";
int len = str.length();

// len will now be equal to 12

2. find(): This method takes two strings as arguments and returns the position of the first argument in the second argument.

Example: 

std::string str = "Hello World!";
int pos = str.find("World");

// pos will now be equal to 6


#2C++ String Manipulation methods examples.
1. length(): This method returns the length of a string.

Example: 

#include <iostream> 
#include <string> 
using namespace std; 

int main() 
{ 
	string str1 = "Hello World"; 
	cout << "str1 length = " << str1.length() << endl; 
	
	return 0; 
} 

Output:
str1 length = 11


2. append(): This method appends a copy of a substring to the end of a string.

Example: 

#include <iostream> 
#include <string> 
using namespace std; 

int main() 
{ 
	// Initializing string 
	string str1 = "Hello "; 
	
	// Appending using append() 
	str1.append("World"); 
	
	cout << "Using append(): "; 
	cout << str1 << endl; 
	
	return 0; 
} 

Output:
Using append(): Hello World


3. substr(): This method returns a substring of a string.

Example: 

#include <iostream> 
#include <string> 
using namespace std; 

int main() 
{ 
	string str1 = "Hello World"; 
	
	// Substring from index 6 to index 11 
	string str2 = str1.substr(6, 11); 
	
	cout << "Using substr(): "; 
	cout << str2 << endl; 
	
	return 0; 
} 

Output:
Using substr(): World

=====================API Hooking You.com Mobile Research=======================
#API Hooking C++ code with detailed explanation

Hooking is a technique used to intercept or modify the behavior of an application or system at runtime. This is typically done through code injection, where a certain piece of code is inserted into an application or system to replace or modify existing code. 

Hooking is a powerful tool for reverse engineering and malware analysis, as it allows the user to gain access to information and functionality that would otherwise be inaccessible.

Hooking in C++ is done by using code injection to modify the application’s or system’s code. Injecting code requires knowledge of the target application and system architecture, as well as the ability to write and compile code.

The first step in hooking is to identify the code that needs to be modified or replaced. This can be done by using a disassembler to view the code in assembly language. Once the code that needs to be modified or replaced is identified, the user can begin writing the code to inject.

The code that is written needs to be compiled into a shared library, such as a .dll or .so file, and then injected into the target application or system. There are multiple ways to inject code into a running application or system, such as using debuggers or specific APIs. 

Once the code has been injected, it will be executed at runtime. The code can be used to modify or replace existing functions, as well as to add new functionality. 

Hooking can be used for legitimate purposes, such as to add features to an application or system, or to improve performance. It can also be used for malicious purposes, such as to steal data or gain access to privileged information. 

Hooking is a powerful tool, but it should be used responsibly and with caution. It can be used to great effect when used for legitimate purposes, but if used for malicious purposes it can cause serious damage.

#API Hooking C++ example code

#include <Windows.h>
#include <iostream>

//Function pointer that holds the address of the original function 
typedef void (*OriginalFunction)();

OriginalFunction pOrigFunc = NULL;

//The hook function 
void HookFunction()
{
	std::cout << "Hook function called instead of the original one.\n";
	
	//Call the original function 
	pOrigFunc();
}

int main()
{
	//Get the address of the original function 
	pOrigFunc = (OriginalFunction)GetProcAddress(GetModuleHandle(NULL), "OriginalFunction");
	
	//Hook the original function
	if(!DetourAttach(&(PVOID&)pOrigFunc, HookFunction)) 
	{
		std::cout << "Hook failed.\n";
		return 0;
	}
	
	//Call the hooked function 
	std::cout << "Calling hooked function...\n";
	pOrigFunc();
	
	//Unhook the original function 
	if(!DetourDetach(&(PVOID&)pOrigFunc, HookFunction))
	{
		std::cout << "Unhook failed.\n";
		return 0;
	}
	
	//Call the original function 
	std::cout << "Calling original function...\n";
	pOrigFunc();
	
	return 0;
}

#WriteProcessMemory API Hooking C++ example code

//Include the necessary Windows headers
#include <windows.h>
#include <tlhelp32.h>

//Define the hook function
BOOL WINAPI NewWriteProcessMemory(HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T *lpNumberOfBytesWritten)
{
    //Call the original WriteProcessMemory function
    BOOL retVal = WriteProcessMemory(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesWritten);
    
    //Check the return value to see if the operation was successful
    if (retVal)
    {
        //The operation was successful, so do something with the data
        //For example, you could log the data to a file
    }
    
    //Return the original return value
    return retVal;
}

//Hook the WriteProcessMemory function
BOOL HookWriteProcessMemory()
{
    //Get the address of the WriteProcessMemory function
    HMODULE hKernel32 = GetModuleHandle(L"kernel32.dll");
    LPVOID lpWriteProcessMemory = GetProcAddress(hKernel32, "WriteProcessMemory");
    
    //Allocate some memory in the target process
    HANDLE hProcess = GetCurrentProcess();
    LPVOID lpMemory = VirtualAllocEx(hProcess, NULL, sizeof(lpWriteProcessMemory), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    
    //Copy the address of the hook function into the target process
    WriteProcessMemory(hProcess, lpMemory, &NewWriteProcessMemory, sizeof(lpWriteProcessMemory), NULL);
    
    //Create a thread to execute the hook function
    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)lpMemory, NULL, 0, NULL);
    
    //Wait for the thread to finish
    WaitForSingleObject(hThread, INFINITE);
    
    //Free the memory in the target process
    VirtualFreeEx(hProcess, lpMemory, 0, MEM_RELEASE);
    
    //Close the thread and process handles
    CloseHandle(hThread);
    CloseHandle(hProcess);
    
    //Return TRUE to indicate success
    return TRUE;
}


#CreateRemoteThread API Hooking C++ example code

// Include the Windows API and C++ libraries
#include <windows.h>
#include <cstdio>

// Define a function pointer type for the CreateRemoteThread API
typedef HANDLE (WINAPI *CreateRemoteThreadFunction)(
	HANDLE hProcess,
	LPSECURITY_ATTRIBUTES lpThreadAttributes,
	SIZE_T dwStackSize,
	LPTHREAD_START_ROUTINE lpStartAddress,
	LPVOID lpParameter,
	DWORD dwCreationFlags,
	LPDWORD lpThreadId
	);

// Declare a pointer to the original CreateRemoteThread API
static CreateRemoteThreadFunction originalCreateRemoteThread;

// Define a new CreateRemoteThread API
HANDLE WINAPI HookCreateRemoteThread(
	HANDLE hProcess,
	LPSECURITY_ATTRIBUTES lpThreadAttributes,
	SIZE_T dwStackSize,
	LPTHREAD_START_ROUTINE lpStartAddress,
	LPVOID lpParameter,
	DWORD dwCreationFlags,
	LPDWORD lpThreadId
	)
{
	//Print a message
	printf("CreateRemoteThread Hooked\n");

	// Call the original CreateRemoteThread API
	return originalCreateRemoteThread(
		hProcess,
		lpThreadAttributes,
		dwStackSize,
		lpStartAddress,
		lpParameter,
		dwCreationFlags,
		lpThreadId
		);
}

// Hook the CreateRemoteThread API
void HookCreateRemoteThreadAPI()
{
	// Get the address of the original CreateRemoteThread API
	HMODULE hKernel32 = GetModuleHandleA("kernel32.dll");
	originalCreateRemoteThread = (CreateRemoteThreadFunction)GetProcAddress(hKernel32, "CreateRemoteThread");

	// Replace the original CreateRemoteThread API with HookCreateRemoteThread
	DWORD dwOldProtect;
	VirtualProtect(originalCreateRemoteThread, sizeof(CreateRemoteThreadFunction), PAGE_EXECUTE_READWRITE, &dwOldProtect);
	*(CreateRemoteThreadFunction*)&originalCreateRemoteThread = HookCreateRemoteThread;
	VirtualProtect(originalCreateRemoteThread, sizeof(CreateRemoteThreadFunction), dwOldProtect, &dwOldProtect);
}

// Unhook the CreateRemoteThread API
void UnhookCreateRemoteThreadAPI()
{
	// Restore the original CreateRemoteThread API
	DWORD dwOldProtect;
	VirtualProtect(originalCreateRemoteThread, sizeof(CreateRemoteThreadFunction), PAGE_EXECUTE_READWRITE, &dwOldProtect);
	*(CreateRemoteThreadFunction*)&originalCreateRemoteThread = originalCreateRemoteThread;
	VirtualProtect(originalCreateRemoteThread, sizeof(CreateRemoteThreadFunction), dwOldProtect, &dwOldProtect);
}

#DLL Injection API Hooking C++ example code

The below example code shows how to perform a DLL injection and API hooking using C++.

#include <windows.h>

// DLL injection and api hooking
void InjectDLLandHook( const char* dllName )
{
    // DLL injection
    HMODULE hDll = LoadLibrary(dllName);
    if(hDll == NULL)
        return;
 
    // Get the address of the function to be hooked
    FARPROC pFunc = GetProcAddress(hDll, "FunctionName");
    if(pFunc == NULL)
        return;
 
    // Hook the function
    HOOKPROC pHookProc = (HOOKPROC) pFunc;
    HHOOK hHook = SetWindowsHookEx(WH_CALLWNDPROC, pHookProc, hDll, 0);
    if(hHook == NULL)
        return;
 
    // Call the function from the DLL
    pFunc();
 
    // Unhook the function
    UnhookWindowsHookEx(hHook);
    FreeLibrary(hDll);
}

#Write Win32 API C++ Hello World code with comments

// include Windows.h library for using Windows APIs
#include <Windows.h>

// define the main function
int main() {
    // call MessageBox API to display a message box
    MessageBox(NULL, "Hello World!", "Win32 API Hello World", MB_OK);
    
    // return 0 to indicate success
    return 0;
}

#Write AutoHotkey code with comments to detect gray pixel in a game and click on it

PixelGetColor, color, x, y ;get color of pixel at x, y

if (color = 0x808080) ;if color is gray
{
    Click ;click on that pixel
    MsgBox Gray pixel found! ;display message
}
else
    MsgBox Not a gray pixel. ;display message

#Write example AutoHotkey DLL calling script

# Single-line comment

; Multi-line comment

#Include <MyLibrary.dll> ; Include the DLL library

MyFunction() ; Call the MyFunction() function from the DLL
{
	MsgBox, % DllCall("MyLibrary.dll\MyFunction") ; Call MyFunction() from the DLL
}

MyFunction() ; Call the function

=======================You.com Mobile Research============================
Win32 API Hooking in C++ example CreateFileW

Here's an example of how to use Win32 API hooking to intercept calls to the CreateFileW function in C++ using the Microsoft Detours library:

#include <windows.h>
#include <detours.h>
#include <stdio.h>

typedef HANDLE (*CreateFileW_t)(
  LPCWSTR lpFileName,
  DWORD dwDesiredAccess,
  DWORD dwShareMode,
  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
  DWORD dwCreationDisposition,
  DWORD dwFlagsAndAttributes,
  HANDLE hTemplateFile
);

LPCWSTR hookPath = L"C:\\hook.log";

HANDLE WINAPI MyCreateFileW(
  LPCWSTR lpFileName,
  DWORD dwDesiredAccess,
  DWORD dwShareMode,
  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
  DWORD dwCreationDisposition,
  DWORD dwFlagsAndAttributes,
  HANDLE hTemplateFile
) {
  HANDLE hFile;
  CreateFileW_t f = (CreateFileW_t)DetourFindFunction("kernel32.dll", "CreateFileW");
  hFile = f(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);

  if (hFile != INVALID_HANDLE_VALUE) {
    FILE* f = _wfopen(hookPath, L"a");
    fwprintf(f, L"CreateFileW hook called: %ls\n", lpFileName);
    fclose(f);
  }

  return hFile;
}

BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
  switch (ul_reason_for_call) {
    case DLL_PROCESS_ATTACH:
      DisableThreadLibraryCalls(hModule);
      DetourTransactionBegin();
      DetourUpdateThread(GetCurrentThread());
      DetourAttach(&(PVOID&)CreateFileW, MyCreateFileW);
      DetourTransactionCommit();
      break;
    case DLL_PROCESS_DETACH:
      DetourTransactionBegin();
      DetourUpdateThread(GetCurrentThread());
      DetourDetach(&(PVOID&)CreateFileW, MyCreateFileW);
      DetourTransactionCommit();
      break;
    default:
      break;
  }
  return TRUE;
}
This code creates a hook for the CreateFileW function, which intercepts calls to the original function and logs the file name to a log file at C:\hook.log. Note that this code assumes that you have already built the Detours library and have included its headers and import library in your

You may be interested in visiting CreateFileW function (fileapi.h) - Win32 apps | Microsoft Learn. https://r.v2i8b.com/api/v1/bid/redirect?campaign_id=01GWHNP35ZW7N25QKXMEA9EHVQ&url=https%3A%2F%2Flearn.microsoft.com%2Fen-us%2Fwindows%2Fwin32%2Fapi%2Ffileapi%2Fnf-fileapi-createfilew&source=youchat&cid=da7ac2b2-2a21-4d1e-9b14-a5ee873d1159&fb=https%3A%2F%2Flearn.microsoft.com%2Fen-us%2Fwindows%2Fwin32%2Fapi%2Ffileapi%2Fnf-fileapi-createfilew https://you.com/search?q=Win32+API+Hooking+in+C%2B%2B+example+CreateFileW&fromSearchBar=true&tbm=youchat&cid=c2_dc7f775d-40ea-4c4a-b394-0546833081ad https://medium.com/geekculture/basic-windows-api-hooking-acb8d275e9b8 xhttps://easyhook.github.io/tutorials/nativeremotehook.html https://easyhook.github.io/tutorials/remotefilemonitor.html https://www.ired.team/offensive-security/defense-evasion/bypassing-cylance-and-other-avs-edrs-by-unhooking-windows-apis https://breakdev.org/defeating-antivirus-real-time-protection-from-the-inside/ https://www.codeproject.com/Articles/27637/EasyHook-The-reinvention-of-Windows-API-hooking

=======================================

What is a C# delegate?
A delegate in C# is a type that represents a reference to a method with a specific signature and return type 1. The delegate type defines the method signature that can be referenced by a delegate instance. Once a delegate is instantiated, it can be passed as an argument to a method or called directly, invoking the method or methods that it references. Delegates are commonly used in event handling, callback mechanisms, and asynchronous programming.

What is a C++ template?
A C++ template is a feature of the C++ programming language that allows functions 1, classes, and data structures to work with generic types. The simple idea behind templates is to pass a data type as a parameter so that the programmer does not need to write separate code for each data type. Templates allow a single function or a single class to work with different data types 2, making C++ code more efficient and easier to read and maintain. With templates, the types can be determined at compile-time, allowing the compiler to optimize the code for the specific data types used. Templates are a fundamental feature of generic programming in C++.

What is a Callback in programming?
In computer programming, a callback is a function or piece of executable code that is passed as an argument to another function or method 12, which is then called or executed inside the outer function or method to complete some task or action. Essentially, a callback function allows developers to control the flow of code execution by postponing the execution of certain code until a specific event or condition occurs, such as the completion of a time-consuming process or the occurrence of an event like a mouse click or a key press. Callbacks can be used in a variety of programming languages, including JavaScript, Python, and C++.

C++ Game Libraries::
SFML (Simple and Fast Multimedia Library): This is a multimedia library that provides simple interfaces to 2D graphics, audio, and networking functions for developing cross-platform games and multimedia applications. It is open-source and has a large community of users and contributors.

SDL (Simple DirectMedia Layer): SDL is a popular cross-platform multimedia library that provides low-level access to audio, keyboard, mouse, joystick, and graphics hardware via OpenGL and Direct3D. It is also open-source and widely used in game and multimedia development.

Allegro: Allegro is another cross-platform game programming library that provides support for several audio and video formats as well as input devices. It also has a built-in physics engine and graphical user interface widgets.

Unity and Unreal Engine: These are two popular game engines that provide a complete set of tools and resources for creating both 2D and 3D games. Both engines enable developers to write game logic using C++, along with support for other programming languages like C# and JavaScript.
https://learn.microsoft.com/en-us/samples/microsoft/windows-universal-samples/simple3dgamedx/

Here is a simple example code for creating a game using WinForms in C#:

using System;
using System.Drawing;
using System.Windows.Forms;

namespace SimpleGame
{
    public partial class Form1 : Form
    {
        private int score = 0;

        public Form1()
        {
            InitializeComponent();
        }

        private void btnStart_Click(object sender, EventArgs e)
        {
            // Hide the start button
            btnStart.Visible = false;
            
            // Set up the game
            score = 0;
            lblScore.Text = "Score: 0";
            timer1.Enabled = true;
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            // Move the ball
            ball.Left += 5;
            if (ball.Right >= ClientRectangle.Right)
            {
                ball.Left = ClientRectangle.Left;
            }

            // Check for collisions
            if (ball.Bounds.IntersectsWith(paddle.Bounds))
            {
                // Increase the score
                score++;
                lblScore.Text = "Score: " + score.ToString();
            }
        }

        private void Form1_KeyDown(object sender, KeyEventArgs e)
        {
            // Move the paddle
            if (e.KeyCode == Keys.Left)
            {
                paddle.Left -= 10;
                if (paddle.Left <= ClientRectangle.Left)
                {
                    paddle.Left = ClientRectangle.Left;
                }
            }
            else if (e.KeyCode == Keys.Right)
            {
                paddle.Left += 10;
                if (paddle.Right >= ClientRectangle.Right)
                {
                    paddle.Left = ClientRectangle.Right - paddle.Width;
                }
            }
        }
    }
}
This code creates a simple game where the player controls a paddle at the bottom of the screen to catch a ball that bounces back and forth. The player earns one point for each time the ball is caught by the paddle. The game starts by clicking a "Start" button.
https://r.v2i8b.com/api/v1/bid/redirect?campaign_id=01GWHNP35ZW7N25QKXMEA9EHVQ&url=https%3A%2F%2Flearn.microsoft.com%2Fen-us%2Fvisualstudio%2Fget-started%2Fcsharp%2Ftutorial-windows-forms-create-match-game&source=youchat&cid=e5ca02bf-1dd1-4806-9abd-f973f9ae6693&fb=https%3A%2F%2Flearn.microsoft.com%2Fen-us%2Fvisualstudio%2Fget-started%2Fcsharp%2Ftutorial-windows-forms-create-match-game
Racing-Game (https://github.com/topics/racing-game): This repository contains a collection of open-source racing game projects written in C# using various game engines such as MonoGame and Godot.

Car-Racing-Game (https://github.com/topics/car-racing-game): This repository contains a collection of open-source car racing game projects written in C# using various technologies such as Windows Forms and LINQ.

Car Racing 2D Game in C#.NET Project with Source code (https://www.itsourcecode.com/free-projects/csharp-projects/car-racing-2d-game-in-c-net-project-with-source-code/): This is a beginner-friendly project that demonstrates how to create a simple car racing game in C# using Visual Studio.

============================================

#API Hooking AppInit_DLLs example function code in C++ with explanation.
Here is an example of how to use AppInit_DLLs to hook into API functions in C++:

#include <Windows.h>

// Declare the function pointer type for the original function
typedef BOOL(WINAPI* OrigCreateFileA)(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);

// Declare the original function pointer variable
OrigCreateFileA pOrigCreateFileA = nullptr;

// Our hook for the CreateFileA function
BOOL WINAPI HookCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
{
    // Do whatever we want with the function call here
    // ...

    // Call the original function if desired
    if (pOrigCreateFileA)
    {
        return pOrigCreateFileA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
    }

    // Return a default value if we didn't call the original function
    return false;
}

// The entry point function (DLLMain) for our DLL
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    switch (fdwReason)
    {
    // The DLL is being loaded
    case DLL_PROCESS_ATTACH:
        // Hook the CreateFileA function by overwriting its import address
        // with the address of our hook function
        {
            HMODULE hModule = GetModuleHandleA("KERNEL32.DLL");
            if (hModule)
            {
                // Get the address of the original function
                pOrigCreateFileA = (OrigCreateFileA)GetProcAddress(hModule, "CreateFileA");

                // Overwrite the import address with the address of our hook function
                DWORD dwOldProtect;
                if (VirtualProtect(&pOrigCreateFileA, sizeof(pOrigCreateFileA), PAGE_EXECUTE_READWRITE, &dwOldProtect))
                {
                    pOrigCreateFileA = (OrigCreateFileA)InterlockedExchangePointer((PVOID*)&pOrigCreateFileA, (PVOID)&HookCreateFileA);
                    VirtualProtect(&pOrigCreateFileA, sizeof(pOrigCreateFileA), dw

https://stackoverflow.com/questions/14804195 Can AppInit_DLLs be used to hook APIs from Ws2_32.dll? {Needs to call only from User32.dll System32 either MessageBoxT or similar to be loaded.}

=======================================

#Explain the C++ this keyword and give a practical example.
The this keyword in C++ is a pointer to the current instance of a class. It is used to refer to the object's own members and methods. In other words, it allows you to access the current object's data members and methods, even if they have the same name as local variables or parameters.

Here is an example of how to use this in a practical context:

#include <iostream>
using namespace std;

class Rectangle {
  private:
    int width, height;
  public:
    void set_values(int, int);
    int area() { return width * height; }
};

void Rectangle::set_values(int w, int h) {
  this->width = w;
  this->height = h;
}

int main() {
  Rectangle rect;
  rect.set_values(3, 4);
  cout << "area: " << rect.area() << endl;
  return 0;
}

In this example, set_values is a member function of the Rectangle class that takes two parameters w and h and sets the width and height data members of the current object. The this pointer is used to refer to the current object's data members.

When set_values is called on the rect object with parameters 3 and 4, this points to the rect object, so this->width and this->height refer to rect's width and height data members. The area method is then called on the rect object to calculate and return its area.

Overall, the this keyword is a powerful tool in C++ that allows you to refer to the current instance of a class and access its data members and methods.

===========================================
#Hello World Win32API C++ code with comments
#Rewrite the above code ^ to include showing a window with Hello World caption in it.

#include <Windows.h>

// Forward declaration of the window procedure
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

// Entry point of the program
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    // Register the window class
    WNDCLASSEX wcex;
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc = WndProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszMenuName = NULL;
    wcex.lpszClassName = "MainWindowClass";
    wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

    if (!RegisterClassEx(&wcex))
    {
        MessageBox(NULL, "Window Registration Failed!", "Error", MB_ICONERROR | MB_OK);
        return 1;
    }

    // Create the window
    HWND hWnd = CreateWindowEx(0, "MainWindowClass", "Hello World", WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 800, 600, NULL, NULL, hInstance, NULL);

    if (!hWnd)
    {
        MessageBox(NULL, "Window Creation Failed!", "Error", MB_ICONERROR | MB_OK);
        return 1;
    }

    // Show and update the window
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);

    // Message loop
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return (int)msg.wParam;
}

// Window procedure
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
        case WM_DESTROY:
            PostQuitMessage(0);
            break;
        default:
            return DefWindowProc(hWnd, msg, wParam, lParam);
    }

    return 0;
}



===========================================
#Sepia image convert C++ source code.
#Rewrite the above code ^ without any headers purely in C++.

#include <iostream>
#include <fstream>

#pragma pack(push, 1)
struct BMPHeader {
    uint16_t type;
    uint32_t size;
    uint16_t reserved1;
    uint16_t reserved2;
    uint32_t offset;
    uint32_t headerSize;
    int32_t width;
    int32_t height;
    uint16_t planes;
    uint16_t bitDepth;
    uint32_t compression;
    uint32_t imageSize;
    int32_t xResolution;
    int32_t yResolution;
    uint32_t colorsUsed;
    uint32_t importantColors;
};

struct RGB {
    uint8_t blue;
    uint8_t green;
    uint8_t red;
};
#pragma pack(pop)

void convertToSepia(RGB* pixels, int width, int height) {
    for (int y = 0; y < height; ++y) {
        for (int x = 0; x < width; ++x) {
            RGB& pixel = pixels[y * width + x];

            // Convert to sepia using the following formula
            uint8_t sepiaBlue = std::min(static_cast<uint8_t>(0.272 * pixel.red + 0.534 * pixel.green + 0.131 * pixel.blue), static_cast<uint8_t>(255));
            uint8_t sepiaGreen = std::min(static_cast<uint8_t>(0.349 * pixel.red + 0.686 * pixel.green + 0.168 * pixel.blue), static_cast<uint8_t>(255));
            uint8_t sepiaRed = std::min(static_cast<uint8_t>(0.393 * pixel.red + 0.769 * pixel.green + 0.189 * pixel.blue), static_cast<uint8_t>(255));

            pixel.blue = sepiaBlue;
            pixel.green = sepiaGreen;
            pixel.red = sepiaRed;
        }
    }
}

int main() {
    const char* inputFilename = "input.bmp";
    const char* outputFilename = "output.bmp";

    std::ifstream inputFile(inputFilename, std::ios::binary);
    if (!inputFile) {
        std::cerr << "Failed to open input file." << std::endl;
        return 1;
    }

    BMPHeader header;
    inputFile.read(reinterpret_cast<char*>(&header), sizeof(BMPHeader));

    if (header.type != 0x4D42) {
        std::cerr << "Invalid input file format." << std::endl;
        return 1;
    }

    if (header.bitDepth != 24) {
        std::cerr << "Unsupported bit depth. Only 24-bit BMP images are supported." << std::endl;
        return 1;
    }

    int imageSize = header.width * header.height;
    RGB* pixels = new RGB[imageSize];

    inputFile.read(reinterpret_cast<char*>(pixels), imageSize * sizeof(RGB));

    inputFile.close();

    // Convert the image to sepia
    convertToSepia(pixels, header.width, header.height);

    std::ofstream outputFile(outputFilename, std::ios::binary);
    if (!outputFile) {
        std::cerr << "Failed to open output file." << std::endl;
        delete[] pixels;
        return 1;
    }

    outputFile.write(reinterpret_cast<char*>(&header), sizeof(BMPHeader));
    outputFile.write(reinterpret_cast<char*>(pixels), imageSize * sizeof(RGB));

    outputFile.close();

    delete[] pixels;

    return 0;
}
================================================
#Creating a DLL working example source code in Win32API C++.

#include <windows.h>

// Exported function
extern "C" __declspec(dllexport) int Multiply(int a, int b) {
    return a * b;
}

// Entry point of the DLL
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved) {
    // Perform any initialization or cleanup tasks here

    switch (fdwReason) {
        case DLL_PROCESS_ATTACH:
            // DLL is being loaded into the process's address space
            break;
        case DLL_PROCESS_DETACH:
            // DLL is being unloaded from the process's address space
            break;
    }

    return TRUE;
}
In this code:

We include the necessary Windows header (windows.h) to work with Win32 API.

The Multiply function is the exported function that will be accessible from other applications using the DLL. It simply multiplies two integers and returns the result.

The DllMain function is the entry point of the DLL. It is called when the DLL is loaded or unloaded. In this example, we provide a minimal implementation that doesn't perform any specific initialization or cleanup tasks.

To create the DLL:

Compile the code into a DLL using a C++ compiler that supports Win32 API development, such as Visual Studio.

Once the DLL is built, you can use it in other applications by loading the DLL dynamically and calling the exported function Multiply. Here's an example of how you can use the DLL in another C++ program:

cpp
Copy code
#include <iostream>
#include <windows.h>

typedef int (*MultiplyFunc)(int, int);

int main() {
    // Load the DLL
    HINSTANCE hDll = LoadLibrary("yourdll.dll");
    if (hDll == NULL) {
        std::cerr << "Failed to load DLL." << std::endl;
        return 1;
    }

    // Get the function pointer
    MultiplyFunc multiply = (MultiplyFunc)GetProcAddress(hDll, "Multiply");
    if (multiply == NULL) {
        std::cerr << "Failed to get function pointer." << std::endl;
        return 1;
    }

    // Call the function
    int result = multiply(5, 7);
    std::cout << "Result: " << result << std::endl;

    // Unload the DLL
    FreeLibrary(hDll);

    return 0;
}
Make sure to replace "yourdll.dll" with the actual name of your DLL file.

This example demonstrates how to load the DLL dynamically using LoadLibrary, obtain the function pointer using GetProcAddress, and call the exported function Multiply from the DLL.


================================================
#Explanation on how to program scrollbars in Win32API C++ with example source code.
ChatGPT
To program scrollbars in Win32 API C++, you need to handle messages related to scrolling and update the scroll position accordingly. Here's an example that demonstrates how to create a window with scrollbars and handle scrolling messages:

cpp
Copy code
#include <windows.h>

// Window procedure
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    static int xPos = 0;  // Horizontal scroll position
    static int yPos = 0;  // Vertical scroll position

    switch (uMsg) {
        case WM_CREATE:
            // Create horizontal scrollbar
            SetScrollRange(hwnd, SB_HORZ, 0, 100, FALSE);
            SetScrollPos(hwnd, SB_HORZ, xPos, TRUE);
            break;

        case WM_HSCROLL:
            // Handle horizontal scrolling
            switch (LOWORD(wParam)) {
                case SB_LINELEFT:
                    xPos -= 10;
                    break;

                case SB_LINERIGHT:
                    xPos += 10;
                    break;

                case SB_PAGELEFT:
                    xPos -= 50;
                    break;

                case SB_PAGERIGHT:
                    xPos += 50;
                    break;

                case SB_THUMBTRACK:
                    xPos = HIWORD(wParam);
                    break;
            }

            xPos = max(0, min(xPos, 100));  // Limit scroll position
            SetScrollPos(hwnd, SB_HORZ, xPos, TRUE);
            break;

        case WM_VSCROLL:
            // Handle vertical scrolling
            switch (LOWORD(wParam)) {
                case SB_LINEUP:
                    yPos -= 10;
                    break;

                case SB_LINEDOWN:
                    yPos += 10;
                    break;

                case SB_PAGEUP:
                    yPos -= 50;
                    break;

                case SB_PAGEDOWN:
                    yPos += 50;
                    break;

                case SB_THUMBTRACK:
                    yPos = HIWORD(wParam);
                    break;
            }

            yPos = max(0, min(yPos, 100));  // Limit scroll position
            SetScrollPos(hwnd, SB_VERT, yPos, TRUE);
            break;

        case WM_PAINT:
            // Handle painting the window
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hwnd, &ps);
            
            // Draw content based on scroll positions
            // ...

            EndPaint(hwnd, &ps);
            break;

        case WM_DESTROY:
            // Destroy the window
            PostQuitMessage(0);
            break;

        default:
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }

    return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    // Register the window class
    const wchar_t CLASS_NAME[] = L"MyWindowClass";

    WNDCLASS wc = {};
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.lpszClassName = CLASS_NAME;

    RegisterClass(&wc);

    // Create the window
    HWND hwnd = CreateWindowEx(
        0,                      // Optional window styles
        CLASS_NAME,             // Window class name
        L"Scrollbars Example",  // Window title
        WS_OVERLAPPEDWINDOW,    // Window style

        // Size and position
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,

        NULL,                   // Parent window
        NULL,                   // Menu
        hInstance,              // Instance handle
        NULL                    // Additional application data
    );

    if (hwnd == NULL) {
        return 0;
    }

    // Show the window
    ShowWindow(hwnd, nCmdShow);

    // Message loop
    MSG msg = {};
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return 0;
}
In this example:

The WindowProc function is the window procedure that handles various messages related to the window, including scrolling messages.

In the WM_CREATE message, the horizontal scrollbar is created using SetScrollRange and SetScrollPos functions. The initial scroll position is set to 0.

The WM_HSCROLL message is handled to update the horizontal scroll position based on different scroll actions, such as clicking the left or right arrow buttons, dragging the thumb, etc. The scroll position is limited to a range of 0 to 100.

Similarly, the WM_VSCROLL message is handled to update the vertical scroll position.

The WM_PAINT message is handled to paint the window content. You can modify this section to draw the actual content based on the current scroll positions.

The WM_DESTROY message is handled to destroy the window and exit the application.

The WinMain function registers the window class, creates the window, and starts the message loop.

You can run this code to create a window with scrollbars. The content inside the window can be updated based on the scroll positions. Feel free to modify the painting logic and adapt it to your specific needs.

================================================
#What are Design Patterns in programming?

Design patterns in programming are reusable solutions to common problems that occur in software design and development. They are proven techniques that provide a way to structure code and relationships between components to achieve specific goals. Design patterns help improve the efficiency, maintainability, and scalability of software systems.

Here are some key aspects of design patterns:

Problem-Solution Approach: Design patterns address specific problems that commonly arise in software design. Each pattern provides a solution or a set of guidelines to solve the problem effectively.

Reusability: Design patterns are reusable because they provide a general approach to solving problems. Once you understand a design pattern, you can apply it to different projects or scenarios.

Standardized Terminology: Design patterns have standard names and terminologies, making it easier for developers to communicate and understand each other's code. This shared vocabulary helps in discussions, documentation, and collaboration.

Best Practices: Design patterns encapsulate best practices and proven techniques that have been refined and validated by the programming community. They embody years of experience and knowledge, allowing developers to leverage the expertise of others.

Flexibility and Adaptability: Design patterns are not rigid templates but rather flexible guidelines. They can be adapted and customized to fit the specific requirements of a project or to address variations in problem domains.

Types of Patterns: Design patterns can be categorized into different types, such as creational patterns (e.g., Singleton, Factory Method), structural patterns (e.g., Adapter, Decorator), and behavioral patterns (e.g., Observer, Strategy). Each type focuses on different aspects of software design.

By understanding and applying design patterns, developers can improve the quality, maintainability, and extensibility of their code. Design patterns promote code reusability, modular design, separation of concerns, and a more structured approach to solving problems in software development. They are widely used in various programming languages and are considered an essential part of a developer's toolkit.

================================================
#What is COM explain in-depth

COM (Component Object Model) is a binary interface standard introduced by Microsoft for developing software components that can be used across different programming languages and platforms. It provides a framework for creating and using reusable software components in a distributed computing environment.

Here is an in-depth explanation of COM:

Component: A component in COM is a self-contained unit of software functionality that encapsulates a specific set of functionality. Components are designed to be independent, reusable, and interchangeable.

Interface: In COM, components communicate with each other through interfaces. An interface defines a contract that specifies the methods, properties, and events that a component exposes to other components. Interfaces provide a way to invoke methods and access properties of a component.

Object Model: COM is based on an object-oriented programming model, where components are represented as objects that encapsulate both data and behavior. Objects in COM adhere to the principles of encapsulation, inheritance, and polymorphism.

Binary Standard: COM is a binary interface standard, meaning that it defines a standard binary format for representing components and their interfaces. This binary format allows components to be language-agnostic, meaning they can be developed in one programming language and used in another without any language-specific dependencies.

Interoperability: One of the key features of COM is its support for interoperability. Components developed in different programming languages, such as C++, Visual Basic, or C#, can seamlessly communicate with each other using COM interfaces. This allows developers to leverage existing components and libraries regardless of the programming language they were written in.

Component Services: COM provides a set of built-in services and facilities to support common tasks such as object activation, object lifetime management, interface querying, and memory management. These services, known as component services, simplify the development and management of COM components.

Distributed Computing: COM supports distributed computing by allowing components to be located on remote machines and accessed over a network. This enables the development of distributed applications and services that can span multiple machines and platforms.

Evolution: COM has evolved over time with the introduction of various extensions and enhancements. These include features such as COM+, ActiveX, and DCOM (Distributed COM), which provide additional capabilities and support for advanced scenarios.

COM has been widely used in the Windows ecosystem for building a wide range of software components, including libraries, frameworks, ActiveX controls, and COM+ applications. It provides a powerful and flexible mechanism for building modular and interoperable software systems, enabling code reuse, extensibility, and distributed computing.

================================================
====================================Google Bard How To Create A DLL=====================================
#Explanation on how to program DLL's in Win32API C++ with example source code.

Sure, here is an explanation on how to program DLL's in Win32API C++ with example source code:

A DLL, or Dynamic Link Library, is a type of library that can be loaded and unloaded at runtime. DLLs are often used to share code and resources between different applications.

To program a DLL in Win32API C++, you will need to create a new project in Visual Studio. When you create the project, you will need to select the "DLL" project type.

Once you have created the project, you will need to add the following header files to your project:

windows.h
libloaderapi.h
The windows.h header file contains declarations for the Windows API functions. The libloaderapi.h header file contains declarations for the functions that are used to load and unload DLLs.

You will also need to add some code to your project. The following code shows an example of a simple DLL that contains a single function:

C++
#include <windows.h>
#include <libloaderapi.h>

extern "C" __declspec(dllexport) int Add(int x, int y) {
  return x + y;
}
Use code with caution. Learn more
This code defines a function called Add that takes two integers as input and returns their sum. The dllexport keyword tells the compiler to export this function so that it can be called from other applications.

To compile and build the DLL, you can use the following commands in the Visual Studio Command Prompt:

Code snippet
cl /LD Add.cpp
Use code with caution. Learn more
This will create a DLL file called Add.dll.

To use the DLL in another application, you will need to load it into the application's memory. You can do this using the LoadLibrary function:

C++
HMODULE hDll = LoadLibrary("Add.dll");
Use code with caution. Learn more
Once the DLL is loaded, you can get the address of the exported function using the GetProcAddress function:

C++
int (*pAdd)(int, int) = GetProcAddress(hDll, "Add");
Use code with caution. Learn more
Once you have the address of the function, you can call it like any other function:

C++
int sum = pAdd(10, 20);
Use code with caution. Learn more
This code will print the value 30 to the console.
===================================End GoogleBard DLL Explanation==========================
===================================GoogleBard Scrollbar=================================
#Explanation on how to program scrollbars in Win32API C++ with example source code.

Sure, here is an explanation on how to program scrollbars in Win32API C++ with example source code:

1. Create the scrollbars.

The first step is to create the scrollbars. This can be done using the CreateWindowEx() function. The following code shows how to create a horizontal and vertical scrollbar:

C++
// Create the horizontal scrollbar.
HWND hWndHScrollBar = CreateWindowEx(
    0,
    "SCROLLBAR",
    NULL,
    WS_VISIBLE | WS_CHILD | SBS_HORZ,
    0,
    0,
    100,
    15,
    hWnd,
    (HMENU)IDC_HSCROLLBAR,
    (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE),
    NULL);

// Create the vertical scrollbar.
HWND hWndVScrollBar = CreateWindowEx(
    0,
    "SCROLLBAR",
    NULL,
    WS_VISIBLE | WS_CHILD | SBS_VERT,
    0,
    0,
    15,
    100,
    hWnd,
    (HMENU)IDC_VSCROLLBAR,
    (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE),
    NULL);
Use code with caution. Learn more
The CreateWindowEx() function takes a number of parameters, but the most important ones are the window class name, the window style, and the window position and size. The window class name for a scrollbar is "SCROLLBAR". The window style specifies the type of scrollbar (horizontal or vertical) and whether it is visible and a child window. The window position and size specify the scrollbar's position and size within its parent window.

2. Set the scroll range.

Once the scrollbars have been created, you need to set their scroll range. The scroll range specifies the minimum and maximum values that the scrollbar can scroll to. This can be done using the SetScrollRange() function. The following code shows how to set the scroll range for the horizontal and vertical scrollbars:

C++
// Set the scroll range for the horizontal scrollbar.
SetScrollRange(hWndHScrollBar, SB_CTL, 0, 100, TRUE);

// Set the scroll range for the vertical scrollbar.
SetScrollRange(hWndVScrollBar, SB_CTL, 0, 100, TRUE);
Use code with caution. Learn more
The SetScrollRange() function takes three parameters: the handle of the scrollbar, the scroll bar identifier, the minimum value, and the maximum value. The scroll bar identifier can be either SB_CTL or SB_PAGE, which specifies whether the scroll range is for the entire document or for a single page. The minimum value is the minimum value that the scrollbar can scroll to, and the maximum value is the maximum value that the scrollbar can scroll to.

3. Handle scroll bar messages.

The scrollbars will send messages to the window procedure when they are scrolled. These messages can be handled using the WM_HSCROLL and WM_VSCROLL messages. The following code shows how to handle the WM_HSCROLL message:

C++
LRESULT CALLBACK WndProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) {
    switch (Msg) {
    case WM_HSCROLL: {
        // Handle the horizontal scroll bar message.
        int nPos = (int)LOWORD(wParam);
        // Do something with the scroll position.
        break;
    }
    default:
        return DefWindowProc(hWnd, Msg, wParam, lParam);
    }
    return 0;
}
Use code with caution. Learn more
The WM_HSCROLL message takes two parameters: the handle of the scrollbar and the scroll position. The scroll position is the new position of the scrollbar, as a percentage of the scroll range.

4. Display the scrollbars.

Once the scrollbars have been created and their scroll ranges have been set, they need to be displayed. This can be done by calling the ShowWindow() function. The following code shows how to display the scrollbars:

C++
ShowWindow(hWndHScrollBar, SW_SHOW);
ShowWindow(hWndVScrollBar, SW_SHOW);
Use code with caution. Learn more
The ShowWindow() function takes two parameters: the handle of the window and the window style. The window style can be either SW_SHOW or SW_HIDE, which specifies whether the window is visible or hidden.
============================End GoogleBard Scrollbar=========================
#Explanation of API Hooking methods (CreateRemoteThread(), Services, DLL Injection) in-depth with working examples and commented code
CreateRemoteThread()

The CreateRemoteThread() API is used to create a new thread in a remote process. This can be used to inject a DLL into a remote process, which is a common technique for malware.

To hook the CreateRemoteThread() API, we can use the following code:

C
#include <windows.h>

typedef DWORD(WINAPI* CreateRemoteThreadFunc)(HANDLE hProcess, LPVOID lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId);

DWORD WINAPI MyCreateRemoteThread(HANDLE hProcess, LPVOID lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId)
{
    // This is the original `CreateRemoteThread()` function.
    CreateRemoteThreadFunc oCreateRemoteThread = (CreateRemoteThreadFunc)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "CreateRemoteThread");

    // This is our hook function.
    DWORD dwResult = oCreateRemoteThread(hProcess, lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, lpThreadId);

    // If the hook function returns successfully, we return the original result.
    if (dwResult != 0)
    {
        dwResult = 0xDEADBEEF;
    }

    return dwResult;
}

int main()
{
    // Get the handle of the target process.
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());

    // Hook the `CreateRemoteThread()` API.
    CreateRemoteThreadFunc oCreateRemoteThread = (CreateRemoteThreadFunc)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "CreateRemoteThread");
    SetHook(oCreateRemoteThread, MyCreateRemoteThread);

    // Create a new thread in the target process.
    DWORD dwThreadId;
    CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "ExitProcess"), 0, 0, &dwThreadId);

    // Unhook the `CreateRemoteThread()` API.
    ResetHook(oCreateRemoteThread);

    return 0;
}
Use code with caution. Learn more
This code will hook the CreateRemoteThread() API and replace it with our own function, MyCreateRemoteThread(). MyCreateRemoteThread() will simply return a value of 0xDEADBEEF if it is called. This will prevent any new threads from being created in the target process.

Services

Another way to hook API calls is to use the Windows service control manager (SCM). The SCM allows you to create and manage Windows services. Services are special types of processes that run in the background and provide a specific function.

To hook API calls using the SCM, we can create a service that intercepts the calls we want to hook. The service can then modify the calls or simply pass them on to the original API.

Here is an example of a service that hooks the CreateRemoteThread() API:

C
// ServiceMain.cpp

#include <windows.h>
#include <tchar.h>

#include "Service.h"

void WINAPI ServiceMain(DWORD dwArgc, LPTSTR* lpszArgv)
{
    // Initialize the service.
    Service* pService = new Service();

    // Hook the `CreateRemoteThread()` API.
    pService->HookAPI(L"kernel32.dll", "CreateRemoteThread", MyCreateRemoteThread);

    // Start the service.
    pService->Start();
}

void WINAPI ServiceCtrlHandler(DWORD dwCtrlCode)
{
    // Handle service control requests.
}

// MyCreateRemoteThread.cpp

#include <windows.h>

DWORD WINAPI MyCreateRemoteThread(HANDLE hProcess, LPVOID lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId)
{
    // This is the hook function.
    DWORD dwResult = 0;

    //
https://es.mathworks.com/help/imaq/adaptorkit/opening-and-closing-a-connection-with-a-device.html https://github.com/CanOzSec/Capsule https://www.apriorit.com/dev-blog/679-windows-dll-injection-for-api-hooks
=========================================================================
The Red-Black Tree is a form of self balancing binary search tree. This type of tree will adjust itself in order to maintain a low (logarithmic) height allowing for faster insertions and deletions. https://github.com/williamfiset/Algorithms/tree/master/slides/datastructures/redblacktree
========================================
=====================================
#Sample code to save and load game assets in C#
Here's a sample code in C# for saving and loading game assets, assuming you're using Unity:

using System.IO;
using UnityEngine;

public static class SaveLoadManager
{
    public static void SaveAsset(string filename, Object asset)
    {
        string savePath = Path.Combine(Application.persistentDataPath, filename);
        string assetPath = AssetDatabase.GetAssetPath(asset);
        File.Copy(assetPath, savePath);
    }

    public static T LoadAsset<T>(string filename) where T : Object
    {
        string loadPath = Path.Combine(Application.persistentDataPath, filename);
        return AssetDatabase.LoadAssetAtPath<T>(loadPath);
    }
}
In this code, SaveAsset takes a filename and the asset you want to save as arguments. It retrieves the asset's path and copies it to a location in the application's persistent data path, where it can be loaded again in the future.

LoadAsset takes a filename and the type of asset you want to load as arguments. It retrieves the asset's path and loads it from that location. The code uses a generic type constraint to ensure that the loaded asset is of the correct type.
=====================================
#How are game assets stored in C# What file formats and frameworks used by game developers?
Game assets can be stored in various formats in C# depending on the specific needs of the game. Some commonly used formats for game assets include PNG, JPEG, WAV, FBX, OBJ, and MP3.

Game developers often use frameworks such as Unity or Unreal Engine to create and manage game assets. These frameworks provide tools for asset creation, importing, and management. Unity, for example, has an Asset Store where developers can purchase pre-built assets or upload their own for others to use.

In addition, game developers use programming languages such as C# to create the game logic and behavior. C# is a popular language for Unity game development as it is fully supported and offers a wide range of functionality through the Unity API. Other programming languages used in game development include C++, Java, and Python, depending on the specific needs of the game.
=====================================

==========================================================
#Give a brief explanation of advanced COM programming with a basic example.
Advanced COM (Component Object Model) programming is a binary-interface standard for software components introduced by Microsoft¹. It is used to enable inter-process communication and object creation in a large range of programming languages¹. COM is the basis for several other Microsoft technologies and frameworks, including OLE, OLE Automation, Browser Helper Object, ActiveX, COM+, DCOM, the Windows shell, DirectX, UMDF and Windows Runtime¹.

The essence of COM is a language-neutral way of implementing objects that can be used in environments different from the one in which they were created, even across machine boundaries¹. For well-authored components, COM allows reuse of objects with no knowledge of their internal implementation, as it forces component implementers to provide well-defined interfaces that are separated from the implementation¹.

Here's a basic example of how you might use a COM object:

```csharp
// Instantiate a CLSID_ShellLink object and request an IShellLink interface pointer to that COM object.
IShellLink link = (IShellLink) new ShellLink();

// Set the path of the shortcut
link.SetPath(@"C:\Path\To\File.txt");

// Save the shortcut to your desktop
IPersistFile file = (IPersistFile)link;
file.Save(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "Shortcut.lnk"), false);
```

In this example, we're creating a new instance of a `ShellLink` object (which is a COM object), setting the path of the shortcut to point to a specific file, and then saving that shortcut to the desktop⁴.

Please note that this is a simplified example and actual usage may require additional error checking and handling⁴.

Source: Conversation with Bing, 21/09/2023
(1) Component Object Model - Wikipedia. https://en.wikipedia.org/wiki/Component_Object_Model.
(2) Introduction to COM - What It Is and How to Use It.. https://www.codeproject.com/articles/633/introduction-to-com-what-it-is-and-how-to-use-it.
(3) What is advanced programming? - University of York. https://online.york.ac.uk/what-is-advanced-programming/.
(4) Advanced C Programming - Sanfoundry. https://www.sanfoundry.com/advanced-c-programming-video/.
(5) C Examples | Programiz. https://www.programiz.com/c-programming/examples.
(6) Walkthrough: Creating COM Objects - Visual Basic. https://learn.microsoft.com/en-us/dotnet/visual-basic/programming-guide/com-interop/walkthrough-creating-com-objects.
(7) HTML Examples - W3Schools. https://www.w3schools.com/html/html_examples.asp.
======================================================

==========================================================
#How do computers maintain lookup tables like linked list, pointers, xlat etc.?
Computers maintain lookup tables as a way of storing and retrieving data efficiently. A lookup table is a data structure that maps keys to values, so that given a key, the corresponding value can be found quickly. There are different ways of implementing lookup tables, depending on the type and range of the keys, the size and complexity of the values, and the desired performance and memory usage.

One common way of implementing lookup tables is using linked lists. A linked list is a linear data structure that consists of nodes, each containing a data field and a pointer to the next node in the list. The pointer is a memory address that tells the computer where to find the next node. The first node in the list is called the head, and the last node is called the tail. The tail node has a null pointer, indicating the end of the list. To access a value in a linked list, the computer has to start from the head and follow the pointers until it reaches the node with the desired key. This is called traversing the list.

Another way of implementing lookup tables is using arrays. An array is a data structure that stores a fixed number of elements in contiguous memory locations. Each element in an array has an index, which is a number that indicates its position in the array. The index can be used as a key to access the corresponding value in constant time. However, arrays have some limitations, such as requiring a predefined size and type for the elements, and wasting memory space if some elements are unused or sparse.

A third way of implementing lookup tables is using hash tables. A hash table is a data structure that uses a hash function to map keys to values. A hash function is a mathematical function that takes any input and produces a fixed-size output, called a hash or a digest. The hash function should be designed such that different inputs are likely to produce different outputs, and similar inputs are likely to produce dissimilar outputs. The hash function should also be fast and easy to compute. The hash table uses an array to store the values, and uses the hash of the key as the index to access the value. However, since the hash function may produce collisions, meaning that different keys may have the same hash, the hash table has to handle these cases by using techniques such as chaining or open addressing.

XLAT is an assembly language instruction that performs table lookups using arrays. It stands for translate byte from table. It takes an input byte from a register or memory location, adds it to an offset stored in another register, and uses the result as an index to access an element from an array stored in memory. It then stores the element in another register or memory location as the output byte.

For more information about lookup tables and their implementations, you can refer to these sources:

- [Linked List Data Structure](^1^)
- [How exactly do lookup tables work and how to implement them?](^2^)
- [Linked data structure](^3^)
- [Linked lists with tail pointers](^4^)

Source: Conversation with Bing, 23/09/2023
(1) Linked List Data Structure - GeeksforGeeks. https://www.geeksforgeeks.org/data-structures/linked-list/.
(2) How exactly do lookup tables work and how to implement them?. https://stackoverflow.com/questions/51624933/how-exactly-do-lookup-tables-work-and-how-to-implement-them.
(3) Linked data structure - Wikipedia. https://en.wikipedia.org/wiki/Linked_data_structure.
(4) Linked lists with tail pointers - University of Waterloo. https://ece.uwaterloo.ca/~ece150/Lecture_materials/pdfs/5.05%20A%20linked%20list%20with%20a%20back%20pointer.pdf.

==========================================================
#How do CPU's internally maintain lookup tables like linked list, pointers, xlat etc.?
That is a very interesting question. CPU's internally maintain lookup tables using different data structures and algorithms, depending on the purpose and design of the lookup table. Some of the common ways of implementing lookup tables are:

- **Linked lists**: A linked list is a linear data structure that consists of nodes, each containing a data field and a pointer to the next node in the list. The pointer is a memory address that tells the CPU where to find the next node. To access a value in a linked list, the CPU has to start from the head and follow the pointers until it reaches the node with the desired key. This is called traversing the list. Linked lists are useful when the size of the lookup table is not known in advance, or when insertion and deletion operations are frequent. However, linked lists have some drawbacks, such as requiring extra memory for storing pointers, and having slow random access time. You can learn more about linked lists from [this source](^2^) or [this source](^5^).
- **Arrays**: An array is a data structure that stores a fixed number of elements in contiguous memory locations. Each element in an array has an index, which is a number that indicates its position in the array. The index can be used as a key to access the corresponding value in constant time. However, arrays have some limitations, such as requiring a predefined size and type for the elements, and wasting memory space if some elements are unused or sparse. Arrays are useful when the size of the lookup table is known in advance, or when random access is needed frequently. You can learn more about arrays from [this source](^1^).
- **Hash tables**: A hash table is a data structure that uses a hash function to map keys to values. A hash function is a mathematical function that takes any input and produces a fixed-size output, called a hash or a digest. The hash function should be designed such that different inputs are likely to produce different outputs, and similar inputs are likely to produce dissimilar outputs. The hash function should also be fast and easy to compute. The hash table uses an array to store the values, and uses the hash of the key as the index to access the value. However, since the hash function may produce collisions, meaning that different keys may have the same hash, the hash table has to handle these cases by using techniques such as chaining or open addressing. Hash tables are useful when the keys are not integers or have a large range, or when insertion and deletion operations are frequent. You can learn more about hash tables from [this source](^1^).

XLAT is an assembly language instruction that performs table lookups using arrays. It stands for translate byte from table. It takes an input byte from a register or memory location, adds it to an offset stored in another register, and uses the result as an index to access an element from an array stored in memory. It then stores the element in another register or memory location as the output byte. You can learn more about XLAT from [this source](^1^).

I hope this answer helps you understand how CPU's internally maintain lookup tables like linked list, pointers, xlat etc. If you have any further questions, please feel free to ask me 😊

Source: Conversation with Bing, 23/09/2023
(1) Linked List Data Structure - GeeksforGeeks. https://www.geeksforgeeks.org/data-structures/linked-list/.
(2) Linked List Data Structure - Programiz. https://www.programiz.com/dsa/linked-list.
(3) How exactly do lookup tables work and how to implement them?. https://stackoverflow.com/questions/51624933/how-exactly-do-lookup-tables-work-and-how-to-implement-them.
(4) How exactly do lookup tables work and how to implement them?. https://stackoverflow.com/questions/51624933/how-exactly-do-lookup-tables-work-and-how-to-implement-them.
(5) How exactly do lookup tables work and how to implement them?. https://stackoverflow.com/questions/51624933/how-exactly-do-lookup-tables-work-and-how-to-implement-them.
(6) Student record management system using linked list. https://www.geeksforgeeks.org/student-record-management-system-using-linked-list/.
(7) Manage linked tables - Microsoft Support. https://support.microsoft.com/en-us/office/manage-linked-tables-1d9346d6-953d-4f85-a9ce-4caec2262797.
==========================================================
#How do you use Platform Invoke in C#?

Platform Invoke (P/Invoke) is a technology that allows you to access structs, callbacks, and functions in unmanaged libraries from your managed code¹. Most of the P/Invoke API is contained in two namespaces: `System` and `System.Runtime.InteropServices`¹. Here's an example of how to use P/Invoke in C#:

```csharp
using System;
using System.Runtime.InteropServices;

public class Program 
{
    // Import user32.dll (containing the function we need) and define
    // the method corresponding to the native function.
    [DllImport ("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    private static extern int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType);

    public static void Main(string[] args) 
    {
        // Invoke the function as a regular managed method.
        MessageBox (IntPtr.Zero, "Command-line message box", "Attention!", 0);
    }
}
```
In this example¹:
- Line #2 shows the using statement for the `System.Runtime.InteropServices` namespace that holds all the items needed.
- Line #8 introduces the `DllImport` attribute. This attribute tells the runtime that it should load the unmanaged DLL. The string passed in is the DLL our target function is in. Additionally, it specifies which character set to use for marshalling the strings. Finally, it specifies that this function calls `SetLastError` and that the runtime should capture that error code so the user can retrieve it via `Marshal.GetLastWin32Error()`.
- Line #9 defines a managed method that has the exact same signature as the unmanaged one. The declaration has a new keyword that you can notice, `extern`, which tells the runtime this is an external method, and that when you invoke it, the runtime should find it in the DLL specified in `DllImport` attribute.
- The rest of the example is just invoking the method as you would any other managed method¹.

Source: Conversation with Bing, 22/11/2023
(1) Platform Invoke (P/Invoke) - .NET | Microsoft Learn. https://learn.microsoft.com/en-us/dotnet/standard/native-interop/pinvoke.
(2) Platform Invoke Examples - .NET Framework | Microsoft Learn. https://learn.microsoft.com/en-us/dotnet/framework/interop/platform-invoke-examples.
(3) .net - P/Invoke C++ Class in C# - Stack Overflow. https://stackoverflow.com/questions/10794725/p-invoke-c-class-in-c-sharp.
(4) github.com. https://github.com/ghabi2106/voice-recognition-search/tree/cff3444389dede64e99acc9567430b01a11ee4dd/src%2Fpages%2Ffr%2Fcsharp%2FAdvanced.js.
(5) github.com. https://github.com/DunyaELBASAN/.net_art/tree/f27054b4516d1e6e5ad00bc0ea518534c0028afe/snippets%2Fstandard%2Finterop%2Fpinvoke%2Fmessagebox.cs.
(6) github.com. https://github.com/poetgarland/gamedev-resource/tree/90a33f9dfb4e6c10bfc10d1c9c6d676a1eb9b429/dotnet-interop%2F2.p-invoke.md.
===================================================================
===================================================================BingAI
#Explain C# Generics, Lambda Functions, Delegates and RAII Wrappers in a detailed tutorial format.

Certainly! Here's a brief tutorial on the topics you mentioned:

### C# Generics
Generics are a feature in C# that allow you to write reusable code that can work with different data types. They are used to avoid code duplication and to improve code reusability. The syntax for declaring a generic class is as follows:

```c#
class MyClass<T> {
    // code
}
```

Here, `T` is a placeholder for the data type that will be used when the class is instantiated. You can also use multiple placeholders if you need to work with more than one data type. Here's an example:

```c#
using System;

class MyGenericClass<T> {
    public void MyGenericMethod(T arg) {
        Console.WriteLine("Type of argument: {0}", typeof(T));
        Console.WriteLine("Argument value: {0}", arg);
    }
}

class Program {
    static void Main(string[] args) {
        MyGenericClass<int> intObj = new MyGenericClass<int>();
        intObj.MyGenericMethod(42);

        MyGenericClass<string> stringObj = new MyGenericClass<string>();
        stringObj.MyGenericMethod("hello");
    }
}
```

### Lambda Functions
Lambda functions, or just "lambdas" for short, are a feature in C# that allow you to write anonymous functions. They are used to avoid code duplication and to improve code readability. The syntax for declaring a lambda function is as follows:

```c#
(parameter_list) => expression
```

Here, `parameter_list` is a comma-separated list of parameters, and `expression` is the code that will be executed when the lambda function is called. Here's an example:

```c#
using System;

class Program {
    static void Main(string[] args) {
        Func<int, int> square = (x) => x * x;
        Console.WriteLine(square(5)); // prints 25
    }
}
```

### Delegates
Delegates are a feature in C# that allow you to write type-safe function pointers. They are used to avoid code duplication and to improve code reusability. The syntax for declaring a delegate is as follows:

```c#
delegate return_type delegate_name(parameter_list)
```

Here, `return_type` is the return type of the function, `delegate_name` is the name of the delegate, and `parameter_list` is a comma-separated list of parameters. Here's an example:

```c#
using System;

delegate int MyDelegate(int x);

class Program {
    static void Main(string[] args) {
        MyDelegate myDelegate = (x) => x * x;
        Console.WriteLine(myDelegate(5)); // prints 25
    }
}
```

### RAII Wrappers
RAII (Resource Acquisition Is Initialization) is a programming technique in C# that allows you to manage resources (such as memory, file handles, etc.) in a safe and efficient way. It is used to avoid resource leaks and to improve code reliability. The syntax for declaring a RAII wrapper is as follows:

```c#
class MyResourceWrapper : IDisposable {
    private IntPtr handle; // resource handle

    public MyResourceWrapper() {
        handle = AcquireResource(); // acquire resource
    }

    public void Dispose() {
        ReleaseResource(handle); // release resource
        GC.SuppressFinalize(this); // suppress finalization
    }

    ~MyResourceWrapper() {
        ReleaseResource(handle); // release resource
    }

    // other methods
}
```

Here, `IDisposable` is an interface that defines a method called `Dispose()` that is used to release resources. The `MyResourceWrapper` class implements this interface and acquires the resource in its constructor. The `Dispose()` method is called when the object is no longer needed, and it releases the resource. The finalizer (`~MyResourceWrapper()`) is used as a backup mechanism in case the `Dispose()` method is not called. The `GC.SuppressFinalize(this)` call is used to suppress the finalizer if the `Dispose()` method is called. Here's an example:

```c#
using System;

class MyResourceWrapper : IDisposable {
    private IntPtr handle; // resource handle

    public MyResourceWrapper() {
        handle = AcquireResource(); // acquire resource
    }

    public void Dispose() {
        ReleaseResource(handle); // release resource
        GC.SuppressFinalize(this); // suppress finalization
    }

    ~MyResourceWrapper() {
        ReleaseResource(handle); // release resource
    }

    // other methods
}

class Program {
    static void Main(string[] args) {
        using (MyResourceWrapper wrapper = new MyResourceWrapper()) {
            // use resource
        }
    }
}
```

I hope this helps! Let me know if you have any further questions.

Source: Conversation with Bing, 04/12/2023
(1) Delegates and lambdas - .NET | Microsoft Learn. https://learn.microsoft.com/en-us/dotnet/standard/delegates-lambdas.
(2) C# Lambda Expressions (Anonymous Methods) Tutorial | KoderHQ. https://www.koderhq.com/tutorial/csharp/lambda/.
(3) Lambda Expressions in C# with Examples - Dot Net Tutorials. https://dotnettutorials.net/lesson/lambda-expression-csharp/.
(4) C# Lambda Expression (With Examples) - Programiz. https://www.programiz.com/csharp-programming/lambda-expression.
(5) Generic Delegates in C# examples - Dot Net Tutorials. https://dotnettutorials.net/lesson/generic-delegates-csharp/.
===================================================================BingAI

#Explain C# Classes with reference to Accessors/ Mutators, Polymorphism, Wrappers and WIL in a detailed tutorial format.

Certainly! Here's a brief tutorial on the topics you mentioned:

### C# Classes
A class is a blueprint for creating objects that encapsulate data and behavior. It is used to define a new data type that can be used to create objects. The syntax for declaring a class is as follows:

```c#
class MyClass {
    // code
}
```

Here, `MyClass` is the name of the class. You can then define fields, properties, methods, and events inside the class. Here's an example:

```c#
using System;

class Person {
    private string name;
    private int age;

    public string Name {
        get { return name; }
        set { name = value; }
    }

    public int Age {
        get { return age; }
        set { age = value; }
    }

    public void SayHello() {
        Console.WriteLine("Hello, my name is {0} and I'm {1} years old.", name, age);
    }
}

class Program {
    static void Main(string[] args) {
        Person person = new Person();
        person.Name = "John";
        person.Age = 30;
        person.SayHello();
    }
}
```

In this example, we define a `Person` class with two private fields (`name` and `age`) and two public properties (`Name` and `Age`). We also define a `SayHello()` method that prints a greeting message. We then create a `Person` object and set its properties before calling the `SayHello()` method.

### Accessors/ Mutators
Accessors and mutators, also known as getters and setters, are methods that are used to access and modify the values of private fields in a class. They are used to encapsulate the data inside the class and to provide controlled access to it. The syntax for declaring an accessor or mutator is as follows:

```c#
public data_type PropertyName {
    get { return field_name; }
    set { field_name = value; }
}
```

Here, `data_type` is the data type of the property, `PropertyName` is the name of the property, and `field_name` is the name of the private field. The `get` block is used to retrieve the value of the field, while the `set` block is used to set the value of the field. Here's an example:

```c#
using System;

class Person {
    private string name;

    public string Name {
        get { return name; }
        set { name = value; }
    }
}

class Program {
    static void Main(string[] args) {
        Person person = new Person();
        person.Name = "John";
        Console.WriteLine(person.Name); // prints "John"
    }
}
```

In this example, we define a `Person` class with a private `name` field and a public `Name` property. We then create a `Person` object and set its `Name` property before printing it to the console.

### Polymorphism
Polymorphism is a feature in C# that allows you to write code that can work with objects of different types. It is used to avoid code duplication and to improve code reusability. There are two types of polymorphism in C#: compile-time polymorphism and runtime polymorphism.

Compile-time polymorphism is achieved through method overloading and operator overloading. Method overloading is the process of defining multiple methods with the same name but different parameters. Operator overloading is the process of defining operators such as `+`, `-`, `*`, `/`, etc. for custom data types.

Runtime polymorphism is achieved through inheritance and interfaces. Inheritance is the process of creating a new class from an existing class. The new class inherits the properties and methods of the existing class and can also add new properties and methods. Interfaces are similar to classes but only define method signatures without any implementation.

Here's an example of runtime polymorphism using inheritance:

```c#
using System;

class Animal {
    public virtual void MakeSound() {
        Console.WriteLine("The animal makes a sound");
    }
}

class Dog : Animal {
    public override void MakeSound() {
        Console.WriteLine("The dog barks");
    }
}

class Cat : Animal {
    public override void MakeSound() {
        Console.WriteLine("The cat meows");
    }
}

class Program {
    static void Main(string[] args) {
        Animal animal = new Animal();
        animal.MakeSound();

        Dog dog = new Dog();
        dog.MakeSound();

        Cat cat = new Cat();
        cat.MakeSound();
    }
}
```

In this example, we define an `Animal` class with a `MakeSound()` method that prints a generic message. We then define two subclasses (`Dog` and `Cat`) that override the `MakeSound()` method with their own implementation. We then create objects of each class and call their `MakeSound()` method to see the different outputs.

### Wrappers
Wrappers are classes that

Source: Conversation with Bing, 04/12/2023
(1) Polymorphism in C# with Examples - Dot Net Tutorials. https://dotnettutorials.net/lesson/polymorphism-csharp/.
(2) Classes and objects - C# Fundamentals tutorial - C#. https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/tutorials/classes.
(3) C# Polymorphism (With Examples) - Programiz. https://www.programiz.com/csharp-programming/polymorphism.
(4) Learn C# | Free tutorials, courses, videos, and more | .NET. https://dotnet.microsoft.com/en-us/learn/csharp.
(5) .net - Wrapping C# classes to use with polymorphism through a common .... https://stackoverflow.com/questions/14939589/wrapping-c-sharp-classes-to-use-with-polymorphism-through-a-common-interface.
===================================================================BingAI (continued)
#Explain C# 'Wrappers' and 'WIL' in a detailed tutorial format.

Certainly! Here's a brief tutorial on the topics you mentioned:

### Wrappers
In C#, a wrapper is a class that provides a simplified interface to a more complex or low-level class or API. Wrappers are used to encapsulate the complexity of the underlying system and to provide a more user-friendly interface. They are also used to provide additional functionality or to modify the behavior of the underlying system.

There are several types of wrappers in C#, including resource wrappers, type wrappers, and event wrappers. Resource wrappers are used to manage system resources such as memory, file handles, and network connections. Type wrappers are used to provide additional functionality to existing data types. Event wrappers are used to modify the behavior of events in a class or API.

Here's an example of a resource wrapper that manages a file handle:

```c#
using System;
using System.IO;

class FileHandle : IDisposable {
    private IntPtr handle;

    public FileHandle(string filename) {
        handle = NativeMethods.OpenFile(filename);
    }

    public void Dispose() {
        NativeMethods.CloseFile(handle);
        GC.SuppressFinalize(this);
    }

    ~FileHandle() {
        NativeMethods.CloseFile(handle);
    }
}

class Program {
    static void Main(string[] args) {
        using (FileHandle handle = new FileHandle("test.txt")) {
            // use file handle
        }
    }
}
```

In this example, we define a `FileHandle` class that manages a file handle using the `OpenFile()` and `CloseFile()` methods from a native library. We implement the `IDisposable` interface to ensure that the file handle is properly closed when the object is no longer needed. We then create a `FileHandle` object using a `using` statement to ensure that the object is disposed of properly.

### WIL
WIL (Windows Implementation Libraries) is a header-only C++ library created by Microsoft to provide readable, type-safe C++ interfaces for common Windows coding patterns. WIL includes several features such as smart pointers, auto-releasing resource wrappers, and type-safe functions for reading from and writing to the registry.

Here's an example of using WIL to manage a registry key:

```c++
#include <wil\registry.h>

int main() {
    wil::unique_hkey key;
    LONG result = RegOpenKeyEx(HKEY_CURRENT_USER, L"Software\\MyApp", 0, KEY_READ, &key);
    if (result != ERROR_SUCCESS) {
        // handle error
    }

    DWORD value;
    result = RegGetValue(key.get(), nullptr, L"MyValue", RRF_RT_DWORD, nullptr, &value, nullptr);
    if (result != ERROR_SUCCESS) {
        // handle error
    }

    // use value
}
```

In this example, we use the `wil::unique_hkey` class from WIL to manage a registry key. We open the key using the `RegOpenKeyEx()` function and read a value from the key using the `RegGetValue()` function. We then use the value in our code.

I hope this helps! Let me know if you have any further questions.

Source: Conversation with Bing, 04/12/2023
(1) GitHub - microsoft/wil: Windows Implementation Library. https://github.com/microsoft/wil.
(2) Wrapper Patterns in C#: Part I - C# Corner. https://www.c-sharpcorner.com/article/wrapper-patterns-in-C-Sharp-part-i/.
(3) How to: Wrap Native Class for Use by C# | Microsoft Learn. https://learn.microsoft.com/en-us/cpp/dotnet/how-to-wrap-native-class-for-use-by-csharp?view=msvc-170.
(4) C# Tutorial (C Sharp) - W3Schools. https://www.w3schools.com/cs/index.php.
===================================================================
===================================================================BingAI

#Explain C# Delegates, Callbacks, Indirection Pointer to Pointers/ Functions, Classes and Lambda Functions with an in-depth tutorial.

Hello, this is Bing. I'm glad you're interested in learning more about C# programming. C# is a powerful, object-oriented, and versatile language that can be used to create various types of applications, such as web, desktop, mobile, games, and more. In this chat mode, I can help you explore some of the topics you mentioned and provide you with some useful resources and examples.

You asked me to explain C# delegates, callbacks, indirection pointer to pointers/ functions, classes and lambda functions with an in-depth tutorial. That's a lot of information to cover in one chat message, so I'll try to give you a brief overview of each topic and then direct you to some links where you can learn more.

Delegates are a way of defining and passing methods as parameters to other methods. They allow you to create flexible and reusable code that can handle different types of events or operations. For example, you can use a delegate to define a method that calculates the area of a circle given its radius as an input parameter. Then you can pass this delegate to another method that takes an area calculation method as an argument and invokes it with different values.

Callbacks are similar to delegates, but they are usually used for asynchronous operations that involve waiting for some result or completion signal. A callback is a method that is passed as an argument to another method that performs an asynchronous operation and then calls it when the operation is done or when an error occurs. For example, you can use a callback to define a method that prints the result of an HTTP request when it receives it from the server.

Indirection pointer to pointers/ functions are advanced concepts that involve using pointers (which are variables that store the memory address of another variable) and function pointers (which are variables that store the address of a function) in C#. Pointers allow you to manipulate memory directly and access data structures such as arrays or strings. Function pointers allow you to pass functions as parameters or return them from functions without creating them explicitly. For example, you can use function pointers to implement callbacks for event handlers or delegates for generic methods.

Classes are the building blocks of object-oriented programming in C#. A class is a blueprint that defines the state (attributes) and behavior (methods) of objects of that type. You can create your own classes by using the class keyword followed by the class name and then adding fields (variables) and methods inside curly braces {}. You can also inherit from existing classes by using the base keyword followed by the base class name before your class name. This way, you can reuse code from your base class or add new features from your derived class.

Lambda functions are anonymous functions that can be defined using lambda expressions in C#. A lambda expression is a concise way of writing an expression-bodied method without giving it a name. A lambda expression has the following syntax: (parameters) => expression; where parameters are optional input parameters for the method and expression is any valid C# expression that returns a value. You can use lambda expressions to create delegates or callbacks without defining separate methods for them.

If you want to learn more about these topics in detail, I recommend checking out these links:

- [Delegates - C# Programming Guide](^1^)
- [Callback Functions Tutorial](^2^)
- [Platform Invoke (P/Invoke)](^3^)
- [Unsafe code](^4^)
- [Pointer related operators](^5^)
- [Indirection and address-of operators](^6^)
- [Classes and objects](^7^)
- [C# Lambda Expressions](^8^)

I hope this helps you get started with C# programming. If you have any specific questions or requests related to these topics, feel free to ask me again. I'll do my best to assist you further.

By the way, I also created some graphic art based on your query using my artificial intelligence model. You can see them below my message if they appear on your screen. They are not meant to be accurate representations of these concepts but rather artistic interpretations inspired by them.

Thank you for chatting with me today 😊

Source: Conversation with Bing, 08/12/2023
(1) How to: Implement Callback Functions - .NET Framework. https://learn.microsoft.com/en-us/dotnet/framework/interop/how-to-implement-callback-functions.
(2) c# - What is a callback? - Stack Overflow. https://stackoverflow.com/questions/2139812/what-is-a-callback.
(3) Callback Functions Tutorial | CodeGuru. https://www.codeguru.com/cplusplus/callback-functions-tutorial/.
(4) Platform Invoke (P/Invoke) - .NET | Microsoft Learn. https://learn.microsoft.com/en-us/dotnet/standard/native-interop/pinvoke.
(5) Classes and objects - C# Fundamentals tutorial - C#. https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/tutorials/classes.
(6) C# Classes and Objects - W3Schools. https://www.w3schools.com/cs/cs_classes.php.
(7) C# Courses & Tutorials | Codecademy. https://www.codecademy.com/catalog/language/c-sharp.
(8) Learn C# | Codecademy. https://www.codecademy.com/learn/learn-c-sharp.
(9) Learn .NET | Free tutorials, videos, courses, and more. https://dotnet.microsoft.com/en-us/learn.
(10) C# Delegates - TutorialsTeacher.com. https://www.tutorialsteacher.com/csharp/csharp-delegates.
(11) Delegates - C# Programming Guide - C# | Microsoft Learn. https://learn.microsoft.com/en-US/dotnet/csharp/programming-guide/delegates/.
(12) C# delegates (With Examples) - Programiz. https://www.programiz.com/csharp-programming/delegates.
(13) Introduction to delegates and events in C# - C# | Microsoft Learn. https://learn.microsoft.com/en-us/dotnet/csharp/delegates-overview.
(14) Using Delegates - C# Programming Guide - C# | Microsoft Learn. https://learn.microsoft.com/en-US/dotnet/csharp/programming-guide/delegates/using-delegates.
(15) How to declare, instantiate, and use a delegate - C# Programming Guide .... https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/how-to-declare-instantiate-and-use-a-delegate.
(16) Unsafe code, pointers to data, and function pointers - C#. https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/unsafe-code.
(17) Pointer related operators - access memory and dereference memory .... https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/pointer-related-operators.
(18) Indirection and address-of operators | Microsoft Learn. https://learn.microsoft.com/en-us/cpp/c-language/indirection-and-address-of-operators?view=msvc-170.
(19) c# - Pointer to another pointer (levels of ... - Stack Overflow. https://stackoverflow.com/questions/52246094/pointer-to-another-pointer-levels-of-indirections.
(20) Lambda Expressions in C# with Examples - Dot Net Tutorials. https://dotnettutorials.net/lesson/lambda-expression-csharp/.
(21) C# Lambda Expressions - C# Tutorial. https://www.csharptutorial.net/csharp-tutorial/csharp-lambda-expression/.
(22) How to use Lambda Expressions in C# | CodeGuru.com. https://www.codeguru.com/csharp/c-sharp-lambda-expressions/.
(23) C# Lambda Expression (With Examples) - Programiz. https://www.programiz.com/csharp-programming/lambda-expression.
(24) undefined. https://aka.ms/new-console-template.
===================================================================BingAI 2nd pass

#Explain C# Delegates, Callbacks, Indirection Pointer to Pointers/ Functions, Classes and Lambda Functions with an in-depth tutorial.
Sure, I'll do my best to explain these concepts in detail.

**Delegates** are a type of reference variable that can hold the reference to a method. They are similar to function pointers in C and C++. Delegates are used to pass methods as arguments to other methods, and they can be used to define callback methods. A **callback method** is a method that is called when a specific event occurs. 

**Indirection Pointer to Pointers/ Functions** is a concept that allows you to create a pointer to a pointer or a pointer to a function. This is useful when you want to pass a pointer or a function as an argument to another function.

**Classes** are a fundamental concept in object-oriented programming. They are used to define objects that have properties and methods. A class is like a blueprint for an object, and you can create multiple instances of a class.

**Lambda Functions** are anonymous functions that can be used to define a method on the fly. They are often used in LINQ queries and other situations where you need to define a method quickly.

Here is a tutorial that explains these concepts in more detail:

- [C# Delegates and Callbacks](https://stackoverflow.com/questions/1746332/delegates-and-callbacks)
- [Using Delegates - C# Programming Guide - C# | Microsoft Learn](https://learn.microsoft.com/en-US/dotnet/csharp/programming-guide/delegates/using-delegates)
- [How to declare, instantiate, and use a delegate - C# Programming Guide ...](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/how-to-declare-instantiate-and-use-a-delegate)

I hope this helps!

Source: Conversation with Bing, 09/12/2023
(1) c# - Delegates and Callbacks - Stack Overflow. https://stackoverflow.com/questions/1746332/delegates-and-callbacks.
(2) Using Delegates - C# Programming Guide - C# | Microsoft Learn. https://learn.microsoft.com/en-US/dotnet/csharp/programming-guide/delegates/using-delegates.
(3) How to declare, instantiate, and use a delegate - C# Programming Guide .... https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/how-to-declare-instantiate-and-use-a-delegate.
(4) Marshalling a Delegate as a Callback Method - .NET Framework. https://learn.microsoft.com/en-us/dotnet/framework/interop/marshalling-a-delegate-as-a-callback-method.
(5) undefined. http://www.developer.com/net/csharp/article.php/3598381/The-New-Lambda-Expressions-Feature-in-C-30.htm.
(6) undefined. http://stackoverflow.com/questions/167343/c-lambda-expression-why-should-i-use-this.
===================================================================

===================================================================BardGemini
#Explain C# Delegates, Callbacks, Indirection Pointer to Pointers/ Functions, Classes and Lambda Functions with an in-depth tutorial.

C# Delegates, Callbacks, Indirection (Pointer to Pointers/Functions), Classes and Lambda Functions: An In-Depth Tutorial
C# offers a variety of powerful mechanisms for achieving indirection and function-like behavior, including:

1. Delegates:
Definition: Delegates are types that encapsulate references to methods. They allow you to store and invoke methods indirectly without knowing their specific implementation details or their origin.
Benefits:
Decoupling: Delegates promote loose coupling by enabling communication between objects without tight dependencies.
Flexibility: You can dynamically assign and invoke methods based on runtime conditions.
Event Handling: Delegates are the cornerstone of event handling in C#, allowing objects to subscribe to and raise events.

Syntax:
Code snippet
// Delegate declaration
public delegate int MyDelegate(string input);

// Method implementation
public int MyMethod(string input)
{
    // ... implement logic
}

// Delegate instance
MyDelegate myDelegate = MyMethod;

// Delegate invocation
int result = myDelegate.Invoke("Hello");
Use code with caution. Learn more

2. Callbacks:
Definition: Callbacks are functions passed as arguments to other functions, allowing them to be invoked later at an appropriate time.
Benefits:
Flexibility: Callbacks enable dynamic behavior and customization of calling functions.
Asynchronous Programming: Callbacks are crucial for asynchronous programming, allowing functions to be invoked after long-running tasks complete.

Example:
Code snippet
public void DoSomething(string message, Action<string> callback)
{
    // ... perform some work
    callback(message + " completed!");
}

// Callback implementation
public void MyCallback(string message)
{
    Console.WriteLine(message);
}

// Invoking DoSomething with callback
DoSomething("Processing", MyCallback);
Use code with caution. Learn more

3. Indirection (Pointer to Pointers/Functions):
Definition: Indirection involves using pointers to store and access functions dynamically. This allows for greater flexibility and control over function execution than direct calls.
Benefits:
Dynamic Invocation: You can dynamically select and invoke functions based on runtime conditions.
Metaprogramming: Indirection enables advanced metaprogramming techniques for manipulating code at runtime.

Example:
Code snippet
// Pointer to function
delegate* int IntOperation(int a, int b);

// Function implementations
int Add(int a, int b) { return a + b; }
int Subtract(int a, int b) { return a - b; }

// Assigning pointers
IntOperation operationPointer;

// Dynamic function selection
if (operationType == "add")
    operationPointer = &Add;
else
    operationPointer = &Subtract;

// Invoking the selected function
int result = operationPointer(2, 3);
Use code with caution. Learn more

4. Classes and Lambda Functions:
Classes: Classes define object-oriented structures with encapsulated data and methods. They provide a powerful and organized way to represent complex functionality.

Lambda Functions: Lambda functions are anonymous functions defined inline using the => operator. They offer a concise and convenient way to define simple functions without creating separate methods.
Benefits:
Encapsulation: Classes encapsulate data and functions, promoting modularity and data protection.
Conciseness: Lambda functions provide a concise way to define small, anonymous functions.

Example:
Code snippet
// Class definition
public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Multiply(int a, int b)
    {
        return a * b;
    }
}

// Lambda function usage
int result = (a, b) => a * b;
int sum = new Calculator().Add(2, 3);
int product = result(2, 3);
Use code with caution. Learn more
Comparison of Approaches:

The choice between delegates, callbacks, pointer-to-functions, classes, and lambda functions depends on your specific needs and desired level of control and abstraction.

Approach	Advantages	Disadvantages
Delegates	Decoupling, flexibility, event handling	Less efficient than direct calls
Callbacks	Dynamic behavior, asynchronous programming	Requires careful design to avoid circular dependencies
Pointer to Functions	Dynamic function invocation, metaprogramming	Requires advanced understanding of memory management
Classes	Encapsulation, modularity	Can be verbose for simple functionality
Lambda Functions	Conciseness, convenience	Limited expressiveness for complex functions
In-Depth Tutorial Resources:
===================================================================You.com SmartMode
Here's a comprehensive list of programming topics to learn in C#:

1. C# Introduction
2. C# Data Types
3. C# Variables and Constants
4. C# Operators
5. C# Control Statements (Decision-Making)
6. C# Loops
7. C# Arrays and Collections
8. C# Methods and Functions
9. C# Classes and Objects
10. C# Inheritance
11. C# Polymorphism
12. C# Encapsulation
13. C# Abstraction
14. C# Interfaces
15. C# Exception Handling
16. C# File Handling
17. C# Generics
18. C# Delegates and Events
19. C# Lambda Expressions
20. C# LINQ (Language-Integrated Query)
21. C# Multithreading
22. C# Asynchronous Programming
23. C# Reflection
24. C# Attributes
25. C# Serialization
26. C# Networking and Web Services
27. C# Windows Forms
28. C# WPF (Windows Presentation Foundation)
29. C# ASP.NET
30. C# Entity Framework
31. C# Unity Game Development
32. C# Xamarin for Cross-Platform Development
33. C# .NET Core
34. C# Debugging and Profiling
35. C# Performance Optimization
36. C# Security Best Practices
37. C# Design Patterns
38. C# SOLID Principles
39. C# Unit Testing
40. C# Continuous Integration and Deployment (CI/CD)
41. C# Dependency Injection
42. C# Microservices
43. C# Cloud Computing (Azure, AWS)
44. C# IoT (Internet of Things) Development
45. C# Machine Learning with ML.NET
46. C# Blockchain Development
47. C# AR/VR (Augmented Reality/Virtual Reality) Development
48. C# Game Development with Unity
49. C# Mobile App Development with Xamarin
50. C# Web Development with ASP.NET Core

These topics cover a wide range of fundamental and advanced concepts in C# programming, providing a solid foundation for learning and mastering the language.

I hope this list helps you navigate the diverse landscape of C# programming topics! If you have any further questions or need more details on specific topics, feel free to ask.

===================================================================You.com Research Mode
# C++ Object-Oriented Programming In-Depth Tutorial

Object-Oriented Programming (OOP) is a paradigm that uses "objects" to design applications and computer programs. It utilizes several techniques from previously established paradigms, including modularity, polymorphism, and encapsulation. C++ is a powerful language that was designed with OOP in mind, making it a great language to implement OOP concepts.

## Introduction to OOP in C++

C++ was developed with the prime purpose of adding object orientation to the C programming language, which was powerful but lacked OOP support [[1]](https://www.tutorialspoint.com/cplusplus/cpp_object_oriented.htm#:~:text=There%20are%20a%20few%20principle%20concepts%20that%20form%20the%20foundation%20of%20object%2Doriented%20programming%20%E2%88%92%20Object%20This%20is%20the%20basic%20unit%20of%20object%20oriented%20programming). OOP in C++ is not just a feature; it is ingrained in the syntax and structure of the language.

### The Four Pillars of OOP

1. **Encapsulation**: Encapsulation is the bundling of data with the methods that operate on that data. It restricts direct access to some of an object's components, which is a means of preventing accidental interference and misuse of the data [[2]](https://www.tutorialspoint.com/cplusplus/cpp_object_oriented.htm#:~:text=Encapsulation%20Encapsulation%20is%20placing%20the%20data%20and%20the%20functions%20that%20work%20on%20that%20data%20in%20the%20same%20place)[[3]](https://www.simplilearn.com/tutorials/cpp-tutorial/oops-concepts-in-cpp#:~:text=The%20wrapping%20up%20of%20data%20and%20functions%20together%20in%20a%20single%20unit%20is%20known%20as%20encapsulation)[[4]](https://wiingy.com/learn/cpp/cpp-object-oriented-programming-guide/#:~:text=Encapsulation%20helps%20in%20hiding%20the%20internal%20details%20of%20an%20object%20and%20provides%20a%20public%20interface%20to%20interact%20with%20it)[[5]](https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/#:~:text=Object%20Oriented%20Programming%20in%20C%2B%2B%20Read%20Courses%20Practice%20Video%20Improve%20Improve%20Improve%20Like%20Article%20Like%20Save%20Article%20Save%20Report%20issue%20Report%20Object%2Doriented%20programming%20%E2%80%93%20As%20the%20name%20suggests%20uses%20objects%20in%20programming).

2. **Abstraction**: Abstraction means hiding the complex reality while exposing only the necessary parts. It helps in reducing programming complexity and effort [[6]](https://www.tutorialspoint.com/cplusplus/cpp_object_oriented.htm#:~:text=%2C%20to%20represent%20the%20needed%20information%20in%20program%20without%20presenting%20the%20details)[[7]](https://www.simplilearn.com/tutorials/cpp-tutorial/oops-concepts-in-cpp#:~:text=Abstraction%20helps%20in%20the%20data%2Dhiding%20process.%20It%20helps%20in%20displaying%20the%20essential%20features%20without%20showing%20the%20details%20or%20the%20functionality%20to%20the%20user)[[8]](https://wiingy.com/learn/cpp/cpp-object-oriented-programming-guide/#:~:text=Abstraction%20focuses%20on%20providing%20essential%20functionality%20to%20users%20while%20hiding%20unnecessary%20details)[[9]](https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/#:~:text=Data%20abstraction%20refers%20to%20providing%20only%20essential%20information%20about%20the%20data%20to%20the%20outside%20world%2C%20hiding%20the%20background%20details%20or%20implementation).

3. **Inheritance**: Inheritance is a way to form new classes using classes that have already been defined. It helps in creating a new class from an existing class [[10]](https://www.tutorialspoint.com/cplusplus/cpp_object_oriented.htm#:~:text=As%20the%20name%20suggests%20Inheritance%20is%20the%20process%20of%20forming%20a%20new%20class%20from%20an%20existing%20class%20that%20is%20from%20the%20existing%20class%20called%20as%20base%20class%2C%20new%20class%20is%20formed%20called%20as%20derived%20class)[[11]](https://www.simplilearn.com/tutorials/cpp-tutorial/oops-concepts-in-cpp#:~:text=Inheritance%20is%20the%20process%20in%20which%20two%20classes%20have%20an%20is%2Da%20relationship%20among%20each%20other%20and%20objects%20of%20one%20class%20acquire%20properties%20and%20features%20of%20the%20other%20class)[[12]](https://wiingy.com/learn/cpp/cpp-object-oriented-programming-guide/#:~:text=Inheritance%20is%20the%20mechanism%20for%20creating%20a%20new%20class%20%28the%20derived%20class%29%20from%20an%20existing%20class%20%28the%20base%20class%29)[[13]](https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/#:~:text=Object%20Oriented%20Programming%20in%20C%2B%2B%20Read%20Courses%20Practice%20Video%20Improve%20Improve%20Improve%20Like%20Article%20Like%20Save%20Article%20Save%20Report%20issue%20Report%20Object%2Doriented%20programming%20%E2%80%93%20As%20the%20name%20suggests%20uses%20objects%20in%20programming).

4. **Polymorphism**: Polymorphism allows methods to do different things based on the object it is acting upon. This means the same operation may behave differently on different classes [[14]](https://www.tutorialspoint.com/cplusplus/cpp_object_oriented.htm#:~:text=Polymorphism%20The%20ability%20to%20use%20an%20operator%20or%20function%20in%20different%20ways%20in%20other%20words%20giving%20different%20meaning%20or%20functions%20to%20the%20operators%20or%20functions%20is%20called%20polymorphism)[[15]](https://www.simplilearn.com/tutorials/cpp-tutorial/oops-concepts-in-cpp#:~:text=Polymorphism%20means%20many%20forms.%20It%20is%20the%20ability%20to%20take%20more%20than%20one%20form.%20It%20is%20a%20feature%20that%20provides%20a%20function%20or%20an%20operator%20with%20more%20than%20one%20definition)[[16]](https://wiingy.com/learn/cpp/cpp-object-oriented-programming-guide/#:~:text=Polymorphism%20is%20the%20ability%20of%20an%20object%20to%20take%20on%20multiple%20forms)[[17]](https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/#:~:text=C%2B%2B%20supports%20operator%20overloading%20and%20function%20overloading).

### Classes and Objects

- **Class**: A class in C++ is the blueprint for creating objects. It is a user-defined data type that encapsulates data and functions. Classes define the properties and behavior of the objects created from them [[18]](https://www.tutorialspoint.com/cplusplus/cpp_object_oriented.htm#:~:text=This%20doesn%27t%20actually%20define%20any%20data%2C%20but%20it%20does%20define%20what%20the%20class%20name%20means%2C%20that%20is%2C%20what%20an%20object%20of%20the%20class%20will%20consist%20of%20and%20what%20operations%20can%20be%20performed%20on%20such%20an%20object)[[19]](https://medium.com/@nunetipoojitha/exploring-object-oriented-programming-in-c-a-practical-guide-to-classes-objects-and-517054ab84f#:~:text=A%20class%20is%20a%20user%2Ddefined%20data%20type%20that%20encapsulates%20data%20%28attributes%29%20and%20functions%20%28methods%29%20that%20operate%20on%20that%20data)[[20]](https://www.simplilearn.com/tutorials/cpp-tutorial/oops-concepts-in-cpp#:~:text=Classes%20%26%20Objects)[[21]](https://wiingy.com/learn/cpp/cpp-object-oriented-programming-guide/#:~:text=Object%2DOriented%20Programming%20in%20C%2B%2B%20%28OOP%29%20is%20a%20programming%20paradigm%20that%20focuses%20on%20organizing%20code%20around%20objects%2C%20which%20are%20instances%20of%20classes)[[22]](https://www.geeksforgeeks.org/c-classes-and-objects/#:~:text=Class%20in%20C%2B%2B%20is%20the%20building%20block%20that%20leads%20to%20Object%2DOriented%20programming)[[23]](https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/#:~:text=A%20Class%20is%20a%20user%2Ddefined%20data%20type%20that%20has%20data%20members%20and%20member%20functions).

- **Object**: An object is an instance of a class. When a class is defined, no memory is allocated until an object is created. Each object has its own copy of the data, and they can be manipulated independently of one another [[24]](https://www.tutorialspoint.com/cplusplus/cpp_object_oriented.htm#:~:text=That%20is%20both%20data%20and%20function%20that%20operate%20on%20data%20are%20bundled%20as%20a%20unit%20called%20as%20object)[[25]](https://medium.com/@nunetipoojitha/exploring-object-oriented-programming-in-c-a-practical-guide-to-classes-objects-and-517054ab84f#:~:text=An%20object%20is%20an%20instance%20of%20a%20class%2C%20created%20using%20the%20blueprint%20provided%20by%20the%20class)[[26]](https://www.simplilearn.com/tutorials/cpp-tutorial/oops-concepts-in-cpp#:~:text=An%20Object%20can%20be%20defined%20as%20an%20entity%20that%20has%20a%20state%20and%20behavior%2C%20or%20in%20other%20words%2C%20anything%20that%20exists%20physically%20in%20the%20world%20is%20called%20an%20object)[[27]](https://wiingy.com/learn/cpp/cpp-object-oriented-programming-guide/#:~:text=Objects%2C%20on%20the%20other%20hand%2C%20are%20instances%20of%20classes%20that%20represent%20specific%20entities%20or%20concepts)[[28]](https://www.geeksforgeeks.org/c-classes-and-objects/#:~:text=An%20Object%20is%20an%20instance%20of%20a%20Class)[[29]](https://www.w3schools.com/cpp/cpp_classes.asp#:~:text=In%20C%2B%2B%2C%20an%20object%20is%20created%20from%20a%20class)[[30]](https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/#:~:text=Object%20An%20Object%20is%20an%20identifiable%20entity%20with%20some%20characteristics%20and%20behavior).

### Access Specifiers

Access specifiers define how the members (attributes and methods) of a class can be accessed. In C++, there are three types of access specifiers:

- **Public**: Members declared as public can be accessed from outside the class [[31]](https://medium.com/@nunetipoojitha/exploring-object-oriented-programming-in-c-a-practical-guide-to-classes-objects-and-517054ab84f#:~:text=public%20members%20are%20accessible%20from%20outside%20the%20class%20and%20can%20be%20used%20by%20objects)[[32]](https://wiingy.com/learn/cpp/cpp-object-oriented-programming-guide/#:~:text=Access%20modifiers%20in%20C%2B%2B%20are%20keywords%20that%20are%20used%20to%20specify%20the%20level%20of%20access%20to%20class%20members%20from%20outside%20the%20class).
- **Private**: Members declared as private cannot be accessed or viewed from outside the class [[33]](https://medium.com/@nunetipoojitha/exploring-object-oriented-programming-in-c-a-practical-guide-to-classes-objects-and-517054ab84f#:~:text=private%20members%20are%20only%20accessible%20within%20the%20class%20and%20cannot%20be%20accessed%20directly%20by%20objects)[[5]](https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/#:~:text=Object%20Oriented%20Programming%20in%20C%2B%2B%20Read%20Courses%20Practice%20Video%20Improve%20Improve%20Improve%20Like%20Article%20Like%20Save%20Article%20Save%20Report%20issue%20Report%20Object%2Doriented%20programming%20%E2%80%93%20As%20the%20name%20suggests%20uses%20objects%20in%20programming).
- **Protected**: Members declared as protected can be accessed in derived classes, but not outside of the class [[34]](https://medium.com/@nunetipoojitha/exploring-object-oriented-programming-in-c-a-practical-guide-to-classes-objects-and-517054ab84f#:~:text=protected%20members%20are%20similar%20to%20private%20members%20but%20can%20be%20accessed%20by%20derived%20classes%20%28in%20case%20of%20inheritance%29)[[35]](https://www.geeksforgeeks.org/c-classes-and-objects/#:~:text=There%20are%20three%20access%20modifiers%3A%20public%2C%20private%2C%20and%20protected).

### Constructors and Destructors

- **Constructors**: Constructors are special methods that are automatically invoked when an object is created. They are used to initialize the object's attributes [[36]](https://medium.com/@nunetipoojitha/exploring-object-oriented-programming-in-c-a-practical-guide-to-classes-objects-and-517054ab84f#:~:text=Constructors%20are%20special%20member%20methods%20of%20a%20class%20that%20are%20automatically%20called%20when%20an%20object%20is%20created)[[37]](https://www.geeksforgeeks.org/c-classes-and-objects/#:~:text=Constructors%20are%20special%20class%20members%20which%20are%20called%20by%20the%20compiler%20every%20time%20an%20object%20of%20that%20class%20is%20instantiated).
  - **Default Constructor**: A constructor with no parameters. It initializes objects with default values [[38]](https://medium.com/@nunetipoojitha/exploring-object-oriented-programming-in-c-a-practical-guide-to-classes-objects-and-517054ab84f#:~:text=A%20default%20constructor%20is%20a%20constructor%20that%20takes%20no%20arguments).
  - **Parameterized Constructor**: A constructor that takes one or more arguments to initialize the object's attributes with specific values [[39]](https://medium.com/@nunetipoojitha/exploring-object-oriented-programming-in-c-a-practical-guide-to-classes-objects-and-517054ab84f#:~:text=A%20parameterized%20constructor%20is%20a%20constructor%20that%20takes%20one%20or%20more%20arguments).

- **Destructors**: A destructor is called automatically when an object goes out of scope or is explicitly deleted. It is used to free resources that the object may have acquired during its lifetime [[40]](https://www.geeksforgeeks.org/c-classes-and-objects/#:~:text=Destructor%20is%20another%20special%20member%20function%20that%20is%20called%20by%20the%20compiler%20when%20the%20scope%20of%20the%20object%20ends).

### Inheritance

Inheritance allows a class to inherit the properties and methods of another class. The class that inherits is called the derived class, and the class it inherits from is called the base class [[10]](https://www.tutorialspoint.com/cplusplus/cpp_object_oriented.htm#:~:text=As%20the%20name%20suggests%20Inheritance%20is%20the%20process%20of%20forming%20a%20new%20class%20from%20an%20existing%20class%20that%20is%20from%20the%20existing%20class%20called%20as%20base%20class%2C%20new%20class%20is%20formed%20called%20as%20derived%20class)[[11]](https://www.simplilearn.com/tutorials/cpp-tutorial/oops-concepts-in-cpp#:~:text=Inheritance%20is%20the%20process%20in%20which%20two%20classes%20have%20an%20is%2Da%20relationship%20among%20each%20other%20and%20objects%20of%20one%20class%20acquire%20properties%20and%20features%20of%20the%20other%20class)[[12]](https://wiingy.com/learn/cpp/cpp-object-oriented-programming-guide/#:~:text=Inheritance%20is%20the%20mechanism%20for%20creating%20a%20new%20class%20%28the%20derived%20class%29%20from%20an%20existing%20class%20%28the%20base%20class%29)[[13]](https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/#:~:text=Object%20Oriented%20Programming%20in%20C%2B%2B%20Read%20Courses%20Practice%20Video%20Improve%20Improve%20Improve%20Like%20Article%20Like%20Save%20Article%20Save%20Report%20issue%20Report%20Object%2Doriented%20programming%20%E2%80%93%20As%20the%20name%20suggests%20uses%20objects%20in%20programming).

### Polymorphism

Polymorphism in C++ is primarily achieved through:

- **Overloading**: This allows you to have more than one function with the same name but different parameters within the same scope [[14]](https://www.tutorialspoint.com/cplusplus/cpp_object_oriented.htm#:~:text=Polymorphism%20The%20ability%20to%20use%20an%20operator%20or%20function%20in%20different%20ways%20in%20other%20words%20giving%20different%20meaning%20or%20functions%20to%20the%20operators%20or%20functions%20is%20called%20polymorphism)[[15]](https://www.simplilearn.com/tutorials/cpp-tutorial/oops-concepts-in-cpp#:~:text=Polymorphism%20means%20many%20forms.%20It%20is%20the%20ability%20to%20take%20more%20than%20one%20form.%20It%20is%20a%20feature%20that%20provides%20a%20function%20or%20an%20operator%20with%20more%20than%20one%20definition)[[17]](https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/#:~:text=C%2B%2B%20supports%20operator%20overloading%20and%20function%20overloading).
- **Overriding**: This allows a derived class to provide a specific implementation of a method that is already defined in its base class.

### Dynamic Binding

Dynamic binding is a mechanism that allows the program to decide at runtime which method to invoke. This is closely related to polymorphism and is achieved through virtual functions in C++ [[41]](https://wiingy.com/learn/cpp/cpp-object-oriented-programming-guide/#:~:text=Dynamic%20binding%20is%20the%20mechanism%20for%20choosing%20the%20appropriate%20function%20implementation%20at%20runtime%20based%20on%20the%20type%20of%20the%20object)[[42]](https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/#:~:text=C%2B%2B%20has%20virtual%20functions%20to%20support%20this).

### Message Passing

Objects communicate with each other using message passing. In C++ terms, this usually means calling methods on objects [[43]](https://wiingy.com/learn/cpp/cpp-object-oriented-programming-guide/#:~:text=Message%20passing%20is%20a%20mechanism%20for%20objects%20to%20communicate%20with%20each%20other%20by%20sending%20messages)[[44]](https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/#:~:text=A%20message%20for%20an%20object%20is%20a%20request%20for%20the%20execution%20of%20a%20procedure%20and%20therefore%20will%20invoke%20a%20function%20in%20the%20receiving%20object%20that%20generates%20the%20desired%20results).

## Benefits of OOP

- **Reusability**: Code reusability is one of the main benefits of OOP. It allows programmers to use the same code in different programs [[45]](https://www.simplilearn.com/tutorials/cpp-tutorial/oops-concepts-in-cpp#:~:text=OOPs%20provide%20reusability%20to%20the%20code%20and%20extend%20the%20use%20of%20existing%20classes)[[46]](https://wiingy.com/learn/cpp/cpp-object-oriented-programming-guide/#:~:text=One%20of%20the%20key%20benefits%20of%20OOP%20concepts%20in%20c%2B%2B%20is%20code%20reusability)[[13]](https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/#:~:text=Object%20Oriented%20Programming%20in%20C%2B%2B%20Read%20Courses%20Practice%20Video%20Improve%20Improve%20Improve%20Like%20Article%20Like%20Save%20Article%20Save%20Report%20issue%20Report%20Object%2Doriented%20programming%20%E2%80%93%20As%20the%20name%20suggests%20uses%20objects%20in%20programming).
- **Data Hiding**: OOP provides the ability to hide internal implementation details and show only the necessary features [[47]](https://www.simplilearn.com/tutorials/cpp-tutorial/oops-concepts-in-cpp#:~:text=It%20also%20helps%20in%20data%20hiding%2C%20keeping%20the%20data%20and%20information%20safe%20from%20leaking%20or%20getting%20exposed)[[5]](https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/#:~:text=Object%20Oriented%20Programming%20in%20C%2B%2B%20Read%20Courses%20Practice%20Video%20Improve%20Improve%20Improve%20Like%20Article%20Like%20Save%20Article%20Save%20Report%20issue%20Report%20Object%2Doriented%20programming%20%E2%80%93%20As%20the%20name%20suggests%20uses%20objects%20in%20programming).
- **Ease of Maintenance**: OOP makes it easier to maintain and modify existing code as new objects can be created with small differences to existing ones [[48]](https://www.simplilearn.com/tutorials/cpp-tutorial/oops-concepts-in-cpp#:~:text=In%20OOPs%2C%20it%20is%20easy%20to%20maintain%20code%20as%20there%20are%20classes%20and%20objects%2C%20which%20helps%20in%20making%20it%20easy%20to%20maintain%20rather%20than%20restructuring).

## Conclusion

C++'s OOP capabilities are vast and powerful. Understanding these concepts is crucial for writing efficient and maintainable code. By mastering classes, objects, inheritance, polymorphism, and other OOP features, you can create robust and scalable C++ applications. Remember to use these features wisely and understand the underlying principles to make the most out of object-oriented programming in C++.
===================================================================You.com Research Mode
# C# Reflection In-Depth Tutorial

Reflection in C# is a powerful feature that allows programs to inspect and interact with their own structure and metadata at runtime. This capability is part of the .NET framework and is essential for a variety of advanced programming tasks. In this tutorial, we will explore the concept of reflection, its practical applications, and how to use it effectively while being aware of its potential drawbacks.

## What is Reflection?

Reflection is the ability of a program to examine its own structure, particularly through the metadata of its assemblies, types, methods, and fields [[1]](https://mabroukmahdhi.medium.com/reflection-in-c-a-guide-to-using-and-avoiding-6b8e2f76bc83#:~:text=Reflection%20in%20C%23%20is%20the%20ability%20of%20a%20program%20to%20inspect%20its%20own%20structure%2C%20including%20metadata%2C%20types%2C%20and%20other%20elements%2C%20during%20runtime)[[2]](https://www.geeksforgeeks.org/what-is-reflection-in-c-sharp/#:~:text=Reflection%20is%20the%20process%20of%20describing%20the%20metadata%20of%20types%2C%20methods%20and%20fields%20in%20a%20code)[[3]](https://www.simplilearn.com/tutorials/c-sharp-tutorial/c-sharp-reflection#:~:text=Reflection%20is%20the%20ability%20of%20a%20computer%20program%20to%20analyze%20its%20behavior%20and%20code%20and%20make%20adjustments)[[4]](https://stackify.com/what-is-c-reflection/#:~:text=We%20call%20%E2%80%9Creflection%E2%80%9D%20the%20ability%20that%20some%20programming%20languages%20have%20to%20inspect%20their%20own%20constructs%20dynamically). This is facilitated by the `System.Reflection` namespace, which provides classes that allow you to obtain information about the application and dynamically add types, values, and objects to it [[5]](https://mabroukmahdhi.medium.com/reflection-in-c-a-guide-to-using-and-avoiding-6b8e2f76bc83#:~:text=It%20is%20part%20of%20the)[[6]](https://www.geeksforgeeks.org/what-is-reflection-in-c-sharp/#:~:text=The%20namespace%20System.Reflection%20enables%20you%20to%20obtain%20data%20about%20the%20loaded%20assemblies%2C%20the%20elements%20within%20them%20like%20classes%2C%20methods%20and%20value%20types)[[7]](https://www.simplilearn.com/tutorials/c-sharp-tutorial/c-sharp-reflection#:~:text=Reflection%22%20namespace%20contains%20the%20classes%20that%20provide%20access%20to%20the%20program%27s%20metadata%20during%20runtime)[[8]](https://www.tutorialspoint.com/csharp/csharp_reflection.htm#:~:text=The%20classes%20that%20give%20access%20to%20the%20metadata%20of%20a%20running%20program%20are%20in%20the%20System.Reflection%20namespace).

## Core Concepts and Classes of Reflection

At the heart of reflection in C# lies the `System.Reflection` namespace, which includes several classes that are crucial for working with reflection:

- `System.Type`: Represents types and grants access to their metadata [[9]](https://medium.com/technology-nineleaps/reflection-in-net-a-comprehensive-guide-for-application-development-66841aa6f4b1#:~:text=Of%20particular%20importance%20is%20the%20System.Type%20class%20serves%20as%20a%20vital%20component%20in%20reflection%20by%20representing%20types%20and%20granting%20access%20to%20their%20metadata)[[10]](https://stackify.com/what-is-c-reflection/#:~:text=The%20main%20class%20for%20reflection%20is%20the%20System.Type%20class%2C%20which%20is%20a%20partial%20abstract%20class%20representing%20a%20type%20in%20the%20Common%20Type%20System%20%28CTS%29).
- `System.Reflection.Assembly`: Works with assemblies, including defining, loading, and locating types within them [[11]](https://medium.com/technology-nineleaps/reflection-in-net-a-comprehensive-guide-for-application-development-66841aa6f4b1#:~:text=Assembly%20class%20provides%20a%20wide%20range%20of%20functionalities%20for%20working%20with%20assemblies%2C%20including)[[12]](https://www.geeksforgeeks.org/what-is-reflection-in-c-sharp/#:~:text=Assembly%20describes%20an%20assembly%20which%20is%20a%20reusable%2C%20versionable%2C%20and%20self%2Ddescribing%20building%20block%20of%20a%20common%20language%20runtime%20application).
- `System.Reflection.Module`: Provides information about modules and the types they contain [[13]](https://medium.com/technology-nineleaps/reflection-in-net-a-comprehensive-guide-for-application-development-66841aa6f4b1#:~:text=The%20System.Reflection.Module%20class%20enables%20us%20to%20discover%20information%20about%20the%20module%20itself%20and%20the%20types%20contained%20within%20it).
- `System.Reflection.*Info` classes (`ConstructorInfo`, `MethodInfo`, `FieldInfo`, `PropertyInfo`, `EventInfo`, `ParameterInfo`): These classes provide insights and mechanisms for accessing and manipulating constructors, methods, fields, properties, events, and parameters [[14]](https://medium.com/technology-nineleaps/reflection-in-net-a-comprehensive-guide-for-application-development-66841aa6f4b1#:~:text=The%20System.Reflection.ConstructorInfo%20and%20System.Reflection.MethodInfo%20classes%20provide%20insights%20into%20constructors%20and%20methods%2C%20respectively)[[15]](https://www.geeksforgeeks.org/what-is-reflection-in-c-sharp/#:~:text=ConstructorInfo%20Describes%20a%20class%20constructor%20and%20gives%20access%20to%20the%20metadata).

## Practical Applications of Reflection

Reflection is used extensively in various programming scenarios:

1. **Dynamic Creation and Manipulation of Objects**: Reflection allows for the instantiation of objects, invocation of methods, and access to fields and properties at runtime [[16]](https://medium.com/technology-nineleaps/reflection-in-net-a-comprehensive-guide-for-application-development-66841aa6f4b1#:~:text=It%20allows%20for%20the%20dynamic%20creation%20of%20objects%2C%20invoking%20methods%2C%20and%20accessing%20fields%20and%20properties)[[17]](https://alinabo.com/reflection-in-csharp#:~:text=Reflection%20also%20enables%20the%20dynamic%20invocation%20of%20methods).
2. **Plugin and Extension Systems**: By dynamically loading assemblies and creating types at runtime, reflection enables the development of extensible applications with plugin architectures [[18]](https://medium.com/@codezone/understanding-reflection-in-c-with-practical-examples-df3c444582f1#:~:text=Creating%20plugins%20and%20extensions%20dynamically)[[19]](https://mabroukmahdhi.medium.com/reflection-in-c-a-guide-to-using-and-avoiding-6b8e2f76bc83#:~:text=This%20is%20particularly%20useful%20for%20improving%20the%20startup%20performance%20of%20your%20application%20or%20for%20implementing%20a%20plugin%20system)[[20]](https://medium.com/technology-nineleaps/reflection-in-net-a-comprehensive-guide-for-application-development-66841aa6f4b1#:~:text=The%20application%20can%20dynamically%20load%20and%20interact%20with%20external%20modules%20or%20plugins%20by%20utilising%20reflection%2C%20allowing%20for%20flexible%20and%20customizable%20functionality).
3. **Code Analysis Tools**: Developers can create tools that analyze code structures and behaviors, which is useful for debugging and testing [[21]](https://medium.com/@codezone/understanding-reflection-in-c-with-practical-examples-df3c444582f1#:~:text=Developing%20tools%20that%20analyze%20code)[[22]](https://www.devleader.ca/2023/10/25/how-to-master-the-art-of-reflection-in-csharp-and-boost-your-programming-skills/#:~:text=Reflection)[[23]](https://medium.com/technology-nineleaps/reflection-in-net-a-comprehensive-guide-for-application-development-66841aa6f4b1#:~:text=Reflection%20helps%20with%20unit%20testing%20and%20debugging%20by%20giving%20access%20to%20private%20members%20of%20classes%2C%20allowing%20developers%20to%20investigate%20and%20modify%20the%20internal%20state%20for%20testing%20or%20troubleshooting%20purposes).
4. **Serialization and Deserialization**: Reflection is essential in serialization frameworks, allowing for the dynamic serialization and reassembly of objects [[24]](https://medium.com/@codezone/understanding-reflection-in-c-with-practical-examples-df3c444582f1#:~:text=Implementing%20serialization%20and%20deserialization%20mechanisms)[[25]](https://medium.com/technology-nineleaps/reflection-in-net-a-comprehensive-guide-for-application-development-66841aa6f4b1#:~:text=It%20enables%20objects%20to%20be%20serialized%20and%20then%20reassembled%20into%20objects%20by%20utilising%20type%20information%20and%20member%20access)[[26]](https://alinabo.com/reflection-in-csharp#:~:text=Reflection%20simplifies%20this%20process%20by%20automatically%20analyzing%20object%20structures%20without%20requiring%20explicit%20coding%20effort).
5. **Object Mapping Libraries**: It simplifies data transfer between different object models by dynamically mapping data from one object to another [[27]](https://medium.com/technology-nineleaps/reflection-in-net-a-comprehensive-guide-for-application-development-66841aa6f4b1#:~:text=Reflection%20is%20used%20in%20object%20mapping%20libraries%20to%20dynamically%20map%20data%20from%20one%20object%20to%20another.%20It%20enables%20the%20automatic%20matching%20of%20property%20names%20and%20values%2C%20simplifying%20transfer%20data%20between%20different%20object%20models).
6. **Dependency Injection (DI)**: Reflection supports the automatic discovery and instantiation of dependencies, promoting loose coupling and modular design [[28]](https://medium.com/technology-nineleaps/reflection-in-net-a-comprehensive-guide-for-application-development-66841aa6f4b1#:~:text=Reflection%20is%20commonly%20used%20in%20frameworks%20that%20implement%20dependency%20injection%20%28DI%29.%20It%20allows%20for%20the%20automatic%20discovery%20and%20instantiation%20of%20dependencies%20based%20on%20their%20types%2C%20facilitating%20loose%20coupling%20and%20modular%20design).
7. **Metadata-Driven Applications**: Developers can build applications where the structure and behavior are specified dynamically [[29]](https://medium.com/technology-nineleaps/reflection-in-net-a-comprehensive-guide-for-application-development-66841aa6f4b1#:~:text=%2D%20Metadata%2Ddriven%20Applications%3A%20Reflection%20helps%20developers%20build%20metadata%2Ddriven%20applications%20in%20which%20the%20structure%20and%20behaviour%20of%20things%20are%20dynamically%20specified).
8. **Unit Testing and Debugging**: Reflection provides access to private members of classes, aiding in testing and troubleshooting [[23]](https://medium.com/technology-nineleaps/reflection-in-net-a-comprehensive-guide-for-application-development-66841aa6f4b1#:~:text=Reflection%20helps%20with%20unit%20testing%20and%20debugging%20by%20giving%20access%20to%20private%20members%20of%20classes%2C%20allowing%20developers%20to%20investigate%20and%20modify%20the%20internal%20state%20for%20testing%20or%20troubleshooting%20purposes)[[30]](https://stackify.com/what-is-c-reflection/#:~:text=Several%20important%20tools%20make%20use%20of%20reflection%20to%20enable%20their%20working.%20One%20example%20is%20unit%20test%20frameworks%2C%20which%20use%20reflection%20to%20identify%20test%20classes%20and%20methods%20marked%20with%20the%20necessary%20attributes)[[31]](https://alinabo.com/reflection-in-csharp#:~:text=Furthermore%2C%20reflection%20provides%20access%20to%20private%20members%20that%20are%20not%20directly%20accessible%20through%20normal%20means).

## Using Reflection

To use reflection, you typically start by obtaining the `Type` object of the class you're interested in. This can be done using methods like `GetType()` or `typeof()` [[32]](https://www.geeksforgeeks.org/what-is-reflection-in-c-sharp/#:~:text=Then%20we%20apply%20reflection%20on%20t%20to%20find%20any%20information%20about%20string%20class%2C%20like%20its%20name%2C%20fullname%2C%20namespace%2C%20and%20basetype)[[33]](https://www.simplilearn.com/tutorials/c-sharp-tutorial/c-sharp-reflection#:~:text=C%23%20Type%20class%20supports%20various%20methods)[[34]](https://alinabo.com/reflection-in-csharp#:~:text=returns%20the%20runtime%20type%20of%20an%20object). Once you have the `Type` object, you can use it to get information about the class's methods, properties, fields, events, and more [[35]](https://alinabo.com/reflection-in-csharp#:~:text=Reflection%20is%20a%20powerful%20feature%20in%20C%23%20that%20allows%20you%20to%20retrieve%20information%20about%20properties%2C%20methods%2C%20fields%20%28variables%29%2C%20events%2C%20and%20more%20defined%20in%20a%20type).

Here's a simple example of using reflection to get the type of an object and its methods:

```csharp
Type myType = typeof(MyClass);
MethodInfo[] methods = myType.GetMethods();
foreach (MethodInfo method in methods)
{
    Console.WriteLine("Method Name: " + method.Name);
}
```

## Reflection and Attributes

Attributes in C# provide a way to associate metadata with code [[36]](https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/reflection-and-attributes/#:~:text=Attributes). Reflection can be used to access these attributes at runtime, which is useful for scenarios like configuring applications or controlling serialization behavior [[37]](https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/reflection-and-attributes/#:~:text=After%20an%20attribute%20is%20associated%20with%20a%20program%20entity%2C%20the%20attribute%20can%20be%20queried%20at%20run%20time%20by%20using%20a%20technique%20called%20reflection)[[38]](https://alinabo.com/reflection-in-csharp#:~:text=One%20of%20the%20key%20benefits%20of%20reflection%20is%20the%20ability%20to%20retrieve%20attributes%20associated%20with%20types%20or%20members).

## Advantages of Reflection

Reflection enhances the flexibility of code by allowing for dynamic interactions with types, which reduces the need for compile-time knowledge of those types [[39]](https://alinabo.com/reflection-in-csharp#:~:text=Reflection%20allows%20you%20to%20work%20with%20types%20dynamically%2C%20reducing%20the%20need%20for%20compile%2Dtime%20knowledge%20of%20those%20types). It also opens up opportunities for building generic frameworks that can adapt to different types [[40]](https://alinabo.com/reflection-in-csharp#:~:text=Reflection%27s%20capability%20to%20discover%20type%20information%20at%20runtime%20opens%20up%20opportunities%20for%20building%20generic%20frameworks%20that%20can%20adapt%20to%20different%20types).

## Cautions and Best Practices

While reflection is powerful, it comes with certain drawbacks:

- **Performance Overhead**: Reflection can be slower than direct code access due to the need to examine metadata [[41]](https://www.devleader.ca/2023/10/25/how-to-master-the-art-of-reflection-in-csharp-and-boost-your-programming-skills/#:~:text=Reflection%20can%20be%20slower%20than%20other%20techniques%20since%20it%20examines%20the%20metadata%20for%20each%20object)[[42]](https://alinabo.com/reflection-in-csharp#:~:text=One%20of%20the%20main%20drawbacks%20of%20using%20reflection%20in%20C%23%20is%20its%20slower%20performance%20compared%20to%20direct%20access).
- **Security Risks**: Dynamic code execution can lead to vulnerabilities if not implemented correctly [[43]](https://www.devleader.ca/2023/10/25/how-to-master-the-art-of-reflection-in-csharp-and-boost-your-programming-skills/#:~:text=Reflection%20allows%20for%20dynamic%20loading%20and%20execution%20of%20code%2C%20which%20can%20lead%20to%20vulnerabilities%20if%20not%20implemented%20correctly).
- **Access to Sensitive Data**: Reflection can access private or protected members, which might include sensitive data or functions [[44]](https://www.devleader.ca/2023/10/25/how-to-master-the-art-of-reflection-in-csharp-and-boost-your-programming-skills/#:~:text=Specifically%2C%20reflection%20allows%20for%20code%20to%20access%20private%20or%20protected%20members%20of%20an%20object%2C%20which%20could%20include%20sensitive%20data%20or%20functions)[[45]](https://alinabo.com/reflection-in-csharp#:~:text=Reflection%20allows%20access%20to%20private%20members%20and%20methods%20that%20are%20not%20intended%20for%20public%20use).
- **Code Complexity**: Overuse of reflection can make code harder to understand and maintain [[46]](https://alinabo.com/reflection-in-csharp#:~:text=Reflection%20should%20be%20used%20sparingly%20as%20it%20has%20the%20potential%20to%20make%20code%20harder%20to%20understand%20and%20maintain%20over%20time).

To mitigate these issues, it's recommended to use reflection judiciously and consider employing caching mechanisms to reduce runtime overhead [[47]](https://alinabo.com/reflection-in-csharp#:~:text=In%20order%20to%20optimize%20your%20use%20of%20reflection%2C%20consider%20employing%20caching%20mechanisms). Additionally, leveraging Emit or Expression Trees can provide alternatives for generating dynamic methods at runtime [[48]](https://alinabo.com/reflection-in-csharp#:~:text=involves%20leveraging%20Emit%20or%20Expression%20Trees%20for%20generating%20dynamic%20methods%20at%20runtime%20instead%20of%20relying).

## Conclusion

Reflection in C# is a powerful tool that allows developers to write more dynamic, flexible, and extensible code. It provides the ability to inspect and manipulate the structure of types at runtime, which can greatly enhance the capabilities of a C# application. However, it's important to use reflection with care, keeping in mind its performance implications and potential security concerns. By understanding and applying reflection appropriately, developers can unlock a new level of programming proficiency and efficiency [[49]](https://www.devleader.ca/2023/10/25/how-to-master-the-art-of-reflection-in-csharp-and-boost-your-programming-skills/#:~:text=Reflection%20in%20CSharp%20is%20a%20powerful%20tool%20in%20a%20C%23%20programmer%E2%80%99s%20toolkit)[[50]](https://alinabo.com/reflection-in-csharp#:~:text=Reflection%20is%20a%20powerful%20feature%20in%20C%23%20that%20allows%20you%20to%20examine%20and%20manipulate%20code%20dynamically%20at%20runtime)
===================================================================
Pre-increment= immediately add 1 Post-increment= after the current statement expression is executed for eg. int result=5; cout << ("The result is" result++) << endl; post=5 pre=6 pre would've been 6 (post not evaluated until last) cout << result << endl; post=now 6. overflow underflow (max highest becomes negative minimum vice versa). Precedence division modulo first % (num%2 checks if num is odd (there's a remainder, even no remainder). One of the variables in expression must be match actual datatype (double or fails to int). Math.Round(var,2) (2 decimal places) int.MaxValue (maximum number of int).
					END OF ADHOC-CPP NOTES.