[C#] On Code to Simplify

2007-12-20T21:13:03-08:00

for the sake of readability, i'm more of a lookup man myself.
it may not be as performant, but it's sure easier to read, and the ultimate addition line is much more understandable/simple.

// just for the switch

Dictionary<char,int> dict = new Dictionary<char,int>(26);
dict.Add('A',1);
dict.Add('B',0);
dict.Add('C',5);
dict.Add('D',7);
dict.Add('E',9);
dict.Add('F',13);
dict.Add('G',15);
dict.Add('H',17);
dict.Add('I',19);
dict.Add('J',21);
dict.Add('K',2);
dict.Add('L',4);
dict.Add('M',18);
dict.Add('N',20);
dict.Add('O',11);
dict.Add('P',3);
dict.Add('Q',6);
dict.Add('R',8);
dict.Add('S',12);
dict.Add('T',14);
dict.Add('U',16);
dict.Add('V',10);
dict.Add('W',22);
dict.Add('X',25);
dict.Add('Y',24);
dict.Add('Z',23);
dict.Add('0',1);
dict.Add('1',0);
dict.Add('2',5);
dict.Add('3',7);
dict.Add('4',9);
dict.Add('5',13);
dict.Add('6',15);
dict.Add('7',17);
dict.Add('8',19);
dict.Add('9',21);
// then instead of the big switch, use this:
somma += dict[codice_fiscale[i]];

[C#] I hate to do this, but...

2007-10-24T15:13:49-07:00

Let the battle begin!

using System;

namespace FizzBuzz
{
    class Program
    {
        static void Main(string[] args)
        {

            for (int i = 1; i < 101; i++)
                Console.WriteLine(string.Format("{0}{1}{2}",
                     i % 3 != 0 && i % 5 != 0 ? i.ToString() : "", i % 3 == 0 ? "Fizz" : "", i % 5 == 0 ? "Buzz" : ""));
            Console.ReadKey();
        }
    }
}

[C#] ExecuteCommandBatch

2007-10-21T02:34:55-07:00

It's rather large, but also rather simple.
The actual implementation has several overloads; it also doesn't seem to roll back every command.

    static class SqlExec
    {
        public static void ExecCommandBatch(System.Data.Common.DbConnection conn, System.Data.IsolationLevel isolation, ExceptionFailSafeEventHandler<System.Exception> failSafe, params System.Data.Common.DbCommand[] cmds)
        {
            if ((conn == null))
                throw new System.ArgumentNullException("conn");
            if ((cmds.Length < 2))
                throw new System.ArgumentException("Must supply more than one Command");
            // TODO: validate isolation?
            bool success = false;
            BatchCommandFailedException excp = null;
            ExceptionFailSafeEventArgs<System.Exception> args = new ExceptionFailSafeEventArgs<System.Exception>();
            int totalAffectedRows = 0;
            int length = cmds.Length - 1;
            int i;
            if ((conn.State != ConnectionState.Open))
                conn.Open();
            DbTransaction trans;
            try
            {
                trans = conn.BeginTransaction(isolation);
            }
            catch (System.Exception ex)
            {
                trans = conn.BeginTransaction();
            }
            for (i = 0; i <= length; i++)
            {
                cmds[i].Connection = conn;
                cmds[i].Transaction = trans;
            }
            try
            {
                for (i = 0; i <= length; i++)
                {
                    totalAffectedRows += cmds[i].ExecuteNonQuery();
                }
                success = true;
            }
            catch (System.Exception ex)
            {
                excp = new BatchCommandFailedException(cmds[i], i, ex);
            }
            finally
            {
                if (success)
                {
                    trans.Commit();
                }
                else
                {
                    trans.Rollback();
                    totalAffectedRows = 0;
                    args.Exception = excp.InnerException;
                    if (failSafe != null)
                        failSafe.Invoke(typeof(SqlExec), args);
                }
                trans.Dispose();
                foreach (DbCommand cmd in cmds)
                {
                    cmd.Dispose();
                }
                conn.Close();
                conn.Dispose();
                if (excp != null)
                    if (args.Throw)
                        throw excp;

            }
            //Return totalAffectedRows?
        }
    }

    public delegate void ExceptionFailSafeEventHandler<T>(object sender, ExceptionFailSafeEventArgs<T> e) where T : System.Exception;
    public class ExceptionFailSafeEventArgs<T> : System.EventArgs where T : System.Exception
    {

        private T _data;
        private bool _throw = true;

        public bool Throw
        {
            get { return _throw; }
            set { _throw = value; }
        }

        public ExceptionFailSafeEventArgs()
            : this(null) { }
        public ExceptionFailSafeEventArgs(T ex)
            : base()
        { _data = ex; }

        public T Exception
        { 
            get { return _data; }
            set { _data = value; }
        }
    }
    [Serializable()]
    public class BatchCommandFailedException : DbException
    {
        public BatchCommandFailedException(string message)
            : base("Command execution has failed.  Reason:  " + message){ }
        public BatchCommandFailedException(string message, DbCommand cmd)
            : base(string.Format("Command execution for command '{0}' has failed.  Reason:  " + message, cmd.CommandText)){ }
        public BatchCommandFailedException(DbCommand cmd)
            : base(string.Format("Command execution for command '{0}' has failed.", cmd.CommandText)){ }
        public BatchCommandFailedException(DbCommand cmd, int ordinal)
            : base(string.Format("Command execution for command {0}:  '{1}' has failed.", ordinal, cmd.CommandText)){ }
        public BatchCommandFailedException(DbCommand cmd, int ordinal, Exception inner)
            : base(string.Format("Command execution for command {0}:  '{1}' has failed.  Reason:  {2}", ordinal, cmd.CommandText, inner.Message), inner){ }
        public BatchCommandFailedException(string message, Exception inner)
            : base(message, inner){ }
        public BatchCommandFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
            : base(info, context){ }
    }

nibbles&bits

[C#] On Code to Simplify

[C#] I hate to do this, but...

[C#] ExecuteCommandBatch