[marinus]

How often do u use the [ ?: ] operator .

I am starting to use it alot and enjoy to use it .

e.g:

 if (ddlLocation.SelectedIndex != 0  && ddlUnitSize.SelectedIndex != 0)
         {
                    Response.Redirect("bookings.aspx?size=" + 
                                      chkNowSize.Checked + "?location=" + 
                                      ddlLocation.SelectedValue + "");
         }
         else
         {
           lblMessage.Text = "Selecting a value from " + 
                             (ddlLocation.SelectedIndex == 0 ? "location dropdown is required" : "unitsize is required");
         }

This works quite good , what do you thing about this operator ?

This post has been edited by marinus: 06 July 2011 - 05:24 AM

[codeprada]

Cuts down the amount of typing I've got to do really.

Since it applies to a few languages other than C#

<?php
$x = true;
echo "x is equal to " . ($x ? "true" : "false");
?>

Nested ternary operators truly can start to get confusing also so I won't over do it.

<?php
#if a number is less than 0 find the absolute value
#then divide by 2
#if the number is zero return 0
$n = -7;
echo ($n < 0 ? ($n * -1) / 2 : ($n == 0 ? 0 : $n /= 2));
?>

This post has been edited by codeprada: 06 July 2011 - 05:30 AM

[Kilorn]

They can definitely be a nice tool in any programmer's toolbag, but as codeprada said, they can get confusing if you're trying to do too much with them, for instance nesting. I try to see them when I feel it will reduce the number of lines of code in a method without making it too difficult for someone else to read over the code and make sense of it.

// For instance...
if (x > 0)
{
    x = 1;
}
else
{
    x = -1;
}

// Can easily be shortened to use the ternary operator without taking too much away from
// the readability of the code
int y = x > 0 ? 1 : -1;

[eclipsed4utoo]

I use it a pretty good bit in code like what Kilorn showed. I also use it in data access code when testing against null values when reading data in..

// some code
using (SqlDataReader dr = cmd.ExecuteReader())
{
    if (dr.Read())
    {
        someDate = (dr["SomeDateColumn"] != DbNull.Value) ? Convert.ToDateTime(dr["SomeDateColumn"]) : DateTime.MinValue;
    }
}

[Kilorn]

I think there is a fine line between efficiency and lack of readability that we as programmers have to keep in mind. Maybe this isn't such a big deal if you're the only programmer on the project, but if you're working on a team, especially if some members on the team are relatively new to programming, perhaps it would be best to limit using this operator as it seems that most entry level programmers have never even heard of it. It's another great weapon in our arsenal, but it has it's place in my opinion and I try to use it when it makes sense, but try to avoid overusing it.

[marinus]

It can look very confusing if you overuse it, almost like the programming language BrainF***

but it can be a good thing to know ..

And it's something extra to add to you knowledge

Thanks for the input

This post has been edited by marinus: 06 July 2011 - 07:49 AM

[Curtis Rutland]

There's another little-known operator in C#: ??, the Null Coalescing Operator.

Example use:

var x = a ?? b;

That's the equivalent to:

var x;
if(a != null)
  x = a;
else
  x = b;

[Kilorn]

The ~ operator is another that I'd imagine doesn't get much use, at least in C#. Basically, it is a bitwise complement operator and is used to find the opposite of whatever address in memory that you want to check.

// Directly from the MSDN library:
// cs_operator_bitwise_compl.cs
using System;
class MainClass
{
    static void Main() 
    {
        int[] values = { 0, 0x111, 0xfffff, 0x8888, 0x22000022};
        foreach (int v in values)
        {
            Console.WriteLine("~0x{0:x8} = 0x{1:x8}", v, ~v);
        }
    }
}

//  Output:
// ~0x00000000 = 0xffffffff
// ~0x00000111 = 0xfffffeee
// ~0x000fffff = 0xfff00000
// ~0x00008888 = 0xffff7777
// ~0x22000022 = 0xddffffdd

The output shows that the complement to 0x00000000 is 0xffffffff. If you know a little about hexadecimal, this would be obvious to you.

[Curtis Rutland]

That would be fairly rare in C#, since most of us don't do too much bitwise calculations.

[Kilorn]

This is very true. In fact I don't think I've ever seen any reason to perform bitwise calculations in C# given the higher level nature of the language, but should the need ever arise for some strange reason, it is there.

[Curtis Rutland]

Yeah, there's a lot of things C# is capable of doing that people just don't usually do. You can wrap a block in unsafe or prepend that to a method declaration and you can use pointers, but hardly anyone does.

[Kilorn]

With C# there really isn't any need to use pointers that I can think of, but it is nice to know that the functionality is there should a programmer ever need it.

[Momerath]

Kilorn, on 06 July 2011 - 08:25 AM, said:

With C# there really isn't any need to use pointers that I can think of

Speed! Pointers are faster than references when dealing with arrays and such.

[Robin19]

Kilorn, on 06 July 2011 - 08:39 AM, said:

Maybe this isn't such a big deal if you're the only programmer on the project, but if you're working on a team, especially if some members on the team are relatively new to programming, perhaps it would be best to limit using this operator as it seems that most entry level programmers have never even heard of it.

marinus, on 06 July 2011 - 09:48 AM, said:

It can look very confusing if you overuse it, almost like the programming language BrainF***

I don't think one should shy away from it. I feel it is elegant. Teaching myself C# for the past year, I understood the ?: operator before I grasped how Properties were different than Fields. I wouldn't shy away from Properties, and I won't shy away from the tertiary operator.

Curtis Rutland, on 06 July 2011 - 09:50 AM, said:

There's another little-known operator in C#: ??, the Null Coalescing Operator.

I did not know about that operator. I will definitely use this in my coding.

[marinus]

Robin19, on 07 July 2011 - 05:23 PM, said:

Kilorn, on 06 July 2011 - 08:39 AM, said:

Maybe this isn't such a big deal if you're the only programmer on the project, but if you're working on a team, especially if some members on the team are relatively new to programming, perhaps it would be best to limit using this operator as it seems that most entry level programmers have never even heard of it.

marinus, on 06 July 2011 - 09:48 AM, said:

It can look very confusing if you overuse it, almost like the programming language BrainF***

I don't think one should shy away from it. I feel it is elegant. Teaching myself C# for the past year, I understood the ?: operator before I grasped how Properties were different than Fields. I wouldn't shy away from Properties, and I won't shy away from the tertiary operator.

Curtis Rutland, on 06 July 2011 - 09:50 AM, said:

There's another little-known operator in C#: ??, the Null Coalescing Operator.

I did not know about that operator. I will definitely use this in my coding.

I have started using ?: operator alot , and becoming a fan of writing code in this style

like today in "Active Server Pages dot net"!!

e.g

 protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsValidToHere()) { Response.Redirect("my-not-known-page.aspx"); }
        }

        public bool IsValidToHere()
        {

            string url = Request.Url.AbsoluteUri;

            return (url.Contains("location")) ? true : false;



        }

     

Works like a charm