C# IVertexType.GetUniqueDefinitions方法代码示例

        /// <summary>
        /// Generate an output for an type with the attributes of the types and all parent types
        /// </summary>         
        /// <param name="myDBContext">The db context</param>
        /// <param name="myType">The db type</param>
        /// <param name="myDepth">If depth == 0 only the type basic attributes will be returned</param>
        private IVertexView GenerateOutput(IVertexType myType, Int32 myDepth = 0)
        {
            var retVal = new Dictionary<String, object>();

            List<IVertexView> result = new List<IVertexView>();
            var edges = new Dictionary<String, IEdgeView>();

            //base output
            retVal.Add("VertexID", myType.ID);
            retVal.Add("Type", myType.GetType().Name);
            retVal.Add("Name", myType.Name);
            retVal.Add("IsUserDefined", myType.IsUserDefined);

            //additional output
            if (myDepth > 0)
            {
                retVal.Add("IsAbstract", myType.IsAbstract);

                edges.Add("Properties", new HyperEdgeView(null, GeneratePropertiesOutput(myType, myType.GetPropertyDefinitions(true), myDepth)));

                edges.Add("Edges", new HyperEdgeView(null, GenerateEdgesOutput(myType, myType.GetOutgoingEdgeDefinitions(true))));

                edges.Add("Incomingedges", new HyperEdgeView(null, GenerateEdgesOutput(myType, myType.GetIncomingEdgeDefinitions(true))));

                edges.Add("UniqueAttributes", new HyperEdgeView(null, GenerateUniquePropertiesOutput(myType, myType.GetUniqueDefinitions(true))));

                edges.Add("Indices", new HyperEdgeView(null, GenerateIndicesOutput(myType)));

                if (myType.HasParentType)
                    edges.Add("Extends", new SingleEdgeView(null, GenerateOutput(myType.ParentVertexType)));

                if (myType.HasChildTypes)
                {
                    List<ISingleEdgeView> list = new List<ISingleEdgeView>();

                    foreach (var child in myType.ChildrenVertexTypes)
                        list.Add(new SingleEdgeView(null, GenerateOutput(child)));

                    edges.Add("ChildrenVertexTypes", new HyperEdgeView(null, list));
                }

                if (!string.IsNullOrWhiteSpace(myType.Comment))
                    retVal.Add("Comment", myType.Comment);
            }

            return new VertexView(retVal, edges);
        }

        /// <summary>
        /// Creates the ddl of a type.
        /// </summary>
        /// <param name="myVertexType">The vertex type.</param>
        private String CreateGraphDDL_VertexType(IVertexType myVertexType)
        {
            var stringBuilder = new StringBuilder();
            String delimiter = ", ";
            stringBuilder.AppendFormat("{0} ", myVertexType.Name);

            #region parent type

            //EXTENDS ...
            if (myVertexType.HasParentType)
            {
                stringBuilder.AppendFormat("{0} {1} ", S_EXTENDS.ToUpperString(), myVertexType.ParentVertexType.Name);
            }

            #endregion

            #region attributes
            //are there attributes
            if (myVertexType.HasAttributes(false))
            {
                #region !incomingEdges

                if (myVertexType.GetAttributeDefinitions(false).Any(aAttribute => aAttribute.Kind != AttributeType.IncomingEdge))
                {
                    //so, there are attributes that are no incoming edges
                    stringBuilder.Append(String.Concat(S_ATTRIBUTES.ToUpperString(), " ", S_BRACKET_LEFT));

                    #region properties

                    if (myVertexType.GetAttributeDefinitions(false).Any(aAttribute => aAttribute.Kind == AttributeType.Property))
                    {
                        stringBuilder.Append(String.Concat(CreateGraphDDLOfProperties(myVertexType.GetPropertyDefinitions(false))));
                    }

                    #endregion

                    #region outgoing edges

                    if (myVertexType.GetAttributeDefinitions(false).Any(aAttribute => aAttribute.Kind == AttributeType.OutgoingEdge))
                    {
                        stringBuilder.Append(String.Concat(CreateGraphDDLOfOutgoingEdges(myVertexType.GetOutgoingEdgeDefinitions(false), myVertexType)));
                    }

                    #endregion

                    if (stringBuilder.ToString().EndsWith(delimiter))
                        stringBuilder.RemoveSuffix(delimiter);

                    stringBuilder.Append(String.Concat(S_BRACKET_RIGHT, " "));

                }

                #endregion

                #region incomingEdges

                if (myVertexType.GetAttributeDefinitions(false).Any(aAttribute => aAttribute.Kind == AttributeType.IncomingEdge))
                {
                    stringBuilder.Append(
                        String.Concat(S_INCOMINGEDGES.ToUpperString(),
                                        " ",
                                        S_BRACKET_LEFT.ToUpperString(),
                                        CreateGraphDDLOfIncomingEdges(
                                            myVertexType.GetIncomingEdgeDefinitions(false)),
                                        S_BRACKET_RIGHT.ToUpperString(), " "));
                }

                #endregion
            }

            #endregion

            #region Uniques

            if (myVertexType.HasUniqueDefinitions(false))
            {
                if (myVertexType.GetUniqueDefinitions(false).Count() > 0)
                {
                    stringBuilder.Append(S_UNIQUE.ToUpperString() +
                                            " " +
                                            S_BRACKET_LEFT.Symbol +
                                            CreateGraphDDLOfUniqueAttributes(
                                                myVertexType
                                                    .GetUniqueDefinitions(false)) +
                                            S_BRACKET_RIGHT.Symbol + " ");
                }
            }

            #endregion

            #region Mandatory attributes

            if (myVertexType.HasProperties(false))
            {
                if (myVertexType.GetPropertyDefinitions(false).Any(aProperty => aProperty.IsMandatory))
                {
//.........这里部分代码省略.........

        private static void CheckToBeRemovedUniques(IEnumerable<string> myUniques, IVertexType vertexType)
        {
            var uniqueDefs = vertexType.GetUniqueDefinitions(true);

            if (myUniques == null)
                return;

            var attributes = vertexType.GetAttributeDefinitions(false).ToList();

            foreach (var aUnique in myUniques)
            {
                if (!attributes.Any(_ => _.Name == aUnique && uniqueDefs.Any(x => x.UniquePropertyDefinitions.Any(y => y.Name == aUnique))))
                {
                    throw new AttributeDoesNotExistException(aUnique, vertexType.Name);
                }
            }
        }