How to avoid duplicate "using" code

You can write a helper method, that handles the transaction logic while calling your actual code as a lambda.

    public static T Execute<T>(Func<T> func, TransactionExecutionOptions options = null)
    {
        options = options ?? TransactionExecutionOptions.Default;

        T res;
        using (var tx = new TransactionScope(options))
        {
            res = func();
            tx.Complete();
        }

        return res;
    }

Depending on your needs you can provide additional arguments to the Func argument; for example, the Execute method could also open a database connection and pass that to the func (then having Func<IDbConnection, T> as parameter type). YMMV.

For your example:

public MyCompleteList ReadOrganisations()
{
    MyCompleteList resp = new MyCompleteList ();
    try
    {
        resp = Execute(() => {
            if (HttpContext.Current.User.Identity.IsAuthenticated)
            {
                DC_Base browser_request = new DC_Base(PROJECT);
                browser_request.cmd_user_id = coreDb.GetUserIDFromLoginName(PROJECT,
                    HttpContext.Current.User.Identity.Name);
                resp =
                    new MyCompleteList (coreSc.User_Read_All_Organisations(browser_request, utils,
                        validation, coreSc, coreDb));
                scope.Complete();
            }
            else
            {
                resp.SetResponseNotLoggedIn();
            }
       });
    }
    catch (TransactionAbortedException ex)
    {
        resp.SetResponseServerError();
    }
    catch (ApplicationException ex)
    {
        resp.SetResponseServerError();
    }
    return resp;
}

If possible, you can also factor the SetResponse*() methods out into a base class or interface (say IMyResponse), thus making it possible to handle this aspect inside the Execute method as well.

    public static T Execute<T>(Func<T> func, TransactionExecutionOptions options = null) where T : IMyResponse
    {
        options = options ?? TransactionExecutionOptions.Default;

        T res;
        try
        {
            using (var tx = new TransactionScope(options))
            {
                res = func();
                tx.Complete();
            }
        }
        catch (TransactionAbortedException ex)
        {
            res.SetResponseServerError();
        }
        catch (ApplicationException ex)
        {
            res.SetResponseServerError();
        }
        return res;
    }

1- Create a ServiceBase class as follows

public class ServiceBase
    {

       protected void ExecuteOperation(Action codetoExecute)
        {                               
            try
            {               
                 using (TransactionScope scope = new TransactionScope())
                {                   
                    codetoExecute.Invoke();             
                    scope.Complete();                
                }                           
            }
            catch (TransactionAbortedException ex)
            {
                // handle exception
            }
            catch (ApplicationException ex)
            {
                // handle exception
            }            
        }
    }

2- Each new service must inherits from ServiceBase and call ExecuteOperation instead. Code as follows:

ExecuteOperation(() =>
            {                 
                 // Custom code here
            });

3- Atomic transactions are useful when executing operations that dont expect results in return.