面试题与答案

abstract, event, new, struct, explicit, null, base, extern, object, this

There are no access restrictions. All can access the public instance from anywhere.

Access is restricted to within the containing class.

Static.

No

using System;
namespace Console1
{
class Class1
{
[STAThread] // No longer needed
static void Main(string[] args)
{
Console.WriteLine("Hello world");
}
}
}

Recursion is when a method calls itself.

A constructor performs initialisation for an object (including the struct type) or class.

A C# destuctor is not like a C++ destructor. It is actually an override for Finalize(). This
is called when the garbage collector discovers that the object is unreachable. Finalize()
is called before any memory is reclaimed.

Bool, char, int, byte, double

Unicode

Any changes to that string are in fact copies.

trim, tolower, toupper, concat, copy, insert, equals, compare.

Converting a value type (stack->heap) to a reference type (heap->stack), and viseversa.

// Boxing
int i = 4;
object o = i;
// Unboxing
i = (int) o;

There are 2 kinds of heap � 1: a chunk of memory where data is stored and 2: a tree
based data structure. When we talk about the heap and the stack we mean the first kind
of heap. The stack is a LIFO data structure that stores variables and flow control
information. Typically each thread will have its own stack.

A pointer is a reference to a memory address.

Initializes an object.

Unlike in C++ a struct is not a class � it is a value type with certain restrictions. It is
usually best to use a struct to represent simple entities with a few variables. Like a Point
for example which contains variables x and y.

sbyte -128 to 127, byte 0 � 255, short -32,768 to 32,767, int -2,147,483,648 to
2,147,483,647, ulong 0 to 18,446,744,073,709,551,615

switch (n)
{
case 1:
x=1;
break;
case 2:
x=2;
break;
default:
goto case 1;
}

Access is restricted to types derived from the containing class.

Access is restricted to types derived from the containing class or from files within the same assembly.

internal for a top level class, private for a nested one.

public

Void

Reference parameters reference the original object whereas value parameters make a
local copy and do not affect the original. Some example code is shown:
using System;
namespace Console1
{
class Class1
{
static void Main(string[] args)
{
TestRef tr1 = new TestRef();
TestRef tr2 = new TestRef();
tr1.TestValue = "Original value";
tr2.TestValue = "Original value";
int tv1 = 1;
int tv2 = 1;
TestRefVal(ref tv1, tv2, ref tr1, tr2);
Console.WriteLine(tv1);
Console.WriteLine(tv2);
Console.WriteLine(tr1.TestValue);
Console.WriteLine(tr2.TestValue);
Console.ReadLine();
}
static public void TestRefVal(ref int tv1Parm,
int tv2Parm,
ref TestRef tr1Parm,
TestRef tr2Parm)
{
tv1Parm = 2;
tv2Parm = 2;
tr1Parm.TestValue = "New value";
tr2Parm.TestValue = "New value";
}
}
}
class TestRef
{
public string TestValue;
}
The output for this is:
2
1
New value
New value

An overloaded method has multiple signatures that are different.

Yes

A delegate in C# is like a function pointer in C or C++. A delegate is a variable that calls
a method indirectly, without knowing its name. Delegates can point to static or/and
member functions. It is also possible to use a multicast delegate to point to multiple
functions.

Member function with a parameter
using System;
namespace Console1
{
class Class1
{
delegate void myDelegate(int parameter1);
static void Main(string[] args)
{
MyClass myInstance = new MyClass();
myDelegate d = new myDelegate(myInstance.AMethod);
d(1); // <--- Calling function without knowing its name.
Test2(d);
Console.ReadLine();
}
static void Test2(myDelegate d)
{
d(2); // <--- Calling function without knowing its name.
}
}
class MyClass
{
public void AMethod(int param1)
{
Console.WriteLine(param1);
}
}
}
Multicast delegate calling static and member functions
using System;
namespace Console1
{
class Class1
{
delegate void myDelegate(int parameter1);
static void AStaticMethod(int param1)
{
Console.WriteLine(param1);
}
static void Main(string[] args)
{
MyClass myInstance = new MyClass();
myDelegate d = null;
d += new myDelegate(myInstance.AMethod);
d += new myDelegate(AStaticMethod);
d(1); //both functions will be run.
Console.ReadLine();
}
}
class MyClass
{
public void AMethod(int param1)
{
Console.WriteLine(param1);
}
}
}

A reference type is known by a reference to a memory location on the heap.
A value type is directly stored in a memory location on the stack. A reference type is
essentially a pointer, dereferencing the pointer takes more time than directly accessing
the direct memory location of a value type.

System.String

Set it equal to null.

They check to see if the references both point to the same object.

