C# ElementViewModel.Property方法代码示例

        protected override void Act()
        {
            logFilter = LoggingSection.GetDescendentsOfType<PriorityFilterData>().FirstOrDefault();
            int maximumPriority = (int) logFilter.Property("MaximumPriority").Value;

            logFilter.Property("MinimumPriority").Value = maximumPriority + 1;
            logFilter.Validate();
        }

        protected override void Arrange()
        {
            base.Arrange();

            var aliasesCollection = (ElementCollectionViewModel)base.UnitySectionViewModel.ChildElement("TypeAliases");
            StringAlias = aliasesCollection.AddNewCollectionElement(typeof(AliasElement));
            StringAlias.Property("Alias").Value = "s";
            StringAlias.Property("TypeName").Value = "System.String, mscorlib";

            Int32Alias = aliasesCollection.AddNewCollectionElement(typeof(AliasElement));
            Int32Alias.Property("Alias").Value = "i";
            Int32Alias.Property("TypeName").Value = "System.Int32, mscorlib";

            base.RegistrationElement.Property("TypeName").Value = "s";
        }

        protected override void Arrange()
        {
            base.Arrange();

            var resources = new ResourceHelper<ConfigFileLocator>();
            resources.DumpResourceFileToDisk("empty.config");

            var applicationViewModel = Container.Resolve<ApplicationViewModel>();
            ConfigurationSourceModel sourceModel = applicationViewModel.CurrentConfigurationSource;
            applicationViewModel.NewEnvironment();

            EhabModel = sourceModel.AddSection(ExceptionHandlingSettings.SectionName, Section);
            EnvironmentViewModel = applicationViewModel.Environments.First();
            EnvironmentSection = (EnvironmentalOverridesSection)EnvironmentViewModel.ConfigurationElement;

            ((EnvironmentSourceViewModel)EnvironmentViewModel).EnvironmentConfigurationFile = "empty.config";
            ((EnvironmentSourceViewModel)EnvironmentViewModel).EnvironmentDeltaFile = "empty.config";

            WrapHandler = EhabModel.DescendentElements().Where(x => x.ConfigurationType == typeof(WrapHandlerData)).First();

            MainExceptionMessage = WrapHandler.Property("ExceptionMessage");
            MainExceptionMessage.Value = "Main Value";

            OverridesProperty = WrapHandler.Properties.Where(x => x.PropertyName.StartsWith("Overrides")).First(); 
            OverriddenExceptionMessage = OverridesProperty.ChildProperties.Where(x => x.PropertyName == "ExceptionMessage").First();
        }

        protected override void SetProperties(ElementViewModel createdElement, Type selectedType)
        {
            base.SetProperties(createdElement, selectedType);

            if (createdElement.ConfigurationType == typeof(KeyedHashAlgorithmProviderData))
            {
                createdElement.Property("Key").Value = keySettings;
            }
        }

        protected override void Arrange()
        {
            base.Arrange();
            validationModel = Container.Resolve<ValidationModel>();
            traceListener = LoggingSettingsViewModel.DescendentElements(x => x.ConfigurationType == typeof(FormattedEventLogTraceListenerData)).First();

            var bindableProperty = traceListener.Property("TraceOutputOptions").BindableProperty;
            bindableProperty.BindableValue = "Invalid";

            result = bindableProperty.Property.ValidationResults.First();
        }

        protected override void Arrange()
        {
            base.Arrange();

            elementViewModel = CachingViewModel.GetDescendentsOfType<CacheManagerData>().Single();
            HostAdapter.TasksChanged += (sender, args) => validationError = args.Tasks.First();

            try
            {
                elementViewModel.Property("ExpirationPollFrequencyInSeconds").BindableProperty.BindableValue = "abc";
            }
            catch { }
        }

 protected override void Act()
 {
     addedElement = collection.AddNewCollectionElement(typeof(TestElement));
     addedElement.Property("KeyValue").BindableProperty.BindableValue = "5";
     addedElement.Property("OtherKeyValue").BindableProperty.BindableValue = "StringKey";
 }

        protected override void Arrange()
        {
            base.Arrange();

            step = Container.Resolve<PickExceptionStep>();

            existingPolicy = GetDescendentsOfType<ExceptionPolicyData>().First();
            existingException = existingPolicy.GetDescendentsOfType<ExceptionTypeData>().Last();

            var handlerCollection = existingException.GetDescendentsOfType<NamedElementCollection<ExceptionHandlerData>>()
                .OfType<ElementCollectionViewModel>().First();
            existingHandlerName = handlerCollection.AddNewCollectionElement(typeof (LoggingExceptionHandlerData)).Name;


            step.Policy.Value = existingPolicy.Name;
            step.ExceptionType.Value = existingException.Property("TypeName").Value;
        }

 protected override void Act()
 {
     viewModel = SectionViewModel.CreateSection(Container, "mockSection", section);
     customProviderElement = viewModel.DescendentElements(x => x.ConfigurationType == typeof(CustomProviderConfigurationElement)).First();
     attributesProperty = customProviderElement.Property("Attributes");
 }

 /// <summary>
 /// Sets properties on the newly minted <see cref="ElementViewModel"/>.
 /// </summary>
 /// <param name="createdElement">The element created.</param>
 /// <param name="selectedType">The element type created.</param>
 /// <remarks>
 /// By default, this sets the <see cref="ElementViewModel.NameProperty"/>'s value, if present.
 /// The command also updates the <see cref="Property.Value"/> of the property specified by <see cref="TypePickingCommandAttribute.Property"/> to
 /// the assembly qualified name of the selected type.
 /// </remarks>
 protected virtual void SetProperties(ElementViewModel createdElement, Type selectedType)
 {
     if (createdElement.NameProperty != null)
     {
         createdElement.NameProperty.Value = ElementCollectionModel.FindUniqueNewName(selectedType.Name);
     }
     createdElement.Property(propertyToSet).Value = selectedType.AssemblyQualifiedName;
 }

        protected override void SetProperties(ElementViewModel createdElement, Type selectedType)
        {
            base.SetProperties(createdElement, selectedType);

            createdElement.Property("Key").Value = keySettings;
        }

 protected override void SetProperties(ElementViewModel createdElement, Type selectedType)
 {
     createdElement.Property("Name").Value = selectedType.FullName;
     createdElement.Property("AssemblyName").Value = selectedType.Assembly.GetName().FullName;
 }

        protected override void Arrange()
        {
            base.Arrange();

            property.Value = "TestElement";

            var testElementCollection = Section.GetDescendentsOfType<NamedElementCollection<TestNamedElement>>()
                .Where(e => e.Name == "ReferencedItems").OfType<ElementCollectionViewModel>().Single();
            referencedElement = testElementCollection.AddNewCollectionElement(typeof(TestNamedElement));
            referencedElement.Property("Name").Value = property.Value;
        }

            private void EnsurePolicy()
            {
                policyModel = exceptionSettingsSection.DescendentConfigurationsOfType<ExceptionPolicyData>()
                                    .Where(x => (string)x.Property("Name").Value == wizardData.Policy).FirstOrDefault();

                if (policyModel == null)
                {
                    var policies = GetCollectionOfType<NamedElementCollection<ExceptionPolicyData>>(exceptionSettingsSection);
                    policyModel = policies.AddNewCollectionElement(typeof(ExceptionPolicyData));
                    policyModel.Property("Name").Value = wizardData.Policy;
                }
            }

            private void EnsureExceptionType()
            {
                var exceptionTypes = GetCollectionOfType<NamedElementCollection<ExceptionTypeData>>(policyModel);

                exceptionType = exceptionTypes.DescendentConfigurationsOfType<ExceptionTypeData>()
                    .Where(x => (string)x.Property("TypeName").Value == wizardData.ExceptionType)
                    .FirstOrDefault();

                if (exceptionType == null)
                {
                    exceptionType = exceptionTypes.AddNewCollectionElement(typeof(ExceptionTypeData));
                    exceptionType.Property("Name").Value = TypeNameParserHelper.ParseTypeName(wizardData.ExceptionType);
                    exceptionType.Property("TypeName").Value = wizardData.ExceptionType;
                }
            }