Package De Débogage De La Console Du Gestionnaire De Mise À Jour De La Base De Données Des Semences Méthode

Question

Je voulais de débogage de la Graine() la méthode dans mon Cadre de l'Entité de la base de données de configuration de la classe, quand je lance la mise à jour de la base de données du Gestionnaire de paquets de la Console mais je ne savais pas comment le faire. Je voulais partager la solution avec les autres dans le cas où ils ont le même problème.

Answer 1

Ici est similaire à la question avec une solution qui fonctionne vraiment bien. Ne nécessite pas de fil.sommeil. Lance le debugger à l'aide de code.

Coupée de la réponse

    if (System.Diagnostics.Debugger.IsAttached == false)
      System.Diagnostics.Debugger.Launch();

Answer 2

La façon dont j'ai résolu ce problème était d'ouvrir une nouvelle instance de Visual Studio, puis ouvrez la même solution dans cette nouvelle instance de Visual Studio. J'ai ensuite attaché le débogueur dans cette nouvelle instance à l'ancienne instance (devenv.exe) lors de l'exécution de la mise à jour de la base de données de commande. Cela m'a permis de débogage de la Graine de la méthode.

Juste pour m'assurer de ne pas manquer le point d'arrêt en ne joignant une fois, j'ai ajouté un Fil.Sommeil avant le point d'arrêt.

J'espère que cela aide quelqu'un.

Answer 3

Si vous avez besoin d'obtenir une des variables de la valeur, un rapide hack est de lever une exception:

throw new Exception(variable);

Answer 4

Je sais que c'est une vieille question, mais si tout ce que vous voulez, c'est des messages, et vous n'avez pas de soins à inclure des références à des WinForms dans votre projet, j'ai fait une simple fenêtre de débogage où je peux envoyer des événements de Trace.

Pour les plus sérieux et étape-par-étape de débogage, je vais ouvrir une autre instance de Visual Studio, mais il n'est pas nécessaire pour les choses simples.

C'est l'ensemble du code:

SeedApplicationContext.cs

using System;
using System.Data.Entity;
using System.Diagnostics;
using System.Drawing;
using System.Windows.Forms;

namespace Data.Persistence.Migrations.SeedDebug
{
  public class SeedApplicationContext<T> : ApplicationContext
    where T : DbContext
  {
    private class SeedTraceListener : TraceListener
    {
      private readonly SeedApplicationContext<T> _appContext;

      public SeedTraceListener(SeedApplicationContext<T> appContext)
      {
        _appContext = appContext;
      }

      public override void Write(string message)
      {
        _appContext.WriteDebugText(message);
      }

      public override void WriteLine(string message)
      {
        _appContext.WriteDebugLine(message);
      }
    }

    private Form _debugForm;
    private TextBox _debugTextBox;
    private TraceListener _traceListener;

    private readonly Action<T> _seedAction;
    private readonly T _dbcontext;

    public Exception Exception { get; private set; }
    public bool WaitBeforeExit { get; private set; }

    public SeedApplicationContext(Action<T> seedAction, T dbcontext, bool waitBeforeExit = false)
    {
      _dbcontext = dbcontext;
      _seedAction = seedAction;
      WaitBeforeExit = waitBeforeExit;
      _traceListener = new SeedTraceListener(this);
      CreateDebugForm();
      MainForm = _debugForm;
      Trace.Listeners.Add(_traceListener);
    }

    private void CreateDebugForm()
    {
      var textbox = new TextBox {Multiline = true, Dock = DockStyle.Fill, ScrollBars = ScrollBars.Both, WordWrap = false};
      var form = new Form {Font = new Font(@"Lucida Console", 8), Text = "Seed Trace"};
      form.Controls.Add(tb);
      form.Shown += OnFormShown;
      _debugForm = form;
      _debugTextBox = textbox;
    }

    private void OnFormShown(object sender, EventArgs eventArgs)
    {
      WriteDebugLine("Initializing seed...");
      try
      {
        _seedAction(_dbcontext);
        if(!WaitBeforeExit)
          _debugForm.Close();
        else
          WriteDebugLine("Finished seed. Close this window to continue");
      }
      catch (Exception e)
      {
        Exception = e;
        var einner = e;
        while (einner != null)
        {
          WriteDebugLine(string.Format("[Exception {0}] {1}", einner.GetType(), einner.Message));
          WriteDebugLine(einner.StackTrace);
          einner = einner.InnerException;
          if (einner != null)
            WriteDebugLine("------- Inner Exception -------");
        }
      }
    }

    protected override void Dispose(bool disposing)
    {
      if (disposing && _traceListener != null)
      {
        Trace.Listeners.Remove(_traceListener);
        _traceListener.Dispose();
        _traceListener = null;
      }
      base.Dispose(disposing);
    }

    private void WriteDebugText(string message)
    {
      _debugTextBox.Text += message;
      Application.DoEvents();
    }

    private void WriteDebugLine(string message)
    {
      WriteDebugText(message + Environment.NewLine);
    }
  }
}

Et sur votre Configuration.cs

// ...
using System.Windows.Forms;
using Data.Persistence.Migrations.SeedDebug;
// ...

namespace Data.Persistence.Migrations
{
  internal sealed class Configuration : DbMigrationsConfiguration<MyContext>
  {
    public Configuration()
    {
      // Migrations configuration here
    }

    protected override void Seed(MyContext context)
    {
      // Create our application context which will host our debug window and message loop
      var appContext = new SeedApplicationContext<MyContext>(SeedInternal, context, false);
      Application.Run(appContext);
      var e = appContext.Exception;
      Application.Exit();
      // Rethrow the exception to the package manager console
      if (e != null)
        throw e;
    }

    // Our original Seed method, now with Trace support!
    private void SeedInternal(MyContext context)
    {
      // ...
      Trace.WriteLine("I'm seeding!")
      // ...
    }
  }
}