AutoCAD & Dynamic LINQ

csharp · 发表于 2014-6-11 23:03:50

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

×

/// Excerpts from AcDbLinq.cs Copyright (c) 2008-2013 Tony Tanzillo
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Internal;
using System.Collections;
namespace Autodesk.AutoCAD.DatabaseServices
{
public static class AcDbLinqExtensions
{
/// <summary>
///
/// Returns an object that enumerates all references
/// to all blocks whose names match the given wildcard
/// pattern, open for read.
///
/// Requires an active transaction (NOT an OpenCloseTransaction)
///
/// </summary>
///
public static IEnumerable<BlockReference> GetBlockReferences(
this Database database,
string pattern )
{
if( string.IsNullOrWhiteSpace( pattern ) )
throw new ArgumentException( "Requires a wildcard pattern" );
if( database == null )
throw new ArgumentNullException( "database" );
Transaction tr = database.TransactionManager.TopTransaction;
if( tr == null )
throw new Autodesk.AutoCAD.Runtime.Exception(
ErrorStatus.NoActiveTransactions );
BlockTable blockTable = (BlockTable)
tr.GetObject( database.BlockTableId, OpenMode.ForRead );
return blockTable.Cast<ObjectId>()
.GetObjects<BlockTableRecord>()
.Where( btr => Utils.WcMatchEx( btr.Name, pattern, true ) )
.SelectMany( btr => btr.GetBlockReferences() );
}
/// <summary>
/// Gets an object that enumerates all references to the given
/// BlockTableRecord, including references to anonymous dynamic
/// BlockTableRecords, open for read.
/// </summary>
public static IEnumerable<BlockReference> GetBlockReferences(
this BlockTableRecord btr,
OpenMode mode = OpenMode.ForRead,
bool directOnly = true )
{
if( btr == null )
throw new ArgumentNullException( "btr" );
var tr = btr.Database.TransactionManager.TopTransaction;
if( tr == null )
throw new InvalidOperationException( "No transaction" );
var ids = btr.GetBlockReferenceIds( directOnly, true );
int cnt = ids.Count;
for( int i = 0; i < cnt; i++ )
{
yield return (BlockReference)
tr.GetObject( ids[i], mode, false, false );
}
if( btr.IsDynamicBlock )
{
BlockTableRecord btr2 = null;
var blockIds = btr.GetAnonymousBlockIds();
cnt = blockIds.Count;
for( int i = 0; i < cnt; i++ )
{
btr2 = (BlockTableRecord) tr.GetObject( blockIds[i],
OpenMode.ForRead, false, false );
ids = btr2.GetBlockReferenceIds( directOnly, true );
int cnt2 = ids.Count;
for( int j = 0; j < cnt2; j++ )
{
yield return (BlockReference)
tr.GetObject( ids[j], mode, false, false );
}
}
}
}
/// <summary>
/// The one, but not only GetObjects<T> (abridged), with due credits
/// to Jeff H, kaefer, Gile, et. al.
///
/// Returns an object that enumerates all instances of the
/// given generic argument type, opened accoring to the given
/// parameters.
/// </summary>
public static IEnumerable<T> GetObjects<T>(
this IEnumerable<ObjectId> ids,
OpenMode mode = OpenMode.ForRead,
bool openErased = false,
bool forceOpenOnLockedLayers = false ) where T : DBObject
{
if( ids.Any() )
{
TransactionManager tm = ids.First().Database.TransactionManager;
RXClass rxclass = RXClass.GetClass( typeof( T ) );
if( typeof( T ) == typeof( DBObject ) )
{
foreach( ObjectId id in ids )
{
yield return (T) tm.GetObject( id, mode, openErased,
forceOpenOnLockedLayers );
}
}
else if( rxclass.GetHasChildren() )
{
foreach( ObjectId id in ids )
{
if( id.ObjectClass.IsDerivedFrom( rxclass ) )
yield return (T) tm.GetObject( id, mode, openErased,
forceOpenOnLockedLayers );
}
}
else
{
foreach( ObjectId id in ids )
{
if( id.ObjectClass == rxclass )
yield return (T) tm.GetObject( id, mode, openErased,
forceOpenOnLockedLayers );
}
}
}
}
// Returns true if at least one RXClass is derived from
// the given RXClass:
public static bool GetHasChildren( this RXClass rxclass )
{
foreach( DictionaryEntry e in SystemObjects.ClassDictionary )
{
if( rxclass == ( (RXClass) e.Value ).MyParent )
return true;
}
return false;
}
}
}

/// Excerpts from AcDbLinq.cs  Copyright (c)  2008-2013 Tony Tanzillo 
 
 
 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using Autodesk.AutoCAD.Runtime; 
using Autodesk.AutoCAD.Internal; 
using System.Collections; 
 
 
namespace Autodesk.AutoCAD.DatabaseServices 
{ 
   public static class AcDbLinqExtensions 
   { 
 
      /// <summary> 
      /// 
      /// Returns an object that enumerates all references 
      /// to all blocks whose names match the given wildcard 
      /// pattern, open for read. 
      /// 
      /// Requires an active transaction (NOT an OpenCloseTransaction) 
      /// 
      /// </summary> 
      ///   
 
      public static IEnumerable<BlockReference> GetBlockReferences( 
         this Database database, 
         string pattern ) 
      { 
         if( string.IsNullOrWhiteSpace( pattern ) ) 
            throw new ArgumentException( "Requires a wildcard pattern" ); 
         if( database == null ) 
            throw new ArgumentNullException( "database" ); 
         Transaction tr = database.TransactionManager.TopTransaction; 
         if( tr == null ) 
            throw new Autodesk.AutoCAD.Runtime.Exception( 
               ErrorStatus.NoActiveTransactions ); 
         BlockTable blockTable = (BlockTable) 
            tr.GetObject( database.BlockTableId, OpenMode.ForRead ); 
         return blockTable.Cast<ObjectId>() 
            .GetObjects<BlockTableRecord>() 
            .Where( btr => Utils.WcMatchEx( btr.Name, pattern, true ) ) 
            .SelectMany( btr => btr.GetBlockReferences() ); 
      } 
 
         /// <summary> 
         /// Gets an object that enumerates all references to the given 
         /// BlockTableRecord, including references to anonymous dynamic 
         /// BlockTableRecords, open for read. 
         /// </summary> 
 
      public static IEnumerable<BlockReference> GetBlockReferences( 
         this BlockTableRecord btr, 
         OpenMode mode = OpenMode.ForRead, 
         bool directOnly = true ) 
      { 
         if( btr == null ) 
            throw new ArgumentNullException( "btr" ); 
         var tr = btr.Database.TransactionManager.TopTransaction; 
 
         if( tr == null ) 
            throw new InvalidOperationException( "No transaction" ); 
         var ids = btr.GetBlockReferenceIds( directOnly, true ); 
 
         int cnt = ids.Count; 
         for( int i = 0; i < cnt; i++ ) 
         { 
            yield return (BlockReference) 
               tr.GetObject( ids[i], mode, false, false ); 
         } 
 
         if( btr.IsDynamicBlock ) 
         { 
            BlockTableRecord btr2 = null; 
            var blockIds = btr.GetAnonymousBlockIds(); 
            cnt = blockIds.Count; 
            for( int i = 0; i < cnt; i++ ) 
            { 
               btr2 = (BlockTableRecord) tr.GetObject( blockIds[i], 
                  OpenMode.ForRead, false, false ); 
               ids = btr2.GetBlockReferenceIds( directOnly, true ); 
               int cnt2 = ids.Count; 
               for( int j = 0; j < cnt2; j++ ) 
               { 
                  yield return (BlockReference) 
                     tr.GetObject( ids[j], mode, false, false ); 
               } 
            } 
         } 
      } 
 
       /// <summary> 
      /// The one, but not only GetObjects<T> (abridged), with due credits 
      /// to Jeff H, kaefer, Gile, et. al. 
      /// 
      /// Returns an object that enumerates all instances of the 
      /// given generic argument type, opened accoring to the given 
      /// parameters. 
      /// </summary> 
 
      public static IEnumerable<T> GetObjects<T>( 
          this IEnumerable<ObjectId> ids, 
          OpenMode mode = OpenMode.ForRead, 
          bool openErased = false, 
          bool forceOpenOnLockedLayers = false ) where T : DBObject 
      { 
 
         if( ids.Any() ) 
         { 
            TransactionManager tm = ids.First().Database.TransactionManager; 
 
            RXClass rxclass = RXClass.GetClass( typeof( T ) ); 
            if( typeof( T ) == typeof( DBObject ) ) 
            { 
               foreach( ObjectId id in ids ) 
               { 
                  yield return (T) tm.GetObject( id, mode, openErased, 
                     forceOpenOnLockedLayers ); 
               } 
            } 
 
            else if( rxclass.GetHasChildren() ) 
            { 
               foreach( ObjectId id in ids ) 
               { 
                  if( id.ObjectClass.IsDerivedFrom( rxclass ) ) 
                     yield return (T) tm.GetObject( id, mode, openErased, 
                        forceOpenOnLockedLayers ); 
               } 
            } 
            else 
            { 
               foreach( ObjectId id in ids ) 
               { 
                  if( id.ObjectClass == rxclass ) 
                     yield return (T) tm.GetObject( id, mode, openErased, 
                        forceOpenOnLockedLayers ); 
               } 
            } 
         } 
      } 
 
      // Returns true if at least one RXClass is derived from 
      // the given RXClass: 
 
      public static bool GetHasChildren( this RXClass rxclass ) 
      { 
         foreach( DictionaryEntry e in SystemObjects.ClassDictionary ) 
         { 
            if( rxclass == ( (RXClass) e.Value ).MyParent ) 
               return true; 
         } 
         return false; 
      } 
   } 
 
}

csharp · 发表于 2014-6-11 23:05:27

RXClass rxc = RXClass.GetClass(typeof(BlockReference));
 return btr.Cast<ObjectId>()
 .Where(id => id.ObjectClass == rxc)
 .Select(id => (BlockReference)id.GetObject(OpenMode.ForRead))
 .Where(br =>
 (br.IsDynamicBlock ?
 ((BlockTableRecord)br.DynamicBlockTableRecord.GetObject(OpenMode.ForRead)).Name :
 br.Name) == pattern);;

csharp · 发表于 2014-6-11 23:13:50

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
namespace DynamicExpression.Example
{
public static class DynamicExpressionTest
{
/// <summary>
/// This example requires the DynamicExpression API referenced at:
/// http://weblogs.asp.net/scottgu/archive/dynamic-linq-part- -using-the-linq-dynamic-query-library.aspx
///
/// The DXTEST command excercises rudimentary use of DynamicExpression to
/// generate a query expression from a string. In this example, the string
/// is hard-coded, but might just as easily be derived from user input, etc.,
/// at runtime in real world use. In essence, DynamicExpression implements
/// a very basic, rudimentary query language that has a syntax designed to
/// be familiar to C#, VB and SQL users.
///
/// It should be noted however, that direct use of user-supplied query
/// strings can be dangerous, without extensive error checking.
///
/// This example will obtain all insertions of the block named 'DOOR'
/// that are inserted on the layer named 'LEVEL ', and change their
/// color to red. Note that the dynamic expression is not used to
/// filter entities by type, as this is done using ObjectIds rather
/// than opened DBObjects. Hence, the input sequence contains only
/// BlockReference objects and is the type which the query operates
/// on and whose properties are used in the query string.
///
/// The example code also requires the AutoCAD Linq Extension Library
/// which is included (AcDbLinq.cs).
///
/// </summary>
[CommandMethod("DXTEST")]
public static void Method()
{
Document doc = Application.DocumentManager.MdiActiveDocument;
using( Transaction tr = doc.TransactionManager.StartTransaction() )
{
/// This returns an object that iterates over all BlockRefence
/// objects in model space:
var blockrefs = doc.Database.GetModelSpace<BlockReference>().AsQueryable();
/// There are three basic ways to compose a query string, and which is
/// best depends on where the parameters are coming from, and where the
/// query string itself comes from. For example, only the parameters
/// may be supplied by the user, or the entire query string may be
/// supplied by the user.
///
/// The first way is simply to express it as a literal string, using
/// escaped double-quotes to surround string constants, thusly:
/// var query = blockrefs.Where( "Name == "DOOR" && Layer = "LEVEL "" );
///
/// Another way of doing it is by constructing the entire
/// query string using String.Format():
///
/// string queryString = string.Format(
/// "Name == "{ }" AND Layer == "{ }"", "DOOR", "LEVEL " );
/// var query = blockrefs.Where( queryString );
///
/// And lastly, and the one we actually use here, is by using replacements,
/// which has the advantage of not requiring string parameters to be
/// surrounded by double quotes, presumably because the type of a parameter
/// can be inferred by the type of the expression on the left side of the
/// relational operator:
///
var query = blockrefs.Where( "Name == @ && Layer == @ ", "DOOR", "LEVEL " );
/// The above 'query' var is an IQueryable<BlockReference>, which implicitly
/// is an IEnumerable<BlockReference> that we can walk using foreach():
foreach( BlockReference door in query.UpgradeOpen() )
{
door.ColorIndex = 1;
}
tr.Commit();
}
}
/// <summary>
///
/// A variation on the above that uses pattern matching for the
/// layer name, and selects all insertions of 'DOOR' from model
/// space, that reside on any layer whose name starts with "LEVEL".
/// Matching is achieved using the string.StartsWith() method
/// within the query expression.
///
/// </summary>
[CommandMethod("DXTEST ")]
public static void Method()
{
Document doc = Application.DocumentManager.MdiActiveDocument;
using( Transaction tr = doc.TransactionManager.StartTransaction() )
{
var blockrefs = doc.Database.GetModelSpace<BlockReference>().AsQueryable();
var query = blockrefs.Where( "Name == @ && Layer.StartsWith(@ )", "DOOR", "LEVEL" );
foreach( BlockReference door in query.UpgradeOpen() )
{
door.ColorIndex = 1;
}
tr.Commit();
}
}
/// <summary>
/// This is a variation of the above example that uses DynamicExpression
/// to filter the initial set of ObjectIds and the opened BlockReferences.
/// </summary>
[CommandMethod("DXTEST ")]
public static void Method()
{
Document doc = Application.DocumentManager.MdiActiveDocument;
using( Transaction tr = doc.TransactionManager.StartTransaction() )
{
var ids = doc.Database.GetModelSpaceIds().AsQueryable();
var blockrefIds = ids.Where( "ObjectClass.DxfName == @ ", "INSERT" );
var query = blockrefIds.GetObjects<BlockReference>().AsQueryable()
.Where( "Name == @ && Layer.StartsWith(@ )", "DOOR", "LEVEL" );
foreach( BlockReference door in query.UpgradeOpen() )
{
door.ColorIndex = 1;
}
tr.Commit();
}
}
}
}

