Null, Nothing, Empty

Excel'de bu kavramlardan sadece Blank(Boş) ve ZLS mevcuttur. Boş değerler ISBLANK(A2) ile, ZLS'ler ise IF(A2="";TRUE;FALSE) veya IF(LEN(A2)=0;TRUE;FALSE) formülüyle sorgulanabilir. Örnek bir gösterim ve sorgulama şekli aşağıdaki gibidir. Görüldüğü gibi sadece hiçbirşey girilmeyen yani boş olan hücre için ISBLANK formülü TRUE döndürmüştür, ancak ZLS sorgusu hem boş hücre için hem de ="" değeri için TRUE dönmüştür.

Empty

Konu programlamaya geldiğinde karşımıza null ve Nothing kavramları da çıkar. VBA'da değer atanmamış tüm değişkenlere otomatik olarak default değerler atanır. Bu, numerik değişkenler için 0, Stringler (metinler) için ZLS, Object(nesne) tipli değişkenler için Nothing ve Variant değişkenler içinse Empty'dir.

Empty, başlangıç değeri atanmamış demektir. Null ise geçerli bir data içermeyen değişken demektir. Empty, Variant alttipi olarak karşımıza çıkar. İstenirse bir değişkene başlangıç anında da Empty değeri verilebilir.

VBA'de yerel değişken(metodların elemanları) ve field(class seviyesindeki global eleman) ayrımı olmadığı için makro çalıştığında tüm değişkenler default değerlerine otomatik atanır. (Vb.Net ve C# gibi dillerde ise yerel değişkenlere mutlaka değer atanması lazım, fieldlar ise otomatik default değerlerine atanır.)

Başlangıç değeri atanmamış veya bilinçli şekilde Empty değeri atanmış bir değişkeni yakalamak için IsEmpty() fonksiyonunu kullanırız. Bununla birlikte bir değişkenin Empty olması çok karşılaşılan bir durum olmayacak, daha çok bir hücre değerinin içinin boş olup olmadığını sorgulayacağız. Aslında bir hücrenin içinin boş olup olmadığını sorgularken Range objesinin default değeri olan Value'yu sorgulamış oluyoruz. Yani If IsEmpty(Range("A1") ile If IsEmpty(Range("A1").Value) aynı şeydir, ve Value da Variant değer döndürdüğü için IsEmpty ile sorguladığımızda gerçekten boşsa True döndürür. Bu sorgulamayı Len metodu ile de yapabiliriz.

If Len(degisken)=0 Then 
'veya excel hücresi için
If Len(Range("A1"))=0 Then

ZLS tıpkı Excelde olduğu gibi "" şeklinde ifade edilir. Bu bir stringtir ve sıfır uzunluktadır. Çoğu durumda vbNullString ile ZLS, VBA tarafından aynı şekilde yorumlanır. vbNullString tam bir string olmamakla birlikte birçok durumda ZLS yerine kullanılabilir ve hatta kullanılmalıdır da çünkü ZLS'ye göre performans açısından daha verimlidir, özellikle büyük bir döngü içinde sürekli bir "" ataması olacaksa. Çünkü ZLS, bellekte 6 byte yer kaplarken vbnullstring ise ilave yer kaplamaz, zira vbnullstring bir constant olup zaten VBA tarafından baştan yaratılmıştır ve yeniden yaratımına gerek yoktur.

Bu arada Excelde olduğunun aksine VBA'de Blank diye bir kavram dolayıysla IsBlank diye bir sorgulama şekli de yoktur.

Son olarak, bir şekilde başlangıç değeri olmayan Variant tipli bir değişkene IsNumeric sorgulaması yapıldığında True değeri döndürür.

Null

