C# ModelElement.GetType方法代码示例

        public static void AddClass(ModelElement cls, CodeTypeDeclaration declaration)
        {
            if (!isInitialized)
                throw new ArgumentException("CodeGenerationContext must first be initialized");
            if (cls == null)
                throw new ArgumentNullException("No class supplied", "cls");
            if (declaration == null)
                throw new ArgumentNullException("No CodeTypeDeclaration supplied", "declaration");

            if (cls.GetType() == typeof(ModelClass))
            {
                ModelClass modelClass = (ModelClass)cls;
                if (!classDeclarations.ContainsKey(modelClass))
                    classDeclarations.Add(modelClass, declaration);
            }
            else if (cls.GetType() == typeof(NestedClass))
            {
                NestedClass nestedClass = (NestedClass)cls;
                if (!nestedClassDeclarations.ContainsKey(nestedClass))
                    nestedClassDeclarations.Add(nestedClass, declaration);
            }
            else
                throw new ArgumentException("Only ModelClass and NestedClass entities supported", "cls");

            generatedClassNames.Add(((NamedElement)cls).Name);
        }

        public static CodeTypeDeclaration GetTypeDeclaration(ModelElement cls)
        {
            if (!isInitialized)
                throw new ArgumentException("CodeGenerationContext must first be initialized");
            if (cls == null)
                throw new ArgumentNullException("No class supplied", "cls");

            if (cls.GetType() == typeof(ModelClass))
            {
                return classDeclarations[(ModelClass)cls];
            }
            else if (cls.GetType() == typeof(NestedClass))
            {
                return nestedClassDeclarations[(NestedClass)cls];
            }
            else
                throw new ArgumentException("Only ModelClass and NestedClass entities supported", "cls");
        }

		public static string ModelElementToString(ModelElement element)
		{
			Guard.ArgumentNotNull(element, "element");

			string name;
			DomainClassInfo.TryGetName(element, out name);
			name = name ?? "no name";
			string type = element.GetType().Name;
			return String.Format(CultureInfo.CurrentUICulture, "{0} '{1}' {2}", type, name, element.Id);
		}

        /// <summary>
        /// Gets the domain property id of a property on a model element.
        /// </summary>
        /// <param name="modelElement">Model element containing the named property.</param>
        /// <param name="propertyName">Property name of the property, for which to get the property domain id.</param>
        /// <returns>Domain property id if found, null otherwise.</returns>
        public static Guid? GetPropertyDomainObjectId(ModelElement modelElement, string propertyName)
        {
            PropertyInfo propertyInfo = modelElement.GetType().GetProperty(propertyName);
            if (propertyInfo != null)
            {
                object[] obj = propertyInfo.GetCustomAttributes(typeof(DomainObjectIdAttribute), false);
                if (obj.Length == 1)
                {
                    DomainObjectIdAttribute idAttribute = (DomainObjectIdAttribute)obj[0];
                    return idAttribute.Id;
                }
            }

            return null;
        }

		/// <summary>
		/// Create a property descriptor for the given property on
		/// the element to emulate the behavior of modifying this
		/// property in the properties window. This will succeed if the property
		/// passed in has a corresponding meta attribute.
		/// </summary>
		/// <param name="element">The element to create a descriptor for</param>
		/// <param name="propertyName">The name of the property on the native object.
		/// Note that the name of this property may be displayed differently in the
		/// properties window. For example, Role.RolePlayerDisplay is shown as RolePlayer
		/// in the properties window.</param>
		/// <returns>PropertyDescriptor, or null if not available</returns>
		public PropertyDescriptor CreatePropertyDescriptor(ModelElement element, string propertyName)
		{
			Type elementType = element.GetType();
			PropertyInfo propInfo = elementType.GetProperty(propertyName);
			if (propInfo != null)
			{
				DomainPropertyInfo attrInfo = element.Store.DomainDataDirectory.FindDomainClass(propInfo.DeclaringType).FindDomainProperty(propertyName, true);
				if (attrInfo != null)
				{
					return DomainTypeDescriptor.CreatePropertyDescriptor(element, attrInfo);
				}
			}
			return null;
		}

 private static void DoValidate(ModelElement element, ValidationContext context, string ruleSet)
 {
     Validator validator = validatorFactory.CreateValidator(element.GetType(), ruleSet);           
     ValidationResults results = validator.Validate(element);
     if (!results.IsValid)
     {
         WriteResultsToLog(context, results);
     }
 }

        /// <summary>
        /// Search a specific model element by using the given search criteria.
        /// </summary>
        /// <param name="modelElement">Model element to be searched.</param>
        /// <param name="criteria">Search criteria to use.</param>
		/// <param name="searchText">Text to search.</param>
        /// <param name="options">Search options.</param>
        /// <returns>Search result list if any found. Empty list otherwise.</returns>
        public virtual List<SearchResult> Search(ModelElement modelElement, SearchCriteriaEnum criteria, string searchText, SearchOptions options)
        {
            List<SearchResult> results = new List<SearchResult>();
            DomainClassInfo info = modelElement.GetDomainClass();
            Type modelElementType = modelElement.GetType();

            #region properties
            if (criteria == SearchCriteriaEnum.Name ||
                criteria == SearchCriteriaEnum.NameAndType ||
                criteria == SearchCriteriaEnum.All ||
                criteria == SearchCriteriaEnum.Properties || 
				criteria == SearchCriteriaEnum.PropertiesWithoutName)
                foreach (DomainPropertyInfo propertyInfo in info.AllDomainProperties)
                {
                    if (propertyInfo == info.NameDomainProperty &&
                        criteria != SearchCriteriaEnum.Name &&
                        criteria != SearchCriteriaEnum.NameAndType &&
                        criteria != SearchCriteriaEnum.Properties &&
                        criteria != SearchCriteriaEnum.All)
                        continue;
                    else if (propertyInfo != info.NameDomainProperty &&
                        criteria != SearchCriteriaEnum.All &&
                        criteria != SearchCriteriaEnum.Properties &&
                        criteria != SearchCriteriaEnum.PropertiesWithoutName)
                        continue;

                    object nameValue = GetPropertyValue(modelElement, modelElementType, propertyInfo.Name);
                    if (nameValue == null && System.String.IsNullOrEmpty(searchText))
                    {
                        SearchResult searchResult = new SearchResult();
                        searchResult.IsSuccessFull = true;
                        searchResult.Source = modelElement;
                        searchResult.Reason = "Property " + propertyInfo.Name + " is 'null'";

                        results.Add(searchResult);
                    }
                    else if (nameValue != null && !System.String.IsNullOrEmpty(searchText))
                        if (Contains(nameValue.ToString(), searchText, options))
                        {
                            SearchResult searchResult = new SearchResult();
                            searchResult.IsSuccessFull = true;
                            searchResult.Source = modelElement;
                            searchResult.Reason = "Property " + propertyInfo.Name + " contains '" + searchText + "'";

                            results.Add(searchResult);
                        }

                }
			#endregion

            #region roles
            if (criteria == SearchCriteriaEnum.Roles ||
                criteria == SearchCriteriaEnum.All)
            {
                foreach (DomainRoleInfo roleInfo in info.AllDomainRolesPlayed)
                {
                    if (!roleInfo.IsSource)
                        continue;

                    DomainRelationshipInfo relInfo = roleInfo.DomainRelationship;
                    if (!IsLinkIncludedInDomainTree(modelElement.Store as DomainModelStore, relInfo.Id))
                        continue;

                    ReadOnlyCollection<ElementLink> links = DomainRoleInfo.GetElementLinks<ElementLink>(modelElement, roleInfo.Id);
                    if (links.Count == 0 && String.IsNullOrEmpty(searchText))
                    {
                        SearchResult searchResult = new SearchResult();
                        searchResult.IsSuccessFull = true;
                        searchResult.Source = modelElement;
                        searchResult.Reason = "Role " + roleInfo.PropertyName + " is empty";

                        results.Add(searchResult);
                    }

                    foreach (ElementLink link in links)
                    {
                        ModelElement m = DomainRoleInfo.GetTargetRolePlayer(link);
                        if (m == null && System.String.IsNullOrEmpty(searchText))
                        {
                            SearchResult searchResult = new SearchResult();
                            searchResult.IsSuccessFull = true;
                            searchResult.Source = modelElement;
                            searchResult.Reason = "Role " + roleInfo.PropertyName + " is null";

                            results.Add(searchResult);
                        }
                        else if (m != null && !System.String.IsNullOrEmpty(searchText))
                            if (Contains((m as IDomainModelOwnable).DomainElementFullName, searchText, options))
                            {
                                SearchResult searchResult = new SearchResult();
                                searchResult.IsSuccessFull = true;
                                searchResult.Source = modelElement;
//.........这里部分代码省略.........

        /// <summary>
        /// Write all properties that need to be serialized as XML attributes.
        /// </summary>
        /// <param name="serializationContext">Serialization context.</param>
        /// <param name="element">PatternModelSchemaDiagram instance to be serialized.</param>
        /// <param name="writer">XmlWriter to write serialized data to.</param>
        protected override void WritePropertiesAsAttributes(SerializationContext serializationContext, ModelElement element, XmlWriter writer)
        {
            Guard.NotNull(() => serializationContext, serializationContext);
            Guard.NotNull(() => element, element);
            Guard.NotNull(() => writer, writer);

            writer.WriteAttributeString("type", element.GetType().FullName);
            base.WritePropertiesAsAttributes(serializationContext, element, writer);
        }

        public static List<KeyValuePair<PropertyInfo, object>> GetModelElementProperties(ModelElement element, params string[] propertyNames)
        {
            var modelElementType = element.GetType();
            var properties = new List<KeyValuePair<PropertyInfo, object>>();

            for (int i = 0; i < propertyNames.Count(); i++)
            {
                var property = modelElementType.GetProperties().FirstOrDefault(p => p.Name == propertyNames[i]);

                properties.Add(new KeyValuePair<PropertyInfo, object>(property, property.GetValue(element)));
            }

            return properties;
        }