¿Por qué capturar y repensar una excepción en C#?

Estoy mirando el artículo C# - Objeto de Transferencia de Datos en DTOS serializables.

El artículo incluye este fragmento de código:

public static string SerializeDTO(DTO dto) {
    try {
        XmlSerializer xmlSer = new XmlSerializer(dto.GetType());
        StringWriter sWriter = new StringWriter();
        xmlSer.Serialize(sWriter, dto);
        return sWriter.ToString();
    }
    catch(Exception ex) {
        throw ex;
    }
}

El resto del artículo se ve sano y razonable (para un novato), pero ese intento-catch-throw lanza una excepción WtfException... ¿No es esto exactamente equivalente a no manejar excepciones en absoluto?

Ergo:

public static string SerializeDTO(DTO dto) {
    XmlSerializer xmlSer = new XmlSerializer(dto.GetType());
    StringWriter sWriter = new StringWriter();
    xmlSer.Serialize(sWriter, dto);
    return sWriter.ToString();
}

¿O me falta algo fundamental sobre el manejo de errores en C#? Es más o menos lo mismo que Java (menos las excepciones marcadas), ¿no? ... Es decir, ambos refinaron C++.

La pregunta de desbordamiento de pila¿La diferencia entre volver a lanzar la captura sin parámetros y no hacer nada? parece apoyar mi afirmación de que try-catch-throw es-un no-op.

EDITAR:

Solo para resumir para cualquiera que encuentre este hilo en el futuro...

NO

try {
    // Do stuff that might throw an exception
}
catch (Exception e) {
    throw e; // This destroys the strack trace information!
}

La información de seguimiento de la pila puede ser crucial para identificar ¡causa raíz del problema!

DO

try {
    // Do stuff that might throw an exception
}
catch (SqlException e) {
    // Log it
    if (e.ErrorCode != NO_ROW_ERROR) { // filter out NoDataFound.
        // Do special cleanup, like maybe closing the "dirty" database connection.
        throw; // This preserves the stack trace
    }
}
catch (IOException e) {
    // Log it
    throw;
}
catch (Exception e) {
    // Log it
    throw new DAOException("Excrement occurred", e); // wrapped & chained exceptions (just like java).
}
finally {
    // Normal clean goes here (like closing open files).
}

Captura las excepciones más específicas antes que las menos específicas (al igual que Java).

Referencias:

• MSDN-Gestión de excepciones
• MSDN-try-catch (Referencia de C#)