C# Frequently Asked Questions : C# Language and Compiler

Where can I find design and coding guidelines for .NET?

CSharpFAQ — Mon, 21 Feb 2005 21:30:00 GMT

tipu_77 asked "What are microsoft suggested naming conventions in C#?"

The .NET Framework Team collects their recommendations at their

GotDotNet community site.

which points to a fairly comprehensive MSDN page

Design Guidelines for Class Library Developers.

which includes the section Naming Guidelines

[Author: SantoshZ]

What does the /target: command line option do in the C# compiler?

CSharpFAQ — Sun, 05 Dec 2004 07:33:00 GMT

All the /target: options except module create .NET assemblies. Depending on the option, the compiler adds metadata for the operating system to use when loading the portable executable (PE) file and for the runtime to use in executing the contained assembly or module.

module creates a module. The metadata in the PE does not include a manifest. Module/s + manifest make an assembly - the smallest unit of deployment. Without the metadata in the manifest, there is little the runtime can do with a module.

library creates an assembly without an entry point, by setting the EntryPointToken of the PE's CLR header to 0. If you look at the IL, it does not contain the .entrypoint clause. The runtime cannot start an application if the assembly does not have an entry point.

exe creates an assembly with an entry point, but sets the Subsystem field of the PE header to 3 (Image runs in the Windows character subsystem - see the _IMAGE_OPTIONAL_HEADER structure in winnt.h). If you ILDASM the PE, you will see this as .subsystem 0x0003. The OS launches this as a console app.

winexe sets the Subsystem field to 2. (Image runs in the Windows GUI subsystem). The OS launches this as a GUI app.

[Author: SantoshZ]
See also:
Chapter 3 of Inside Microsoft .NET IL assembler (Serge Lidin, Microsoft Press)
Metadata and the PE File Structure at MSDN
An In-Depth Look into the Win32 Portable Executable File Format - Part 1 and Part 2 (Matt Pietrek, MSDN Magazine)

What is the difference between const and static readonly?

CSharpFAQ — Sat, 04 Dec 2004 01:13:00 GMT

The difference is that the value of a static readonly field is set at run time, and can thus be modified by the containing class, whereas the value of a const field is set to a compile time constant.

In the static readonly case, the containing class is allowed to modify it only

