Only allow 5 attempts on the EntityFrameWork key duplication? to 6 on SaveChange ()

The solution is here:

link

public class PharylonExecutionStrategy : DbExecutionStrategy
    {
        /// <summary>
        /// The default retry limit is 5, which means that the total amount of time spent 
        /// between retries is 26 seconds plus the random factor.
        /// </summary>
        public PharylonExecutionStrategy()
        {
        }

        /// <summary>
        /// Creates a new instance of "PharylonExecutionStrategy" with the specified limits for
        /// number of retries and the delay between retries.
        /// </summary>
        /// <param name="maxRetryCount"> The maximum number of retry attempts. </param>
        /// <param name="maxDelay"> The maximum delay in milliseconds between retries. </param>
        public PharylonExecutionStrategy(int maxRetryCount, TimeSpan maxDelay)
            : base(maxRetryCount, maxDelay)
        {
        }

        protected override bool ShouldRetryOn(Exception ex)
        {
            bool retry = false;

            SqlException sqlException = ex as SqlException;
            if (sqlException != null)
            {
                int[] errorsToRetry =
                {
                    1205,  //Deadlock
                    -2,    //Timeout
                    2601  //primary key violation. Normally you wouldn't want to retry these, 
                          //but some procs in my database can cause it, because it's a crappy 
                          //legacy junkpile.
                };
                if (sqlException.Errors.Cast<SqlError>().Any(x => errorsToRetry.Contains(x.Number)))
                {
                    retry = true;
                }
                else
                {
                    //Add some error logging on this line for errors we aren't retrying.
                    //Make sure you record the Number property of sqlError. 
                    //If you see an error pop up that you want to retry, you can look in 
                    //your log and add that number to the list above.
                }
            }
            if (ex is TimeoutException)
            {
                retry = true;
            }
            return retry;
        }
    } 

The opening of the transactional scope is wrong. You do not open the scope from the connection to the database: open from the .NET itself, because handling objects is not purely a database issue.

The correct would look something like this:

Public Sub AdicionaAux(ByRef Tentativas As Integer)
    Dim inBlnRepete As Boolean = False
    Try
        Using ctx As New BD.Dinamica.Aplicacao
            'Mude aqui
            Using trans As New TransactionScope(TransactionScopeAsyncFlowOption.Enabled)
                'Não use Try com contexto. Intercepte exceções nos eventos OnException 
                'do Controller ou SaveChanges e SaveChangesAsync do contexto.
                'Try
                Dim t As tbArtigos = ctx.tbArtigos.FirstOrDefault
                'Não entendi por que você está selecionando o registro e fazendo Attach nele.
                'Apenas a seleção já faz o registro ser observado, então estou comentando esta linha.
                'ctx.tbArtigos.Attach(t)
                ctx.Entry(t).State = EntityState.Added
                ctx.SaveChanges()
                trans.Complete()
                'Catch ex As Exception
                '    trans.Rollback()
                '    Throw
                'End Try
            End Using
        End Using
    'Considere retirar este Catch também
    Catch
        inBlnRepete = True 'RepeteFuncaoPorConcorrencia(ex, Tentativas)
        If inBlnRepete And Tentativas < 5 Then
            AdicionaAux(Tentativas)
        Else
            Throw
        End If
    End Try
End Sub

The Entity Framework is not a 100% ORM dedicated to SQL, or a type of relational technology that involves SQL: it is an agnostic framework . In addition, multithreading support is not natively secure: it takes extra effort from the programmer for critical regions.