The experts in clean code advise not to use if/else since it's creating an unreadable code. They suggest rather using IF and not to wait till the end of a method without real need. 

Now, this if/else advice confuses me. Do they say that I should not use if/else at all (!) or to avoid if/else nesting?

Also, if they refer to the nesting of if/else, should I not do even a single nesting or I should limit it to max 2 nestings (as some recommends)?

When I say single nesting, I mean this:

    if (...) {

        if (...) {

        } else {

        }

    } else {

    }


EDIT

Also tools like Resharper will suggest reformatting if/else statements. It usually concerts them to if stand-alone statement, and sometimes even to ternary expression. 

I think this advice came from a software metric which called Cyclomatic complexity or Conditional complexity check this wiki page

Definition:


  The cyclomatic complexity of a section of source code is the count of
  the number of linearly independent paths through the source code. For
  instance, if the source code contained no decision points such as IF
  statements or FOR loops, the complexity would be 1, since there is
  only a single path through the code. If the code had a single IF
  statement containing a single condition there would be two paths
  through the code, one path where the IF statement is evaluated as TRUE
  and one path where the IF statement is evaluated as FALSE.


So


  Do they say that I should not use if/else at all (!) or to avoid
  if/else nesting?


No you shouldn't avoid if/else at all! but you should be careful about Cyclomatic complexity of your code. More code complexity tends to have more defects. According to this the right limit would be 11. A tool called Code Complete categorize the score like that Ref.:


0-5 - the routine is probably fine
6-10 - start to think about ways to simplify the routine
10+ - break part of the routine into a second routine and call it
from the first  routine


How to calculate Cyclomatic complexity "basically":

From example here:
consider the following pseudo code :

if (A=354) {

    if (B>C) {/*decision 1*/ A=B} else {/*decision 2*/ A=C}

   }/*decision 3 , in case A is NOT equal 354*/ 
print A


please note that this metric is concerned about number of decision in your program/code so from the code above we could say that we have 3 decisions ( 3 values of A)

let's calculate it formally so consider the following control flow of the code: 


The complexity M is then defined* as:Ref

M = E − N + 2P


where

E = the number of edges of the graph
N = the number of nodes of the graph
P = the number of connected components (exit nodes).


by applying the formula E(flow lines) = 8 , N (nodes)= 7 , P (exit nodes) =1
then M = 8-7 + (2*1) = 3

*there is also another definition stated but it is close :M = E − N + P check the reference for theory.

Please note that many of static code analysis tools could calculate the Cyclomatic complexity of your code.
