MEF用到的Class（万一用到MEF框架，可以参考）

MEF.cs

using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Data;
using System.Linq;
using System.Xml.Linq;
using Aspose.Cells;

namespace Interface
{
    public class MEF
    {
        private static MEF _simpleMef;

        public static MEF GetSimpleMef(string pathMEF)
        {
            return _simpleMef ?? (_simpleMef = new MEF(pathMEF));
        }

        private MEF(string pathMEF)
        {
            this.ComposePartsSelf(pathMEF);
        }

        [ImportMany]
        private IEnumerable<Lazy<IExcuteGetTable, IMeteData>> ExcuteGetTables;

        [ImportMany]
        private IEnumerable<Lazy<IExcute, IMeteData>> Excutes;

        [ImportMany]
        private IEnumerable<Lazy<IExcuteTxt, IMeteData>> ExcutesTxt;

        [ImportMany]
        private IEnumerable<Lazy<IFindFile, IMeteData>> FindFiles;

        [ImportMany]
        private IEnumerable<Lazy<IExcuteSql, IMeteData>> ExcuteSqls;

        [ImportMany]
        private IEnumerable<Lazy<IExcuteCells, IMeteData>> ExcuteCells;

        [ImportMany]
        private IEnumerable<Lazy<IExcuteTitle, IMeteData>> ExcuteTitles;

        [ImportMany]
        private IEnumerable<Lazy<ISaveData, IMeteData>> SaveDatas;

        [ImportMany]
        private IEnumerable<Lazy<IExcuteDataTable, IMeteData>> ExcuteDataTables;

        public DataTable ExcuteDataTable(string operation, Cells cells, XElement xElement)
        {
            return ExcuteDataTables.Where(i => i.Metadata.Symbol.Equals(operation)).Select(i => i.Value.ReturnData(cells, xElement)).FirstOrDefault();
        }

        private object Excute(string operation, Cells cells, XElement xElement)
        {
            foreach (var i in Excutes.Where(i => i.Metadata.Symbol.Equals(operation)))
            {
                return i.Value.ReturnData(cells, xElement);
            }
            return "";
        }

        public object[] SaveData(string operation, DataTable datable, string createdId)
        {
            return SaveDatas.Where(i => i.Metadata.Symbol.Equals(operation)).Select(i => i.Value.InsertData(datable, createdId)).FirstOrDefault();
        }

        public DataTable ExcuteQuery(string operation, string strSql)
        {
            return ExcuteSqls.Where(i => i.Metadata.Symbol.Equals(operation)).Select(i => i.Value.ExcuteQuery(strSql)).FirstOrDefault();
        }
        
        public List<string> FindFile(string operation, DateTime dateTime, int interval, XElement xElement)
        {
            return FindFiles.Where(i => i.Metadata.Symbol.Equals(operation)).Select(i => i.Value.FindFile(xElement, dateTime, interval) as List<string>).FirstOrDefault();
        }

        public void ExcuteCell(string operation, Cells cells, XElement xElement)
        {
            foreach (var cell in ExcuteCells.Where(cell => cell.Metadata.Symbol.Equals(operation)))
            {
                cell.Value.ReturnData(cells, xElement);
                break;
            }
        }

        private object ExcuteSql(string operation, XElement xElement, List<object> matchs)
        {
            foreach (var i in ExcuteSqls.Where(i => i.Metadata.Symbol.Equals(operation)))
            {
                return i.Value.ReturnData(xElement, matchs);
            }
            return "";
        }

        private object ExcuteTitle(string operation, string title, XElement xElement)
        {
            foreach (var i in ExcuteTitles.Where(i => i.Metadata.Symbol.Equals(operation)))
            {
                return i.Value.ReturnData(title, xElement);
            }
            return "";
        }

        public string Excute(string type, string operation, XElement xElement, string title = "", Cells cells = null, List<object> matchs = null)
        {
            if (type.Equals("数据库"))
                return ExcuteSql(operation, xElement, matchs).ToString();
            if (type.Equals("文本") )
            {
                var node = from e1 in xElement.Descendants("Type")
                           select e1;
                foreach (var element in node)
                {
                    string value = Excute(element.Attribute("DllName").Value, cells, element).ToString();
                    if (!string.IsNullOrEmpty(value))
                        return value;
                } 
                return string.Empty;
            }

          

            #region  8-23 单独处理

            if (type.Equals("组合"))
            {
                var node = from e1 in xElement.Descendants("Type")
                           select e1;
                foreach (var element in node)
                {
                    string value = Excute(element.Attribute("DllName").Value, cells, element).ToString();
                  
                    if (!string.IsNullOrEmpty(value))
                        return value;
                }
                return string.Empty;                            
            }

            if (type.Equals("先决") || type.Equals("依赖"))
            {
                var node = from e1 in xElement.Descendants("Type")
                           select e1;
                foreach (var element in node)
                {
                    string value = Excute(element.Attribute("DllName").Value, cells, element).ToString();
                    if (!string.IsNullOrEmpty(value))
                        return value;
                }
                return string.Empty;   
            }
            #endregion

            return ExcuteTitle(operation, title, xElement).ToString();
        }

