Bir C # lambda ifadesi birden fazla ifadeye sahip olabilir mi?

131

Bir C # lambda ifadesi birden fazla ifade içerebilir mi?

(Düzenleme: Aşağıdaki yanıtların birçoğunda belirtildiği gibi, bu soru başlangıçta "ifadeler" yerine "satırlar" hakkında sorulmuştur.)

c# lambda

— paseena
kaynak

17

Evet, birden çok hat kullanabilirsiniz. Tam bir cevap vermekte kendimi doğru hissetmiyorum.

— Tesserex

1

@Tesserex - bunu bir cevap haline getirmeyen şey ... haklısın!

— RQDQ

3

@RQDQ Evet ya da hayır sorusu olduğu için, olumlu oylardan üreteceği replere layık olduğunu düşünmüyorum.

— Tesserex

195

Elbette:

List<String> items = new List<string>();

var results = items.Where(i => 
            {
                bool result;

                if (i == "THIS")
                    result = true;
                else if (i == "THAT")
                    result = true;
                else
                    result = false;

                return result;
            }
        );

— RQDQ
kaynak

31

(Gerçekten birden çok satır yerine birden çok ifadeden bahsettiğinizi varsayıyorum.)

Küme ayraçları kullanarak bir lambda ifadesinde birden çok ifade kullanabilirsiniz, ancak yalnızca ayraç kullanmayan sözdizimi bir ifade ağacına dönüştürülebilir:

// Valid
Func<int, int> a = x => x + 1;
Func<int, int> b = x => { return x + 1; };        
Expression<Func<int, int>> c = x => x + 1;

// Invalid
Expression<Func<int, int>> d = x => { return x + 1; };

— Jon Skeet
kaynak

1

Func'un neden parantezlere izin verdiğini ve İfadenin izin vermediğini anlamaya çalışıyorum. Her neyse, İfade Func olarak uyumlu olacaktır, İfade Ağacına birden çok satır mantığı eklemenin herhangi bir yolu var mı? Hayır ise, neden kısıtlanıyor?

— Habeeb

8

@Habeeb: "Her neyse İfade Func olarak uyulacaktır" Her zaman değil. Çoğu zaman asla bir temsilciye derlenmez - sadece veri olarak incelenir. .NET 4.0 İfade ağaçlar yoluyla birden ifadeleri kapsayacak şekilde yeteneğini kazandırmak yaptılar Expression.Block ancak C # dili olduğunu desteklememektedir. Olabilir, ancak bu daha fazla tasarım / uygulama / test çalışması gerektirir.

— Jon Skeet

26

Lambda ifadesine istediğiniz kadar yeni satır koyabilirsiniz; C # yeni satırları yok sayar.

Muhtemelen birden çok ifade sormak istediniz .

Birden çok ifade parantez içine alınabilir.

Belgelere bakın .

— SLaks
kaynak

17

C # 'nin satırsonları dahil tüm beyaz boşlukları eşit olarak ele aldığını söylemek daha doğru olmaz mıydı? Yeni satırları yok saydığını söylemek biraz yanıltıcı geliyor - bu onları tamamen çıkarıyormuş gibi gösteriyor ve bir anahtar kelimeyi yeni satıra veya başka bir şeye bölebilirsiniz.

— Tesserex

6

C # 7'den beri:

Tek satırlık açıklama:

int expr(int x, int y) => x + y + 1;

Çok satırlı ifade:

int expr(int x, int y) { int z = 8; return x + y + z + 1; };

bunlar yerel işlevler olarak adlandırılsa da bence bu aşağıdakilerden biraz daha temiz görünüyor ve etkili bir şekilde aynı

Func<int, int, int> a = (x, y) => x + y + 1;

Func<int, int, int> b = (x, y) => { int z = 8; return x + y + z + 1; };

— Büyük şef
kaynak

4

Func<string, bool> test = (name) => 
{
   if (name == "yes") return true;
   else return false;
}

— hükümet şekli
kaynak

5

Func <string, bool> test = name => name == "yes";

— asawyer

3

Polity, golf önerilerini eğlendirici değil, sorunun talep ettiği çok çizgili formatı gösteriyor. Akıllı kodunuzu uygulamak onu "cevap değil" yapar!

— Caius Jard

3

Gönderen Lambda Expressions (C # programlama Kılavuzu) :

Lambda ifadesinin gövdesi herhangi bir sayıda ifadeden oluşabilir; ancak pratikte tipik olarak iki veya üçten fazla yoktur.

— jfs
kaynak

0

C # 7.0 ile bunun gibi de kullanabilirsiniz

Public string ParentMethod(int i, int x){
    int calculation = (i*x);
    (string info, int result) InternalTuppleMethod(param1, param2)
    {
        var sum = (calculation + 5);
        return ("The calculation is", sum);
    }
}

— jigar prajapati
kaynak

0

Diyelim ki bir dersiniz var:

    public class Point
    {
        public int X { get; set; }
        public int Y { get; set; }
    }

Bu sınıfın içindeki C # 7.0 ile bunu küme parantezleri olmadan da yapabilirsiniz:

Action<int, int> action = (x, y) => (_, _) = (X += x, Y += y);

ve

Action<int, int> action = (x, y) => _ = (X += x, Y += y);

şununla aynı olacaktır:

Action<int, int> action = (x, y) => { X += x; Y += y; };

Bu ayrıca, normal bir yöntemi veya yapıcıyı tek bir satıra yazmanız gerektiğinde veya tek bir ifadede birden fazla ifadeye / ifadeye ihtiyaç duyduğunuzda yararlı olabilir:

public void Action(int x, int y) => (_, _) = (X += x, Y += y);

veya

public void Action(int x, int y) => _ = (X += x, Y += y);

veya

public void Action(int x, int y) => (X, Y) = (X + x, Y + y);

Dokümantasyondaki demetlerin yapısökümü hakkında daha fazla bilgi .

— Konard
kaynak