CODEWITHSUNDEEP
c#.netcastingxnatype-conversion
General Waters
General Waters

Reputation: 1139

Using as operator to cast, even after using is operator to verify class type in C#?

I understand that using the as operator to cast an object, over an explicit cast, is usually more desirable due to the fact that if the cast fails, the reference variable goes to null instead of throwing an exception.

However, lets say I check to see the type of class an object is, that's inside of a List, prior using the as operator, like so,

DrawableGameComponent drawComponent;
foreach (component in Components)
{
     if (component is DrawableGameComponent)
     {
          drawComponent = component as DrawableGameComponent;

         // do something with drawComponent
     }
}

does using the as operator lose its benefits by checking with the is operator first? So doing the following cast is just as good, because we first check the class type using is before attempting the cast?

if (component is DrawableGameComponent)
{
     ((DrawableGameComponent)componet).Visible = true;
}

I'm just wondering if there is some underlying piece I'm missing, or if this truly comes down to a matter of taste which pattern to use. Does the latter pattern create garbage through the explicit cast?

Thanks in advance!

Upvotes: 3

Views: 214

Answers (5)

Vlad Bezden
Vlad Bezden

Reputation: 89527

You can use LINQ just to get your types. This way no casting is required.

public class A
{   
}

public class B : A
{
    public bool Visible { get; set; }
}

public class C : A
{
}

void Main()
{
    var data = new List<A> { new A(), new B(), new C(), new B() };

    data.OfType<B>().ToList().ForEach(x => x.Visible = true);
}

Upvotes: 0

Andrew Cooper
Andrew Cooper

Reputation: 32576

By combining is and as you're effectively doing the type checking twice. Just using as in this context (as the other answers show) gets you what you want, and results in more readable code IMO.

Upvotes: 0

Andy Dent
Andy Dent

Reputation: 17969

You're checking the class twice by using the as operator, although I doubt the overhead would be noticeable unless in a truly massive loop.

I much prefer using as and testing for null and also cleaning up your declaration for even fewer lines:

foreach (component in Components)
{
     var drawComponent = component as DrawableGameComponent;
     if (drawComponent != null)
     {
          // do something with drawComponent
     }
}

Upvotes: 5

Rob
Rob

Reputation: 4753

I would use

DrawableGameComponent drawComponent;
foreach (component in Components)
{
    drawComponent = component as DrawableGameComponent;
    if (drawComponent != null)
    {
        // do something with drawComponent
    }
 }

FXCop can help picking up places in your code that can benefit from small optimisations like this

Upvotes: 1

Yahia
Yahia

Reputation: 70369

better (saves one "cast" - compare the generated IL):

DrawableGameComponent drawComponent;
foreach (component in Components)
{
     drawComponent = component as DrawableGameComponent;
     if (drawComponent != null)
     {


         // do something with drawComponent
     }
}

Upvotes: 11

Related Questions