Exemplo n.º 1
0
        public void RemoveCodeCompileUnit(CodeCompileUnit codeCompileUnit)
        {
            if (codeCompileUnit == null)
            {
                throw new ArgumentNullException("codeCompileUnit");
            }
            CodeDomLoader loader = this.compileUnitLoaders[codeCompileUnit] as CodeDomLoader;

            if (loader != null)
            {
                loader.Dispose();
                this.compileUnitLoaders.Remove(codeCompileUnit);
            }
            if ((this.addedCompileUnits != null) && this.addedCompileUnits.Contains(codeCompileUnit))
            {
                this.addedCompileUnits.Remove(codeCompileUnit);
            }
            if ((this.needRefreshCompileUnits != null) && this.needRefreshCompileUnits.ContainsKey(codeCompileUnit))
            {
                this.needRefreshCompileUnits.Remove(codeCompileUnit);
            }
            if (this.typeLoadErrors.ContainsKey(codeCompileUnit))
            {
                this.typeLoadErrors.Remove(codeCompileUnit);
                if (this.TypeLoadErrorsChanged != null)
                {
                    FireEventsNoThrow(this.TypeLoadErrorsChanged, new object[] { this, EventArgs.Empty });
                }
            }
            if (this.TypesChanged != null)
            {
                FireEventsNoThrow(this.TypesChanged, new object[] { this, EventArgs.Empty });
            }
        }
 private void EnsureCurrentTypes()
 {
     if (!this.executingEnsureCurrentTypes)
     {
         try
         {
             bool flag = false;
             this.executingEnsureCurrentTypes = true;
             if (this.addedAssemblies != null)
             {
                 string[] strArray = this.addedAssemblies.ToArray();
                 this.addedAssemblies = null;
                 foreach (string str in strArray)
                 {
                     AssemblyLoader loader = null;
                     try
                     {
                         loader = new AssemblyLoader(this, str);
                         this.assemblyLoaders[str] = loader;
                     }
                     catch (Exception exception)
                     {
                         this.typeLoadErrors[str] = exception;
                         flag = true;
                     }
                 }
             }
             if (this.addedCompileUnits != null)
             {
                 CodeCompileUnit[] unitArray = this.addedCompileUnits.ToArray();
                 this.addedCompileUnits = null;
                 foreach (CodeCompileUnit unit in unitArray)
                 {
                     CodeDomLoader loader2 = null;
                     try
                     {
                         loader2 = new CodeDomLoader(this, unit);
                         this.compileUnitLoaders[unit] = loader2;
                     }
                     catch (Exception exception2)
                     {
                         if (loader2 != null)
                         {
                             loader2.Dispose();
                         }
                         this.typeLoadErrors[unit] = exception2;
                         flag = true;
                     }
                 }
             }
             if (this.needRefreshCompileUnits != null)
             {
                 Dictionary<CodeCompileUnit, EventHandler> dictionary = new Dictionary<CodeCompileUnit, EventHandler>();
                 foreach (KeyValuePair<CodeCompileUnit, EventHandler> pair in this.needRefreshCompileUnits)
                 {
                     dictionary.Add(pair.Key, pair.Value);
                 }
                 this.needRefreshCompileUnits = null;
                 foreach (KeyValuePair<CodeCompileUnit, EventHandler> pair2 in dictionary)
                 {
                     CodeDomLoader loader3 = this.compileUnitLoaders[pair2.Key] as CodeDomLoader;
                     if (loader3 != null)
                     {
                         try
                         {
                             loader3.Refresh(pair2.Value);
                         }
                         catch (Exception exception3)
                         {
                             this.typeLoadErrors[pair2.Value] = exception3;
                             flag = true;
                         }
                     }
                 }
             }
             if (flag && (this.TypeLoadErrorsChanged != null))
             {
                 FireEventsNoThrow(this.TypeLoadErrorsChanged, new object[] { this, EventArgs.Empty });
             }
         }
         finally
         {
             this.executingEnsureCurrentTypes = false;
         }
     }
 }