using Autodesk.AutoCAD.ApplicationServices; 
using Autodesk.AutoCAD.DatabaseServices; 
using Autodesk.AutoCAD.Runtime; 
 
namespace DynamicExpression.Example 
{ 
 
    public static class DynamicExpressionTest 
    { 
 
 
        /// <summary> 
        /// This example requires the DynamicExpression API referenced at: 
        /// http://weblogs.asp.net/scottgu/archive/dynamic-linq-part- -using-the-linq-dynamic-query-library.aspx 
        /// 
        /// The DXTEST command excercises rudimentary use of DynamicExpression to 
        /// generate a query expression from a string. In this example, the string 
        /// is hard-coded, but might just as easily be derived from user input, etc., 
        /// at runtime in real world use. In essence, DynamicExpression implements 
        /// a very basic, rudimentary query language that has a syntax designed to 
        /// be familiar to C#, VB and SQL users. 
        /// 
        /// It should be noted however, that direct use of user-supplied query 
        /// strings can be dangerous, without extensive error checking. 
        /// 
        /// This example will obtain all insertions of the block named 'DOOR' 
        /// that are inserted on the layer named 'LEVEL ', and change their 
        /// color to red. Note that the dynamic expression is not used to 
        /// filter entities by type, as this is done using ObjectIds rather 
        /// than opened DBObjects. Hence, the input sequence contains only 
        /// BlockReference objects and is the type which the query operates 
        /// on and whose properties are used in the query string. 
        /// 
        /// The example code also requires the AutoCAD Linq Extension Library 
        /// which is included (AcDbLinq.cs). 
        /// 
        /// </summary> 
 
        [CommandMethod("DXTEST")] 
        public static void Method() 
       { 
          Document doc = Application.DocumentManager.MdiActiveDocument; 
          using( Transaction tr = doc.TransactionManager.StartTransaction() ) 
          { 
              /// This returns an object that iterates over all BlockRefence 
             /// objects in model space: 
 
             var blockrefs = doc.Database.GetModelSpace<BlockReference>().AsQueryable(); 
 
             /// There are three basic ways to compose a query string, and which is 
             ///  best depends on where the parameters are coming from, and where the 
             /// query string itself comes from. For example, only the parameters 
             /// may be supplied by the user, or the entire query string may be 
             /// supplied by the user. 
             /// 
                         /// The first way is simply to express it as a literal string, using 
             /// escaped double-quotes to surround string constants, thusly: 
             /// var query = blockrefs.Where( "Name == "DOOR" && Layer = "LEVEL "" ); 
             /// 
                         /// Another way of doing it is by constructing the entire 
                         /// query string using String.Format(): 
                         /// 
                         /// string queryString = string.Format( 
                         ///      "Name == "{ }" AND Layer == "{ }"", "DOOR", "LEVEL " ); 
                         /// var query = blockrefs.Where( queryString ); 
                         /// 
                         /// And lastly, and the one we actually use here, is by using replacements, 
                         /// which has the advantage of not requiring string parameters to be 
                         /// surrounded by double quotes, presumably because the type of a parameter 
                         /// can be inferred by the type of the expression on the left side of the 
                         /// relational operator: 
                         /// 
             var query = blockrefs.Where( "Name == @  && Layer == @ ", "DOOR", "LEVEL " ); 
 
             /// The above 'query' var is an IQueryable<BlockReference>, which implicitly 
             /// is an IEnumerable<BlockReference> that we can walk using foreach(): 
 
             foreach( BlockReference door in query.UpgradeOpen() ) 
             { 
                door.ColorIndex = 1; 
             } 
             tr.Commit(); 
          } 
       } 
 
        /// <summary> 
        /// 
        /// A variation on the above that uses pattern matching for the 
        /// layer name, and selects all insertions of 'DOOR' from model 
        ///  space, that reside on any layer whose name starts with "LEVEL". 
        /// Matching is achieved using the string.StartsWith() method 
        /// within the query expression. 
        /// 
        /// </summary> 
 
        [CommandMethod("DXTEST ")] 
        public static void Method() 
        { 
           Document doc = Application.DocumentManager.MdiActiveDocument; 
           using( Transaction tr = doc.TransactionManager.StartTransaction() ) 
           { 
              var blockrefs = doc.Database.GetModelSpace<BlockReference>().AsQueryable(); 
              var query = blockrefs.Where( "Name == @  && Layer.StartsWith(@ )", "DOOR", "LEVEL" ); 
              foreach( BlockReference door in query.UpgradeOpen() ) 
              { 
                 door.ColorIndex =  1; 
              } 
              tr.Commit(); 
           } 
        } 
                
        /// <summary> 
        /// This is a variation of the above example that uses DynamicExpression 
        /// to filter the initial set of ObjectIds and the opened BlockReferences. 
        /// </summary> 
                
        [CommandMethod("DXTEST ")] 
        public static void Method() 
        { 
           Document doc = Application.DocumentManager.MdiActiveDocument; 
           using( Transaction tr = doc.TransactionManager.StartTransaction() ) 
           { 
              var ids = doc.Database.GetModelSpaceIds().AsQueryable(); 
              var blockrefIds = ids.Where( "ObjectClass.DxfName == @ ", "INSERT" ); 
              var query = blockrefIds.GetObjects<BlockReference>().AsQueryable() 
                 .Where( "Name == @  && Layer.StartsWith(@ )", "DOOR", "LEVEL" ); 
              foreach( BlockReference door in query.UpgradeOpen() ) 
              { 
                 door.ColorIndex =  1; 
              } 
               tr.Commit(); 
           } 
        } 
    } 
}

csharp · 发表于 2014-6-11 23:15:00

static class Extensions
{
 public static T GetObject<T>(this ObjectId id) where T : DBObject
 {
 return (T)id.GetObject(OpenMode.ForRead);
 }

 public static IEnumerable<T> GetObjects<T>(this SymbolTable source) where T : SymbolTableRecord
 {
 foreach (ObjectId id in source)
 yield return (T)id.GetObject(OpenMode.ForRead);
 }

 public static IEnumerable<BlockReference> GetBlockReferences(this BlockTableRecord btr, ObjectId ownerId)
 {
 return btr.GetStaticReferences(ownerId)
 .Concat(btr.GetAnonymousBlockIds()
 .Cast<ObjectId>()
 .SelectMany(id => id.GetObject<BlockTableRecord>().GetStaticReferences(ownerId)));
 }

