İf ifadesinde atama

Bir sınıfım Animalve onun alt sınıfı var Dog. Sık sık kendimi aşağıdaki satırları kodlarken buluyorum:

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

Değişken için Animal animal;.

Böyle bir şey yazmama izin veren bazı sözdizimi var mı:

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

Aşağıdaki cevap yıllar önce yazılmış ve zaman içinde güncellenmiştir. C # 7'den itibaren, desen eşleştirmeyi kullanabilirsiniz:

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

dogİfadeden sonra hala kapsamda olduğunu if, ancak kesinlikle atanmadığını unutmayın.

Hayır, yok. Yine de bunu yazmak daha deyimsel:

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

Hemen hemen her zaman bu şekilde kullanıldığı takdirde, "ardından gelen" ifadesi göz önüne alındığında, her iki parçayı tek seferde gerçekleştiren bir operatör olması daha mantıklı olabilir. Bu şu anda C # 6'da değil, ancak desen eşleştirme teklifi uygulanmışsa C # 7'nin bir parçası olabilir .

Sorun, ¹ ifadesinin koşul bölümünde bir değişkeni bildirememenizdir . Aklıma gelen en yakın yaklaşım şudur:if

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

Bu sadece kötü ... (Sadece denedim ve işe yarıyor. Ama lütfen, lütfen bunu yapma. Oh, ve elbette dogkullanarak beyan edebilirsin var.)

Tabii ki bir uzantı yöntemi yazabilirsiniz:

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

Sonra şununla ara:

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

Alternatif olarak, ikisini birleştirebilirsiniz:

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

Ayrıca, lambda ifadesi olmadan for döngüsüne göre daha temiz bir şekilde bir genişletme yöntemi kullanabilirsiniz:

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

Sonra:

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

¹ Şunları yapabilirsiniz atamak değerler ifNadiren bunu da, ifadeleri. Bu değişkenleri bildirmekle aynı şey değildir. Veri akışlarını okurken bunu yapmak benim için çok sıradışı değil while. Örneğin:

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

Bu günlerde normalde kullanmama izin veren bir sarıcı kullanmayı tercih ediyorum foreach (string line in ...)ama yukarıdakileri oldukça deyimsel bir desen olarak görüyorum. Bu var genellikle bir koşul içinde yan etkileri olması güzel değil ama alternatifleri genellikle kod tekrarını içerir ve bu desen bildiğinde doğru almak kolaydır.

Eğer asbaşarısız döndürür null.

Dog dog = animal as Dog;

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

Sen edebilirsiniz sürece değişken zaten var gibi değişkene değer atamak. Değişkeni, adın daha sonra aynı yöntemde tekrar kullanılmasına izin verecek şekilde de değiştirebilirsiniz, bu bir sorunsa.

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

varsayarak

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

çıktı alır:

Name is now Scopey
Flying

Testteki değişken atama modeli, akışlardaki bayt bloklarını okurken de kullanılır, örneğin:

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

Bununla birlikte, yukarıda kullanılan değişken kapsam paterni özellikle yaygın bir kod kalıbı değildir ve eğer her yerde kullanıldığını görürsem, onu yeniden düzenlemenin bir yolunu ararım.

Böyle bir şey yazmama izin veren bazı sözdizimi var mı:

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

?

Muhtemelen C # 6.0'da olacak. Bu özelliğe "bildirim ifadeleri" denir. Görmek

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

detaylar için.

Önerilen sözdizimi:

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

Daha genel olarak, önerilen özellik, bir yerel değişken bildiriminin bir ifade olarak kullanılabilmesidir . Bu ifsözdizimi, daha genel özelliğin sadece güzel bir sonucudur.

Kendimi sık sık * yazarken ve kullandığımda bulduğum uzantı yöntemlerinden biri

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

Bu durumda hangi kullanılabilir

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

Ve sonra nameköpeğin adı (eğer bir köpekse), aksi takdirde null.

* Bunun performans olup olmadığı hakkında hiçbir fikrim yok. Profil oluşturmada hiçbir zaman bir darboğaz olarak ortaya çıkmadı.

