コード例 #1
0
        SerializeProperty(
            SerializablePropertyContext serializablePropertyContext
            )
        {
            if (serializablePropertyContext == null)
            {
                throw new ArgumentNullException("serializablePropertyContext");
            }

            if (!serializablePropertyContext.IsComplex)
            {
                //
                // Non-Complex Properties are serialized as attributes
                //
                WriteSerializedAttribute(serializablePropertyContext);
            }
            else
            {
                //
                // Complex properties could be treated in different ways
                // based on their type. Examples of that are:
                //
                //
                //
                ReachSerializer serializer = SerializationManager.GetSerializer(serializablePropertyContext.Value);

                // If there is no serializer for this type, we won't serialize this property
                if (serializer != null)
                {
                    serializer.SerializeObject(serializablePropertyContext);
                }
            }
        }
コード例 #2
0
        SerializeProperties(
            SerializableObjectContext serializableObjectContext
            )
        {
            if (serializableObjectContext == null)
            {
                throw new ArgumentNullException("serializableObjectContext");
            }

            SerializablePropertyCollection propertyCollection = serializableObjectContext.PropertiesCollection;

            if (propertyCollection != null)
            {
                for (propertyCollection.Reset();
                     propertyCollection.MoveNext();)
                {
                    SerializablePropertyContext serializablePropertyContext =
                        (SerializablePropertyContext)propertyCollection.Current;

                    if (serializablePropertyContext != null)
                    {
                        SerializeProperty(serializablePropertyContext);
                    }
                }
            }
        }
 SerializeObject(
     SerializablePropertyContext serializedProperty
     )
 {
     _syncSerializer.Initialize();
     base.SerializeObject(serializedProperty);
 }
コード例 #4
0
 SerializableObjectContext(
     object target,
     SerializablePropertyContext serializablePropertyContext
     )
 {
     Initialize(target, serializablePropertyContext);
 }
コード例 #5
0
        DiscoverObjectData(
            Object serializedObject,
            SerializablePropertyContext serializedProperty
            )
        {
            //
            // Trying to figure out the parent of this node, which is at this stage
            // the same node previously pushed on the stack or in other words it is
            // the node that is currently on the top of the stack
            //
            SerializableObjectContext
                serializableObjectParentContext = (SerializableObjectContext)SerializationManager.
                                                  GraphContextStack[typeof(SerializableObjectContext)];
            //
            // Create the context for the current object
            //
            SerializableObjectContext serializableObjectContext =
                SerializableObjectContext.CreateContext(SerializationManager,
                                                        serializedObject,
                                                        serializableObjectParentContext,
                                                        serializedProperty);

            //
            // Set the root object to be serialized at the level of the SerializationManager
            //
            if (SerializationManager.RootSerializableObjectContext == null)
            {
                SerializationManager.RootSerializableObjectContext = serializableObjectContext;
            }

            return(serializableObjectContext);
        }
コード例 #6
0
 WriteSerializedAttribute(
     SerializablePropertyContext serializablePropertyContext
     )
 {
     if (serializablePropertyContext == null)
     {
         throw new ArgumentNullException("serializablePropertyContext");
     }
 }
コード例 #7
0
 SerializeObject(
     SerializablePropertyContext serializedProperty
     )
 {
     //
     // Do nothing here.
     // We do not support serializing visuals that come in as
     // properties out of context of a FixedPage or a DocumentPage
     //
 }
コード例 #8
0
        SerializeObject(
            SerializablePropertyContext serializedProperty
            )
        {
            if (serializedProperty == null)
            {
                throw new ArgumentNullException("serializedProperty");
            }

            SerializeObject(serializedProperty.Value);
        }
コード例 #9
0
        SerializeObject(
            SerializablePropertyContext serializedProperty
            )
        {
            //
            // Create the ImageTable required by the Type Converters
            // The Image table at this time is shared / currentPage
            //
            ((XpsSerializationManager)SerializationManager).ResourcePolicy.CurrentPageImageTable = new Dictionary<int, Uri>();

            base.SerializeObject(serializedProperty);
        }
コード例 #10
0
 XpsTokenContext(
     PackageSerializationManager serializationManager,
     SerializablePropertyContext propertyContext
     )
 {
     //
     // Make necessary checks and throw necessary exceptions
     //
     this.serializationManager = serializationManager;
     this.targetObject         = propertyContext.TargetObject;
     this.objectValue          = propertyContext.Value;
     this.propertyInfo         = propertyContext.PropertyInfo;
     this.dependencyProperty   = (propertyContext is SerializableDependencyPropertyContext) ?
                                 (DependencyProperty)((SerializableDependencyPropertyContext)propertyContext).DependencyProperty :
                                 null;
 }
