Пример #1
0
        /// <summary>
        /// Saves the project content to the stream.
        /// </summary>
        public static void WriteProjectContent(ReflectionProjectContent pc, Stream stream)
        {
            BinaryWriter writer = new BinaryWriter(stream);

            new ReadWriteHelper(writer).WriteProjectContent(pc);
            // do not close the stream
        }
Пример #2
0
        public virtual IProjectContent GetProjectContentForReference(string itemInclude, string itemFileName)
        {
            lock (_contents)
            {
                IProjectContent pc = GetExistingProjectContent(itemInclude, itemFileName);
                if (pc != null)
                {
                    return(pc);
                }

                LoggingService.Debug("Loading PC for " + itemInclude);

                string shortName = itemInclude;
                int    pos       = shortName.IndexOf(',');
                if (pos > 0)
                {
                    shortName = shortName.Substring(0, pos);
                }

                HostCallback.BeginAssemblyLoad(shortName);
#if DEBUG
                int time = Environment.TickCount;
#endif

                try
                {
                    pc = LoadProjectContent(itemInclude, itemFileName);
                }
                catch (Exception ex)
                {
                    HostCallback.ShowAssemblyLoadErrorInternal(itemFileName, itemInclude, "Error loading assembly:\n" + ex.ToString());
                    throw ex;
                }
                finally
                {
#if DEBUG
                    LoggingService.Debug(string.Format("Loaded {0} in {1}ms", itemInclude, Environment.TickCount - time));
#endif
                    HostCallback.FinishAssemblyLoad();
                }

                if (pc != null)
                {
                    ReflectionProjectContent reflectionProjectContent = pc as ReflectionProjectContent;
                    if (reflectionProjectContent != null && reflectionProjectContent.AssemblyFullName != null)
                    {
                        _contents[reflectionProjectContent.AssemblyFullName] = pc;
                    }
                    _contents[itemInclude]  = pc;
                    _contents[itemFileName] = pc;
                }
                return(pc);
            }
        }
Пример #3
0
        public string SaveProjectContent(ReflectionProjectContent pc)
        {
            string assemblyFullName = pc.AssemblyFullName;
            int    pos      = assemblyFullName.IndexOf(',');
            string fileName = Path.Combine(cacheDirectory,
                                           assemblyFullName.Substring(0, pos)
                                           + "." + assemblyFullName.GetHashCode().ToString("x", CultureInfo.InvariantCulture)
                                           + "." + pc.AssemblyLocation.GetHashCode().ToString("x", CultureInfo.InvariantCulture)
                                           + ".dat");

            AddFileNameToCacheIndex(Path.GetFileName(fileName), pc);
            using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write)) {
                WriteProjectContent(pc, fs);
            }
            return(fileName);
        }
Пример #4
0
            public ReflectionProjectContent ReadProjectContent(ProjectContentRegistry registry)
            {
                if (_reader.ReadInt64() != FileMagic)
                {
                    LoggingService.Warn("Read dom: wrong magic");
                    return(null);
                }
                if (_reader.ReadInt16() != FileVersion)
                {
                    LoggingService.Warn("Read dom: wrong version");
                    return(null);
                }
                string assemblyName     = _reader.ReadString();
                string assemblyLocation = _reader.ReadString();
                long   time             = 0;

                try
                {
                    time = File.GetLastWriteTimeUtc(assemblyLocation).ToFileTime();
                }
                catch { }
                if (_reader.ReadInt64() != time)
                {
                    LoggingService.Warn("Read dom: assembly changed since cache was created");
                    return(null);
                }
                DomAssemblyName[] referencedAssemblies = new DomAssemblyName[_reader.ReadInt32()];
                for (int i = 0; i < referencedAssemblies.Length; i++)
                {
                    referencedAssemblies[i] = new DomAssemblyName(_reader.ReadString());
                }
                _pc = new ReflectionProjectContent(assemblyName, assemblyLocation, referencedAssemblies, registry);
                if (ReadClasses())
                {
                    return(_pc);
                }
                else
                {
                    LoggingService.Warn("Read dom: error in file (invalid control mark)");
                    return(null);
                }
            }
Пример #5
0
            public void WriteProjectContent(ReflectionProjectContent pc)
            {
                this.pc = pc;
                writer.Write(FileMagic);
                writer.Write(FileVersion);
                writer.Write(pc.AssemblyFullName);
                writer.Write(pc.AssemblyLocation);
                long time = 0;

                try {
                    time = File.GetLastWriteTimeUtc(pc.AssemblyLocation).ToFileTime();
                } catch {}
                writer.Write(time);
                writer.Write(pc.ReferencedAssemblyNames.Count);
                foreach (DomAssemblyName name in pc.ReferencedAssemblyNames)
                {
                    writer.Write(name.FullName);
                }
                WriteClasses();
            }
Пример #6
0
 public string LoadAndCreateDatabase(string fileName, string include, string cacheDirectory)
 {
     try {
         ReflectionProjectContent content = LoadProjectContent(fileName, include, new ProjectContentRegistry());
         if (content == null)
         {
             return(null);
         }
         return(new DomPersistence(cacheDirectory, null).SaveProjectContent(content));
     } catch (Exception ex) {
         if (ex is FileLoadException)
         {
             LoggingService.Info(ex);
         }
         else
         {
             LoggingService.Error(ex);
         }
         throw;
     }
 }
