Introduction

A non-editable ComboBox is useful when users must choose from a controlled set of values rather than typing arbitrary text. In .NET the exact property differs between WinForms and WPF, but the design goal is the same: allow selection while preventing free-form input.

WinForms Uses DropDownStyle

In WinForms, the key property is DropDownStyle. Set it to ComboBoxStyle.DropDownList to make the control selection-only.

1using System;
2using System.Windows.Forms;
3
4public class StatusForm : Form
5{
6    private readonly ComboBox statusCombo = new ComboBox();
7
8    public StatusForm()
9    {
10        statusCombo.Left = 20;
11        statusCombo.Top = 20;
12        statusCombo.Width = 220;
13        statusCombo.DropDownStyle = ComboBoxStyle.DropDownList;
14
15        statusCombo.Items.AddRange(new object[]
16        {
17            "Pending",
18            "Approved",
19            "Rejected"
20        });
21
22        statusCombo.SelectedIndex = 0;
23        Controls.Add(statusCombo);
24    }
25
26    [STAThread]
27    public static void Main()
28    {
29        Application.EnableVisualStyles();
30        Application.Run(new StatusForm());
31    }
32}

With DropDownList, the user can still open the dropdown and select values, but cannot type new ones into the text area.

WPF Uses IsEditable="False"

In WPF, the equivalent behavior is controlled by the IsEditable property.

1<Window x:Class="ComboDemo.MainWindow"
2        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4        Title="Status" Height="180" Width="320">
5    <Grid Margin="20">
6        <ComboBox x:Name="StatusCombo"
7                  IsEditable="False"
8                  SelectedIndex="0">
9            <ComboBoxItem>Pending</ComboBoxItem>
10            <ComboBoxItem>Approved</ComboBoxItem>
11            <ComboBoxItem>Rejected</ComboBoxItem>
12        </ComboBox>
13    </Grid>
14</Window>

That gives you a selection control without turning the ComboBox into a disabled widget.

Prefer Data Binding Over Hardcoded Strings

For maintainability, bind the ComboBox to strongly typed values instead of scattering raw strings through the form code. An enum is a common choice.

1public enum ApprovalStatus
2{
3    Pending,
4    Approved,
5    Rejected
6}

In WinForms:

statusCombo.DataSource = Enum.GetValues(typeof(ApprovalStatus));
statusCombo.DropDownStyle = ComboBoxStyle.DropDownList;

In WPF, expose the enum values through the view model and bind the ItemsSource. This keeps UI options and business logic aligned.

Do Not Confuse “Non-Editable” With “Disabled”

A disabled ComboBox and a non-editable ComboBox are not the same thing. Disabling the control blocks all interaction, including selection. Non-editable mode still allows users to choose a valid option.

That distinction matters for usability and accessibility. If the goal is to enforce valid choices, selection-only mode is usually correct. If the goal is to prevent any interaction, disable the control deliberately and explain why.

Keep Keyboard and Accessibility Behavior Intact

Selection-only should still feel like a normal control. Users should be able to tab into the ComboBox, open the list with the keyboard, and move through options without being forced to use the mouse. If a custom style or template breaks that behavior, the control may technically be non-editable while still being a poor input experience.

Keep Validation in the Domain Layer

Even when the ComboBox is non-editable, you should still validate the selected value in business logic. UI constraints do not protect you from programmatic changes, bad imports, or mismatched defaults.

1if (statusCombo.SelectedItem is null)
2{
3    MessageBox.Show("Please select a status.");
4    return;
5}
6
7var selected = (ApprovalStatus)statusCombo.SelectedItem;

That keeps the application safe even if the UI changes later.

Watch for Runtime Rebinding Issues

Editable behavior sometimes appears to “come back” after data rebinding or control recreation. If options are refreshed dynamically, confirm that the relevant selection-only property is still set after the update.

In WinForms, that means checking DropDownStyle after rebinding. In WPF, it means making sure a custom control template or style has not reintroduced editable text behavior.

Common Pitfalls

The biggest mistake is disabling the control when you only meant to prevent typing. Another is hardcoding string lists in the UI while the rest of the application uses a typed status model. Developers also forget that runtime rebinding can effectively reset the behavior they expected.

Summary

• Use ComboBoxStyle.DropDownList in WinForms for a non-editable ComboBox.
• Use IsEditable="False" in WPF for the same selection-only behavior.
• Prefer binding to typed values such as enums instead of raw strings.
• Keep domain validation even when the UI blocks free typing.
• Check behavior again after rebinding or applying custom control styles.