Délai d'attente de commande avec Entity Framework 4.1 Code First

Question

Comment définir le délai d'expiration de la commande d'un DbContext?

Answer 1

J'ai trouvé cette solution après une autre recherche sur Google. Vous pouvez accéder à ObjectContext pour un DbContext en convertissant this en un IObjectContextAdapter.

De http://social.msdn.microsoft.com/Forums/en-ZA/adodotnetentityframework/thread/6fe91a64-0208-4ab8-8667-d061af340994 :

 public class MyContext : DbContext
{
    public MyContext ()
        : base(ContextHelper.CreateConnection("my connection string"), true)
    {
        ((IObjectContextAdapter)this).ObjectContext.CommandTimeout = 300;
    }
}
 

Answer 2

Pour les versions ultérieures d’Entity Framework, une meilleure solution consiste à utiliser la propriété DbContext.Database.CommandTimeout . Je pense que cela est venu avec EF 6.

Answer 3

Veuillez essayer le code suivant avant d'exécuter une commande de base de données. Le code suivant nécessite 3/4 minute pour être exécuté. Ainsi, CommandTimeout a défini 300 (en secondes) avant l'exécution de la commande.

 public List<CollectionEfficiencyByUnitOfficeSummary> ReadCollectionEfficiencyByUnitOfficeSummary(string yearMonth, string locationCode, string reportType)
        {
            ((System.Data.Entity.Infrastructure.IObjectContextAdapter)context).ObjectContext.CommandTimeout = 300;
            return context.CollectionEfficiencyByUnitOfficeSummary(yearMonth, locationCode, reportType).ToList();
        }
 

Answer 4

J'ai eu le même problème l'exécution de EntityFramework v4.4 avec CodeFirstStoredProc v2.2. La mise à niveau n'était pas une option pour moi, donc j'ai dû mettre à jour le CodeFirstStoredProcs.cs fichier pour prendre un nouveau nullable int paramètre appelé "commandTimeout" dans les 3 méthodes suivantes, comme indiqué ci-dessous.

public static ResultsList CallStoredProc<T>(this DbContext context, StoredProc<T> procedure, T data, int? commandTimeout = null)
    {
        IEnumerable<SqlParameter> parms = procedure.Parameters(data);
        ResultsList results = context.ReadFromStoredProc(procedure.fullname, parms, commandTimeout, procedure.returntypes);
        procedure.ProcessOutputParms(parms, data);
        return results ?? new ResultsList();
    }

public static ResultsList CallStoredProc(this DbContext context, StoredProc procedure, IEnumerable<SqlParameter> parms = null, int? commandTimeout = null)
    {
        ResultsList results = context.ReadFromStoredProc(procedure.fullname, parms, commandTimeout, procedure.returntypes);
        return results ?? new ResultsList();
    }

Dans la méthode ci-dessous, c'est là une condition pour vérifier le paramètre et d'appliquer la cmd.connectionTimeout valeur.

internal static ResultsList ReadFromStoredProc(this DbContext context,
        String procname,
        IEnumerable<SqlParameter> parms = null,
        int? commandTimeout = null,
        params Type[] outputtypes)
    {
        // create our output set object
        ResultsList results = new ResultsList();

        // ensure that we have a type list, even if it's empty
        IEnumerator currenttype = (null == outputtypes) ?
            new Type[0].GetEnumerator() :
            outputtypes.GetEnumerator();

        // handle to the database connection object
        var connection = (SqlConnection)context.Database.Connection;
        try
        {
            // open the connect for use and create a command object
            connection.Open();
            using (var cmd = connection.CreateCommand())
            {
                // command to execute is our stored procedure
                cmd.CommandText = procname;
                cmd.CommandType = System.Data.CommandType.StoredProcedure;

                if (commandTimeout.HasValue)
                {
                    cmd.CommandTimeout = commandTimeout.Value;
                }

                // move parameters to command object
                if (null != parms)
                    foreach (SqlParameter p in parms)
                        cmd.Parameters.Add(p);
                //    foreach (ParameterHolder p in parms)
                //        cmd.Parameters.Add(p.toParameter(cmd));

                // Do It! This actually makes the database call
                var reader = cmd.ExecuteReader();

                // get the type we're expecting for the first result. If no types specified,
                // ignore all results
                if (currenttype.MoveNext())
                {
                    // process results - repeat this loop for each result set returned by the stored proc
                    // for which we have a result type specified
                    do
                    {
                        // get properties to save for the current destination type
                        PropertyInfo[] props = ((Type)currenttype.Current).GetMappedProperties();

                        // create a destination for our results
                        List<object> current = new List<object>();

                        // process the result set
                        while (reader.Read())
                        {
                            // create an object to hold this result
                            object item = ((Type)currenttype.Current).GetConstructor(System.Type.EmptyTypes).Invoke(new object[0]);

                            // copy data elements by parameter name from result to destination object
                            reader.ReadRecord(item, props);

                            // add newly populated item to our output list
                            current.Add(item);
                        }

                        // add this result set to our return list
                        results.Add(current);
                    }
                    while (reader.NextResult() && currenttype.MoveNext());
                }
                // close up the reader, we're done saving results
                reader.Close();
            }
        }
        catch (Exception ex)
        {
            throw new Exception("Error reading from stored proc " + procname + ": " + ex.Message, ex);
        }
        finally
        {
            connection.Close();
        }

        return results;
    }
}

J'espère que cette aide alors que je cherchais de l'aide, mais ne trouve rien, pas jusqu'à ce que j'ai réalisé que je pouvais le faire sans mettre à jour les versions de CodeFirstStoredProcs qui m'oblige à mettre à jour EntityFramework ainsi.

Answer 5

Si vous utilisez SqlServer, ajoutez simplement ceci à votre chaîne de connexion: "... Connect Timeout = x" où x est le délai d'attente en ms.