~briangenisio/mypetproject/Main : /ActiveViewModel/ActiveViewModel.cs (revision 7)

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Reflection;

using Microsoft.Practices.Composite.Presentation.Commands;

namespace HouseOfBilz

{

    public class ActiveViewModel<PropertyT> : CustomTypeDescriptor, INotifyPropertyChanged

    {

        private readonly Dictionary<string, object> _values = new Dictionary<string, object>();

        public ActiveViewModel()

        {

            if (!typeof(PropertyT).IsEnum) throw new InvalidCastException("ActiveModel<PropertyT>: PropertyT must be an enum");

            CreateCommands();

        }

        public object Get(PropertyT name) { return Get(name.ToString()); }

        public T Get<T>(PropertyT name) { return (T)Get(name); }

        public T Get<T>(string name) { return (T)Get(name); }

        public object Get(string name)

        {

            if (_values.ContainsKey(name))

                return _values[name];

            return null;

        }

        protected void Set<T>(PropertyT name, T value) { Set(name.ToString(), value); }

        public void Set<T>(string name, T value)

        {

            if (_values.ContainsKey(name))

                _values[name] = value;

            else

                _values.Add(name, value);

            FirePropertyChanged(name);

            FireCanExecuteChanged(name);

        }

        protected void FirePropertyChanged(string propertyName)

        {

            var handlers = PropertyChanged;

            if (handlers != null)

                handlers(this, new PropertyChangedEventArgs(propertyName));

        }

        public event PropertyChangedEventHandler PropertyChanged;

        public override PropertyDescriptorCollection GetProperties()

        {

            return GetProperties(new Attribute[0]);

        }

        public override PropertyDescriptorCollection GetProperties(Attribute[] attributes)

        {

            var result = new PropertyDescriptorCollection(base.GetProperties().Cast<PropertyDescriptor>().ToArray());

            PropertyNames.Union(CommandNames).Each(name => result.Add(new ViewModelProperty(name, attributes)));

            return result;

        }

        private const string EXECUTE_PREFIX = "Execute_";

        private const string CAN_EXECUTE_PREFIX = "CanExecute_";

        private IEnumerable<string> CommandNames

        {

            get

            {

                return from method in GetType().GetMethods().Cast<MethodInfo>()

                       where method.Name.StartsWith(EXECUTE_PREFIX)

                       select method.Name.StripLeft(EXECUTE_PREFIX.Length);

            }

        }

        private static IEnumerable<string> PropertyNames

        {

            get

            {

                return from name in Enum.GetValues(typeof(PropertyT)).Cast<PropertyT>()

                       select name.ToString();

            }

        }

        private void CreateCommands()

        {

            CommandNames.Each(name => Set(name, new DelegateCommand<object>(x => ExecuteCommand(name), x => CanExecuteCommand(name))));

        }

        private void ExecuteCommand(string name)

        {

            var methodInfo = GetType().GetMethod(EXECUTE_PREFIX + name);

            if (methodInfo == null) return;

            methodInfo.Invoke(this, null);

        }

        private bool CanExecuteCommand(string name)

        {

            var methodInfo = GetType().GetMethod(CAN_EXECUTE_PREFIX + name);

            if (methodInfo == null) return true;

            return (bool)methodInfo.Invoke(this, null);

        }

        private void FireCanExecuteChanged(string propertyName)

        {

            CommandsDependentUpon(propertyName)

                .Each(commandName => {

                    var command = Get<DelegateCommand<object>>(commandName);

                    if (command != null)

                        command.RaiseCanExecuteChanged();

                });

        }

        private IEnumerable<string> CommandsDependentUpon(string propertyName)

        {

            foreach (var name in CommandNames)

            {

                var methodInfo = GetType().GetMethod(CAN_EXECUTE_PREFIX + name);

                if (methodInfo == null) continue;

                var dependentUpon = methodInfo.GetCustomAttributes(typeof(DependentUponAttribute), true).Cast<DependentUponAttribute>()

                    .Any(attribute => attribute.Names.Contains(propertyName));

                if (dependentUpon)

                    yield return name;

            }

        }

        private class ViewModelProperty : PropertyDescriptor

        {

            public ViewModelProperty(string name, Attribute[] attributes)

                : base(name, attributes)

            {

            }

            public override object GetValue(object component)

            {

                var viewModel = component as ActiveViewModel<PropertyT>;

                if (viewModel == null) return null;

                return viewModel.Get(Name);

            }

            public override void SetValue(object component, object value)

            {

                var viewModel = component as ActiveViewModel<PropertyT>;

                if (viewModel == null) return;

                viewModel.Set(Name, value);

            }

            public override void ResetValue(object component) { SetValue(component, null); }

            public override bool ShouldSerializeValue(object component) { return false; }

            public override Type ComponentType { get { return typeof(ActiveViewModel<PropertyT>); } }

            public override bool IsReadOnly { get { return false; } }

            public override Type PropertyType { get { return typeof(object); } }

            public override bool CanResetValue(object component) { return true; }

        }

    }

    [AttributeUsage(AttributeTargets.Method)]

    public class DependentUponAttribute : Attribute

    {

        public DependentUponAttribute(params object[] properties)

        {

            Names = properties.Select(name => name.ToString());

        }

        public IEnumerable<string> Names { get; private set; }

    }

    public static class Extensions

    {

        public static string StripLeft(this string value, int length)

        {

            return value.Substring(length, value.Length - length);

        }

        public static void Each<T>(this IEnumerable<T> list, Action<T> action)

        {

            foreach (var item in list)

                action(item);

        }

    }

}