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()); }