C#

protected void gvCATW_RowDataBound(object sender, GridViewRowEventArgs e)

{
    if (e.Row.RowType == DataControlRowType.DataRow)
    {                

    // To check condition on integer value
    if (Convert.ToDecimal(DataBinder.Eval(e.Row.DataItem, "ActualFTE")) > 1.25M)
    {
      e.Row.BackColor = System.Drawing.Color.Red;
    }
}

Sascha Lefèvre wrote:

Expose only the required actions on the dictionary as methods in the interface, not the dictionary (-property).

BillWoodruff wrote:

do you mean have the Interface declare method signatures for such actions as Dictionary ... 'Add, 'Remove, etc. ?

BillWoodruff wrote:

Or, could you mean ... in the Interface ... declare the signature of a method whose "only purpose" is to set the initial Value of the Property ?

BillWoodruff wrote:

Have a great day (well, it's GMT +07:00 here) !

Sascha Lefèvre wrote:

Generally I think any complex member of a class shouldn't be publicly exposed in order to be able to control which actions can be performed on it.

public interface IRequire
{
    Dictionary<string, int> RequiredDictionary { get; }
}

public class Example : IRequire
{
    // explicit implementation of IRequire
    Dictionary<string, int> IRequire.RequiredDictionary
    {
        get { return this.internalDictionary; }
    }

    private Dictionary<string, int> internalDictionary { set; get; }

    public Example()
    {
        internalDictionary = new Dictionary<string, int>();
    }

    public void AddToRequiredDictionary(string str, int i)
    {
        internalDictionary.Add(str, i);
    }

    public void RemoveRequiredDictionary(string key)
    {
        internalDictionary.Remove(key);
    }
}

public interface IRequire
{
    void AddEntry(string key, int value );
    void RemoveEntry(string key);
}

public class Example : IRequire
{
    private Dictionary<string, int> internalDictionary { set; get; }

    public Example()
    {
        internalDictionary = new Dictionary<string, int>();
    }

    public void AddEntry(string key, int value)
    {
        internalDictionary.Add(key, value);
    }

    public void RemoveEntry(string key)
    {
        internalDictionary.Remove(key);
    }
}

Example ex1 = new Example();
// casting ex1 to IRequire:
((IRequire)ex1).RequiredDictionary.Clear(); // probably not desired to be possible

// or assign the new instance to an IRequire-variable:
IRequire ex2 = new Example();
ex2.RequiredDictionary.Clear();

public interface IRequire
{
    IReadOnlyDictionary<string, int> RequiredDictionary { get; }
    void AddEntry(string key, int i);
    void RemoveEntry(string key);
}

public class Example : IRequire
{
    public IReadOnlyDictionary<string, int> RequiredDictionary
    {
        get { return new ReadOnlyDictionary<string, int>(InternalDictionary); }
    }

    private Dictionary<string, int> InternalDictionary;

    public Example()
    {
        InternalDictionary = new Dictionary<string, int>();
    }

    public void AddEntry(string key, int i)
    {
        InternalDictionary.Add(key, i);
    }

    public void RemoveEntry(string key)
    {
        InternalDictionary.Remove(key);
    }
}

BillWoodruff wrote:

I, for one, look forward to the upcoming provision in future versions of C# of method constraints: that's been mentioned in something I read recently (mabye Eric Lippert's blog ?), but I locate find the source right now.

BillWoodruff wrote:

you must, of course, implement those Properties the Interface specifies as 'Public ... that's the way Interfaces work in C# / .NET.

public partial class SomeComponent : TextBox, IHasSomething
{
    public SomeComponent() 
    { 
        InitializeComponent(); 

        this.AutoSize = true;
        IntToString = new Dictionary<int, string>();
    }
    
    public SomeComponent(IContainer container)
    {
        container.Add(this);
        InitializeComponent();

        this.AutoSize = true;
        IntToString = new Dictionary<int, string>();
    }

    protected Dictionary<int, string> IntToString { get; set; }

    Dictionary<int, string> IHasSomething.IntToString
    {
        get { return IntToString; }
        set { IntToString = value; }
    }
}

Pete O'Hanlon wrote:

The second part is more architectural. It sounds to me like the problem you are trying to solve is most likely one that indicates that you aren't separating concerns. In other words, you are mixing the behaviour of the interface with the form.

[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public Dictionary<int, string> IntToString {
  get { return dic; }
  set { dic = value; }
}

this.someComponent1.IntToString = ((System.Collections.Generic.Dictionary<int, string>)(resources.GetObject("someComponent1.IntToString")));