C# DependencyObject.GetLocalValueEnumerator方法代码示例

        // Converts array of PropertyRecords into a LocalValueEnumerator.
        // The array is safe to cache, LocalValueEnumerators are not.
        internal static LocalValueEnumerator ArrayToLocalValueEnumerator(PropertyRecord[] records)
        {
            DependencyObject obj;
            int i;

            obj = new DependencyObject();

            for (i = 0; i < records.Length; i++)
            {
                obj.SetValue(records[i].Property, records[i].Value);
            }

            return obj.GetLocalValueEnumerator();
        }

        /// <summary>
        /// Writes complex properties in form of child elements with compound names
        /// </summary>        
        /// <SecurityNote>
        /// To mask the security exception from XamlWriter.Save in partial trust case, 
        /// this function checks if the current call stack has unmanaged code permission.
        /// </SecurityNote>
        private static void WriteComplexProperties(XmlWriter xmlWriter, DependencyObject complexProperties, Type elementType)
        {
            if (!SecurityHelper.CheckUnmanagedCodePermission())
            {
                // In partial trust, we cannot serialize any complex properties because
                // XamlWriter.Save demands UnmanagedCodePermission.
                //
                // If we're in PT, drop the properties.
                //
                // If you're here debugging a lost complex property, consider adding
                // code to DPTypeDescriptorContext to convert the complex property
                // into a non-complex property, or consider modifying XamlWriter.Save.
                return;
            }

            LocalValueEnumerator properties = complexProperties.GetLocalValueEnumerator();

            properties.Reset();
            while (properties.MoveNext())
            {
                LocalValueEntry propertyEntry = properties.Current;

                // Build an appropriate name for the complex property
                string complexPropertyName = GetPropertyNameForElement(propertyEntry.Property, elementType, /*forceComplexName:*/true);

                // Write the start element for the complex property.
                xmlWriter.WriteStartElement(complexPropertyName);

                // Serialize the complex property value from SaveAsXml().
                string complexPropertyXml = System.Windows.Markup.XamlWriter.Save(propertyEntry.Value);

                // Write the serialized complext property value as Xml.
                xmlWriter.WriteRaw(complexPropertyXml);

                // Close the element for the complex property
                xmlWriter.WriteEndElement();
            }
        }

        // Gets an array of PropertyRecords from a DependencyObject's LocalValueEnumerator.
        // The array is safe to cache, LocalValueEnumerators are not.
        internal static PropertyRecord[] GetPropertyRecordArray(DependencyObject d)
        {
            LocalValueEnumerator valuesEnumerator = d.GetLocalValueEnumerator();
            PropertyRecord[] records = new PropertyRecord[valuesEnumerator.Count];
            int count = 0;

            valuesEnumerator.Reset();
            while (valuesEnumerator.MoveNext())
            {
                DependencyProperty dp = valuesEnumerator.Current.Property;
                if (!dp.ReadOnly)
                {
                    // LocalValueEntry.Value can be an Expression, which we can't duplicate when we 
                    // undo, so we copy over the current value from DependencyObject.GetValue instead.
                    records[count].Property = dp;
                    records[count].Value = d.GetValue(dp);

                    count++;
                }
            }

            PropertyRecord[] trimmedResult;
            if(valuesEnumerator.Count != count)
            {
                trimmedResult = new PropertyRecord[count];
                for(int i=0; i<count; i++)
                {
                    trimmedResult[i] = records[i];
                }
            }
            else
            {
                trimmedResult = records;
            }

            return trimmedResult;
        }