difference between VARCHAR and CHAR?

CHAR Used to store character string value of fixed length. The maximum no. of characters the data type can hold is 255 characters. It's 50% faster than VARCHAR. Uses static memory allocation. VARCHAR Used to store variable length alphanumeric data. The maximum this data type can hold is up to 4000 characters. It's slower than CHAR. Uses dynamic memory allocation.

Get this Recent Comments Widget

Different Types of SQL Keys

We have following types of keys in SQL which are used to fetch records from tables and to make relationship among tables or views.

1. Super Key

   Super key is a set of one or more than one keys that can be used to identify a record uniquely in a table.Example : Primary key, Unique key, Alternate key are subset of Super Keys.

2. Candidate Key

   A Candidate Key is a set of one or more fields/columns that can identify a record uniquely in a table. There can be multiple Candidate Keys in one table. Each Candidate Key can work as Primary Key.
   Example: In below diagram ID, RollNo and EnrollNo are Candidate Keys since all these three fields can be work as Primary Key.
   

3. Primary Key

   Primary key is a set of one or more fields/columns of a table that uniquely identify a record in database table. It can not accept null, duplicate values. Only one Candidate Key can be Primary Key.
   

4. Alternate key

   A Alternate key is a key that can be work as a primary key. Basically it is a candidate key that currently is not primary key.
   Example: In below diagram RollNo and EnrollNo becomes Alternate Keys when we define ID as Primary Key.
   

5. Composite/Compound Key

   Composite Key is a combination of more than one fields/columns of a table. It can be a Candidate key, Primary key.

6. Unique Key

   Uniquekey is a set of one or more fields/columns of a table that uniquely identify a record in database table. It is like Primary key but it can accept only one null value and it can not have duplicate values. For more help refer the article Difference between primary key and unique key.

7. Foreign Key

   Foreign Key is a field in database table that is Primary key in another table. It can accept multiple null, duplicate values. For more help refer the article Difference between primary key and foreign key.
   Example : We can have a DeptID column in the Employee table which is pointing to DeptID column in a department table where it a primary key.
   

Defining Keys in SQL Server

--Department Table
 CREATE TABLE Department 
(
 DeptID int PRIMARY KEY, --primary key
 Name varchar (50) NOT NULL,
 Address varchar (200) NOT NULL
 ) 
--Student Table
CREATE TABLE Student 
(
 ID int PRIMARY KEY, --primary key
 RollNo varchar(10) NOT NULL,
 Name varchar(50) NOT NULL,
 EnrollNo varchar(50) UNIQUE, --unique key
 Address varchar(200) NOT NULL,
 DeptID int FOREIGN KEY REFERENCES Department(DeptID) --foreign key
) 

Note

1. Practically in database, we have only three types of keys Primary Key, Unique Key and Foreign Key. Other types of keys are only concepts of RDBMS which you should know.

C# - Constructors in C# with Example, Types of Constructor in C# with Example

, ,

Introduction:

Here I will explain what is constructor in c# with example, uses and types of constructors in c# default constructor, static constructor, copy constructor, parameterized constructor and private constructor examples in c#.net.  

Description:

Constructor is a special method of a class which will invoke automatically whenever instance or object of class is created. Constructors are responsible for object initialization and memory allocation of its class. If we create any class without constructor, the compiler will automatically create one default constructor for that class. There is always at least one constructor in every class.

Here you need to remember that a class can have any number of constructors and constructors don’t have any return type, not even void and within a class we can create only one static constructor.

Generally constructor name should be same as class name. If we want to create constructor in a class we need to create a constructor method name same as class name check below sample method for constructor

class SampleA { public SampleA() { Console.WriteLine("Sample A Test Method"); } }

Types of Constructors

Basically constructors are 5 types those are

      1.    Default Constructor

      2.    Parameterized Constructor

      3.    Copy Constructor

      4.    Static Constructor

      5.    Private Constructor

Default Constructor

A constructor without having any parameters called default constructor. In this constructor every instance of the class will be initialized without any parameter values like as shown below