False

public enum animals {Dog=1,Cat,Bear};

Yes

By default C# does not check for overflow (unless using constants), we can use
checked to raise an exception. E.g.:
static short x = 32767; // Max short value
static short y = 32767;
// Using a checked expression
public static int myMethodCh()
{
int z = 0;
try
{
z = checked((short)(x + y));
//z = (short)(x + y);
}
catch (System.OverflowException e)
{
System.Console.WriteLine(e.ToString());
}
return z; // Throws the exception OverflowException
}
This code will raise an exception, if we remove unchecked as in:
//z = checked((short)(x + y));
z = (short)(x + y);
Then the cast will raise no overflow exception and z will be assigned �2. unchecked can
be used in the opposite way, to say avoid compile time errors with constanst overflow.
E.g. the following will cause a compiler error:
const short x = 32767; // Max short value
const short y = 32767;
public static int myMethodUnch()
{
int z = (short)(x + y);
return z; // Returns -2
}
The following will not:
const short x = 32767; // Max short value
const short y = 32767;
public static int myMethodUnch()
{
int z = unchecked((short)(x + y));
return z; // Returns -2
}

No

as acts is like a cast but returns a null on conversion failure. Is comares an object to a
type and returns a boolean.

The new operator creates an instance of a class whereas the new modifier is used to
declare a method with the same name as a method in one of the parent classes.

typeof obtains the System.Type object for a type and sizeof obtains the size of a type.

Some operators have temporal properties depending on their placement. E.g.
double x;
x = 2;
Console.Write(++x);
x = 2;
Console.Write(x++);
Console.Write(x);
Returns
323

Private

No

Only one of them is run, that is the one marked (public) static, e.g:
public static void Main(string[] args)
{
//
// TODO: Add code to start application here
//
}
private void Main(string[] args, int i)
{
}

void and int

An out parameter allows an instance of a parameter object to be made inside a method.
Reference parameters must be initialised but out gives a reference to an uninstanciated
object.

using System;
namespace Console1
{
class Class1
{
static void Main(string[] args)
{
ParamsMethod(1,"example");
ParamsMethod(1,2,3,4);
Console.ReadLine();
}
static void ParamsMethod(params object[] list)
{
foreach (object o in list)
{
Console.WriteLine(o.ToString());
}
}
}
}

No

The main reason we use delegates is for use in event driven programming.

Asynchronous

Objects publish events to which other applications subscribe. When the publisher raises
an event all subscribers to that event are notified.

Yes, also - here's some code for a publisher with multiple subscribers.
using System;
namespace Console1
{
class Class1
{
delegate void myDelegate(int parameter1);
static event myDelegate myEvent;
static void AStaticMethod(int param1)
{
Console.WriteLine(param1);
}
static void Main(string[] args)
{
MyClass myInstance = new MyClass();
myEvent += new myDelegate(myInstance.AMethod);
myEvent += new myDelegate(AStaticMethod);
myEvent(1); //both functions will be run.
Console.ReadLine();
}
}
class MyClass
{
public void AMethod(int param1)
{
Console.WriteLine(param1);
}
}
}
Another example:
using System;
using System.Threading;
namespace EventExample
{
public class Clock
{
public delegate void TwoSecondsPassedHandler(object clockInstance,
TimeEventArgs time);
//The clock publishes an event that others subscribe to
public event TwoSecondsPassedHandler TwoSecondsPassed;
public void Start()
{
while(true)
{
Thread.Sleep(2000);
//Raise event
TwoSecondsPassed(this, new TimeEventArgs(1));
}
}
}
public class TimeEventArgs : EventArgs
{
public TimeEventArgs(int second)
{
seconds += second;
instanceSeconds = seconds;
}
private static int seconds;
public int instanceSeconds;
}
public class MainClass
{
static void Main(string[] args)
{
Clock cl = new Clock();
// add some subscribers
cl.TwoSecondsPassed += new
Clock.TwoSecondsPassedHandler(Subscriber1);
cl.TwoSecondsPassed += new
Clock.TwoSecondsPassedHandler(Subscriber2);
cl.Start();
Console.ReadLine();
}
public static void Subscriber1(object clockInstance, TimeEventArgs time)
{
Console.WriteLine("Subscriber1:" + time.instanceSeconds);
}
public static void Subscriber2(object clockInstance, TimeEventArgs time)
{
Console.WriteLine("Subscriber2:" + time.instanceSeconds);
}
}
}

Stack

Yes

When converting from a smaller numeric type into a larger one the cast is implicit. An
example of when an explicit cast is needed is when a value may be truncated.

Allocate a block of memory on the stack (used in unsafe mode).