Why do we have to make the GetInstance() method or Instance Property of a Singleton class Static?

Because the constructor of the singleton class is private and can't be accessed from the outside world. Therefore there is no other way for us to access the methods of this class than making it static.

What is an Assembly in C# .Net?

An assembly is the compiled output of your code, typically a DLL, but your EXE is also an assembly. It's the smallest unit of deployment for any .NET project.

The assembly typically contains .NET code in MSIL (Microsoft Intermediate language) that will be compiled to native code ("JITted" - compiled by the Just-In-Time compiler) the first time it is executed on a given machine. That compiled code will also be stored in the assembly and reused on subsequent calls.

The assembly can also contain resources like icons, bitmaps, string tables and so on. Furthermore, the assembly also contains metadata in the assembly manifest - information like version number, strong name, culture, referenced assemblies and so forth.

In 99% of your cases, one assembly equals a physical file on disk - the case of a multi-file assembly (one assembly, distributed across more than a single file) appears to be a rather odd-ball edge case

In a multifile assembly there would still be only one assembly manifest in a DLL or EXE and the MSIL code in multiple netmodule files. 

What are access modifiers in C#?

Access modifiers are keywords used to specify the declared accessibility of a member or a type.

 

Why to use access modifiers?

 

Access modifiers are an integral part of object-oriented programming. They support the concept of encapsulation, which promotes the idea of hiding functionality. Access modifiers allow you to define who does or doesn't have access to certain features.

 

In C# there are 5 different types of Access Modifiers.

Modifier	Description
public	There are no restrictions on accessing public members.
private	Access is limited to within the class definition. This is the default access modifier type if none is formally specified
protected	Access is limited to within the class definition and any class that inherits from the class
internal	Access is limited exclusively to classes defined within the current project assembly
protected internal	Access is limited to the current assembly and types derived from the containing class. All members in current project and all members in derived class can access the variables.

public

 

The public keyword is an access modifier for types and type members. Public access is the most permissive access level.

 

There are no restrictions on accessing public members.

 

Accessibility: 

• Can be accessed by objects of the class
• Can be accessed by derived classes

Example: In the following example num1 is direct access.

 

using System;

 

namespace AccessModifiers

{

    class Program

    {

        class AccessMod

        {

            public int num1;

        }

        static void Main(string[] args)

        {

            AccessMod ob1 = new AccessMod();

 

            //Direct access to public members

            ob1.num1 = 100;

 

            Console.WriteLine("Number one value in main {0}", ob1.num1);

            Console.ReadLine();

        }

    }

}

 

private

 

Private access is the least permissive access level.

 

Private members are accessible only within the body of the class or the struct in which they are declared.

 

Accessibility: 

• Cannot be accessed by object
• Cannot be accessed by derived classes

Example: In the following example num2 is not accessible outside the class.

 

using System;

 

namespace AccessModifiers

{

    class Program

    {

        class AccessMod

        {

            public int num1;

            int num2;

        }

        static void Main(string[] args)

        {

            AccessMod ob1 = new AccessMod();

 

            //Direct access to public members

            ob1.num1 = 100;

 

            //Access to private member is not permitted

 

            ob1.num2 = 20;

            Console.WriteLine("Number one value in main {0}", ob1.num1);

            Console.ReadLine();

        }

    }

}

 

The above program will give compilation error, as access to private is not permissible. In the below figure you can see the private member num2 is not available.

 

protected

 

A protected member is accessible from within the class in which it is declared, and from within any class derived from the class that declared this member.

 

A protected member of a base class is accessible in a derived class only if the access takes place through the derived class type.

 

Accessibility: 

• Cannot be accessed by object
• By derived classes

using System;

 

namespace AccessModifiers

{

    class Program

    {

        class Base

        {

            protected int num1;

        }

 

        class Derived : Base

        {

            public int num2;

            static void Main(string[] args)

            {

                Base ob1 = new Base();

                Derived ob2 = new Derived();

                ob2.num1 = 20;

 

                // Access to protected member as it is inhertited by the Derived class

                ob2.num2 = 90;

 

                Console.WriteLine("Number2 value {0}", ob2.num2);

                Console.WriteLine("Number1 value which is protected {0}", ob2.num1);

                Console.ReadLine();

            }

        }

    }

}

 

In the above program we try to access protected member in main it is not available as shown in the picture below that num1 is not listed in intellisense.

 

internal

 

The internal keyword is an access modifier for types and type members. We can declare a class as internal or its member as internal. Internal members are accessible only within files in the same assembly (.dll).

 

