มันสมเหตุสมผลไหมที่จะใช้“ เป็น” แทนที่จะใช้ตัวละครถึงแม้ว่าจะไม่มีการตรวจสอบที่เป็นโมฆะ? [ปิด]

ในบล็อกการพัฒนาตัวอย่างรหัสออนไลน์และ (เมื่อเร็ว ๆ นี้) แม้แต่หนังสือฉันยังคงสะดุดเกี่ยวกับรหัสเช่นนี้:

var y = x as T;
y.SomeMethod();

หรือแย่ยิ่งกว่า:

(x as T).SomeMethod();

นั่นไม่สมเหตุสมผลสำหรับฉัน ถ้าคุณแน่ใจว่าxเป็นประเภทที่คุณควรใช้โยนโดยตรง:T (T)xหากคุณไม่แน่ใจคุณสามารถใช้asแต่จำเป็นต้องตรวจสอบnullก่อนดำเนินการบางอย่าง ทุกสิ่งที่โค้ดข้างต้นไม่สามารถที่จะเปิด (ประโยชน์) InvalidCastExceptionเป็น NullReferenceException(ไม่มีประโยชน์)

ฉันเป็นคนเดียวที่คิดว่านี่เป็นการละเมิดasคำหลักที่โจ่งแจ้งหรือไม่ หรือว่าฉันพลาดบางสิ่งบางอย่างที่ชัดเจนและรูปแบบข้างต้นนั้นสมเหตุสมผล

ความเข้าใจของคุณเป็นเรื่องจริง ฟังดูเหมือนจะพยายามเพิ่มประสิทธิภาพให้ฉัน คุณควรใช้นักแสดงปกติเมื่อคุณแน่ใจในประเภท นอกเหนือจากการสร้างข้อยกเว้นที่สมเหตุสมผลมากขึ้นแล้วมันยังล้มเหลวอย่างรวดเร็ว หากคุณคิดผิดเกี่ยวกับประเภทของโปรแกรมของคุณจะล้มเหลวทันทีและคุณจะสามารถเห็นสาเหตุของความล้มเหลวได้ทันทีแทนที่จะรอสักครู่NullReferenceExceptionหรือArgumentNullExceptionมีข้อผิดพลาดเชิงตรรกะในอนาคต โดยทั่วไปการasแสดงออกที่ไม่ได้ตามมาด้วยการnullตรวจสอบที่ไหนสักแห่งเป็นกลิ่นรหัส

ในทางกลับกันหากคุณไม่แน่ใจเกี่ยวกับนักแสดงและคาดว่าจะล้มเหลวคุณควรใช้asแทนที่จะใช้บล็อกธรรมดาที่มีtry-catchบล็อก นอกจากนี้asแนะนำให้ใช้มากกว่าการตรวจสอบประเภทตามด้วยนักแสดง แทน:

if (x is SomeType)
   ((SomeType)x).SomeMethod();

ซึ่งสร้างisinstคำแนะนำสำหรับisคำหลักและcastclassคำแนะนำสำหรับนักแสดง (ประสิทธิภาพในการส่งนักแสดงสองครั้ง) คุณควรใช้:

var v = x as SomeType;
if (v != null)
    v.SomeMethod();

สิ่งนี้จะสร้างisinstคำสั่งเท่านั้น วิธีการก่อนหน้านี้มีข้อบกพร่องที่อาจเกิดขึ้นในแอพพลิเคชั่นแบบมัลติเธรดเนื่องจากสภาพการแข่งขันอาจทำให้ตัวแปรเปลี่ยนประเภทหลังจากการisตรวจสอบสำเร็จและล้มเหลวที่ไลน์คาสต์ วิธีการหลังไม่น่าจะเกิดข้อผิดพลาดนี้

