Welcome to the Lounge

R. Giskard Reventlov wrote:

size of Texas

using System;

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

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

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

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<string>(ref astring1, SomeFuncOkay);
DodgyResult dr2 = Dodgy.RunDodgy<string>(ref astring2, SomeFuncNull);
DodgyResult dr3 = Dodgy.RunDodgy<string>(ref astring3, SomeFuncError);

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);
        }
    }
    
    public static DodgyResult<TResult> RunDodgy<T, TResult>(Func<T, TResult> dodgyFunc, T arg)
    {
        try
        {
            return Success(dodgyFunc(arg));
        }
        catch (Exception ex)
        {
            return DodgyResult<TResult>.Failure(ex);
        }
    }

    // TODO: "RunDodgy" overloads for the other Func<...> types...
}

var dr1 = DodgyResult.RunDodgy(SomeFuncOkay, "hello");
var dr2 = DodgyResult.RunDodgy(SomeFuncNull, "doctor");
var dr3 = DodgyResult.RunDodgy(SomeFuncError, "name");

SomeOtherMethod(
    (string)dr1, // Throws an exception if dr1 is a failure;
    dr2 ? (string)dr2 : null, // Using the bool operators and explicit cast;
    dr3.GetValueOrDefault("continue") // Providing a default value;
);

string result = DodgyApi.GetValue?*.();

John Simmons / outlaw programmer wrote:

And why aren't you working on my latest feature request?

John Simmons / outlaw programmer wrote:

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

#pragma on error resume next

// ... code you wouldn't let your worst enemey near

string result = DodgyApi.GetValue().OrDefault();

class DodgyApiAdapter: IDodgyApi {
    string GetValue() {
        try {
           string result = _dodgyApiImpl.GetValue();
           return result;
        }
        catch {
           return null;
        }
    }
}

string result = dodgyApiAdapterInst.GetValue();

string GetString(int x)
{
    throw new NotImplementedException();
}

void Foo()
{
    string s = NoEx.Run(() => GetString(100));
    Console.WriteLine(s == null);
}

class NoEx
{
    public static T Run<T>(Func<T> method)
    {
        try
        {
            return method();
        }
        catch
        {
            return default(T);
        }
    }
}

var s = (() => GetString(100)).IgnoreExceptions();

var s = (() => GetString(100)).Ignore<ArgumentException>();