in the variable declaration (through a variable initializer)
in the static constructor (instance constructors, if it's not static)

static readonly is typically used if the type of the field is not allowed in a const declaration, or when the value is not known at compile time.

Instance readonly fields are also allowed.

Remember that for reference types, in both cases (static and instance) the readonly modifier only prevents you from assigning a new reference to the field. It specifically does not make immutable the object pointed to by the reference.

class Program

{

public static readonly Test test = new Test();

static void Main(string[] args)

{

test.Name = "Program";

test = new Test(); // Error: A static readonly field cannot be assigned to (except in a static constructor or a variable initializer)

}

class Test

{

public string Name;

}

On the other hand, if Test were a value type, then assignment to test.Name would be an error.

How do I create a constant that is an array?

CSharpFAQ — Fri, 03 Dec 2004 20:33:00 GMT

Strictly speaking you can't, since const can only be applied to a field or local whose value is known at compile time.

In both the lines below, the right-hand is not a constant expression (not in C#).

const int [] constIntArray = newint [] {2, 3, 4};
 // error CS0133: The expression being assigned to 'constIntArray' must be constant
const int [] constIntArrayAnother = {2, 3, 4};
 // error CS0623: Array initializers can only be used in a variable or field
 //               initializer. Try using a new expression instead.

However, there are some workarounds, depending on what it is you want to achieve.

If want a proper .NET array (System.Array) that cannot be reassigned, then static readonly will do for you.

static readonly int [] constIntArray = new int[] {1, 2, 3};

The constIntArray field will be initialized before it its first use.

If, on the other hand, you really need a const set of values (say as an argument to an attribute constructor), then - if you can limit yourself to integral types - an enum would serve you well.

For example:

[Flags]
public enum Role
{
	Administrator = 1,
	BackupOperator = 2,
	// etc. 
}

public class RoleAttribute : Attribute
{
	public RoleAttribute()
	{
		CreateRole = DefaultRole;
	}

	public RoleAttribute(Role role)
	{
		CreateRole = role;
	}

	public Role CreateRole
	{
		get { return this.createRole; }
		set { this.createRole = value; }
	}

	private Role createRole = 0;
	public const Role DefaultRole = Role.Administrator
	 | Role.BackupOperator;
}

[RoleAttribute(RoleAttribute.DefaultRole)]
public class DatabaseAccount
{
	//.............. 
}

RoleAttribute, instead of taking an array, would only take a single argument of flags (appropriately or-ed). If the underlying type of the Role enum is long or ulong, that gives you 64 different Roles.

[Author: SantoshZ]

How to keep a local variable in scope across a try and catch block?

CSharpFAQ — Fri, 13 Aug 2004 01:33:00 GMT

The following code won't work, because conn goes out of scope before you enter the catch block.

try

{

Connection conn = new Connection();

conn.Open();

}

catch

{

if (conn != null) conn.Close();

}

The fix is simple - just declare conn before entering the try block

Connection conn = null; // Note the assignment to null to avoid error CS0165 - Use of possibly unassigned local variable 'conn'.

try

{

conn = new Connection();

conn.Open();

}

catch

{

if (conn != null) conn.Close();

}

Of course, for this particular example, you could wrap the Connection class in one that implements IDisposable (if it does not already), so that you could then use a using statement instead of extending the scope of the local.

[author: SantoshZ]

Why does my switch statement works differently?

CSharpFAQ — Fri, 23 Jul 2004 03:50:00 GMT

C# does not support an explicit fall through for case blocks (unless the block is empty)

For an explanation of why, see Why is the C# switch statement designed to not allow fall through, but still require a break? on MSDN

The following code is not legal and will not compile in C#:

switch (x)
{
case 0:
Console.WriteLine(x)
// do something
case 1:
Console.WriteLine(x)
// do something in common with 0
default:
Console.WriteLine(x)
// do something in common with 0, 1 and everything else
break;
}

In order to achieve the same effect in C# the code must be modified as shown below (notice how the control flows are very explicit):

class Test
{static void Main()
{
int x = 3;
 
switch (x)
{
case 0:
// do something
goto case 1;
case 1:
// do something in common with 0
goto default;
default:
// do something in common with 0, 1, and anything else
break;
}
}
}

Why does C#'s iterators feature spit out a class definition instead of a struct definition?

CSharpFAQ — Tue, 20 Jul 2004 17:30:00 GMT

Q: Why does C#'s iterators feature spit out a class definition instead of a struct definition?

The iterators feature in C# generates classes that implement the enumerators required. This is detailed in the C# Specification. Why doesn't it use structs, which would be more efficient.

There are two reasons.

(1) Naming. We generate classes that implement the enumerator interfaces and then use only the interface types in the public protocol. That way the names of the generated classes are purely an implementation detail. This is highly desirable from a versioning perspective. With a struct-based implementation, to get any of the efficiencies associated with structs we would have to use their types in the public protocol (using interfaces the structs would just get boxed). That in turns means we'd have to invent a name mangling scheme for the structs. In particular, iterators returning IEnumerable<T> would be complicated because a type could have multiple such members that differ only in their parameter list, meaning that the parameter list would have to be part of the mangled name.

(2) Structs don't work in recursive cases. For example, a TreeNode type could implement an iterator that recursively iterates first the left and then the right subtrees by foreach-ing contained members that are also of type TreeNode. With a struct-based implementation this would translate into an enumerator struct that contains a field of its own type--which isn't possible. (Think of it this way: A foreach statement obtains an enumerator and stores that in a local variable. In iterators, local variables are transformed into fields in the enumerator. A recursive iterator would therefore create a struct with a member of its own type.) You could argue that we can detect whether or not iterators are recursive and adjust our code generation scheme accordingly. However, you then end up with a versioning problem when a previously non-recursive iterator changes its (supposedly private) implementation to become recursive.

Anders (via Eric)

How do I cast a string to an int, float, double, etc?

CSharpFAQ — Sun, 30 May 2004 19:08:00 GMT

You can use the Convert class or the Parse method of the built-in type you are casting to. i.e.

    string myStr = "123";
    int myParsedInt = Int32.Parse(myStr);
    int myConvertedInt = Convert.ToInt32(myStr);

This example uses the int type, but you can also use the same techniques for any of the other integral or floating point types.

[Author: Joe Mayo]

How are return values from a delegate handled?

CSharpFAQ — Thu, 27 May 2004 22:50:00 GMT

Q: How are multiple return values from a delegate handled?

In C#, it's possible to write a delegate such as:

delegate double GetResult(params double p);

If there is more than one method on this delegate, there are multiple return values.

A: In this situation, the return value is the value that is returned from the last delegate.

If you want more control on this, you can call GetInvocationList() on the delegate, which will allow you to call each method individually, and process the double values appropriately.

[Author: Eric Gunnerson]

Why can't I use the same variable as an inner loop does?

CSharpFAQ — Tue, 18 May 2004 21:59:00 GMT

Q: Why can't I do the following:

namespace Bug

{

class Class1

{

[STAThread]

static void Main(string[] args)

{

for(int i=0; i<100; i++)

{

}

int i = 0;

}

the compiler gives me an error on the “int i = 0;” part of the code.

A: This is correct behavior, and is covered in section 3.7 of the language spec. It says, “The scope of a local variable declared in a local-variable-declaration (8.5.1) is the block in the which the declaration occurs”.

The scope of i is therefore the entire Main() function, and that means that the use in the for loop is a re=use, and therefore is not allowed.

This behavior is inteded to make incorrect re-use of variable names (such as in a cut and paste) less likely.

[Author: Eric Gunnerson]

How do I write a method that accepts a variable number of parameters?

CSharpFAQ — Thu, 13 May 2004 22:44:00 GMT

Q: How do I write a method that accepts a variable number of parameters?

A: Languages like C and C++ have always offered some means for using and creating functions capable to accept a variable number of parameters. The most widely known example of a function which takes a variable number of parameters is printf():

int printf(char *format, …); // the ellipsis means "variable number of params"

Using this function is pretty easy:

printf("Hello, world\n");

printf("The sum of %d and %d is %d\n", a, b, a+b);

However, the creation of such functions in these languages relays on a set of predefined macros and is not particularly elegant or intuitive.

C# offers an elegant solution to this problem through parameter arrays. A parameter array is a single-dimensional array included as the last parameter in the parameter list of a method:

public string Concat(string separator, params string[] strings)

{

string result = "";

for (int i = 0; i < strings.Length; i++)

{

if (i > 0)

result += separator;

result += strings[i];

}

return result;

}

Such a function can be called in two different ways:

a) Passing the function an array instance argument:

string[] names = { "Anders", "Eric", "Scott", "Duncan" };

MessageBox.Show(Concat("+", names) + " = great team");

b) Using zero or more type-compatible arguments for the parameter array:

MessageBox.Show(Concat("+", "Anders", "Eric", "Scott", "Duncan") +

" = great team");

In this case, the invocation will create an array from the supplied arguments and use it as the actual argument.

Thanks to the unified .NET type system, object[] can be used as “common denominator” for arguments of different types:

public int SumTheIntegers(params object[] list)

{

// sum all the integers included in list

int sum = 0;

foreach (object o in list)

if (o.GetType() == typeof(int))

sum += (int) o;

return sum;

}

[Author: Octavio "Dave" Hernandez]

Why doesn't C# support static method variables?

CSharpFAQ — Wed, 12 May 2004 04:41:00 GMT

Q: In C++, it's possible to write a static method variable, and have a variable that can only be accessed from inside the method. C# doesn't provide this feature. Why?

A: There are two reasons C# doesn't have this feature.

First, it is possible to get nearly the same effect by having a class-level static, and adding method statics would require increased complexity.

Second, method level statics are somewhat notorious for causing problems when code is called repeatedly or from multiple threads, and since the definitions are in the methods, it's harder to find the definitions.

[Author: Eric Gunnerson]

Why must attribute properties be read/write in C#?

CSharpFAQ — Wed, 12 May 2004 04:16:00 GMT

Q: Why must attribute properties be read/write in C#?

In the C# language, when you define an attribute class, you can define both constructor arguments and properties. For example:

class MyAttribute: Attribute
{
    string name;
    int number;
    public MyAttribute(string name) { this.name = name;}
    public int Number
    {
        get {return number;}
        set {number = value; }
    }
    public string Name
    {
        get {return name;}
    }
}
[My("Fred", Number=5)]
class Fred
{
}

When you do this, C# requires that properties (such as Number in this example) be read/write properties, though languages such as VB.NET only require them to be readable.

Why?

A: Using an attribute in C# is logically equivalent to calling the constructor of the attribute class, and then executing the “property = value” part for each named property. Requiring a writeable property is consistent with this view.

Author: Eric Gunnerson

Why do I get the error "Object reference not set to an instance of an object"?

CSharpFAQ — Fri, 07 May 2004 04:01:00 GMT

The code is trying to access a member of a reference type variable that is set to null.

Given the following class, let's examine some code that could be in the Main method:

using System;

class Foo
{
 static void Main()
 {
  // foo has not been instantiated
  Foo foo = null;

  // implementation to be discussed...
 }

 public int BarProperty
 {
  get { return 0; }
 }

 public string BarMethod() 
 {
  return null;
 }
}

Looking at Main, notice that foo is set to null. Your situation will not be this explicit because the variable you are trying to use could be a class field, parameter, or local variable that was once instantiated but was subseqently set to null. Given that foo is null, the following code will throw a NullReferenceException:

  try
  {
   // foo is null, and you can't call
   // BarProperty on null.
   int resultBad = foo.BarProperty;
  }
  catch (NullReferenceException nre)
  {
   Console.WriteLine(
    "\nCan't read BarProperty, foo is null.\n" + 
    nre.Message);
  }

Since foo is null, you can not use its members. This was a property, but the following code demonstrates calling a method:

  try
  {
   // foo is null, and you can't call
   // BarMethod on null.
   foo.BarMethod();
  }
  catch (NullReferenceException nre)
  {
   Console.WriteLine(
    "\nCan't call BarMethod(), foo is null.\n" + 
    nre.Message);
  }

The code above throws a NullReferenceException because foo is still null. It doesn't matter that the first call was a property and the second is a method - they are both members of the type.

Now, to fix this problem, you must ensure that foo is instantiated before it is used. The following code instantiates foo and the previous problems are solved:

  // now we have an instance
  foo = new Foo();

  // works fine
  int resultGood = foo.BarProperty;

Since foo now refers to a valid instance, the code can call any of its members. This was easier than many null reference problems. Sometimes you have multiple levels of indirection, leaving you with a scenario you didn't expect. Assuming that foo now references an object, there is still a problem with the following code:

  try
  {
   // still breaks because BarMethod() returned
   // null and you can't call Trim() on null.
   foo.BarMethod().Trim();
  }
  catch (NullReferenceException nre)
  {
   Console.WriteLine(
    "\nCan't call Trim(), BarMethod() returns null.\n" + 
    nre.Message);
  }

The problem occurs in the code above because BarMethod returned null, which means that the code is trying to call the Trim method on a string reference that is set to null.

The proper way to fix this problem is to debug BarMethod to find out why it returned null. That assumes BarMethod is not supposed to return null. If, in your application, it made sense for BarMethod to sometimes return null, then you would have to check the return value of BarMethod before you called any members of the return value.

[Author: Joe Mayo]

Why did I receive the error: "The type or namespace '' does not exist in the class or namespace '' (are you missing an assembly reference?)"

CSharpFAQ — Thu, 29 Apr 2004 16:09:00 GMT

You need to add a reference in your project to an assembly where that namespace is defined.

If you are using VS.NET:

1. Right click on the References folder on your project.
2. Select Add Reference.
3. Select the .NET tab (or select the Browse button if it is not a .NET Framework assembly).
4. Double-click the assembly containing the namespace in the error message.
5. Press the OK button.

If you are using the command line, use the /r: or /reference: option. For Example:

csc.exe /reference:System.Drawing.dll MyFontDisplayApp.cs

When you recompile, this error will no longer appear.

You can find the assembly, where a namespace is defined, in the documentation. Identify one of the types in the namespace that you want to use. Every type in the .NET Framework has an "About" page that provides an overview, basic information about the type, and example code if you're lucky. At the bottom of the Overview, for all types, there is a "Requirements" section. This has a Namespace member that tells what namespace the type belongs to. It also tells what assembly type belongs to, which is the assembly you need to reference in your application. For example, if I had an application that was using Font types, I would look up Font in the .NET Framework documentation, using the Index tab, and observe that the Font type is in the System.Drawing namespace and its assembly is System.Drawing.dll.

Another question related to this is "If I've already declared a using statement, why do I have to add the reference to the project?"

The reason derives from the fact that the using statement and assembly references have two different purposes. Recall that the purpose of namespaces is to disambiguate type references and provide logical organization of types. When specifying a namespace in a using statement, you are telling C# that you want to use the types in that namespace in an unqualified manner. The key point is that namespaces are "logical" entities that could exist in one or more assemblies. On the other hand, assemblies are "physical" entities that contain multiple types. Assemblies are many things, but for the purposes of this discussion, an assembly is the unit of deployment in .NET. So, the reason you need a reference to the assembly that the type is located in is so that C# can find the physical location of that type, which is not possible with the logical namespace provided by a using statement.

[Author: Joe Mayo]