codedomdesignerserializationmanager.cs

c#源代码

						Type type = GetType(serAtt.SerializerTypeName);
						return LicenseManager.CreateWithContext(type, new DesigntimeLicenseContext()) as CodeDomSerializer;
					}
				}
			}
			return GetRootSerializer(objectType.BaseType);
		}

		/// <summary>
		/// TODO - add method description
		/// </summary>
		/// <remarks>
		/// Interface method from IDesignerSerializationManager
		///
		/// </remarks>
		/// <param name='value'>TODO - add parameter description</param>
		public virtual string GetName(object value)
		{
			//System.Console.WriteLine("Looking for name of {0}",value);
			object name = objectToName[value];
			return (string)name;
		}

		/// <summary>
		/// TODO - add method description
		/// </summary>
		/// <remarks>
		/// Interface method from IDesignerSerializationManager
		///
		/// </remarks>
		/// <param name='name'>TODO - add parameter description</param>
		public virtual object GetInstance(string name)
		{
			object o = nameToObject[name];
			if (o != null) {
				return o;
			}
			o = OnResolveName(name);
			if (o != null){
				nameToObject[name] = o;
			}
			return o;
		}

		/// <summary>
		/// TODO - add method description
		/// </summary>
		/// <remarks>
		/// Interface method from IDesignerSerializationManager
		///
		/// </remarks>
		/// <param name='type'>TODO - add parameter description</param>
		/// <param name='arguments'>TODO - add parameter description</param>
		/// <param name='name'>TODO - add parameter description</param>
		/// <param name='addToContainer'>TODO - add parameter description</param>
		public virtual object CreateInstance(Type type, ICollection arguments, string name, bool addToContainer)
		{
			object o = null;
//			Console.WriteLine("create instance :{0} with name {2} should add:{1}", type, addToContainer, name);
//			Console.WriteLine(Environment.StackTrace);
//			Console.ReadLine();
//			Console.WriteLine(host.Container.Components.Count);
			
			try {
				AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(ResolveAssembly);
				if (arguments == null) {
					o = LicenseManager.CreateWithContext(type, new DesigntimeLicenseContext());
					//o = Activator.CreateInstance(type);
				} else {
					
					object[] args = new object[arguments.Count];
					arguments.CopyTo(args,0);
					// fix for misbehaviour:
					// some components DO add themselve to the container
					// this is my way to listen to this event
					int oldComponentCount = host.Container.Components.Count;
					try {
						o = Activator.CreateInstance(type, args);
					} catch (MissingMethodException) {
						throw;
					} catch (Exception ex) {
						IMessageService messageService =(IMessageService)ServiceManager.Services.GetService(typeof(IMessageService));
						messageService.ShowError(ex, "Exception while creating the component for the Forms Designer (a component has thrown an exception in the constructor).\nTHIS DOES NOT AFFECT THE SOURCE CODE.");
					}
					if (oldComponentCount != host.Container.Components.Count) {
						IComponent c = o as IComponent;
						
						if (name != null) {
							// overwrite default name
							ComponentChangeService changeService = host.GetService(typeof(IComponentChangeService)) as ComponentChangeService;
							changeService.OnComponentRename(c, c.Site.Name, name);
							SetName(o, name);
						} else {
							// when they added themselves they got already a site
							// now we need to recognice their name
							objectToName[o]           = c.Site.Name;
							nameToObject[c.Site.Name] = o;
						}
						return o;
					}
				}
			} finally {
				AppDomain.CurrentDomain.AssemblyResolve -= new ResolveEventHandler(ResolveAssembly);				
			}
			
			if (o == null) {
				throw new Exception(String.Format("Can't create instance of type {0}",type));
			}
			try {
				if (name != null) {
					INameCreationService nameCreationService = (INameCreationService)GetService(typeof(INameCreationService));
					if (!nameCreationService.IsValidName(name)) {
						name = nameCreationService.CreateName(host.Container, o.GetType());
					}
					SetName(o, name);
				}
			} catch (Exception e) {
				Console.WriteLine("Got Exception : " + e);
			}
			if (addToContainer && name != null) {
				IComponent comp = o as IComponent;
				if (comp != null) {
					host.Container.Add(comp, name);
				}
			}
			return o;
		}

		/// <summary>
		/// TODO - add method description
		/// </summary>
		/// <remarks>
		/// Interface method from IDesignerSerializationManager
		///
		/// </remarks>
		/// <param name='provider'>TODO - add parameter description</param>
		public virtual void AddSerializationProvider(IDesignerSerializationProvider provider)
		{
			//System.Console.WriteLine("Adding serilization provider {0}",provider);
			providers.Add(provider);
		}

		/// <summary>
		/// TODO - add method description
		/// </summary>
		/// <remarks>
		/// Interface method from IServiceProvider
		///
		/// </remarks>
		/// <param name='serviceType'>TODO - add parameter description</param>
//		public virtual object GetService(Type serviceType)
//		{
//			object service = host.GetService(serviceType);
//			if (service == null)
//				System.Console.WriteLine("Manager service not found {0}",serviceType);
//
//			return service;
//		}

		public void Initialize()
		{
			while (context.Pop() != null) {}
			providers.Clear();
			nameToObject.Clear();
			objectToName.Clear();
			props = PropertyDescriptorCollection.Empty;
			services = new ServiceContainer(host);
			services.AddService(typeof(IDesignerSerializationManager),this);
			services.AddService(typeof(IServiceContainer),this);
		}


		protected virtual object OnResolveName(string name)
		{
			
			if (ResolveName == null) {
				return null;
			}
			ResolveNameEventArgs e = new ResolveNameEventArgs(name);
			ResolveName(this,e);
			return e.Value;
		}

		public void OnSerializationComplete()
		{
			if (SerializationComplete != null) {
				SerializationComplete(this,EventArgs.Empty);
			}
		}

#region System.IServiceProvider interface implementation
		public object GetService(System.Type serviceType)
		{
			return services.GetService(serviceType);
		}
#endregion


#region System.ComponentModel.Design.IServiceContainer interface implementation
		public void RemoveService(Type serviceType)
		{
			services.RemoveService(serviceType);
		}

		public void RemoveService(Type serviceType,bool promote)
		{
			services.RemoveService(serviceType,promote);
		}

		public void AddService(Type serviceType, object serviceInstance)
		{
			//Console.WriteLine("DesignerHost added service {0} object {1}",serviceType.Name,serviceInstance);
			services.AddService(serviceType,serviceInstance);
		}

		public void AddService(Type serviceType, ServiceCreatorCallback callback)
		{
			//Console.WriteLine("DesignerHost added callback {1} as service {0}",serviceType.Name ,callback);
			services.AddService(serviceType, callback);
		}

		public void AddService(Type serviceType, object serviceInstance,bool promote)
		{
			//Console.WriteLine("service {0} object promote added to DesignerHost",serviceType);
			services.AddService(serviceType, serviceInstance,promote);
		}

		public void AddService(Type serviceType, ServiceCreatorCallback callback, bool promote)
		{
			//Console.WriteLine("service {0} callback promote added to DesignerHost",serviceType);
			services.AddService(serviceType, callback,promote);
		}
#endregion


		public event ResolveNameEventHandler ResolveName;
		public event EventHandler SerializationComplete;

		/// <summary>
		/// Looks in the current app domain for assembly that cannot be resolved.
		/// </summary>
		Assembly ResolveAssembly(object sender, ResolveEventArgs args)
		{
			foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies()) {
				if (asm.FullName == args.Name) {
					return asm;
				}
			}

			return null;
		}
	}
}