Кратко съдържание

Референтните типове и производителността

Ако изчислим средното време, необходимо за заделяне и освобождаване на динамична памет, се оказва, че заделянето и освобождаване на стой­ностните типове е значително по-бързо от референтните типове. Когато производителността е важна за нашата система, трябва да се съобразя­ваме с особеностите на стойностните и референтните типове и начина, по който те заделят и освобождават памет.

Глобално погледнато, нещата около управлението на динамичната памет в .NET Framework са доста комплексни, но в тази тема няма да се спираме на тях. По-нататък, в темата за управление на паметта и ресурсите, ще им обърнем специално внимание.

Стойностни срещу референтни типове

Следват някои по-съществени разлики между тях:

• 
  Стойностните типове наследяват системния тип System.ValueType, а референтните наследяват директно System.Object.
  
• 
  При създаване на променлива от стойностен тип тя се заделя в стека, а при референтните типове – в динамичната памет.
  
• 
  При присвояване на стойностни типове се копира самата им стой­ност, а при референтни типове – само референцията (указа­теля).
  
• 
  При предаване на променлива от стойностен тип като параметър на метод, се предава копие на стойността й, а при референтните типове се предава копие на референцията, т.е. самата стойност не се ко­пира. В резултат, ако даден метод променя стойностен входен пара­метър, промените се губят при излизане от метода, а ако входният параметър е референтен, те се запазват.
  
• 
  Стойностните типове не могат да приемат стойност null, защото не са указатели, докато референтните могат.
  
• 
  Стойностните типове се унищожават при излизане от обхват, докато референтните се унищожават от системата за почистване на паметта (garbage collector) в някой момент, в който се установи, че вече не са необходими за работата на програмата.
  
• 
  Променливи от стойностен тип могат да се съхраняват в променливи от референтен тип чрез т.нар. "опаковане" (boxing), което ще раз­гледаме след малко.
  

Стойностни и референтни типове – пример

В настоящия пример се демонстрира използването на стойностни и рефе­рентни типове и се илюстрира разликата между тях:

using System; // SomeClass is reference type class SomeClass { public int mValue; } // SomeStruct is value type struct SomeStruct { public int mValue; } class TestValueAndReferenceTypes { static void Main() { SomeClass class1 = new SomeClass(); class1.mValue = 100; SomeClass class2 = class1; // Копира се референцията class2.mValue = 200; // Променя се и class1.mValue Console.WriteLine(class1.mValue); // Отпечатва се 200 SomeStruct struct1 = new SomeStruct(); struct1.mValue = 100; SomeStruct struct2 = struct1; // Копира се стойността struct2.mValue = 200; // Променя се копираната стойност Console.WriteLine(struct1.mValue); // Отпечатва се 100 } }

След като се изпълни примерът, се получава следния резултат:

Как работи примерът?

В началото на примера се създава инстанция на класа SomeClass, в нея се записва числото 100 и след това тя се присвоява на две променливи. Аналогично се създава инстанция на структурата SomeStruct, в нея също се записва 100 и след това тя се присвоява на две променливи.

При присвояването на инстанциите на класа, понеже той е референтен тип, се присвоява само референцията и стойността реално не се копира, а остава обща. При присвояването на инстан­цията на структурата, понеже тя е стойностен тип, се присвоява самата стойност (нейно копие). Поради тази причина в резултат от изпълнението на програмата на конзолата се отпечатват различни стойности.

По-долу са показани схематично стекът за изпълнение на програмата и динамичната памет в момента преди приключване на програмата. Данните са взети от дебъгера на Visual Studio .NET поради което са много близки до истинското разположение на паметта по време на изпълнение на примерната програма:

Стекът расте отгоре надолу (от големите адреси към адрес 0), защото про­грамата е изпълнена върху Intel-съвместима архитектура, при която това поведение е нормално.

Проследяване на примера с VS.NET

За да проследим как се изпълнява горният пример стъпка по стъпка, можем да използваме проекта Demo-1-Value-And-Reference-Types от де­монстра­циите:

1. 
   Отваряме с VS.NET проекта Demo-1-Value-And-Reference-Types.sln.
   
2. 
   Слагаме точка на прекъсване на последния ред от Main() метода на основния клас.
   
3. 
   Стартираме приложението с [F5].
   
4. 
   След като дебъгерът спре в точката на прекъсване, показваме Disassembly и Registers прозорците. От менюто на VS.NET избираме Debug | Windows | Disassembly и Debug | Windows | Registers. Ето как изглежда VS.NET в този момент:
   

5. 
   Можем да разгледаме асемблерния код, получен след компилиране на програмата и след превръщането на MSIL кода в чист Win32 код за процесор Intel x86.
   

Повечето компилатори за Intel-базирани процесори генерират код, който използва в тялото на методите регистър EBP като указател към върха на стека. Адресиране от типа на dword ptr [ebp-14h] най-често реферира стойност в стека – локална променлива или параметър.

Спомнете си за разликите между класове и структури (референтни и стойностни типове). Стойностните типове съхраняват стойността си директно в стека. Референтните типове съхраняват в стека само 4-байтов адрес, който указва мястото на променливата в динамичната памет.

Често пъти, с цел оптимизация на производителността, компилато­рът вместо някаква област от стека използва регистри за съхране­ние на локални променливи. В случая в EBX се съхранява референ­цията class2, а в EDI – референцията class1.

6. 
   Да разгледаме асемблерния код, генериран за операцията присвоя­ване class2=class1. В него се присвоява на регистър EBX стойност­та на регистър EDI, т.е. на референцията class2 се присвоява референ­цията class1. Обърнете внимание, че се копира референ­цията, а не самата стойност.
   
7. 
   Да разгледаме асемблерния код, генериран за операцията присвоя­ване struct2=struct1. В него се присвоява на регистър EAX стой­ността от стека, съответстваща на struct1 и след това стой­ността от EAX се записва обратно в стека, в променливата struct2. На практика се копира самата стойност на структурата, като се изпол­зва за работна променлива регистърът EAX.
   

Каталог: dotnetbook
dotnetbook -> Кратко съдържание
dotnetbook -> Кратко съдържание

Изтегляне 9.03 Mb.

Сподели с приятели: