C#

decimal ActualFTE=Convert.ToDecimal("0.9500");

if (ActualFTE > 1.25)
{
   e.Row.BackColor = Color.Red;
 }

using System;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Web.UI;
using System.Drawing;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;

namespace StaffingWebParts.CatwComment
{
    public partial class CatwCommentUserControl : UserControl
    {
        SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["SQLStaffingConn"].ConnectionString);
        SqlCommand cmd = new SqlCommand();
                
        protected void Page_Load(object sender, EventArgs e)
        {
            lblMsg.Text = "";
            if (!Page.IsPostBack)
            {
                BindSubjectData();
            }
        }
        protected void highlightrow(object sender, GridViewRowEventArgs e)
        {
           if (e.Row.RowType == DataControlRowType.DataRow)
           {
             decimal ActualFTE = Convert.ToDecimal(e.Row.Cells[5].Text.ToString());
               
             if (ActualFTE > 1.2500M)
               {
                  e.Row.BackColor = Color.Red;
                }
            }
        }
        //call to bind gridview
        protected void BindSubjectData()
        {
            using (SqlConnection sqlCon = new SqlConnection(ConfigurationManager.ConnectionStrings["SQLStaffingConn"].ConnectionString))
            {
                using (SqlCommand cmd = new SqlCommand())
                {
                    cmd.CommandText = ("select a.id, b.StaffTrackingID, a.ResourceName, b. EstimateHours, EstimateFTE, b.ActualHours, b.ActualFTE,b.Comment, b.CommentBy, b.Period  from  StaffTracking a, StaffTrackingFTEData b where a.id = b.StaffTrackingid  order by ResourceName");
                    cmd.Connection = sqlCon;
                    sqlCon.Open();
                    SqlDataAdapter da = new SqlDataAdapter(cmd);
                    DataTable dt = new DataTable();
                                   
                    da.Fill(dt);
                    if (dt.Rows.Count > 0)
                    {
                        gvCATW.DataSource = dt;
                        gvCATW.DataBind();
                    }
                    else
                    {
                        DataRow dr = dt.NewRow();
                        dt.Rows.Add(dr);
                        gvCATW.DataSource = dt;
                        gvCATW.DataBind();
                        gvCATW.Rows[0].Visible = false;
                    }
                    sqlCon.Close();
                }
            }
        }
        //called on row edit command
        protected void gvCATW_RowEditing(object sender, GridViewEditEventArgs e)
        {
            gvCATW.EditIndex = e.NewEditIndex;
            BindSubjectData();
        }

        //called when cancel edit mode
        protected void gvCATW_RowCancelingEdit(object sender, GridViewCancelEditEventArgs e)
        {
            gvCATW.EditIndex = -1;
            BindSubjectData();
        }

        //called on row update command
        protected void gvCATW_RowUpdating(object sender, GridViewUpdateEventArgs e)
        {
            bool IsUpdated = false;
            //getting key value, row id
            int StaffTrackingID =
            Convert.ToInt32(gvCATW.DataKeys[e.RowIndex].Value.ToString());
            //getting row field details
            TextBox ResourceName =
            (TextBox)gvCATW.Rows[e.RowIndex].FindControl("txtResourceName");
            TextBox EstimateHours = (TextBox)gvCATW.Rows[e.RowIndex].FindControl("txtEstimateHours");
            TextBox EstimateFTE = (TextBox)gvCATW.Rows[e.RowIndex].FindControl("txtEstimateFTE");
            TextBox ActualHours = (TextBox)gvCATW.Rows[e.RowIndex].FindControl("txtActualHours");
            TextBox ActualFTE = (TextBox)gvCATW.Rows[e.RowIndex].FindControl("txtActualFTE");
            TextBox Comment = (TextBox)gvCATW.Rows[e.RowIndex].FindControl("txtComment");
            TextBox CommentBy = (TextBox)gvCATW.Rows[e.RowIndex].FindControl("txtCommentBy");
            TextBox Period =  (TextBox)gvCATW.Rows[e.RowIndex].FindControl("txtPeriod");
                 

            //   TextBox Grade = (TextBox)gvSubDetails.Rows[e.RowIndex].FindControl("txtGrade");
            using (SqlConnection sqlCon = new SqlConnection(ConfigurationManager.ConnectionStrings["SQLStaffingConn"].ConnectionString))
            {
                using (SqlCommand cmd = new SqlCommand())
                {
                   
                    //here i'd added "@" for continuous string in new line
                    cmd.CommandText = @"UPDATE StaffTrackingFTEData SET StaffTrackingID=@StaffTrackingID, EstimateHours=@EstimateHours, EstimateFTE=@EstimateFTE, ActualHours=@ActualHours, ActualFTE=@ActualFTE,Comment=@Comment, CommentBy=@CommentBy, period=@Period WHERE StaffTrackingID=@StaffTrackingID";
                    cmd.Parameters.AddWithValue("@StaffTrackingId", StaffTrackingID);
                    cmd.Parameters.AddWithValue("@EstimateHours", EstimateHours.Text);
                    cmd.Parameters.AddWithValue("@EstimateFTE", EstimateFTE.Text);
                    cmd.Parameters.AddWithValue("@ActualHours", ActualHours.Text);
                    cmd.Parameters.AddWithValue("@ActualFTE", ActualFTE.Text);
                    cmd.Parameters.AddWithValue("@Comment", Comment.Text);
                    cmd.Parameters.AddWithValue("@CommentBy", CommentBy.Text);
                    cmd.Parameters.AddWithValue("@Period", Period.Text);




                    cmd.Connection = sqlCon;
                    sqlCon.Open();
                    IsUpdated = cmd.ExecuteNonQuery() > 0;
                    sqlCon.Close();
                }
            }
            if (IsUpdated)
            {
                lblMsg.Text = "'" + ResourceName.Text + "' CATW Comment updated successfully!";
                lblMsg.ForeColor = System.Drawing.Color.Green;
            }
            else
            {
                lblMsg.Text = "Error while updating '" + ResourceName.Text + "' subject details";
                lblMsg.ForeColor = System.Drawing.Color.Red;
            }
            gvCATW.EditIndex = -1;
            BindSubjectData();
        }

    
    }
}

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")));