Exemplo n.º 3
0
        // This function could be re-entrant, so I have kept the flag to make it non-reentrant
        // I had one call stack in whcih ----eblyLoader.GetTypes() called ServiceProvider.GetService()for which
        // some one did Marshal.GetObjectForIUnknown() which caused the message pump to be executed
        // which caused EnsureCurrentTypes to be called once again.
        private void EnsureCurrentTypes()
        {
            if (this.executingEnsureCurrentTypes)
            {
                return;
            }

            try
            {
                bool hasTypeLoadErrors = false;
                this.executingEnsureCurrentTypes = true;
                if (this.addedAssemblies != null)
                {
                    // cache it to local variable
                    string[] addedAssemblies2 = this.addedAssemblies.ToArray();
                    this.addedAssemblies = null;

                    foreach (string path in addedAssemblies2)
                    {
                        AssemblyLoader loader = null;
                        try
                        {
                            loader = new AssemblyLoader(this, path);
                            this.assemblyLoaders[path] = loader;
                        }
                        catch (Exception e)
                        {
                            this.typeLoadErrors[path] = e;
                            hasTypeLoadErrors         = true;
                        }
                    }
                }

                if (this.addedCompileUnits != null)
                {
                    // cache it to local variable
                    CodeCompileUnit[] addedCompileUnits2 = this.addedCompileUnits.ToArray();
                    this.addedCompileUnits = null;

                    foreach (CodeCompileUnit codeCompileUnit in addedCompileUnits2)
                    {
                        CodeDomLoader loader = null;
                        try
                        {
                            loader = new CodeDomLoader(this, codeCompileUnit);
                            this.compileUnitLoaders[codeCompileUnit] = loader;
                        }
                        catch (Exception e)
                        {
                            // this will cause it to remove types
                            if (loader != null)
                            {
                                loader.Dispose();
                            }

                            this.typeLoadErrors[codeCompileUnit] = e;
                            hasTypeLoadErrors = true;
                        }
                    }
                }

                if (this.needRefreshCompileUnits != null)
                {
                    // cache it to local variable
                    Dictionary <CodeCompileUnit, EventHandler> needRefreshCompileUnits2 = new Dictionary <CodeCompileUnit, EventHandler>();
                    foreach (KeyValuePair <CodeCompileUnit, EventHandler> entry in this.needRefreshCompileUnits)
                    {
                        needRefreshCompileUnits2.Add(entry.Key, entry.Value);
                    }
                    this.needRefreshCompileUnits = null;

                    foreach (KeyValuePair <CodeCompileUnit, EventHandler> entry in needRefreshCompileUnits2)
                    {
                        CodeDomLoader codeDomLoader = this.compileUnitLoaders[entry.Key] as CodeDomLoader;

                        Debug.Assert(codeDomLoader != null, "How come we don't have CodeDOMLoader for the guy who needs refresh?");
                        if (codeDomLoader != null)
                        {
                            try
                            {
                                codeDomLoader.Refresh(entry.Value);
                            }
                            catch (Exception e)
                            {
                                this.typeLoadErrors[entry.Value] = e;
                                hasTypeLoadErrors = true;
                            }
                        }
                    }
                }

                if (hasTypeLoadErrors)
                {
                    if (this.TypeLoadErrorsChanged != null)
                    {
                        FireEventsNoThrow(this.TypeLoadErrorsChanged, new object[] { this, EventArgs.Empty });
                    }
                }
            }
            finally
            {
                this.executingEnsureCurrentTypes = false;
            }
        }
