Technical Counselling

Unary Operators

2008-12-16T21:00:00.000-08:00

Definition and Types:

The unary operators enable operations with simpler syntax than a comparable binary operation. The unary operators include + (plus), - (minus), ++ (increment), -- (decrement), ! (logical negation), and ~ (bitwise complement).

Increment Operator:(++)

The increment operator (++) allows incrementing the value of a variable by 1. The timing of the effect of this operator depends upon which side of the expression it's on.

Here's a post-increment example:

int count;
int index = 6;

count = index++; // count = 6, index = 7

In this example, the ++ operator comes after the expression index. That's why it's called a post-increment operator. The assignment takes place, and then index is incremented. Because the assignment occurs first, the value of index is placed into count, making it equal to 6. Then index is incremented to become 7.

Here's an example of a preincrement operator:

int count;
int index = 6;

count = ++index; // count = 7, index = 7

This time, the ++ operator comes before the expression index. This is why it's called the preincrement operator. index is incremented before the assignment occurs. Because index is incremented first, its value becomes 7. Next, the assignment occurs to make the value of count equal to 7.

Example:

class Program

{

static void Main(string[] args)

{

int Value = 2;

int preIncrement;

int postIncrement;

preIncrement = ++Value;

Console.WriteLine("PreIncrement Value is: {0}", preIncrement);

Console.ReadLine();

Console.WriteLine("Value is:{0}", Value);

Console.ReadLine();

postIncrement = Value++;

Console.WriteLine("PostIncrement Value is: {0}", postIncrement);

Console.ReadLine();

Console.WriteLine("Value is:{0}", Value);

Console.ReadLine();

}

Output:

PreIncrement Value is: 3
Value is:3
PostIncrement Value is:3
Value is:4

Decrement Operator:(--)

The decrement operator (--) allows decrementing the value of a variable. The timing of the effect of this operator again depends upon which side of the expression it is on. Here's a post-decrement example:

int count;

int index = 6;

count = index--; // count = 6, index = 5

In this example, the -- operator comes after the expression index, and that's why it's called a post-decrement operator. The assignment takes place, and then index is decremented. Because the assignment occurs first, the value of index is placed into count, making it equal to 6. Then index is decremented to become 5.

Here's an example of a predecrement operator:

int count;

int index = 6;

count = --index;	 // count = 5, index = 5

This time the -- operator comes before the expression index, which is why it's called the predecrement operator. index is decremented before the assignment occurs. Because index is decremented first, its value becomes 5, and then the assignment occurs to make the value of count equal 5.

Example:

class Program

{

static void Main(string[] args)

{

int Value = 2;

int preDecrement;

int postDecrement;

preDecrement = --Value;

Console.WriteLine("PreDecrement Value is {0}:", preDecrement);

Console.ReadLine();

Console.WriteLine("Value is:{0}", Value);

Console.ReadLine();

postDecrement = Value--;

Console.WriteLine("PostDecrement Value is {0} :", postDecrement);

Console.ReadLine();

Console.WriteLine("Value is:{0}", Value);

Console.ReadLine(); }

}

Output:

PreIncrement Value is: 1
Value is:1
PostIncrement Value is:1
Value is:0

Logical Complement Operator:(!)

A logical complement operator (!) serves to invert the result of a Boolean expression. The Boolean expression evaluating to true will be false. Likewise, the Boolean expression evaluating to false will be true.

Example:

class Program

{

static void Main(string[] args)

{

int Value = 2;

bool logNot;

logNot = false;

logNot = !logNot;

Console.WriteLine("Logical Not: {0}", logNot);

Console.ReadLine();

}

Output:
Logical Not:True

Bitwise Complement Operator:(~)

A bitwise complement operator (~) inverts the binary representation of an expression. All 1 bits are turned to 0. Likewise, all 0 bits are turned to 1.

Example:

class Program

{

static void Main(string[] args)

{

int Value = 2;

sbyte bitNot;

bitNot = 0;

bitNot = (sbyte)(~bitNot);

Console.WriteLine("Bitwise Not: {0}", bitNot);

Console.ReadLine();

}

Output:
Bitwise Not:-1;

break Satement:

2008-12-15T21:33:00.000-08:00

Definition:

This statement is often used in conjunction with switch statements; however, C# allows you to use it to break out of the current block of statements. The break statement is usually used to break out from an iteration statement block.

Example:

static void Main(string[] args)

{

int i = 0;

while (i !=5)

{

Console.WriteLine(i);

Console.ReadLine();

if (i == 2)

break;

i++;

}

Output:

0
1
2

continue Statement:

2008-12-15T20:51:00.000-08:00

Definition:

This statement returns the control back to the Boolean expression that controls an iteration statement.

Example:

static void Main(string[] args)

{

for (int i = 1; i <= 4; i++)

{

if (i !=1)

{

Console.WriteLine(i);
Console.ReadLine();

continue;

}

Output:

2
3
4

goto Statement:

2008-12-15T20:45:00.000-08:00

Definition:

A labeled statement permits a statement to be prefixed by a label, and goto statements can be used to transfer control to a labeled statement.

This statement transfers control to a labeled statement unconditionally. In C#, any statement can be labeled. A colon follows a statement label, and a label identifier follows the goto keyword. The goto statement transfers control to the statement named by the label identifier.

If you overuse the goto statement, it can create code that is hard to read and follow. In general, it's a good practice to avoid using goto altogether by restructuring the code in a way that allows you to get around using the goto statements.

Example:

static void Main(string[] args)

{

goto A;

B: Console.WriteLine("Hello Hems");

Console.ReadLine();

return;

A: Console.WriteLine("Hello Dulip");

Console.ReadLine();

goto B;

}

Output:

Hello Dulip;
Hello Hems;

do-while loops

2008-12-14T22:45:00.000-08:00

Definition:

syntax: do statement[s] while (expression)

A 'do-while' loop is just like a 'while' loop except that the condition is evaluated after the block of code specified in the 'do' clause has been run. So even where the condition is initially false, the block runs once. For instance, the following code outputs '2':

Example:

class Program

{

static void Main(string[] args)

{

int a=2;

{

Console.WriteLine(a);

Console.ReadLine();

a++;

}

while (a > 3);

}

Foreach Statement

2008-12-14T22:29:00.000-08:00

Definition:

syntax: foreach (variable1 in variable2) statement[s]

The 'foreach' loop is used to iterate through the values contained by any object which implements the IEnumerable interface. When a 'foreach' loop runs, the given variable1 is set in turn to each value exposed by the object named by variable2. As we have seen previously, such loops can be used to access array values. So, we could loop through the values of an array in the following way:

Example:1

class Program

{

static void Main(string[] args)

{

String[] List={"Hemnath","Mani","Siva","Arivu","Jagan",

"Nagendra","John","Anand"};

foreach (string Names in List)

{

Console.WriteLine("{0}", Names);

Console.ReadLine();

}

Example:2

private void Form1_Load(object sender, EventArgs e)

{

string conn = "Data Source=localhost;Initial Catalog=master;Integrated Security=True";

SqlConnection connection = new SqlConnection(conn);

SqlDataAdapter da = new SqlDataAdapter("select * from Student", connection);

DataSet ds = new DataSet();

DataTable dt = new DataTable("Student");

da.Fill(ds);

foreach (DataRow dr in ds.Tables[0].Rows)

{

ListViewItem itm = new ListViewItem();

itm.Text = Convert.ToString(dr["Name"]);

itm.SubItems.Add(Convert.ToString(dr["Name"]));

listBox1.Items.Add(itm);

}

Note:
The main drawback of 'foreach' loops is that each value extracted (held in the given example by the variable 'List') is read-only.

For Statement:

2008-12-12T00:39:00.000-08:00

Definition:

A for statement evaluates a sequence of initialization expressions and then, while a condition is true, repeatedly executes a statement and evaluates a sequence of iteration expressions.

In the below example will show you how to print numbers from 1 to 5

Example:

class Program
{
static void Main(string[] args)
{
int i = 1;
for (; i <= 5; i++) {
Console.WriteLine(i);
Console.ReadLine();
}
}
}

Output:
1
2
3
4
5

While Statement-Simple Program

2008-12-12T00:30:00.000-08:00

Definition:

1.For example if i want to print 1 to 10 , use while statement or for looping statement.
2.Until the condition satisfies while loop will execute, once it reaches the condition it will come out from the loop.

Example:

class Program
{
static void Main(string[] args)
{

int i = 0;
while (i!=5 ){
i++;
Console.WriteLine(i);
Console.ReadLine();
}
}
}

Output:
1
2
3
4
5

Switch Statement :Simple Program

2008-12-12T00:03:00.000-08:00

Definition:

1.Declare some int or string or anyother datatype. Here in the below example i declared int i variable.
2.For 'switch' statement use switch keyword to declare the statement, under the switch statement declare the different cases as per the requirements.
3.For Example switch(i), based on the input it will redirect to the proper cases.
4.If input value "1" it redirect into case 1, if input value 2 it redirect into case 2, if input value is other than these two cases , it will move into default case.

Example:

class Program

{

static void Main(string[] args)

{

int i;

Console.Write("i:");

i = Convert.ToInt32(Console.ReadLine());

switch (i)

{

case 1:

{

Console.WriteLine("This is 1");

Console.ReadLine();

break;

}

case 2:

{

Console.WriteLine("This is 2");

Console.ReadLine();

break;

}

default:

{

Console.WriteLine("This is Default");

Console.ReadLine();

break;

}

Output:
i=2
This is 2

i=4
This is Default

Simple Calculator Program

2008-12-10T22:04:00.000-08:00

namespace Calculator
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();

}

private void btnAdd_Click(object sender, EventArgs e)
{
try
{
if ((textBox1.Text == string.Empty)||(textBox2.Text==string.Empty))
{
MessageBox.Show("Please enter some numbers to validate");
}
else
{
int Total = Convert.ToInt32(textBox1.Text) + Convert.ToInt32(textBox2.Text);
textBox3.Text = Convert.ToString(Total);
}
}
catch (Exception ex)
{
MessageBox.Show("Number1 and Number2 should be numeric");
}

}

private void btnSubtract_Click(object sender, EventArgs e)
{
try
{
if ((textBox1.Text == string.Empty) || (textBox2.Text == string.Empty))
{
MessageBox.Show("Please enter some numbers to validate");
}
else
{
if (Convert.ToInt32(textBox1.Text) > Convert.ToInt32(textBox2.Text))
{
int Total = Convert.ToInt32(textBox1.Text) - Convert.ToInt32(textBox2.Text);
textBox3.Text = Convert.ToString(Total);
}
else
{
MessageBox.Show("Number1 should be greater than Number2");
}
}
}
catch (Exception ex)
{
MessageBox.Show("Number1 and Number2 should be numeric");
}

}

private void btnMultiply_Click(object sender, EventArgs e)
{
try
{
if ((textBox1.Text == string.Empty) || (textBox2.Text == string.Empty))
{
MessageBox.Show("Please enter some numbers to validate");
}
else
{
int Total = Convert.ToInt32(textBox1.Text) * Convert.ToInt32(textBox2.Text);
textBox3.Text = Convert.ToString(Total);
}
}
catch(Exception ex)
{
MessageBox.Show("Number1 and Number2 should be numeric");
}
}

private void btnDivide_Click(object sender, EventArgs e)
{
try
{
if ((textBox1.Text == string.Empty) || (textBox2.Text == string.Empty))
{
MessageBox.Show("Please enter some numbers to validate");
}
else
{
if (Convert.ToInt32(textBox1.Text) > Convert.ToInt32(textBox2.Text))
{
int Total = Convert.ToInt32(textBox1.Text) / Convert.ToInt32(textBox2.Text);
textBox3.Text = Convert.ToString(Total);
}
else
{
MessageBox.Show("Number1 should be greater than Number2");
}
}
}
catch (Exception ex)
{
MessageBox.Show("Number1 and Number2 should be numeric");
}
}
}
}

Output:

Comparision between Structures and Classes

2008-12-10T20:26:00.001-08:00

Structures and Class Differences:
1.Classes are reference types and structs are value types.
Since classes are reference type, a class variable can be assigned null.But we cannot assign null to a struct variable, since structs are value type.

Example:

namespace SampleStruct

{

struct Test

{

public int add(int a, int b)

{

return a + b;

}

public void Display()

{

Console.WriteLine("Hi from Structure Declaration");

Console.ReadLine();

}

class Program

{

static void Main(string[] args)

{

Program p = null; //No Error

Test t = null;//Error Occurred(Cannot convert null to ‘SampleStruct.Test’because it is a value type)

}

2. When you instantiate a class, it will be allocated on the heap.When you instantiate a struct, it gets created on the stack.

3. You will always be dealing with reference to an object ( instance ) of a class. But you will not be dealing with references to an instance of a struct ( but dealing directly with them ).

4. When passing a class to a method, it is passed by reference. When passing a struct to a method, it's passed by value instead of as a reference.

5. You cannot have instance Field initializers in structs.But classes can have initializers.

Example:

namespace ConsoleApplication9

{

class Program

{

int y = 34;

public void Show()

{

Console.WriteLine("Hi from Structure");

Console.ReadLine();

}

static void Main(string[] args)

{

Test t;

t.Show();

}

struct Test

{

int x = 10;//Error: 'ConsoleApplication9.Test.x': cannot have instance field initializers in structs

public void Show()

{

Console.WriteLine("Hello from structure");

Console.ReadLine();

}

6. Classes can have explicit parameterless constructors. But structs cannot have explicit parameterless constructors.

Example:

namespace ConsoleApplication9

{

class Program

{

int y = 34;

public Program()// No Error

{

Console.WriteLine("Class Constructor");

Console.ReadLine();

}

public void Show()

{

Console.WriteLine("Hi from Structure");

Console.ReadLine();

}

static void Main(string[] args)

{

Program pgm = new Program();

Test t;

t.Show();

}

struct Test

{

//int x = 10;

public void Show()

{

Console.WriteLine("Hello from structure");

Console.ReadLine();

}

public Test()//Error: Structs cannot contain explicit parameterless constructors

{

Console.WriteLine("Structure Destructor");

Console.ReadLine();

}

7. Classes must be instantiated using the new operator. But structs can be instantiated without using the new operator.

Example:

namespace ConsoleApplication9

{

class Program

{

int y = 34;

public Program()

{

Console.WriteLine("Class Constructor");

Console.ReadLine();

}

public void Show()

{

Console.WriteLine("Hi from Structure");

Console.ReadLine();

}

static void Main(string[] args)

{

Program pgm;

pgm.Show();//Error: Use of unassigned local variable 'pgm'

Test t;

t.Show();

}

struct Test

{

public void Show()

{

Console.WriteLine("Hello from structure");

Console.ReadLine();

}

8. Classes support inheritance.But there is no inheritance for structs.( structs don't support inheritance polymorphism ). So we cannot have a base structure and a derived structure.

Example:

namespace ConsoleApplication9

{

class Program:Test//Error: 'ConsoleApplication9.Program': cannot derive from sealed type

{

int y = 34;

public Program()

{

Console.WriteLine("Class Constructor");

Console.ReadLine();

}

public void Show()

{

Console.WriteLine("Hi from Structure");

Console.ReadLine();

}

static void Main(string[] args)

{

Test t;

t.Show();

}

struct Test:Program//Error: Type 'Program' in interface list is not an interface {

public void Show()

{

Console.WriteLine("Hello from structure");

Console.ReadLine();

}

Note : Like classes, structures can implement interfaces

9. Since struct does not support inheritance, access modifier of a member of a struct cannot be protected or protected internal.

10. It is not mandatory to initialize all Fields inside the constructor of a class.But all the Fields of a struct must be fully initialized inside the constructor.

Example:

namespace ConsoleApplication9

{

class Program

{

int y;

public Program(int y)

{

Console.WriteLine("Class Constructor");

Console.ReadLine();

}

public void Show()

{

Console.WriteLine("Hi from Structure");

Console.ReadLine();

}

static void Main(string[] args)

{

}

struct Test

{

int a;

public Test(int a)//Error: Field 'ConsoleApplication9.Test.a' must be fully assigned before control leaves the constructor

{

}

public void Show()

{

Console.WriteLine("Hello from structure");

Console.ReadLine();

}

11. A class is permitted to declare a destructor.But a struct is not permitted to declare a destructor.

12. classes are used for complex and large set data. structs are simple to use.
structs are useful whenever you need a type that will be used often and is mostly just a piece of data.

13. The modifiers namely abstract and sealed are not permitted in struct. But it is permitted in class.

Features of Structures

2008-12-08T02:39:00.000-08:00

Features of Structures: -
==========================

* A structure or struct can contain only fields, methods, Etc.,

* In struct we can't initialize the variable whereas in class it can be possible

* It must be initialized either through function or using object

* Fields can't be given initial values at that time of creation.

* struct can't have a constructor.

* struct can't support the concept of inheritance

* We can derive a structure from an interface

* We can't inherit from sealed class

* A structure could not inherit from a class, the reverse is also true

* You can't declare a struct as sealed, because by default it is sealed

* A structure declare as abstract can't be used as a base class, i.e., be used in a derivation

* No destructor for struct

* struct are created on the stack and die when we reach the closing brace

Multiple Interfaces

2008-12-07T23:13:00.000-08:00

Example:

namespace ConsoleApplication7
{
interface Example
{
void Show(); //Method declaration
}
interface Test
{
void Display(); //Method declaration
}
class Program1:Test,Example
{
void Test.Display() //Method Definition
{
Console.WriteLine("Hi from Test Interface");
Console.ReadLine();
}
void Example.Show() //Method Definition
{
Console.WriteLine("Hello from Example Interface");
Console.ReadLine();
}
}
class Program
{
static void Main(string[] args)
{
Program1 pgm1 = new Program1();
Test t = (Test)pgm1;//Instance declaration
t.Display(); //Calling the method
Example ex = (Example)pgm1;//Instance declaration
ex.Show(); //Calling the method
}
}
}

Abstract class Vs Interface:

2008-12-04T03:59:00.000-08:00

What is an Abstract Class?

An abstract class is a special kind of class that cannot be instantiated. So the question is why we need a class that cannot be instantiated? An abstract class is only to be sub-classed (inherited from). In other words, it only allows other classes to inherit from it but cannot be instantiated. The advantage is that it enforces certain hierarchies for all the subclasses. In simple words, it is a kind of contract that forces all the subclasses to carry on the same hierarchies or standards.

What is an Interface?

An interface is not a class. It is an entity that is defined by the word Interface. An interface has no implementation; it only has the signature or in other words, just the definition of the methods without the body. As one of the similarities to Abstract class, it is a contract that is used to define hierarchies for all subclasses or it defines specific set of methods and their arguments. The main difference between them is that a class can implement more than one interface but can only inherit from one abstract class. Since C# doesn’t support multiple inheritance, interfaces are used to implement multiple inheritance.

Both Together

When we create an interface, we are basically creating a set of methods without any implementation that must be overridden by the implemented classes. The advantage is that it provides a way for a class to be a part of two classes: one from inheritance hierarchy and one from the interface.

When we create an abstract class, we are creating a base class that might have one or more completed methods but at least one or more methods are left uncompleted and declared abstract. If all the methods of an abstract class are uncompleted then it is same as an interface. The purpose of an abstract class is to provide a base class definition for how a set of derived classes will work and then allow the programmers to fill the implementation in the derived classes.

There are some similarities and differences between an interface and an abstract class that I have arranged in a table for easier comparison:

Feature	Interface	Abstract class
Multiple inheritance	A class may inherit several interfaces.	A class may inherit only one abstract class
Default implementation	An interface cannot provide any code, just the signature.	An abstract class can provide complete, default code and/or just the details that have to be overridden.
Access Modfiers	An interface cannot have access modifiers for the subs, functions, properties etc everything is assumed as public	An abstract class can contain access modifiers for the subs, functions, properties
Core VS Peripheral	Interfaces are used to define the peripheral abilities of a class. In other words both Human and Vehicle can inherit from a IMovable interface.	An abstract class defines the core identity of a class and there it is used for objects of the same type.
Homogeneity	If various implementations only share method signatures then it is better to use Interfaces.	If various implementations are of the same kind and use common behaviour or status then abstract class is better to use.
Speed	Requires more time to find the actual method in the corresponding classes.	Fast

Accessibility Levels in C#:

2008-12-03T22:45:00.000-08:00

public:Access is not restricted.
private:Access is limited to the containing type.
protected:Access is limited within the class or types derived from the containing class
internal:Access is limited within the assembly
protected internal:Access is limited within the assembly or types derived from the containing class.

Default Access specifier for Classes and Methods in C#:

2008-12-03T22:39:00.000-08:00

Default access specifier for class is public;
Default access specifier for method is private;

In C#, this has all changed. We can append our class declarations with class access modifiers to restrict both access to its internal members and methods, as well as instantiation rights. These eight access specifiers are:

public: This class is accessible to all other classes. If a class is declared without explicitly specifying an access modifier for it, then it's public by default.
private: Accessible only by the class in which it is declared.
protected: Accessible only by the class in which it is declared, as well as any derived classes.
protected internal: Accessible only by the class in which it is declared, as well as any derived classes in the same source code file.
internal: Accessible only from within the same assembly (in C#, an assembly is a package of inter-related data that contains both code and meta data).
sealed: Prevents a class from every being derived. If another class tries to use this class as its base class either directly or indirectly then the C# compiler will raise an error.
abstract: Similar to the concept of a pure virtual function in C++, an abstract class can't actually be instantiated. It contains a signature, but can only be used when it is the base class of a derived class.
new: Using the new keyword as an access modifier for a nested class allows us to hide an inherited method of a parent class by providing the compiler with a new version of that class.

Sealed class:

2008-12-03T22:29:00.000-08:00

Sealed Class:

If you made class as sealed, we can create instance for the class.
We can access the members.
We can't derive sealed class from other classes.

namespace ConsoleApplication6
{
sealed class Program
{
void menu()
{
Console.WriteLine("Hello");
Console.ReadLine();
}
static void Main(string[] args)
{
Program pgm=new Program();
pgm.menu();
}
}
}

Static class:

2008-12-03T22:08:00.000-08:00

Static Class:

No need to create instance for the 'static class'.
Inside static class, we can use only static members.
If use the other than static members inside the static class, the compiler will throw error.
We can directly access the members using class name.member name , for Ex:Program.display();Here Program is the class name and display is the method name.
We can't derive static class.

Example:

namespace ConsoleApplication6
{
static class Program
{
static int a = 10;
static void display()
{
Console.WriteLine(a);
Console.ReadLine();
}
static void menu()
{
Console.WriteLine("TOTAL="+ (a+a+a) );
Console.ReadLine();
}

static void Main(string[] args)
{

Program.display();
Program.menu();

}
}
}

Output:

10
Total:30

If use other than static members inside the static class, the compiler will throw error.

Example:
namespace ConsoleApplication6
{
static class Program
{

public void message()
{
Console.WriteLine(a);
Console.ReadLine();
}
static void Main(string[] args)
{

}
}
}

Output:

Error 1 'message': cannot declare instance members in a static class