carbon_golem - Professional Profile

using System;
using System.Collections.Generic;

namespace CodesKata {
    class Program {
        static void Main(string[] args) {
            var dumps = new List<errordump>();
            var d1 = new ErrorDump("0|R002|this is not a valid transaction");
            var d2 = new ErrorDump("1|R003|the card has expired");
            var d3 = new ErrorDump("2|R004|card code is invalid");
            var d4 = new ErrorDump("this is an invalid item / 5/ 1Z234J0952435");
            dumps.AddRange(new[] {d1, d2, d3, d4});
            foreach(var item in dumps) Console.WriteLine(item.LongCode);
            Console.ReadLine();
        }
    }

    public class ErrorDump {
        private Boolean valid;
        private readonly String error = String.Empty;
        public ErrorDump(String dump) {
            if(dump.Split('|').Length == 3) valid = true;
            error = dump;
        }
        public String LongCode { get { return valid ? error.Split('|')[2] : String.Empty; } }
    }
}
</errordump>

"Simplicity carried to the extreme becomes elegance."
-Jon Franklin

    public class TypeCache {

        private readonly Type actual;
        private Object subject;

      
        public TypeCache(Object cache) {
            subject = cache;
            actual = cache.GetType();
        }
      
        public Boolean IsA(Type proposed) {
            return proposed.IsAssignableFrom(actual);
        }

        public Type CachedType {
            get { return actual; }
        }

    
        public T Cast<t>() where T : class {
            return TypeCheck.Cast<t>(subject);
        }
    }


    public static class TypeCheck {
        
        public static Boolean IsA<t>(Object check) where T : class {
            //return check is T;
            return check.GetType().IsAssignableFrom(typeof(T));
        }

     
        public static T Cast<t>(Object subject) where T : class {
            return subject as T;
        }
    }
</t></t></t></t>

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;

namespace SynchroKata {
    public partial class Form1 : Form {

        SynchroServer serv;

        public Form1() {
            InitializeComponent();
            serv = new SynchroServer(this.lbNumberPending);
        }

        private void btnAdd_Click(object sender, EventArgs e) {
            serv.RunCommand(new SynchroCommand());
        }
    }

    public sealed class SynchroServer {

        private Label display;
        private Int32 count;

        public SynchroServer(Label label) {
            display = label;
        }

        public void RunCommand(SynchroCommand command) {
            Console.WriteLine("Command started");
            command.OnWorkComplete += new EventHandler(command_OnWorkComplete);
            count++;
            SetDisplay(count);
            ThreadPool.QueueUserWorkItem(new WaitCallback(command.CommandImpl));
        }


        private void SetDisplay(int cnt) {
            lock (this) {
                display.Invoke(new MethodInvoker(delegate { display.Text = cnt.ToString(); }));
            }
        }

        void command_OnWorkComplete(object sender, EventArgs e) {
            count--;
            SetDisplay(count);
            ((SynchroCommand)sender).OnWorkComplete -= command_OnWorkComplete;
        }
    }

    public sealed class SynchroCommand {

        private static Object sLock = new Object();

        public void CommandImpl(Object obj) {
            lock (sLock) {
                Thread.Sleep(3000);
                FireOnWorkComplete(this, new EventArgs());
            }
        }

        private Object syncLockA = new Object();
        private EventHandler onWorkComplete;
        public event EventHandler OnWorkComplete {
            add { lock (syncLockA) { onWorkComplete += value; } }
            remove { lock (syncLockA) { onWorkComplete -= value; } }
        }
        private void FireOnWorkComplete(Object sender, EventArgs args) {
            if (onWorkComplete != null) { onWorkComplete(sender, args); }
        }


    }
}

 public class StatusField<t> where T : struct{
        private T template;
        private ValueType v;
        private StatusField(ValueType initialValue) {
            v = initialValue;
            template = new T();
        }
                

        public Object UnderlyingValue {
            get {
                return v;
            }
            set {
                v = (ValueType)value;
            }

        }

        public Boolean this[T index] {
            get {
                if (Enum.IsDefined(typeof(T), index)) {
                    return false;
                } else {
                    throw new IndexOutOfRangeException("Field is not defined");
                }
            }
            set {

            }
        }

        public static StatusField<t> New(ValueType value) {
            return new StatusField<t>(value);
        }
    }
</t></t></t>

namespace StatusByteKata {
    class Program {
        static void Main(string[] args) {
            
            StatusField<alarms> field = StatusField<alarms>.New(Alarms.Battery | Alarms.Motion);
            Console.WriteLine(field.UnderlyingValue);
            Console.WriteLine(field[Alarms.Battery]);
            Console.ReadLine();
        }
    }

    [Flags]
    public enum Alarms : byte {
        [Description("Motion Alarm")]
        Motion = 0x01,
        [Description("Fire Alarm")]
        Fire = 0x02,
        [Description("Temperature Alarm")]
        Temperature = 0x04,
        [Description("Low Battery Alarm")]
        Battery = 0x08,
        [Description("Gas Alarm")]
        Gas = 0x10,
        [Description("Service Request")]
        ServiceRequest = 0x20,
        [Description("Camera Status")]
        Camera = 0x40
    }

    public class StatusField<T>
        where T : struct {

        #region Members
        private T template;
        private ValueType sword;
        #endregion

        private StatusField(ValueType initialValue) {
            template = new T();
            if (template is Enum) {
                Type t = template.GetType();
                if (t.GetCustomAttributes(typeof(FlagsAttribute), false).Length == 0) {
                    throw new System.InvalidCastException("Requires Enum that defines FlagsAttribute");
                }
                sword = initialValue;
            } else {
                throw new System.InvalidCastException("Could  not convert generic type");
            }
        }

        public Object UnderlyingValue {
            get {
                return sword;
            }
            set {
                sword = (ValueType)value;
            }

        }

        public Boolean this[T index] {
            get {
                if (Enum.IsDefined(typeof(T), index)) {
                    Object x = Convert.ChangeType(index, typeof(Int64));
                    Int64 temp1 = (Int64)x;
                    Object y = Convert.ChangeType(sword, typeof(Int64));
                    Int64 temp2 = (Int64)y;
                    return (temp1 & temp2) == temp1;
                } else {
                    throw new IndexOutOfRangeException("Field is not defined");
                }
            }
            set {
                if (Enum.IsDefined(typeof(T), index)) {
                    // setter not defined
                } else {
                    throw new IndexOutOfRangeException("Field is not defined");
                }
            }
        }

        public static StatusField<T> New(ValueType value) {
            return new StatusField<T>(value);            
        }       
    }    
}