Want to listen to a tutor?

LEARNING OUTCOME 6

IMPORTANCE OF USING ARRAYS

Arrays:

Arrays are fundamental data structures in C# that provide a structured way to store a fixed-size collection of elements of the same data type. They offer several advantages that make them essential for various programming tasks:

Efficient Data Management: Arrays store elements contiguously in memory, allowing for fast access and retrieval of individual elements using their index (position) within the array. This is particularly beneficial for large datasets where random access is required.
Improved Memory Usage: Arrays are memory-efficient because they allocate a single block of memory to store all elements of the same type. This can be more efficient than using separate variables for each element, especially for large collections.
Code Readability and Maintainability: Arrays represent a collection of related data with a clear structure. By using descriptive names for arrays and their elements, you can enhance code readability and make the program logic easier to understand for both yourself and others.
Iteration and Processing: Arrays are well-suited for tasks involving processing sequences of data. You can use for loops, foreach loops, and other iteration constructs to efficiently iterate through each element in the array, applying calculations or operations as needed.

Common Use Cases for Arrays:

Storing lists of items (e.g., names, scores, product prices)
Representing multidimensional data (e.g., matrices, grids, game boards)
Simulating sequences or progressions of values (e.g., animation frames, time series data)
Creating lookup tables or dictionaries (using indexes to access specific values)

Alternatives to Arrays:

Lists: While arrays offer efficiency for fixed-size collections, lists are dynamic data structures that can grow or shrink at runtime. They are more versatile for situations where the collection size is unknown beforehand.
Custom Data Structures: For complex data relationships or specialized requirements, you might consider creating custom data structures that encapsulate data and operations together.

Key Points to Consider When Using Arrays:

Fixed Size: Arrays have a fixed size, so determine the necessary size before creating an array to avoid potential issues.
Accessing Elements: Accessing elements outside the array bounds can lead to runtime errors (IndexOutOfRangeException). Be mindful of proper indexing within the valid range (0 to array_length - 1).
Reference Types: Arrays are reference types, meaning they store the memory address of the allocated block. Passing arrays to functions involves passing the reference, not copying the entire array.

Example: Calculating Average Temperature in a Month

// Daily temperatures
int[] temperatures = { 15, 18, 20, 22, 25, 23, 21, 19, 17, 16 };
double total = 0;
for (int i = 0; i < temperatures.Length; i++)
{
    total += temperatures[i]; // Add each temperature to the total
}
double averageTemperature = total / temperatures.Length;
Console.WriteLine("The average temperature for the month is: {0:F2} degrees Celsius", averageTemperature);

How to create one-dimensional, two-dimensional (multidimensional), and jagged arrays in C#:

1. One-Dimensional Arrays:

One-dimensional arrays store a collection of elements of the same data type in a contiguous memory block. You can create them in two ways:

Using initialization:

// Array with initial values
int[] numbers = { 10, 20, 30, 40, 50 };

Specifying size and assigning values later:

// Array with size 5, initially filled with zeros
int[] scores = new int[5];
scores[0] = 95;
scores[1] = 88;
// ... assign values to other elements

2. Two-Dimensional Arrays (Multidimensional Arrays):

Two-dimensional arrays represent a grid-like structure where each element is identified by two indexes, one for the row and one for the column. You can create them similarly to one-dimensional arrays:

Using initialization:

// Matrix with initial values
int[,] matrix = {
    { 1, 2, 3 },
    { 4, 5, 6 },
    { 7, 8, 9 }
};

Specifying size and assigning values later:

// 3 rows, 4 columns, initially filled with zeros
int[,] table = new int[3, 4];
table[0, 0] = 11;
table[1, 2] = 22;
// ... assign values to other elements

3. Jagged Arrays:

Jagged arrays are arrays of arrays, where each inner array can have a different size. They offer flexibility when you don't need a fixed number of elements in each row:

// Array of 3 arrays (size of each unknown yet)
int[][] jaggedArray = new int[3][];
// First row with 3 elements
jaggedArray[0] = new int[] { 1, 3, 5 };
// Second row with 2 elements
jaggedArray[1] = new int[] { 2, 4 };
// Third row with 4 elements
jaggedArray[2] = new int[] { 7, 8, 9, 10 };

Accessing Elements:

One-dimensional array: `arrayName[index]` (e.g., `numbers[2]` accesses the third element)
Two-dimensional array: `arrayName[rowIndex, columnIndex]` (e.g., `matrix[1, 0]` accesses the element in row 2, column 1)
Jagged array: `jaggedArray[rowIndex][columnIndexWithinInnerArray]` (e.g., `jaggedArray[2][1]` accesses the second element in the third row)

MANIPULATING ARRAYS

Here are some common ways to manipulate arrays in C#:

