Develop Reference

How can I avoid code duplication in C# while and do-while loops?

I have a loop inside a C# method that has the following structure.
do
{
getUserInput();
if (inputIsBad)
{
doSomethingElse();
}
} while (inputIsBad);
alternately, with a while loop:
getUserInput();
while (inputIsBad)
{
doSomethingElse();
getUserInput();
}
But both methods use redundant code: the do-while has both an if statement and while loop checking the same condition; the while loop calls getUserInput() both before and inside the loop.
Is there a simple, non-redundant, non-ad hoc way to do what these method patterns do, either generally or in C# specifically, that only involves writing each basic component once?

Assuming that getUserInput(..) can be converted into a expression yielding a boolean value*..
while (getUserInput()
&& isBadInput()) {
doSomethingElse();
}
// Prompts for user input, returns false on a user-abort (^C)
private bool getUserInput() { .. }
Other variations (presumed without non-local state) shown in comments.
*Trivially, it can always be written as a wrapping function - see Local Functions, introduced in C#7. (There are other methods for the same effect, some of which I consider 'too clever'.)
// local function
bool getUserInputAlwaysTrue() {
getUserInput(); // assume void return
return true;
}
while (getUserInputAlwaysTrue()
&& isBadInput()) {
doSomethingElse();
}
This can be followed to pushing out the logic further, in some cases. The general premise holds: getUserInput() is always invoked prior to the next isBadInput().
// local function or member method
// Prompt for user input, returning true on bad input.
bool getCheckedUserInput() {
getUserInput(); // assume void return
return isBadInput();
}
while (getCheckedUserInput()) {
doSomethingElse();
}

do
{
getUserInput();
if (!inputIsBad) break;
doSomethingElse();
} while (true);

I would use a boolean variable, which you need to declare outside the body of the loop. That way you only need to run the inputIsBad check once. I have turned it into a method as well, since that seems more logical.
bool badInput = true; // Assume bad until checked -- failsafe.
do
{
getUserInput();
badInput = inputIsBad();
if (badInput)
{
doSomethingElse();
}
} while (badInput);

Building on user2864740's answer:
Assume getUserInput() can be converted into a function which returns true if the input is good and bad otherwise. Assuming its original return type wasn't boolean or void, return its original return value via an out or ref parameter depending on the case, e.g.
int originalReturnValue;
while (!getUserInput(out originalReturnValue))
{
doSomethingElse();
}
...
bool getUserInput<T>(out T output)
{
// method body
}

Why is a return required when Environment.Exit() is used, but not for a thrown exception?

I'm trying to better understand the compiler for C#. It insists that all code paths must return a value, and I think that's pretty fair.
It also recognizes that if an exception is thrown in a path where a value would need to be returned, that there is no point in returning something there. This also makes sense.
My question is: why wouldn't this also apply for exiting the program in a more graceful manner? e.g Environment.Exit()
-Examples-
This will compile:
private string TestMethod(int x, int y)
{
if (x == y)
{
return "this is a string";
}
throw new Exception();
// No point in a return after this, it could never be reached.
}
This will NOT compile:
private string TestMethod(int x, int y)
{
if (x == y)
{
return "this is a string";
}
Environment.Exit(1);
// This will not compile.
// "Not all code paths return a value"
// But, the code would never make it to the return here.
}

Environment.Exit is nothing but a method as far as the compiler is concerned.
It enforces that the TestMethod either return a value or throw an exception. Calling a method that might terminate the application or do something completely different is not a valid way to "return" from a method.

If-statement: Best way to handle layering with same condition

I'm pretty new to programming, but I've been trying to make sure I learn good design practices. My question is related to how to handle this sort of if-statement situation, as it seems to violate Don't Repeat Yourself.
I have a class with a constructor that includes a method to connect to a database. The method will write to a string if there was an error in the connection code block. I then have a process method that analyzes metadata of the database, and will also write errors if any are found. I don't want the metadata analysis to run if there was already an error in the connection method, but is this the best way to do this?:
public bool Process()
{
if (ErrorLog == null)
{
//Metadata analysis code that may write errors
if (ErrorLog == null)
return true;
else
PublishErrorLog();
return false;
}
else
PublishErrorLog();
return false;
}

