C# Tutorial

Firstly, distributed computing is rather like object oriented programming, in that it encourages specialised code to be collected in one place, rather than copied redundantly in lots of places. There are thus potential efficiency gains to be made in moving to the distributed model.

Secondly, by collecting specialised code in one place and opening up a generally accessible interface to it, different types of machines (phones, handhelds, desktops, etc.) can all be supported with the same code. Hence Microsoft's 'run-anywhere' aspiration.

Thirdly, by controlling real-time access to some of the distributed nodes (especially those concerning authentication), companies like Microsoft can control more easily the running of its applications. It moves applications further into the area of 'services provided' rather than 'objects owned'.

Interestingly, in taking on the .NET vision, Microsoft seems to have given up some of its proprietary tendencies (whereby all the technology it touched was warped towards its Windows operating system). Because it sees its future as providing software services in distributed applications, the .NET framework has been written so that applications on other platforms will be able to access these services. For example, .NET has been built upon open standard technologies like XML and SOAP.

At the development end of the .NET vision is the .NET Framework. This contains the Common Language Runtime, the .NET Framework Classes, and higher-level features like ASP.NET (the next generation of Active Server Pages technologies) and WinForms (for developing desktop applications).

The Common Language Runtime (CLR) manages the execution of code compiled for the .NET platform. The CLR has two interesting features. Firstly, its specification has been opened up so that it can be ported to non-Windows platforms. Secondly, any number of different languages can be used to manipulate the .NET framework classes, and the CLR will support them. This has led one commentator to claim that under .NET the language one uses is a 'lifestyle choice'.

Not all of the supported languages fit entirely neatly into the .NET framework, however (in some cases the fit has been somewhat Procrustean). But the one language that is guaranteed to fit in perfectly is C#. This new language, a successor to C++, has been released in conjunction with the .NET framework, and is likely to be the language of choice for many developers working on .NET applications.

C# Tutorial For Beginners

First tutorial

You should first open a DOS command shell. (If you don't know what it is, clic on the Start menu then run (at the bottom) and type, in the text field: "cmd".
exercise: there is an easiest way to do that, try to find it.)
You should begin to work in an empty directory for this. let call it "C:\learncs". Type in the shell:
    > md C:\learncs
    > cd C:\learncs
    > C:
   
Now you should create your first C# program, type "notepad hello.cs" and type (in the notepad)
    using System;
 
    public class Hello
    {
        public static void Main()
        {
            Console.WriteLine("Hello C# World :-)");
        }
    }
   
the using keyword just let you write Console at line 7, instead of System.Console. It's very usefull shortcut when you use a lot of "class" define in System.
Save the file.
Now you could compile. Type in the DOS Shell again and type:
  csc /nologo /out:hello.exe hello.cs
You probaly have some errors, correct them, compile again, and now you have a working hello.exe program... type hello, see...

Second tutorial

  Congratulation you've done the most difficult, let increase the difficulty. and create an object instance. in the DOS shell create a new directory:
    > md ..\learncs2
    > cd ..\learncs2
    > notepad hello.cs
   
and then type, in the notepad
    using System;
 
    public class Echo
    {
        string myString;
       
        public Echo(string aString)
        {
            myString = aString;
        }
      
        public void Tell()
        {
            Console.WriteLine(myString);
        }
    }
       
    public class Hello
    {
     public static void Main()
     {
            Echo h = new Echo("Hello my 1st C# object !");
            h.Tell();
     }
    }
   
Wouah, 25 lines! That's a program! Save it, compile it, run it...
What happened? csc look for a Main() function in your program, it should find one (and only one) and it will be the entry point of your program.
In this tutorial we create 2 classes: Echo & Hello. In the Main() method you create an Echo object (an instance of the Echo class) with the keyword new
Then we called the instance method "Tell()".
the upper case letter on class or Method is just a MS convention, do as it pleased you.
public is a visibility access, method wich are not public could not be seen from outside, there is also other visibility keywords, to learn more, clic on Start menu-> Programs -> Microsoft .NET Framework SDK -> Documentation there is a search window, an index window, etc... try to learn more about public private protected.

Third tutorial