Accessing Elements: You can access individual elements in an array using their index (position) within square brackets (`[]`). The index starts from 0 and goes up to the array's length minus 1.
C#
```
int[] numbers = { 10, 20, 30 };
// Access the first element (value 10)
int firstElement = numbers[0];
```
Modifying Elements: Once you've accessed an element using its index, you can modify its value by assigning a new value to the index.
C#
```
// Change the second element from 20 to 50
numbers[1] = 50;
```
Iterating over Elements: You can use `for` loops or `foreach` loops to iterate through all elements in an array:
- for loop: Provides more control over the index.
  C#
```
for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine("Element {0}: {1}", i + 1, numbers[i]);
}
```
- foreach loop: More concise for iterating through elements without needing an index.
  C#
```
foreach (int number in numbers)
{
    Console.WriteLine(number);
}
```
Searching for Elements: Use methods like `IndexOf` or `LastIndexOf` to find the index of the first or last occurrence of a specific value in the array.
C#
```
// Find the index of 20 (returns -1 if not found)
int index = Array.IndexOf(numbers, 20);
```
Sorting Elements: Use the `Array.Sort` method to arrange array elements in ascending or descending order.
C#
```
// Sorts numbers in ascending order
Array.Sort(numbers);
```

Reversing Elements: You can reverse the order of elements in an array using a loop or by leveraging the `Array.Reverse` method.

// Using a loop
for (int i = 0; i < numbers.Length / 2; i++)
{
    int temp = numbers[i];
    numbers[i] = numbers[numbers.Length - 1 - i];
    numbers[numbers.Length - 1 - i] = temp;
}
// Using Array.Reverse
Array.Reverse(numbers); // Reverses the order in-place

Copying Arrays: To create a new copy of an array, use the `Array.Copy` method or create a new array and assign elements individually.

int[] copy = new int[numbers.Length];
// Copy elements to a new array
Array.Copy(numbers, copy, numbers.Length);
// Or, assign individually
for (int i = 0; i < numbers.Length; i++)
{
    copy[i] = numbers[i];
}

SORTING AND SEARCHING ARRAYS in C#

1. Sorting Arrays:

Similar to JavaScript's `sort` method, C# offers the `Array.Sort` method to arrange array elements in a specific order.

int[] numbers = { 5, 2, 8, 1, 3 };
// Sort elements in ascending order (default behavior)
Array.Sort(numbers);
Console.WriteLine("Sorted numbers: {0}", string.Join(", ", numbers));
// Output: 1, 2, 3, 5, 8

2. Sorting with Custom Comparison:

Like JavaScript's comparison function, C# allows you to define a custom comparison function for `Array.Sort` to control the sorting order.

string[] names = { "Alice", "Charlie", "Bob" };
// Function to compare names by length (ascending order)
int CompareByNameLength(string a, string b)
{
    return a.Length.CompareTo(b.Length); // Compare string lengths
}
Array.Sort(names, CompareByNameLength); // Use custom comparison function
Console.WriteLine("Sorted names by length: {0}", string.Join(", ", names));
// Output: Bob, Alice, Charlie

3. Searching Arrays:

C# provides methods like `IndexOf` and `LastIndexOf` to find the index of a specific value within an array.

int[] numbers = { 10, 20, 30, 20, 40 };
// Find the first occurrence of 20
int firstIndex = Array.IndexOf(numbers, 20);
// Find the last occurrence of 20 (if present)
int lastIndex = Array.LastIndexOf(numbers, 20);
Console.WriteLine("First index of 20: {0}", firstIndex); // Output: 1
Console.WriteLine("Last index of 20: {0}", lastIndex); // Output: 3 (if not found, returns -1)

STRUCTURES: User-Defined Value Types

Structures in C# are user-defined data types that group related variables of various data types under a single unit. They act as value types, meaning a copy of the structure's data is created when passed around or assigned, unlike reference types (like arrays) that pass references to the memory location.

Importance of Structures:

Data Organization: Structures help organize related data into a cohesive unit, improving code readability and maintainability. They create a clear representation of complex data entities.
Improved Memory Efficiency: For small datasets, structures can be more memory-efficient than using separate variables for each data member since they hold the data contiguously in memory.
Custom Value Types: Structures provide a way to define custom value types with behavior beyond built-in types. You can include methods and operators within structures to encapsulate data and related operations.
Passing Data by Value: When you pass a structure to a function, a copy of the structure's data is passed, ensuring that changes within the function don't affect the original structure. This can be beneficial for preventing unintended side effects.

Distinguishing Structures from Arrays:

Feature	Arrays	Structures
Data Type	Fixed-size collection of elements of the same type	Group of variables of possibly different data types
Value vs. Reference Type	Reference type (stores memory address)	Value type (stores actual data)
Passing Mechanism	Passes reference to the underlying data block	Passes a copy of the entire structure's data
Inheritance	Can inherit from other arrays or classes	Cannot inherit from other structures or classes
Default Constructor	Has a default constructor that initializes to zeros	No default constructor (needs explicit definition)
Methods and Operators	Generally don't have methods or operators	Can optionally have methods and operators

DEFINING AND INSTANTIATING STRUCTURES IN C#

1. Defining a Structure:

Use the `struct` keyword: to define a structure.
Give it a meaningful name: that reflects its purpose.
Declare member variables: of different data types within the curly braces.

2. Instantiating (Creating) a Structure Instance:

You can create an instance of a structure by declaring a variable of the structure type and then assigning values to its members.

struct Book
{
    public string Title;
    public string Author;
    public int YearPublished;

    // Optional method to display book information
    public void PrintDetails() 
    {
        Console.WriteLine("Title: {0}", Title);
        Console.WriteLine("Author: {0}", Author);
        Console.WriteLine("Year Published: {0}", YearPublished);
    }
}

class Program
{
    static void Main()
    {
        // Create a Book structure instance and assign values
        Book myBook; 
        myBook.Title = "The Hitchhiker's Guide to the Galaxy";
        myBook.Author = "Douglas Adams";
        myBook.YearPublished = 1979;

        // Call the PrintDetails method
        myBook.PrintDetails();
    }
}

COMBINING STRUCTURES WITH NESTED STRUCTURES IN C#

Nested structures allow you to create complex data hierarchies by placing structures within other structures.

Example: Representing a Customer with an Address:

struct Address
{
    public string Street;
    public string City;
    public string State;
    public string ZipCode;
}

struct Customer
{
    public string Name;
    public string Email;
    public Address BillingAddress; // Nested structure member
}

// Accessing Nested Member Variables:
Customer customer1 = new Customer();
customer1.Name = "John Doe";
customer1.Email = "john.doe@example.com";
customer1.BillingAddress.Street = "123 Main St";
customer1.BillingAddress.City = "Anytown";

STRUCTURES AND ARRAYS

You can combine structures and arrays to create powerful data models. Here are two common ways:

Array of Structures:

You can create an array to hold multiple structures of the same type. This allows you to manage collections of related data objects.

struct Point { public int X; public int Y; }
// Array to hold 5 Point structures
Point[] points = new Point[5];
// Access and modify elements
points[0].X = 10;
points[0].Y = 20;

Structure with an Array Member:

A structure can have a member variable that is itself an array. This can be useful for modeling complex entities with variable-length data.

struct Student
{
    public string Name;
    public int[] Scores; // Array of integer scores
}
Student student1;
student1.Name = "Alice";
// Assign scores to the array member
student1.Scores = new int[3] { 90, 85, 92 };

PASSING ARRAYS TO FUNCTIONS

Arrays in C# are reference types. This means when you pass an array to a function, you're passing a reference (memory location) to the array's data. Any changes made to the array elements within the function will be reflected in the original array.

void ModifyArray(int[] numbers)
{
    numbers[0] = 100; // Modify the first element
}
int[] myNumbers = { 1, 2, 3 };
ModifyArray(myNumbers);
Console.WriteLine("Modified array: {0}", string.Join(", ", myNumbers));
// Output: 100, 2, 3

MODULARIZATION

Benefits of Modularization:

Modularization, also known as modular programming, is a fundamental software design technique that involves breaking down a program into smaller, independent, and reusable units called modules (functions, classes, or components). Here are the key advantages it offers:

Improved Code Organization and Readability: By dividing a complex problem into smaller, well-defined modules, the code becomes easier to understand, maintain, and modify.
Enhanced Maintainability: When changes are needed, you can focus on modifying a specific module without affecting unrelated parts of the program.
Reusability: Modular code promotes reusability. Code within modules can be used in different parts of the same program or even across multiple programs.
Reduced Complexity: Modularization helps manage complexity by compartmentalizing different aspects of the program.

DEFINING AND INVOKING FUNCTIONS IN C#

1. Defining Functions:

The general syntax for defining a function (method) in C# is:

access_modifier return_type function_name(parameter_list)
{
    // Function body containing statements and logic
    return value_to_return; // Optional return statement
}

2. Invoking Functions:

Once you've defined a function, you can call it (invoke it) from another part of your code using its name followed by parentheses.

public double CalculateArea(int length, int width)
{
    return length * width;
}

// Invocation
double area = CalculateArea(5, 10);
Console.WriteLine("Area: {0}", area);

FUNCTION OVERLOADING

Function overloading is a powerful feature in C# that allows you to define multiple functions with the same name but different parameter lists (number, types, or order of parameters). The compiler determines which function to call based on the types and number of arguments provided during invocation.

class Calculator
{
    public int Add(int x, int y)
    {
        return x + y;
    }

    public double Add(double x, double y)
    {
        return x + y;
    }

    public string Add(string message1, string message2)
    {
        return message1 + message2;
    }
}

End of Outcome 6 Assessment

1 of 20

Question text will load here.

Assessment Results

Score: 0%

Answered: 0 of 0

Correct: 0

OBJECT ORIENTED PROGRAMMING