Question

UPDATE   主要问题仍然存在   在这个例子下，但我猜它归结为一般   致：

**如果您的类型中99％的值可以用一个表示   快速，强大的类型，只有1％   非常沉重的类型，（比如int vs.   BigInteger）如何表现？ **

一所学校我们学到了很多关于内部表征的知识，但从未在运行时如何改变它。我的意思是：假设你有一个表示小数的类，但是你使用一个整数来表示它是内部的，直到你实际需要一个比整数更大的值，而只是改变表示...

我之前从未想过这一点，当我想到它时，我认为这样做永远不会奏效，因为所有的检查都会杀掉它。但是我只是做了一个测试，因为我对自己的好处太好奇了，并且确实存在更改表示更多的情况：给定这个界面：

interface INumber
    {
        void add1000();
        void SetValue(decimal d);
        decimal GetValue();                     
    }

我发现两种实现中的后一种在很多情况下都更强大，包括this one我为了吸引尽可能多的想法而不是代表，它是社区的

    1. Representation by only a decimal

        public class Number1:INumber
        {

            private decimal d { get; set; }


            public void add1000()
            {
                d += 1000;
            }



            public decimal GetValue()
            {
                return d;
            }



            public void SetValue(decimal d)
            {
                this.d = d;
            }

        }


2. Representation by a decimal and an int

public class Number2:INumber
    {
        private bool usedecimal; 
        private int i;
        private decimal d;

        public void add1000()
        {
            if (usedecimal)
            {
                d += 1000;
                return; 
            }

            i += 1000;

            if (i > 2147480000)
            {
                d = i;              
                usedecimal = true;              
            }


        }

        public void SetValue(decimal d)
        {
            try
            {
                i = (int)d;

            }
            catch (OverflowException e)
            {

                this.d = d;
            }

        }

        public decimal GetValue()
        {
            return Math.Max(i,d);
        }
    }
}

我的问题如下：

这似乎是......我一直在想，但这一定是明显的流血。任何人都可以帮我解决这个问题吗？

是否有混合表示的指导原则，何时使用它们？
如果在没有基准测试的情况下混合重新缓和可以更快，如何预感？
任何例子？
任何模式？
关于此事的任何想法？

Answer 1

如果你有一个类型，其中99％的值可以用一个快速强大的类型表示，而只有1％用非常重的类型表示，（比如int与BigInteger）如何表示它？

BigInteger实现通常就是这样做的;他们将所有内容保持在整数或长期内，直到出现溢出，然后才进入较重的实施。

有很多方法可以代表它。我喜欢的模式是：

public abstract class Thing
{
    private class LightThing : Thing
    { ... }
    private class HeavyThing : Thing 
    { ... }
    public static Thing MakeThing(whatever) 
    { /* make a heavy or light thing, depending */ }
    ... etc ...
}

是否有混合表示的指导原则，何时使用它们？

不确定。我们可以轻松编译这样的列表。在以下情况下，这种技术是有意义的：

（1）轻量级实现比重量级实现轻得多

（2）大多数情况下，典型用法属于轻量级代码路径

（3）与重量级解决方案的成本相比，检测转换的成本并不是一个显着的成本

（4）为了实现以客户为中心，切合实际的绩效目标，需要更复杂的双表示解决方案。

如果在没有基准测试的情况下混合重新缓和可以更快，如何预感？

别。基于预感做出绩效决策是事先推理的。推动现实，以客户为中心，数据驱动分析的绩效决策，而不是预感。如果我多年来对性能分析有所了解，那我的预感通常是错误的。

任何例子？

BigInteger的任意数量的实现。

任何模式？

击败了我。我不太喜欢记忆模式分类法。

关于此事的任何想法？

见上文。

Answer 2

也许您正在寻找Bridge pattern。

在运行时更改内部表示

2 个答案: