Arabic Programmer DotNet

How to make program to get device drivers - Part 2

2011-02-05T22:44:00.004+02:00

In order to get device drivers which installed on your computer we will write method its name (GetDriversList), this method is it most important part of our program which it consists of sub-method its name (GetDriver), which get and store driver informaion.

So the first stage is to bring a list containing the device drivers installed on your computer, which, as we mentioned previously that it found in the Registry Editor, and then brought the information contained in the key of each driver.

To store information about each driver, you declare the structure (DriverInfo) containing 6 fields to store the name, version, date, manufacture ....... of each driver.

The method that bring in device drivers (GetDriversList), supplied with a parameter determines if we want to get all the drivers, including drivers that are installed with the system or only drivers that you installed after you install the system. In order to get that we test the value of the manufacturer (drvManufacture) If it is equal to (Microsoft), this means that the driver was already installed with the system and we do not need to do a backup copy of it.

struct DriverInfo //structure for storing driver informations

{

public string drvName;

public string drvVersion;

public string drvManufacture;

public string drvDate;

public string drvInfPath;

public string drvInfSection;

}

//this methode collect and store driver info using the given driver path
DriverInfo GerDriver(string DriverPath)

{

DriverInfo temp = new DriverInfo();

try

{ //open the key which contains driver info

RegistryKey tKey = Registry.LocalMachine.OpenSubKey(DriverPath);

temp.drvManufacture = tKey.GetValue("ProviderName", "").ToString();

temp.drvName = tKey.GetValue("DriverDesc", "").ToString();

temp.drvDate = tKey.GetValue("DriverDate", "").ToString();

temp.drvVersion = tKey.GetValue("DriverVersion", "").ToString();

temp.drvInfPath = tKey.GetValue("InfPath", "").ToString();

temp.drvInfSection = tKey.GetValue("InfSection", "").ToString();

}

catch (SecurityException exs)

{

MessageBox.Show("SecurityException:\n" + exs.Message);

}

catch (Exception ex)

{

MessageBox.Show("GetDriver\\Error:\n" + ex.Message);

}

return temp;

}

void GetDriversList(bool bAllDrivers = true) //main methode in our program