Bir değişken veri içermiyorsa bu değişken Null değere sahiptir diyebiliriz. Bir değişkenin değerinin Null olabilmesi için ya bilinçli bir şekilde Null ataması ya da Null içeren başka birşeyle etkileşime girmesi gerekir. Empty gibi Null da sadece Variant tipinin bir özelliğidir, yani saece Variant tipteki bir değişlen Null değer alabilir. Başka tipteki bir değişkene Null atanmak istendiğinde hata alınır. Ancak Stringlere vbNullString ile null atama yapılabilir. Bir değişkenin içeriğinin Null olma olasılığı varsa ve bunu başka bir değişeknele işleme sokacaksanız, işleme sokmadan önce o anda Null içerip içermediğini IsNull() ile kontrol etmeniz gerekir, aksi halde yine hatayla karşılaşırsınız.

Nothing

Ve son olarak bir de Nothing var. Tanımlanmış ancak henüz yaratılmamış objelerin değeri Nothingdir. Bir objeye bu değer atandığında ise, objenin kendisiyle obje değişkeni arasındaki bağı koparmış oluruz.

Nothing sadece object tipindeki değişkenlere atanan bir özelliktir ve Set ifadesi ile kullanılır. Bir nesnenin Nothing olup olmadığını anlamak için "Is Nothing"(iki kelme ayrı) sorgulaması yapılır. Burada "is" kullanımı önemlidir, eşitlik ("=") yerine "olmak" ile sorguluyoruz.

If Degisken Is Nothing Then

Şimdi de VBA'de tüm bunlar nasıl kullanılıyor, sonuçları ne oluyor, ona bi bakalım.

Sub null_empty_nothing_zls()
'Vartype, TypeName
'0:empty, 1:null, 2:int, 3:long,....7:Date, 8:string, 9:object, 11:boolena, 12:Variant (sadece variant arraylerde), 8192:Array(normal değer + 8192)
'Vartype'ı sorgularken rakamları bilmen gerekmez, vbConst ifadelerini de kullanabilrsin, aşağıdaki örnekte ='den sonra intellisense ile seçebilirsinizDebug.Print "henüz tanımlanmamış bir p değişkeni için VarType(p) = vbNull mı sonucu:" & IIf(VarType(p) = vbNull, True, False) 'intellisense de çalışır ve sana seçtirir
Debug.Print vbNewLine

'Default değerler
'bi makro çalışıtğında tüm değişkenler ilk olarak default değerlere atanır
'numerikse:0 stringse:""(ZLS) objectse:Nothing variantsa:Empty

Dim v 'variant olduğu için empty başlar
Dim v2 'az sonra değer atıycam
Dim i As Integer 'int olduğu için 0 başlar
Dim s As String 'string olduğu için zls bşlar, empty değil
Dim r As Range 'object olduğu için başlangıcı nothing
Dim z As String 'zls olacak, s ile aynı sonuçları verir
Dim n 'variant olduğu için empty başlar
Dim n2 'variant olduğu için empty başlar
Dim u 'null string
Dim o As Object 'obje olduğu için nothing başlar
Dim d(10) As String ' dizi olduğu için defaultdeğerlerle başlar
Dim vd() As Variant

'atamalar
v2 = Array("armut", "elma", "kiraz") 'dizi
z = ""
n = Null 'artık empty değil null
u = vbNullString
n2 = n * 10 'null ile etkileşime girdiği için null


