How about new syntactical sugar for exception checking?

[Foothill]

To those of who still use pointers (even in .Net), using (*) might be a little confusing but I have an idea. How about using a construct similar to the for loop

// similar to...
for (int i = 0; i < limit; ++i) { ... }

// you can have
NoThrow (var <out>; Func<T>; <result on throw>);

// so your example becomes
string result;
NoThrow (result; dodgyApi.GetValue(); "I.M.Foo.Bar");

if (Object.DividedByZero == true) { Universe.Implode(); } Meus ratio ex fortis machina. Simplicitatis de formae ac munus. -Foothill, 2016

[Joe Woodbury]

"new" doesn't mean what you think it does.

[Chris Maunder]

Too explicit. We need something that truly, deeply hides what's going on ;)

cheers Chris Maunder

[Foothill]

If that's the end goal, just use a carrot (^) instead of equals. That way anyone the uses managed C++ is really hosed. :laugh:

string result ^ dodgyApi.GetValue();

if (Object.DividedByZero == true) { Universe.Implode(); } Meus ratio ex fortis machina. Simplicitatis de formae ac munus. -Foothill, 2016

[BillWoodruff]

using System;

namespace InMemoriamMaunder
{
public enum DodgyResult
{
ResultNull,
ResultNonNull,
ResultError
}

public static class Dodgy
{
    public static DodgyResult RunDodgy(ref T param, Func dodgyFunc)
    {
        try
        {
            param = dodgyFunc(param);

            if (param == null)
            {
                return DodgyResult.ResultNull;
            }
            else
            {
                return DodgyResult.ResultOkay;
            }
        }
        catch (Exception)
        {
             return DodgyResult.ResultError;
        }
    }
}

}

Tests:

private string SomeFuncError(string astring)
{
astring = null;
return astring.ToString();
}

private string SomeFuncNull(string astring)
{
astring = null;
return astring;
}

private string SomeFuncOkay(string astring)
{
astring = astring + astring;
return astring;
}

string astring1 = "hello";
string astring2 = null;
string astring3 = "whatever";

DodgyResult dr1 = Dodgy.RunDodgy(ref astring1, SomeFuncOkay);
DodgyResult dr2 = Dodgy.RunDodgy(ref astring2, SomeFuncNull);
DodgyResult dr3 = Dodgy.RunDodgy(ref astring3, SomeFuncError);

Now, Chris, all you have left to do is boil this down to a single operator :)

«There is a spectrum, from "clearly desirable behaviour," to "possibly dodgy behavior that still makes some sense," to "clearly undesirable behavior." We try to make the latter into warnings or, better, errors. But stuff that is in the middle category you don’t want to restrict unless there is a clear way to work around it.» Eric Lippert, May 14, 2008

[PIEBALDconsult]

Just something along the lines of a TryGetValue<T> Extension Method. :shrug:

[BillWoodruff]

You get my up-vote for the idea, but making the idea more general-purpose means, imho, not being able to use an Extension method with generics, since the 'this parameter of an Extension method cannot be declared 'ref, or 'out. How about this (based on the code example in my previous reply to this thread)

using System;

namespace InMemoriamMaunder
{
public enum DodgyResult
{
ResultNull,
ResultOkay,
ResultError
}

public static class DodgyUtilities
{
    public static DodgyResult TryGetValueFromDodgy<T1,T2>(T1 t1, ref T2 t2, Func<T1,T2> func)
    {
        try
        {
            t2 = func(t1);

            if (t2 == null)
            {
                return DodgyResult.ResultNull;
            }
            else
            {
                return DodgyResult.ResultOkay;
            }
        }
        catch (Exception)
        {
            return DodgyResult.ResultError;
        }
    }
}

}

«There is a spectrum, from "clearly desirable behaviour," to "possibly dodgy behavior that still makes some sense," to "clearly undesirable behavior." We try to make the latter into warnings or, better, errors. But stuff that is in the middle category you don’t want to restrict unless there is a clear way to work around it.» Eric Lippert, May 14, 2008

[Sander Rossel]

John Simmons / outlaw programmer wrote:

On the "?" operator - I will strive NEVER to use that.

Why? :confused:

Read my (free) ebook Object-Oriented Programming in C# Succinctly. Visit my blog at Sander's bits - Writing the code you need. Or read my articles here on CodeProject.

Simplicity is prerequisite for reliability. — Edsger W. Dijkstra

Regards, Sander

[Roger Wright]

No programming questions in the Lounge! ;P

Chris Maunder wrote:

Or am I setting a new standard for lazy, shameful programming here this hot, lazy afternoon?

Surely you jest! It's only 117° today, but we're supposed to warm up for the weekend.

