cad.net 委托事务和OpenDwg

定义

委托可以看成函数指针! (没有学过c语言的忽略这句话...)
它几乎等价于一个回调函数.

但是它的全名应该叫有泛型传参的函数指针链,它确实是个动态数组,因为它有委托链.
委托本身有一条委托链,它是构成"事件"的方式,用+= -=实现.

委托在.net core上还是"中间件"的构成要素.至于这地方这里就不详细说了,

本次教程只针对cad数据库上用委托和lambda表达式.
若你想知道函数指针在c#怎么调用,那就看vla-idata-get
视频参考

一个简单的快速说明

//首先委托可以返回一个以上的变量出来,其次不用委托的话,它会是:
var a = Fun1(out b);
int c = Fun2(a);
if(c == 0) 
    Fun3(b);
//要写三个函数处理.

//而委托压缩了它们:
//先看调用:
var e = FunK(a,b=>//从FunK获取a,b两个变量
{ 
    //处理a和b.
    return 0; //返回需要的值
}/*FunK内部再处理c*/);

//再看定义:
int FunK(Func<int,int,int> fn)
{
  int c = fn(11,12);//传出去两个参数
  //这里是FunK内部,处理参数c
  if(c == 0)
  {
     //其他处理
  }
  return 1234;//就是e
}

//单步调试可知,执行先流入FunK内,然后流出匿名函数,再回流到到FunK内.
//形成了一种夹芯饼干式的编程方法,饼干的两端是固定的,把芯的内容抛出去给调用的人,让调用者给芯加料(巧克力,还是草莓酱)

//为什么这么做呢?我认为最重要的是写sdk的,和调用者不是同一个人,
//但是写sdk的人想调用者写的函数插在这个函数的中间.例如微软提供linq

WinForm例子

在窗体面板的多线程操作的时候,你就会遇到基于面板控制的委托...
面板程序创建时候必然会创建一个主线程,这个主线程来维护所有的UI,
你新建的线程只是辅助线程,用来计算数值等等信息,然后你要让主线程来处理,而不是其他线程直接处理,否则会引发非线程安全操作.

这个时候就是委托上场了,一个简单的多线程UI demo:

using System;
using System.Threading;
using System.Windows.Forms;

namespace WindowsFormsApp1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        //这样会点击一次按钮新建一次线程,所以高版本net才有携程这回事,Task不new就是携程
        private void Button1_Click(object sender, EventArgs e)
        {
            int k = 0;
            var th = new Thread(() =>
            {
                while (true)
                {
                    //此时线程不安全
                    k++;
#if false
                    //此时调用委托达到线程安全
                    this.BeginInvoke(new Action(() =>
                    {
                        textBox1.Text = k.ToString();
                    }));
#else
                    //直接关闭
                    //使用Invoke的时候会阻塞等待并等待主线程运行,然后关闭了界面产生这个错误
                    //System.ObjectDisposedException:“无法访问已释放的对象。
                    try
                    {
                        this.Invoke(new Action(() =>
                        {
                            textBox1.Text = k.ToString();
                        }));
                    }
                    catch (Exception)
                    {}
#endif 
                    //当没有Sleep(1)的时候,代表此线程频繁委托主线程,
                    //以至于达到完全占用的情况,在同一时间片内无法调出.
                    Thread.Sleep(1);
                }
            });

            //由于主程序窗体关闭时候此线程扔在执行,所以要设置到背景线程去
            th.IsBackground = true;
            th.Start();
        }
    }
}

若你还知道多线程的背后原理,看看这个视频

CAD例子:无返回值写法

"数据库给我一个事务,我要让它来操作其他东西..用完它之后如果没有命令你不许提交,你就给我提交去"..实现了一种默认控制...

形象的理解一下: 相当于委托了一个狗腿子,让它帮你跑腿,然后它还会跑腿了之后自己还会回去它的狗窝...

