C# PropertyCollection类代码示例

        protected override ControlInfo OnCreateConfigUI(PropertyCollection props)
        {
            ControlInfo configUI = base.OnCreateConfigUI(props);

            configUI.SetPropertyControlValue(PropertyNames.Amount, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("PolarInversion.ConfigUI.Amount.DisplayName"));
            configUI.SetPropertyControlValue(PropertyNames.Amount, ControlInfoPropertyNames.UseExponentialScale, true);
            configUI.SetPropertyControlValue(PropertyNames.Amount, ControlInfoPropertyNames.SliderLargeChange, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Amount, ControlInfoPropertyNames.SliderSmallChange, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Amount, ControlInfoPropertyNames.UpDownIncrement, 0.01);

            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("PolarInversion.ConfigUI.Offset.DisplayName"));
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderSmallChangeX, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderLargeChangeX, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.UpDownIncrementX, 0.01);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderSmallChangeY, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.SliderLargeChangeY, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.UpDownIncrementY, 0.01);

            Rectangle selection = this.EnvironmentParameters.GetSelection(base.EnvironmentParameters.SourceSurface.Bounds).GetBoundsInt();
            ImageResource propertyValue = ImageResource.FromImage(base.EnvironmentParameters.SourceSurface.CreateAliasedBitmap(selection));
            configUI.SetPropertyControlValue(PropertyNames.Offset, ControlInfoPropertyNames.StaticImageUnderlay, propertyValue);

            configUI.SetPropertyControlValue(PropertyNames.EdgeBehavior, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("PolarInversion.ConfigUI.EdgeBehavior.DisplayName"));

            PropertyControlInfo edgeBehaviorPCI = configUI.FindControlForPropertyName(PropertyNames.EdgeBehavior);
            edgeBehaviorPCI.SetValueDisplayName(WarpEdgeBehavior.Clamp, PdnResources.GetString("PolarInversion.ConfigUI.EdgeBehavior.Clamp.DisplayName"));
            edgeBehaviorPCI.SetValueDisplayName(WarpEdgeBehavior.Reflect, PdnResources.GetString("PolarInversion.ConfigUI.EdgeBehavior.Reflect.DisplayName"));
            edgeBehaviorPCI.SetValueDisplayName(WarpEdgeBehavior.Wrap, PdnResources.GetString("PolarInversion.ConfigUI.EdgeBehavior.Wrap.DisplayName"));

            configUI.SetPropertyControlValue(PropertyNames.Quality, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("PolarInversion.ConfigUI.Quality.DisplayName"));

            return configUI;
        }

        public MapContent(string filePath, Renderer renderer, string contentRoot)
        {
            XmlDocument document = new XmlDocument();
            document.Load(filePath);

            XmlNode mapNode = document[AttributeNames.MapAttributes.Map];

            Version = mapNode.Attributes[AttributeNames.MapAttributes.Version].Value;
            Orientation = (Orientation)Enum.Parse(typeof(Orientation), mapNode.Attributes[AttributeNames.MapAttributes.Orientation].Value, true);
            Width = Utilities.TryToParseInt(mapNode.Attributes[AttributeNames.MapAttributes.Width].Value);
            Height = Utilities.TryToParseInt(mapNode.Attributes[AttributeNames.MapAttributes.Height].Value);
            TileWidth = Utilities.TryToParseInt(mapNode.Attributes[AttributeNames.MapAttributes.TileWidth].Value);
            TileHeight = Utilities.TryToParseInt(mapNode.Attributes[AttributeNames.MapAttributes.TileHeight].Value);

            XmlNode propertiesNode = document.SelectSingleNode(AttributeNames.MapAttributes.MapProperties);
            if (propertiesNode != null)
                properties = new PropertyCollection(propertiesNode);

            BuildTileSets(document);

            BuildLayers(document);

            BuildTileSetTextures(renderer, contentRoot);

            GenerateTileSourceRectangles();
        }

 public void AddTypedProperty1()
 {
     var col = new PropertyCollection();
     col.AddTypedProperty("foo");
     Assert.AreEqual(1, col.PropertyList.Count);
     Assert.IsTrue(col.ContainsProperty(typeof(string)));
 }

 public Level(string uniqueName, string caption, int number, PropertyCollection properties)
 {
     UniqueName = uniqueName;
     Caption = caption;
     Number = number;
     Properties = properties;
 }

        public Layer(XElement node)
        {
            //string Type = node.Name;
            Name = node.Attribute("name").Value;
            if (node.Attribute("width") != null)
                Width = int.Parse(node.Attribute("width").Value, CultureInfo.InvariantCulture);
            else
                Width = 0;
            if (node.Attribute("height") != null)
                Height = int.Parse(node.Attribute("height").Value, CultureInfo.InvariantCulture);
            else
                Height = 0;

            if (node.Attribute("opacity") != null)
            {
                Opacity = float.Parse(node.Attribute("opacity").Value, CultureInfo.InvariantCulture);
            }
            else
                Opacity = 1;

            if (node.Attribute("visible") != null)
            {
                Visible = int.Parse(node.Attribute("visible").Value, CultureInfo.InvariantCulture) == 1;
            }
            else
                Visible = true;

            XElement propertiesNode = node.Element("properties");
            if (propertiesNode != null)
            {
                Properties = new PropertyCollection(propertiesNode);
            }
        }

 internal Settings(StyleCopCore core)
 {
     this.globalSettings = new PropertyCollection();
     this.parserSettings = new Dictionary<string, AddInPropertyCollection>();
     this.analyzerSettings = new Dictionary<string, AddInPropertyCollection>();
     this.core = core;
 }

        public ObjectContent(XmlNode node)
        {
            if (node.Attributes[AttributeNames.MapObjectAttributes.Name] != null)
                Name = node.Attributes[AttributeNames.MapObjectAttributes.Name].Value;

            if (node.Attributes[AttributeNames.MapObjectAttributes.Type] != null)
                Type = node.Attributes[AttributeNames.MapObjectAttributes.Type].Value;

            if (node[AttributeNames.MapObjectAttributes.Properties] != null)
                properties = new PropertyCollection(node[AttributeNames.MapObjectAttributes.Properties]);

            int x = 0, y = 0, width = 0, height = 0;

            if (node.Attributes[AttributeNames.MapObjectAttributes.X] != null)
                x = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.X].Value);

            if (node.Attributes[AttributeNames.MapObjectAttributes.Y] != null)
                y = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.Y].Value);

            if (node.Attributes[AttributeNames.MapObjectAttributes.Width] != null)
                width = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.Width].Value);

            if (node.Attributes[AttributeNames.MapObjectAttributes.Height] != null)
                height = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.Height].Value);

            Bounds = new Rectangle(x, y, width, height);

            string objectPoints = String.Empty;

            if (node.Attributes[AttributeNames.MapObjectAttributes.GID] != null)
            {
                objectType = MapObjectType.Tile;
                GID = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.GID].Value);
            }
            else if (node.Attributes[AttributeNames.MapObjectAttributes.Polygon] != null)
            {
                objectType = MapObjectType.Polygon;
                objectPoints = node.Attributes[AttributeNames.MapObjectAttributes.Polygon].Value;
            }
            else if (node.Attributes[AttributeNames.MapObjectAttributes.Polyline] != null)
            {
                objectType = MapObjectType.Polyline;
                objectPoints = node.Attributes[AttributeNames.MapObjectAttributes.Polyline].Value;
            }

            if(!String.IsNullOrEmpty(objectPoints))
            {
                string[] splitPoints = objectPoints.Split(' ');
                foreach(string splitPoint in splitPoints)
                {
                    string[] coordinates = splitPoint.Split(',');

                    float coordinateX = 0f, coordinateY = 0f;
                    float.TryParse(coordinates[0], NumberStyles.None, CultureInfo.InvariantCulture, out coordinateX);
                    float.TryParse(coordinates[1], NumberStyles.None, CultureInfo.InvariantCulture, out coordinateY);

                    points.Add(new Point((int)x, (int)y));
                }
            }
        }

        /// <summary>
        /// Constructor for creating a Content object
        /// </summary>
        /// <param name="name">Name of the content</param>
        /// <param name="parentId">Id of the Parent content</param>
        /// <param name="contentType">ContentType for the current Content object</param>
        /// <param name="properties">Collection of properties</param>
        public Content(string name, int parentId, IContentType contentType, PropertyCollection properties) 
			: base(name, parentId, contentType, properties)
        {
            Mandate.ParameterNotNull(contentType, "contentType");

            _contentType = contentType;
        }

        internal Tileset(ContentReader reader)
            : this()
        {
            _manager = reader.ContentManager;

            int version = reader.ReadInt16();
            int id = reader.ReadInt16();

            TileWidth = reader.ReadInt16();
            TileHeight = reader.ReadInt16();
            string texAsset = reader.ReadString();

            Properties = new PropertyCollection(reader);

            int tileCount = reader.ReadInt16();
            for (int i = 0; i < tileCount; i++) {
                int tileId = reader.ReadInt16();
                int tileX = reader.ReadInt16();
                int tileY = reader.ReadInt16();

                Tile tile = new Tile(tileId, this, tileX, tileY)
                {
                    Properties = new PropertyCollection(reader),
                };
                _tiles.Add(tileId, tile);
            }

            _texture = _manager.Load<Texture2D>(texAsset);
        }

        protected override ControlInfo OnCreateConfigUI(PropertyCollection props)
        {
            ControlInfo configUI = CreateDefaultConfigUI(props);

            configUI.SetPropertyControlValue(PropertyNames.Scale, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("CloudsEffect.ConfigDialog.ScaleLabel"));

            configUI.SetPropertyControlValue(PropertyNames.Power, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("CloudsEffect.ConfigDialog.RoughnessLabel"));
            configUI.SetPropertyControlValue(PropertyNames.Power, ControlInfoPropertyNames.SliderLargeChange, 0.25);
            configUI.SetPropertyControlValue(PropertyNames.Power, ControlInfoPropertyNames.SliderSmallChange, 0.05);
            configUI.SetPropertyControlValue(PropertyNames.Power, ControlInfoPropertyNames.UpDownIncrement, 0.01);

            PropertyControlInfo blendOpControl = configUI.FindControlForPropertyName(PropertyNames.BlendOp);
            blendOpControl.ControlProperties[ControlInfoPropertyNames.DisplayName].Value = PdnResources.GetString("CloudsEffect.ConfigDialog.BlendModeHeader.Text");

            Type[] blendOpTypes = UserBlendOps.GetBlendOps();
            foreach (Type blendOpType in blendOpTypes)
            {
                string blendOpDisplayName = UserBlendOps.GetBlendOpFriendlyName(blendOpType);
                blendOpControl.SetValueDisplayName(blendOpType, blendOpDisplayName);
            }

            configUI.SetPropertyControlType(PropertyNames.Seed, PropertyControlType.IncrementButton);
            configUI.SetPropertyControlValue(PropertyNames.Seed, ControlInfoPropertyNames.DisplayName, PdnResources.GetString("CloudsEffect.ConfigDialog.SeedHeader.Text"));
            configUI.SetPropertyControlValue(PropertyNames.Seed, ControlInfoPropertyNames.ButtonText, PdnResources.GetString("CloudsEffect.ConfigDialog.ReseedButton.Text"));
            configUI.SetPropertyControlValue(PropertyNames.Seed, ControlInfoPropertyNames.Description, PdnResources.GetString("CloudsEffect.ConfigDialog.UsageLabel"));

            return configUI;
        }

        protected virtual void ReadDetail(XPathNavigator navigator, PropertyCollection collection, ReadingJournal journal)
        {
            Dictionary<string, string> attributes = GetAttributes(navigator);
            Type type = attributes["typeName"].ToType();

            if (type != typeof(ContentItem))
            {
                collection.Add(Parse(navigator.Value, type));
            }
            else
            {
                int referencedItemID = int.Parse(navigator.Value);
                ContentItem referencedItem = journal.Find(referencedItemID);
                if (referencedItem != null)
                    collection.Add(referencedItem);
                else
                    journal.ItemAdded += (sender, e) =>
            {
                if (e.AffectedItem.ID == referencedItemID)
                {
                    collection.Add(e.AffectedItem);
                }
            };
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="Mesh"/> class.
 /// </summary>
 public Mesh()
 {
     VertexBuffers = new List<VertexBuffer>();
     IndexBuffers = new List<IndexBuffer>();
     MeshParts = new List<MeshPart>();
     Properties = new PropertyCollection();
 }

        internal PropertyManager(PropertyClassManager classManager, object inst)
        {
            _classManager = classManager;
            _inst = inst;

            _custom = new PropertyCollection(_classManager.RegisteredNames);
        }

 /// <summary>
 /// Default constructor requires a name, the bounds of the object, the orientation of projection, and a collection of properties assigned to the object
 /// </summary>
 /// <param name="name"></param>
 /// <param name="bounds"></param>
 /// <param name="orientation"></param>
 /// <param name="properties"></param>
 public MapObject(string name, Rectangle bounds, Orientation orientation, PropertyCollection properties)
 {
     Name = name;
     Bounds = bounds;
     Orientation = orientation;
     Properties = properties;
 }

 internal MapObject(string name, string type, Rectangle location, PropertyCollection properties)
 {
     Name = name;
     Type = type;
     Location = location;
     Properties = properties;
 }