Revit二次开发小技巧（十三）共享参数操作封装类

共享参数操作

自己封装的一个共享参数操作类，分享出来，希望可以对你有所帮助~~~

 public class ShareParameterMethod
    {
        /// <summary>
        /// 文件保存路径
        /// </summary>
        private string DataPath = "";
        /// <summary>
        /// 参数组集合
        /// </summary>
        public List<DefinitionGroup> ShareGroupList { get; private set; } = new List<DefinitionGroup>();
        /// <summary>
        /// 共享参数文件夹类
        /// </summary>
        private DefinitionFile SharedParametersFile = null;
        /// <summary>
        /// 项目doc
        /// </summary>
        private Document Doc;
        /// <summary>
        /// 错误信息
        /// </summary>
        public string ErrorMessage { get; set; } = "";



        public ShareParameterMethod(Document doc, string dataName)
        {
            DataPath = $@"C:\ProgramData\Autodesk\Revit\Addins\ShareParameterFiles\{dataName}.txt";
            if (!File.Exists(DataPath))
            {
                FileInfo fileInfo = new FileInfo(DataPath);
                if (!File.Exists(fileInfo.DirectoryName))
                    fileInfo.Directory.Create();
                File.Create(DataPath);
            }
            doc.Application.SharedParametersFilename = DataPath;
            SharedParametersFile = doc.Application.OpenSharedParameterFile();
            ShareGroupList = SharedParametersFile.Groups.ToList();
            if (ShareGroupList == null)
            {
                ShareGroupList = new List<DefinitionGroup>();
            }
            Doc = doc;
        }
        /// <summary>
        /// 修改路径
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public bool ChangePath(string path)
        {
            try
            {
                DataPath = path;
                if (!File.Exists(DataPath))
                {
                    FileInfo fileInfo = new FileInfo(DataPath);
                    fileInfo.Directory.Create();
                    File.Create(DataPath);
                }
                Doc.Application.SharedParametersFilename = DataPath;
                SharedParametersFile = Doc.Application.OpenSharedParameterFile();
                ShareGroupList = SharedParametersFile.Groups.ToList();
                if (ShareGroupList == null)
                {
                    ShareGroupList = new List<DefinitionGroup>();
                }
                return true;
            }
            catch (Exception ex)
            {
                ErrorMessage += $"路径替换失败\r{ex.Message}\t{ex.StackTrace}\r";
                return false;
            }

        }
        /// <summary>
        /// 添加一个共享参数组
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public bool AddGroup(string name)
        {
            try
            {
                if (SharedParametersFile.Groups.Where(x => x.Name.Equals(name, StringComparison.OrdinalIgnoreCase)).Count() != 0)
                {
                    ErrorMessage += "组的名字有唯一性，请不要重复添加\r";
                    return false;
                }
                DefinitionGroup parameterGroup = SharedParametersFile.Groups.Create(name);
                ShareGroupList.Add(parameterGroup);
                return true;
            }
            catch (Exception ex)
            {
                ErrorMessage += $"添加组错误\r{ex.Message}\r";
                return false;
            }

        }
        /// <summary>
        /// 添加参数
        /// </summary>
        /// <param name="name">属性名字</param>
        /// <param name="type">类型</param>
        /// <param name="groupName">族名字</param>
        /// <returns></returns>
        public bool AddParameter(string name, ParameterType type, string groupName)
        {
            try
            {
                DefinitionGroup selGroup = ShareGroupList.FirstOrDefault(x => x.Name.Equals(groupName, StringComparison.OrdinalIgnoreCase));
                Definitions definitions = selGroup.Definitions;
                if (definitions.Where(x => x.Name.Equals(name, StringComparison.OrdinalIgnoreCase)).Count() != 0)
                {
                    ErrorMessage += "属性的名字有唯一性，请不要重复添加\r";
                    return false;
                }
                ExternalDefinitionCreationOptions options = new ExternalDefinitionCreationOptions(name, type);
                Definition definition = definitions.Create(options);
                return true;
            }
            catch (Exception ex)
            {
                ErrorMessage += $"添加属性错误\r{ex.Message}\r";
                return false;
            }
        }
        /// <summary>
        /// 删除参数(删除文档中的信息再重新加载)
        /// </summary>
        /// <param name="name"></param>
        /// <param name="groupName"></param>
        /// <returns></returns>
        public bool DelectShareParameter(string name, string groupName)
        {
            try
            {
                DefinitionGroup selGroup = ShareGroupList.FirstOrDefault(x => x.Name.Equals(groupName, StringComparison.OrdinalIgnoreCase));
                Definitions definitions = selGroup.Definitions;
                ExternalDefinition changeDefinition = definitions.get_Item(name) as ExternalDefinition;
                string GuidString = changeDefinition.GUID.ToString();
                SharedParametersFile.Dispose();

                List<string> readAllDataList = File.ReadAllLines(DataPath).ToList();
                for (int i = 0; i < readAllDataList.Count; i++)
                {
                    if (readAllDataList[i].Contains(GuidString))
                    {
                        readAllDataList.RemoveAt(i);
                        i--;
                    }
                }
                File.WriteAllLines(DataPath, readAllDataList.ToArray(), Encoding.Unicode);
                SharedParametersFile = Doc.Application.OpenSharedParameterFile();
                ShareGroupList = SharedParametersFile.Groups.ToList();
                if (ShareGroupList == null)
                {
                    ShareGroupList = new List<DefinitionGroup>();
                }
                return true;
            }
            catch (Exception ex)
            {
                ErrorMessage += $"删除属性错误\r{ex.Message}\r{ex.StackTrace}";
                return false;
            }
        }

        /// <summary>
        /// 添加参数
        /// </summary>
        /// <param name="name">属性名字</param>
        /// <param name="type">类型</param>
        /// <param name="groupName">族名字</param>
        /// <param name="description">描述</param>
        /// <returns></returns>
        public bool AddParameter(string name, ParameterType type, string groupName, string description)
        {
            try
            {
                DefinitionGroup selGroup = ShareGroupList.FirstOrDefault(x => x.Name.Equals(groupName, StringComparison.OrdinalIgnoreCase));
                Definitions definitions = selGroup.Definitions;
                if (definitions.Where(x => x.Name.Equals(name, StringComparison.OrdinalIgnoreCase)).Count() != 0)
                {
                    ErrorMessage += "属性的名字有唯一性，请不要重复添加\r";
                    return false;
                }
                ExternalDefinitionCreationOptions options = new ExternalDefinitionCreationOptions(name, type);
                options.Description = description;
                Definition definition = definitions.Create(options);

                return true;
            }
            catch (Exception ex)
            {
                ErrorMessage += $"添加属性错误\r{ex.Message}\r";
                return false;
            }
        }
        /// <summary>
        /// 设置项目属性
        /// </summary>
        /// <param name="groupName"></param>
        /// <param name="builtInCategoryList"></param>
        /// <param name="builtInParameterGroup"></param>
        /// <returns></returns>
        public bool SetParameter(string groupName, List<BuiltInCategory> builtInCategoryList, BuiltInParameterGroup builtInParameterGroup)
        {
            bool result = false;
            Transaction createTrans = null;
            if (!Doc.IsModifiable)
            {
                createTrans = new Transaction(Doc, "添加项目参数");
            }
            createTrans?.Start();
            try
            {
                DefinitionGroup selGroup = ShareGroupList.FirstOrDefault(x => x.Name.Equals(groupName, StringComparison.OrdinalIgnoreCase));
                Definitions definitions = selGroup.Definitions;
                CategorySet catSet = Doc.Application.Create.NewCategorySet();
                foreach (var builtInCategory in builtInCategoryList)
                {
                    catSet.Insert(Doc.Settings.Categories.get_Item(builtInCategory));
                }
                foreach (Definition def in definitions)
                {
                    Doc.ParameterBindings.Insert(def, Doc.Application.Create.NewInstanceBinding(catSet), builtInParameterGroup);
                }

                result = true;
            }
            catch (Exception ex)
            {
                ErrorMessage += $"添加属性报错\r{ex.Message}\t{ex.StackTrace}\r";
            }
            createTrans?.Commit();

            return result;
        }
        /// <summary>
        /// 删除共享参数的项目参数
        /// </summary>
        /// <param name="groupName">共享参数中的名称</param>
        /// <param name="parameterName">属性名称</param>
        /// <returns></returns>
        public bool RemoveShareParameter(string groupName, string parameterName)
        {
            bool result = false;
            Transaction createTrans = null;
            if (!Doc.IsModifiable)
            {
                createTrans = new Transaction(Doc, "删除项目参数");
            }
            createTrans?.Start();
            try
            {
                DefinitionGroup selGroup = ShareGroupList.FirstOrDefault(x => x.Name.Equals(groupName, StringComparison.OrdinalIgnoreCase));
                Definition selDefinition = selGroup.Definitions.FirstOrDefault(x => x.Name.Equals(parameterName, StringComparison.OrdinalIgnoreCase));
                bool removeResult = Doc.ParameterBindings.Remove(selDefinition);
                result = removeResult;
                if (!result)
                {
                    ErrorMessage += $"属性{parameterName}删除失败\r";
                }
            }
            catch (Exception ex)
            {
                ErrorMessage += $"属性删除致命错误\r{ex.Message}\t{ex.StackTrace}";
            }
            createTrans?.Commit();
            return result;
        }




    }

大家可以自行提取类库直接使用