if 语句中的赋值

Question

我有一个类 Animal 及其子类 Dog。 我经常发现自己编写以下几行代码：

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

对于变量Animalanimal;。

是否有某种语法允许我编写类似以下内容的语法：

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

Answer 1

下面的答案是几年前写的，并随着时间的推移而更新。从 C# 7 开始，您可以使用模式匹配：

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

请注意，dog 仍在 if 语句之后的范围内，但并未明确分配。

---

不，没有。不过，这样写更符合习惯用法：

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

鉴于“as 随后是 if”几乎总是以这种方式使用，因此有一个运算符一次性执行这两个部分可能更有意义。目前 C# 6 中没有此功能，但如果 模式匹配提案<，则可能是 C# 7 的一部分/a> 已实施。

问题是您无法在 if 语句¹的条件部分声明变量。我能想到的最接近的方法是：

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

That's just nasty...（我刚刚尝试过，它确实有效。但是请不要这样做。哦，还有你当然可以使用 var 声明 dog。）当然

，您可以编写一个扩展方法：

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

然后用以下方式调用它：

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

或者，您可以将两者结合起来：

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);
    }
}

您还可以使用没有 lambda 表达式的扩展方法比 for 循环更简洁：

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

然后：

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

---

¹ 您可以在 if 语句中赋值值，尽管我很少这样做。但这与声明变量不同。不过，在读取数据流时，在一段时间内执行此操作对我来说并不罕见。例如：

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

这些天我通常更喜欢使用一个包装器，它允许我使用 foreach (string line in ...) 但我认为上面是一个非常惯用的模式。在一个条件中产生副作用通常不太好，但替代方案通常涉及代码重复，当您知道这种模式时，就很容易做到正确。

Answer 2

如果 as 失败，则返回 null。

Dog dog = animal as Dog;

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

Answer 3

只要变量已经存在，您就可以将值分配给该变量。您还可以设置变量的范围，以允许稍后在同一方法中再次使用该变量名称（如果这是一个问题）。

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();
                // ...
            }
        }
    }
}

假设

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");
    }
}

获得输出：

Name is now Scopey
Flying

从流中读取字节块时也会使用测试中的变量赋值模式，例如：

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

上面使用的变量作用域模式，但是，不是一个特别常见的代码模式，如果我看到它被全部使用在这个地方我会寻找一种方法来重构它。

Answer 4

是否有一些语法可以让我编写如下内容：

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

？

C# 6.0 中可能会有。此功能称为“声明表达式”。 有关详细信息，请参阅

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

。

建议的语法是：

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

更一般地说，建议的功能是局部变量声明可以用作表达式。这个 if 语法只是更通用功能的一个很好的结果。

Answer 5

我发现自己经常编写和使用的扩展方法之一* 是

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

Which 可以在这种情况下使用，

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

然后 name 是狗的名字（如果它是狗），否则为 null。

*我不知道这是否有效。它从来没有成为分析的瓶颈。

Answer 6

这里违背了原则，但也许你一开始就做错了。检查对象的类型几乎总是代码味道。在你的例子中，不是所有的动物都有名字吗？然后只调用 Animal.name ，而不检查它是否是狗。

或者，反转该方法，以便调用 Animal 上的方法，该方法根据 Animal 的具体类型执行不同的操作。另请参见：多态性。

Answer 7

较短的声明

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

Answer 8

问题（语法方面）与赋值无关，因为 C# 中的赋值运算符是有效的表达式。相反，它是带有所需的声明，因为声明就是语句。

如果我必须编写这样的代码，我有时会（取决于更大的上下文）编写这样的代码：

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

上述语法有优点（接近请求的语法），因为：

1. 使用 dog 外部 if 将导致编译错误，因为它没有在其他地方赋值。 （也就是说，不要在其他地方分配dog。）
2. 这种方法也可以很好地扩展到if/else if/...（只有选择适当分支所需的as；这是大情况，当我必须时，我会以这种形式编写它。）
3. 避免重复是/作为。 （但也用Dog dog = ...形式完成。）
4. 与“惯用的while”没有什么不同。 （只是不要得意忘形：保持条件的形式一致且简单。）

为了真正将 dog 与世界其他地方隔离，可以使用一个新块：

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

快乐编码。

Answer 9

在 C# 9.0 和 .NET 5.0 中，您可以使用 as 来编写它：

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
}

这是因为 if 语句中的 animal as Dog 产生与以下相同的结果：

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

then is not null 部分检查上述语句的结果是否不为 null。仅当该语句为 true 时，它​​才会创建 Dog 类型的变量，该变量不能为 null。

此功能随模式组合器一起出现在 C# 9.0 中，您可以在此处阅读有关该功能的更多信息：
https:// learn.microsoft.com/pl-pl/dotnet/csharp/language-reference/proposals/csharp-9.0/patterns3#pattern-combinators

Answer 10

另一个迟到的条目：

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

Answer 11

这里有一些额外的脏代码（不过不像乔恩的那么脏:-)）依赖于修改基类。我认为它抓住了意图，但可能没有抓住要点：

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();
    }
}

Answer 12

如果您必须一个接一个地执行多个 if-if（并且使用多态性不是一种选择），请考虑使用 SwitchOnType 构造。

Answer 13

使用 C# 7 的模式匹配您现在可以执行以下操作：

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

这个问题是十多年前提出的，所以几乎所有其他答案都已过时/错误

Answer 14

IDK 如果这对任何人都有帮助，但您始终可以尝试使用 TryParse 来分配变量。下面是一个示例：

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;
    }

total 变量将在 if 语句之前声明。

Answer 15

你可以使用类似的东西

//声明变量
布尔温度=假；

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

Answer 16

所有的小实验表明，我们可以在 if 语句中使用赋值

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;

至于任何潜在的副作用或“邪恶”，我想不出任何副作用，尽管我确信有人可以。欢迎评论！

Answer 17

另一个带有扩展方法的邪恶解决方案:)

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;
    }
}

我个人更喜欢干净的方式：

Dog dog = animal as Dog;

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

Answer 18

if 语句不允许这样做，但 for 循环可以。

例如，

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

如果它的工作方式不是很明显，那么这里是该过程的逐步说明：

• 变量dog被创建为dog类型并分配了变量animal
  被投射到 Dog 上。
• 如果分配失败，则dog为空，这会阻止内容
  for 循环停止运行，因为它立即被打破
  的。
• 如果赋值成功，则 for 循环将运行
  迭代。
• 在迭代结束时，dog 变量被赋值为
  null，它会跳出 for 循环。

Answer 19

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

    }

}

Answer 20

我知道我参加聚会的时间太晚了，但我想我应该发布自己的解决方法来解决这个困境，因为我还没有在这里（或任何地方）看到它。

/// <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;
        }
    }
}

有了这个，您可以执行以下操作：

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

重要提示：如果您想通过接口使用 TryAs()，则必须让该接口继承 IAble。

享受！

Answer 21

有一个解决方法，我给你再举一个例子，你有一个返回字符串 Id 的方法，而不是 if 语句：

var userId = GetUserId();

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

你可能需要这样的语法，这是行不通的：

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

但是现在，你可以使用以下命令获得相同的结果： ：

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

在您的示例中，您当然可以这样做：

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

但考虑使用方法很有用

var animal = GetAnimal();

if (animal is Dog)
{
    //logic
}

，最后您可以将其重写为：

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