Revit二次開發——讀取構件的材料外觀資訊

阿新 • • 發佈：2019-02-05

如有不明白，請qq254033230詢問。

revit讀取材料的外觀資訊不能通過lookup來搞定，所以讀取起來稍微有點麻煩。但是在revit二次開發的官方基礎教程裡有相關的解釋。

這裡就以一個牆體為例，讀取牆體材料的所有外觀資訊（如下圖）。這裡主要針對autodesk的官方材料庫來說的。對於非官方材料庫的，下面的程式碼裡被註釋掉的可以參考一下。其實讀取材料的原理比較簡單，過程如下：

1)獲取材料的ID，ICollection<ElementId> matId = elem.GetMaterialIds(true);

2）// 讀取revit標準材質庫
AssetSet objlibraryAsset = revitApp.get_Assets(AssetType.Appearance);

3）從CompoundStructureLayer中獲得材料

4）分兩種情況讀取材料。

對於 APT_Asset和APT_Reference這兩種型別還需要再次遞迴。具體程式碼如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Autodesk.Revit.UI;
using Autodesk.Revit.DB;
using Autodesk.Revit.UI.Selection;
using Autodesk.Revit.ApplicationServices;
using Autodesk.Revit.Utility;
using System.IO;

namespace 讀取牆體材料
{
    [Autodesk.Revit.Attributes.Transaction(Autodesk.Revit.Attributes.TransactionMode.Manual)]
    [Autodesk.Revit.Attributes.Journaling(Autodesk.Revit.Attributes.JournalingMode.NoCommandData)]
    [Autodesk.Revit.Attributes.Regeneration(Autodesk.Revit.Attributes.RegenerationOption.Manual)]
    public class MyClass : IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            Document revitDoc = commandData.Application.ActiveUIDocument.Document;  //取得文件
            Application revitApp = commandData.Application.Application;             //取得應用程式
            UIDocument uiDoc = commandData.Application.ActiveUIDocument;
            Selection sel = uiDoc.Selection;
            Reference ref1 = sel.PickObject(ObjectType.Element, "選擇一個族例項");
            Element elem = revitDoc.GetElement(ref1);

            // 讀取revit標準材質庫  
            AssetSet objlibraryAsset = revitApp.get_Assets(AssetType.Appearance);

            Wall wall = elem as Wall;  
            ICollection<ElementId> matId = elem.GetMaterialIds(true);           
            #region 從elementId中獲得材料，這種方法獲得的是主材
            //foreach (var item in matId)
            //{

            //    TaskDialog.Show("REVIT", item.ToString());
            //    Material mat2 = revitDoc.GetElement(item) as Material;   //從elementId中獲得材料
            //}
            #endregion

            #region 從CompoundStructureLayer中獲得材料，這種方法可以獲得與該元素相關的全部材料
            WallType wallType = wall.WallType;
            CompoundStructure compoundStructure = wallType.GetCompoundStructure();
            IList<CompoundStructureLayer> layers = compoundStructure.GetLayers();
            ReadAssetProperty readAssetProperty = new ReadAssetProperty();
            foreach (var item in layers)
            {
                
                Material mat2 = revitDoc.GetElement(item.MaterialId) as Material;
               // TaskDialog.Show("REVIT", mat2.Name.ToString()+ mat2.Id);
                ElementId assetElementId = mat2.AppearanceAssetId;
                if(assetElementId!=ElementId.InvalidElementId)
                {
                    //獲取外觀元素
                    AppearanceAssetElement appearanceAssetElement = revitDoc.GetElement(assetElementId) as AppearanceAssetElement;

                    //讀寫外觀元素 
                    
                    Asset currentAsset = appearanceAssetElement.GetRenderingAsset();
                    //  TaskDialog.Show("revit", currentAsset.AssetType.ToString() + ";" + currentAsset.LibraryName.ToString() 
                    //    + ";" + currentAsset.Title.ToString()+";" + currentAsset.Size.ToString());

                    ////外觀子元素
                    //IList<AssetProperty> listProperty=new List<AssetProperty>() ;
                    //for(int i=0;i<currentAsset.Size;i++)
                    //{
                    //    listProperty.Add(currentAsset[i]);
                    //}

                    //string info = "";
                    //foreach(var item2 in listProperty)
                    //{
                    //    info +=  item2.Name.ToString()+ "\n";
                    //}
                    //TaskDialog.Show("revit", info);
                    ReadAsset(currentAsset, objlibraryAsset, readAssetProperty, assetElementId.ToString());
                }
            }

