只读记录

Question

I have a Windows Forms application that has data-bound controls (detail view), using BindingSource, BindingNavigator and TableAdapter controls. I would like to make a single record read-only. I have read numerous articles and tried several things without luck. I handled the DeleteItem on the Navigator, but soon realized you could still change it and a Move would save the changes.

I have read about IEditableObject and Filters, but not sure how to implement this with the above controls.

Answer 1

Your situation may be different, but since the special record I want to make read-only is added programmatically and the other records are entered by the user, I could just change the BindingSource's Filter property to this:

field1 <> 'Special' AND field2 <> 'Record'

and then the special record will not be displayed.

However, I really want to display the record, just not allow changes or deletion.

The relationship between the BindingSource and the BindingNavigator is explained in the Remarks in the BindingNavigator Class document.

However, I downloaded the BindingNavigator.cs source code in C# .NET and found these BindingNavigator button event handlers: OnMoveFirst, OnMovePrevious, OnMoveNext, OnMoveLast, OnAddNew, OnDelete, and each does a little more than just calling the related function in the BindingSource.

Here is one of interest:

    private void OnDelete(object sender, EventArgs e) {
        if (Validate()) { 
            if (bindingSource != null) {
                bindingSource.RemoveCurrent(); 
                RefreshItemsInternal(); 
            }
        } 
    }

We can see the Validate() function, but it suffers from less than great developer documentation:

    // <include file="doc\BindingNavigator.uex" path='docs/doc[@for="BindingNavigator.Validate"]/*'>
    // <devdoc> 
    //     Triggers form validation. Used by the BindingNavigator's standard items when clicked. If a validation error occurs
    //     on the form, focus remains on the active control and the standard item does not perform its standard click action. 
    //     Custom items may also use this method to trigger form validation and check for success before performing an action. 
    // </devdoc>
    public bool Validate() { 
        bool validatedControlAllowsFocusChange;
        return this.ValidateActiveControl(out validatedControlAllowsFocusChange);
    }

Bit hey, since it's public, I could call it too. They all finish up with:

    /// <devdoc>
    ///     Refresh the state of the items when the state of the data changes.
    /// </devdoc> 
    private void RefreshItemsInternal() {
        // Block all updates during initialization 
        if (initializing) { 
            return;
        } 

        // Call method that updates the items (overridable)
        OnRefreshItems();
    } 

    /// <include file="doc\BindingNavigator.uex" path='docs/doc[@for="BindingNavigator.OnRefreshItems"]/*'> 
    /// <devdoc> 
    ///     Called when the state of the tool strip items needs to be refreshed to reflect the current state of the data.
    ///     Calls <see cref="RefreshItemsCore"> to refresh the state of the standard items, then raises the RefreshItems event. 
    /// </see>
    protected virtual void OnRefreshItems() {
        // Refresh all the standard items
        RefreshItemsCore(); 

        // Raise the public event 
        if (onRefreshItems != null) { 
            onRefreshItems(this, EventArgs.Empty);
        } 
    }

    /// <include file="doc\BindingNavigator.uex" path='docs/doc[@for="BindingNavigator.RefreshItemsCore"]/*'>
    /// <devdoc> 
    ///     Refreshes the state of the standard items to reflect the current state of the data. 
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)] 
    protected virtual void RefreshItemsCore() {
        int count, position;
        bool allowNew, allowRemove;

        // Get state info from the binding source (if any)
        if (bindingSource == null) { 
            count = 0; 
            position = 0;
            allowNew = false; 
            allowRemove = false;
        }
        else {
            count = bindingSource.Count; 
            position = bindingSource.Position + 1;
            allowNew = (bindingSource as IBindingList).AllowNew; 
            allowRemove = (bindingSource as IBindingList).AllowRemove; 
        }

        // Enable or disable items (except when in design mode)
        if (!DesignMode) {
            if (MoveFirstItem != null)    moveFirstItem.Enabled    = (position > 1);
            if (MovePreviousItem != null) movePreviousItem.Enabled = (position > 1); 
            if (MoveNextItem != null)     moveNextItem.Enabled     = (position < count);
            if (MoveLastItem != null)     moveLastItem.Enabled     = (position < count); 
            if (AddNewItem != null)       addNewItem.Enabled       = (allowNew); 
            if (DeleteItem != null)       deleteItem.Enabled       = (allowRemove && count > 0);
            if (PositionItem != null)     positionItem.Enabled     = (position > 0 && count > 0); 
            if (CountItem != null)        countItem.Enabled        = (count > 0);
        }

        // Update current position indicator 
        if (positionItem != null) {
            positionItem.Text = position.ToString(CultureInfo.CurrentCulture); 
        } 

        // Update record count indicator 
        if (countItem != null) {
            countItem.Text = DesignMode ? CountItemFormat : String.Format(CultureInfo.CurrentCulture, CountItemFormat, count);
        }
    } 