コード例 #11
0
        SerializeObject(
            SerializablePropertyContext serializedProperty
            )
        {
            if (serializedProperty == null)
            {
                throw new ArgumentNullException("serializedProperty");
            }

            if (SerializationManager == null)
            {
                throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_MustHaveSerializationManager));
            }

            //
            // At this stage discover the graph of properties of the object that
            // need to be serialized
            //
            SerializableObjectContext serializableObjectContext = DiscoverObjectData(serializedProperty.Value,
                                                                                     serializedProperty);

            if (serializableObjectContext != null)
            {
                //
                // Push the object at hand on the context stack
                //
                SerializationManager.GraphContextStack.Push(serializableObjectContext);

                //
                // At this stage we should start streaming the markup representing the
                // object graph to the corresponding destination
                //
                PersistObjectData(serializableObjectContext);

                //
                // Pop the object from the context stack
                //
                SerializationManager.GraphContextStack.Pop();

                //
                // Recycle the used SerializableObjectContext
                //
                SerializableObjectContext.RecycleContext(serializableObjectContext);
            }
        }
        SerializeObject(
            SerializablePropertyContext serializedProperty
            )
        {
            //
            // Create the ImageTable required by the Type Converters
            // The Image table at this time is shared / document
            //
            ((XpsSerializationManager)SerializationManager).ResourcePolicy.ImageCrcTable = new Dictionary <UInt32, Uri>();

            ((XpsSerializationManager)SerializationManager).ResourcePolicy.ImageUriHashTable = new Dictionary <int, Uri>();
            //
            // Create the ColorContextTable required by the Type Converters
            // The Image table at this time is shared / document
            //
            ((XpsSerializationManagerAsync)SerializationManager).ResourcePolicy.ColorContextTable = new Dictionary <int, Uri>();

            base.SerializeObject(serializedProperty);
        }
コード例 #13
0
        SerializableObjectContext(
            string name,
            string prefix,
            object target,
            SerializablePropertyContext serializablePropertyContext
            ) :
            base(name, prefix)
        {
            //
            // Validate Input Arguments
            //
            if (target == null)
            {
                throw new ArgumentNullException("target");
            }

            _targetObject           = target;
            _isComplexValue         = false;
            _backingPropertyContext = serializablePropertyContext;
        }
        GetValueOfAttributeAsString(
            SerializablePropertyContext serializablePropertyContext
            )
        {
            if (serializablePropertyContext == null)
            {
                throw new ArgumentNullException("serializablePropertyContext");
            }

            String valueAsString = null;
            Object targetObjectContainingProperty = serializablePropertyContext.TargetObject;
            Object propertyValue = serializablePropertyContext.Value;

            if (propertyValue != null)
            {
                TypeConverter typeConverter = serializablePropertyContext.TypeConverter;

                valueAsString = typeConverter.ConvertToInvariantString(new XpsTokenContext(SerializationManager,
                                                                                           serializablePropertyContext),
                                                                       propertyValue);


                if (typeof(Type).IsInstanceOfType(propertyValue))
                {
                    int index = valueAsString.LastIndexOf('.');

                    if (index > 0)
                    {
                        valueAsString = valueAsString.Substring(index + 1);
                    }

                    valueAsString = XpsSerializationManager.TypeOfString + valueAsString + "}";
                }
            }
            else
            {
                valueAsString = XpsSerializationManager.NullString;
            }

            return(valueAsString);
        }
コード例 #15
0
        InitializeSerializableClrProperties(
            )
        {
            TypePropertyCache[] clrProperties = _serializationManager.CacheManager.GetClrSerializableProperties(_target);

            if (clrProperties != null)
            {
                for (int indexInClrSerializableProperties = 0;
                     indexInClrSerializableProperties < clrProperties.Length;
                     indexInClrSerializableProperties++)
                {
                    TypePropertyCache propertyCache = clrProperties[indexInClrSerializableProperties];

                    //
                    // Create SerializablePropertyContext out of the cache retrieved
                    //
                    SerializablePropertyContext propertyContext = new SerializablePropertyContext(_target,
                                                                                                  propertyCache);

                    propertyContext.Name = propertyContext.TypePropertyCache.PropertyInfo.Name;

                    //
                    // We have to differentiate between simple properties and complex properties.
                    // o Simple properties would be considered as attributes within the markup and
                    //   would not require new writers
                    // o Complex properties would be considered elements within the markup and might
                    //   require a new writer
                    //
                    if (propertyContext.IsComplexProperty(_serializationManager))
                    {
                        propertyContext.IsComplex = true;
                        _complexPropertyCollection.Enqueue(propertyContext);
                    }
                    else
                    {
                        propertyContext.IsComplex = false;
                        _simplePropertyCollection.Enqueue(propertyContext);
                    }
                }
            }
        }
