cad.net 块裁剪边界反向修剪

目录

• 说明
• 代码
• 测试命令
• SpatialFilter.cs
• SpatialFilterHelper.cs
• DwgFilerEx.cs
• DwgFiler.cs

返回目录

说明

看起来Autodesk忘记了通过API公开此设置,或将其包含在DXF输出中.也许您可以通过调用 SpatialFilter.ClipVolumeIntersectsExtents() 来确定它,它的内容完全在边界之内.
该设置通过 DwgOutFields() 提交给DWG文件管理器,
因此,如果所有其他操作均失败,则可以编写一个自定义AcDbDwgFiler来捕获该设置.

Querying for XCLIP information inside AutoCAD using .NET (帖子下面评论讨论了)

How do I determine if an x-clip boundary is inverted?

根据以上的帖子,我们会得到一个消息是,
桌子并没有封装好cad的块裁剪边界翻转部分.

然后我翻了翻api,
在Acad2015版本上面是已经加了一个 SpatialFilter.Inverted 这个函数.
而我们低版本需要的就是自己写.
最后进行刷新.

而这个模块到底有什么用呢?
实际上它是cad图元序列化
不过需要注意,单行文本会出错...没分析出原因...

但是要注意下面的函数,它们只是个例子,
没有提供撤销回滚的时候要刷新的操作...这个部分大家自己自行制作.

返回目录

代码

返回目录

测试命令

子函数参考: cad.net的undo返回操作

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

namespace JoinBox;

public static partial class Cmd_jjMoveBlockCropBoundary {
 
// 存在问题,undo撤回的时候无法代码刷新,只能用户自己去刷新...
// 选择图块,进行反向裁剪
[CommandMethod(nameof(JJ_Inverted),
CommandFlags.Modal | CommandFlags.UsePickSet | CommandFlags.Redraw | CommandFlags.Session)]
public static void JJ_Inverted() {
    var doc = Acap.DocumentManager.MdiActiveDocument;
    var ed = doc.Editor;
    var peo = new PromptEntityOptions(Environment.NewLine + "点选图块:") {
        AllowObjectOnLockedLayer = false,
        AllowNone = false
    };
    var per = ed.GetEntity(peo);
    if (per.Status != PromptStatus.OK) return;          
    CadSystem.Undo(true);

    using var docLocker = doc.Lock();
    using DBTrans tr = new();
    using var ent = tr.GetObject(per.ObjectId, OpenMode.ForRead);
    if (ent is BlockReference brf) {
        brf.SpatialFilterInverted();
    }

    CadSystem.Undo(false);
}
}

返回目录

SpatialFilter.cs

利用组合模式来制作同名的SpatialFilter类

using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using System.Collections.Generic;
using AcadSF = Autodesk.AutoCAD.DatabaseServices.Filters.SpatialFilter;
namespace JoinBox;

// 感觉这个封装不是很好,因为需要释放,
// 但是又写在了助手类传出去外面...
public class SpatialFilter : IDisposable  {
    bool _disposed = false;
    ~SpatialFilter(){
        Dispose(false);
    }
    public void Dispose(){
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    protected virtual void Dispose(bool disposing){
        if (_disposed) return;
        _disposed = true;
        if (disposing) {
            // 释放托管资源
        }
        // 释放非托管资源
        Filter.Dispose();
    }


    bool _inverted;
    public bool Inverted {
        get => _inverted;
        set {
            if (_inverted == value) return;
            _inverted = value;
            // 设定反向裁剪
            var df = new DwgFilerEx(Filter);
            df.DwgOut();
            df.Inverted();
            df.DwgIn();
        }
    }

    public AcadSF Filter { get; private set; }
    public SpatialFilter() { Filter = new(); }
    public SpatialFilter(AcadSF sp) {
        Filter = sp;
    }

    /// <summary>
    /// 生成块裁剪边界多段线
    /// </summary>
    /// <returns></returns>
    public ObjectId CreatePolyLine()  {
        var vertices = Filter.Definition.GetPoints();
        var tr = DBTrans.Top;
        List<BulgeVertex> bulges;
         // 生成一个矩形
        if (vertices.Count == 2) {
            bulges = new List<BulgeVertex> {
                new BulgeVertex(vertices[0],0),
                new BulgeVertex(new Point2d(vertices[0].X, vertices[1].Y),0),
                new BulgeVertex(vertices[1],0),
                new BulgeVertex(new Point2d(vertices[1].X, vertices[0].Y),0)
            };
        }
        else {
            bulges = vertices.Cast<Point2d>
                .Select(item => new BulgeVertex(item, 0))
                .ToList();
        }
        var pl = EntityAdd.AddPolyLineToEntity(0, bulges.ToArray());
        return tr.AddEntityToMsPs(db, pl);
    }

    /// <summary>
    /// 隐式转换(相当于是重载赋值运算符)
    /// </summary>
    public static implicit operator SpatialFilter(DBObject spatial) {
        if (spatial is AcadSF sp) {
            return new SpatialFilter(sp);
        }
        throw new("错误");
    }
}

返回目录

SpatialFilterHelper.cs

using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.DatabaseServices.Filters;
using AcadSF = Autodesk.AutoCAD.DatabaseServices.Filters.SpatialFilter;
namespace JoinBox;

public static class SpatialFilterHelper {
    /// <summary>
    /// 块裁剪边界翻转
    /// </summary>
    /// <param name="brf">块参照</param>
    public static void SpatialFilterInverted(this BlockReference brf) {
        using var sf = brf.GetBlockBoundaryInfo();
        if (sf is null) return;
        // 直接设置为反向
        sf.Filter.UpgradeOpen();
        sf.Inverted = !info.Inverted;
        sf.Filter.DowngradeOpen();
        var ids = brf.ToIEnumerable().ToIds();
        tr.EntityRedraw(ids, Bright.RecordGraphicsModified);
    }

