Class Decorator

Namespace

Cuemon

Assembly

Cuemon.Kernel.dll

Provides a way to support hiding of non-common extension methods by enclosing/wrapping an object within the IDecorator<T> interface.

public static class Decorator

Inheritance

object

Decorator

Examples

The following example demonstrates how to wrap values using Decorator.Enclose and related methods. It shows accessing the inner value, argument name, syntactic default, and raw (nullable) wrapping.

using System;
using Cuemon;

namespace MyApp.Wrapping;

public class DecoratorExample
{
    public void Demonstrate()
    {
        var wrappedString = Decorator.Enclose("Hello, World!");
        Console.WriteLine(wrappedString.Inner); // "Hello, World!"
        Console.WriteLine(wrappedString.ArgumentName); // ""

        var withArg = Decorator.EncloseToExpose("test", argumentName: "myArg");
        Console.WriteLine(withArg.ArgumentName); // "myArg"

        var syntactic = Decorator.Syntactic<DateTime>();
        Console.WriteLine(syntactic.Inner); // "01-01-0001 00:00:00" (default(DateTime))

        var raw = Decorator.RawEnclose<string>(null);
        Console.WriteLine(raw.Inner is null); // True
    }
}

Remarks

The original idea for this class was due to feedback from developers; often they are overwhelmed by vast numbers of extensions methods for various types of various libraries.

<p></p>

To help reduce the cognitive load inferred from this feedback (and to avoid traditional Utility/Helper classes), these interfaces and classes was added, leaving a sub-convenient way (fully backed by IntelliSense) to use non-common extension methods.

<p></p>

Pure extension methods should (IMO) be used in the way Microsoft has a paved path to the many NuGet packages complementing the .NET platform and overall follow these guidelines: https://learn.microsoft.com/en-us/dotnet/standard/design-guidelines/extension-methods.

<p></p>

Non-common extension methods could also include those rare cases were you need to support your product infrastructure cross-assembly.

Methods

EncloseToExpose<T>(T, bool, string)

Encloses the specified inner so that it can be extended by both common and non-common extension methods.

public static Decorator<T> EncloseToExpose<T>(T inner, bool throwIfNull = true, string argumentName = null)

Parameters

inner T

The object to extend for non-common extension methods.

throwIfNull bool

true to throw an ArgumentNullException when inner is null; false to allow inner to be null. Default is true.

argumentName string

The name of the argument from which inner parameter was provided.

Returns

Decorator<T>

An instance of Decorator<T>.

Type Parameters

T

The type of the inner to wrap for non-common extension methods.

Remarks

This should be used to re-use non-common extension methods from native extension methods without double-validating arguments.

Exceptions

ArgumentNullException

inner cannot be null.

Enclose<T>(T, bool)

Encloses the specified inner so that it can be extended by non-common extension methods.

public static Decorator<T> Enclose<T>(T inner, bool throwIfNull = true)

Parameters

inner T

The object to extend for non-common extension methods.

throwIfNull bool

true to throw an ArgumentNullException when inner is null; false to allow inner to be null. Default is true.

Returns

Decorator<T>

An instance of Decorator<T>.

Type Parameters

T

The type of the inner to wrap for non-common extension methods.

Exceptions

ArgumentNullException

inner cannot be null.

RawEnclose<T>(T)

Encloses the specified inner so that it can be extended by non-common extension methods.

public static Decorator<T> RawEnclose<T>(T inner)

Parameters

inner T

The object to extend for non-common extension methods.

Returns

Decorator<T>

An instance of Decorator<T>.

Type Parameters

T

The type of the inner to wrap for non-common extension methods.

Remarks

Unlike Enclose<T>(T, bool), this method does not perform a null-check when wrapping the value.

Syntactic<T>()

Syntactic sugar for the rare cases where retrieving properties exposed as methods is a necessity.

public static Decorator<T> Syntactic<T>()

Returns

Decorator<T>

An instance of Decorator<T> where the Inner defaults to T.

Type Parameters

T

The type to wrap for non-common extension methods.