วิธีการย้ายความคิดของฉันจาก C ++ ไปยัง C #

ฉันเป็นนักพัฒนา C ++ ที่มีประสบการณ์ฉันรู้ภาษาอย่างละเอียดและใช้คุณสมบัติบางอย่างของมันอย่างเข้มข้น นอกจากนี้ฉันรู้หลักการของ OOD และรูปแบบการออกแบบ ตอนนี้ฉันเรียนรู้ C # แต่ฉันไม่สามารถหยุดความรู้สึกที่ไม่สามารถกำจัดความคิด C ++ ได้ ฉันผูกตัวเองอย่างหนักเพื่อจุดแข็งของ C ++ ที่ฉันไม่สามารถอยู่ได้หากไม่มีคุณสมบัติบางอย่าง และฉันไม่สามารถหาวิธีแก้ปัญหาที่ดีสำหรับพวกเขาได้ใน C #

อะไรแนวปฏิบัติที่ดี , รูปแบบการออกแบบ , สำนวนที่มีความแตกต่างกันใน C # จากมุมมองของ C ++ คุณสามารถแนะนำ? วิธีการได้รับการออกแบบ C ++ ที่สมบูรณ์แบบไม่ได้ดูโง่ใน C #

โดยเฉพาะฉันไม่สามารถหาวิธีที่ดีในการจัดการกับ C # (ตัวอย่างล่าสุด):

• การควบคุมอายุการใช้งานของทรัพยากรที่ต้องมีการล้างข้อมูลที่กำหนด (เช่นไฟล์) นี่เป็นเรื่องง่ายที่มีusingอยู่ในมือ แต่จะใช้งานได้อย่างไรเมื่อมีการถ่ายโอนความเป็นเจ้าของทรัพยากร [... betwen threads]? ใน C ++ ฉันจะใช้พอยน์เตอร์ที่ใช้ร่วมกันและปล่อยให้มันดูแล 'การรวบรวมขยะ' ในเวลาที่เหมาะสม
• การดิ้นรนอย่างต่อเนื่องกับฟังก์ชั่นการเอาชนะสำหรับ generics เฉพาะ (ฉันชอบสิ่งต่าง ๆ เช่นความเชี่ยวชาญเทมเพลตบางส่วนใน C ++) ฉันควรละทิ้งความพยายามในการเขียนโปรแกรมทั่วไปใน C # หรือไม่ บางทียาชื่อสามัญอาจมีข้อ จำกัด ในวัตถุประสงค์และไม่ใช่ C # -ish ที่จะใช้ยกเว้นโดเมนที่ระบุปัญหา
• ฟังก์ชั่นเหมือนมาโคร ในขณะที่โดยทั่วไปเป็นความคิดที่ไม่ดีสำหรับโดเมนของปัญหาบางอย่างไม่มีวิธีแก้ปัญหาอื่น ๆ (เช่นการประเมินเงื่อนไขของคำสั่งเช่นกับบันทึกที่ควรไปที่ Debug release เท่านั้น) การไม่มีพวกมันหมายความว่าฉันต้องใส่if (condition) {...}หม้อไอน้ำมากขึ้นและมันก็ยังไม่เท่ากันในแง่ของการกระตุ้นผลข้างเคียง

จากประสบการณ์ของฉันไม่มีหนังสือให้ทำ ฟอรัมช่วยด้วยสำนวนและแนวทางปฏิบัติที่ดีที่สุด แต่ในที่สุดคุณจะต้องใช้เวลา ฝึกฝนโดยการแก้ปัญหาต่าง ๆ ใน C # ดูสิ่งที่ยาก / อึดอัดใจและพยายามทำให้มันน้อยลงและอึดอัดน้อยลงในครั้งต่อไป สำหรับฉันกระบวนการนี้ใช้เวลาประมาณหนึ่งเดือนก่อนที่ฉันจะ "รับ"

