"Operación de hilo cruzado no válida" excepción en los controles internos

Question

He estado luchando con esto durante bastante tiempo: Tengo una función diseñada para agregar control a un panel con manejo de hilos cruzados, pero el problema es que el panel y el control están en "InvokeRequired = false" - Recibo una excepción diciéndome que se accede a uno de los controles internos desde un hilo que no sea el hilo en el que se creó, el fragmento es así:

public delegate void AddControlToPanelDlgt(Panel panel, Control ctrl); 
    public void AddControlToPanel(Panel panel, Control ctrl) 
    { 
     if (panel.InvokeRequired) 
     { 
      panel.Invoke(new AddControlToPanelDlgt(AddControlToPanel),panel,ctrl); 
      return; 
     } 
     if (ctrl.InvokeRequired) 
     { 
      ctrl.Invoke(new AddControlToPanelDlgt(AddControlToPanel),panel,ctrl); 
      return; 
     } 
     panel.Controls.Add(ctrl); //<-- here is where the exception is raised 
    } 

el mensaje de excepción es la siguiente:

"Cross- operación hilo no válido: Control 'pnlFoo' se accede desde un subproceso distinto del subproceso que se creó el"

('pnlFoo' está bajo ctrl.Controls)

¿Cómo puedo añadir a ctrl panel? !

---

Cuando el código llega al "panel.Controles.Agregar (ctrl);" línea - tanto el panel como la propiedad "InvokeRequired" del ctrl están configuradas en falso, el problema es que los controles dentro de ctrl tienen "InvokeRequired" establecido en verdadero. Para aclarar cosas: "panel" se crea en el hilo base y "ctrl" en el nuevo hilo, por lo tanto, se debe invocar "panel" (haciendo que "ctrl" necesite invocar nuevamente). Una vez que se realizan ambas invocaciones, llega al panel.Controles.Agregar (ctrl) comando (tanto "panel" como "ctrl" no necesita invocación en este estado)

Aquí hay un pequeño fragmento del completo programa:

public class ucFoo : UserControl 
{ 
    private Panel pnlFoo = new Panel(); 

    public ucFoo() 
    { 
     this.Controls.Add(pnlFoo); 
    } 
} 

public class ucFoo2 : UserControl 
{ 
    private Panel pnlFooContainer = new Panel(); 

    public ucFoo2() 
    { 
     this.Controls.Add(pnlFooContainer); 
     Thread t = new Thread(new ThreadStart(AddFooControlToFooConatiner()); 
     t.Start() 
    } 

    private AddFooControlToFooConatiner() 
    { 
     ucFoo foo = new ucFoo(); 
     this.pnlFooContainer.Controls.Add(ucFoo); //<-- this is where the exception is raised 
    } 
} 

Answer 1

¿Dónde se crea pnlFoo y en qué thread? ¿Sabes cuándo se está creando su mango? Si se está creando en el hilo original (no UI), ese es el problema.

Todos los controles en la misma ventana deben crearse y accederse en el mismo hilo. En ese momento, no debería necesitar dos comprobaciones para determinar si Invoke es necesario, porque ctrl y panel deberían estar usando el mismo hilo.

Si esto no ayuda, proporcione un programa breve pero completo para demostrar el problema.

Answer 2

En su propia respuesta usted afirma:

Para aclarar las cosas: "panel" se crea en el hilo de base y "Ctrl" en el nuevo hilo

Creo que esto podría ser el causa de tu problema Todos los elementos de la interfaz de usuario se deben crear en el mismo subproceso (el de la base). Si necesita crear "ctrl" como consecuencia de alguna acción en el nuevo hilo, luego reinicie un evento al hilo base y realice la creación allí.

Answer 3

Como acotación al margen - para ahorrarse tener que crear un sinnúmero de tipos de delegado:

if (panel.InvokeRequired) 
{ 
    panel.Invoke((MethodInvoker) delegate { AddControlToPanel(panel,ctrl); }); 
    return; 
} 

Además, esto ahora hace comprobaciones regulares estáticas en la llamada interior a AddControlToPanel, por lo que no puede equivocarse.

Answer 4

'panel' y 'ctrl' se deben crear en el mismo hilo, es decir. no puede tener el panel. InvokeRequired devuelve un valor diferente que ctrl.InvokeRequired. Eso es si tanto el panel como ctrl tienen los identificadores creados o pertenecen a un contenedor con el identificador creado. De MSDN:

Si el identificador del control hace aún no existir, InvokeRequired searches hasta la cadena principal del control de hasta que encuentra un control o formulario que tiene un mango ventana. Si no se puede encontrar el identificador apropiado, el método InvokeRequired devuelve falso.

Como está ahora su código es abierta a condiciones de carrera porque el panel.InvokeNeeded puede volver falsa ya que el panel no ha sido creada, entonces ctrl.InvokeNeeded sin duda volverá falsa porque lo más probable ctrl aún no se añade a cualquier contenedor y luego cuando llega al panel.Controls.Add el panel se creó en el hilo principal, por lo que la llamada fallará.

Answer 5

Aquí es una pieza de trabajo de código:

public delegate void AddControlToPanelDlg(Panel p, Control c); 

     private void AddControlToPanel(Panel p, Control c) 
     { 
      p.Controls.Add(c); 
     } 

     private void AddNewContol(object state) 
     { 
      object[] param = (object[])state; 
      Panel p = (Panel)param[0]; 
      Control c = (Control)param[1] 
      if (p.InvokeRequired) 
      { 
       p.Invoke(new AddControlToPanelDlg(AddControlToPanel), p, c); 
      } 
      else 
      { 
       AddControlToPanel(p, c); 
      } 
     } 

Y aquí es cómo lo probé. Es necesario tener un formulario con 2 botones y una FlowLayoutPanel (elegí esto, así que no tiene que preocuparse acerca de la ubicación hCuando dinámicamente la adición de controles en el panel)

private void button1_Click(object sender, EventArgs e) 
     { 
      AddNewContol(new object[]{flowLayoutPanel1, CreateButton(DateTime.Now.Ticks.ToString())}); 
     } 

     private void button2_Click(object sender, EventArgs e) 
     { 
      ThreadPool.QueueUserWorkItem(new WaitCallback(AddNewContol), new object[] { flowLayoutPanel1, CreateButton(DateTime.Now.Ticks.ToString()) }); 
     } 

I que problema tomando con su exaple es que cuando ingresas en la rama InvokeRequired invocas la misma función en la que estás, lo que resulta en un extraño caso de recursión.

Answer 6

Aquí es un pequeño fragmento del programa completo:

public class ucFoo : UserControl 
{ 
    private Panel pnlFoo = new Panel(); 

    public ucFoo() 
    { 
     this.Controls.Add(pnlFoo); 
    } 
} 

public class ucFoo2 : UserControl 
{ 
    private Panel pnlFooContainer = new Panel(); 

    public ucFoo2() 
    { 
     this.Controls.Add(pnlFooContainer); 
     Thread t = new Thread(new ThreadStart(AddFooControlToFooConatiner()); 
     t.Start() 
    } 

    private AddFooControlToFooConatiner() 
    { 
     ucFoo foo = new ucFoo(); 
     this.pnlFooContainer.Controls.Add(ucFoo); //<-- this is where the exception is raised 
    } 
} 

Answer 7

muchas respuestas interesantes aquí, pero un elemento clave para cualquier multihilo en una aplicación Winform está utilizando el BackgroundWorker para iniciar las discusiones, y comunicar de nuevo a el hilo principal de Winform.