System.Design 2.0.0.0 System.ComponentModel.Design.Serialization.DesignerLoader System.ComponentModel.Design.Serialization.IDesignerLoaderService

A is a complete implementation of a designer loader without anything relating to a persistence format. A does not dictate either a text or binary persistence, but it does support the following features:

Multiple load dependencies.

Tracking changes within the designer.

Deferred idle-time reloading.

A adds two kinds of services to the designer host’s service container: replaceable services and irreplaceable services. You can replace a replaceable service by changing the value of the protected property. You cannot replace irreplaceable services because their implementations depend on each other.

The following table describes the services that are provided by default.

Default Service

Description

Allows objects to request that the designer reload itself when it is idle. This is a replaceable service.

Used to serialize and deserialize objects. The serialization manager is added as a service so objects that need to perform serialization can utilize any serialization providers that were added to the serialization manager. This is an irreplaceable service.

Provides an implementation of the interface.

- Constructor
  2.0.0.0
  To be added.

  Initializes a new instance of the class.

- Method
  2.0.0.0
  System.Void ``

  This is an implementation of the abstract method. You do not need to override this method in your own class. The method performs the following actions:

  It verifies that the design surface has not already loaded.

  On the first call, it adds relevant services and calls the method.

  It calls the , , and methods.

  If the designer loader service has not been removed from the service container, will call the and methods instead of the and methods. In this situation, it is the responsibility of the designer loader service to call and .

  Starts the loading process.

  The designer loader host to load.
- Method
  2.0.0.0
  System.Void

  Calling the method does not flush changes to the designer loader. If you want changes to be saved, call before calling .

  Call when you are finished using the . The method leaves the in an unusable state. After calling , you must release all references to the so the garbage collector can reclaim the memory that the was occupying. For more information, see Cleaning Up Unmanaged Resources and Implementing a Dispose Method.

  Always call before you release your last reference to the . Otherwise, the resources it is using will not be freed until the garbage collector calls the object's Finalize method.

  Releases the resources used by the .

- Method
  2.0.0.0
  System.Boolean `` To be added.

  Enables or disables component notification with the .

  true if the component notification was enabled prior to this call; otherwise, false.

  true to enable component notification by the ; false to disable component notification by the .
- Method
  2.0.0.0
  System.Void

  If the designer loader has not been loaded or has not been marked as modified, the method returns immediately. Otherwise, asks the serialization manager to create a serialization session and then calls .

  Flushes pending changes to the designer loader.

- Method
  2.0.0.0
  System.Object ``

  is a helper method that allows classes deriving from to access services offered by the designer loader host.

  Gets the requested service.

  The requested service, or null if the requested service cannot be found.

  The of the service.
- Method
  2.0.0.0
  System.Void

  The method is called the first time is invoked. You can add any services necessary to the designer loader host at this time. The base implementation adds services that provides, so after calling the base implementation you may replace existing services. You must remove any custom services you add here by overriding .

  Initializes services.

- Method
  2.0.0.0
  System.Boolean

  The method is used by some designer loaders to optimize reloading. This method can be overridden if your designer loader supports intelligent reloading. Some designer loaders can detect changes made to their underlying document and determine if a reload of the designer is actually necessary. If not, they should return false from this method. The default implementation always returns true, indicating that any call to will succeed.

  Indicates whether the designer should be reloaded.

  true if the designer should be reloaded; otherwise, false. The default implementation always returns true.

- Property
  2.0.0.0
  System.ComponentModel.Design.Serialization.IDesignerLoaderHost To be added.

  This method returns the loader host that was given to this designer loader. This can be null if has not been called yet, or if this designer loader has been disposed.

  Gets the loader host.

- Property
  2.0.0.0
  System.Boolean To be added.

  The class provides the , which supports load dependencies. This property takes load dependencies into account and will return true if there are any outstanding load dependencies.

  Gets a value indicating whether the designer loader is loading the design surface.

- Property
  2.0.0.0
  System.Boolean To be added.

  Determines if the designer loader has detected that the designer has been modified. If this property is true when the designer loader’s method is called, the designer loader will call the method.

  Gets or sets a value indicating whether the designer has been modified.

