Things in C# you might have missed

http://fekberg.com/2012/09/18/things-in-c-you-might-have-missed/

by knasteddy • 14 years ago

18 11 14 years ago

gjulianm2• 14 years ago

C# has a lot of these little things, that can make you struggle until you discover them.

But beware with yield-return, you have to be very conscious of the execution model of LINQ. Take for example this piece of code:

    IEnumerable<string> Readlines(Stream io)
    {
        while(io.CanRead)
        {
           io.Read(buffer, 0, bufferLength)
           ... do things with buffer and get a line...
           yield return line;
        }
    }
    
    IEnumerable<string> ReadFileLines(string filename)
    {
        IEnumerable<string> lines
        using(FileStream file = new FileStream(filename))
        {
           lines = ReadLines(file);
        }
        return lines;
    }

This would always fail and throw an exception. Why? When you call ReadLines, the actual object that is returned is not the list of strings. ReadLines is not executed until that list is not enumerated. ReadFileLines opens the stream, passes it as an argument and then closes the stream. When you enumerate that list, ReadLines will start and try to access a closed stream, which causes an exception. Read more here: http://blogs.msdn.com/b/charlie/archive/2007/12/09/deferred-...

EDIT: Another problem that you could face with deferred execution is that you could execute a method multiple times without noticing.

    var lines = ReadLines(file);
    var count = lines.Count();
    var text = lines.Aggregate("", (acc, x) => x + acc);

This would read all the lines two times (one for count and another for aggregate), and would probably throw another exception because the EOF had been reached in the first execution. In other situations you could have a ultra-slow function because you're executing a heavy function with yield-return multiple times.

This is not a problem of yield-return on itself (as SideburnsOfDoom says, it's as easy as calling ToList()), but should remind you that using yield-return everywhere instead of lists is not a good idea.

SideburnsOfDoom3• 14 years ago

I guess you'd fix that by doing this?

   lines = ReadLines(file).ToList();

ToList() is the go-to method to force eager evaluation of a lazy enumeration.

gjulianm2• 14 years ago

Of course, but you can only do that if you know that ReadLines is using yield-return. If this method were to be used by other people you should use a temporary list to read all the stream before returning from the method; it's the expected behaviour.

davedx• 14 years ago

Was hoping for some of C#'s more interesting features. Bit shifting isn't really anything to do with C#, any C programmer will know about it.

lmm• 14 years ago

Very disappointing article; half of it is irrelevant low-level bit-fiddling which isn't in any way specific to C#

SideburnsOfDoom3• 14 years ago

> When the code is compiled, it doesn’t matter if you wrote string or System.String

... however the coding guidelines are to use the language keyword (i.e. "string" ) where you can.

csmattryder• 14 years ago

Another neat tip, you can alias namespaces:

    using Super.Long.Namespace.Utilities

Can be used as:

    using Utils = Super.Long.Namespace.Utilities

Using C# since 2.0 and only learned about this a month ago!

intractable• 14 years ago

This is one which had escaped me for years:

    private static bool GreaterThanOne(int @int)
    {
        return @int > 1;
    }

However, it would seem to me to fall into the "never, ever use this" category.

DrJokepu• 14 years ago

In 2012, using bit shifting in your code for multiplication or division by powers of 2 is a bad idea. It makes the intent of your code less obvious and it's not always safe (think 2's complement negative numbers). The compiler or the JITter will make this optimization for you when it's appropriate.

michielvoo• 14 years ago

This thread on Stack Overflow is useful if you want to broaden your C# skills by using features/idioms/techniques you may not yet even be aware of:

http://stackoverflow.com/questions/9033/hidden-features-of-c

The question is closed, but there are plenty of interesting answers.

One caveat: some idioms may seem really smart and/or terse, but others may have trouble understanding such code at at glance.

Things in C# you might have missed

Related Stories