How to Initialize Flags Enumerations in C#


I have a friend who is just starting to learn C#, so I am getting some interesting questions whose answers seem obvious to me but apparently not to beginners.  Today I answer the question: What’s the best way to initialize Flags enumerations in C#?

As a quick review, here is how Microsoft describes the Flags enumeration:  “You can use an enumeration type to define bit flags, which enables an instance of the enumeration type to store any combination of the values that are defined in the enumerator list.  (Of course, some combinations may not be meaningful or allowed in your program code.)  You create a bit flags enum by applying the System.FlagsAttribute attribute and defining the values appropriately so that AND, OR, NOT and XOR bitwise operations can be performed on them.”

In other words, each enumeration value must correspond to a single, unique bit.  So one way to initialize flags is to use integers that are a power of 2.  The disadvantage of this method is it’s not easy to see which bit is being set, and errors might creep in enumerations with many flags, especially when you start getting up into the range of 16384, 32768, 65536, and 131072.  But there is nothing inherently wrong with this approach either:

public enum DaysOfTheWeek
	None = 0,
	Sunday = 1,
	Monday = 2,
	Tuesday = 4,
	Wednesday = 8,
	Thursday = 16,
	Friday = 32,
	Saturday = 64,

Read the rest of this entry »

Google Considered C# as the Native Language for Android


Wow, I nearly fell out of my chair when I read this little gem on TechCrunch:

Android chief Andy Rubin wrote in a 2005 email, “If Sun doesn’t want to work with us, we have two options: 1) Abandon our work and adopt MSFT CLR VM and C# language – or – 2) Do Java anyway and defend our decision, perhaps making enemies along the way.”

Imagine how different the world would be today if Google had chosen .NET instead of Java as the native development framework for the Android mobile operating system…

Read more at DevTopics >>

C# Custom Enumerators Made Simple with the Yield Keyword


An enumerator enables you to iterate over a collection in a foreach loop.  You can use foreach to iterate over all C# collection classes, because all C# collection classes inherit from the IEnumerable interface (regular or generic).  IEnumerable contains the GetEnumerator method, which returns an enumerator.

Occasionally you may find a need to create a custom enumerator, which used to be somewhat of a challenge until the yield keyword was introduced.  Here is how Microsoft describes yield:

The yield keyword signals to the compiler that the method in which it appears is an iterator block.  The compiler generates a class to implement the behavior that is expressed in the iterator block.  In the iterator block, the yield keyword is used together with the return keyword to provide a value to the enumerator object.  This is the value that is returned, for example, in each loop of a foreach statement.

So rather than creating your own enumerator class and managing the enumeration state — which is time consuming and tricky — you can simply write the enumeration logic in the GetEnumerator method, and the yield keyword will automagically wrap your code in a handy-dandy enumerator.

Read the rest of this entry »

.NET Isn’t Dead


I jump into the controversy about the future of the .NET Framework and HTML5+JavaScript.

Read “.NET Isn’t Dead” on >>

Apparently C# Doesn’t Suck


YourLanguageSucks is a wiki on that lists reasons why the most popular programming languages suck.  There are long lists of reasons why Java, JavaScript, C++ and PHP suck.  But the list for C# is very short:

  • Supports ‘goto’.
  • Two distinct sets of collections: non-generic and generic.  Stack and Queue have the same name in both their generic and non-generic flavors, but then we have Hashtable (non-generic) and Dictionary (generic).

The first reason is easy to discount: just avoid using goto!  The second reason is valid, but not really an issue if you use only generic collections, as I do.

Read the rest on DevTopics >>

C# Internal Interface


When building a C# interface, you may find a need for both public and internal methods, such as:

public class MyClass : IMyInterface
    public void MyPublicMethod() { }
    internal void MyInternalMethod() { }
public interface IMyInterface
    public void MyPublicMethod();
    internal void MyInternalMethod();

Read the rest of this entry »

Where is PaddingF? And Other Padding Oddities

1 Comment »

There is No PaddingF

There is Point and PointF, Size and SizeF, Rectangle and RectangleF, Padding and… wait, there is no PaddingF!

System.Drawing vs. System.Windows.Forms

The 2-D drawing functions in the System.Drawing namespace accept both integer and floating point measurements.  That’s why the main 2-D drawing structures have both int and float versions such as Point and PointF, respectively.

However, the Padding structure is defined separately in the System.Windows.Forms namespace where most 2-D measurements are in integers.  Hence, there is an integer Padding structure but no floating point PaddingF.

Read the rest of this entry »

Vanity Guids


Do you notice anything odd about the following list?


Read the rest of this entry »

Rename a File in C#


If you want to rename a file in C#, you’d expect there to be a File.Rename method, but instead you must use the System.IO.File.Move method. 

You must also handle a special case when the new file name has the same letters but with difference case.  For example, if you want to rename “test.doc” to “Test.doc”, the File.Move method will throw an exception.  So you must rename it to a temp file, then rename it again with the desired case.

Here is the sample source code:

/// <summary> 
/// Renames the specified file. 
/// </summary> 
/// <param name="oldPath">Full path of file to rename.</param> 
/// <param name="newName">New file name.</param> 
static public void RenameFile( string oldPath, string newName ) 
    if (String.IsNullOrEmpty( oldPath )) 
        throw new ArgumentNullException( "oldPath" ); 
    if (String.IsNullOrEmpty( newName )) 
        throw new ArgumentNullException( "newName" );

    string oldName = Path.GetFileName( oldPath );

    // if the file name is changed 
    if (!String.Equals( oldName, newName, StringComparison.CurrentCulture )) 
        string folder = Path.GetDirectoryName( oldPath ); 
        string newPath = Path.Combine( folder, newName ); 
        bool changeCase = String.Equals( oldName, newName, StringComparison.CurrentCultureIgnoreCase );

        // if renamed file already exists and not just changing case 
        if (File.Exists( newPath ) && !changeCase) 
            throw new IOException( String.Format( "File already exists:n{0}", newPath ) ); 
        else if (changeCase)
            // Move fails when changing case, so need to perform two moves
            string tempPath = Path.Combine( folder, Guid.NewGuid().ToString() );
            Directory.Move( oldPath, tempPath );
            Directory.Move( tempPath, newPath );
            Directory.Move( oldPath, newPath );

C# TextBox Scroll to Cursor

No Comments »

To scroll a C# TextBox to the cursor/caret, it’s important that the TextBox is both visible and focused, then call the ScrollToCaret method:


To scroll to the bottom/end of a TextBox, set the SelectionLength to 0 to remove any selection, then set SelectionStart to the end of the text in the TextBox:

textBox.SelectionLength = 0;
textBox.SelectionStart = textBox.Text.Length;
keep looking »