private void CheckClasses()
 {
     lock (this.SyncObject)
         if (this.classes == null)
         {
             if (this.IsDisposed)
             {
                 throw new InvalidOperationException(Resources.ObjectStateThrowMessage);
             }
             this.classes = this.InitializeClasses();
             SuspendCheck(this.SyncObject, this.classes, this.suspendLevel);
         }
 }
 /// <summary>
 /// Frees managed resources used by the
 /// <see cref="IntermediateGenericSegmentableParentType{TTypeIdentifier, TType, TIntermediateType, TInstanceIntermediateType}"/>.
 /// </summary>
 public override void Dispose()
 {
     try
     {
         if (this.classes != null)
         {
             this.classes.Dispose();
             this.classes = null;
         }
         if (this.enums != null)
         {
             this.enums.Dispose();
             this.enums = null;
         }
         if (this.delegates != null)
         {
             this.delegates.Dispose();
             this.delegates = null;
         }
         if (this.interfaces != null)
         {
             this.interfaces.Dispose();
             this.interfaces = null;
         }
         if (this.structs != null)
         {
             this.structs.Dispose();
             this.structs = null;
         }
         if (this.types != null)
         {
             if (this.IsRoot)
             {
                 this.types.Dispose();
             }
             else
             {
                 this.types.ConditionalRemove(this);
             }
             this.types = null;
         }
         if (this.scopeCoercions != null)
         {
             this.scopeCoercions = null;
         }
     }
     finally
     {
         base.Dispose();
     }
 }
        /// <summary>
        /// Initializes the <see cref="Classes"/> property.
        /// </summary>
        /// <returns>A new <see cref="IntermediateClassTypeDictionary"/> instance.</returns>
        /// <remarks>If <see cref="IntermediateGenericSegmentableType{TTypeIdentifier, TType, TIntermediateType, TInstanceIntermediateType}.IsRoot"/>
        /// is true, this creates a new standalone class type dictionary linked to the master
        /// <see cref="Types"/> dictionary; however, if false, it creates a dependent
        /// class type dictionary which mirrors the members of the root declaration and all other
        /// partial instances.  Parent target discernment is provided by the
        /// <see cref="IntermediateTypeDictionary{TTypeIdentifier, TType, TIntermediateType}.Parent"/>
        /// of the dictionary for the current instance.  Add methods called upon the
        /// instance provided here report the current partial instance as the parent.</remarks>
        protected virtual IntermediateClassTypeDictionary InitializeClasses()
        {
            IntermediateClassTypeDictionary result;

            if (this.IsRoot)
            {
                result = new IntermediateClassTypeDictionary(this, this._Types);
            }
            else
            {
                result = new IntermediateClassTypeDictionary(this, this._Types, (IntermediateClassTypeDictionary)this.GetRoot().Classes);
            }
            if (this.IsLocked)
            {
                result.Lock();
            }
            return(result);
        }
Esempio n. 4
0
 /// <summary>
 /// Disposes the <see cref="IntermediateNamespaceDeclaration"/>
 /// </summary>
 /// <param name="disposing">whether to dispose the managed
 /// resources as well as the unmanaged resources.</param>
 protected override void Dispose(bool disposing)
 {
     try
     {
         if (disposing)
         {
             lock (this.SyncObject)
             {
                 this.parent = null;
                 if (this.methods != null)
                 {
                     this.methods.Dispose();
                     this.methods = null;
                 }
                 if (this.fields != null)
                 {
                     this.fields.Dispose();
                     this.fields = null;
                 }
                 if (this.members != null)
                 {
                     if (this.IsRoot)
                     {
                         this.members.Dispose();
                     }
                     else
                     {
                         this.members.ConditionalRemove(this);
                     }
                     this.members = null;
                 }
                 if (this.classes != null)
                 {
                     this.classes.Dispose();
                     this.classes = null;
                 }
                 if (this.enums != null)
                 {
                     this.enums.Dispose();
                     this.enums = null;
                 }
                 if (this.delegates != null)
                 {
                     this.delegates.Dispose();
                     this.delegates = null;
                 }
                 if (this.interfaces != null)
                 {
                     this.interfaces.Dispose();
                     this.interfaces = null;
                 }
                 if (this.structs != null)
                 {
                     this.structs.Dispose();
                     this.structs = null;
                 }
                 if (this.types != null)
                 {
                     if (this.IsRoot)
                     {
                         this.types.Dispose();
                     }
                     else
                     {
                         this.types.ConditionalRemove(this);
                     }
                     this.types = null;
                 }
                 if (this.namespaces != null)
                 {
                     this.namespaces.Dispose();
                     this.namespaces = null;
                 }
                 this.scopeCoercions = null;
             }
         }
     }
     finally
     {
         base.Dispose(disposing);
     }
 }
 /// <summary>
 /// Creates a new <see cref="IntermediateClassTypeDictionary"/> with the
 /// <paramref name="parent"/> and <paramref name="master"/> and
 /// <paramref name="root"/> provided.
 /// </summary>
 /// <param name="parent">The <see cref="IIntermediateTypeParent"/> which contains the
 /// <see cref="IntermediateClassTypeDictionary"/>.</param>
 /// <param name="master">The <see cref="IntermediateFullTypeDictionary"/>
 /// which contains the set of classes.</param>
 /// <param name="root">The <see cref="IntermediateClassTypeDictionary"/> which links
 /// multiple sets together.</param>
 public IntermediateClassTypeDictionary(IIntermediateTypeParent parent, IntermediateFullTypeDictionary master, IntermediateClassTypeDictionary root)
     : base(parent, master, root)
 {
 }