            #endregion
            Form1 form = new Form1();
            form.ShowDialog();

            return Result.Succeeded;
        }
        public void ReadAsset(Asset currentAsset, AssetSet objlibraryAsset, ReadAssetProperty readAssetProperty,string matId)
        {
            //歐特克的外觀子元素
            IList<AssetProperty> listProperty = new List<AssetProperty>();
            if (currentAsset.Size == 0)
            {
                foreach (Asset objCurrentAsset in objlibraryAsset)
                {
                    if (objCurrentAsset.Name == currentAsset.Name &&
                        objCurrentAsset.LibraryName == currentAsset.LibraryName)
                    {
                        for (int i = 0; i < objCurrentAsset.Size; i++)
                        {
                            listProperty.Add(objCurrentAsset[i]);
                        }
                        foreach (var item2 in listProperty)
                        {
                            ReadAutodeskAssetProperty(item2, readAssetProperty, objlibraryAsset,matId);
                        }
                    }                   
                }               
            }
            else
            {
 
                        for (int i = 0; i < currentAsset.Size; i++)
                        {
                            listProperty.Add(currentAsset[i]);
                        }
                        foreach (var item2 in listProperty)
                        {
                            ReadAutodeskAssetProperty(item2, readAssetProperty, objlibraryAsset, matId);
                        }                    
               
            }
        }
        
        public void ReadAutodeskAssetProperty(AssetProperty assetProperty, ReadAssetProperty readAssetProperty, AssetSet objlibraryAsset, string matId)
        {
            switch (assetProperty.Type)
            {
                case AssetPropertyType.APT_Integer:
                    var assetPropertyInt = assetProperty as AssetPropertyInteger;
                    if(readAssetProperty.CheckMaterialMxExists(matId, assetProperty.Name))
                    {
                        readAssetProperty.ReadAssetPropertyFromRevit(matId, assetProperty.Name, assetProperty.Type.ToString(), assetPropertyInt.Value.ToString());
                    }
                    break;

                case AssetPropertyType.APT_Distance:
                    var assetPropertyDistance = assetProperty as AssetPropertyDistance;
                    if (readAssetProperty.CheckMaterialMxExists(matId, assetProperty.Name))
                    {
                        readAssetProperty.ReadAssetPropertyFromRevit(matId, assetProperty.Name, assetProperty.Type.ToString(), assetPropertyDistance.Value.ToString());
                    }
                        break;

                case AssetPropertyType.APT_Double:
                    var assetPropertyDouble = assetProperty as AssetPropertyDouble;
                    if (readAssetProperty.CheckMaterialMxExists(matId, assetProperty.Name))
                    {
                        readAssetProperty.ReadAssetPropertyFromRevit(matId, assetProperty.Name, assetProperty.Type.ToString(), assetPropertyDouble.Value.ToString());
                    }
                        break;

                case AssetPropertyType.APT_DoubleArray2d:
                    var assetPropertyDoubleArray2d = assetProperty as AssetPropertyDoubleArray2d;
                    if (readAssetProperty.CheckMaterialMxExists(matId, assetProperty.Name))
                    {
                        readAssetProperty.ReadAssetPropertyFromRevit(matId, assetProperty.Name, assetProperty.Type.ToString(), assetPropertyDoubleArray2d.Value.ToString());
                    }
                        break;

                case AssetPropertyType.APT_DoubleArray4d:
                    var assetPropertyDoubleArray4d = assetProperty as AssetPropertyDoubleArray4d;
                    if (readAssetProperty.CheckMaterialMxExists(matId, assetProperty.Name))
                    {
                        string value4d = assetPropertyDoubleArray4d.Value.get_Item(0).ToString() + "," + assetPropertyDoubleArray4d.Value.get_Item(1).ToString() + "," +
                                               assetPropertyDoubleArray4d.Value.get_Item(2).ToString() + "," + assetPropertyDoubleArray4d.Value.get_Item(3).ToString();
                        readAssetProperty.ReadAssetPropertyFromRevit(matId, assetProperty.Name, assetProperty.Type.ToString(), value4d);
                     }
                    break;

                case AssetPropertyType.APT_String:
                    var assetPropertyString = assetProperty as AssetPropertyString;
                    if (readAssetProperty.CheckMaterialMxExists(matId, assetProperty.Name))
                    {
                        readAssetProperty.ReadAssetPropertyFromRevit(matId, assetProperty.Name, assetProperty.Type.ToString(), assetPropertyString.Value);
                    }
                    break;

                case AssetPropertyType.APT_Boolean:
                    var assetPropertyBoolean = assetProperty as AssetPropertyBoolean;
                    if (readAssetProperty.CheckMaterialMxExists(matId, assetProperty.Name))
                    {
                        readAssetProperty.ReadAssetPropertyFromRevit(matId, assetProperty.Name, assetProperty.Type.ToString(), assetPropertyBoolean.Value.ToString());
                    }
                    break;

                case AssetPropertyType.APT_Double44:
                    var assetPropertyDouble44 = assetProperty as AssetPropertyDoubleArray4d;
                    if (readAssetProperty.CheckMaterialMxExists(matId, assetProperty.Name))
                    {
                        readAssetProperty.ReadAssetPropertyFromRevit(matId, assetProperty.Name, assetProperty.Type.ToString(), assetPropertyDouble44.Value.ToString());
                    }
                    break;

                case AssetPropertyType.APT_List:
                    AssetPropertyList propList = assetProperty as AssetPropertyList;
                    IList<AssetProperty> subProps = propList.GetValue();
                    if (subProps.Count == 0)
                        break;
                    switch (subProps[0].Type)
                    {
                        case AssetPropertyType.APT_Integer:
                            foreach (AssetProperty subProp in subProps)
                            {
                                AssetPropertyInteger intProp = subProp as AssetPropertyInteger;
                                if (readAssetProperty.CheckMaterialMxExists(matId, assetProperty.Name))
                                {
                                    readAssetProperty.ReadAssetPropertyFromRevit(matId, assetProperty.Name, assetProperty.Type.ToString(), intProp.Value.ToString());
                                }
                            }
                            break;
                    }
                    break;

                case AssetPropertyType.APT_Asset:                    
                    var assetPropertyAsset = assetProperty as Asset;
                    ReadAsset(assetPropertyAsset, objlibraryAsset, readAssetProperty,matId);
                    break;

                case AssetPropertyType.APT_Reference:
                  
                    var assetPropertyReference = assetProperty as AssetPropertyReference;
                    IList<AssetProperty> listProperty2 = assetPropertyReference.GetAllConnectedProperties();
                    foreach (var item3 in listProperty2)
                    {
                        var AssetProperty3 = item3 as Asset;
                        for (int i = 0; i < AssetProperty3.Size; i++)
                        {
                            switch (AssetProperty3[i].Type)
                            {
                                case AssetPropertyType.APT_Integer:
                                    var assetPropertyInt2 = AssetProperty3[i] as AssetPropertyInteger;
                                    if (readAssetProperty.CheckMaterialMxExists(matId, AssetProperty3[i].Name))
                                    {
                                        readAssetProperty.ReadAssetPropertyFromRevit(matId, AssetProperty3[i].Name, AssetProperty3[i].Type.ToString(), assetPropertyInt2.Value.ToString());
                                    }
                                    break;

                                case AssetPropertyType.APT_Distance:
                                    var assetPropertyDistance2 = AssetProperty3[i] as AssetPropertyDistance;
                                    if (readAssetProperty.CheckMaterialMxExists(matId, AssetProperty3[i].Name))
                                    {
                                        readAssetProperty.ReadAssetPropertyFromRevit(matId, AssetProperty3[i].Name, AssetProperty3[i].Type.ToString(), assetPropertyDistance2.Value.ToString());
                                    }
                                    break;

                                case AssetPropertyType.APT_Double:
                                    var assetPropertyDouble2 = AssetProperty3[i] as AssetPropertyDouble;
                                    if (readAssetProperty.CheckMaterialMxExists(matId, AssetProperty3[i].Name))
                                    {
                                        readAssetProperty.ReadAssetPropertyFromRevit(matId, AssetProperty3[i].Name, AssetProperty3[i].Type.ToString(), assetPropertyDouble2.Value.ToString());
                                    }
                                    break;

                                case AssetPropertyType.APT_DoubleArray2d:
                                    var assetPropertyDoubleArray2d2 = AssetProperty3[i] as AssetPropertyDoubleArray2d;
                                    if (readAssetProperty.CheckMaterialMxExists(matId, AssetProperty3[i].Name))
                                    {
                                        readAssetProperty.ReadAssetPropertyFromRevit(matId, AssetProperty3[i].Name, AssetProperty3[i].Type.ToString(), assetPropertyDoubleArray2d2.Value.ToString());
                                    }
                                    break;

                                case AssetPropertyType.APT_DoubleArray4d:
                                    var assetPropertyDoubleArray4d2 = AssetProperty3[i] as AssetPropertyDoubleArray4d;
                                    if (readAssetProperty.CheckMaterialMxExists(matId, AssetProperty3[i].Name))
                                    {
                                        readAssetProperty.ReadAssetPropertyFromRevit(matId, AssetProperty3[i].Name, AssetProperty3[i].Type.ToString(), assetPropertyDoubleArray4d2.Value.ToString());
                                    }
                                    break;

                                case AssetPropertyType.APT_String:
                                    var assetPropertyString2 = AssetProperty3[i] as AssetPropertyString;
                                    if (readAssetProperty.CheckMaterialMxExists(matId, AssetProperty3[i].Name))
                                    {
                                        readAssetProperty.ReadAssetPropertyFromRevit(matId, AssetProperty3[i].Name, AssetProperty3[i].Type.ToString(), assetPropertyString2.Value.ToString());
                                    }
                                    break;

                                case AssetPropertyType.APT_Boolean:
                                    var assetPropertyBoolean2 = AssetProperty3[i] as AssetPropertyBoolean;
                                    if (readAssetProperty.CheckMaterialMxExists(matId, AssetProperty3[i].Name))
                                    {
                                        readAssetProperty.ReadAssetPropertyFromRevit(matId, AssetProperty3[i].Name, AssetProperty3[i].Type.ToString(), assetPropertyBoolean2.Value.ToString());
                                    }
                                    break;

                                case AssetPropertyType.APT_Double44:
                                    var assetPropertyDouble442 = AssetProperty3[i] as AssetPropertyDoubleArray4d;
                                    if (readAssetProperty.CheckMaterialMxExists(matId, AssetProperty3[i].Name))
                                    {
                                        readAssetProperty.ReadAssetPropertyFromRevit(matId, AssetProperty3[i].Name, AssetProperty3[i].Type.ToString(), assetPropertyDouble442.Value.ToString());
                                    }
                                    break;

                                case AssetPropertyType.APT_List:
                                    AssetPropertyList propList2 = AssetProperty3[i] as AssetPropertyList;
                                    IList<AssetProperty> subProps2 = propList2.GetValue();
                                    if (subProps2.Count == 0)
                                        break;
                                    switch (subProps2[0].Type)
                                    {
                                        case AssetPropertyType.APT_Integer:
                                            foreach (AssetProperty subProp in subProps2)
                                            {
                                                AssetPropertyInteger intProp2 = subProp as AssetPropertyInteger;
                                                if (readAssetProperty.CheckMaterialMxExists(matId, AssetProperty3[i].Name))
                                                {
                                                    readAssetProperty.ReadAssetPropertyFromRevit(matId, AssetProperty3[i].Name, AssetProperty3[i].Type.ToString(), intProp2.Value.ToString());
                                                }
                                                }
                                            break;
                                    }
                                    break;
                            }

                        }
                    }
                    break;
                default:
                    //info += assetProperty.Name + ";" + assetProperty.Type.ToString() + "\n";
                    break;
            }
        }
    }
}

