Equivalent to Java's Optional.orElse in C#

Question

I'm looking for nice syntax for providing a default value in the case of null. I've been used to using Optional's instead of null in Java where API's are concerned, and was wondering if C#'s nicer nullable types have an equivalent?

Optionals

Optional<String> x = Optional<String>.absent();
String y = x.orElse("NeedToCheckforNull"); //y = NeedToCheckforNull

@nullable

String x = null;
String y = x == null ? "NeedToCheckforNull" : x ; //y = NeedToCheckforNull

How would I make the above more readable in C#?

JavaScript would allow y = x | "NeedToCheckforNull"

Answer 1

You can use the ?? operator.

Your code will be updated to:

string x = null;
string y = x ?? "NeedToCheckforNull"; 

See: ?? Operator (C# Reference)

Answer 2

C# has the special Nullable<T> type which can be declared with int?, decimal?, etc. These can provide a default value by using .GetValueOrDefault(), T GetValueOrDefault(T defaultValue), and the ?? operator.

string x = null;
Console.WriteLine(x ?? "NeedToCheckforNull");

Answer 3

.Net developers always try to compare C# feature to java. This is their big mistake. Microsoft always teach them like that. But they don't know how java capable of. Optional is not only nullable type. Nullable type is one of the its feature. But main purpose of Optional is single stream. You can use map(), flatMap() and filter() Lambda expression functions. There is no such alternative in .Net world unfortunately. However there is lambda expression on List if you want to use as Optional. But for single item, there is not such feature in .Net

Answer 4

consider using language extensions option type

int x = optional.IfNone("NeedToCheckforNull");

Answer 5

Thanks for the inspiration @sm-adnan

using System;
using System.Diagnostics.CodeAnalysis;

namespace Common;

public readonly struct Optional<T>
{
    private readonly T _value;

    private Optional(T value)
    {
        _value = value;
    }

    public static Optional<T> Empty() => new Optional<T>(default);

    public static Optional<T> Of([AllowNull] T value)
    {
        return value is null ? Empty() : new Optional<T>(value);
    }

    public T GetValue()
    {
        if (HasValue()) return _value;
        throw new InvalidOperationException("No value present");
    }

    public bool HasValue()
    {
        return _value is not null;
    }

    public void HasValue(Action<T> method)
    {
        if (HasValue()) method.Invoke(_value);
    }

    public void HasValue(Func<object> method)
    {
        if (HasValue()) method.Invoke();
    }

    public T OrElse(T other)
    {
        return HasValue() ? _value : other;
    }

    public T OrElseGet(Func<T> method)
    {
        return HasValue() ? _value : method.Invoke();
    }

    public T OrElseThrow(Func<Exception> method)
    {
        return HasValue() ? _value : throw method.Invoke();
    }

    public Optional<TU> Map<TU>(Func<T, TU> method)
    {
        return HasValue() ? new Optional<TU>(method.Invoke(_value)) : default;
    }
}

Answer 6

I've created my own.

public class Optional<T> {
    private T value;
    public bool IsPresent { get; private set; } = false;

    private Optional() { }

    public static Optional<T> Empty() {
        return new Optional<T>();
    }

    public static Optional<T> Of(T value) {
        Optional<T> obj = new Optional<T>();
        obj.Set(value);
        return obj;
    }

    public void Set(T value) {
        this.value = value;
        IsPresent = true;
    }

    public T Get() {
        return value;
    }
}