Veya OrElse'e karşı

Question 1

Arasındaki fark nedir ya ve OrElse ?

if temp is dbnull.value or temp = 0

şu hatayı üretir:

Operatör '=', 'DBNull' türü ve 'Tamsayı' türü için tanımlanmadı.

bu bir cazibe gibi çalışırken !?

if temp is dbnull.value OrElse temp = 0

Question 2

OrElseBir olan kısa devre operatör Ordeğil.

Boolean 'veya' operatörünün tanımına göre, ilk terim Doğru ise bütün kesinlikle doğrudur - bu nedenle ikinci terimi değerlendirmemize gerek yoktur.

OrElseBu biliyor, bu yüzden denemek ve değerlendirmek değil temp = 0o kurulmuş oluyor keztemp Is DBNull.Value

Orbunu bilmiyor ve her zaman her iki terimi de değerlendirmeye çalışacak. Ne zaman temp Is DBNull.Value, sıfırla karşılaştırılamaz, bu yüzden düşer.

Kullanmalısınız ... iyi, hangisi mantıklıysa.

Question 3

Bu, herkesin Coditional Or (||) ve Koşullu Ve (&&) kullandığı C # ile aynı davranıştır, burada normal Or (|) ve normal And (&) da vardır. Dolayısıyla C # ile VB.Net'i karşılaştırmak:

| => Veya

|| => OrElse

& => Ve

&& => VeAyrıca

Koşullu mantıksal işleçler çok kullanışlıdır, eğer yapıların iç içe geçmesini engeller. Ancak bazen her iki kod yolunun da isabetli olmasını sağlamak için normal boole operatörlerine ihtiyaç duyulur.

Question 4

OrElse kısa devre yapıyor , bu, ilk taraf bir eşleşme ise ifadenin yalnızca bir tarafının test edileceği anlamına gelir.

Tıpkı AndAlso gibi, ilk yarısı başarısız olursa ifadenin sadece bir tarafını test edecektir.

Question 5

(Diğer cevaplara baktım ve çok hatalı olduğumu fark ettim)