using System; namespace ConsoleApplication3 { class Sample { public string param1, param2; public Sample()     // Default Constructor { param1 = "Welcome"; param2 = "Om Prakash"; } } class Program { static void Main(string[] args) { Sample obj=new Sample();   // Once object of class created automatically constructor will be called Console.WriteLine(obj.param1); Console.WriteLine(obj.param2); Console.ReadLine(); } } }

When we run above program it will show output like as shown below

Output

Welcome Om Prakash

Parameterized Constructors

A constructor with at least one parameter is called as parameterized constructor. In parameterized constructor we can initialize each instance of the class to different values like as shown below

using System; namespace ConsoleApplication3 { class Sample { public string param1, param2; public Sample(string x, string y)     // Declaring Parameterized constructor with Parameters { param1 = x; param2 = y; } } class Program { static void Main(string[] args) { Sample obj=new Sample("Welcome","Om Prakash");   // Parameterized Constructor Called Console.WriteLine(obj.param1 +" to "+ obj.param2); Console.ReadLine(); } } }

When we run above program it will show output like as shown below

Output

Welcome to Om Prakash

Constructor Overloading

In c# we can overload constructor by creating another constructor with same method name and different parameters like as shown below

using System; namespace ConsoleApplication3 { class Sample { public string param1, param2; public Sample()     // Default Constructor { param1 = "Hi"; param2 = "I am Default Constructor"; } public Sample(string x, string y)     // Declaring Parameterized constructor with Parameters { param1 = x; param2 = y; } } class Program { static void Main(string[] args) { Sample obj = new Sample();   // Default Constructor will Called Sample obj1=new Sample("Welcome","Om Prakash");   // Parameterized Constructor will Called Console.WriteLine(obj.param1 + ", "+obj.param2); Console.WriteLine(obj1.param1 +" to " + obj1.param2); Console.ReadLine(); } }

When we run above program it will show output like as shown below

Output

Hi, I am Default Constructor Welcome to Om Prakash

Copy Constructor

A parameterized constructor that contains a parameter of same class type is called as copy constructor. Main purpose of copy constructor is to initialize new instance to the values of an existing instance. Check below example for this

using System; namespace ConsoleApplication3 { class Sample { public string param1, param2; public Sample(string x, string y) { param1 = x; param2 = y; } public Sample(Sample obj)     // Copy Constructor { param1 = obj.param1; param2 = obj.param2; } } class Program { static void Main(string[] args) { Sample obj = new Sample("Welcome", "Om Prakash");  // Create instance to class Sample Sample obj1=new Sample(obj); // Here obj details will copied to obj1 Console.WriteLine(obj1.param1 +" to " + obj1.param2); Console.ReadLine(); } } }

When we run above program it will show output like as shown below

Output

Welcome to Om Prakash

Static Constructor

When we declared constructor as static it will be invoked only once for any number of instances of the class and it’s during the creation of first instance of the class or the first reference to a static member in the class. Static constructor is used to initialize static fields of the class and to write the code that needs to be executed only once.

using System; namespace ConsoleApplication3 { class Sample { public string param1, param2; static Sample() { Console.WriteLine("Static Constructor"); } public Sample() { param1 = "Sample"; param2 = "Instance Constructor"; } } class Program { static void Main(string[] args) { // Here Both Static and instance constructors are invoked for first instance Sample obj=new Sample(); Console.WriteLine(obj.param1 + " " + obj.param2); // Here only instance constructor will be invoked Sample obj1 = new Sample(); Console.WriteLine(obj1.param1 +" " + obj1.param2); Console.ReadLine(); } } }

When we run above program we will get output like as shown below

Output

Static Constructor Sample Instance Constructor Sample Instance Constructor

Importance points of static constructor

-      Static constructor will not accept any parameters because it is automatically called by CLR.

-      Static constructor will not have any access modifiers.

-      Static constructor will execute automatically whenever we create first instance of class

-      Only one static constructor will allowed.

Private Constructor

Private constructor is a special instance constructor used in a class that contains static member only. If a class has one or more private constructor and no public constructor then other classes is not allowed to create instance of this class this mean we can neither create the object of the class nor it can be inherit by other class. The main purpose of creating private constructor is used to restrict the class from being instantiated when it contains every member as static.

using System; namespace ConsoleApplication3 { public class Sample { public string param1, param2; public Sample(string a,string b) { param1 = a; param2 = b; } private Sample()  // Private Constructor Declaration { Console.WriteLine("Private Constructor with no prameters"); } } class Program { static void Main(string[] args) { // Here we don't have chance to create instace for private constructor Sample obj = new Sample("Welcome","to Om Prakash"); Console.WriteLine(obj.param1 +" " + obj.param2); Console.ReadLine(); } } }

Output

Welcome to Om Prakash

In above method we can create object of class with parameters will work fine. If create object of class without parameters it will not allow us create.

// it will works fine Sample obj = new Sample("Welcome","to Om Prakash"); // it will not work because of inaccessability Sample obj=new Sample();

Important points of private constructor

-      One use of private construct is when we have only static member.

-      Once we provide a constructor that is either private or public or any, the compiler will not allow us to add public constructor without parameters to the class.

-      If we want to create object of class even if we have private constructors then we need to have public constructor along with private constructor