'TM=Type Mismatch hatası almasınlar diye bu ifadenin kısaltaması olan TM yazdım
Debug.Print "Variable açıklaması" & vbTab & "Değer" & vbTab & "VarType" & vbTab & "TypeName" & vbTab & "IsEmpty" & vbTab & vbTab & "IsNull" & vbTab & "ZLS mi" & vbTab & "0 mı" & vbTab & "vbNullStrmi" & vbTab & "LenB" & vbTab & "Nothing mi"
Debug.Print "---------------------------------------------------------------------------------------------------------------------------"
Debug.Print "v:Variant data yok" & vbTab & "| " & v & vbTab & vbTab & "| " & VarType(v) & vbTab & vbTab & TypeName(v) & vbTab & vbTab & IsEmpty(v) & vbTab & vbTab & IsNull(v) & vbTab & IIf(v = "", True, False) & vbTab & IIf(v = 0, True, False) & vbTab & IIf(v = vbNullString, True, False) & vbTab & vbTab & LenB(v) & vbTab & vbTab & "N/A"
Debug.Print "v2:Variant dizi " & vbTab & "| " & "N/A" & vbTab & "| " & VarType(v2) & vbTab & TypeName(v2) & vbTab & IsEmpty(v2) & vbTab & vbTab & IsNull(v2) & vbTab & "N/A" & vbTab & vbTab & "N/A" & vbTab & vbTab & "N/A" & vbTab & vbTab & vbTab & "*TM*" & vbTab & "N/A"
Debug.Print "v2(0):V Dizi Eleman" & vbTab & "| " & v2(0) & vbTab & "| " & VarType(v2(0)) & vbTab & vbTab & TypeName(v2(0)) & vbTab & vbTab & IsEmpty(v2(0)) & vbTab & vbTab & IsNull(v2(0)) & vbTab & IIf(v2(0) = "", True, False) & vbTab & "*TM*" & vbTab & IIf(v2(0) = vbNullString, True, False) & vbTab & vbTab & LenB(v2(0)) & vbTab & vbTab & "N/A"
Debug.Print "i:Integer data yok" & vbTab & "| " & i & vbTab & vbTab & "| " & VarType(i) & vbTab & vbTab & TypeName(i) & vbTab & vbTab & IsEmpty(i) & vbTab & vbTab & IsNull(i) & vbTab & "*TM*" & vbTab & IIf(i = 0, True, False) & vbTab & "*TM*" & vbTab & vbTab & LenB(i) & vbTab & vbTab & "*TM*"
Debug.Print "s:String data yok" & vbTab & "| " & s & vbTab & vbTab & "| " & VarType(s) & vbTab & vbTab & TypeName(s) & vbTab & vbTab & IsEmpty(s) & vbTab & vbTab & IsNull(s) & vbTab & IIf(s = "", True, False) & vbTab & "*TM*" & vbTab & IIf(s = vbNullString, True, False) & vbTab & vbTab & LenB(s) & vbTab & vbTab & "*TM*"
Debug.Print "z:ZLS çift tırnak" & vbTab & "| " & z & vbTab & vbTab & "| " & VarType(z) & vbTab & vbTab & TypeName(z) & vbTab & vbTab & IsEmpty(z) & vbTab & vbTab & IsNull(z) & vbTab & IIf(z = "", True, False) & vbTab & "*TM*" & vbTab & IIf(z = vbNullString, True, False) & vbTab & vbTab & LenB(z) & vbTab & vbTab & "*TM*"
Debug.Print "n:Null atanmış " & vbTab & vbTab & "| " & n & vbTab & vbTab & "| " & VarType(n) & vbTab & vbTab & TypeName(n) & vbTab & vbTab & IsEmpty(n) & vbTab & vbTab & IsNull(n) & vbTab & IIf(n = "", True, False) & vbTab & IIf(n = 0, True, False) & vbTab & IIf(n = vbNullString, True, False) & vbTab & vbTab & LenB(n) & vbTab & vbTab & "N/A"
Debug.Print "n2:Null'la işlem " & vbTab & "| " & n & vbTab & vbTab & "| " & VarType(n2) & vbTab & vbTab & TypeName(n2) & vbTab & vbTab & IsEmpty(n2) & vbTab & vbTab & IsNull(n2) & vbTab & IIf(n2 = "", True, False) & vbTab & IIf(n2 = 0, True, False) & vbTab & IIf(n2 = vbNullString, True, False) & vbTab & vbTab & LenB(n2) & vbTab & vbTab & "N/A"
Debug.Print "u:vbNullString " & vbTab & vbTab & "| " & u & vbTab & vbTab & "| " & VarType(u) & vbTab & vbTab & TypeName(u) & vbTab & vbTab & IsEmpty(u) & vbTab & vbTab & IsNull(u) & vbTab & IIf(u = "", True, False) & vbTab & IIf(u = 0, True, False) & vbTab & IIf(u = vbNullString, True, False) & vbTab & vbTab & LenB(u) & vbTab & vbTab & "N/A"
Debug.Print "r:Range set'siz " & vbTab & "| " & "N/A" & vbTab & "| " & VarType(r) & vbTab & vbTab & TypeName(r) & vbTab & vbTab & "N/A " & vbTab & vbTab & IsNull(r) & vbTab & "N/A" & vbTab & vbTab & "N/A" & vbTab & vbTab & "N/A" & vbTab & vbTab & vbTab & "*TM*" & vbTab & IIf(r Is Nothing, True, False)
Debug.Print "o:Obje nesne yok " & vbTab & "| " & "N/A" & vbTab & "| " & VarType(o) & vbTab & vbTab & TypeName(o) & vbTab & vbTab & "N/A " & vbTab & vbTab & IsNull(o) & vbTab & "N/A" & vbTab & vbTab & "N/A" & vbTab & vbTab & "N/A" & vbTab & vbTab & vbTab & "*TM*" & vbTab & IIf(o Is Nothing, True, False)
Debug.Print "d:Dizi elemansız " & vbTab & "| " & "N/A" & vbTab & "| " & VarType(d) & vbTab & TypeName(d) & vbTab & IsEmpty(d) & vbTab & vbTab & IsNull(d) & vbTab & "N/A" & vbTab & vbTab & "N/A" & vbTab & vbTab & "N/A" & vbTab & vbTab & vbTab & "*TM*" & vbTab & "*TM*"
Debug.Print "d(0):Dizi Eleman" & vbTab & "| " & d(0) & vbTab & vbTab & "| " & VarType(d(0)) & vbTab & vbTab & TypeName(d(0)) & vbTab & vbTab & IsEmpty(d(0)) & vbTab & vbTab & IsNull(d(0)) & vbTab & IIf(d(0) = "", True, False) & vbTab & "*TM*" & vbTab & IIf(d(0) = vbNullString, True, False) & vbTab & vbTab & LenB(d(0)) & vbTab & vbTab & "N/A"
Debug.Print "vd:Variant dizi " & vbTab & "| " & "N/A" & vbTab & "| " & VarType(vd) & vbTab & TypeName(vd) & vbTab & IsEmpty(vd) & vbTab & vbTab & IsNull(vd) & vbTab & "N/A" & vbTab & vbTab & "N/A" & vbTab & vbTab & "N/A" & vbTab & vbTab & vbTab & "*TM*" & vbTab & "N/A"


Debug.Print vbNewLine
Debug.Print "Yeniden atamalar yapıyoruz"

'Empty değer ataması
v = Empty 'hala emtpydir
Debug.Print "v:Empty Atanıyor " & vbTab & "| " & v & vbTab & vbTab & "| " & VarType(v) & vbTab & vbTab & TypeName(v) & vbTab & vbTab & IsEmpty(v) & vbTab & vbTab & IsNull(v) & vbTab & IIf(v = "", True, False) & vbTab & IIf(v = 0, True, False) & vbTab & IIf(v = vbNullString, True, False) & vbTab & vbTab & LenB(v) & vbTab & vbTab & "N/A "

i = Empty 'yine de 0'dır, çünkü empty sadece variantın bir tipi
i = 456
Debug.Print "i:Değerli Integer" & vbTab & "| " & i & vbTab & "| " & VarType(i) & vbTab & vbTab & TypeName(i) & vbTab & vbTab & IsEmpty(i) & vbTab & vbTab & IsNull(i) & vbTab & "N/A" & vbTab & vbTab & IIf(i = 0, True, False) & vbTab & "N/A" & vbTab & vbTab & vbTab & LenB(i) & vbTab & vbTab & "*TM*"

v = 23
Debug.Print "v:Integer variant" & vbTab & "| " & v & vbTab & "| " & VarType(v) & vbTab & vbTab & TypeName(v) & vbTab & vbTab & IsEmpty(v) & vbTab & vbTab & IsNull(v) & vbTab & IIf(v = "", True, False) & vbTab & IIf(v = 0, True, False) & vbTab & IIf(v = vbNullString, True, False) & vbTab & vbTab & LenB(v) & vbTab & vbTab & "N/A "
v = "acb"
Debug.Print "v:String variant" & vbTab & "| " & v & vbTab & "| " & VarType(v) & vbTab & vbTab & TypeName(v) & vbTab & vbTab & IsEmpty(v) & vbTab & vbTab & IsNull(v) & vbTab & IIf(v = "", True, False) & vbTab & IIf(v = 0, True, False) & vbTab & IIf(v = vbNullString, True, False) & vbTab & vbTab & LenB(v) & vbTab & vbTab & "N/A "

