Notes on C# Programming

Access Modifiers in C#

In C#, access modifiers control the visibility of classes, methods, and other members:

• Public: Accessible by any code in the same or another assembly.
• Private: Accessible only within the same class or struct.
• Protected: Accessible within the same class, derived classes, or the same assembly.
• Internal: Accessible by any code in the same assembly.
• Protected internal: Accessible by code in the declaring assembly or derived classes in other assemblies.

Default Access Modifiers

In C#, classes are internal by default, while their members are private.

Interfaces in C#

Interfaces in C# can contain methods, properties, events, or indexers. Interface members are always public and cannot include access modifiers or be static.

Sealed Classes

A sealed class in C# cannot be inherited.

Constructor Behavior

If no constructor is explicitly defined, a default constructor is provided by the compiler.

Shadowing and Inheritance

When inheriting classes in C#, the new keyword can be used to indicate shadowing of inherited members.

Extension Methods

Extension methods allow adding new methods to existing types like integers using static classes and methods.

Named Arguments

In C#, named arguments can be used in method calls after positional arguments.

Indexers in C#

class IPAddress {
    public int[] ip;
    public int this[int index] {
        get { return ip[index]; }
        set { ip[index] = value; }
    }
}
IPAddress myIp = new IPAddress();
myIp[0] = 0;

Reference Variables and Generics

Reference variables use ref in both calling arguments and called parameters. They are commonly used in generics.

Conversion and Casting

C# provides various methods for conversions and casting, such as int.Parse for parsing integers and System.Convert.

Unmanaged Code

Unmanaged code in C# refers to code written outside the Common Language Runtime (CLR) and can be accessed using P/Invoke and COM Interop.

P/Invoke in C#

Static extern uint GetShortPathName([MarshalAs(UnmanagedType.LPStr)] string Pathname);

COM Interop

COM Interop in C# involves adding references, using dynamic data types, and utilizing interfaces for communicating with COM components.

Strings in C#

C# provides various constructors and methods for working with strings, including formatting options and immutable string behavior.

Delegates and Events

Delegates and events are powerful features in C# for implementing callbacks and event-driven programming.

Exception Handling

C# supports exception handling using try-catch blocks, custom exceptions, and serialization for cross-AppDomain exceptions.

Understanding Indexers in C#

Indexers in C# provide a way to access elements in a class similar to arrays. They are defined using the this keyword, allowing objects of a class to be indexed like arrays. This feature enhances the flexibility and usability of classes in C#.

How Indexers Work

An indexer in C# is implemented using this keyword followed by square brackets containing the parameters that define the index. It can have one or more parameters based on the requirements. The get accessor is used to retrieve the value of an element at the specified index, while the set accessor is used to assign a value to the element at that index.

Here is a basic example of an indexer in C#:

public string this[int index]
{
    get { return someArray[index]; }
    set { someArray[index] = value; }
}

Benefits of Using Indexers

• Enhanced Readability: Indexers make the code more readable by providing a familiar syntax for accessing elements in a class.
• Custom Data Structures: Indexers allow for the creation of custom data structures that can be accessed using index notation.
• Convenience: Using indexers simplifies the process of accessing elements in a class, especially when dealing with collections or arrays.

Example of Indexer Implementation

Let’s consider an example where we create an indexer in a class to store and retrieve values based on a custom index:

public class CustomCollection
{
    private string[] data = new string[10];

    public string this[int index]
    {
        get { return data[index]; }
        set { data[index] = value; }
    }
}

Conclusion

Indexers in C# provide a powerful mechanism to access elements in a class in a way that resembles array indexing. By implementing indexers, developers can enhance the usability and functionality of their classes, making the code more intuitive and efficient.

Tags: C#, Programming World

The Power of LINQ in C# Programming

Introduction

LINQ (Language Integrated Query) is a powerful feature in C# that allows developers to write structured, type-safe queries over local object collections and remote data sources. It provides a more intuitive way to interact with data by using a set of query operators.

Key Concepts in LINQ

1. Sequences and Elements

In LINQ, sequences represent collections of data, while elements refer to individual items within those collections.

2. Query Operators