Now you become to be pretty confident, I guess, so we could start using multiple file, and even a dll ? go into an other directory (or stay in this one, I won't mind) and create 2 file:

hello.cs
    using System;
   
    public class Hello
    {
     public static void Main()
     {
         HelloUtil.Echo h = new HelloUtil.Echo("Hello my 1st C# object !");
            h.Tell();
     }
    }
   
echo.cs
    using System;
   
    namespace HelloUtil
    {
        public class Echo
        {
            string myString;
           
            public Echo(string aString)
            {
                myString = aString;
            }
           
            public void Tell()
            {
                Console.WriteLine(myString);
            }
        }
    }
   
Note in hello.cs I have used the syntax "HelloUtil.Echo" it's because Echo is in the namespace HelloUtil, you could have typed (at he start of the file) using HelloUtil and avoid HelloUtil., that's the way namespace work.
Now you could compile both in one .exe with
  > csc /nologo /out:hello.exe *.cs
But it's not my intention, no.
Well.
(Have you tried?)
Let's go building a DLL:
  > csc /nologo /t:library /out:echo.dll echo.cs
that's it (dir will confirm).
Now we could use it ...
  > csc /out:hello.exe /r:echo.dll hello.cs
if you typed "hello" it will worked as usual..., but if you delete "echo.dll" the program will now crash: it use the DLL. You could also change Echo.cs, rebuild the DLL and see... that's the advantage of DLL!

You could also put your DLL in the global assembly cache (GAC), and any program would be able to access it, even if the DLL is not in its directory!
to put it in the GAC, I sugest you read MS doc but here are the unexplained step:

create your assembly key, create it once and use it for every version. you create it with:
  sn -k myKeyName.snk
the .snk file should be in your compilation directory (the one where your run csc)
create a strong asssembly title by adding in any .cs source file the following directive at top level:
    using System.Reflection; 
    using System.Runtime.CompilerServices;
    [assembly: AssemblyTitle("My Lib Title")]
    [assembly: AssemblyVersion("1.2.3.4")]
    [assembly: AssemblyKeyFile("myKeyName.snk")]
   
now add it to the GAC:
  > gacutil.exe /if myLib.dll
By the way, did I tell you ? when I referenced the hello.dll while compiling, remember? csc /out:hello.exe /r:echo.dll hello.cs, it could have been any assembly, even a .exe !!!

Fourth tutorial

  Congratulation you would soon be able to hack CsGL but there is one last step you should understand : interop (with C code).
You will need a C compiler, I advise gcc for windows called MinGW, it's free, it's good, it's GCC!
We will create 3 file:
echo.c
    #include <stdio.h>
   
    #define DLLOBJECT __declspec(dllexport)
   
    DLLOBJECT void writeln(char* s)
    {
        printf("%s\n", s);
    }
   
echo.cs
    using System;
    using System.Runtime.InteropServices;
   
    namespace HelloUtil
    {
        public class Echo
        {
            [DllImport("echo.native.dll", CallingConvention=CallingConvention.Cdecl)]
            static extern void writeln(string s);
           
            string myString;
           
            public Echo(string aString)
            {
                myString = aString;
            }
           
            public void Tell()
            {
                writeln(myString);
            }
        }
    }
   
hello.cs
    using System;
    using HelloUtil;
   
    public class Hello
    {
     public static void Main()
     {
      Echo h = new Echo("Hello my 1st interop code !");
      h.Tell();
     }
    }
   
Hehe, here you discover a completly new thing, Attribute.
"[DllImport(.." is an attribute.
You could tag any method/field/class with any number of attribute.
They generate extra information that could be used by anyone who could understand them.
This DllImport attribute is understand by the compiler and told him that the function below is in fact in a DLL whose name is "echo.native.dll". I add a calling convention parameter as the default .NET calling convention is __stdcall whereas, in C, it's __cdecl.
By the way, if you look for DllImport in the documentation, look for DllImportAttribute, because you remove "Attribute" to attribute classname when using them, it's like this.
And now let's compile this!

    > csc /nologo /t:library /out:echo.dll echo.cs
    > csc /nologo /out:hello.exe /r:echo.dll hello.cs
    >
    > rem "if the following line don't work, read bellow.."
    > gcc -shared -o echo.native.dll echo.c
    > strip echo.native.dll
   
the 2 last line (the gcc & strip command) are for building the "C-DLL".
If they don't work maybe gcc is not in a directory listed in your path environment variable ? check with:
  %lt; echo %PATH%
Well it's probably not,anyway, so type, assumin mingc is in C:\MinGW:
  set PATH=C:\MinGW;%PATH%
And try again... you sure it's not a syntax error ?
If it compile test it now: hello
Great isn't it ?
Now I should admit I didn't tell you all the truth. echo.dll and echo.native.dll are not the same kind of DLL. It's not just the language (C / C#) the C one is a plain executable full of, probably, x86 instruction, whereas the C# one is what MS call a portable executable.. anyway they are different.
If you install echo.dll in the GAC it wont work because it won't find echo.native.dll except if you put in into the PATH (like C:\Windows\System32).
In the same manner when you add the reference in VS.NET echo.native.dll is overlooked and your program won't work....
So either put the native one in your path or copy it in the debug/release directory of VS.NET.
Or do everything by hand (makefile? build.bat?) and put all your dll in you build directory, and everything work fine..

A collection of c# tutorials

C# Tutorials 
Look under sections "C# Language", and "Windows Programming Using C#" for some great C# tutorials. C# syntax and language essentials, OOP with C#, Winforms, and File handling operations are all covered. 
 
MSDN Visual C# Development Center 
The Microsoft Visual C# Dev Center has tons of great links, downloads, blogs, and anything else you may need. 
 
C# Tutorial 
Very large single page tutorial with excercises and sample code. Topics include a hello world app, C# syntax, error handling, and object oriented programming. 
 
C# Example Programs 
Download and reference Chilkat's C# examples for samples on mail, encryption, and more. 
 
C# Web Services 
Nice smaller single page web service tutorial. Link at bottom to download the entire tutorial with source code. 
 
MasterCSharp.com Tutorials 
Tutorials include writing your first hello world program, namespaces, and properties. 
 
C# Language Reference 
Msdn's C# language reference pages. Learn about namespaces, structs, classes, interfaces, conversions and more. 
 
Windows Forms Quickstart Tutorials 
Quickstart tutorial covering winforms from Microsoft. Tutorials and C sharp code samples available in VB.Net as well. 
 
Hitmill C# Tutorials 
Remoting, reflection, multithreading, file manipulations, and creating a simple winform are all covered.