        /// <summary>
        /// 表格处理
        /// </summary>
        /// <param name="operation"></param>
        /// <param name="cells"></param>
        /// <param name="xElement"></param>
        /// <returns></returns>
        public DataTable ExcuteGetTable(string operation, Cells cells, XElement xElement, string type, string longStr, string logPath)
        {
            foreach (var i in ExcuteGetTables.Where(i => i.Metadata.Symbol.Equals(operation)))
            {
                return i.Value.ReturnData(cells, xElement, type, longStr, logPath) as DataTable;
            }          
            return null; 
        }
        public DataTable ExcuteTable(string type, string operation, XElement xElement, string longStr, string logPath,string title = "", Cells cells = null, List<object> matchs = null)
        {
            var node = from e1 in xElement.Descendants("Type")
                       select e1;
            foreach (var element in node)
            {
                return ExcuteGetTable(element.Attribute("DllName").Value, cells, element, title, longStr, logPath);
            } 
            return null;
        } 

        #region  txt 文本处理

        public string ExcuteT(string type, string operation, XElement xElement, string title = "", string longStr = null, List<object> matchs = null)
        {
            var node = from e1 in xElement.Descendants("Type")
                       select e1;
            foreach (var element in node)
            {
                string value = ExcuteTxt(element.Attribute("DllName").Value, longStr, element).ToString();
                if (!string.IsNullOrEmpty(value))
                    return value;
            }
            return string.Empty;
        }


        public object ExcuteTxt(string operation, string longTxt, XElement xElement)
        {
            foreach (var i in ExcutesTxt.Where(i => i.Metadata.Symbol.Equals(operation)))
            {
                return i.Value.ReturnTxtData(longTxt, xElement);
            }
            return "";
        }
        #endregion
    }
}

MefIntance.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Xml.Linq;
using Aspose.Cells;

namespace Interface
{
    /// <summary>
    /// 查找文件
    /// </summary>
    public interface IFindFile
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="element">xml配置参数</param>
        /// <param name="startTime">开始日期</param>
        /// <param name="inteval">间隔日期</param>
        /// <returns>文件列表</returns>
        List<string> FindFile(XElement element, DateTime startTime, int inteval);
    }

    /// <summary>
    /// 查询数据库
    /// </summary>
    public interface IExcuteSql
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="element">xml配置参数</param>
        /// <param name="matchs">匹配项的值</param>
        /// <returns>一般来说都是string</returns>
        object ReturnData(XElement element, List<object> matchs);


        DataTable ExcuteQuery(string strsql);       
    }

    /// <summary>
    /// 文本匹配
    /// </summary>
    public interface IExcute
    {
        /// <summary>
        /// 需要aspose.cell.dll
        /// </summary>
        /// <param name="cells">cell集合</param>
        /// <param name="element">xml配置参数</param>
        object ReturnData(Cells cells, XElement element);
        //object ReturnTxtData(string str, XElement element);
    }

    /// <summary>
    /// txt 文本匹配
    /// </summary>
    public interface IExcuteTxt
    {
        /// <summary>
        /// 需要aspose.cell.dll
        /// </summary>
        /// <param name="cells">cell集合</param>
        /// <param name="element">xml配置参数</param>
       
        object ReturnTxtData(string str, XElement element);
    }
    
    public interface IExcuteGetTable
    { 
        /// <summary>
        /// 需要aspose.cell.dll
        /// </summary>
        /// <param name="cells">cell集合</param>
        /// <param name="element">xml配置参数</param>
        
        //object ReturnData(Cells cells, XElement element); 
        object ReturnData(Cells cells, XElement element, string type, string longstr, string logPath); 

    }


    /// <summary>
    /// 筛选excel
    /// </summary>
    public interface IExcuteCells
    {
        /// <summary>
        /// 需要aspose.cell.dll
        /// </summary>
        /// <param name="cells">cell集合</param>
        /// <param name="element">xml配置参数</param>
        void ReturnData(Cells cells, XElement element);
    }

    /// <summary>
    /// 分析文件名
    /// </summary>
    public interface IExcuteTitle
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="title">文件名</param>
        /// <param name="element">xml配置参数</param>
        /// <returns></returns>
        string ReturnData(string title, XElement element);
    }

    /// <summary>
    /// 保存数据
    /// </summary>
    public interface ISaveData
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="dataTable">要保存的数据</param>
        /// <returns>返回保存不成功的数据</returns>
        object[] InsertData(DataTable dataTable, string createdId);
    }

    /// <summary>
    /// 一对多模型,定制
    /// </summary>
    public interface IExcuteDataTable
    {
        DataTable ReturnData(Cells cells, XElement element);
    }

    /// <summary>
    /// 获取解析dll的元数据信息
    /// </summary>
    public interface IMeteData
    {
        string Symbol { get; }
    }

}

ObjectExt.cs

using System;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.IO;
using System.Reflection;

namespace Interface
{
    public static class ObjectExt
    {
        public static T ComposePartsSelf<T>(this T obj, string pathMEF) where T : class
        {
            var catalog = new AggregateCatalog();
            catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
            //catalog.Catalogs.Add(new DirectoryCatalog(Assembly.GetExecutingAssembly().Location.Replace(Assembly.GetExecutingAssembly().ManifestModule.Name, "")));
            //catalog.Catalogs.Add(new DirectoryCatalog(@"D:\新建文件夹\PDF"));
            // catalog.Catalogs.Add(new DirectoryCatalog(@"E:\DataDnalyze V1.0\04.安装部署\Modules\16.其他\04.scb0292_股东定期报告解析\PDF"));
            //  string path = @"E:\DataDnalyze V1.0\04.安装部署\Modules\16.其他\04.scb0292_股东定期报告解析\PDF";
            Util.CreateFolder(pathMEF);
            catalog.Catalogs.Add(new DirectoryCatalog(pathMEF));
            var _container = new CompositionContainer(catalog);
            try
            {
                _container.ComposeParts(obj);
            }
            catch (Exception ex)
            {

            }
            return obj;
        }
    }
}