C#

    public class LookupTable
    {
        public int Id { get; set; }

        [Required(ErrorMessage = "Code is required.")]<br />
        public string Code { get; set; }

        [Required(ErrorMessage = "Description is required.")]
        public string Description { get; set; }
        public int? ForeignKeyId { get; set; }
        public string ForeignKeyValue { get; set; }
        public DateTime? CreatedDate {get;set;} 
        public string CreatedBy {get;set;}       
        public int CodeLength { get; set; }
    }

        protected override IEnumerable<System.Web.Mvc.ModelValidator> GetValidators(System.Web.Mvc.ModelMetadata metadata, ControllerContext context, IEnumerable<Attribute> attributes)
        { 
            if (metadata.Model is LookupTable)
            {
                LookupTable model = metadata.Container as LookupTable;                

                if (metadata.PropertyName == GetPropertyName(() => model.Code) && (model.CodeLength > 0))
                {
                    var newAttributes = new List<Attribute>(attributes);
                    var stringLength = newAttributes.OfType<StringLengthAttribute>().FirstOrDefault();
                    if (stringLength != null)
                    {
                        newAttributes.Remove(stringLength);

                        if (model.CodeLength != 0)
                        {
                            newAttributes.Add(new StringLengthAttribute(model.CodeLength)
                            {
                                MinimumLength = model.CodeLength,
                                ErrorMessage = @"The field {{0}} length must be at least {model.CodeLength}."
                            });
                        }

                        attributes = newAttributes;
                    }
                }
            }            

            return base.GetValidators(metadata, context, attributes);
        }

if (stringLength != null)
{
    newAttributes.Remove(stringLength);
}

if (model.CodeLength != 0)
{
    newAttributes.Add(new StringLengthAttribute(model.CodeLength)
    {
        MinimumLength = model.CodeLength,
        ErrorMessage = @"The field {{0}} length must be at least {model.CodeLength}."
    });
}

attributes = newAttributes;

<configuration>
    <appSettings>
        <add key="ClientValidationEnabled" value="true"/>
        <add key="UnobtrusiveJavaScriptEnabled" value="true"/>

class Complex
{
    private double real;                // member #1
    private double imag;                // member #2

    // Constructors
    public Complex()
    {
        real = 0.0;
        imag = 0.0;
    }

    public Complex(double x)
    {
        real = x;
        imag = 0.0;
    }

    public Complex(double x, double y)
    {
        real = x;
        imag = y;
    }

    // property
    public double Real { get; set; }

    // method
    public double norm()
    {
        return real * real + imag * imag;
    }
};

public abstract class HierarchyBase : INotifyPropertyChanged
   {

       private ObservableCollection<HierarchyBase> children = new ObservableCollection<HierarchyBase>();

       public ObservableCollection<HierarchyBase> Children
       {
           get { return children; }
           set { children = value; }
       }


       public string Name { get; set; }

       private bool pIsEnabled;
       public bool IsEnabled
       {
           get { return pIsEnabled; }
           set { pIsEnabled = value;
               StateUpdated();
               OnPropertyChanged();
           }
       }

       private bool pIsVisible;

       public bool IsVisible
       {
           get { return pIsVisible; }
           set {
               pIsVisible = value;
               StateUpdated();
               OnPropertyChanged();
           }
       }

       private void StateUpdated()
       {
           if (this is IDrawing)
           {
               ((IDrawing)this).Redraw(IsVisible);
           }

           foreach (HierarchyBase child in Children)
           {
               if (!this.IsEnabled || !this.IsVisible)
               {
                   child.IsVisible = false;
               }
           }
       }

       public event PropertyChangedEventHandler PropertyChanged;

       private void OnPropertyChanged([CallerMemberName]string caller = "")
       {
           // make sure only to call this if the value actually changes

           var handler = PropertyChanged;
           if (handler != null)
           {
               handler(this, new PropertyChangedEventArgs(caller));
               StateUpdated();
           }
       }
   }

<TreeView x:Name="tree">
    <TreeView.Resources>
        <HierarchicalDataTemplate DataType="{x:Type local:HierarchyBase}" ItemsSource="{Binding Children}" >
            <TextBox Text="{Binding Name}"/>
        </HierarchicalDataTemplate>
    </TreeView.Resources>
</TreeView>

public abstract class HierarchyBase : INotifyPropertyChanged
   {
       public HierarchyBase()
       {
           Delete = new RelayCommand( CanDelete, DeleteThis);
           children.CollectionChanged +=ItemChildren_CollectionChanged;
       }

       public Canvas myCanvas;
       private HierarchyBase _parent;

       private void ItemChildren_CollectionChanged(object sender,NotifyCollectionChangedEventArgs e)
       {
           //different kind of changes that may have occurred in collection
           if (e.Action == NotifyCollectionChangedAction.Add)
           {
               foreach (var item in e.NewItems)
               {
                   ((HierarchyBase)item)._parent = this;
                   ((HierarchyBase)item).myCanvas = this.myCanvas;
               }
               //((List<object>)e.NewItems).ForEach(i => ((HierarchyBase)i)._parent = this); // foreach (e.NewItems)(i => i;)

           }
           if (e.Action == NotifyCollectionChangedAction.Replace)
           {
               //your code
           }
           if (e.Action == NotifyCollectionChangedAction.Remove)
           {
               foreach (var item   in e.OldItems)
               {
                   ((HierarchyBase)item)._parent = null;
                   ((HierarchyBase)item).myCanvas = null;
               }
           }
           if (e.Action == NotifyCollectionChangedAction.Move)
           {
               //your code
           }
       }

       private ObservableCollection<HierarchyBase> children = new ObservableCollection<HierarchyBase>();


       public ObservableCollection<HierarchyBase> Children
       {
           get { return children; }
           set { children = value; }
       }

       public ICommand Delete { get; set; }

       private bool CanDelete(object obj)
       {
           return IsEnabled;
       }

       private void DeleteThis(object obj)
       {
           this._parent.Children.Remove(this);
       }

       public string Name { get; set; }

       private bool pIsEnabled = true;
       public bool IsEnabled
       {
           get { return pIsEnabled; }
           set { pIsEnabled = value;
               OnPropertyChanged();
           }
       }

       private bool pIsVisible = true;

       public bool IsVisible
       {
           get { return pIsVisible; }
           set {
               pIsVisible = value;
               OnPropertyChanged();
           }
       }

       private void StateUpdated()
       {
           if (this is IDrawing)
           {
               ((IDrawing)this).Redraw(IsVisible);
           }

           foreach (HierarchyBase child in Children)
           {
               if (!this.IsEnabled || !this.IsVisible)
               {
                   child.IsVisible = false;
               }
           }
       }

       public event PropertyChangedEventHandler PropertyChanged;

       private void OnPropertyChanged([CallerMemberName]string caller = "")
       {
           // make sure only to call this if the value actually changes

           var handler = PropertyChanged;
           if (handler != null)
           {
               handler(this, new PropertyChangedEventArgs(caller));
               StateUpdated();
           }
       }
   }