C#

combobox.items.insert("","")

private static List<T> CreateList<T>(List<T> data) 
        {
            //create new generic item (blank)

             
             List<T> list = new List<T>();
            // list.Add(); add new generic item here
             list.AddRange(data);

            return list;
        }

public struct MyWrapper<T>
{
  public MyWrapper(T value)
  {
    _value = value;
    _hasValue = value != null;
  }

  private T _value;
  public T Value
  {
    get
    {
      return _value;
    }
  }
  
  private bool _hasValue;
  public bool HasValue
  {
    get
    {
      return _hasValue;
    }
  }

  public override string ToString()
  {
    if (!_hasValue)
      return "";

    return _value.ToString();
  }
}

private void BindToComboBox()
{
    List<string> items = new List<string>();
    items.Add("Hello");
    items.Add("Hello 1");
    items.Add("Hello 2");
    items.Add("Hello 3");
    items.Add("Hello 4");

    cboList.Items.AddRange(items.ToArray());
    cboList.Items.Insert(0, " ");
}

SqlConnection MyConnection = new SqlConnection(PublicVars.ConnectionString);
                MyConnection.Open();

                SqlDataAdapter sqlDA1 = new SqlDataAdapter("SELECT ItemID FROM some_items", MyConnection);
                DataSet sqlDS = new DataSet();

                sqlDA1.Fill(sqlDS, "some_items");
                DataTable tblItems= sqlDS.Tables["some_items"];

                DataRow NewRow = tblItems.NewRow();
                NewRow[0] = "-- Click To Select --";
                tblItems.Rows.InsertAt(NewRow, 0);

                cboItems.DataSource = tblItems;
                cboItems.DisplayMember = "ItemID";
                cboItems.ValueMember = "ItemID";
                cboItems.SelectedIndex = 0;

                MyConnection.Dispose();

public MyClass {

    // Delegate type. The 'firstArgument' will be 'this', i.e., this is an open instance method:
    // the implicit argument is here given explicitly, in 'firstArgument'.
    // (below there's a link explaining open instance methods; I couldn't get it to work within
    // the code block)
    public delegate Object DirectReadAccessor<T>(T firstArgument);

    // Array of delegates. T has been replaced with MyClass because the argument will be 'this',
    // which is of type MyClass.
    private static DirectReadAccessor<MyClass>[] directReadAccessors;

    // Method that looks up a delegate in the array of delegates and calls it with 'this'.
    public Object DirectRead(int i) {
        directReadAccessors[i](this);
    }
    
    // Method that is called by the declaring type to pass an array with the MethodInfo of some
    // methods. MyClass then creates delegates for these methods and stores them in the
    // directReadAccessors array.
    public static void InitializeClass(MethodInfo[] directReadAccessorsMInfo) {
        int length = directReadAccessorsMInfo.Length;
        Type[] typeArguments = new Type[] { typeof(MyClass) };
        directReadAccessors = new DirectReadAccessor<MyClass>[length];
        // For each method in directReadAccessorsMInfo...
        for (int i = 0; i < length; i++) {
            // Create a delegate and store it in directReadAccessors.
            directReadAccessors[i] = (DirectReadAccessor<MyClass>)
                    Delegate.CreateDelegate(
                            DirectReadAccessor<MyClass>,  // Type of the delegate.
                            null, // Specify null first argument so that it's *open* instance.
                            directReadAccessorsMInfo[i].MakeGenericMethod(typeArguments) // The method.
                    );
        }
    }

}

ilGenerator.Emit(OpCodes.Callvirt, invokeMInfo);

MethodInfo invokeMInfo = typeof(DirectReadAccessor<MyClass>).GetMethod(
        "Invoke",                        // Name of the method.
        BindingFlags.Instance | BindingFlags.Publ<code></code>ic | BindingFlags.NonPublic, // Binding attributes.
        null,                            // Binder.
        new Type[] { typeof(MyClass) },  // Types of the arguments.
        null                             // Modifiers for the arguments.
);

directReadAccessorType = typeof(DirectReadAccessor<>).MakeGenericType(typeBuilder);

typeBuilder.CreateType();

TypeBuilder.GetMethod(directReadAccessorType, typeof(DirectReadAccessor<>).GetMethod("Invoke"));