Exemplo n.º 4
0
        // This function could be re-entrant, so I have kept the flag to make it non-reentrant
        // I had one call stack in whcih ----eblyLoader.GetTypes() called ServiceProvider.GetService()for which
        // some one did Marshal.GetObjectForIUnknown() which caused the message pump to be executed
        // which caused EnsureCurrentTypes to be called once again.
        private void EnsureCurrentTypes()
        {
            if (this.executingEnsureCurrentTypes)
                return;

            try
            {
                bool hasTypeLoadErrors = false;
                this.executingEnsureCurrentTypes = true;
                if (this.addedAssemblies != null)
                {
                    // cache it to local variable
                    string[] addedAssemblies2 = this.addedAssemblies.ToArray();
                    this.addedAssemblies = null;

                    foreach (string path in addedAssemblies2)
                    {
                        AssemblyLoader loader = null;
                        try
                        {
                            loader = new AssemblyLoader(this, path);
                            this.assemblyLoaders[path] = loader;
                        }
                        catch (Exception e)
                        {
                            this.typeLoadErrors[path] = e;
                            hasTypeLoadErrors = true;
                        }
                    }
                }

                if (this.addedCompileUnits != null)
                {
                    // cache it to local variable
                    CodeCompileUnit[] addedCompileUnits2 = this.addedCompileUnits.ToArray();
                    this.addedCompileUnits = null;

                    foreach (CodeCompileUnit codeCompileUnit in addedCompileUnits2)
                    {
                        CodeDomLoader loader = null;
                        try
                        {
                            loader = new CodeDomLoader(this, codeCompileUnit);
                            this.compileUnitLoaders[codeCompileUnit] = loader;
                        }
                        catch (Exception e)
                        {
                            // this will cause it to remove types
                            if (loader != null)
                                loader.Dispose();

                            this.typeLoadErrors[codeCompileUnit] = e;
                            hasTypeLoadErrors = true;
                        }
                    }
                }

                if (this.needRefreshCompileUnits != null)
                {
                    // cache it to local variable
                    Dictionary<CodeCompileUnit, EventHandler> needRefreshCompileUnits2 = new Dictionary<CodeCompileUnit, EventHandler>();
                    foreach (KeyValuePair<CodeCompileUnit, EventHandler> entry in this.needRefreshCompileUnits)
                        needRefreshCompileUnits2.Add(entry.Key, entry.Value);
                    this.needRefreshCompileUnits = null;

                    foreach (KeyValuePair<CodeCompileUnit, EventHandler> entry in needRefreshCompileUnits2)
                    {
                        CodeDomLoader codeDomLoader = this.compileUnitLoaders[entry.Key] as CodeDomLoader;

                        Debug.Assert(codeDomLoader != null, "How come we don't have CodeDOMLoader for the guy who needs refresh?");
                        if (codeDomLoader != null)
                        {
                            try
                            {
                                codeDomLoader.Refresh(entry.Value);
                            }
                            catch (Exception e)
                            {
                                this.typeLoadErrors[entry.Value] = e;
                                hasTypeLoadErrors = true;
                            }
                        }
                    }
                }

                if (hasTypeLoadErrors)
                {
                    if (this.TypeLoadErrorsChanged != null)
                        FireEventsNoThrow(this.TypeLoadErrorsChanged, new object[] { this, EventArgs.Empty });
                }
            }
            finally
            {
                this.executingEnsureCurrentTypes = false;
            }
        }
Exemplo n.º 5
0
 private void EnsureCurrentTypes()
 {
     if (!this.executingEnsureCurrentTypes)
     {
         try
         {
             bool flag = false;
             this.executingEnsureCurrentTypes = true;
             if (this.addedAssemblies != null)
             {
                 string[] strArray = this.addedAssemblies.ToArray();
                 this.addedAssemblies = null;
                 foreach (string str in strArray)
                 {
                     AssemblyLoader loader = null;
                     try
                     {
                         loader = new AssemblyLoader(this, str);
                         this.assemblyLoaders[str] = loader;
                     }
                     catch (Exception exception)
                     {
                         this.typeLoadErrors[str] = exception;
                         flag = true;
                     }
                 }
             }
             if (this.addedCompileUnits != null)
             {
                 CodeCompileUnit[] unitArray = this.addedCompileUnits.ToArray();
                 this.addedCompileUnits = null;
                 foreach (CodeCompileUnit unit in unitArray)
                 {
                     CodeDomLoader loader2 = null;
                     try
                     {
                         loader2 = new CodeDomLoader(this, unit);
                         this.compileUnitLoaders[unit] = loader2;
                     }
                     catch (Exception exception2)
                     {
                         if (loader2 != null)
                         {
                             loader2.Dispose();
                         }
                         this.typeLoadErrors[unit] = exception2;
                         flag = true;
                     }
                 }
             }
             if (this.needRefreshCompileUnits != null)
             {
                 Dictionary <CodeCompileUnit, EventHandler> dictionary = new Dictionary <CodeCompileUnit, EventHandler>();
                 foreach (KeyValuePair <CodeCompileUnit, EventHandler> pair in this.needRefreshCompileUnits)
                 {
                     dictionary.Add(pair.Key, pair.Value);
                 }
                 this.needRefreshCompileUnits = null;
                 foreach (KeyValuePair <CodeCompileUnit, EventHandler> pair2 in dictionary)
                 {
                     CodeDomLoader loader3 = this.compileUnitLoaders[pair2.Key] as CodeDomLoader;
                     if (loader3 != null)
                     {
                         try
                         {
                             loader3.Refresh(pair2.Value);
                         }
                         catch (Exception exception3)
                         {
                             this.typeLoadErrors[pair2.Value] = exception3;
                             flag = true;
                         }
                     }
                 }
             }
             if (flag && (this.TypeLoadErrorsChanged != null))
             {
                 FireEventsNoThrow(this.TypeLoadErrorsChanged, new object[] { this, EventArgs.Empty });
             }
         }
         finally
         {
             this.executingEnsureCurrentTypes = false;
         }
     }
 }