详情
报

南飓风 Lv.8

2025-7-24 06:10:37 关注
        Teigha是一款专为开辟者设计的工具，其焦点技术在于强大的API和丰富的功能集，提供了一系列工具和方法，使开辟者可以或许轻松地读取、分析和操纵DWG文件。它支持多种操纵系统，能在处理大型DWG文件时保持高效性能，还可用于构建数据转换工具，将DWG文件转换为其他格式，或举行反向转换。
        此外，Teigha能与BIM软件集成，支持DWG文件的导入和导出，提拔BIM模子的数据兼容性。众多CAD软件更换品，如Bricscad、ZWCAD和IntelliCAD等，也都依赖Teigha来处理DWG格式和与Acad对象举行交互。

Teigha简介

Teigha是Bentley公司提供的CAD文件格式开辟库，允许开辟者在不依赖AutoCAD的情况下读写DWG/DXF文件。与AutoCAD .NET API相比，Teigha具有跨平台特性，支持多种开辟语言和操纵系统。
 
焦点定名空间
 
-  Bentley.MicroStation.DgnPlatformNET ：基础平台功能
 
-  Bentley.DgnPlatformNET ：DGN文件操纵
 
-  Bentley.DwgPlatformNET ：DWG文件操纵
 
-  Bentley.GeometryNET ：多少图形处理
 
-  Bentley.MathNET ：数学盘算功能
 
根本功能示例与代码
 