สิ่งที่สำคัญที่สุดคือการขาดการจัดการหน่วยความจำ ใน C ++ เจ้านี่จะตัดสินการออกแบบทุกครั้งที่คุณตัดสินใจ แต่ใน C # มันมีประสิทธิภาพในการตอบโต้ ใน C # คุณมักจะต้องการละเว้นความตายหรือการเปลี่ยนสถานะอื่น ๆ ของวัตถุของคุณ การเรียงลำดับของความสัมพันธ์นั้นเพิ่มการมีเพศสัมพันธ์ที่ไม่จำเป็น

ส่วนใหญ่ให้ความสำคัญกับการใช้เครื่องมือใหม่อย่างมีประสิทธิภาพมากที่สุดโดยไม่กระทบกับสิ่งที่แนบมากับสิ่งเก่า

วิธีการได้รับการออกแบบที่สมบูรณ์แบบ C + + ไม่ดูโง่ใน C #?

โดยสำนึกว่าสำนวนที่แตกต่างผลักดันแนวทางการออกแบบที่แตกต่าง คุณไม่สามารถเทียบบางสิ่งกับ 1: 1 ระหว่างภาษา (ส่วนใหญ่) และคาดหวังว่าสิ่งที่สวยงามและเป็นสำนวนในอีกด้านหนึ่ง

แต่ในการตอบสนองต่อสถานการณ์เฉพาะ:

แชร์ทรัพยากรที่ไม่มีการจัดการ - นี่เป็นแนวคิดที่ไม่ดีใน C ++ และเป็นความคิดที่ไม่ดีใน C # หากคุณมีไฟล์ให้เปิดใช้งานและปิดไฟล์ การแชร์ระหว่างเธรดกำลังถามปัญหาและถ้ามีเพียงหนึ่งเธรดเท่านั้นที่ใช้งานจริงให้เปิดเธรดนั้น / ปิด / เปิด หากคุณจริงๆมีไฟล์อยู่นานด้วยเหตุผลบางอย่างแล้วให้ชั้นเรียนที่จะเป็นตัวแทนที่และให้โปรแกรมจัดการที่ตามความจำเป็น (ใกล้ทางออกก่อนที่จะผูกใกล้กับแอพลิเคชันปิดการเรียงลำดับของเหตุการณ์ที่เกิดขึ้น ฯลฯ )

ความเชี่ยวชาญเทมเพลตบางส่วน - คุณโชคไม่ดีที่นี่ฉันยิ่งใช้ C # ยิ่งฉันพบการใช้เทมเพลตที่ฉันทำใน C ++ เพื่อตกหลุม YAGNI ทำไมต้องทำอะไรบางอย่างที่ทั่วไปเมื่อ T เป็นint เสมอ ? สถานการณ์อื่น ๆ ได้รับการแก้ไขที่ดีที่สุดใน C # โดยการใช้อินเทอร์เฟซแบบเสรี คุณไม่ต้องการข้อมูลทั่วไปเมื่ออินเทอร์เฟซหรือประเภทผู้ได้รับมอบหมายสามารถพิมพ์สิ่งที่คุณต้องการเปลี่ยนแปลงได้อย่างมาก

เงื่อนไข preprocessor - C # มี#ifไปถั่ว ยังดีกว่ามันมีคุณสมบัติตามเงื่อนไขที่จะลดลงฟังก์ชั่นนั้นจากรหัสหากสัญลักษณ์คอมไพเลอร์ไม่ได้กำหนด

เท่าที่ฉันเห็นสิ่งเดียวที่อนุญาตสำหรับการจัดการอายุการใช้งานที่กำหนดขึ้นคือการIDisposableแยกย่อย (เช่น: ไม่มีภาษาหรือระบบสนับสนุนประเภท) เมื่อคุณสังเกตเห็นว่าคุณต้องโอนความเป็นเจ้าของทรัพยากรดังกล่าว

