¿Cuál es la forma correcta de comprobar los valores nulos?

Si haces esto con frecuencia específicamente con ToString() entonces podrías escribir un método de extensión:

public static string NullPreservingToString(this object input)
{
    return input == null ? null : input.ToString();
}

...

string y = Session["key"].NullPreservingToString() ?? "none";

O un método que toma un valor predeterminado, por supuesto:

public static string ToStringOrDefault(this object input, string defaultValue)
{
    return input == null ? defaultValue : input.ToString();
}

...

string y = Session["key"].ToStringOrDefault("none");

También puedes usar as, que produce null si la conversión falla:

Session["key"] as string ?? "none"

Esto regresaría "none" incluso si alguien rellenara un int en Session["key"].

Si siempre será un string, puedes lanzar:

string y = (string)Session["key"] ?? "none";

Esto tiene la ventaja de quejarse en lugar de ocultar el error si alguien mete un int o algo en Session["key"]. ;)

Todas las soluciones sugeridas son buenas, y responde a la pregunta; así que esto es solo para extenderlo un poco. Actualmente, la mayoría de las respuestas solo tratan con validación nula y tipos de cadena. Podría extender el objeto StateBag para incluir un método genérico GetValueOrDefault, similar a la respuesta publicada por Jon Skeet.

Un método de extensión genérico simple que acepta una cadena como clave, y luego type comprueba el objeto de sesión. Si el objeto es null o no es del mismo tipo, se devuelve el valor predeterminado, de lo contrario, el valor de la sesión se devuelve fuertemente escrito.

Algo como esto

/// <summary>
/// Gets a value from the current session, if the type is correct and present
/// </summary>
/// <param name="key">The session key</param>
/// <param name="defaultValue">The default value</param>
/// <returns>Returns a strongly typed session object, or default value</returns>
public static T GetValueOrDefault<T>(this HttpSessionState source, string key, T defaultValue)
{
    // check if the session object exists, and is of the correct type
    object value = source[key]
    if (value == null || !(value is T))
    {
        return defaultValue;
    }

    // return the session object
    return (T)value;
}

Usamos un método llamado NullOr.

Uso

// Call ToString() if it’s not null, otherwise return null
var str = myObj.NullOr(obj => obj.ToString());

// Supply default value for when it’s null
var str = myObj.NullOr(obj => obj.ToString()) ?? "none";

// Works with nullable return values, too —
// this is properly typed as “int?” (nullable int)
// even if “Count” is just int
var count = myCollection.NullOr(coll => coll.Count);

// Works with nullable input types, too
int? unsure = 47;
var sure = unsure.NullOr(i => i.ToString());

Fuente

/// <summary>Provides a function delegate that accepts only value types as return types.</summary>
/// <remarks>This type was introduced to make <see cref="ObjectExtensions.NullOr{TInput,TResult}(TInput,FuncStruct{TInput,TResult})"/>
/// work without clashing with <see cref="ObjectExtensions.NullOr{TInput,TResult}(TInput,FuncClass{TInput,TResult})"/>.</remarks>
public delegate TResult FuncStruct<in TInput, TResult>(TInput input) where TResult : struct;

/// <summary>Provides a function delegate that accepts only reference types as return types.</summary>
/// <remarks>This type was introduced to make <see cref="ObjectExtensions.NullOr{TInput,TResult}(TInput,FuncClass{TInput,TResult})"/>
/// work without clashing with <see cref="ObjectExtensions.NullOr{TInput,TResult}(TInput,FuncStruct{TInput,TResult})"/>.</remarks>
public delegate TResult FuncClass<in TInput, TResult>(TInput input) where TResult : class;

/// <summary>Provides extension methods that apply to all types.</summary>
public static class ObjectExtensions
{
    /// <summary>Returns null if the input is null, otherwise the result of the specified lambda when applied to the input.</summary>
    /// <typeparam name="TInput">Type of the input value.</typeparam>
    /// <typeparam name="TResult">Type of the result from the lambda.</typeparam>
    /// <param name="input">Input value to check for null.</param>
    /// <param name="lambda">Function to apply the input value to if it is not null.</param>
    public static TResult NullOr<TInput, TResult>(this TInput input, FuncClass<TInput, TResult> lambda) where TResult : class
    {
        return input == null ? null : lambda(input);
    }

