Assignment in an if statement

I have a class Animal, and its subclass Dog. I often find myself coding the following lines:

if (animal is Dog)
{
    Dog dog = animal as Dog;    
    dog.Name;    
    ... 
}

For the variable Animal animal;.

Is there some syntax that allows me to write something like:

if (Dog dog = animal as Dog)
{    
    dog.Name;    
    ... 
}

The answer below was written years ago and updated over time. As of C# 7, you can use pattern matching:

if (animal is Dog dog)
{
    // Use dog here
}

Note that dog is still in scope after the if statement, but isn't definitely assigned.

---

No, there isn't. It's more idiomatic to write this though:

Dog dog = animal as Dog;
if (dog != null)
{
    // Use dog
}

Given that "as followed by if" is almost always used this way, it might make more sense for there to be an operator which performs both parts in one go. This isn't currently in C# 6, but may be part of C# 7, if the pattern matching proposal is implemented.

The problem is that you can't declare a variable in the condition part of an if statement¹. The closest approach I can think of is this:

// EVIL EVIL EVIL. DO NOT USE.
for (Dog dog = animal as Dog; dog != null; dog = null)
{
    ...
}

That's just nasty... (I've just tried it, and it does work. But please, please don't do this. Oh, and you can declare dog using var of course.)

Of course you could write an extension method:

public static void AsIf<T>(this object value, Action<T> action) where T : class
{
    T t = value as T;
    if (t != null)
    {
        action(t);
    }
}

Then call it with:

animal.AsIf<Dog>(dog => {
    // Use dog in here
});

Alternatively, you could combine the two:

public static void AsIf<T>(this object value, Action<T> action) where T : class
{
    // EVIL EVIL EVIL
    for (var t = value as T; t != null; t = null)
    {
        action(t);
    }
}

You can also use an extension method without a lambda expression in a cleaner way than the for loop:

public static IEnumerable<T> AsOrEmpty(this object value)
{
    T t = value as T;
    if (t != null)
    {
        yield return t;
    }
}

Then:

foreach (Dog dog in animal.AsOrEmpty<Dog>())
{
    // use dog
}

---

¹ You can assign values in if statements, although I rarely do so. That's not the same as declaring variables though. It's not terribly unusual for me to do it in a while though when reading streams of data. For example:

string line;
while ((line = reader.ReadLine()) != null)
{
    ...
}

These days I normally prefer to use a wrapper which lets me use foreach (string line in ...) but I view the above as a pretty idiomatic pattern. It's usually not nice to have side-effects within a condition, but the alternatives usually involve code duplication, and when you know this pattern it's easy to get right.

If as fails, it returns null.

Dog dog = animal as Dog;

if (dog != null)
{
    // do stuff
}

You can assign the value to the variable, as long as the variable already exists. You can also scope the variable to allow that variable name to be used again later in the same method, if that is a problem.

public void Test()
{
	var animals = new Animal[] { new Dog(), new Duck() };

	foreach (var animal in animals)
	{
		{	// <-- scopes the existence of critter to this block
			Dog critter;
			if (null != (critter = animal as Dog))
			{
				critter.Name = "Scopey";
				// ...
			}
		}

		{
			Duck critter;
			if (null != (critter = animal as Duck))
			{
				critter.Fly();
				// ...
			}
		}
	}
}

assuming

public class Animal
{
}

public class Dog : Animal
{
	private string _name;
	public string Name
	{
		get { return _name; }
		set
		{
			_name = value;
			Console.WriteLine("Name is now " + _name);
		}
	}
}

public class Duck : Animal
{
	public void Fly()
	{
		Console.WriteLine("Flying");
	}
}

gets output:

Name is now Scopey
Flying

The pattern of variable assignment in the test is also used when reading byte blocks from streams, for example:

int bytesRead = 0;
while ((bytesRead = fs.Read(buffer, 0, buffer.Length)) > 0) 
{
    // ...
}

The pattern of variable scoping used above, however, is not a particularly common code pattern and if I saw it being used all over the place I'd be looking for a way to refactor it out.

> Is there some syntax that allows me to write something like:

if (Dog dog = animal as Dog) { ... dog ... }

> ?

There likely will be in C# 6.0. This feature is called "declaration expressions". See

https://roslyn.codeplex.com/discussions/565640

for details.

The proposed syntax is:

if ((var i = o as int?) != null) { … i … }
else if ((var s = o as string) != null) { … s … }
else if ...

More generally, the proposed feature is that a local variable declaration may be used as an expression. This if syntax is just a nice consequence of the more general feature.