_{ไม่แนะนำวิธีแก้ไขปัญหาต่อไปนี้เพื่อใช้ในรหัสการผลิต หากคุณเกลียดการสร้างพื้นฐานใน C # จริงๆคุณอาจลองเปลี่ยนมาใช้ VB หรือภาษาอื่น ๆ}

ในกรณีที่ผู้หนึ่งเกลียดไวยากรณ์การร่ายเขาสามารถเขียนวิธีการขยายเพื่อเลียนแบบนักแสดง:

public static T To<T>(this object o) { // Name it as you like: As, Cast, To, ...
    return (T)o;
}

และใช้ไวยากรณ์ [?] ที่เรียบร้อย:

obj.To<SomeType>().SomeMethod()

IMHO asเพียงทำให้รู้สึกเมื่อรวมกับการnullตรวจสอบ:

var y = x as T;
if (y != null)
    y.SomeMethod();

การใช้ 'as' ไม่ได้ใช้การแปลงที่ผู้ใช้กำหนดในขณะที่นักแสดงจะใช้พวกเขาตามความเหมาะสม นั่นอาจเป็นความแตกต่างที่สำคัญในบางกรณี

ฉันเขียนเรื่องนี้เล็กน้อยที่นี่:

http://blogs.msdn.com/ericlippert/archive/2009/10/08/what-s-the-difference-between-as-and-cast-operators.aspx

ฉันเข้าใจประเด็นของคุณ และฉันเห็นด้วยกับแรงผลักดันของมัน: ผู้ดำเนินการนักสื่อสารสื่อสาร "ฉันแน่ใจว่าวัตถุนี้สามารถแปลงเป็นประเภทนั้นและฉันยินดีที่จะเสี่ยงยกเว้นถ้าฉันผิด" ในขณะที่ "เป็น" ผู้ประกอบการสื่อสาร "ฉันไม่แน่ใจว่าวัตถุนี้สามารถแปลงเป็นประเภทนั้นให้ฉันเป็นโมฆะถ้าฉันผิด"

อย่างไรก็ตามมีความแตกต่างเล็กน้อย (x เป็น T). สิ่งใด () สื่อสาร "ฉันรู้ไม่เพียงว่า x สามารถแปลงเป็น T ได้ แต่ยิ่งไปกว่านั้นการทำเช่นนั้นเกี่ยวข้องกับการอ้างอิงหรือการแปลง unboxing เท่านั้นและยิ่งไปกว่านั้น x ไม่ใช่โมฆะ" นั่นเป็นการสื่อสารข้อมูลที่แตกต่างจาก (T) x) .Wh สิ่งที่ () และบางทีนั่นอาจเป็นสิ่งที่ผู้เขียนรหัสตั้งใจ

ฉันมักจะเห็นการอ้างอิงถึงบทความที่ทำให้เข้าใจผิดนี้เป็นหลักฐานว่า "เป็น" เร็วกว่าการคัดเลือก

