* CodeDomComponentSerializationService.cs: implemented.
* ComponentCodeDomSerializer.cs, CollectionCodeDomSerializer.cs,
CodeDomSerializerBase.cs, CodeDomSerializer.cs,
EventCodeDomSerializer.cs, RootCodeDomSerializer.cs,
PropertyCodeDomSerializer.cs:
- Change the serialization process logic not to require an
ExpressionContext for full serialization of a component/instance.
- Provide statement ordering hints for the RootCodeDomSerializer.
* DesignerSerializationManager.cs: try-catch around
* CreateInstance just in case.
svn path=/trunk/mcs/; revision=92221
+2008-01-04 Ivan N. Zlatev <contact@i-nz.net>
+
+ * CodeDomComponentSerializationService.cs: implemented.
+ * ComponentCodeDomSerializer.cs, CollectionCodeDomSerializer.cs,
+ CodeDomSerializerBase.cs, CodeDomSerializer.cs,
+ EventCodeDomSerializer.cs, RootCodeDomSerializer.cs,
+ PropertyCodeDomSerializer.cs:
+ - Change the serialization process logic not to require an
+ ExpressionContext for full serialization of a component/instance.
+ - Provide statement ordering hints for the RootCodeDomSerializer.
+ * DesignerSerializationManager.cs: try-catch around CreateInstance
+ just in case.
+
2008-01-04 Ivan N. Zlatev <contact@i-nz.net>
* CodeDomDesignerLoader.cs: Check for duplicate names in
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
-// STUBS ONLY
-
#if NET_2_0
using System;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Formatters.Binary;
using System.ComponentModel;
+using System.ComponentModel.Design.Serialization;
using System.Collections;
+using System.Collections.Generic;
using System.IO;
namespace System.ComponentModel.Design.Serialization
{
+ // A ComponentSerializationService that uses a CodeDomSerializationStore
+ // to serialize Components and MemberDescriptors to CodeStatement and CodeStatementCollection
+ //
public sealed class CodeDomComponentSerializationService : ComponentSerializationService
{
+ [Serializable]
+ private class CodeDomSerializationStore : SerializationStore
+ {
+
+ [Serializable]
+ private class Entry
+ {
+ private bool _isSerialized;
+ private object _serialized;
+ private object _deserialized;
+ private bool _isDeserialized;
+ private bool _absolute;
+ private string _name;
+
+ protected Entry ()
+ {
+ }
+
+ public Entry (string name)
+ {
+ if (name == null)
+ throw new ArgumentNullException ("name");
+ _name = name;
+ _isDeserialized = true;
+ _isSerialized = false;
+ _absolute = false;
+ }
+
+ public bool IsSerialized {
+ get { return _isSerialized; }
+ set { _isSerialized = value; }
+ }
+
+ public object Serialized {
+ get { return _serialized; }
+ set {
+ _serialized = value;
+ _isSerialized = true;
+ }
+ }
+
+ public bool IsDeserialized {
+ get { return _isDeserialized; }
+ set { _isDeserialized = value; }
+ }
+
+ public object Deserialized {
+ get { return _deserialized; }
+ set {
+ _deserialized = value;
+ _isDeserialized = true;
+ }
+ }
+
+ public bool Absolute {
+ get { return _absolute; }
+ set { _absolute = value; }
+ }
+
+ public string Name {
+ get { return _name; }
+ set { _name = value; }
+ }
+ }
+
+ [Serializable]
+ private class MemberEntry : Entry
+ {
+ private MemberDescriptor _descriptor;
+
+ protected MemberEntry ()
+ {
+ }
+
+ public MemberEntry (MemberDescriptor descriptor)
+ {
+ if (descriptor == null)
+ throw new ArgumentNullException ("descriptor");
+ _descriptor = descriptor;
+ base.Name = descriptor.Name;
+ }
+
+ public MemberDescriptor Descriptor {
+ get { return _descriptor; }
+ set { _descriptor = value; }
+ }
+ }
+
+ [Serializable]
+ private class ObjectEntry : Entry
+ {
+ private Type _type;
+ [NonSerialized]
+ private object _instance;
+ private Dictionary<string,MemberEntry> _members;
+ private bool _entireObject;
+
+ protected ObjectEntry ()
+ {
+ }
+
+ public ObjectEntry (object instance, string name) : base (name)
+ {
+ if (instance == null)
+ throw new ArgumentNullException ("instance");
+ _instance = instance;
+ _type = instance.GetType ();
+ _entireObject = false;
+ }
+
+ public Type Type {
+ get { return _type; }
+ }
+
+ public object Instance {
+ get { return _instance; }
+ set {
+ _instance = value;
+ if (value != null)
+ _type = value.GetType ();
+ }
+ }
+
+ public Dictionary<string,MemberEntry> Members {
+ get {
+ if (_members == null)
+ _members = new Dictionary <string, MemberEntry> ();
+ return _members;
+ }
+ set { _members = value; }
+ }
+
+ public bool EntireObject {
+ get { return _entireObject; }
+ set { _entireObject = value; }
+ }
+ }
+
+ private bool _closed;
+ private Dictionary <string, ObjectEntry> _objects;
+ private IServiceProvider _provider;
+ private ICollection _errors;
+
+ internal CodeDomSerializationStore () : this (null)
+ {
+ }
+
+ internal CodeDomSerializationStore (IServiceProvider provider)
+ {
+ _provider = provider;
+ }
+
+ public override void Close ()
+ {
+ if (!_closed) {
+ Serialize (_provider);
+ _closed = true;
+ }
+ }
+
+ internal static CodeDomSerializationStore Load (Stream stream)
+ {
+ return new BinaryFormatter ().Deserialize (stream) as CodeDomSerializationStore;
+ }
+
+ public override void Save (Stream stream)
+ {
+ Close ();
+ new BinaryFormatter ().Serialize (stream, this);
+ }
+
+ private void Serialize (IServiceProvider provider)
+ {
+ if (provider == null)
+ return;
+ DesignerSerializationManager manager = provider.GetService (typeof (IDesignerSerializationManager)) as DesignerSerializationManager;
+ if (manager == null)
+ return;
+
+ using (IDisposable session = manager.CreateSession ()) {
+ foreach (ObjectEntry objectEntry in _objects.Values) {
+ if (objectEntry.EntireObject) {
+ CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer (objectEntry.Type,
+ typeof (CodeDomSerializer));
+ if (serializer != null) {
+ object serialized = null;
+ if (objectEntry.Absolute)
+ serialized = serializer.SerializeAbsolute (manager, objectEntry.Instance);
+ else
+ serialized = serializer.Serialize (manager, objectEntry.Instance);
+ if (serialized != null)
+ objectEntry.Serialized = serialized;
+ }
+ } else {
+ foreach (MemberEntry memberEntry in objectEntry.Members.Values) {
+ CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer (
+ objectEntry.Type, typeof (CodeDomSerializer));
+ if (serializer != null) {
+ object serialized = null;
+ if (memberEntry.Absolute) {
+ serialized = serializer.SerializeMemberAbsolute (manager,
+ objectEntry.Instance,
+ memberEntry.Descriptor);
+ } else {
+ serialized = serializer.SerializeMember (manager,
+ objectEntry.Instance,
+ memberEntry.Descriptor);
+ }
+ if (serialized != null)
+ memberEntry.Serialized = serialized;
+ }
+ }
+ }
+ }
+ _errors = manager.Errors;
+ }
+ }
+
+ internal void AddObject (object instance, bool absolute)
+ {
+ if (_closed)
+ throw new InvalidOperationException ("store is closed");
+
+ if (_objects == null)
+ _objects = new Dictionary <string, ObjectEntry> ();
+ string objectName = GetName (instance);
+
+ if (!_objects.ContainsKey (objectName)) {
+ ObjectEntry objectEntry = new ObjectEntry (instance, objectName);
+ objectEntry.Absolute = absolute;
+ objectEntry.EntireObject = true;
+ _objects[objectName] = objectEntry;
+ }
+ }
+
+ internal void AddMember (object owner, MemberDescriptor member, bool absolute)
+ {
+ if (_closed)
+ throw new InvalidOperationException ("store is closed");
+ if (member == null)
+ throw new ArgumentNullException ("member");
+ if (owner == null)
+ throw new ArgumentNullException ("owner");
+
+ if (_objects == null)
+ _objects = new Dictionary <string, ObjectEntry> ();
+ string objectName = GetName (owner);
+
+ if (!_objects.ContainsKey (objectName)) {
+ ObjectEntry objectEntry = new ObjectEntry (owner, objectName);
+ MemberEntry memberEntry = new MemberEntry (member);
+ memberEntry.Absolute = absolute;
+ objectEntry.Members[member.Name] = memberEntry;
+ _objects[objectName] = objectEntry;
+ }
+ }
+
+ private string GetName (object value)
+ {
+ string name = null;
+
+ IComponent component = value as IComponent;
+ if (component != null) {
+ if (component.Site is INestedSite)
+ name = ((INestedSite)component.Site).FullName;
+ else
+ name = component.Site != null ? component.Site.Name : null;
+ } else if (value is MemberDescriptor) {
+ name = ((MemberDescriptor) value).Name;
+ } else {
+ name = value.GetHashCode ().ToString ();
+ }
+
+ return name;
+ }
+
+ internal ICollection Deserialize (IServiceProvider provider, IContainer container,
+ bool validateRecycledTypes, bool applyDefaults)
+ {
+ List<object> objectInstances = new List<object> ();
+
+ if (provider == null)
+ return objectInstances;
+ _provider = provider;
+
+ DesignerSerializationManager manager = provider.GetService
+ (typeof (IDesignerSerializationManager)) as DesignerSerializationManager;
+ if (manager == null)
+ return objectInstances;
+
+ bool validateRecycleBackup = manager.ValidateRecycledTypes;
+ IContainer containerBackup = manager.Container;
+
+ if (container != null)
+ manager.Container = container;
+
+ using (IDisposable session = manager.CreateSession ()) {
+ ((IDesignerSerializationManager) manager).ResolveName += OnResolveInstance;
+ foreach (ObjectEntry entry in _objects.Values)
+ objectInstances.Add (DeserializeEntry (manager, entry));
+ ((IDesignerSerializationManager) manager).ResolveName -= OnResolveInstance;
+ _errors = manager.Errors;
+ }
+
+ manager.ValidateRecycledTypes = validateRecycleBackup;
+ manager.Container = containerBackup;
+ return objectInstances;
+ }
+
+ private void OnResolveInstance (object sender, ResolveNameEventArgs args)
+ {
+ if (args.Value == null && _objects != null && _objects.ContainsKey (args.Name)) {
+ IDesignerSerializationManager manager = _provider.GetService
+ (typeof (IDesignerSerializationManager)) as IDesignerSerializationManager;
+ if (manager != null) {
+ ObjectEntry entry = _objects[args.Name];
+ if (entry.EntireObject)
+ args.Value = DeserializeEntry (manager, entry);
+ }
+ }
+ }
+
+ private object DeserializeEntry (IDesignerSerializationManager manager, ObjectEntry objectEntry)
+ {
+ object deserialized = null;
+
+ if (objectEntry.EntireObject) {
+ if (objectEntry.IsDeserialized) {
+ deserialized = objectEntry.Deserialized;
+ } else {
+ CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer (objectEntry.Type,
+ typeof (CodeDomSerializer));
+ if (serializer != null) {
+ deserialized = serializer.Deserialize (manager, objectEntry.Serialized);
+ objectEntry.Deserialized = deserialized;
+ // check if the name of the object has changed
+ // (if it e.g clashes with another name)
+ string newName = manager.GetName (deserialized);
+ if (newName != objectEntry.Name)
+ objectEntry.Name = newName;
+ }
+ }
+ } else {
+ foreach (MemberEntry memberEntry in objectEntry.Members.Values) {
+ if (!memberEntry.IsDeserialized) {
+ CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer (objectEntry.Type,
+ typeof (CodeDomSerializer));
+ if (serializer != null) {
+ serializer.Deserialize (manager, memberEntry.Serialized);
+ memberEntry.IsDeserialized = true;
+ }
+ }
+ }
+ }
+
+ return deserialized;
+ }
+
+ public override ICollection Errors {
+ get {
+ if (_errors == null)
+ _errors = new object[0];
+ return _errors;
+ }
+ }
+ } // CodeDomSerializationStore
+
+ private IServiceProvider _provider;
public CodeDomComponentSerializationService () : this (null)
{
public CodeDomComponentSerializationService (IServiceProvider provider)
{
+ _provider = provider;
}
public override SerializationStore CreateStore ()
{
- throw new NotImplementedException ();
+ return new CodeDomSerializationStore (_provider);
+ }
+
+ public override SerializationStore LoadStore (Stream stream)
+ {
+ return CodeDomSerializationStore.Load (stream);
}
public override ICollection Deserialize (SerializationStore store)
{
- throw new NotImplementedException ();
+ return this.Deserialize (store, null);
}
public override ICollection Deserialize (SerializationStore store, IContainer container)
{
- throw new NotImplementedException ();
+ return DeserializeCore (store, container, true, true);
}
- public override SerializationStore LoadStore (Stream stream)
+ public override void DeserializeTo (SerializationStore store, IContainer container, bool validateRecycledTypes, bool applyDefaults)
{
- throw new NotImplementedException ();
+ DeserializeCore (store, container, validateRecycledTypes, applyDefaults);
+ }
+
+ private ICollection DeserializeCore (SerializationStore store, IContainer container, bool validateRecycledTypes,
+ bool applyDefaults)
+ {
+ CodeDomSerializationStore codeDomStore = store as CodeDomSerializationStore;
+ if (codeDomStore == null)
+ throw new InvalidOperationException ("store type unsupported");
+ return codeDomStore.Deserialize (_provider, container, validateRecycledTypes, applyDefaults);
}
public override void Serialize (SerializationStore store, object value)
{
- throw new NotImplementedException ();
+ SerializeCore (store, value, false);
}
public override void SerializeAbsolute (SerializationStore store, object value)
{
- throw new NotImplementedException ();
+ SerializeCore (store, value, true);
}
public override void SerializeMember (SerializationStore store, object owningObject, MemberDescriptor member)
{
- throw new NotImplementedException ();
+ SerializeMemberCore (store, owningObject, member, false);
}
public override void SerializeMemberAbsolute (SerializationStore store, object owningObject, MemberDescriptor member)
{
- throw new NotImplementedException ();
+ SerializeMemberCore (store, owningObject, member, true);
}
- public override void DeserializeTo (SerializationStore store, IContainer container, bool validateRecycledTypes, bool applyDefaults)
+ private void SerializeCore (SerializationStore store, object value, bool absolute)
+ {
+ if (value == null)
+ throw new ArgumentNullException ("value");
+ if (store == null)
+ throw new ArgumentNullException ("store");
+
+ CodeDomSerializationStore codeDomStore = store as CodeDomSerializationStore;
+ if (store == null)
+ throw new InvalidOperationException ("store type unsupported");
+
+ codeDomStore.AddObject (value, absolute);
+ }
+
+ private void SerializeMemberCore (SerializationStore store, object owningObject, MemberDescriptor member, bool absolute)
{
- throw new NotImplementedException ();
+ if (member == null)
+ throw new ArgumentNullException ("member");
+ if (owningObject == null)
+ throw new ArgumentNullException ("owningObject");
+ if (store == null)
+ throw new ArgumentNullException ("store");
+
+ CodeDomSerializationStore codeDomStore = store as CodeDomSerializationStore;
+ if (codeDomStore == null)
+ throw new InvalidOperationException ("store type unsupported");
+ codeDomStore.AddMember (owningObject, member, absolute);
}
}
}
if (manager == null)
throw new ArgumentNullException ("manager");
+ object serialized = null;
bool isComplete = false;
CodeExpression createExpr = base.SerializeCreationExpression (manager, value, out isComplete);
- if (!isComplete) {
- ExpressionContext context = manager.Context[typeof (ExpressionContext)] as ExpressionContext;
- if (context != null && context.PresetValue == value) {
+ if (createExpr != null) {
+ if (isComplete) {
+ serialized = createExpr;
+ } else {
CodeStatementCollection statements = new CodeStatementCollection ();
- if (createExpr != null) {
- statements.Add (new CodeAssignStatement (context.Expression, createExpr));
- CodeExpression expression = base.GetExpression (manager, value);
- if (expression == null)
- base.SetExpression (manager, value, createExpr);
- }
base.SerializeProperties (manager, statements, value, new Attribute[0]);
base.SerializeEvents (manager, statements, value, new Attribute[0]);
+ serialized = statements;
}
+ base.SetExpression (manager, value, createExpr);
}
-
- return createExpr;
+ return serialized;
}
- [Obsolete ("This method has been deprecated. Use SerializeToExpression or GetExpression instead.")]
+ [Obsolete ("This method has been deprecated. Use SerializeToExpression or GetExpression instead.")]
protected CodeExpression SerializeToReferenceExpression (IDesignerSerializationManager manager, object value)
{
return base.SerializeToExpression (manager, value);
}
public virtual CodeStatementCollection SerializeMember (IDesignerSerializationManager manager,
- object owningobject, MemberDescriptor member)
+ object owningobject, MemberDescriptor member)
{
if (member == null)
throw new ArgumentNullException ("member");
base.SetExpression (manager, owningobject, expression);
}
- manager.Context.Push (new ExpressionContext (expression, expression.GetType (), null, owningobject));
-
if (member is PropertyDescriptor)
base.SerializeProperty (manager, statements, owningobject, (PropertyDescriptor) member);
if (member is EventDescriptor)
}
public virtual CodeStatementCollection SerializeMemberAbsolute (IDesignerSerializationManager manager,
- object owningobject, MemberDescriptor member)
+ object owningobject, MemberDescriptor member)
{
if (member == null)
throw new ArgumentNullException ("member");
expression = new CodeFieldReferenceExpression (target, member.Name);
} else if (member is MethodInfo) {
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression (target, member.Name);
- manager.Context.Push (new ExpressionContext (methodInvoke, methodInvoke.GetType (), null, null));
if (descriptor.Arguments != null && descriptor.Arguments.Count > 0)
methodInvoke.Parameters.AddRange (SerializeParameters (manager, descriptor.Arguments));
- manager.Context.Pop ();
expression = methodInvoke;
} else if (member is ConstructorInfo) {
CodeObjectCreateExpression createExpr = new CodeObjectCreateExpression (member.DeclaringType);
- manager.Context.Push (new ExpressionContext (createExpr, createExpr.GetType (), null, null));
if (descriptor.Arguments != null && descriptor.Arguments.Count > 0)
createExpr.Parameters.AddRange (SerializeParameters (manager, descriptor.Arguments));
- manager.Context.Pop ();
expression = createExpr;
}
}
protected virtual object SerializeCollection (IDesignerSerializationManager manager, CodeExpression targetExpression,
- Type targetType, ICollection originalCollection, ICollection valuesToSerialize)
+ Type targetType, ICollection originalCollection, ICollection valuesToSerialize)
{
if (valuesToSerialize == null)
throw new ArgumentNullException ("valuesToSerialize");
CodeStatementCollection statements = new CodeStatementCollection ();
foreach (object value in valuesToSerialize) {
+
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression ();
methodInvoke.Method = new CodeMethodReferenceExpression (targetExpression, "Add");
- manager.Context.Push (new ExpressionContext (methodInvoke, methodInvoke.GetType (), null, originalCollection));
CodeExpression expression = base.SerializeToExpression (manager, value);
- if (expression != null)
+ if (expression != null) {
methodInvoke.Parameters.AddRange (new CodeExpression[] { expression });
- manager.Context.Pop ();
-
- if (methodInvoke != null)
statements.Add (methodInvoke);
+ }
}
return statements;
if (rootContext != null && rootContext.Value == value)
return rootContext.Expression;
+ CodeStatementCollection statements = new CodeStatementCollection ();
+
if (((IComponent)value).Site == null) {
ReportError (manager, "Component of type '" + value.GetType().Name + "' not sited");
- return null;
+ return statements;
}
- object serialized = null;
// the trick with the nested components is that GetName will return the full name
// e.g splitter1.Panel1 and thus the code below will create a reference to that.
//
else
componentRef = new CodeFieldReferenceExpression (new CodeThisReferenceExpression () , name);
- ExpressionContext exprContext = manager.Context[typeof (ExpressionContext)] as ExpressionContext;
- if (exprContext != null && exprContext.PresetValue == value) {
+ base.SetExpression (manager, value, componentRef);
+
+ ExpressionContext context = manager.Context[typeof (ExpressionContext)] as ExpressionContext;
+ // Perform some heuristics here.
+ //
+ // If there is an ExpressionContext of PropertyReference where PresetValue == this
+ // partial serialization doesn't make sense, so perform full. E.g in the case of:
+ //
+ // PropertyCodeDomSerializer.SerializeContentProperty and splitContainer1.*Panel1*
+ //
+ if (context == null || context.PresetValue != value ||
+ (context.PresetValue == value && (context.Expression is CodeFieldReferenceExpression ||
+ context.Expression is CodePropertyReferenceExpression))) {
bool isComplete = true;
- CodeStatementCollection statements = new CodeStatementCollection ();
statements.Add (new CodeCommentStatement (String.Empty));
statements.Add (new CodeCommentStatement (name));
statements.Add (new CodeCommentStatement (String.Empty));
-
+
// Do not serialize a creation expression for Nested components
//
- if (! (((IComponent)value).Site is INestedSite))
- statements.Add (new CodeAssignStatement (componentRef,
- base.SerializeCreationExpression (manager, value, out isComplete)));
-
- manager.Context.Push (new ExpressionContext (componentRef, componentRef.GetType (), null, value));
+ if (! (((IComponent)value).Site is INestedSite)) {
+ CodeStatement assignment = new CodeAssignStatement (componentRef,
+ base.SerializeCreationExpression (manager, value,
+ out isComplete));
+ assignment.UserData["statement-order"] = "initializer";
+ statements.Add (assignment);
+ }
+
base.SerializeProperties (manager, statements, value, new Attribute[0]);
base.SerializeEvents (manager, statements, value);
- manager.Context.Pop ();
-
- serialized = statements;
- } else {
- serialized = base.GetExpression (manager, value);
- if (serialized == null)
- serialized = componentRef;
}
- if (base.GetExpression (manager,value) == null)
- base.SetExpression (manager, value, componentRef);
-
- return serialized;
+ return statements;
}
}
}
DesignerSerializerAttribute serializerAttribute = attributes[typeof (DesignerSerializerAttribute)] as DesignerSerializerAttribute;
if (serializerAttribute != null &&
this.GetType (serializerAttribute.SerializerBaseTypeName) == serializerType) {
- serializer = Activator.CreateInstance (this.GetType (serializerAttribute.SerializerTypeName),
- BindingFlags.CreateInstance | BindingFlags.Instance |
- BindingFlags.Public | BindingFlags.NonPublic,
- null, null, null);
+ try {
+ serializer = Activator.CreateInstance (this.GetType (serializerAttribute.SerializerTypeName),
+ BindingFlags.CreateInstance | BindingFlags.Instance |
+ BindingFlags.Public | BindingFlags.NonPublic,
+ null, null, null);
+ } catch {}
}
if (serializer != null)
}
- public override void Serialize (IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements)
+ public override void Serialize (IDesignerSerializationManager manager, object value, MemberDescriptor descriptor,
+ CodeStatementCollection statements)
{
if (statements == null)
throw new ArgumentNullException ("statements");
if (methodName != null) {
CodeDelegateCreateExpression listener = new CodeDelegateCreateExpression (new CodeTypeReference (eventDescriptor.EventType),
_thisReference, methodName);
- manager.Context.Push (new ExpressionContext (listener, listener.GetType (), null, eventDescriptor));
CodeExpression targetObject = base.SerializeToExpression (manager, value);
- manager.Context.Pop ();
CodeEventReferenceExpression eventRef = new CodeEventReferenceExpression (targetObject, eventDescriptor.Name);
statements.Add (new CodeAttachEventStatement (eventRef, listener));
}
private void SerializeNormalProperty (IDesignerSerializationManager manager,
- object component, PropertyDescriptor descriptor, CodeStatementCollection statements)
+ object instance, PropertyDescriptor descriptor, CodeStatementCollection statements)
{
CodeAssignStatement assignment = new CodeAssignStatement ();
ExpressionContext expression = manager.Context[typeof (ExpressionContext)] as ExpressionContext;
RootContext root = manager.Context[typeof (RootContext)] as RootContext;
- if (expression != null && expression.PresetValue == component && expression.Expression != null) {
+ if (expression != null && expression.PresetValue == instance && expression.Expression != null) {
leftSide = new CodePropertyReferenceExpression (expression.Expression, descriptor.Name);
- } else if (root != null && root.Value == component) {
+ } else if (root != null && root.Value == instance) {
leftSide = new CodePropertyReferenceExpression (root.Expression, descriptor.Name);
} else {
propRef = new CodePropertyReferenceExpression ();
propRef.PropertyName = descriptor.Name;
- propRef.TargetObject = TryGetCachedExpression (manager, component, propRef);
+ propRef.TargetObject = base.SerializeToExpression (manager, instance);
leftSide = propRef;
}
CodeExpression rightSide = null;
- MemberRelationship relationship = GetRelationship (manager, component, descriptor);
+ MemberRelationship relationship = GetRelationship (manager, instance, descriptor);
if (!relationship.IsEmpty) {
propRef = new CodePropertyReferenceExpression ();
propRef.PropertyName = relationship.Member.Name;
- propRef.TargetObject = TryGetCachedExpression (manager, relationship.Owner, propRef);
+ propRef.TargetObject = base.SerializeToExpression (manager, relationship.Owner);
rightSide = propRef;
} else {
- object rightSideValue = descriptor.GetValue (component);
- rightSide = TryGetCachedExpression (manager, rightSideValue, null, component);
+ rightSide = base.SerializeToExpression (manager, descriptor.GetValue (instance));
}
if (rightSide == null || leftSide == null) {
- base.ReportError (manager, "Cannot serialize " + ((IComponent)component).Site.Name + "." + descriptor.Name,
- "Property Name: " + descriptor.Name + System.Environment.NewLine +
- "Property Type: " + descriptor.PropertyType.Name + System.Environment.NewLine);
+ base.ReportError (manager, "Cannot serialize " + ((IComponent)instance).Site.Name + "." + descriptor.Name,
+ "Property Name: " + descriptor.Name + System.Environment.NewLine +
+ "Property Type: " + descriptor.PropertyType.Name + System.Environment.NewLine);
} else {
assignment.Left = leftSide;
assignment.Right = rightSide;
}
}
- private CodeExpression TryGetCachedExpression (IDesignerSerializationManager manager, object value)
- {
- return TryGetCachedExpression (manager, value, null);
- }
-
- private CodeExpression TryGetCachedExpression (IDesignerSerializationManager manager, object value,
- CodeExpression parentExpression)
- {
- return TryGetCachedExpression (manager, value, parentExpression, null);
- }
-
- private CodeExpression TryGetCachedExpression (IDesignerSerializationManager manager, object value,
- CodeExpression parentExpression, object presetValue)
- {
- CodeExpression expression = null;
- if (value != null) // in order to support null value serialization
- expression = base.GetExpression (manager, value);
- if (expression == null) {
- if (parentExpression == null)
- manager.Context.Push (new ExpressionContext (null, null, value, presetValue));
- else
- manager.Context.Push (new ExpressionContext (parentExpression, parentExpression.GetType (), value, presetValue));
- expression = base.SerializeToExpression (manager, value);
- manager.Context.Pop ();
- }
- return expression;
- }
-
- private void SerializeContentProperty (IDesignerSerializationManager manager, object component,
- PropertyDescriptor descriptor, CodeStatementCollection statements)
+ private void SerializeContentProperty (IDesignerSerializationManager manager, object instance,
+ PropertyDescriptor descriptor, CodeStatementCollection statements)
{
CodePropertyReferenceExpression propRef = new CodePropertyReferenceExpression ();
propRef.PropertyName = descriptor.Name;
- object value = descriptor.GetValue (component);
+ object propertyValue = descriptor.GetValue (instance);
ExpressionContext expressionCtx = manager.Context[typeof (ExpressionContext)] as ExpressionContext;
- if (expressionCtx != null && expressionCtx.PresetValue == component) {
+ if (expressionCtx != null && expressionCtx.PresetValue == instance)
propRef.TargetObject = expressionCtx.Expression;
- } else {
- manager.Context.Push (new CodeStatementCollection ());
- propRef.TargetObject = TryGetCachedExpression (manager, component, propRef, value);
- manager.Context.Pop ();
- }
-
- CodeDomSerializer serializer = manager.GetSerializer (value.GetType (), typeof (CodeDomSerializer)) as CodeDomSerializer;
+ else
+ propRef.TargetObject = base.SerializeToExpression (manager, instance);
+ CodeDomSerializer serializer = manager.GetSerializer (propertyValue.GetType (), typeof (CodeDomSerializer)) as CodeDomSerializer;
if (propRef.TargetObject != null && serializer != null) {
- // request full serialization (presetvalue == instance)
- //
- manager.Context.Push (new ExpressionContext (propRef, propRef.GetType (), component, value));
- object serialized = serializer.Serialize (manager, value);
+ manager.Context.Push (new ExpressionContext (propRef, propRef.GetType (), null, propertyValue));
+ object serialized = serializer.Serialize (manager, propertyValue);
manager.Context.Pop ();
-
+
CodeStatementCollection serializedStatements = serialized as CodeStatementCollection;
if (serializedStatements != null)
statements.AddRange (serializedStatements);
private string _className;
private Type _classType;
private List<CodeMemberField> _fields;
- private CodeStatementCollection _preInit;
- private CodeStatementCollection _init;
- private CodeStatementCollection _postInit;
+ private CodeStatementCollection _initializers;
+ private CodeStatementCollection _begin;
+ private CodeStatementCollection _default;
+ private CodeStatementCollection _end;
+
public CodeMap (Type classType, string className)
{
_classType = classType;
_className = className;
_fields = new List<CodeMemberField> ();
- _preInit = new CodeStatementCollection ();
- _init = new CodeStatementCollection ();
- _init = new CodeStatementCollection ();
- _postInit = new CodeStatementCollection ();
+ _initializers = new CodeStatementCollection ();
+ _begin = new CodeStatementCollection ();
+ _default = new CodeStatementCollection ();
+ _end = new CodeStatementCollection ();
}
public void AddField (CodeMemberField field)
_fields.Add (field);
}
- public void AddPreInitStatement (CodeStatement statement)
- {
- _preInit.Add (statement);
- }
-
- public void AddInitStatement (CodeStatement statement)
- {
- _init.Add (statement);
- }
-
- public void AddInitStatements (CodeStatementCollection statements)
+ public void Add (CodeStatementCollection statements)
{
- _init.AddRange (statements);
+ foreach (CodeStatement statement in statements)
+ this.Add (statement);
}
- public void AddPostInitStatement (CodeStatement statement)
+ public void Add (CodeStatement statement)
{
- _postInit.Add (statement);
+ if (statement.UserData["statement-order"] == null)
+ _default.Add (statement);
+ else if ((string)statement.UserData["statement-order"] == "initializer")
+ _initializers.Add (statement);
+ else if ((string)statement.UserData["statement-order"] == "begin")
+ _begin.Add (statement);
+ else if ((string)statement.UserData["statement-order"] == "end")
+ _end.Add (statement);
}
/*
private void InitializeComponent ()
{
- preInit;
- init;
- postInit;
+ // statement-order:
+ initializer
+ pre-begin - e.g: // ComponentName
+ begin - e.g: SuspendLayout
+ default
+ end - e.g: ResumeLayout
+ post-end
}
private field1;
#endregion
}
- */
+ */
public CodeTypeDeclaration GenerateClass ()
{
initialize.ReturnType = new CodeTypeReference (typeof (void));
initialize.Attributes = MemberAttributes.Private;
- initialize.Statements.AddRange (_preInit);
- initialize.Statements.AddRange (_init);
- initialize.Statements.AddRange (_postInit);
+ initialize.Statements.AddRange (_initializers);
+ initialize.Statements.AddRange (_begin);
+ initialize.Statements.AddRange (_default);
+ initialize.Statements.AddRange (_end);
clas.Members.Add (initialize);
public void Clear ()
{
- _preInit.Clear ();
- _init.Clear ();
- _postInit.Clear ();
- _fields.Clear ();
+ _initializers.Clear ();
+ _begin.Clear ();
+ _default.Clear ();
+ _end.Clear ();
}
}
// It will check for RootContext and return that.
base.SerializeProperties (manager, statements, value, new Attribute[0]);
base.SerializeEvents (manager, statements, value, new Attribute[0]);
- _codeMap.AddInitStatements (statements);
+ _codeMap.Add (statements);
manager.Context.Pop ();
return _codeMap.GenerateClass ();
private void SerializeComponents (IDesignerSerializationManager manager, ICollection components, IComponent rootComponent)
{
foreach (IComponent component in components) {
- if (!Object.ReferenceEquals (component, rootComponent)) {
- manager.Context.Push (new ExpressionContext (null, null, rootComponent, component));
+ if (!Object.ReferenceEquals (component, rootComponent))
SerializeComponent (manager, component);
- manager.Context.Pop ();
- }
}
}
{
CodeDomSerializer serializer = base.GetSerializer (manager, component) as CodeDomSerializer; // ComponentCodeDomSerializer
if (serializer != null) {
- this.Code.AddField (new CodeMemberField (component.GetType (), manager.GetName (component)));
-
- CodeStatementCollection statements = (CodeStatementCollection) serializer.Serialize (manager, component);
-
- CodeStatement ctorStatement = ExtractCtorStatement (manager, statements, component);
- if (ctorStatement != null)
- Code.AddPreInitStatement (ctorStatement);
- Code.AddInitStatements (statements);
+ this._codeMap.AddField (new CodeMemberField (component.GetType (), manager.GetName (component)));
+ // statements can be a CodeExpression if the full serialization has been completed prior
+ // to this serialization call (e.g when it is requested during the serialization of another
+ // component.
+ //
+ CodeStatementCollection statements = serializer.Serialize (manager, component) as CodeStatementCollection;
+ if (statements != null)
+ _codeMap.Add (statements);
+ CodeStatement statement = serializer.Serialize (manager, component) as CodeStatement;
+ if (statement != null)
+ _codeMap.Add (statement);
}
}
- internal CodeMap Code {
- get { return _codeMap; }
- }
-
- // Used to remove the ctor from the statement colletion in order for the ctor statement to be moved.
- //
- private CodeStatement ExtractCtorStatement (IDesignerSerializationManager manager, CodeStatementCollection statements,
- object component)
- {
- CodeStatement result = null;
- CodeAssignStatement assignment = null;
- CodeObjectCreateExpression ctor = null;
- int toRemove = -1;
-
- for (int i=0; i < statements.Count; i++) {
- assignment = statements[i] as CodeAssignStatement;
- if (assignment != null) {
- ctor = assignment.Right as CodeObjectCreateExpression;
- if (ctor != null && manager.GetType (ctor.CreateType.BaseType) == component.GetType ()) {
- result = assignment;
- toRemove = i;
- }
- }
- }
-
- if (toRemove != -1)
- statements.RemoveAt (toRemove);
-
- return result;
- }
-
public override object Deserialize (IDesignerSerializationManager manager, object codeObject)
{
CodeTypeDeclaration declaration = (CodeTypeDeclaration) codeObject;
projects / mono.git / commitdiff