When to use Null Forgiving (!) vs Non-Nullable casts

surwren · 2022-11-01T23:20:37.545Z

```int? n = null; string input; if (int.TryParse(input,out _)) { n = int.Parse(input); } int[] arr = new int[(int)n]; ``` In this example, n needs to be cast from int? to int My question is why null forgiving (!) syntax does not seem to work (new int[n!];] and where null forgiving syntax would actually be applicable.

A

Angius•11/1/22, 11:22 PM

That's a very weird thing you're doing there tbh

A

Angius•11/1/22, 11:22 PM

Parsing once, discarding the result of the parse, then parsing again..?

S

surwrenOP•11/2/22, 12:03 AM

it's supposed to be

while(input==null){
if (int.TryParse(input,out _))
        {
            n = int.Parse(input);
        }
}

while(input==null){
if (int.TryParse(input,out _))
        {
            n = int.Parse(input);
        }
}

while(input==null){
if (int.TryParse(input,out _))
        {
            n = int.Parse(input);
        }
}

while(input==null){
if (int.TryParse(input,out _))
        {
            n = int.Parse(input);
        }
}

S

surwrenOP•11/2/22, 12:03 AM

I omitted the while loop because the question is about null forgiving vs non-nullable casting

S

surwrenOP•11/2/22, 12:04 AM

didn't wanna detract from the main query

A

Angius•11/2/22, 12:11 AM

You're still discarding the result of parsing for some reason

AAngius You're still discarding the result of parsing for some reason

S

surwrenOP•11/2/22, 12:13 AM

I'm discarding the parse in the if statement, I'm only assigning if the if statement is fulfilled

what's wrong with discarding if it's just a conditional checker?

A

Angius•11/2/22, 12:13 AM

Because then you parse it anyway

A

Angius•11/2/22, 12:14 AM

if (int.TryParse(input,out _))
{
    n = int.Parse(input);
}

if (int.TryParse(input,out _))
{
    n = int.Parse(input);
}

if (int.TryParse(input,out _))
{
    n = int.Parse(input);
}

if (int.TryParse(input,out _))
{
    n = int.Parse(input);
}

can just be

if (int.TryParse(input, out n))
{
    
}

if (int.TryParse(input, out n))
{
    
}

if (int.TryParse(input, out n))
{
    
}

if (int.TryParse(input, out n))
{
    
}

S

surwrenOP•11/2/22, 12:15 AM

This is the actual code

        if (int.Parse(input) < 0)
        {
            Console.Write("Number must be a positive integer. ");
            continue;
        }
        else if (!int.TryParse(input, out _))
        {
            throw new FormatException();

        }
        else if (int.TryParse(input, out _))
        {
            n = int.Parse(input);
        }

        if (int.Parse(input) < 0)
        {
            Console.Write("Number must be a positive integer. ");
            continue;
        }
        else if (!int.TryParse(input, out _))
        {
            throw new FormatException();

        }
        else if (int.TryParse(input, out _))
        {
            n = int.Parse(input);
        }

        if (int.Parse(input) < 0)
        {
            Console.Write("Number must be a positive integer. ");
            continue;
        }
        else if (!int.TryParse(input, out _))
        {
            throw new FormatException();

        }
        else if (int.TryParse(input, out _))
        {
            n = int.Parse(input);
        }

        if (int.Parse(input) < 0)
        {
            Console.Write("Number must be a positive integer. ");
            continue;
        }
        else if (!int.TryParse(input, out _))
        {
            throw new FormatException();

        }
        else if (int.TryParse(input, out _))
        {
            n = int.Parse(input);
        }

I will correct it to

        if (int.Parse(input) < 0)
        {
            Console.Write("Number must be a positive integer. ");
            continue;
        }
        else if (!int.TryParse(input, out _))
        {
            throw new FormatException();

        }
        else if (int.TryParse(input, out n))
        {        }

        if (int.Parse(input) < 0)
        {
            Console.Write("Number must be a positive integer. ");
            continue;
        }
        else if (!int.TryParse(input, out _))
        {
            throw new FormatException();

        }
        else if (int.TryParse(input, out n))
        {        }

        if (int.Parse(input) < 0)
        {
            Console.Write("Number must be a positive integer. ");
            continue;
        }
        else if (!int.TryParse(input, out _))
        {
            throw new FormatException();

        }
        else if (int.TryParse(input, out n))
        {        }

        if (int.Parse(input) < 0)
        {
            Console.Write("Number must be a positive integer. ");
            continue;
        }
        else if (!int.TryParse(input, out _))
        {
            throw new FormatException();

        }
        else if (int.TryParse(input, out n))
        {        }

A

Angius•11/2/22, 12:15 AM

You can even, instead of doing

int? n = null;
if (int.TryParse(input,out _))
{
    n = int.Parse(input);
}
var arr = new int[n];

