O que é boxe e unboxing e quais são as compensações?

Estou procurando uma resposta clara, concisa e precisa.

Idealmente, como a resposta real, embora os links para boas explicações sejam bem-vindos.

Valores em caixa são estruturas de dados que são invólucros mínimos em torno de tipos primitivos *. Os valores em caixa geralmente são armazenados como ponteiros para objetos na pilha .

Assim, os valores em caixa usam mais memória e levam no mínimo duas pesquisas de memória para acessar: uma para obter o ponteiro e outra para segui-lo até o primitivo. Obviamente, este não é o tipo de coisa que você deseja em seus circuitos internos. Por outro lado, os valores em caixa normalmente são melhores com outros tipos no sistema. Como são estruturas de dados de primeira classe no idioma, eles têm os metadados e a estrutura esperados que outras estruturas de dados possuem.

No Java e Haskell, as coleções genéricas não podem conter valores sem caixa. Coleções genéricas no .NET podem conter valores sem caixa, sem penalidades. Onde os genéricos de Java são usados ​​apenas para verificação de tipo em tempo de compilação, o .NET gera classes específicas para cada tipo genérico instanciado em tempo de execução .

Java e Haskell têm matrizes sem caixa, mas são claramente menos convenientes do que as outras coleções. No entanto, quando o desempenho máximo é necessário, vale a pena um pequeno inconveniente para evitar a sobrecarga do boxe e do unboxing.

* Para esta discussão, um valor primitivo é aquele que pode ser armazenado na pilha de chamadas , em vez de ser armazenado como um ponteiro para um valor no heap. Freqüentemente, são apenas os tipos de máquinas (entradas, flutuadores, etc.), estruturas e, às vezes, matrizes de tamanho estático. O .NET-land os chama de tipos de valor (em oposição aos tipos de referência). O pessoal de Java os chama de tipos primitivos. Os haskellions apenas os chamam de fora da caixa.

** Também estou focando em Java, Haskell e C # nesta resposta, porque é isso que eu sei. Pelo que vale, Python, Ruby e Javascript têm valores exclusivamente em caixa. Isso também é conhecido como a abordagem "Tudo é um objeto" ***.

*** Advertência: Em alguns casos, um compilador / JIT suficientemente avançado pode realmente detectar que um valor que é semanticamente encaixotado ao olhar a fonte pode ser com segurança um valor não encaixotado no tempo de execução. Em essência, graças aos implementadores de linguagem brilhantes, suas caixas às vezes são gratuitas.

do C # 3.0 Em poucas palavras :

Boxe é o ato de converter um tipo de valor em um tipo de referência:

int x = 9; 
object o = x; // boxing the int

unboxing é ... o inverso:

// unboxing o
object o = 9; 
int x = (int)o; 

Boxing & unboxing é o processo de converter um valor primitivo em uma classe de wrapper orientada a objetos (boxing) ou converter um valor de uma classe de wrapper orientada a objetos de volta ao valor primitivo (unboxing).

Por exemplo, em java, pode ser necessário converter um intvalor em um Integer(boxe) se você deseja armazená-lo em, Collectionporque os primitivos não podem ser armazenados em Collectionapenas objetos. Mas quando você deseja recuperá-lo, Collectionvocê pode obter o valor como um inte não um, Integerpara que você o desmarque.

Boxe e unboxing não são inerentemente ruins , mas são uma troca. Dependendo da implementação do idioma, ele pode ser mais lento e consome mais memória do que apenas o uso de primitivas. No entanto, também pode permitir que você use estruturas de dados de nível superior e obtenha maior flexibilidade no seu código.

Atualmente, é mais discutido no contexto do recurso "autoboxing / autounboxing" de Java (e de outra linguagem). Aqui está uma explicação centrada em java do autoboxing .

Na rede:

Freqüentemente, você não pode confiar no tipo de variável que uma função consumirá; portanto, é necessário usar uma variável de objeto que se estende do menor denominador comum - em .Net, este é object.

No entanto, objecté uma classe e armazena seu conteúdo como referência.

List<int> notBoxed = new List<int> { 1, 2, 3 };
int i = notBoxed[1]; // this is the actual value

List<object> boxed = new List<object> { 1, 2, 3 };
int j = (int) boxed[1]; // this is an object that can be 'unboxed' to an int

Enquanto ambos mantêm a mesma informação, a segunda lista é maior e mais lenta. Cada valor na segunda lista é na verdade uma referência a um objectque contém o int.

Isso é chamado de caixa porque o inté envolvido pelo object. Quando ele é lançado fora da intcaixa - convertido de volta ao seu valor.

Para tipos de valor (isto é, todos structs), isso é lento e potencialmente usa muito mais espaço.

Para tipos de referência (isto é, todos classes), isso é muito menos problemático, pois eles são armazenados como referência de qualquer maneira.

Um outro problema com um tipo de valor em caixa é que não é óbvio que você está lidando com a caixa, e não com o valor. Quando você compara dois structs, você está comparando valores, mas quando você compara dois, classesentão (por padrão), você está comparando a referência - ou seja, essas são a mesma instância?

Isso pode ser confuso ao lidar com tipos de valor em caixa:

int a = 7;
int b = 7;

if(a == b) // Evaluates to true, because a and b have the same value

object c = (object) 7;
object d = (object) 7;

if(c == d) // Evaluates to false, because c and d are different instances

É fácil contornar:

if(c.Equals(d)) // Evaluates to true because it calls the underlying int's equals

if(((int) c) == ((int) d)) // Evaluates to true once the values are cast

No entanto, é outra coisa a ter cuidado ao lidar com valores em caixa.

Boxingé o processo de conversão de um tipo de valor em um tipo de referência. Considerando que Unboxingé a conversão de um tipo de referência em um tipo de valor.

EX: int i = 123;
    object o = i;// Boxing
    int j = (int)o;// UnBoxing

Tipos de valor são: int, chare structures, enumerations. Tipos de referência são: Classes, interfaces, arrays, stringseobjects

As coleções genéricas do FCL do .NET:

List<T>
Dictionary<TKey, UValue>
SortedDictionary<TKey, UValue>
Stack<T>
Queue<T>
LinkedList<T>

foram todos projetados para superar os problemas de desempenho do boxe e do unboxing nas implementações de coleções anteriores.

Para obter mais informações, consulte o capítulo 16, CLR via C # (2ª edição) .

O boxe e o unboxing facilitam os tipos de valor a serem tratados como objetos. Boxe significa converter um valor em uma instância do tipo de referência do objeto. Por exemplo, Inté uma classe e inté um tipo de dados. A conversão intpara Inté uma exemplificação do boxe, enquanto a conversão Intpara inté unboxing. O conceito ajuda na coleta de lixo, o Unboxing, por outro lado, converte o tipo de objeto em tipo de valor.

int i=123;
object o=(object)i; //Boxing

o=123;
i=(int)o; //Unboxing.

Como qualquer outra coisa, a autoboxing pode ser problemática se não for usada com cuidado. O clássico é acabar com uma NullPointerException e não conseguir rastreá-la. Mesmo com um depurador. Tente o seguinte:

public class TestAutoboxNPE
{
    public static void main(String[] args)
    {
        Integer i = null;

        // .. do some other stuff and forget to initialise i

        i = addOne(i);           // Whoa! NPE!
    }

    public static int addOne(int i)
    {
        return i + 1;
    }
}