Set r = Range("a1")
Debug.Print "r:Range set'li " & vbTab & vbTab & "| " & "" & vbTab & vbTab & "| " & VarType(r) & vbTab & vbTab & TypeName(r) & vbTab & vbTab & "N/A " & vbTab & vbTab & IsNull(r) & vbTab & IIf(r = "", True, False) & vbTab & IIf(r = 0, True, False) & vbTab & "N/A" & vbTab & vbTab & vbTab & "N/A" & vbTab & vbTab & IIf(r Is Nothing, True, False) 'obj olduğu için değer yazdırılamaz

Set o = CreateObject("Outlook.Application")
Debug.Print "o:Obje(outlook) " & vbTab & "| " & "" & vbTab & vbTab & "| " & VarType(o) & vbTab & vbTab & TypeName(o) & " N/A " & vbTab & vbTab & IsNull(o) & vbTab & "N/A" & vbTab & vbTab & "N/A" & vbTab & vbTab & "N/A" & vbTab & vbTab & vbTab & "N/A" & vbTab & vbTab & IIf(o Is Nothing, True, False) 'obj olduğu için değer yazdırılamaz


'Çıktısı aşağıdaki gibidir
'henüz tanımlanmamış bir p değişkeni için VarType(p) = vbNull mı sonucu:False


'Variable açıklaması Değer VarType TypeName IsEmpty IsNull ZLS mi 0 mı vbNullStrmi LenB Nothing mi
'---------------------------------------------------------------------------------------------------------------------------
'v:Variant data yok | | 0 Empty True False True True True 0 N/A
'v2:Variant dizi | N/A | 8204 Variant() False False N/A N/A N/A *TM* N/A
'v2(0):V Dizi Eleman | armut | 8 String False False False *TM* False 10 N/A
'i:Integer data yok | 0 | 2 Integer False False *TM* True *TM* 2 *TM*
's:String data yok | | 8 String False False True *TM* True 0 *TM*
'z:ZLS çift tırnak | | 8 String False False True *TM* True 0 *TM*
'n:Null atanmış | | 1 Null False True False False False N/A
'n2:Null'la işlem | | 1 Null False True False False False N/A
'u:vbNullString | | 8 String False False True False True 0 N/A
'r:Range set'siz | N/A | 9 Nothing N/A False N/A N/A N/A *TM* True
'o:Obje nesne yok | N/A | 9 Nothing N/A False N/A N/A N/A *TM* True
'd:Dizi elemansız | N/A | 8200 String() False False N/A N/A N/A *TM* *TM*
'd(0):Dizi Eleman | | 8 String False False True *TM* True 0 N/A
'vd:Variant dizi | N/A | 8204 Variant() False False N/A N/A N/A *TM* N/A


'Yeniden atamalar yapıyoruz
'v:Empty Atanıyor | | 0 Empty True False True True True 0 N/A
'i:Değerli Integer | 456 | 2 Integer False False N/A False N/A 2 *TM*
'v:Integer variant | 23 | 2 Integer False False False False False 4 N/A
'v:String variant | acb | 8 String False False False False False 6 N/A
'r:Range set'li | | 0 Range N/A False True True N/A N/A False
'o:Obje(outlook) | | 8 Application N/A False N/A N/A N/A N/A False
End Sub

VB.Net, .Net çatısı altındaki dillerden biri olup, sadece VBA'den değil onun atası olan VB6'dan da bazı noktalarda ayrılmaktadır. Mesela VBA'de tüm değişkenler local değişken iken VB.Net'de local değişken ve global değişken(field) ayrımı vardır. VBA'de tüm değişkenler makro çalışır çalışmaz default değerlerine atanırken, VB.Net'te sadece global değişkenler default değerlerine atanır, local değişkenlerin ise mutlaka bir ilk değerinin olması beklenir, aksi halde hata alınır.

