¿Es la verificación de tipo en lugar de nulo una opción razonable?

Esta no es una buena manera. Una mejor manera sería simplemente:

return _bar ?? string.Empty;

¿Está claro cuando lee el código de sus colegas que está buscando nulos? No, entonces no es una buena elección. Probablemente, lo que hará primero el operador "es" es simplemente verificar si hay nulo y luego devolver falso. Por lo tanto, se vuelve mucho más limpio hacerlo usted mismo. O simplemente use el operador de fusión nula

Creo que este código es completamente confuso y nunca lo usaría. _bar es declarado como un string por lo que esta verificación de tipo solo le ruega a la gente que no entienda el código.

Sí, eso es un poco extraño. ¿Por qué no simplemente escribir:

return _bar ?? "" ;

Cuando necesito hacer algo como esto, tengo una pequeña clase para manejar estos detalles:

public class DefaultableValue<T>
{
    private T m_Value = default(T);
    public T Value
    {
        get
        {
            if (IsInvalidPredicate(m_Value))
            {
                m_Value = IfDefaultValueFunc();
            }
            return m_Value;
        }
    }
    private Predicate<T> IsInvalidPredicate { get; set; }
    private Func<T> IfDefaultValueFunc { get; set; }
    public static implicit operator T(DefaultableValue<T> property)
    {
        return property.Value;
    }
    public DefaultableValue(Predicate<T> isInvalidPredicate,Func<T> ifDefaultFunc)
        : this(default(T), isInvalidPredicate, ifDefaultFunc)
    {
    }
    public DefaultableValue(T initValue, Predicate<T> isInvalidPredicate, Func<T> ifDefaultFunc)
    {
        this.m_Value = initValue;
        this.IsInvalidPredicate = isInvalidPredicate;
        this.IfDefaultValueFunc = ifDefaultFunc;
    }
}

Entonces mi clase parece

class Test
{
    DefaultableValue<string> AString { get; set; }

    public Test(string initialValue)
    {
        this.AString = new DefaultableValue<string>(initialValue, 
            (value) => string.IsNullOrWhiteSpace(value),
            () => string.Empty);
    }
}

....
var test = new Test(null);
var someString = test.AString; // = "" not null

si la propiedad pública anterior fue declarada para volver object en lugar de string, lo anterior podría tener sentido. Sin embargo, debido a que está devolviendo una cadena, ese tipo de verificación no tiene sentido. Si desea devolver una cadena vacía, podría hacer algo como esto:

public class Foo 
{ 
    private string _bar = null; 

    public string Bar 
    { 
        get 
        {  
            return (String.IsNullOrWhitespace(_bar)) ? "": _bar; 
        } 
        set { _bar = value; } 
    } 
}