Przekazywanie parametrów w C#

Przekazywanie parametrów mimo wszechobecności w każdej nawet najprostrzej aplikacji jest często pomijanym elementem w czasie nauki języka. Jest to na tyle prosta i naturalna czynność, że nie każdy zastanawia się jak to na prawdę funkcjonuje. Często słyszy się powszechnie, że: typy wartościowe przekazywane są przez wartość a obiekty przez referencję. Większości tak informacja wystarcza i nie zastanawiają się  czy to w ogóle prawda i o co w tym tak na prawdę chodzi. Warto jednak przyjrzeć się temu tematowi choćby z tego powodu, że na rozmowach czy testach kwalifikacyjnych jest to powtarzający się element przy analizie kodu źródłowego. Zatem taka wiedza może okazać się niezbędna o ile zależy wam na dostaniu pracy o którą się ubiegamy.

W  języku C# możemy przekazywać zmienne na dwa sposoby poprzez wartość i referencję. Przez wartość przekazujemy parametry podając jedynie ich nazwę  jeżeli jednak chcemy aby funkcja miała możliwość dokonywania zmian na przekazywanych parametrach musimy przekazać je przez referencję wykorzystując do tego słowo kluczowe ref lub out. Różnica między tymi słówkami zostanie wyjaśniona w dalszej części.

Przekazywanie parametrów typu wartościowego

Typy wartościowe są najprostszymi dostępnymi typami, przechowują one dane bezpośrednio w przeciwieństwie do typów referencyjnych. Przekazywanie zmiennych typu wartościowego do metody jest równoznaczne z przekazaniem kopi tej zmiennej do metody. Oznacza to tyle, że w metodzie do której przekazaliśmy zmienne posługujemy się kopiami przekazanych zmiennych i zmiany dokonywane na nich nie mają wpływu na zmiany zmiennych które do metody przekazaliśmy.

[csharp]class PassingValByVal
{
static void SquareIt(int x)
{
x *= x;
Console.WriteLine("The value inside the method: {0}", x);
}
public static void Main()
{
int myInt = 5;
Console.WriteLine("The value before calling the method: {0}",
myInt);
SquareIt(myInt); // Passing myInt by value.
Console.WriteLine("The value after calling the method: {0}",
myInt);
}
} [/csharp]

Wynikiem powyższej aplikacji będzie:

The value before calling the method: 5
The value inside the method: 25
The value after calling the method: 5

Przekazując zmienną myInt do metody SquereIt kopiujemy jej zawartość do parametru x. Efektem czego wszystkie zmiany dokonywane są na kopi zmiennej myInt i nie mają żadnego wpływu na tą zmienną. Dlatego zmienna myInt przed jak i po wywołaniu metody SquareIt nie zmieniła swojej wartości.

Jeżeli chcemy dać możliwość metodzie bezpośredniego operowania na zmiennych przekazywanych do niej powinniśmy wykorzystać słowo kluczowe ref lub out.:

[csharp]class PassingValByRef
{
static void SquareIt(ref int x)
{
x *= x;
Console.WriteLine("The value inside the method: {0}", x);
}
public static void Main()
{
int myInt = 5;
Console.WriteLine("The value before calling the method: {0}",
myInt);
SquareIt(ref myInt); // Passing myInt by reference.
Console.WriteLine("The value after calling the method: {0}",
myInt);
}
}[/csharp]

Wynikiem powyższej aplikacji będzie:

The value before calling the method: 5
The value inside the method: 25
The value after calling the method: 25

Jak widzimy po wywołaniu metody SquareIt wartość zmiennej myInt uległa zmianie i uzyskaliśmy efekt o jaki nam chodziło podnieśliśmy do kwadratu zmienną którą przekazaliśmy do metody.

Przekazywanie parametrów typu referencyjnego

Typy referencyjne przechowują adres w pamięci określający gdzie obiekt się znajduje. Warto jednak pamiętać, że sama referencja zawierająca adres obiektu jest typem wartościowym którego wielkość zależy od platformy na jaką aplikacja została utworzona (system 32 lub 64 bitowy). Zatem przekazując zmienną typu referencyjnego przekazujemy ją również przez wartość z tą różnicą, że cały czas jest to wskaźnik na miejsce w pamięci dzięki czemu w metodzie możemy modyfikować obiekt na który przekazana referencja wskazuję. Jednak mimo możliwości zmian w obiekcie nie możemy dokonać zmian na samej referencji gdyż jest to jej kopia.

[csharp]class PassingRefByVal
{
static void Change(StringBuilder sb)
{
sb = new StringBuilder();
sb.AppendLine("Append inside method.");
}
public static void Main()
{
StringBuilder builder = null;
Change(builder);
builder.AppendLine("Append after calling method."); //Exception
Console.WriteLine(builder.ToString());
}
} [/csharp]

