1

OK - so maybe I'm tired, but I'm trying figure out a way to do the following (one which seems... more... elegant?)

  • I have a boolean value (we'll call it loopTwice)
  • loopTwice is used by (and modifies the behavior of) the contents of the loop to perform mutually exclusive functions
  • If loopTwice is true, I want the loop to execute twice, first with the value true, then with the value false
  • If loopTwice is false, I want the loop to only execute once, with the value false
  • loopTwice is not used after the loop, so it doesn't matter what the final value is

...that seems to make enough sense, but for some reason, my brain is not coming up with anything more elegant than a while-loop that has an if condition towards the end with a break:

// loopTwice is already set as true or false
while (true) //this seems ugly, not to mention breakable...
{
    DoThis(loopTwice);          //these act slightly differently based upon loopTwice
    DoThat(loopTwice);          //these act slightly differently based upon loopTwice
    DoAnotherThing(loopTwice);  //these act slightly differently based upon loopTwice

    if (!loopTwice) break;
    loopTwice = false;
}

This code (well, not this code, but equivalent code...) works exactly as I would like it without provisioning another variable (I guess that's not such a bad thing, but I don't see using another variable making any loop more elegant than this one...)

It seems to me there must be something I'm missing (a way to loop twice if something is true and once if something is false, with the "false" value always being last - and preferably without a second variable, like a counter or a second flag to indicate the loop has already run once).

Is it actually more elegant to use a counter or flag? (I guess with computers of the past several decades, it doesn't really risk breaking memory requirements or anything, does it...). Would breaking this into a function and using recursion be more elegant? hmm...

Elegance, of course, is in the eye of the beholder...

Improve this question

6 Answers 6

Reset to default
4

I'm assuming that you've got enough common code for both loop iterations that it makes sense to keep it as a loop. You can write this easily as a do...while loop:

do {
  ....
} while (!(loopTwice = !loopTwice));
Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Your assumption is correct - I've gotta run this through my brain... it's a bit slow today (I think it's running Norton Anti virus in the background)... but it looks like what I'm looking for :-) - be back in a bit
This was along the lines of what I had been originally thinking must be possible, but I think I'll have to go with recursion - even though it requires me to decompose into a separate function. I'm glad you love the simplicity of @SiLo's answer!
3

Just to add another method here, recursion!

void MyRecursiveMethod(bool repeat)
{
   // Do something here.

   // Should we do this more than once?
   if(repeat)
     MyRecursiveMethod(false); // Don't do this indefinitely!
}

EDIT: This also allows you to easily extend this to n iterations if necessary, not just two.

For example, in the future you decide you may need to execute this three times, you can change it to int repeatCount instead of a simple bool and then just decrement each time.

Improve this answer

2 Comments

I love the simplicity of this.
Though I'm not eagerly anticipating refactoring/decomposing into a function, it is a bit more "elegant" (in the simple and readable sense of the word) than the answer provided by @hvd - as admirable as that answer is - he's got enough points anyways :-P. Thanks both of you!
2

Using boolean flags to indicate how many times you want to loop seems to obscure your intention to the reader (at least, this one). I'd prefer something like this:

int loops = someFlag ? 2 : 1;
while(loops-- > 0) {

    DoThis(someFlag);
    DoThat(someFlag);
    DoAnotherThing(someFlag);

}

It expresses your intent clearly: loop 2 times if the flag is true, execute only once if the flag is false. Also, it would let you modify the loop iterations in the future really easily. No recursion, no additional functions, resilient to number of iterations needed, readable, etc.

Edit

Adding an inner flag to express the intent of having the flag always false on the final iteration, which is still resilient to the number of loops required. Also, I changed to pre-decrementing the loop variable so the inner loops isn't comparing against 0:

int loops = someFlag ? 2 : 1;
while (--loops >= 0) {
    bool lastIter = loops == 0;

    DoThis(someFlag && !lastIter);
    ...
}
Improve this answer

2 Comments

interesting... uses a separate variable, but not too bad! strictly for my purposes, it needs to have someFlag always be false during the last iteration, but I've gotta +1 at least for the username choice :-D
I missed that requirement. I've edited my answer to include an inner variable which should clearly express the intent to the reader (a big thing for me, clearly) of having the flag be false on the final iteration.
1

This kind of feels like a 'count down' loop but with booleans. You can figure out the booleans to use:

var iterations = new[] {true,false}.SkipUntil(e => e == loopTwice);
// or
var iterations = new[] {true,false}.Skip(loopTwice ? 0 : 1);
// or
var iterations = loopTwice? new[] {true, false} : new[] {false};

Then use them:

foreach (var b in iterations) {
    DoThis(b);
    DoThat(b);
    DoAnotherThing(b);
}
Improve this answer

2 Comments

I see your point, except the example abstraction calls only two functions (one in each situation), while my actual code has seven function calls that are the same functions, but act on the boolean differently (well some of them act differently)
@CodeJocket Ah. I'll handle the general case then.
0

Would something like this work or strike your fancy?

switch (count) {
     case 0:
        break;
     case 1:
        doThisThingSecond();
        goto case: 2;
     case 2:
        doThisThingFirst();
        break;
}
Improve this answer

2 Comments

C# doesn't allow one case to fall through to another. It does, however, extend the goto syntax to allow goto case 2;, if you really want to.
Right you are, Ken. Corrected
0

After reconsidering the requirements, I'd really suggest adding another method. Wrapping another method or a bunch of methods is a very common pattern (facade, etc.) and will make your code very readable. All this obfuscation using Linq and recursion takes away from your original intent. Adding an additional method or variable will have negligible impact on the performance of your code unless you're running on 1980s hardware.

Here's my other suggestion:

void ExecuteWithFlag(bool withFlag)
{
    DoSomething(withFlag);
    DoSomethingElse(withFlag);
    // etc.
}

void Execute()
{
    ExecuteWithFlag(true);
    ExecuteWithFlag(false);
}
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.