下面通过几个典型场景演示Teigha在C#中的根本应用，包括文件读写、图形创建、对象遍历和属性操纵：
  2. using System;
  3. using System.Collections.Generic;
  4. using Bentley.DwgPlatformNET;
  5. using Bentley.DgnPlatformNET;
  6. using Bentley.GeometryNET;
  7. using Bentley.MathNET;
  8. using Bentley.Transactions;
  10. namespace TeighaCADExample
  11. {
  12.     class Program
  13.     {
  14.         static void Main(string[] args)
  15.         {
  16.             // 初始化Teigha平台
  17.             InitializeTeigha();
  19.             try
  20.             {
  21.                 // 1. 创建新DWG文件并添加图形
  22.                 CreateNewDWGFile();
  23.                
  24.                 // 2. 读取DWG文件并遍历对象
  25.                 ReadAndProcessDWGFile();
  26.                
  27.                 // 3. 修改现有图形对象属性
  28.                 ModifyEntityProperties();
  29.                
  30.                 // 4. 执行图形集合运算
  31.                 PerformGeometryOperations();
  32.                
  33.                 Console.WriteLine("Teigha示例执行完成！");
  34.             }
  35.             catch (Exception ex)
  36.             {
  37.                 Console.WriteLine($"错误: {ex.Message}");
  38.             }
  39.             finally
  40.             {
  41.                 // 清理资源
  42.                 CleanUpTeigha();
  43.             }
  44.             
  45.             Console.ReadKey();
  46.         }
  48.         // 初始化Teigha平台
  49.         static void InitializeTeigha()
  50.         {
  51.             // 加载Teigha许可证
  52.             License BentleyLicense = new License();
  53.             BentleyLicense.SetProductLevel(License.ProductLevels.Professional);
  54.             Console.WriteLine("Teigha平台初始化成功");
  55.         }
  57.         // 清理Teigha资源
  58.         static void CleanUpTeigha()
  59.         {
  60.             // 释放许可证等资源
  61.             Console.WriteLine("Teigha资源已清理");
  62.         }
  64.         // 示例1：创建新DWG文件并添加图形
  65.         static void CreateNewDWGFile()
  66.         {
  67.             string filePath = @"C:\Temp\TeighaExample.dwg";
  68.             
  69.             // 创建DWG文档
  70.             using (DwgDocument doc = new DwgDocument())
  71.             {
  72.                 // 开始事务
  73.                 using (Transaction tr = doc.TransactionManager.StartTransaction())
  74.                 {
  75.                     // 获取模型空间
  76.                     BlockTableRecord modelSpace = doc.Database.ActiveModelSpace;
  77.                     
  78.                     // 1. 添加直线
  79.                     LineString line = new LineString();
  80.                     line.StartPoint = new Point3d(0, 0, 0);
  81.                     line.EndPoint = new Point3d(10, 0, 0);
  82.                     
  83.                     // 创建DwgLine实体
  84.                     DwgLine dwgLine = new DwgLine();
  85.                     dwgLine.Geometry = line;
  86.                     
  87.                     // 添加到模型空间
  88.                     modelSpace.AppendEntity(dwgLine);
  89.                     tr.AddNewlyCreatedDBObject(dwgLine, true);
  90.                     Console.WriteLine("已添加直线");
  91.                     
  92.                     // 2. 添加圆
  93.                     Circle circle = new Circle();
  94.                     circle.Center = new Point3d(5, 5, 0);
  95.                     circle.Radius = 3.0;
  96.                     
  97.                     DwgCircle dwgCircle = new DwgCircle();
  98.                     dwgCircle.Geometry = circle;
  99.                     
  100.                     modelSpace.AppendEntity(dwgCircle);
  101.                     tr.AddNewlyCreatedDBObject(dwgCircle, true);
  102.                     Console.WriteLine("已添加圆");
  103.                     
  104.                     // 3. 添加文本
  105.                     TextElement text = new TextElement();
  106.                     text.Text = "Teigha示例文本";
  107.                     text.Position = new Point3d(5, 0, 0);
  108.                     text.Height = 1.0;
  109.                     
  110.                     DwgText dwgText = new DwgText();
  111.                     dwgText.Geometry = text;
  112.                     
  113.                     modelSpace.AppendEntity(dwgText);
  114.                     tr.AddNewlyCreatedDBObject(dwgText, true);
  115.                     Console.WriteLine("已添加文本");
  116.                     
  117.                     // 提交事务并保存文件
  118.                     tr.Commit();
  119.                     doc.SaveAs(filePath);
  120.                     Console.WriteLine($"文件已保存至: {filePath}");
  121.                 }
  122.             }
  123.         }
  125.         // 示例2：读取DWG文件并遍历对象
  126.         static void ReadAndProcessDWGFile()
  127.         {
  128.             string filePath = @"C:\Temp\TeighaExample.dwg";
  129.             
  130.             if (!System.IO.File.Exists(filePath))
  131.             {
  132.                 Console.WriteLine("示例文件不存在，请先执行创建文件操作");
  133.                 return;
  134.             }
  135.             
  136.             using (DwgDocument doc = new DwgDocument())
  137.             {
  138.                 // 打开DWG文件
  139.                 doc.Open(filePath);
  140.                 Console.WriteLine("已打开DWG文件");
  141.                
  142.                 using (Transaction tr = doc.TransactionManager.StartTransaction())
  143.                 {
  144.                     // 获取模型空间
  145.                     BlockTableRecord modelSpace = doc.Database.ActiveModelSpace;
  146.                     
  147.                     Console.WriteLine("开始遍历模型空间对象:");
  148.                     int entityCount = 0;
  149.                     
  150.                     // 遍历模型空间所有实体
  151.                     foreach (DBObject obj in modelSpace)
  152.                     {
  153.                         if (obj is Entity entity)
  154.                         {
  155.                             entityCount++;
  156.                            
  157.                             // 根据实体类型执行不同操作
  158.                             if (entity is DwgLine line)
  159.                             {
  160.                                 LineString lineGeom = line.Geometry as LineString;
  161.                                 Console.WriteLine($"发现直线: 起点({lineGeom.StartPoint.X},{lineGeom.StartPoint.Y}), 终点({lineGeom.EndPoint.X},{lineGeom.EndPoint.Y})");
  162.                             }
  163.                             else if (entity is DwgCircle circle)
  164.                             {
  165.                                 Circle circleGeom = circle.Geometry as Circle;
  166.                                 Console.WriteLine($"发现圆: 圆心({circleGeom.Center.X},{circleGeom.Center.Y}), 半径{circleGeom.Radius}");
  167.                             }
  168.                             else if (entity is DwgText text)
  169.                             {
  170.                                 TextElement textGeom = text.Geometry as TextElement;
  171.                                 Console.WriteLine($"发现文本: "{textGeom.Text}", 位置({textGeom.Position.X},{textGeom.Position.Y})");
  172.                             }
  173.                         }
  174.                     }
  175.                     
  176.                     Console.WriteLine($"共找到{entityCount}个图形实体");
  177.                     tr.Commit();
  178.                 }
  179.             }
  180.         }
  182.         // 示例3：修改现有图形对象属性
  183.         static void ModifyEntityProperties()
  184.         {
  185.             string filePath = @"C:\Temp\TeighaExample.dwg";
  186.             
  187.             if (!System.IO.File.Exists(filePath))
  188.             {
  189.                 Console.WriteLine("示例文件不存在，请先执行创建文件操作");
  190.                 return;
  191.             }
  192.             
  193.             using (DwgDocument doc = new DwgDocument())
  194.             {
  195.                 doc.Open(filePath);
  196.                
  197.                 using (Transaction tr = doc.TransactionManager.StartTransaction())
  198.                 {
  199.                     BlockTableRecord modelSpace = doc.Database.ActiveModelSpace;
  200.                     
  201.                     Console.WriteLine("开始修改对象属性:");
  202.                     int modifiedCount = 0;
  203.                     
  204.                     foreach (DBObject obj in modelSpace)
  205.                     {
  206.                         if (obj is Entity entity)
  207.                         {
  208.                             // 1. 修改颜色：将所有对象设为红色
  209.                             entity.Color = Color.FromColorIndex(ColorMethod.ByAci, 1); // 红色
  210.                            
  211.                             // 2. 特别处理圆：增大半径
  212.                             if (entity is DwgCircle circle)
  213.                             {
  214.                                 Circle circleGeom = circle.Geometry as Circle;
  215.                                 circleGeom.Radius *= 1.5;
  216.                                 circle.Geometry = circleGeom;
  217.                                 Console.WriteLine($"圆半径已修改为{circleGeom.Radius}");
  218.                                 modifiedCount++;
  219.                             }
  220.                             // 3. 特别处理文本：修改内容
  221.                             else if (entity is DwgText text)
  222.                             {
  223.                                 TextElement textGeom = text.Geometry as TextElement;
  224.                                 textGeom.Text = "修改后的Teigha示例文本";
  225.                                 text.Geometry = textGeom;
  226.                                 Console.WriteLine("文本内容已修改");
  227.                                 modifiedCount++;
  228.                             }
  229.                         }
  230.                     }
  231.                     
  232.                     if (modifiedCount > 0)
  233.                     {
  234.                         Console.WriteLine($"成功修改{modifiedCount}个对象属性");
  235.                         tr.Commit();
  236.                         doc.Save();
  237.                     }
  238.                     else
  239.                     {
  240.                         Console.WriteLine("未找到可修改的对象");
  241.                     }
  242.                 }
  243.             }
  244.         }
  246.         // 示例4：执行图形集合运算
  247.         static void PerformGeometryOperations()
  248.         {
  249.             // 创建新文件用于演示几何运算
  250.             string filePath = @"C:\Temp\TeighaGeometry.dwg";
  251.             
  252.             using (DwgDocument doc = new DwgDocument())
  253.             {
  254.                 using (Transaction tr = doc.TransactionManager.StartTransaction())
  255.                 {
  256.                     BlockTableRecord modelSpace = doc.Database.ActiveModelSpace;
  257.                     
  258.                     // 1. 创建两个相交的圆用于求交运算
  259.                     Circle circle1 = new Circle();
  260.                     circle1.Center = new Point3d(5, 5, 0);
  261.                     circle1.Radius = 3.0;
  262.                     
  263.                     DwgCircle circleEnt1 = new DwgCircle();
  264.                     circleEnt1.Geometry = circle1;
  265.                     modelSpace.AppendEntity(circleEnt1);
  266.                     tr.AddNewlyCreatedDBObject(circleEnt1, true);
  267.                     
  268.                     Circle circle2 = new Circle();
  269.                     circle2.Center = new Point3d(8, 5, 0);
  270.                     circle2.Radius = 3.0;
  271.                     
  272.                     DwgCircle circleEnt2 = new DwgCircle();
  273.                     circleEnt2.Geometry = circle2;
  274.                     modelSpace.AppendEntity(circleEnt2);
  275.                     tr.AddNewlyCreatedDBObject(circleEnt2, true);
  276.                     
  277.                     // 2. 执行几何求交运算
  278.                     GeometryIntersector intersector = new GeometryIntersector();
  279.                     GeometryBase result = intersector.GetIntersection(circle1, circle2);
  280.                     
  281.                     if (result is Point3dCollection intersectionPoints)
  282.                     {
  283.                         Console.WriteLine($"两圆相交，找到{intersectionPoints.Count}个交点");
  284.                         
  285.                         // 将交点绘制成点
  286.                         foreach (Point3d pt in intersectionPoints)
  287.                         {
  288.                             PointElement point = new PointElement();
  289.                             point.Position = pt;
  290.                            
  291.                             DwgPoint pointEnt = new DwgPoint();
  292.                             pointEnt.Geometry = point;
  293.                            
  294.                             modelSpace.AppendEntity(pointEnt);
  295.                             tr.AddNewlyCreatedDBObject(pointEnt, true);
  296.                         }
  297.                     }
  298.                     else
  299.                     {
  300.                         Console.WriteLine("两圆未相交");
  301.                     }
  302.                     
  303.                     // 3. 创建矩形和圆形用于求差运算
  304.                     Polyline polyline = new Polyline();
  305.                     polyline.AddVertexAt(0, new Point3d(2, 2, 0), 0, 0, 0);
  306.                     polyline.AddVertexAt(1, new Point3d(2, 8, 0), 0, 0, 0);
  307.                     polyline.AddVertexAt(2, new Point3d(8, 8, 0), 0, 0, 0);
  308.                     polyline.AddVertexAt(3, new Point3d(8, 2, 0), 0, 0, 0);
  309.                     polyline.Closed = true;
  310.                     
  311.                     DwgPolyline rectEnt = new DwgPolyline();
  312.                     rectEnt.Geometry = polyline;
  313.                     modelSpace.AppendEntity(rectEnt);
  314.                     tr.AddNewlyCreatedDBObject(rectEnt, true);
  315.                     
  316.                     // 执行矩形减去圆形的差集运算
  317.                     GeometryDifferencer differencer = new GeometryDifferencer();
  318.                     GeometryBase diffResult = differencer.GetDifference(polyline, circle1);
  319.                     
  320.                     if (diffResult is Polyline resultPolyline)
  321.                     {
  322.                         Console.WriteLine("成功执行差集运算");
  323.                         
  324.                         // 绘制差集结果
  325.                         DwgPolyline diffEnt = new DwgPolyline();
  326.                         diffEnt.Geometry = resultPolyline;
  327.                         diffEnt.Color = Color.FromColorIndex(ColorMethod.ByAci, 2); // 绿色
  328.                         
  329.                         modelSpace.AppendEntity(diffEnt);
  330.                         tr.AddNewlyCreatedDBObject(diffEnt, true);
  331.                     }
  332.                     
  333.                     tr.Commit();
  334.                     doc.SaveAs(filePath);
  335.                     Console.WriteLine($"几何运算结果已保存至: {filePath}");
  336.                 }
  337.             }
  338.         }
  339.     }
  340. }
                    
 