You final function could look as simple as this:
public bool Process()
{
if (hasError())
return false;
//Metadata analysis code that may write errors
//Note that error log may change here
return !hasError(); //updated by juharr
}
Explanation:
The code you present may not be exactly same condition if the line with //metadata analysis could actually change the state of ErrorLog.
Simplification Step 1: Single If-Else Loop
Seeing your nested loop however, I would rather make the codes become easier to handle and to read by doing something like this
public bool Process()
{
if (ErrorLog != null){
PublishErrorLog();
return false;
}
//Metadata analysis code that may write errors
//Note that error log may change here
if (ErrorLog != null){
PublishErrorLog();
return false;
}
return true;
}
Basically, rather than making nested if-else, you make simple statement which can be returned first. Then you return if it is satisfied, else you continue.
This way, your code become single conditional loop - no nested loop.
Simplification Step 2: Error Log + Has Error Combined Function
You could further improve the code above still, given that your error logging pattern is the same, you could create function like this
bool hasError(){
if (ErrorLog != null){
PublishErrorLog();
return true;
}
return false; //no error, can continue
}
Final Code
Then the Process function would look like
public bool Process()
{
if (hasError())
return false;
//Metadata analysis code that may write errors
//Note that error log may change here
return !hasError(); //updated by juharr
}
Very concise. And you can repeat the pattern elsewhere too.

The other answers are valid. But to me this looks like a perfect case for using Exceptions. Anytime you would write to ErrorLog also throw an exception. Then you can have exactly one block at the top that handles the error.
public bool Process()
{
if (ErrorLog != null)
//At this point, the PublishErrorLog should have already been called.
return false;
try
{
// Do Metadata analysis that may throw errors
}
catch (ErrorLogException e)
{
PublishErrorLog()
return false;
}
return true;
}
This has the advantage that the metadata analysis can be as complicated and nested as you need. It just needs to throw the exception.
EDIT:
As pointed out by Aron, this can be done without having ErrorLog as a class member at all. The log information can be stored in the exception itself. The catch block could look like:
catch (ErrorLogException e)
{
var logMessage = e.logMessage;
PublishErrorLog(logMessage);
return false;
}

It seems that you are using your ErrorLog property to signal the validity of your connection. If the ErrorLog is a string, as I understand from your question, I would have a specific way to tell if the connection is valid or not, and don't rely on the nullity of the log.
e.g.
public bool Process()
{
if (HasValidConnection)
{
//Metadata analysis code that may write errors
}
if (ErrorLog == null)
{
// no errors establishing the connection neither processing metadata
return true;
}
else
PublishErrorLog();
return false;
}

Unreachable code and not all code paths return a value

Ok I'm getting an unreachable code and not all code paths return value from this block of code
private string MoveForward()
{
//if current direction is east, GetRoomEast
if (Player.CurrentDirection == "EAST")
{
return GetroomEast();
if (Player.NextMove != "")
{
Player.Y++;
}
else
{
Console.WriteLine("You Bumped into a Wall");
}
//if GetRoomEast is not "", then playercol = playercol+1;
//if current direction is west...
}
}
and my initialized variables at the top are
public struct DragonPlayer
{
public int X, Y;
public string CurrentDirection;
public string NextMove;
}
public class DragonGameboard
{
public string[,] GameboardArray;
public DragonPlayer Player;
private Random r;
public DragonGameboard()
{
GameboardArray = new string[4, 4];
Player.CurrentDirection = "EAST";
Player.NextMove = "";
r = new Random();
Player.X = r.Next(0, 4);
Player.Y = r.Next(0, 4);
GenerateRandomBoard();
}
}
Why is it doing this? I'm sure it has to be something really silly but I'm having trouble figuring out what it is?

You are returning from your function before your if statement,it's never going to your if statement.Therefore your if statement become unreachable code
return GetroomEast();
if (Player.NextMove != "")
You should put this return statement after the if statement.

