protected override object CreateInstance(WorkflowMarkupSerializationManager serializationManager, Type type)
 {
     if (typeof(PropertySegment) == type)
         return Activator.CreateInstance(type, new object[] { serializationManager as IServiceProvider, serializationManager.Context.Current });
     else
         return base.CreateInstance(serializationManager, type);
 }

 protected internal override void AddChild(WorkflowMarkupSerializationManager serializationManager, object obj, object childObj)
 {
     if (this.containedSerializer != null)
     {
         this.containedSerializer.AddChild(serializationManager, obj, childObj);
     }
 }

        protected internal override bool CanSerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)
        {
            bool canSerializeToString = false;
            if (value != null)
            {
                ITypeDescriptorContext context = null;
                TypeConverter converter = GetTypeConversionInfoForPropertySegment(serializationManager, value.GetType(), out context);
                if (converter != null)
                    canSerializeToString = converter.CanConvertTo(context, typeof(string));

                if (!canSerializeToString)
                {
                    if (this.containedSerializer != null)
                        canSerializeToString = this.containedSerializer.CanSerializeToString(serializationManager, value);
                    else
                        canSerializeToString = base.CanSerializeToString(serializationManager, value);
                }
            }
            else
            {
                canSerializeToString = true;
            }

            return canSerializeToString;
        }

 protected internal override void AddChild(WorkflowMarkupSerializationManager serializationManager, object parentObj, object childObj)
 {
     if (parentObj == null)
     {
         throw new ArgumentNullException("parentObj");
     }
     if (childObj == null)
     {
         throw new ArgumentNullException("childObj");
     }
     IDictionary dictionary = parentObj as IDictionary;
     if (dictionary == null)
     {
         throw new InvalidOperationException(SR.GetString("Error_DictionarySerializerNonDictionaryObject"));
     }
     object key = null;
     foreach (DictionaryEntry entry in this.keylookupDictionary)
     {
         if ((!entry.Value.GetType().IsValueType && (entry.Value == childObj)) || (entry.Value.GetType().IsValueType && entry.Value.Equals(childObj)))
         {
             key = entry.Key;
             break;
         }
     }
     if (key == null)
     {
         throw new InvalidOperationException(SR.GetString("Error_DictionarySerializerKeyNotFound", new object[] { childObj.GetType().FullName }));
     }
     dictionary.Add(key, childObj);
     this.keylookupDictionary.Remove(key);
 }

 protected internal override object DeserializeFromString(WorkflowMarkupSerializationManager serializationManager, Type propertyType, string value)
 {
     if (serializationManager == null)
     {
         throw new ArgumentNullException("serializationManager");
     }
     if (propertyType == null)
     {
         throw new ArgumentNullException("propertyType");
     }
     if (value == null)
     {
         throw new ArgumentNullException("value");
     }
     if (string.Equals(value, "*null", StringComparison.Ordinal))
     {
         return null;
     }
     ITypeDescriptorContext context = null;
     TypeConverter converter = this.GetTypeConversionInfoForPropertySegment(serializationManager, propertyType, out context);
     if ((converter != null) && converter.CanConvertFrom(context, typeof(string)))
     {
         return converter.ConvertFromString(context, value);
     }
     if (this.containedSerializer != null)
     {
         return this.containedSerializer.DeserializeFromString(serializationManager, propertyType, value);
     }
     return base.DeserializeFromString(serializationManager, propertyType, value);
 }

        protected internal override object DeserializeFromString(WorkflowMarkupSerializationManager serializationManager, Type propertyType, string value)
        {
            if (!propertyType.IsAssignableFrom(typeof(CodeTypeReference)))
                return null;

            // if the string is empty or markup extension,
            // then the object is null
            if (string.IsNullOrEmpty(value) || IsValidCompactAttributeFormat(value))
                return null;

            // value is the fully qualified name of the type
            // however, it may refer to non-existant assemblies, so we may get an error
            CodeTypeReference result;
            try
            {
                Type type = serializationManager.GetType(value);
                if (type != null)
                {
                    result = new CodeTypeReference(type);
                    result.UserData[QualifiedName] = type.AssemblyQualifiedName;
                    return result;
                }
            }
            catch (Exception)
            {
                // something went wrong getting the type, so simply pass in the string and
                // let CodeTypeReference figure it out. Note that CodeTypeReference has a method
                // RipOffAssemblyInformationFromTypeName, so assembly names are ignored.
            }
            result = new CodeTypeReference(value);
            result.UserData[QualifiedName] = value;
            return result;
        }

 protected internal override object DeserializeFromString(WorkflowMarkupSerializationManager serializationManager, Type propertyType, string value)
 {
     CodeTypeReference reference;
     if (!propertyType.IsAssignableFrom(typeof(CodeTypeReference)))
     {
         return null;
     }
     if (string.IsNullOrEmpty(value) || base.IsValidCompactAttributeFormat(value))
     {
         return null;
     }
     try
     {
         Type type = serializationManager.GetType(value);
         if (type != null)
         {
             reference = new CodeTypeReference(type);
             reference.UserData["QualifiedName"] = type.AssemblyQualifiedName;
             return reference;
         }
     }
     catch (Exception)
     {
     }
     reference = new CodeTypeReference(value);
     reference.UserData["QualifiedName"] = value;
     return reference;
 }

 protected internal override PropertyInfo[] GetProperties(WorkflowMarkupSerializationManager serializationManager, object obj)
 {
     if (serializationManager == null)
     {
         throw new ArgumentNullException("serializationManager");
     }
     if (obj == null)
     {
         throw new ArgumentNullException("obj");
     }
     XmlWriter writer = serializationManager.WorkflowMarkupStack[typeof(XmlWriter)] as XmlWriter;
     PropertyInfo[] properties = base.GetProperties(serializationManager, obj);
     FreeformActivityDesigner designer = obj as FreeformActivityDesigner;
     if (designer == null)
     {
         return properties;
     }
     List<PropertyInfo> list = new List<PropertyInfo>();
     foreach (PropertyInfo info in properties)
     {
         if (((writer == null) || !info.Name.Equals("AutoSizeMargin", StringComparison.Ordinal)) || (designer.AutoSizeMargin != FreeformActivityDesigner.DefaultAutoSizeMargin))
         {
             list.Add(info);
         }
     }
     list.Add(typeof(FreeformActivityDesigner).GetProperty("DesignerConnectors", BindingFlags.NonPublic | BindingFlags.Instance));
     return list.ToArray();
 }

        internal override void OnBeforeSerializeContents(WorkflowMarkupSerializationManager serializationManager, object obj)
        {
            base.OnBeforeSerializeContents(serializationManager, obj);

            //For root activity we will go through all the nested activities and put the namespaces at the top level
            CompositeActivity compositeActivity = obj as CompositeActivity;
            XmlWriter writer = serializationManager.WorkflowMarkupStack[typeof(XmlWriter)] as XmlWriter;
            if (compositeActivity.Parent == null && writer != null)
            {
                Dictionary<string, Activity> writtenMappings = new Dictionary<string, Activity>();

                string prefix = String.Empty;
                XmlQualifiedName xmlQualifiedName = serializationManager.GetXmlQualifiedName(compositeActivity.GetType(), out prefix);
                writtenMappings.Add(xmlQualifiedName.Namespace, compositeActivity);

                foreach (Activity containedActivity in Helpers.GetNestedActivities(compositeActivity))
                {
                    prefix = String.Empty;
                    xmlQualifiedName = serializationManager.GetXmlQualifiedName(containedActivity.GetType(), out prefix);
                    if (!writtenMappings.ContainsKey(xmlQualifiedName.Namespace))
                    {
                        writer.WriteAttributeString("xmlns", prefix, null, xmlQualifiedName.Namespace);
                        writtenMappings.Add(xmlQualifiedName.Namespace, containedActivity);
                    }
                }
            }
        }

 protected internal override void ClearChildren(WorkflowMarkupSerializationManager serializationManager, object obj)
 {
     if (this.containedSerializer != null)
     {
         this.containedSerializer.ClearChildren(serializationManager, obj);
     }
 }

 protected override InstanceDescriptor GetInstanceDescriptor(WorkflowMarkupSerializationManager serializationManager, object value)
 {
     ActivityBind activityBind = value as ActivityBind;
     if (activityBind == null)
         throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(ActivityBind).FullName), "value");
     return new InstanceDescriptor(typeof(ActivityBind).GetConstructor(new Type[] { typeof(string) }),
         new object[] { activityBind.Name });
 }

        protected override void OnBeforeSerialize(WorkflowMarkupSerializationManager serializationManager, object obj)
        {
            if (serializationManager == null)
                throw new ArgumentNullException("serializationManager");
            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");

            XmlWriter writer = serializationManager.WorkflowMarkupStack[typeof(XmlWriter)] as XmlWriter;
            if (writer == null)
            {
                //We should not throw an exception here as both of the above properties are internal and
                //our serializer makes sure that they are always set. Note that OnBeforeSerialize can be 
                //only called by WorkflowMarkupSerializer.
                Debug.Assert(false);
                return;
            }

            StringWriter stringWriter = serializationManager.WorkflowMarkupStack[typeof(StringWriter)] as StringWriter;
            if (stringWriter != null)
            {
                // we capture the start and end line of the activity getting serialized to xoml
                writer.Flush();
                string currentXoml = stringWriter.ToString();
                int startLine = 0;
                int currentIndex = 0;
                string newLine = stringWriter.NewLine;
                int newLineLength = newLine.Length;

                // Get to the starting line of this activity.
                while (true)
                {
                    int nextNewLineIndex = currentXoml.IndexOf(newLine, currentIndex, StringComparison.Ordinal);
                    if (nextNewLineIndex == -1)
                        break;

                    currentIndex = nextNewLineIndex + newLineLength;
                    startLine++;
                }

                // We always serialize an element start tag onto exactly 1 line.
                activity.SetValue(ActivityMarkupSerializer.StartLineProperty, startLine);
                activity.SetValue(ActivityMarkupSerializer.EndLineProperty, startLine);

                // Cache the index of the beginning of the line.
                activity.SetValue(ActivityMarkupSerializer.EndColumnProperty, currentIndex);
                activity.SetValue(ActivityMarkupSerializer.StartColumnProperty, (currentXoml.IndexOf('<', currentIndex) - currentIndex + 1));
            }

            // write x:Class attribute
            string className = activity.GetValue(WorkflowMarkupSerializer.XClassProperty) as string;
            if (className != null)
                writer.WriteAttributeString(StandardXomlKeys.Definitions_XmlNs_Prefix, StandardXomlKeys.Definitions_Class_LocalName, StandardXomlKeys.Definitions_XmlNs, className);

        }

        protected internal override string SerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)
        {
            if (serializationManager == null)
                throw new ArgumentNullException("serializationManager");
            if (value == null)
                throw new ArgumentNullException("value");

            return SynchronizationHandlesTypeConverter.Stringify(value as ICollection<String>);
        }

        protected internal override bool CanSerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)
        {
            if (serializationManager == null)
                throw new ArgumentNullException("serializationManager");
            if (value == null)
                throw new ArgumentNullException("value");

            return (value is ICollection<String>);
        }

 protected internal override string SerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)
 {
     TypeConverter converter = TypeDescriptor.GetConverter(value);
     if ((converter != null) && converter.CanConvertTo(typeof(string)))
     {
         return (converter.ConvertTo(value, typeof(string)) as string);
     }
     return base.SerializeToString(serializationManager, value);
 }

 public XmlQualifiedName GetXmlQualifiedName(WorkflowMarkupSerializationManager manager, out string prefix)
 {
     prefix = string.Empty;
     if (this.OnGetXmlQualifiedName != null)
     {
         return this.OnGetXmlQualifiedName(this, manager, out prefix);
     }
     return null;
 }

 protected virtual InstanceDescriptor GetInstanceDescriptor(WorkflowMarkupSerializationManager serializationManager, object value)
 {
     MarkupExtension extension = value as MarkupExtension;
     if (extension == null)
     {
         throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(MarkupExtension).FullName }), "value");
     }
     return new InstanceDescriptor(extension.GetType().GetConstructor(new Type[0]), null);
 }

 protected internal override PropertyInfo[] GetProperties(WorkflowMarkupSerializationManager serializationManager, object obj)
 {
     List<PropertyInfo> list = new List<PropertyInfo>();
     if (obj is Size)
     {
         list.Add(typeof(Size).GetProperty("Width"));
         list.Add(typeof(Size).GetProperty("Height"));
     }
     return list.ToArray();
 }

        protected internal override PropertyInfo[] GetProperties(WorkflowMarkupSerializationManager serializationManager, object obj)
        {
            if (this.containedSerializer != null)
                return this.containedSerializer.GetProperties(serializationManager, obj);

            if (obj != null && obj.GetType() == typeof(PropertySegment))
                return (obj as PropertySegment).GetProperties(serializationManager);
            else
                return base.GetProperties(serializationManager, obj);
        }

        protected internal override void AddChild(WorkflowMarkupSerializationManager serializationManager, object parentObj, object childObj)
        {
            if (parentObj == null)
                throw new ArgumentNullException("parentObj");

            if (!IsValidCollectionType(parentObj.GetType()))
                throw new Exception(SR.GetString(SR.Error_SerializerTypeRequirement, parentObj.GetType().FullName, typeof(ICollection).FullName, typeof(ICollection<>).FullName));

            parentObj.GetType().InvokeMember("Add", BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.Instance, null, parentObj, new object[] { childObj }, CultureInfo.InvariantCulture);
        }