【Revit二次开发】模型中存储数据——参数和外部存储(Parameter, Schema and Entity)

参数

在Revit平台API中，每个图元对象都有参数属性，它是隶属于图元所有属性的集合，在此集合中更改属性值。

• 每个图元的参数都有一个与之关联的ElementId类型的ID
• 大多数参数是Revit内置的
• 还有一部分是存储在硬盘外部共享参数文件的共享参数

Revit API中参数相关的类

• Autodesk.Revit.Parameters.BuiltInParameter枚举：Revit内建参数枚举
• Parameter类: 参数
• Defination类：参数定义类
• ParameterType枚举: 参数类型枚举

通过Lookup获取参数，点击Parameter得到该元素所有参数

选择你想获取的参数，然后点击Definition

读取

1. e.Parameters

2. e.GetParameters(string name)

3. e.get_Parameter(BuiltInParameter parameterId)

4. e.LookupParameter(string name)

写入

判断该参数是否是ReadOnly (p.IsReadOnly)

判断该参数交互时是否可修改(p.UserModifiable)

判断该参数的StorageType

将要写入该参数的值转换为相应的数据类型，然后Set().

外部存储

Revit API允许创建Schema类数据结构并将它们的实例附着到Revit模型中的任何Element。

Revit API中外部存储相关的类
Sechema:数据结构
SchemaBuilder：数据架构编辑器
Field：字段
FieldBuilder：字段编辑器
Entity：数据实体

Schema

using Autodesk.Revit.UI;
using System;
using System.IO;
using System.Linq;
using Autodesk.Revit.DB;
using System.Collections.Generic;

namespace ParameterBasicDemo
{