You defined your MoveForward() forward method to return a string, but you're not returning one. Change the definition to:
private void MoveForward();
...or return a string.

Every path of your code has to return value of type string. Plus you have code that can never execute, namely:
if (Player.NextMove != "")
{
Player.Y++;
}
else
{
Console.WriteLine("You Bumped into a Wall");
}
You've already returned a value, so nothing after that gets executed.
Furthermore, every path that results in ending of the function HAS TO return a value. Go through your code logically and find the scenarios, you'll find plenty.
Maybe I'd suggest to start slow and learn the basics, because these mistakes are really fundamental to any programming language + you already got the message, that is pretty clear. Programming games isn't really a good starting point for programmers.

I have added comments in the code to show you why have unreachable code and why all code paths do not return a value.
private string MoveForward()
{
if (Player.CurrentDirection == "EAST")
{
return GetroomEast(); //Once you return the value here it ends the call.
if (Player.NextMove != "") //This line (or anything below it) will never run.
{
Player.Y++;
}
else
{
Console.WriteLine("You Bumped into a Wall");
}
//if GetRoomEast is not "", then playercol = playercol+1;
//if current direction is west...
}
//We reach here if Player.CurrentDirection does not equal "EAST"
//As there is no more code there is no returned value.
//You would need to do something like return NoValidMove()
}

After this line, return GetroomEast() the execution is bailed out of the loop and hence, u are getting unreachable code error. Also nothing is returned inside the next if , else blocks. As your method is of string return type....it has to return string..

Use of return keyword in code block

What is the difference between saying:
if (abc == "a")
{
// do something here...
return;
}
and the same as above, but without the return keyword?
I am a C# coder and I know that the return keyword followed by a type or variable returns that item, but in the above context, return seems to be just to exit the code block but does it make any functional or performance change on the code?
Thanks

"return" exits from the function, not just the enclosing code block. So if your code block was in the context of a function, like so (I don't know C# so I'm using Java syntax):
int thisIsAFunction(int a) {
if (abc == "a")
{
// do something here...
return 1;
}
// do something else here...
}
if abc == "a" then the "do something else here" will not run. But if you removed the return statement inside the if block, then it would run.

return statement exits the function immediately, so it might have performance benefits as the following code in the function would not be executed at all.

MSDN
The return statement terminates execution of the method in which it appears and returns control to the calling method. It can also return an optional value. If the method is a void type, the return statement can be omitted.
Example
//this would do nothing
public void method()
{
return;
}
//this would return true
//notice the return type of bool this means
//the method expects a true\false value
public bool method2()
{
return true;
}
public void test()
{
if(method2())
method()
}
Now if you ran test method2 would always return true and method1 would just end its processing

The return statement does exit the current method, not just the code block (for/while/if/etc). So it is useful for situations like the following:
public void MyMethod(object myObject)
{
if (myObject == null)
{
return; // exits method.
}
// do something with myObject
}
Additional info: I will point out, that many people prefer to have one exit point in a method, however, it can be useful to do something similar to the example here in some cases. I would always try to find ways to limit the number of return or exit points in your method.

In your case, no - but if you had other code after your 'if' statement that you only wanted to run if your statement was false (e.g. if abc != "a"), then the return allows you to bypass that and exit the function / method.

In a loop or case statement, you can use break to achieve this result. This doesn't work on if statements or code blocks in general though.
And yes, return exits the enclosing function.

Executing the return statement will make the execution jump out of the method. Without the return, it would simply go on with the next statement instead.

Yes, your method does not have return type in this case.
e.g.
public void Foo
{
if (abc == "a")
{
// do something here...
return;
}
// some other code
}
This is to say if abd = "a", then exit the method so that some other code won't be executed.

It can be a cleaner way of writing code. I typically do it in a guard clause at or near the beginning of a method. If you have an error condition, just "return" out of the method. It saves wrapping the rest of your work in an else block. Seems trivial, but it helps to reduce code complexity.