Hello, 

To achieve case sensitive inputs to the UltraCombo you must set a ValueMember and DisplayMember path

eg. 

this.ultraCombo1.ValueMember = "Code";
this.ultraCombo1.DisplayMember = "Description";

Adding these two properties will allow you to select "UPPERCASE" with "C" entry.

That works if you want "Description" to be the DisplayMember but I need "Code" to be both ValueMember and DisplayMember... And then it does not work.

The combobox in question in our application contains user-defined data and the description is an optional field that may be empty. The primary data is the code.

The combobox is used to select result codes. Users know most of the codes by heart and only need the dropdown list for the rare cases. Therefore it's important they can reliably enter the codes directly by the keyboard. This works fine for most customers but some use the same codes in uppercase and lowercase to indicate differences. We can't simply ask them to stop doing that - they may have been using these codes for years already in other applications.

Is there a way to achieve this with the UltraCombo or do we have to think about alternative approaches?

That's unfortunate.

However I think I may have found a workaround. It's not pretty, it has some issues, it probably only applies to our particular case,... but it seems to work.

public Form1()
{
    InitializeComponent();

    ultraCombo.DataSource = GetDataTable();
    ultraCombo.ValueMember = "Code";
    ultraCombo.DisplayMember = "Display";
}

private static DataTable GetDataTable()
{
    var dataTable = new DataTable();

    dataTable.Columns.Add("Code", typeof(string));
    dataTable.Columns.Add("Display", typeof(string));
    dataTable.Columns.Add("Description", typeof(string));

    dataTable.Rows.Add("a", "a ", "lowercase"); // Selectable with a or A
    dataTable.Rows.Add("B", "B ", "UPPERCASE"); // Selectable with b or B
    dataTable.Rows.Add("c", "c ", "lowercase"); // Selectable with c
    dataTable.Rows.Add("C", "C ", "UPPERCASE"); // Selectable with C

    return dataTable;
}

What I've done is inserting a new column "Display" for the DisplayMember that is identical to the original "Code" column except each value is followed by a space. This space ensures the UltraCombo does not automatically select the list item when typing the code (AutoComplete is set to None).

The drawback is that the RowSelected/ValueChanged events are no longer fired automatically when typing a code that is in the list (you either have to type the extra space or leave the control). Another problem is that if for example codes "d" and "D D" exist, it's once again impossible to type the second because it contains a space and matches with "d " before you can type the second "D".

It is however relatively easy to fix this with some custom code in the TextChanged event:

private void UltraCombo_TextChanged(object sender, EventArgs e)
{
    var row = GetBestMatchInUltraCombo();
    if (row != null)
        selectedTextBox.Text = $@"{row["Code"]} {row["Description"]}";
    else
        selectedTextBox.Clear();
}

private void UltraCombo_Leave(object sender, EventArgs e)
{
    UpdateUltraCombo();
}

private DataRow GetBestMatchInUltraCombo()
{
    var text = ultraCombo.Text;
    if (string.IsNullOrWhiteSpace(text))
        return null;

    var dataTable = ultraCombo.DataSource as DataTable;
    if (dataTable == null)
        return null;

    // Trim trailing space(s) and protect against single
    // quotes for Select() below
    text = text.Replace("'", "''").TrimEnd();

    // Select all rows that match text (not case sensitive)
    var filteredDataRows = dataTable.Select($"Code = '{text}'");
    // If a row matches exactly (case sensitive) return it,
    // otherwhise return first best match
    if (filteredDataRows.Length > 1)
    {
        var row = filteredDataRows.FirstOrDefault(r => r["Code"].ToString() == text);
        return row ?? filteredDataRows[0];
    }
    if (filteredDataRows.Length == 1)
        return filteredDataRows[0];
    
    return null;
}

private void UpdateUltraCombo()
{
    var row = GetBestMatchInUltraCombo();
    if (row == null)
        return;

    ultraCombo.Value = row["Code"];
}

This is just some quick and dirty code to make the sample work. It'll probably need more spit and polish but I think this workaround is usable for our case.

So... just in case you are interested or run into future issues, I thought you might like to know WHY this code works...

Basically, what happens in this case is that you type in a string and the combo tries to find a matching string in the DisplayText column. Since your DisplayText values contain an extra space, it does not find a match. 

Ordinarily, the combo would find a match on the DisplayText list, and then it's Value would return the DataValue from the matching item? But what does the combo do for the Value when there is no matching DisplayText? The only thing it can do is return the actual text you typed in - ignoring the DisplayText. The Value is, of course, an exact match - it is essentially case sensitive.

So that's why this works. You are essentially setting it up in such a way that the DisplayText will NEVER match. Unless, of course, the user happens to type in a matching text with a space at the end.

Other than that one caveat (which seems unlikely to occur), I can't immediately thing of anything wrong with this solution. It's relying on some weird and esoteric behavior, but that behavior has been that way forever and it's unlikely to change. 

Thank you for the explanation, Mike!

So far we have not found major issues with the workaround. It has some weird (but expected) behavior when following data is present:

dataTable.Rows.Add("d", "d ", "lowercase");
dataTable.Rows.Add("D D", "D D ", "UPPERCASE");

Typing <D> <space> <D> to get the second item actually results into "d D" being displayed because once you typed <D> <space> the UltraCombo automatically selects item "d " and updates the displayed text. Despite that it does not break functionality. After completing the entry with the second <D>, the new code in the TextChanged event will find the best match ("D D") and use that. At that moment the displayed text is still wrong but after leaving the UltraCombo the Leave event will update the Value property with the best match. Then the displayed text updates to "D D ". Perfect.

There are obviously scenarios that do not work:

dataTable.Rows.Add("d", "d ", "lowercase");
dataTable.Rows.Add("d D", "d D ", "mixed case");
dataTable.Rows.Add("D D", "D D ", "UPPERCASE");

It is now impossible to select the last entry by typing <D> <space> <D> because the behavior described above forces the first uppercase "D" to lowercase "d" and hence you'll always end up with the second item "d D".

This is not really a problem for us. The data in this particular UltraCombo will rarely, if ever, contain spaces so users are unlikely to end up into that scenario.

Yeah, that makes sense. If you have duplicate DisplayText - or in this case duplicates that only differ by case (which is ignored), then it will always end up picking the first one when typing. 

The combo should handle it correctly if you were to drop down the list and select "D D", though.