C# Walker.WalkProperties方法代码示例

        public virtual ValidationErrorCollection ValidateProperties(ValidationManager manager, object obj)
        {
            if (manager == null)
                throw new ArgumentNullException("manager");
            if (obj == null)
                throw new ArgumentNullException("obj");

            ValidationErrorCollection errors = new ValidationErrorCollection();

            Activity activity = manager.Context[typeof(Activity)] as Activity;

            // Validate all members that support validations.
            Walker walker = new Walker(true);
            walker.FoundProperty += delegate(Walker w, WalkerEventArgs args)
            {
                //If we find dynamic property of the same name then we do not invoke the validator associated with the property
                //Attached dependency properties will not be found by FromName().

                // args.CurrentProperty can be null if the property is of type IList.  The walker would go into each item in the
                // list, but we don't need to validate these items.
                if (args.CurrentProperty != null)
                {
                    DependencyProperty dependencyProperty = DependencyProperty.FromName(args.CurrentProperty.Name, args.CurrentProperty.DeclaringType);
                    if (dependencyProperty == null)
                    {
                        object[] validationVisibilityAtrributes = args.CurrentProperty.GetCustomAttributes(typeof(ValidationOptionAttribute), true);
                        ValidationOption validationVisibility = (validationVisibilityAtrributes.Length > 0) ? ((ValidationOptionAttribute)validationVisibilityAtrributes[0]).ValidationOption : ValidationOption.Optional;
                        if (validationVisibility != ValidationOption.None)
                        {
                            errors.AddRange(ValidateProperty(args.CurrentProperty, args.CurrentPropertyOwner, args.CurrentValue, manager));
                            // don't probe into subproperties as validate object inside the ValidateProperties call does it for us
                            args.Action = WalkerAction.Skip;
                        }
                    }
                }
            };

            walker.WalkProperties(activity, obj);

            return errors;
        }

        public virtual void GenerateCode(CodeGenerationManager manager, object obj)
        {
            if (manager == null)
                throw new ArgumentNullException("manager");
            if (obj == null)
                throw new ArgumentNullException("obj");

            Activity activity = obj as Activity;
            if (activity == null)
                throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(Activity).FullName), "obj");

            manager.Context.Push(activity);

            // Generate code for all the member Binds.
            Walker walker = new Walker();
            walker.FoundProperty += delegate(Walker w, WalkerEventArgs args)
            {
                //
                ActivityBind bindBase = args.CurrentValue as ActivityBind;
                if (bindBase != null)
                {
                    // push
                    if (args.CurrentProperty != null)
                        manager.Context.Push(args.CurrentProperty);
                    manager.Context.Push(args.CurrentPropertyOwner);

                    // call generate code
                    foreach (ActivityCodeGenerator codeGenerator in manager.GetCodeGenerators(bindBase.GetType()))
                        codeGenerator.GenerateCode(manager, args.CurrentValue);

                    // pops
                    manager.Context.Pop();
                    if (args.CurrentProperty != null)
                        manager.Context.Pop();
                }
            };
            walker.WalkProperties(activity, obj);
            manager.Context.Pop();
        }

        private void OnRefreshTypes(object sender, EventArgs e)
        {
            if (this.refreshTypesHandler != null)
            {
                WorkflowView workflowView = this.serviceProvider.GetService(typeof(WorkflowView)) as WorkflowView;
                if (workflowView != null)
                    workflowView.Idle -= this.refreshTypesHandler;
                this.refreshTypesHandler = null;
            }

            IDesignerHost designerHost = this.serviceProvider.GetService(typeof(IDesignerHost)) as IDesignerHost;
            Activity rootActivity = (designerHost != null) ? designerHost.RootComponent as Activity : null;
            if (rootActivity == null)
                return;

            //Now Refresh the types as well as the designer actions
            ITypeProvider typeProvider = this.serviceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider;
            if (typeProvider != null)
            {
                Walker walker = new Walker();
                walker.FoundProperty += delegate(Walker w, WalkerEventArgs args)
                {
                    if (args.CurrentValue != null &&
                        args.CurrentProperty != null &&
                        args.CurrentProperty.PropertyType == typeof(System.Type) &&
                        args.CurrentValue is System.Type)
                    {
                        Type updatedType = typeProvider.GetType(((Type)args.CurrentValue).FullName);
                        if (updatedType != null)
                        {
                            args.CurrentProperty.SetValue(args.CurrentPropertyOwner, updatedType, null);

                            if (args.CurrentActivity != null)
                                TypeDescriptor.Refresh(args.CurrentActivity);
                        }
                    }
                    else if (args.CurrentProperty == null && args.CurrentValue is DependencyObject && !(args.CurrentValue is Activity))
                    {
                        walker.WalkProperties(args.CurrentActivity, args.CurrentValue);
                    }
                };
                walker.FoundActivity += delegate(Walker w, WalkerEventArgs args)
                {
                    if (args.CurrentActivity != null)
                    {
                        TypeDescriptor.Refresh(args.CurrentActivity);

                        ActivityDesigner activityDesigner = ActivityDesigner.GetDesigner(args.CurrentActivity);
                        if (activityDesigner != null)
                            activityDesigner.RefreshDesignerActions();

                        InvokeWorkflowDesigner invokeWorkflowDesigner = activityDesigner as InvokeWorkflowDesigner;
                        if (invokeWorkflowDesigner != null)
                            invokeWorkflowDesigner.RefreshTargetWorkflowType();
                    }
                };

                walker.Walk(rootActivity);
            }

            IPropertyValueUIService propertyValueService = this.serviceProvider.GetService(typeof(IPropertyValueUIService)) as IPropertyValueUIService;
            if (propertyValueService != null)
                propertyValueService.NotifyPropertyValueUIItemsChanged();

            RefreshTasks();
            RefreshDesignerActions();
        }