Arrays in C# || C# full course || basics in C# || ABFirstTech

                               Arrays in C#

Arrays in C# are used to store collections of elements of the same data type. C# supports single-dimensional arrays, multidimensional arrays, and jagged arrays.

1. Single-Dimensional Array:

A single-dimensional array is a collection of elements stored in a linear sequence. It is declared with a specified data type, followed by square brackets []:

int[] numbers = new int[5]; // Declare an integer array of size 5

You can initialize and access elements like this:

numbers[0] = 1; numbers[1] = 2; // ... int thirdElement = numbers[2];

2. Multidimensional Array:

A multidimensional array is an array of arrays. Commonly used are two-dimensional arrays, but you can have arrays with more dimensions.

Two-Dimensional Array:

int[,] matrix = new int[3, 4]; // Declare a 2D array of size 3x4

You can initialize and access elements as follows:

matrix[0, 0] = 1; matrix[0, 1] = 2; // ... int value = matrix[1, 2];

Three-Dimensional Array:

int[,,] cube = new int[2, 3, 4]; // Declare a 3D array of size 2x3x4

3. Jagged Array:

A jagged array is an array of arrays where each element can be an array of different sizes.

int[][] jaggedArray = new int[3][];

You need to initialize each sub-array separately:

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

Accessing elements:

int value = jaggedArray[1][0]; // Accessing the first element of the second sub-array

Jagged arrays are flexible and allow different lengths for each row.

Arrays in C# are zero-indexed, meaning the first element is at index 0, the second at index 1, and so on. Array elements are accessed using square brackets [].

Branching Statements- in C# || Full C# course || ABFirstTech

Branching Statements- in C#

Branching statements in C# are used to alter the normal flow of program execution. They include keywords like break, continue, return, goto, and throw. Let's discuss each of these branching statements:

1. break statement:

• Used to exit from a loop or switch statement prematurely.

• Example:

• for (int i = 0; i < 10; i++) { if (i == 5) { break; // exit the loop when i equals 5 } Console.WriteLine(i); }

• 
  

2. continue statement:

• Used to skip the rest of the loop and jump to the next iteration.

• Example:

• for (int i = 0; i < 10; i++) { if (i % 2 == 0) { continue; // skip even numbers } Console.WriteLine(i); }

• 
  

3. return statement:

• Used to exit a method and return a value, if the method has a return type.

• Example:

• int Square(int x) { return x * x; }

• 
  

4. goto statement:

• Allows you to transfer the control of the program to a labeled statement.

• It is generally considered bad practice and is rarely used in modern C# programming due to its potential to create unreadable and hard-to-maintain code. It can lead to "goto spaghetti" code.

• Example:

• int i = 0; loopStart: Console.WriteLine(i); i++; if (i < 5) { goto loopStart; }

• 
  

5. throw statement:

• Used to raise an exception explicitly.

• Example:

• int Divide(int numerator, int denominator) { if (denominator == 0) { throw new DivideByZeroException("Denominator cannot be zero."); } return numerator / denominator; }

• 
  
6. While break and continue are often used in loops, return and throw are used in methods/functions to control the program's flow. The use of goto should be avoided in most cases due to its negative impact on code readability and maintainability.

Variable and Control structure in C# || C# Full course || ABFirstTech

 Variable and Control structure in C#

Variables in C#:

A variable is a named storage location in a computer's memory where data can be stored and retrieved during the execution of a program. In C#, variables must be declared before they are used. The declaration specifies the data type of the variable and the name by which it can be referred to in the program.

Here is an example of declaring variables in C#:

// Variable declaration
int age; // Declaring an integer variable named 'age'
// Variable initialization
age = 25; // Assigning a value to the 'age' variable

In this example, int is the data type, and age is the variable name. The variable is then assigned a value of 25. C# supports various data types, including int, float, double, char, string, bool, etc.

Control Structures in C#:

Control structures in C# are used to control the flow of a program's execution. They include decision-making structures (if, else, switch) and loop structures (for, while, do-while). These structures help in making decisions based on conditions and repeating certain tasks.

1. Decision-Making Structures:

a. If statement:

int number = 10;
if (number > 0) {
Console.WriteLine("Number is positive");
}

b. If-else statement:

int number = -5;
if (number > 0) {
Console.WriteLine("Number is positive");
} else {
Console.WriteLine("Number is non-positive");
}

c. Switch statement:

int dayOfWeek = 3;
switch (dayOfWeek) {
case 1:
Console.WriteLine("Monday");
break;
case 2:
Console.WriteLine("Tuesday");
break;
// ... (other cases)
default:
Console.WriteLine("Invalid day");
break;
}

2. Loop Structures:

a. For loop:

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

b. While loop:

int i = 0;
while (i < 5) {
Console.WriteLine(i);
i++;
}

c. Do-while loop:

int i = 0;
do {
Console.WriteLine(i);
i++;
} while (i < 5);

Boxing and Unboxing in C Sharp || ABFirstTech || C# for Beginners

         Boxing and Unboxing in C Sharp

Introduction

• Briefly introduce the concept of Boxing and Unboxing.
• Mention that these operations involve converting between value types and reference types in C#.

Value Types vs Reference Types

• Explain the difference between value types and reference types in C#.
• Value types are stored directly in memory, whereas reference types are stored on the heap and accessed through a reference.

Boxing

• Define Boxing as the process of converting a value type to a reference type.
• Provide examples of common value types (e.g., int, char) being boxed.
• Explain that boxing involves creating a new object on the heap and copying the value into it.

Unboxing

• Define Unboxing as the process of converting a reference type to a value type.
• Provide examples of common reference types (e.g., object) being unboxed.
• Explain that unboxing involves extracting the value from the boxed object on the heap.

Performance Considerations

• Discuss the performance implications of boxing and unboxing.
• Mention that these operations can introduce overhead due to heap allocation and additional memory copying.
• Explain that frequent boxing and unboxing can impact the performance of your application.

Where Boxing and Unboxing Occur

• Identify scenarios where boxing and unboxing may occur in C# code.
• Examples include collections that store value types in a container designed for reference types (e.g., ArrayList), and usage of interfaces like IEnumerable.

How to Minimize Boxing and Unboxing

• Provide tips on how to minimize or avoid boxing and unboxing in your code.
• Use generic collections (e.g., List<T>) instead of non-generic ones.
• Be mindful of interfaces and choose appropriately based on the scenario.

Code Examples

• Demonstrate practical examples of boxing and unboxing in C#.
• Show scenarios where developers might encounter these operations and how to handle them efficiently.

Conclusion

• Summarize the key points about Boxing and Unboxing in C#.
• Emphasize the importance of understanding these concepts for writing efficient and performant code.