Class

Sealed class is a class which is instantiable, but not inheritable. You can use a sealed class when you don't want to let other developers create child classes for the specific class.

sealed class Class1 {
}

class Class2 : Class1  // not possible
{
}

Partial Class is a class that splits into multiple files. Each file is treated as a "part of the class."

// File1.cs
partial class ClassName {
    member1
}

// File2.cs
partial class ClassName {
    member2
}

// Compiled source code in assembly
class ClassName {
    member1
    member2
}

• At compilation time, all partial classes that have the same name, become a "single class".
• All the partial classes (that want to be a part of a class) should have the same name and should be in the same namespace and the same assembly, and should have the same access modifier (such as 'internal' or 'public').
• Duplicate members are not allowed in partial classes.
• Any attributes/modifiers (such as abstract, sealed) applied on one partial class will be applied to all partial classes that have the same name.
• The 'partial' keyword can be used only before the keywords 'class', 'struct', 'interface', and 'void'.
• Each partial class can be developed individually by different developers/teams.
• In WinForms/WebForms, the 'Designer-generated code' will be kept in one partial class; the 'code written by the developer' will be kept in another partial class with the same name, so both become a single class at compilation time.

Static class is a class that can contain only "static members".

• If you don't want even a single 'instance member' (non-static member), then use 'static class'.
• We can avoid accidental creation of object for the class, by making it a "static class".

static class ClassName {
    static fields
    static methods
    static constructors
    static properties
    static events
}

Special syntax to initialize fields / properties of a class, along with creating the object.

• Executes after the constructor.
• It is only for initialization of fields / properties, after creating the object; it can't have any initialization logic.

new ClassName() { field1 = value, field2 = value, ... }

Execution sequence:

new Class() ---> Constructor ---> Object Initializer

Destructor is a special method of the class, which is used to close un-managed resources (such as database connections and file connections), that are opened during the class execution.

~ClassName() {
    // body here...
}

• Is like __delete__ in Python
• Destructor doesn't de-allocate any memory; it just will be called by CLR (.net runtime engine) automatically, just before a moment of deleting the object of the class.
• Destructor's name should be same as class name, started with ~ (tilde) character.
• A Destructor is unique to its class i.e. there cannot be more than one destructor in a class.
• Destructor can't have parameters or return value.
• Destructor is public by default, we can't change its access modifier.
• Destructor doesn't support any other modifiers such as virtual, abstract, override etc.
• Destructors can be defined only in classes; but not in structs, interfaces etc.
• Destructors can't be overloaded or inherited.
• Destructors are usually called at the end of program execution.

The IDisposable interface of the System namespace has a method called Dispose, which is used to close un-managed resources that are created during the lifetime of the object.

• Is like context manager in Python

// Implementing System.IDisposable interface
class ClassName : System.IDisposable {
    public void Dispose()
    {
        // Close un-managed resources here
    }
}

// Creating object with IDisposable
using (ClassName referenceVariable = new ClassName()) {
    // Your code here
}

You can prefix the using keyword before the local variable declaration in order to call the Dispose method when that variable goes out of scope.

public void Method() {
    using ClassName referenceVariable = new ClassName();

    // do work here

} // Dispose will be called automatically here

Generic class is a class, which contains one or more "type parameters". You must pass any data type (standard data type/structure/class) while creating an object for the generic class.

class ClassName<T> {
    public T FieldName;
}

ClassName<int> referenceVariable = new ClassName<int>();

Generic Constraints are used to specify the types allowed to be accepted in the generic type parameter.

• where T : class
• where T : struct
• where T : ClassName
• where T : InterfaceName
• where T : new()

class ClassName<T> where T : class {
    public T FieldName;
}

ClassName<int> referenceVariable = new ClassName<int>();   // error

Example:

public class MarksPrinter<T1, T2> where T1 : Student where T2 : Employee

Covariance allows you to supply child type, where the parent type is expected.

• Implemented with the out keyword for the generic type parameter of an interface.
• In this case, the generic type parameter can be used for return types of methods or properties created in the interface.

InterfaceName<ParentType> variable = new ClassName<ChildType>();

Example:

// "out" indicates covariance in the interface

namespace System.Collections.Generic {
    public interface IEnumerable<out T> : IEnumerable
    {
        IEnumerator<T> GetEnumerator();
    }
}

Contravariance allows you to supply a parent type, where the child type is expected.

• Implemented with the in keyword for the generic type parameter of an interface.
• In this case, the generic type parameter can be used for parameter types of methods created in the interface.

InterfaceName<ChildType> variable = new ClassName<ParentType>();

Example:

// "in" indicates contravariance in the interface

public interface IComparable<in T>

The System.Tuple class represents a set of values of any data type.

• Introduced in C# 4.0.
• Useful to return multiple values from a method or to pass multiple values to a method.
• Represents a set of values quickly without creating a separate class.
• Alternative to anonymous objects (to be used as parameter types / return types).

// Step 1: Object of Tuple class
var referenceVariable = new Tuple<type1, type2, ...>( ) { value1, value2, ... };

// Step 2: Accessing Elements
referenceVariable.Item1     // returns value1
referenceVariable.Item2     // returns value2

• Tuple stores only a set of values (of any data type); but doesn't store property names.
• So you should access them as Item1, Item2, etc.; which doesn't make sense sometimes.
• Tuple supports up to 8 elements only by default.
• You can store more than 8 values by using nested tuples (tuple inside tuple).
• Tuples are mainly used to pass multiple values to a method as parameter; and also return multiple values from a method.
• It's very useful for returning multiple value from a method
• Also we can use it for accepting multiple values in one method parameter

Example:

// Create a new Tuple that stores person name and age
Tuple<string, int> person = new Tuple<string, int>("Scott", 20);

// Access values from tuple
Console.WriteLine(person.Item1); // Scott
Console.WriteLine(person.Item2); // 20

'Value Tuples' are an advancement to the 'Tuple' class with simplified syntax.

• Introduced in C# 7.1.
• Supports unlimited values.
• You will access elements with real field names; instead of Item1, Item2, etc.
• Can be used as method parameters/return values; much like the Tuple class.
• In this cases we will store all the tuple elements in one variable.

// Step 1: Creating Value Tuple
(type fieldName1, type fieldName2, ...) referenceVariable = (value1, value2, ...);

// Step 2: Accessing Elements
referenceVariable.fieldName1 // returns value1
referenceVariable.fieldName2 // returns value2
...

Deconstruction allows you to assign elements of value tuple into individual local variables.

• In this case we will directly store the tuple elements into multiple variable.

// Step 1: Create Value Tuple
(type fieldName1, type fieldName2, ...) referenceVariable = (value1, value2, ...);

// Step 2: Deconstruction
(type variableName1, type variableName2, ...) = referenceVariable;

Discard allows you to skip a value which you don't require, by using underscore ( _ ).

// Step 1: Create Value Tuple
(type fieldName1, type fieldName2) referenceVariable = (value1, value2);

// Step 2: Deconstruction with Discard
(type variableName1, _) = referenceVariable;