问通过在代码中设置高度和宽度来缩小视图的大小不会正确更新

EN

private static void CalculateWindowSize(BaseWindow window, List<View> views, bool adjustCurrentSize)
        {
            // Calculate the extra space the window consumes.
            View topView = views.First();
            double heightDiff = window.ActualHeight - topView.ActualHeight;

            double widthDiff = window.ActualWidth - topView.ActualWidth;
            double ww = window.Width; //
            double tvw = topView.Width;


            const double zeroTolerance = 0.6;
            double maxHeightMax = 0, maxWidthMax = 0;
            double maxHeightSum = 0, maxWidthSum = 0;
            double minHeightMax = 0, minWidthMax = 0;
            double minHeightSum = 0, minWidthSum = 0;
            double heightSum = 0, widthSum = 0;
            double heightMax = 0, widthMax = 0;
            foreach (View view in views)
            {
                ViewSizeBehaviour viewHeightBehaviour = GetHeightSizeBehaviour(view);
                ViewSizeBehaviour viewWidthBehaviour = GetWidthSizeBehaviour(view);

                switch (viewHeightBehaviour)
                {
                    case ViewSizeBehaviour.Sum:
                    {
                        if (!double.IsInfinity(view.MaxHeight)) maxHeightSum += view.MaxHeight;
                        if (Math.Abs(view.MinHeight) > zeroTolerance) minHeightSum += view.MinHeight;

                        // Default to MinHeight if WindowHeight not defined
                        if (!double.IsNaN(view.WindowHeight)) heightSum += view.WindowHeight;
                        else heightSum += view.MinHeight;
                        break;
                    }
                    case ViewSizeBehaviour.Max:
                    {
                        if (!double.IsInfinity(view.MaxHeight)) maxHeightMax = Math.Max(maxHeightMax, view.MaxHeight);
                        if (Math.Abs(view.MinHeight) > zeroTolerance) minHeightMax = Math.Max(minHeightMax, view.MinHeight);

                        // Default to MinHeight if WindowHeight not defined
                        heightMax = Math.Max(heightMax, !double.IsNaN(view.WindowHeight) ? view.WindowHeight : view.MinHeight);
                        break;
                    }
                }

                switch (viewWidthBehaviour)
                {
                    case ViewSizeBehaviour.Sum:
                    {
                        if (!double.IsInfinity(view.MaxWidth)) maxWidthSum += view.MaxWidth;
                        if (Math.Abs(view.MinWidth) > zeroTolerance) minWidthSum += view.MinWidth;

                        // Default to MinWidth if WindowWidth not defined
                        if (!double.IsNaN(view.WindowWidth)) widthSum += view.WindowWidth;
                        else widthSum += view.MinWidth;
                        break;
                    }
                    case ViewSizeBehaviour.Max:
                    {
                        if (!double.IsInfinity(view.MaxWidth)) maxWidthMax = Math.Max(maxWidthMax, view.MaxHeight);
                        if (Math.Abs(view.MinWidth) > zeroTolerance) minWidthMax = Math.Max(minWidthMax, view.MinWidth);

                        // Default to MinWidth if WindowWidth not defined
                        widthMax = Math.Max(widthMax, !double.IsNaN(view.WindowWidth) ? view.WindowWidth : view.MinWidth);
                        break;
                    }
                }
            }

            if (adjustCurrentSize)
            {
                window.Height = Math.Max(heightSum, heightMax) + heightDiff;
                window.Width = Math.Max(widthSum, widthMax) + widthDiff;
            }

            // Only set maximum height & width if they are greater than zero. Otherwise all views have specified Infinity as max height

            double maxHeight = Math.Max(maxHeightSum, maxHeightMax);
            double maxWidth = Math.Max(maxWidthSum, maxWidthMax);
            if (Math.Abs(maxHeight) > zeroTolerance)
            {
                window.MaxHeight = maxHeight + heightDiff;
                if (window.MaxHeight < window.Height || window.MaxHeight < window.ActualHeight)
                {
                    window.Height = window.MaxHeight;
                }
            }
            if (Math.Abs(maxWidth) > zeroTolerance)
            {
                window.MaxWidth = maxWidth + widthDiff;
                if (window.MaxWidth < window.Width || window.MaxWidth < window.ActualWidth)
                {
                    window.Width = window.MaxWidth;
                }
            }

            // Minimum height & width are the maximum of either the sum or max calculations

            window.MinHeight = Math.Max(minHeightSum, minHeightMax) + heightDiff;
            window.MinWidth = Math.Max(minWidthSum, minWidthMax) + widthDiff;