C# ObjectId.Open方法代码示例

 public void AddMarkToPanelBtr(string panelMark, ObjectId idBtr)
 {
     using (BlockTableRecord btr = idBtr.Open(OpenMode.ForWrite) as BlockTableRecord)
      {
     foreach (ObjectId idEnt in btr)
     {
        if (idEnt.ObjectClass.Name == "AcDbText" || idEnt.ObjectClass.Name == "AcDbHatch")
        {
           using (Entity entity = idEnt.Open( OpenMode.ForRead, false, true) as Entity)
           {
              if (string.Equals(entity.Layer, Settings.Default.LayerMarks, StringComparison.OrdinalIgnoreCase))
              {
                 try
                 {
                    entity.UpgradeOpen();
                    entity.Erase(true);
                 }
                 catch (Exception ex)
                 {
                    Logger.Log.Error(ex, "AddMarkToPanelBtr - entity.UpgradeOpen();");
                 }
              }
           }
        }
     }
     if (panelMark.EndsWith(")"))
     {
        CreateCaptionMarkAr(panelMark, btr);
     }
     else
     {
        CreateCaptionMarkSb(panelMark, btr);
     }
      }
 }

 public static void AddError(string message, ObjectId idEnt)
 {
    using (var ent = idEnt.Open(OpenMode.ForRead) as Entity)
    {
       AddError(message, ent);
    }
 }      

 public Isoline(ObjectId id)
 {
    IdCurve = id;
    using (var curve = id.Open(OpenMode.ForRead, false, true) as Curve)
    {
       getIsolineProperties(curve);
    }
 }

 public LayerInfo(ObjectId idLayer)
 {
     using (var layer = idLayer.Open( OpenMode.ForRead)as LayerTableRecord)
     {
         Name = layer.Name;
         Color = layer.Color;
         LineWeight = layer.LineWeight;
         IsPlotable = true;
     }
 }

 private ObjectId checkBlock(ObjectId idBlRef, string errMsg, out bool isOk)
 {
     if (idBlRef.IsNull)
      {
     Inspector.AddError(errMsg, icon: System.Drawing.SystemIcons.Error);
     isOk = false;
     return ObjectId.Null;
      }
      using (var blRefCover = idBlRef.Open(OpenMode.ForRead, false, true) as BlockReference)
      {
     isOk = true;
     return blRefCover.BlockTableRecord;
      }
 }

 ///// <summary>
 ///// Копирование определенич блока из внешнего чертежа
 ///// </summary>
 ///// <param name="blName">Имя блока</param>
 ///// <param name="fileDrawing">Полный путь к чертежу из которого копируется блок</param>
 ///// <param name="destDb">База чертежа в который копируетсяя блок</param>
 ///// <exception cref="Exception">Если нет блока в файле fileDrawing.</exception>
 //public static void CopyBlockFromExternalDrawing(string blName, string fileDrawing, Database destDb)
 //{
 //   using (var extDb = new Database(false, true))
 //   {
 //      extDb.ReadDwgFile(fileDrawing, System.IO.FileShare.ReadWrite, true, "");
 //      ObjectIdCollection ids = new ObjectIdCollection();
 //      using (var t = extDb.TransactionManager.StartTransaction())
 //      {
 //         var bt = (BlockTable)t.GetObject(extDb.BlockTableId, OpenMode.ForRead);
 //         if (bt.Has(blName))
 //         {
 //            ids.Add(bt[blName]);
 //         }
 //         else
 //         {
 //            throw new Exception(string.Format("Не найдено определение блока {0} в файле {1}", blName, fileDrawing));
 //         }
 //         t.Commit();
 //      }
 //      // Если нашли – добавим блок
 //      if (ids.Count != 0)
 //      {
 //         // Получаем текущую базу чертежа
 //         IdMapping iMap = new IdMapping();
 //         destDb.WblockCloneObjects(ids, destDb.BlockTableId, iMap, DuplicateRecordCloning.Ignore, false);
 //      }
 //   }
 //}
 /// <summary>
 /// Копирование определения блока и добавление его в таблицу блоков.
 /// </summary>
 /// <param name="idBtrSource">Копируемый блок</param>
 /// <param name="name">Имя для нового блока</param>
 /// <returns>ID скопированного блока, или существующего в чертеже с таким именем.</returns>
 public static ObjectId CopyBtr(ObjectId idBtrSource, string name)
 {
     ObjectId idBtrCopy = ObjectId.Null;
      Database db = idBtrSource.Database;
      ObjectIdCollection ids = new ObjectIdCollection ();
      using (var btrSource = idBtrSource.Open(OpenMode.ForRead) as BlockTableRecord)
      {
     using (var bt = db.BlockTableId.Open( OpenMode.ForRead) as BlockTable)
     {
        //проверка имени блока
        if (bt.Has(name))
        {
           idBtrCopy = bt[name];
        }
        else
        {
           using (var btrCopy = btrSource.Clone() as BlockTableRecord)
           {
              btrCopy.Name = name;
              bt.UpgradeOpen();
              idBtrCopy = bt.Add(btrCopy);
              // Объекты в блоке для копирования
              foreach (ObjectId idEnt in btrSource)
              {
                 ids.Add(idEnt);
              }
           }
        }
     }
      }
      if (ids.Count>0)
      {
     // Копирование объектов блока
     IdMapping map = new IdMapping();
     db.DeepCloneObjects(ids, idBtrCopy, map, false);
      }
      return idBtrCopy;
 }

        public static List<AttributeRefInfo> GetAttrDefs(ObjectId idBtr)
        {
            List<AttributeRefInfo> resVal = new List<AttributeRefInfo>();

             if (!idBtr.IsNull)
             {
            using (var btr = idBtr.Open(OpenMode.ForRead) as BlockTableRecord)
            {
               foreach (var idEnt in btr)
               {
                  using (var attrDef = idEnt.Open(OpenMode.ForRead, false, true) as AttributeDefinition)
                  {
                     if (attrDef != null)
                     {
                        var attrDefInfo = new AttributeRefInfo((DBText)attrDef);
                        resVal.Add(attrDefInfo);
                     }
                  }
               }
            }
             }
             return resVal;
        }

        public void Check(ObjectId idBlRefFrame)
        {
            if (idBlRefFrame.IsNull)
             {
            Inspector.AddError($"Блок '{Settings.Default.BlockFrameName}' не найден.", icon: System.Drawing.SystemIcons.Error);
            return;
             }

             using (var blRefFrame = idBlRefFrame.Open(OpenMode.ForRead, false, true) as BlockReference)
             {
            _idBtrFrame = blRefFrame.BlockTableRecord;
            if (blRefFrame.AttributeCollection == null)
            {
               Inspector.AddError($"Блок '{Settings.Default.BlockFrameName}' не соответствует требованиям. У него должны быть атрибуты: Наименование, Вид, Лист.",
                                 icon: System.Drawing.SystemIcons.Error);
               return;
            }
            _attrs = new Dictionary<string, string>();
            foreach (ObjectId idAtrRef in blRefFrame.AttributeCollection)
            {
               using (var atrRef = idAtrRef.Open(OpenMode.ForRead, false, true) as AttributeReference)
               {
                  string key = atrRef.Tag.ToUpper();
                  if (!_attrs.ContainsKey(key))
                  {
                     string text;
                     if (atrRef.IsMTextAttribute)
                     {
                        text = atrRef.MTextAttribute.Contents;
                     }
                     else
                     {
                        text = atrRef.TextString;
                     }
                     _attrs.Add(key, text);
                  }
               }
            }

            string errMsg = string.Empty;
            if (!_attrs.ContainsKey("ВИД"))
            {
               errMsg += "Не найден атибут ВИД. ";
            }
            if (!_attrs.ContainsKey("НАИМЕНОВАНИЕ"))
            {
               errMsg += "Не найден атибут НАИМЕНОВАНИЕ. ";
            }
            if (!_attrs.ContainsKey("ЛИСТ"))
            {
               errMsg += "Не найден атибут ЛИСТ. ";
            }
            if (!string.IsNullOrEmpty(errMsg))
            {
               Inspector.AddError($"Ошибки в блоке {Settings.Default.BlockFrameName}: {blRefFrame}", icon: System.Drawing.SystemIcons.Error);
            }
            else
            {
               IsOk = true;
            }
             }
        }

 private ObjectId getFirstBlRefInModel(ObjectId idBtrFrame, ObjectId msId)
 {
     using (var btr = idBtrFrame.Open( OpenMode.ForRead) as BlockTableRecord)
      {
     var idsBlRef = btr.GetBlockReferenceIds(true, false);
     foreach (ObjectId idBlRef in idsBlRef)
     {
        using (var blRef = idBlRef.Open( OpenMode.ForRead, false, true) as BlockReference)
        {
           if (blRef.OwnerId == msId)
           {
              return idBlRef;
           }
        }
     }
      }
      return ObjectId.Null;
 }

 public void DefineGeom(ObjectId idBtrPanelAkr)
 {
     string blName;
     _extentsTiles = new Extents3d();
     using (var btrAkr = idBtrPanelAkr.Open(OpenMode.ForRead) as BlockTableRecord)
     {
         blName = btrAkr.Name;
         foreach (ObjectId idEnt in btrAkr)
         {
             if (idEnt.ObjectClass.Name == "AcDbBlockReference")
             {
                 using (var blRefTile = idEnt.Open(OpenMode.ForRead, false, true) as BlockReference)
                 {
                     if (string.Equals(blRefTile.GetEffectiveName(), Settings.Default.BlockTileName, StringComparison.CurrentCultureIgnoreCase))
                     {
                         _extentsTiles.AddExtents(blRefTile.GeometricExtents);
                     }
                 }
             }
         }
         Image = AcadLib.Blocks.Visual.BlockPreviewHelper.GetPreview(btrAkr);
     }
     HeightPanelByTile = _extentsTiles.MaxPoint.Y - _extentsTiles.MinPoint.Y + Settings.Default.TileSeam;
     double shiftEnd = 0;
     if (blName.IndexOf(Settings.Default.EndLeftPanelSuffix, StringComparison.OrdinalIgnoreCase) != -1)
     {
         shiftEnd = -Settings.Default.FacadeEndsPanelIndent * 0.5;// 445;// Торец слева - сдвинуть влево FacadeEndsPanelIndent
     }
     else if (blName.IndexOf(Settings.Default.EndRightPanelSuffix, StringComparison.OrdinalIgnoreCase) != -1)
     {
         shiftEnd = -Settings.Default.FacadeEndsPanelIndent * 0.5;// 445;// Торец спрва - сдвинуть вправо
     }
     var test = _extentsTiles.MaxPoint.X - _extentsTiles.MinPoint.X;
     //_distToCenterFromBase = (_extentsTiles.MaxPoint.X - _extentsTiles.MinPoint.X) * 0.5 + shiftEnd;
 }

 private ObjectId getAttrDef(ObjectId idBtr, string tag)
 {
     ObjectId idAttrDef = ObjectId.Null;
      if (!idBtr.IsNull)
      {
     using (var btr = idBtr.Open(OpenMode.ForRead) as BlockTableRecord)
     {
        foreach (ObjectId idEnt in btr)
        {
           using (var attrDef = idEnt.Open(OpenMode.ForRead, false, true) as AttributeDefinition)
           {
              if (attrDef == null) continue;
              if (!attrDef.Constant && attrDef.Tag.Equals(tag, StringComparison.OrdinalIgnoreCase))
              {
                 idAttrDef = idEnt;
                 break;
              }
           }
        }
     }
      }
      return idAttrDef;
 }

 /// <summary>
 /// Поиск квартир в чертеже.
 /// </summary>      
 public static List<RevitBlock> GetChilds(ObjectId idBtr, string patternBlockNameMatch)
 {
     List<RevitBlock> places = new List<RevitBlock>();
      using (var btrParent = idBtr.Open(OpenMode.ForRead) as BlockTableRecord)
      {
     foreach (ObjectId idEnt in btrParent)
     {
        using (var blRefChild = idEnt.Open(OpenMode.ForRead, false, true) as BlockReference)
        {
           if (blRefChild != null)
           {
              string blName = blRefChild.GetEffectiveName();
              if (IsRevitBlockName(blName, patternBlockNameMatch))
              {
                 try
                 {
                    var place = new RevitBlock(blRefChild, blName);
                    places.Add(place);
                 }
                 catch (System.Exception ex)
                 {
                    Inspector.AddError($"Ошибка считывания блока квартиры {blName} - {ex.Message}.",
                       blRefChild, icon: SystemIcons.Error);
                 }
              }
              else
              {
                 Inspector.AddError($"Отфильтрован блок квартиры '{blName}', имя не соответствует " +
                    $"'{Options.Instance.BlockApartmentNameMatch}",
                    blRefChild, icon: SystemIcons.Information);
              }
           }
        }
     }
      }
      return places;
 }