Home arrow C# arrow Page 3 - The Basics of C#: A "HelloWorld" Application
C#

The Basics of C#: A "HelloWorld" Application


C# is part of Microsoft's evolutionary .NET environment. It has collected the best features and aspects of many other programming languages including Visual Basic and C++. In this article James will show us how to create and compile a simple "HelloWorld" C# console application.

Author Info:
By: James Yang
Rating: 4 stars4 stars4 stars4 stars4 stars / 41
January 09, 2002
TABLE OF CONTENTS:
  1. · The Basics of C#: A "HelloWorld" Application
  2. · Hello World Example
  3. · HelloWorld source code explained
  4. · Simple C# language features
  5. · Conclusion

print this article
SEARCH DEVARTICLES

The Basics of C#: A "HelloWorld" Application - HelloWorld source code explained
(Page 3 of 5 )

The HelloWord sample we created on the last page is fairly elementary, yet precisely outlines the structure of a simple C# application:

using library_name;

namespace namespace_name

{

class class_name

{

static void Main([string[] args])

{

// Application code goes here

}

}

}


Let's take a look at what each these lines mean in relation to our C# application as a whole:

using library_name;

C# is based on the concept of using namespaces. Namespaces separate code into individually named-containers and avoids the chance of having duplicate variable names within the scope of a block. The "using" command allows us to specify which libraries namespaces we want access to. "using" commands are in no way similar to C++'s "#include" directive, and do not physically include any other source code into our file, they simply give us access to the namespaces available in the libraries that we have specified.

The "System" library contains the namespaces for all common .NET variables such as System.Int32 (which represents an integer) amongst other things.

Note: For any language to be compatible with .NET, it must provide implementations of the base .NET variable types. These include Int32, Int64, etc, C# provides its own version of these base variables in a form that resembles C++'s variable types: ushort, int, string, etc.

 If we reference the System library with a "using" command at the top of our source file like this:

using System;

... and want to create a new integer variable, then we don't need to explicitly declare Int32 as part of the System namespace, because we already have access to the system libraries namespace:

Int32 myNum = 10;

On the other hand, if we didn't include a "using" command to reference the system library, then we would have to explicitly specify which namespace the Int32 class resides in, like this:

System.Int32 myNum = 10;

Although .NET contains several pre-defined namespaces, we can create our own using a namespace block, like this:

namespace myNS

{

System.Int32 x = 10;

}


This would create a new namespace named "myNS" under the global section of our C# application. To reference the integer variable x from within our new "myNS" namespace, we would use the following syntax:

myNS.x;

To access variables, objects, or other namespaces (namespaces can be nested) from within a namespace, you call the namespaces in the order that they are nested and separate each one with a dot operator. If we have three nested namespaces like this:

namespace ns1

{

namespace ns2

{

namespace ns3

{

System.Int32 number;

}

}

}


... then we can retrieve the value of the "number" integer with a command like this:

ns1.ns2.ns3.number;

Although a namespace isn't required in our sample application, it helps to physically differentiate our code from any other code that might be present in the same source code file.

class class_name

{

}


Just like in C++, C# uses classes to facilitate its object-orientated design methodology. Classes allow us to create individual self-contained units of code, which can be instantiated throughout our application. All C# applications must contain at least one class. If we wanted to create a class named "myClass", then we would use the following commands:

class myClass

{

// Methods and members for this class go here

}


All C# applications must have a Main() function, which is the entry point for execution of the application:

static void Main([string[] args])

{

// Application code goes here

}


As you can see, the "string[] args" argument list is optional, and can be used to access the parameters passed to your executable from the command line. The Main() function is declared as public by default and can return either an integer variable type or nothing, with "void". To explicitly specify our Main() function as public and to return an integer variable, we would use the following Main() function:

public static int Main()

{

}


blog comments powered by Disqus
C# ARTICLES

- Introduction to Objects and Classes in C#, P...
- Visual C#.NET, Part 1: Introduction to Progr...
- C# - An Introduction
- Hotmail Exposed: Access Hotmail using C#
- Razor Sharp C#
- Introduction to Objects and Classes in C#
- Making Your Code CLS Compliant
- Programming with MySQL and .NET Technologies
- Socket Programming in C# - Part II
- Socket Programming in C# - Part I
- Creational Patterns in C#
- Type Conversions
- Creating Custom Delegates and Events in C#
- Inheritance and Polymorphism
- Understanding Properties in C#

Watch our Tech Videos 
Dev Articles Forums 
 RSS  Articles
 RSS  Forums
 RSS  All Feeds
Write For Us 
Weekly Newsletter
 
Developer Updates  
Free Website Content 
Contact Us 
Site Map 
Privacy Policy 
Support 

Developer Shed Affiliates

 




© 2003-2017 by Developer Shed. All rights reserved. DS Cluster - Follow our Sitemap
Popular Web Development Topics
All Web Development Tutorials