xsharp.eu

Code: Select all

public class CIOResult<T>
{
    /// <summary>
    /// Enum of different outcomes eg Success, NotFound, etc
    /// </summary>
    public CIOResultType Result { get; set; }

    /// <summary>
    /// Optional Exception object that can be returned for debugging.
    /// </summary>
    public Exception CIOException { get; set; }

    /// <summary>
    /// Construtor used when a call has failed, and an exception is to be returned.
    /// </summary>
    /// <param name="result">Result enum value.</param>
    /// <param name="excep">Exception object.</param>
    public CIOResult(CIOResultType result, Exception excep)
    {
        Result = result;
        CIOException = excep;
    }

    /// <summary>
    /// Constructor used when a value is to be returned.
    /// </summary>
    /// <param name="result">Result enum value.</param>
    /// <param name="cargo">Data object to be returned.</param>
    public CIOResult(CIOResultType result, T cargo)
    {
        Result = result;
        Cargo = cargo;
    }

    /// <summary>
    /// Constructor used when only the result is to be returned.
    /// </summary>
    /// <param name="result">Enum value of result.</param>
    public CIOResult(CIOResultType result)
    {
        Result = result;
    }
    
    /// <summary>
    /// Constructor for successful completion and to return a data object.
    /// </summary>
    /// <param name="cargo">Data object to return.</param>
    public CIOResult(T cargo) : base()
    {
        Result = CIOResultType.success;
        Cargo = cargo;
    }

    /// <summary>
    /// Constructor for successful completion but without a data object.
    /// </summary>
    public CIOResult()
    {
        Result = CIOResultType.success;
    }

    /// <summary>
    /// Data object to be included in the CIOResult object.
    /// </summary>
    public T Cargo { get; set; }
}

Code: Select all

public class ResultEx<T>
	protect _oResult as T
	protect _oException as Exception
	protect _oCargo as object

constructor( oResult as T, oException as Exception, oCargo as object )

	_oResult := oResult
	_oException := oException
	_oCargo := oCargo

	return

constructor( oResult as T, oException as Exception )

	self( oResult, oException, null )

	return

constructor( oResult as T )

	self( oResult, null, null )

	return

constructor( oResult as T, oCargo as object )

	self( oResult, null, oCargo )

	return

public property Result as T get _oResult set _oResult := value
public property Exception as Exception get _oException set _oException := value
public property Cargo as object get _oCargo set _oCargo := value

end class

Code: Select all

function TestResultEx( lSuccess as logic ) as void
	local oResult			as ResultEx<logic>

	oResult := ExecuteTestResultEx( lSuccess )

	if oResult:Result
		System.Console.WriteLine( "Execution succeeded" )
	else
		System.Console.WriteLine( String.Format( "Execution failed with error message '{0}'", oResult:Exception:Message ) )
	endif

function ExecuteTestResultEx( lSuccess as logic ) as ResultEx<logic>
	local oResult as ResultEx<logic>

	oResult := ResultEx<logic>{ true }

	try

	if lSuccess == false
		throw Exception{ "I have to fail" }
	endif

	catch oEx as Exception

	oResult:Exception	:= oEx
	oResult:Result		:= false

	end try

	return oResult

Code: Select all

function MyFunc() as logic
local lReturn as logic

lReturn := true

begin sequence

< processing something >

recover

lReturn := false

end sequence

return lReturn

Code: Select all

class LogicResultEx inherit ResultEx<logic>

constructor( lResult as logic, oException as Exception, oCargo as object )

	super( lResult, oException, oCargo )

	return

constructor( oResult as logic, oException as Exception )

	self( oResult, oException, null )

	return

constructor( oResult as logic )

	self( oResult, null, null )

	return

constructor( oResult as logic, oCargo as object )

	self( oResult, null, oCargo )

	return