/// <summary>
/// 事务处理器的封装,无返回值
/// </summary>
/// <param name="db">数据库对象</param>
/// <param name="act">delegate函数</param>
/// <param name="commit">是否提交,默认提交</param>
public static void Action(this Database db, Action<Transaction> act, bool commit = true)
{
    using (var tr = db.TransactionManager.StartTransaction())
    {
        try
        {
            act.Invoke(tr);//事务就被传出去了
        }
        catch (Exception e)
        {
            Debugger.Break();
        }
        finally
        {
            if (tr != null && !tr.IsDisposed)
            {
                if (commit && tr.TransactionManager.NumberOfActiveTransactions != 0)//防止重复提交
                    tr.Commit();
                tr.Dispose();
            }
        }
    }
}

调用方法:

//通过数据库,调用委托(狗腿子跑),(狗腿子捡回东西)拿到传出来的事务,然后加入图元到数据库..(跑会狗窝)再回到委托内,进行提交.
Database db = Acap.DocumentManager.MdiActiveDocument.Database;            
db.Action(tr =>
{ 
    var line = new Line(Point3d.Origin, new Point3d(1,1,0));
    var acBlkTblRec = tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite) as BlockTableRecord;              
    acBlkTblRec.AppendEntity(line);
    tr.AddNewlyCreatedDBObject(line, true);
});

CAD例子:有返回值写法

/// <summary>
/// 事务处理器的封装,有返回值
/// </summary>
/// <typeparam name="T">泛型</typeparam>
/// <param name="db">数据库对象</param>
/// <param name="func">delegate函数</param>
/// <param name="commit">是否提交,默认提交</param>
/// <returns>泛型</returns>
public static T Func<T>(this Database db, Func<Transaction, T> func, bool commit = true)
{
    T rtn = default; //泛型返回
    using (var tr = db.TransactionManager.StartTransaction())
    {
        try
        {
            rtn = func.Invoke(tr);//接收了返回值
        }
        catch (Exception e)
        {
            Debugger.Break();
        }
        finally
        {
            if (tr != null && !tr.IsDisposed)
            {
                if (commit && tr.TransactionManager.NumberOfActiveTransactions != 0)//防止重复提交
                    tr.Commit();
                tr.Dispose();
            }
        }
    }
    return rtn; //返回接收到的
}

调用方法:

var retLine = db.Func(tr =>
{
    var line = new Line(Point3d.Origin, new Point3d(1, 1, 0));
    var acBlkTblRec = tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite) as BlockTableRecord;
    acBlkTblRec.AppendEntity(line);
    tr.AddNewlyCreatedDBObject(line, true);
    return line;
});
//接着对返回的东西做其他处理.....
var ents = new List<Entity>() { retLine };

委托的需求诞生:

你写了很多foreach (例如一百个功能你就写了一百次) 来遍历同一个集合(例如块表),
然后要判断这个集合的 n位 是不是 Null ,因为 Null 获取属性就崩溃了....
然后突然有一天你发现如果集合上的 n位 不为 Null ,但是 n.Length==0,也没发干活....

你就发闹骚....难道我要改那一百个foreach吗? vs的替换? 要是接下来还有个新想法,那岂不是不能一劳永逸吗??
岂不是每次都修改了一个标准代码,然后又去替换100个位置的代码?
要是这个时候 只用修改了一个标准代码就可以完事了,不需要替换,就很爽了呢?
这个时候,一劳永逸的委托就可以帮助你...

需求1: 打开块表

把上面遇到的问题转化成我的需求:
1,打开块表;
2,遍历块表;
3,判断块表的id是否可用;
4,打开id转为块表记录;
5:再让给外部修改(通过委托扔给外面修改).
6:接下来判断委托的返回值,看是不是要结束内部的循环

A形写法:

//委托 块表
public delegate bool DelegateBlockTableRecord(BlockTableRecord record); 

/// <summary>
/// 遍历块表
/// </summary>
/// <param name="table"></param>
/// <param name="tr">事务</param>
/// <param name="de">委托</param> 
public static void Traverse(this BlockTable table, Transaction tr, DelegateBlockTableRecord de)
{
    foreach (var taid in table)
    {
        if (taid.IsOk())//如果你的新想法在这里..要进行判断 taid各种情况的话...需求无限增.....
        {
            var rec = tr.GetObject(taid, OpenMode.ForRead) as BlockTableRecord;
            if (rec != null && de(rec))//传rec出去给其他函数.
                break;
        }
    }
}

现在因为不光有块表,还有层表,文字样式表,标注符号表....那么要写很多行这个委托句(还要不同名称的),就显得很笨了.....

delegate bool DelegateBlockTableRecord(BlockTableRecord record); 

而微软给我们提供了简化:

Func<BlockTableRecord, bool>

Func是有返回值的委托 ,意思是Func<传参1,返回值>,用法见下面代码

注明:Action<传参1>这是无返回值的,而不能写成Func<传参1,Void>,或者Func<传参1,null>

B型写法:

/// <summary>
/// 遍历块表
/// </summary>
/// <param name="table"></param>
/// <param name="tr">事务</param>
/// <param name="de">委托</param> 
public static void Traverse(this BlockTable table, Transaction tr, Func<BlockTableRecord, bool> de)
{
    foreach (var taid in table)
    {
        if (taid.IsOk())
        {
            var rec = tr.GetObject(taid, OpenMode.ForRead) as BlockTableRecord;
            if (rec != null && de(rec))//这里传块表记录出去给调用的函数!
                break;
        }
    }
}

A型和B型写法的调用方法:

_block = _Transaction.GetObject(Database.BlockTableId, OpenMode.ForRead) as BlockTable;//块表
_block.Traverse(_Transaction, btRec => //这里的btRec就是委托传出来的表记录!!!!
                {
                    if (btRec.Name == "块的名字")
                    {                 ..........其他操作
                        return true; //找到就中断内部的循环,这就是为什么需要 bool返回值的原因
                    }
                    return false;
                });

需求增加: 全部符号表<模板类>

然而,我觉得这样要每次打开符号表这句也挺烦的..因此我做了个模板类,并且实现了多个符号表的静态方法:

public class Traverse<TTable, TTableRecord>
        where TTable : SymbolTable
        where TTableRecord : SymbolTableRecord
        {
            /// <summary>
            /// 遍历表记录
            /// </summary>
            /// <param name="tableId">符号表id</param>
            /// <param name="tr">事务</param>
            /// <param name="de">委托</param> 
            public Traverse(Transaction tr, ObjectId tableId, Func<TTableRecord, bool> de)
            {
                var bt = tr.GetObject(tableId, OpenMode.ForRead) as TTable;
                if (bt is LayerTable table)
                {
                    table = table.IncludingHidden;//层表包含隐藏的,全部显示出来
                    if (table is TTable tt)
                        bt = tt;
                }
                foreach (var taid in bt)
                {
                    if (taid.IsOk())
                    {
                        var rec = tr.GetObject(taid, OpenMode.ForRead) as TTableRecord;
                        if (rec != null && de(rec))
                            break;
                    }
                }
                bt.Dispose();
            }
        }

//静态调用
public static class TableRecord
{
    //块表
    public static void TraverseBlockTable(this Database db, Transaction tr, Func<BlockTableRecord, bool> de)
    {
        new Traverse<BlockTable, BlockTableRecord>(tr, db.BlockTableId, de);
    }