コード例 #16
0
        Initialize(
            object target,
            SerializablePropertyContext serializablePropertyContext
            )
        {
            Initialize();
            _targetObject           = target;
            _isComplexValue         = false;
            _backingPropertyContext = serializablePropertyContext;

            if (_backingPropertyContext != null)
            {
                _isComplexValue  = _backingPropertyContext.IsComplex;
                _isReadOnlyValue = _backingPropertyContext.IsReadOnly;
            }
            else
            {
                _isComplexValue  = true;
                _isReadOnlyValue = false;
            }
        }
コード例 #17
0
        WriteSerializedAttribute(
            SerializablePropertyContext serializablePropertyContext
            )
        {
            if (serializablePropertyContext == null)
            {
                throw new ArgumentNullException("serializablePropertyContext");
            }

            String attributeValue = String.Empty;

            attributeValue = GetValueOfAttributeAsString(serializablePropertyContext);

            if ((attributeValue != null) &&
                (attributeValue.Length > 0))
            {
                //
                // Emit name="value" attribute
                //
                XmlWriter.WriteAttributeString(serializablePropertyContext.Name, attributeValue);
            }
        }
コード例 #18
0
        SerializeNextProperty(
            SerializableObjectContext serializableObjectContext
            )
        {
            SerializablePropertyCollection propertyCollection = serializableObjectContext.PropertiesCollection;

            if (propertyCollection.MoveNext())
            {
                SerializablePropertyContext serializablePropertyContext =
                    (SerializablePropertyContext)propertyCollection.Current;

                if (serializablePropertyContext != null)
                {
                    ReachSerializerContext context = new ReachSerializerContext(this,
                                                                                serializableObjectContext,
                                                                                SerializerAction.serializeNextProperty);

                    _serializationManager.OperationStack.Push(context);
                    SerializeProperty(serializablePropertyContext);
                }
            }
        }
コード例 #19
0
        CreateContext(
            PackageSerializationManager serializationManager,
            object serializableObject,
            SerializableObjectContext serializableObjectParentContext,
            SerializablePropertyContext serializablePropertyContext
            )
        {
            //
            // Check for element pre-existance to avoid infinite loops
            // in the process of serialization
            //
            int stackIndex = 0;

            object currentObject = null;

            for (currentObject = serializationManager.GraphContextStack[stackIndex];
                 currentObject != null;
                 currentObject = serializationManager.GraphContextStack[++stackIndex])
            {
                SerializableObjectContext currentObjectContext = currentObject as SerializableObjectContext;

                if (currentObjectContext != null &&
                    currentObjectContext.TargetObject == serializableObject)
                {
                    throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_CycleDetectedInSerialization));
                }
            }

            SerializableObjectContext serializableObjectContext;

            lock (_stackLock)
            {
                serializableObjectContext =
                    _recycableSerializableObjectContexts.Count == 0 ?
                    null :
                    (SerializableObjectContext)_recycableSerializableObjectContexts.Pop();
            }

            if (serializableObjectContext == null)
            {
                serializableObjectContext = new SerializableObjectContext(serializableObject,
                                                                          serializablePropertyContext);
            }
            else
            {
                serializableObjectContext.Initialize(serializableObject,
                                                     serializablePropertyContext);
            }

            {
                //
                // Namespace related creation within the context
                //
                MetroSerializationNamespaceTable parentNamespaceTable =
                    serializableObjectParentContext != null ? serializableObjectParentContext.NamespaceTable : null;

                if (serializableObjectContext.NamespaceTable == null)
                {
                    serializableObjectContext.NamespaceTable = new MetroSerializationNamespaceTable(parentNamespaceTable);
                }
            }

            {
                //
                // Properties related creation within the context
                //
                if (serializableObjectContext.PropertiesCollection == null)
                {
                    serializableObjectContext.PropertiesCollection = new  SerializablePropertyCollection(serializationManager,
                                                                                                         serializableObject);
                }
                else
                {
                    serializableObjectContext.PropertiesCollection.Initialize(serializationManager,
                                                                              serializableObject);
                }
            }

            serializableObjectContext.Name = serializableObjectContext.TargetObject.GetType().Name;

            return(serializableObjectContext);
        }
コード例 #20
0
 WriteSerializedAttribute(
     SerializablePropertyContext serializablePropertyContext
     )
 {
     _syncSerializer.WriteSerializedAttribute(serializablePropertyContext);
 }
コード例 #21
0
 SerializeObject(
     SerializablePropertyContext serializedProperty
     )
 {
     BeginSerializeObject(serializedProperty);
 }