1. Single line

Example:

//This is a single line comment

2. XML Comments (///).

Eg:

/// summary;
/// Set error message for multilingual language.
/// summary

3. Multiple line (/ /)

Example:

/This is a multiple line comment
We are in line 2
Last line of comment/

• C is being a procedural language whereas C# is an object-oriented language.
• C# sustains automatic garbage collection by Common Language Runtime (CLR) whereas C does not.
• C# mainly needs a .NET framework to run whereas C is a platform-agnostic language.

It is an abstract class that uses only public abstract techniques, and the methods only can declared but are not able to define. These abstract procedures need to implement in the inherited classes.

using System;
using System.Collections.Generic;
using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace DemoApplication

{

interface JobinterviewninjasInterface

{

void SetTutorial(int pID, string pName);

String GetTutorial();

}

class JobinterviewninjasTutorial : JobinterviewninjasInterface

{

protected int TutorialID;

protected string TutorialName;

public void SetTutorial(int pID, string pName)

{

TutorialID = pID;

TutorialName = pName;

}

public String GetTutorial()

{

return TutorialName;

}

static void Main(string[] args)

{

JobinterviewninjasTutorial pTutor = new JobinterviewninjasTutorial();

pTutor.SetTutorial(1,".Net by Jobinterviewninjas”);

Console.WriteLine(pTutor.GetTutorial());

Console.ReadKey();

}

}

}

A value type carries a data value in its memory space. Example

int a = 30;

Reference type reserves the address of the object where the value is being kept. It acts as a pointer to another memory location.

string b = “Hello Jobinterviewninjas!!";

We use try-catch blocks to catch an exception. The catch block needs to have a parameter of the system.Exception type.

Eg:

try {

GetAllData();

}

catch (Exception ex) {

}

• If the occupied memory surpasses the pre-set threshold value
• If the garbage collection method is called up
• If your system is on low physical memory

C# has four different types of classes:

Static class: As the name itself says, the ‘static’ keyword doesn’t allow inheritance. So, you are not able to make an object for a static class.

Sample code:

static class classname

{
//static data members
//static methods
}

Partial class: As the name itself says, the ‘partial’ keyword permits its members to partially separate or share source (.cs) files.

Abstract class: Abstract classes can’t be instantiated and don’t allow you to create objects. It works on the OOPS concept of abstraction. It extracts the essential details and hides the unessential ones.

Sealed class: These classes can’t be inherited and use the keyword sealed to do the same.

sealed class Jobinterviewninjas

{
// data members
// methods
.
.
.
}

Managed code allows you to execute the code on a controlled CLR runtime environment in the .NET framework. It executes on the managed runtime atmosphere than the operating system itself. It gives services like a garbage collector, exception handling, etc.

Unmanaged code is when the code doesn’t operate on CLR, and functions outside the .NET framework. It doesn’t deliver high-level languages services and executes without them. For example C++.

• Abstract classes cannot be instantiated which means that they cannot make an object. The interface is similar to the abstract class as all the methods inside the interface are abstract.
• Abstract classes have both that is abstract and non-abstract methods whereas interface only has are abstract methods.
• In abstract classes, we need to declare abstract methods as it uses both methods. In interface, there is no such requirement.
• An abstract class contains constructors whereas an interface encompasses none.

Example:

Abstract class:

public abstract class Shape{
public abstract void draw();
}
Interface:
public interface Paintable{
void paint();
}

C# ref keywords pass arguments by reference and not by value. You need to mention ‘ref’ to use the ‘ref’ keyword.

void Method(ref int refArgument)
{
refArgument = refArgument + 10;
}
int number = 1;
Method(ref number);
Console.WriteLine(number);
// Output: 11

C# out keywords pass arguments within the given methods and functions. To return numerous values, the ‘out’ keyword is used to pass arguments in a method. The ref and out keywords are useful when we want to bring back a value in the similar variables that are passed as an argument.

public static string GetNextFeature(ref int id)
{
string returnText = “Next-” + id.ToString();
id += 1;
return returnText;
}
public static string GetNextFeature(out int id)
{
id = 1;
string returnText = “Next-” + id.ToString();
return returnText;
}

It allows us to add new methods to the current ones. The methods which will be added are static. Sometimes you want to add methods to the current class but don’t get the right to change that class then you can make a new static class using the new methods. Once the methods are declared, attach this class with the current one and notice that the methods will be added to the current one.

// C# program to illustrate the concept

// of the extension methods

using System;

namespace ExtensionMethod {

static class NewMethodClass {

// Method 4

public static void M4(this Scaler s)

{

Console.WriteLine(“Method Name: M4”);

}

// Method 5

public static void M5(this Scaler s, string str)

{

Console.WriteLine(str);

}

}

// Now we create a new class in which

// Scaler class access all the five methods

public class IB {

// Main Method

public static void Main(string[] args)

{

Scaler s = new Scaler();

s.M1();

s.M2();

s.M3();

s.M4();

s.M5(“Method Name: M5”);

}

}

}

Output:

Method Name: M1

Method Name: M2

Method Name: M3

Method Name: M4

Method Name: M5

Inheritance means obtaining some properties from a master class.

Here is an example of inheritance where class C can inherit properties from Class A and Class B

// C# program to illustrate

// multiple class inheritance

using System;

using System.Collections;

// Parent class 1

class Scaler {

// Providing the implementation

// of features() method

public void features()

{

// Creating ArrayList

ArrayList My_features= new ArrayList();

// Adding elements in the

// My_features ArrayList

My_features.Add(“Abstraction”);

My_features.Add(“Encapsulation”);

My_features.Add(“Inheritance”);

Console.WriteLine(“Features provided by OOPS:");

foreach(var elements in My_features)

{

Console.WriteLine(elements);

}

}

}

// Parent class 2

class Scaler2 :Scaler{

// Providing the implementation

// of courses() method

public void languages()

{

// Creating ArrayList

ArrayList My_features = new ArrayList();

// Adding elements in the

// My_features ArrayList

My_features.Add(“C++”);

My_features.Add(“C#");

My_features.Add(“JScript”);

Console.WriteLine("\nLanguages that use OOPS concepts:");

foreach(var elements in My_features)

{

Console.WriteLine(elements);

}

}

}

// Child class

class ScalertoScaler : Scaler2 {

}

public class Scaler1 {

// Main method

static public void Main()

{

// Creating object of ScalertoScaler class

ScalertoScaler obj = new ScalertoScaler();

obj.features();

obj.languages();

}

}

Also, the C# language doesn’t support multiple inheritances. Rather, you can use interfaces.

Boxing: Boxing changes value type (char, int, etc.) to reference type (object) that makes an implicit conversion method using object value.

Example:

int num = 23; // 23 will assigned to num
Object Obj = num; // Boxing

Unboxing: Unboxing changes reference type (object) to value type (char, int, etc.) by using an explicit conversion method that is opposite of it.

Example:

int num = 23; // value type is int and assigned value 23
Object Obj = num; // Boxing
int i = (int)Obj;// Unboxing

Partial classes apply the functionality of one class into several files. These multiple files are collected into one at the time of compilation. By using the partial keyword, a partial class is made.

public partial Clas_name

{

// code

}

You can easily divide the functionalities of procedures, interfaces, or structures into different multiple files.

Early Binding: When the binding function occurs during the compile-time, it is named early binding. It analyzes and inspects the methods and properties of static objects. It decreases the number of run-time errors substantially and it runs pretty quickly.

Late Binding: When the binding occurs at runtime, it is named late binding. Late binding occurs when the objects are dynamic at run-time. It executes slowly as it examines through during run-time.

When a group of the same elements is combined together under one name then the arrays are formed. The memory allotments for the elements of the array occur dynamically.

A few pointers for arrays in C#:

• The memory allotment is DYNAMIC.
• Arrays in C# are considered objects.
• By noticing the number of members in the array, the length of the array can easily be found.
• The array members are ordered and start with the index value=0.
• The array types are reference types emanated from the base array type.

Syntax: < Data Type > [ ] < Name_Array >

Indexers are also known as a smart array that permits access to a member variable. Indexers permit member variables to use the features of an array. By using the Indexer keyword Indexers are made and they are not static members.

For example:

<return type> this[ index]
{
get{
// return the value from the specified index of an internal collection
}
set{
// set values at the specified index in an internal collection
}
}

Though Equality Operator (==) and Equals() Method, both compare two objects by value, but still used differently.

For ex.:

int x = 10;

int y = 10;

Console.WriteLine( x == y);

Console.WriteLine(x.Equals(y));

Output:

True

True

• Equality operator (==): It is used, to bring back true only if both references point belongs to the same object. It is of reference type.
• Equals() method: It is used to compare the objects values. For example the values are int x=10, int y=10 and If x==y is matched or compared then, the values of x and y is equal or the same then they return true.
• Equals(): Compares by value
• Equality operator: Compares by reference

Overloading represents when a method has a similar name but holds different values to use in a separate context. The main() method cannot be overloaded other than that overloading is done in C# some of the methods are.

• Change the number of parameters in a method, or
• Use different data types for parameters
• Change the order of parameters in a method, or

For example.

public class Area {

public double area(double x) {

double area = x * x;

return area;

}

public double area(double a, double b) {

double area = a * b;

return area;

}

}

During runtime, reflection abstracts metadata from the datatypes.

In the .NET framework to add reflection just use System.Refelction namespace in the programming code to retrieve the type which can be anything from the following:

• Assembly
• Enum
• Module
• MethodInfo
• MemberInfo
• ConstructorInfo
• FieldInfo
• ParameterInfo
• PropertyInfo
• Type
• EventInfo

The foremost difference between both of them is String objects are immutable whereas StringBuilder makes a mutable string of characters. StringBuilder does the modifications to the existing object. StringBuilder streamlines the entire procedure of constructing changes to the prevailing string object. As we know String class is immutable, it is costlier to create a new object every time we need to make a change. So, the StringBuilder class comes into the picture which can be evoked using the System.Text namespace.

In case, a string object will not change throughout the entire program, then use String class or else StringBuilder.

For ex:

string s = string.Empty;

for (i = 0; i < 1000; i++)

{

s += i.ToString() + " “;

}

Here, you’ll need to create 2001 objects out of which 2000 will be of no use.

The same can be applied using StringBuilder:

StringBuilder sb = new StringBuilder();

for (i = 0; i < 1000; i++)

{

sb.Append(i); sb.Append(’ ‘);

}

By using StringBuilder here, you also de-stress the memory allocator.

internal static void ReverseString(string str)

{

char[] charArray = str.ToCharArray();

for (int i = 0, j = str.Length - 1; i < j; i++, j–)

{

charArray[i] = str[j];

charArray[j] = str[i];

}

string reversedstring = new string(charArray);

Console.WriteLine(reversedstring);

internal static void ReverseWordOrder(string str)

{

int i;

StringBuilder reverseSentence = new StringBuilder();

int Start = str.Length - 1;

int End = str.Length - 1;

while (Start > 0)

{

if (str[Start] == ' ‘)

{

i = Start + 1;

while (i <= End)

{

reverseSentence.Append(str[i]);

i++;

}

reverseSentence.Append(’ ‘);

End = Start - 1;

}

Start–;

}

for (i = 0; i <= End; i++)

{

reverseSentence.Append(str[i]);

}

Console.WriteLine(reverseSentence.ToString());

}

internal static void chkPalindrome(string str)

{

bool flag = false;

for (int i = 0, j = str.Length - 1; i < str.Length / 2; i++, j–)

{

if (str[i] != str[j])

{

flag = false;

break;

}

else

flag = true;

}

if (flag)

{

Console.WriteLine(“Palindrome”);

}

else

Console.WriteLine(“Not Palindrome”);

Output:

Input: Key Output: Not Palindrome

Input: step on no pets Output: Palindrome

internal static void findallsubstring(string str)

{

for (int i = 0; i < str.Length; ++i)

{

StringBuilder subString = new StringBuilder(str.Length - i);

for (int j = i; j < str.Length; ++j)

{

subString.Append(str[j]);

Console.Write(subString + " “);

}

}

}

static void Main(string[] args)

{

if (FindPrime(47))

{

Console.WriteLine(“Prime”);

}

else

{

Console.WriteLine(“Not Prime”);

}

Console.ReadLine();

}

internal static bool FindPrime(int number)

{

if (number == 1) return false;

if (number == 2) return true;

if (number % 2 == 0) return false;

var squareRoot = (int)Math.Floor(Math.Sqrt(number));

for (int i = 3; i <= squareRoot; i += 2)

{

if (number % i == 0) return false;

}

return true;

}

• ArgumentException
• InvalidCastException
• ArgumentNullException
• OverflowException
• ArgumentOutOfRangeException
• IOEndOfStreamException
• ArithmeticException
• DivideByZeroException
• NullReferenceException
• IndexOutOfRangeException
• OutOfMemoryException
• InvalidOperationException
• StackOverflowException

A Colon can be used as an inheritance operator in C#. You just need to place a colon and then the class name.

public class DerivedClass : BaseClass