1. 基础文件操纵
 
- 文件创建：通过 DwgDocument 类创建新DWG文件，利用 Transaction 管理数据库事务
 
- 文件读取：通过 doc.Open() 方法读取现有DWG文件，遍历 ActiveModelSpace 中的实体
 
2. 图形对象操纵
 
- 直线创建：通过 LineString 界说线段起点和终点，封装为 DwgLine 实体
 
- 圆形创建：利用 Circle 多少对象界说圆心和半径，转换为 DwgCircle 
 
- 文本创建：通过 TextElement 设置文本内容、位置和高度，天生 DwgText 实体
 
3. 对象属性修改
 
- 颜色修改：通过 entity.Color 属性设置对象颜色（示例中利用红色Aci 1）
 
- 多少修改：直接操纵多少对象（如圆的半径、文本内容）并更新实体
 
4. 多少运算应用
 
- 求交运算：利用 GeometryIntersector 盘算两圆交点，结果为 Point3dCollection 
 
- 差集运算：通过 GeometryDifferencer 实现矩形与圆形的差集盘算，返回新的多边形
 
Teigha与AutoCAD API的紧张差异
 
5. 架构设计：
 
- Teigha采用更通用的对象模子，不依赖AutoCAD情况
 
- AutoCAD API精密绑定AutoCAD历程，需在AutoCAD中运行
 