One of the extension methods I find myself writing and using often* is

public static TResult IfNotNull<T,TResult>(this T obj, Func<T,TResult> func)
{
    if(obj != null)
    {
        return func(obj);
    }
    return default(TResult);
}

Which could be used in this situation as

string name = (animal as Dog).IfNotNull(x => x.Name);

And then name is the dog's name (if it is a dog), otherwise null.

*I have no idea if this is performant. It has never come up as a bottleneck in profiling.

Going against the grain here, but maybe you're doing it wrong in the first place. Checking for an object's type is almost always a code smell. Don't all Animals, in your example, have a Name? Then just call Animal.name, without checking whether it's a dog or not.

Alternatively, invert the method so that you call a method on Animal that does something differently depending on the concrete type of the Animal. See also: Polymorphism.

Shorter Statement

var dog = animal as Dog
if(dog != null) dog.Name ...;

The problem (with the syntax) is not with the assignment, as the assignment operator in C# is a valid expression. Rather, it is with the desired declaration as declarations are statements.

If I must write code like that I will sometimes (depending upon the larger context) write the code like this:

Dog dog;
if ((dog = animal as Dog) != null) {
    // use dog
}

There are merits with the above syntax (which is close to the requested syntax) because:

1. Using dog outside the if will result in a compile error as it is not assigned a value elsewhere. (That is, don't assign dog elsewhere.)
2. This approach can also be expanded nicely to if/else if/... (There are only as many as as required to select an appropriate branch; this the big case where I write it in this form when I must.)
3. Avoids duplication of is/as. (But also done with Dog dog = ... form.)
4. Is no different than "idiomatic while". (Just don't get carried away: keep the conditional in a consistent form and and simple.)

To truly isolate dog from the rest of the world a new block can be used:

{
  Dog dog = ...; // or assign in `if` as per above
}
Bite(dog); // oops! can't access dog from above

Happy coding.

Here's some additional dirty code (not as dirty as Jon's, though :-)) dependent on modifying the base class. I think it captures the intent while perhaps missing the point:

class Animal
{
    public Animal() { Name = "animal";  }
    public List<Animal> IfIs<T>()
    {
        if(this is T)
            return new List<Animal>{this};
        else
            return new List<Animal>();
    }
    public string Name;
}

class Dog : Animal
{
    public Dog() { Name = "dog";  }
    public string Bark { get { return "ruff"; } }
}


class Program
{
    static void Main(string[] args)
    {
        var animal = new Animal();

        foreach(Dog dog in animal.IfIs<Dog>())
        {
            Console.WriteLine(dog.Name);
            Console.WriteLine(dog.Bark);
        }
        Console.ReadLine();
    }
}

If you have to do multiple such as-ifs one after one (and using polymorphism is not an option), consider using a SwitchOnType construct.

With C# 9.0 and .NET 5.0 you can write it using as like that:

Animal animal;
if (animal as Dog is not null and Dog dog)
{
    //You can get here only if animal is of type Dog and you can use dog variable only
    //in this scope
}

It is because the animal as Dog in if statement produces the same result as:

animal is Dog ? (Dog)(animal) : (Dog)null

then is not null part checks if the result of above statement isn't null. Only if this statement is true it creates variable of type Dog dog, which can't be null.

This feature came to C# 9.0 with Pattern Combinators, you can read more about that right here: https://docs.microsoft.com/pl-pl/dotnet/csharp/language-reference/proposals/csharp-9.0/patterns3#pattern-combinators

IDK if this helps anybody but you can always try to use a TryParse to assign your variable. Here is an example:

if (int.TryParse(Add(Value1, Value2).ToString(), out total))
        {
            Console.WriteLine("I was able to parse your value to: " + total);
        } else
        {
            Console.WriteLine("Couldn't Parse Value");
        }
     

        Console.ReadLine();
    }

    static int Add(int value1, int value2)
    {
        return value1 + value2;
    }

The total variable would be declared before your if statement.

you can use something like that

//Declare variable bool temp= false;

 if (previousRows.Count > 0 || (temp= GetAnyThing()))
                                    {
                                    }

Another EVIL solution with extension methods :)

public class Tester
{
    public static void Test()
    {
        Animal a = new Animal();

        //nothing is printed
        foreach (Dog d in a.Each<Dog>())
        {
            Console.WriteLine(d.Name);
        }

        Dog dd = new Dog();

        //dog ID is printed
        foreach (Dog dog in dd.Each<Dog>())
        {
            Console.WriteLine(dog.ID);
        }
    }
}