อีกด้านหนึ่งที่ทำให้เข้าใจผิดที่ชัดเจนมากขึ้นของบทความนี้คือกราฟิกซึ่งไม่ได้ระบุสิ่งที่กำลังถูกวัด: ฉันสงสัยว่ามันเป็นการวัดที่ไม่ได้ปลดเปลื้อง (โดยที่ "เป็น" เห็นได้ชัดว่าเร็วกว่ามาก

หากคุณใช้เวลาในการทำการวัดคุณจะเห็นว่าการคัดเลือกนักแสดงนั้นเร็วกว่า "เป็น" เมื่อนักแสดงประสบความสำเร็จ

ฉันสงสัยว่านี่อาจเป็นเหตุผลหนึ่งในการใช้คำว่า "ขนส่งสินค้าลัทธิ" ของคำหลักแทนการส่ง

การส่งโดยตรงต้องใช้วงเล็บมากกว่าasคำหลัก ดังนั้นแม้ในกรณีที่คุณแน่ใจ 100% ประเภทนี้จะช่วยลดความยุ่งเหยิงภาพ

ตกลงในสิ่งยกเว้นแม้ว่า แต่อย่างน้อยสำหรับฉันการใช้งานส่วนใหญ่ของasต้มลงไปตรวจสอบในnullภายหลังซึ่งฉันพบว่าดีกว่าจับข้อยกเว้น

99% ของเวลาที่ฉันใช้ "as" คือเมื่อฉันไม่แน่ใจว่าเป็นประเภทวัตถุจริง

var x = obj as T;
if(x != null){
 //x was type T!
}

และฉันไม่ต้องการที่จะจับข้อยกเว้นการโยนที่ชัดเจนและทำให้การโยนสองครั้งโดยใช้ "คือ":

//I don't like this
if(obj is T){
  var x = (T)obj; 
}

มันเป็นเพราะคนชอบวิธีที่มันดูมันอ่านง่ายมาก

ให้เผชิญหน้ากับมัน: ตัวดำเนินการหล่อ / การแปลงในภาษา C เหมือนจะแย่มากอ่านง่าย ฉันอยากให้ดีขึ้นถ้า C # ใช้ไวยากรณ์ Javascript ของ:

object o = 1;
int i = int(o);

หรือกำหนดtoผู้ประกอบการเทียบเท่าการหล่อของas:

object o = 1;
int i = o to int;

คนชอบasมากเพราะทำให้พวกเขารู้สึกปลอดภัยจากข้อยกเว้น ... เช่นเดียวกับการรับประกันในกล่อง ผู้ชายคนหนึ่งให้การรับประกันแฟนซีบนกล่องเพราะเขาต้องการให้คุณรู้สึกอบอุ่นและน่าเบื่อภายใน คุณคิดว่าคุณวางกล่องเล็ก ๆ ไว้ใต้หมอนของคุณในเวลากลางคืนนางฟ้าผู้รับประกันอาจลงมาและออกไปหนึ่งในสี่ฉันถูกเท็ดใช่ไหม?

ย้อนกลับไปที่หัวข้อ ... เมื่อใช้การส่งโดยตรงมีความเป็นไปได้สำหรับการยกเว้นการส่งที่ไม่ถูกต้อง ดังนั้นผู้คนจึงนำไปใช้asเป็นโซลูชั่นครอบคลุมความต้องการการหล่อของพวกเขาเพราะas(โดยตัวเอง) จะไม่มีข้อยกเว้น แต่สิ่งที่ตลกเกี่ยวกับสิ่งนั้นคือในตัวอย่างที่คุณให้(x as T).SomeMethod();คุณซื้อขายข้อยกเว้นการส่งแบบไม่ถูกต้องสำหรับข้อยกเว้นการอ้างอิงแบบ null ซึ่งทำให้งงงวยปัญหาที่แท้จริงเมื่อคุณเห็นข้อยกเว้น

โดยทั่วไปฉันไม่ได้ใช้asมากเกินไป ฉันชอบการisทดสอบเพราะสำหรับฉันมันอ่านง่ายขึ้นและดูสมเหตุสมผลแล้วลองใช้ตัวนักแสดงและตรวจสอบค่าว่าง

นี้จะต้องมีหนึ่งของฉันpeeves ด้านบน

Stroustrup ของ D & E และ / หรือบางบล็อกโพสต์ฉันลาดเทพบในขณะนี้กล่าวถึงความคิดของการเป็นtoผู้ประกอบการซึ่งจะอยู่ที่จุดที่ทำโดยhttps://stackoverflow.com/users/73070/johannes-rossel (เช่นเดียวกับไวยากรณ์asแต่มีDirectCastความหมาย )

สาเหตุที่การดำเนินการนี้ไม่ได้เกิดขึ้นเนื่องจากนักแสดงควรทำให้เกิดความเจ็บปวดและน่าเกลียดดังนั้นคุณจึงถูกผลักออกจากการใช้งาน

น่าเสียดายที่โปรแกรมเมอร์ 'ฉลาด' (มักจะเป็นนักเขียนหนังสือ (Juval Lowy IIRC)) ทำสิ่งนี้โดยการใช้asวิธีนี้ (C ++ ไม่มีข้อเสนอasอาจเป็นเพราะเหตุผลนี้)

แม้ VB มีความสอดคล้องมากขึ้นในการมีไวยากรณ์เครื่องแบบที่บังคับให้คุณเลือกTryCastหรือDirectCastและให้ขึ้นใจของคุณ !

ฉันเชื่อว่าasคำหลักอาจถือเป็นรุ่นที่ดูหรูหรากว่า dynamic_castจาก C ++

อาจเป็นที่นิยมมากขึ้นโดยไม่มีเหตุผลทางเทคนิค แต่เป็นเพราะง่ายต่อการอ่านและใช้งานง่ายขึ้น (ไม่ได้บอกว่าทำให้ดีกว่าเพียงแค่พยายามตอบคำถาม)

เหตุผลหนึ่งที่ใช้ "เป็น":

T t = obj as T;
 //some other thread changes obj to another type...
if (t != null) action(t); //still works

แทน (รหัสไม่ดี):

if (obj is T)
{
     //bang, some other thread changes obj to another type...
     action((T)obj); //InvalidCastException
}