Out Of Memory

Hello World

2004-10-17T17:33:00.000-07:00

1. A Beginners Hello World

public class HelloWorld
{
public static void Main()
{
System.Console.WriteLine("HELLO WORLD");
}
}

2. Slightly improved version

using System;

public class HelloWorld
{
public static void Main()
{
Console.WriteLine("HELLO WORLD");
}
}

3. Command Line Arguments

using System;

public class HelloWorld
{
public static void Main(string[] args)
{
Console.WriteLine(args[0]);
}
}

4. From Constructor

using System;
public class HelloWorld
{
public HelloWorld()
{
Console.WriteLine("HELLO WORLD");
}

public static void Main()
{
HelloWorld hw = new HelloWorld();
}
}

5. More OO

using System;
public class HelloWorld
{
public void helloWorld()
{
Console.WriteLine("HELLO WORLD");
}

public static void Main()
{
HelloWorld hw = new HelloWorld();
hw.HelloWorld();
}
}

6. From another class

using System;
public class HelloWorld
{
public static void Main()
{
HelloWorldHelperClass hwh = new HelloWorldHelperClass();
hwh.writeHelloWorld();
}
}

public class HelloWorldHelperClass
{
public void writeHelloWorld()
{
Console.WriteLine("Hello World");
}
}

7. Inheritance

abstract class HelloWorldBase
{
public abstract void writeHelloWorld();
}
class HelloWorld : HelloWorldBase
{
public override void writeHelloWorld()
{
Console.WriteLine("Hello World");
}
}
class HelloWorldImp
{
static void Main() {
HelloWorldBase hwb = HelloWorld;
HelloWorldBase.writeHelloWorld();
}
}

8. Static Constructor

using System;
public class HelloWorld
{
private static string strHelloWorld;

static HelloWorld()
{
strHelloWorld = "Hello World";
}
void writeHelloWorld()
{
Console.WriteLine(strHelloWorld);
}

public static void Main()
{
HelloWorld hw = new HelloWorld();
hw.writeHelloWorld();
}
}

9. Exception Handling

using System;

public class HelloWorld
{
public static void Main(string[] args)
{
try
{
Console.WriteLine(args[0]);
}
catch(IndexOutOfRangeException e)
{
Console.WriteLine(e.ToString());
}
}
}

10. Creating a DLL and using it in an application

using System;

namespace HelloLibrary
{
public class HelloMessage
{
public string Message
{
get
{
return "Hello, World!!!";
}
}
}
}
------
using System;
using HelloLibrary;

namespace HelloApplication
{
class HelloApp
{

public static void Main(string[] args)
{
HelloMessage m = new HelloMessage();

}
}
}

11. Using Property

using System;
public class HelloWorld
{
public string strHelloWorld
{
get
{
return "Hello World";
}
}

public static void Main()
{
HelloWorld hw = new HelloWorld();
Console.WriteLine(cs.strHelloWorld);
}
}

12. Using Delegates

using System;
class HelloWorld
{
static void writeHelloWorld() {
Console.WriteLine("HelloWorld");
}
static void Main() {
SimpleDelegate d = new SimpleDelegate(writeHelloWorld);
d();
}
}

13. Using Attributes

#define DEBUGGING

using System;
using System.Diagnostics;

public class HelloWorld : Attribute
{
[Conditional("DEBUGGING")]

public void writeHelloWorld()
{
Console.WriteLine("Hello World");
}

public static void Main()
{
HelloWorld hw = new HelloWorld();

hw.writeHelloWorld();
}
}

14. Using Interfaces

using System;

interface IHelloWorld
{
void writeHelloWorld();
}

public class HelloWorld : IHelloWorld
{
public void writeHelloWorld()
{
Console.WriteLine("Hello World");
}

public static void Main()
{
HelloWorld hw = new HelloWorld();

hw.writeHelloWorld();
}
}

15. Dynamic Hello World

using System;
using System.Reflection;