public class Animal
{
    public Animal()
    {
        Console.WriteLine("Animal constructued:" + this.ID);
    }

    private string _id { get; set; }

    public string ID { get { return _id ?? (_id = Guid.NewGuid().ToString());} }

    public bool IsAlive { get; set; }
}

public class Dog : Animal 
{
    public Dog() : base() { }

    public string Name { get; set; }
}

public static class ObjectExtensions
{
    public static IEnumerable<T> Each<T>(this object Source)
        where T : class
    {
        T t = Source as T;

        if (t == null)
            yield break;

        yield return t;
    }
}

I personally prefer the clean way:

Dog dog = animal as Dog;

if (dog != null)
{
    // do stuff
}

An if statement won't allow that, but a for loop will.

e.g.

for (Dog dog = animal as Dog; dog != null; dog = null)
{
    dog.Name;    
    ... 
}

In case the way it works is not immediately obvious then here is a step by step explanation of the process:

• Variable dog is created as type dog and assigned the variable animal that is cast to Dog.
• If the assignment fails then dog is null, which prevents the contents of the for loop from running, because it is immediately broken out of.
• If the assignment succeeds then the for loop runs through the
  iteration.
• At the end of the iteration, the dog variable is assigned a value of null, which breaks out of the for loop.

using(Dog dog = animal as Dog)
{
    if(dog != null)
    {
        dog.Name;    
        ... 

    }

}

I know I'm super duper late to the party, but I figured I'd post my own workaround to this dilemma since I haven't seen it on here yet (or anywhere for that matter).

/// <summary>
/// IAble exists solely to give ALL other Interfaces that inherit IAble the TryAs() extension method
/// </summary>
public interface IAble { }

public static class IAbleExtension
{
    /// <summary>
    /// Attempt to cast as T returning true and out-ing the cast if successful, otherwise returning false and out-ing null
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="able"></param>
    /// <param name="result"></param>
    /// <returns></returns>
    public static bool TryAs<T>(this IAble able, out T result) where T : class
    {
        if (able is T)
        {
            result = able as T;
            return true;
        }
        else
        {
            result = null;
            return false;
        }
    }

    /// <summary>
    /// Attempt to cast as T returning true and out-ing the cast if successful, otherwise returning false and out-ing null
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="obj"></param>
    /// <param name="result"></param>
    /// <returns></returns>
    public static bool TryAs<T>(this UnityEngine.Object obj, out T result) where T : class
    {
        if (obj is T)
        {
            result = obj as T;
            return true;
        }
        else
        {
            result = null;
            return false;
        }
    }
}

With this, you can do things such as:

if (animal.TryAs(out Dog dog))
{
    //Do Dog stuff here because animal is a Dog
}
else
{
    //Cast failed! animal is not a dog
}

IMPORTANT NOTE: If you want to use TryAs() using an Interface, you MUST have that interface inheriting IAble.

Enjoy! 

Al little experimentation shows that we can use assignment in an if statement

public static async Task Main(string[] args)
{
    bool f = false;
    if (f = Tru())
    {
        System.Diagnostics.Debug.WriteLine("True");
    }
    if (f = Tru(false))
    {
        System.Diagnostics.Debug.WriteLine("False");
    }
}

private static bool Tru(bool t = true) => t ? true : false;

As far as any potential side effects or "Evil", I can't think of any, although I am sure somebody can. Comments welcome!

With C# 7's Pattern Matching you can now do things like:

if (returnsString() is string msg) {
  Console.WriteLine(msg);
}

This question was asked over 10 years ago now so almost all the other answers are outdated/wrong

There is workaround, I give you a little bit another example, you have a method which returns string Id, than if statement:

var userId = GetUserId();

if (!string.IsNullOrEmpty(userId))
{ 
    //logic
}

you might be expected syntax like this, which isn't work:

if (string userId = GetUserId() && !string.IsNullOrEmpty(userId))
{
    //logic
}

But now, you can achieve the same result with:

if (GetUserId() is string userId && !string.IsNullOrEmpty(userId))
{ 
    //logic
}

In your example you can do of course:

if(animal is Dog dog)
{
    //logic
}

but it find be usefull to consider using a method

var animal = GetAnimal();

if (animal is Dog)
{
    //logic
}

and finally you can rewrite it to:

if(GetAnimal() is Dog dog)
{
    //logic
}

Another late entry:

if (animal is Dog dog) 
{ 
    dog.Name="Fido"; 
}
else if (animal is Cat cat)
{
    cat.Name="Bast";
}