Honest Illusion : .Net, C#

Lambda Expressions as Properties

James — Mon, 07 Jun 2010 23:05:35 GMT

Peter recently caused a bit of a stir with his article “Sometimes an enum is not the best idea”. In it, he had a very specific problem: When an enum is passed to a method as an Object, and that method converts it to a usable value by calling ToString(), you get that enum’s name and not it’s value. And he gave a gave very specific solution to that problem. Peter wanted an simple ad hoc solution that he could just drop into his code. Peter’s idea was basically a quick fix to replace a bad design with something slightly less bad. The problem arose when readers inferred that it was intended as a far more general solution, and pointed out different, more architectural solutions. Bickering started in the comments.

I think the main problem is that Peter just want a quick fix to his existing design, and viewed a proper design as overkill for his simple needs. However, since those simple needs were out of scope of his original purpose for the article, he never got into specifics. However, knowing the specifics would be key to knowing how complex the design needs to be. This was the essence of Peter’s follow-up article (which he posted as I was in the middle of writing this)

So, let’s try looking at this problem to see if we can come up with a better design that still meets the goal of being simple.

In Peter’s design, he has a Suppliers class (which he occasionally refers to as the Company class), which has several instances --- one for each supplier. There is also an enum, PublicIds with one entry for each supplier. PublicIds was used in two places: In switch statements, and as a parameter in an ADO.NET statement:

public void DoWithCompany(PublicIds company)
{
    switch (company)
    {
      case PublicIds.Company1:
      // Do something with Company 1
      break;
      case PublicIds.MyCompany:
      // Do something with My Company  
      break;
      case PublicIds.ThatOtherCompany:
      // Do something else
      break;
    }
}

cmdExists.Parameters.AddWithValue("@idSupplier", Supplier.PublicIds.MyCompany);

The second use was the real motivator of Peter’s article – The first was what caused all the hoopla on the blog.

Commenters proposed some general ideas, basically out of Object-Oriented Design 101 – Creating a new subclass for each of the Suppliers, with overridden methods. Peter fought back --- the code in the “do something” blocks is not part of Supplier, but is in other classes. Subclasses would requiring moving non-related code to where it doesn’t belong.

Since Peter still hasn’t provided any real-world examples of his problem (which is reasonable, as they might involve proprietary material or just have too many dependencies to post meaningful excerpts), lets try to imagine some scenarios that might fit his description (namely that DoWithCompany is an example of a method that “is a member of several quite different other classes and comes in many flavors”).

Ok, so let’s say we have a Order class, with a ProcessOrderToSupplier(Supplier sup) method. Let’s further say that most of Order processing is the same for all suppliers, but some suppliers offer a discount (or surcharge) under some conditions. Hence we need custom processing per supplier to handle the discount, but moving order handling into the Supplier class would clearly be wrong.

So, let’s try three different discounting schemes, and come up with three means of handling them in ways that are scalable, maintainable & understandable.

#1 – A flat discount rate on all items.

That’s simple. A discount rate property (getter only) in Supplier. It could be an abstract property which is overridden in derived classes (one for each Supplier), or just set in Supplier’s constructor. (Could be set to zero for those suppliers not offering a discount).

#2 - Several suppliers offering (free shipping on orders over $100).