這其中還有一個往資料庫中讀取材料性質的類，這個類有兩個作用：

1）把材料放到資料庫裡

2）檢查資料庫裡是否已經存在該材料的資訊

其中下面這句程式碼是資料庫的連結地址，依據個人的電腦不同而改變。

private string str = "Data Source=USER-20161016YA\\MEDICINE;Initial Catalog=MyMaterials;Integrated Security=True";

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 讀取牆體材料
{
   
    public   class ReadAssetProperty
    {
        private string str = "Data Source=USER-20161016YA\\MEDICINE;Initial Catalog=MyMaterials;Integrated Security=True";
        public void ReadAssetPropertyFromRevit(string materialId  ,string paramName, string type,string value)
        {
            int n = -1;
            //連線資料庫
            using (SqlConnection con = new SqlConnection(str))
            {
                //string sql = string.Format("insert into MaterialFormRevit(MaterialId,ParamName, MatType, Value) values('{0}','{1}','{2}',{3})", 1,paramName, type, value);
                string sql = string.Format("insert into MaterialFormRevit(MaterialId,ParamName, MatType, Value) values('{0}','{1}','{2}','{3}')", materialId, paramName, type, value);
                using (SqlCommand cmd = new SqlCommand(sql, con))
                {
                    con.Open();
                    n = cmd.ExecuteNonQuery();
                }
            }
            //string msg = n > 0 ? "操作成功" : "操作失敗";
            //LoadData();//重新整理資料
        }
        public bool CheckMaterialMxExists(string strMaterialId, string paramName)
        {
            bool flag = false;            
            SqlConnection mycon = new SqlConnection(str);
            //查詢此編號是否存在
             mycon.Open();
            SqlCommand mycmd = new SqlCommand("select MaterialId from MaterialFormRevit where MaterialId='" + strMaterialId + "'AND  ParamName='" + paramName + "'", mycon);
                SqlDataReader mysdr = mycmd.ExecuteReader();
                if (mysdr.HasRows)
                {
                    flag = false;
                }
                else
                {
                    flag = true;
                }
                mysdr.Close();
                mycon.Close();
            return flag;
        }
    }
    
}

