C#

bgw.DoWork += ( s, e ) => { ... };

----------------------------------
Be excellent to each other

public class EMPLOYEE
    {
        /// <summary>
        /// list of EMPLOYEEs
        /// </summary>
        public static List<Tools.DB.OL.Xtime.EMPLOYEE> listEMPLOYEE = new List<Tools.DB.OL.Xtime.EMPLOYEE>();

        #region Methods

        /// <summary>
        /// Fills the EMPLOYEE.
        /// </summary>
        public static void FillEMPLOYEE()
        {
            listEMPLOYEE = GenericFactory<Tools.DB.OL.Xtime.EMPLOYEE>.FillList("SELECT * FROM EMPLOYEE");
        }
        /// <summary>
        /// Inserts the specified new EMPLOYEE.
        /// </summary>
        /// <param name="employee">The employee.</param>
        public static void InsertEMPLOYEE(Tools.DB.OL.Xtime.EMPLOYEE employee)
        {
            GenericFactory<Tools.DB.OL.Xtime.EMPLOYEE>.Insert(ref listEMPLOYEE, employee);
        }
        /// <summary>
        /// Updates the specified new EMPLOYEE.
        /// </summary>
        /// <param name="employee">The employee.</param>
        public static void UpdateEMPLOYEE(Tools.DB.OL.Xtime.EMPLOYEE employee)
        {
            GenericFactory<Tools.DB.OL.Xtime.EMPLOYEE>.Update(ref listEMPLOYEE, employee);
        }
        /// <summary>
        /// Deletes the EMPLOYEE.
        /// </summary>
        /// <param name="employee">The employee.</param>
        public static void DeleteEMPLOYEE(Tools.DB.OL.Xtime.EMPLOYEE employee)
        {
            GenericFactory<Tools.DB.OL.Xtime.EMPLOYEE>.Delete(ref listEMPLOYEE, employee);
        }

        #endregion

        #region SQL Queries

        public static Tools.DB.OL.Xtime.EMPLOYEE FindEMPLOYEE(Predicate<Tools.DB.OL.Xtime.EMPLOYEE> p)
        {
            Tools.DB.OL.Xtime.EMPLOYEE employee = new Tools.DB.OL.Xtime.EMPLOYEE();
            if (listEMPLOYEE.Exists(p))
            {
                employee = listEMPLOYEE.Find(p);
            }
            return employee;
        }
        #endregion
    }

Bardy85 wrote:

Tools.DB.OL.Xtime.EMPLOYEE employee = new Tools.DB.OL.Xtime.EMPLOYEE();
if (listEMPLOYEE.Exists(p))
{
employee = listEMPLOYEE.Find(p);
}

Tools.DB.OL.Xtime.EMPLOYEE employee = listEMPLOYEE.Find(p); // employee will be null if not found
return employee;

Bardy85 wrote:

There can be up to about 5000 or so Employee records.

Bardy85 wrote:

Tools.DB.OL.Xtime.EMPLOYEE employee = new Tools.DB.OL.Xtime.EMPLOYEE(); if (listEMPLOYEE.Exists(p)) { employee = listEMPLOYEE.Find(p); } return employee;

public class Person: IComparable(Person){
    private string name="";
    private string ocupation="";
      
    public string Name{
      get{return name;}
      set{name=value;}
    }
    .
    .
    .
    //implement IComparable
    public int CompareTo(Person other){
        return this.name.CompareTo(other.name);
    }
}

//now somewhere fill a List of Persons
      List(Person) persons = Utils.StoredProcs.PersonProcs.GetPersons();
      
      //and use binary search witch is very fast
      Person p = persons[
             persons.BinarySearch(new Person{Name="Some Name"})];
      //Do something with the rest of fields/data
      
      // Binary Search has O(n) = log (n); Of course you need to Order the data
      //I'm retriving it already oreder by the Select(s) statements/procs

I actually implemented a Reporting program this way. It's blazing fast.
Faster then our "entity" server. Memory consumption is like 170MB for a hole year worth of data.
//And there are tens of milions rows of data from over 10 tables/classes.

Botom line: if your app is to be run by a well established nr of users within your "entity"/firm/enterprise/whatever then go for it.
Try using StoredProcs instead of string commands => significant speed gains.

Bardy85 wrote:

I currently do implement IComparable, but don't sort the list of Objects or Use BinarySearch.
I guess this would speed up things up. Only problem I see is that BinarySearch does not take a Predicate as an arguement, and I use Predicates to find a matching object.
Do you know another way arround this? For example my Employee object has quite a few fields and I don't always want to search where the whole employee object matches, only maybe ID or Lastname, thats why I like using Predicates. In your above example you can only search on Name.

Mos Dan - Lucian wrote:

Try using StoredProcs instead of string commands => significant speed gains.

if (e.Button == MouseButtons.Left && _selecting)

if ((e.Button == MouseButtons.Left) && _selecting)

using (Graphics g = Graphics.FromImage(picItem.Image))
   {
   g.FillRectangle(Brushes.White, new Rectangle(0, 0, _selection.X, _selection.Y));
   }

using (Graphics g = Graphics.FromImage(picItem.Image))
   {
   int X = _selection.X - 1;
   int Y = _selection.Y - 1;
   if ((X > 0) && (Y > 0))
      {
      g.FillRectangle(Brushes.White, new Rectangle(0, 0, X, Y));
      }
   }