Not really, because rust doesn't have exceptions. Instead you are encouraged to handle every possible case with pattern matching. For example:

fn maybe_add_one(number: Option<u8>) -> u8 {
    match number {
        None => 0,
        Some(i) => i + 1,
    }
}

Option is a type which can either be some 8bit unsigned integer, or none. It's conceptually similar to a Nullable<int> in C#.

In C# you could correctly implement this like:

public int MaybeAddOne(int? number)
{
    if (number.HasValue)
    {
        return number.Value + 1;
    }

    return 0;
} 

In rust, you can call Unwrap on an option to get the underlying value, but it will panic if the value is None (because None isn't a u8):

fn maybe_add_one(number: Option<u8>) -> u8 {
    number.unwrap() + 1
}

In some cases unwrap could be useful if you don't care about a panic or if you know the value can't be None. Sometimes it's just used as a shortcut. You can likewise do this in C#:

public int MaybeAddOne(int? number)
{
    return number.Value + 1;
} 

But this throws an exception if number is null.

A panic isn't the same as an exception though, you can't 'catch' a panic, it's unrecoverable and the program will terminate more-or-less immediately.

Rust provides a generic type Result<T, E>, T being a successful result and E being some error type, which you are encouraged to use along with pattern matching to make sure all cases are handled.