    // 定义扩展词典和条目名称的名称
    const string dictName = "ACAD_FILTER";
    const string spName = "SPATIAL";

    /// <summary>
    /// 设置块裁剪边界
    /// </summary>
    /// <param name="filterDef">边界信息</param>
    /// <param name="brf">块参照</param>
    public static SpatialFilter? SetBlockBoundaryInfo(this BlockReference brf, SpatialFilterDefinition filterDef) {
        var tr = DBTrans.Top;
        if (brf.ExtensionDictionary.IsNull) {
            brf.UpgradeOpen();
            brf.CreateExtensionDictionary(); // 创建扩展字典
            brf.DowngradeOpen();
        }

        // eInvalidInput错误 1:是因为矩形边界要从左下到右上 2:非当前空间
        var filter = new SpatialFilter();
        filter.Filter.Definition = filterDef;

        // 删除已有边界词典,再重新加入
        using var extDict = (DBDictionary)tr.GetObject(brf.ExtensionDictionary, OpenMode.ForWrite);

        if (extDict.Contains(dictName)) {
            var fid = extdict.GetAt(dictName);
            if (!fid.IsOk()) return null;
            using var filterDict = (DBDictionary)tr.GetObject(fid, OpenMode.ForWrite);
            if (filterDict.Contains(spName)) filterDict.Remove(spName);
            filterDict.SetAt(spName, filter.Filter);
            filterDict.DowngradeOpen();
        }
        else {
            using var filterDict = new DBDictionary();
            extDict.SetAt(dictName, filterDict);
            tr.AddNewlyCreatedDBObject(filterDict, true);
            filterDict.SetAt(spName, filter.Filter);
        }
        extDict.DowngradeOpen();
        tr.AddNewlyCreatedDBObject(filter.Filter, true);
        return filter;
    }

    /// <summary>
    /// 获取块参照的裁剪边界信息
    /// </summary>
    /// <param name="brf">块参照</param>
    /// <returns>裁剪信息,null表示没有裁剪</returns>
    public static SpatialFilter? GetBlockBoundaryInfo(this BlockReference brf) {
        // 拓展词典存在,遇到没有裁剪就报错
        if (brf.ExtensionDictionary.IsNull) return null;
        var tr = DBTrans.Top;
        using var extdict = (DBDictionary)tr.GetObject(brf.ExtensionDictionary, OpenMode.ForRead);

        if (extdict.Contains(dictName)) return null;
        var fid = extdict.GetAt(dictName);
        if (!fid.IsOk()) return null;

        using var dict = (DBDictionary)tr.GetObject(fid, OpenMode.ForRead);
        if (!dict.Contains(spName)) return null;
        var spid = dict.GetAt(spName);
        if (!spid.IsOk()) return null;

        // todo 所有GetObject都要加入using,此处无法添加,因此外部调用需要添加
        SpatialFilter filter = (AcadSF)tr.GetObject(spid, OpenMode.ForRead);
        return filter;
    }

