.Net C# Data Types Data is physically stored inside cells of memory. This memory could be physical memory (Hard disk ) or logical memory (RAM). Any cell of memory is represented with a unique address. This address is more than some combination of numbers or symbols. C# language provides for practically all the data types . These types can be divided in three categories: value types, reference types and pointer types. There are some more basic concepts to be learnt before the discussion of the data types. This is about variables and constants. A Variable is a named cell of memory used for data storage . A Variable value can be changed anytime. Every variable must have a type and this type must be set before it is used. Qualifying a variable with a type is called as declaration of variable. The type of a variable is the most important aspect and it defines the behavior of variable. All variables can be divided into seven main categories depending on the context of usage: 1. Static variables. 2. Variable of instance. 3. Array's elements. 4. Parameters given by reference. 5. Parameters given by value. 6. Returned values. 7. Local variables. Static Variables will be alive throughout the life of a program. It can be declared using static modifier. An Instance variable is a variable declared without static modifier. Usually it is declared inside a class or structure definition.
Transcript
.Net C# Data Types Data is physically stored inside cells of memory. This memory could be physical memory (Hard disk) or logical memory (RAM). Any cell of memory is represented with a unique address. This address is more than some combination of numbers or symbols.
C# language provides for practically all the data types. These types can be divided in three categories: value types, reference types and pointer types.
There are some more basic concepts to be learnt before the discussion of the data types. This is about variables and constants. A Variable is a named cell of memory used for data storage. A Variable value can be changed anytime. Every variable must have a type and this type must be set before it is used. Qualifying a variable with a type is called as declaration of variable. The type of a variable is the most important aspect and it defines the behavior of variable. All variables can be divided into seven main categories depending on the context of usage:
1. Static variables.2. Variable of instance.3. Array's elements.4. Parameters given by reference.5. Parameters given by value.6. Returned values.7. Local variables.
Static Variables will be alive throughout the life of a program. It can be declared using static modifier.
An Instance variable is a variable declared without static modifier. Usually it is declared inside a class or structure definition.
Parameter Values can be viewed as input parameters into methods:
public static void Sum(int a, int b){ Console.WriteLine("The sum of elements {0} and {1} is {2}",a,b,a + b);}
This code writes in console values of variables a, b and their summary value. Now if the values of these parameters are modified inside the method, this
change will not be reflected inside the main function. It is because the compiler creates copies of them when it passes them as value types. This ensures that their original values are not modified.
Instead if one wants to modify the parameter variables inside the function, C# has something called Reference variables. Reference variables also have a modifier out which can be used before their type. Look at the following example:
public static void SumRef(ref int a, ref int b){ a = 4; b = 6; Console.WriteLine("The sume of elements {0} and {1} is {2}",a,b,a + b);}
Now this method modifies the value of variables a and b with values 4 and 6. These values are retained even after the execution of the function gets completed.If the parameters need to be returned then they can be qualified with out modifier or as returned parameter in method definition. Here is an example of both of them, in which both of them return the same value:
public static int SumOut(int a, int b, out int sum1){
sum1 = a+b;Console.WriteLine("The sum1 of elements {0} and {1} is {2}",a,b,a+b);return sum1;
}
In main function it must be called in the next manner:
int sume ;sume = SumeOut(2,2, out sume);
Constants in C#:
Constant type of data cannot be changed. To declare a constant the keyword const is used. An example for the constant declaration is: const double PI = 3.1415;
Value type stores real data. When the data are queried by different function a local copy of it these memory cells are created. It guarantees that changes made to our data in one function don't change them in some other function. Let see at a simple example:
public class IntClass { public int I = 1;}
Here we have simple class that contains only one public data field of integer type. Now have a look on its usage in main function:
static void Main(string[] args){// test class int i = 10;int j = i;j = 11;IntClass ic1 = new IntClass();IntClass ic2 = ic1;ic2.I = 100;
Console.WriteLine("value of i is {0} and j is {1}",i,j);Console.WriteLine();Console.WriteLine("value of ic1.I is {0} and ic2.I is {1}",ic1.I,ic2.I);Console.WriteLine();}
Reference Types in C#:
In the above example, assume that First we have two value type i and j. Also assume that the second variable is initialized with the value of the first one. It creates new copy in memory and after it the values of these variables will be next:
i = 10;j = i;
There are a few more things written in the above example for explaining the Reference Types in C#. At first, the variable ic1 of IntClass is created using dynamic memory allocation. Then we initialize the variable ic2 with value of ic1.
This makes both the variables ic1 and ic2 referring to the same address. If we change a value of ic2, it automatically changes the value of ic1.
Now, over to the discussions about the important value types used in C#. The category simple types contains some predefined or system types that also are commonly used in other programming languages. It contains integer types: byte, Sbyte, Long, Ulong, Short, Ushort, int, Uint. These common types differs only range of values and sign.
Next simple type is character type. To declare a variable of this type need use keyword char. It can take values of characters or numbers as 16-digit symbol of the type Unicode.
The Boolean type has only two values: true, false. But these values cannot be assigned with a 0 or 1 as in C++ language.
Next category of simple types is floating point types. It contains two types float and double. Float type can get values in range from 1.5*10-45 to 3.4*1038. Double type has range of values from 5.0*10-324 to 1.7*10308.
A structural value types are struct and enum. Struct is a the same as class but it uses real values not references. The following code snippet contains the definition for struct:
struct Point3D{
public float m_x;public float m_y;public float m_z;
The above is declaration for a simple structure of real 3D point. As you see a class declaration looks very similar to the struct except that the class also has a constructor.
Enumerated types can be used to create some set of identifiers that can have values of simple type. Let us see at example of enum type:
In example there are enum that has days of week names. The values of days by default are in range from 0 to 6.
Common types in C#:
Object in C# language is universal; it means that all supported types are derived from it. It contains only a couple of methods: GetType() - returns a type of object, ToString() returns string equivalent of type that called.
Next type is class. It is declared in the same manner as structure type but it has more advanced features.
Interface is an abstract type. It is used only for declaring type with some abstract members. It means members without implementations. Please, have a look at piece of code with a declaration for a simple interface:
interface IRect{int Width{get;set;}
int Height{get;set;}
int CalculateArea();}
The members of interface can be methods, properties and indexers.
Next reference type to be dealt is delegate. The main goal of delegate usage is encapsulation of methods. It most like at pointers to function in C++.
String is common type that is used in almost all programming languages of high level. An example of string declaration and initialization:
string s = "declaration and init";
The last very used reference type is array. Array it is set of elements that have the same type. Array contains list of references on memory cells and it can contain any amount of members. In C# there are three types of arrays: one-dimensional, two-dimensional and jagged array.
So, this covers almost all types used in C#. All these types can be cast to another type using special rules. An implicit casting can be done with types when values of variables can be converted without losing of any data. There is special type of implicit casting called boxing. This enables us to convert any type to the reference type or to the object type. Boxing example:
// boxing char ch = 'b';object obj = ch;Console.WriteLine("Char value is {0}",ch);Console.WriteLine("Object value is {0}",obj);Console.WriteLine();
This piece of code prints the same values of integer type variable and object type variable. The opposite process to the boxing is un-boxing. An example for un-boxing is as follows.
// unboxing float q = 4.6f;object ob = q; Console.WriteLine("Object value is {0}",ob);float r = (float)ob;Console.WriteLine("Float value is {0}",r);
So, it is main item of common data type creating and using. All sources are attached. To compile and run it need to run .NET command line. Just type: csc DataTypes.cs. It creates DataTypes.exe that can be run as standard executable file.
.Net C# Tutorial Intermediate Language - MSIL
Microsoft Intermediate Language (MSIL) is a platform independent language that gets compiled into platform dependent executable file or dynamic link library. It means .NET compiler can generate code written using any supported languages and finally convert it to the required machine code depending on the target machine.
To get some clarity in this language we need to write some code. In this tutorial we?ll use a very simple piece of source code in C# .Net. Now we need to compile this code using csc command in Microsoft .NET on the command line. To do this, please type next string: csc ILSample.cs. After it compiler will create an executable file named ILSample.exe.
After this type the command called ILDasm. It will open application called Intermediate Language Disassembler. In file menu choose open and find our executable file.This application opens our assembly showing all structural units viz., classes, methods, data fields and all global and local application data. Now if you click on the method it shows code in intermediate language. This code is most like at language with independent set of instructions.
public double GetVolume(){ double volume = height*width*thickness; if(volume<0) return 0;
To clearly understand that IL really is immediately language you should write the same code in VB .NET and look at these two sources in IL. These methods will be almost identical.
The main advantages of IL are:
1. IL isn?t dependent on any language and there is a possibility to create applications with modules that were written using different .NET compatible languages.
2. Platform independence - IL can be compiled to different platforms or operating systems.
OOP & C#
The skeleton of object - oriented programming is of course the concepts of class. This C# tutorial on OOPS explains classes and their importance in implementation of object ? oriented principles.
Any language can be called object ? oriented if it has data and method that use data encapsulated in items named objects. An object ? oriented programming method has many advantages, some of them are flexibility and code reusability.
All the programming languages supporting Object oriented Programming will be supporting these three main concepts:
1. Encapsulation2. Inheritance3. Polymorphism
Encapsulation in C#:
Encapsulation is process of keeping data and methods together inside objects. In this way developer must define some methods of object?s interaction. In C# , encapsulation is realized through the classes. A Class can contain data structures and methods. Consider the following class.
In this example we encapsulate some data such as height, width, thickness and method GetVolume. Other methods or objects can interact with this object through methods that have public access modifier. It must be done using ?.? operator.
Inheritance in C#:
In a few words, Inheritance is the process of creation new classes from already existing classes. The inheritance feature allows us to reuse some parts of code. So, now we have some derived class that inherits base class?s members. Consider the following code snippet:
public class Door : Aperture{
public Door() : base(){
}
public bool isOutside = true;
}
As you see to inherit one class from another, we need to write base class name after ?:? symbol. Next thing that was done in code Door () ? constructor also
inherits base class constructor. And at last we add new private field. All members of Aperture class are also in Door class. We can inherit all the members that has access modifier higher than protected.
Polymorphism in C#:
Polymorphism is possibility to change behavior with objects depending of object?s data type. In C# polymorphism realizes through the using of keyword virtual and override. Let look on the example of code:
public virtual void Out(){ Console.WriteLine("Aperture virtual method called");} //This method is defined in Aperture class. public override void Out(){ Console.WriteLine("Door virtual method called");}
Now we need to re-define it in our derived Door class. The usage of virtual methods can be clarified when we creating an instance of derived class from the base class:
Aperture ap = new Door();ap.Out();
In such cases, the runtime keeps record of all the virtual function details in a table called VMT(Virtual Method Table) and then in runtime dynamically picks the correct version of the function to be used. Here it uses Out() method from derived class of course.
.Net C# Tutorial Namespaces A Namespace in Microsoft .Net is like containers of objects. They may contain unions, classes, structures, interfaces, enumerators and delegates. Main goal of using namespace in .Net is for creating a hierarchical organization of program. In this case a developer does not need to worry about the naming conflicts of classes, functions, variables etc., inside a project.
In Microsoft .Net, every program is created with a default namespace. This default namespace is called as global namespace. But the program itself can declare any number of namespaces, each of them with a unique name. The advantage is that every namespace can contain any number of classes, functions, variables and also namespaces etc., whose names are unique only inside the namespace. The members with the same name can be created in some other namespace without any compiler complaints from Microsoft .Net.
To declare namespace C# .Net has a reserved keyword namespace. If a new project is created in Visual Studio .NET it automatically adds some global namespaces. These namespaces can be different in different projects. But each of them should be placed under the base namespace System. The names space must be added and used through the using operator, if used in a different project.
Please now have a look at the example of declaring some namespace:
using System;namespace OutNamespace{
namespace WorkNamespace{ /// can be placed some classes, structures etc. }
}
In this example we create two namespaces. These namespaces have hierarchical structure. We have some outer one named OutNamespace and the inner one called WorkNamespace. The inner namespace is declared with a C# .Net class WorkItem.
The next logical discussion after a namespace is classes. A class is the basis of object ? oriented programming. It encapsulates the data and methods into one itself and manipulates them through the interaction with that object.
The above sample contains the .Net namespace with the class WorkItem inside it.
As already discussed, a class is the basis of Object oriented programming. A class must have a constructor. The constructor method is used for initialization purposes. Each class can have different modifiers which pertains to the type and functionality of the class. Some such modifiers are: new, public, protected, internal, private, abstract, and sealed. A class members can also have these modifiers. In the above example, there is declared special constructor type ?
static constructor. It uses only for class not for its instances. In the same way we can access to the static members of class.
OutNamespace.WorkNamespace.WorkItem item = new WorkItem();int i = WorkItem.GetCounter();
In this piece of code there was created some instance of WorkItem but called using its full name (including all namespace?s names). The second line it is an access to the public static property of WorkItem. There are many advanced features that can be used in class constructing process. One of them polymorphism that can be realized though the virtual methods.
.Net Framework basics
When we speak about .Net, we mean by .NET framework. .NET Framework is made up of the Common Language Runtime (CLR), the Base Class Library (System Classes). This allows us to build our own services (Web Services or Windows Services) and Web Applications (Web forms Or Asp .Net), and Windows applications (Windows forms). We can see how this is all put together.?
Above Picture shows overall picture, demonstrating how the .NET languages follows rules provided by the Common Language Specifications (CLS). These languages can all be used?Independently to build application and can all be used with built-in data describers (XML) and data assessors (ADO .NET and SQL). Every component of the .NET Framework can take advantage of the large pre- built library of classes called the Framework Class Library (FCL). Once everything is put together, the code that is created is executed in the Common Language Runtime. Common Language Runtime is designed to allow any .NET-compliant language to execute its code. At the time of writing, these languages included VB .Net, C# and C++ .NET, but any language can become .NET- compliant, if they follow CLS rules. The following sections will address each of the parts of the architecture.
In an object-oriented environment, everything is considered as an object. (This point is explained in this article and the more advanced features are explained in other articles.) You create a template for an object (this is called the class file), and this class file is used to create multiple objects.TIP: Consider a Rectangle. You may want to create many Rectangle in your lifetime; but each Rectangle will have certain characteristics and certain functions. For example, each rectangle will have a specific width and color. So now, suppose your friend also wants to create a Rectangle. Why reinvent the Rectangle? You can create a common template and share it with others. They create the Rectangle based on your template. This is the heart of object-oriented programming?the template is the class file, and the Rectangle is the objects built from that class. Once you have created an object, your object needs to communicate with many other Objects.
Even if it is created in another .NET language doesn?t matter, because each language follows the rules of the CLS. The CLS defines the necessary things as common variable types (this is called the Common Type System CTS ), common visibility like when and where can one see these variables, common method specifications, and so on. It doesn?t have one rule which tells how C# composes its objects and another rule tells how VB .Net does the same thing . To steal a phrase, there is now ?One rule to bind them all.? One thing to note here is that the CLS simply provides the bare rules. Languages can adhere to their own specification. In this case, the actual compilers do not need to be as powerful as those that support the full CLS.
The Common Language Runtime (CLR):
The heart of .net Framework is Common Language Runtime (CLR). All .NET-compliant languages run in a common, managed runtime execution environment. With the CLR, you can rely on code that is accessed from different languages. This is a huge benefit. One coder can write one module in C#, and another can access and use it from VB .Net. Automatic object management, the .NET languages take care of memory issues automatically. These are the few listed?benefits which you get from CLR.
Microsoft Intermediate Language (MSIL):
So how can many different languages be brought together and executed together??Microsoft Intermediate Language (MSIL) or, as it?s more commonly known, Intermediate Language (IL). In its simplest terms, IL is a programming language.?If you wanted to, you could write IL directly, compile it, and run it. But why would want to write such low level code? Microsoft has provided with higher-level languages, such as C#, that one can use. Before the code is executed, the
The above is the order of compilation and execution of programs. Once a program is written in a .Net compliant language, the rest all is the responsibility of the frame work.
Methods and propertiesAny class in an object-oriented language has method and property members. These are the places where the actual business logic or functionality is written and executed. This tutorial explains how to create and use methods and properties in C#.
C# Methods:
Method is object-oriented item of any language. All C# programs are constructed from a number of classes and almost all the classes will contain methods. A class when instantiated is called an object. Object-oriented concepts of programming say that the data members of each object represent its state and methods represent the object behavior.
Method Signature in C#:
Each method is declared as follows:
Return-type methodname ( Parameterslist );
For better understanding of methods let consider following example. We have a class Man. It can have many fields like that:
public class Man{ public Man(){} private int m_old; private string m_name; public string WhatIsYourName() { Console.WriteLine(m_name); return m_name; }
public string HowOldAreYou() { Console.WriteLine(m_old.ToString()); return m_old; } }
The private members m_old and m_name define some state of objects that can be created as instances of our class. Also the class Man has two methods, which serve some of our requests. Method string WhatIsYourName() writes current object?s name to the console and returns it, and the second one similar to first return age of man and also writes an output to the console.
The return type in the example above returns strings, which is an in-built data type. The methods can also return any generic C# type or any custom types created by us.
Passing Parameters to Methods in C#:
The input parameters can be passed in two ways. Value type Reference type.
If parameters are passed as value types a new copy of it will be created and passed inside the function. If they are created as reference types, only the address of the parameters will be passed.
See next example:
public int CalculateBirthYear(int year){ int b = year - m_old; Console.WriteLine("Birth year is {0}",b); return b; }
If input parameter pass as reference type it must use keyword ref, in that way we operate with the same cell in memory. That?s mean it can be changed inside any method. A small example for a parameter passed by reference is:
public int CalculateBirthYear(ref int year) { int b = year - m_old; Console.WriteLine("Birth year is {0}",b); return b;}
Now, the function CalculateBirthYear can even modify the value of year as it is passed by reference.
Output Parameters in Methods: The return values in any function will be enough for any one if only one value is needed. But in case a function is required to return more than one value, then output parameters are the norm. This is not supported in C++ though it can be achieved by using some programming tricks. In C# the output parameter is declared with the keyword out before the data type. A typical example is as follows.
public void CalculateBirthYear(ref int year, out int birthyear){ int b = year - m_old; Console.WriteLine("Birth year is {0}",b); birthyear = b; return; }
Strictly speaking there is no difference between ref and out parameters. The only difference is that the ref input parameters need an input value and the out parameters don?t.
Variable arguments in C#: The C# language supports variable arguments through a keyword called params. A typical example for the declaration of a function with variable argument signature is as follows.
Public void functionName(int a, params int[] varParam);
Method Overloading in C#:A method is considered to be an overloaded method, if it has two or more signatures for the same method name. These methods will contain different parameters but the same return types.
A simple example for an overloaded methods are:
Public void functionName(int a, params int[] varParam);Public void functionName(int a);
Property in C#:
Property ? it is a special method that can return a current object?s state or set it. Simple syntax of properties can see in the following example:
public int Old { get {return m_old;} set {m_old = value;} } public string Name { get {return m_name;} }
Here are two types of properties. A first one can set or get field of class named m_old, and the second is read only. That?s mean it can only get current object?s state.
The significance of these properties is its usability. These properties need not be called with any function names like objectname.get or objectname.set etc., But they can be directly assigned the values or retrieve the values.
C# .Net and Java
This article compares the same program written in the C# and Java languages and then compares the dissembled code of both languages.
Java Hello Program:
class Hello{
public static void main(String args[]) { System.out.println("Hello");}
To understand this you must have some knowledge of computer internals concepts for eg. Opcodes, instruction templates etc. I assume that you already know them.
As usual this code will also start with main method. The first line tells that print ?Hello? it is a normal print statement. A specific instruction, with type information, is built by replacing the ?T? in the instruction template in the opcode column by the letter in the type column. In this case it is a load instruction for type reference.
Invokespecial instruction must name an instance initialization method, a method in the current class, or a method in a superclass of the current class. Class and interface initialization methods are invoked implicitly by the Java virtual machine; they are never invoked directly from any Java virtual machine instruction, but are invoked only indirectly as part of the class initialization process.
invokevirtual or invokespecial is used to access a protected method of a superclass, then the type of the class instance being accessed must be the same as or a subclass of the current class.
The Java virtual machine uses local variables to pass parameters on method invocation. On class method invocation any parameters are passed in consecutive local variables starting from local variable 0.
C# Hello Program:
using System;
class Hello {
public static void Main(string[] args) { Console.WriteLine("Hello"); }
The first line defines the Main method by using the .method MSIL keyword. Note that the method is defined as being public and static, which are the default
modifiers for the Main method. Also note that this method is defined as managed.
The next line of code uses the MSIL .entrypoint keyword to designate this particular method as the entry point to the application. When the .NET runtime executes this application, this is where control will be passed to the program.
Next, look at the MSIL opcodes on lines IL_0000 and IL_0005. The first uses the the ldstr (Load String) opcode to load a hard-coded literal ("Hello") onto the stack.
The next line of code calls the System.Console.WriteLine method. Notice that the MSIL prefixes the method name with the name of the assembly that defines the method. This line also tells us the number of arguments (and their types) that are expected by the method. Here, the method will expect a System.String object to be on the stack when it's called. Finally, line IL_000a is a simple ret MSIL opcode to return from the method
C# .Net Tutorial Attributes This article deals with the new C# .net features named attributes. This can be used as a Self paced C# .net training or C# tutorial material.
C# .net Attributes provide a powerful method of associating declarative information with C# code. It can work with types, methods, properties and other language components.
As a thumb-rule, a class is said to be an attribute class, if it directly or indirectly derives from the System.Attribute class.
Attributes in C# .net - Sample:
This C# tutorial on attributes uses custom attributes by defining an attribute class. The class ProductInfo is derived from System.Attribute class. This class contains information about application author and product version. The created class is:
[AttributeUsage(AttributeTargets.All)] public class ProductInfo : System.Attribute {
private double m_version = 1.00; public string AuthorName {
get { return m_authorName; }
}
private string m_authorName;
}
There is a new item in the first line of code. It is an attribute that allows us to use a c# attribute keyword AttributeUsage to all elements of our class (parameter AttributeTargets.All).
Now we can use these c# attributes in declaration of any other custom class:
[ProductInfo(1.005,"CoderSource"])
public class AnyClass { }
After creating simple custom type c# attributes, we can get information about all its attributes at runtime. Such run-time information can be pulled out from a class by using the namespace System.Reflection. In main function of our C# tutorial program we can get from our object all information about custom attributes. Next piece of code demonstrate it:
Using standard methods of getting type information and members of his type we can get all custom attributes.
The example in this C# tutorial uses only one of three library c# attributes (AttributeUsage). It uses only with declaration some custom c# attribute. There is another standard attribute called Conditional. It calls method with that attribute only in case when method application has some needed condition. Most often it is used to define some preprocessor commands (?#?). And the last reserved attribute is Obsolete. It helps us to mark some elements of program that are old to use. These are basic things about attributes and their usage in applications.
C# .Net Tutorial Exceptions This article is a basic c# tutorial dealing with exceptions in c# .net.
Practically any program including c# .net can have some amount of errors. They can be broadly classified as compile-time errors and runtime errors. Compile-time errors are errors that can be found during compilation process of source code. Most of them are syntax errors. Runtime errors happen when program is running.
It is very difficult to find and debug the run-time errors. These errors also called exceptions. Rules of good coding style say that program must be able to handle any runtime error. Exception generates an exception call at runtime. Exceptions in C# can be called using two methods:
1. Using the throw operator. It call the manage code anyway and process an exception.
2. If using the operators goes awry, it can generate an exception.
C# language uses many types of exceptions, which are defined in special classes. All of them are inherited from base class named System.Exception. There are classes that process many kinds of exceptions: out of memory exception, stack overflow exception, null reference exception, index out of range exception, invalid cast exception, arithmetic exception etc. This c# tutorial deals with DivideByZero c# exception and custom classes in c# exceptions.
C# has defined some keywords for processing exceptions. The most important are try, catch and finally.
The first one to be known is the try operator. This is used in a part of code, where there exists a possibility of exception to be thrown. But operator ?try? is always used with the operators: catch and finally.
See the following example of handling a simple exception in c#.
//Sample code for C# Exception tutorial using try , catch
// try catch exceptionint zero = 0;try{ int div = 100/zero;}catch(DivideByZeroException){ Console.WriteLine("Division by zero exception passed");}
This code in runtime throws a DivideByZeroException and writes some message through the console. But if you want to release some resources that were created you must use try ? finally construction. Finally will be called even if there were no exceptions raised.
//Sample code for C# Exception tutorial using try, finally
bit.Dispose();Console.WriteLine("bitmap is disposed");
}
In the similar way we can use try ? catch ? finally construction. The attached c# tutorial program contains sample including all the three.
Custom Exception Classes - C# Tutorial:
Some larger projects might have a requirement of creating their own custom exception classes. Let us try to create class that validates email address. It will validate for the ?@? symbol. Please have a look on the following piece of code:
//Sample code for C# .Net Exception tutorial - validates an email address
public class TextException : Exception{
public TextException() : base()<br>{}
public TextException(string message) : base(message){
}
}
public class MailValidator{
MailValidator(){
}
private static char symbol = '@';
public static void TestEnteredMail(string mailAddress){
if(mailAddress.IndexOf(symbol)==-1){
Console.WriteLine("The string entered is not a valid email address");<br>throw(new TextException());
}
}
}
Here were created a C# .Net TextException class that inherits from System.Exception class of .NET class library. Actually it does nothing, but there is an additional class MailValidator. It has TestEnteredMail method that raises a TextException. Now look at usage of it in Main function.
So, if user enters mail address without it throws an exception. All the sources are attached and compliable. The example can be compiled using .NET command line through the csc command line program. You only need to type csc filename.cs.
C# .Net Tutorial Interfaces This C# Tutorial deals with interfaces in C# .Net. An Interface is a reference type and it contains only abstract members. Interface's members can be Events, Methods, Properties and Indexers. But the interface contains only declaration for its members. Any implementation must be placed in class that realizes them. The interface can't contain constants, data fields, constructors, destructors and static members. All the member declarations inside interface are implicitly public.
Defining an Interface:
Let us look at a simple example for c# interfaces. In this example interface declares base functionality of node object.
The above INode interface has declared a few abstract properties and function which should be implemented by the derived classes.
//Sample for Deriving a class using a C# .Net interface - c# tutorial
public class Node : INode {
public Node(){}public string Text{
get{ return m_text;}
set{ m_text = value; }
}
private string m_text; public object Tag{
get{ return m_tag; }
set{
m_tag = value; }
}
private object m_tag = null; public int Height{
get{ return m_height; }
set{ m_height = value; }
}
private int m_height = 0; public int Width{
get{ return m_width; }
set{ m_width = value; }
}
private int m_width = 0;
public float CalculateArea(){
if((m_width<0)||(m_height<0))
return 0;
return m_height*m_width;
}
}
Now the above code has created a c# class Node that inherits from INode c# interface and implement all its members. A very important point to be remembered about c# interfaces is, if some interface is inherited, the program must implement all its declared members. Otherwise the c# compiler throws an error.
The above code was a simple example of c# interface usage. Now this has to be followed with some advanced details of interface building in C# .Net. The previous example used only names of methods or properties that have the same names as in interface. But there is another alternative method for writing the implementation for the members in class. It uses full method or property name e.g. INode.CalculateArea () {// implemetation}.
Multiple Inheritance using C# interfaces:
Next feature that obviously needs to be explained is multiple inheritance using c# interfaces. This can be done using child class that inherits from any number of c# interfaces. The inheritance can also happen with a combination of a C# .Net class and c# interfaces. Now let us see a small piece of code that demonstrate us multiple inheritance using only interfaces as parent data types.
The above example created a class ClonableNode. It implements all the functionality of INode interface in the same way as it was done in Node class. Also it realizes Clone method only one item of IClonable interface of .NET library.
is Operator for C# .Net interfaces - C# Tutorial:
At last a new C# operator that can be used to define that class should be explained. It is the is operator. Look at the following piece of code:
if(nodeC is INode) Console.WriteLine("nodeC is object of INode type");else Console.WriteLine("nodeC isn't object of INode type");
In example nodeC object was created as ClonableNode type, but when we run program "if operator" returns true. It means that nodeC also is of INode type.
C# .Net Tutorial Multithreading Any Windows application must have one or more processes. A Process is structural unit with a memory block and using some set of resources. For each executable, the Windows operating system creates some isolated memory block. This C# .Net Tutorial tries to explain the basics of Multithreading in C# .Net.
Every process must have at least one thread. The first thread is created with a process and is known as primary thread. This Primary Thread is entry point of application. In traditional Windows applications it is the method WinMain() and in console applications it is named main().
Main goal of creating multithreading application is performance improvement. As an example, imagine a situation where in a user starts a long process (e.g. copying), he can?t use a single threaded application and wait for an infinite time for the operation to get completed. But if he uses multi?threading application he can set copying process in the background and interact with application without any problems.
At first, if one wants to create a multi-threaded application an important point to be remembered is, a global variable, which is being accessed by different threads, can try to modify the same variable. This is a generic problem, which is solved using a mechanism called Synchronization of threads. Synchronization is nothing but the process of creating some set of rules to operate data or resources.
The C# .Net language has a powerful namespace which can be used for programming with Threads as well as Thread Synchronization in C# .Net programming. The name of the namespace is Sytem.Threading. The most important class inside this namespace for manipulating the threads is the C# .Net class Thread. It can run other thread in our application process.
Sample program on C# Multithreading - C# Tutorial:
The example it creates an additional C# .Net class Launcher. It has only one method, which output countdown in the console.
//Sample for C# tutorial on Multithreading using lock
public void Coundown(){
lock(this){
for(int i=4;i>=0;i--){
Console.WriteLine("{0} seconds to start",i);
}
Console.WriteLine("GO!!!!!");
}
}
There is a new keyword lock inside the above chunk of .Net C# tutorial code. This provides a mechanism for synchronizing the thread operation. It means at the same point of time only one thread can access to this method of created object. Unless the lock is released after completion of the code, the next routine or iteration cannot enter the block.
To understand it more clearly please have a look at the piece of main method?s code:
Launcher la = new Launcher();
Thread firstThread = new Thread(new ThreadStart(la.Coundown));Thread secondThread =new Thread(new ThreadStart(la.Coundown));Thread thirdThread = new Thread(new ThreadStart(la.Coundown));
As you see there were created three additional threads. These threads start a method of object that has Launcher type. The above program is a very simple example of using multi-threading in C#. Net. But C# .Net allows us to create more powerful applications with any level of complexity.
C# .Net Tutorial Reflection
Reflection is the feature in .Net, which enables us to get some information about object in runtime. That information contains data of the class. Also it can get the names of the methods that are inside the class and constructors of that object.
To write a C# .Net program which uses reflection, the program should use the namespace System.Reflection. To get type of the object, the typeof operator can be used. There is one more method GetType(). This also can be used for retrieving the type information of a class. The Operator typeof allow us to get class name of our object and GetType() method uses to get data about object?s type. This C# tutorial on reflection explains this feature with a sample class.
public class TestDataType{
public TestDataType(){ counter = 1;}
public TestDataType(int c){ counter = c;}
private int counter;
public int Inc(){ return counter++;}public int Dec(){ return counter--;}
}
At first we should get type of object that was created. The following C# .Net code snippet shows how to do it.
TestDataType testObject = new TestDataType(15);Type objectType = testObject.GetType();
Now objectType has all the required information about class TestDataType. We can check if our class is abstract or if it is a class. The System.Type contains a few properties to retrieve the type of the class: IsAbstract, IsClass. These functions return a Boolean value if the object is abstract or of class type. Also there are some methods that return information about constructors and methods that belong to the current type (class). It can be done in a way as it was done in next example:
Type objectType = testObject.GetType();
ConstructorInfo [] info = objectType.GetConstructors();MethodInfo [] methods = objectType.GetMethods();
// get all the constructorsConsole.WriteLine("Constructors:");foreach( ConstructorInfo cf in info )
Console.WriteLine();// get all the methodsConsole.WriteLine("Methods:");foreach( MethodInfo mf in methods ){ Console.WriteLine(mf);}
Now, the above program returns a list of methods and constructors of TestDataType class.
Reflection is a very powerful feature that any programming language would like to provide, because it allows us to get some information about objects in runtime. It can be used in the applications normally but this is provided for doing some advanced programming. This might be for runtime code generation (It goes through creating, compilation and execution of source code in runtime).
The Sample code can be downloaded from here. The attached example can be compiled using .NET command line csc command. Type csc Reflection.cs. This will create the executable Reflection.exe, which can be run as a normal executable.
COM InteropThe ultimate goal of COM Interop is to provide access to the existing COM
components without requiring that the original component be modified. This tries to make the .NET types equivalent to the COM Types.
COM Interop and Marshalling:
COM had a mechanism of marshalling and un-marshalling to convert between the source and target data types. This is now totally covered in COM Interop using RCW or Runtime Callable Wrapper. This automatically converts the .Net data types to the corresponding COM data types.
In addition, COM Interop allows COM developers to access managed objects as easily as they access other COM objects. It provides a specialized utility (RegAsm.exe) that exports the managed types into a type library and registers the managed component as a traditional COM component. At run time, the common language runtime marshals data between COM objects and managed objects as needed.
This tutorial shows how C# can use COM objects to develop applications. First thing to be done is the creation of wrapper class for the selected COM object. It can be done manually through the command line application called TlbImp.exe (Type Library Importer). This utility converts COM type library to the .NET Framework metadata. This procedure can be done automatically through the .NET environment. We just need to add reference to the COM object to our C# project. So, type in .NET command line next string: tlbimp $WindowsPath$\system32\quartz.dll /out: quartzNET.dll. This command will create a new dll with types that are compatible with any of Managed .NET languages. Now we can add this dll to our C# project or compile our C# file with additional feature "/r quartzNET.dll".
The following is an example of usage this COM object in C# managed code:
quartzNET.FilgraphManager manager = new quartzNET.FilgraphManagerClass();quartzNET.IMediaControl mc = (quartzNET.IMediaControl)manager;mc.RenderFile(args[0]);mc.Run();// Wait for completion.Console.WriteLine("Press Enter to continue."); Console.ReadLine();
Here is the MediaControl object, which was created in COM. This application gets a name of video file that we want to play from command line and shows it. So, this is a simple example of usage COM Interop. To compile an attached example we just need this quartzNET.dll (is attached too) and .NET command line. Type here next command csc InteropSample.cs /r:quartzNET.dll. It must create an executable file, but it can be run using command line, just type InteroPsample.exe some.avi. So, it opens a console application and also runs a standard Windows media player control to play the video.
This tutorial describes some basics about some of the great features of C# language namely Delegates and Events. These new constructs are used in object-oriented programming languages like C# and Java.
Delegates in C# .Net:
If we look at C++ there is a feature called callback function. This feature uses Pointers to Functions to pass them as parameters to other functions. Delegate is a similar feature but it is more type safe, which stands as a stark contrast with C++ function pointers. A delegate can hold reference/s to one more more functions and invoke them as and when needed.
A delegate needs the method's name and its parameters (input and output variables) when we create a delegate. But delegate is not a standalone construction. it's a class. Any delegate is inherited from base delegate class of .NET class library when it is declared. This can be from either of the two classes from System.Delegate or System.MulticastDelegate.
If the delegate contains a return type of void, then it is automatically aliased to the type of System.MulticastDelegate. This can support multiple functions with a += operator. If the delegate contains a non-void return type then it is aliased to System.Delegate class and it cannot support multiple methods.
Let us have a look at the following sample code.
class Figure{ public Figure(float a, float b, float c) { m_xPos = a; m_yPos = b; m_zPos = c; }
Now, we have a class named Figure and it has three private fields that use to store position and three methods to invert this position by every axis. In main class we declare delegate as follows:
public delegate void FigureDelegate();
And now in the main function we should use it like this: Figure figure = new Figure(10,20,30);FigureDelegate fx = new FigureDelegate(figure.InvertX); FigureDelegate fy = new FigureDelegate(figure.InvertY); FigureDelegate fz = new FigureDelegate(figure.InvertZ); MulticastDelegate f_del = fx+fy+fz;
In this example we create three delegates of FigureDelegate type and attach to these elements our three methods from Figure class. Now every delegate keeps the address of the attached function. The last line of code is very interesting, here we create a delegate of base type (MulticastDelegate) and attach three of our already created delegates. As all our methods are of void return type they are automatically of type MutlticastDelegate and a MulticastDelegate can support multiple methods invocation also. Hence we can write
Figure figure = new Figure(10,20,30); FigureDelegate fMulti = new FigureDelegate(figure.InvertX); fMulti += new FigureDelegate(figure.InvertY); fMulti();
Events in C# .Net:
Delegate usefulness does not just lie in the fact that it can hold the references to functions but in the fact that it can define and use
function names at runtime and not at compile time. A large goal of design delegates is their applicability in events model of .Net. Events are the actions of the system on user manipulations (e.g. mouse clicks, key press, timer etc.) or any event triggered by the program. To understand the usage of delegates for event model, the previous examples are used here. We should add to our Figure class next things:
public delegate void FigureHandler(string msg); public static event FigureHandler Inverted;
public void InvertZ() {
m_zPos = - m_zPos; Inverted("inverted by z-axis");
}
Now we have a delegate declared and event that uses this delegate's type. In every function we should call our event. The next code snippet should explain it clearly:
static void Main(string[] args) {
Figure figure = new Figure(10,20,30); Figure.Inverted+=new Test.Figure.FigureHandler(OnFigureInverted); figure.InvertX(); figure.InvertZ(); } private static void OnFigureInverted(string msg) { Console.WriteLine("Figure was {0}",msg); }
So, in the main function we should create an object of figure class and attach event handler to the method OnFigureInverted. And when we call any of invert methods the event is fired and it calls our event handler. The application will print the following string into the console: Figure was inverted by x-axis Figure was inverted by z-axis There was simple examples of using delegates and events and should be treated as a starting point to learn it more yourself. Download the C# Delegates source files from the link. To compile and run it need to run .NET
command line. Just type: csc TestClass.cs. It creates TestClass.exe that can be run as standard executable file.
C# Method Overloading
Last Update: 9 February, 2005
In complex applications written in C#, we may need many methods which do essentially similar functions but are just different enough to be considered unique. For example, we may have to calculate a person's tax liability and would need to implement a method for doing this calculation in our application program. However, there are many different rules when it comes to tax calculations and they vary throughout the world. While there may be many rules, one basic equation stays the same: Your net income equals your gross income minus a computed tax amount. It is the method of computing your tax that varies.
We would probably have to implement different methods for each type of tax calculation. And, we could give each method a unique name such as TaxCalc1, TaxCalc2, TaxCalc3, etc. But wouldn't it be nice to just name the method TaxCalc and pass different arguments to it based on the computation desired?
For instance, let's say you live in a region within your country where you are taxed on your personal income, the value of your home, and any income you generate by doing business. On sales you generate through business activity, you must pay a gross receipts tax on all sales. If you own your home, you must pay a property tax on the imputed value of it. Then lastly, you must pay a tax on all income you generate through a job with another employer.
An Example: Tax Calculation
For this article, we will use a hypothetical example of computing various taxes on a person's property, sales, and income. Let's summarize the logical flow through pseudocode:
HV = Home_ValueHR = Home_Tax_RateGS = Gross_SalesGR = Gross_Sales_Tax_RatePI = Personal Income
If YOU_OWN_YOUR_OWN_HOME and DO_NOT_OWN_A_BUSINESS THEN Tax = TaxCalc(HV,HR) ' Calculate tax on the home's valueELSE If YOU_DO_NOT_OWN_YOUR_OWN_HOME and OWN_A_BUSINESS THEN
Tax = TaxCalc(GS,GR) ' Calculate tax on your gross receipts from sales ELSE If YOU_OWN_YOUR_OWN_HOME and OWN_A_BUSINESS THEN Tax = TaxCalc(HV,HR,GS,GR) ' Calculate tax on both your home and gross receipts ENDIF ENDIFENDIF
Tax = Tax + TaxCalc(PI) ' And everyone gets a tax calculation on personal income
The pseudo code says that if you own your own home but do not have a business, then you will calculate your tax based on the home's value and the tax rate on a home. If you don't own a home but you own a business then you will calculate your tax based on your gross sales and gross sales tax rate. Finally, if you own a home and a business then you will call TaxCalc and pass all four values. Everyone is run through the TaxCalc method for personal income tax. We don't have to pass a rate for personal income tax calculation because everyone is at a fixed rate which is embedded within the method.
Keep in mind that this example of tax calculation is all hypothetical. Tax codes and calculations, as you know, are much more complex than what is described here throughout the world. But for the sake of this example, we see that we have a method named TaxCalc that is able to take one, two, or four arguments based upon the type of tax we are calculating. Without method overloading, we would have to create a unique method name for each type of calculation we would have to do. We would probably name each TaxCalc1, TaxCalc2, and TaxCalc3 respectively.
How does C# know which method to call? It's easy. It knows which method to invoke based on the number and type of arguments passed to it. This is also referred to as the signature of the method. If C# sees you are calling TaxCalc with four arguments, then it will call that method with four receiving arguments. The same is true for the other two methods as well.
The Overloaded Methods
Each method is defined as follows in our overloading example:
// This method takes for arguments: two amounts and two ratespublic static double TaxCalc(double pamt1, double prate1, double pamt2, double prate2){ double taxamt;
// This method only takes two arguments: an amount and a ratepublic static double TaxCalc(double pamt1, double prate1){ double taxamt; Console.WriteLine("Using method with 2 arguments"); taxamt = pamt1 * prate1; return taxamt;
} // *** TaxCalc ***
// This method only takes one argument: an amountpublic static double TaxCalc(double pamt){ double taxrate = 0.15; double taxamt = 0; Console.WriteLine("Using method with 1 argument"); taxamt = pamt * taxrate; return taxamt;
} // *** TaxCalc ***
The methods are all very similar however they are differ by the number of arguments used in the tax calculation. If we have two tax rates and two amounts, C# would pick the first method based on four arguments and invoke that. The same holds true for the other two methods.
Caveat
It is important to remember that C# determines which method to call based upon the method's signature. If you were to define two methods with the same name and the same number and type of passed arguments, you would get a compile-time error in Visual Studio .NET of:
Class1.cs(53): Class 'MethodOverload.MainClass' already defines a member called 'TaxCalc' with the same parameter types
However, you can have two methods with the same name and the same number of arguments as long as the argument types differ. Let's say, for instance, that you want to have another one-argument
method named TaxCalc that takes a string argument. If the string is the literal "TaxTable1", then it will return the tax rate used in personal tax calculations:
// This method only takes one argument as well but it differs// from the above in the argument type.
public static double TaxCalc(string whichtable){ double taxrate = 0; Console.WriteLine("Calling the method with on string argument"); if (whichtable == "TaxTable1") taxrate = 0.15;
return taxrate;
} // *** TaxCalc ***
The Example Program: MethodOverLoad.exe
This article has an example application available for download with the above methods. It is a C#.NET console application and can be invoked from a Dos command window by typing in methodoverload in the folder containing methodoverload.exe. The main driver implements the pseudocode we defined previously:
Console.WriteLine("Do you own a home? (y/n)"); inputs = Console.ReadLine();
if (inputs == "y") { ownshome = true;
Console.WriteLine("What is its value?"); inputs = Console.ReadLine(); hv = Convert.ToDouble(inputs); Console.WriteLine("What is the home tax rate?"); inputs = Console.ReadLine(); hr = Convert.ToDouble(inputs); }
Console.WriteLine("Do you own a business? (y/n)"); inputs = Console.ReadLine();
if (inputs == "y") { ownsbusiness = true; Console.WriteLine("What was your total sales?"); inputs = Console.ReadLine(); gs = Convert.ToDouble(inputs); Console.WriteLine("What is the gross sales tax rate?"); inputs = Console.ReadLine(); gr = Convert.ToDouble(inputs); }
if (ownshome && !ownsbusiness) totaltax = TaxCalc(hv, hr); else if (!ownshome && ownsbusiness) totaltax = TaxCalc(gs, gr); else if (ownshome && ownsbusiness) totaltax = TaxCalc(hv, hr, gs, gr);
Console.WriteLine("How much did you make last year?"); inputs = Console.ReadLine(); pi = Convert.ToDouble(inputs); totaltax = totaltax + TaxCalc(pi); Console.WriteLine("Your total tax is {0}", totaltax); pitaxrate = TaxCalc("TaxTable1"); Console.WriteLine("Personal tax rate is {0}", pitaxrate);
Method overloading is a powerful concept in C# in that it helps to simplify code reusability and clarity. If our example method of TaxCalc was placed in a .dll file somewhere, I would only have to remember that I have to call TaxCalc and only fill in the appropriate arguments to pass. Without method overloading, I would have to try and remember which specific uniquely-named method to call. This would present a problem if you do not code everyday using a particular method in that time would be spent getting familiar with the methods all over.
Reflection in C# This article is aimed to explain reflection in .NET Framework.
Reflection is one of the features of .Net framework and has greater importance during the development of large applications. In brief it is a powerful way of collecting and manipulate information present in application's assemblies and its metadata. Metadata contain all the Type information used by the application. The ability to obtain information at runtime also makes it even more advantageous. When reflection is used along with system.type, it allows the developer to get the valuable information about all the types and about the assemblies. We can even create the instances and then invoke various types that are used across the application.
What is Reflection?
Reflection is the ability to find out information about objects, the application details (assemblies), its metadata at run-time.
This allows application to collect information about itself and also manipulate on itself. It can be used effectively to find all the types in an assembly and/or dynamically invoke methods in an assembly. This includes information about the type, properties, methods and events of an object and to invoke the methods of object Invoke method can be used too. With reflection we can dynamically create an instance of a type, bind the type to an existing object, or get the type from an existing object and invoke its methods or access its fields and properties. If Attributes (C#) are used in application, then with help of reflection we can access these attributes. It can be even used to emit Intermediate Language code dynamically so that the generated code can be executed directly.
System.Reflection namespace contains all the Reflection related classes. These classes are used to get information from any of the class under .NET framework. The Type class is the root of all reflection operations. Type is an abstract base class that acts as means to access metadata though the reflection classes. Using Type object, any information related to methods, implementation details and manipulating information can be obtained. The types include the constructors, methods, fields, properties, and events of a class, along with this the module and the assembly in which these information are present can be accessed and manipulated easily.
As mentioned earlier, we can use reflection to dynamically create an instance of any type, bind the type to an existing object, or get the type from an existing object. Once this is done appropriate method can be invoked, access the fields and properties. This can be done by specifying the Type of object or by specifying both assembly and Type of the object that needs to be created. By this the new object created acts like any other object and associated methods, fields and properties can be easily accessed. With reflection we can also find out about various methods associated with newly created object and how to use these object. To find out the attributes and methods associated with an object we can use the abstract class MemberInfo, this class is available under the namespace System.Reflection.
Understanding Constructors in C#Constructors are used for initializing the members of a class whenever an object is created with the default values for initialization.
If a class is not defined with the constructor then the CLR (Common
Language Runtime) will provide an implicit constructor which is called as Default Constructor.
A class can have any number of constructors provided they vary with the number of arguments that are passed, which is they should have different signatures.
Constructors do not return a value. Constructors can be overloaded.
If a class is defined with static and Non-static constructors then the privilege will be given to the Non-static constructors.
The following are the access modifiers for constructors,
Public : A constructor that is defined as public will be called whenever a class is instantiated.
Protected : A constructor is defined as protected in such cases where the base class will initialize on its own whenever derived types of it are created.
Private : A constructor is defined as private in such cases whenever a class which contains only static members has to be accessed will avoid the creation of the object for the class.
Internal : An internal constructor can be used to limit concrete implementations of the abstract class to the assembly defining the class. A class containing an internal constructor cannot be instantiated outside of the assembly.
External : When a constructor is declared using an extern modifier, the constructor is said to be an external constructor.
Types of Constructors
i) Static : Used for initializing only the static members of the class. These will be invoked for the very first time the class is being loaded on the memory. They cannot accept any arguments. Static Constructors cannot have any access modifiers.
ii) Non-Static : are used for initializing the Non-Static and Static members of a class. These will be invoked everytime a new object is defined for a class.
If you observe in the above example the static variable `ns' cannot be assigned a value in the static Constructor as it is a Non-static member of the class and a static constructor cannot initialize a Non-Static member.
Also as you see in the above code the Non-static constructor initializing the values for both the static and Non-Static members of class, when we say `sc' we are creating an object for the class and using the object we do the call the methods, it is not valid to call a static member of class using the object of the class we have to call it through the method name/Constructor name through the member will be invoked.
Methods help you to separate code into modules that perform a given task. Every program or application have a starting entry point to there application that decide the path execution and all. We already come across different application where the starting point or entry point is main ( ) method. Methods provide the flexibility where we can separate the code into modules. This will make easy understanding of code, more reusability and increase performance. The method can pass parameters to another method and return the value that is optional. If the method contains “void” keyword, this means method will not return any thing.
Method Chaining:- The method chaining is the process by which one method calls another method. The caller method can pass parameters to the called method and in return the called method return some value (this is optional).
Example
The following example will demonstrate the method concepts along with the method chaining.
Method Chaining: Here we can add two values to the form and User can select the options i.e. 1 Add, 2 Subtract, 3 Multiply and 4 Divide. And result will be displayed when the user click Execute.
case 2: fxsubtract(_firstVal, _secondVal); break ;
case 3: fxmultiply(_firstVal, _secondVal); break ;
case 4: fxdivide(_firstVal, _secondVal); break ;
default :
MessageBox .Show( "Please Enter Specified Value.." );
break ;
}
}
void fxadd( int firstarg, int secondarg) {
int _add = firstarg + secondarg;
txtResult.Text = _add.ToString();
}
void fxsubtract( int firstarg, int secondarg) {
int _sub = (firstarg - secondarg);
txtResult.Text = _sub.ToString();
}
void fxmultiply( int firstarg, int secondarg){
int _mul = firstarg * secondarg;
txtResult.Text = _mul.ToString();
}
void fxdivide( int firstarg, int secondarg){
int _div = firstarg / secondarg;
txtResult.Text = _div.ToString();
}
}
}
Output
Namespaces are C# program elements that are used for logical grouping of the classes. They also provide assistance in avoiding name clashes between two sets of codes. Namespaces doesn't corresponds to file or directory names. The using directives e.g.
Using System;
This contains number of classes, by including this namespace we can access those classes that are there in the System namespace.
MessageBox .Show( "Display under rootnamespace " );
}
}
}
}
namespace secondnamespace
{
// nested namespace
namespace firstlevelnamespace
{
class TestDemo1
{
public static void fxTest1()
{
MessageBox .Show( "Fire UP secondnamespace" );
}
public static void fxTest()
{
MessageBox .Show( "Fire UP secondnamespace.firstlevelnamespace.fxTest" );
}
}
}
}
Example Explanation:
In above example we have 3 namespaces i.e. cSHARPEXAMPLES, rootnamespace, secondnamespace.Rootnamespace contains irstlevelnamespace namespace,2 classes i.e TestDemo, TestDemo11 and these classes contains methods i.e. fxTest(),fxDisplay(). Secondnamespace contains nested namespace i.e. firstlevelnamespace, 1 class i.e. TestDemo1 and the class contains methods i.e fxTest1(),fxTest().
Classes are the core of OOP's. Classes are declared by using the keyword classes. Classes contain data members that represent the class. We can create object of the class, objects are entities and we can create as many number of objects of a given class.
Syntax:
Class classname {
//Variable declaration
// Method declaration
}
Classes can contain the following entities inside its declaration:
Constructors
Destructors
Fields
Methods
Properties
Indexers
Delegates
Events
Nested Classes.
Constructors:- Constructors are called or initialized automatically whenever an object of the class is created. The purpose of the constructors is to initialize the class members whenever an object of the class is created.
Constructor name is same as of class name.
Constructor doesn't return any value, nor even void
Constructor initialize the class members at the time of its creation
There are different types of constructor:
Default Constructor
Parameterized Constructor
Copy Constructor
Destructor:- Destructor is used to deallocate any memory that is allocated to the object at the time of its creation. Destructor is used for memory management and avoids any memory leaks that occur in the case of reference variables that store on heap memory.
Destructor keeps tracks of all the unwanted and unused memory and frees it when we are not using it.
In .net the memory management is automatically done through GC i.e. garbage collection, this is responsible for deallocation of memory.
The reference variable memory allocated on heap and here the job of GC comes into picture, it will deallocate the memory that is not in used.
The value type variables allocated memory on stack, here the variable doesn't require any GC, they just fall from the stack if there are not in used.
Example: Demonstrate Constructor, Destructor and used of Static method .
Inheritance is one of the primary concepts of object-oriented programming. Inheritance is the process by which we can inherits the properties or methods of one class into the other class. The concept behind inheritance, take the base class that contains methods and properties and inherits it into the derived class, that now contains all the members and properties of the base class as well as its own newly added members or properties. The following are the advantages of Inheritance:-
Reuse the existence code
Save time, we need not do the code verification and testing.
Here, we can add and modify the methods of the existing class.
Help in modularization of code.
Types of Inheritance:
The following are the types of inheritance exist in C# programming.
Single Inheritance:
Here we have single base class that is inherited by the derived class. Here the derived class has all the features of the base class and can add new features or modify existing features. The inheritance also depends on the access specifier that is used at the time of base class inheritance.
Multi-level Inheritance:
In the multi-level inheritance, here we having a chain of inheritance i.e. the base class A is inherited by derived class B, and it is further inherited by another derived class C. So, the feature we have in base class A, is also there in Derived class B, and all the combination features of class A and class B are there in derived class C.
Multiple Inheritance:
In C#, we don't have multiple inheritance where one class can inherit two base classes. So, the multiple inheritance can be done by using the concept of interfaces. Here one class can inherit one class and can implements more than one interface.
Hybrid Inheritance:
The hybrid inheritance can also be done through with the help of interface. Here the derived class cans implements more than two interfaces and only one class.
MessageBox.Show( "Call in Derived method that further call Base method ===>" + obj.Show1());
}
}
}
OutPut:
When User Clicks On :Simple Inheritance Button
When User Clicks On :Calling Base Method in Derived Method Button
Polymorphism is the core concept of OOP's. Polymorphism means one name many forms.
Types of polymorphism
1. Compile Time Polymorphism
2. Run Time Polymorphism
Compile Time Polymorphism
The compile time polymorphism, here the polymorphism is implemented during compile time, that means at the time of compilation the compiler knows where to bind the method. The compile time polymorphism can be implemented through:
Method Overloading
Operator Overloading
Method Overloading:
In complex applications written in C#, we may need many methods which do essentially similar functions but are just different enough to be considered unique. So, we can define method overloading as if two or three method in a class has same name but they differ by number of arguments or type of argument.
Operator Overloading:
This provides a meaningful understanding of the operation by using operator overloading. Here what we did is we overload an operator and change its meaning, so that a valuable information is send to the programmer and this help in reducing the complexity.
E.g.
If we need to add two matrix of 3X3
Matrix result = Matrix.Add(mat1, mat2); // this doesn't give any relevant information
Run Time Polymorphism
The run time polymorphism, here the compiler doesn't know which method to call at runtime. Here we can call the derived method through base class pointer at runtime. The run time polymorphism can be implemented through: Virtual – Override Keyword.
Vitual function:
The virtual function is used to implement runtime polymorphism; here we have same name method in the base class as well as in the derived class. We can access the derived method using the base pointer. The virtual keyword should be write in front of the base class method and in the derived class we have to write override in front of the method. For Example:-
Class BaseClass {
Virtual void display () {//statements}
}
Class DerivedClass {
Override void display () {//statements}
}
Example: Demonstrate Polymorphism
BaseClass8.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace cSHARPEXAMPLES
{
class BaseClass8
{
String str = "Base" ;
public BaseClass8() { }
public String display() {
return str + ": BaseClass Display" ;
}
public virtual String show() {
return str + ": BaseClass Show" ;
}
}
}
DerivedClass8.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace cSHARPEXAMPLES
{
class DerivedClass8 : BaseClass8
{
String str = "Derived" ;
public DerivedClass8() { }
public new String display() { //NEW KEYWORD is USE TO HIDE THE
//SAME METHOD IN TH BASE CLASS
return str + ": Display Derived" ;
}
public override String show() { //OVERRIDE KEYWORD IS USED IF
Properties are used to protect the field in a class by reading and writing it through the property. Here the field consists of one getter and one setter that are associated with a given field. We can access this field through this getter/setter combination.
Two ways to declare property in the class
1. One way to declare:
class PropertyDemo {
private String name; //Declare a field
public String getName() { //Getter
return name;
}
public void setName( String Value) {//Setter
name = value;
}
}
2.
Another way to declare:
class PropertyDemo {
private String name; //Declare a field
public String Name{
get{ return name;} //Getter
set{ name = value;} // Setter
}
}
Read-Only property:
We can declare a property as read-only; by only have its getter. So that the user can't set the value of the field, because there is no setter for the field. Hence we restrict the user to change the value of the field at any given time.
Write-Only property:
We can declare a property as write-only, by only have its setter. Here the user can't access the value that is there in the field. We can manipulate the value of the field by using its setter, but we can't get the value of this field.
Example: Demonstarte propery, Read-Only Property, Write Only Property.
This will set the values in the class fields i.e. name, address
Click On: Get the Value
This will display the values that are set by the setters.
First value that we get is the name.
Second is the age value.
This field only has getter associated to it.
This field only has setter associated with it, we can
If properties are 'virtual fields', indexers are more like 'virtual arrays' . They allow a class to emulate an array, where the elements of this array are actually dynamically generated by function calls. They allow a class to be used just like an array. On the inside of a class, you manage a collection of values any way you want. These objects could be a finite set of class members, another array, or some complex data structure. The following are the advantages of the Indexers.
Regardless of the internal implementation of the class, its data can be obtained consistently through the use of indexers.
Indexers aren't differentiated by name, and a class cannot declare two indexers with the same signature. However, this does not entail that a class is limited to just one indexer. Different indexers can have different types and numbers of indexing elements (these being equivalent to method parameters, except that each indexer must have at least one indexing element, and the 'ref' and 'out' modifiers cannot be used).
Example: Demonstrate Indexers
ClsIndexers10.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace cSHARPEXAMPLES
{
class ClsIndexers10
{
private String [] arrString;
private int arrSize;
public ClsIndexers10( int sizeofArray) { //Constructor
label1.Text = label1.Text + "Indexer at " + i + obj[i] + "\n" ;
}
}
}
}
Output:
Click On: Indexer Implementation
Click On: Indexer – With String
Structs is value-type user defined data type same as int, float, bool etc.
Structs features:
structs are value-type
In structs memory allocation can be done on stack.
No garbage collector required to remove structs variable because as they are value type, the memory allocated is on stack and so no memory allocated on heap, when structs variable are not in used they just fall from the stack.
Structs can't have destructors.
Structs can't inherit another class or structs. This means there is no concept of inheritance in structs.
Structs may inherit multiple interfaces. Interface is a reference type and any class or structs that implements interface must override all the methods that are there in the interface.
Example: Demonstrate Structs
ClsStruct11.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace cSHARPEXAMPLES
{
interface ITest
{
string Test();
}
struct Rectangle : ITest
{
public int length;
public int breath;
public int height;
public Rectangle( int length, int breath, int height)
Clicking On Both the Buttons: The concept behind the structs will be executed and displayed.
An interface looks like a class, but has no implementation. An interface is a C# reference type with members that do not have implementations. Interfaces only have method signatures. The following are the properties of the interfaces:-
It contains definitions of events , indexers , methods and/or properties .
The reason interfaces only provide definitions is because they are inherited by classes and structs , which must provide an implementation for each interface member defined.
Interfaces are like protocol or standard that needs to be maintained by the classes or structs that are implementing that interface.
We can have final variables and abstract methods in interface. This means the classes or structs that are implementing interfaces need to provide the body for all the methods that are there in interfaces.
No need to provide the access specifier for method that is there in interface, all the methods are public.
We have the concept of inheritance in interface. One interface can extends another interface.
A delegate in C# language allows us to reference a method. The other way to say this delegate is a function pointer. The function pointer is same as we have pointer to an address now in this case we have pointer to a method address. There are two types of delegates :-
Single-Cast Delegate:- Here the delegate will refer to or point to single method or we can Say that the pointer is to single method from the delegate.
Multi-Cast Delegate:-In the multi-cast delegate, the delegate refer to or point to more than One method at runtime.
Delegates features:
Delegate is a function pointer.
Delegate declaration is same as method declaration, except they have delegate modifier in front of it.
The method that a delegate refers or pointing to must have same signature as of delegate method.
To use a delegate, we have to create the instance of the delegate and pass the method that it is pointing too or referring to.
Invoke (), This method can be used to invoke the delegate.
The delegates can be declared by adding a delegate keyword in front of any method. For Example- delegate void Mydelegate();
Note:- This is declaration of the delegate and it specifies the method signature that it is pointing or referring. This means the signature of the
method that a delegate pointing has no parameter and will not return any thing. But this is an example and we can say the delegate can refer to any type of method.
Exceptions are unforeseen errors that happen in your programs. Programmers always detect and most of the time writes correct code to avoid all the errors or exceptions that can distract the execution of the code and cause unwanted results.
However, there are times when you don't know if an error will occur. For example, you can't predict when you'll receive a file I/O error, run out of system memory, or encounter a database error. These things are generally unlikely, but they could still happen and you want to be able to deal with them when they do occur. This is where exception handling comes in. When exceptions occur, they are said to be "thrown". What is actually thrown is an object that is derived from the “S ystem. Exception” class
Try/catch and Finally Block:
This is a way we can handle exceptions in C#.
Try Block:- In this block, we include all the suspected code. This means the code that is most likely to cause exception.
Catch Block:- In this block we include all handlers that will be take care of exception that occurs. We can have number of catch blocks associated to single try block.
Finally Block : The finally block contains the cleanup code that we needed whether the code is succeed or not. Most of the time we write a code that will deal locate the memory that we associated in the beginning like memory allocated to connection object.
Attributes are elements that allow you to add declarative information to your programs. This declarative information is used for various purposes during runtime and can be used at design time by application development tools. Attributes are also used extensively in securing .NET assemblies, forcing calling code to be evaluated against pre-defined security constraints. Attribute declared using the ‘[‘and ‘]' brackets before any type declaration.
The following are the advantages the attributes provide:
Declarative information to your program
This information can be used at runtime or at compile time by programmers.
DllImportAttribute: This attribute provide information to communicate with the Win32 libraries.
ObsoleteAttribute: This provides compile time information to the developer that this method is now deprecated.
Attribute add what is called metadata to your program.
Attributes are classes that can be written in C# and used to decorate your code with declarative information.
Many attributes have parameter lists that allow inclusion of additional information that customizes a program even further.
Examples of Attributes:-
[ Obsolete ]
public String firstDeprecatedFX(){}
[ ObsoleteAttribute ]
public String secondDeprecatedFX(){}
Obsolete ( "Don't Use This Method." )]
public String thirdDeprecatedFX()
[ STAThread ]
static void Main () {}
Note:- This attribute declare that this is the entry point for the application. This indicates that C# program should communicate with unmanaged COM code using the single threading apartment. The parameter provide additional information about the attribute
Example To Demonstrate Attributes
The following is the screen appeared when run the form 15 program in the source.
An enumeration is a special kind of value type limited to a restricted and unchangeable set of numerical values. Enums are strongly typed constants. They are essentially unique types that allow you to assign symbolic names to integral values.
Advantages of Enums:-
In the C# tradition, they are strongly typed, meaning that an enum of one type may not be implicitly assigned to an enum of another type even though the underlying value of their members are the same.
By default, these numerical values are integers, but they can also be longs, Bytes, etc.
When you define an enumeration you provide literals which are then used as Constants for their corresponding values.
Values specified in enumeration are static.
These values are final and you can't change the value at runtime.
The System.Enum BCL type is the base class of enum types and contains methods that allow you to work with enums in different ways, such as working with a list of names or values, converting from value to name, and converting from name to value.
Syntax
enum enumname { //values}
Example:-
enum DayOfWeek {
Monday=2,
Tuesday,
Wednesday,
Thursday=10,
Friday,
Saturday,
Sunday
}
Note:-
The first literal, is unassigned then it value is set to 0.
For any other literal, if the value is unassigned then the value set is greater than the value of the preceding literal.
By this the value of Monday is set to 0 and the value of Sunday is 6.
We can also specify the value to the literal in the enums.
Note:- Here the value will be Monday-2, Tuesday-3, Wednesday-4 and Thursday-10, Friday-11, Saturday-12, Sunday-13.
Example: Demonstrate Enums
ClsEnum16.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace cSHARPEXAMPLES
{
enum DayOfWeek {
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday
}
enum ValuesEnum : byte
{
One = 1,
two,
three=5,
four,
five
}
class ClsEnum16
{
public String GetvalueEnteredByUser( int enteredValue) {
Encapsulation is the process of wrapping up of data and members in a class. Encapsulation provides the way to hide data from the external usage. This is important in the scenario when we don't want our precious data to be used or manipulated by external user. Encapsulation is an object-oriented principle of hiding the internal state and behavior of an object, making your code more maintainable.
Advantages of Encapsulation
Data-hiding through the access specifier private.
Reduce coupling between objects.
Increases the maintainability of code.
Wrapping up of data variables and members inside the class.
The following table will give the description of the Access modifiers available in C#.
Access Modifier Description (who can access)
Private
Private members can be accessed within the class where they are declared. We can't access private members outside the class, not even with the object of the class.
This basically provides the concept of Data-Hiding.
Protected Protected members scope can be outside the class but only limited to the immediate derived class that is inheriting the base class where the protected members resides.
The protected can be used by the members of same class or the members of derived class.
Internal Here the internal members are accessible within the same assembly.
If you don't specify any modifier, by default it is of internal type.
Protected Internal Here either accessed in the same assembly or the
derived assembly also. This is basically a combination of protected and internal access modifiers.
Public Public members can be accessed anywhere. No restriction associated with this access modifier.
Sealed Class
The sealed keyword provides the restriction that no other class in the context can inherit this class. By this, we can make our class not to be inherited by other class. If the class tries to inherit the class that is declared as sealed, the compile time error occurs.
1] Class declared as sealed
sealed class ClsSealed17 {// Any members }
Abstract Class
The class declared with abstract keyword, this means the class is only provide the essential elements and not including the background details. Abstraction is the process of including the essential elements and hiding the details. In layman terms, we can say that a computer is the abstract form, because we are not aware of the internal technicality.
If the class is declared as abstract, we have to give the body to all the methods that are declared as abstract.
1] Class declared as abstract
abstract class clsAbstractDemo{
// This can contains abstract or concrete methods.
}
2] Abstract Members
public abstract string displayname();
Note:- The abstract methods can only include the signature of the method.
Example: Demonstrate Encapsulation
ClsEncapsulation17.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace cSHARPEXAMPLES
{
class Customer
{
public void CustomerRecord()
{
AddNewRecord();
UpdateExistingRecord();
DeleteRecord();
}
protected virtual string AddNewRecord()
{ return "Base: AddNewRecord" ; } //ADD NEW RECORD
protected virtual string UpdateExistingRecord()
{ return "Base: UpdateExistingRecord" ; } //UPDATE EXISTING RECORD
protected virtual string DeleteRecord()
{ return "Base: DeleteRecord" ; } //DELETE EXISTING RECORD
}
class ClsEncapsulation17 : Customer
{
private string name = "" ; //Can't Access Outside the Class
private string address = "" ; //Can't Access Outside the Class
private string pri_Display() //Can't Access Outside the Class
{
return "This method can't be access outside the class" ;
public abstract string displayname(); // Abstract method
public int calcTotal() //Concreate Method
{
return (_number * 10);
}
}
class ClsAbstract17 : clsAbstractDemo
{
public override string displayname() { //Abstract Method
return "Abstract Method Provide Body in Derived Class" ;
}
}
}
Output
Click On: Private Members Button
Click On: Public Members Button
Click On: Protected Members Button
Click On: Sealed
Click On: Abstract
A method's parameters are the types that get passed to it when the method is called. The list of parameters begins by specifying zero or more 'fixed parameters', and it may finish by specifying a single parameter-array. This latter element - declared using the 'params' keyword - means that it is possible to pass an arbitrary number of types to a single method.
[Modifier]: This is optional and can be either 'ref' or 'out'.
Parameter-type: This declares the type of the parameter.
Parameter-identifier: The name of the parameter.
There are 3 type of parameter that are passed to the method
Passing by Value
Passing by Reference
‘Output' Parameter.
Passing By Value:
The parameter modifiers 'ref' and 'out' relate to how the parameter is passed into the method. Where neither of these modifiers is used, the parameter is passed in 'by value'. By default we are passing variable by value. Here the new copy of the variable is send to the called method. So changes done to the variables are not reflected on the actual parameter.
Syntax:
passValueByValueType(_initialValue); //Call a method
private void passValueByValueType( int iV)
{ iV = 20; }
Passing By Reference:
In C# we can pass variables into methods 'by reference'. Where a variable is passed by reference, the 'ref' modifier must be used both in the method head and the method invocation (illustrated by the next code block). The changes made to the formal argument will reflect on the actual argument.
private void passValueByReferenceType( ref int iV)
{ iV = 20; }
‘Output' parameter:
Where a method parameter is defined (and invoked) using the 'out' modifier, it is passed by reference. The difference between the 'out' and the 'ref' modifier is this: a parameter modified by the 'out' keyword need not be assigned a value before being passed into the method, but must be assigned a value in the method.
Syntax:
passValueByOutParameter( out _initialValue, out _bValue);//Calling
‘Params' Modifier
One can pass an arbitrary number of types to a method by declaring a parameter array with the 'params' modifier.
Syntax:
public int getTheTotalUsingParam( params int [] intArr)
passValueByOutParameter( out _initialValue, out _bValue);
textBox3.Text = _initialValue.ToString();
MessageBox .Show( "After getting the value " +
_initialValue.ToString());
}
private void passValueByReferenceType( ref int iV)
{
iV = 20;
}
private void passValueByValueType( int iV)
{
iV = 20;
}
private void passValueByOutParameter( out int iV, out bool bValue)
{
bValue = false ;
iV = 2;
if (iV > 40)
bValue = true ;
else
bValue = false ;
iV = iV * 20;
}
}
}
OutPut:
Clicking On:- Passing Parameter By Value
Clicking On:- Passing Parameter By Reference
Clicking On:- Passing Parameter By Out
C# is a language. The classes defined in the class libraries are used to communicate with the database and we are using C# language to interact with the database. In Ado.Net components we have number of classes that are responsible to communicate with the database.
Introducing ADO.NET
Ado.Net is an Object-oriented set of libraries that allows you to interact with data sources. Following are the data providers in ado.net.
1. System.Data.SqlClient:- contains classes that communicate with Ms SQLServer.
2. System.Data.OracleClient:- communicate with Oracle.
3. System.Data.Oledb:- communicate to a data source that has an OLEDB provider.
4. System.Data.Odbc:- communicate to a data source that has an ODBC provider
ADO.NET OBJECTS
Ado.net includes many objects you can use to work with data. Some of the primary objects are as follows:-
1. SqlConnection:- To interact with a database, you must have a connection to it. The connection objects helps identifying the database server, database name, user name and password. The connection object is used by command objects.
2. SqlCommand:- You can use this object to send SQL statements to the database. This can represent a SQL Statement or stored procedure.
3. SqlDataReader:- The data reader object allows you to obtain the results of a Select statement from a command object. The data returned from a data reader is a fast forward-only stream of data. This fetch data in a sequential manner.
4. DataSet:- You can imagine dataset as a database. This contain multiple datatable objects, which further contains columns and rows objects. We can also define relationship among tables in the dataset. This is disconnected approach.
5. SqlDataAdapter:- The SqlDataAdapter is used to fill dataset object when reading the data and writes in a single batch when persisting changes back to the database. A data adapter contains a reference to the connection object and opens and closes the connection automatically when reading from or writing to the data base. The data adapter contains 4 command objects i.e. SELECT, UPDATE, DELETE, and INSERT
Example: Demonstrate Database Interaction
This example will provide the interaction with the database. The user will enter his credentials, if the user is valid and the credentials matched with the database, he is able to view all the other users' credentials that are valid.
There are varieties of operators available for use in C#. The C# language defines the behavior of these operators when used in an expression with the C# built-in data types. C# gives user the flexibility to change the default behaviour of the operators that means, user can define the behavior of many of the standard operators with his own structures and classes.
Suppose, for example, that you're writing a class that manages a set of records read from a database. If another piece of code has two objects of your class, it may want to write an expression that joins the records together into a third object. This sounds like an addition operation, and it seems natural for other pieces of code to write code like the following:
Records Records1;
Records Records2;
Records Records3;
Records3 = Records1 + Records2;
Your Records class would include a method that specifies "how objects of the class will behave when used in an expression with the addition operator. These methods are called user-defined operator implementations , and the object-oriented terminology for defining operator behavior in a class is called operator overloading .
Note: All operator overloading methods must be declared with both the static and public keywords.
Overloading Unary Plus /Unary Minus:
If you need to overload the unary plus operator, the following characteristics must be enjoyed by the method that is used to overload the unary plus.
A return type of your choice
The keyword operator
The operator being overloaded
A parameter list specifying a single parameter of the type of class or structure containing the overloaded operator method
Overloading Prefix Increment and Decrement Operator:
If you need to overload the prefix increment or prefix decrement operators in your class or structure, define a method with the following characteristics:
A return type specifying the type of class or operator method
The keyword operator
The operator being overloaded
A parameter list specifying a single parameter containing the overloaded operator method
ClsOverLoadingDecrement objDecrement = new ClsOverLoadingDecrement ();
objDecrement.X = 100;
objDecrement.Y = 200;
MessageBox.Show((objDecrement.X).ToString());
MessageBox.Show((objDecrement.Y).ToString());
objDecrement = --objDecrement;
MessageBox.Show((objDecrement.X).ToString());
MessageBox.Show((objDecrement.Y).ToString());
}
}
}
Output:
Click on Overloading Unary Plus:
Click on Overloading Unary Minus:
Click on Prefix Increment:
Click on Prefix Decrement:
Overloading Boolean Operator:
If you need to overload the true or false operators in your class or structure, define a method with the following characteristics:
A return type of bool
The keyword operator
The operator being overloaded
A parameter list specifying a single parameter of the type of class or structure containing the overloaded operator method
Overloading Conversion Operator:
You can also write operator overload methods that convert one type into another type. If you need to define a new conversion operator in your class or structure, define a method with the following characteristics:
The keyword implicit if the conversion is to be treated as an implicit conversion, or the keyword explicit if the conversion is to be treated as an explicit conversion
The keyword operator
A type specifying the target type of the conversion
A parameter list specifying the source type of the conversion
Overloading Binary Operators:
The operators that fall under this category are : Addition, Subtraction, Division, Multiplication, Remainder, AND, OR, Exclusive OR, Shift left, Shift Right, Equality, Inequality, Greater than, less than. If you need to overload any of the binary operators in your class or structure, define a method with the following characteristics:
A return type of your choice
The keyword operator
The operator being overloaded
A parameter list specifying two parameters, at least one of which must be of the type of class or structure containing the overloaded operator method
Example: Demonstrate Boolean Overloading, Conversion Overloading and Binary Operators Overloading
ClsOverloadingBooleanOpertors.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace _CSharpApplication
{
class ClsOverloadingBooleanOpertors
{
public int X;
public int Y;
public static bool operator true ( ClsOverloadingBooleanOpertors RValue)
{
if ((RValue.X == 0) && (RValue.Y == 0))
return true ;
return false ;
}
public static bool operator false ( ClsOverloadingBooleanOpertors RValue)
{
if ((RValue.X == 0) && (RValue.Y == 0))
return false ;
return true ;
}
}
}
ClsOverloadingConversion.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace _CSharpApplication
{
class ClsOverloadingConversion
{
public int X;
public int Y;
public static implicit operator double ( ClsOverloadingConversion RValue)
ClsOverloadingEqualityInequality MyFirstPoint = new ClsOverloadingEqualityInequality ();
ClsOverloadingEqualityInequality MySecondPoint = new ClsOverloadingEqualityInequality ();
ClsOverloadingEqualityInequality MyThirdPoint = new ClsOverloadingEqualityInequality ();
MyFirstPoint.X = 100;
MyFirstPoint.Y = 200;
MySecondPoint.X = 500;
MySecondPoint.Y = 750;
MyThirdPoint.X = 100;
MyThirdPoint.Y = 200;
if (MyFirstPoint == MySecondPoint)
MessageBox.Show( "MyFirstPoint and MySecondPoint are at the same coordinates." );
else
MessageBox.Show( "MyFirstPoint and MySecondPoint are not at the same coordinates." );
if (MyFirstPoint == MyThirdPoint)
MessageBox.Show( "MyFirstPoint and MyThirdPoint are at the same coordinates." );
else
MessageBox.Show( "MyFirstPoint and MyThirdPoint are not at the same coordinates." );
}
}
}
Output:
Clicking on Overloading True/False Operator
Clicking on Overloading Conversion Operator
Clicking on Overloading Equality/Inequality Operator
Overloading Boolean Operator:
If you need to overload the true or false operators in your class or structure, define a method with the following characteristics:
A return type of bool
The keyword operator
The operator being overloaded
A parameter list specifying a single parameter of the type of class or structure containing the overloaded operator method
Overloading Conversion Operator:
You can also write operator overload methods that convert one type into another type. If you need to define a new conversion operator in your class or structure, define a method with the following characteristics:
The keyword implicit if the conversion is to be treated as an implicit conversion, or the keyword explicit if the conversion is to be treated as an explicit conversion
The keyword operator
A type specifying the target type of the conversion
A parameter list specifying the source type of the conversion
Overloading Binary Operators:
The operators that fall under this category are : Addition, Subtraction, Division, Multiplication, Remainder, AND, OR, Exclusive OR, Shift left, Shift Right, Equality, Inequality, Greater than, less than. If you need to overload any of the binary operators in your class or structure, define a method with the following characteristics:
A return type of your choice
The keyword operator
The operator being overloaded
A parameter list specifying two parameters, at least one of which must be of the type of class or structure containing the overloaded operator method
Example: Demonstrate Boolean Overloading, Conversion Overloading and Binary Operators Overloading
ClsOverloadingBooleanOpertors.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace _CSharpApplication
{
class ClsOverloadingBooleanOpertors
{
public int X;
public int Y;
public static bool operator true ( ClsOverloadingBooleanOpertors RValue)
{
if ((RValue.X == 0) && (RValue.Y == 0))
return true ;
return false ;
}
public static bool operator false ( ClsOverloadingBooleanOpertors RValue)
{
if ((RValue.X == 0) && (RValue.Y == 0))
return false ;
return true ;
}
}
}
ClsOverloadingConversion.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace _CSharpApplication
{
class ClsOverloadingConversion
{
public int X;
public int Y;
public static implicit operator double ( ClsOverloadingConversion RValue)
ClsOverloadingEqualityInequality MyFirstPoint = new ClsOverloadingEqualityInequality ();
ClsOverloadingEqualityInequality MySecondPoint = new ClsOverloadingEqualityInequality ();
ClsOverloadingEqualityInequality MyThirdPoint = new ClsOverloadingEqualityInequality ();
MyFirstPoint.X = 100;
MyFirstPoint.Y = 200;
MySecondPoint.X = 500;
MySecondPoint.Y = 750;
MyThirdPoint.X = 100;
MyThirdPoint.Y = 200;
if (MyFirstPoint == MySecondPoint)
MessageBox.Show( "MyFirstPoint and MySecondPoint are at the same coordinates." );
else
MessageBox.Show( "MyFirstPoint and MySecondPoint are not at the same coordinates." );
if (MyFirstPoint == MyThirdPoint)
MessageBox.Show( "MyFirstPoint and MyThirdPoint are at the same coordinates." );
else
MessageBox.Show( "MyFirstPoint and MyThirdPoint are not at the same coordinates." );
}
}
}
In socket-based network programming, you do not directly access the network interface device to send and receive packets. Instead, an intermediary file descriptor is created to handle the programming interface to the network. The special file descriptors used to reference network connections are called sockets . The socket defines the following:
A specific communication domain, such as a network connection or a Unix Interprocess Communication (IPC) pipe
A specific communication type, such as stream or datagram
A specific protocol, such as TCP or UDP
After the socket is created, it must be bound to either a specific network address or port on the system, or to a remote network address and port. Once the socket is bound, it can be used to send and receive data from the network.
Network Addresses
After the socket is created, it must be bound to a network address/port pair. UNIX offers an IP-specific address structure, sockaddr_in , which uses the following elements. Using the sockaddr_in structure requires placing the appropriate IP address and port values in the proper data element.
1. sin_family An address family, defined as a short type
2. sin_port A port number, defined as a short type
3. sin_addr An address, defined as a long type (4-byte) IP address
4. sin_data 8 bytes of padding.
.NET defines two classes in the System.Net namespace to handle various types of IP address information.The classes are IPAddress and IPEndPoint IPAddress object is used to represent a single IP address. This value can be used in the various socket methods to represent the IP address.
IPAddress Methods:-
Method Description
Equals Compares two IP addresses.
GetHashCode Returns a hash value for an IPAddress object.
GetType Returns the type of the IP address instance.
Converts an IP address from host byte order to
HostToNetworkOrder network byte order.
IsLoopBack Indicates whether the IP address is considered the loopback address.
NetworkToHostOrder Converts an IP address from network byte order to host byte order.
Parse Converts a string to an IPAddress instance.
ToString Converts an IPAddress to a string representation of the dotted decimal format of the IP address.
IPEndPoint: object is used when binding sockets to local addresses, or when connecting sockets to remote addresses. The following two constructors are used to create IPEndPoint instances:
IPEndPoint (long address , int port )
IPEndPoint(IPAddress address , int port )
PEndPoint Methods:
Method Description
Create Creates an EndPoint object from a SocketAddress object
GetType Returns the type of the IPEndPoint instance
Equals Compares two IPEndPoint objects
Serialize Creates a SocketAddress instance of the IPEndPoint instance
Creates a string representation of the IPEndPoint
ToString instance
GetHashCode Returns a hash value for an IPEndPoint object
lstIPEndPoint.Items.Add( "SocketAddress is :: " + _socketAddress.ToString());
}
}}
Output:
Clicking on both the buttons the output will be:
To simplify the unwieldy state of computer naming, the Domain Name System (DNS) was created. It allows the master host database to be split up and distributed among multiple systems on the Internet. DNS uses a hierarchical database approach, creating levels of information that can be split and stored on various systems throughout the Internet.
DNS Structure
The structure of a hierarchical database is similar to an organization chart with nodes connected in a treelike manner (that's the hierarchical part). The top node is called the root . The root node does not explicitly show up in Internet host addresses, so it is often referred to as the “nameless” node. Multiple categories were created under the root level to divide the database into pieces called domains . Each domain contains DNS servers that are responsible for maintaining the database of computer names for that area of the database (that's the distributed part).
The first (or top) level of distribution is divided into domains based on country codes. Additional top-level domains for specific organizations were created to prevent the country domains from getting overcrowded.
Domain Description
.mil U.S. military sites
.com Commercial organizations
.edu Educational institutions
.gov U.S. government organizations
.net Internet Service Providers (ISPs)
.us Other U.S. organizations (such as local governments)
.org Nonprofit organizations
.ca Canadian organizations
.de German organizations
[other countries] Organizations from other countries
Using DNS
The last way to determine system IP information is to utilize the C# DNS (Domain Name System) classes. DNS can be used to obtain Internet hostnames and IP Addresses. The C# System.Net namespace contains the DNS class, which comprises several methods that allow you to obtain DNS information about hosts. The GetHostName() method retrieves the hostname of the local system. The GetHostByName() method attempts to find the IP address of a hostname.
DNS Configuration
When your C# application is running on a customer's system, you have no guarantee that there are any DNS servers configured. You can find out what (if any) DNS servers are configured by using the .NET Registry class methods to examine the DNS Registry values.
Fortunately, all Windows platforms store the DNS server information in the same place:
HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters Registry Data Values for DNS Servers
Data Value Description
DatabasePath The location of the host's file
Domain The name of the system's domain
NameServer The list of DNS servers
Hostname The name of the system's DNS host
SearchList A list of DNS domains to append to the end of hostnames in DNS name searches
The value of most interest here is NameServer . This should contain a single string value representing all the configured DNS servers, separated by spaces. The primary DNS server will be listed first, followed by the alternate servers.
Example: Demonstrate DNS and its Configuration in Registry
File access in .NET is generally handled with stream objects. In this section, we will discuss about the two classes BinaryWriter and BinaryReader to demonstrate the file handling in C#. The BinaryReader and BinaryWriter classes support binary file access. These classes permit binary operations to and from streams.
BinaryWriter
The BinaryWriter class allows primitive data types to be written to streams; and with the use of subclassing, you can override the methods of this class
and fulfill your own unique character encoding requirements. The following table will summarize the properties of the class:-
Name Type Purpose
BaseStream Property Allow access to binary writer underlying stream.
Close Method Close the Binary writer class and the underlying stream.
Flush Method Flushes out all data to the underlying stream and then clears buffers.
Seek Method Sets the current position within the current stream.
Write Method This overloaded method writes a value out to the current stream.
BinaryReader
The BinaryReader class, much like the BinaryWriter class, relies on a FileStream object to read files .
Method
Description
Close Close the binary reader object and the base stream.
PeekChar Reads the next available byte from the stream but does not advance the byte or character position within the file.
ReadBoolean Reads a Boolean [True/False] value from the stream.
ReadByte Reads a single byte from the stream. There is also a readbytes method for specifying the number of bytes to read.
ReadChar Reads a single char value from the stream. There is also a readchars method for specifying the number of chars to read.
An interesting feature of the C# compiler is to generate XML documentation from the comments. C# compiler reads specially formatted comments and generates XML documentation from the comments. You can then displays this XML on the Web to provide an extra level of documentation to developers who need to understand the structure of your applications.
Pre-requisites to generate XML documentation from the comments are:
Use three slashes for comments(///). The C# compiler does not generate any XML Documentation for any comments that do not begin with three slashes. Nor does the C# compiler generates any XML documentation for regular, multi line, comments.
Use the /doc option of the C# compiler to specify the name of the file that should contain the generated XML documentation.
Example: Demonstrate XML documentation from Comments
Step1: In the first step we create the C# code file.
System.Console.WriteLine( "StartUp for C# World!" );
}
}
}
Step2: The following command is used to generate the help file. The command will create two files i.e. “Program.exe” and other is “ProgramHelpFile.xml” .
Command: csc /doc: HelpFile.xml ProgramFile.cs
Output:-
The following xml will be generated by the above command.
ProgramHelpFile.xml
<?xml version="1.0"?>
<doc>
<assembly>
<name>Program</name>
</assembly>
<members>
<member name="M:_CSharpApplication.Program.Main">
<summary>
The main entry point for the application.
Developed By : C# Team
Developed On : 21 Oct,07
</summary>
</member>
</members>
</doc>
Note: -Main portion of XML documentation is found in <member> element: This element contains one <member> tag for each documented item in the source code. The <member> tag contains one attribute, name, which names the member being documented. The value of the name attribute starts with a one-letter prefix describing the type of information being described. Options
for the first letter of the name attribute's value and its meaning. <member> “name” = Attribute Prefixes >
Other Important Tags:
The following is the list of more help file tags which can be used in the C#.
1. <c>:- T ag to indicate that a small part of your comment should be treated as code. Style sheets may use this element to display the code portion of your comment E.g. /// This is the <c> Main ()</c> function for the /// Program class.
2. <code>:- Tag to indicate that multiple lines of text in your comments should be treated as code: E.g. /// <code>/// Argument[0]: command line argument 1 /// Argument[1]: command line argument 2/// Argument[2]: command line argument 3 /// </code>
3. <exception>:- You can use the <exception> tag to document any exceptions that may be raised from the member's code. The <exception> tag must contain an attribute called cref whose value specifies the type of exception being documented. The cref attribute value must be enclosed in quotes. The text of the element describes the conditions under which the exception is thrown: E.g. /// <exception cref="System.Exception">/// Raised if the input is less than 0. /// </exception>
4. <permission>:- Use the <permission> tag to document the permissions available on a given function or variable. Access to a
class's code and data can mean access to all of the code or it can be restricted to a certain subset of code. You can use the <permission> tag to document the availability of your code and data. The <permission> tag makes use of one attribute: cref. The value of the cref element must name the function or variable whose permissions are being documented: E.g. /// <permission name="Main()"> /// Everyone can access Main (). /// </permission>
5. <remarks>:- Use the <remarks> tag to add information about an item. The <remarks> element is great for providing an overview of a method or variable and its usage. The <remarks> tag carries no attributes and its text contains the remarks: E.g. /// <remarks> /// The Main () function is the entry point into the /// application. The CLR will call Main () to start /// the application after the application loads/// </remarks>
Code access security is a feature of .NET that manages code, dependent on our level of trust. If the CLR trusts the code enough to allow it to run, it will begin executing the code. Depending on the permissions provided to the assembly, however, it might run within a restricted environment. If the code is not trusted enough to run, or if it runs but then attempts to perform an action, for which it does not have the relevant permissions, a SecurityException is thrown. The code access security system means that we can stop malicious code running, but we can also allow code to run within a protected environment where we are confident that it cannot do any damage.
CAS is part of .Net security model that determines whether or not a piece of code is allowed to run and what resources it can use while running. CAS grants rights to program depending on the security configuration of the machine. For e.g. the program has rights to edit or create a new file but the
security configuration of machine does not allow the program to delete a file.
Code access security is based on two concepts Code Groups and Permissions. The following sections will discuss both in detail.
Code Group
Code Group is the concept of bringing together the code with similar characteristics. Two examples for code groups are Internet and Intranet. The group Internet defines code that is sourced from the Internet, the group Intranet defines code sourced from the LAN. Code groups have an entry requirement called membership condition . Each code group has one, and only one, membership condition.
Following is the available list of code group memberships:
Zone: The region from which the code originated. A zone is one of the commonly used condition. A zone is the region of origin of a piece of code and refers to one of the following: My Computer, Internet, Intranet, Trusted, or not trusted.
Site: The Web site from which the code originated.
Strong Name: A unique, verifiable name for the code.
Publisher: The publisher of the code.
URL: The specific location from which the code originated.
Hash Value: The hash value for the assembly.
Skip Verification: This condition requests that it bypasses code verification checks.
Application Directory: The location of the assembly within the application.
All Code: All code fulfills this condition.
Custom: A user-specified condition.
Code groups are arranged hierarchically with the All Code membership condition at the root.
Permissions
Permissions are the actions we allow each code group to perform? For example, permissions include “able to access the user interface” and “able to access local storage.” The system administrator usually manages the permissions at the enterprise, machine, and user levels.
A thread is a sequence of execution in a program. All our C# programs up to this point have one entry point—the Main () method. Execution starts with the first statement in the Main () method and continues until that method returns. A thread is the basic unit to which the operating system allocates processor time.
Processes are made up of one or more threads. A thread is defined as a single flow of operation within a program. When a program executes on the CPU, it traverses the program statements in a single thread until the thread is complete. A multithreaded application distributes functions among multiple program flows, allowing two or more paths of execution to occur. Each path of execution is a separate thread.
Multi-tasking: It's a feature of modern operating systems with which we can run multiple programs at same time example word, excel etc
Multi-Threading: Multi-threading forms subset of multi-tasking instead of having to switch between programs this feature switches between different parts of the same program. Example we are writing a word document and at the same time word is doing a spell check in background.
Multithreaded programs create their own threads that can be executed separately from the main thread of the program. All threads created by the primary thread share the same memory address space as the primary thread. Often the secondary threads are used to perform computationally intensive functions, allowing the main thread to continue responding to Windows events. Without the secondary threads, the user could not select anything from the menu or click any buttons while an application computed a mathematical function
System.Threading: This namespace has all the classes that are related to implement threading. Any .Net application who wants to implements threading has to import this namespace.
Note: In .Net program, there are always at least two threads running, i.e. one is the main program and other is the garbage collector.
States:
Threads have several operational states, which are enumerated using the .NET Thread State enumeration, found in the System.Threading namespace.
Initialized: The thread has been initialized but not started.
Ready: The thread is waiting for a processor.
Running: The thread is currently using the processor.
Standby: The thread is about to use the processor.
Terminated: The thread is finished and is ready to exit.
Transition: The thread is waiting for a resource other than the processor.
Unknown: The system is unable to determine the thread state.
Wait: The thread is not ready to use the processor
The Thread Class
Use the Thread class to create a new Thread object, which produces a new thread within the current process. The format of the Thread constructor is as follows, where start is a ThreadStart delegate:
Thread (ThreadStart start) The ThreadStart delegate points to the method that will be performed within the new thread.
E.g. Thread newthread= new Thread (new ThreadStart (anyMethod));
Void anyMethod () {}
After the Thread object is created, it can be controlled using various Thread class methods, which are as under:
Abort (): Terminate the thread.
Equals (): Determines whether two thread objects are same.
GetHashCode (): Get a unique representation for the thread.
GetType (): Get the type of the current thread.
Interrupt (): Interrupts a thread that is in a wait state.
Join (): Blocks the calling thread until the thread terminates.
Resume (): Resumes a thread that has been suspended.
Start (): Change the state of the thread to running.
Suspend (): Suspend the execution of the thread.
ToString (): gets a string representation of the Thread object.
Thread priority: The thread priority determines the order in which thread has to execute. The thread priority can be changed by using Threadname.Priority = ThreadPriority.Highest.
Different levels of priority provided by .Net:
ThreadPriority.Highest
ThreadPriority.AboveNormal
ThreadPriority.Normal
ThreadPriority.BelowNormal
ThreadPriority.Lowest
Thread.Sleep (): Thread execution can be paused by calling the Thread.Sleep method. This method takes an integer value that determines how long the thread should sleep.
Example: Demonstrate Threading
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting;
using System.Threading;
namespace ConsoleApplication1
{
class Program1
{
static void Main ( string [] args)
{
Program1 ts = new Program1 ();
}
public Program1()
{
int i;
Thread firstThread = new Thread ( new ThreadStart (FirstMethod));
Thread secondThread = new Thread ( new ThreadStart (SecondMethod));
firstThread.Start();
secondThread.Start();
for (i = 0; i < 10; i++)
{
Console.WriteLine( "Main: {0}" , i);
Thread .Sleep(1000);
}
}
void FirstMethod()
{
int i;
for (i = 0; i < 10; i++)
{
Console.WriteLine( " First thread: {0}" , i);
Thread .Sleep(2000);
}
}
void SecondMethod()
{
int i;
for (i = 0; i < 10; i++)
{
Console.WriteLine( " Second thread2: {0}" , i);
Thread .Sleep(3000);
}
}
}
}
When writing applications for international distribution, different cultures and regions must be kept in mind. Different cultures have diverging calendars and use different number and date formats, and also the sort order with the letters A-Z may lead to various results. To make applications fit for global markets you have to globalize and localize them.
Globalization is about internationalizing applications: preparing applications for international markets. With globalization, the application supports number and date formats depending on the culture, different calendars, and so on.
Localization is about translating applications for specific cultures. For translations of strings, you can use resources.
.NET supports globalization and localization of Windows and Web applications. To globalize an application you can use classes from the namespace System.GlobalizationSystem.Resources. whereas to localize an application you can use resources that are supported by the namespace
System.Globalization
The System.Globalization namespace holds all culture and region classes to support different date formats, different number formats, and even different calendars that are represented in classes such as Gregorian calendar, Hebrew Calendar, Japanese Calendar, and so on. Using these classes you can display different representations depending on the user's locale.
Cultures and Regions
The world is divided into multiple cultures and regions, and applications have to be aware of these cultural and regional differences. RFC 1766 defines culture names that are used worldwide depending on a language and a country or region. Some examples are en-AU, en-CA, en-GB, and en-US for the English language in Australia , Canada , United Kingdom , and the United States .
Note:- Most Important class in System.Globaliation namespace is CultureInfo [Represents a Culture]
Example: Demonstrate CultureInfo
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting;
using System.Threading;
using System.Globalization;
namespace ConsoleApplication1
{
class Program1
{
static void Main ( string [] args)
{
int val = 1234567890;
string name = "visualbuilder" ;
//Culture of the Current Thread
Console .WriteLine(val.ToString( "N" ));
//use IFormatProvider
Console .WriteLine(val.ToString( "N" , new CultureInfo ( "fr- FR" )));
//Change the culture of the thread
Thread .CurrentThread.CurrentCulture = new CultureInfo ( "de- DE" );
Console .WriteLine(val.ToString( "N" ));
}
}
}
Windows Registry is a central database for application configuration settings and other information required by the applications. The Windows Registry is a data repository that exists on each computer in Windows Operating systems. Both the system and application programs use this repository to store information needed at runtime. For example, the system stores file associations (the applications or command lines associated with each known file extension) in the Registry. Applications often use the Registry to store information such as users' option settings and data file pathnames.
Note:- If you've never open Windows registry, you can see it by running regedit from command line
.NET Framework Library provides two classes - Registry and RegistryKey to work with the windows registry. These classes are defined in Microsoft.Win32 namespace. So before using these classes, you need to add reference to this namespace.
Registry Class:
The Registry class contains members to provides access to registry keys. We can define registry keys in the following order.
CurrentUser - Stores information about user preferences.
LocalMachine - Stores configuration information for the local machine.
ClassesRoot - Stores information about types (and classes) and their properties.
Users - Stores information about the default user configuration.
PerformanceData - Stores performance information for software components.
The Registry class members are described in the following table.
ClassesRoot Returns a RegistryKey type which provides access to HKEY_CLASSES_ROOT key.
LocalMachine Returns a RegistryKey type which provides access to HKEY_LOCAL_MACHINE key.
CurrentConfig Returns a RegistryKey type which provides access to HKEY_CURRENT_CONFIG key.
DynData Returns a RegistryKey type which provides access to HKEY_DYN_DATA key.
CurrentUser Returns a RegistryKey type which provides access to HKEY_CURRENT_USER key
PerformanceData Returns a RegistryKey type which provides access to HKEY_PERFORMANCE_DATA key.
Users Returns a RegistryKey type which provides access to HKEY_USERS key.
RegistryKey Class :
The RegistryKey class contains members to add, remove, replace, and read registry data. Some of its common methods and properties are defined in the following table.
Properties:
Name - Represents the name of the key.
SubKeyCount - Represents the count of subkeys at the base level, for theCurrent key.
ValueCount - Represents the count of values in the key.
Methods:
GetValueNames Retrieves an array of strings that contains all the value names associated with this key.
GetValue Returns the specified value.
OpenSubKey Opens a subkey.
GetSubKeyNames Returns an array of strings that contains all the subkey names.
DeleteSubKeyTree Deletes a subkey and any children.
DeleteSubKey Deletes the specified subkey.
CreateSubKey Creates a new subkey if not exists, otherwise opens an existing subkey.
SetValue Sets the specified value.
DeleteValue Deletes the specified value from a key.
MessageBox.Show( "Deleting Key/Value in the Registry" );
}
}
} The coming section will discuss about some more classes used for Globalization in C#.
Resources and ResourceWriter
Resources such as pictures or string tables can be put into resource files or satellite assemblies. Such resources can be very helpful when localizing applications, and .NET has built-in support to search for localized resources. A resource file can be a text file or a .resx file or XML file. This file contains the key/value pairs. Where the keys are used in the program and at run time they are replaced with the values that is corresponding to each key. For example:-
Name = Jim Tire
Address = USA
Author = Puppet
Publisher = Jim Toe
Note:-ResGen.exe utility is used to create a resource file out of this “test.txt” file. the command Resgen test.txt will create the text.txt resource file and Resgen test.txt test.resx will createtthe XML file from the test.txt file.
ResourceWriter
This class under the System.Resources namespace is used to create the resource file through the programming. The below example will create the object of the ResourceWriterAddResource() method. and then we can use the same object to add upto 2GB of resources. We have to just supply the key/value pair to the object's
Example: Demonstrate ResourceWriter
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting;
using System.Threading;
using System.Globalization;
using System.Resources;
namespace ConsoleApplication1
{
class Program1
{
static void Main ( string [] args)
{
ResourceWriter rw = new ResourceWriter ( "RWDemo.resources" );
rw.AddResource( "Name " , "VisualBuilder" );
rw.AddResource( "Adress" , " UK " );
rw.AddResource( "Hobby" , "Cricket" );
rw.AddResource( "Favourite Country" , " Australia " );
rw.AddResource( "Player" , "Sunny" );
rw.Close();
}
}
}
Output:
This will create RWDemo.resources file, which contains the key/value pairs. The Close() method of the ResourceWriter class automatically calls ResourceWriter.Generate() to finally write the resources to the file RWDemo.resources.
Using Resource File in an Application
We can add resource files to assemblies using the assembly generation tool al.exe, using the /embed option or using the c# compiler with /resource option or directly using the VS.Net. The following are the steps to use the resource files in C# application.
1. Open the application
2. Use the context menu of the solution explorer (Add >> Add Existing Item)
3. Locate the path where the resource file is situated.
4. If you check the Resource after adding it to the projects, its BuildAction is “Embedded Resource”, this means the resource is embedded to the output assembly.
5. You can view the resource file using the ILDasm.exe utility by checking it in the assembly manifest.
6. To access the embedded resources, use the Resource Manager class from the System.Resources namespace.
7. You can pass the assembly that has the resources as an argument to the constructor of the Resource Manager class
8. Once you include the resource file in the application use the Resource Manager and load the resource file into this.
The core function of a Windows Service is to run an application in the background. One of the ways that it differs from an windows application in that a Windows Service starts before any user logs in to the system (if it has been setup to start at boot up), although it can also be setup in such a way that it requires user to start it manually. A Windows Service also has its own process hence it runs very efficiently. Normally a Windows Service will not have a user interface for a simple reason it can be run even if no one is logged on to the system but this is not a rule, you can still have a Windows Service with a user interface.
Creating a Windows Service:
Step 1:- Open VS 2005, Click on File > Projects.
Step 2:- This will open up a project and clicking on the hyperlink that is there on the page, you will be able to open the code behind page where you can code for the web service.
Step 3:- Add Functionality to the web service that you have created. There are two overridden function i.e. “OnStart” and “OnStop”. The OnStart function executes when you start your service and the OnStop function gets execute when you stop a service.
//OnStart
protected override void OnStart( string [] args)
{}
//OnStop
protected override void OnStop()
{}
Step 4:- Install and Run the Service: For Installation of the service on the computer, one need to have the administrator rights to install the service on the computer. The installUtil tool is provided by with the .Net framework to install the application.
Note:- The use should have administrator rights to install the utility. If the utility is not installed then it will display a popup when you run the program.
Example: Demonstrate Windows Services.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.ServiceProcess;
using System.Text;
using System.IO;
namespace winServiceFirst
{
public partial class OTestService : ServiceBase
{
public OTestService()
{
InitializeComponent();
}
protected override void OnStart( string [] args)
{
//This will be printed at the start of the service....
Note:- Thr program will write the content in the text file that we specified. The following lines gets printed in the text file.
**************************
mcWindowsService: Service Started
**************************
***************************
mcWindowsService: Service Stopped
***************************
The term "web service" refers to a form of a component that can be used remotely. Web services are invoked remotely using SOAP or HTTP-GET and HTTP-POST protocols. Web services are based on XML and return an
"answer" to the client in XML format. Web services have all the advantages of components plus many more.
The most significant benefits include:
1. Platform and Language Independence : Web services can be built and consumed on any operating system just as long as that operating system supports the SOAP protocol and XML.
2. Automatic Upgrade : Unlike components, if a web service requires an update, that update is propagated to all applications consuming that web service immediately. This is because the actual methods and properties for the web service are invoked from the web server remotely, meaning that each function contained within a web service appears as a "black box" to a client: they aren't concerned with the way the function does its job, just as long as it returns the expected result.
Some Important Terms in Web Services:
1. UDDI : UDDI (Universal Description, Discovery and Integration) is a registry that provides a place for a company to register its business and the services that it offers. People or businesses that need a service can use this registry to find a business that provides the service. When you search for a web service using UDDI's web service or web browser, UDDI returns a listing of web services that matched your
criteria. This list is returned in the form of a DISCO or WSDL document.
2. WSDL: WSDL (Web Services Description Language) is a language that describes a web service. It contains information such as where you can find the web service, methods and properties that it supports, its data types, and the protocol used to communicate with the web service. WSDL is based on the XML format and it's used to create proxy objects. Basically, without a WSDL document, developers wouldn't be able to use web services simply because they wouldn't know which methods and properties they support and also which communication method any particular web service supports.
3. DISCO : DISCO (Abbreviated from disco very) is a list of WSDL documents. DISCO is used to group common web services together. DISCO documents are also in XML format.
4. SOAP: SOAP (Simple Object Access Protocol) is a protocol to transport data to and from the web server. It is in XML format and allows you to transport a variety of data types used in .NET. As an alternative to SOAP, we can use HTTP-GET and HTTP-POST, which will be covered later in the article. These protocols return the output in a non-SOAP format; however this output is still in XML format.
Example: Demonstrate Web Service
using System;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;
[ WebService (Namespace = "http://tempuri.org/" , Description = "New WEB Service Developed by V.D" )]
public class Service : System.Web.Services. WebService
{
public Service () {
//Uncomment the following line if using designed components
//InitializeComponent();
}
[ WebMethod (Description= "GetEmployeeName: This will return the Employee Name." )]
public string getEmployeeName()
{
return "James Tube" ;
}
[ WebMethod (Description = "GetEmployeeAge: This will return the Employee Age." )]
public string getEmployeeAge()
{
return "23" ;
}
}
Output: Run this Web Service or F5
Note:
1]. There are 2 methods that are associated with this web service.
2]. The web service us under the default namespace that is http://tempuri.org. .
3]. Each XML Web service needs a unique namespace in order for client applications to distinguish it from other services on the Web.http://tempuri.org/ is available for XML Web services that are under development, but published XML Web services should use a more permanent namespace .
Output: If user clicks on the getEmployeeAge link
A Web Service is an external interface provided by a Web site that can be called from other Web sites. For example, a financial company may make up
to the minute stock quotes available via Web Service for those who do their trading with that company. This information could be read from a Web page and displayed, or read from a stand-alone application on a customer's desktop computer.
Client Communicate through web service:
SOAP over HTTP SOAP over HTTP
XML XML
Location 1 Location 2
Soap calls are remote function calls that invoke methods executions on Web Service components at Location 2. The output is render as XML and pass back to the Location 1 where the user wants to access the Web Service.
At Location 1, the user need to consume some of the functions of the web service that is available on the internet, to make the remote function calls (RFC). All the processing can't be done on the remote machine, therefore, we have to create the proxy of the web service from where we can process our data. This whole process is also called as marshalling of data.
Due to security threats, we create the proxy of the server object here it is web service. That means we are creating a " proxy object " to act on behalf of the original Web service. The proxy object will have all the public available data interfaces as the original Web service.
Consuming a Web Service
The following are the steps to call/consume a webservice.
Step 1: Create a Web Service project and run it so that no compilation error exists.
Step 2: Create new Web Site that will consume this web site that is there in your system using the VS.Net. Create New Web Site with the name: Web Site Name that will consume web service: WebService_Consume.
Step 3: Once you are done with the creation of the new site that will consume the web Service. Let example the web service run as this URL: http://localhost:1508/WebService_New/MyWebService.asmx
Step 4: Right click on the solution, Click on “Add Web Reference”. This will open up a new pop-up window where you can specify the URL name of your web service .
Here we specify the web service URL and if you look at the right panel there is Web Reference Name: localhost [This the default name that is there].
Step5: We specify “localhost_myWebService” name for the web reference. This will include 3 files under this folder.
MyWebService.disco
MyWebService.discomap
MyWebService.wsdl
Step6: Look Inside the contents of the “disco” file
Click on the Fetcher button: This will fetch the value from the Web Service.
There are many ways to consume Web Services.
1. The first way is to use a SOAP Proxy Client Object generated by the WSDL utility, and it provides programmers with their familiar object model that they can use to call methods provided by the generated Proxy Interface.
2. The second way is to use HTTP-POST and HTTP-GET protocols.
3. The third way is to use a SOAP standard Request message that parses SOAP response messages with the help of the XMLHTTP COM object that is installed by the Microsoft XML Parser.
WSDL: Web Services Description Language (WSDL) is an XML based protocol for information exchange in decentralized and distributed environments. A WSDL document defines services as collections of network endpoints, or ports. A WSDL document uses the following elements in the definition of network services:
Types – a container for data type definitions using some type system (such as XSD).
Message – an abstract, typed definition of the data being communicated.
Operation – an abstract description of an action supported by the service.
Port Type –an abstract set of operations supported by one or more endpoints.
Binding – a concrete protocol and data format specification for a particular port type.
Port – a single endpoint defined as a combination of a binding and a network address.
Service – a collection of related endpoints.
Proxy Class: This proxy class serves as an intermediate between the ASP.NET Web page and the Web service
Consuming Web Service object:
1. The Asp.Net page instantiates an instance of the proxy class. For e.g. ProxyClassName objproxy = new ProxyClassName();
2. Once the object is instantiated, then with the help of proxy object, this will make a call to the web service method. For e.g. objproxy.WebMethodName(any Parameter that has to send);
3. The proxy class marshals the parameter list and makes an HTTP request to the Web service sitting on Web Server 2.
4. The Web service unmarshals the incoming parameters, runs the method, and marshals the output parameters. These are sent back in an HTTP response.
5. The proxy class unmarshals the return parameters and passes back the result to the ASP.NET Web page.
Creating a Proxy Class:
Creating a Proxy class involves three steps:
Step 1:- First create the proxy class of the web service using the WSDL tool.
wsdl.exe:-Utility to generate code for xml web service clients and xml web services using ASP.NET from WSDL contract files, XSD schemas and discomap discovery documents. This tool can be used in conjunction with disco.exe.
Run this from the Command Prompt:
C:\Program Files\Microsoft Visual Studio 8\VC> wsdl http://localhost:1508/WebService_New/MyWebService.asmx
Microsoft (R) Web Services Description Language Utility
[Microsoft (R) .NET Framework, Version 2.0.50727.42]
Copyright (C) Microsoft Corporation. All rights reserved.
Writing file 'C:\Program Files\Microsoft Visual Studio
8\VC\Service.cs'.
Step 2:- This will create the “Service.cs” file on the specified location. After this compile this Proxy Class to generate the compiled proxy
Class i.e. “Service.dll” Run this from the command Prompt:
C:\Program Files\Microsoft Visual Studio 8\VC> csc /t:library Service.cs
Microsoft (R) Visual C# 2005 Compiler version 8.00.50727.42
for Microsoft (R) Windows (R) 2005 Framework version 2.0.50727
Copyright (C) Microsoft Corporation 2001-2005. All rights Reserved.
Step 3:-Place this compiled proxy class in the dll of the Web Site from where you want to access the Web Service.
WSDL.EXE:
• Wsdl.exe contains only one required parameter, a URL or path to the WSDL for the Web service. The following optional parameters can be specified:
• /language: language – specifies what language the Proxy class should be created in (vb/cs/js).
• /protocol: protocol – specifies the payload protocol to be used (SOAP, HttpGet, HttpPost)
• /namespace: namespace – the namespace of the generated Proxy class.
• /out: filename – the filename of the Proxy class.
Proxy Class inclusion
1. Add the proxy class to the newly created Web Site
2. Go to Solution Explorer; right click on that solution à click on “Add Reference”. Below pop-up window appears
1. Clicking “Ok” will include the proxy class to the solution under “Bin folder”.
2. Now we can use this proxy class and the methods that are there in the web services.
Note: A proxy class is a class containing all of the methods and objects exposed by the Web service. These methods handle the marshalling of the parameters into SOAP, sending the SOAP request over HTTP, receiving the response from the Web service, and unmarshalling the return value. The proxy class allows the client program to call a Web service as if the Web service was a local component.
Once you create a proxy class using the .NET command-line tool wsdl.exe , a Web service client may invoke proxy class methods, which communicate with a Web service over the network by processing the SOAP messages sent to and from the Web service.
Example: Demonstrate the Creation of Proxy Class and its Usage
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
public partial class _Default : System.Web.UI. Page
The .NET gives us flexibility to work with the XML files easily. .NET provides following five namespaces for XML manipulation.
1. System.Xml:- Contains major XML classes.This namespace contains many classes to read and write XML documents.Some classes under this namespace are XmlReader, XmlTextReader, XmlValidatingReader, XmlNodeReader, XmlWriter, and XmlTextWriter.
2. System.Xml.Schema:- Contains classes which work with XML schemas. XmlSchema, XmlSchemaAll, XmlSchemaXPath, and XmlSchemaType are the classes comes under this namespace..
3. System.Xml.Serialization:- Contains classes that are used to serialize objects into XML format documents or streams.
4. System.Xml.XPath:- Contains XPath related classes to use XPath specifications. XPathDocument, XPathExression, XPathNavigator, and XPathNodeIterator classes comes under this namespace..
5. System.Xml.Xsl :- Contains classes to work with XSLT transformations.
The XmlReader and XmlTextReader classes are defined in the System.XML namespace.The XmlTextReader class is derived from XmlReader class. The XmlTextReader class can be used to read the XML documents. The read function of this document reads the document until end of its nodes.
<< Prev: Creating an XML document
Next: Using XMLWriter class to Write XML document in C sharp
Output: The following screen will be displayed when run the above program.
Clicking On the ‘ Read XML “ button the following screen will be displayed.
Using XMLWriter class to Write XML document in C sharp
The XmlWriter class contains the functionality to write to XML documents. XmlWriter is an abstract base class and is a super class of XmlTextWriter and XmlNodeWriter classes which are used to write the XML documents. This class has many WriteXXX methods to write paired, unpaired and empty XML elements. Some of these methods are used in a start and end pair. For example, to write an element, you need to call WriteStartElement then write a string followed by WriteEndElement.
Example: Demonstrate Writing to XML file
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Xml;
<< Prev: Reading XML document in C sharp
Next: Assembly Information : Getting Permission set of the
<WRITING CHARACTER IN XML DOCUMENT>XML</WRITING CHARACTER IN XML DOCUMENT>
</r:RECORD>
</EMPLOYEE>
Assembly Information : Getting Permission set of the assembly
The basics of CAS is whenever any code is being executed in managed world the .NET runtime verifies whether that code is allowed or not based on evidence and set of permissions. Two important things that are very much importance to the framework is:
Evidence:- From where the code comes? Is the code managed or unmanaged.
<< Prev: Using XMLWriter class to Write XML document in C sharp
Permissions:- The permission set on which the code executes.
Permissions and Permission Sets
Permission is what a code can do with particular resource like File, Registry etc., and Permission Set is collection of permission.
Policy Levels
NET System comes up with 4 Policies that are Enterprise , Machine User, and AppDomain (which can be done through programmatically). Each policy has multiple code groups and multiple permission sets.They have the hierarchy given below.
Enterprise : All managed code in an enterprise setting.
Machine: All managed code on the computer.
User: Code in all processes associated with the current user.
Application Domain: Managed code in the host's application domain.
Example:- To get the permission set of Current Assembly.
Form13.cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using System.Diagnostics;
using System.Reflection;
using System.Security;
using System.Security.Policy;
using System.Security.Permissions;
using System.Collections;
namespace _CSharpApplication
{
public partial class Form13 : Form
{
//NAME OF THE BUILD_IN NAMED PERMISSION SET FOR FULLTRUST.
const string sFullTrust = "FullTrust" ;
static PermissionSet finalSet = new NamedPermissionSet ( "FinalAssemblySet" );
static PermissionSet permSet = null ;
//FIND OUT WHETHER THIS ASSEMBLY IS FULLTRUST PERMISSIONS.
lblMode.Text = "Assembly is running in full-trust mode." ;
else
getOutput(finalSet, lstPermission);
}
}
}
Output:
Clicking on the “Assembly Information” button.
Creating your own Permission Set
User can also create their own permission sets and code groups in the C#. The following are the steps needs to follow to create your own permission sets and code groups:-
Steps to create your own permission set and Code group
1. Go to Control Panel --> Administrative Tools --> Microsoft .NET Framework 2.0 Configuration à Double click on this a popup windows appear
2. Creating a new Permission Set à Expand “Runtime Security Policy”.
<< Prev: Assembly Information : Getting Permission set of the assembly
There are 3 security policy levels i.e. Enterprise , Machine and User. We are creating the permission set for the machine security level.
3. Assign the permission to the permission set: Each permission set is a collection of much different permission to various resources on the computer. Select the permission that you need in the permission set.
4. Here I am selecting the “File IO” permission from the pool of permission set. And then change the settings for this permission. Here specify the “C:\” in the file path and assign only reading permission to this.
5. Here we assign 3 permission to the newly create permission set i.e. File IO, Security and User Interface.
Create New Code Group
Create new code group and assign the permission that you create to this code group so that your assembly will work under the specified permission set. Right click on the All_Code node and this will open a pop-up window i.e. Create Code Group wizard. Specify the name for your code group.
1. Choose a condition type for the code group:
The membership condition determines whether or not an assembly meets specific requirements to get the permission associated with a code group.
Condition type in the specified context: Strong Name. You have to just click on the Import button à Select the assembly from the pop-up and this will extract the information that we needed.
2. Assign a Permission Set to the code group:
Here through this window we can assign the permission set to this code group that we are going to create. Select the permission set that we created earlier. Though this window either we can create new permission set or
reuse the existing one.
3. Go through the properties of the newly created Code Group
Right click on the code group that you just created and you can view the “Code Group ” properties like the Code Group Name, its membership conditions and permission set that is associated to it.
Create an Application: That will perform read and write operations on file.
StreamReader _streamWriter = new StreamReader ( "c:\\TestPermission.txt" );
lstPSET.Items.Add(_streamWriter.ReadLine());
lstPSET.Items.Add(_streamWriter.ReadLine());
_streamWriter.Close();
}
}
}
Output:
Now run the application and try to click on the “write” button the screen, this will give you following exception.:-
Using C sharp Socket
The System.Net.Sockets namespace contains the classes that provide the actual .NET interface to the low-level Winsock APIs. This section gives a brief overview of the C# Socket class. The core of the System.Net.Sockets namespace is the Socket class. It provides the C# managed code implementation of the Winsock API. The Socket class constructor is as follows:
Socket(AddressFamily af , SocketType st , ProtocolType pt )
As you can see, the basic format of the Socket constructor mimics the original Unix socket() function. It uses three parameters to define the type of socket to create:
An AddressFamily to define the network type
A SocketType to define the type of data connection
A ProtocolType to define a specific network protocol
Each of these parameters is represented by a separate enumeration within the System.Net_.Sockets namespace. Each enumeration contains the values that can be used. For normal IP communications on networks, the AddressFamily.InterNetwork value should always be used for the AddressFamily. With the InterNetwork AddressFamily, the SocketType parameter must match a particular ProtocolType parameter. You are not allowed to mix and match SocketTypes and ProtocolTypes.
Socket Properties: Several properties of the Socket class can be used to retrieve information from a created Socket object
Property Description
AddressFamily Gets the address family of the Socket
Blocking Gets or sets whether the Socket is in blocking mode
LocalEndPoint Gets the local EndPoint object for the Socket
Connected Gets a value that indicates if the Socket is connected to a remote device
RemoteEndPoint Gets the remote EndPoint information for the Socket
SocketType Gets the type of the Socket
Handle Gets the operating system handle for the Socket
ProtocolType Gets the protocol type of the Socket
Available Gets the amount of data that is ready to be read
Introduction to Socket Exceptions:
One feature of socket programming included in .NET Framework is neither used by Unix nor the Winsock API is socket exceptions. All of the Socket
class methods use the SocketException exception. Any socket programming you do should always check for SocketException exceptions and then attempt to recover from the error, or at least warn the user of the problem.
Example: Demonstrate Socket Properties and Socket Exception Handling
