DateTime myDate = DateTime.Today;

Etc.

DateTime myDate2 = DateTime.Now.AddHours(3000);

Example :

DateTime myDate1 = DateTime.Now;

DateTime myDate2 = DateTime.Now.AddHours(3000);

TimeSpan difference;

difference = myDate2.Subtract(myDate1);

double numberOfMinutes;

numberOfMinutes = difference.TotalMinutes;

The DateTime and TimeSpan classes also support the + and – arithmetic operators, which

do the same work as the built-in methods. That means you can rewrite the example shown

earlier like this:

// Adding a TimeSpan to a DateTime creates a new DateTime.

DateTime myDate1 = DateTime.Now;

TimeSpan interval = TimeSpan.FromHours(3000);

DateTime myDate2 = myDate1 + interval;

// Subtracting one DateTime object from another produces a TimeSpan.

TimeSpan difference;

difference = myDate2 – myDate1;

myString = myString.Trim();     // = “This is a test string”

myString = myString.Substring(0, 4);      // = “This”

myString = myString.ToUpper();      // = “THIS”

myString = myString.Replace(“IS”, “AT”); // = “THAT”

int length = myString.Length;      // = 4

myString = myString.Trim().Substring(0, 4).ToUpper().Replace(“IS”, “AT”);

myString = “hello”.ToUpper(); // Sets myString to “HELLO”

Conversions are of two types: widening and narrowing. Widening conversions always succeed. For example, you can always convert a 32-bit integer into a 64-bit integer. You won’t need any special code:

int mySmallValue;

long myLargeValue;

// Get the largest possible value that can be stored as a 32-bit integer.

// .NET provides a constant named Int32.MaxValue that provides this number.

mySmallValue = Int32.MaxValue; //can omit with your own self value.

// This always succeeds. No matter how large mySmallValue is,

// it can be contained in myLargeValue.

myLargeValue = mySmallValue;

On the other hand, narrowing conversions may or may not succeed, depending on the data. If you’re converting a 32-bit integer to a 16-bit integer, you could encounter an error if the 32-bit number is larger than the maximum value that can be stored in the 16-bit data type. All narrowing conversions must be performed explicitly. C# uses an elegant method for explicit type conversion. To convert a variable, you simply need to specify the type in parentheses before the expression you’re converting.

The following code shows how to change a 32-bit integer to a 16-bit integer:

int count32 = 1000;

short count16;

// Convert the 32-bit integer to a 16-bit integer.

// If count32 is too large to fit, .NET will discard some of the

// information you need, and the resulting number will be incorrect.

count16 = (short)count32;

If you don’t use an explicit cast when you attempt to perform a narrowing conversion, you’ll receive an error when you try to compile your code. However, even if you perform an explicit conversion, you could still end up with an overflow problem (where count32 value is more than 32767. Eg; count32 = 40000. Even with explicit conversion, count16 can’t hold value more than 32k thus resulting error.

The checked block enables overflow checking for a portion of code. If an overflow occurs, you’ll automatically receive an error, just like you would in VB: (IT IS NOT RECOMMENDED TO USE CHECK UNLESS WHEN YOU ARE DEBUGGING)

checked

{

// This will cause an exception to be thrown.

mySmallValue = (int)myLargeValue;

}

Convert Number to String and vice versa

string countString = “10″;

// Convert the string “10″ to the numeric value 10.

int count = Convert.ToInt32(countString);

// Convert the numeric value 10 into the string “10″.

countString = Convert.ToString(count);

Alternatively:

int count;

string countString = “10″;

// Convert the string “10″ to the numeric value 10.

count = Int32.Parse(countString);

Alternatively II (Java Flavor)

string myString;

int myInteger = 100;

// Convert a number to a string. myString will have the contents “100″.

myString = myInteger.ToString();

number = 4 + 2 * 3;

// number will be 10.

If you divide 5 by 2, you’ll end up with 2 instead of 2.5. The solution is to explicitly indicate that one of your numbers is a fractional value. For example, if you replace 5 with 5M, C# will treat the 5 as a decimal. If you replace 5 with 5.0, C# will treat it as a double. Either way, the division will return the expected value of 2.5.

// Join three strings together.

myName = firstName + ” ” + lastName;

// Add 10 to myValue. This is the same as myValue = myValue + 10;

myValue += 10;

// Multiple myValue by 3. This is the same as myValue = myValue * 3;

myValue *= 3;

// Divide myValue by 12. This is the same as myValue = myValue / 12;

myValue /= 12;

To use the math operations, you invoke the methods of the System.Math class.

double myValue;

myValue = Math.Sqrt(81); // myValue = 9.0

myValue = Math.Round(42.889, 2); // myValue = 42.89

myValue = Math.Abs(-10); // myValue = 10.0

myValue = Math.Log(24.212); // myValue = 3.18.. (and so on)

myValue = Math.PI; // myValue = 3.14.. (and so on)

Here’s an example of an enumeration that defines different types of users:

// Define an enumeration type named UserType with three possible values.

enum UserType

{

Admin,

Guest,

Invalid

}

Now you can use the UserType enumerationas a special data type that is restricted to one

of three possible values. You assign or compare the enumerated value using the dot notation

shown in the following example:

// Create a new value and set it equal to the UserType.Admin constant.

UserType newUserType = UserType.Admin;

Internally, enumerations are maintained as numbers. In the preceding example, 0 is automatically assigned to Admin, 1 to Guest, and 2 to Invalid.

But, if you want to manually assign integer value to each enumerate option :

enum ErrorCode

{

NoResponse = 166,

TooBusy = 167,

Pass = 0

}

Now you can use the ErrorCode enumeration with a function that returns an integer representing an error condition, as shown here:

ErrorCode err;

err = DoSomething();

if (err == ErrorCode.Pass)

{

// Operation succeeded.

}

// Create an array with four strings (from index 0 to index 3).

// You need to initialize the array with the

// new keyword in order to use it.

string[] stringArray = new string[4];

// Create a 2×4 grid array (with a total of eight integers).

int[,] intArray = new int[2, 4];

// Create an array with four strings, one for each number from 1 to 4.

string[] stringArray = {“1″, “2″, “3″, “4″};

The same technique works for multidimensional arrays, except that two sets of curly

brackets are required:

// Create a 4×2 array (a grid with four rows and two columns).

int[,] intArray = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};