Will Rogers never met me.

[Duncan Edwards Jones]

how about setting that as default for the whole app... you could use a constant like #ON_ERROR_RESUME_NEXT = true; ;P

[CPallini]

:thumbsup:

[realJSOP]

Because it obfuscates the code, and because I'm not yet coding in the appropriate version of .Net.

".45 ACP - because shooting twice is just silly" - JSOP, 2010
-----
You can never have too much ammo - unless you're swimming, or on fire. - JSOP, 2010
-----
When you pry the gun from my cold dead hands, be careful - the barrel will be very hot. - JSOP, 2013

[Gary Wheeler]

Who are you, and what have you done with that nice, wholesome Mr. Maunder?

Software Zen: delete this;

[Richard Deeming]

Foothill wrote:

To those of who still use pointers (even in .Net), using (*) might be a little confusing

And to those of us who use multiplication. :)

---

"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer

[Richard Deeming]

How about something like this:

public abstract class DodgyResult<T>
{
public abstract bool Succeeded { get; }
public abstract T Value { get; }
public abstract Exception Error { get; }

public T GetValueOrDefault(T defaultValue = default(T))
{
    return Succeeded ? Value : defaultValue;
}

public static DodgyResult<T> Success(T value)
{
    return new SuccessResult(value);
}

public static DodgyResult<T> Failure(Exception error)
{
    return new ErrorResult(error);
}

// Explicit cast to the return type; 
// throws an InvalidOperationException if this is a failure result:
public static explicit operator T(DodgyResult<T> result)
{
    return result.Value;
}

// Allow the result to be treated as a bool value indicating success:
public static bool operator true(DodgyResult<T> result)
{
    return result.Succeeded;
}

public static bool operator false(DodgyResult<T> result)
{
    return !result.Succeeded;
}

private sealed class SuccessResult : DodgyResult<T>
{
    public SuccessResult(T value)
    {
        Value = value;
    }
    
    public override bool Succeeded => true;
    public override T Value { get; }
    public override Exception Error => null;
}

private sealed class ErrorResult : DodgyResult<T>
{
    public ErrorResult(Exception error)
    {
        Debug.Assert(error != null);
        Error = error;
    }
    
    public override bool Succeeded => false;
    public override Exception Error { get; }
    
    public override T Value 
    { 
        // Wrap the error in a new exception to preserve the original stack trace:
        get { throw new InvalidOperationException(Error.Message, Error); }
    }
}

}

public static class DodgyResult
{
// Helper to let the compiler infer the generic parameter:
public static DodgyResult<T> Success<T>(T value)
{
return DodgyResult<T>.Success(value);
}

public static DodgyResult<T> RunDodgy<T>(Func<T> dodgyFunc)
{
    try
    {
        return Success(dodgyFunc());
    }
    catch (Exception ex)
    {
        return DodgyResult<T>.Failure(ex);

[Dan Neely]

Why not make it a compiler flag that can be set once per file.

#pragma OnError ResumeNext

Did you ever see history portrayed as an old man with a wise brow and pulseless heart, waging all things in the balance of reason? Is not rather the genius of history like an eternal, imploring maiden, full of fire, with a burning heart and flaming soul, humanly warm and humanly beautiful? --Zachris Topelius Training a telescope on one’s own belly button will only reveal lint. You like that? You go right on staring at it. I prefer looking at galaxies. -- Sarah Hoyt

[TheGreatAndPowerfulOz]

Just NO!

#SupportHeForShe Government can give you nothing but what it takes from somebody else. A government big enough to give you everything you want is big enough to take everything you've got, including your freedom.-Ezra Taft Benson You must accept 1 of 2 basic premises: Either we are alone in the universe or we are not alone. Either way, the implications are staggering!-Wernher von Braun

[agolddog]

Chris Maunder wrote:

string result = DodgyApi.GetValue*();

What about string result = DodgyApi.GetValue*(value); as you don't always want the type default. Not sure how we define my value for reference types, maybe it could use the C# new type { prop1 = val1, ...} paradigm? Anyway, no, bad idea. I want to fire people who silently swallow exceptions. At least, the code should be logging at some level, "hey, DodgyApi failed, using default value x" so that (in theory) somebody could investigate and make the api somewhat less dodgy.

[Chris Maunder]

I just love to imagine the absolute mayhem such a pragma would allow.

cheers Chris Maunder

[englebart]

Don't use DodgyApi directly. string result = MyDodgyApiWrapper.GetValue(); Your wrapper can log any exceptions, provide a reasonable default value "Service unavailable. Try back later.", etc. If a better backend evolves later, just update your wrapper.