private void AddStatement(string name, CodeStatement statement)
{
CodeDomSerializerBase.OrderedCodeStatementCollection statements = (CodeDomSerializerBase.OrderedCodeStatementCollection) this.statementTable[name];
if (statements == null)
{
statements = new CodeDomSerializerBase.OrderedCodeStatementCollection {
Order = this.statementTable.Count,
Name = name
};
this.statementTable[name] = statements;
}
statements.Add(statement);
}
public int Compare(object left, object right)
{
CodeDomSerializerBase.OrderedCodeStatementCollection statements = left as CodeDomSerializerBase.OrderedCodeStatementCollection;
CodeDomSerializerBase.OrderedCodeStatementCollection statements2 = right as CodeDomSerializerBase.OrderedCodeStatementCollection;
if (left == null)
{
return(1);
}
if (right == null)
{
return(-1);
}
if (right == left)
{
return(0);
}
return(statements.Order - statements2.Order);
}
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
if ((manager == null) || (codeObject == null))
{
throw new ArgumentNullException((manager == null) ? "manager" : "codeObject");
}
object obj2 = null;
using (CodeDomSerializerBase.TraceScope("RootCodeDomSerializer::Deserialize"))
{
if (!(codeObject is CodeTypeDeclaration))
{
throw new ArgumentException(System.Design.SR.GetString("SerializerBadElementType", new object[] { typeof(CodeTypeDeclaration).FullName }));
}
bool caseInsensitive = false;
CodeDomProvider service = manager.GetService(typeof(CodeDomProvider)) as CodeDomProvider;
if (service != null)
{
caseInsensitive = (service.LanguageOptions & LanguageOptions.CaseInsensitive) != LanguageOptions.None;
}
CodeTypeDeclaration declaration = (CodeTypeDeclaration)codeObject;
CodeTypeReference reference = null;
Type type = null;
foreach (CodeTypeReference reference2 in declaration.BaseTypes)
{
Type type2 = manager.GetType(CodeDomSerializerBase.GetTypeNameFromCodeTypeReference(manager, reference2));
if ((type2 != null) && !type2.IsInterface)
{
reference = reference2;
type = type2;
break;
}
}
if (type == null)
{
Exception exception = new SerializationException(System.Design.SR.GetString("SerializerTypeNotFound", new object[] { reference.BaseType }))
{
HelpLink = "SerializerTypeNotFound"
};
throw exception;
}
if (type.IsAbstract)
{
Exception exception2 = new SerializationException(System.Design.SR.GetString("SerializerTypeAbstract", new object[] { type.FullName }))
{
HelpLink = "SerializerTypeAbstract"
};
throw exception2;
}
ResolveNameEventHandler handler = new ResolveNameEventHandler(this.OnResolveName);
manager.ResolveName += handler;
if (!(manager is DesignerSerializationManager))
{
manager.AddSerializationProvider(new CodeDomSerializationProvider());
}
obj2 = manager.CreateInstance(type, null, declaration.Name, true);
this.nameTable = new HybridDictionary(declaration.Members.Count, caseInsensitive);
this.statementTable = new HybridDictionary(declaration.Members.Count, caseInsensitive);
this.initMethod = null;
RootContext context = new RootContext(new CodeThisReferenceExpression(), obj2);
manager.Context.Push(context);
try
{
foreach (CodeTypeMember member in declaration.Members)
{
if (member is CodeMemberField)
{
if (string.Compare(member.Name, declaration.Name, caseInsensitive, CultureInfo.InvariantCulture) != 0)
{
this.nameTable[member.Name] = member;
}
}
else if ((this.initMethod == null) && (member is CodeMemberMethod))
{
CodeMemberMethod method = (CodeMemberMethod)member;
if ((string.Compare(method.Name, this.InitMethodName, caseInsensitive, CultureInfo.InvariantCulture) == 0) && (method.Parameters.Count == 0))
{
this.initMethod = method;
}
}
}
if (this.initMethod != null)
{
foreach (CodeStatement statement in this.initMethod.Statements)
{
CodeVariableDeclarationStatement statement2 = statement as CodeVariableDeclarationStatement;
if (statement2 != null)
{
this.nameTable[statement2.Name] = statement;
}
}
}
if (this.nameTable[declaration.Name] != null)
{
this.nameTable[declaration.Name] = obj2;
}
if (this.initMethod != null)
{
this.FillStatementTable(this.initMethod, declaration.Name);
}
PropertyDescriptor descriptor = manager.Properties["SupportsStatementGeneration"];
if (((descriptor != null) && (descriptor.PropertyType == typeof(bool))) && ((bool)descriptor.GetValue(manager)))
{
foreach (string str in this.nameTable.Keys)
{
CodeDomSerializerBase.OrderedCodeStatementCollection statements = (CodeDomSerializerBase.OrderedCodeStatementCollection) this.statementTable[str];
if (statements != null)
{
bool flag2 = false;
foreach (CodeStatement statement3 in statements)
{
object obj3 = statement3.UserData["GeneratedStatement"];
if (((obj3 == null) || !(obj3 is bool)) || !((bool)obj3))
{
flag2 = true;
break;
}
}
if (!flag2)
{
this.statementTable.Remove(str);
}
}
}
}
IContainer container = (IContainer)manager.GetService(typeof(IContainer));
if (container != null)
{
foreach (object obj4 in container.Components)
{
base.DeserializePropertiesFromResources(manager, obj4, designTimeProperties);
}
}
object[] array = new object[this.statementTable.Values.Count];
this.statementTable.Values.CopyTo(array, 0);
Array.Sort(array, StatementOrderComparer.Default);
foreach (CodeDomSerializerBase.OrderedCodeStatementCollection statements2 in array)
{
string name = statements2.Name;
if ((name != null) && !name.Equals(declaration.Name))
{
this.DeserializeName(manager, name);
}
}
CodeStatementCollection statements3 = (CodeStatementCollection)this.statementTable[declaration.Name];
if ((statements3 != null) && (statements3.Count > 0))
{
foreach (CodeStatement statement4 in statements3)
{
base.DeserializeStatement(manager, statement4);
}
}
return(obj2);
}
finally
{
manager.ResolveName -= handler;
this.initMethod = null;
this.nameTable = null;
this.statementTable = null;
manager.Context.Pop();
}
}
return(obj2);
}
public virtual object Deserialize(IDesignerSerializationManager manager, CodeTypeDeclaration declaration)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (declaration == null)
{
throw new ArgumentNullException("declaration");
}
object obj2 = null;
using (CodeDomSerializerBase.TraceScope("TypeCodeDomSerializer::Deserialize"))
{
bool caseInsensitive = false;
CodeDomProvider service = manager.GetService(typeof(CodeDomProvider)) as CodeDomProvider;
if (service != null)
{
caseInsensitive = (service.LanguageOptions & LanguageOptions.CaseInsensitive) != LanguageOptions.None;
}
Type type = null;
string name = declaration.Name;
foreach (CodeTypeReference reference in declaration.BaseTypes)
{
Type type2 = manager.GetType(CodeDomSerializerBase.GetTypeNameFromCodeTypeReference(manager, reference));
name = reference.BaseType;
if ((type2 != null) && !type2.IsInterface)
{
type = type2;
break;
}
}
if (type == null)
{
CodeDomSerializerBase.Error(manager, System.Design.SR.GetString("SerializerTypeNotFound", new object[] { name }), "SerializerTypeNotFound");
}
if (CodeDomSerializerBase.GetReflectionTypeFromTypeHelper(manager, type).IsAbstract)
{
CodeDomSerializerBase.Error(manager, System.Design.SR.GetString("SerializerTypeAbstract", new object[] { type.FullName }), "SerializerTypeAbstract");
}
ResolveNameEventHandler handler = new ResolveNameEventHandler(this.OnResolveName);
manager.ResolveName += handler;
obj2 = manager.CreateInstance(type, null, declaration.Name, true);
int count = declaration.Members.Count;
this._nameTable = new HybridDictionary(count, caseInsensitive);
this._statementTable = new Dictionary <string, CodeDomSerializerBase.OrderedCodeStatementCollection>(count);
Dictionary <string, string> names = new Dictionary <string, string>(count);
RootContext context = new RootContext(new CodeThisReferenceExpression(), obj2);
manager.Context.Push(context);
try
{
StringComparison comparisonType = caseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
foreach (CodeTypeMember member in declaration.Members)
{
CodeMemberField field = member as CodeMemberField;
if ((field != null) && !string.Equals(field.Name, declaration.Name, comparisonType))
{
this._nameTable[field.Name] = field;
if ((field.Type != null) && !string.IsNullOrEmpty(field.Type.BaseType))
{
names[field.Name] = CodeDomSerializerBase.GetTypeNameFromCodeTypeReference(manager, field.Type);
}
}
}
CodeMemberMethod[] initializeMethods = this.GetInitializeMethods(manager, declaration);
if (initializeMethods == null)
{
throw new InvalidOperationException();
}
foreach (CodeMemberMethod method in initializeMethods)
{
foreach (CodeStatement statement in method.Statements)
{
CodeVariableDeclarationStatement statement2 = statement as CodeVariableDeclarationStatement;
if (statement2 != null)
{
this._nameTable[statement2.Name] = statement;
}
}
}
this._nameTable[declaration.Name] = context.Expression;
foreach (CodeMemberMethod method2 in initializeMethods)
{
CodeDomSerializerBase.FillStatementTable(manager, this._statementTable, names, method2.Statements, declaration.Name);
}
PropertyDescriptor descriptor = manager.Properties["SupportsStatementGeneration"];
if (((descriptor != null) && (descriptor.PropertyType == typeof(bool))) && ((bool)descriptor.GetValue(manager)))
{
foreach (string str2 in this._nameTable.Keys)
{
if (!this._statementTable.ContainsKey(str2))
{
continue;
}
CodeStatementCollection statements = this._statementTable[str2];
bool flag2 = false;
foreach (CodeStatement statement3 in statements)
{
object obj3 = statement3.UserData["GeneratedStatement"];
if (((obj3 == null) || !(obj3 is bool)) || !((bool)obj3))
{
flag2 = true;
break;
}
}
if (!flag2)
{
this._statementTable.Remove(str2);
}
}
}
base.DeserializePropertiesFromResources(manager, obj2, _designTimeFilter);
CodeDomSerializerBase.OrderedCodeStatementCollection[] array = new CodeDomSerializerBase.OrderedCodeStatementCollection[this._statementTable.Count];
this._statementTable.Values.CopyTo(array, 0);
Array.Sort(array, StatementOrderComparer.Default);
CodeDomSerializerBase.OrderedCodeStatementCollection statements2 = null;
foreach (CodeDomSerializerBase.OrderedCodeStatementCollection statements3 in array)
{
if (statements3.Name.Equals(declaration.Name))
{
statements2 = statements3;
}
else
{
this.DeserializeName(manager, statements3.Name, statements3);
}
}
if (statements2 != null)
{
this.DeserializeName(manager, statements2.Name, statements2);
}
}
finally
{
this._nameTable = null;
this._statementTable = null;
manager.ResolveName -= handler;
manager.Context.Pop();
}
}
return(obj2);
}