Null/Nothing

Bir diğer fark da şudur: Vb.Net'te değişkenler değer tipli ve referans tipli olmak üzere ikiye ayrılır. Mesela stringler referans tiplidir ve tüm diğer referans tipler gibi null değer alabilir, (VBA'da sadece variant tipi değişkenler null değer alabiliyordu). Bu arada konuşurken null değerden bahsediyoruz ancak Vb.Net'te bir değişkenin null değer alması Nothing keywordu ile sağlanır, null keywordu ile değil.

Dim str As String = Nothing

Değişkenin null mı olduğu IsNothing(degisken) metodu ile veya referans tiplerde if degisken is Nothing, nullable olmayan değer tipli değişkenler if degisken = Nothing şeklinde gibi sorgulanabilir. Burada detayına girmeyeceğim ancak IsNothing metodunun birçok yerde kullanılmaması öğütleniyor, ben de bu öğüte uyuyorum, aşağıdaki karşılaştırma tablosuna dahi almıyorum. Bunun yerine ikinci yöntemi kullanacağız.

'değer tipli sorgulama şekli. Her ne kadar stringler referans tipli de olsa daha önceden belirtitğim gibi değer tipli sorgulamsı yapılır.
Dim str As String = Nothing
If str = Nothing Then 
   MsgBox("String Null'dır")
End If

'referans tipli sorgulama
Dim obj As Object = Nothing
If obj is Nothing Then 
   MsgBox("Nesnemiz Null'dır")
End If

'IsNothing ile her iki tür (değer veya referans)de sorgulanabilr
If IsNothing(s) Then
    Console.WriteLine(True)
End If

Nullable olmayan değer tipli değişkenler için Nothing'in özel bir anlamı vardır; böyle bir değişkene Nothing değeri atadığımızda ona default değerini atamış oluruz. (Bu, obje elemanlardan oluşan bir dizi veya dizimsi yapılardaki tüm elemanları bir döngü içinde default değere döndürmek için kullanışlı bir yöntemdir, onun dışında bir değişkene default değeri atamak için Nothing yerine kendi default değeri neyse onu atamak daha mantıklı bir yol olacaktır.) C#'ta ise nullable olmayan bir değişkene null değer atamak hata verecektir.

Aşağıda MSDN sitesinden alınan ve bu durumu açıklayan bir kod bloğu bulunmaktadır.

Module Module1

    Sub Main()
        Dim ts As TestStruct 'değer tipli bir değişken, çünkü bir structure
        Dim i As Integer 'nullable olmayan değer tipli bir integer
        Dim b As Boolean 'nullable olmayan değer tipli bir boolean

        ' Aşağıdaki ifade ts.Name'in değerini Nothing'e ve ts.Number'ı da 0'a çevirir.
        ts = Nothing

        ' Aşağıdaki ifade i'yi 0 ve b'yi False yapar.
        i = Nothing
        b = Nothing

        Console.WriteLine("ts.Name: " & ts.Name)
        Console.WriteLine("ts.Number: " & ts.Number)
        Console.WriteLine("i: " & i)
        Console.WriteLine("b: " & b)

        Console.ReadKey()
    End Sub

    Public Structure TestStruct
        Public Name As String
        Public Number As Integer
    End Structure
End Module

Bir değişken referans tipliyse ona Nothing değerini atamak onun hiçbir nesneyle bağının kalmaması demektir. Aşağıdaki örnek bunu gösterir.

Module Module1

    Sub Main()

        Dim testObject As Object
        ' Aşağıdaki ifade testObject'i null yapar
        testObject = Nothing

        Dim tc As New TestClass
        tc = Nothing
        ' yukardaki ifade tc'yi null yapar, böylece tc'nn hiçbr elamnına erişlemez, çünkü bu bir referans tipli classtır. bir önceki örnekte ise bir strcuturın elenalrıan erişeibliyorduk. Dolayıyısla bir alt satırda hata alınır.
        Console.WriteLine(tc.Field1)

    End Sub

    Class TestClass
        Public Field1 As Integer
        ' . . .
    End Class