int? n = null;
if (int.TryParse(input,out _))
{
    n = int.Parse(input);
}
var arr = new int[n];

int? n = null;
if (int.TryParse(input,out _))
{
    n = int.Parse(input);
}
var arr = new int[n];

int? n = null;
if (int.TryParse(input,out _))
{
    n = int.Parse(input);
}
var arr = new int[n];

do

if (int.TryParse(input, out var n))
{
    var arr = new int[n];
}

if (int.TryParse(input, out var n))
{
    var arr = new int[n];
}

if (int.TryParse(input, out var n))
{
    var arr = new int[n];
}

if (int.TryParse(input, out var n))
{
    var arr = new int[n];
}

and guarantee that

n

n will never be

null

null

null

null

A

Angius•11/2/22, 12:16 AM

Also, you're using

int.TryParse()

int.TryParse()

int.TryParse()

int.TryParse(), something made explicitly for the purpose of avoiding throwing format exceptions... to throw a format exception

S

surwrenOP•11/2/22, 12:17 AM

oh so that's what's triggering it

S

surwrenOP•11/2/22, 12:17 AM

smh

S

surwrenOP•11/2/22, 12:17 AM

so parse is throwing the exception

S

surwrenOP•11/2/22, 12:17 AM

that's good actually

S

surwrenOP•11/2/22, 12:18 AM

it severely shortens my code

A

Angius•11/2/22, 12:18 AM

Your best bet is to parse once, with

.TryParse()

.TryParse()

.TryParse()

.TryParse()

S

surwrenOP•11/2/22, 12:18 AM

and then just catch the exceptions after

S

surwrenOP•11/2/22, 12:18 AM

i will do this

S

surwrenOP•11/2/22, 12:18 AM

thank you

A

Angius•11/2/22, 12:19 AM

if (int.TryParse(input, out var num))
{
    if (num < 0)
    {
        // ...
    }
    if (num % 2 == 0)
    {
        // ...
    }

    var arr = new int[num];
    // etc
}

if (int.TryParse(input, out var num))
{
    if (num < 0)
    {
        // ...
    }
    if (num % 2 == 0)
    {
        // ...
    }

    var arr = new int[num];
    // etc
}

if (int.TryParse(input, out var num))
{
    if (num < 0)
    {
        // ...
    }
    if (num % 2 == 0)
    {
        // ...
    }

    var arr = new int[num];
    // etc
}

if (int.TryParse(input, out var num))
{
    if (num < 0)
    {
        // ...
    }
    if (num % 2 == 0)
    {
        // ...
    }

    var arr = new int[num];
    // etc
}

A

Angius•11/2/22, 12:19 AM

No

A

Angius•11/2/22, 12:19 AM

Why catch exceptions

A

Angius•11/2/22, 12:19 AM

int.TryParse()

int.TryParse()

int.TryParse()

int.TryParse() lets you avoid exceptions

A

Angius•11/2/22, 12:19 AM

Don't make your life harder for no reason

S

surwrenOP•11/2/22, 12:19 AM

I'm trying to intentionally throw and catch exceptions

S

surwrenOP•11/2/22, 12:19 AM

it's a learning type of thing

S

surwrenOP•11/2/22, 12:19 AM

I'm just gonna throw them more efficiently

A

Angius•11/2/22, 12:20 AM

Rethrowing an exception isn't any more efficient than letting it bubble up lol

C

cap5lut•11/2/22, 12:20 AM

exceptions are never efficient

S

surwrenOP•11/2/22, 12:20 AM

yea

A

Angius•11/2/22, 12:20 AM

But sure

A

Angius•11/2/22, 12:20 AM

As long as you never actually do it this way in the wild

A

Angius•11/2/22, 12:20 AM

Kinda like learning to use a spoon by peeling an apple with it

A

Angius•11/2/22, 12:20 AM

But whatever works for you

M

MODiX•11/2/22, 12:21 AM

Sorry @surwren your message contained blocked content and has been removed!

S

surwrenOP•11/2/22, 12:21 AM

I'm ret(@)rded ok

S

surwrenOP•11/2/22, 12:21 AM

i need to learn by getting my hands dirty

S

surwrenOP•11/2/22, 12:21 AM

this is my own way of learning exception propagation

S

surwrenOP•11/2/22, 12:22 AM

but you guys have been a great help, thank you

S

surwrenOP•11/2/22, 12:22 AM

why doesn't this board let me insult myself

S

surwrenOP•11/2/22, 12:22 AM

C

cap5lut•11/2/22, 12:22 AM

because it just detects the insult, not whom it refers to

S

surwrenOP•11/2/22, 12:25 AM

it's not letting me do it

S

surwrenOP•11/2/22, 12:25 AM

S

surwrenOP•11/2/22, 12:26 AM

When to use Null Forgiving (!) vs Non-Nullable casts

Similar Threads

Similar Threads

Similar Threads