C#

public static IEnumerable<T> SortObject<T>(this IEnumerable<T> ObjectToSort, string SortBy)
   {
       if (ObjectToSort == null)
           return null;
       if (string.IsNullOrEmpty(SortBy) == true)
           return null;

       // Handle sorting on object methods as well as properties
       string[] tempSorts = SortBy.Split(',');
       List<string> SortList = new List<string>();
       bool inParanthese = false;
       string addString = string.Empty;
       foreach (string tempSort in tempSorts)
       {
           if ((tempSort.Contains("(") == true) && (tempSort.Contains(")") == false))
           {
               inParanthese = true;
           }
           else if (tempSort.Contains(")") == true)
           {
               inParanthese = false;
           }
           if (inParanthese == false)
           {
               if (string.IsNullOrEmpty(addString) == false)
               {
                   SortList.Add(addString + "," + tempSort.Trim());
               }
               else
               {
                   SortList.Add(tempSort);
               }
               addString = string.Empty;
           }
           else
           {
               if (string.IsNullOrEmpty(addString) == false)
                   addString += ",";
               addString += tempSort.Trim();
           }
       }
       string[] Sorts = SortList.ToArray();
       bool Sorted = false;
       foreach (string FieldSort in Sorts)
       {
           string[] SubSort = FieldSort.Trim().Split(' ');

           string[] props = SubSort[0].Split('.');
           Type type = typeof(T);
           ParameterExpression arg = Expression.Parameter(type, "x");
           Expression expr = arg;
           foreach (string prop in props)
           {
               System.Reflection.PropertyInfo pi = type.GetProperty(prop);
               if (pi != null)
               {
                   Sorted = true;
                   //expr = Expression.Property(expr, pi);
                   expr = Expression.MakeMemberAccess(expr, pi);
                   type = pi.PropertyType;
               }
               else
               {
                   // Handle sorting on object methods as well as properties
                   string wholeMethod = prop;
                   if ((wholeMethod.Contains("(") == false) && (wholeMethod.Contains(")") == false))
                   {
                       //Ensure that method is in the proper format
                       wholeMethod += "()";
                   }
                   int firstParans = wholeMethod.IndexOf('(');
                   int lastParans = wholeMethod.LastIndexOf(')');
                   if ((firstParans > -1) && (lastParans > firstParans))
                   {
                       //Parse out method name and parameters
                       string methodname = wholeMethod.Substring(0, firstParans).Trim();
                       string paramList = wholeMethod.Substring(firstParans + 1, lastParans - (firstParans + 1));

                       System.Reflection.MethodInfo mi = null;
                       List<string> indParams = null;
                       if (paramList.Length > 0)
                       {
                           //Found some parameters
                           bool inDoubleQuotes = false;
                           bool inSingleQuotes = false;
                           string currParam = string.Empty;
                           indParams = new List<string>();
                           //Parse each individual parameter into a list of strings
                           foreach (char c in paramList)
                           {
                               if (c == '\"')
                               {
                                   if (inSingleQuotes == false)
                                   {
                                       inDoubleQuotes = !inDoubleQuotes;
                                   }
                                   currParam += c;
                               }
                               else if (c == '\'')
                               {
                                   if (inDoubleQuotes == false)
                                   {
                                       inSingleQuotes = !inSingleQuotes;
                                   }
                                   currParam += c;
                               }
                               else if ((c == ',') && (inDoubleQuotes == false) && (inSingleQuotes == false))
                               {
                                   //end of parameter
                                   if (string.IsNullOrEmpty(currParam) == false)
                                   {
                                       indParams.Add(currParam);
                                       currParam = string.Empty;
                                   }
                               }
                               else
                               {
                                   currParam += c;
                               }
                           }
                           if ((string.IsNullOrEmpty(currParam) == false) && (inDoubleQuotes == false) &&
                               (inSingleQuotes == false))
                           {
                               indParams.Add(currParam);
                           }
                           Type[] methodTypes = new Type[indParams.Count];
                           Expression[] methodParams = new Expression[indParams.Count];
                           int paramTypeIndex = 0;
                           int intResult;
                           //Determine parameter types and values for each parameter
                           foreach (string indParam in indParams)
                           {
                               if (indParam[0] == '\'')
                               {
                                   if ((indParam.Length == 3) && (indParam[2] == '\''))
                                   {
                                       //char
                                       methodTypes[paramTypeIndex] = typeof(char);
                                       methodParams[paramTypeIndex] = Expression.Constant(indParam[1], typeof(char));
                                   }
                                   else
                                   {
                                       //Invalid char so do as string
                                       methodTypes[paramTypeIndex] = typeof(string);
                                       methodParams[paramTypeIndex] = Expression.Constant(indParam, typeof(string));
                                   }
                               }
                               else if (indParam[0] == '"')
                               {
                                   //string
                                   methodTypes[paramTypeIndex] = typeof(string);
                                   methodParams[paramTypeIndex] = Expression.Constant(indParam, typeof(string));
                               }
                               else if (int.TryParse(indParam, out intResult) == true)
                               {
                                   //Int
                                   methodTypes[paramTypeIndex] = typeof(int);
                                   methodParams[paramTypeIndex] = Expression.Constant(intResult, typeof(int));
                               }
                               else
                               {
                                   methodTypes[paramTypeIndex] = typeof(object);
                                   methodParams[paramTypeIndex] = Expression.Constant(indParam);
                               }
                               paramTypeIndex++;
                           }
                           //Get the method
                           mi = type.GetMethod(methodname, methodTypes);
                           if (mi != null)
                           {
                               //Add the method with parameters to the dynamic LINQ expression
                               expr = Expression.Call(expr, mi, methodParams);
                           }
                       }
                       else
                       {
                           //No parameters for this method
                           mi = type.GetMethod(methodname, System.Type.EmptyTypes);
                           if (mi != null)
                           {
                               //Add the method to the dynamic LINQ expression
                               expr = Expression.Call(expr, mi);
                           }
                       }
                   }
               }
           }
           LambdaExpression lambda = Expression.Lambda(expr, arg);
           if (Sorted == true)
           {
               //Sorted = true;
               IQueryable<T> queryableData = ObjectToSort.AsQueryable<T>();
               if ((SubSort.Count() > 1) && (string.Compare(SubSort[1].Trim(), "desc", true) == 0))
               {
                   MethodCallExpression MyExpr = Expression.Call(
                       typeof(Queryable), "OrderByDescending",
                       new Type[] { typeof(T), type },
                       queryableData.Expression, lambda);
                   IQueryable<T> results = queryableData.Provider.CreateQuery<T>(MyExpr);
                   try
                   {
                       //Trying to determine when sub-property is a nullable object how to
                       //get the sort results without a NullReferenceException error
                       //Getting the count() throws the error if the sort is performed on a
                       //sub-property of a nullable object that is the property of the main object
                       results.Count();
                       ObjectToSort = results;
                   }
                   catch (Exception exc){}
                   //ObjectToSort = ObjectToSort.OrderByDescending(lambda);
                   //ObjectToSort = ObjectToSort.OrderByDescending(i => propInfo.GetValue(i, null));
               }
               else
               {
                   MethodCallExpression MyExpr = Expression.Call(
                       typeof(Queryable), "OrderBy",
                       new Type[] { typeof(T), type },
                       queryableData.Expression, Expression.Quote(lambda));
                   IQueryable<T> results = queryableData.Provider.CreateQuery<T>(MyExpr);
                   try
                   {
                       //Trying to determine when sub-property is a nullable object how to
                       //get the sort results without a NullReferenceException error
                       //Getting the count() throws the error if the sort is performed on a
                       //sub-property of a nullable object that is the property of the main object
                       results.Count();
                       ObjectToSort = results;
                   }
                   catch (Exception exc){}
                   //ObjectToSort = ObjectToSort.OrderBy(x => expr);
                   //ObjectToSort = ObjectToSort.OrderBy(i => propInfo.GetValue(i, null));
               }
           }
       }
       if (Sorted == true)
       {
           //Found at least one property to sort on in SortBy string
           return ObjectToSort;
       }
       else
       {
           //No valid properties found to sort on in SortBy string
           return null;
       }
   }