Пример #7
0
        private void AddFileNameToCacheIndex(string cacheFile, ReflectionProjectContent pc)
        {
            Dictionary <string, string> l = LoadCacheIndex();

            l[pc.AssemblyLocation] = cacheFile;
            string txt = pc.AssemblyFullName;

            l[txt] = cacheFile;
            int pos = txt.LastIndexOf(',');

            do
            {
                txt = txt.Substring(0, pos);
                if (l.ContainsKey(txt))
                {
                    break;
                }
                l[txt] = cacheFile;
                pos    = txt.LastIndexOf(',');
            } while (pos >= 0);
            SaveCacheIndex(l);
            _cacheIndex = l;
        }
        /// <summary>
        /// Load a project content using Reflection in a separate AppDomain.
        /// This method first tries to load the assembly from the disk cache, if it exists there.
        /// If it does not exist in disk cache, it creates a new AppDomain, instanciates a ReflectionLoader in it
        /// and loads the assembly <paramref name="filename"/>.
        /// If the file does not exist, <paramref name="include"/> is loaded from GAC.
        /// </summary>
        protected ReflectionProjectContent ReflectionLoadProjectContent(string filename, string include)
        {
            DomPersistence persistence;
            bool           tempPersistence;

            if (this.persistence == null)
            {
                tempPersistence = true;
                persistence     = new DomPersistence(Path.GetTempPath(), this);
            }
            else
            {
                // non-temp persistence
                tempPersistence = false;
                persistence     = this.persistence;

                ReflectionProjectContent pc = persistence.LoadProjectContentByAssemblyName(filename);
                if (pc != null)
                {
                    return(pc);
                }
                pc = persistence.LoadProjectContentByAssemblyName(include);
                if (pc != null)
                {
                    return(pc);
                }
            }

            AppDomainSetup setup = new AppDomainSetup();

            setup.DisallowCodeDownload = true;
            setup.ApplicationBase      = AppDomain.CurrentDomain.BaseDirectory;
            AppDomain domain = AppDomain.CreateDomain("AssemblyLoadingDomain", AppDomain.CurrentDomain.Evidence, setup);

            string database;

            try {
                object           o      = domain.CreateInstanceAndUnwrap(typeof(ReflectionLoader).Assembly.FullName, typeof(ReflectionLoader).FullName);
                ReflectionLoader loader = (ReflectionLoader)o;
                database = loader.LoadAndCreateDatabase(filename, include, persistence.CacheDirectory);
            } catch (FileLoadException e) {
                database = null;
                HostCallback.ShowAssemblyLoadErrorInternal(filename, include, e.Message);
            } catch (Exception e) {
                database = null;
                HostCallback.ShowError("Error loading code-completion information for " + include + " from " + filename, e);
                throw e;
            } finally {
                AppDomain.Unload(domain);
            }
            if (database == null)
            {
                LoggingService.Debug("AppDomain finished but returned null...");
                return(null);
            }
            else
            {
                LoggingService.Debug("AppDomain finished, loading cache...");
                try {
                    return(persistence.LoadProjectContent(database));
                } finally {
                    if (tempPersistence)
                    {
                        try {
                            File.Delete(database);
                        } catch {}
                    }
                }
            }
        }
        protected virtual IProjectContent LoadProjectContent(string itemInclude, string itemFileName)
        {
            string shortName = itemInclude;
            int    pos       = shortName.IndexOf(',');

            if (pos > 0)
            {
                shortName = shortName.Substring(0, pos);
            }

            Assembly assembly = GetDefaultAssembly(shortName);

            ReflectionProjectContent pc = null;

            if (assembly != null)
            {
                if (persistence != null)
                {
                    pc = persistence.LoadProjectContentByAssemblyName(assembly.FullName);
                }
                if (pc == null)
                {
                    pc = new ReflectionProjectContent(assembly, this);
                    if (persistence != null)
                    {
                        persistence.SaveProjectContent(pc);
                    }
                }
                if (pc != null)
                {
                    // add default .NET assemblies to redirected assemblies (both when loaded from persistence
                    // and when loaded using Reflection)
                    lock (redirectedAssemblyNames)
                    {
                        redirectedAssemblyNames[shortName] = pc.AssemblyFullName;
                    }
                }
            }
            else
            {
                if (pc == null)
                {
                    pc = ReflectionLoadProjectContent(itemFileName, itemInclude);
                }
                // find real file name for cecil:
                //if (File.Exists(itemFileName)) {
                //    pc = CecilReader.LoadAssembly(itemFileName, this);
                //} else {
                //    GacAssemblyName asmName = GacInterop.FindBestMatchingAssemblyName(itemInclude);
                //    if (persistence != null && asmName != null) {
                //        //LoggingService.Debug("Looking up in DOM cache: " + asmName.FullName);
                //        pc = persistence.LoadProjectContentByAssemblyName(asmName.FullName);
                //    }
                //    if (pc == null && asmName != null) {
                //        string subPath = Path.Combine(asmName.Name, GetVersion__Token(asmName));
                //        subPath = Path.Combine(subPath, asmName.Name + ".dll");
                //        foreach (string dir in Directory.GetDirectories(GacInterop.GacRootPath, "GAC*")) {
                //            itemFileName = Path.Combine(dir, subPath);
                //            if (File.Exists(itemFileName)) {
                //                pc = CecilReader.LoadAssembly(itemFileName, this);
                //                if (persistence != null) {
                //                    persistence.SaveProjectContent(pc);
                //                }
                //                break;
                //            }
                //        }
                //    }
                //    if (pc == null) {
                //        HostCallback.ShowAssemblyLoadErrorInternal("?", itemInclude, "Could not find assembly file.");
                //    }
                //}
            }
            return(pc);
        }