To access an element in an array, you specify the corresponding index number in square

brackets: []. Array indices are always zero-based. That means that myArray[0] accesses the first

cell in a one-dimensional array, myArray[1] accesses the second cell, and so on:

// Access the value in row 0 (first row), column 1 (second column).

int element;

element = intArray[0, 1]; // Element is now set to 2.

Once you create an array, you can’t change its size. Instead, you would need to create a new array with the new size and copy

values from the old array to the new, which would be a tedious process.

Dynamic Array List

However, if you need adynamic array-like list, you can use one of the collection classes provided to all .NET lan-

guages through the .NET class library. One of the simplest collection classes that .NET offers is

the ArrayList, which always allows dynamic resizing. Here’s a snippet of C# code that uses an

ArrayList:

// Create an ArrayList object. It’s a collection, not an array,

// so the syntax is slightly different.

ArrayList dynamicList = new ArrayList();

// Add several strings to the list.

// The ArrayList is not strongly typed, so you can add any data type

// although it’s simplest if you store just one type of object

// in any given collection.

dynamicList.Add(“one”);

dynamicList.Add(“two”);

dynamicList.Add(“three”);

// Retrieve the first string. Notice that the object must be converted to a

// string, because there’s no way for .NET to be certain what it is.

string item = Convert.ToString(dynamicList[0]);

\” (double quote)

• \n (new line)

•\t (horizontal tab)

•\\ (backward slash)

You can also insert a special character based on its hex code using the syntax \x123. This

inserts a single character with hex value 123.

Note that in order to specify the actual backslash character (for example, in a directory

name), you require two slashes. Here’s an example:

// A C# variable holding the

// c:\MyApp\MyFiles path.

path = “c:\\MyApp\\MyFiles”;

Alternatively, youcan turn off C# escaping by preceding a string with an @ symbol, as

shown here:

path = @”c:\MyApp\MyFiles”;

If we declare integer type variable but initialize it with decimal variable:

int myInteger = 10.55;    //error will occur

We will get syntax error.

To get around this problem, C# defines a few special characters that you can append

to literal values to indicate their data type so that no conversion will be required. These are as

follows:

•M (decimal)

•D (double)

•F (float)

•L (long)

For example, you can rewrite the earlier example using the decimal indicator as follows:

decimal myDecimal = 14.5M;

C# safeguards you from errors by restricting you from using uninitialized variables. This

means the following code will not succeed:

int number; // Number is uninitialized.

number = number + 1; // This causes a compile error.

C# also deals strictly with data types. For example, the following code statement won’t

work as written:

decimal myDecimal = 14.5;

1. C# adalah general purpose programming language. Dia tak specific kepada tugas-tugas tertentu jer. C# mungkin kurang sesuai utk buat OS (C lebih sesuai dalam kes nie), tapi utk buat program yang simpan dan ambil data dari database, communication software, video controller, games …. idea is the limit.
2. C# dapat hasilkan program yang solid dan robust spt C++, tanpa perlukan pointer.
3. C# mempunyai kawalan skrin (screen handler) yang lbeih baik dari C++. Dikatakan sebaik Visual Basic dan Delphi.
4. Program yang ditulis menggunakan C# tidak semestinya terhad pada Microsoft Windows semata-mata. Project Mono dan DOTGNU project membolehkan applikasi yang ditulis menggunakan C# dijalankan di LINUX.
5. Sesetegah developer mendakwa C# lebih perlahan dari C++ kerena C# tidak di compile sepenuhnya. Walaupun demikian, dotnet runtime akan compile interpreted code (CIL) semasa program itu pertama kali dijalankan. Microsoft mendakwa, C# sepantas C++ if not faster.

Link :

• Game Development.
• Professional Career
• Software Engineering
• C# Code Library
• Tools And Utilities
• Download and Install Borland’s Turbo C# Explorer
• Download and Install Microsoft’s Visual C# 2005 Express Edition