using System；
using System.Collections.Generic；
using System.Linq；
using System.Text；
using System.Threading.Tasks；
using Autodesk.Revit.DB；
using Autodesk.Revit.UI；
using Autodesk.Revit.Attributes；

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            TaskDialog.Show("Revit"，"Hello World")；
            return Result.Succeeded；
        }
    }
}

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //应用过滤器，获得所有墙体
            List<Element> walls = collector.OfClass(typeof(Wall)).WhereElementIsNotElementType().ToList()；
            //获得所有墙体的ID
            string wallIds = "本项目墙体ID如下：\n"；
            foreach (Element wall in walls)
            {
                wallIds = wallIds + wall.Id.ToString() + "\n"；
            }
            TaskDialog.Show("Revit"， wallIds)；
            return Result.Succeeded；
        }
    }
}

new FilteredElementCollector(Document document)

new FilteredElementCollector(Document document， ElementId viewId)

new FilteredElementCollector(Document document， ICollection<ElementId> elementIds)

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //创建属于“墙类”的快速过滤器
            ElementClassFilter wallClassFilter = new ElementClassFilter(typeof(Wall))；
            //创建与标高2相关的的慢速过滤器，2607为标高2的ID
            ElementLevelFilter elementLevelFilter = new ElementLevelFilter(new ElementId(2607))；
            //创建逻辑与过滤器，连接两个过滤器
            LogicalAndFilter logicalAndFilter = new LogicalAndFilter(wallClassFilter， elementLevelFilter)；
            //应用逻辑与过滤找属于标高2的墙体
            List<Element> walls = collector.WherePasses(logicalAndFilter).ToList()；  
            //获得所有墙体的ID
            string wallIds = "本项目标高墙体ID如下：\n"；
            foreach (Element wall in walls)
            {
                wallIds = wallIds + wall.Id.ToString() + "\n"；
            }
            TaskDialog.Show("Revit"， wallIds)；
            return Result.Succeeded；
        }
    }
}

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //获取所有墙体
            List<Element> walls = collector.OfClass(typeof(Wall)).ToList()；  
            //获取墙体修改前无连接高度
            string before = "修改前墙体无连接高度为：\n"+walls.First().LookupParameter("无连接高度").AsValueString()+"\n"；
            //修改高度（修改模型必须在事务中进行，后续介绍）
            //创建事务
            Transaction transaction = new Transaction(document， "创建事务")；
            //事务开始
            transaction.Start()；
            //修改高度
            foreach (Element wall in walls)
            {
                wall.LookupParameter("无连接高度").Set(4000 / 304.8)；
            }
            //事务介绍
            transaction.Commit()；
            //获取墙体修改后无连接高度
            string after = "修改后墙体无连接高度为：\n" + walls.First().LookupParameter("无连接高度").AsValueString()；
            TaskDialog.Show("Revit"， before+after)；
            return Result.Succeeded；
        }
    }
}

public static void MoveElement(Document document， ElementId elementToMove， XYZ translation)；

public static void MoveElements(Document document， ICollection<ElementId> elementsToMove， XYZ translation)；

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建事务
            Transaction transaction = new Transaction(document， "创建事务")；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //获取所有墙体
            List<Element> walls = collector.OfClass(typeof(Wall)).ToList()；
            //遍历所有墙体，收集墙体ID
            List<ElementId> wallIds = new List<ElementId>()；
            foreach (Element wall in walls)
            {
                wallIds.Add(wall.Id)；
            }
            //移动墙体，向上移动200mm
            transaction.Start()；
            ElementTransformUtils.MoveElements(document， wallIds， new XYZ(0， 200 / 304.8， 0))；
            transaction.Commit()；
            return Result.Succeeded；
        }
    }
}

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建事务
            Transaction transaction = new Transaction(document， "创建事务")；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //获取所有墙体
            List<Element> walls = collector.OfClass(typeof(Wall)).ToList()；
            //遍历所有墙体，修改Location属性，使墙体向左偏移300mm，向上偏移400mm
            transaction.Start()；
            foreach (Element wall in walls)
            {
                (wall.Location as LocationCurve).Move(new XYZ(300 / 304.8， 400 / 304.8， 0))；
            }
            transaction.Commit()；
            return Result.Succeeded；
        }
    }
}

CopyElement(Document document， ElementId elementToCopy， XYZ translation)

CopyElements(Document document， ICollection<ElementId> elementsToCopy， XYZ translation)

CopyElements(Document sourceDocument， ICollection<ElementId> elementsToCopy， Document destinationDocument， Transform transform， CopyPasteOptions options)；

CopyElements(View sourceView， ICollection<ElementId> elementsToCopy， View destinationView， Transform additionalTransform， CopyPasteOptions options)

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建事务
            Transaction transaction = new Transaction(document， "创建事务")；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //获取所有墙体
            List<Element> walls = collector.OfClass(typeof(Wall)).ToList()；
            //遍历所有墙体，获取所有墙体ID
            List<ElementId> wallIds = new List<ElementId>()；
            foreach (Element wall in walls)
            {
                wallIds.Add(wall.Id)；
            }
            //复制墙体，并向上偏移2000mm
            transaction.Start()；
            ElementTransformUtils.CopyElements(document， wallIds， new XYZ(0， 2000 / 304.8， 0))；
            transaction.Commit()；
            return Result.Succeeded；
        }
    }
}

RotateElement(Document document， ElementId elementToRotate， Line axis， double angle)；

RotateElements(Document document， ICollection<ElementId> elementsToRotate， Line axis， double angle)；

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建事务
            Transaction transaction = new Transaction(document， "创建事务")；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //获取所有墙体
            List<Element> walls = collector.OfClass(typeof(Wall)).ToList()；
            //遍历所有墙体，将墙体绕其自身中点逆时针旋转30°
            transaction.Start()；
            foreach (Element wall in walls)
            {
                //获取墙体的定位线
                Line wallLocaionLine = (wall.Location as LocationCurve).Curve as Line；
                //获取墙体中点
                XYZ midPoint = wallLocaionLine.GetEndPoint(0) + wallLocaionLine.Direction * wallLocaionLine.Length / 2；
                //创建旋转轴
                Line axis = Line.CreateBound(midPoint， new XYZ(midPoint.X， midPoint.Y， midPoint.Z + 10))；
                //旋转墙体
                ElementTransformUtils.RotateElement(document， wall.Id， axis， Math.PI / 6)；
            }
            transaction.Commit()；
            return Result.Succeeded；
        }
    }
}

ItemFactoryBace.NewAlignment(View view， Reference reference1， Reference reference2)

MirrorElement(Document document， ElementId elementToMirror， Plane plane)

MirrorElements(Document document， ICollection<ElementId> elementsToMirror， Plane plane， bool mirrorCopies)

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获取项目UI文档
            UIDocument uIDocument = commandData.Application.ActiveUIDocument；
            //获得本项目文档
            Document document = uIDocument.Document；
            //创建事务
            Transaction transaction = new Transaction(document， "创建事务")；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //获取所有墙体
            List<Element> walls = collector.OfClass(typeof(Wall)).ToList()；
            //遍历所有墙体，获取所有墙体的ID
            List<ElementId> wallIds = new List<ElementId>()；
            foreach (Element wall in walls)
            {
                wallIds.Add(wall.Id)；
            }
            //选择一条线
            Reference lineRe = uIDocument.Selection.PickObject(Autodesk.Revit.UI.Selection.ObjectType.Element，"请选择镜像轴线")；
            DetailLine detailLine = document.GetElement(lineRe) as DetailLine；
            //获得轴线的定位线
            Line locationLine = (detailLine.Location as LocationCurve).Curve as Line；
            //获得定位线的起点和终点
            XYZ startPoint = locationLine.GetEndPoint(0)；
            XYZ endPoint = locationLine.GetEndPoint(1)；
            //创建轴线上方的点
            XYZ topPoint = new XYZ(startPoint.X， startPoint.Y， startPoint.Z + 10)；
            //以三点创建一个平面
            Plane plane = Plane.CreateByThreePoints(startPoint， endPoint， topPoint)；
            //镜像墙体并保留原图元
            transaction.Start()；
            ElementTransformUtils.MirrorElements(document， wallIds， plane， true)；
            transaction.Commit()；
            return Result.Succeeded；
        }
    }
}

NewGroup(ICollection<DB.ElementId> elementIds)

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建事务
            Transaction transaction = new Transaction(document， "创建事务")；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //获取所有墙体
            List<Element> walls = collector.OfClass(typeof(Wall)).ToList()；
            //遍历所有墙体，获取所有墙体ID
            List<ElementId> wallIds = new List<ElementId>()；
            foreach (Element wall in walls)
            {
                wallIds.Add(wall.Id)；
            }
            transaction.Start()；
            //成组墙体
            Group wallGroup = document.Create.NewGroup(wallIds)；
            //修改组名
            wallGroup.GroupType.Name = "墙组1"；
            transaction.Commit()；
            return Result.Succeeded；
        }
    }
}

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目的UI文档
            UIDocument uIDocument = commandData.Application.ActiveUIDocument；
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建事务
            Transaction transaction = new Transaction(document， "创建事务")；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //获取所有墙体
            List<Element> walls = collector.OfClass(typeof(Wall)).ToList()；
            //遍历所有墙体，获取所有墙体ID
            List<ElementId> wallIds = new List<ElementId>()；
            foreach (Element wall in walls)
            {
                wallIds.Add(wall.Id)；
            }
            //阵列墙体，间距500mm，个数6
            transaction.Start()；
            LinearArray.Create(document， uIDocument.ActiveView， wallIds， 6， new XYZ(0， 500 / 304.8， 0)， ArrayAnchorMember.Second)；
            transaction.Commit()；
            return Result.Succeeded；
        }
    }
}

amespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目的UI文档
            UIDocument uIDocument = commandData.Application.ActiveUIDocument；
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建事务
            Transaction transaction = new Transaction(document， "创建事务")；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //获取所有墙体
            List<Element> walls = collector.OfClass(typeof(Wall)).ToList()；
            //遍历所有墙体，获取所有墙体ID
            List<ElementId> wallIds = new List<ElementId>()；
            foreach (Element wall in walls)
            {
                wallIds.Add(wall.Id)；
            }
            //删除所有墙体
            transaction.Start()；
            document.Delete(wallIds)；
            transaction.Commit()；
            return Result.Succeeded；
        }
    }
}

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目的UI文档
            UIDocument uIDocument = commandData.Application.ActiveUIDocument；
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建事务
            Transaction transaction = new Transaction(document， "创建事务")；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //获取所有墙体
            List<Element> walls = collector.OfClass(typeof(Wall)).ToList()；
            //获取结构柱类型
            FamilySymbol columnSymbol = new FilteredElementCollector(document).WhereElementIsElementType().OfClass(typeof(FamilySymbol)).Where(x => x.Name == "UC305x305x97").First() as FamilySymbol；
            //获取标高1
            Level level1 = new FilteredElementCollector(document).WhereElementIsNotElementType().OfClass(typeof(Level)).Where(x => x.Name == "标高 1").First() as Level；
            //遍历所有墙体，创建结构柱
            transaction.Start()；
            foreach (Element wall in walls)
            {
                //获取墙体的定位线
                Line wallLine = (wall.Location as LocationCurve).Curve as Line；
                //创建结构柱
                document.Create.NewFamilyInstance(wallLine.GetEndPoint(0)， columnSymbol， level1， StructuralType.Column)；
                document.Create.NewFamilyInstance(wallLine.GetEndPoint(1)， columnSymbol， level1， StructuralType.Column)；
            }
            transaction.Commit()；
            return Result.Succeeded；
        }
    }
}

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目的UI文档
            UIDocument uIDocument = commandData.Application.ActiveUIDocument；
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建事务
            Transaction transaction = new Transaction(document， "创建事务")；
            //获取结构柱类型
            FamilySymbol columnSymbol = new FilteredElementCollector(document).WhereElementIsElementType().OfClass(typeof(FamilySymbol)).Where(x => x.Name == "UC305x305x97").First() as FamilySymbol；
            //获取标高1
            Level level1 = new FilteredElementCollector(document).WhereElementIsNotElementType().OfClass(typeof(Level)).Where(x => x.Name == "标高 1").First() as Level；
            //构造10个柱子信息
            List<Autodesk.Revit.Creation.FamilyInstanceCreationData> familyInstanceCreationDatas = new List<Autodesk.Revit.Creation.FamilyInstanceCreationData>()；
            for (int i = 1； i <= 10； i++) 
            {
                Autodesk.Revit.Creation.FamilyInstanceCreationData familyInstanceCreationData = new Autodesk.Revit.Creation.FamilyInstanceCreationData(new XYZ(i * 1000 / 304.8， 0， 0)， columnSymbol， level1， StructuralType.Column)；
                familyInstanceCreationDatas.Add(familyInstanceCreationData)；
            }
            //创建结构柱
            transaction.Start()；
            document.Create.NewFamilyInstances2(familyInstanceCreationDatas)；
            transaction.Commit()；
            return Result.Succeeded；
        }
    }
}

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目的UI文档
            UIDocument uIDocument = commandData.Application.ActiveUIDocument；
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建事务
            Transaction transaction = new Transaction(document，"创建事务")；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //获取所有墙体
            List<Element> walls = collector.OfClass(typeof(Wall)).ToList()；
            //获取标高1视图
            View level1View = new FilteredElementCollector(document).WhereElementIsNotElementType().OfClass(typeof(View)).Where(x => x.Name == "标高 1").First() as View；
            //遍历所有墙体，创建尺寸标注
            transaction.Start()；
            foreach (Element wall in walls)
            {
                //获取墙体的定位线
                Line wallLine = (wall.Location as LocationCurve).Curve as Line；
                //创建标注的定位线，墙体定位线向上偏移1500mm
                Line dimensionLine = Line.CreateUnbound(wallLine.GetEndPoint(0) + level1View.UpDirection * 1500 / 304.8， level1View.RightDirection)；
                //创建参照集
                ReferenceArray referenceArray = new ReferenceArray()；
                //定位线
                Line line1 = Line.CreateBound(wallLine.GetEndPoint(0)， wallLine.GetEndPoint(0) + level1View.UpDirection * 1 / 304.8)；
                Line line2 = Line.CreateBound(wallLine.GetEndPoint(1)， wallLine.GetEndPoint(1) + level1View.UpDirection * 1 / 304.8)；
                //定位详图线
                DetailLine detailLine1 = document.Create.NewDetailCurve(level1View， line1) as DetailLine；
                DetailLine detailLine2 = document.Create.NewDetailCurve(level1View， line2) as DetailLine；
                //详图线转参照
                referenceArray.Append(new Reference(detailLine1))；
                referenceArray.Append(new Reference(detailLine2))；
                //创建尺寸标注
                Dimension wallDimension = document.Create.NewDimension(level1View， dimensionLine， referenceArray)；
                //修改尺寸标注值
                wallDimension.ValueOverride = $"墙体长度为{wallDimension.ValueString}毫米"；
            }
            transaction.Commit()；
            return Result.Succeeded；
        }
    }
}

Autodesk.Revit.Creation.ItemFactoryBase.NewDetailCurve(View view， Curve geometryCurve)

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //获取一个桌子的实例
            FamilyInstance desk = collector.OfClass(typeof(FamilyInstance)).Where(x=>(x as FamilyInstance).Symbol.FamilyName=="桌").First() as FamilyInstance；
            //声明体积
            double deskVolume = 0；
            //获取桌子的几何元素
            GeometryElement deskGeo = desk.get_Geometry(new Options())；
            //遍历桌子的几何元素，获取几何实例
            foreach (GeometryObject geometryObject in deskGeo)
            {
                GeometryInstance geometryInstance = geometryObject as GeometryInstance；
                if (geometryInstance != null)
                {
                    //获取几何实例中的几何元素
                    GeometryElement instGeoEle = geometryInstance.GetInstanceGeometry()；
                    //遍历实例中的几何元素，获得所有实体
                    foreach (GeometryObject instGeoObj in instGeoEle)
                    {
                        Solid solid = instGeoObj as Solid；
                        if(solid != null)
                        {
                            //获取所有实体体积
                            deskVolume += solid.Volume；
                        }
                    }
                }
            }
            //对体积进行单位转换（由立方英尺转换为立方米）
            deskVolume = Math.Round(deskVolume * 0.3048 * 0.3048 * 0.3048， 2)；
            //打印信息
            TaskDialog.Show("Revit"， $"该桌子的体积为{deskVolume}m³")；
            return Result.Succeeded；
        }
    }
}

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 ： IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData， ref string message， ElementSet elements)
        {
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document；
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document)；
            //获取一个墙体的实例
            Wall wall = collector.OfClass(typeof(Wall)).WhereElementIsNotElementType().First() as Wall；
            //声明周长
            double wallPerimeter = 0；
            //获取墙体的几何元素
            GeometryElement deskGeo = wall.get_Geometry(new Options())；
            //遍历墙体的几何元素，获取实体
            foreach (GeometryObject geometryObject in deskGeo)
            {
                Solid solid = geometryObject as Solid；
                if (solid != null && solid.Faces.Size != 0) 
                {
                    //遍历实体的所有边，获取周长
                    foreach (Edge edge in solid.Edges)
                    {
                        wallPerimeter += edge.ApproximateLength；
                    }
                }
            }
            //对体积进行单位转换（由英尺转换为米）
            wallPerimeter = Math.Round(wallPerimeter * 0.3048， 2)；
            //打印信息
            TaskDialog.Show("Revit"， $"该墙体的周长为{wallPerimeter}m")；
            return Result.Succeeded；
        }
    }
}

//创建事务对象
Transaction transaction = new Transaction(document， "事务名称")；
//启动事务
transaction.Start()；
 //模型修改内容……

//提交事务
transaction.Commit()；

//创建事务对象
Transaction transaction = new Transaction(document)；
//启动事务
transaction.Start("事务名称")；
 //模型修改内容……

//提交事务
transaction.Commit()；

//创建事务对象
using(Transaction transaction = new Transaction(document， "事务名称"))
{
    //启动事务
    transaction.Start()；
    //模型修改内容……

    //提交事务
    transaction.Commit()；
}

public class ExternalEventExamp : IExternalEventHandler
{
    public void Execute(UIApplication app)
    {
        TaskDialog.Show("Revit","示例窗口");
    }
    public string GetName()
    {
        return  "外部事件接口示例代码";
    }
}

namespace WpfApp2
{
    [Transaction(TransactionMode.Manual)]
    class CreatWallMainProgram : IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            //创建窗口对象
            MainWindow mainWindow = new MainWindow();
            //显示主窗口
            mainWindow.Show();
            return Result.Succeeded;
        }
    }

namespace WpfApp2
{
    class CreatWallEvent : IExternalEventHandler
    {
        //墙体位置属性
        public XYZ  WallLocation { get; set; }
        //墙体高度属性
        public double WallHight { get; set; }
        //墙体长度属性
        public double WallLength { get; set; }
        public void Execute(UIApplication app)
        {
            //获取用户文档;
            Document document = app.ActiveUIDocument.Document;
            //声明事务
            Transaction transaction = new Transaction(document);
            //墙体放置点1
            XYZ point1 = WallLocation;
            //墙体高度点2 
            XYZ point2 = point1 + XYZ.BasisZ * WallHight / 304.8;
            //墙体长度点3
            XYZ point3 = point1 + XYZ.BasisX * WallLength / 304.8;
            //墙体点4
            XYZ point4 = point3 + XYZ.BasisZ * WallHight / 304.8;
            //创建墙体轮廓
            Line line1 = Line.CreateBound(point1, point2);
            Line line2 = Line.CreateBound(point2, point4);
            Line line3 = Line.CreateBound(point4, point3);
            Line line4 = Line.CreateBound(point3, point1);
            List<Curve> curves = new List<Curve>() { line1, line2, line3, line4 };
            //开启事务
            transaction.Start("创建墙体");
            //创建墙体
            Wall.Create(document, curves, true);
            //提交事务
            transaction.Commit();
        }

        public string GetName()
        {
            return "创建墙体";
        }
    }
}

<Window x:Class="WpfApp2.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WpfApp2"
        mc:Ignorable="d"
        Title="MainWindow" Height="153.426" Width="192.628" >
    <Grid>
        <Button Content="生成墙体" HorizontalAlignment="Left" Margin="56,82,0,0" VerticalAlignment="Top" Width="74" Click="Button_Click"/>
        <TextBox x:Name="wallHight" HorizontalAlignment="Left" Height="23" Margin="47,18,0,0" TextWrapping="Wrap" VerticalAlignment="Top" Width="120"/>
        <TextBlock HorizontalAlignment="Left" Margin="11,22,0,0" TextWrapping="Wrap" Text="高度：" VerticalAlignment="Top"/>
        <TextBox x:Name="wallLength" HorizontalAlignment="Left" Height="23" Margin="47,46,0,0" TextWrapping="Wrap" VerticalAlignment="Top" Width="120"/>
        <TextBlock HorizontalAlignment="Left" Margin="10,51,0,0" TextWrapping="Wrap" Text="长度：" VerticalAlignment="Top"/>
    </Grid>
</Window>

namespace WpfApp2
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        //注册外部事件
        CreatWallEvent creatWallEvent;
        ExternalEvent externalEvent;
        public MainWindow()
        {
            InitializeComponent();
            //初始化外部事件
            creatWallEvent = new CreatWallEvent();
            externalEvent = ExternalEvent.Create(creatWallEvent);
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            //参数传递
            creatWallEvent.WallHight = Convert.ToDouble(wallHight.Text);
            creatWallEvent.WallLength = Convert.ToDouble(wallLength.Text);
            //执行外部命令
            externalEvent.Raise();
        }
    }
}

namespace HelloWord
{
    [Transaction(TransactionMode.Manual)]
    public class Class1 : IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            //获得本项目文档
            Document document = commandData.Application.ActiveUIDocument.Document;
            //创建事务
            Transaction transaction = new Transaction(document);
            //创建图元过滤集，收集整个文档所有构件
            FilteredElementCollector collector = new FilteredElementCollector(document);
            //获取本项目所有墙体
            List<Element> walls = collector.OfClass(typeof(Wall)).ToList();
            //遍历所有墙体，创建部件
            foreach (Element wall in walls)
            {
                //开启事务
                transaction.Start("创建部件");
                //创建部件
                AssemblyInstance wallAssembly = AssemblyInstance.Create(document, new List<ElementId>() { wall.Id }, wall.Category.Id);
                //提交事务(必须先提交事务，否则找不到部件进行下一步名称修改)
                transaction.Commit();
                //开启事务
                transaction.Start("修改名称，创建视图");
                //修改部件名称为墙体长度*墙体高度
                document.GetElement(wallAssembly.GetTypeId()).Name = wall.LookupParameter("长度").AsValueString()+"*"+ wall.LookupParameter("无连接高度").AsValueString();
                //创建墙体三视图
                ViewSection frontView = AssemblyViewUtils.CreateDetailSection(document, wallAssembly.Id, AssemblyDetailViewOrientation.ElevationFront);
                ViewSection rightView = AssemblyViewUtils.CreateDetailSection(document, wallAssembly.Id, AssemblyDetailViewOrientation.ElevationRight);
                ViewSection topView = AssemblyViewUtils.CreateDetailSection(document, wallAssembly.Id, AssemblyDetailViewOrientation.ElevationTop);
                //提交事务
                transaction.Commit();
            }
            //提交事务
            return Result.Succeeded;
        }
    }
}