End Module

Empty

Bir değişkene ilk değer olarak boş değer atanmak isteniyorsa String.Empty ifadesi kullanılmalıdır. Bu, VBA'deki vbNullstringe denk düşmektedir. ZLS burda da geçerlidir ancak VBA'daki aynı performans sebeplerinden dolayı kullanılmaması daha iyi olacaktır.

Dim str As String = String.Empty

Değişkenin empty mi olduğu aşağıdaki gibi sorgulanabilir:

Dim str As String = String.Empty
If str = String.Empty Then
   MsgBox("String Empty'dir")
End If

veya

If degisken.Length=0

String sınıfının IsNullOrEmpty diye güzel bir metodu var, bununla bir değişkenin aynı anda null veya empty mi olduğu tek seferde sorgulanabilir. Ancak sadece Empty mi veya sadece Null mı sorgulaması yapmak için bunu değil yukardaki fonskiyonları kullanın.

  Dim str As String = Nothing
  If String.IsNullOrEmpty(str) Then
	  MsgBox("String null veya empty'dir")
  End If

C# da Vb.Net gibi .Net çatısının altındaki dillerden biri olup, VB.Net konusu altında bahsettiğim birçok şey C# için de geçerlidir. Farklılıklar ise şöyledir.

Vb.Net null değerler için Nothing ifadesini kullanırken c# null ifadesini kullanır ve sorgulaması if (degiksen==null) ifadesi ile yapılır.

class Program
{
    static string globaldegisken; //class seviyesindeki global değişken, diğer adı field

    static void Main()
    {
	// global string değişkenimize hemen defualt değeri olan null atanır
	if (globaldegisken == null) //string her ne kadar referans tipli olsa da sorgulama yapılırken değer tipli değişkenler gibi == ile sorgulanır. eğer bu başka bir obje olsaydı "Is" ile sorgulardık
	{
	    Console.WriteLine("Global Değişkenimiz null'dır");
	}

	string localdegisken1; //local değişken

	// // burayı çalışıtırısak hata laırız, çünkü lokcal değişkene henüz bir değer atanmadı
	// if (localdegisken1== null)
	// {
        // ......
	// }

	string localdegisken2=null; //local değişken

	 // burayı çalışıtırısak hata laırız, çünkü lokcal değişkene henüz bir değer atanmadı
	 if (localdegisken2== null)
	 {
	    Console.WriteLine("Local Değişkenimiz null'dır");
	 }
    }
}

Ayrıca yine Vb.Net bölümünde gördüğümüz üzere, C#'ta referans tipli olmayan hiçbir değişkene null değer atanamaz(nullable değişkenler hariç)

Coalesce:İlk null olmayan değeri elde edersiniz. Coalesce(x,y,z). Ansi standartı olup tüm SQL platformlarında geçerlidir. Alternatifi Case When

Nvl(Oracle):ifade sonucu nullsa ikinci parametre döner. Nvl(ifade,x)

IsNull(SQL Server):İfade sonucu nullsa ikinci parametre. IsNull(ifade,x)   

Nvl2(Oracle):ifade sonucu null değilse ikinci parametre yoksa üçüncü parametre döner. Nvl2(ifade,x,y)
IIF(SQL Server):ifade sonucu nulsa ikinci parametre, yoksa üçüncü parametre döner. IIF(ifade is null,x,y)

Nullif:iki değer de eşitse null, eşit değilse ilk değer. Ansi standartı olup tüm SQL platformlarında geçerlidir.

Where kısmında null kayıtları sorgulamak ise çok daha basit.

Select * 
from tabloadı
where
alan is null --null olmayanlar için "alan is not null"

İlk değer ataması, boş değer atama ve boş değer sorgulaması aşağıdaki gibi özetlenebilir

Null/Nothing ataması ve sorgulaması ise aşağıdaki gibi özetlenebilir