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 statement1. 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
}
1 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.
AsIf extension (upon object) taking the destination type as a type paramater and an Action<T> parameter for the body which encapsulates the as conversion and null check. (IfIs might be a more accurate though less entertaining name.) –
Liberalism t = null in the final for clause? It should work just fine without it. –
Tubercular for here though. –
Liberalism EVIL EVIL EVIL, but I'm not positive. –
Hermilahermina AsEither(...), I think it's a bit clearer than AsIf(...), so I can write myAnimal.AsEither(dog => dog.Woof(), cat => cat.Meeow(), unicorn => unicorn.ShitRainbows()). –
Iowa schyeah.AsIf :D (wow, @Eric and Jon, both of you at the same time! [hmm.] anyway, just don't get too close to each other—don't want your reps to go prompt critical! :P) isExcellent = xpert[0].AsIf<JonSkeet>(j => j.partyOn) && xpert[1].AsIf<EricLippert>(e => e.partyOn()); :D ♡ –
Angkor Dog dog; if ((dog = animal as Dog) != null) { ... }. You still need two lines to do that though; so you might as well go for clarity. –
Parkland AsOrEmpty is very nearly built-in: foreach (var dog in new[] { animal }.OfType<Dog>()) - nothing evil about that :) –
Gorton AsIf :) –
Pilgarlic If as fails, it returns null.
Dog dog = animal as Dog;
if (dog != null)
{
// do stuff
}
if statement and not in outer scope. –
Edana if can have a bool result and an assignment. Dog dog; if ((dog = animal as Dog) != null) { // Use Dog } but that still introduces the variable in the outer scope. –
Swordtail 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.
Try* (e.g., TryParse). This feature not only makes such calls into a single expression (as they should be, IMO), but also allows for cleaner scoping of such variables. I am enthusiastic about having the out parameter of a Try method be scoped to its conditional; this makes it harder to introduce certain types of bugs. –
Kunkel if ((var myLocal = myObj.myProp) != null ) { … myLocal … } –
Borst 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:
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.)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.)is/as. (But also done with Dog dog = ... form.)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.
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://learn.microsoft.com/pl-pl/dotnet/csharp/language-reference/proposals/csharp-9.0/patterns3#pattern-combinators
Another late entry:
if (animal is Dog dog)
{
dog.Name="Fido";
}
else if (animal is Cat cat)
{
cat.Name="Bast";
}
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.
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()))
{
}
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
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:
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! 🙂
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
}
© 2022 - 2024 — McMap. All rights reserved.
nullis cast tofalse. So, if the result of the assignment is null, the statement evaluates tonullwhich is then cast tofalse. That is why in some languages you can useif(var) {...}to execute code only if that variable is non-null. Generally, assigning to variables in anifstatement is poo-pooed because it looks like a common error (typing=instead of==). One used to be able to gain some (small) performance benefit from using an assignment in anifblock, but many modern compilers will do optimizations like this for you. – Pablopabonif($var = <expression>)and then$varis casted tobooland used for the check.$varis than also available in the scope where theifstatement is. – Accumulatornull!=falsein C#; C# only allows actual bools or things implicitly convertible to bools inifconditions. Neither nulls nor any of the integer types are implicitly convertible to bools. – Casperifclause, I wrap everything is a scope, which is more verbose, and almost as ugly than thefor(...)solution of Jon Skeet, markedEVIL EVIL EVILfor some reason... Aaah, sweet Inquisition... ^_^ ... – Scat