public void DeleteTest()
{
DBDictionary dbDictionary = new DBDictionary();
dbDictionary.Connection = GetConnection();
dbDictionary.Delete("AEF29AAA-0F23-4ba3-AA10-BAE05B3E4503");
dbDictionary.Load("AEF29AAA-0F23-4ba3-AA10-BAE05B3E4503");
Assert.IsNull(dbDictionary.BusinessObject);
}
public static ObjectId CreateDivision(String division, String manager)
{
Database db = HostApplicationServices.WorkingDatabase;
using (Transaction trans = db.TransactionManager.StartTransaction())
{
//Define a corporate level dictionary
DBDictionary acmeDict;
//First, get the NOD...
DBDictionary NOD = (DBDictionary)trans.GetObject(db.NamedObjectsDictionaryId, OpenMode.ForRead, false);
try
{
//if it exists, just get it
acmeDict = (DBDictionary)trans.GetObject(NOD.GetAt("ACME_DIVISION"), OpenMode.ForRead);
}
catch
{
//Doesn//t exist, so create one
NOD.UpgradeOpen();
acmeDict = new DBDictionary();
NOD.SetAt("ACME_DIVISION", acmeDict);
trans.AddNewlyCreatedDBObject(acmeDict, true);
}
//Now get the division we want from acmeDict
DBDictionary divDict;
try
{
divDict = (DBDictionary)trans.GetObject(acmeDict.GetAt(division), OpenMode.ForWrite);
}
catch
{
acmeDict.UpgradeOpen();
divDict = new DBDictionary(); //Division doesn//t exist, create one
acmeDict.SetAt(division, divDict);
trans.AddNewlyCreatedDBObject(divDict, true);
}
//Now get the manager info from the division
//We need to add the name of the division supervisor. We//ll do this with another XRecord.
Xrecord mgrXRec;
try
{
mgrXRec = (Xrecord)trans.GetObject(divDict.GetAt("Department Manager"), OpenMode.ForWrite);
}
catch
{
mgrXRec = new Xrecord();
mgrXRec.Data = new ResultBuffer(new TypedValue((int)DxfCode.Text, manager));
divDict.SetAt("Department Manager", mgrXRec);
trans.AddNewlyCreatedDBObject(mgrXRec, true);
}
trans.Commit();
//return the department manager XRecord
return mgrXRec.ObjectId;
}
}
public void CollectionTest()
{
InsertTest();
DBDictionary dbDictionary = new DBDictionary();
dbDictionary.Connection = GetConnection();
DictionaryEntry entry = new DictionaryEntry();
entry.Active = true;
entry.Guid = "69E68ADF-A083-4889-BC11-8353B8CA5EAD";
entry.Name = "Test";
entry.Type = MWRCommonTypes.Enum.ObjectType.State;
dbDictionary.Save(entry);
DBDictionaryCollection collection = new DBDictionaryCollection(new SqlDataProvider());
collection.Connection = GetConnection();
collection.Load();
Assert.IsTrue(collection.List.Count == 2);
dbDictionary.Delete();
dbDictionary.Delete("AEF29AAA-0F23-4ba3-AA10-BAE05B3E4503");
}
/// <summary>
/// Agrega un diccionario al diccionario de extensión de una entidad
/// </summary>
/// <param name="dictionaryName">El nombre del diccionario</param>
/// <param name="ent">La entidad agregar el diccionario</param>
/// <returns>El object id del diccionario recien creado</returns>
public static ObjectId AddDictionary(Entity ent, String dictionaryName)
{
Database db = AcadApp.DocumentManager.MdiActiveDocument.Database;
ObjectId id = new ObjectId();
using (Transaction tr = db.TransactionManager.StartTransaction())
{
try
{
Entity e = (Entity)ent.ObjectId.GetObject(OpenMode.ForRead);
DBDictionary extDic;
if (e.ExtensionDictionary.IsValid)
{
extDic = (DBDictionary)e.ExtensionDictionary.GetObject(OpenMode.ForWrite);
}
else
{
e.UpgradeOpen();
e.CreateExtensionDictionary();
extDic = (DBDictionary)e.ExtensionDictionary.GetObject(OpenMode.ForWrite);
}
DBDictionary d = new DBDictionary();
extDic.SetAt(dictionaryName, d);
tr.AddNewlyCreatedDBObject(d, true);
id = d.ObjectId;
tr.Commit();
}
catch (AcadExc exc)
{
ed.WriteMessage(exc.Message);
tr.Abort();
}
catch (System.Exception exc)
{
ed.WriteMessage(exc.Message);
tr.Abort();
}
}
return(id);
}
// show all attributes of group object
// just for debug
// <param name="groupId">group id of object</param>
public static void showAttr(ObjectId groupId)
{
Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
Transaction trans = ed.Document.Database.TransactionManager.StartTransaction();
try
{
Group ent = (Group)trans.GetObject(groupId, OpenMode.ForRead);
// test the IsNull property of the ExtensionDictionary of the ent.
if (ent.ExtensionDictionary.IsNull)
{
return;
}
// variable as DBDictionary.
DBDictionary extensionDict = (DBDictionary)trans.GetObject(ent.ExtensionDictionary, OpenMode.ForRead);
DBObject dbObj;
foreach (System.Collections.DictionaryEntry dEntry in extensionDict)
{
dbObj = (DBObject)trans.GetObject((ObjectId)dEntry.Value, OpenMode.ForRead, false);
if (dbObj is DBDictionary)
{
}
else if (dbObj is Xrecord)
{
foreach (TypedValue value in (Xrecord)dbObj)
{
ed.WriteMessage("\n" + value.TypeCode.ToString() + " . " + value.Value.ToString());
}
}
}
}
catch (System.Exception e)
{
ed.WriteMessage("\n" + e.Message);
}
finally
{
trans.Dispose();
}
}
public override void Run(string filename, Database db)
{
using (Transaction tr = db.TransactionManager.StartTransaction())
{
try
{
if (db.TileMode)
{
DBDictionary layoutDictionary = (DBDictionary)tr.GetObject(db.LayoutDictionaryId, OpenMode.ForRead);
if (layoutDictionary.Count != 0)
{
foreach (DBDictionaryEntry entry in layoutDictionary)
{
Layout layout = tr.GetObject(entry.Value, OpenMode.ForRead, false) as Layout;
if (layout == null || layout.LayoutName == "Model" || layout.GetViewports().Count == 0)
{
continue;
}
else
{
db.TileMode = false;
BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
BlockTableRecord btr = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.PaperSpace], OpenMode.ForWrite);
btr.LayoutId = layout.Id;
break;
}
}
}
}
}
catch (Exception ex)
{
OnError(ex);
}
tr.Commit();
}
}
/// <summary>
/// objectIds에 들어있는 객체들로 group 객체를 생성합니다.
/// </summary>
/// <param name="groupName">Group의 이름입니다.</param>
/// <param name="objectIds">객체의 ID들 입니다.</param>
/// <returns></returns>
public static ObjectId CreateGroup(string groupName, ObjectIdCollection objectIds)
{
Document doc = DatabaseUtil.GetActiveDocument();
Database db = doc.Database;
ObjectId idResult = ObjectId.Null;
try
{
using (doc.LockDocument())
{
using (Transaction tr = DatabaseUtil.GetTransaction(db))
{
DBDictionary oGroupDict = tr.GetObject(db.GroupDictionaryId, OpenMode.ForWrite) as DBDictionary;
Group oGrp = null;
if (oGroupDict.Contains(groupName))
{
oGrp = oGroupDict[groupName] as Group;
oGrp.Clear();
}
oGrp = new Group(groupName, false); // 새로운 그룹생성
idResult = oGroupDict.SetAt(groupName, oGrp); // 그룹을 그룹DB에 등록하고, ObjectId를 저장한다.
tr.AddNewlyCreatedDBObject(oGrp, true); // 트랜잭션에 새로 추가
oGrp.InsertAt(0, objectIds); // 그룹에 객체를 추가합니다.
oGrp.Selectable = true; // 선택가능하게.
tr.Commit();
}
}
return(idResult);
}
catch (System.Exception ex)
{
return(ObjectId.Null);
}
}
public void Write(Database db, Transaction t)
{
try
{
DBDictionary parentDict = base.ParentDataset.Open(db, t, this.DictionaryName, (OpenMode)1);
DBDictionary dBDictionary = this.WriteMapDictionary(parentDict, t);
if (dBDictionary != null && this.Layers.Count > 0)
{
DBDictionary dBDictionary2 = new DBDictionary();
dBDictionary.SetAt("ESRI_Layers", dBDictionary2);
dBDictionary2.DisableUndoRecording(true);
t.AddNewlyCreatedDBObject(dBDictionary2, true);
foreach (MSCMapLayer current in this.Layers)
{
current.WriteMapLayer(dBDictionary2, t);
}
}
}
catch
{
}
}
public void Insert()
{
//ed.WriteMessage("Go to Insert \n");
Database db = Application.DocumentManager.MdiActiveDocument.Database;
using (DocumentLock docLock = Application.DocumentManager.MdiActiveDocument.LockDocument())
{
using (Transaction tr = db.TransactionManager.StartTransaction())
{
DBObject dbObject = tr.GetObject(SelectedObjectId, OpenMode.ForRead);
if (dbObject.ExtensionDictionary == ObjectId.Null)
{
dbObject.UpgradeOpen();
dbObject.CreateExtensionDictionary();
}
//ed.WriteMessage(" AT ParentCode : {0} \n", ParentCode);
//ed.WriteMessage(" AT NodeCode : {0} \n", NodeCode);
//ed.WriteMessage(" AT NodeType : {0} \n", NodeType);
//ed.WriteMessage(" AT ProductCode : {0} \n", ProductCode);
//ed.WriteMessage(" AT Angle : {0} \n", Angle);
DBDictionary ExtensionDictionary = (DBDictionary)tr.GetObject(dbObject.ExtensionDictionary, OpenMode.ForWrite);
Xrecord xrec = new Xrecord();
xrec.Data = new ResultBuffer(
new TypedValue((int)DxfCode.Text, ParentCode),
new TypedValue((int)DxfCode.Text, NodeCode),
new TypedValue((int)DxfCode.Int32, NodeType),
new TypedValue((int)DxfCode.Int32, ProductCode),
new TypedValue((int)DxfCode.Real, Angle));
ExtensionDictionary.SetAt("AT_INFO", xrec);
tr.AddNewlyCreatedDBObject(xrec, true);
tr.Commit();
}
}
}
public bool HitDataFilter(ObjectId oid, Transaction tr)
{
bool dataFlag = true;
var data = GetData();
if (data.Any())
{
dataFlag = false;
var obj = tr.GetObject(oid, OpenMode.ForRead);
if (obj != null)
{
if (!obj.ExtensionDictionary.IsNull && obj.ExtensionDictionary.IsValid)
{
using (DBDictionary dbextdic = tr.GetObject(obj.ExtensionDictionary, OpenMode.ForRead) as DBDictionary)
{
dataFlag = data.All(kv => IfEntityContainsKeyValue(dbextdic, kv, tr));
}
}
}
}
return(dataFlag);
}
/// <summary>
/// 将图形数据库与tdGenParas中的数据同步
/// </summary>
/// <param name="db">图形数据库</param>
/// <param name="tdGenParas">程序中的tdGenParas类</param>
public static void SyncDwgToTdGenParas(this Database db, TendonGeneralParameters tdGenParas)
{
using (Transaction trans = db.TransactionManager.StartTransaction())//开始事务处理
{
// 获取当前图形数据库的有名对象字典
DBDictionary dicts = db.NamedObjectsDictionaryId.GetObject(OpenMode.ForWrite) as DBDictionary;
ObjectId tdsDictId = new ObjectId(); //
if (!dicts.Contains("DA_Tendons")) //如果字典中不含DA_Tendons的字典项
{
tdsDictId = db.AddNamedDictionary("DA_Tendons"); //则添加该字典项
}
else//如果字典中含有DA_Tendons的字典项
{
tdsDictId = dicts.GetAt("DA_Tendons");//则获取该字典项
}
//将字典项内容与tdGenParas同步
//管道偏差系数
TypedValueList values = new TypedValueList();
values.Add(DxfCode.Real, tdGenParas.Kii);
tdsDictId.AddXrecord2DBDict("kii", values);
//摩阻系数
values = new TypedValueList();
values.Add(DxfCode.Real, tdGenParas.Miu);
tdsDictId.AddXrecord2DBDict("miu", values);
//钢束弹性模量
values = new TypedValueList();
values.Add(DxfCode.Real, tdGenParas.Ep);
tdsDictId.AddXrecord2DBDict("Ep", values);
//张拉控制应力
values = new TypedValueList();
values.Add(DxfCode.Real, tdGenParas.CtrlStress);
tdsDictId.AddXrecord2DBDict("ctrlStress", values);
//张拉端工作长度
values = new TypedValueList();
values.Add(DxfCode.Real, tdGenParas.WorkLen);
tdsDictId.AddXrecord2DBDict("workLen", values);
trans.Commit();//执行事务处理
}
}
GetRecursiveDictionaryEntries(ObjectId dictId, ref ObjectIdCollection objIds, ref ArrayList names)
{
// NOTE: when recursively processing items in a dictionary
// we may encounter things that are not derived from DBDictionary.
// In that case, the cast to type DBDictionary will fail and
// we'll just return without adding any nested items.
DBObject tmpObj = m_trHlp.Transaction.GetObject(dictId, OpenMode.ForRead);
DBDictionary dbDict = tmpObj as DBDictionary;
if (dbDict != null)
{
foreach (DictionaryEntry curEntry in dbDict)
{
objIds.Add((ObjectId)curEntry.Value);
names.Add((string)curEntry.Key);
// if this is a dictionary, it will recursively add
// all of its children to the tree
GetRecursiveDictionaryEntries((ObjectId)curEntry.Value, ref objIds, ref names);
}
}
}
/// <summary>
/// 获取对象的扩展字典中的扩展记录
/// </summary>
/// <param name="objId">对象的id</param>
/// <param name="xRecordSearchKey">扩展记录名称</param>
/// <returns></returns>
public static ResultBuffer GetObjXrecord(ObjectId objId, string xRecordSearchKey)
{
try
{
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
DocumentLock m_DocumentLock = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.LockDocument();
using (Transaction tr = db.TransactionManager.StartTransaction())
{
DBObject obj = objId.GetObject(OpenMode.ForRead); //以读的方式打开对象
ObjectId dictId = obj.ExtensionDictionary; //获取对象的扩展字典的id
if (dictId.IsNull)
{
tr.Commit();
m_DocumentLock.Dispose();
return(null); //若对象没有扩展字典，则返回null
}
DBDictionary dict = dictId.GetObject(OpenMode.ForRead) as DBDictionary; //获取对象的扩展字典
if (!dict.Contains(xRecordSearchKey))
{
tr.Commit();
m_DocumentLock.Dispose();
return(null);//如果扩展字典中没有包含指定关键字的扩展记录，则返回null；
}
//先要获取对象的扩展字典或图形中的有名对象字典，然后才能在字典中获取要查询的扩展记录
ObjectId xrecordId = dict.GetAt(xRecordSearchKey); //获取扩展记录对象的id
Xrecord xrecord = xrecordId.GetObject(OpenMode.ForRead) as Xrecord; //根据id获取扩展记录对象
ResultBuffer values = xrecord.Data;
tr.Commit();
m_DocumentLock.Dispose();
return(values);
}
}
catch (System.Exception ex)
{
System.Windows.Forms.MessageBox.Show("扩展属性读" + ex.Message);
return(null);
}
}
/// <summary>
/// 创建组
/// </summary>
/// <param name="db">数据库对象</param>
/// <param name="groupName">组名</param>
/// <param name="ids">要加入实体的ObjectId集合</param>
/// <returns>返回组的Id</returns>
public static ObjectId CreateGroup(this Database db, string groupName, ObjectIdList ids)
{
//打开当前数据库的组字典对象
DBDictionary groupDict = (DBDictionary)db.GroupDictionaryId.GetObject(OpenMode.ForRead);
//如果已经存在指定名称的组，则返回
if (groupDict.Contains(groupName))
{
return(ObjectId.Null);
}
//新建一个组对象
Group group = new Group(groupName, true);
groupDict.UpgradeOpen(); //切换组字典为写的状态
//在组字典中加入新创建的组对象，并指定它的搜索关键字为groupName
groupDict.SetAt(groupName, group);
//通知事务处理完成组对象的加入
db.TransactionManager.AddNewlyCreatedDBObject(group, true);
group.Append(ids); // 在组对象中加入实体对象
groupDict.DowngradeOpen(); //为了安全，将组字典切换成写
return(group.ObjectId); //返回组的Id
}
/// <summary>
/// Get database's dictionary id.
/// </summary>
/// <param name="database"></param>
/// <param name="dictName"></param>
/// <param name="createIfNotExisting"></param>
/// <returns></returns>
public static ObjectId GetNodDictionaryId(Database database, string dictName, bool createIfNotExisting)
{
var dictId = ObjectId.Null;
using (var transaction = database.TransactionManager.StartTransaction())
{
var nod = (DBDictionary)transaction.GetObject(database.NamedObjectsDictionaryId, OpenMode.ForRead);
if (!nod.Contains(dictName) && createIfNotExisting)
{
nod.UpgradeOpen();
var dict = new DBDictionary();
dictId = nod.SetAt(dictName, dict);
transaction.AddNewlyCreatedDBObject(dict, add: true);
}
else
{
dictId = nod.GetAt(dictName);
}
transaction.Commit();
}
return(dictId);
}
public void DelLayouts()
{
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
LayoutManager LMR = LayoutManager.Current;
ArrayList Layoutlist = new ArrayList();
using (Transaction Trans = db.TransactionManager.StartTransaction())
{
try
{
//获取布局列表(剔除模型空间)
DBDictionary Layouts = Trans.GetObject(db.LayoutDictionaryId, OpenMode.ForRead) as DBDictionary;
foreach (DBDictionaryEntry item in Layouts)
{
if (item.Key != "Model")
{
Layout layoutobject = Trans.GetObject(item.Value, OpenMode.ForRead) as Layout;
Layoutlist.Add(layoutobject);
}
}
Trans.Commit();
}
catch (Autodesk.AutoCAD.Runtime.Exception Ex)
{
ed.WriteMessage("出错啦！{0}", Ex.ToString());
}
finally
{
Trans.Dispose();
}
}
foreach (Layout LT in Layoutlist)
{
LMR.DeleteLayout(LT.LayoutName);
}
}
public static List <string> GetLayoutNames(FileInfo file)
{
var result = new List <string>();
if (file == null && !file.Exists || file.Extension.ToLower() != ".dwg")
{
return(result);
}
Database sourceDb = new Database(false, true);
sourceDb.ReadDwgFile(file.FullName, FileOpenMode.OpenForReadAndAllShare, true, "");
using (Transaction tr = sourceDb.TransactionManager.StartTransaction())
{
DBDictionary lays = tr.GetObject(sourceDb.LayoutDictionaryId, OpenMode.ForRead) as DBDictionary;
foreach (DBDictionaryEntry item in lays)
{
result.Add(item.Key);
}
tr.Abort();
}
return(result);
}
/// <summary>
/// Gets a Named Objects Dictionary with the given key
/// If the collection does not contain the key, it will create a new Named Objects Dictionary instance.
/// </summary>
/// <param name="key">Name of the Named objects Dictionary</param>
/// <returns>DBDictionary</returns>
public DBDictionary GetNamedObjectsDictionary(string key)
{
DBDictionary nod = null; // Named Objects Dictionary
DBDictionary nod_collection = null; // Named Objects Dictionary Collection
try
{
_document.StartTransaction(tr =>
{
Transaction t = tr.Transaction;
nod_collection = t.GetObject <DBDictionary>(_nodId, OpenMode.ForRead);
if (nod_collection.Contains(key))
{
ObjectId oid = nod_collection.GetAt(key);
nod = t.GetObject <DBDictionary>(oid, OpenMode.ForRead);
}
else
{
using (WriteEnabler we = new WriteEnabler(nod_collection))
{
if (nod_collection.IsWriteEnabled)
{
nod = new DBDictionary();
nod_collection.SetAt(key, nod);
t.AddNewlyCreatedDBObject(nod, true);
}
}
}
});
}
catch (Exception ex)
{
string err_message = string.Format("DBDictionary named: '{0}' could not be found.", key);
throw new XRecordHandlerException(err_message, ex);
}
return(nod);
}
checkGroup(ObjectId idBlock)
{
Database db = HostApplicationServices.WorkingDatabase;
using (Transaction tr = BaseObjs.startTransactionDb())
{
DBDictionary groups = (DBDictionary)db.GroupDictionaryId.GetObject(OpenMode.ForRead);
foreach (DBDictionaryEntry entry in groups)
{
ObjectId idGrp = entry.Value;
Group group = (Group)tr.GetObject(idGrp, (OpenMode.ForRead));
ObjectId[] ids = group.GetAllEntityIds();
List <ObjectId> lstIDs = new List <ObjectId>();
foreach (ObjectId id in ids)
{
lstIDs.Add(id);
}
if (lstIDs.Contains(idBlock))
{
group.UpgradeOpen();
foreach (ObjectId idObj in lstIDs)
{
group.Remove(idObj);
if (idObj.GetType() == typeof(Wipeout))
{
idObj.delete();
}
}
group.Erase();
break;
}
}
tr.Commit();
}
}
private void AddXRecord(Transaction tr, DBDictionary dict, string key, ObjectId id)
{
Xrecord xr = null;
if (dict.Contains(key))
{
// Update the existing lock object
xr = tr.GetObject((ObjectId)dict[key], OpenMode.ForWrite) as Xrecord;
xr.Data = SoftPointerForId(id);
}
else
{
// Create a new lock object
xr = new Xrecord();
xr.XlateReferences = true;
xr.Data = SoftPointerForId(id);
dict.UpgradeOpen();
dict.SetAt(key, xr);
tr.AddNewlyCreatedDBObject(xr, true);
}
}
/// <summary>
/// Проверка корректности желаемого имени листа
/// Если лист с желаемым именем уже существует, к данному имени добавится "(1)"
/// Если и это имя уже есть - цифра в скобках будет увеличиваться, пока не будет найден
/// уникальный вариант
/// </summary>
/// <param name="expectedName">Желаемое имя листа</param>
/// <returns>Корректное имя листа</returns>
string CheckLayoutName(string expectedName)
{
string layoutName = expectedName;
using (Transaction tr = this.wdb.TransactionManager.StartTransaction())
{
// Проверяем на наличие листа с указанным именем
DBDictionary layoutsDic = (DBDictionary)tr.GetObject(wdb.LayoutDictionaryId, OpenMode.ForRead);
if (layoutsDic.Contains(layoutName))
{
// Если есть - добавляем номер в скобках, итерируем номер, пока имя не станет уникальным
int dublicateLayoutIndex = 1;
while (layoutsDic.Contains(string.Format("{0}({1})", layoutName, dublicateLayoutIndex)))
{
dublicateLayoutIndex++;
}
layoutName = string.Format("{0}({1})", layoutName, dublicateLayoutIndex);
}
tr.Commit();
}
return(layoutName);
}
protected T LoadBinary <T>(string Key)
{
//Database acCurDb = Application.DocumentManager.MdiActiveDocument.Database;
Transaction tr = acCurDb.TransactionManager.TopTransaction;
// Find the NOD in the database
DBDictionary nod = (DBDictionary)tr.GetObject(acCurDb.NamedObjectsDictionaryId, OpenMode.ForWrite);
if (nod.Contains(Key))
{
ObjectId plotId = nod.GetAt(Key);
Xrecord plotXRecord = (Xrecord)tr.GetObject(plotId, OpenMode.ForRead);
MemoryStream ms = new MemoryStream();
foreach (TypedValue value in plotXRecord.Data)
{
byte[] data = new byte[512];
string message = (string)value.Value;
data = Encoding.ASCII.GetBytes(message);
ms.Write(data, 0, data.Length);
}
ms.Position = 0;
XmlSerializer xml = new XmlSerializer(typeof(T));
try
{
string s = Encoding.ASCII.GetString(ms.ToArray());
return((T)xml.Deserialize(ms));
}
catch (Exception e)
{
throw new NotImplementedException();
}
}
else
{
return(default(T));
}
}
public void Scan()
{
_logger.LogTrace($"Layout sheet controller scanning {_document.Filename}");
Database acCurDb = _document;
Transaction acTrans = acCurDb.TransactionManager.TopTransaction;
DBDictionary layouts = acTrans.GetObject(acCurDb.LayoutDictionaryId, OpenMode.ForRead) as DBDictionary;
// Step through and list each named layout and Model
foreach (DBDictionaryEntry item in layouts)
{
if (!Sheets.ContainsKey(item.Key) && item.Key != "Model")
{
_logger.LogTrace($"Sheet {item.Key} found");
Layout acLayout = acTrans.GetObject(item.Value, OpenMode.ForRead) as Layout;
LayoutSheet ls = new LayoutSheet(_logger, acLayout);
_logger.LogTrace($"Sheet {item.Key} added");
Sheets.Add(item.Key, ls);
}
}
}
public BlockReference GetRefBlkFromIndex(Database db, DBDictionary dbExt, string idHn)
{
BlockReference blk;
using (var tr = db.TransactionManager.StartTransaction())
{
// Pega o handle a partir do id dado
ObjectId idId = dbExt.GetAt(idHn);
Xrecord xRec = (Xrecord)tr.GetObject(idId, OpenMode.ForRead);
ResultBuffer rb = xRec.Data;
TypedValue[] tp = rb.AsArray();
string hand = tp[0].Value as string;
long ln = Convert.ToInt64(hand, 16);
Handle hn = new Handle(ln);
ObjectId id = db.GetObjectId(false, hn, 0);
blk = (BlockReference)tr.GetObject(id, OpenMode.ForRead);
}
return(blk);
}
public static string ReadState(Document doc, string key)
{
// https://adndevblog.typepad.com/autocad/2012/05/how-can-i-store-my-custom-information-in-a-dwg-file.html
var db = doc.Database;
string state;
try
{
using (Transaction trans = db.TransactionManager.StartTransaction())
{
// Find the NOD in the database
DBDictionary nod = (DBDictionary)trans.GetObject(db.NamedObjectsDictionaryId, OpenMode.ForRead);
if (!nod.Contains(key))
{
return(string.Empty);
}
ObjectId objectId = nod.GetAt(key);
Xrecord xRecord = (Xrecord)trans.GetObject(objectId, OpenMode.ForRead);
var sb = new StringBuilder();
foreach (TypedValue value in xRecord.Data)
{
sb.Append(value.Value.ToString());
}
state = sb.ToString();
trans.Commit();
return(state);
}
}
catch (Exception ex)
{
throw new Exception("Error reading Speckle state.", ex);
}
}
/// <summary>
/// This function get a sub "DBDictionary" objectId in a parent DBDictionary.
/// </summary>
/// <param name="parentDictionaryId">Parent Dictionary Id</param>
/// <param name="childDictionaryName">Sub dictionary name</param>
/// <param name="createForNone">If true, a new DBDictionary will be created and added under parent dictionary if not found.</param>
/// <returns>Object Id of the retrieved Dictionary</returns>
public static ObjectId GetSubDictionaryInDictionary(ObjectId parentDictionaryId, string childDictionaryName, bool createForNone = true)
{
if (parentDictionaryId.IsNull)
{
throw new ArgumentNullException(/*MSG0*/ "parentDictionaryId");
}
if (String.IsNullOrEmpty(childDictionaryName))
{
throw new ArgumentNullException(/*MSG0*/ "childDictionaryName");
}
var dictId = ObjectId.Null;
using (Transaction myTrans = parentDictionaryId.Database.TransactionManager.StartTransaction())
{
var parentDictionary = (DBDictionary)myTrans.GetObject(parentDictionaryId, OpenMode.ForRead);
if (parentDictionary.Contains(childDictionaryName))
{
dictId = parentDictionary.GetAt(childDictionaryName);
}
else if (createForNone)
{
// Create a new dictionary and add it.
using (var factoryDictory = new DBDictionary())
{
parentDictionary.UpgradeOpen();
parentDictionary.SetAt(childDictionaryName, factoryDictory);
myTrans.AddNewlyCreatedDBObject(factoryDictory, true);
dictId = factoryDictory.ObjectId;
}
}
myTrans.Commit();
}
return(dictId);
}
public static void Set(string key, object value)
{
try {
if (World.Docu != null)
{
if (World.Docu.IsActive == true && World.Docu.IsDisposed == false)
{
using (World.Docu.LockDocument()) {
using (Database db = World.Docu.Database) {
using (Transaction tr = db.TransactionManager.StartTransaction()) {
using (DBDictionary dict = (DBDictionary)tr.GetObject(db.NamedObjectsDictionaryId, OpenMode.ForWrite, false)) {
DxfCode code = AcadIO.DxfHelper.GetFromObject(value);
if (dict.Contains(key))
{
Xrecord xRec = (Xrecord)tr.GetObject(dict.GetAt(key), OpenMode.ForWrite);
ResultBuffer resBuf = new ResultBuffer(new TypedValue(Convert.ToInt32(code), value));
xRec.Data = resBuf;
}
else
{
Xrecord xRec = new Xrecord();
ResultBuffer resBuf = new ResultBuffer(new TypedValue(Convert.ToInt32(code), value));
xRec.Data = resBuf;
dict.SetAt(key, xRec);
tr.AddNewlyCreatedDBObject(xRec, true);
}
}
tr.Commit();
}
}
}
}
}
}
catch (System.Exception ex) {
Err.Log(ex);
}
}
dictExists(string nameDict)
{
ObjectId idDict = ObjectId.Null;
DBDictionary dictNOD = null;
Database db = BaseObjs._db;
try
{
using (Transaction tr = BaseObjs.startTransactionDb())
{
try
{
dictNOD = (DBDictionary)db.NamedObjectsDictionaryId.GetObject(OpenMode.ForRead);
}
catch (System.Exception ex)
{
BaseObjs.writeDebug(ex.Message + " Dict.cs: line: 232");
}
try
{
if (dictNOD.Contains(nameDict))
{
idDict = dictNOD.GetAt(nameDict);
}
}
catch (System.Exception ex)
{
BaseObjs.writeDebug(ex.Message + " Dict.cs: line: 243");
}
tr.Commit();
}
}
catch (System.Exception ex)
{
BaseObjs.writeDebug(ex.Message + " Dict.cs: line: 250");
}
return(idDict);
}
public void CreateEmployee()
{
Database db = HostApplicationServices.WorkingDatabase;
Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
using (Transaction trans = db.TransactionManager.StartTransaction())
try
{
BlockTable bt = (BlockTable)(trans.GetObject(db.BlockTableId, OpenMode.ForWrite));
BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
//Create the block reference...use the return from CreateEmployeeDefinition directly!
BlockReference br = new BlockReference(new Point3d(10, 10, 0), CreateEmployeeDefinition());
btr.AppendEntity(br); //Add the reference to ModelSpace
trans.AddNewlyCreatedDBObject(br, true); //Let the transaction know about it
//Create the custom per-employee data
Xrecord xRec = new Xrecord();
//We want to add 'Name', 'Salary' and 'Division' information. Here is how:
xRec.Data = new ResultBuffer(
new TypedValue((int)DxfCode.Text, "Earnest Shackleton"),
new TypedValue((int)DxfCode.Real, 72000),
new TypedValue((int)DxfCode.Text, "Sales"));
//Next, we need to add this data to the 'Extension Dictionary' of the employee.
br.CreateExtensionDictionary();
DBDictionary brExtDict = (DBDictionary)trans.GetObject(br.ExtensionDictionary, OpenMode.ForWrite, false);
brExtDict.SetAt("EmployeeData", xRec); //Set our XRecord in the dictionary at 'EmployeeData'.
trans.AddNewlyCreatedDBObject(xRec, true);
trans.Commit();
}
catch (System.Exception ex)
{
ed.WriteMessage("Error Creating Employee Block: " + ex.Message);
}
// No 'finally' block is required to clean up the transaction
// since it was declared inside a 'using' statement.
}
protected DBDictionary WriteMapDictionary(DBDictionary parentDict, Transaction t)
{
DBDictionary result;
try
{
parentDict.UpgradeOpen();
DBDictionary dBDictionary = new DBDictionary();
this.AcadDictionaryID = parentDict.SetAt(base.Name, dBDictionary);
dBDictionary.DisableUndoRecording(true);
t.AddNewlyCreatedDBObject(dBDictionary, true);
DocUtil.WriteXRecord(t, dBDictionary, "AutoCADID", (DxfCode)330, base.RasterObjectId);
DocUtil.WriteXRecord(t, dBDictionary, "ServiceFullName", (DxfCode)1, this.ServiceFullName);
DocUtil.WriteXRecord(t, dBDictionary, "ConnectionName", (DxfCode)1, base.ConnectionName);
DocUtil.WriteXRecord(t, dBDictionary, "ConnectionURL", (DxfCode)1, base.ConnectionURL);
DocUtil.WriteXRecord(t, dBDictionary, "UserName", (DxfCode)1, base.UserName);
if (base.Dynamic)
{
Xrecord xrecord = new Xrecord();
xrecord.Data = (new ResultBuffer(new TypedValue[]
{
new TypedValue(290, true)
}));
dBDictionary.SetAt("Dynamic", xrecord);
xrecord.DisableUndoRecording(true);
t.AddNewlyCreatedDBObject(xrecord, true);
}
DocUtil.WriteBoundingBox(t, dBDictionary, base.BoundaryExtent);
DocUtil.WriteXRecord(t, dBDictionary, "ImageFormat", (DxfCode)1, base.ExportOptions.Format);
result = dBDictionary;
}
catch (Exception ex)
{
string arg_122_0 = ex.Message;
result = null;
}
return(result);
}
public static AT_SUB SelectBySelectedObjectId(ObjectId SelectedObjectId)
{
Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
AT_SUB at_SUB = new AT_SUB();
Database db = Application.DocumentManager.MdiActiveDocument.Database;
using (DocumentLock docLock = Application.DocumentManager.MdiActiveDocument.LockDocument())
{
using (Transaction tr = db.TransactionManager.StartTransaction())
{
DBObject ent = tr.GetObject(SelectedObjectId, OpenMode.ForRead);
if (ent.ExtensionDictionary != ObjectId.Null)
{
DBDictionary ExtDict = (DBDictionary)tr.GetObject(ent.ExtensionDictionary, OpenMode.ForRead);
if (ExtDict.Contains("AT_SUB"))
{
at_SUB.SelectedObjectId = SelectedObjectId;
Xrecord xrec = (Xrecord)tr.GetObject(ExtDict.GetAt("AT_SUB"), OpenMode.ForRead);
foreach (TypedValue tv in xrec.Data)
{
string Temp = tv.Value.ToString().Substring(1, tv.Value.ToString().Length - 2);
//ed.WriteMessage("{0} \n", Temp);
at_SUB.SubIdCollection.Add(new ObjectId(new IntPtr(int.Parse(Temp))));
}
}
else
{
//ed.WriteMessage("AT_SUB : NOT EXIST \n");
}
}
}
}
return(at_SUB);
}
//为当前图形添加一个新的表格样式
public static ObjectId AddTableStyle(string style)
{
ObjectId styleId; // 存储表格样式的Id
Database db = HostApplicationServices.WorkingDatabase;
using (Transaction trans = db.TransactionManager.StartTransaction())
{
// 打开表格样式字典
DBDictionary dict = (DBDictionary)db.TableStyleDictionaryId.GetObject(OpenMode.ForRead);
if (dict.Contains(style)) // 如果存在指定的表格样式
{
styleId = dict.GetAt(style); // 获取表格样式的Id
}
else
{
TableStyle ts = new TableStyle(); // 新建一个表格样式
// 设置表格的标题行为灰色
//ts.SetBackgroundColor(Color.FromColorIndex(ColorMethod.ByAci, 8), (int)RowType.TitleRow);
// 设置表格所有行的外边框的线宽为0.30mm
ts.SetGridLineWeight(LineWeight.LineWeight030, (int)GridLineType.OuterGridLines, TableTools.AllRows);
// 不加粗表格表头行的底部边框
ts.SetGridLineWeight(LineWeight.LineWeight000, (int)GridLineType.HorizontalBottom, (int)RowType.HeaderRow);
// 不加粗表格数据行的顶部边框
ts.SetGridLineWeight(LineWeight.LineWeight000, (int)GridLineType.HorizontalTop, (int)RowType.DataRow);
// 设置表格中所有行的文本高度为1
ts.SetTextHeight(1, TableTools.AllRows);
// 设置表格中所有行的对齐方式为正中
ts.SetAlignment(CellAlignment.MiddleCenter, TableTools.AllRows);
dict.UpgradeOpen();//切换表格样式字典为写的状态
// 将新的表格样式添加到样式字典并获取其Id
styleId = dict.SetAt(style, ts);
// 将新建的表格样式添加到事务处理中
trans.AddNewlyCreatedDBObject(ts, true);
trans.Commit();
}
}
return(styleId); // 返回表格样式的Id
}
//Creates a custom property in object contains number of floors and bars
public void SaveToDB(ObjectId objectId, int floorNum, int numBars)
{
Document document = Application.DocumentManager.MdiActiveDocument;
Database database = document.Database;
using (Transaction transaction = database.TransactionManager.StartTransaction())
{
DBObject databaseObject = transaction.GetObject(objectId, OpenMode.ForRead);
ObjectId extId = databaseObject.ExtensionDictionary;
if (extId == ObjectId.Null)
{
databaseObject.UpgradeOpen();
databaseObject.CreateExtensionDictionary();
extId = databaseObject.ExtensionDictionary;
}
DBDictionary dbExt = (DBDictionary)transaction.GetObject(extId, OpenMode.ForRead);
if (!dbExt.Contains("CustomProp"))
{
dbExt.UpgradeOpen();
Xrecord xRec = new Xrecord();
ResultBuffer rb = new ResultBuffer
{
new TypedValue((int)DxfCode.ExtendedDataAsciiString, floorNum.ToString()),
new TypedValue((int)DxfCode.ExtendedDataAsciiString, numBars.ToString())
};
xRec.Data = rb;
dbExt.SetAt("CustomProp", xRec);
transaction.AddNewlyCreatedDBObject(xRec, true);
}
transaction.Commit();
}
}
/// <summary>
/// Agrega un diccionario al diccionario de AutoCAD
/// </summary>
/// <param name="dictionaryName">El nombre del diccionario</param>
/// <returns>El object id del nuevo diccionario</returns>
public ObjectId AddDictionary(String dictionaryName)
{
Database db = AcadApp.DocumentManager.MdiActiveDocument.Database;
ObjectId id = new ObjectId();
using (Transaction tr = db.TransactionManager.StartTransaction())
{
try
{
DBDictionary NOD = (DBDictionary)NOD_ID.GetObject(OpenMode.ForWrite);
DBDictionary d = new DBDictionary();
NOD.SetAt(dictionaryName, d);
tr.AddNewlyCreatedDBObject(d, true);
id = d.ObjectId;
tr.Commit();
}
catch (Exception exc)
{
ed.WriteMessage(exc.Message);
tr.Abort();
}
}
return id;
}
/// <summary>
/// Agrega un diccionario a otro diccionario, si el id es de una entidad el
/// diccionario que se abre es el del extensión
/// </summary>
/// <param name="dName">El nombre del diccionario</param>
/// <param name="objId">El id del objeto</param>
/// <returns>El object id del diccionario del nuevo diccionario</returns>
public ObjectId AddDictionary(ObjectId objId, String dName)
{
Database db = AcadApp.DocumentManager.MdiActiveDocument.Database;
ObjectId id = new ObjectId();
using (Transaction tr = db.TransactionManager.StartTransaction())
{
try
{
DBObject obj = objId.GetObject(OpenMode.ForRead);
DBDictionary dic = null;
if (obj is Entity)
{
Entity ent = obj as Entity;
if (ent.ExtensionDictionary.IsValid)
dic = (DBDictionary)ent.ExtensionDictionary.GetObject(OpenMode.ForWrite);
else
{
ent.UpgradeOpen();
ent.CreateExtensionDictionary();
dic = (DBDictionary)ent.ExtensionDictionary.GetObject(OpenMode.ForWrite);
}
}
else if (obj is DBDictionary)
dic = (DBDictionary)objId.GetObject(OpenMode.ForWrite);
//Si el id fue de una entidad o de otro diccionario,
//se tuvo que abrir algun diccionario.
if (dic != null)
{
DBDictionary newDic = new DBDictionary();
dic.SetAt(dName, newDic);
tr.AddNewlyCreatedDBObject(newDic, true);
id = newDic.ObjectId;
}
tr.Commit();
}
catch (Exception exc)
{
ed.WriteMessage(exc.Message);
tr.Abort();
}
}
return id;
}
private ObjectId CreateDivision(string division, string manager)
{
ObjectId retId = ObjectId.Null;
Database db = HostApplicationServices.WorkingDatabase;
using (Transaction trans = db.TransactionManager.StartTransaction())
{
// First, get the Named Objects Dictionary (NOD)...
DBDictionary NOD = (DBDictionary)trans.GetObject(db.NamedObjectsDictionaryId, OpenMode.ForWrite);
// Define a corporate level dictionary
DBDictionary acmeDict;
// here's another way to check to see if an entry exists, using try/catch instead of has[]
try
{
// Just throw if it doesn't exist...do nothing else
acmeDict = (DBDictionary)trans.GetObject(NOD.GetAt("ACME_DIVISION"), OpenMode.ForRead);
}
catch
{
//Doesn't exist, so create one, and set it in the NOD?/font>
acmeDict = new DBDictionary();
NOD.SetAt("ACME_DIVISION", acmeDict);
trans.AddNewlyCreatedDBObject(acmeDict, true);
}
// Now get the division we want from acmeDict
DBDictionary divDict;
try
{
divDict = (DBDictionary)trans.GetObject(acmeDict.GetAt(division), OpenMode.ForWrite);
}
catch
{
divDict = new DBDictionary();
//Division doesn't exist, create one
acmeDict.UpgradeOpen();
acmeDict.SetAt(division, divDict);
trans.AddNewlyCreatedDBObject(divDict, true);
}
// Now get the manager info from the division
// We need to add the name of the division supervisor. We'll do this with another XRecord.
Xrecord mgrXRec;
try
{
mgrXRec = (Xrecord)trans.GetObject(divDict.GetAt("Department Manager"), OpenMode.ForWrite);
}
catch
{
mgrXRec = new Xrecord();
mgrXRec.Data = new ResultBuffer(new TypedValue((int)DxfCode.Text, manager));
divDict.SetAt("Department Manager", mgrXRec);
trans.AddNewlyCreatedDBObject(mgrXRec, true);
}
// Return the department manager XRecord
retId = mgrXRec.ObjectId;
trans.Commit();
}
return retId;
}
private void CreateDivision()
{
Database db = HostApplicationServices.WorkingDatabase;
using (Transaction trans = db.TransactionManager.StartTransaction())
{
//First, get the NOD...
DBDictionary NOD = (DBDictionary)trans.GetObject(db.NamedObjectsDictionaryId, OpenMode.ForWrite);
//Define a corporate level dictionary
DBDictionary acmeDict;
try
{
//Just throw if it doesn't exist...do nothing else
acmeDict = (DBDictionary)trans.GetObject(NOD.GetAt("ACME_DIVISION"), OpenMode.ForRead);
}
catch
{
//Doesn't exist, so create one, and set it in the NOD?/font>
acmeDict = new DBDictionary();
NOD.SetAt("ACME_DIVISION", acmeDict);
trans.AddNewlyCreatedDBObject(acmeDict, true);
}
//Now get the division we want from acmeDict
DBDictionary divDict;
try
{
divDict = (DBDictionary)trans.GetObject(acmeDict.GetAt("Sales"), OpenMode.ForWrite);
}
catch
{
divDict = new DBDictionary();
//Division doesn't exist, create one
acmeDict.UpgradeOpen();
acmeDict.SetAt("Sales", divDict);
trans.AddNewlyCreatedDBObject(divDict, true);
}
//Now get the manager info from the division
//We need to add the name of the division supervisor. We'll do this with another XRecord.
Xrecord mgrXRec;
try
{
mgrXRec = (Xrecord)trans.GetObject(divDict.GetAt("Department Manager"), OpenMode.ForWrite);
}
catch
{
mgrXRec = new Xrecord();
mgrXRec.Data = new ResultBuffer(new TypedValue((int)DxfCode.Text, "Randolph P. Brokwell"));
divDict.SetAt("Department Manager", mgrXRec);
trans.AddNewlyCreatedDBObject(mgrXRec, true);
}
trans.Commit();
}
}
public void AddInNOD()
{
Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
ed.WriteMessage("����������ʵ����������\n");
Database db = HostApplicationServices.WorkingDatabase;
using (Transaction trans = db.TransactionManager.StartTransaction())
{
//��ȡ��������ʵ䣨NOD)
DBDictionary NOD =trans.GetObject(db.NamedObjectsDictionaryId, OpenMode.ForWrite) as DBDictionary ;
// ����һ���µĴʵ�
DBDictionary copyrightDict;
// �ж��Ƿ����COPYRIGHT�ʵ䣬û����
try
{
// ��ȡCOPYRIGHT�ʵ�
copyrightDict = (DBDictionary)trans.GetObject(NOD.GetAt("COPYRIGHT"), OpenMode.ForRead);
}
catch
{
//��NOD�´���COPYRIGHT�ʵ�
copyrightDict = new DBDictionary();
NOD.SetAt("COPYRIGHT", copyrightDict);
trans.AddNewlyCreatedDBObject(copyrightDict, true);
}
// ��copyrightDict�У���ȡ�� "author" �ʵ�
DBDictionary authorDict;
try
{
authorDict = (DBDictionary)trans.GetObject(copyrightDict.GetAt("Author"), OpenMode.ForWrite);
}
catch
{
authorDict = new DBDictionary();
//"author" doesn't exist, create one
copyrightDict.UpgradeOpen();
copyrightDict.SetAt("Author", authorDict);
trans.AddNewlyCreatedDBObject(authorDict, true);
}
// ͨ��Xrecord��ResultBuffer�����չ����
Xrecord authorRec;
try
{
authorRec = (Xrecord)trans.GetObject(authorDict.GetAt("AuthorInfo"), OpenMode.ForWrite);
}
catch
{
authorRec = new Xrecord();
authorRec.Data = new ResultBuffer(new TypedValue((int)DxfCode.Text, "����"));
authorDict.SetAt("AuthorInfo", authorRec);
trans.AddNewlyCreatedDBObject(authorRec, true);
}
trans.Commit();
}
}
public bool UpdateDictionary(string Guid, int newState, string newConfig)
{
DBDictionary dbDictionary = new DBDictionary(dataProvider);
dbDictionary.Connection = connection;
dbDictionary.Load(Guid);
dbDictionary.BusinessObject.Active = newState == 1;
dbDictionary.BusinessObject.Config = newConfig;
return dbDictionary.Save();
}
public bool MWRStateExists(string guid, ref bool active)
{
DBDictionary dbDictionary = new DBDictionary(dataProvider);
dbDictionary.Connection = connection;
dbDictionary.Load(guid);
if (dbDictionary.BusinessObject != null)
{
active = dbDictionary.BusinessObject.Active;
return true;
}
return false;
}
public void InsertTest()
{
DBDictionary dbDictionary = new DBDictionary();
dbDictionary.Connection = GetConnection();
DictionaryEntry entry = new DictionaryEntry();
entry.Active = true;
entry.Guid = "AEF29AAA-0F23-4ba3-AA10-BAE05B3E4503";
entry.Name = "Test";
entry.Type = MWRCommonTypes.Enum.ObjectType.State;
Assert.IsTrue(dbDictionary.Save(entry));
}
private static ObjectId getDict()
{
ObjectId idDic = ObjectId.Null;
Database db = HostApplicationServices.WorkingDatabase;
using (DBDictionary nod = (DBDictionary)db.NamedObjectsDictionaryId.Open(OpenMode.ForRead))
{
if (!nod.Contains(_dicName))
{
nod.UpgradeOpen();
using (var dic = new DBDictionary())
{
idDic = nod.SetAt(_dicName, dic);
dic.TreatElementsAsHard = true;
}
}
else idDic = nod.GetAt(_dicName);
}
return idDic;
}
public void LoadTest()
{
DBDictionary dbDictionary = new DBDictionary();
dbDictionary.Connection = GetConnection();
dbDictionary.Load("AEF29AAA-0F23-4ba3-AA10-BAE05B3E4503");
Assert.IsNotNull(dbDictionary.BusinessObject);
Assert.IsTrue(dbDictionary.BusinessObject.Active);
Assert.IsTrue(dbDictionary.BusinessObject.Name == "Test");
Assert.IsTrue(dbDictionary.BusinessObject.Type == MWRCommonTypes.Enum.ObjectType.State);
}
public void UpdateTest()
{
DBDictionary dbDictionary = new DBDictionary();
dbDictionary.Connection = GetConnection();
dbDictionary.Load("AEF29AAA-0F23-4ba3-AA10-BAE05B3E4503");
dbDictionary.BusinessObject.Active = false;
dbDictionary.BusinessObject.Name = "Test2";
dbDictionary.BusinessObject.Type = MWRCommonTypes.Enum.ObjectType.Task;
dbDictionary.Save();
dbDictionary.Load("AEF29AAA-0F23-4ba3-AA10-BAE05B3E4503");
Assert.IsFalse(dbDictionary.BusinessObject.Active);
Assert.IsTrue(dbDictionary.BusinessObject.Name == "Test2");
Assert.IsTrue(dbDictionary.BusinessObject.Type == MWRCommonTypes.Enum.ObjectType.Task);
}