 public static IEnumerable<BlockReference> GetBlockReferences(this Database db, string pattern, ObjectId ownerId)
 {
 return db.BlockTableId
 .GetObject<BlockTable>()
 .GetObjects<BlockTableRecord>()
 .Where(btr => Autodesk.AutoCAD.Internal.Utils.WcMatch(btr.Name, pattern))
 .SelectMany(btr => btr.GetBlockReferences(ownerId));
 }

 static IEnumerable<BlockReference> GetStaticReferences(this BlockTableRecord btr, ObjectId ownerId)
 {
 return btr.GetBlockReferenceIds(true, false)
 .Cast<ObjectId>()
 .Select(id => id.GetObject<BlockReference>())
 .Where(br => br.OwnerId == ownerId);
 }
}

csharp · 发表于 2014-6-23 00:37:38

csharp · 发表于 2014-6-23 00:39:31

// Get all items from drawing Database. All ObjectIds will grouped by types;
Database db = Application.DocumentManager.MdiActiveDocument.Database;
Dictionary<string, List<ObjectId>> dict = new Dictionary<string, List<ObjectId>>();
using (Transaction t = db.TransactionManager.StartTransaction()) {
for (long i = db.BlockTableId.Handle.Value; i < db.Handseed.Value; i++) {
 ObjectId id = ObjectId.Null;
 Handle h = new Handle(i);
 if (db.TryGetObjectId(h, out id)) {
 string type = id.ObjectClass.Name;
 if (!dict.Keys.Contains(type))
 dict.Add(type, new List<ObjectId>());
 dict[type].Add(id);
 }
}
t.Commit();
}

csharp · 发表于 2014-6-23 01:18:37

[CommandMethod("GetAllRectangles")]
public static void GetCircles()
{
Document document = Application.DocumentManager.MdiActiveDocument;
Database database = document.Database;
Editor editor = document.Editor;
RXClass rxClassPoly = RXClass.GetClass(typeof (Polyline));
var count = 0;

using (Transaction transaction = document.TransactionManager.StartOpenCloseTransaction())
{
      var blockTable = transaction.GetObject(database.BlockTableId, OpenMode.ForWrite, false) as BlockTable;
var blocktableRecord = transaction.GetObject(blockTable[BlockTableRecord.ModelSpace], OpenMode.ForRead, false) as BlockTableRecord;
foreach (ObjectId objectId in blocktableRecord)
{
      if (objectId.ObjectClass == rxClassPoly)
      {
         var poly = transaction.GetObject(objectId, OpenMode.ForRead) as Polyline;
if (poly.Layer == "0" && poly != null)
{
      if (poly.NumberOfVertices == 4)
      {
         var line0 = poly.GetLineSegmentAt(0);
         var line1 = poly.GetLineSegmentAt(1);
         var line2 = poly.GetLineSegmentAt(2);
         var line3 = poly.GetLineSegmentAt(3);

         if (line0.IsPerpendicularTo(line1) && line1.IsPerpendicularTo(line2) &&
                        line2.IsPerpendicularTo(line3) && line3.IsPerpendicularTo(line0))
         {
            count = count + 1;

      // Put all your rectangle processing code here.

         }
               }
         }
         }
      }
      transaction.Commit();
}
editor.WriteMessage(string.Format("\r\nFound {0} rectangles!", count));
}

csharp · 发表于 2014-6-23 22:06:55

private static List<BlockReference> GetBlockRefs(string blkName, Document dwg)
{
List<BlockReference> blks = null;

Database db = dwg.Database;
using (Transaction tran = db.TransactionManager.StartTransaction())
{
 BlockTable tbl =
 (BlockTable)tran.GetObject(db.BlockTableId, OpenMode.ForRead);

 //Get modelspace BloclTableRecord
 BlockTableRecord br =
 (BlockTableRecord)tran.GetObject(tbl[BlockTableRecord.ModelSpace], OpenMode.ForRead);

 //Cast the BlockTableRecord into IEnumeralbe<T> collection
 IEnumerable<ObjectId> b = br.Cast<ObjectId>();

 //Use lambda extension method
 blks = b.Where(id => id.ObjectClass.DxfName.ToUpper() == "INSERT")
 .Select(id => GetBlockRef(id, tran)).ToList<BlockReference>();

 //Use LINQ statement. This is more readable
 blks = (from id in b
 where id.ObjectClass.DxfName.ToUpper() == "INSERT"
 select GetBlockRef(id, tran)).ToList<BlockReference>();

 tran.Commit();
}

//return only blockreferences with name starting with blkName with lambda extension method
return blks.Where(b => b.Name.ToUpper() == blkName.ToUpper()).ToList();

//Or return with LINQ statement
return (from b in blks where b.Name.ToUpper() == blkName.ToUpper() select b).ToList();
}