    //遍历所有图元
    public static void TraverseEntitys(this Database db, Transaction tr, Func<Entity, bool> de)
    {
        bool flag = false;
        db.TraverseBlockTable(tr, btRec =>
        {
            foreach (var entId in btRec)
            {
                var entId = ge.Current;
                if (!entId.IsOk())
                    continue;

                var ent = entId.ToEntity(tr);//这里是这样写的: (Entity)tr.GetObject(entId, OpenMode.ForRead, true, true)
                if (ent is null)
                    continue;

                ent.UpgradeOpen();
                isBreak = action(ent);
                ent.DowngradeOpen();

                if (!ent.IsDisposed)//防止委托内释放
                    ent.Dispose();
                if (isBreak)
                    break;
            }
            return flag;
        });
    }

    //层表
    public static void TraverseLayerTable(this Database db, Transaction tr, Func<LayerTableRecord, bool> de)
    {
        new Traverse<LayerTable, LayerTableRecord>(tr, db.LayerTableId, de);
    }

    //线型表
    public static void TraverseLinetypeTable(this Database db, Transaction tr, Func<LinetypeTableRecord, bool> de)
    {
        new Traverse<LinetypeTable, LinetypeTableRecord>(tr, db.LinetypeTableId, de);
    }

    //文字样式
    public static void TraverseTextStyleTable(this Database db, Transaction tr, Func<TextStyleTableRecord, bool> de)
    {
        new Traverse<TextStyleTable, TextStyleTableRecord>(tr, db.TextStyleTableId, de);
    }

    //标注样式
    public static void TraverseDimStyleTable(this Database db, Transaction tr, Func<DimStyleTableRecord, bool> de)
    {
        new Traverse<DimStyleTable, DimStyleTableRecord>(tr, db.DimStyleTableId, de);
    }

    //视口样式
    public static void TraverseViewportTable(this Database db, Transaction tr, Func<ViewportTableRecord, bool> de)
    {
        new Traverse<ViewportTable, ViewportTableRecord>(tr, db.ViewportTableId, de);
    }

    //视图样式
    public static void TraverseViewTable(this Database db, Transaction tr, Func<ViewTableRecord, bool> de)
    {
        new Traverse<ViewTable, ViewTableRecord>(tr, db.ViewTableId, de);
    }

    //坐标系表
    public static void TraverseUcsTable(this Database db, Transaction tr, Func<UcsTableRecord, bool> de)
    {
        new Traverse<UcsTable, UcsTableRecord>(tr, db.UcsTableId, de);
    }

    //注册应用表
    public static void TraverseRegAppTable(this Database db, Transaction tr, Func<RegAppTableRecord, bool> de)
    {
        new Traverse<RegAppTable, RegAppTableRecord>(tr, db.RegAppTableId, de);
    }
}

调用方法:

db.TraverseBlockTable(tr, btr =>
{
    if (btr.Name == "块名称")
    {            
        //.........其他操作                       
        return true;//找到就中断内部的循环,这就是为什么需要 bool返回值的原因
    }
    return false;
});

疑问和原理:

你可能会提问,为什么要写奇奇怪怪的委托?
因为这是一种用旧代码来减少新代码的方式.
例如你可能已经厌烦了每次开启事务,再每次提交事务.也都可以利用这种方法来进行优化你的代码.

如图所示制作委托函数时候,尽可能制作成夹芯饼干(或者循环内部),不然没有后面的处理的话,那倒不如去做一个简单的函数.

需求2: 批量打开dwg

如果到这里你还没理解这样可以令遍历简单化的话,继续看懂这个需求吧.

你写了一个功能来让用户选择项目文件夹,遍历出一堆dwg,这一堆dwg有的是用户已经在cad打开的,有的是没有打开的.
用户已经打开的,必须用前台来进行,而没有打开的就用后台来进行...否则cad会致命错误.(它就是那么不讲武德)
那么前台和后台打开之后处理的代码是一样的,也就是委托的处理代码 =>{ 一样的处理代码 };
委托之前,前台要进行锁文档(后台不用),
委托之后,前台要释放锁.这就涉及了封装时候的控制.
但是封装之后,你只需要调用这个函数,然后给予一个路径,让它返回一个数据库,不需要再进行判断是否要锁和不锁.其后要释放还是不释放,如何保存等等

