if语句中的赋值

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

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

对于变量Animal animal;。

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

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

下面的答案是几年前写的，并且随着时间的推移而更新。从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中可能包含此功能。

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

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

那太讨厌了 ……（我已经尝试过了，它确实起作用了。但是请，请不要这样做。哦，您当然可以声明dog使用var。）

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

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

与for循环相比，您还可以使用没有lambda表达式的扩展方法：

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，尽管我很少这样做。但是，这与声明变量不同。这不是非常不寻常的，我做在while读取数据流时，虽然。例如：

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

如今，我通常更喜欢使用可以使用的包装器，foreach (string line in ...)但我将以上内容视为一种惯用的模式。这通常不是很好，有一个条件中的副作用，但替代品通常涉及重复代码，当你知道这种模式很容易得到的权利。

如果as失败，则返回null。

Dog dog = animal as Dog;

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

您可以将值分配给变量，只要该变量已经存在即可。如果有问题，还可以将变量的作用域限定为允许该变量名稍后在同一方法中再次使用。

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

但是，上面使用的变量作用域模式不是特别常见的代码模式，如果我发现在各处使用它，我会寻找一种重构它的方法。

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

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语法只是更通用功能的不错结果。

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

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

在这种情况下可以用作

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

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

*我不知道这是否表现出色。它从来没有成为概要分析的瓶颈。

在这里与谷物背道而驰，但也许您一开始做错了。检查对象的类型几乎总是一种代码味道。在您的示例中，所有动物都没有名字吗？然后，只需调用Animal.name，而无需检查它是否是狗。

或者，反转方法，以便您在Animal上调用一个方法，该方法根据Animal的具体类型而做不同的事情。另请参阅：多态。

简短声明

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

这是一些依赖于修改基类的其他脏代码（尽管不如Jon的脏：)。我认为它抓住了意图，但可能遗漏了要点：

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

如果您必须一个接一个地执行多个诸如此类的假设（并且不能使用多态），请考虑使用SwitchOnType构造。

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

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

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

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

1. 使用dog 外的if会导致编译错误，因为它没有被分配在别处的值。（也就是说，不要dog在其他地方分配。）
2. 这种方法也可以很好地扩展为if/else if/...（as选择一个适当的分支仅需要多少；这是在需要时以这种形式编写的大情况。）
3. 避免重复is/as。（但也可以使用Dog dog = ...表格。）
4. 与“惯用语”没有什么不同。（只是不要被带走：使条件保持一致且简单的形式。）

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

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

快乐的编码。

你可以用这样的东西

//声明变量bool temp = false;

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

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

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
}

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

例如

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

万一它的工作原理不很明显，那么这里是对过程的逐步说明：

• 可变狗被创建为类型dog，并分配了被转换为Dog的可变动物。
• 如果分配失败，则dog为null，这会阻止for循环的内容运行，因为它会立即中断。
• 如果分配成功，则for循环将贯穿
  迭代。
• 在迭代结束时，给dog变量分配了一个null值，该值脱离了for循环。

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

    }

}

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

该总变量将你的if语句前声明。

我刚刚内联了if语句，以创建看起来像您感兴趣的代码行。它只是帮助压缩了一些代码，我发现它更具可读性，尤其是在嵌套分配时：

var dog = animal as Dog; if (dog != null)
{
    Console.WriteLine("Parent Dog Name = " + dog.name);

    var purebred = dog.Puppy as Purebred; if (purebred != null)
    {
         Console.WriteLine("Purebred Puppy Name = " + purebred.Name);
    }

    var mutt = dog.Puppy as Mongrel; if (mutt != null)
    {
         Console.WriteLine("Mongrel Puppy Name = " + mutt.Name);
    }
 }

我知道我晚会很晚，但是我想我会针对这个难题发布自己的解决方法，因为我还没有在这里（或任何地方）看到它。

/// <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的接口。

请享用！🙂