    /// <summary>
    /// 删除裁剪边界
    /// </summary>
    /// <param name="blockId">块参照的id</param>
    public static void DelBlockBoundary(this ObjectId blockId) {
        if (!blockId.IsOk()) return;
        var tr = DBTrans.Top;
        using var brf = (BlockReference)tr.GetObject(blockId, OpenMode.ForWrite);
        if (brf is null) return;
        if (brf.ExtensionDictionary.IsNull) return;
            
        using var extDict = (DBDictionary)tr.GetObject(brf.ExtensionDictionary, OpenMode.ForWrite);
        // var extDict = brf.ExtensionDictionary.ToDBDictionary(tr);

        if (extDict.Contains(dictName)) {
            var fid = extDict.GetAt(dictName);
            if (fid.IsOk()) {
                using var filterDict = (DBDictionary)tr.GetObject(fid, OpenMode.ForWrite);
                if (filterDict.Contains(spName)) 
                    filterDict.Remove(spName);
                filterDict.DowngradeOpen();
            }
            // 直接删它不也可以吗?可达性算法会移除下面成员吗?
            extDict.Remove(dictName);
        }

        extDict.DowngradeOpen();
        // 删除"ACAD_FILTER"中的"SPATIAL"就删除边界了
        brf.ReleaseExtensionDictionary();
        brf.DowngradeOpen();
    }
}

返回目录

DwgFilerEx.cs

using Autodesk.AutoCAD.DatabaseServices;
using Newtonsoft.Json;
using System.Text.RegularExpressions;

namespace JoinBox;

public class DwgFilerEx {
    DBObject _entity;
    public DwgFiler DwgFiler { get; set; }
    public DwgFilerEx(DBObject entity) {
        _entity = entity;
        DwgFiler = new DwgFiler();
    }

    public void DwgOut() => _entity.DwgOut(DwgFiler);
    public void DwgIn() => _entity.DwgIn(DwgFiler);

    /// <summary>
    /// 设定裁剪边界翻转
    /// </summary>
    public void Inverted() {
        // true反向裁剪,false正向裁剪
        if (DwgFiler.Uint16List[1] == 1) DwgFiler.Uint16List[1] = 0;
        else DwgFiler.Uint16List[1] = 1;
    }

    /// <summary>
    /// 序列化
    /// </summary>
    /// <returns></returns>
    public string SerializeObject() {
        return JsonConvert.SerializeObject(DwgFiler);  //序列化*类转字符串
        // Root = JsonConvert.DeserializeObject<Root>(json);//反序列化*字符串转类
    }

