ShrlAlgoToolkit/ShrlAlgoToolkit.RevitAddins/ModelManager/RemoveParamCmd.cs

using System.Text;
using System.Windows;
using Autodesk.Revit.Attributes;
using Autodesk.Revit.DB;
using Microsoft.Win32;
using Nice3point.Revit.Toolkit.External;

namespace ShrlAlgoToolkit.RevitAddins.ModelManager;
/// <summary>
/// Revit执行命令
/// </summary>
[Transaction(TransactionMode.Manual)]
public class RemoveParamCmd : ExternalCommand
{
    public override void Execute()
    {
        var list = new List<string>();
        var filter = "族文件|*.rfa";
        var openFile = new OpenFileDialog
        {
            Multiselect = true,
            Filter = filter
        };
        openFile.ShowDialog();
        if (openFile.FileNames.Length != 0)
        {
            var strFiles = openFile.FileNames;

            foreach (var file in strFiles)
            {
                list.Add(file);
            }
        }
        foreach (var fileName in list)
        {
            var doc = Application.OpenDocumentFile(fileName);
            doc.Save();
            doc.Close(false);
        }
    }
    /// <summary>
    /// 移除任意参数
    /// </summary>
    /// <param name="element"></param>
    /// <param name="paramNames"></param>
    private void RemoveParams(Element element, params string[] paramNames)
    {
        var dict = ParameterAssist.GetParameterElementBindings(Document);
        var bindings = Document.ParameterBindings;
        var parameterElements = Document.OfClass<ParameterElement>().Cast<ParameterElement>();
        Document.InvokeGroup(
            _ =>
            {
                StringBuilder sb = new StringBuilder();
                Element type = null;
                var hasTypeId = element.GetTypeId() != ElementId.InvalidElementId;
                if (hasTypeId)
                {
                    type = Document.GetElement(element.GetTypeId());
                }
                Document.Invoke(
                _ =>
                {
                    //实例参数
                    foreach (Parameter param in element.ParametersMap)
                    {
                        if (paramNames.Contains(param.Definition.Name))
                        {
                            //var name = param.Definition.Name;
                            //var defs = dict.Keys.Select(e => e.GetDefinition());
                            var ds = dict.Where(
                                e => e.Key.GetDefinition().Id == (param.Definition as InternalDefinition)?.Id);
                            if (ds.Any())//说明是项目参数
                            {
                                var d = ds.FirstOrDefault();
                                var parameter = d.Key;
                                var binding = d.Value;
                                if (binding.Categories.Size == 1)//如果只剩下一个类别，则直接移除
                                {
                                    if (parameter is SharedParameterElement)//共享参数
                                    {
                                        bindings.Remove(param.Definition);
                                    }
                                    else//项目参数
                                    {
                                        dict.Remove(parameter);
                                        Document.Delete(parameter.Id);
                                    }
                                }
                                else//否则只移除一个类别
                                {
                                    binding.Categories.Erase(element.Category);
                                    Document.ParameterBindings.ReInsert(parameter.GetDefinition(), binding);
                                }
                            }
                        }
                    }
                    Document.Regenerate();

                    //类型参数
                    if (hasTypeId)
                    {
                        foreach (Parameter param in type.ParametersMap)
                        {
                            if (paramNames.Contains(param.Definition.Name))
                            {
                                //var name = param.Definition.Name;
                                //var defs = dict.Keys.Select(e => e.GetDefinition());
                                var ds = dict.Where(
                                    e => e.Key.GetDefinition().Id == (param.Definition as InternalDefinition)?.Id);
                                if (ds.Any())//说明是项目参数
                                {
                                    var d = ds.FirstOrDefault();
                                    var parameter = d.Key;
                                    var binding = d.Value;
                                    if (binding.Categories.Size == 1)//如果只剩下一个类别，则直接移除
                                    {
                                        if (parameter is SharedParameterElement)//共享参数
                                        {
                                            bindings.Remove(param.Definition);
                                        }
                                        else//项目参数
                                        {
                                            dict.Remove(parameter);
                                            Document.Delete(parameter.Id);
                                        }
                                    }
                                    else
                                    {
                                        binding.Categories.Erase(element.Category);
                                        Document.ParameterBindings.ReInsert(parameter.GetDefinition(), binding);
                                    }
                                }
                            }
                        }
                    }
                }, "清理项目参数");

                bool instaneFlag = element.ParametersMap
                    .OfType<Parameter>()
                    .Any(param => paramNames.Contains(param.Definition.Name));
                bool typeFlag = false;

                if (hasTypeId)
                {
                    typeFlag = type.ParametersMap.OfType<Parameter>()
                    .Any(param => paramNames.Contains(param.Definition.Name));
                }
                var NeedToEditFamily = instaneFlag || typeFlag;

                if (NeedToEditFamily && element is FamilyInstance instance)
                {
                    Document famdoc = null;
                    try
                    {
                        Family family = instance.Symbol.Family;

                        if (family.IsEditable)
                        {
                            famdoc = Document.EditFamily(family);
                        }
                        else
                        {
                            sb.AppendLine($"{family.Name} 不可编辑。");
                        }

                        if (famdoc != null)
                        {
                            using (Transaction ts = new(famdoc, "删除参数"))
                            {
                                ts.Start();
                                var parametersToRemove = famdoc.FamilyManager
                                    .GetParameters()
                                    .Where(fp => paramNames.Contains(fp.Definition.Name));
                                foreach (FamilyParameter fp in parametersToRemove)
                                {
                                    famdoc.FamilyManager.RemoveParameter(fp);
                                }
                                ts.Commit();
                            }

                            famdoc.LoadFamily(Document);
                            famdoc.Close(false);
                        }
                    }
                    catch (Exception)
                    {
                        sb.AppendLine($"{famdoc.Title} 发生错误！");
                    }
                }
                if (sb.Length > 0)
                {
                    MessageBox.Show(sb.ToString());
                }
            }, "参数移除");
    }
}