也就是它是这样调用:

//遍历所有dwg,获取图签信息
foreach (var path in dwgsPathArr)
{
    //这里可以自动处理前后台了
    OpenDwg.Read(path, sdb =>
    {
        BackstageDatabase.Add(sdb); //.......获取图签的操作函数           
    }, false);//不释放,如果选择了不释放,代表后台持续占用着图纸.
}

它是这样封装:

#if !HC2020
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.ApplicationServices;
using Acap = Autodesk.AutoCAD.ApplicationServices.Application;
#else
using GrxCAD.DatabaseServices;
using GrxCAD.ApplicationServices;
using Acap = GrxCAD.ApplicationServices.Application;
#endif
using System;
using System.IO;

namespace JoinBox
{
    public static class OpenDwg
    {
        /// <summary>
        /// 通过路径打开图纸(前后台已经打开均可调用)
        /// </summary>
        /// <param name="dwgpath">dwg文件</param>
        /// <param name="change">打开后的处理</param>
        /// <param name="isDispose">是否打开后就立即关闭</param>
        /// <param name="save">是否保存</param>
        public static void Read(string dwgpath, Action<Database> change,
            bool isDispose = true, bool save = false)
        {
            var dm = Acap.DocumentManager;
            Database sdb = null;
            Document doc = null;
            DocumentLock doclock = null;

            //先遍历一遍当前文档集合,避免打开出错
            foreach (Document item in dm)
            {
                if (item.Database.Filename == dwgpath)
                {
                    doc = item;
                    sdb = doc.Database;
                    doclock = doc.LockDocument();//锁文档,操作非活动文档的时候必须
                    break;
                }
            }
            try
            {
                //异常: 打开的操作可能是失败的.
                //不是已经开启的数据库,就后台打开图纸
                if (sdb == null)
                {
                    sdb = new Database(false, true);//不这样写参数的话会导致 ePermanentlyErased 报错
                    sdb.ReadDwgFile(dwgpath, FileShare.ReadWrite, true, null);
                    //sdb.CloseInput(true); //阻止输入,前台是可交互,后台没有
                }
                change(sdb);

                //异常: 下面任何的操作都可能被委托给sdb.Dispose(),所以需要给try-catch
                if (save)
                {
                    if (doc != null)
                    {
                        //前台保存
                        //不需要切换文档
                        doc.SendStringToExecute("_qsave\n_regen\n", false, true, true);
                        return;
                    }
                    //后台保存
                    //这里错误会弹对话框,所以只能判断是不是 DocumentManager 的
                    DwgVersion dwgVersion = DwgVersion.Max;
                    foreach (DwgVersion suit in Enum.GetValues(typeof(DwgVersion)))
                    {
                        if ((int)suit == 27)//07版的版本号
                        {
                            dwgVersion = (DwgVersion)27;
                            break;
                        }
                    }
                    sdb.SaveAs(sdb.Filename, dwgVersion);
                }
            }
            catch (System.Exception e)
            {
                string str;
                switch (e.Message)
                {
                    case "eFileSharingViolation":
                        str = Environment.NewLine + "他人在打开此图!" + dwgpath +
                              Environment.NewLine + "请他人关闭再操作!!";
                        break;
                    case "eWrongObjectType":
                        str = Environment.NewLine + "错误的对象类型";
                        break;
                    default:
                        str = Environment.NewLine + "此文件发生错误:  " + dwgpath +
                              Environment.NewLine + "错误代码:  " + e.Message;
                        break;
                }
                Acap.ShowAlertDialog(str);
            }
            finally
            {
                if (sdb != null && isDispose && !sdb.IsDisposed)
                    sdb.Dispose();
                doclock?.Dispose();
            }
        }
    }
}

(完)

posted @ 2020-01-15 14:01  惊惊  阅读(1084)  评论(1编辑  收藏  举报