OrElse operatörü "iki ifade üzerinde kısa devre yapan mantıksal ayırma gerçekleştirir", yani: eğer sol işlenen doğruysa ve bu nedenle tüm ifadenin doğru olması garanti edilirse, sağ işlenen bile değerlendirilmez (bu, gibi durumlar:

string a;
//...
if (a is null) or (a = "Hi") //...

sağ taraftaki işlenen tarafından bir NullReferenceException atmasından kaçınmak için.

Umarım bu (yani şaşırttı değilim tembel değerlendirme ) varsayılan davranış değildir orve andbu C / C ++ olduğu gibi C # (ve diğer birçok dil ...)

Question 6

OrElse ilk ifadeyi değerlendirdikten sonra eğer doğruysa ifadeye ilerlerken OR ifadelerine geçmeden önce iki ifadeyi değerlendirir.

Misal:

Textbox1.Text= 4

Textbox2.Text= ""

OrElse Kullanımı

  If TextBox1.Text > 2 OrElse TextBox2.Text > 3 Then
      MsgBox("True")
  End If

Sonuç: DOĞRU

OR kullanma

 If TextBox1.Text > 2 Or TextBox2.Text > 3 Then

            MsgBox("True")
  End If

Sonuç: Dize ikiye dönüştürülemez hata.

Question 7

Bert'in cevabı pek doğru değil. '|' veya '&' mantıksal operatördür, C # 'da her zaman bit operatörü olarak davranır, lütfen örnek olarak aşağıdaki koda bakın

        static void Main()
        {
            object a = null;
            int b = 3;
            if (a == null | a.ToString() == "sdffd")
            {
                Console.WriteLine("dddd");
            }
            Console.WriteLine(b | b);
            Console.Read();
        }

Aşağıdaki IL

    .method private hidebysig static void  Main() cil managed
{
  .entrypoint
  // Code size       62 (0x3e)
  .maxstack  3
  .locals init ([0] object a,
           [1] int32 b,
           [2] bool CS$4$0000)
   IL_0000:  nop
   IL_0001:  ldnull
   IL_0002:  stloc.0
   IL_0003:  ldc.i4.3
   IL_0004:  stloc.1
   IL_0005:  ldloc.0
   IL_0006:  ldnull
   IL_0007:  ceq
   IL_0009:  ldloc.0
   IL_000a:  callvirt   instance string [mscorlib]System.Object::ToString()
   IL_000f:  ldstr      "sdffd"
   IL_0014:  call       bool [mscorlib]System.String::op_Equality(string,
                                                                 string)
   IL_0019:  or
   IL_001a:  ldc.i4.0
   IL_001b:  ceq
   IL_001d:  stloc.2
   IL_001e:  ldloc.2
   IL_001f:  brtrue.s   IL_002e
   IL_0021:  nop
   IL_0022:  ldstr      "dddd"
   IL_0027:  call       void [mscorlib]System.Console::WriteLine(string)
   IL_002c:  nop
   IL_002d:  nop
   IL_002e:  ldloc.1
   IL_002f:  ldloc.1
   IL_0030:  or
   IL_0031:  call       void [mscorlib]System.Console::WriteLine(int32)
   IL_0036:  nop
   IL_0037:  call       int32 [mscorlib]System.Console::Read()
   IL_003c:  pop
   IL_003d:  ret
    } // end of method Program::Main

|| kullandığınızda "a == null" ve "a.ToString () ==" sdffd "yi test etmek için IL,

 .method private hidebysig static void  Main() cil managed
{
  .entrypoint
  // Code size       63 (0x3f)
  .maxstack  2
  .locals init ([0] object a,
           [1] int32 b,
           [2] bool CS$4$0000)
  IL_0000:  nop
  IL_0001:  ldnull
  IL_0002:  stloc.0
  IL_0003:  ldc.i4.3
  IL_0004:  stloc.1
  IL_0005:  ldloc.0
  IL_0006:  brfalse.s  IL_001d
  IL_0008:  ldloc.0
  IL_0009:  callvirt   instance string [mscorlib]System.Object::ToString()
  IL_000e:  ldstr      "sdffd"
  IL_0013:  call       bool [mscorlib]System.String::op_Equality(string,
                                                                 string)
  IL_0018:  ldc.i4.0
  IL_0019:  ceq
  IL_001b:  br.s       IL_001e
  IL_001d:  ldc.i4.0
  IL_001e:  stloc.2
  IL_001f:  ldloc.2
  IL_0020:  brtrue.s   IL_002f
  IL_0022:  nop
  IL_0023:  ldstr      "dddd"
  IL_0028:  call       void [mscorlib]System.Console::WriteLine(string)
  IL_002d:  nop
  IL_002e:  nop
  IL_002f:  ldloc.1
  IL_0030:  ldloc.1
  IL_0031:  or
  IL_0032:  call       void [mscorlib]System.Console::WriteLine(int32)
  IL_0037:  nop
  IL_0038:  call       int32 [mscorlib]System.Console::Read()
  IL_003d:  pop
  IL_003e:  ret
} // end of method Program::Main

Şimdi farkı görebilirsiniz, lütfen '|' veya 've' koşullu operatör olarak, sadece mantıksal bir operatör, koşulu yargılamak için kullanmanın gerekli olduğunu düşünmüyorum

Question 8

Kod mantığınız OrElse'nin sağladığı kısa devre davranışını gerektirmedikçe, Or operatörünü kullanmaya eğilimliyim çünkü:

"Veya" kullanmak basittir ve daha az yazı gerektirir.
OrElse kullanmanın hesaplamalı zaman tasarrufu çoğu durumda ihmal edilebilir düzeydedir.
En önemlisi, OrElse kullanımı, daha sonraki cümlelerde bulunan ve bu koşullar sonunda program mantığı tarafından karşılanana kadar başlangıçta ortaya çıkmayabilecek hataları gizleyebilir.

Question 9

Örnekte derlemenin başarısız olmasının nedeni işlemlerin sırasıdır.

İfade ayrıştırıcısı önce "dbnull.value veya temp" değerini değerlendirmeye çalışıyor.

if temp is (dbnull.value or temp) = 0

Hata burada, çünkü bir tamsayı (temp) ile dbnull.value arasında bit düzeyinde VEYA yapamazsınız.

OrElse, kısa devre olduğu için değil, işlem sırasına göre daha düşük olduğu için bunu düzeltir . düzeltir ve bu nedenle dbNull ile karşılaştırmaya çalışan ayrıştırıcı yerine ilk önce "temp dbnull.value" ve "3 = 0" değerlendirilir. temp.

Yani OrElse ile değerlendirme beklediğiniz gibi çalışır: (temp = 3 varsayınız)

if temp is dbnull.value OrElse temp = 0 then
if 3 is dbnull.value OrElse 3 = 0 then
if false OrElse 3=0 then
if false OrElse false then
if false then

Bu aslında eskiden çalıştığım bir yazılım şirketinde bir giriş sınavındaydı ve VB6'da karşılaştığım yaygın bir sorundu. Bu nedenle, boole operatörlerini kullanırken alt ifadelerinizi parantez içine almak iyi bir fikirdir:

Bu doğru bir şekilde derlenmiş olurdu:

if (temp is dbnull.value) Or (temp = 0) then

Yine de, herkesin daha önce işaret ettiği gibi, OrElse ve AndAlso, bu bağlamda kullanılacak gerçekten doğru operatörlerdir.