public void DesignerSerializationManager_OnResolveName_InvokeWithResolveName_CallsHandler(ResolveNameEventArgs eventArgs)
{
var manager = new SubDesignerSerializationManager();
int callCount = 0;
ResolveNameEventHandler handler = (sender, e) =>
{
Assert.Same(manager, sender);
Assert.Same(eventArgs, e);
callCount++;
};
IDisposable session = manager.CreateSession();
manager.ResolveName += handler;
manager.OnResolveName(eventArgs);
Assert.Equal(1, callCount);
session.Dispose();
// Call again.
session = manager.CreateSession();
manager.OnResolveName(eventArgs);
Assert.Equal(1, callCount);
session.Dispose();
// Remove handler.
session = manager.CreateSession();
manager.ResolveName += handler;
manager.ResolveName -= handler;
Assert.Equal(1, callCount);
session.Dispose();
}
/// <summary>Raises the <see cref="E:System.ComponentModel.Design.Serialization.DesignerSerializationManager.SessionDisposed" /> event. </summary>
/// <param name="e">An <see cref="T:System.EventArgs" /> that contains the event data.</param>
protected virtual void OnSessionDisposed(EventArgs e)
{
try
{
try
{
this.sessionDisposedEventHandler?.Invoke(this, e);
}
finally
{
this.serializationCompleteEventHandler?.Invoke(this, EventArgs.Empty);
}
}
finally
{
this.resolveNameEventHandler = null;
this.serializationCompleteEventHandler = null;
this.instancesByName = null;
this.namesByInstance = null;
this.serializers = null;
this.contextStack = null;
this.errorList = null;
this.session = null;
}
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// resolvenameeventhandler.BeginInvoke(sender, e, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this ResolveNameEventHandler resolvenameeventhandler, Object sender, ResolveNameEventArgs e, AsyncCallback callback)
{
if (resolvenameeventhandler == null)
{
throw new ArgumentNullException("resolvenameeventhandler");
}
return(resolvenameeventhandler.BeginInvoke(sender, e, callback, null));
}
public void DesignerSerializationManager_ResolveName_AddNoSession_ThrowsInvalidOperationException()
{
var manager = new SubDesignerSerializationManager();
int callCount = 0;
ResolveNameEventHandler handler = (sender, e) => callCount++;
Assert.Throws <InvalidOperationException>(() => manager.ResolveName += handler);
manager.ResolveName -= handler;
Assert.Equal(0, callCount);
}
void OnSessionDisposed(object sender, EventArgs e)
{
try
{
if (this.serializationCompleteEventHandler != null)
this.serializationCompleteEventHandler(this, EventArgs.Empty);
}
finally
{
this.resolveNameEventHandler = null;
this.serializationCompleteEventHandler = null;
}
}
void OnSessionDisposed(object sender, EventArgs e)
{
try
{
if (this.serializationCompleteEventHandler != null)
{
this.serializationCompleteEventHandler(this, EventArgs.Empty);
}
}
finally
{
this.resolveNameEventHandler = null;
this.serializationCompleteEventHandler = null;
}
}
/// This ends the loading process. This resets the state
/// of the serialization manager and merges the provided
/// error collection into the manager's own error list and
/// returns the merged list.
internal ICollection Terminate(ICollection errors)
{
// Let interested parties know that we're finished.
//
try
{
if (_serializationCompleteEventHandler != null)
{
_serializationCompleteEventHandler(this, EventArgs.Empty);
}
}
catch { }
// Merge the error list
//
if (_errorList != null && _errorList.Count > 0)
{
if (errors != null && errors.Count > 0)
{
_errorList.AddRange(errors);
}
errors = _errorList;
}
// Now disolve our state. The serialization manager
// should remain stateless.
//
_resolveNameEventHandler = null;
_serializationCompleteEventHandler = null;
_instancesByName = null;
_namesByInstance = null;
_serializers = null;
_errorList = null;
_contextStack = null;
return(errors);
}
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 (str2.Equals(declaration.Name) || !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;
}
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);
}
/// <summary>
/// This method deserializes a previously serialized code type declaration. The default implementation performs the following tasks:
/// • Case Sensitivity Checks: It looks for a CodeDomProvider service to decide if it should treat members as case sensitive or case insensitive.
/// • Statement Sorting: All member variables and local variables from init methods are stored in a table. Then each statement in an init method is added to a statement collection grouped according to its left hand side. So all statements assigning or operating on a particular variable are grouped under that variable. Variables that have no statements are discarded.
/// • Deserialization: Finally, the statement collections for each variable are deserialized according to the variable. Deserialize returns an instance of the root object.
/// </summary>
public virtual object Deserialize(IDesignerSerializationManager manager, CodeTypeDeclaration declaration)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (declaration == null)
{
throw new ArgumentNullException("declaration");
}
object rootObject = null;
using (TraceScope("TypeCodeDomSerializer::Deserialize"))
{
// Determine case-sensitivity
bool caseInsensitive = false;
CodeDomProvider provider = manager.GetService(typeof(CodeDomProvider)) as CodeDomProvider;
TraceWarningIf(provider == null, "Unable to determine case sensitivity. Make sure CodeDomProvider is a service of the manager.");
if (provider != null)
{
caseInsensitive = ((provider.LanguageOptions & LanguageOptions.CaseInsensitive) != 0);
}
// Get and initialize the document type.
Type baseType = null;
string baseTypeName = declaration.Name;
foreach (CodeTypeReference typeRef in declaration.BaseTypes)
{
Type t = manager.GetType(GetTypeNameFromCodeTypeReference(manager, typeRef));
baseTypeName = typeRef.BaseType;
if (t != null && !(t.IsInterface))
{
baseType = t;
break;
}
}
if (baseType == null)
{
TraceError("Base type for type declaration {0} could not be loaded. Closest base type name: {1}", declaration.Name, baseTypeName);
Error(manager, string.Format(SR.SerializerTypeNotFound, baseTypeName), SR.SerializerTypeNotFound);
}
if (GetReflectionTypeFromTypeHelper(manager, baseType).IsAbstract)
{
TraceError("Base type {0} is abstract, which isn't allowed", baseType.FullName);
Error(manager, string.Format(SR.SerializerTypeAbstract, baseType.FullName), SR.SerializerTypeAbstract);
}
ResolveNameEventHandler onResolveName = new ResolveNameEventHandler(OnResolveName);
manager.ResolveName += onResolveName;
rootObject = manager.CreateInstance(baseType, null, declaration.Name, true);
// Now that we have the root object, we create a nametable and fill it with member declarations.
int count = declaration.Members.Count;
_nameTable = new HybridDictionary(count, caseInsensitive);
_statementTable = new Dictionary <string, OrderedCodeStatementCollection>(count);
Dictionary <string, string> names = new Dictionary <string, string>(count);
RootContext rootCxt = new RootContext(new CodeThisReferenceExpression(), rootObject);
manager.Context.Push(rootCxt);
try
{
StringComparison compare = caseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
foreach (CodeTypeMember typeMember in declaration.Members)
{
if (typeMember is CodeMemberField member)
{
if (!string.Equals(member.Name, declaration.Name, compare))
{
// always skip members with the same name as the type -- because that's the name we use when we resolve "base" and "this" items...
_nameTable[member.Name] = member;
if (member.Type != null && !string.IsNullOrEmpty(member.Type.BaseType))
{
names[member.Name] = GetTypeNameFromCodeTypeReference(manager, member.Type);
}
}
}
}
CodeMemberMethod[] methods = GetInitializeMethods(manager, declaration);
if (methods == null)
{
throw new InvalidOperationException();
}
Trace("Members to deserialize: {0}", _nameTable.Keys.Count);
Trace("Methods to deserialize: {0}", methods.Length);
TraceWarningIf(methods.Length == 0, "Serializer did not find any methods to deserialize.");
// Walk through all of our methods and search for local variables. These guys get added to our nametable too.
foreach (CodeMemberMethod method in methods)
{
foreach (CodeStatement statement in method.Statements)
{
if (statement is CodeVariableDeclarationStatement local)
{
_nameTable[local.Name] = statement;
}
}
}
// The name table should come pre-populated with our root expression.
_nameTable[declaration.Name] = rootCxt.Expression;
// We fill a "statement table" for everything in our init methods. This statement table is a dictionary whose keys contain object names and whose values contain a statement collection of all statements with a LHS resolving to an object by that name. If supportGenerate is true, FillStatementTable will skip methods that are marked with the tag "GeneratedStatement".
foreach (CodeMemberMethod method in methods)
{
FillStatementTable(manager, _statementTable, names, method.Statements, declaration.Name);
}
// Interesting problem. The CodeDom parser may auto generate statements that are associated with other methods. VB does this, for example, to create statements automatically for Handles clauses. The problem with this technique is that we will end up with statements that are related to variables that live solely in user code and not in InitializeComponent. We will attempt to construct instances of these objects with limited success. To guard against this, we check to see if the manager even supports this feature, and if it does, we must look out for these statements while filling the statement collections.
PropertyDescriptor supportGenerate = manager.Properties["SupportsStatementGeneration"];
if (supportGenerate != null && supportGenerate.PropertyType == typeof(bool) && ((bool)supportGenerate.GetValue(manager)) == true)
{
// Ok, we must do the more expensive work of validating the statements we get.
foreach (string name in _nameTable.Keys)
{
if (!name.Equals(declaration.Name) && _statementTable.ContainsKey(name))
{
CodeStatementCollection statements = _statementTable[name];
bool acceptStatement = false;
foreach (CodeStatement statement in statements)
{
object genFlag = statement.UserData["GeneratedStatement"];
if (genFlag == null || !(genFlag is bool) || !((bool)genFlag))
{
acceptStatement = true;
break;
}
}
if (!acceptStatement)
{
_statementTable.Remove(name);
}
}
}
}
// Design time properties must be resolved before runtime properties to make sure that properties like "language" get established before we need to read values out the resource bundle
Trace("--------------------------------------------------------------------");
Trace(" Beginning deserialization of {0} (design time)", declaration.Name);
Trace("--------------------------------------------------------------------");
// Deserialize design time properties for the root component.
DeserializePropertiesFromResources(manager, rootObject, s_designTimeFilter);
// sort by the order so we deserialize in the same order the objects were decleared in.
OrderedCodeStatementCollection[] statementArray = new OrderedCodeStatementCollection[_statementTable.Count];
_statementTable.Values.CopyTo(statementArray, 0);
Array.Sort(statementArray, StatementOrderComparer.s_default);
// make sure we have fully deserialized everything that is referenced in the statement table. Skip the root object for last
OrderedCodeStatementCollection rootStatements = null;
foreach (OrderedCodeStatementCollection statements in statementArray)
{
if (statements.Name.Equals(declaration.Name))
{
rootStatements = statements;
}
else
{
DeserializeName(manager, statements.Name, statements);
}
}
if (rootStatements != null)
{
DeserializeName(manager, rootStatements.Name, rootStatements);
}
}
finally
{
_nameTable = null;
_statementTable = null;
Debug.Assert(manager.Context.Current == rootCxt, "Context stack corrupted");
manager.ResolveName -= onResolveName;
manager.Context.Pop();
}
}
return(rootObject);
}
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);
}
/// <include file='doc\DesignerSerializationObject.uex' path='docs/doc[@for="DesignerSerializationObject.ISerializable.GetObjectData"]/*' />
/// <devdoc>
/// Implements the save part of ISerializable.
/// </devdoc>
void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
{
// check if we need to save any components as source code.
//
if (code == null && manager != null)
{
instancesByName = new Hashtable(objects.Length);
namesByInstance = new Hashtable(objects.Length);
foreach (object o in objects)
{
if (o is IComponent && ((IComponent)o).Site != null && ((IComponent)o).Site.Name != null)
{
IComponent comp = (IComponent)o;
((IContainer)this).Add(comp, comp.Site.Name);
instancesByName[comp.Site.Name] = comp;
namesByInstance[comp] = comp.Site.Name;
}
}
if (containerComponents != null && containerComponents.Count > 0)
{
IDesignerSerializationManager ourManager = (IDesignerSerializationManager)this;
// Add our own object into the container. This gives the root serializer something
// to serialize.
//
((IContainer)this).Add(this, DataTypeName);
// Now just ask the serializer to serialize.
//
try {
code = rootSerializer.Serialize(ourManager, this);
#if DEBUG
if (traceDSO.TraceVerbose)
{
Debug.WriteLine("Serializing:");
Debug.Indent();
GenerateCodeFromSerializedData(code);
Debug.Unindent();
}
#endif
designTimeProperties = SerializeDesignTimeProperties(manager, objects);
}
finally {
if (serializationCompleteEventHandler != null)
{
try {
serializationCompleteEventHandler(this, EventArgs.Empty);
}
catch {}
}
this.manager = null;
resolveNameEventHandler = null;
serializationCompleteEventHandler = null;
designerSerializationProviders = null;
instancesByName = null;
namesByInstance = null;
contextStack = null;
((IContainer)this).Remove(this);
containerComponents = null;
}
}
// Now that we have made this pass, we can null out persister so
// we will not re-enter here should someone call us again.
//
manager = null;
rootSerializer = null;
}
// Now serialize all the stuff.
//
ArrayList objectsToSerialize = new ArrayList();
if (code != null)
{
foreach (object obj in objects)
{
if (!(obj is IComponent))
{
objectsToSerialize.Add(obj);
}
}
}
info.AddValue(serializableObjects, objectsToSerialize);
info.AddValue(componentCode, code);
info.AddValue(componentResources, resourceManager != null ? resourceManager.Data : null);
info.AddValue(designTimeProps, designTimeProperties);
}
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;
}
protected virtual void OnSessionDisposed(EventArgs e)
{
try
{
try
{
if (this.sessionDisposedEventHandler != null)
{
this.sessionDisposedEventHandler(this, e);
}
}
finally
{
if (this.serializationCompleteEventHandler != null)
{
this.serializationCompleteEventHandler(this, EventArgs.Empty);
}
}
}
finally
{
this.resolveNameEventHandler = null;
this.serializationCompleteEventHandler = null;
this.instancesByName = null;
this.namesByInstance = null;
this.serializers = null;
this.contextStack = null;
this.errorList = null;
this.session = null;
}
}
internal void Deserialize(IDesignerSerializationManager manager, IDictionary objectState, IList objectNames, bool applyDefaults)
{
CodeStatementCollection completeStatements = new CodeStatementCollection();
this._expressions = new Dictionary<string, ArrayList>();
this.applyDefaults = applyDefaults;
foreach (string str in objectNames)
{
object[] objArray = (object[]) objectState[str];
if (objArray != null)
{
if (objArray[0] != null)
{
this.PopulateCompleteStatements(objArray[0], str, completeStatements);
}
if (objArray[1] != null)
{
this.PopulateCompleteStatements(objArray[1], str, completeStatements);
}
}
}
CodeStatementCollection targetStatements = new CodeStatementCollection();
CodeMethodMap map = new CodeMethodMap(targetStatements, null);
map.Add(completeStatements);
map.Combine();
this._statementsTable = new Hashtable();
CodeDomSerializerBase.FillStatementTable(manager, this._statementsTable, targetStatements);
ArrayList list = new ArrayList(objectNames);
foreach (string str2 in this._statementsTable.Keys)
{
if (!list.Contains(str2))
{
list.Add(str2);
}
}
this._objectState = new Hashtable(objectState.Keys.Count);
foreach (DictionaryEntry entry in objectState)
{
this._objectState.Add(entry.Key, entry.Value);
}
ResolveNameEventHandler handler = new ResolveNameEventHandler(this.OnResolveName);
manager.ResolveName += handler;
try
{
foreach (string str3 in list)
{
this.ResolveName(manager, str3, true);
}
}
finally
{
this._objectState = null;
manager.ResolveName -= handler;
}
}
/// This ends the loading process. This resets the state
/// of the serialization manager and merges the provided
/// error collection into the manager's own error list and
/// returns the merged list.
internal ICollection Terminate(ICollection errors)
{
// Let interested parties know that we're finished.
//
try
{
if (_serializationCompleteEventHandler != null)
{
_serializationCompleteEventHandler(this, EventArgs.Empty);
}
}
catch {}
// Merge the error list
//
if (_errorList != null && _errorList.Count > 0)
{
if (errors != null && errors.Count > 0)
{
_errorList.AddRange(errors);
}
errors = _errorList;
}
// Now disolve our state. The serialization manager
// should remain stateless.
//
_resolveNameEventHandler = null;
_serializationCompleteEventHandler = null;
_instancesByName = null;
_namesByInstance = null;
_serializers = null;
_errorList = null;
_contextStack = null;
return errors;
}
/// <include file='doc\DesignerSerializationObject.uex' path='docs/doc[@for="DesignerSerializationObject.Deserialize"]/*' />
/// <devdoc>
/// Returns the original collection of objects, deserializing
/// them from saved state if necessary.
/// </devdoc>
public ICollection Deserialize(IDesignerSerializationManager manager, CodeDomSerializer rootSerializer)
{
// If we have a set of objects, and we don't have
// any code that needs to be deserialized, then
// we're done.
//
if (objects != null && code == null)
{
return(objects);
}
// If we need to deserialize, we just ask the real serialization manager for
// the root serializer, and we let it party on the code. The result is
// going to be a (hopefully) non-null containerComponents object whose
// values contain all the components we were interested in.
//
this.manager = manager;
ArrayList components = null;
try {
#if DEBUG
if (traceDSO.TraceVerbose)
{
Debug.WriteLine("Deserializing:");
Debug.Indent();
GenerateCodeFromSerializedData(code);
Debug.Unindent();
}
#endif
rootSerializer.Deserialize(this, code);
}
finally {
if (serializationCompleteEventHandler != null)
{
try {
serializationCompleteEventHandler(this, EventArgs.Empty);
}
catch {}
}
this.manager = null;
resolveNameEventHandler = null;
serializationCompleteEventHandler = null;
designerSerializationProviders = null;
instancesByName = null;
namesByInstance = null;
contextStack = null;
components = containerComponents;
containerComponents = null;
}
// If we got some compnents into our container, get 'em out!
//
if (components != null)
{
// The designer host's root object will be sitting in this
// container, because the root serializer believes that it
// created an instance of it. Remove this object here because
// it is not actually a part of the serialization work.
//
IDesignerHost host = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if (host != null && components.Contains(host.RootComponent))
{
components.Remove(host.RootComponent);
}
object[] finalObjects = new object[objects.Length + components.Count];
objects.CopyTo(finalObjects, 0);
components.CopyTo(finalObjects, objects.Length);
objects = finalObjects;
if (host != null)
{
this.componentChangeSvc = (IComponentChangeService)host.GetService(typeof(IComponentChangeService));
if (this.componentChangeSvc != null)
{
this.componentChangeSvc.ComponentAdded += new ComponentEventHandler(this.OnComponentAdded);
addedComps = new Hashtable();
foreach (IComponent ic in components)
{
addedComps[ic.Site.Name] = ic;
}
}
}
}
return(objects);
}