Buradaki tahıllara karşı çıkmak, ama belki de ilk başta yanlış yapıyorsunuz. Bir nesnenin türünü kontrol etmek neredeyse her zaman bir kod kokusudur. Örneğinizdeki tüm Hayvanların bir Adı yok mu? O zaman sadece bir köpek olup olmadığını kontrol etmeden Animal.name'i arayın.

Alternatif olarak, Hayvan üzerinde, Hayvanın beton tipine bağlı olarak farklı bir şey yapan bir yöntem çağırmak için yöntemi ters çevirin. Ayrıca bakınız: Polimorfizm.

Daha Kısa Açıklama

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

İşte bazı ek kirli kod (Jon kadar kirli değil ama :-)) temel sınıf değiştirmeye bağlıdır. Bence belki de amacı kaçırırken amacı yakalar:

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

Birbiri gibi birden çok ifs yapmak zorundaysanız (ve polimorfizm kullanmak bir seçenek değilse), bir SwitchOnType yapısı kullanmayı düşünün .

C # 'daki atama işleci geçerli bir ifade olduğundan, sorun (sözdiziminde) atamayla ilgili değildir . Aksine, beyanlar ifadeler olduğu için istenen beyandadır .

Böyle bir kod yazmanız gerekiyorsa bazen (daha büyük bağlama bağlı olarak) böyle kodu yazacağım:

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

Yukarıdaki sözdizimine (istenen sözdizimine yakın) sahip olan avantajlar vardır, çünkü:

1. Kullanılması dog dışındaif başka bir yerde bir değer atanmamış olarak bir derleme hata ile sonuçlanır. (Yani, yok atamak dogbaşka yerde.)
2. Bu yaklaşım da güzelce genişletilebilir if/else if/...( asUygun bir dal seçmek için sadece gerektiği kadar vardır; bu, gerektiğinde bu formda yazdığım büyük durumdur .)
3. Çoğaltmasını önler is/as. (Ama aynı zamanda Dog dog = ...formla da yapılır .)
4. "Deyimsel süre" den farklı değildir. (Sadece taşınmayın: koşulu tutarlı bir biçimde ve basit tutun.)

dogDünyanın geri kalanından gerçekten izole etmek için yeni bir blok kullanılabilir:

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

Mutlu kodlama.

böyle bir şey kullanabilirsin

// Değişken bildir bool temp = false;

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

Uzantı yöntemleriyle başka bir EVIL çözümü :)

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

Ben şahsen temiz yolu tercih ederim:

Dog dog = animal as Dog;

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

Bir if ifadesi buna izin vermez, ancak bir for döngüsü olacaktır.

Örneğin

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

Çalışma şekli hemen belli değilse, işte sürecin adım adım açıklaması:

• Değişken köpek tip köpek olarak yaratılır ve Köpeğe dökülen değişken hayvan atanır.
• Atama başarısız olursa, köpek null olur, bu da for döngüsünün içeriğinin çalışmasını önler, çünkü hemen ayrılır.
• Atama başarılı olursa, for döngüsü
  yineleme yoluyla çalışır .
• Yinelemenin sonunda, köpek değişkenine for döngüsünden kopan bir null değeri atanır.

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

    }

}

IDK bu herkese yardımcı olursa, ancak değişkeninizi atamak için her zaman bir TryParse kullanmaya çalışabilirsiniz. İşte bir örnek:

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

Toplam değişken senin eğer deyimi önce ilan edilirdi.

Ben sadece ilgilendiğiniz gibi görünüyor bir kod satırı oluşturmak için if deyimi inline var. Sadece bazı kodu sıkıştırmak yardımcı olur ve özellikle atamaları yuvalama sırasında daha okunabilir bulundu:

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

Partiye süper kandırıldığımı biliyorum, ama henüz burada (veya bu konuda herhangi bir yerde) görmediğim için bu ikileme kendi geçici çözümümü yayınlayacağımı düşündüm.

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

Bununla, aşağıdakileri yapabilirsiniz:

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

ÖNEMLİ NOT: Bir Arabirim kullanarak TryAs () kullanmak istiyorsanız, IAble'ı devralan bu arabirime sahip olmalısınız.

Zevk almak! 🙂