Yes, but he's only doing that to build a call stack.  .NET keeps track of the
call stack for automatically, so this is no longer needed.  (This is one of
the things that needs to be updated.)

My first job out of school I worked on a very buggy application so error
handling became a topic I researched a lot.  In fact, I wrote and marketed an
error reporting DLL that was featured on DevX and VBtotheMax.com.  When I
coded in VB6, I always put an error handler in every routine.  But given that
.NET now keeps track of the call stack and even allows you to create a
centralized error handler (at least for Windows Forms app), all this boiler
plate code is simply no longer necessary.  

Honestly, error handling for the sake of error handling is a waste of time
and only serves to obsficate your code.  The only reason why you should
handle an error is if you're going to do something meaningful with the
exception. For example, you know what the error is and how to fix it.  Or
maybe you want to log it to the database.  Or you need to rollback a
transaction.  But if all you're going to do is catch it and raise it up the
call stack, that's pointless code because the error will bubble up the
callstack anyway.  

So is that any different from old style error handling using @Error?  IOW, is
there anything that @Error will 'catch' that TRY...CATCH won't?

OK, here's my 'final' code:

-- Verify that stored procedure does not exist.
IF OBJECT_ID (N'usp_RethrowError',N'P') IS NOT NULL
   DROP PROCEDURE usp_RethrowError;
GO

/******************************************************************************
* Original Auther:
* Creation Date: 12/02/2008>
* Purpose: To rethrow an error.  The original error information is used to
* construct the msg_str for RAISERROR.
* Last Revised By: <Last Revised By Name>
* Last Revised Date: <mm/dd/yyyy>
*******************************************************************************/

CREATE PROCEDURE uspRethrowError AS

   -- Return if there is no error information to retrieve.
   IF ERROR_NUMBER() IS NULL
       RETURN;

   DECLARE
       @errorMessage          NVARCHAR(4000),
       @errorNumber           INT,
       @errorSeverity         INT,
       @errorState            INT,
       @errorLine             INT,
       @errorProcedure        NVARCHAR(200),
       @adjustedErrorState    INTEGER,
       @adjustedErrorSeverity INTEGER;

   -- Assign variables to error-handling functions that capture information
for
   -- RAISERROR.
   SELECT
       @errorNumber = ERROR_NUMBER(),
       @errorSeverity = ERROR_SEVERITY(),
       @errorState = ERROR_STATE(),
       @errorLine = ERROR_LINE(),
       @errorProcedure = ISNULL(ERROR_PROCEDURE(), '-');

   -- Build the message string that will contain original error information.
   SELECT @errorMessage =
       N'Error %d, Level %d, State %d, Procedure %s, Line %d, '
       + 'Message: ' + ERROR_MESSAGE();

   -- It is not always possible to rethrow an error with the same severity
as
   -- was caught. Only a member of the sysadmin role can raise an error
with a
   -- severity greater than or equal to 19.
   IF @errorSeverity < 19
       BEGIN
           SET @adjustedErrorSeverity = @errorSeverity
       END
   ELSE
       BEGIN
           SET @adjustedErrorSeverity = 18
       END

   -- RAISERROR only generates errors with state from 1 through 127. Because
   -- the Database Engine may raise errors with state 0, we need to check
the
   -- error state returned by ERROR_STATE before passing it as a value to
the
   -- state parameter of RAISERROR.
   IF @errorState <> 0
       BEGIN
           SET @adjustedErrorState = @errorState
       END
   ELSE
       BEGIN
           SET @adjustedErrorState = 1
       END

   -- Raise an error: msg_str parameter of RAISERROR will contain the
original
   -- error information.
   RAISERROR
       (
       @errorMessage,
       @adjustedErrorSeverity,
       @adjustedErrorState,              
       @errorNumber,           -- parameter: original error number.
       @errorSeverity,         -- parameter: original error severity.
       @errorState,            -- parameter: original error state.
       @errorProcedure,        -- parameter: original error procedure name.
       @errorLine              -- parameter: original error line number.
       );
GO