6. 定名空间差异：
 
- Teigha利用 Bentley 定名空间（如 Bentley.DwgPlatformNET ）
 
- AutoCAD API利用 Autodesk.AutoCAD 定名空间
 
7. 多少处理：
 
- Teigha提供独立的 GeometryNET 定名空间，多少运算功能更丰富
 
- AutoCAD API的多少处理与实体对象耦合更精密
 
8. 事务管理：
 
- 两者都利用事务机制管理数据库操纵，但Teigha的 Transaction 接口更简便
 
开辟情况配置
 
3. 引用步调集：
 
- 需要在项目中引用以下Teigha步调集：
 
- Bentley.DgnPlatformNET.dll
 
- Bentley.DwgPlatformNET.dll
 
- Bentley.GeometryNET.dll
 
- Bentley.MathNET.dll
 
- Bentley.Transactions.dll
 
4. 许可证管理：
 
- 利用Teigha前需初始化许可证（如示例中的 License 类）
 
- 商业应用需购买Bentley官方许可证
 
应用场景扩展
 
5. 批量文件处理：利用Teigha不依赖AutoCAD的特性，开辟批量转换、检查DWG文件的工具
 
6. 跨平台应用：基于Teigha的跨平台本事，开辟Windows、Linux或macOS情况下的CAD文件处理步调
 
