ResultBuffer简化类

雪山飞狐_lzh · 发表于 2010-1-4 14:31:00

经常要做些选择集的过滤器，然而.Net的过滤器写起来真的很繁琐
所以。。。
ResultList类，原创是TonyT，：）

using System;
using System.Collections.Generic;
using System.Text;
using Autodesk..DatabaseServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
namespace TlsCad.Collections
{
    /// 
    /// TypedValue Collection
    /// 
    public class ResultList : List, IFormattable
    {
        public ResultList(){ }
        public ResultList(IEnumerable values) : base(values)
        { }
        public ResultList(ResultBuffer rb) : base(rb.AsArray())
        { }
        #region Add
        public void Add(int typeCode, object obj)
        {
            base.Add(new TypedValue(typeCode, obj));
        }
        public void Add(LispDataType type, object obj)
        {
            base.Add(new TypedValue((int)type, obj));
        }
        public void Add(DxfCode type, object obj)
        {
            base.Add(new TypedValue((int)type, obj));
        }
        #endregion
        #region Convert
        public static implicit operator TypedValue[](ResultList rlst)
        {
            return rlst.ToArray();
        }
        public static implicit operator ResultBuffer(ResultList rlst)
        {
            return new ResultBuffer(rlst.ToArray());
        }
        public static implicit operator SelectionFilter(ResultList rlst)
        {
            return new SelectionFilter(rlst.ToArray());
        }
        #endregion
        #region IFormattable 成员
        public override string ToString()
        {
            var rb = new ResultBuffer(ToArray());
            return rb.ToString();
        }
        string IFormattable.ToString(string format, IFormatProvider formatProvider)
        {
            var rb = new ResultBuffer(ToArray());
            return rb.ToString(format, formatProvider);
        }
        #endregion
    }
}

ResultTree类，原创飞狐

copy

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
using System.Collections;
namespace TlsCad.Collections
{
    
    public enum ResultTreeType
    {
        Node,
        List,
        DottedPair,
        RelationalOperator,
        LogicalOperator,
    }
    
