C# Dimension类代码示例

        public KnownUnit CreateUnit(IUnitSystem system, double factor, Dimension dimension, string symbol, string name,
            bool inherentPrefix)
        {
            var unit = new KnownUnit(system, factor, dimension, symbol, name, inherentPrefix);

            return unit;
        }

        public static DimensionInfo CreateDimensionInfo(Dimension dim)
        {
            if (dim == null)
                return null;
            DimensionInfo info = new DimensionInfo();
            info.Caption = dim.Caption;
            info.Description = dim.Description;
            info.DimensionType = (DimensionInfoTypeEnum)(dim.DimensionType);
            info.Name = dim.Name;
            info.WriteEnabled = dim.WriteEnabled;
            info.UniqueName = dim.UniqueName;

            // Информация о предках
            if (dim.ParentCube != null)
            {
                info.ParentCubeId = dim.ParentCube.Name;
                info.CustomProperties.Add(new PropertyInfo(InfoBase.CUBE_CAPTION, dim.ParentCube.Caption));
            }

            // Свойства
            foreach (Property prop in dim.Properties)
            {
                //                PropertyInfo pi = new PropertyInfo(prop.Name, prop.Type, prop.Value);
                PropertyInfo pi = new PropertyInfo(prop.Name, prop.Value);
                info.Properties.Add(pi);
            }
            return info;
        }

		protected override void OnCreate (Bundle bundle)
		{
			base.OnCreate (bundle);

			// Set our view from the "main" layout resource
			SetContentView (Resource.Layout.Main);

			// Get our button from the layout resource,
			// and attach an event to it
			Button button = FindViewById<Button> (Resource.Id.getcloudwatchdata);
			EditText cloudwatchdata = FindViewById<EditText> (Resource.Id.cloudwatchdata);

			button.Click += delegate {
				const string ACCESS_KEY = "";
				const string SECRET_KEY = "";
				IAmazonCloudWatch cw = Amazon.AWSClientFactory.CreateAmazonCloudWatchClient (ACCESS_KEY, SECRET_KEY, Amazon.RegionEndpoint.USWest1);

				string measureName = "CPUUtilization";

				GetMetricStatisticsRequest request = new GetMetricStatisticsRequest ();
				request.StartTime = DateTime.Now.AddDays (-1);
				request.Namespace = "AWS/EC2";
				request.Period = 5 * 60;
				var dimensions = new Dimension ();
				dimensions.Name = "InstanceType";
				dimensions.Value = "t1.micro";
				request.Dimensions = new List<Dimension>{ dimensions };
				request.MetricName = measureName;
				request.Statistics = new List<string>{"Average", "Maximum", "Minimum"};
				request.EndTime = DateTime.Now;

				List<Datapoint> datapoints = cw.GetMetricStatistics(request).Datapoints;
				datapoints.ForEach(d => cloudwatchdata.Text = String.Format("Min: {0} Max: {1} Average: {3} Unit: {4}\n", d.Minimum, d.Maximum, d.Average, d.Unit));
			};
		}

        protected override Point MatchCoordinate(Dimension dimension)
        {
            Match match = MatchRegex(@"^(-?\d+\.?\d*)\s+(-?\d+\.?\d*)\s+(-?\d+\.?\d*)\s+(-?\d+\.?\d*)");

            if (match.Success)
            {
                geometryDimension = Dimension.Xyzm;
                return new Point(double.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture), double.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture), double.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture), double.Parse(match.Groups[4].Value, CultureInfo.InvariantCulture));
            }

            match = MatchRegex(@"^(-?\d+\.?\d*)\s+(-?\d+\.?\d*)\s+(-?\d+\.?\d*)");

            if (match.Success)
            {
                if (dimension == Dimension.Xym)
                {
                    geometryDimension = Dimension.Xym;
                    return new Point(double.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture), double.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture), null, double.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture));
                }
                else
                {
                    geometryDimension = Dimension.Xyz;
                    return new Point(double.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture), double.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture), double.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture));
                }
            }

            geometryDimension = Dimension.Xy;
            match = MatchRegex(@"^(-?\d+\.?\d*)\s+(-?\d+\.?\d*)");
            return new Point(double.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture), double.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture));
        }

 public static Dimension Discharge()
 {
     Dimension d = new Dimension();
     d.SetPower(DimensionBase.Length, 3.0);
     d.SetPower(DimensionBase.Time, -1.0);
     return d;
 }

        public void ThenExponentsDetermineEquality()
        {
            var dim1 = new Dimension(1, 2, 3);
            var dim2 = new Dimension(1, 2, 3);
            var dim3 = new Dimension(3, 2, 1);

            Assert.AreEqual(dim1, dim2);
            Assert.AreEqual(dim1.GetHashCode(), dim1.GetHashCode());
            Assert.AreNotEqual(dim1, dim3);
            Assert.AreNotEqual(dim1.GetHashCode(), dim3.GetHashCode());
            Assert.AreNotEqual(dim2, dim3);
            Assert.AreNotEqual(dim2.GetHashCode(), dim3.GetHashCode());

            var dim4 = new Dimension(1);
            var dim5 = new Dimension(1);

            Assert.AreEqual(dim4, dim5);
            Assert.AreEqual(dim4.GetHashCode(), dim5.GetHashCode());

            var dim6 = new Dimension();
            var dim7 = new Dimension();

            Assert.AreEqual(dim6, dim7);
            Assert.AreEqual(dim6.GetHashCode(), dim7.GetHashCode());
        }

 public Renderable(String texturePath)
 {
     Texture = new Bitmap(texturePath);
     Position = new Coordinate();
     Dimension = new Dimension();
     PinPositions = new List<Coordinate>();
 }

    public static Bitmap Render(Dimension d, LatticeLayoutMethod method, bool ShowOnlyMultilevelRelationships)
    {
        if (ShowOnlyMultilevelRelationships)
        {
            if (d.Attributes.Count == 1)
            {
                //avoid an error
                ShowOnlyMultilevelRelationships = false;
            }
        }
        LatticeDrawing ld = new LatticeDrawing(d.Name);
        ld.LayoutMethod = method;
        foreach (DimensionAttribute a in d.Attributes)
        {
            ld.Nodes.Add(a.ID, new LatticeNode(a.Name));
            if (d.KeyAttribute == a)
            {
                ld.Nodes[a.ID].IsKey = true;
            }
            ld.Nodes[a.ID].Visible = a.AttributeHierarchyVisible;
            ld.Nodes[a.ID].Enabled = a.AttributeHierarchyEnabled;
        }
        foreach (DimensionAttribute a in d.Attributes)
        {
            foreach (AttributeRelationship r in a.AttributeRelationships)
            {
                ld.Nodes[a.ID].Relationships.Add(new LatticeRelationship(ld.Nodes[r.AttributeID], r.RelationshipType, r.Visible));
                if (d.KeyAttribute != a)
                {
                    ld.Nodes[r.AttributeID].NonKeyReferenceCount++;
                }
            }
        }
        if (ShowOnlyMultilevelRelationships)
        {
            foreach (DimensionAttribute a in d.Attributes)
            {
                if (a.AttributeRelationships.Count == 0 && ld.Nodes[a.ID].NonKeyReferenceCount == 0)
                {
                    ld.Nodes.Remove(a.ID);
                }
            }
            foreach (LatticeNode ln in ld.Nodes.Values)
            {
                for (int i = 0; i < ln.Relationships.Count; i++)
                {
                    LatticeRelationship lr = ln.Relationships[i];
                    if (!ld.Nodes.ContainsValue(lr.node))
                    {
                        ln.Relationships.Remove(lr);
                        i--;
                    }
                }
            }
        }


        ld.LayoutMethod = method;
        return ld.Render();
    }

        public CubicGrid(int3 dimensions, float valueMin, float valueMax, Dimension gradientDirection)
        {
            Dimensions = dimensions;
            Values = new float[dimensions.Z, dimensions.Y, dimensions.X];
            float Step = valueMax - valueMin;
            if (gradientDirection == Dimension.X)
                Step /= Math.Max(1, dimensions.X - 1);
            else if (gradientDirection == Dimension.Y)
                Step /= Math.Max(1, dimensions.Y - 1);
            else if (gradientDirection == Dimension.Z)
                Step /= Math.Max(1, dimensions.Z - 1);

            for (int z = 0; z < dimensions.Z; z++)
                for (int y = 0; y < dimensions.Y; y++)
                    for (int x = 0; x < dimensions.X; x++)
                    {
                        float Value = valueMin;
                        if (gradientDirection == Dimension.X)
                            Value += x * Step;
                        if (gradientDirection == Dimension.Y)
                            Value += y * Step;
                        if (gradientDirection == Dimension.Z)
                            Value += z * Step;

                        Values[z, y, x] = Value;
                    }

            Spacing = new float3(1f / Math.Max(1, dimensions.X - 1), 1f / Math.Max(1, dimensions.Y - 1), 1f / Math.Max(1, dimensions.Z - 1));
        }

 public void testBlockDimensions()
 {
     Dimension frame = new Dimension(320,240);
     for(int numY = 1; numY < 10; numY ++) {
         for(int numX = 1; numX < 10; numX++) {
         Console.WriteLine("numX: %d\tnumY: %d\n", numX, numY);
         Dimension block = new Dimension(frame.Width / numX,
                         frame.Height / numY);
         for(int i = 0; i < numY; i++)
             for(int j = 0; j < numX; j++) {
             int testStart = (block.Width*j) +
                 (frame.Width*block.Height*i);
             int testEnd = testStart + block.Width +
                 (frame.Width*(block.Height-1));
             int specX = (frame.Width * j)/numX;
             int specY = (frame.Height *i)/numY;
             int specStart = (frame.Width*specY) + specX;
             int specEndX = (frame.Width * (j+1))/numX;
             int specEndY = (frame.Height *(i+1))/numY;
             int specEnd = (frame.Width*(specEndY - 1)) + specEndX;
             if(specEnd != testEnd ||
                specStart != testStart) {
                 Console.WriteLine("Spec:\t\tTest\n%d\t\t%d\n",
                           specEnd, testEnd);
                 Console.WriteLine("%d\t\t%d\n", specStart,
                           testStart);
             }
             }
         }
     }
 }

        private static void ImportD5()
        {
            Dictionary<string,string> dict =  new Dictionary<string,string>(11);
            //dict.Add("Peroid","期");
            //dict.Add("DaXiao","大小");
            //dict.Add("DanShuang","单双");
            //dict.Add("ZiHe","质合");
            //dict.Add("Lu012","012路");
            //dict.Add("He","和");
            //dict.Add("HeWei","和尾");
            //dict.Add("Ji","积");
            //dict.Add("JiWei","积尾");
            //dict.Add("KuaDu","跨度");
            //dict.Add("AC","AC");
            //dict.Add("DaXiaoBi", "大小比");
            //dict.Add("ZiHeBi", "质合比");
            //dict.Add("DanShuangBi", "单双比");
            //dict.Add("Lu012Bi", "012路比");

            foreach (var kp in dict)
            {
                Dimension dim = new Dimension();
                dim.Name = kp.Value;
                dim.Code = kp.Key;
                dim.Seq = 100;
                DimensionBiz.Instance.Add(dim);
            }
        }

 public LightSequenceBar(LightSequence sequence, Point pivot, Dimension tileSize, int indent)
     : base(Geometry.ConstructRectangle(pivot, tileSize))
 {
     this.sequence = sequence;
     this.tileSize = tileSize;
     this.indent = indent;
 }

        public void ThenStartingZerosAreNotIgnored()
        {
            var dim1 = new Dimension(0, 0, 1);
            var dim2 = new Dimension(1);

            Assert.AreNotEqual(dim1, dim2);
        }

 public void ReadPacket(IMinecraftStream stream)
 {
     EntityID = stream.ReadInt32();
     stream.ReadString(); // Unused
     Seed = stream.ReadInt64();
     Dimension = (Dimension)stream.ReadInt8();
 }

 public LifeBoard(Dimension dim)
 {
     width = dim.Width;
     height = dim.Height;
     size = dim.Size;
     array = new bool[width, height];
 }