    [Autodesk.Revit.Attributes.Transaction(Autodesk.Revit.Attributes.TransactionMode.Manual)]
    public class CreateSharedParameterCmd : IExternalCommand
    {
        public Autodesk.Revit.UI.Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            try
            {
                string dllLocation = string.Empty;
                string sharedFile = string.Empty;

                dllLocation = "D:\\";
                sharedFile = Path.Combine(dllLocation, "SharedParameters.txt");
                //需要文件存在
                commandData.Application.Application.SharedParametersFilename = sharedFile;

                DefinitionFile defFile = null;
                defFile = commandData.Application.Application.OpenSharedParameterFile();
                using (Transaction tran = new Transaction(commandData.Application.ActiveUIDocument.Document))
                {
                    tran.Start("创建共享参数");
                    try
                    {
                        // 创建、获得共享参数
                        DefinitionGroup defGroup = defFile.Groups.Create("BasicDemo");
                        Definition def = defGroup.Definitions.get_Item("BasicDemoId");
                        ExternalDefinitionCreationOptions edcOpt = new ExternalDefinitionCreationOptions("BasicDemoId", ParameterType.Text);
                        //高版本不能用ParameterType要用ForgeTypeId(在SpecTypeId类中)
                        if (null == def)
                        {
                            def = defGroup.Definitions.Create(edcOpt);
                        }
                        // 获得墙类别集合
                        CategorySet cs = new CategorySet();
                        Category wallCategory =
                            commandData.Application.ActiveUIDocument.Document.Settings.Categories.get_Item(BuiltInCategory
                                .OST_Walls);
                        cs.Insert(wallCategory);
                        // 实例绑定
                        InstanceBinding instBd = commandData.Application.Application.Create.NewInstanceBinding(cs);
                        commandData.Application.ActiveUIDocument.Document.ParameterBindings.Insert(def, instBd);
                        if (TransactionStatus.Committed != tran.Commit())
                        {
                            TaskDialog.Show("共享参数", "事务提交失败！");
                        }
                    }
                    catch
                    {
                        tran.RollBack();
                        throw;
                    }
                }
                return Autodesk.Revit.UI.Result.Succeeded;
            }
            catch (Exception ex)
            {
                message = ex.Message;
                return Autodesk.Revit.UI.Result.Failed;
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

Entity

using System;
using Autodesk.Revit.DB;
using Autodesk.Revit.DB.ExtensibleStorage;
using Autodesk.Revit.UI;
using Autodesk.Revit.UI.Selection;

namespace ParameterBasicDemo
{
    [Autodesk.Revit.Attributes.Transaction(Autodesk.Revit.Attributes.TransactionMode.Manual)]
    public class WallExternalStorageCmd : IExternalCommand
    {
        public Autodesk.Revit.UI.Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            try
            {
                UIDocument uidoc = commandData.Application.ActiveUIDocument;
                Wall wall = PickWall(uidoc);
                StoreDataInWall(wall, XYZ.Zero);
                return Autodesk.Revit.UI.Result.Succeeded;
            }
            catch (Exception ex)
            {
                message = ex.Message;
                return Autodesk.Revit.UI.Result.Failed;
            }
        }

        private Wall PickWall(UIDocument uidoc)
        {
            Wall wall = null;
            while (null == wall)
            {
                Reference reference = uidoc.Selection.PickObject(ObjectType.Element);
                wall = uidoc.Document.GetElement(reference.ElementId) as Wall;
            }
            return wall;
        }

        //创建一个数据结构，将其附加到墙上，用数据填充它，然后从墙上检索数据
        void StoreDataInWall(Wall wall, XYZ dataToStore)
        {
            using (Transaction createSchemaAndStoreData = new Transaction(wall.Document, "tCreateAndStore"))
            {
                createSchemaAndStoreData.Start();
                SchemaBuilder schemaBuilder = new SchemaBuilder(new Guid("720080CB-DA99-40DC-9415-E53F280AA1F0"));
                schemaBuilder.SetReadAccessLevel(AccessLevel.Public); // 读权限：所有用户 
                schemaBuilder.SetWriteAccessLevel(AccessLevel.Vendor); // 可写权限：发行商
                schemaBuilder.SetVendorId("ADSK"); // 必须，由于可写权限为Vendor
                schemaBuilder.SetSchemaName("WireSpliceLocation");
                FieldBuilder fieldBuilder = schemaBuilder.AddSimpleField("WireSpliceLocation", typeof(XYZ)); // create a field to store an XYZ
                fieldBuilder.SetSpec(SpecTypeId.Length);
                fieldBuilder.SetDocumentation("A stored location value representing a wiring splice in a wall.");

                Schema schema = schemaBuilder.Finish(); // 注册外部存储的数据结构
                Entity entity = new Entity(schema); // 创建该数据结构类型的数据实体
                Field fieldSpliceLocation = schema.GetField("WireSpliceLocation"); // 获得数据结构的字段
                entity.Set<XYZ>(fieldSpliceLocation, dataToStore, UnitTypeId.Meters); // 设置数据实体的指定字段的值

                wall.SetEntity(entity); // 存储数据实体到墙元素

                // 读取墙上的外部数据
                Entity retrievedEntity = wall.GetEntity(schema);
                XYZ retrievedData = retrievedEntity.Get<XYZ>(schema.GetField("WireSpliceLocation"), UnitTypeId.Meters);
                createSchemaAndStoreData.Commit();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

快速获取外部存储参数

方法1

在LookUp上获取所需的外部存储的guid，得到schema，再得到entity，然后通过get方法输入参数的名称得到参数的值

Schema schema = Schema.Lookup(new Guid("{*****************}"));
Entity entity = ele.GetEntity(schema);
string data = entity.Get<string>(schema.GetField("id"));
1
2
3

方法2

            string data = null;
            IList<Guid> listGuids = ele.GetEntitySchemaGuids().ToList();
            foreach (Guid guid in listGuids)
            {
                Schema schema = Schema.Lookup(guid);
                if (schema.SchemaName == "schema名称"){
                    Entity entity = ele.GetEntity(schema);
                    data = entity.Get<string>(schema.GetField("参数名称"));
                }
            }
1
2
3
4
5
6
7
8
9
10