(How)
C^# You Are - 14 January 2007

1. How can you determine if a string is empty or not?  Answer

   The most efficient manner is to use the Length property of the string.  This requires a simple integer comparison.  You can use an empty string for comparison but this is more inefficient.  Surprisingly the compiler does not attempt to replace the string comparison in normal cases although the JIT process might.  Either of the above two methods will work but they will not detect the case of a string consisting of only spaces.  Normally such a string should also consider to be empty so you should call Trim first.

   In v2 the String class has a static method called IsNullOrEmpty that can be used in lieu of either of the above methods.  However it also will not handle a string containing just spaces so you will still need to call Trim.  Finally note that the method uses the first method given earlier as it is the more efficient version.

2. What is the difference between an empty string literal and the member String.Empty?  Answer

   There is no difference.  String.Empty is an empty string literal field.  This member is provided for languages that do not provide a convenient empty string literal.  For most languages (like C++ or C#) use the string literal instead.

3. What does the @ symbol do to a string literal in C#?  Answer

   The @ symbol specifies that the string contains no escape characters.  More specifically the compiler will skip the processing of any escape characters in the string.  This is great for specifying file paths or registry keys.

   string strLiteral1 = "C:\\Temp\\error.log";
   string strLiteral2 = @"C:\Temp\error.log";

   
   
4. What does the @ symbol do to an identifier?  Answer

   The @ symbol allows you to use a C# keyword as an identifier.  This is never a good idea although presumably the language developers must have had at least one good reason in mind.

   Employee old = ...;
   Employee @new = new Employee();

   
   
5. How do you define code conditionally at compile time?  Answer

   We are not talking about if statements here.  We are talking about the #if preprocessor token here.  This token is processed during compilation.  If the symbol is defined at compilation time then the encased code is compiled otherwise it is not.  Compile-time symbols are defined either through the command line or through the #define symbol. 

   #define DEBUG
   
   #if DEBUG
   public class MyDebug
   {
   }
   #else
   #endif

   
   

   These tokens are similar (although far less useful) to the C++ versions.  They are not recommended for general use.  Instead use the ConditionalAttribute.  The attribute can be applied to most types and members.  The attribute does basically the same thing as the preprocessor token.  The difference lies in the behavior of the compiler when the enclosed code is not included.

   [Conditional("DEBUG")]
   public class MyDebug
   {
   }

   
   

   If the condition is not met then the code is completely removed from the assembly during compilation.  With the attribute the code is always compiled and included in the assembly but is excluded at runtime if the condition was not met.  For debug, testing or tracing classes or members this is great as only one assembly need to be generated containing all the types or members but they will only be used if the condition is true when they are referenced later in the code.

6. How do you generate a warning during compilation?  Answer

   The #warning directive allows you to generate a compiler warning.  #error can be used to generate an error.  In both cases the compiler will generate the message when the line is hit during compilation.  You would need to use #if to conditionally include the message.

   #if TEST_CODE
   #warning This is test code.
   #endif

   
   
7. How do you mark a type or member as obsolete?  Answer

   You could use the #warning/#error directive but you should use the ObsoleteAttribute instead.  This attribute causes a type or member to generate a warning (or error) when it is referenced.  This attribute should be used to mark types or members that are obsolete.  Normally a type or member is marked as obsolete and a reference is given to the replacement type or member.  Any references to the type or member will generate a warning at compile time.  After a few releases the member can be removed or the attribute modified to generate an error.

   [Obsolete("This class is obsolete.  Use Debug instead.")]
   public static class MyDebug
   {
   }

   
   
8. What happens if you overflow an integer value in C#?  How about a float?  A decimal?  Answer

   By default an integer will simply roll over the results (in the case of additional the value will become negative).  You can change this either programmatically or through the compiler options.  When checking for overflow (not the default) an OverflowException will be thrown instead.

   int value1 = Int32.MaxValue;
   int value2 = value1 + 1;

   Note that the compiler will detect cases of overflow when dealing with constant expressions (such as Int32.MaxValue + 1).  Floats will be set to a infinity (positive or negative) in all cases.  Decimals will always throw an OverflowException.

9. A decimal?  What is that type used for?  Answer

   A Decimal is used for large, precise numbers such as scientific calculations or financial calculations.  Refer to MSDN for the minimum and maximum values.

10. What is an interned string?  Answer

    An interned string (identified by the IsIntern method) specifies a string that is stored in the CLR's string pool.  Each string in .NET is stored only once.  Subsequent strings with the same value use the same reference (pointer) value.  The IsIntern method determines if a string is already contained in the pool.  This method is always used with a string literal as passing a string reference would always return true.