7. 轻量化表现：提取DWG文件中的多少数据，用于轻量化图形表现或Web端可视化
 
8. 数据提取与分析：从DWG文件中提取特定范例的对象（如管道、结构构件）举行数据分析
 
上述示例代码可直接编译运行（需精确配置Teigha情况），现实项目中可根据需求进一步扩展功能，如添加图层管理、块参照处理、尺寸标注操纵等高级功能。

以下是关于 **Teigha (Open Design Alliance SDK)** 在CAD二次开辟中的根本应用示例，包含常见功能的详细代码和解释。Teigha 是用于处理DWG/DXF文件的跨平台开辟库，支持无需AutoCAD情况即可操纵CAD文件。
一、Teigha开辟情况准备**
1. 安装Teigha SDK（ODA SDK）
2. 在C#项目中添加以下引用：
   - `Teigha.Core.dll`
   - `Teigha.Runtime.dll`
   - `Teigha.DatabaseServices.dll`
   - `Teigha.Geometry.dll`
二、根本功能示例**#### **1. 创建新DWG文件并添加直线**
 
  2. using Teigha.Core;
  3. using Teigha.DatabaseServices;
  4. using Teigha.Geometry;
  5. using System;
  7. public class TeighaBasicDemo
  8. {
  9.     public static void CreateDwgWithLine()
  10.     {
  11.         // 初始化Teigha环境
  12.         Services.Start(); 
  14.         try
  15.         {
  16.             // 创建内存中的新Database（相当于DWG文件）
  17.             using (Database db = new Database(true, true))
  18.             using (Transaction tr = db.TransactionManager.StartTransaction())
  19.             {
  20.                 // 打开块表（BlockTable）
  21.                 BlockTable bt = tr.GetObject(db.BlockTableId, OpenMode.ForWrite) as BlockTable;
  23.                 // 打开模型空间块表记录
  24.                 BlockTableRecord modelSpace = tr.GetObject(
  25.                     bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
  27.                 // 创建一条直线（从点(0,0,0)到点(100,100,0)）
  28.                 Line line = new Line(
  29.                     new Point3d(0, 0, 0),
  30.                     new Point3d(100, 100, 0)
  31.                 );
  33.                 // 将直线添加到模型空间
  34.                 modelSpace.AppendEntity(line);
  35.                 tr.AddNewlyCreatedDBObject(line, true);
  37.                 // 保存为DWG文件
  38.                 db.SaveAs("C:\\Temp\\Output.dwg", DwgVersion.Current);
  40.                 tr.Commit();
  41.             }
  42.         }
  43.         catch (Exception ex)
  44.         {
  45.             Console.WriteLine("Error: " + ex.Message);
  46.         }
  47.         finally
  48.         {
  49.             // 释放Teigha资源
  50.             Services.Release();
  51.         }
  52.     }
  53. }
2. 读取DWG文件并遍历所有实体**
 
  2. using Teigha.Core;
  3. using Teigha.DatabaseServices;
  5. public class TeighaReadDemo
  6. {
  7.     public static void ReadDwgEntities()
  8.     {
  9.         Services.Start();
  11.         try
  12.         {
  13.             using (Database db = new Database(false, true))
  14.             {
  15.                 // 读取现有DWG文件
  16.                 db.ReadDwgFile("C:\\Temp\\Sample.dwg", FileOpenMode.OpenForReadAndAllShare, false, null);
  18.                 using (Transaction tr = db.TransactionManager.StartTransaction())
  19.                 {
  20.                     BlockTable bt = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
  21.                     BlockTableRecord modelSpace = tr.GetObject(
  22.                         bt[BlockTableRecord.ModelSpace], OpenMode.ForRead) as BlockTableRecord;
  24.                     // 遍历模型空间中的实体
  25.                     foreach (ObjectId entityId in modelSpace)
  26.                     {
  27.                         Entity entity = tr.GetObject(entityId, OpenMode.ForRead) as Entity;
  28.                         if (entity != null)
  29.                         {
  30.                             // 输出实体类型和句柄
  31.                             Console.WriteLine($"Entity Type: {entity.GetType().Name}, Handle: {entity.Handle}");
  32.                         }
  33.                     }
  35.                     tr.Commit();
  36.                 }
  37.             }
  38.         }
  39.         catch (Exception ex)
  40.         {
  41.             Console.WriteLine("Error: " + ex.Message);
  42.         }
  43.         finally
  44.         {
  45.             Services.Release();
  46.         }
  47.     }
  48. }
3. 创建图层并设置颜色**
 
  2. using Teigha.Core;
  3. using Teigha.DatabaseServices;
  5. public class LayerDemo
  6. {
  7.     public static void CreateLayer()
  8.     {
  9.         Services.Start();
  11.         try
  12.         {
  13.             using (Database db = new Database(true, true))
  14.             using (Transaction tr = db.TransactionManager.StartTransaction())
  15.             {
  16.                 // 获取层表（LayerTable）
  17.                 LayerTable lt = tr.GetObject(db.LayerTableId, OpenMode.ForWrite) as LayerTable;
  19.                 // 创建新图层
  20.                 LayerTableRecord layer = new LayerTableRecord
  21.                 {
  22.                     Name = "MyLayer",
  23.                     Color = Color.FromColorIndex(ColorMethod.ByAci, 1) // 红色
  24.                 };
  26.                 // 将图层添加到层表
  27.                 lt.Add(layer);
  28.                 tr.AddNewlyCreatedDBObject(layer, true);
  30.                 tr.Commit();
  31.                 db.SaveAs("C:\\Temp\\LayerDemo.dwg", DwgVersion.Current);
  32.             }
  33.         }
  34.         catch (Exception ex)
  35.         {
  36.             Console.WriteLine("Error: " + ex.Message);
  37.         }
  38.         finally
  39.         {
  40.             Services.Release();
  41.         }
  42.     }
  43. }
4. 添加块界说与块引用
 
  2. using Teigha.Core;
  3. using Teigha.DatabaseServices;
  5. public class BlockDemo
  6. {
  7.     public static void CreateBlockWithReference()
  8.     {
  9.         Services.Start();
  11.         try
  12.         {
  13.             using (Database db = new Database(true, true))
  14.             using (Transaction tr = db.TransactionManager.StartTransaction())
  15.             {
  16.                 // 创建块定义
  17.                 BlockTable bt = tr.GetObject(db.BlockTableId, OpenMode.ForWrite) as BlockTable;
  18.                 BlockTableRecord blockDef = new BlockTableRecord
  19.                 {
  20.                     Name = "MyBlock"
  21.                 };
  23.                 // 在块定义中添加一个圆
  24.                 Circle circle = new Circle(
  25.                     new Point3d(0, 0, 0),
  26.                     Vector3d.ZAxis,
  27.                     50.0
  28.                 );
  29.                 blockDef.AppendEntity(circle);
  30.                 tr.AddNewlyCreatedDBObject(circle, true);
  32.                 // 将块定义添加到块表
  33.                 bt.Add(blockDef);
  34.                 tr.AddNewlyCreatedDBObject(blockDef, true);
  36.                 // 在模型空间中插入块引用
  37.                 BlockTableRecord modelSpace = tr.GetObject(
  38.                     bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
  40.                 BlockReference blockRef = new BlockReference(
  41.                     new Point3d(200, 200, 0),
  42.                     blockDef.ObjectId
  43.                 );
  44.                 modelSpace.AppendEntity(blockRef);
  45.                 tr.AddNewlyCreatedDBObject(blockRef, true);
  47.                 tr.Commit();
  48.                 db.SaveAs("C:\\Temp\\BlockDemo.dwg", DwgVersion.Current);
  49.             }
  50.         }
  51.         catch (Exception ex)
  52.         {
  53.             Console.WriteLine("Error: " + ex.Message);
  54.         }
  55.         finally
  56.         {
  57.             Services.Release();
  58.         }
  59.     }
  60. }
三、关键技术点说明**
1. **情况初始化与释放**  
   - `Services.Start()`：初始化Teigha运行时情况
   - `Services.Release()`：释放资源（必须调用，否则内存走漏）
2. **数据库操纵**  
   - `new Database(true, true)`：创建空数据库（第一个参数为`true`表示新建）
   - `db.ReadDwgFile()`：读取现有DWG文件
   - `db.SaveAs()`：保存DWG文件
3. **事务管理**  
   - 所有数据库操纵必须包裹在事务中
   - 利用`TransactionManager.StartTransaction()`开启事务
   - 必须调用`Commit()`或`Abort()`结束事务
4. **实体操纵流程**  
   ```plaintext
   创建实体 → 打开目标块表记录 → AppendEntity → AddNewlyCreatedDBObject
   ```
四、Teigha与AutoCAD API的区别


| 功能                 | Teigha (ODA)                           | AutoCAD .NET API          |
|---------------------|----------------------------                |---------------------------|
| 情况依赖            | 无需安装AutoCAD                 | 必须安装AutoCAD           |
| 跨平台支持         | 支持Windows/Linux/macOS  | 仅Windows                 |
| 文件格式支持     | 支持DWG/DXF/DWF             | 紧张支持DWG               |
| 类名前缀            | 无定名空间前缀（如`Database`）| 带`Autodesk.AutoCAD`前缀 |
| 商业授权            | 需要ODA商业许可                    | 需AutoCAD授权             |


五、常见题目处理


1. **句柄(Handle)辩论**  
   利用`db.Undo()`回滚操纵时需注意对象状态管理。
2. **内存走漏**  
   确保所有`DBObject`在利用后调用`Dispose()`或包裹在`using`语句中。
3. **坐标系差异**  
   Teigha利用右手坐标系，需注意与AutoCAD坐标系的一致性。
---
通过上述示例，可以快速掌握Teigha在CAD文件操纵中的焦点功能。发起参考ODA官方文档（[Open Design Alliance](https://www.opendesign.com/)）获取更详细的API说明。


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
57阅读

数据仓库与分析

主题 3.3万   帖数 3.3万
0回复

暂无评论，点我抢沙发吧

高级模式
插入