Powyższy kod po wykonaniu wyrzuci nam wyjątek NullReferenceException gdyż po wywołaniu metody Change zmienna builder nadal ma wartość null. Dzieje się tak ponieważ do metody przekazaliśmy kopię referencji wskazującej na obiekt klasy StringBuilder. Fakt operowania kopią referencji sprawił, że utworzony obiekt był przypisany do kopi referencji, a nie do zmiennej builder.

Aby móc dokonywać zmian nie tylko na obiekcie ale również na jego referencji musimy dodać słowo kluczowe ref lub out.

[csharp]class PassingRefByRef
{
static void Change(ref StringBuilder sb)
{
sb = new StringBuilder();
sb.AppendLine("Append inside method.");
}
public static void Main()
{
StringBuilder builder = null;
Change(ref builder);
builder.AppendLine("Append after calling method.");
Console.WriteLine(builder.ToString());
}
} [/csharp]

Wynikiem powyższego kodu będzie:

Append inside method.
Append after calling method.

Dzięki użyciu słówka ref mogliśmy utworzyć obiekt wewnątrz metody i dokonać na nim zmian.

Więcej o ref i out

W prezentowanych przykładach używaliśmy jedynie słówka ref przy przekazywaniu parametrów przez referencją. Jak wspominałem wcześniej istnieje również możliwość użycia słowa kluczowego out które również umożliwia przekazanie parametru przez referencję. Jednak jest pewna różnica w zastosowaniu tych słów kluczowych. Różnica ta polega na tym, że w metodzie w której przekazujemy parametry ze out musimy zainicjować zmienną którą przekazujemy z tym słowem kluczowym. Ze słówkiem ref sytuacja jest taka, że przed przekazaniem zmiennej do funkcji musimy zmienną najpierw zainicjować.

Musimy również pamiętać, że do metod używających słów kluczowych ref lub out, czyli przekazując zmienne przez referencję nie możemy przekazać właściwości klasy jak również indekserów w niej zdefiniowanych.

Opisywane słowa kluczowe umożliwiają nam również przeciążanie metod dzięki czemu taki zapis jest poprawny:

[csharp]class MyClass
{
public void MyMethod(int i) {i = 10;}
public void MyMethod(out int i) {i = 10;}
}[/csharp]

Słowa kluczowe ref i out możemy użyć zamiennie jednak nie możemy ich użyć razem, dlatego poniższy kod jest niepoprawny:

[csharp]class MyClass
{
public void MyMethod(out int i) {i = 10;}
public void MyMethod(ref int i) {i = 10;}
}[/csharp]

Podsumowanie

Wracając do stwierdzenia przedstawionego na początku tego postu:  typy wartościowe przekazywane są przez wartość a obiekty przez referencję nie trudno stwierdzić że jest to przesadne uogólnienie które nie jest prawdą. Typy wartościowe jak i typy referencyjne przekazujemy przez wartość mimo faktu że dzięki referencji możemy modyfikować obiekty na które ona wskazuje. Aby przekazać zmienne przez referencję musimy dodatkowo użyć jednego ze słów kluczowych ref i out które też mają swoją specyfikę i podlegają pewnym ograniczeniom o czym należy pamiętać. Kończąc chciałbym życzyć wszystkim udanych rozmów kwalifikacyjnych.

Wpis powstał na podstawie: Passing ParametersPassing Arrays Using ref and out

Value Types C#

Zmienne typu wartościowego (ValueType) są najprostszymi strukturami danych dostępnymi w frameworku .NET. W odróżnieniu od typów referencyjnych ich wartość jest przechowywana na stosie co znacznie ułatwia i przyspiesza dostęp do danych. W przypadku typów referencyjnych na stosie jest przechowywana jedynie referencja na  obiekt znajdujący się na stercie (heap).

Z uwagi na to, że w sieci jest dużo informacji na ten temat przedstawię tylko ciekawostki warte zapamiętania.

Typy wartościowe możemy podzielić na trzy główne kategorie:

  • Typy wbudowane
  • Typy wyliczeniowe (Enumeration)
  • Typy tworzone przez użytkownika (Struktury)

Wszystkie typy wartościowe są pochodnymi klasy System.ValueType. Główną cechą zmiennych tego typu jest fakt, że po przypisaniu jednej zmiennej do innej dostajemy kopię danego obiektu. Zatem po takiej operacji dostajemy dwie niezależne zmienne. Podobna sytuacja ma miejsce podczas przekazywania takich zmiennych jako parametry w funkcjach.

Domyślna implementacja metody ValueType.Equals do porównywania wartości wykorzystuje system refleksji. Nadpisanie tej metody w określonych typach może znacznie zwiększyć wydajność ich porównywania.

Typy wbudowane

Pierwszą ważną kwestią jest inicjalizacji  zmiennych lokalnych, gdyż brak inicjalizacji powoduje błąd podczas kompilacji. Typy wartościowe będące polami klas nie muszą być inicjalizowany. Przy tworzeniu obiektu danej klasy mają przypisaną domyślną wartość dla danego typu.