    public override string ToString() {
        var str = SerializeObject();
        // 替换中括号以外的字符串,替换逗号为换行符 https://bbs.csdn.net/topics/370134253
        str = str.Substring(1, str.Length - 2);
        str = Regex.Replace(str, @"(?:,)(?![^\[]*?\])", "\r\n");
        return str;
    }
}

返回目录

DwgFiler.cs

ObjectId不能序列化,不然会出现报错.要转为int或者long...

#if !HC2020
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.Runtime;
using Acap = Autodesk.AutoCAD.ApplicationServices.Application;
using AcadDwgFiler = Autodesk.AutoCAD.DatabaseServices.DwgFiler;
#else
using GrxCAD.DatabaseServices;
using GrxCAD.EditorInput;
using GrxCAD.Geometry;
using GrxCAD.Runtime;
using Acap = GrxCAD.ApplicationServices.Application;
using AcadDwgFiler = GrxCAD.DatabaseServices.DwgFiler;
#endif
using System.Reflection;
using System;
using System.Collections.Generic;
using System.Linq;

/*
Arx自定义实体类,
加读函数(assertReadEnabled)和写函数(assertWriteEnabled)
[Serializable] 设置序列化
[Newtonsoft.Json.JsonIgnore] 设置成员不可序列化
*/

namespace JoinBox;
[Serializable]
public class DwgFiler : AcadDwgFiler {
#if NET35
    public int m_Position;
#else
    public long m_Position;
#endif
    public FilerType m_FilerType;
    public ErrorStatus m_FilerStatus;
    public List<IntPtr> AddressList { get; set; }
    public int AddressListPt = 0;
    public List<byte[]> BinaryChunkList { get; set; }
    public int BinaryChunkListPt = 0;
    public List<bool> BooleanList { get; set; }
    public int BooleanListPt = 0;
    public List<byte> ByteList { get; set; }
    public int ByteListPt = 0;
    public List<byte[]> BytesList { get; set; }
    public int BytesListPt = 0;
    public List<double> DoubleList { get; set; }
    public int DoubleListPt = 0;
    public List<Handle> HandleList { get; set; }
    public int HandleListPt = 0;
    [Newtonsoft.Json.JsonIgnore]
    public List<ObjectId> HardOwnershipIdList { get; set; }
    public int HardOwnershipIdListPt = 0;
    [Newtonsoft.Json.JsonIgnore]
    public List<ObjectId> HardPointerIdList { get; set; }
    public int HardPointerIdListPt = 0;
    public List<short> Int16List { get; set; }
    public int Int16ListPt = 0;
    public List<int> Int32List { get; set; }
    public int Int32ListPt = 0;
#if !NET35
    public List<long> Int64List { get; set; }
    public int Int64ListPt = 0;
#endif
    public List<Point2d> Point2dList { get; set; }
    public int Point2dListPt = 0;
    public List<Point3d> Point3dList { get; set; }
    public int Point3dListPt = 0;
    public List<Scale3d> Scale3dList { get; set; }
    public int Scale3dListPt = 0;
    [Newtonsoft.Json.JsonIgnore]
    public List<ObjectId> SoftOwnershipIdList { get; set; }
    public int SoftOwnershipIdListPt = 0;
    [Newtonsoft.Json.JsonIgnore]
    public List<ObjectId> SoftPointerIdList { get; set; }
    public int SoftPointerIdListPt = 0;
    public List<string> StringList { get; set; }
    public int StringListPt = 0;
    public List<ushort> Uint16List { get; set; }
    public int uint16ListPt = 0;
    public List<uint> Uint32List { get; set; }
    public int uint32ListPt = 0;
#if !NET35
    public List<ulong> Uint64List { get; set; }
    public int uint64ListPt = 0;
#endif
    public List<Vector2d> Vector2dList { get; set; }
    public int Vector2dListPt = 0;
    public List<Vector3d> Vector3dList { get; set; }
    public int Vector3dListPt = 0;

    public DwgFiler() {
        m_Position          = 0;
        m_FilerType         = FilerType.CopyFiler;
        m_FilerStatus       = ErrorStatus.OK;

        AddressList         = new List<IntPtr>();
        BinaryChunkList     = new List<byte[]>();
        BooleanList         = new List<bool>();
        ByteList            = new List<byte>();
        BytesList           = new List<byte[]>();
        DoubleList          = new List<double>();
        HandleList          = new List<Handle>();
        HardOwnershipIdList = new List<ObjectId>();
        HardPointerIdList   = new List<ObjectId>();
        Int16List           = new List<short>();
        Int32List           = new List<int>();
#if !NET35
        Int64List           = new List<long>();
#endif
        Point2dList         = new List<Point2d>();
        Point3dList         = new List<Point3d>();
        Scale3dList         = new List<Scale3d>();
        SoftOwnershipIdList = new List<ObjectId>();
        SoftPointerIdList   = new List<ObjectId>();
        StringList          = new List<string>();
        Uint16List          = new List<ushort>();
        Uint32List          = new List<uint>();
#if !NET35
        Uint64List          = new List<ulong>();
#endif
        Vector2dList        = new List<Vector2d>();
        Vector3dList        = new List<Vector3d>();
    }

#if NET35
    public override int Position => m_Position;
#else
    public override long Position => m_Position;
#endif
    public override FilerType FilerType => this.m_FilerType;

    public override ErrorStatus FilerStatus {
        get => m_FilerStatus;
        set => m_FilerStatus = value;
    }

    public override IntPtr ReadAddress() {
        if (AddressList.Count() == 0) return new IntPtr();
        return AddressList[AddressListPt++];
    }

    public override byte[] ReadBinaryChunk() {
        if (BinaryChunkList.Count() == 0) return new byte[0];
        return BinaryChunkList[BinaryChunkListPt++];
    }

    public override bool ReadBoolean() {
        if (BooleanList.Count() == 0) return false;
        return BooleanList[BooleanListPt++];
    }

    public override byte ReadByte() {
        if (ByteList.Count() == 0) return 0;
        return ByteList[ByteListPt++];
    }