Matt U. wrote:

What I am looking for is the most efficient method for monitoring the orders and printing the label automatically. I hope that was explained clearly.

Matt U. wrote:

When an order is placed it will be inserted into a table in Microsoft SQL Server 2008.

Matt U. wrote:

The first potential solution I have contemplated: A Windows Service on Worker #2's station which monitors

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

using (SqlConnection connection = new SqlConnection(connectionString))
    {
        connection.Open();
        // Do work here; connection closed on leaving scope.
    }

devvvy wrote:

that's the problem - i ran it on debugger whole night just can't reproduce this problem. It only happens once in a full moon

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

devvvy wrote:

Column 'SomeCol' does not belong to table ABC

        // Register the User
        private void RegisterUser()
        {
            if (tbUsername.Text.Length > 0) // You may want longer than 1 char minimum for usernames
            {
                if (tbPassword.Text != tbRepeatPassword.Text) { MessageBox.Show("Passwords do not match"); RegisterUser(); } // passwords do not match retry
                // ok passwords do match are they empty?
                if (tbPassword.Text.Length == 0) { MessageBox.Show("Passwords can not be empty"); RegisterUser(); } // empty passwords try again!
                // Ok username and passwords are valid.
                // register the user !
                usersTableAdapter.Insert(tbUsername.Text, tbPassword.Text);
                Registered = true;
                RegisterUser(); // moved!
                this.Close();
            }
            else
                 MessageBox.Show("Username can not be empty");
        }

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

if(str.Length < 3)

if (str.Length < 4)

public static class Exte
   {
       public static void add(int x, int y)
       {
       }
       public static string GetFirstThreeCh(this string str)
       {
           if (str.Length < 3)
           {
               return str;
           }
           else
           {
               return str.Substring(0, 3);
           }
       }
   }

   class Program
   {
       static void Main(string[] args)
       {
           String str = "my new String";
           //str = str.GetFirstThreeCharacters();
           str = str.GetFirstThreeCh();
        }
}