    /// <summary>Returns null if the input is null, otherwise the result of the specified lambda when applied to the input.</summary>
    /// <typeparam name="TInput">Type of the input value.</typeparam>
    /// <typeparam name="TResult">Type of the result from the lambda.</typeparam>
    /// <param name="input">Input value to check for null.</param>
    /// <param name="lambda">Function to apply the input value to if it is not null.</param>
    public static TResult? NullOr<TInput, TResult>(this TInput input, Func<TInput, TResult?> lambda) where TResult : struct
    {
        return input == null ? null : lambda(input);
    }

    /// <summary>Returns null if the input is null, otherwise the result of the specified lambda when applied to the input.</summary>
    /// <typeparam name="TInput">Type of the input value.</typeparam>
    /// <typeparam name="TResult">Type of the result from the lambda.</typeparam>
    /// <param name="input">Input value to check for null.</param>
    /// <param name="lambda">Function to apply the input value to if it is not null.</param>
    public static TResult? NullOr<TInput, TResult>(this TInput input, FuncStruct<TInput, TResult> lambda) where TResult : struct
    {
        return input == null ? null : lambda(input).Nullable();
    }
}

Mi preferencia, por un solo off, sería usar un cast seguro para string en caso de que el objeto almacenado con la clave no sea uno. Usar ToString() puede no tener los resultados que desea.

var y = Session["key"] as string ?? "none";

Como dice @Jon Skeet, si te encuentras haciendo esto mucho, un método de extensión o, mejor aún, tal vez un método de extensión junto con una clase SessionWrapper fuertemente mecanografiada. Incluso sin el método de extensión, la envoltura fuertemente mecanografiada podría ser una buena idea.

public class SessionWrapper
{
    private HttpSessionBase Session { get; set; }

    public SessionWrapper( HttpSessionBase session )
    {
        Session = session;
    }

    public SessionWrapper() : this( HttpContext.Current.Session ) { }

    public string Key
    {
         get { return Session["key"] as string ?? "none";
    }

    public int MaxAllowed
    {
         get { return Session["maxAllowed"] as int? ?? 10 }
    }
}

Utilizado como

 var session = new SessionWrapper(Session);

 string key = session.Key;
 int maxAllowed = session.maxAllowed;

Crear una función auxiliar

public static String GetValue( string key, string default )
{
    if ( Session[ key ] == null ) { return default; }
    return Session[ key ].toString();
}


string y = GetValue( 'key', 'none' );

La respuesta de Skeet es la mejor - en particular, creo que la suya ToStringOrNull() es bastante elegante y se adapta mejor a sus necesidades. Quería añadir una opción más a la lista de métodos de extensión:

Devuelve el objeto original o el valor de cadena predeterminado para null :

// Method:
public static object OrNullAsString(this object input, string defaultValue)
{
    if (defaultValue == null)
        throw new ArgumentNullException("defaultValue");
    return input == null ? defaultValue : input;
}

// Example:
var y = Session["key"].OrNullAsString("defaultValue");

Use var para el valor devuelto, ya que volverá como el tipo de entrada original, solo como la cadena predeterminada cuando null

Este es mi pequeño tipo seguro "Elvis operator" para versiones de. NET que no son compatibles ?.

public class IsNull
{
    public static O Substitute<I,O>(I obj, Func<I,O> fn, O nullValue=default(O))
    {
        if (obj == null)
            return nullValue;
        else
            return fn(obj);
    }
}

El primer argumento es el objeto probado. La segunda es la función. Y tercero es el valor nulo. Así que para su caso:

IsNull.Substitute(Session["key"],s=>s.ToString(),"none");

También es muy útil para tipos nullables. Por ejemplo:

decimal? v;
...
IsNull.Substitute(v,v.Value,0);
....