其中中間過渡屬性的材料如下

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 讀取牆體材料
{
   public class Depart
    {
        private int _MaterialId;
        private string _ParamName;
        private string _Type;
        private string _Value;

        public int MaterialId
        {
            get
            {
                return _MaterialId;
            }

            set
            {
                _MaterialId = value;
            }
        }

        public string ParamName
        {
            get
            {
                return _ParamName;
            }

            set
            {
                _ParamName = value;
            }
        }

        public string Type
        {
            get
            {
                return _Type;
            }

            set
            {
                _Type = value;
            }
        }

        public string Value
        {
            get
            {
                return _Value;
            }

            set
            {
                _Value = value;
            }
        }
    }
}

最後Form的程式碼如下：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Data.SqlClient;

namespace 讀取牆體材料
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        string str = "Data Source=USER-20161016YA\\MEDICINE;Initial Catalog=MyMaterials;Integrated Security=True";
        private void Form1_Load(object sender, EventArgs e)
        {
            LoadData();
        }
        private void LoadData()
        {
            List<Depart> list = new List<Depart>();
            //通過連線字串連線資料庫
            using (SqlConnection con = new SqlConnection(str))
            {

                //拼接sql語句
                string sql = "select  * from MaterialFormRevit";
                //準備執行sql語句的物件
                using (SqlCommand cmd = new SqlCommand(sql, con))
                {
                    con.Open();//開啟資料庫
                    //準備讀資料
                    using (SqlDataReader reader = cmd.ExecuteReader())
                    {
                        //判斷是否有資料(有沒有行)
                        if (reader.HasRows)
                        {

                            //讀取每一行
                            while (reader.Read())
                            {

                                Depart dk = new Depart();//建立部門物件
                                                         // dk.MaterialId= Convert.ToInt32(reader["MaterialId"]);
                                dk.MaterialId =Convert.ToInt32(reader["MaterialId"].ToString()) ;
                                dk.ParamName = reader["ParamName"].ToString();
                                dk.Type = reader["MatType"].ToString();
                                dk.Value = reader["Value"].ToString();

                                list.Add(dk);//新增到集合中


                            }//end while
                        }//end if
                    }// end sqldatareader
                }//end using
            }//end using


            dgv.AutoGenerateColumns = false;//禁止自動生成列
            dgv.DataSource = list;//繫結資料
            //dgv.SelectedRows[0].Selected = false;//禁止被選中

        }
    }
}

最後結果如圖：

Revit二次開發——讀取構件的材料外觀資訊

如有不明白，請qq254033230詢問。 revit讀取材料的外觀資訊不能通過lookup來搞定，所以讀取起來稍微有點麻煩。但是在revit二次開發的官方基礎教程裡有相關的解釋。這裡就以一個牆體為例，讀取牆體材料的所有外觀資訊（如下圖

revit二次開發構件上色

首先給構件族建立一個材質引數，然後讓族的材質使用該引數，即可直接用引數化的過程改變材質建立某顏色的材質 class MaterialColor { public Material materialTest; public Document document;

Revit二次開發—引數的讀取與寫入

注：本文轉自公眾號：BIMCoder樑老師一、前言在Revit二次開發中，引數是非常重要的組成部分，那麼我們該如何從構件獲取引數並修改該引數。二、方法首先得到一個Element後，有如下

Revit 二次開發獲取元素的材質和外觀資訊以及貼圖

最近群裡的朋友們這個問題問的比較多，有必要寫一篇文章介紹利用Revit 二次開發獲取元素的材質和貼圖的方法！總體來說利用Revit API 獲取元素的材質和貼圖比較麻煩，而且有的材質還無法獲取。總結一下思路如下： 1.假設我們已經得到元素，利用Element.GetMa

revit 二次開發模型線讀取

目前只能讀取模型線長度，閉合的區域讀不到面積 UIApplication uiapp = commandData.Application; UIDocument uidoc = uiapp.ActiveUIDocument;

Revit二次開發之WPF通過txt讀取和儲存TextBox的字串【附原始碼】

軟體版本：VS2015 Revit2018 功能：Revit中執行程式時，在Window中的TextBox中自動顯示指定txt檔案中的字串內容缺點：會將txt檔案中的字串全部顯示程式展示： 1.程式啟動 2.輸入“666”，點選Button1，自動關閉窗體 3

Revit二次開發--Hello World

man dem users att try encoding cli 引用類庫部署完開發環境，就要進行每次學習新的技能，必寫的Hello World。 1、打開VS開發環境，新建一個項目類庫RevitDemo。 2、修改Class1名稱為Command。 3、在引

revit 二次開發之基於族獲得實例

相關 space typeof cef doc 過濾 list eric category Revit並沒有直接開放基於族獲取實例元素的過濾器。不過有兩個相關的過濾器，一個是FamilySymbolFilter（ElementId familyId），可以基於族ID過濾出所

踏上Revit二次開發之路 2 從“HelloWorld”入手

import none 工具環境變量各級 style first app ati 2 從“HelloWorld”入手在歐特克的官方網頁上有個叫《My First Plug-in Training》的項目，號稱可以讓一個完全沒有編程基礎的人照著做出一個插件來。我快速瀏覽

Revit二次開發事務標簽值

sub nsa ESS 需要 ret 使用用戶 ado 命令執行 Revit開發中，事務應用非常頻繁，所有revit API提供了用戶顯式地指定標簽值。來控制在revit的IExternalCommand中，是否使用事務，其使用的屬性為TransactionMode。如

Revit二次開發日誌文檔 JournalingMode

用戶名 bsp journal IE 操作日誌操作 nal 所有 nbsp 在revit的操作過程中，revit會將所有的操作，生成對應的操作日誌Journal文件，此文件是在目錄： C:\Users\%用戶名%\AppData\Local\Autodesk\Revi

Revit二次開發任務對話框TaskDialog

添加方法 exp ask all 細節 truct AD 當前對話框是revit常用的功能，可以提示revit一個命令的結果或者錯誤，其基本代碼如下“ TaskDialog mainDialog = new TaskDialog("Hello,TaskDia

Revit二次開發之載入族

return mes 刪除開發 urn com tar 失敗 commit 載入族此方法載入族無法覆蓋原有族,即若存在相同名稱的族則會載入失敗 1 Family family = null; //族 2 3 Transaction transact

Revit二次開發之自定義選項卡排在最前端

引用AdWindows.dll類庫 Autodesk.Windows.RibbonControl ribbon = AutodeskWindows.ComponentManager.Ribbon;

Revit二次開發——如何搭建多版本的框架，方便程式設計

Revit基本兩年一大變。所以在做開發的時候需要做多個版本的才行。但是每個版本做一個專案又很不方便，因為很多程式碼類似，改了前面忘了後面的版本，所以很頭疼，最好能夠幾個版本共用一個類，不同版本通過預編譯來解決。這裡只說怎麼解決多版本共用一個類

Revit二次開發高階應用（二）——怎樣在Revit中使用多執行緒

在Revit中完全可以使用多執行緒，只是需要滿足一定的規則：不改變Revit的Document文件的工作都可以線上程中完成，改變Document文件的工作都需要在主執行緒中完成。如下：不改變文件，只是在執行緒裡建立輔助的線，執行之後，絲毫不錯。 namespace RevitUseTh

Revit二次開發高階應用（1）——利用wcf做簡單的族庫管理

因為對應用場景不是特別明確，暫時就用wcf做一個可以上傳和下載的功能來管理族庫。 1、用WCF做服務端的上傳下載管理首先新增上傳下載的介面： [ServiceContract] public interface IFileService { //上傳

Revit二次開發之單位轉換

Revit內部基本單位是英尺，如果要獲取或設定構件引數數值需要進行單位轉換，比如轉換為基本的毫米或米等單位 1.可以使用常規方式進行轉換： 1英尺等於0.3047999995367米，等於304.7999995367毫米 2.可以使用RevitA

Revit二次開發新增按鈕

整體結構佈局命令類 namespace HW { [Transaction(TransactionMode.Manual)] class Cmd : IExternalCommand { public Result Ex

Revit二次開發基礎知識

獲取應用、文件及當前檢視資訊 public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements) {

Revit二次開發——讀取構件的材料外觀資訊

相關推薦