34. enum
An enum (enumeration) is a named set of constants, making code
more readable and maintainable by replacing magic numbers with
meaningful names.
Example:
enum DayOfWeek { Sunday, Monday, Tuesday, Wednesday,
Thursday, Friday, Saturday }
DayOfWeek today = DayOfWeek.Monday;
Enums improve code clarity and reduce errors
by restricting values to predefined options.
35. delegate
A delegate is a type-safe function pointer
that stores references to methods and allows methods to be passed as
parameters.
Example:
delegate void PrintMessage(string message);
void Print(string msg) => Console.WriteLine(msg);
PrintMessage printer = Print;
printer(“Hello, Delegates!”);
Delegates enable callbacks, event handling, and flexible
method invocation.
36. event
An event is a specialized delegate used in the
observer pattern, allowing subscribers to listen for changes and react
dynamically.
Example:
class Button
{
public event
Action Clicked; // Declaring an event
public void
Press() => Clicked?.Invoke(); //
Trigger event
}
var button = new Button();
button.Clicked += () => Console.WriteLine(“Button
clicked!”); // Subscribing
button.Press();
Events enable publish-subscribe communication,
improving modularity.
37. partial class
A partial class allows splitting a class definition across
multiple files, useful for large projects, auto-generated code, or
maintaining cleaner code.
Example:
File 1:
partial class Car
{
public void
Drive() { Console.WriteLine(“Driving…”); }
}
File 2:
partial class Car
{
public void
Brake() { Console.WriteLine(“Braking…”); }
}
Partial classes improve code organization and collaborative
development.
38. partial method
A partial method is a method declared in a partial
class that only compiles if implemented in another file.
Example:
partial class Logger
{
partial void
Log(string message);
}
partial class Logger
{
partial void
Log(string message)
{
Console.WriteLine(“Log: ” + message);
}
}
Partial methods are useful for auto-generated code,
allowing optional developer overrides.
39. sealed
A sealed class cannot be inherited, and a sealed
method cannot be overridden in derived classes. This is useful for security,
performance, and enforcing final implementations.
Example:
sealed class FinalClass { }
// Sealed method example
class Base
{
public virtual
void Show() { Console.WriteLine(“Base”); }
}
class Derived : Base
{
public sealed
override void Show() { Console.WriteLine(“Derived”); }
}
Sealed classes prevent unintended inheritance and optimize
runtime performance.
40. abstract
An abstract class serves as a base class that cannot
be instantiated, while abstract methods are required to be
implemented in derived classes.
Example:
abstract class Animal
{
public abstract
void MakeSound(); // No implementation
}
class Dog : Animal
{
public override
void MakeSound() { Console.WriteLine(“Bark!”); }
}
Abstract classes provide a template for subclasses,
enforcing structure while allowing flexibility.
41. abstract method
An abstract method is a method that is declared in a
base class but has no implementation. It acts as a blueprint, enforcing that
any derived class must provide a concrete implementation. Abstract methods can
only be declared within abstract classes, meaning the class itself is
incomplete and cannot be instantiated directly.
For example, in C#:
abstract class Animal {
public abstract
void MakeSound(); // No implementation
}
class Dog : Animal {
public override
void MakeSound() {
Console.WriteLine(“Bark!”);
}
}
Here, MakeSound() is abstract in Animal, and Dog must
override it. This ensures all animals define their own sound. Abstract methods
enforce consistency across subclasses while allowing flexibility in
implementation.
They are useful in scenarios where a common interface is
required, but the behavior must be determined by individual subclasses. This
follows the Liskov Substitution Principle (LSP) in Object-Oriented
Programming (OOP), ensuring that derived classes can be used interchangeably
with their base types.
42. virtual method
A virtual method is a method in a base class that
provides a default implementation but allows derived classes to override it if
needed. Unlike abstract methods, virtual methods do not force derived classes
to provide an implementation—they have the option to do so.
Example in C#:
class Animal {
public virtual
void MakeSound() {
Console.WriteLine(“Some generic animal sound”);
}
}
class Dog : Animal {
public override
void MakeSound() {
Console.WriteLine(“Bark!”);
}
}
Here, MakeSound() is virtual, meaning it has a
default behavior, but Dog can (and does) override it. If Dog did not override
it, it would inherit the base class behavior.
Virtual methods allow for polymorphism, enabling
dynamic method invocation at runtime. This is particularly useful in scenarios
like designing extensible frameworks where subclasses can modify only necessary
behaviors without reimplementing everything.
43. override
The override keyword in C# is used in a derived class to
provide a new implementation for a virtual or abstract method
from its base class. The overriding method must have the same signature as the
base method.
Example:
class Animal {
public virtual
void Speak() {
Console.WriteLine(“Animal speaks”);
}
}
class Dog : Animal {
public override
void Speak() {
Console.WriteLine(“Bark!”);
}
}
Here, Speak() in Dog overrides the base class
implementation, ensuring that when called on a Dog object, the specific method
runs instead of the base version.
Overriding is a key feature of runtime polymorphism,
allowing objects to be treated as their base type while executing derived-type
behavior. Overridden methods replace base implementations but still
allow calling the base version using base.MethodName() if needed.
44. new keyword (hiding/shadowing)
The new keyword in C# is used to hide or shadow
a member (method, property, or field) from the base class rather than
overriding it. It is different from override, as it does not participate in
polymorphism.
Example:
class BaseClass {
public void
Display() {
Console.WriteLine(“Base class method”);
}
}
class DerivedClass : BaseClass {
public new void
Display() {
Console.WriteLine(“Derived class method”);
}
}
If you declare a DerivedClass object but reference it as a BaseClass,
the base method will be called. Unlike overriding, new keyword hides the
base method instead of replacing it.
Hiding can be useful when dealing with legacy code but is
generally discouraged because it can lead to confusion and maintenance issues.
45. access modifiers
Access modifiers in C# define visibility and
accessibility of classes, methods, and variables. They enforce
encapsulation and determine how members are accessed across different classes
and assemblies.
- public
→ Accessible from anywhere. - private
→ Accessible only within the same class. - protected
→ Accessible within the same class and derived classes. - internal
→ Accessible within the same assembly (project). - protected
internal → Accessible within the same assembly OR by derived classes. - private
protected → Accessible only within the same assembly AND by derived
classes.
Choosing the right access modifier is crucial for designing secure
and maintainable code.
46. public
A public member is accessible from anywhere, inside
or outside the class or assembly. This is the least restrictive access
level.
Example:
class Example {
public int Value =
10;
}
Example obj = new Example();
Console.WriteLine(obj.Value); // Allowed
While public is convenient, overusing it can lead to poor
encapsulation, making code harder to maintain.
47. private
A private member is only accessible within the same class.
This is the most restrictive modifier, enforcing data hiding and
encapsulation.
Example:
class Example {
private int value
= 10;
}
Attempting to access value from outside the class results in
a compilation error. Private fields are often accessed via public methods
(getters and setters) to control access.