installing Ubuntu 10.10

installing Ubuntu 10.10


Adjust text size:

October 14th, 2010, 11:30 GMT| By Marius Nestor

Ubuntu 10.10
Enlarge picture
Ubuntu 10.10, also known as the Maverick Meerkat, arrived on October 10th, 2010 and is the twelfth release of the Ubuntu OS. This new version of Ubuntu includes a revamped installer, so we've created the following tutorial to teach both Linux newcomers and existing Ubuntu users how to install the Ubuntu 10.10 operating system on their personal computer.

This tutorial is also addressed to people who have just heard about Ubuntu, those who have never installed Ubuntu before and want to test it, but don't know how!

The tutorial will make things very simple for you, but if you get stuck somewhere in the middle of the installation and you need help, do not hesitate to use our commenting system at the end of the article!

Requirements:

You will need the Ubuntu 10.10 Desktop ISO image that corresponds to your hardware architecture (i386 or amd64), and that can be downloaded from here. When the download is over, burn the ISO image with your favorite CD/DVD burning application (Nero, CDBurnerXP, Roxio) on a blank CD at 8x speed.

Reinsert or leave the CD in your CD/DVD-ROM device and reboot the computer in order to boot from the CD. Hit the F8, F11 or F12 key (depending on your BIOS) to select the CD/DVD-ROM as the boot device.

Wait for the CD to load...

Review image

In a couple of minutes you will see the wallpaper and the installation wizard. Select your language and click the "Install Ubuntu" button to continue...

Review image

Preparing to install Ubuntu

Make sure you have all the listed requirements. Optionally, you can choose to download updates while installing and/or install third party software, such as MP3 support. Be aware, though, that if you select those options, the entire installation process will be longer!

Review image

Allocate drive space

At this screen you have three options:

Review image

1. Install alongside other operating systems

- Choose this option ONLY if you have another OS (e.g. Windows XP) and you want a dual boot system.

Editor's Note: Remember that, after the installation, the Windows boot loader will be overwritten by the Ubuntu boot loader!

2. Erase and use the entire disk

- Choose this option if you want to delete your existing operating system, or the hard drive is already empty and you want to let the installer automatically partition the hard drive for you. This is the option recommended for all users, especially those who want a machine with a single operating system on it.

3. Specify partitions manually (advanced)

- This option is recommended ONLY for advanced users, to create special partitions or format the hard drive with other filesystems than the default one. But it can also be used to create a /home partition, which is very useful in case you reinstall the whole system.

Here's how you do a manual partitioning with /home:

- Select the "Specify partitions manually (advanced) and click the "Forward" button;

- Make sure that the selected hard drive is the right one. /dev/sda is the first physical hard drive. /dev/sdb is the second hard drive in your machine. So, make sure that you know which is the one you want to format! Otherwise, you will lose ALL YOUR DATA on that hard drive;

- Let's say that the selected drive is empty (no other operating system or important data on it), but it has some partitions on it. Select each one of those partitions and click the "Delete" button. After a few seconds, it will say "free space." Do this with the other partitions from the selected hard drive, until they're all deleted and you have a single "free space" entry;

- With the "free space" entry selected, click on the "Add" button. In the new window, type 2048 in the "New partition size in megabytes" field and select the "swap area" option from the "Use as:" drop down list. Click the OK button and, in a few seconds, you'll notice a "swap" line with the specified size;

- With the "free space" entry selected, click on the "Add" button. In the new window, select the "Primary" option, type a value between 10,000 and 50,000 in the "New partition size in megabytes" field and select / as the "Mount point." Click the OK button and, in a few seconds, you'll notice an "ext4 /" line with the specified size;

- With the "free space" line selected, click on the "Add" button. In the new window, select the "Primary" option, type a value between 30,000 and 50,000 (or whatever space you have left on the drive) in the "New partition size in megabytes" field and select /home as the "Mount point." Click the OK button and, in a few seconds, you'll notice an "ext4 /home" line with the specified size.