    /// 
    /// TypedValue Tree
    /// 
    public class ResultTree : IEnumerable, IFormattable
    {
        ResultTreeType _treeType;
        ResultTree _owner;
        TypedValue _typedValue;
        List _lst = new List();
        static readonly List _relationalOperatorNames =
            new List { "not", "and", "or", "xor" };
        #region Properties
        public ResultTree this[int index]
        {
            get
            {
                if (_lst.Count == 0)
                {
                    if(index == 0)
                    {
                        return this;
                    }
                }
                else
                {
                    if (index >= 0 && index ()
        {
            return (T)_typedValue.Value;
        }
        #endregion
        #region Constructor
        public ResultTree()
        {
            _treeType = ResultTreeType.Node;
        }
        public ResultTree(TypedValue value)
            :this()
        {
            _typedValue = value;
        }
        public ResultTree(int typeCode, object obj)
            : this(new TypedValue(typeCode, obj))
        { }
        public ResultTree(LispDataType type, object obj)
            : this(new TypedValue((int)type, obj))
        { }
        public ResultTree(DxfCode type, object obj)
            : this(new TypedValue((int)type, obj))
        { }        public ResultTree(string operatorContext)
        {
            operatorContext = operatorContext.ToLower();
            _treeType = 
                _relationalOperatorNames.Contains(operatorContext) ?
                ResultTreeType.RelationalOperator : ResultTreeType.LogicalOperator;
            _typedValue = new TypedValue(-4, operatorContext);
        }
        public ResultTree(ResultTreeType type)
        {
            _treeType = type;
        }
        private enum ResultNodeType
        {
            Node,
            ListBegin,
            ListEnd,
            DottedPairEnd,
            LogicalOperator,
            RelationalOperatorBegin,
            RelationalOperatorEnd,
        }
        private ResultNodeType GetNodeType(TypedValue tvalue, out ResultTree rt)
        {
            short typeCode = tvalue.TypeCode;
            object value = tvalue.Value;
            rt = null;
            
            if (typeCode == -4)
            {
                string s = ((string)value).ToLower();
                if(s[0] == '' && _relationalOperatorNames.Contains(s.Substring(0, s.Length - 1)))
                {
                    return ResultNodeType.RelationalOperatorEnd;
                }
                else
                {
                    rt = new ResultTree(s);
                    return ResultNodeType.LogicalOperator;
                }
            }
            else if(typeCode == (short)LispDataType.ListBegin)
            {
                rt = new ResultTree(ResultTreeType.List);
                return ResultNodeType.ListBegin;
            }
            else if(typeCode == (short)LispDataType.ListEnd)
            {
                return ResultNodeType.ListEnd;
            }
            else if(typeCode == (short)LispDataType.DottedPair)
            {
                return ResultNodeType.DottedPairEnd;
            }
            else
            {
                rt = new ResultTree(tvalue);
                return ResultNodeType.Node;
            }
        }
        public ResultTree(ResultBuffer rb)
        {
            ResultTree rt = this;
            foreach (TypedValue tv in rb)
            {
                ResultTree trt;
                switch (GetNodeType(tv, out trt))
                {
                    case ResultNodeType.LogicalOperator:
                    case ResultNodeType.RelationalOperatorBegin:
                    case ResultNodeType.ListBegin:
                        rt = rt.Add(trt);
                        break;
                    case ResultNodeType.DottedPairEnd:
                        rt._treeType = ResultTreeType.DottedPair;
                        rt = rt._owner;
                        break;
                    case ResultNodeType.RelationalOperatorEnd:
                    case ResultNodeType.ListEnd:
                        rt = rt._owner;
                        break;
                    default:
                        rt.Add(trt);
                        if (rt._treeType == ResultTreeType.RelationalOperator)
                            rt = rt._owner;
                        break;
                }
            }
            if (_lst.Count == 1)
            {
                rt = _lst[0];
                _lst.Remove(rt);
                _lst.AddRange(rt);
                _treeType = rt._treeType;
                _typedValue = rt._typedValue;
            }
        }
        #endregion
        #region Set
        public void Set(int typeCode, object obj)
        {
            _typedValue = new TypedValue(typeCode, obj);
        }
        public void Set(LispDataType type, object obj)
        {
            _typedValue = new TypedValue((int)type, obj);
        }
        public void Set(DxfCode type, object obj)
        {
            _typedValue = new TypedValue((int)type, obj);
        }        public void Set(int typeCode)
        {
            _typedValue = new TypedValue(typeCode);
        }
        public void Set(LispDataType type)
        {
            _typedValue = new TypedValue((int)type);
        }
        public void Set(DxfCode type)
        {
            _typedValue = new TypedValue((int)type);
        }
        #endregion
        #region Add
        public ResultTree Add(TypedValue value)
        {
            return Add(new ResultTree(value));
        }
        public ResultTree Add(int typeCode, object obj)
        {
            return Add(new ResultTree(typeCode, obj));
        }
        public ResultTree Add(LispDataType type, object obj)
        {
            return Add(new ResultTree(type, obj));
        }
        public ResultTree Add(DxfCode type, object obj)
        {
            return Add(new ResultTree(type, obj));
        }
        public ResultTree Add(ResultTree rt)
        {
            rt._owner = this;
            _lst.Add(rt);
            return rt;
        }
        #region Add LispData
        public ResultTree Add(short value)
        {
            return Add(new ResultTree(LispDataType.Int16, value));
        }
        public ResultTree Add(int value)
        {
            return Add(new ResultTree(LispDataType.Int32, value));
        }
        public ResultTree Add(double value)
        {
            return Add(new ResultTree(LispDataType.Double, value));
        }
        public ResultTree Add(string value)
        {
            return Add(new ResultTree(LispDataType.Text, value));
        }
        public ResultTree Add(Point2d value)
        {
            return Add(new ResultTree(LispDataType.Point2d, value));
        }
        public ResultTree Add(Point3d value)
        {
            return Add(new ResultTree(LispDataType.Point3d, value));
        }
        public ResultTree Add(ObjectId value)
        {
            return Add(new ResultTree(LispDataType.ObjectId, value));
        }
        public ResultTree Add(SelectionSet value)
        {
            return Add(new ResultTree(LispDataType.SelectionSet, value));
        }
        //public void Add(ResultType type, params object[] values)
        //{
        //    ResultTree rt = new ResultTree(type);
        //    foreach (object value in values)
        //    {
        //        if (value is short)
        //        {
        //            rt.Add((short)value);
        //        }
        //        else if (value is int)
        //        {
        //            rt.Add((int)value);
        //        }
        //        else if (value is double)
        //        {
        //            rt.Add((double)value);
        //        }
        //        else if (value is string)
        //        {
        //            rt.Add((string)value);
        //        }
        //        else if (value is Point2d)
        //        {
        //            rt.Add((Point2d)value);
        //        }
        //        else if (value is Point3d)
        //        {
        //            rt.Add((Point3d)value);
        //        }
        //        else if (value is ObjectId)
        //        {
        //            rt.Add((ObjectId)value);
        //        }
        //        else if (value is SelectionSet)
        //        {
        //            rt.Add((SelectionSet)value);
        //        }
        //    }
        //}
        #endregion
        #endregion
        #region Convert
        private void GetValues(List values)
        {
            switch (_treeType)
            {
                case  ResultTreeType.Node:
                    if (_lst.Count == 0)
                    {
                        values.Add(_typedValue);
                    }
                    else
                    {
                        _lst.ForEach(rtree => rtree.GetValues(values));
                    }
                    break;
                case ResultTreeType.List:
                    values.Add(new TypedValue((int)LispDataType.ListBegin));
                    _lst.ForEach(rtree => rtree.GetValues(values));
                    values.Add(new TypedValue((int)LispDataType.ListEnd));
                    break;
                case ResultTreeType.DottedPair:
                    values.Add(new TypedValue((int)LispDataType.ListBegin));
                    _lst.ForEach(rtree => rtree.GetValues(values));
                    values.Add(new TypedValue((int)LispDataType.DottedPair));
                    break;
                case ResultTreeType.LogicalOperator:
                    values.Add(_typedValue);
                    _lst.ForEach(rtree => rtree.GetValues(values));
                    break;
                case ResultTreeType.RelationalOperator:
                    values.Add(new TypedValue(-4, " rtree.GetValues(values));
                    values.Add(new TypedValue(-4, _typedValue.Value + ">"));
                    break;
            }
        }
        public TypedValue[] ToArray()
        {
            List values = new List();
            GetValues(values);
            return values.ToArray();
        }
        public static implicit operator SelectionFilter(ResultTree rtree)
        {
            return new SelectionFilter(rtree.ToArray()); 
        }
        public static implicit operator ResultBuffer(ResultTree rtree)
        {
            return new ResultBuffer(rtree.ToArray());
        }
        #endregion
        #region RelationalOperator
        private void MakeRelationalOperator(string operatorContext, ResultTree res)
        {
            if (_treeType == ResultTreeType.RelationalOperator && _typedValue.Value.ToString() == operatorContext)
            {
                res._lst.AddRange(_lst);
            }
            else
            {
                res.Add(this);
            }
        }
        public static ResultTree operator !(ResultTree rt1)
        {
            ResultTree rt = new ResultTree("not") { rt1 };
            return rt;
        }
        public static ResultTree operator &(ResultTree rt1, ResultTree rt2)
        {
            ResultTree rt = new ResultTree("and");
            rt1.MakeRelationalOperator("and", rt);
            rt2.MakeRelationalOperator("and", rt);
            return rt;
        }
        public static ResultTree operator |(ResultTree rt1, ResultTree rt2)
        {
            ResultTree rt = new ResultTree("or");
            rt1.MakeRelationalOperator("or", rt);
            rt2.MakeRelationalOperator("or", rt);
            return rt;
        }
        public static ResultTree operator ^(ResultTree rt1, ResultTree rt2)
        {
            return
                new ResultTree("xor")
                {
                    rt1,
                    rt2
                };
        }
        #endregion
        
        #region IFormattable 成员
        public override string ToString()
        {
            var rb = new ResultBuffer(ToArray());
            return rb.ToString();
        }
        string IFormattable.ToString(string format, IFormatProvider formatProvider)
        {
            var rb = new ResultBuffer(ToArray());
            return rb.ToString(format, formatProvider);
        }
        #endregion
        #region IEnumerable 成员
        #region IEnumerable 成员
        IEnumerator IEnumerable.GetEnumerator()
        {
            return _lst.GetEnumerator();
        }
        #endregion
        IEnumerator IEnumerable.GetEnumerator()
        {
            return _lst.GetEnumerator();
        }
        #endregion
    }
}

扩展方法

copy


 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TlsCad.Collections;
using Autodesk.AutoCAD.DatabaseServices;
namespace TlsCad.ExtendMethods
{
    public static class ResultBufferEx
    {
        public static ResultList ToList(this ResultBuffer rb)
        {
            return new ResultList(rb);
        }
        public static ResultTree ToTree(this ResultBuffer rb)
        {
            return new ResultTree(rb);
        }
    }
}

示例代码

copy


        [CommandMethod("t9")]
        public static void Test9()
        {
            Document doc = Application.DocumentManager.MdiActiveDocument;
            Database db = doc.Database;
            Editor ed = doc.Editor;
            PromptSelectionResult res1 =
                ed.SelectAll(
                    new ResultTree
                    {
                        new ResultTree(">,>,*")
                        {
                            {10, new Point3d()}
                        },
                        new ResultTree(",>,*"},
                        {10, new Point3d()},
                        {-4, ""},
                            {-4, ""},
                        {-4, "or>"}
                    });        }
        [CommandMethod("t10")]
        public static void Test10()
        {
            Document doc = Application.DocumentManager.MdiActiveDocument;
            Database db = doc.Database;
            Editor ed = doc.Editor;
            PromptEntityResult res = ed.GetEntity("Select a Entity:");
            using (DBTransaction tr = new DBTransaction())
            {
                tr.OpenRegAppTable(OpenMode.ForWrite);
                tr.RegApp("MyApp");
                Entity ent = tr.GetObject(res.ObjectId, OpenMode.ForWrite) as Entity;
                ent.XData =
                    new ResultList 
                    {
                        {1001, "MyApp"},
                        {1000, "This is a Test"},
                        {DxfCode.ExtendedDataInteger16, 12}
                    };
            }
        }
        [CommandMethod("t11")]
        public static void Test11()
        {
            Document doc = Application.DocumentManager.MdiActiveDocument;
            Database db = doc.Database;
            Editor ed = doc.Editor;
            PromptEntityResult res1 = ed.GetEntity("\nSelect a Entity:");
            InvokeArx.CmdEcho = false;
            InvokeArx.Command(
                false,
                new ResultTree
                {
                    "break",
                    new ResultTree(ResultType.List)
                    {
                        res1.ObjectId,
                        res1.PickedPoint
                    },
                    res1.PickedPoint
                });
            InvokeArx.CmdEcho = true;
        }
        [LispFunction("lsptest1")]
        public static ResultBuffer LTest1(ResultBuffer rb)
        {
            ResultTree rtree =
                new ResultTree(ResultType.List) 
                { 
                    1,
                    new ResultTree(ResultType.DottedPair)
                    {
                        10,
                        new Point3d(10, 10, 0)
                    }
                };
            return rtree;
        }

雪山飞狐_lzh · 发表于 2010-1-4 14:33:00

不过，简化写法必须在VS2008及以上版本才支持

雪山飞狐_lzh · 发表于 2010-1-4 21:24:00

ResultTree的操作符重载版本(一楼代码已更改)，这样写挺好玩的，：）
测试代码复制代码返回：
((-4,)(-4,and>)(-4,)(-4,or>))

游天居士 · 发表于 2010-1-4 21:36:00

个人觉得还是太麻烦。实际可能少用到。我就没有这样用过。

single-yu · 发表于 2010-1-4 21:37:00

顶我们的狐老大，哈哈！

雪山飞狐_lzh · 发表于 2010-7-9 15:53:00

更新版本，增加与ResultBuffer的互相转换，增强Lisp相关操作
简化选择集中逻辑表达式的写法（见示例）

LispFunction的相关示例

copy

        [LispFunction("mylisp1")]
        public object lsptest11(ResultBuffer rb)
        {
            ResultTree rt = rb.ToTree();
            switch (rt.TreeType)
            {
                case ResultTreeType.Node:
                    switch (rt.LispDataType)
                    {
                        case LispDataType.Point2d:
                            Point2d pt2d = rt.GetValue();
                            rt.Set(LispDataType.Point2d, new Point2d(10, pt2d.Y));
                            break;
                        case LispDataType.Point3d:
                            Point3d pt3d = rt.GetValue();
                            rt.Set(LispDataType.Point3d, new Point3d(10, pt3d.Y, pt3d.Z));
                            break;
                    }
                    break;
                case ResultTreeType.List:
                case ResultTreeType.DottedPair:
                    rt[0].Set(LispDataType.Int16, 10);
                    return (ResultBuffer)rt;
            }
            return rt.TypedValue;
        }

效果：复制代码

Student · 发表于 2010-7-13 22:01:00

好。

Rain_Franklin · 发表于 2010-8-24 17:32:00

必须留言 .... 好东西呀

arxnew · 发表于 2010-10-2 15:35:00

好东西，学习中

河伯 · 发表于 2011-1-24 10:01:00

lisp传递参数的ResultBuffer，有时表被当成点对，如何解决？
//Lisp：第二个参数是四个整数
(TTT "AAA" (list 10 20 30 40) 12.36)
//.NET：把(list 10 20 30 40)当成点对，得到一个Point3D(20,30,40)，显然不对
Public Sub TTT(ByVal rbArgs As ResultBuffer)
'rbArgs
End Sub

ResultBuffer简化类

发表回复

精选推荐

浏览过的版块