C# ObjectUUID.ToString方法代码示例

        private Exceptional<ResultType> AddAttributeToDBObject(GraphDBType myTypeOfDBObject, ObjectUUID myUUID, AttributeUUID myAttributeUUID, IObject myAttributeValue)
        {
            //myGraphType is needed due to correctness concerning the attribute name

            #region Input exceptions

            if ((myTypeOfDBObject == null) || (myUUID == null) || (myAttributeUUID == null) || (myAttributeValue == null))
            {
                throw new ArgumentNullException();
            }

            #endregion

            #region Check GraphType for new Attribute

            TypeAttribute typeAttribute = myTypeOfDBObject.GetTypeAttributeByUUID(myAttributeUUID);

            if (typeAttribute == null)
            {
                //Todo: add notification here (the user has to be informed about the detailed circumstances)

                GraphDBError aError = new Error_AttributeIsNotDefined(myTypeOfDBObject.Name, myAttributeUUID.ToString());

                return new Exceptional<ResultType>(aError);
            }

            #endregion

            #region Data

            var objectLocation = new ObjectLocation(myTypeOfDBObject.ObjectLocation, DBConstants.DBObjectsLocation, myUUID.ToString());
            Exceptional<DBObjectStream> aNewDBObject;
            Exceptional<ResultType> result = new Exceptional<ResultType>();

            #endregion

            #region add attribute

            aNewDBObject = _DBContext.DBObjectManager.LoadDBObject(myTypeOfDBObject, myUUID);

            if (aNewDBObject.Failed())
            {
                result.PushIError(new Error_LoadObject(aNewDBObject.Value.ObjectLocation));
                return result;
            }

            result = aNewDBObject.Value.AddAttribute(typeAttribute.UUID, myAttributeValue);

            if (result.Failed())
                return result;

            try
            {
                _DBContext.DBObjectManager.FlushDBObject(aNewDBObject.Value);
            }
            catch (Exception ex)
            {
                result.PushIError(new Error_FlushObject(aNewDBObject.Value.ObjectLocation, ex));
                aNewDBObject.Value.RemoveAttribute(typeAttribute.UUID);
            }

            #endregion

            return result;
        }

 public Exceptional<DBObjectStream> LoadDBObject(GraphDBType myGraphDBType, ObjectUUID myObjectUUID, String myNameOfType)
 {
     return LoadDBObject(new ObjectLocation(myGraphDBType.ObjectLocation, DBConstants.DBObjectsLocation, myObjectUUID.ToString()));
 }

 /// <summary>
 /// Internal method for loading a DBBackwardEdge from GraphFS. 
 /// </summary>
 /// <param name="myType">The Type of the DBObjects as GraphType.</param>
 /// <param name="myObjectUUID">The UUID of the corresponding DBObject.</param>
 /// <returns>A BackwardEdge</returns>
 private Exceptional<BackwardEdgeStream> LoadDBBackwardEdgeInternal(GraphDBType myType, ObjectUUID myObjectUUID)
 {
     return _DBObjectManager.LoadBackwardEdge(new ObjectLocation(myType.ObjectLocation, DBConstants.DBObjectsLocation, myObjectUUID.ToString()));
 }

        /// <summary>
        /// Inserts a complete DBObject with all attributes and edges without verifying references.
        /// Be aware that an already existing DBObject will be overwritten! 
        /// Do not forget to call Flush() after doing all changes! Otherwise no objects will be stored.
        /// </summary>
        /// <param name="myObjectUUID"></param>
        /// <returns></returns>
        public BulkInsertDBO Insert(ObjectUUID myObjectUUID)
        {
            var dbContext = (DBContext)_DBTransaction.GetDBContext();

            if (myObjectUUID == null)
            {
                myObjectUUID = ObjectUUID.NewUUID;
            }

            var DBObjectStream = new DBObjectStream(myObjectUUID,
                                                    _Type,
                                                    new Dictionary<AttributeUUID, IObject>(),
                                                    new ObjectLocation(_Type.ObjectLocation, DBConstants.DBObjectsLocation, dbContext.DBObjectManager.GetDBObjectStreamShard(_Type, myObjectUUID), myObjectUUID.ToString()));

            return new BulkInsertDBO(dbContext, _Type, DBObjectStream, this);
        }

 public Boolean Contains(ObjectUUID myUUID, GraphDBType myTypeOfDBObject, DBContext dbContext)
 {
     return GetDirectoryObject(myTypeOfDBObject, myUUID, dbContext).ObjectExists(myUUID.ToString());
 }

 public ObjectLocation GetObjectLocation(ObjectUUID objectUUID)
 {
     return new ObjectLocation(ObjectLocation, DBConstants.DBObjectsLocation, objectUUID.ToString());
 }

 public Exceptional<Boolean> Contains(ObjectUUID myUUID, GraphDBType myTypeOfDBObject, DBContext dbContext)
 {
     return Contains_private(GetDirectoryObject(myTypeOfDBObject, dbContext), myUUID.ToString());
 }