Review image

This is how your partition table should look like...

Review image

WARNING: Be aware that all the data on the selected hard drive or partition will be ERASED and IRRECOVERABLE.

Click the "Install Now" button to continue with the installation...

Review image

Editor's note: At this point the hard drive will be erase and partitioned, the CD data will be copied to the hard drive, and you can relax and continue to input the following required information.

Where are you?

This screen will feature a map of the Earth. Upon the selection of your current location, the time for the final system will adjust accordingly. You can try to guess you exact location with the mouse on the map, or just type the town in the designated field. Click the "Forward" button after you have selected your desired location...

Review image

Keyboard layout

On this screen, you will be able to choose a desired keyboard layout. But the default automatic selection should work for most of you. You can also click the "Figure Out Keyboard Layout" button for better recognition of your keyboard's layout. Click the "Forward" button when you have finished with the keyboard configuration...

Review image

Who are you?

On this screen, you must do exactly what the title says. Fill in the fields with your real name, the name of the computer (automatically generated, but can be overwritten), the name you want to use to log in on your Ubuntu OS (also known as the "username," which will be required to log in to the system), and the password.

Also at this step, there's an option called "Log in automatically." If you check it, you will automatically be logged in to the Ubuntu desktop.

Other option, called "Encrypt my home folder," will encrypt your Ubuntu installation. Click the "Forward" button to continue...

Review image

At this point the Ubuntu 10.10 (Maverick Meerkat) operating system will be installed...

Review image