The “free shipping blah-blah-blah” part is handled entirely in the Order class. The Supplier class just needs a way to say whether of not a particular supplier offers it. This could be handled by a Property as described above, or an attribute on the derived class, or by a marker interface (a marker interface has no members, and is just used in statements like:

if (sup is IOffersFreeShipping)
     ProcessFreeShipping();

#3 – One supplier offers 10% off total orders over $100. Another offers 15% off individual items over $25. And a third offers a $1 shipping surcharge on items over 20 lb.

Basically, every supplier offers something different, and each is complex. We’d think we’d need derived classes with overridden methods here to keep this object-oriented. But that is exactly “the first step to multiple inheritance or an unmaintainable set of interfaces” which Peter was afraid of.

(My laptop has an interesting way of telling me that I haven’t saved in a while --- the battery falls out. I’ve now – too late -- discovered Windows Live Writer’s auto-save feature. Now let’s see if I can recreate what I just lost……).

And besides that, creating a subclass specifically for one instance of a class just feels wrong --- particularly when we would be creating multiple subclass, one for each of several instances. But how can be package instances of distinct functionality in individual instances of an object.

By using Lambda Expressions as Properties.

The idea is pretty simple. We define a property, which, instead of returning some scalar value, returns a lambda expression (or pretty much any form on anonymous function). The property works just like a instance method, except we can assign and change it at run-time. If you’ve done any work in JavaScript, you’ve probably seen very much the same thing.

Let’s look at some code. We start by defining the Supplier class like this:

public class Supplier 
{
    public PublicIds Id {get; private set;}
    public int IdCode {get { return (int) Id;}}
    public Action<OrderItem> PerItem {get; private set;}
    
    public Supplier(PublicIds id, Action<OrderItem> perItem)
    {
        Id = id;
        PerItem = perItem;
    }
    
    public Supplier(PublicIds id) : this(id, oi=> oi=oi)
    {}
}

Note that the constructor takes a Action delegate, and stores it in the PerItem property.

Next, define our instances like this:

Supplier Company1 = new Supplier(PublicIds.Company1);
Supplier MyCompany = new Supplier(PublicIds.MyCompany, oi=> { if (oi.Price > 25m) oi.Discount = oi.Price * 0.15m;});
Supplier ThatOtherCompany = new Supplier(PublicIds.ThatOtherCompany, oi=> {if (oi.Weight >=20) oi.Shipping = 1m;});

And used them like this:

List<OrderItems> items = new List<OrderItems>();    
void ProcessOrderToSupplier(Supplier sup)
{
    // :
    items.ForEach(sup.PerItem);
    //:
}

“Ok“, you say. “We’ve got the distinct behavior without subclasses – but we still have order processing code defined outside of the Order class, and to make matters worse, it moved to the instance definition in a really messy way.”

No Problem, we just go back to out (new) old friend: Lambda Expression as Properties:

This time, we’ll create static properties in the Order class:

public class Order
{
    List<OrderItem> items = new List<OrderItem>();    
    void ProcessOrderToSupplier(Supplier sup)
    {
        // :
        items.ForEach(sup.PerItem);
        //:
    }    
    
    public static  Action<OrderItem> Discount15on25
    {
        get
        {
            return oi => 
                { 
                    if (oi.Price > 25m) 
                        oi.Discount = oi.Price * 0.15m;
                };
        }
    }
    
    public static  Action<OrderItem> Shipping1Over20
    {
        get
        {
            return oi=> 
                {
                    if (oi.Weight >=20) 
                        oi.Shipping = 1m;
                };
        }
    }
}

And we can now define out Supplier instances like this:

Supplier Company1 = new Supplier(PublicIds.Company1);
Supplier MyCompany = new Supplier(PublicIds.MyCompany, Order.Discount15on25);
Supplier ThatOtherCompany = new Supplier(PublicIds.ThatOtherCompany, Order.Shipping1Over20);

So, what have we accomplished?

We’ve distinct behavior amongst the different suppliers, without resorting to subclasses or switch/case blocks
We’ve all the Order processing code in the Order class.
We’ve neat & tidy Supplier instance definitions, which nevertheless indicates the special features of that supplier.
And we have those special features as part of the Supplier object.

But, wait. You’re probably saying that those properties we’ve defined on Order are rather specific to one particular trait. Would it be nice to be able to have one general algorithm which is customizable? That can be done too, by just extending the general principle, which involves using a method instead of a property, but the basic idea is still the same: instead of returning a value, we return a function:

public static  Action<OrderItem> ShippingByWeight(int pounds, decimal cost)
{
    return oi=> 
        {
            if (oi.Weight >=pounds) 
                oi.Shipping = cost;
        };
}

// :

Supplier ThatOtherCompany = new Supplier(PublicIds.ThatOtherCompany, Order.ShippingByWeight(20,1m);

Share this post: Email it! | bookmark it! | digg it! | reddit!

Portable Areas for Castle Monorail, Part 2

James — Thu, 01 Apr 2010 23:15:00 GMT

In our last episode, we discussed the PortableAreaController base class, which makes it simple to create a portable area using Monorail. In this installment, we put that class to use.

For the purposes of this example, the controller isn’t going to do anything useful – I’m not even going to bother with code in the actions. The different actions will display different views so you can see the effect, and I’m hoping you’ll just trust that you can put real code in the action methods.

[Layout("default","patest")]
public class PATest : PortableAreaController
{
    public void Page1()
    {         }
    public void Page2()
    {         }
    public void Page3()
    {         }
}

That’s our minimalistic example. If it looks a lot like an ordinary Monorail controller, that’s the idea. “PATest” is the name of the controller, which in the case of a Portable Area, is the name of the entire feature, so it’s be something like CoolWiki or MyForum.

The Action methods are identical to what you’d have in a normal controller. In fact, everything in the portable controller is just like it would be if this were a intrinsic part of a website.

The rest is just about putting the pieces together in the assembly.

Individual files (images, css files etc) should be placed in the root level of the project. When referencing then in a view, just added “.rails” to the end ( <img src=”${siteRoot}/PATest/autolist.png.rails” />)

View templates should be in a folder named after the controller, and layouts in a “layouts” folder --- just as if the root level was the website’s “Views” folder. You don;t have to do anything special to get Monorail to find them – that is handled for you by the base class.

All those files (not the CS files obviously) should have their Build Action set to Embedded Resource.

Note that when a view template is needed, Monorail will first look for a physical file in the website’s Views files, and failing there, search in the assembly. This allows the end user to override the embedded view templates with their own. In the example I’ve uploaded to the CastleContrib SVN repository, I’ve locally overridden Page2.

The same holds for layouts, which I’ve put to use in the example. I assumed that most sites will have a default layout for the site (which I further assumed is called “default”). The controller uses that layout and adds it’s own child layout. (The project should also define a simple default layout as just “${childContent}” just in case the website it’s being used in doesn’t define one.)

The PortableAreaController base class has been added to the ViewComponent project in the CastleContrib SVN repository. (Yes, I know it’s not a ViewComponent, but I didn’t want to create a whole new branch -- particularly not for just one file-- and ViewComponents were the closest available existing project). The PATest example shown here is a separate project under that branch, with the resulting Castle.MonoRail.PortableAreaExample.dll assembly added to the ViewComponent.TestSite project. Note that that assembly is the only file added to the website to enable this functionality, and the only other change was to add a reference to it into the web.config.

Share this post: Email it! | bookmark it! | digg it! | reddit!

Portable Areas for Castle Monorail

James — Thu, 01 Apr 2010 23:09:59 GMT

Recently I had read a blogger comparing Castle Monorail with ASP.NET MVC. He chose ASP.NET mainly because it supported Portable Areas while Monorail did not. As a supporter of Monorail, I was very offended by this, and decided to correct the problem. The first step… finding out exactly what a “portable area” was.

A Portable Area is a piece of functionality, with all pieces bundled up into a single assembly, which can be just “dropped into” an existing website. Think of a forum or a wiki. The idea is basically, I could just add wiki.dll to my site, and suddenly www.mysite.com/wiki just works.

Now, having a controller and its actions together in a single assembly is a basic design principle of Monorail (and essentially all of MVC design), so that part was done before I even began. The rest was a bit trickier.

I would have to store – and retrieve at the right times, the view template files, and all other associated files – images, style sheets, script files, etc.

Storing the files was in itself trivial -- .NET has a means built right it. The file just need to be added to the project as embedded resources. In Visual Studio, on the file’s property panel, set the “Build Action” to “Embedded Resource”.

Now that the files were in the assembly, we had to get them out of it. For views, which I had assumed were going to be the most trouble, this turned out to be simple, with the plumbing for it was already built into the Monorail framework. Apparently, someone had planned for portable areas, but never followed through. View templates are loaded by a class aptly called the FileAssemblyViewSourceLoader. It looks in the “Views” folder for the template, and failing there, looks among the embedded resources of the assemblies in its collection. However, nothing in the framework ever added an assembly to that collection, so this feature has always laid fallow.

The final feature was getting it to load a random file from the resources. Whenever I need to do something with a name not known in advance, a DefaultAction seems like the way to go.

With that, all the pieces were in place, I just had a wee bit of code to tie them all together. Defining a base class which a portable area could be derived from seemed the best approach.

  public class PortableAreaController : SmartDispatcherController

{

The first step was to override the Initialize() method, so that I could add this assembly to the list searched by FileAssemblyViewSourceLoader. The only trick here is we must make sure that the assembly is only added once, regardless of how many times the controller is initialized. And, while we are at it, we’ll also get the assembly name and a list of the resources and save them for later.

  private string[] resourceNames;
private string asmName;

public override void Initialize()
{
    base.Initialize();
    var asm = this.GetType().Assembly;
    resourceNames = asm.GetManifestResourceNames();
    asmName = asm.GetName().Name;
    var asminfo = new AssemblySourceInfo(asm, asmName.ToLower());
    if (!this.Context.Services.ViewSourceLoader.AssemblySources.Cast<AssemblySourceInfo>()
                            .Any(asi=>asi.AssemblyName==asminfo.AssemblyName))
        this.Context.Services.ViewSourceLoader.AddAssemblySource(asminfo);
}

Next is the DefaultAction. The idea here is that you request somefile.jpg.rails, and we pull somefile.jpg out of the resources, and stream it to the browser. In Monorail, a DefaultAction is a method which is called when no other method in the controller matches the action. In our DefaultAction, we’ll generate a resource name from the assembly name and the Action name. The Action is basically, the name of the “file” requested without the “.rails” extension, so if we ask for file “http://mysite.com/portable/myimage.gif.rails”, then the pseudo-file we are requesting is “myimage.gif.rails” which makes the Action “myimage.gif” which just happens to be the file we really want. The only tricky part here is the GetContentTypeFromExt() function. The problem is that there is a very simple way to do this --- which only works under Windows. Now, while the vast majority of web servers running Monorail are Windows based, Monorail is designed to also run under Mono (Linux). I couldn’t find a good portable way to handle this, so I just punted (check the source for dirty secrets).

[DefaultAction]
public void DefaultAction()
{
    string filename = asmName + "." + Action;
    var resourceName = resourceNames.FirstOrDefault(rn=> rn.Equals(filename,StringComparison.InvariantCultureIgnoreCase));
    if (resourceName!= null)
    {
        string ext = Path.GetExtension(filename);
        this.Response.ContentType = GetContentTypeFromExt(ext);

        Stream contents = this.GetType().Assembly.GetManifestResourceStream(resourceName);
        this.Response.BinaryWrite(contents);
        CancelView();
    }
}

This method is the controller’s Default action by virtue of the [DefaultAction] attribute. The name is arbitrary – DefaultAction just kept things simple.

And with that, everything you need to write a portable area in Monorail is neatly contained in a simple base class. Everything we’ve just gone over, you can now completely ignore.

Next, we discuss how you use this base class to write your own portable area.

Share this post: Email it! | bookmark it! | digg it! | reddit!

Some Better-Written Custom String Methods using C#

James — Wed, 03 Feb 2010 01:07:00 GMT

In my daily web-surfing, I often stumble upon snippets of C# code posted by people. Usually, I can tweak it a bit. Sometimes, I can tweak it a lot. I usually post a quick comment to the site offering it. Today, I came upon some code that was so bad --- which the author said was from his forthcoming book! --- more drastic measures must be taken.

First we have a function to put a string into “Title Case” (which the author refers to as “Proper Case”) – Having the first letter of each word capitalized. Here’s the original:

public static String PCase(String strParam)
 {
     String strProper = strParam.Substring(0, 1).ToUpper();
     strParam = strParam.Substring(1).ToLower();
     String strPrev = "";
     for (int iIndex = 0; iIndex < strParam.Length; iIndex++)
     {         
         if (iIndex > 1)
         {
             strPrev = strParam.Substring(iIndex - 1, 1);
         }
         if (strPrev.Equals(" ") ||
         strPrev.Equals("\t") ||
         strPrev.Equals("\n") ||
         strPrev.Equals("."))
         {
             strProper += strParam.Substring(iIndex, 1).ToUpper();
         }
         else
         {
             strProper += strParam.Substring(iIndex, 1);
         }
     }
     return strProper;
 }

What wrong here? Lot’s of really bad string handling. Remember, strings are immutable, so any action on one creates a new string. So, “strParam.Substring(iIndex, 1)” creates a new string. “strParam.Substring(iIndex, 1).ToUpper()” create two new strings, and “strProper += strParam.Substring(iIndex, 1).ToUpper();” creates three new strings. And, that’s within a loop. And, since Substring is always used here to create a one-character string, it easier to just use a char --- except apparently, this book author doesn’t know how to. Nor, doesn’t he apparently know about StringBuilder. Then, we get to the algorithm itself, where he does such bizarre things as pointlessly treat the first character as a special case, in two different places.

Ok, now let’s see the revision:

    public static String PCase(String strParam)
{
         StringBuilder sb = new StringBuilder(strParam.Length);
         char cPrev = '.';  // start with something to force the next character to upper.
        foreach(char c in strParam)
         {
             if (cPrev == '.' || Char.IsWhiteSpace(cPrev))
                 sb.Append(Char.ToUpper(c));
             else
                 sb.Append(Char.ToLower(c));
             cPrev = c;
         }
         return sb.ToString();
     }

First we start with a string builder, preallocated to the size of the string we are building. The method doesn’t change the length of the string, so we know the length of the final string right from the start.

Next, since we are going to capitalize every letter after a period, and also the first letter, why not just pretend the mythical initial “last” character was a period? Suddenly, the first letter is no longer a special case, and we still get what we want.

Then, we just loop through the letters, raising or lowering letter as we need. Note that it works on characters and not strings, and uses the build-in IsWhitespace method, instead of using a hardcoded list of a subset of them. A for() loop can in certain cases (however, not the one used in the original) be faster than a foreach(), but here I figured it was safe to sacrifice a tiny bit of speed for clearer code.

Next up, Reversing a String. The Original:

    public static String Reverse(String strParam)
     {
         if (strParam.Length == 1)
         {
             return strParam;
         }
         else
         {
             return Reverse(strParam.Substring(1)) + strParam.Substring(0, 1);
         }
     }

Now, here the author might be able to earn a pass. It’s possible that somewhere in his book he talks about recursive functions, and uses this as an example. Then, if might be OK. I mean, it is the only reason I can think of that someone might want a function which reverses a string – despite ubiquity of string reversing functions in libraries like this. But, he presented it on his blog as a collection of string functions, so we’ll have to judge them on that basis.

Again we have lots of string manipulation to accomplish something simple --- where there are already method built into the framework to handle such things:

public static String Reverse(String strParam)
{
     byte[] rev = Encoding.ASCII.GetBytes(strParam);
     Array.Reverse(rev);
     return Encoding.ASCII.GetString(rev);
}

UPDATE: One commentator noted (quite rightly) noted that my Reverse() method would only work for strings of ASCII characters and will fail if there are any Unicode characters. I knew that at the time, but I was hoping no one else would notice. The problem was I needed a method which converted a string into an array of characters, and being unable to find one in the CLR, I substituted a string to byte array method instead. I guess this is one of those times where you just have to step away for a while and come back to it, because now, I found the right method in a few seconds:

public static String Reverse(String strParam)

     char[] rev = strParam.ToCharArray();

     Array.Reverse(rev);

     return new String(rev);

And while my first version was a big improvement over the original, this is a big improvement over my first version, so you get double the benefits!

Next, we have a simple function to count the occurrences of a substring.

public static int CharCount(String strSource, String strToCount)
{
    int iCount = 0;
    int iPos = strSource.IndexOf(strToCount);
    while (iPos != -1)
    {
        iCount++;
        strSource = strSource.Substring(iPos + 1);
        iPos = strSource.IndexOf(strToCount);
    }
    return iCount;}

The revision isn’t much different but the subtle difference is important. Instead of creating a new, shorter string to search, we tell it to just start looking after the last match. Instead we now merely look at the string.

public static int CharCount(String strSource, String strToCount)
{
    int iCount = 0;
    int iPos = strSource.IndexOf(strToCount);
    while (iPos != -1)
    {
        iCount++;
        iPos = strSource.IndexOf(strToCount, iPos+1);
    }
    return iCount;
}

The next one has a special problem --- It doesn’t do what it claims to do!

// Trim the string to contain only a single whitepace between words

public static String ToSingleSpace(String strParam)
{
    int iPosition = strParam.IndexOf(" ");
    if (iPosition == -1)
    {
        return strParam;
    }
    else
    {
        return ToSingleSpace(strParam.Substring(0, iPosition) +        strParam.Substring(iPosition + 1));
    }
}

Now, it says that it should remove repeated space, so that there is only one space between words. However, what it actually does it to remove all spaces. This gives us a problem: Should my rewritten function do what it claims to do, or what it actually does? I decided to give you one of each.

Duplicating the result is quite straightforward:

public static String RemoveAllSpaces(String strParam)
{
    return strParam.Replace(" ", "");
}

Writing a function to do what it is supposed to is a little more involved, but still simple:

public static String ToSingleSpace(String strParam)
{
    var sb = new StringBuilder(strParam.Length);
    var prevWS =true;
    foreach(var c in strParam)
    {
        if (Char.IsWhiteSpace(c))
        {
            if (!prevWS)
                sb.Append(' ');
            prevWS = true;
        }
        else
        {
            sb.Append(c);
            prevWS = false;
        }
    }
    return sb.ToString();
}

We create a string builder the size of our source string, which would be the maximum size our trimmed string could be, and we set prevWS to true. This way, it will remove all leading whitespace. Then we just step through the string, character by character, appending that character to our new string if it’s not a whitespace character, and appending a space for the first whitespace character found. Note that this reduces all forms of whitespace (tabs, newlines, spaces etc) to a single space. The original just worked on spaces.

Finally, we have a function to determine is a string is a palindrome.

public static bool IsPalindrome(String strParam)
{
    int iLength, iHalfLen;
    iLength = strParam.Length - 1;
    iHalfLen = iLength / 2;
    for (int iIndex = 0; iIndex <= iHalfLen; iIndex++)
    {
        if (strParam.Substring(iIndex, 1) != strParam.Substring(iLength - iIndex, 1))
        {
            return false;
        }
    }
    return true;
}

Here the change is subtle (ignore the length calculations at the start, which are a trivial micro-optimization).

public static bool IsPalindrome(String strParam)
{
    var iLength = strParam.Length;
    var iHalfLen = iLength / 2;
    iLength --;
    for (int iIndex = 0; iIndex < iHalfLen; iIndex++)
    {
        if (strParam[iIndex] != strParam[iLength - iIndex])
        {
            return false;
        }
    }
    return true;
}

In this function, instead of comparing one-character long strings, I compare individual characters. That change, by itself, cause a 4X speed improvement.

So, there you have it. The article had more, but the other were trivial, and I couldn’t make them any better. And in case you think I’m all talk here, each of those rewrites was benchmarked to run 2 to 5 times faster than the original.

Share this post: Email it! | bookmark it! | digg it! | reddit!

A ViewComponent extension for Castle MonoRail, Part II

James — Tue, 25 Aug 2009 00:44:00 GMT

This was intended to be a two-part article. It was just after I published the original article, I noticed that I’d left out a large part of ViewComponentEx. We continue…..

        protected bool RenderOptionalSection(string section) 
        protected bool RenderOptionalSection(string section, string defaultText)

Renders the named section of a block component – if the section is present. If not, it just silently returns. The second overload lets you provide some text to be rendered, if that section isn’t given:

RenderOptionalSection("tablestart", “<table>”)

Returns true if this section was rendered; false, if the section was present. This seems like a very simple method (and it is), but if your component has a number of different sections for styling (such as the SmartGridViewComponent, which has 18!), this can do wonders to streamline your code.

        void RenderComponent<VC>(params string[] componentParams) where VC : ViewComponentEx, new();
        void RenderComponent<VC>(IDictionary componentParams) where VC : ViewComponentEx, new();
        void RenderComponent(ViewComponentEx component, params string[] componentParams); 
        void RenderComponent(ViewComponentEx component, IDictionary componentParams);

This implement, with a slightly different syntax, a technique originally devised by Joey Beninghove. The idea is to make a ViewComponent which is composite of several other VCs. The basic syntax is

 RenderComponent<LinkSubmitButtonComponent>("linkText=Search",
             string.Format("formToSubmit={0}", searchFormName));

However, the various overloads allow using an already exist component object, and/or an already built dictionary of options.

Also include in the source file is the class ViewComponentUsingSiteMap which, like ViewComponentEx, is an abstract base use for creating ViewComponents, but I’ll hold off discussing that until I ready to talk about the VCs the derive from it.

Share this post: Email it! | bookmark it! | digg it! | reddit!

A ViewComponent extension for Castle MonoRail

James — Mon, 24 Aug 2009 11:21:08 GMT

I’ve been rewriting my website, njtheater.com, (very slowly) as a Castle MonoRail application. Along the way, I’ve written a number of ViewComponent and other elements. Many of these were of general use, so I’ve added them to the CastleContib project, and documented them in the using.castleproject.org wiki.

Two problem there: First, some of the items I wrote don’t fit into an exist category in CastleContrib (There’s one for ViewComponents, which I’ve stick a filter into, but putting a Controller base class there seemed wrong). Second, CastleContrib & using.castleproject.org seem to be somewhat of a black hole. No one seems to look there for information about the Castle Project (which is kind of a shame, since that’s exactly it’s purpose).

On the other hand, blogs posts about Castle are turning up everywhere. We’ve even now got an aggregated blog feed specific to Castle. So, I figured, I start using my blog to talk about what I’ve written.

In fact, one article I discovered on that aggregator was Andy Pike’s “Integrating Gravatar with Castle MonoRail” inwhich he discusses a Helper object for Monorail which creates Gravatars for use’s email addresses. It was written last January. The only thing is, I’ve written (and added to CastleContrib) a Gravatar component three months earlier. That was going to be the topic of my first MonoRail blog post (and I will be my second), but first, I figure I should talk about the base class I once for all my ViewComponents, which I’ve given the rather imaginative name of ViewComponentEx.

ViewComponentEx derives from ViewComponent, and can be used as a “drop-in” replacement for it, as the base class for your ViewComponents. It provides a number of simple methods to help building ViewComponents.

void ConfirmSectionPresent(string section);

Throws an exception if the given section is not present.

string GetSectionText(string section);

Get the text of a section as a string.

string GetBodyText();

Get the text of the body of a block component (without section)

void RenderTextFormat(string format, params object[] args);

Renders the text, formatted. Just like String.Format()

string GetParamValue(string key, string defaultValue);

bool GetParamValue(string key, bool defaultValue);

E GetParamValue(string key, E defaultValue) where E : struct;

Gets a parameter value, with a default. Overloaded to handle string, boolean, or Enum value.

Castle.Core.Logging.ILogger Logger { get; set; }

A property for the system Logger. Automatically wired by Windsor, if active and a Logger is defined in the container. Default to NullLogger, otherwise.

string MakeUniqueId(string prefix);

Makes an unique id. The given prefix is prepended to the generated number. The ID isn't actually guaranteed to be unique (which would require using all 32 digits of the guid). But this produce ids sufficiently distinctive to generate multiple controls on a page.

Code available here: ViewComponentex.cs

Share this post: Email it! | bookmark it! | digg it! | reddit!

#songsincode : The Turtle’s “Happy Together”

James — Sat, 22 Aug 2009 15:26:29 GMT

    (Me + you) &&  (you + me)
var nomatter = dice.toss(); assert (it != null)
me.Only1(you); assert(you == me.Only1());
(Me + you).happy  = so;

(more on the meme here)

Share this post: Email it! | bookmark it! | digg it! | reddit!

Code Tune-Up: Shuffling a List

James — Sun, 16 Aug 2009 23:14:11 GMT

Over on CodeProject, I spotted an article by Mahdi Yousefi called " Creating an ASP.NET captcha using jQuery and s3capcha”.

public static List<int> shuffle(List<int> input)
{
    List<int> output = new List<int>();
    Random rnd = new Random();
 
    int FIndex;
    while (input.Count > 0)
    {
        FIndex = rnd.Next(0, input.Count);
        output.Add(input[FIndex]);
        input.RemoveAt(FIndex);
    }
 
    input.Clear();
    input = null;
    rnd = null;
 
    return output;
}

So, what’s wrong with this? Well, let’s see:

It takes a List as a parameter and returns a list. This is rather limiting. What if we have array we want to shuffle?
It takes and returns a list of integers. Again rather limiting. What if we had strings or say, PlayingCard objects we want to shuffle?
It creates a new Random object every time it’s called. Two problems there. First, when a Random object is created, a seed is produced. This is a fairly time-consuming task, which you don’t want to do repeatedly necessarily. Second, when the default constructor is called, like here, the seed is initialized using the internal clock’s TickCount --- which is the time in milliseconds. If you called shuffle() twice within a millisecond -– not unreasonable if you were writing a game – the Random objects would be using the same seed, and produce the same sequence.
It creates a new list for output. This is a problem only in that it’s a time expense we might as well avoid if possible. It also builds this list by repeated calls to Add(), but without specifying an initial size, meaning that Add() will frequently have to resize the list to keep expanding it. The fix to this would be trivial. Just create the new list as “new List<int>(input.Count);”. But as you’ll see, this won’t be necessary.
It destroys the list input. In fact, it destroys it three times over: First by removing all of it’s items. Then by calling Clear() on the empty list. Then by setting the local reference to null. That last one might cause it to be garbage-collected a couple microseconds earlier – if the calling routine didn’t hold a reference to it. I don’t want to claim this as a “Problem”, as much as a “Behavior” – It’s just something it does, so if our replacement does that as well (as it will), we haven’t lost anything. But, if you nevertheless thing that is a problem, don’t worry, we’ll address that to.
It removes that items from the list using Remove() – This is a very time-consuming method on Lists (which, contrary to popular belief are not linked-lists, but are internally implement as arrays). One call to List.Remove() is O(N) by itself. Since it’s called in a loop, that makes the complicity of this method O(N^2). Clearly that’s something we should avoid.

So, let’s tackle these. First the signature. we say we want a List, but we really only want so features of a list – that usually means we want an interface. And we want to be usable for List of all types, so it’s wants to be generic:

public static IList<T> Shuffle<T>(this IList<T> input)

IList has just the features we need, and allows us to pass different collection types (notably arrays) to the method. I’ve also implemented it as an extension method, because it seemed more useful that way. But to be an extension method, it has to be in a static class, which brings us to our next change:

static class Helper
{
       static readonly Random rnd = new Random();
    // :

I’ve moved that Random object to be a static member. That way, only one is created & initialized, and every call to Shuffle reuses the same one.

Next is that main loop:

for(var top = input.Count -1; top > 1; --top)
{
    var swap = rnd.Next(0, top);
    T tmp = input[top];
    input[top] = input[swap];
    input[swap] = tmp;
}

Here’s where we see the major change to the implementation. Both method use basically the same algorithm, but instead of building a new List, I move the elements around within the same list. Essentially, I’m doing the same thing, if you imagine the two arrays occupying that same space – as one grows small the other grows bigger.

And with that, we’re done. Since the original List is now shuffled, we could return void, but by returning the input, we can allow chaining (and it also maintains the original method signature)

So, How does it work ? Here’s a quick example, showing off some of it’s new abilities:

        string[] A = {"A", "B", "C", "D", "E", "F", "G"};
        A.Shuffle().Print();

output: D-F-A-G-B-E-C-

Print() is a simple-minded extension method which just takes a list and prints it’s elements separated by dashes. Good for demos but not much else. Also for these examples, I’ve hard-coded the seed for Random to be 1234, so the sequence is always repeated. Again, good for demos, but not for production work.

But, you said you didn’t want the original list destroyed. (yes, you did in fact say that!). No problem, we’ll just write a second method, and since the problem definition requires two lists, there’s no shame in eating the cost of creating a copy of the input list. To keep it simple, I’ll also create & return a List<> regardless of what type of IList<> you passed in.

  return new List<T>(input).Shuffle();

But that brings us to another key point. The only thing that the input is being used for is to seed the new List, and that ctor doesn’t take an IList<>, it takes the much more common IEnumerable<> (which IList just happens to be a descendant of). So, we might as well make that our input parameter.

public static IList<T> ShuffleCopy<T>(this IEnumerable<T> input)
{        return new List<T>(input).Shuffle();    }

With this, we can do some interesting things, since you input doesn’t have to be a collection at all:

        Enumerable.Range(1,10).ShuffleCopy().Print();

output:  1-5-7-9-10-2-6-3-8-4-

Here’s the full source code:

static class Helper
{
    static readonly Random rnd = new Random();
       
    public static IList<T> Shuffle<T>(this IList<T> input)
    {
        for(var top = input.Count -1; top > 1; --top)
        {
            var swap = rnd.Next(0, top);
            T tmp = input[top];
            input[top] = input[swap];
            input[swap] = tmp;
        }
    
        return input;
    }      
    
    public static IList<T> ShuffleCopy<T>(this IEnumerable<T> input)
    {        return new List<T>(input).Shuffle();    }      
    
    public static void Print<T>(this IList<T> list)
    {
        foreach(T t in list)
        {
                Console.Write("{0}-", t);
        }
        Console.WriteLine();
    }
}

Share this post: Email it! | bookmark it! | digg it! | reddit!

Posts from Comments: QuickDataBind

James — Tue, 28 Jul 2009 10:49:49 GMT

You may have noticed that I don’t write on this blog much. But the thing is I do write a lot on the inter-webs about technical matters --- I just don’t to it here. Usually, I find something interesting on someone else’s blog, and then write an improvement in the comments. So, my work goes to helping other people’s pagerank. I figure this has got to stop… To this end, I start a series where I turn comments I made on other blogs into posts on this one….

To start us off, a few days ago, Samer wrote about an extension method he created for ListView:

public static ListView QuickDataBind(this ListView myListView, object myDataSource)
    {
        myListView.DataSource = myDataSource;
        myListView.DataBind();
        return myListView;
    }

Now, this is all well and good. but why are we limiting ourselves to just ListViews? Many ASP.NET WebControl take a datasource and use that idiom. Why not make an generic extension method to handle all of them?

public static T QuickDataBind(this T myDataBoundControl, object myDataSource) 
        where T: BaseDataBoundControl
{
        myDataBoundControl.DataSource = myDataSource;
        myDataBoundControl.DataBind();
        return myDataBoundControl;
}

It's still called exactly the same well:

       myGridView.QuickDataBind(myDS);

but now it can be used on ListViews, GridView, DropDownLists DataGrids, Repeaters or anything else that uses a DataSOurce.

Share this post: Email it! | bookmark it! | digg it! | reddit!

DEV102's Programming Job Interview Challenge #6

James — Mon, 02 Jun 2008 14:16:00 GMT

Another week, another C# interview question from the good folk's at Dev102.com -- Although I use the term "good folks" advisedly, as this week they did not even acknowledge the solution I posted for last weeks puzzle (which was both correct, and, I believe, the first blog post about it).

Anyway, time to move on to this week's question.

Look at the following Code segment written in C#:

   1: ArrayList a = new ArrayList();

   2: ArrayList b = new ArrayList();

3:

   4: a.Add(1);

   5: b.Add(1);

   6: a.Add(2);

   7: b.Add(2.0);

8:

   9: Console.WriteLine((a[0] == b[0]));

  10: Console.WriteLine((a[1] == b[1]));

What will be typed into the console? And WHY?

This one is fairly trivial (They seem to be alternating between difficult and easy questions). And, as requested, I formulated my answer before typing it into VS (actually, I copy'n'pasted in SnippetCompiler), but the compiler DID confirm the answer I'd already theorized.

This answer is short enough that we can use the cool "white-on-white; select to see it" trick--- However, RSS feed (and apparently the theme of this blog) seem to ignore the color style, so it's probably visible to you below..

ArrayList is deep-down, just an object[]. To store an valuetype, like an int or float, in an ArrayList, that value would first have to be boxed. Each valuetype is boxed separately, in distinct objects, even if they do happen to have the same value. When we get to the WriteLines, we are just performing (object) == (object) (actually, Object.ReferenceEquals(object1, object2); ) ReferenceEquals knows nothing about unboxing. It just asks, "Are these two references pointing to the exact same object?". For any two boxed objects, regardless of their value, the answer would be "No". Hence, both lines print "False".

(select the blank space above)

Share this post: Email it! | bookmark it! | digg it! | reddit!

DEV102's Programming Job Interview Challenge #4

James — Fri, 23 May 2008 13:58:31 GMT

The folks at Dev102.com are offering weekly programming challenges, where they offer questions, and let bloggers post about them. I meant to write an answer for last week, but never got around to it. Just as well -- my answer would have been wrong. SO, let's move on to this week's:

How would you implement the following method: Foo(7) == 17 and Foo(17) == 7. Any other input to that method is not defined so you can return anything you want. Just follow those rules:

Conditional statements (if, switch, …) are not allowed.

Usage of containers (hash tables, arrays, …) are not allowed.

My first thought was, since we can't use conditional statements, to use conditional expressions instead:

int foo(int n)
{
return (n==7) ? 17 : (n==17) ? 7 : n;
}

But clearly, that is just cheating. (And, besides, it turns out, it's not the best solution).

My next attempt was to use subtraction to create factors of zero.

int foo(int n)
{
return n + (10 * (n-17) * (n-6)) + (-10 * (n-16) * (n-7)) ;
}

There may be a formula in there that works, but that one doesn't, and before I found it, I stumble upon the correct solution, which was just sitting there staring me in the face:

int foo(int n)
{
return 24-n;
}

Yep, it's just that simple.

Share this post: Email it! | bookmark it! | digg it! | reddit!

How can I easily log a message to a file for debugging purposes?

James — Wed, 16 Apr 2008 14:06:47 GMT

Today, either Bloglines.com or blogs.MSDN.com blinked, and suddenly I'm seeing old entries on the 'C# Frequently Asked Questions' blog as new. No one has posted anything there in over two years.

Anyway, reading the most recent message, it offered a method for logging a message. Now, ignoring side debates over log4net vs nLog vs. the Event log vs. Trace, and just concentrating on the code post --- It's not very good. Look for yourself (then come back here) http://blogs.msdn.com/csharpfaq/archive/2006/03/27/562555.aspx

Despite being written by a C# MVP (*), it shows a lack of understanding of basic .Net library features, and well as C#. So, I figured, I'd rewrite it. I limited myself to taking what's there and fixing it instead of going an entirely different way (ie, log4net vs nLog vs etc). Here's the revised code:

using System.IO;

public void LogMessageToFile(string msg)

    string logFilepath = Path.Combine(Environment.GetEnvironmentVariable("TEMP"),"My Log File.txt");

    using (StreamWriter sw = File.AppendText(logFilepath))

        string logLine = String.Format("{0:G}: {1}.", DateTime.Now, msg);

        sw.WriteLine(logLine);

A few years ago, I bought a number of books, all with the title of same variation of "C# Cookbook". Again, a lot of bad code. I've been meaning to start a series of articles about revising them.....

(*) Years ago, I was one of the very first C++ MVPs. After ten years, I was dropped from the program. Since then I've tried to become a C# MVP, without any luck. I'm beginning to get bitter about it. ;-)

Share this post: Email it! | bookmark it! | digg it! | reddit!

What's inside a foreach() statement?

James — Fri, 18 May 2007 15:31:47 GMT

Recently I was looking at some C# code where the author, to loop through some collection, would frequently use call GetEnumerator() and the manually step through the collections, calling MoveNext(). It seemed to me that the code could be written more cleanly using a foreach. I got to wondering it the author knew some funky optimization detail, that I didn't, that made his code more efficient.

So I tried an experiment. I wrote two methods: one, a lightly adapter version of the code I had been studying; and the other, the equivalent code, using a foreach. I compiled them, and examined the generated IL in Reflector.

void Test1(Dictionary<string, int> bag)

    Dictionary<string, int>.Enumerator enumerator = bag.GetEnumerator();

    while (enumerator.MoveNext())

        if (bag.ContainsKey(enumerator.Current.Key))

            bag.Add(enumerator.Current.Key, 5);

void Test2(Dictionary<string, int> bag)

    foreach (KeyValuePair<string, int> item in bag)

        if(bag.ContainsKey(item.Key))

            bag.Add(item.Key, 5);

I'll spare you the IL listings, but Test1() was shorter by a small amount. More interestingly, while some parts of the IL matched in both methods, a lot was different. I studied the code to see the variations. One difference was in Test1, get_Current() was called twice, but only once in Test2(). But, mainly, Reflector claimed the Test2 had try and finally statements, which I figured were essentially a using{} block. After a bit of playing, I came up with this:

void Test3(Dictionary<string, int> bag)

    using (Dictionary<string, int>.Enumerator enumerator = bag.GetEnumerator())

        while (enumerator.MoveNext())

            KeyValuePair<string, int> item = enumerator.Current;

            if (bag.ContainsKey(item.Key))

                bag.Add(item.Key, 5);

Except for a few insignificant deviations (the order of temporaries on the stack, the placement of NOP instructions), Test2 & Test3 produce identical IL code. More interesting, if I ask Reflector to disassemble the assembly into C# code, it displays identical foreach loops for both methods.

So, what have we learned from this? Well, a simply manual GetEnumerator loop will end up skipping the call to Enumerator.Dispose(). Whether that is an optimization or a bug depends on your code. And, if you're not careful, you'll probably end up retrieving the Current property more than you need to.

In the end, you're probably better off calling foreach, which, one suspects, is why it was added to the language in the first place.

Share this post: Email it! | bookmark it! | digg it! | reddit!

Design Patterns: Thoughts on the Singleton Pattern

James — Tue, 13 Mar 2007 20:27:52 GMT

(Note: I started writing this a couple days ago --- a short while before Andrew Matthews published his own very similar article. He, of course, finished his first...)

(Update: Fixed the spelling/grammar, and then wrote a bit more)

Lately on some of the blogs I read, I've been seeing people giving code implementing various Design Patterns. Much of it, I thought, wasn't particularly good, so I figured I'd inflected the blogosphere with my takes on some of them.

I'll start with everyone's favorite Pattern : The Singleton.

However, before I get to code, I figure I should give some principles for proper use:

1. You will, almost certainly, never actually need a singleton.

Singletons are, by far, the most overused, misused, and generally abused Design Pattern.

2. The Singleton pattern is used to model objects of which there can be only one (in the universe). It is not intended for objects for which you happen to need only one in your program.

For example, some might want to create a singleton for "currently logged-in user", based on the idea that can only be one "currently logged-in user". But no. There are many users, one just happens to be logged in now. That is not a place not a singleton.

If you have just one of an object, and you want to make sure that when you reference that object anywhere in your program, you refer specifically to that one object, you do not need a singleton. What you want is a completely different programming technique known as a Global Variable.

"Wait a minute", you say. "Aren't global variables evil?"

Well, not exactly evil, but they are definitely frowned upon, and they will definitely cause problems if they are not handled properly. However, the important point here is that regardless of how you refer to your global variable -- whether it's as "g_MyVar" or "pMasterPtr->pMyStructPtr->MyVar" or "CMySingleton.Instance().MyVar" -- It's still a global variable and will still have all the problems associated with one. If you are going to have to deal with all those problems anyway, you might as well choose the method which is both the most easily understood, most efficient, and requires the least typing.

Side Note: The second example of "renamed global variables" above came from an actual C program I was involved with some years ago. pMasterPtr pointed to a (malloc'ed) struct, which was just a collection of pointers to other malloc'ed structs (one of each). The elements of these structs had nothing to do with each, beyond the fact that they were all associated with a particular module. The project leader proudly announced that the program had "only one global variable". On program start-up, the "Structure Allocated Assignment Block" (i.e., SAAB, named after my car, over my objections) was malloc'ed, and then assigned to pMasterPtr (which I think was actually called pSAAB), then the other struct were malloc'ed and their pointers stored in the SAAB. We could have just as easily made the elements of the secondary structs, elements of the primary struct, or just plain hard allocated data items, and it would have have no effect on the program --- the only difference is that this plan allowed the boss to say it had "only one global variable" --- which is, of course, nonsense -- it had dozens, they just had awkward names. Additionally, due to a over-eager company coding policy, every access to a pointer had to be proceeded by a check if it were NULL, so, we'd have long blocks of code like this:

if (pSAAB == NULL)
{
    PrintErrorMessage();
    return;
}
if (pSAAB->pIOStruct == NULL)
{
    PrintErrorMessage();
    return;
}
pSAAB->pIOStruct->nColor = NewColor;

When actually a simple line like this would have sufficed:

g_nIOColor = NewColor;

The point of all the was to show to what great length some programmers would go to, to pretend that they don't use global variables. And this leads directly to our obsession with, and abuse of, singletons.

Now, when you find something in your application of which there Can Be Only One, such as the Screen or the Mouse or the Keyboard, then you have a place for a singleton. And in these cases, in .Net, I suggest using a static class.

"Wait a minute", you say. "Aren't static classes as singletons evil?"

Well, not exactly evil, but they are definitely frowned upon, mainly because they aren't inherently thread-safe. However, no singleton technique is inherently thread-safe. The methods of making a singleton and serializing access are completely separate. The basic logic here is that if you are going to go to the trouble of allocating a singleton, it's easy to remember to also add the code to serialize access, but if you're going to take the easy way out on the singleton, you'll probably forget about synchronization also. Not a particularly rational design strategy, but we haven't talked about a rational design policy yet in this article.

So, we've created the static class, and carefully implement thread-safe access, now do we have a good case for a singleton. Still, no. Because, as I pointed out earlier, a singleton is just a special kind of global variable. Which means it has all the problems of a global variable. For instance, going back to another earlier example, the currently logged on user. This appears to be a perfect candidate for a global variable if not actually a singleton. And it was in that light the High-Priced Consultant Who Was Designing The System (on another project I worked on years ago - C++ this time), decided that there would be "just a handful" of global variables in the app, one of which was "CurrentUser". And I immediately protested -- I was assigned to write the administration module, where an admin user could log-in and impersonate another user. Hence many (most) of the tasks in the app was to perform had to be done for this specified user, who is not necessarily the (singular) CurrentUser. Nevertheless, everyone else on the team used the global CurrentUser throughout the app, and I was forced to re-write much of it, to pass EffectiveUser as a parameter.

"Wait a minute", you say. "Aren't you talking about a global variable, not a singleton?" Yes, but the same rules apply. Consider the examples I gave before of true singletons: the Screen, or the Mouse or the Keyboard. Can you say for sure that you application will only ever have to deal with one of each of them? Multiple monitors are already quite fashionable, and in this connected world, having a local user & a remote user, sharing one screen but each with their own mouse & keyboard isn't that unusual.

Share this post: Email it! | bookmark it! | digg it! | reddit!

More Fun with C# Iterators: Take, Skip, TakeWhile, SkipWhile

James — Sat, 10 Mar 2007 00:04:16 GMT

As I was reading this article by Granville Barnett on some of the new operators available on LINQ queries, I thought, "That's all well and good, but for the time being, we're living in a .Net 2.0 world. I wonder if I could emulate those with just generics & iterators?" As it turned out, it was quite easy.

First up is Take: Given a collection, we want to return the subset which is just the first N items. To handle this, we just return items while counting down to zero. When we reach zero, we stop.

        static public IEnumerable<T> Take<T>(IEnumerable<T> enm, int take)

            foreach (T t in enm)

                if (take-- == 0)

                    break;

                yield return t;

            } // foreach

            string[] peopleinit = new string[] { "Granville", "Rachel", "Monica", "John", "Ross", "Joey" };

            List<string> people = new List<string>(peopleinit);

            Console.WriteLine("Take Test....");

            foreach (string person in Iter.Take(people, 2))

                Console.WriteLine(person);   // Prints  Granville, Rachel

Next, is Skip. This is essentially the reverse of Take: Given a collection, we want to return the subset which is everything after the first N items. And handling Skip is essnetially the reverse of Take as well: We still count down to zero as we iterator through the collection, but we don't return anything until we reach zero. (Of course, after we reach zero, we have to stop decrementing the count, or the if() will fail when skip equal -1.)

static public IEnumerable<T> Skip<T>(IEnumerable<T> enm, int skip)

    foreach (T t in enm)

        if (skip == 0)

            yield return t;

        else

            --skip;

    } // foreach

Console.WriteLine("Skip Test....");

foreach (string person in Iter.Skip(people, 4))

    Console.WriteLine(person);   // Prints  Ross, Joey

Now, once we have Skip, SkipFirst (which we discussed before) just become an instance of that.

static public IEnumerable<T> SkipFirst<T>(IEnumerable<T> enm)

    return Skip(enm, 1);

There is no simple way to expand SkipLast, which was also discussed in that previous article, beyond just one item, so we'll leave it's implementation.

A bit more advanced are TakeWhile and SkipWhile. And, unlike the LINQ versions, we can't use lambda expression, so we'll have to make do with delagates.

The essense of TakeWhile is, given a collection, we return items until we reach one which fails a given predicate. Note that we stop at the first failure we reach (even if there may be later item which pass the predicate test)

public delegate bool whilecond<T>(T t);

static public IEnumerable<T> TakeWhile<T>(IEnumerable<T> enm, whilecond<T> take)

      foreach (T t in enm)

        if (take(t))

            yield return t;

        else

            break;

    } // foreach

public static bool LongerThan5(string a)

    return a.Length > 5;

        // :

//:

 Console.WriteLine("TakeWhile Test....");

foreach (string person in Iter.TakeWhile(people, LongerThan5))

    Console.WriteLine(person);   // Prints  Granville, "Rachel", "Monica",

Final, this brings us to SkipWhile, which is the inverse of TakeWhile: Given a collection, we skip items until one fails a given predicate, and then we return the rest (even though some of the rest may fail the predicate)

static public IEnumerable<T> SkipWhile<T>(IEnumerable<T> enm, whilecond<T> skip)

    bool doneskipping = false;

    foreach (T t in enm)

        if (doneskipping || !skip(t))

            doneskipping = true;

            yield return t;

         } // else

    } // foreach

Console.WriteLine("SkipWhile Test....");

foreach (string person in Iter.SkipWhile(people, LongerThan5))

    Console.WriteLine(person);   // Prints  "John", "Ross", "Joey"

Share this post: Email it! | bookmark it! | digg it! | reddit!