{"id":4623,"date":"2008-03-12T01:36:00","date_gmt":"2008-03-12T01:36:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vbteam\/2008\/03\/12\/orcas-introduces-the-if-operator-a-new-and-improved-iif-sophia-salim\/"},"modified":"2024-07-05T14:32:43","modified_gmt":"2024-07-05T21:32:43","slug":"orcas-introduces-the-if-operator-a-new-and-improved-iif-sophia-salim","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/vbteam\/orcas-introduces-the-if-operator-a-new-and-improved-iif-sophia-salim\/","title":{"rendered":"Orcas introduces the IF operator – a new and improved IIF (Sophia Salim)"},"content":{"rendered":"<\/p>\n

One of my all time favorite features in C# and CPP has been the conditional operator (?:). The brevity and elegance introduced by this operator in the code is unparalleled. We had IIF<\/strong> in all the previous versions of VB.net, which was not an operator in the true sense (It was a call to a function). But now with Visual Studio 2008, we have taken an "i" from this function and promoted it to operator status. "IF" <\/strong>can now be used instead of "IIF"<\/strong>. It provides full functionality of the IIF function with some very interesting additions of its own, including short-circuiting. It even comes in two flavors: the ternary flavor<\/strong> which mimics the functionality of the IIF function while adding some more to it, and the binary flavor<\/strong> which introduces a new sort of comparison\/assignment. Before I start getting too vague, I will just delve into the details of how to use the greatness called the IF operator<\/strong>!<\/p>\n

Note: I will touch only the ternary flavor in this blog, and will follow up with the binary if operator and other interesting examples for if in blogs to come.<\/p>\n

The first and most basic use of IF is the universal "compare, choose and assign" which is the functionality of conditional operators, and the iif function. The following are the definitions of the three operands of IF(TestExpression, TruePart, FalsePart):<\/p>\n

    \n
      \n
    1. TestExpression, <\/strong>is any expression that produces a boolean value or a value convertible to boolean. With option strict on the expression needs to produce a value that is either boolean or has a widening conversion to boolean.<\/li>\n
    2. TruePart, <\/strong>is the return value of the IF operator if the test expression above evaluates to true. Note that the return type<\/strong> of the operator is decided based on the wider of the types of the truepart and the falsepart, e.g, if the truepart is an integer and the falsepart is a decimal, then decimal which is the wider of the two types will be the return value’s type. For details on type conversions and for a list of wider and narrower types, please refer here<\/a><\/li>\n
    3. FalsePart,<\/strong>  is the return value of the IF operator if the test expression evaluates to false. Here in lies the short-circuiting. If the test expression evaluates to true, the FalsePart is just ignored. <\/strong>The compiler will not touch it. It will not evaluate it. So as long as your test expression is true, you can do null references here, call functions on objects that do not actually exist, or anything that the parser will let you get away with. It will just not be evaluated. (Please do not think that I am recommending you to do any of the afore-mentioned evils, but as long as your test expression remains true you can get away with this). This can be very useful while calling a function on a variable which may not be instantiated, You can simply do:<\/li>\n
      Dim return <\/span>= If<\/span>(var Is Nothing<\/span>, foo1(), var.foo())<\/pre>\n
          <\/a><\/ol>\n<\/ol>\n
      Now lets look at some code that shows the ternary flavor of the IF operator<\/p>\n
      Module <\/span>Module1\n    Public Class <\/span>Number\n        Private <\/span>_RealPart As Double\n        Public Property <\/span>RealPart() As Double\n            Get\n                Return <\/span>_RealPart\n            End Get\n            Set<\/span>(ByVal <\/span>value As Double<\/span>)\n                _RealPart = value\n            End Set\n        End Property\n        Private <\/span>_ComplexPart As Double\n        Public Property <\/span>ComplexPart() As Double\n            Get\n                Return <\/span>_ComplexPart\n            End Get\n            Set<\/span>(ByVal <\/span>value As Double<\/span>)\n                _ComplexPart = value\n            End Set\n        End Property\n        Public Sub New<\/span>(ByVal <\/span>pRealPart As Double<\/span>, Optional ByVal <\/span>pComplexPart As Double <\/span>= 0.0)\n            _RealPart = pRealPart\n            _ComplexPart = pComplexPart\n        End Sub\n        Public Overrides Function <\/span>ToString() As String\n            Return If<\/span>(_ComplexPart = 0.0, _RealPart.ToString(), _\n                      _RealPart.ToString & " + " <\/span>& _ComplexPart.ToString() & "i"<\/span>)\n        End Function\n    End Class\n    Sub <\/span>Main()\n        Dim <\/span>i As New <\/span>Number(1)\n        'The If operator looks checks the number to see if it is real or complex, and prints accordingly\n        <\/span>Dim <\/span>NumberPrinter = Function<\/span>(arg As <\/span>Number) arg.RealPart.ToString & " + " <\/span>& arg.ComplexPart.ToString() & "i"\n        <\/span>Console.WriteLine("i is a real number:"<\/span>)\n        Console.WriteLine(If<\/span>(i.ComplexPart = 0.0, i.RealPart.ToString(), NumberPrinter(i)))\n        'Or the If operator can be moved inside the lambda to add to the elegance\n        <\/span>Dim <\/span>j As New <\/span>Number(1, 2)\n        Dim <\/span>NumberPrinter2 = Function<\/span>(arg As <\/span>Number) If<\/span>(arg.ComplexPart = 0.0, arg.RealPart.ToString(), _\n                                                        arg.RealPart.ToString & " + " <\/span>& arg.ComplexPart.ToString() & "i"<\/span>)\n        Console.WriteLine("j is a complex number:"<\/span>)\n        Console.WriteLine(NumberPrinter2(j))\n        'You can also use the short-circuiting feature of the if operator\n        <\/span>Dim <\/span>k As <\/span>Number\n        Console.WriteLine("k does not have any value, so we print j again:"<\/span>)\n        Console.WriteLine(If<\/span>(k Is Nothing<\/span>, j.ToString, k.ToString))\n        k = New <\/span>Number(3, 4)\n        Console.WriteLine("And now for k with a value:"<\/span>)\n        Console.WriteLine(If<\/span>(k Is Nothing<\/span>, j.ToString, k.ToString))\n    End Sub\nEnd Module\n<\/span><\/pre>\n
      <\/a><\/a><\/p>\n
      Notice how short-circuiting is used in the above code when k does not have a value (the first call). The call to a method from a null object is never evaluated.<\/p>\n
      For those addicted IIF users wondering if they can still use the legacy IIF function in Orcas, the answer is yes. <\/strong>We still support IIF, but with all the amazing things that you can do with the IF operator, <\/strong>why would you want to keep on typing those extra "i"s? And while you explore the many, many things that you can do with IF, I will be writing and posting more IF code and then some more! Until then,<\/p>\n
      Dim <\/span>blog_next = If<\/span>(bIFoundMoreInterestingScenarios, blogDelvingIntoIF, blogUnknown)<\/pre>\n
      If you know what I mean \ud83d\ude42<\/p>\n","protected":false},"excerpt":{"rendered":"
      One of my all time favorite features in C# and CPP has been the conditional operator (?:). The brevity and elegance introduced by this operator in the code is unparalleled. We had IIF in all the previous versions of VB.net, which was not an operator in the true sense (It was a call to a […]<\/p>\n","protected":false},"author":260,"featured_media":8818,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[192,195],"tags":[142,166],"class_list":["post-4623","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-featured","category-visual-basic","tag-sophia-salim","tag-vb2008"],"acf":[],"blog_post_summary":"
      One of my all time favorite features in C# and CPP has been the conditional operator (?:). The brevity and elegance introduced by this operator in the code is unparalleled. We had IIF in all the previous versions of VB.net, which was not an operator in the true sense (It was a call to a […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/4623","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/users\/260"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/comments?post=4623"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/4623\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media\/8818"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media?parent=4623"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/categories?post=4623"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/tags?post=4623"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}