Obtener un control de formularios de Windows por nombre en C#

string name = "the_name_you_know";

Control ctn = this.Controls[name];

ctn.Text = "Example...";

Control GetControlByName(string Name)
{
    foreach(Control c in this.Controls)
        if(c.Name == Name)
            return c;

    return null;
}

Ignore esto, reinvento las ruedas.

Suponiendo que tiene el objeto menuStrip y el menú tiene un solo nivel de profundidad, use:

ToolStripMenuItem item = menuStrip.Items
    .OfType<ToolStripMenuItem>()
    .SelectMany(it => it.DropDownItems.OfType<ToolStripMenuItem>())
    .SingleOrDefault(n => n.Name == "MyMenu");

Para niveles de menú más profundos agregue más operadores SelectMany en la instrucción.

Si desea buscar todos los elementos del menú en la tira, use

ToolStripMenuItem item = menuStrip.Items
    .Find("MyMenu",true)
    .OfType<ToolStripMenuItem>()
    .Single();

Sin embargo, asegúrese de que cada menú tenga un nombre diferente para evitar excepciones lanzadas por duplicados de claves.

Para evitar excepciones, podría usar FirstOrDefault en lugar de SingleOrDefault / Single, o simplemente devuelva una secuencia si es posible que tenga Name duplicados.

esto.Controles.Find (name, searchAllChildren) no encuentra ToolStripItem porque ToolStripItem no es un Control

  using SWF = System.Windows.Forms;
  using NUF = NUnit.Framework;
  namespace workshop.findControlTest {
     [NUF.TestFixture]
     public class FormTest {
        [NUF.Test]public void Find_menu() {
           // == prepare ==
           var fileTool = new SWF.ToolStripMenuItem();
           fileTool.Name = "fileTool";
           fileTool.Text = "File";

           var menuStrip = new SWF.MenuStrip();
           menuStrip.Items.Add(fileTool);

           var form = new SWF.Form();
           form.Controls.Add(menuStrip);

           // == execute ==
           var ctrl = form.Controls.Find("fileTool", true);

           // == not found! ==
           NUF.Assert.That(ctrl.Length, NUF.Is.EqualTo(0)); 
        }
     }
  }

Ya que los está generando dinámicamente, mantenga un mapa entre una cadena y el elemento del menú, que permitirá una recuperación rápida.

// in class scope
private readonly Dictionary<string, ToolStripMenuItem> _menuItemsByName = new Dictionary<string, ToolStripMenuItem>();

// in your method creating items
ToolStripMenuItem createdItem = ...
_menuItemsByName.Add("<name here>", createdItem);

// to access it
ToolStripMenuItem menuItem = _menuItemsByName["<name here>"];

this.Controls["name"];

Este es el código real que se ejecuta:

public virtual Control this[string key]
{
    get
    {
        if (!string.IsNullOrEmpty(key))
        {
            int index = this.IndexOfKey(key);
            if (this.IsValidIndex(index))
            {
                return this[index];
            }
        }
        return null;
    }
}

Vs:

public Control[] Find(string key, bool searchAllChildren)
{
    if (string.IsNullOrEmpty(key))
    {
        throw new ArgumentNullException("key", SR.GetString("FindKeyMayNotBeEmptyOrNull"));
    }
    ArrayList list = this.FindInternal(key, searchAllChildren, this, new ArrayList());
    Control[] array = new Control[list.Count];
    list.CopyTo(array, 0);
    return array;
}

private ArrayList FindInternal(string key, bool searchAllChildren, Control.ControlCollection controlsToLookIn, ArrayList foundControls)
{
    if ((controlsToLookIn == null) || (foundControls == null))
    {
        return null;
    }
    try
    {
        for (int i = 0; i < controlsToLookIn.Count; i++)
        {
            if ((controlsToLookIn[i] != null) && WindowsFormsUtils.SafeCompareStrings(controlsToLookIn[i].Name, key, true))
            {
                foundControls.Add(controlsToLookIn[i]);
            }
        }
        if (!searchAllChildren)
        {
            return foundControls;
        }
        for (int j = 0; j < controlsToLookIn.Count; j++)
        {
            if (((controlsToLookIn[j] != null) && (controlsToLookIn[j].Controls != null)) && (controlsToLookIn[j].Controls.Count > 0))
            {
                foundControls = this.FindInternal(key, searchAllChildren, controlsToLookIn[j].Controls, foundControls);
            }
        }
    }
    catch (Exception exception)
    {
        if (ClientUtils.IsSecurityOrCriticalException(exception))
        {
            throw;
        }
    }
    return foundControls;
}

Asumiendo que tienes Windows.Form Form1 como la forma padre que posee el menú que has creado. Uno de los atributos de la forma se llama .Menu. Si el menú fue creado programáticamente, debería ser el mismo, y sería reconocido como un menú y colocado en el atributo Menu del Formulario.

En este caso, tenía un menú principal llamado File. Un submenú, llamado MenuItem bajo File contenía la etiqueta Open y fue nombrado menu_File_Open. Lo siguiente funcionó. Asumiendo que

// So you don't have to fully reference the objects.
using System.Windows.Forms;

// More stuff before the real code line, but irrelevant to this discussion.

MenuItem my_menuItem = (MenuItem)Form1.Menu.MenuItems["menu_File_Open"];

// Now you can do what you like with my_menuItem;

Una de las mejores formas es una sola fila de código como esta:

En este ejemplo buscamos todos PictureBox por nombre en una forma

PictureBox[] picSample = 
                    (PictureBox)this.Controls.Find(PIC_SAMPLE_NAME, true);

Lo más importante es el segundo parámetro de find.

Si está seguro de que el nombre del control existe, puede usarlo directamente:

  PictureBox picSample = 
                        (PictureBox)this.Controls.Find(PIC_SAMPLE_NAME, true)[0];

Usando el mismo enfoque de Philip Wallace , podemos hacer lo siguiente:

    public Control GetControlByName(Control ParentCntl, string NameToSearch)
    {
        if (ParentCntl.Name == NameToSearch)
            return ParentCntl;

        foreach (Control ChildCntl in ParentCntl.Controls)
        {
            Control ResultCntl = GetControlByName(ChildCntl, NameToSearch);
            if (ResultCntl != null)
                return ResultCntl;
        }
        return null;
    }

Ejemplo:

    public void doSomething() 
    {
            TextBox myTextBox = (TextBox) this.GetControlByName(this, "mytextboxname");
            myTextBox.Text = "Hello!";
    }

Espero que ayude! :)

Echa un vistazo a la tira de herramientas.Colección de artículos. Incluso tiene un método de búsqueda disponible.

Puedes hacer lo siguiente:

private ToolStripMenuItem getToolStripMenuItemByName(string nameParam)
   {
      foreach (Control ctn in this.Controls)
         {
            if (ctn is ToolStripMenuItem)
               {
                   if (ctn.Name = nameParam)
                      {
                         return ctn;
                      }
                }
         }
         return null;
    }

Una solución simple sería recorrer la lista Controls en un bucle foreach. Algo como esto:

foreach (Control child in Controls)
{
    // Code that executes for each control.
}

Así que ahora tienes tu iterador, child, que es de tipo Control. Ahora haz lo que quieras con eso, personalmente encontré esto en un proyecto que hice hace un tiempo en el que se agregó un evento para este control, como este:

child.MouseDown += new MouseEventHandler(dragDown);