อยู่ในเรือลำเดียวกันกับคุณ - นักพัฒนา C ++ กำลังทำ C # atm - การขาดการสนับสนุนการเป็นเจ้าของแบบจำลองการถ่ายโอน (ไฟล์, การเชื่อมต่อฐานข้อมูล, ... ) ใน C # ประเภท / ลายเซ็นต์เป็นสิ่งที่น่ารำคาญสำหรับฉันมาก แต่ฉันต้องยอมรับว่ามันใช้งานได้ดีกับ "พึ่ง" ตามระเบียบและเอกสาร API เพื่อให้ได้รับสิทธินี้

• ใช้IDisposableในการทำทำความสะอาดกำหนดIFFจำเป็น
• เมื่อคุณต้องการโอนสิทธิ์การเป็นเจ้าของIDisposableให้ตรวจสอบว่า API ที่เกี่ยวข้องนั้นชัดเจนและไม่ได้ใช้usingในกรณีนี้เพราะusingไม่สามารถ "ยกเลิก" เพื่อพูด

ใช่มันไม่หรูหราเท่าที่คุณสามารถแสดงในระบบการพิมพ์ด้วย C ++ ที่ทันสมัย ​​(ย้าย sematics ฯลฯ ) แต่มันทำให้งานเสร็จและ (น่าอัศจรรย์สำหรับฉัน) ชุมชน C # โดยรวมดูเหมือนจะไม่ ดูแลมากเกินไป AFAICT

คุณพูดถึงคุณสมบัติสองอย่างของ C ++ ฉันจะหารือ RAII:

มันมักจะไม่สามารถใช้งานได้เนื่องจาก C # เป็นขยะที่เก็บรวบรวม โครงสร้าง C # ที่ใกล้เคียงที่สุดน่าจะเป็นIDisposableอินเตอร์เฟสที่ใช้ดังนี้:

using (FileStream fs = File.OpenRead(@"c:\path\filename.txt"))
{
   //Do stuff with the file.
} //File will be closed here.

คุณไม่ควรคาดหวังว่าจะนำไปใช้IDisposableบ่อยๆ (และการทำเช่นนั้นจะเป็นขั้นสูงเล็กน้อย) เนื่องจากไม่จำเป็นสำหรับทรัพยากรที่มีการจัดการ อย่างไรก็ตามคุณควรใช้usingโครงสร้าง (หรือเรียกDisposeตัวเองว่าถ้าusingเป็นไปไม่ได้) สำหรับการดำเนินการใดIDisposableๆ แม้ว่าคุณจะทำสิ่งนี้แย่ลงคลาส C # ที่ออกแบบมาอย่างดีจะพยายามจัดการสิ่งนี้ให้คุณ (ใช้ finalizers) อย่างไรก็ตามในภาษาที่รวบรวมขยะรูปแบบ RAII ไม่ทำงานอย่างสมบูรณ์ (เนื่องจากการรวบรวมไม่ได้กำหนดไว้) ดังนั้นการล้างทรัพยากรของคุณจะล่าช้า (บางครั้งก็เกิดความหายนะ)

นี่เป็นคำถามที่ดีมากเพราะฉันเห็นนักพัฒนา C ++ เขียนรหัส C # จำนวนมาก

วิธีที่ดีที่สุดคืออย่าคิดว่า C # เป็น "C ++ ที่มีไวยากรณ์ของ nicer" พวกเขาเป็นภาษาที่แตกต่างกันซึ่งต้องการแนวทางที่แตกต่างในการคิด C ++ บังคับให้คุณต้องคิดอย่างต่อเนื่องเกี่ยวกับสิ่งที่ CPU และหน่วยความจำจะทำ C # ไม่ใช่อย่างนั้น C # ได้รับการออกแบบมาโดยเฉพาะเพื่อให้คุณไม่ได้คิดเกี่ยวกับ CPU และหน่วยความจำและกำลังคิดถึงโดเมนธุรกิจที่คุณกำลังเขียนแทน