{ //bAllDrivers determines if we will extract both windows and device drivers or
//just devices drivers

int i, j, iCnt;

//path = @"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Class";

RegistryKey hKey = Registry.LocalMachine.OpenSubKey(@"SYSTEM\CurrentControlSet\Control\Class\", false);

string[] subKeys = hKey.GetSubKeyNames();

string[] guidSubKeys;

for (i = 0; i < subKeys.Length; i++) //loop through all subkeys

{ //get the subkeys of the driver key

guidSubKeys = hKey.OpenSubKey(subKeys[i].ToString()).GetSubKeyNames();

//loop through all subkeys of the driver key

for (j = 0; j < guidSubKeys.Length; j++)

{
//this key exist in all drivers keys and it doesn't benefit us so we skip it

if (guidSubKeys[j].ToUpper() == "PROPERTIES")

continue;

try

{ //delete the first part of the path "HKEY_LOCAL_MACHINE\"

string path = hKey.Name.Substring(19);

path += "\\" + subKeys[i].ToString() + "\\" + guidSubKeys[j].ToString();

//path now will be:
//SYSTEM\CurrentControlSet\Control\Class\subkey[i]\guidSubkey[j]

DriverInfo tmp = GerDriver(path); //collect driver info

if (tmp.drvName.Trim() != "") //add the driver to gridview

{

if (bAllDrivers)

goto AddIt;

else if (bAllDrivers == false && (tmp.drvManufacture.ToUpper() != "MICROSOFT"))

goto AddIt;

else

continue;

AddIt:

lvwDrivers.Items.Add(tmp.drvName);

iCnt = lvwDrivers.Items.Count - 1;

lvwDrivers.Items[iCnt].SubItems.Add(tmp.drvManufacture);

lvwDrivers.Items[iCnt].SubItems.Add(tmp.drvDate);

lvwDrivers.Items[iCnt].SubItems.Add(tmp.drvVersion);

lvwDrivers.Items[iCnt].SubItems.Add(tmp.drvInfPath);

lvwDrivers.Items[iCnt].SubItems.Add(tmp.drvInfSection);

}

catch (SecurityException ex)

{

MessageBox.Show("SecurityException In GetDriversList:\n" + "Key: " + subKeys[i].ToString() + "\\" + guidSubKeys[j].ToString());

continue;

}

catch (NullReferenceException ex)

{

MessageBox.Show("NullReferenceException IN GetDriversList:\n" + ex.Message);

}

How to make program to get device drivers

2011-02-03T23:39:00.001+02:00

Where do we find device drivers??
We can we find device drivers in the registry editor and in the following key:
HKEY_LOCAL_MACHINE \ SYSTEM \ CurrentControlSet \ Control \ Class

Where this key (Class) contains many of the subkeys that represent device drivers, as we see in the picture that the names of these keys is a (GUID)
Under these subkeys we find other sub-keys have their names, like this: 0000-0001-0002 - etc.

In these keys we find the required information, as we see there are values in these keys contain information on device drivers, most important of these values are:

DriverDesc: which represents the name of the driver
DriverVersion: which is the version of the driver
DriverDate: which is the date the driver
InfPath: which represents the name of the Inf file for this this driver, which is located in the folder: C: \ Windows \ Inf
ProviderName: which represents the name of the manufacturer of this driver, this is very important since by this value we can identify the drives that install automatically with the system and its value is 'Microsoft', either to have installed by the user will be value certainly not a 'Microsoft', but 'Intel' Or 'Relatek' for example

The program interface:
The program interface consists of ListView to display the drives and their information, as well as some buttons such as: Get Drivers List and Backup Drivers.

How we will make a backup??
We can do it by the Inf file for each driver (*. Inf)Where contains inside a section containing the names of the files that make up the driver.
Our task is to extract the names of the files from the Inf file and then copy it to the location specified by the user.

Conclusion:
This lesson was just a paving and a brief explanation for the work through the program in general .. It sounds easy for a moment, but its implementation will be a little harder, for reasons I will mention in other parts of this lesson, but surely there is nothing difficult or impossible in the world of programming.

Author: Abdullah Alezzo

GDI+ Introducation - C#

2011-01-31T22:51:00.006+02:00

What is GDI+ :

This technique is the upgraded version of the GDI are used in the drawing for the making new tools, or for any purpose that needs to draw such a chart ...

Principles in the GDI +:
Create a new project Windows Forms Application, and then place a button on the form and type in the event Click:

Graphics myg = this.CreateGraphics();

Pen myp = new Pen(Brushes.Red, 2);

myg.DrawLine(myp, 0, 0, this.Width, this.Height);

myg.Dispose();

Try the code ...
The code will draw a red line of the upper-right corner of the form to the lower right corner ...

What happened?

When we declare the Graphics object to be used, we did so, as shown and as we draw outside Paint event you must use this way ...
When we declare the object Pen we have specify the red color and width 2 pixel ...
We draw a line by the variable myg which we declare it as Graphics by the the sub DrawLine

This sub is used as follows:

DrawLine(FirstX, FirstY, SecX, SecY); 

Examples:

Drawing dotted frame:

Graphics myg = this.CreateGraphics();

Pen myp = new Pen(Brushes.Red, 2);

myp.DashStyle = System.Drawing.Drawing2D.DashStyle.DashDotDot;

myg.DrawRectangle(myp, 5, 5, 100, 100);

myg.Dispose();

Draw a triangle:

Graphics myg = this.CreateGraphics();

Pen myp = new Pen(Brushes.Red, 2);

System.Drawing.Drawing2D.GraphicsPath mypath = new System.Drawing.Drawing2D.GraphicsPath();

mypath.AddLine(new Point(10, 10), new Point(50, 50));

mypath.AddLine(new Point(50, 50), new Point(10, 50));

mypath.AddLine(new Point(10, 50), new Point(10, 10));

myg.DrawPath(myp, mypath);

myg.Dispose();

Fill a rectangle:

Graphics myg = this.CreateGraphics();

myg.FillRectangle(Brushes.Gray, new Rectangle(50, 50, 400, 400));

myg.Dispose();

This was just a simple introduction to dealing with the 2D graphics library using GDI + ... And there is still more to learn

Tip: Adding files to your program and extract them when need

2011-01-30T22:19:00.003+02:00

Add executable files or other files, and then extract it from the program in one line:

Open a new project first, then add the files you want as follows:

From the solution explorer window
Open My project
And select resources
Then select the type of files and select Other
Add files and then clicking on the Add existing file
And select the files you want

When you want to retrieve files and save them on your computer You only write this line:

My.Computer.FileSystem.WriteAllBytes(OutPutFN, My.Resources.ResourceFN, False)

OutPutFN: a name and location of the file after extraction
My.Resources.ResourceFN: the file that you want to extract
False: If the file exists, do you want to overwrite it?

What is the benefit of adding and extracting such files?

In terms of safety to the environment of your program, you can keep a copy of the files on which your program, and when you damage one of these files, you can restore it this way ... And this gives your program additional strength.

Using Regular Expression - VB.NET

2011-01-29T16:10:00.016+02:00

What is Regular Expression?

It is great technique to search through texts.
Supported by many programming languages.
It use textual formulas contain some special characters that have special meaning.

Imagine that you want to search for emails in a text file or search for titles in websites here comes the role of the Regular Expression optimal solution.

The support of framework for Regular Expression:

Like many programming languages, the framework supports the Regular Expression through a set of classes exist in the space of names System.Text.RegularExpressions.

Regex object is used to search through text on a certain formula Declaration for the object is like this:

Dim r As Regex

r = New Regex("abc")

After that comes the role of the Match, which contains the results of the search operation.It will be a good idea to test 'Match.Success' before attempting to read the results:

Dim r As New Regex("abc")

Dim m As Match = r.Match("123abc456")

If m.Success Then

Console.WriteLine("Found match at position " & m.Index.ToString())

End If

In the former case the 'Match' will be the first characters group that equal to search pattern (i.e. the first result) but if we want to bring all search results we use Regex.Matches.MatchCollection

Dim mc As MatchCollection

Dim results(20) As String

Dim matchposition(20) As Integer

Dim r As New Regex("abc")

mc = r.Matches("123abc4abcd")

For i As Integer = 0 To mc.Count - 1

results(i) = mc(i).Value

matchposition(i) = mc(i).Index

Next i

How to write formulas for the Regular Expression:

Static text:

If you want to search for a word or phrase or a set of characters you can simply write formula

Example:

I Can write In visual Basic, visual c + + and visual foxpro

If we want to search for "visual"; will be three outcomes Search Results for "visual"

Search for any character:

We use the point "." To replace any character or symbol

Example:

I Have visual basic6, visual basic8, visual basic9

Search for: "Basic." ; This will result in basic6 and basic8 and basic9

Note: In the previous example, the point is equal to numbers, but can be equal to any character

Note: the point is equal to any character or symbol, including the point itself, but if you want to search for the point itself must be preceded by backslash(\)

Search for a character from the character set:

We use brackets [] to search for any character within the brackets
Example:

[chr] at

This formula will result hat or cat or rat
Note: The Regular Expression is case sensitive

* Dashes can be used to specify spans of characters in a class:

[0-9] ==> [0123456789]
[a-z] ==>> [abcdefghigklmnopqrstuvwxyz]
[A-Z] ==>> [ABCDEFGHIJKLMNOPQRSTUVWXYZ]

Can also mix them like this: [a-zA-Z0-9]

Example: To search for color in HTML format can use the following formula

# [0-9A-Fa-f] [0-9A-Fa-f] [0-9A-Fa-f] [0-9A-Fa-f] [0-9A-Fa-f] [0-9A-Fa-f]

* A caret at the left end of a class definition means the opposite: [^0-9]

Search for white space:

To search for characters that are not printed using the following formulas:

[\b] Backspace

\f Form feed

\n Line feed

\r Carriage return

\t Tab

\v Vertical tab

Character class abbreviations:

\d [0-9]

\D [^0-9]

\w [A-Za-z_0-9]

\W [^A-Za-z_0-9]

\s [ \r\t\n\f]

\S [^ \r\t\n\f]

Hanoi Towers - C#

2011-01-28T17:18:00.004+02:00

Here I'll show you the issue of Towers of Hanoi code .. Using a recursive way:

namespace HanoiTowers

{

class Program

{

static void Main(string[] args)

{

int n;

do{

Console.WriteLine("Enter number: ");

n = Int32.Parse(Console.ReadLine());

}while(n<=0);

Hanoi(n, 'A', 'B', 'C');

Console.ReadLine();

}

static void Hanoi(int n, char A, char B, char C)

{

if (n == 1)

Console.WriteLine("{0} --> {1}", A, C);

else

{

Hanoi(n - 1, A, C, B);

Console.WriteLine("{0} --> {1}", A, C);

Hanoi(n - 1, B, A, C);

}

This picture shows the method of work on this issue:

How to show line numbers in Visual Studio.NET

2011-01-27T17:06:00.006+02:00

How to show line numbers:

In order to show line numbers in the program Visual Studio. Net as it appears in following image:

1. Open the Tools menu and then choose Options

2. Then from the left side expand the node Text Editor

3. Then choose the node All Languages

4. Then check the Line Numbers

Killing Processes - VB.NET

2011-01-25T22:11:00.006+02:00

Introduction

This article provides a simple example of how to use the System.Diagnostics.Process library to display a list of running processes, and to select and kill processes by their process name and ID. It would not be a major trick to display additional information about the process using the same library or to kill processes by their ID or name alone rather than their name and ID but in this example, process names and IDs are used for display purposes and the purpose of killing a running process.

Figure 1: Listing and Killing Processes by Process Name and ID

Getting Started

There is a single solution included with this download, the solution contains a Win Forms project called “ProcessKillerVB”; this project contains one form (Form1.vb) and all of the code required to display and kill processes is contained within that single form class. If you open the attached project into Visual Studio 2008; you should see the following in the solution explorer:

Figure 2: Solution Explorer

Code: The Main Form

The main form contains all of the user interface elements necessary to display and update the list of currently running processes found on the user’s machine. It also contains a button handler which will kill a process by the process name. You can also kill a process by its ID but in terms of readability, if the user is selecting the process, the process name is going to make a lot more sense to them than will the process ID.

The class begins with the normal and default imports:

Imports System.Diagnostics

The constructor calls a method called “UpdateProcessList” which is used to get and display a list of running processes; it will be described shortly.

Public Class Form1

Public Sub New()

' This call is required by the Windows Form Designer.

InitializeComponent()

' display the list of running processes

UpdateProcessList()

End Sub

The next bit of code is the UpdateProcessList function; this function clears the listbox of any existing entries and then loops through each of the current processes, adding the name and ID of each process to the list (as Process Name – ID). At the end of the function, a status message is updated to display the current number of found processes.

''' <summary>

''' Loop through the list of running processes

''' and add each process name to the process

''' listbox

''' </summary>

''' <remarks></remarks>

Private Sub UpdateProcessList()

' clear the existing list of any items

lstProcesses.Items.Clear()

' loop through the running processes and add

'each to the list

Dim p As System.Diagnostics.Process

For Each p In System.Diagnostics.Process.GetProcesses()

lstProcesses.Items.Add(p.ProcessName & " - " & p.Id.ToString())

lstProcesses.Sorted = True

' display the number of running processes in

' a status message at the bottom of the page

tslProcessCount.Text = "Processes running: " & _

lstProcesses.Items.Count.ToString()

End Sub

The next bit of code in the application is the update button’s click event handler; all it does is to call the UpdateProcessList function to update the contents of the listbox.

''' <summary>

''' Manually update the list of runnings

''' processes

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

Private Sub btnUpdateProcessList_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) _

Handles btnUpdateProcessList.Click

UpdateProcessList()

End Sub

The last bit of the code in the application is used to kill a running process. Since you can have multiple processes with the same name, it was necessary to add in the ID along with the name in order to make some distinction between multiple instances of a single application, else, we would end up killing all running instances of the application which may or may not be desirable depending upon what you are doing. If you do want to kill off all running instances of an application, disregard the ID and kill all running processes with the same process name.

In the kill button click event handler; we again loop through all of the running processes and we take the selected item from the process/ID list, and parse it into a string containing the process name and an integer value containing the ID. If the current process (in the loop) matches on both the process name and process ID, the process is killed. At the end, the handler calls the update method used to repopulate the listbox such that is displays the current list of active processes and their IDs.

''' <summary>

''' Kill the process selected in the process name

''' and ID listbox

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

Private Sub btnKill_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) _

Handles btnKill.Click

If lstProcesses.SelectedItems.Count <= 0 Then

MessageBox.Show("Click on a process name to select it.", "No Process

Selected")

Return

End If

' loop through the running processes looking for a match

' by comparing process name to the name selected in the listbox

Dim p As System.Diagnostics.Process

For Each p In System.Diagnostics.Process.GetProcesses()

Dim arr() As String = _

lstProcesses.SelectedItem.ToString().Split("-")

Dim sProcess As String = arr(0).Trim()

Dim iId As Integer = Convert.ToInt32(arr(1).Trim())

If p.ProcessName = sProcess And p.Id = iId Then

p.Kill()

End If

' update the list to show the killed process

' has been removed

UpdateProcessList()

End Sub

End Class

That concludes the description of all of the code used in this example.

Summary

The article shows one approach that may be used to display a list of current processes, and to single out and kill a single process based upon both the process name and its ID. One could also kill all instances of a particular process by killing all processes that match on name without giving any consideration to the process ID. The approach shown allows for singling out specific instances of a process and killing it without taking down all other matching processes.

Author: Scott Lysle

Handling strings in C#

2011-01-24T23:11:00.020+02:00

We can deal with strings as an array of characters. This means that we can access the characters of the string separately using a formula as follows:

string m = "a world";

char c = m[1];

Reading the characters in this way is possible, but we can not use this method to assign characterss to any text string that is acceptable to code the following:

m[1] = 'w';

So that we can get a char array can write to it we use it ToCharArray () which returns a array characters represent the array codes the text string:

string m = "a world";

char[] c = m.ToCharArray();

You can treat the char array method that we want we can change the elements and write, including what we want.

We can also use text strings within foreach loops also, for example:

foreach (char ch in m)

{

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

}

As in the arrays, we can make up the text string using the Length as follows:

string m = Console.ReadLine("you typed {0} characters.", m.Length);

There are similar commands for ToCharArray () and are what ToLower () and ToUpper () and two characters to convert the text string to all lowercase or large ..

For example: if we had the application is expected from the user's income and based on this income there code software will be implemented, for example, the user enters yes then we have converted the text string the user entered to lowercase, we will be able to handle the events in which the user where to enter Yes or yeS or YES and cases are included too.

string u = Console.ReadLine ();

if (u.ToLower () == "yes")

{

// Act on response

}

Note that if we assume non-use of this function, we make sure that all cases in which the user can enter the word yes (all cases must be taken into account) has therefore become a complex code.

Follow-up to the previous example: if a user tries to put additional spaces to the beginning or end of the string and in this case will not be able to get answer yes from the user.

The solution is to use the Trim (), which can be applied to the string where the removal of all blanks from the text string.

and also to remove any characters from the text string we define a array of type char as parameter for this function are as follows:

char [] t = {' ', 'e', 's'};

string u = Console.ReadLine ();

u = u.ToLower ();

u = u.Trim (t);

if (u == "y")

{

// Act on response

}

In this way we get rid of any extra characters were written in the wrong that this would lead to address the situation of entry such as:

"Yeeeeeeees"

"Y"

"Yeess"

We can use the functions TrimStart () and TrimEnd () to get rid of spaces at the beginning or the end of the text string and can accept an array of characters as parameter for them if we are to remove certain characters from the beginning or the end of the string ..

The function PadLeft () adds a number of spaces to the left of the text string.

string m = "huda";

m = m.PadLeft(7);

Will this code to put three spaces in the beginning of a word in the variable huda m: "huda"

These approaches can tell us about the alignment of text strings within the columns and is important when the chains and put the numbers under each other.

As in The function Trim (), these two functions accept another parameter for the character that we would like to put it in surplus areas of the text string instead of blanks, for example:

string m = "huda";

m = m.PadLeft(7, '-');

The result is that the variable 'm' will contain the text string: "--- huda"

The function Split () returns an array of strings resulting from the separation of a text string, according to a specific character.

string m = "This is a test";

char[] s = {' '};

string [] w = m.Split(s);

foreach (string a in w)

{

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

}

Split command removes the character interval of the text string as well.

• You can apply the previous functions to the string values directly.

string x = "Ahmad".ToUpper();

The result is that the variable x will contain the text string: "AHMAD"

Structures in C#

2011-01-24T22:38:00.008+02:00

Structures:

The second kind of the types of variables is the structure 'Struct' acronym for the word (structure)
Represent the structure of different parts of the data can be different for each part type. It enables us to define our species of special variables, depending on the structure ...
For example:
Suppose we wish to save the path for the site specific from the point where this path composed of direction and distance measured in miles and simplify things we'll impose that the trend is one of the four directions of knowledge within a census orientation
And that the mileage represented by type double
Now we can use separate converts to represent this path as in the following code:

orientation direction;

double distance;

There is nothing wrong in what we have done but it would be simpler if we used a single variable to store this information

The definition of structures:

Struct <type name>
{
<member Declaration>
}

Section <memberDeclaration>: include the declaration of the variables (called data members of this structure) with the same usual method of almost every statement of intention to take the following formula:

<accessibility> <type> <name>;
: <name> Represents the name of any user name variable
: <type> Represents the type of user
: <accessibility> Is an extent of access to the member from outside the structure

namespace s {

class class1

{

enum orientation : byte

{

North = 1,

South = 2,

East = 3,

West = 4

}

struct route

{

public orientation direction;

public double distance;

}

static void main(string[] args)

{

route myRoute;

int myDirection;

Double myDistance;

Console.WriteLine(@"1) North \ n 2) South \ n" + @"3) East \ n4) West");

{

Console.WriteLine("select a direction:");

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

} while ((myDirection < 1) || (myDirection > 4));

Console.WriteLine("Input a distance: ");

myDistance = Convert.ToDouble(Console.ReadLine());

myRoute.direction = (orientation)myDirection;

myRoute.distance = myDistance;

Console.WriteLine("myRout specifies a direction of {0}" + "and a distance of {1} ", myRoute.direction, myRoute.distance);

}

AJAX

2011-01-24T15:26:00.006+02:00

AJAX, shorthand for Asynchronous JavaScript and XML, is a web development technique for creating interactive web applications.

AJAX meant to increase the web page’s interactivity, speed, and usability.

If you know JavaScript, HTML, CSS and XML then you need to spend just one hour to start with AJAX.

Ajax Acts as an Intermediary

The Ajax engine works within the Web browser (through JavaScript and the DOM) to render the Web application and handle any requests that the customer might have of the Web server. The beauty of it is that because the Ajax engine is handling the requests, it can hold most information in the engine itself, while allowing the interaction with the application and the customer to happen asynchronously and independently of any interaction with the server.

Asynchronous

This is the key. In standard Web applications, the interaction between the customer and the server is synchronous. This means that one has to happen after the other. If a customer clicks a link, the request is sent to the server, which then sends the results back.

With Ajax, the JavaScript that is loaded when the page loads handles most of the basic tasks such as data validation and manipulation, as well as display rendering the Ajax engine handles without a trip to the server. At the same time that it is making display changes for the customer, it is sending data back and forth to the server. But the data transfer is not dependent upon actions of the customer.

Ajax is Not New Technology

Ajax is instead a new way of looking at technology that is already mature and stable. If you’re designing Web applications right now, why aren’t you using Ajax? Your customers will thank you, and frankly, it’s just fun!

What is AJAX ?

AJAX stands for Asynchronous JavaScript and XML. AJAX is a new technique for creating better, faster, and more interactive web applications with the help of XML, HTML, CSS and Java Script.
Ajax uses XHTML for content and CSS for presentation, as well as the Document Object Model and JavaScript for dynamic content display.
Conventional web application trasmit information to and from the sever using synchronous requests. This means you fill out a form, hit submit, and get directed to a new page with new information from the server.
With AJAX when submit is pressed, JavaScript will make a request to the server, interpret the results and update the current screen. In the purest sense, the user would never know that anything was even transmitted to the server.
XML is commonly used as the format for receiving server data, although any format, including plain text, can be used.
AJAX is a web browser technology independent of web server software.
A user can continue to use the application while the client program requests information from the server in the background
Intuitive and natural user interaction. No clicking required only Mouse movement is a sufficient event trigger.
Data-driven as opposed to page-driven

Rich Internet Application (RIA) Technology

AJAX is most viable RIA technology so far. Its getting tremendous industry momentum and several toolkit and framworks areemerging. But same time JAX has browser incompatibility and it is supported by Java Script which is hard to maintain nand debug.

AJAX Is Based On Open Standards

AJAX is based on the following open standards:

Browser-based presentation using HTML and Cascading Style Sheets (CSS)
Data stored in XML format and fetched from the server
Behind-the-scenes data fetches using XMLHttpRequest objects in the browser
JavaScript to make everything happen

Technologies Used in AJAX

JavaScript

Loosely typed scripting language
JavaScript function is called when an event in a page occurs
Glue for the whole AJAX operation

API for accessing and manipulating structured documents

Represents the structure of XML and HTML documents

CSS

Allows for a clear separation of the presentation style from the content and may be changed programmatically by JavaScript

XMLHttpRequest

JavaScript object that performs asynchrous interaction with the server

Current Issues with AJAX

AJAX is growing very fast and that is the reason that it contains many issues with it. We hope with the passes of time they will be resolved ab AJAX will be ideal for web applications. We are listing down few issues which AJAX has as a challenge.

Complexity is increased

Server side developers will need to understand that presentation logic will be required in the HTML client pages as well as in the server-side logic
Page developers must have JavaScript technology skills

AJAX-based applications can be difficult to debug, test, and maintain

JavaScript is hard to test – automatic testing is hard
Weak modularity in JavaScript
Lack of design patterns or best practice guidelines yet

Toolkits/Frameworks are not mature yet

Most of them are in beta phase

No standardization of the XMLHttpRequest yet

Future version of IE will address this

No support of XMLHttpRequest in old browsers

Iframe will help

JavaScript technology dependency & incompatibility

Must be enabled for applications to function
Still some browser incompatibilities

JavaScript code is visible to a hacker

Poorly designed JavaScript code can invite security problem

Author: SandeepSawant.com

Top 10 reasons C# is better than VB.NET

2011-01-24T15:04:00.009+02:00

Let’s get practical, religion aside, with an eye on programmer productivity, here are the top 10 reasons why C# is better than VB.NET, in no particular order. If you have some other ones, let me know.

1. In C# the line ends when I type the semicolon. The practical offshoot of this is that I write code like this

string sql = @"SELECT *

FROM SomeSuchTable

WHERE ID=’WhatHaveYou’

ORDER BY ThisAndThatField ASC ";

So when someone hands you a SQL statement you can just paste it into your code and the output (i.e. carriage returns) will still keep the format. In VB.NET, you would have to write the following to keep the formatting.

Dim sql As String = "SELECT *" & vbCrLf

sql += "FROM SomeSuchTable" & vbCrLf

sql += "WHERE ID=’WhatHaveYou’" & vbCrLf

sql += "ORDER BY ThisAndThatField ASC "

And that’s annoying.

2. Increments/Decrements. a++;a–; ‘Nuff said

3. Money. No, not the data type. The green. C# developers make more money. Don’t believe me? Here is the proof. Like Orwell said, War Is Peace, Freedom Is Slavery, Ignorance Is Strength and yeah, it’s the same .NET framework, but Perception is Reality. Get over it. Learn it. Put it on the resume.

4. I am not sure whether this is a valid reason, but with C# I can use Borland C# Builder which sports my beloved SDI interface, a la VB3, so that you can code full screen. This interface was also available (though not by default), in VB4,5,6 and VS.NET 2002 beta 1. The SDI interface disappeared from the VS.NET product before it shipped though. Anyway, if you miss that kind of interface, you can use it in Borland C# Builder.

5. Error Catching. C# catches a lot more errors than VB.NET, such as uninitialized variables, dead code, etc…

6. You get to act really snotty to VB.NET developers, yeah! That’s priceless.

7. The source code to the C# compiler is available from Microsoft and Novell. This means that you can theoretically develop apps for OSes other than Windows, such as Linux and MacOS. Thanks to Jai Lue for this tidbit.

8. C# has Operator Overloading (my favorite feature from C++). Though, via the grapevine, VB.NET will have this feature in VS 2005. Thanks to Aditya Vaze for this language delicacy.

9. Comments in C# are just better. You can do multiline comments, XML comments, single line comments, etc… Thanks to German Voronin for this.

10. Regions in C# are far better. The key here is that you can place a region inside a function, thus breaking up the implementation into logical pieces. I simply love this ability.

Author: SandeepSawant.com

Using Objects Instead of Enumerations

2011-01-24T14:51:00.003+02:00

Introduction

Enumerations are one of many useful tools at the fingertips of developers. Most of us have been using them for years. Because they are so common and easy to use, I believe we sometimes overuse them. An enumeration at its core is merely a number value. Try this in C# and you will see how easy it is to convert between enumerations and integer values. Enumerations are useful because they are named collections of values which are associated under the surface with integer values.

This example shows how one could quickly and easily print out the names and number values of an enumeration.

Listing 1: Simple Enumeration Console Output

using System;
class Program
{
    static void Main(string[] args)
    {
        HaveFunWithEnums();
    }

    public static void HaveFunWithEnums()
    {
            Console.WriteLine(MyEnum.Something);
            Console.WriteLine(MyEnum.SomethingElse);
            Console.WriteLine(MyEnum.AndNow);
            Console.WriteLine(MyEnum.ForSomething);
            Console.WriteLine(MyEnum.CompletelyDifferent);
            Console.WriteLine((int)MyEnum.Something);
            Console.WriteLine((int)MyEnum.SomethingElse);
            Console.WriteLine((int)MyEnum.AndNow);
            Console.WriteLine((int)MyEnum.ForSomething);
            Console.WriteLine((int)MyEnum.CompletelyDifferent);
    }
}

internal enum MyEnum
{
    Something,
    SomethingElse,
    AndNow,
    ForSomething,
    CompletelyDifferent
}

That is some very easy code, and I think most people have probably seen enumerations printed by name as well enums converted to integers and their values used. So if enums are so great, why would I write an article talking about a way of avoiding them? Well, I would first like to say that I am a big fan of enums. I think they are quite useful; they just have some risks as well as some circumstances under which they fall a little bit short as far as software design is concerned.

Some Problems with Enumerations

I mentioned that there are problems with enumerations above, so by now you are probably wondering what those problems are. Well, one of them is the same thing I said was great up above. Enumerations are basically just numbers (please do not kill me for saying that). At the end of the day it is easy to convert between enums and numbers. Sometimes it is safe and sometimes it is not safe. Take a look at this simple code snippet which illustrates a couple of the ways we can mess around with enums.

Listing 2: Converting Enumerations to Integers and Integers to Enumerations

// This is safe, but a little bit odd
MyEnum myEnum = (MyEnum)(1 + (int)MyEnum.SomethingElse);
Console.WriteLine(myEnum);

// This is a really bad dangerous thing that can happen
MyEnum badEnum = (MyEnum)10;
Console.WriteLine(badEnum);

The first one works as we expect, it gives us the enum "AndNow" and will write it to the screen. The second one, however, offers disturbing results when it writes the number "10" to the screen. It actually allows us to cast any integer value to one of our enumerations. That was not very safe at all, and it was actually really easy to do. Enumerations give the illusion of being safe here. Because we have the intellisense and strongly-typed values, we believe an enumeration is a lot safer than it really is.

In Combination with Lookup Tables

One thing I have seen used way more often than it should be is a combination of lookup tables and enumerations. What I mean here is that an enumeration is created which matches with a lookup table. In my opinion the use of an enumeration implies that there will be logical decisions made based on the enumeration. If you are using a lookup table, it means that this is simply data, data likely to change. It also implies that the values in the table should not have much logic associated with them.

The reason for this is that values in a table are easily changed, and because of this, people assume the change is safe to make. We know there are instances when changing the data can cause problems because logic needs to be adjusted when adding, removing, or altering entries in the lookup table.

Differences between lookup tables and enumerations cause them to be incompatible in my opinion. If there will be a good amount of logic based on these use an enumeration or an object. Do not have a lookup table. I know it is nice for the database, but any changes to the database will cause problems in the code.

Adding Information

Over time, people often try to add extra information to go along with enumerations. Sometimes you will see people have added extra attributes to enumerations for descriptions, colors, or something else. They are trying to associate extra information with those enumeration values. Well this is just one big sign that you need to move away from an enumeration. It is time to decide whether that should just be a lookup table (if it is only data) or if it should be a full-blown object (there is logic based on the values). If there is logic based on those values you might want to do something similar to what I outline next in this article.

Creating an Object-based Solution

What are the properties of enumerations we want to be able to replicate?

· Strongly typed access

· Unchanging at runtime

· Name and value pairing

· Customizable values

· Conversion to integers

· Get by value

· Get by name

· List all

So in order to replace our enumeration we are going to need to include these. Since we are using objects, the first one should be easily done. Our object will need to have at least two properties for the Name and the Value. So if we were just going to create a regular object we would have something like this.

Listing 3: Normal Object

public class MyObject
{
public int Id { get; set; }
public string Name { get; set; }
}

With this object we could create instances of it at runtime, but this is not what we want yet. The next step is making sure that we have a set of instances to start with and no more can be created. To do this we will make out constructor private. With the constructor private, we will need to declare the instances of this object inside the class, so the instances will need to be static. We will need to make sure that all of the values can be passed into the constructor so the instances can be created easily as static properties of the class This has the nice effect of allowing us to access them using ClassName.InstanceName. That naming convention will look similar to the one for enumerations which is Enumname.InstanceName.

Our new code which uses static instances and a private constructor looks like this.

Listing 4: Static Instances and Private Constructor

public class MyObject
{
    public static MyObject MyObjectOne = new MyObject(1, "MyObjectOne");
    public static MyObject MyObjectTwo = new MyObject(2, "MyObjectTwo");
    public static MyObject MyObjectThree = new MyObject(3, "MyObjectThree");

    public int Id { get; private set; }
    public string Name { get; private set; }

    private MyObject(int id, string name)
    {
        Id = id;
        Name = name;
    }
}

This object will already do a lot of what we need. It maintains a limited set, is strongly typed, has a name, has a value, you have control over the values for each, and the Id property lets you have it as an integer. Now we need to be able to get these based on the Id and the Name, and we also need to maintain a list of them.

Listing all of the values is useful for displaying them in different places such as a DropDownList or something similar.

Listing 5: Listing All of the Instances

public static List<MyObject> ListAll()
{
   return new List<MyObject>
  {
    MyObjectOne,
    MyObjectTwo,
    MyObjectThree
  };
}

For this it is pretty easy to just put them in a list like this or something similar. Not too difficult to maintain, it gives you good control of what is in the list.

Getting the instance of the object by Id and by Name is also pretty easy. With very little effort we are able to get them, and we throw some exceptions if we receive invalid method arguments.

Listing 6: FromId and FromName

public static MyObject FromId(int id)
{
    List<MyObject> items = ListAll();
    MyObject match = Array.Find(items.ToArray(), instance => instance.Id == id);

    if (match == null)
    {
        throw new ArgumentOutOfRangeException(string.Format(
            "Id '{0}' is invalid for {1}", id, typeof(MyObject).Name));
    }

    return match;
}

public static MyObject FromName(string name)
{
    List<MyObject> items = ListAll();
    MyObject match = Array.Find(items.ToArray(), instance => instance.Name == name);

    if (match == null)
    {
        throw new ArgumentOutOfRangeException(string.Format(
            "Name '{0}' is not a valid {1}", name, typeof(MyObject).Name));
    }

    return match;
}

At this point our object does pretty much everything we want it to do. This class is fairly testable, and is designed in such a way that we can add extra information to it. We can also add extra properties for any attributes we want like descriptions.

Conclusion

For many people, an enumeration is the correct solution, and for others the solution is a lookup table. I do not think those should be used together, but some people might have a reason to do so. It is important to keep in mind the circumstances of your exact situation when deciding, because I think there are plenty of times when an object should be used instead of either one.

Using the method outlined in this article should allow you to get around using an enumeration or a lookup table. It is an alternative that lets you extend enumerations, and has some other pros and cons. In some ways they are not as easy to work with as enumerations, but they are also safer in some ways.

Enumerations are a commonly used and known tool built into programming languages. They are however not the only way of doing things. In this article, Brendan outlines an alternative to using enumerations. He discusses some of the reasons why you might use an alternative and uses source code to explain how to achieve a comparable equivalent to enumerations.
by Brendan Enrick

Why .net is famous - Why ASP.NET ??

2011-01-22T22:55:00.007+02:00

Author: TOPS Technology

Microsoft Technology

Microsoft .NET (pronounced "dot net") is a software component that runs on the Windows operating system. .NET provides tools and libraries that enable developers to create Windows software much faster and easier. .NET benefits end-users by providing applications of higher capability, quality and security. The .NET Framework must be installed on a user's PC to run .NET applications.
ASP.NET is a technology for building powerful, dynamic Web applications and is part of the .NET Framework.
One can code ASP.NET applications in most .NET compatible languages including VB.NET, C#, and J#. ASP.NET pages, commonly known as web forms are compiled and stored on the web server for providing better performance. Web forms give you the flexibly to build powerful forms-based website pages. While building web forms based website pages you can use ASP.NET server controls to create common user interface (UI) elements and code them for accomplishing common tasks. These feature rich web controls allow you to build your web forms rapidly and make it usable as custom components.
So many top level technicians select Microsoft platform with ASP.NET with following reasons.

Easy Programming Model

ASP.NET makes building real world Web applications dramatically easier.
ASP.NET server controls enable an
HTML-like style of declarative programming that let you build great pages with far less code than with classic ASP. Displaying data, validating user input, and uploading files are all amazingly easy. Best of all, ASP.NET pages work in all browsers including Netscape, Opera, AOL, and Internet Explorer.

Flexible Language Options

ASP.NET lets you leverage your current programming language skills. Unlike classic ASP, which supports only interpreted VBScript and JScript, ASP.NET now supports more than 25 .NET languages (built-in support for VB.NET, C#, and JScript.NET), giving you unprecedented flexibility in your choice of language.

Great Tool Support

You can harness the full power of ASP.NET using any text editor, even Notepad. But Visual Studio .NET adds the productivity of Visual Basic-style development to the Web. Now you can visually design ASP.NET Web Forms using familiar drag-drop-doubleclick techniques, and enjoy full-fledged code support including statement completion and color-coding. VS.NET also provides integrated support for debugging and deploying ASP.NET Web applications. The Enterprise versions of Visual Studio .NET deliver life-cycle features to help organizations plan, analyze, design, build, test, and coordinate teams that develop ASP.NET Web applications. These include UML class modeling, database.
modeling (conceptual, logical, and physical models), testing tools (functional, performance and scalability), and enterprise frameworks and templates, all available within the integrated Visual Studio .NET environment.

Rich Class Framework

Application features that used to be hard to implement, or required a 3rd-party component, can now be added in just a few lines of code using the .NET Framework. The .NET Framework offers over 4500 classes that encapsulate rich functionality like XML, data access, file upload, regular expressions, image generation, performance monitoring and logging, transactions, message queuing, SMTP mail, and much more. With Improved Performance and Scalability ASP.NET lets you use serve more users with the same hardware.

Compiled execution

ASP.NET is much faster than classic ASP, while preserving the "just hit save" update model of ASP. However, no explicit compile step is required. ASP.NET will automatically detect any changes, dynamically compile the files if needed, and store the compiled results to reuse for subsequent requests. Dynamic compilation ensures that your application is always up to date, and compiled execution makes it fast. Most applications migrated from classic
ASP see a 3x to 5x increase in pages served.

Rich output caching

ASP.NET output caching can dramatically improve the performance and scalability of your application. When output caching is enabled on a page, ASP.NET executes the page just once, and saves the result in memory in addition to sending it to the user. When another user requests the same page, ASP.NET serves the cached result from memory without re-executing the page. Output caching is configurable, and can be used to cache individual regions or an entire page. Output caching can dramatically improve the performance of data-driven pages by eliminating the need to query the database on every request.

Web-Farm Session State

ASP.NET session state lets you share session data user-specific state values across all machines in your Web farm. Now a user can hit different servers in the Web farm over multiple requests and still have full access to her session. And since business components created with the .NET Framework are free-threaded, you no longer need to worry about thread affinity.

Enhanced Reliability

ASP.NET ensures that your application is always available to your users.

Memory Leak, DeadLock and Crash Protection

ASP.NET automatically detects and recovers from errors like deadlocks and memory leaks to ensure your application is always available to your users. For example, say that your application has a small memory leak, and that after a week the leak has tied up a significant percentage of your server's virtual memory. ASP.NET will detect this condition, automatically start up another copy of the ASP.NET worker process, and direct all new requests to the new process. Once the old process has finished processing its pending requests, it is gracefully disposed and the leaked memory is released. Automatically, without administrator intervention or any interruption of service, ASP.NET has recovered from the error.

Easy Deployment

ASP.NET takes the pain out of deploying server applications. "No touch" application deployment. ASP.NET dramatically simplifies installation of your application. With ASP.NET, you can deploy an entire application as easily as an HTML page, just copy it to the server. No need to run regsvr32 to register any components, and configuration settings are stored in an XML file within the application.

Dynamic update of running application

ASP.NET now lets you update compiled components without restarting the web server. In the past with classic COM components, the developer would have to restart the web server each time he deployed an update. With ASP.NET, you simply copy the component over the existing DLL, ASP.NET will automatically detect the change and start using the new code.

Easy Migration Path

You don't have to migrate your existing applications to start using ASP.NET. ASP.NET runs on IIS side-by-side with classic ASP on Windows 2000 and Windows XP
platforms. Your existing ASP applications continue to be processed by ASP.DLL, while new ASP.NET pages are processed by the new ASP.NET engine. You can migrate application by application, or single pages. And ASP.NET even lets you continue to use your existing classic COM business components.

XML Web Services

XML Web services allow applications to communicate and share data over the Internet, regardless of operating system or programming language. ASP.NET makes exposing and calling XML Web Services simple. Any class can be converted into an XML Web Service with just a few lines of code, and can be called by any SOAP client. Likewise, ASP.NET makes it incredibly easy to call XML Web Services from your application. No knowledge of networking, XML, or SOAP is required.

Mobile Web Device Support

ASP.NET Mobile Controls let you easily target cell phones, PDAs and over 80 mobile Web devices. You write your application just once, and the mobile controls automatically generate WAP/WML, HTML, or iMode as required by the requesting device.

If you have any requirement in .Net, please feel free to Contact Us Your privacy is guaranteed, we won't share your information.

Article Source: http://www.articlesbase.com/online-education-articles/why-net-is-famous-why-aspnet-3594106.html

About the Author

TOPS Technologies stands for Trainining Outsourcing and Placement Services. We have offices in Ahmedabad Baroda Surat Rajkot Maninagar and Udaipur. To know more about our company please visit our website http://www.tops-int.com

C# Codes

2011-01-22T21:30:00.014+02:00

Create a directory if it does not exist

if (!Directory.Exists(location))
Directory.CreateDirectory(location);

How to read the hard drive serial number

public string GetHDDSerialNumber(string drive)
{
    if (drive == "" || drive == null)
    {
        drive = "C";
    }

    ManagementObject disk = new ManagementObject("win32_logicaldisk.deviceid=\"" + drive +":\"");
    disk.Get();

    return disk["VolumeSerialNumber"].ToString();
}

Get a random number between two concrete

Random Rnd = new Random();
int A = Rnd.Next(0, 10);

Change the keyboard language to Arabic or English

public enum Languge : int{
    Arabic = 0,
    English = 1}

public static void SetLang(Languge Lang)
{
    try
    {
        string MyLang;
        if (Lang == Languge.Arabic)
            MyLang = "Arabic";
        else
            MyLang = "English";

        foreach (InputLanguage ThisLang in InputLanguage.InstalledInputLanguages)
            if (ThisLang.Culture.EnglishName.Contains(MyLang))
                InputLanguage.CurrentInputLanguage = ThisLang;
    }
    catch { }
}

To get the number of seconds that passed the device starts

Int64 SecondsFromStart = Environment.TickCount/1000;

Way of sending e-mail from your porgram

using System.ServiceProcess;
using System.Net.Mail;
using System.Text;
using System.Collections;
using System;

namespace MOJ {
    class Email
    {
        public bool SendEmail(MailAddress FromEmail, MailAddress ToEmail, string Subject, MailAddressCollection ToCC, MailAddressCollection ToBCC, string Body, string SMTP, bool IsHTML, ArrayList Attachments)
        {
            CheckService("smtpsvc");

            MailMessage mailMsg = new MailMessage(FromEmail, ToEmail);
            mailMsg.Subject = Subject.Trim.ToString;
            if (ToCC.Count != 0) mailMsg.CC.Add(ToCC.ToString);
            mailMsg.Bcc.Add(ToBCC.ToString);
            mailMsg.IsBodyHtml = IsHTML;
            mailMsg.BodyEncoding = Encoding.UTF8;
            mailMsg.SubjectEncoding = mailMsg.BodyEncoding;
            mailMsg.Body = Body.Trim.ToString;
            if (Attachments != null)
            {
                Attachment mailAttachment;
                foreach (Attachment mailAttachment in Attachments)
                    mailMsg.Attachments.Add(mailAttachment);
            }

            SmtpClient client = new SmtpClient(SMTP.Trim.ToString);
            try
            {
                client.Host = "localhost";
                client.Send(mailMsg);
            }
            catch (Exception ex) { throw ex; }
            return true;
        }

        public void CheckService(string ServiceName)
        {
            //Ensure the SMTP Service is installed.
            //Loop through all the services on the machine and find the SMTP Service.
            ServiceController[] services = ServiceController.GetServices;
            ServiceController service = null;
            bool blnHasSmtpService = false;
            string Message = "";

            foreach (ServiceController service in services)
            {
                if (service.ServiceName.ToLower != ServiceName.ToLower)
                    continue;
                blnHasSmtpService = true;
                break;
            }
            if (!blnHasSmtpService) Message += "- There're no SMTP service on your system." & Environment.NewLine;

            if (service.Status != ServiceControllerStatus.Running)
            {
                try
                {
                    service.Start();
                }
                catch (Exception ex) { throw ex; }
            }
        }
    }
}

To send an e-mail should be the SMTP service status and operated on your computer and be connected to the Internet and then can be used SendEmail () to send.

Know the screen resolution

string ScrRes = Screen.PrimaryScreen.Bounds.Width + "X" + Screen.PrimaryScreen.Bounds.Height;

XML - Introduction

2011-01-22T17:50:00.002+02:00

XML Basics

XML stands for eXtensible Markup Language.
XML is designed to transport and store data.

What is XML?

XML stands for EXtensible Markup Language

XML is a markup language much like HTML

XML was designed to carry data, not to display data

XML tags are not predefined. You must define your own tags

XML is designed to be self-descriptive

XML is a W3C Recommendation

The Difference Between XML and HTML :

XML is not a replacement for HTML.

XML and HTML were designed with different goals:

XML was designed to transport and store data, with focus on what data is.

HTML was designed to display data, with focus on how data looks.

HTML is about displaying information, while XML is about carrying information

Understanding the Vocabulary:

Well-formed XML:

Rules of Elements:

Element names cannot contain white space

Names cannot start with a number or a punctuation mark

Names cannot start with xml or variants

No space after the left angle bracket (<)

The case of start and closing tags must match

The first element is the root element

The root element must have start and closing tags

All child elements must nest within the root

Nesting elements cannot overlap

An empty child element can consist of a single tag

Rules of Attributes:

Declare them in start tags and processing instructions

Separate multiple declarations with a space

An attribute consists of a name and an assignment

Each name must be unique within an element

You can reuse names throughout a document

There are no spaces in names

Use either single or double quotes for assignments

<Book Type="IT">XML Principles</Book>

Processing instructions to applications

Use it to send a command to an external application

Multiple PIs to applications are allowed

<?MyDbAppSELECT * FROM orders?>

Processing instructions to the XML processor – the XML declaration

It begins with the XML keyword

It must appear only once per document at the top of the document

Use it to declare the XML version and character encoding

<?xml version="1.0" encoding="UTF-8"?>

Comments:

Do not embed a comment within a tag

<Books></Books>         Error: <Books></Books>

Use the double hyphen (--) only to open and close the comment

<--Option use–fas option -->      Error:<--option use --d as option-->

Do not use a triple hyphen (---) at the end

<---10 Centigrade -->     Error: <---10 Centigrade --->

Reserved Characters:

Reserved Characters	Entity References
&	&
<	<
>	>
'	'
"	"
Space

What Is an XML Vocabulary?

Problem: two XML sources cannot be easily combined

Solution: each XML source shares the same structure, naming, and case

Guidelines for Creating Vocabularies

Determine if a vocabulary already exists

Make your XML easy to read and understand

Use title case for elements and attribute names

Avoid abbreviations

بدء العمل بالمدونة

2011-01-21T18:05:00.001+02:00

السلام عليكم

Peace be upon you

بفضل الله وعونه تم انشاء مدونة

 المبرمج العربي دوت نت

  والتي ستجدون من خلالها مواضيع ومقالات تخص مختلف التقنيات البرمجية وبمختلف اللغات