After approximately 10 to 15 minutes (depending on your computer's specs), a pop-up window will appear, notifying you that the installation is complete, and you'll need to restart the computer in order to use the newly installed Ubuntu operating system. Click the "Restart Now" button...

Review image

The CD will be ejected; remove it and press the "Enter" key to reboot. The computer will be restarted and, in a few seconds, you will see the Ubuntu boot splash...

Review image

At the login screen, click on your username and input your password. Click the "Log In" button or hit Enter to log in...

Review image

That it! Have fun using Ubuntu 10.10.

Review image

delegates and events

Overview

All of us have been exposed to event driven programming of some sort or the other. C# adds on value to the often mentioned world of event driven programming by adding support through events and delegates. The emphasis of this article would be to identify what exactly happens when you add an event handler to your common UI controls. A simple simulation of what could possibly be going on behind the scenes when the AddOnClick or any similar event is added to the Button class will be explained. This will help you understand better the nature of event handling using multi cast delegates.

Delegates

A delegate in C# is similar to a function pointer in C or C++. Using a delegate allows the programmer to encapsulate a reference to a method inside a delegate object. The delegate object can then be passed to code which can call the referenced method, without having to know at compile time which method will be invoked.

Call a Function directly - No Delegate

In most cases, when we call a function, we specify the function to be called directly. If the class MyClass has a function named Process, we'd normally call it like this (SimpleSample.cs):

using System;

namespace Akadia.NoDelegate
{
public class MyClass
{
public void Process()
{
Console.WriteLine("Process() begin");
Console.WriteLine("Process() end");
}
}

public class Test
{
static void Main(string[] args)
{
MyClass myClass = new MyClass();
myClass.Process();
}
}
}

That works well in most situations. Sometimes, however, we don't want to call a function directly - we'd like to be able to pass it to somebody else so that they can call it. This is especially useful in an event-driven system such as a graphical user interface, when I want some code to be executed when the user clicks on a button, or when I want to log some information but can't specify how it is logged.

The very basic Delegate

An interesting and useful property of a delegate is that it does not know or care about the class of the object that it references. Any object will do; all that matters is that the method's argument types and return type match the delegate's. This makes delegates perfectly suited for "anonymous" invocation.

The signature of a single cast delegate is shown below:

delegate result-type identifier ([parameters]);

where:

* result-type: The result type, which matches the return type of the function.
* identifier: The delegate name.
* parameters: The Parameters, that the function takes.

Examples:

public delegate void SimpleDelegate ()

This declaration defines a delegate named SimpleDelegate, which will encapsulate any method that takes
no parameters and returns no value.

public delegate int ButtonClickHandler (object obj1, object obj2)

This declaration defines a delegate named ButtonClickHandler, which will encapsulate any method that takes
two objects as parameters and returns an int.

A delegate will allow us to specify what the function we'll be calling looks like without having to specify which function to call. The declaration for a delegate looks just like the declaration for a function, except that in this case, we're declaring the signature of functions that this delegate can reference.

There are three steps in defining and using delegates:

* Declaration
* Instantiation
* Invocation

A very basic example (SimpleDelegate1.cs):

using System;

namespace Akadia.BasicDelegate
{
// Declaration
public delegate void SimpleDelegate();

class TestDelegate
{
public static void MyFunc()
{
Console.WriteLine("I was called by delegate ...");
}

public static void Main()
{
// Instantiation
SimpleDelegate simpleDelegate = new SimpleDelegate(MyFunc);

// Invocation
simpleDelegate();
}
}
}

Compile an test:

# csc SimpleDelegate1.cs
# SimpleDelegate1.exe
I was called by delegate ...

Calling Static Functions

For our next, more advanced example (SimpleDelegate2.cs), declares a delegate that takes a single string parameter and has no return type:

using System;

namespace Akadia.SimpleDelegate
{
// Delegate Specification
public class MyClass
{
// Declare a delegate that takes a single string parameter
// and has no return type.
public delegate void LogHandler(string message);

// The use of the delegate is just like calling a function directly,
// though we need to add a check to see if the delegate is null
// (that is, not pointing to a function) before calling the function.
public void Process(LogHandler logHandler)
{
if (logHandler != null)
{
logHandler("Process() begin");
}

if (logHandler != null)
{
logHandler ("Process() end");
}
}
}

// Test Application to use the defined Delegate
public class TestApplication
{
// Static Function: To which is used in the Delegate. To call the Process()
// function, we need to declare a logging function: Logger() that matches
// the signature of the delegate.
static void Logger(string s)
{
Console.WriteLine(s);
}

static void Main(string[] args)
{
MyClass myClass = new MyClass();

// Crate an instance of the delegate, pointing to the logging function.
// This delegate will then be passed to the Process() function.
MyClass.LogHandler myLogger = new MyClass.LogHandler(Logger);
myClass.Process(myLogger);
}
}
}

Compile an test:

# csc SimpleDelegate2.cs
# SimpleDelegate2.exe
Process() begin
Process() end

Calling Member Functions

In the simple example above, the Logger( ) function merely writes the string out. A different function might want to log the information to a file, but to do this, the function needs to know what file to write the information to (SimpleDelegate3.cs)

using System;
using System.IO;

namespace Akadia.SimpleDelegate
{
// Delegate Specification
public class MyClass
{
// Declare a delegate that takes a single string parameter
// and has no return type.
public delegate void LogHandler(string message);

// The use of the delegate is just like calling a function directly,
// though we need to add a check to see if the delegate is null
// (that is, not pointing to a function) before calling the function.
public void Process(LogHandler logHandler)
{
if (logHandler != null)
{
logHandler("Process() begin");
}

if (logHandler != null)
{
logHandler ("Process() end");
}
}
}

// The FileLogger class merely encapsulates the file I/O
public class FileLogger
{
FileStream fileStream;
StreamWriter streamWriter;

// Constructor
public FileLogger(string filename)
{
fileStream = new FileStream(filename, FileMode.Create);
streamWriter = new StreamWriter(fileStream);
}

// Member Function which is used in the Delegate
public void Logger(string s)
{
streamWriter.WriteLine(s);
}

public void Close()
{
streamWriter.Close();
fileStream.Close();
}
}

// Main() is modified so that the delegate points to the Logger()
// function on the fl instance of a FileLogger. When this delegate
// is invoked from Process(), the member function is called and
// the string is logged to the appropriate file.
public class TestApplication
{
static void Main(string[] args)
{
FileLogger fl = new FileLogger("process.log");

MyClass myClass = new MyClass();

// Crate an instance of the delegate, pointing to the Logger()
// function on the fl instance of a FileLogger.
MyClass.LogHandler myLogger = new MyClass.LogHandler(fl.Logger);
myClass.Process(myLogger);
fl.Close();
}
}
}

The cool part here is that we didn't have to change the Process() function; the code to all the delegate is the same regardless of whether it refers to a static or member function.

Compile an test:

# csc SimpleDelegate3.cs
# SimpleDelegate3.exe
# cat process.log
Process() begin
Process() end

Multicasting

Being able to point to member functions is nice, but there are more tricks you can do with delegates. In C#, delegates are multicast, which means that they can point to more than one function at a time (that is, they're based off the System.MulticastDelegate type). A multicast delegate maintains a list of functions that will all be called when the delegate is invoked. We can add back in the logging function from the first example, and call both delegates. Here's what the code looks like:

using System;
using System.IO;

namespace Akadia.SimpleDelegate
{
// Delegate Specification
public class MyClass
{
// Declare a delegate that takes a single string parameter
// and has no return type.
public delegate void LogHandler(string message);

// The use of the delegate is just like calling a function directly,
// though we need to add a check to see if the delegate is null
// (that is, not pointing to a function) before calling the function.
public void Process(LogHandler logHandler)
{
if (logHandler != null)
{
logHandler("Process() begin");
}

if (logHandler != null)
{
logHandler ("Process() end");
}
}
}

// The FileLogger class merely encapsulates the file I/O
public class FileLogger
{
FileStream fileStream;
StreamWriter streamWriter;

// Constructor
public FileLogger(string filename)
{
fileStream = new FileStream(filename, FileMode.Create);
streamWriter = new StreamWriter(fileStream);
}

// Member Function which is used in the Delegate
public void Logger(string s)
{
streamWriter.WriteLine(s);
}

public void Close()
{
streamWriter.Close();
fileStream.Close();
}
}

// Test Application which calls both Delegates
public class TestApplication
{
// Static Function which is used in the Delegate
static void Logger(string s)
{
Console.WriteLine(s);
}

static void Main(string[] args)
{
FileLogger fl = new FileLogger("process.log");

MyClass myClass = new MyClass();

// Crate an instance of the delegates, pointing to the static
// Logger() function defined in the TestApplication class and
// then to member function on the fl instance of a FileLogger.
MyClass.LogHandler myLogger = null;
myLogger += new MyClass.LogHandler(Logger);
myLogger += new MyClass.LogHandler(fl.Logger);

myClass.Process(myLogger);
fl.Close();
}
}
}

Compile an test:

# csc SimpleDelegate4.cs
# SimpleDelegate4.exe
Process() begin
Process() end
# cat process.log
Process() begin
Process() end

Events

The Event model in C# finds its roots in the event programming model that is popular in asynchronous programming. The basic foundation behind this programming model is the idea of "publisher and subscribers." In this model, you have publishers who will do some logic and publish an "event." Publishers will then send out their event only to subscribers who have subscribed to receive the specific event.

In C#, any object can publish a set of events to which other applications can subscribe. When the publishing class raises an event, all the subscribed applications are notified. The following figure shows this mechanism.

Conventions

The following important conventions are used with events:

* Event Handlers in the .NET Framework return void and take two parameters.
* The first paramter is the source of the event; that is the publishing object.
* The second parameter is an object derived from EventArgs.
* Events are properties of the class publishing the event.
* The keyword event controls how the event property is accessed by the subscribing classes.

Simple Event

Let's modify our logging example from above to use an event rather than a delegate:

using System;
using System.IO;

namespace Akadia.SimpleEvent
{
/* ========= Publisher of the Event ============== */
public class MyClass
{
// Define a delegate named LogHandler, which will encapsulate
// any method that takes a string as the parameter and returns no value
public delegate void LogHandler(string message);

// Define an Event based on the above Delegate
public event LogHandler Log;

// Instead of having the Process() function take a delegate
// as a parameter, we've declared a Log event. Call the Event,
// using the OnXXXX Method, where XXXX is the name of the Event.
public void Process()
{
OnLog("Process() begin");
OnLog("Process() end");
}

// By Default, create an OnXXXX Method, to call the Event
protected void OnLog(string message)
{
if (Log != null)
{
Log(message);
}
}
}

// The FileLogger class merely encapsulates the file I/O
public class FileLogger
{
FileStream fileStream;
StreamWriter streamWriter;

// Constructor
public FileLogger(string filename)
{
fileStream = new FileStream(filename, FileMode.Create);
streamWriter = new StreamWriter(fileStream);
}

// Member Function which is used in the Delegate
public void Logger(string s)
{
streamWriter.WriteLine(s);
}

public void Close()
{
streamWriter.Close();
fileStream.Close();
}
}

/* ========= Subscriber of the Event ============== */
// It's now easier and cleaner to merely add instances
// of the delegate to the event, instead of having to
// manage things ourselves
public class TestApplication
{
static void Logger(string s)
{
Console.WriteLine(s);
}

static void Main(string[] args)
{
FileLogger fl = new FileLogger("process.log");
MyClass myClass = new MyClass();

// Subscribe the Functions Logger and fl.Logger
myClass.Log += new MyClass.LogHandler(Logger);
myClass.Log += new MyClass.LogHandler(fl.Logger);

// The Event will now be triggered in the Process() Method
myClass.Process();

fl.Close();
}
}
}

Compile an test:

# csc SimpleEvent.cs
# SimpleEvent.exe
Process() begin
Process() end
# cat process.log
Process() begin
Process() end

The Second Change Event Example

Suppose you want to create a Clock class that uses events to notify potential subscribers whenever the local time changes value by one second. Here is the complete, documented example:

using System;
using System.Threading;

namespace SecondChangeEvent
{
/* ======================= Event Publisher =============================== */

// Our subject -- it is this class that other classes
// will observe. This class publishes one event:
// SecondChange. The observers subscribe to that event.
public class Clock
{
// Private Fields holding the hour, minute and second
private int _hour;
private int _minute;
private int _second;

// The delegate named SecondChangeHandler, which will encapsulate
// any method that takes a clock object and a TimeInfoEventArgs
// object as the parameter and returns no value. It's the
// delegate the subscribers must implement.
public delegate void SecondChangeHandler (
object clock,
TimeInfoEventArgs timeInformation
);

// The event we publish
public event SecondChangeHandler SecondChange;

// The method which fires the Event
protected void OnSecondChange(
object clock,
TimeInfoEventArgs timeInformation
)
{
// Check if there are any Subscribers
if (SecondChange != null)
{
// Call the Event
SecondChange(clock,timeInformation);
}
}

// Set the clock running, it will raise an
// event for each new second
public void Run()
{
for(;;)
{
// Sleep 1 Second
Thread.Sleep(1000);

// Get the current time
System.DateTime dt = System.DateTime.Now;

// If the second has changed
// notify the subscribers
if (dt.Second != _second)
{
// Create the TimeInfoEventArgs object
// to pass to the subscribers
TimeInfoEventArgs timeInformation =
new TimeInfoEventArgs(
dt.Hour,dt.Minute,dt.Second);

// If anyone has subscribed, notify them
OnSecondChange (this,timeInformation);
}

// update the state
_second = dt.Second;
_minute = dt.Minute;
_hour = dt.Hour;

}
}
}

// The class to hold the information about the event
// in this case it will hold only information
// available in the clock class, but could hold
// additional state information
public class TimeInfoEventArgs : EventArgs
{
public TimeInfoEventArgs(int hour, int minute, int second)
{
this.hour = hour;
this.minute = minute;
this.second = second;
}
public readonly int hour;
public readonly int minute;
public readonly int second;
}

/* ======================= Event Subscribers =============================== */

// An observer. DisplayClock subscribes to the
// clock's events. The job of DisplayClock is
// to display the current time
public class DisplayClock
{
// Given a clock, subscribe to
// its SecondChangeHandler event
public void Subscribe(Clock theClock)
{
theClock.SecondChange +=
new Clock.SecondChangeHandler(TimeHasChanged);
}

// The method that implements the
// delegated functionality
public void TimeHasChanged(
object theClock, TimeInfoEventArgs ti)
{
Console.WriteLine("Current Time: {0}:{1}:{2}",
ti.hour.ToString(),
ti.minute.ToString(),
ti.second.ToString());
}
}

// A second subscriber whose job is to write to a file
public class LogClock
{
public void Subscribe(Clock theClock)
{
theClock.SecondChange +=
new Clock.SecondChangeHandler(WriteLogEntry);
}

// This method should write to a file
// we write to the console to see the effect
// this object keeps no state
public void WriteLogEntry(
object theClock, TimeInfoEventArgs ti)
{
Console.WriteLine("Logging to file: {0}:{1}:{2}",
ti.hour.ToString(),
ti.minute.ToString(),
ti.second.ToString());
}
}

/* ======================= Test Application =============================== */

// Test Application which implements the
// Clock Notifier - Subscriber Sample
public class Test
{
public static void Main()
{
// Create a new clock
Clock theClock = new Clock();

// Create the display and tell it to
// subscribe to the clock just created
DisplayClock dc = new DisplayClock();
dc.Subscribe(theClock);

// Create a Log object and tell it
// to subscribe to the clock
LogClock lc = new LogClock();
lc.Subscribe(theClock);

// Get the clock started
theClock.Run();
}
}
}

Conclusion

The Clock class from the last sample could simply print the time rather tahn raising an event, so why bother with the introduction of using delegates? The advantage of the publisg / subscribe idiom is that any number of classes can be notified when an event is raised. The subscribing classes do not need to know how the Clock works, and the Clock does not need to know what they are going to do in response to the event. Similarly a button can publish an Onclick event, and any number of unrelated objects can subscribe to that event, receiving notification when the button is clicked.

The publisher and the subscribers are decoupled by the delegate. This is highly desirable as it makes for more flexible and robust code. The clock can chnage how it detects time without breaking any of the subscribing classes. The subscribing classes can change how they respond to time changes without breaking the Clock. The two classes spin indepentdently of one another, which makes for code that is easier to maintain.

overview of c#

The C# Overview contains a brief overview of the C# language, feature lists for the various C# versions, as well as a brief C# history.

Contents 1 Overview of the C# Language 2 C# design goals 3 C# 2.0 new language features 4 C# 3.0 new language features 5 A Brief History of C# 6 The Java Connection 7 See also

Overview of the C# Language

C# is an object-oriented programming language developed by Microsoft Corporation as part of their .NET initiative in response to the success of Sun Microsystems' Java programming language. C# source code—as well as those of other .NET languages—is compiled into an intermediate byte code called MSIL (Microsoft Intermediate Language. C# is primarily derived from the C, C++, and Java programming languages with some features of Microsoft's Visual Basic in the mix.
C# is used to develop applications for the Microsoft .NET environment. .NET offers an alternative to Java development. Microsoft's Visual Studio .NET development environment incorporates several different languages including ASP.NET, C#, C++, and J# (Microsoft Java for .NET), all of which compile to the Common Language Runtime.

C# design goals

According to the Introduction to the Standard ECMA-334 C# Language Specification:

As the definition of C# evolved, the goals used in its design were as follows:

• C# is intended to be a simple, modern, general-purpose, object-oriented programming language.
• The language, and implementations thereof, should provide support for software engineering principles such as strong type checking, array bounds checking, detection of attempts to use uninitialized variables, and automatic garbage collection. Software robustness, durability, and programmer productivity are important.
• The language is intended for use in developing software components suitable for deployment in distributed environments.
• Source code portability is very important, as is programmer portability, especially for those programmers already familiar with C and C++.
• Support for internationalization is very important.
• C# is intended to be suitable for writing applications for both hosted and embedded systems, ranging from the very large that use sophisticated operating systems, down to the very small having dedicated functions.
• Although C# applications are intended to be economical with regard to memory and processing power requirements, the language was not intended to compete directly on performance and size with C or assembly language.

C# 2.0 new language features

New Features in C# 2.0 - twelve "labs" which cover only the new C# 2.0 features.

• A new form of iterator employs co-routines via a functional-style yield keyword similar to the one found in the Python language.
• Anonymous methods provide closure functionality.
• Generics or parameterized types support some features not supported by C++ templates such as type constraints on generic parameters. However, expressions cannot be used as generic parameters as in C++ templates. In contrast to the Java implementation, parameterized types are first class objects in the virtual machine, allowing for optimizations and preservation of type information.
• Nullable value types facilitate interaction with SQL databases. Sample nullable type declaration:

  int? variableName = null;

• Partial types allow the separation of a class implementation into more than one source file. This feature was implemented primarily so Visual Studio generated code can be kept seperate from developer code.

C# 3.0 new language features

C# version 3.0 introduces several language extensions to support higher order, functional style class libraries. The extensions enable the construction of compositional APIs with the expressive power of query languages in areas such as relational databases and XML. C# 3.0 will include the following new features:

• Anonymous types: tuple types automatically inferred and created from object initializers.
• Object initializers ease construction and initialization of objects.
• Implicitly typed local variables permit the type of local variables to be inferred from the expressions used to initialize them.
• Implicitly typed arrays: a form of array creation and initialization that infers the element type of the array from an array initializer.
• Extension methods make it possible to extend existing types and constructed types with additional methods.
• Lambda expressions: an evolution of anonymous methods providing improved type inference and conversions to both delegate types and expression trees.
• Expression trees permit lambda expressions to be represented as data (expression trees) instead of as code (delegates).
• Query expressions provide a language integrated syntax for queries that is similar to relational and hierarchical query languages such as SQL and XQuery.

Microsoft C# developers note that C# 3.0 is bytecode compatible with C# version 2.0. For the most part, enhancements comprise purely syntactic or compile-time improvements. For example, many of the most common integrated queries can already be implemented using anonymous delegates in combination with predicate-based container methods such as List.FindAll and List.RemoveAll.

A Brief History of C#

C# was designed for developing components in a fully object-oriented manner as part of the Microsoft .NET initiative. C# debuted in the year 2000 at the Professional Developers Conference (PDC) where Microsoft founder Bill Gates was the keynote speaker. At the same time, Visual Studio .NET was announced.
The primary architects of C# were Peter Golde, Eric Gunnerson, Anders Hejlsberg, Peter Sollichy, and Scott Wiltamuth. Of these, the principal designer of the the C# language was Anders Hejlsberg, a lead architect at Microsoft. Previously, he was a framework designer with experience with Visual J++ (Microsoft's old version of the Java language), Delphi, and Turbo Pascal.
Both C# and the Common Language Infrastructure (CLI) have been submitted to international standards organizations European Computer Manufacturers Association (ECMA) and International Organization for Standardization (ISO) / International Electrotechnical Commission (IEC).

The Java Connection

You will find that many C# books and sources ignore or minimize the role of the Java language in the development of C# and .NET, as if it were all Microsoft's original idea. This view is prevalent in exclusively Microsoft shops. However, the fact is that Microsoft was a latecomer to Internet development and the oft cited pedigree of C# from C and C++ applies equally well to the Java language, which preceded C# by some five years. Microsoft and Sun Microsystems have a long history of legal struggle over control of the Java language, a battle which Sun finally won. Prevented from adapting the Java language to the Windows platform, Microsoft decided to go its own way using its own version of the Java system—namely C# and .NET. The influence of the Java language on C# and other languages takes nothing away from C#, which in some ways improves upon its ancestor.