ตัวอย่างหนึ่งของสิ่งนี้ที่ฉันได้เห็นคือนักพัฒนา C ++ จำนวนมากจะชอบใช้ลูปเพราะพวกเขาเร็วกว่ารุ่นก่อนหน้า นี่เป็นความคิดที่ไม่ดีใน C # เพราะมันจะ จำกัด ประเภทที่เป็นไปได้ของการรวบรวมซ้ำ (ดังนั้นการใช้งานใหม่และความยืดหยุ่นของรหัส)

ฉันคิดว่าวิธีที่ดีที่สุดในการปรับจาก C ++ ถึง C # คือการลองและเขียนโค้ดจากมุมมองที่ต่างออกไป ในตอนแรกสิ่งนี้จะยากเพราะในช่วงหลายปีที่ผ่านมาคุณจะคุ้นเคยกับการใช้เธรด "CPU และหน่วยความจำทำอะไร" ในสมองของคุณเพื่อกรองรหัสที่คุณเขียน แต่ใน C # คุณควรคิดถึงความสัมพันธ์ระหว่างวัตถุในโดเมนธุรกิจแทน "ฉันต้องการทำอะไร" ตรงข้ามกับ "คอมพิวเตอร์กำลังทำอะไร"

หากคุณต้องการทำบางสิ่งกับทุกสิ่งในรายการออบเจ็กต์แทนที่จะเขียนลูป for for ในรายการให้สร้างเมธอดที่รับIEnumerable<MyObject>และใช้การforeachวนซ้ำ

ตัวอย่างเฉพาะของคุณ:

การควบคุมอายุการใช้งานของทรัพยากรที่ต้องมีการล้างข้อมูลที่กำหนด (เช่นไฟล์) นี่เป็นเรื่องง่ายที่จะมีการใช้งานอยู่ในมือ แต่จะใช้งานได้อย่างถูกต้องเมื่อมีการถ่ายโอนความเป็นเจ้าของทรัพยากร [... betwen threads]? ใน C ++ ฉันจะใช้พอยน์เตอร์ที่ใช้ร่วมกันและปล่อยให้มันดูแล 'การรวบรวมขยะ' ในเวลาที่เหมาะสม

คุณไม่ควรทำสิ่งนี้ใน C # (โดยเฉพาะระหว่างกระทู้) หากคุณต้องการทำบางสิ่งกับไฟล์ให้ทำในที่เดียวในคราวเดียว มันก็โอเค (และเป็นแนวปฏิบัติที่ดี) ในการเขียนคลาส wrapper ซึ่งจัดการทรัพยากรที่ไม่มีการจัดการซึ่งถูกส่งผ่านระหว่างคลาสของคุณ แต่อย่าพยายามส่งไฟล์ระหว่างเธรดและมีคลาสแยกต่างหากเขียน / อ่าน / ปิด / เปิด อย่าแชร์การเป็นเจ้าของทรัพยากรที่ไม่มีการจัดการ ใช้Disposeรูปแบบเพื่อจัดการกับการล้างข้อมูล

การดิ้นรนอย่างต่อเนื่องกับฟังก์ชั่นการเอาชนะสำหรับ generics เฉพาะ (ฉันชอบสิ่งต่าง ๆ เช่นความเชี่ยวชาญเทมเพลตบางส่วนใน C ++) ฉันควรละทิ้งความพยายามในการเขียนโปรแกรมทั่วไปใน C # หรือไม่ บางทียาชื่อสามัญอาจมีข้อ จำกัด ในวัตถุประสงค์และไม่ใช่ C # -ish ที่จะใช้ยกเว้นโดเมนที่ระบุปัญหา