Nazwy typów int, long, double itd są tylko aliasami na typy, odpowiednio System.Int32, System.Int64, System.Double. Wszystkie aliasy możemy zobaczyć tutaj.

Każdy typ wartościowy posiada domyślny konstruktor który możemy wywołać:

[csharp]int i = new int();
double d = new double();[/csharp]

Po wywołaniu konstruktora zostanie utworzony obiekt z domyślną wartością.

Enum

Kolejnym typem wartościowym jest typ wyliczeniowy. Domyślnym typem dla typu enumeracyjnego jest int, aby wskazać inny typ podajemy go po nazwie, do dyspozycji mamy wszystkie typy całkowite za wyjątkiem typu char

[csharp]enum Days : long { Mon=1, Tue, Wed, Thu, Fri, Sat, Sun };[/csharp]

Elementy typu wyliczeniowego możemy rzutować na typ w jakim wartości są przechowywane (w tym przypadku long) jak i możliwa jest konwersja w drugą stronę.

[csharp] long mon = (long) Days.Mon;
Days d = (Days) mon;[/csharp]

Domyślną wartością każdego typu enumeracyjnego jest 0, zatem warto o tym pamiętać przypisując wartości do poszczególnych jej elementów.

[csharp]Days days = new Days(); //Domyślny konstruktor

Days days = 0; //nie wymaga rzutowania

Days days = (Days)1; //rzutowanie wymagane

[/csharp]

Słowem kluczowym new możemy zastąpić dany typ enumeracyjny zagnieżdżony w klasie na nowy.

Flags

Aby móc typem enumeracyjnym posługiwać się jako flagami musimy dodać do niego atrybut [Flags]. Warto pamiętać aby do konkretnych elementów typu wyliczeniowego przypisać wartości będące kolejnymi potęgami 2, w przeciwnym wypadku typ może zachowywać się nie tak jak byśmy tego oczekiwali.

[csharp][Flags]
enum Colors : short
{
Black = 0,
Red = 1,
Green = 2,
Blue = 4,
All = Black | Red | Green | Blue
}
[/csharp]

Struct

Struktury są typem definiowanym przez użytkownika. Struktury posiadają kilka podstawowych cech o których warto pamiętać:

  • rozmiar struktury musi być nie większy niż 16 B (bajtów)
  • struktura nie może posiadać bezparametrowego konstruktora
  • w strukturach nie ma dziedziczenia tak jak w klasach jednakże struktura jest pochodną klasy System.Object
  • sturuktua nie może być bazą dla klasy jak również struktura nie może dziedziczyć po innej strukturze lub klasie
  • mimo braku dziedziczenia struktury mogą implementować interfejsy.

Dzięki atrybutom możemy określić niestandardowe rozłożenie struktury w pamięci (coś na wzór union w C/C++)

[csharp]
[StructLayout(LayoutKind.Explicit)]
struct TestExplicit
{
[FieldOffset(0)]
public long lg;
[FieldOffset(0)]
public int i1;
[FieldOffset(4)]
public int i2;
} [/csharp]

W powyższym przypadku pole lg wskazuje na ten sam obszar pamięci co pola i1 i i2. Zatem zmiana pola lg zmienia wartości pól i1 i i2, jak również zmiana pól i1 i/lub i2 zmienia wartość pole lg.

Nullable

Domyślnie do typu wartościowego nie można przypisać wartości null. Jednak platforma .NET dostarcza nam typ generyczyn umożliwiający takie przypisanie, mowa tu o strukturze Nullable<T>.

[csharp]
Nullable<int> nint = null;
int? a = null; // skrócony zapis
[/csharp]

Boxing/Unboxing

Boxing i unboxing to mechanizmy o których istnieniu warto wiedzieć. Prostym przykładem boxing’u jest poniższy kod:

[csharp]Point p = new Point();
object obj = (object)p;
p.X = 5;
Console.WriteLine(p);
Console.WriteLine(obj);
[/csharp]

Po wykonaniu tego kodu na ekranie ujrzymy:

{X=5,Y=0}
{X=0,Y=0}

Jak widzimy po przypisaniu struktury typu Point do zmiennej typu object uzyskaliśmy dwa różne obiekty, a to za sprawą faktu, że przy przypisaniu struktury do zmiennej typu referencyjnego obiekt został skopiowany do sterty i uzyskaliśmy dwie kopie tego samego obiektu jedna na stosie, a drugą na stercie. W wyniku czego zmiana pierwszego nie wpływa na drugi obiekt.

Więcej informacji jak również przykładowe ilustracje przybliżające działanie mechanizmu boxingu można znaleźć w The C# Value Type and Boxing .

Wpis powstał na podstawie: Value Types, Structs Tutorial, Enumeration Types, Boxing and Unboxing, Nullable Types.