LINQ offers a wide range of query operators to manipulate data, including:
– Take, Skip, and Reverse for pagination.
– FirstOrDefault, LastOrDefault, SingleOrDefault, or ElementAtOrDefault for retrieving specific elements.
– Aggregation operators like Count, Min, Max, and Average for performing calculations.
– Contains, Any, All, and SequenceEquals for checking conditions.
– Concat, Union, Intersect, and Except for combining sets.

3. Lazy Evaluation

LINQ uses deferred or lazy evaluation, meaning that queries are not executed until the results are actually needed. However, lazy execution can be overridden by certain operators like element operators, aggregation operators, and conversion operators such as ToArray, ToList, ToDictionary, and ToLookup.

4. Chaining Query Operators

Developers can chain multiple query operators together to create complex queries that efficiently manipulate data.

5. Query Comprehension Syntax

LINQ supports query syntax or query comprehension syntax, which provides advantages such as:
– Ability to use let clauses to introduce new variables.
– Multiple generators (SelectMany) or Join/GroupJoin equivalents for complex queries.
– Proper scoping rules where variables declared in earlier parts of the query are accessible in subsequent parts.

6. Type Conversion

LINQ provides operators like Cast and OfType for type conversions, allowing developers to work with specific data types within their queries.

Conclusion

LINQ is a versatile tool in C# programming that simplifies data manipulation and querying. By leveraging LINQ’s query operators and syntax, developers can write efficient and expressive code to interact with various data sources seamlessly. Mastering LINQ can greatly enhance a developer’s productivity and the performance of their applications.

Threading in C# Programming

Threading in C# allows developers to create multitasking applications by executing multiple operations concurrently. Here are some key points to understand about threading in C#:

1. System.Threading Namespace

The System.Threading namespace in C# provides classes and interfaces that enable multithreaded programming. It includes classes like Thread, Mutex, Monitor, and more, to support synchronization and threading operations.

2. Creating and Managing Threads

Thread t = new Thread(fn); // Here, a new thread is created by passing a delegate to the Thread constructor

A thread’s IsAlive property remains true until the thread completes its execution. Threads have their own memory stack, with each thread having a separate copy of local variables.

3. Sharing Data Between Threads

• Threads can share data if they have a common reference to the same object instance. Static fields provide another way to share data between threads.
• To ensure thread safety and deterministic output, exclusive locks can be used while reading and writing to shared fields.
• When multiple threads contend for a lock, one thread waits or blocks until the lock becomes available, ensuring that critical sections are executed one at a time.

4. Thread Synchronization

Methods like Sleep and Join can be used for thread synchronization:

• When a thread calls Sleep, it waits for a specific time without consuming CPU resources.
• The Join method allows one thread to wait for another thread to complete its execution. It returns true if the thread ended or false if it timed out.
• Sleep(0) relinquishes the current thread’s time slice to the CPU immediately, while the Yield function allows other processes on the same processor to execute.

Understanding threading concepts and synchronization mechanisms is essential for developing efficient and scalable applications in C#.

Reflection in C# Programming

Reflection in C# is a powerful feature that allows developers to inspect and manipulate types, methods, properties, and other members of objects at runtime. It provides a way to obtain metadata about types in the code, such as class hierarchies, interfaces implemented, methods available, and more.

Key Points about Reflection:

• Enables us to get information about objects at runtime.
• Using GetField(varName, BindingFlags.XXX | BindingFlags.YYY) allows accessing fields of a class through reflection.
• Methods like SetValue(null, newInt) and GetValue(null) help in setting and getting values dynamically.
• Classes like Typeof and System.Type provide information about types, while methods like IsAbstract, IsClass, GetConstructors(), and GetMethods() allow further exploration of classes and methods.

Performance Thumb Rules

• Cache variables: Storing frequently accessed data in memory can significantly improve performance by reducing the need to recalculate values.
• Move max code out of loops: In order to enhance performance, it is important to minimize the amount of code within loops, especially repetitive calculations or function calls.
• Factoring control statements: Refactoring control statements such as loops and conditionals can lead to more efficient code execution and better performance.
• Use switch statements: Switch statements are often more efficient than nested if-else statements, especially when dealing with multiple conditional branches.

Parameter Passing

In C#, when calling a method or function, parameters can be passed in different ways depending on the requirements. Here are the common ways of passing parameters:

1. Pass by Value

Pass by value involves passing a copy of the parameter’s value to the method. Any changes made to the parameter within the method do not affect the original value outside the method.

2. Pass by Reference (ref)

Passing by reference allows the method to modify the actual value of the parameter. Changes made to the parameter within the method are reflected in the original value outside the method.

3. Pass as Out

Passing as out requires the parameter to be assigned within the method before returning. It is often used when a method needs to return multiple values.

4. Pass as Param

Passing as param allows passing any number of similar parameters to a method. This can be useful when working with variable-length argument lists.

Understanding the different ways of parameter passing in C# is essential for writing efficient and effective code.

Performance For Generics

Introduction

When working with generics in C#, it is essential to consider performance implications. The choice between using generics or objects can significantly impact the efficiency of your code.

Key Points to Consider:

• When we use object instead of a generic variable for value types, we incur overhead due to boxing. This inefficiency arises from the need to convert value types to objects, leading to performance degradation.
• Type safety during downcasting is crucial. Using generics ensures type safety, reducing the risk of runtime errors related to type mismatches.
• The server compiler compiles generics into Intermediate Language (IL), incorporating placeholders for types and associated metadata. This approach enables efficient handling of generic types during compilation.
• Client compilers convert IL to machine code, optimizing the performance for both value and reference types. This process involves replacing values directly and efficiently handling references by using objects where necessary. Emphasis is placed on code reuse rather than object reuse to enhance performance.
• Significant performance gains can be achieved by utilizing generics appropriately. Expect around a 200% performance improvement for value types and a 100% enhancement for reference types by leveraging generics effectively.

Conclusion

Understanding the performance implications of using generics in C# is crucial for developing efficient and optimized code. By prioritizing type safety and leveraging generics’ capabilities, developers can enhance the performance of their applications significantly.

The Importance of Namespaces in C# Programming

When working with C# programming, namespaces play a crucial role in organizing and categorizing code elements. They help prevent naming conflicts, improve code readability, and enhance code reusability.

The global:: Keyword

The global:: keyword is used to access root-level namespaces. It ensures that the compiler starts searching for the namespace from the global namespace scope.

Alias Declaration

Alias declarations provide a way to create a shorthand reference for a namespace or a type. For example, using PropertyInfo2 = System.Reflection.PropertyInfo; creates an alias for System.Reflection.PropertyInfo, allowing for easier and more concise usage.

Commonly Used System Namespaces

• System.Numerics: Contains numeric types that complement the existing numeric primitives in C#.
• System.Boolean, System.Convert, System.String: Fundamental namespaces for handling boolean values, type conversions, and string operations respectively.
• System.Collections: Provides higher-level data structures like arrays and dictionaries for efficient data manipulation.
• System.Object: Serves as the base class for all types in C#, forming the root of the type hierarchy.
• System.Collections.Generic: Offers interfaces for mutable collections, essential for working with generic types.
• System.Delegate: Contains the necessary types for defining and working with delegates, a key feature of C# for implementing callbacks and event handling.
• System.Exception: Handles exceptions and errors in C# applications, allowing for robust error management.
• System.Attribute: Supports the creation and consumption of custom attributes in C# code, enabling metadata annotations for types and members.
• System.Web.Services: Specifically designed for building SOAP-based web services, providing the necessary components for web communication.

By utilizing these namespaces effectively in your C# projects, you can streamline development, promote code organization, and leverage the rich set of functionalities offered by the .NET framework.

Miscellaneous

Categories

C#

IT Notes

Tags

C#

Programming World

Content

• The foreach statement is a consumer of an enumerator, while an iterator is a producer of an enumerator.

• yield and yield break are keywords used in C# to create iterators.

• int? i = null; The ? allows the variable i to be assigned a null value in C#.

• Extension methods in C# allow an existing type to be extended with new methods without altering its original structure.

• In C#, an instance method takes precedence over an extension method if both exist with the same signature.