C#

pictureBox1.Image = capture.QueryFrame().ToBitmap(); 

Image oldImage=pictureBox1.Image;
pictureBox1.Image = capture.QueryFrame().ToBitmap();
if (oldImage!=null) oldImage.Dispose();

public string SchoolName
{
    get { return name; }
    set { name = value; }
}

d.SetSchool("Alan");
Console.WriteLine("The School is :" + d.GetSchool());

d.SchoolName = "Alan";
Console.WriteLine("The School is :" + d.SchoolName);

binn019 wrote:

protect the data by outside world

public class School
{
    private int name;

    public string testing;
    // Accessor.
    public string GetSchool()
    {
        return name.ToString();
    }
    // Mutator.
    public void SetSchool(string a)
    {
        if (!int.TryParse(a, out name))
        {
            name=0;
        }
    }
}

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.