namespace HelloWorldNS{

public class HelloWorld
{
public string writeHelloWorld()
{
return "HelloWorld";
}

public static void Main(string[] args)
{
Type hw = Type.GetType(args[0]);

// Instantiating a class dynamically

object[] nctorParams = new object[] {};
object nobj = Activator.CreateInstance(hw, nctorParams);//, nctorParams);

// Invoking a method

object[] nmthdParams = new object[] {};
string strHelloWorld = (string) hw.InvokeMember("writeHelloWorld", BindingFlags.Default | BindingFlags.InvokeMethod, null, nobj, nmthdParams);

Console.WriteLine(strHelloWorld);
}
}

16. Unsafe Hello World

using System;

public class HelloWorld
{
unsafe public void writeHelloWorld(char[] chrArray)
{
fixed(char *parr = chrArray)
{
char *pch = parr;
for(int i=0; iConsole.Write(*(pch+i));
}
}

public static void Main()
{
HelloWorld hw = new HelloWorld();
char[] chrHelloWorld = new char[] {'H','e','l','l','o', ' ', 'W','o','r','l','d'};
hw.writeHelloWorld(chrHelloWorld);
}
}

17. Using InteropServices

using System;
using System.Runtime.InteropServices;

class Class1
{
[DllImport("kernel32")]
private static extern int Beep(int dwFreq, int dwDuration);

static void Main(string[] args)
{
Console.WriteLine("Hello World");
Beep(1000, 2000);
}
}

C# Golden Words

2004-10-11T20:31:00.000-07:00

Naming and Accessibility: .NET Framework recommendation
-public should start with a capital letter(PascalCase)
-not public (which include local variables) should start with a lowercase letter(camelCase)

When you write your own class constructor, remember that the fields you don't initialize are still implicitly initialized to 0, false, or null. This often means you don't have to explicitly initialize all the fields.

-finally block can be put without a catch after

C# does not support default arguments. However, you can mimic default arguments using overloaded methods

-Don't declare two public class members whose names differ only in case. If you do, your class will not conform to the Common Language Specification (CLS), which is important for language interoperability. However, it's perfectly okay to declare two class members whose names differ only in case when only one of the members is public.

- Never create variables with underscores
- Never create two variables that differ by just cases
The above two would make the code incompatible to be used by other .Net languages

-Stack : parameters and local variables. Memory is automatically released
-Heap : objects when used new keyword. Memory is not relased automatically. OutOfMemoryException is thrown when memory is full and a new object is created.

-Can constructor thow exception. ??? Yes. A null reference is returned in such case

-unsafe keyword must be used for pointers. It can be used to mark a block of code, or an entire method
unsafe { swap (&x, &amp;amp;y); }
public static unsafe void swap(int *a, int *b){//pointers code}

- struct is a value type. Class is reference type
-If you declare your own constructor, will the compiler still write the default constructor? Yes for Struct and No for Class
-Are you allowed to initialize instance fields at their point of declaration? No for struct. Yes for class
-struct : a default consturctor is automatically created by complier and user should never create a default consutructor. In default constructor, all the fields are defaulted to 0, false or null. In non default consturctor, this will not happen for struct. However, for class defaults are created.

--In a class, you can initialize instance fields at their point of declaration. In a struct, you cannot.

C# - Code

2004-10-10T17:52:00.000-07:00

//Console
c:>csc /target:exe /out:HelloWorld.exe Hello.cs
c:>csc Hello.cs

//Win app
c:>csc /target:winexe /out:HelloWorld.exe Hello.cs

//Library DLL
c:>csc /target:library out:HelloWorld.dll hello.cs

int, long
float, double
decimal
bool
string
char

--

int amount = System.Int32.Parse(strNumber);

System.FormatException
System.DivideByZeroException

When there is not catch block in main, the common language runtime catches the exception and starts asking you questions about which debugger you want to use.
--
Using "checked" throws excepiton when an int overflows

int number = System.Int32.MaxValue;
checked
{
int willThrow = number++;
Console.WriteLine("this won't be reached");
}

int wontThrow = unchecked(System.Int32.MaxValue + 1); // doesn't throw exception
int willThrow = checked(System.Int32.MaxValue + 1); // throws over flow exception
--
public void Value(ref int param){}
Value(ref arg); //arg need to be initalized before utilized
--
public void Value(out int param){}
Value(arg);//arg need not be initalized before utilized
--