public void _location_PropertyChanging(object sender, PropertyChangingEventArgs e)
        {
            //if (e.PropertyName == "StadiumName")
            //{
            //    if (((PropertyChangingCancelEventArgs<String>)e).NewValue.All(char.IsLetter))
            //    {
            //        ((PropertyChangingCancelEventArgs<String>)e).Cancel = false;
            //    }
            //    else
            //    {
            //        ((PropertyChangingCancelEventArgs<String>)e).Cancel = true;

            //        throw new Exception("StadiumName should not have numbers");
            //    }
            //}

             if (e.PropertyName == "LocationName")
            {
                if (((PropertyChangingCancelEventArgs<String>)e).NewValue.All(char.IsLetter))
                {
                    ((PropertyChangingCancelEventArgs<String>)e).Cancel = false;
                }
                else
                {
                    ((PropertyChangingCancelEventArgs<String>)e).Cancel = true;

                    throw new Exception("LocationName should not have numbers");
                }
            }
        }

		protected virtual void RaisePropertyChanging(PropertyChangingEventArgs property)
		{
			if (this.PropertyChanging != null)
			{
				this.PropertyChanging(this, property);
			}
		}

 static void CPropertyChanging(Object sender, PropertyChangingEventArgs e)
 {
     if ("Nome|Sobrenome".Contains(e.PropertyName))
         Console.WriteLine("o valor original da propriedade {0} é {1}",
             e.PropertyName,
             sender.GetType().GetProperty(e.PropertyName).GetValue(sender, null));
 }

 /// <summary>
 /// Raises the PropertyChanging event.
 /// </summary>
 /// <param name="propertyName">The name of the property.</param>
 protected virtual void OnPropertyChanging([CallerMemberName] string propertyName = "")
 {
     if (PropertyChanging != null && SuppressEvents == false)
     {
         PropertyChangingEventArgs args = new PropertyChangingEventArgs(propertyName);
         PropertyChanging(this, args);
     }
 }

        protected virtual void NotifyPropertyChanging(string propertyName)
        {
            if (this.PropertyChanging != null)
            {
                var e = new PropertyChangingEventArgs(propertyName);

                this.PropertyChanging(this, e);
            }
        }

        public void Preset(object sender, PropertyChangingEventArgs args)
        {
            if (!_resetOnce)
                return;

            var stones = ((CupVM)DataContext).Stones;
            tbStones.ClearValue(TextBlock.TextProperty);
            tbStones.Text = stones.ToString();
            _resetOnce = false;
        }

        public void RememberOldValue(object sender, PropertyChangingEventArgs e)
        {
            if(instance != null)
            {
                throw new InvalidOperationException("Old value is already initialized");
            }

            instance = sender;
            propertyName = e.PropertyName;
            oldValue = TypeUtils.GetPropertyValue(sender, e.PropertyName);
        }

        /// <summary>
        /// elevar el evento de PropertyChanging. La propiedad especificada va a ser cambiada.
        /// </summary>
        /// <param name="propertyName">El nombre de la propiedad que ha cambiado.</param>
        public virtual void RaisePropertyChangingEvent(string propertyName)
        {
            // Salir si los cambios son ignorados.
            if (IgnorePropertyChangeEvents) return;

            // Salir si no se suscriben
            if (PropertyChanging == null) return;

            // Elevar el evento
            var e = new PropertyChangingEventArgs(propertyName);
            PropertyChanging(this, e);
        }

        private void MyPropertyChanging(object sender, PropertyChangingEventArgs e)
        {
            lock (this.oldPropertyValueDic)
            {
                // ViewModelの状態を元すため、プロパティの元の値を保存します。
                if (!this.oldPropertyValueDic.ContainsKey(e.PropertyName))
                {
                    this.oldPropertyValueDic[e.PropertyName] =
                        MethodUtil.GetPropertyValue(sender, e.PropertyName);
                }
            }

            base.OnPropertyChanging(e);
        }

        protected void OnLocationPropertyChanging(object sender, PropertyChangingEventArgs e)
        {
            LocationObj loc = sender as LocationObj;
            if (loc == null)
                return;

//            Trace.WriteLine("Location property changing: " + loc.ToString() + " property: " + e.PropertyName); 

            //Update if a position or everything has changed
            if (e.PropertyName.Contains("Position") || e.PropertyName.Contains("WorldPosition") || string.IsNullOrEmpty(e.PropertyName))
            {
//                Location locView = new Location(loc);
                RemoveStructureLinks(new LocationObj[]{loc});
                RemoveLocations(new LocationObj[] { loc }, false);
            }
        }

        public void _team_PropertyChanging(object sender, PropertyChangingEventArgs e)
        {
            if (e.PropertyName == "ShortName")
            {
                if(((PropertyChangingCancelEventArgs<String>)e).NewValue.All(char.IsLetter))
                {
                    ((PropertyChangingCancelEventArgs<String>)e).Cancel = false;
                }
                else
                {
                    ((PropertyChangingCancelEventArgs<String>)e).Cancel = true;

                    throw new Exception("Short Name should not have numbers");
                }
            }
        }

        public void _player_PropertyChanging(object sender, PropertyChangingEventArgs e)
        {
            //if (e.PropertyName == "FirstName")
            //{
            //    if (((PropertyChangingCancelEventArgs<String>)e).NewValue.All(char.IsLetter))
            //    {
            //        ((PropertyChangingCancelEventArgs<String>)e).Cancel = false;
            //    }
            //    else
            //    {
            //        ((PropertyChangingCancelEventArgs<String>)e).Cancel = true;

            //        throw new Exception("First Name should contain only Characters");
            //    }
            //}

            //else if (e.PropertyName == "LastName")
            //{
            //    if (((PropertyChangingCancelEventArgs<String>)e).NewValue.All(char.IsLetter))
            //    {
            //        ((PropertyChangingCancelEventArgs<String>)e).Cancel = false;
            //    }
            //    else
            //    {
            //        ((PropertyChangingCancelEventArgs<String>)e).Cancel = true;

            //        throw new Exception("Last Name should contain only Characters");
            //    }
            //}

             if (e.PropertyName == "MobileNo")
            {
                if (((PropertyChangingCancelEventArgs<String>)e).NewValue.All(char.IsDigit))
                {
                    ((PropertyChangingCancelEventArgs<String>)e).Cancel = false;
                }
                else
                {
                    ((PropertyChangingCancelEventArgs<String>)e).Cancel = true;

                    throw new Exception("Mobile No should contain only Numbers");
                }
            }
        }

 private void OnPropertyChanging(object subject, PropertyChangingEventArgs args)
 {
     if (args.PropertyName == PropertyName)
     {
         log.Trace("OnPropertyChanging " + args.PropertyName);
         // Unsubscribe from children
         UnsubscribeFromChildren(subject);
     }
 }

 private void OnPropertyChanging(object sender, PropertyChangingEventArgs e)
 {
     switch (e.PropertyName)
     {
         case "SelectedView":
             CheckSettingsWorkspace(SelectedView);
             break;
     }
 }

 private static void InstancePropertyChanging(object sender, PropertyChangingEventArgs e)
 {
 }

 private void _correspondenceFilter_PropertyChanging(object sender, PropertyChangingEventArgs e)
 {
     switch (e.PropertyName)
     {
         case "Value":
             RaisePropertyChanging(() => CorrespondenceFilter);
             break;
     }
 }

		private void HousesLazyItemPropertyChangingEventHandler(object sender, PropertyChangingEventArgs e)
		{
			NotifyChildPropertyChanging(PROPERTIES.HOUSES_LAZY, sender, e);
		}

        private static void OnViewModelPropertyChanging(object sender, PropertyChangingEventArgs e)
        {
            if (!AuditingManager.IsAuditingEnabled)
            {
                return;
            }

            var viewModel = (IViewModel)sender;

            object propertyValue = null;
            if (!string.IsNullOrEmpty(e.PropertyName))
            {
                PropertyHelper.TryGetPropertyValue(viewModel, e.PropertyName, out propertyValue);
            }

            AuditingManager.OnPropertyChanging(viewModel, e.PropertyName, propertyValue);
        }

		private void P2PropertyChangingEventHandler(object sender, PropertyChangingEventArgs e)
		{
			NotifyChildPropertyChanging(PROPERTIES.P2, sender, e);
		}

		protected virtual void NotifyChildPropertyChanging(string propertyName, object sender, PropertyChangingEventArgs e)
		{
			ChildPropertyChangingEventHandler handler = ChildPropertyChanging;
			if (handler != null)
				handler(sender, new ChildPropertyChangingEventArgs(this, propertyName, sender, e));
				
			if (propertyName == PROPERTIES.CHILDREN)
			{
				NotifyPropertyChanging(PROPERTIES.COMP_SUB);
				NotifyPropertyChanging(PROPERTIES.COMP_SUB_CACHED);
			}
			else if (propertyName == PROPERTIES.PS)
			{
				string path = (e is ChildPropertyChangingEventArgs ? ((ChildPropertyChangingEventArgs) e).FullPath : e.PropertyName);
				if (path == ModelUtils.NameOfProperty((MyClass o) => o.P))
				{
					NotifyPropertyChanging(PROPERTIES.COMP_SUB);
				}
				else if (path == ModelUtils.NameOfProperty((MyClass o) => o.P.X))
				{
					NotifyPropertyChanging(PROPERTIES.COMP_SUB_CACHED);
				}
			}
			else if (propertyName == PROPERTIES.P)
			{
				string path = (e is ChildPropertyChangingEventArgs ? ((ChildPropertyChangingEventArgs) e).FullPath : e.PropertyName);
				if (path == ModelUtils.NameOfProperty((Point o) => o.X))
				{
					NotifyPropertyChanging(PROPERTIES.COMP_SUB);
					NotifyPropertyChanging(PROPERTIES.COMP_SUB_CACHED);
				}
				else if (path == ModelUtils.NameOfProperty((Point o) => o.Y))
				{
					NotifyPropertyChanging(PROPERTIES.COMP_SUB);
					NotifyPropertyChanging(PROPERTIES.COMP_SUB_CACHED);
				}
			}
		}