csharp · 发表于 2014-6-23 22:09:25

private static string[] GetBlockNameList(Document dwg)
{
string[] names = null;

Database db = dwg.Database;
using (Transaction tran = db.TransactionManager.StartTransaction())
{
 BlockTable tbl =
 (BlockTable)tran.GetObject(db.BlockTableId, OpenMode.ForRead);

 //Get modelspace BloclTableRecord
 BlockTableRecord br =
 (BlockTableRecord)tran.GetObject(tbl[BlockTableRecord.ModelSpace], OpenMode.ForRead);

 //Cast the BlockTableRecord into IEnumeralbe<T> collection
 IEnumerable<ObjectId> b = br.Cast<ObjectId>();

 //Use lambda extension method
 names = b.Where(id => id.ObjectClass.DxfName.ToUpper() == "INSERT")
 .Select(id => GetBlockRef(id, tran).Name).Distinct().ToArray();

 //Use LINQ statement. This is more readable
 names = (from id in b
 where id.ObjectClass.DxfName.ToUpper().Contains("INSERT")
 select GetBlockRef(id, tran).Name).Distinct().ToArray();

 tran.Commit();
}

return names;
}

csharp · 发表于 2014-6-23 22:11:41

本帖最后由 csharp 于 2014-6-23 22:12 编辑

private List<ObjectId> GetCertainEntityIDs(Database db)
{
List<ObjectId> ids = null;
using (Transaction tran = db.TransactionManager.StartTransaction())
{
 BlockTable tbl =
 (BlockTable)tran.GetObject(db.BlockTableId, OpenMode.ForRead);
 //Get modelspace BloclTableRecord
 BlockTableRecord br =
 (BlockTableRecord)tran.GetObject(tbl[BlockTableRecord.ModelSpace], OpenMode.ForRead);
 //Cast the BlockTableRecord into IEnumeralbe<T> collection
 IEnumerable<ObjectId> b = br.Cast<ObjectId>();
 //==============search certain entity========================//
 //"LINE" for line
 //"LWPOLYLINE" for polyline
 //"CIRCLE" for circle
 //"INSERT" for block reference
 //...
 //We can use "||" (or) to search for more then one entity types
 //============================================================//
 //Use lambda extension method
 ids = b.Where(id => id.ObjectClass.DxfName.ToUpper() == "LINE" ||
 id.ObjectClass.DxfName.ToUpper() == "LWPOLYLINE").ToList<ObjectId>();
 //Use LINQ statement. This is more readable
 ids = (from id in b
 where id.ObjectClass.DxfName.ToUpper() == "LINE" ||
 id.ObjectClass.DxfName.ToUpper() == "LWPOLYLINE"
 select id).ToList<ObjectId>();
 tran.Commit();
}
return ids;
}

csharp · 发表于 2014-6-23 22:13:46

private static string[] GetEntityType(Document dwg)
{
string[] types = null;

Database db = dwg.Database;
using (Transaction tran = db.TransactionManager.StartTransaction())
{
 BlockTable tbl =
 (BlockTable)tran.GetObject(db.BlockTableId, OpenMode.ForRead);

 //Get modelspace BloclTableRecord
 BlockTableRecord br =
 (BlockTableRecord)tran.GetObject(tbl[BlockTableRecord.ModelSpace], OpenMode.ForRead);

 //Cast the BlockTableRecord into IEnumeralbe<T> collection
 IEnumerable<ObjectId> b = br.Cast<ObjectId>();

 //Use lambda extension method
 types = b.Select(id => id.ObjectClass.DxfName).Distinct().ToArray();

 //Use LINQ statement. This is more readable
 types = (from id in b select id.ObjectClass.DxfName).Distinct().ToArray();

 tran.Commit();
}

return types;
}

账号		自动登录	找回密码
密码			立即注册

[分享] AutoCAD & Dynamic LINQ

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

相关帖子