In other words, access is limited exclusively to classes defined within the current project assembly.

 

Accessibility:

 

In same assembly (public) 

• Can be accessed by objects of the class
• Can be accessed by derived classes

In other assembly (internal) 

• Cannot be accessed by object
• Cannot be accessed by derived classes

protected internal

 

The protected internal accessibility means protected OR internal, not protected AND internal.

 

In other words, a protected internal member is accessible from any class in the same assembly, including derived classes.

 

The protected internal access modifier seems to be a confusing but is a union of protected and internal in terms of providing access but not restricting. It allows:  

• Inherited types, even though they belong to a different assembly, have access to the protected internal members.
• Types that reside in the same assembly, even if they are not derived from the type, also have access to the protected internal members.

Default access

 

A default access level is used if no access modifier is specified in a member declaration. The following list defines the default access modifier for certain C# types:

 

enum: The default and only access modifier supported is public.

 

class: The default access for a class is private. It may be explicitly defined using any of the access modifiers.

 

interface: The default and only access modifier supported is public.

 

struct: The default access is private with public and internal supported as well.

 

The default access may suffice for a given situation, but you should specify the access modifier you want to use to ensure proper application behavior.

 

Note: Interface and enumeration members are always public and no access modifiers are allowed.

What is the difference between an abstract function and a virtual function?

An abstract function can have no functionality. You're basically saying, any child class MUST give their own version of this method, however it's too general to even try to implement in the parent class.

A virtual function, is basically saying look, here's the functionality that may or may not be good enough for the child class. So if it is good enough, use this method, if not, then override me, and provide your own functionality.

What are the differences between Stored Procedure and a Trigger

1. We can execute a stored procedure whenever we want with the help of the exec command, but a trigger can only be executed whenever an event (insert, delete, and update) is fired on the table on which the trigger is defined.
2. We can call a stored procedure from inside another stored procedure but we can't directly call another trigger within a trigger. We can only achieve nesting of triggers in which the action (insert, delete, and update) defined within a trigger can initiate execution of another trigger defined on the same table or a different table.
3. Stored procedures can be scheduled through a job to execute on a predefined time, but we can't schedule a trigger.
4. Stored procedure can take input parameters, but we can't pass parameters as input to a trigger.
5. Stored procedures can return values but a trigger cannot return a value.
6. We can use Print commands inside a stored procedure for debugging purposes but we can't use print commands inside a trigger.
7. We can use transaction statements like begin transaction, commit transaction, and rollback inside a stored procedure but we can't use transaction statements inside a trigger.
8. We can call a stored procedure from the front end (.asp files, .aspx files, .ascx files, etc.) but we can't call a trigger from these files.
9. Stored procedures are used for performing tasks. Stored procedures are normally used for performing user specified tasks. They can have parameters and return multiple results sets.
10. The Triggers for auditing work: Triggers normally are used for auditing work. They can be used to trace the activities of table events.

What are the differences between Arrays and Collections

• Arrays are fixed in size, therefore once we create an array we are not allowed to increase or decrease its size, based on the requirement. Collections are grow-able, therefore base on our requirement we can increase or decrease its size
• Arrays use more memory space as compared to Collections
• Performance point of view arrays are recommended (Faster), where as collections are not recommended
• Arrays can hold only homogeneous elements, collections can hold both homogeneous and heterogeneous elements
• Arrays can hold both primitives as well as objects, where as collection can not hold primitives (although they can store primitive wrapper classes such as Integer etc)
• In Array , there are no underlined Data Structures, whereas ,Collection has Underlined DS

Difference and Similarities between class and structure?

DIFFERENCES

Class

1. Class is a reference type and its object is created on the heap memory.
    
2. Class can inherit the another class.
    
3. Class can have the all types of constructor and destructor.
    
4. The member variable of class can be initialized directly.
    
5. class object can not be created without using the new keyword, it means we have to use it.
   
   Demo obj=new Demo();

Structure

1. Structure is a value type that is why its object is created on the stack memory.
    
2. Structure does not support the inheritance.
    
3. Structure can only have the parametrized constructor. it means a structure can not have the non-parametrized constructor,default constructor and destructor also.
    
4. The member variable of structure can not be initialized directly.
    
5. Structure object can be created without using the new keyword.(optional) 

SIMILARITIES

1. Both can have constructors, methods, properties, fields, constants, enumerations,
   events, and event handlers.
2. Structures and classes can implement interface.
3. Both can have delegates and events.