public override object Serialize(IDesignerSerializationManager manager, object value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (manager == null)
{
throw new ArgumentNullException("manager");
}
ICollection originalCollection = value as ICollection;
if (originalCollection == null)
{
throw new ArgumentException("originalCollection is not an ICollection");
}
CodeExpression targetExpression = null;
ExpressionContext exprContext = manager.Context[typeof(ExpressionContext)] as ExpressionContext;
RootContext root = manager.Context[typeof(RootContext)] as RootContext;
if (exprContext != null && exprContext.PresetValue == value)
{
targetExpression = exprContext.Expression;
}
else if (root != null)
{
targetExpression = root.Expression;
}
ArrayList valuesToSerialize = new ArrayList();
foreach (object o in originalCollection)
{
valuesToSerialize.Add(o);
}
return(this.SerializeCollection(manager, targetExpression, value.GetType(), originalCollection, valuesToSerialize));
}
public virtual CodeTypeDeclaration Serialize(IDesignerSerializationManager manager, object root, ICollection members)
{
if (root == null)
{
throw new ArgumentNullException("root");
}
if (manager == null)
{
throw new ArgumentNullException("manager");
}
RootContext rootContext = new RootContext(new CodeThisReferenceExpression(), root);
StatementContext statementContext = new StatementContext();
if (members != null)
{
statementContext.StatementCollection.Populate(members);
}
statementContext.StatementCollection.Populate(root);
CodeTypeDeclaration declaration = new CodeTypeDeclaration(manager.GetName(root));
manager.Context.Push(rootContext);
manager.Context.Push(statementContext);
manager.Context.Push(declaration);
if (members != null)
{
foreach (object member in members)
{
base.SerializeToExpression(manager, member);
}
}
base.SerializeToExpression(manager, root);
manager.Context.Pop();
manager.Context.Pop();
manager.Context.Pop();
return(declaration);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
if (_codeMap == null)
{
_codeMap = new CodeMap(value.GetType(), manager.GetName(value));
}
_codeMap.Clear();
RootContext rootContext = new RootContext(new CodeThisReferenceExpression(), value);
manager.Context.Push(rootContext);
this.SerializeComponents(manager, ((IComponent)value).Site.Container.Components, (IComponent)value);
// Serialize root component
//
CodeStatementCollection statements = new CodeStatementCollection();
statements.Add(new CodeCommentStatement(String.Empty));
statements.Add(new CodeCommentStatement(manager.GetName(value)));
statements.Add(new CodeCommentStatement(String.Empty));
// Note that during the serialization process below ComponentCodeDomSerializer
// will be invoked to serialize the rootcomponent during expression serialization.
// 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.Add(statements);
manager.Context.Pop();
return(_codeMap.GenerateClass());
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (manager == null)
{
throw new ArgumentNullException("manager");
}
// Check if we are serializing the root component. Happens, because GetSerializer does not
// check for a RootCodeDomSerializer so reference-to type of an expression is delivered
// by the CodeDomSerializer
RootContext rootContext = manager.Context[typeof(RootContext)] as RootContext;
if (rootContext != null && rootContext.Value == value)
{
return(rootContext.Expression);
}
if (((IComponent)value).Site == null)
{
Console.WriteLine("ComponentCodeDomSerializer: Not sited : " + value);
return(null);
}
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.
//
string name = manager.GetName(value);
CodeExpression componentRef = null;
if (rootContext != null)
{
componentRef = new CodeFieldReferenceExpression(rootContext.Expression, name);
}
else
{
componentRef = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), name);
}
ExpressionContext exprContext = manager.Context[typeof(ExpressionContext)] as ExpressionContext;
if (exprContext != null && exprContext.PresetValue == value)
{
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));
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)
{
base.SetExpression(manager, value, componentRef);
serialized = componentRef;
}
}
return(serialized);
}
protected object DeserializeExpression(IDesignerSerializationManager manager, string name, CodeExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
if (manager == null)
{
throw new ArgumentNullException("manager");
}
object deserialized = null;
// CodeThisReferenceExpression
//
CodeThisReferenceExpression thisExpr = expression as CodeThisReferenceExpression;
if (thisExpr != null)
{
RootContext context = manager.Context[typeof(RootContext)] as RootContext;
if (context != null)
{
deserialized = context.Value;
}
else
{
IDesignerHost host = manager.GetService(typeof(IDesignerHost)) as IDesignerHost;
if (host != null)
{
deserialized = host.RootComponent;
}
}
}
// CodeVariableReferenceExpression
//
CodeVariableReferenceExpression varRef = expression as CodeVariableReferenceExpression;
if (deserialized == null && varRef != null)
{
deserialized = manager.GetInstance(varRef.VariableName);
}
// CodeFieldReferenceExpression
//
CodeFieldReferenceExpression fieldRef = expression as CodeFieldReferenceExpression;
if (deserialized == null && fieldRef != null)
{
deserialized = manager.GetInstance(fieldRef.FieldName);
}
// CodePrimitiveExpression
//
CodePrimitiveExpression primitiveExp = expression as CodePrimitiveExpression;
if (deserialized == null && primitiveExp != null)
{
deserialized = primitiveExp.Value;
}
// CodePropertyReferenceExpression
//
// Enum references are represented by a PropertyReferenceExpression, where
// PropertyName is the enum field name and the target object is a TypeReference
// to the enum's type
//
CodePropertyReferenceExpression propRef = expression as CodePropertyReferenceExpression;
if (deserialized == null && propRef != null)
{
object target = DeserializeExpression(manager, null, propRef.TargetObject);
if (target != null)
{
if (target is Type) // Enum reference
{
FieldInfo field = ((Type)target).GetField(propRef.PropertyName,
BindingFlags.GetField | BindingFlags.Public | BindingFlags.Static);
if (field != null)
{
deserialized = field.GetValue(null);
}
}
else
{
PropertyDescriptor property = TypeDescriptor.GetProperties(target)[propRef.PropertyName];
if (property != null)
{
deserialized = property.GetValue(target);
}
}
}
}
// CodeObjectCreateExpression
//
CodeObjectCreateExpression createExpr = expression as CodeObjectCreateExpression;
if (deserialized == null && createExpr != null)
{
Type type = manager.GetType(createExpr.CreateType.BaseType);
object[] arguments = new object[createExpr.Parameters.Count];
for (int i = 0; i < createExpr.Parameters.Count; i++)
{
arguments[i] = this.DeserializeExpression(manager, null, createExpr.Parameters[i]);
}
bool addToContainer = false;
if (typeof(IComponent).IsAssignableFrom(type))
{
addToContainer = true;
}
deserialized = this.DeserializeInstance(manager, type, arguments, name, addToContainer);
}
// CodeArrayCreateExpression
//
CodeArrayCreateExpression arrayCreateExpr = expression as CodeArrayCreateExpression;
if (deserialized == null && arrayCreateExpr != null)
{
Type arrayType = manager.GetType(arrayCreateExpr.CreateType.BaseType);
if (arrayType != null)
{
ArrayList initializers = new ArrayList();
foreach (CodeExpression initExpression in arrayCreateExpr.Initializers)
{
initializers.Add(this.DeserializeExpression(manager, null, initExpression));
}
deserialized = Array.CreateInstance(arrayType, initializers.Count);
initializers.CopyTo((Array)deserialized, 0);
}
}
// CodeMethodInvokeExpression
//
CodeMethodInvokeExpression methodExpr = expression as CodeMethodInvokeExpression;
if (deserialized == null && methodExpr != null)
{
object target = this.DeserializeExpression(manager, null, methodExpr.Method.TargetObject);
object[] parameters = new object[methodExpr.Parameters.Count];
for (int i = 0; i < methodExpr.Parameters.Count; i++)
{
parameters[i] = this.DeserializeExpression(manager, null, methodExpr.Parameters[i]);
}
MethodInfo method = null;
if (target is Type)
{
method = GetExactMethod((Type)target, methodExpr.Method.MethodName,
BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static,
parameters);
}
else
{
method = GetExactMethod(target.GetType(), methodExpr.Method.MethodName,
BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance,
parameters);
}
if (method == null)
{
Console.WriteLine("DeserializeExpression: Unable to find method: " + methodExpr.Method.MethodName);
}
else
{
deserialized = method.Invoke(target, parameters);
}
}
// CodeTypeReferenceExpression
//
CodeTypeReferenceExpression typeRef = expression as CodeTypeReferenceExpression;
if (deserialized == null && typeRef != null)
{
deserialized = manager.GetType(typeRef.Type.BaseType);
}
// CodeBinaryOperatorExpression
//
CodeBinaryOperatorExpression binOperator = expression as CodeBinaryOperatorExpression;
if (deserialized == null && binOperator != null)
{
switch (binOperator.Operator)
{
case CodeBinaryOperatorType.BitwiseOr:
IConvertible left = DeserializeExpression(manager, null, binOperator.Left) as IConvertible;
IConvertible right = DeserializeExpression(manager, null, binOperator.Right) as IConvertible;
if (left is Enum)
{
deserialized = Enum.ToObject(left.GetType(), Convert.ToInt64(left) | Convert.ToInt64(right));
}
break;
}
}
if (deserialized == null && methodExpr == null && primitiveExp == null)
{
Console.WriteLine("DeserializeExpression not supported for: " + expression);
}
return(deserialized);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (manager == null)
{
throw new ArgumentNullException("manager");
}
RootContext rootContext = manager.Context[typeof(RootContext)] as RootContext;
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(statements);
}
// 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.
//
string name = manager.GetName(value);
CodeExpression componentRef = null;
if (rootContext != null)
{
componentRef = new CodeFieldReferenceExpression(rootContext.Expression, name);
}
else
{
componentRef = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), name);
}
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;
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))
{
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);
}
return(statements);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
// Add the provider to supply the ComponentCodeSerializer, Primitives..., etc
manager.AddSerializationProvider(_provider);
RootContext rootContext = new RootContext(new CodeThisReferenceExpression(), value);
manager.Context.Push(rootContext);
// Initialize code map
if (_codeMap != null)
{
_codeMap = new CodeMap(value.GetType(), manager.GetName(value));
}
_codeMap.Clear();
CodeStatementCollection statements = null;
CodeDomSerializer serializer = null;
foreach (object component in ((IComponent)value).Site.Container.Components)
{
if (!Object.ReferenceEquals(component, value))
{
serializer = base.GetSerializer(manager, component) as CodeDomSerializer; // ComponentCodeDomSerializer
if (serializer != null)
{
// add an expressioncontext to inform the component that we want it fully serialized (it is in context)
ExpressionContext context = new ExpressionContext(null, null, null, component);
manager.Context.Push(context);
_codeMap.AddField(new CodeMemberField(value.GetType(), manager.GetName(value)));
statements = (CodeStatementCollection)serializer.Serialize(manager, component);
manager.Context.Pop();
// XXX: what if there are more than one objects constructed by the serializer?
// this will only add the first one on the statements list.
CodeStatement ctorStatement = ExtractCtorStatement(statements);
if (ctorStatement != null)
{
_codeMap.AddPreInitStatement(ctorStatement);
}
_codeMap.AddInitStatements(statements);
}
}
}
// Serializer root component
//
statements = new CodeStatementCollection();
base.SerializeProperties(manager, statements, value, new Attribute[0]);
base.SerializeEvents(manager, statements, value, new Attribute[0]);
_codeMap.AddInitStatements(statements);
manager.Context.Pop();
return(_codeMap.GenerateClass());
}