So I came up with the following to prevent deletion, which works:

    // First change bindingNavigator1's DeleteItem property from bindingNavigatorDeleteItem to (none)
    // and then add a click event handler for the Delete button:
    private void bindingNavigatorDeleteItem_Click(object sender, EventArgs e)
    {
        // prevent special record deletion
        if ((textBox1.Text == "Special") && (textBox2.Text == "Record"))
        {
            MessageBox.Show("This record cannot be deleted.",
                "Delete operation aborted",
                MessageBoxButtons.OK,
                MessageBoxIcon.Information,
                MessageBoxDefaultButton.Button1);
        }
        else
        {
            if (this.Validate() && (this.bindingSource1 != null))
            {
                this.bindingSource1.RemoveCurrent();
                this.bindingSource1.EndEdit();
                this.tableAdapterManager.UpdateAll(this.dataSet1);
            }
        }
    }

Now, what about preventing changes? I have added a click handler for the Save button:

    private void bindingNavigator1SaveItem_Click(object sender, EventArgs e)
    {
        if ((textBox1.Text == "Special") && (textBox2.Text == "Record"))
        {
            MessageBox.Show("Cannot change this record.",
                "Save operation aborted",
                MessageBoxButtons.OK,
                MessageBoxIcon.Exclamation,
                MessageBoxDefaultButton.Button1);
            return;
        }

        try
        {
            this.Validate();
            this.bindingSource1.EndEdit();
            this.tableAdapterManager1.UpdateAll(this.DataSet1);
            this.tableAdapter1.Fill(DataSet1.Customers);
            this.bindingSource1.Position = this.DataSet1.Tables[0].Rows.Count;
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }
    }

However, at this point, the user can change a record and then click one of the move buttons. Now it seems the TableAdapter? gets updated, but the change never gets written back to the database without the Save button clicked. Maybe we can do better here.

Now, remember that Validate() function that all of the buttons called? Looking at the other event handlers, we see they all call Validate:

    private void OnMoveFirst(object sender, EventArgs e) { 
        if (Validate()) { 
            if (bindingSource != null) {
                bindingSource.MoveFirst(); 
                RefreshItemsInternal();
            }
        }

One might be led to think that the BindingNavigator Validating event might fire, and we could have displayed a MessageBox and set e.Cancel = true, but for some reason, it didn't fire on any button clicks.

The approach I finally took (a little kludgy looking) was to handle the TextChanged event for a key field of the special record and disable all the controls:

    private void textBox2_TextChanged(object sender, EventArgs e)
    {
        if (textBox2.Text == "Record")
        {
            foreach (Control ctrl in groupBox1.Controls)
            {
                if ((ctrl.GetType() == typeof(TextBox)) ||
                   (ctrl.GetType() == typeof(ComboBox)) ||
                   (ctrl.GetType() == typeof(CheckBox)))
                {
                    ctrl.Enabled = false;
                }
            }
        }
        else
        {
            foreach (Control ctrl in groupBox1.Controls)
            {
                if ((ctrl.GetType() == typeof(TextBox)) ||
                   (ctrl.GetType() == typeof(ComboBox)) ||
                   (ctrl.GetType() == typeof(CheckBox)))
                {
                    ctrl.Enabled = true;
                }
            }
        }
    }

If the only controls are TextBoxes, you may prefer to use "ctrl.ReadOnly = true" instead of "ctrl.Enabled = false".

I'm still looking for possibly a simpler, more elegant way to catch changes and prevent them...