C# Database.AddinScanResult类代码示例

        public AddinScanner(AddinDatabase database, AddinScanResult scanResult, IProgressStatus monitor)
        {
            this.database = database;
            if (!scanResult.CheckOnly) {

                // If there is a local copy of the cecil reflector, use it instead of the one in the gac
                Type t;
                string asmFile = Path.Combine (Path.GetDirectoryName (GetType().Assembly.Location), "Mono.Addins.CecilReflector.dll");
                if (File.Exists (asmFile)) {
                    Assembly asm = Assembly.LoadFrom (asmFile);
                    t = asm.GetType ("Mono.Addins.CecilReflector.Reflector");
                }
                else {
                    string refName = GetType().Assembly.FullName;
                    int i = refName.IndexOf (',');
                    refName = "Mono.Addins.CecilReflector.Reflector, Mono.Addins.CecilReflector" + refName.Substring (i);
                    t = Type.GetType (refName, false);
                }
                if (t != null)
                    reflector = (IAssemblyReflector) Activator.CreateInstance (t);
                else
                    reflector = new DefaultAssemblyReflector ();

                if (monitor.LogLevel > 1)
                    monitor.Log ("Using assembly reflector: " + reflector.GetType ());
                reflector.Initialize (scanResult);
                coreAssembly = reflector.LoadAssembly (GetType().Assembly.Location);
            }
        }

		public static void AddDependencies (AddinDescription desc, AddinScanResult scanResult)
		{
			// Not implemented in AddinScanResult to avoid making AddinDescription remotable
			foreach (ModuleDescription mod in desc.AllModules) {
				foreach (Dependency dep in mod.Dependencies) {
					AddinDependency adep = dep as AddinDependency;
					if (adep == null) continue;
					string depid = Addin.GetFullId (desc.Namespace, adep.AddinId, adep.Version);
					scanResult.AddAddinToUpdateRelations (depid);
				}
			}
		}

		internal void ScanFolders (IProgressStatus monitor, AddinScanResult scanResult)
		{
			IDisposable checkLock = null;
			
			if (scanResult.CheckOnly)
				checkLock = fileDatabase.LockRead ();
			else {
				// All changes are done in a transaction, which won't be committed until
				// all files have been updated.
				
				if (!fileDatabase.BeginTransaction ()) {
					// The database is already being updated. Can't do anything for now.
					return;
				}
			}
			
			EventInfo einfo = typeof(AppDomain).GetEvent ("ReflectionOnlyAssemblyResolve");
			ResolveEventHandler resolver = new ResolveEventHandler (OnResolveAddinAssembly);
			
			try
			{
				// Perform the add-in scan
				
				if (!scanResult.CheckOnly) {
					AppDomain.CurrentDomain.AssemblyResolve += resolver;
					if (einfo != null) einfo.AddEventHandler (AppDomain.CurrentDomain, resolver);
				}
				
				InternalScanFolders (monitor, scanResult);
				
				if (!scanResult.CheckOnly)
					fileDatabase.CommitTransaction ();
			}
			catch {
				if (!scanResult.CheckOnly)
					fileDatabase.RollbackTransaction ();
				throw;
			}
			finally {
				currentScanResult = null;
				
				if (scanResult.CheckOnly)
					checkLock.Dispose ();
				else {
					AppDomain.CurrentDomain.AssemblyResolve -= resolver;
					if (einfo != null) einfo.RemoveEventHandler (AppDomain.CurrentDomain, resolver);
				}
			}
		}

		public Assembly Resolve (object s, ResolveEventArgs args)
		{
			if (scanResult == null) {
				scanResult = new AddinScanResult ();
				scanResult.LocateAssembliesOnly = true;
			
				foreach (string dir in registry.AddinDirectories)
					scanner.ScanFolder (progressStatus, dir, scanResult);
			}
		
			string afile = scanResult.GetAssemblyLocation (args.Name);
			if (afile != null)
				return Util.LoadAssemblyForReflection (afile);
			else
				return null;
		}

		internal void UninstallRootAddin (IProgressStatus monitor, string addinId, string addinFile, AddinScanResult scanResult)
		{
			string file = fileDatabase.GetSharedObjectFile (AddinCachePath, addinId, ".mroot", addinFile);
			DeleteAddin (monitor, file, scanResult);
		}

        bool ScanDescription(IProgressStatus monitor, IAssemblyReflector reflector, AddinDescription config, object rootAssembly, AddinScanResult scanResult)
        {
            // First of all scan the main module

            ArrayList assemblies = new ArrayList ();

            try {
                string rootAsmFile = null;

                if (rootAssembly != null) {
                    ScanAssemblyAddinHeaders (reflector, config, rootAssembly, scanResult);
                    ScanAssemblyImports (reflector, config.MainModule, rootAssembly);
                    assemblies.Add (rootAssembly);
                    rootAsmFile = Path.GetFileName (config.AddinFile);
                }

                // The assembly list may be modified while scanning the headears, so
                // we use a for loop instead of a foreach
                for (int n=0; n<config.MainModule.Assemblies.Count; n++) {
                    string s = config.MainModule.Assemblies [n];
                    string asmFile = Path.GetFullPath (Path.Combine (config.BasePath, s));
                    scanResult.AddPathToIgnore (asmFile);
                    if (s == rootAsmFile || config.MainModule.IgnorePaths.Contains (s))
                        continue;
                    object asm = reflector.LoadAssembly (asmFile);
                    assemblies.Add (asm);
                    ScanAssemblyAddinHeaders (reflector, config, asm, scanResult);
                    ScanAssemblyImports (reflector, config.MainModule, asm);
                }

                // Add all data files to the ignore file list. It avoids scanning assemblies
                // which are included as 'data' in an add-in.
                foreach (string df in config.MainModule.DataFiles) {
                    string file = Path.Combine (config.BasePath, df);
                    scanResult.AddPathToIgnore (Path.GetFullPath (file));
                }
                foreach (string df in config.MainModule.IgnorePaths) {
                    string path = Path.Combine (config.BasePath, df);
                    scanResult.AddPathToIgnore (Path.GetFullPath (path));
                }

                // The add-in id and version must be already assigned at this point

                // Clean host data from the index. New data will be added.
                if (scanResult.HostIndex != null)
                    scanResult.HostIndex.RemoveHostData (config.AddinId, config.AddinFile);

                foreach (object asm in assemblies)
                    ScanAssemblyContents (reflector, config, config.MainModule, asm, scanResult);

            } catch (Exception ex) {
                ReportReflectionException (monitor, ex, config, scanResult);
                return false;
            }

            // Extension node types may have child nodes declared as attributes. Find them.

            Hashtable internalNodeSets = new Hashtable ();

            ArrayList setsCopy = new ArrayList ();
            setsCopy.AddRange (config.ExtensionNodeSets);
            foreach (ExtensionNodeSet eset in setsCopy)
                ScanNodeSet (reflector, config, eset, assemblies, internalNodeSets);

            foreach (ExtensionPoint ep in config.ExtensionPoints) {
                ScanNodeSet (reflector, config, ep.NodeSet, assemblies, internalNodeSets);
            }

            // Now scan all modules

            if (!config.IsRoot) {
                foreach (ModuleDescription mod in config.OptionalModules) {
                    try {
                        assemblies.Clear ();
                        for (int n=0; n<mod.Assemblies.Count; n++) {
                            string s = mod.Assemblies [n];
                            if (mod.IgnorePaths.Contains (s))
                                continue;
                            string asmFile = Path.Combine (config.BasePath, s);
                            object asm = reflector.LoadAssembly (asmFile);
                            assemblies.Add (asm);
                            scanResult.AddPathToIgnore (Path.GetFullPath (asmFile));
                            ScanAssemblyImports (reflector, mod, asm);
                        }
                        // Add all data files to the ignore file list. It avoids scanning assemblies
                        // which are included as 'data' in an add-in.
                        foreach (string df in mod.DataFiles) {
                            string file = Path.Combine (config.BasePath, df);
                            scanResult.AddPathToIgnore (Path.GetFullPath (file));
                        }
                        foreach (string df in mod.IgnorePaths) {
                            string path = Path.Combine (config.BasePath, df);
                            scanResult.AddPathToIgnore (Path.GetFullPath (path));
                        }

                        foreach (object asm in assemblies)
                            ScanAssemblyContents (reflector, config, mod, asm, scanResult);

                    } catch (Exception ex) {
                        ReportReflectionException (monitor, ex, config, scanResult);
//.........这里部分代码省略.........

        void ScanAssemblyContents(IAssemblyReflector reflector, AddinDescription config, ModuleDescription module, object asm, AddinScanResult scanResult)
        {
            bool isMainModule = module == config.MainModule;

            // Get dependencies

            object[] deps = reflector.GetCustomAttributes (asm, typeof(AddinDependencyAttribute), false);
            foreach (AddinDependencyAttribute dep in deps) {
                AddinDependency adep = new AddinDependency ();
                adep.AddinId = dep.Id;
                adep.Version = dep.Version;
                module.Dependencies.Add (adep);
            }

            if (isMainModule) {

                // Get properties

                object[] props = reflector.GetCustomAttributes (asm, typeof(AddinPropertyAttribute), false);
                foreach (AddinPropertyAttribute prop in props)
                    config.Properties.SetPropertyValue (prop.Name, prop.Value, prop.Locale);

                // Get extension points

                object[] extPoints = reflector.GetCustomAttributes (asm, typeof(ExtensionPointAttribute), false);
                foreach (ExtensionPointAttribute ext in extPoints) {
                    ExtensionPoint ep = config.AddExtensionPoint (ext.Path);
                    ep.Description = ext.Description;
                    ep.Name = ext.Name;
                    ExtensionNodeType nt = ep.AddExtensionNode (ext.NodeName, ext.NodeTypeName);
                    nt.ExtensionAttributeTypeName = ext.ExtensionAttributeTypeName;
                }
            }

            // Look for extension nodes declared using assembly attributes

            foreach (CustomAttribute att in reflector.GetRawCustomAttributes (asm, typeof(CustomExtensionAttribute), true))
                AddCustomAttributeExtension (module, att, "Type");

            // Get extensions or extension points applied to types

            foreach (object t in reflector.GetAssemblyTypes (asm)) {

                string typeFullName = reflector.GetTypeFullName (t);

                // Look for extensions

                object[] extensionAtts = reflector.GetCustomAttributes (t, typeof(ExtensionAttribute), false);
                if (extensionAtts.Length > 0) {
                    Dictionary<string,ExtensionNodeDescription> nodes = new Dictionary<string, ExtensionNodeDescription> ();
                    ExtensionNodeDescription uniqueNode = null;
                    foreach (ExtensionAttribute eatt in extensionAtts) {
                        string path;
                        string nodeName = eatt.NodeName;

                        if (eatt.TypeName.Length > 0) {
                            path = "$" + eatt.TypeName;
                        }
                        else if (eatt.Path.Length == 0) {
                            path = GetBaseTypeNameList (reflector, t);
                            if (path == "$") {
                                // The type does not implement any interface and has no superclass.
                                // Will be reported later as an error.
                                path = "$" + typeFullName;
                            }
                        } else {
                            path = eatt.Path;
                        }

                        ExtensionNodeDescription elem = module.AddExtensionNode (path, nodeName);
                        nodes [path] = elem;
                        uniqueNode = elem;

                        if (eatt.Id.Length > 0) {
                            elem.SetAttribute ("id", eatt.Id);
                            elem.SetAttribute ("type", typeFullName);
                        } else {
                            elem.SetAttribute ("id", typeFullName);
                        }
                        if (eatt.InsertAfter.Length > 0)
                            elem.SetAttribute ("insertafter", eatt.InsertAfter);
                        if (eatt.InsertBefore.Length > 0)
                            elem.SetAttribute ("insertbefore", eatt.InsertBefore);
                    }

                    // Get the node attributes

                    foreach (ExtensionAttributeAttribute eat in reflector.GetCustomAttributes (t, typeof(ExtensionAttributeAttribute), false)) {
                        ExtensionNodeDescription node;
                        if (!string.IsNullOrEmpty (eat.Path))
                            nodes.TryGetValue (eat.Path, out node);
                        else if (eat.TypeName.Length > 0)
                            nodes.TryGetValue ("$" + eat.TypeName, out node);
                        else {
                            if (nodes.Count > 1)
                                throw new Exception ("Missing type or extension path value in ExtensionAttribute for type '" + typeFullName + "'.");
                            node = uniqueNode;
                        }
                        if (node == null)
                            throw new Exception ("Invalid type or path value in ExtensionAttribute for type '" + typeFullName + "'.");
//.........这里部分代码省略.........

        void ScanAssemblyAddinHeaders(IAssemblyReflector reflector, AddinDescription config, object asm, AddinScanResult scanResult)
        {
            // Get basic add-in information
            AddinAttribute att = (AddinAttribute) reflector.GetCustomAttribute (asm, typeof(AddinAttribute), false);
            if (att != null) {
                if (att.Id.Length > 0)
                    config.LocalId = att.Id;
                if (att.Version.Length > 0)
                    config.Version = att.Version;
                if (att.Namespace.Length > 0)
                    config.Namespace = att.Namespace;
                if (att.Category.Length > 0)
                    config.Category = att.Category;
                if (att.CompatVersion.Length > 0)
                    config.CompatVersion = att.CompatVersion;
                if (att.Url.Length > 0)
                    config.Url = att.Url;
                config.IsRoot = att is AddinRootAttribute;
                config.EnabledByDefault = att.EnabledByDefault;
                config.Flags = att.Flags;
            }

            // Author attributes

            object[] atts = reflector.GetCustomAttributes (asm, typeof(AddinAuthorAttribute), false);
            foreach (AddinAuthorAttribute author in atts) {
                if (config.Author.Length == 0)
                    config.Author = author.Name;
                else
                    config.Author += ", " + author.Name;
            }

            // Name

            atts = reflector.GetCustomAttributes (asm, typeof(AddinNameAttribute), false);
            foreach (AddinNameAttribute at in atts) {
                if (string.IsNullOrEmpty (at.Locale))
                    config.Name = at.Name;
                else
                    config.Properties.SetPropertyValue ("Name", at.Name, at.Locale);
            }

            // Description

            object catt = reflector.GetCustomAttribute (asm, typeof(AssemblyDescriptionAttribute), false);
            if (catt != null && config.Description.Length == 0)
                config.Description = ((AssemblyDescriptionAttribute)catt).Description;

            atts = reflector.GetCustomAttributes (asm, typeof(AddinDescriptionAttribute), false);
            foreach (AddinDescriptionAttribute at in atts) {
                if (string.IsNullOrEmpty (at.Locale))
                    config.Description = at.Description;
                else
                    config.Properties.SetPropertyValue ("Description", at.Description, at.Locale);
            }

            // Copyright

            catt = reflector.GetCustomAttribute (asm, typeof(AssemblyCopyrightAttribute), false);
            if (catt != null && config.Copyright.Length == 0)
                config.Copyright = ((AssemblyCopyrightAttribute)catt).Copyright;

            // Localizer

            AddinLocalizerGettextAttribute locat = (AddinLocalizerGettextAttribute) reflector.GetCustomAttribute (asm, typeof(AddinLocalizerGettextAttribute), false);
            if (locat != null) {
                ExtensionNodeDescription node = new ExtensionNodeDescription ();
                if (!string.IsNullOrEmpty (locat.Catalog))
                    node.SetAttribute ("catalog", locat.Catalog);
                if (!string.IsNullOrEmpty (locat.Location))
                    node.SetAttribute ("location", locat.Catalog);
                config.Localizer = node;
            }

            // Optional modules

            atts = reflector.GetCustomAttributes (asm, typeof(AddinModuleAttribute), false);
            foreach (AddinModuleAttribute mod in atts) {
                if (mod.AssemblyFile.Length > 0) {
                    ModuleDescription module = new ModuleDescription ();
                    module.Assemblies.Add (mod.AssemblyFile);
                    config.OptionalModules.Add (module);
                }
            }
        }

        public void ScanFile(IProgressStatus monitor, string file, AddinScanFolderInfo folderInfo, AddinScanResult scanResult)
        {
            if (scanResult.IgnorePath (file)) {
                // The file must be ignored. Maybe it caused a crash in a previous scan, or it
                // might be included by a .addin file (in which case it will be scanned when processing
                // the .addin file).
                folderInfo.SetLastScanTime (file, null, false, fs.GetLastWriteTime (file), true);
                return;
            }

            if (monitor.LogLevel > 1)
                monitor.Log ("Scanning file: " + file);

            // Log the file to be scanned, so in case of a process crash the main process
            // will know what crashed
            monitor.Log ("plog:scan:" + file);

            string scannedAddinId = null;
            bool scannedIsRoot = false;
            bool scanSuccessful = false;
            AddinDescription config = null;

            try {
                string ext = Path.GetExtension (file).ToLower ();

                if (ext == ".dll" || ext == ".exe")
                    scanSuccessful = ScanAssembly (monitor, file, scanResult, out config);
                else
                    scanSuccessful = ScanConfigAssemblies (monitor, file, scanResult, out config);

                if (config != null) {

                    AddinFileInfo fi = folderInfo.GetAddinFileInfo (file);

                    // If version is not specified, make up one
                    if (config.Version.Length == 0) {
                        config.Version = "0.0.0.0";
                    }

                    if (config.LocalId.Length == 0) {
                        // Generate an internal id for this add-in
                        config.LocalId = database.GetUniqueAddinId (file, (fi != null ? fi.AddinId : null), config.Namespace, config.Version);
                        config.HasUserId = false;
                    }

                    // Check errors in the description
                    StringCollection errors = config.Verify (fs);

                    if (database.IsGlobalRegistry && config.AddinId.IndexOf ('.') == -1) {
                        errors.Add ("Add-ins registered in the global registry must have a namespace.");
                    }

                    if (errors.Count > 0) {
                        scanSuccessful = false;
                        monitor.ReportError ("Errors found in add-in '" + file + ":", null);
                        foreach (string err in errors)
                            monitor.ReportError (err, null);
                    }

                    // Make sure all extensions sets are initialized with the correct add-in id

                    config.SetExtensionsAddinId (config.AddinId);

                    scanResult.ChangesFound = true;

                    // If the add-in already existed, try to reuse the relation data it had.
                    // Also, the dependencies of the old add-in need to be re-analized

                    AddinDescription existingDescription = null;
                    bool res = database.GetAddinDescription (monitor, folderInfo.Domain, config.AddinId, config.AddinFile, out existingDescription);

                    // If we can't get information about the old assembly, just regenerate all relation data
                    if (!res)
                        scanResult.RegenerateRelationData = true;

                    string replaceFileName = null;

                    if (existingDescription != null) {
                        // Reuse old relation data
                        config.MergeExternalData (existingDescription);
                        Util.AddDependencies (existingDescription, scanResult);
                        replaceFileName = existingDescription.FileName;
                    }

                    // If the scanned file results in an add-in version different from the one obtained from
                    // previous scans, the old add-in needs to be uninstalled.
                    if (fi != null && fi.IsAddin && fi.AddinId != config.AddinId) {
                        database.UninstallAddin (monitor, folderInfo.Domain, fi.AddinId, fi.File, scanResult);

                        // If the add-in version has changed, regenerate everything again since old data can't be reused
                        if (Addin.GetIdName (fi.AddinId) == Addin.GetIdName (config.AddinId))
                            scanResult.RegenerateRelationData = true;
                    }

                    // If a description could be generated, save it now (if the scan was successful)
                    if (scanSuccessful) {

                        // Assign the domain
                        if (config.IsRoot) {
                            if (folderInfo.RootsDomain == null) {
//.........这里部分代码省略.........

        internal void UninstallAddin(IProgressStatus monitor, string domain, string addinId, string addinFile, AddinScanResult scanResult)
        {
            AddinDescription desc;

            if (!GetAddinDescription (monitor, domain, addinId, addinFile, out desc)) {
                // If we can't get information about the old assembly, just regenerate all relation data
                scanResult.RegenerateRelationData = true;
                return;
            }

            scanResult.AddRemovedAddin (addinId);

            // If the add-in didn't exist, there is nothing left to do

            if (desc == null)
                return;

            // If the add-in already existed, the dependencies of the old add-in need to be re-analyzed

            Util.AddDependencies (desc, scanResult);
            if (desc.IsRoot)
                scanResult.HostIndex.RemoveHostData (desc.AddinId, desc.AddinFile);

            RemoveAddinDescriptionFile (monitor, desc.FileName);
        }

 internal void ScanFolders(IProgressStatus monitor, string currentDomain, string folderToScan, StringCollection filesToIgnore)
 {
     AddinScanResult res = new AddinScanResult ();
     res.Domain = currentDomain;
     res.AddPathsToIgnore (filesToIgnore);
     ScanFolders (monitor, res);
 }

        public void ParseAddin(IProgressStatus progressStatus, string domain, string file, string outFile, bool inProcess)
        {
            if (!inProcess) {
                ISetupHandler setup = GetSetupHandler ();
                setup.GetAddinDescription (progressStatus, registry, Path.GetFullPath (file), outFile);
                return;
            }

            using (fileDatabase.LockRead ())
            {
                // First of all, check if the file belongs to a registered add-in
                AddinScanFolderInfo finfo;
                if (GetFolderInfoForPath (progressStatus, Path.GetDirectoryName (file), out finfo) && finfo != null) {
                    AddinFileInfo afi = finfo.GetAddinFileInfo (file);
                    if (afi != null && afi.IsAddin) {
                        AddinDescription adesc;
                        GetAddinDescription (progressStatus, afi.Domain, afi.AddinId, file, out adesc);
                        if (adesc != null)
                            adesc.Save (outFile);
                        return;
                    }
                }

                AddinScanResult sr = new AddinScanResult ();
                sr.Domain = domain;
                AddinScanner scanner = new AddinScanner (this, sr, progressStatus);

                SingleFileAssemblyResolver res = new SingleFileAssemblyResolver (progressStatus, registry, scanner);
                ResolveEventHandler resolver = new ResolveEventHandler (res.Resolve);

                EventInfo einfo = typeof(AppDomain).GetEvent ("ReflectionOnlyAssemblyResolve");

                try {
                    AppDomain.CurrentDomain.AssemblyResolve += resolver;
                    if (einfo != null) einfo.AddEventHandler (AppDomain.CurrentDomain, resolver);

                    AddinDescription desc = scanner.ScanSingleFile (progressStatus, file, sr);
                    if (desc != null) {
                        // Reset the xml doc so that it is not reused when saving. We want a brand new document
                        desc.ResetXmlDoc ();
                        desc.Save (outFile);
                    }
                }
                finally {
                    AppDomain.CurrentDomain.AssemblyResolve -= resolver;
                    if (einfo != null) einfo.RemoveEventHandler (AppDomain.CurrentDomain, resolver);
                }
            }
        }

 void InternalScanFolders(IProgressStatus monitor, AddinScanResult scanResult)
 {
     try {
         fs.ScanStarted ();
         InternalScanFolders2 (monitor, scanResult);
     } finally {
         fs.ScanFinished ();
     }
 }

		bool ScanSubmodule (IProgressStatus monitor, ModuleDescription mod, IAssemblyReflector reflector, AddinDescription config, AddinScanResult scanResult, string assemblyName, object asm)
		{
			AddinDescription mconfig;
			ScanEmbeddedDescription (monitor, assemblyName, reflector, asm, out mconfig);
			if (mconfig != null) {
				if (!mconfig.IsExtensionModel) {
					monitor.ReportError ("Submodules can't define new add-ins: " + assemblyName, null);
					return false;
				}
				if (mconfig.OptionalModules.Count != 0) {
					monitor.ReportError ("Submodules can't define nested submodules: " + assemblyName, null);
					return false;
				}
				if (mconfig.ConditionTypes.Count != 0) {
					monitor.ReportError ("Submodules can't define condition types: " + assemblyName, null);
					return false;
				}
				if (mconfig.ExtensionNodeSets.Count != 0) {
					monitor.ReportError ("Submodules can't define extension node sets: " + assemblyName, null);
					return false;
				}
				if (mconfig.ExtensionPoints.Count != 0) {
					monitor.ReportError ("Submodules can't define extension points sets: " + assemblyName, null);
					return false;
				}
				mod.MergeWith (mconfig.MainModule);
			}
			ScanAssemblyContents (reflector, config, mod, asm, scanResult);
			return true;
		}

		bool ScanAssembly (IProgressStatus monitor, string filePath, AddinScanResult scanResult, out AddinDescription config)
		{
			config = null;
				
			try {
				IAssemblyReflector reflector = GetReflector (monitor, scanResult, filePath);
				object asm = reflector.LoadAssembly (filePath);
				if (asm == null)
					throw new Exception ("Could not load assembly: " + filePath);
				
				// Get the config file from the resources, if there is one
				
				if (!ScanEmbeddedDescription (monitor, filePath, reflector, asm, out config))
					return false;
				
				if (config == null || config.IsExtensionModel) {
					// In this case, only scan the assembly if it has the Addin attribute.
					AddinAttribute att = (AddinAttribute) reflector.GetCustomAttribute (asm, typeof(AddinAttribute), false);
					if (att == null) {
						config = null;
						return true;
					}

					if (config == null)
						config = new AddinDescription ();
				}
				
				config.SetBasePath (Path.GetDirectoryName (filePath));
				config.AddinFile = filePath;
				
				string rasmFile = Path.GetFileName (filePath);
				if (!config.MainModule.Assemblies.Contains (rasmFile))
					config.MainModule.Assemblies.Add (rasmFile);
				
				return ScanDescription (monitor, reflector, config, asm, scanResult);
			}
			catch (Exception ex) {
				// Something went wrong while scanning the assembly. We'll ignore it for now.
				monitor.ReportError ("There was an error while scanning assembly: " + filePath, ex);
				return false;
			}
		}