    public override void ReadBytes(byte[] value) {
        if (ByteList.Count() == 0) return;
        value = new byte[BytesList[BytesListPt].Length];
        BytesList[BytesListPt++].CopyTo(value, 0);
    }

    public override double ReadDouble() {
        if (DoubleList.Count() == 0) return 0;
        return DoubleList[DoubleListPt++];
    }

    public override Handle ReadHandle() {
        if (HandleList.Count() == 0) return new Handle();
        return HandleList[HandleListPt++];
    }

    public override ObjectId ReadHardOwnershipId() {
        if (HardOwnershipIdList.Count() == 0) return new ObjectId();
        return HardOwnershipIdList[HardOwnershipIdListPt++];
    }

    public override ObjectId ReadHardPointerId() {
        if (HardPointerIdList.Count() == 0) return new ObjectId();
        return HardPointerIdList[HardPointerIdListPt++];
    }

    public override short ReadInt16() {
        if (Int16List.Count() == 0) return 0;
        return Int16List[Int16ListPt++];
    }

    public override int ReadInt32() {
        if (Int32List.Count() == 0) return 0;
        return Int32List[Int32ListPt++];
    }

#if !NET35
    public override long ReadInt64() {
        if (Int64List.Count() == 0) return 0;
        return Int64List[Int64ListPt++];
    }
#endif

    public override Point2d ReadPoint2d() {
        if (Point2dList.Count() == 0) return new Point2d();
        return Point2dList[Point2dListPt++];
    }

    public override Point3d ReadPoint3d() {
        if (Point3dList.Count() == 0) return new Point3d();
        return Point3dList[Point3dListPt++];
    }

    public override Scale3d ReadScale3d() {
        if (Scale3dList.Count() == 0) return new Scale3d();
        return Scale3dList[Scale3dListPt++];
    }

    public override ObjectId ReadSoftOwnershipId() {
        if (SoftOwnershipIdList.Count() == 0) return new ObjectId();
        return SoftOwnershipIdList[SoftOwnershipIdListPt++];
    }

    public override ObjectId ReadSoftPointerId() {
        if (SoftPointerIdList.Count() == 0) return new ObjectId();
        return SoftPointerIdList[SoftPointerIdListPt++];
    }

    public override string ReadString() {
        if (StringList.Count() == 0) return "";
        return StringList[StringListPt++];
     }

    public override ushort ReadUInt16() {
        if (Uint16List.Count() == 0) return 0;
        return Uint16List[uint16ListPt++];
    }

    public override uint ReadUInt32() {
        if (Uint32List.Count() == 0) return 0;
        return Uint32List[uint32ListPt++];
    }

#if !NET35
    public override ulong ReadUInt64() {
        if (Uint64List.Count() == 0) return 0;
        return Uint64List[uint64ListPt++];
    }
#endif

    public override Vector2d ReadVector2d() {
        if (Vector2dList.Count() == 0) return new Vector2d();
        return Vector2dList[Vector2dListPt++];
    }

    public override Vector3d ReadVector3d() {
        if (Vector3dList.Count() == 0) return new Vector3d();
        return Vector3dList[Vector3dListPt++];
    }

