Readability with "if (! mybool)" statement in C#. Is there another way?

Another hat being thrown in the ring. I also like to avoid having exclamation marks (simply personal preference) in the conditions, but also accept that sometimes it's unavoidable. However in some situations consider how you can invert the boolean value before it reaches the condition.

Most of the time your booleans are going to be produced from inline condition statements and method invocations, so you can invert the value at those points.

For example:

var idIsPositive = id > 0;
var accountExists = IsAccount(id);

if (!idIsPositive|| !accountExists) {
  // show an error
}

Could be:

var idIsInvalid = id <= 0;
var accountIsMissing = !IsAccount(id);

if (idIsInvalid || accountIsMissing) {
  // show an error
}

Just make sure that you use really good naming conventions for your variables. Nothing is worse than reading code and the variables don't make sense in the context, even moreso than having reallyLongVariableNamesUnncessarily;

To be honest, all your attempts at "getting round" what you see as a problem are ugly, inefficient, and unnecessary - and would almost certainly fail code reviews everywhere I've seen.
And make your code look "student grade" at the same time!

If you can't "see" the exclamation mark, then increase the font size of your IDE - "!" is quite large and visible compared to ".", ",", "^", and "~" for example, and missing any of them would make your code even harder to read.

if (!int.TryParse(userInput, out qtyOfCheese))
   {
   ...
   }

Is pretty standard code!

Readability with "if (! mybool)" statement in C#. Is there another way?

If really you can't read code with an '!', you will have big problems reading other's code and samples codes.
You can also try:

if (myBool)
{
    DoTrue();
}
else
{
    DoFalse();
}

How code reads is more important then how it "looks"

How do you read: (and we mostly read left to right)

if(!IsSuccess)

Left to right as coded:
If not IsSuccess

With human pre-processing, by reading the statement and then adding words:
If IsSuccess is false or If IsSuccess equals false

Compare to

if(IsSuccess is false) or if(IsSuccess == false)

Left to right:
if IsSuccess is false or if IsSuccess equals false

So we end up reading and not interpreting the code using the syntax above

Removing the interpretation step allows our pattern recognition brain to scan once and obtain meaning, resulting in fewer logic errors.

So when I see code like the above I see a developer with tons of experience who writes code that will be read by humans (mostly left to right) -- weighting debugging over looks, and we know we'll spend more resources later debugging or extending where we must trust the original intent is clear, i.e.

The probable intent of

if( IsSuccess is false ) is higher then if(!IsSuccess) because the developer dictated in their head, what was coded left to right