ยาสามัญใน C # ได้รับการออกแบบให้เป็นยาสามัญ ความเชี่ยวชาญของยาชื่อสามัญควรได้รับการจัดการโดยคลาสที่ได้รับ ทำไมควรList<T>ทำงานแตกต่างกันถ้าเป็นList<int>หรือList<string>? ทั้งหมดของการดำเนินงานเกี่ยวกับการList<T>ให้ทั่วไปที่จะนำไปใช้กับการใด ๆ List<T>หากคุณต้องการเปลี่ยนพฤติกรรมของ.Addเมธอดบน a List<string>ให้สร้างคลาสที่ได้รับมาMySpecializedStringCollection : List<string>หรือคลาสที่ประกอบขึ้นMySpecializedStringCollection : IList<string>ซึ่งใช้สามัญภายใน แต่ทำสิ่งต่าง ๆ ในแบบที่ต่างกัน สิ่งนี้จะช่วยให้คุณหลีกเลี่ยงการละเมิดหลักการทดแทน Liskov และทำให้ผู้อื่นที่ใช้คลาสของคุณรู้สึกผิด

ฟังก์ชั่นเหมือนมาโคร ในขณะที่โดยทั่วไปเป็นความคิดที่ไม่ดีสำหรับโดเมนของปัญหาบางอย่างไม่มีวิธีแก้ปัญหาอื่น ๆ (เช่นการประเมินเงื่อนไขของคำสั่งเช่นกับบันทึกที่ควรไปที่ Debug release เท่านั้น) การไม่มีพวกเขาหมายความว่าฉันต้องใส่ให้มากขึ้นถ้า (เงื่อนไข) {... } สำเร็จรูปและยังคงไม่เท่ากันในแง่ของการเรียกผลข้างเคียง

อย่างที่คนอื่นพูดคุณสามารถใช้คำสั่ง preprocessor เพื่อทำสิ่งนี้ คุณสมบัติดียิ่งขึ้น โดยทั่วไปคุณสมบัติเป็นวิธีที่ดีที่สุดในการจัดการสิ่งต่าง ๆ ซึ่งไม่ใช่ฟังก์ชั่น "แกนกลาง" สำหรับชั้นเรียน

กล่าวโดยย่อเมื่อเขียน C # โปรดจำไว้ว่าคุณควรคำนึงถึงโดเมนธุรกิจทั้งหมดโดยไม่คำนึงถึง CPU และหน่วยความจำ คุณสามารถปรับให้เหมาะสมในภายหลังหากจำเป็นแต่รหัสของคุณควรสะท้อนถึงความสัมพันธ์ระหว่างหลักการทางธุรกิจที่คุณพยายามทำแผนที่

สิ่งที่แตกต่างกันมากที่สุดสำหรับผมก็คือแนวโน้มที่จะใหม่ทุกอย่าง หากคุณต้องการวัตถุลืมพยายามส่งผ่านไปยังรูทีนและแชร์ข้อมูลพื้นฐานดูเหมือนว่ารูปแบบ C # เป็นเพียงการสร้างวัตถุใหม่ด้วยตัวคุณเอง โดยทั่วไปดูเหมือนว่าจะเป็นวิธี C # มากกว่านี้ ตอนแรกรูปแบบนี้ดูเหมือนไม่มีประสิทธิภาพมาก แต่ฉันคิดว่าการสร้างวัตถุส่วนใหญ่ใน C # เป็นการดำเนินการที่รวดเร็ว

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

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

คุณจะหยิบมันได้อย่างรวดเร็ว แต่ C # นั้นแทบจะไม่แตกต่างจาก VB ดังนั้นคุณจึงสามารถใช้มันเป็นเครื่องมือ RAD เดียวกับมันได้ (ถ้าช่วยให้คิดถึง C # เช่น VB.NET แล้วให้ทำเช่นนั้นไวยากรณ์ก็เพียงเล็กน้อยเท่านั้น แตกต่างกันและวันเก่า ๆ ของฉันในการใช้ VB ทำให้ฉันมีความคิดที่ถูกต้องสำหรับการพัฒนา RAD) บิตเดียวที่ยากคือการกำหนดว่าคุณควรใช้ไลบรารี. net ขนาดใหญ่แบบใด Google เป็นเพื่อนของคุณที่นี่แน่นอนที่สุด!