    public override void ResetFilerStatus() {
            AddressList.Clear();
            AddressListPt = 0;
            BinaryChunkList.Clear();
            BinaryChunkListPt = 0;
            BooleanList.Clear();
            BooleanListPt = 0;
            ByteList.Clear();
            ByteListPt = 0;
            BytesList.Clear();
            BytesListPt = 0;
            DoubleList.Clear();
            DoubleListPt = 0;
            HandleList.Clear();
            HandleListPt = 0;
            HardOwnershipIdList.Clear();
            HardOwnershipIdListPt = 0;
            HardPointerIdList.Clear();
            HardPointerIdListPt = 0;
            Int16List.Clear();
            Int16ListPt = 0;
            Int32List.Clear();
            Int32ListPt = 0;
#if !NET35
            Int64List.Clear();
            Int64ListPt = 0;
#endif
            Point2dList.Clear();
            Point2dListPt = 0;
            Point3dList.Clear();
            Point3dListPt = 0;
            Scale3dList.Clear();
            Scale3dListPt = 0;
            SoftOwnershipIdList.Clear();
            SoftOwnershipIdListPt = 0;
            SoftPointerIdList.Clear();
            SoftPointerIdListPt = 0;
            StringList.Clear();
            StringListPt = 0;
            Uint16List.Clear();
            uint16ListPt = 0;
            Uint32List.Clear();
            uint32ListPt = 0;
#if !NET35
            Uint64List.Clear();
            uint64ListPt = 0;
#endif
            Vector2dList.Clear();
            Vector2dListPt = 0;
            Vector3dList.Clear();
            Vector3dListPt = 0;

            m_FilerType = FilerType.CopyFiler;
    }

#if NET35
    public override void Seek(int offset, int method) {
        Editor ed = Acap.DocumentManager.MdiActiveDocument.Editor;
        ed.WriteMessage(MethodInfo.GetCurrentMethod().Name + " = " + " \n ");
    }
#else
    public override void Seek(long offset, int method) {
        Editor ed = Acap.DocumentManager.MdiActiveDocument.Editor;
        ed.WriteMessage(MethodInfo.GetCurrentMethod().Name + " = " + " \n ");
    }
#endif
    public override void WriteAddress(IntPtr value) => AddressList.Add(value);
    public override void WriteBinaryChunk(byte[] chunk) => BinaryChunkList.Add(chunk);
    public override void WriteBoolean(bool value) => BooleanList.Add(value);
    public override void WriteByte(byte value) => ByteList.Add(value);
    public override void WriteBytes(byte[] value) => BytesList.Add(value);
    public override void WriteDouble(double value) => DoubleList.Add(value);
    public override void WriteHandle(Handle handle) => HandleList.Add(handle);
    public override void WriteHardOwnershipId(ObjectId value) => HardOwnershipIdList.Add(value);
    public override void WriteHardPointerId(ObjectId value) => HardPointerIdList.Add(value);
    public override void WriteInt16(short value) => Int16List.Add(value);
    public override void WriteInt32(int value) => Int32List.Add(value);
#if !NET35
    public override void WriteInt64(long value) => Int64List.Add(value);
#endif
    public override void WritePoint2d(Point2d value) => Point2dList.Add(value);
    public override void WritePoint3d(Point3d value) => Point3dList.Add(value);
    public override void WriteScale3d(Scale3d value) => Scale3dList.Add(value);
    public override void WriteSoftOwnershipId(ObjectId value) => SoftOwnershipIdList.Add(value);
    public override void WriteSoftPointerId(ObjectId value) => SoftPointerIdList.Add(value);
    public override void WriteString(string value) => StringList.Add(value);
    public override void WriteUInt16(ushort value) => Uint16List.Add(value);
    public override void WriteUInt32(uint value) => Uint32List.Add(value);
#if !NET35
    public override void WriteUInt64(ulong value) => Uint64List.Add(value);
#endif
    public override void WriteVector2d(Vector2d value) => Vector2dList.Add(value);
    public override void WriteVector3d(Vector3d value) => Vector3dList.Add(value);
    public override string ToString() {
            int ptCount = AddressListPt +
                          BinaryChunkListPt +
                          BooleanListPt +
                          ByteListPt +
                          BytesListPt +
                          DoubleListPt +
                          HandleListPt +
                          HardOwnershipIdListPt +
                          HardPointerIdListPt +
                          Int16ListPt +
                          Int32ListPt +
#if !NET35
                          Int64ListPt +
                          uint64ListPt +
#endif
                          Point2dListPt +
                          Point3dListPt +
                          Scale3dListPt +
                          SoftOwnershipIdListPt +
                          SoftPointerIdListPt +
                          StringListPt +
                          uint16ListPt +
                          uint32ListPt +
                          Vector2dListPt +
                          Vector3dListPt;

            int ltCount = AddressList.Count() +
                          BinaryChunkList.Count() +
                          BooleanList.Count() +
                          ByteList.Count() +
                          BytesList.Count() +
                          DoubleList.Count() +
                          HandleList.Count() +
                          HardOwnershipIdList.Count() +
                          HardPointerIdList.Count() +
                          Int16List.Count() +
                          Int32List.Count() +
#if !NET35
                          Int64List.Count() +
                          Uint64List.Count() +
#endif
                          Point2dList.Count() +
                          Point3dList.Count() +
                          Scale3dList.Count() +
                          SoftOwnershipIdList.Count() +
                          SoftPointerIdList.Count() +
                          StringList.Count() +
                          Uint16List.Count() +
                          Uint32List.Count() +
                          Vector2dList.Count() +
                          Vector3dList.Count();

            return "\nDataIn::" + ptCount + "\nDataOut::" + ltCount;
        }
    }
}

(完)