- Method
  2.0.0.0
  System.Void

  The method is invoked to start the loading process. You should perform any necessary initialization for loading at this time. This method should not be used to perform the actual load. The default implementation disables change notifications and sets up the for loading.

  If you implement to provide dependent load support, you should call when the first dependent load occurs. Call the method after the last call to the method. By default, implements and does this for you. If is not available when is called, will directly call .

  If you provide your own loader service, or if you choose not to provide a loader service, you are responsible for calling this method. The method will automatically call this, either indirectly by calling if is available, or directly if it is not.

  Notifies the designer loader that loading is about to begin.

- Method
  2.0.0.0
  System.Void

  The method is invoked when the designer loader is about to unload the document.

  The document may be unloaded in preparation for reloading, or if the document failed to load. If you added document-specific services in or , remove them here.

  Notifies the designer loader that unloading is about to begin.

- Method
  2.0.0.0
  System.Void `` ``

  The method is invoked when loading is finished. It is always called, even if an exception is thrown during loading. The value of will be set to true if the load succeeded, or false if a fatal error occurred. The collection will contain objects that were reported as errors. Usually, these objects are exceptions.

  If you implement to provide dependent load support, you should call the method after the last call to the method. By default, implements and does this for you. If is not available when is called, will directly call after calling .

  This method should be called by the designer loader service when all dependent loads have been completed. This stops the loading process that was initiated by the method. If you provide your own loader service, or if you choose not to provide a loader service, you are responsible for calling this method. The method will automatically call this, either indirectly by calling the method if is available, or directly if it is not.

  Notifies the designer loader that loading is complete.

  true if the load completed successfully; otherwise, false. An containing objects (usually exceptions) that were reported as errors.
- Method
  2.0.0.0
  System.Void

  The method is called in response to a component changing, adding, or removing event which indicates that the designer is about to be modified. You can implement source code control by overriding this method. A call to does not mean that the property will later be set to true; it merely indicates an intention to do so.

  Notifies the designer loader that the state of the document is about to be modified.

- Method
  2.0.0.0
  System.Void ``

  The method is invoked when the designer loader needs to flush to persistence any changes made to the designers. It is invoked in response to a call to the method.

  Flushes all changes to the designer.

  An to use for persisting the state of loaded designers.
- Method
  2.0.0.0
  System.Void ``

  The method is invoked when the designer loader needs to load its state. is called before the method. You must implement this method to load the designer contents.

  Loads a designer from persistence.

  An to use for loading state for the designers.
- Property
  2.0.0.0
  System.Object To be added.

  The serialization manager provides a Properties property on its primary interface that can be read by serializers to customize their serialization to specific needs. The properties that are examined by the serializers vary depending on the type of serializer used.

  Gets or sets the property provider for the serialization manager being used by the loader.

- Method
  2.0.0.0
  System.Void `` To be added. To be added. To be added.
- Property
  2.0.0.0
  System.Boolean To be added. To be added.

  Gets a value indicating whether a reload has been queued.

- Method
  2.0.0.0
  System.Void ``

  The method is called during if one or more errors occurred while flushing changes. The values in the collection can be exceptions or objects with values that describe the error. The default implementation of raises the last exception in the collection.

  Reports errors that occurred while flushing changes.

  An containing error objects, usually exceptions.
- Method
  2.0.0.0
  System.Void ``

  The method should be called during loading to establish the full name of the component a designer is designing.

  Sets the full class name of the base component.

  A string representing the full name of the component to be designed.
- Method
  2.0.0.0
  System.Void

  Call the method once for each external object participating in the load process. The method is called when the work of the load process is done.

  Registers an external component as part of the load process managed by .

- Method
  2.0.0.0
  System.Void `` ``

  The method is called to signal that a dependent loading operation has completed. Call the method once for every process that was registered by calling the method, which has already completed.

  If the dependent load succeeds, the caller sets the parameter to true and passes either an empty collection or null to the parameter. If the dependent load encounters errors, the caller sets the parameter to false and passes a collection of exceptions that indicate the reason or reasons for failure to the parameter.

  Signals that a dependent load has finished.

  true to load successfully; otherwise, false. An containing errors that occurred during the load.
- Method
  2.0.0.0
  System.Boolean

  Any object can call the method to request that the loader reload the design document. If the loader supports reloading and complies with the reload, the designer loader can return true. Otherwise, it returns false, indicating that the reload will not occur. Callers cannot rely on the reload happening immediately; the designer loader can schedule this for some other time, or it can try to reload the designer at once.

  The caller can display a message to the user if the designer cannot be reloaded.

  Reloads the design document.

  true if the reload request is accepted; false if the loader does not allow the reload.