คำถามติดแท็ก static-methods

ฉันได้พบว่ามีเพียง 3 วิธีในการทดสอบหน่วยอ้างอิง (จำลอง / ต้นขั้ว) ที่คงที่ใน C # .NET: ไฝ TypeMock JustMock เนื่องจากว่าสองสิ่งนี้ไม่ฟรีและไม่มีการปล่อยรุ่น 1.0 การเยาะเย้ยสิ่งคงไม่ง่ายเกินไป นั่นทำให้วิธีการคงที่และ "ความชั่วร้าย" (ในแง่การทดสอบหน่วย) หรือไม่? และถ้าเป็นเช่นนั้นทำไม resharper จึงต้องการให้ฉันทำอะไรที่คงที่ (การสมมติว่า resharper ไม่ได้เป็น "ความชั่วร้าย" ด้วย) ชี้แจง: ฉันกำลังพูดถึงสถานการณ์เมื่อคุณต้องการทดสอบหน่วยวิธีและวิธีการที่เรียกว่าวิธีการคงที่ในหน่วย / ระดับที่แตกต่างกัน โดยคำจำกัดความส่วนใหญ่ของการทดสอบหน่วยหากคุณเพียงให้วิธีการทดสอบเรียกวิธีการคงที่ในหน่วย / ชั้นเรียนอื่น ๆ แล้วคุณไม่ได้ทดสอบหน่วยคุณกำลังทดสอบบูรณาการ (มีประโยชน์ แต่ไม่ใช่การทดสอบหน่วย)

85 c#  unit-testing  static-methods  mocking 

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

68 object-oriented  class  methods  static-methods  access-modifiers 

UpdateSubject ทั้งสองวิธีด้านล่างแตกต่างกันอย่างไร ฉันรู้สึกว่าการใช้วิธีการคงที่จะดีกว่าถ้าคุณเพียงต้องการที่จะทำงานกับหน่วยงาน ในสถานการณ์ใดที่ฉันควรไปด้วยวิธีการที่ไม่คงที่ public class Subject { public int Id {get; set;} public string Name { get; set; } public static bool UpdateSubject(Subject subject) { //Do something and return result return true; } public bool UpdateSubject() { //Do something on 'this' and return result return true; } } ฉันรู้ว่าฉันจะได้รับความบันเทิงมากมายจากชุมชนสำหรับคำถามที่น่ารำคาญนี้ …

64 object-oriented  static-methods 

เราพยายามออกแบบระบบของเราให้สามารถทดสอบได้และส่วนใหญ่พัฒนาโดยใช้ TDD ขณะนี้เรากำลังพยายามแก้ไขปัญหาต่อไปนี้: ในสถานที่ต่าง ๆ เราจำเป็นต้องใช้วิธีการช่วยเหลือแบบคงที่เช่น ImageIO และ URLEncoder (ทั้ง Java API มาตรฐาน) และห้องสมุดอื่น ๆ อีกมากมายที่ประกอบด้วยวิธีคงที่ส่วนใหญ่ (เช่นไลบรารี Apache Commons) แต่มันยากมากที่จะทดสอบวิธีการเหล่านั้นที่ใช้คลาสตัวช่วยแบบคงที่ ฉันมีความคิดหลายอย่างสำหรับการแก้ปัญหานี้: ใช้เฟรมเวิร์กจำลองที่สามารถจำลองคลาสแบบคงที่ (เช่น PowerMock) นี่อาจเป็นทางออกที่ง่ายที่สุด แต่ก็รู้สึกอยากยอมแพ้ สร้างคลาส wrapper ทันทีที่มีรอบยูทิลิตี้คงที่เหล่านั้นเพื่อให้พวกเขาสามารถฉีดเข้าไปในชั้นเรียนที่ใช้พวกเขา ดูเหมือนว่าจะเป็นคำตอบที่ค่อนข้างสะอาด แต่ฉันกลัวว่าเราจะจบลงด้วยการสร้างคลาส wrapper เหล่านั้น แยกการเรียกคลาสผู้ช่วยแบบคงที่เหล่านี้ลงในฟังก์ชันที่สามารถแทนที่ได้และทดสอบคลาสย่อยของคลาสที่ฉันต้องการทดสอบจริง ๆ แต่ฉันคิดอยู่เสมอว่านี่จะเป็นปัญหาที่หลายคนต้องเผชิญเมื่อทำ TDD - ดังนั้นจะต้องมีวิธีแก้ไขปัญหานี้อยู่แล้ว กลยุทธ์ที่ดีที่สุดในการรักษาคลาสที่ใช้ตัวช่วยคงที่สามารถทดสอบได้คืออะไร

62 java  testing  tdd  static-methods 

ต่อไปนี้เป็นรหัสหลอกฉันลองใน Java และ PHP และทั้งสองทำงาน: class Test { private int a = 5; public static function do_test(){ var t = new Test(); t.a = 1; print t.a // 1 } } Test::do_test(); ทำไมคุณสามารถทำสิ่งนี้ในกระบวนทัศน์ OOP และการใช้งานของมันคืออะไร?

25 object-oriented  language-features  static-methods 

ตกลงฉันได้เรียนรู้ว่าฟังก์ชั่นคงที่คืออะไร แต่ฉันยังไม่เห็นว่าทำไมพวกเขาจึงมีประโยชน์มากกว่าฟังก์ชั่นสมาชิกส่วนตัว นี่อาจเป็นคำถามใหม่ที่นี่ แต่ทำไมไม่แทนที่ฟังก์ชั่นสมาชิกส่วนตัวทั้งหมดด้วยฟังก์ชั่นสแตติกแทน?

24 static-methods 

ฉันมีการสนทนาที่น่าสนใจในวันนี้กับผู้พัฒนารายอื่นเกี่ยวกับวิธีการเข้าเรียนด้วยวิธีการที่ยอมรับสตริงและเอาต์พุตสตริง ลองนึกภาพบางสิ่งเช่นสิ่งต่อไปนี้ซึ่งสร้างขึ้นโดยสมบูรณ์เพื่อเป็นตัวอย่าง public string GetStringPart(string input) { //Some input validation which is removed for clarity if(input.Length > 5) return input.Substring(0,1); if(input.Substring(0,1) == "B") return input.Substring(0,3); return string.empty; } ฟังก์ชั่นที่มีตรรกะบางอย่างตามการป้อนสตริงของมันจะถูกเพิ่มเข้าไปในโครงการโดยใช้ DI และมี DI Container ในสถานที่ คุณจะเพิ่มคลาสใหม่นี้ด้วยอินเทอร์เฟซและฉีดเมื่อจำเป็นหรือคุณจะทำให้คลาสคงที่หรือไม่ ข้อดีและข้อเสียของแต่ละข้อคืออะไร? ทำไมคุณ (หรือไม่) ต้องการที่จะทำให้สิ่งนี้ใช้กับการฉีดคอนสตรัคเตอร์แทนที่จะเข้าถึงเมื่อต้องการได้ทุกที่

21 dependency-injection  static-methods 

ฉันได้รับรหัสฐานซึ่งมีรหัสจำนวนมากที่ไปในลักษณะนี้: SomeDataAdapter sda = new SomeDataAdapter(); sda.UpdateData(DataTable updateData); จากนั้น sda จะไม่ถูกใช้อีกครั้ง เป็นกลิ่นรหัสที่บ่งชี้ว่าวิธีการเหล่านั้นควรเป็นวิธีการเรียนแบบคงที่แทน?

14 code-smell  static-methods 

ในการตอบคำถามนี้ฉันทามติทั่วไปคือว่าวิธีการแบบสแตติกไม่ได้หมายความว่าจะถูกเขียนทับ (และฟังก์ชันแบบคงที่ใน C # ไม่สามารถเสมือนหรือนามธรรม) นี่ไม่ใช่เฉพาะกรณีใน C # เท่านั้น Java ยังห้ามสิ่งนี้และ C ++ ดูเหมือนจะไม่ชอบเช่นกัน อย่างไรก็ตามฉันสามารถนึกถึงตัวอย่างของฟังก์ชั่นคงที่ที่ฉันต้องการแทนที่ในระดับเด็ก (ตัวอย่างเช่นวิธีการจากโรงงาน) ในทางทฤษฎีมีวิธีการรอบพวกเขาไม่มีพวกเขาสะอาดหรือเรียบง่าย ทำไมฟังก์ชั่นคงที่ไม่สามารถเขียนทับได้?

13 object-oriented-design  abstract-class  static-methods 

สองสามเดือนที่ผ่านมาฉันเริ่มทำงานในโครงการใหม่และเมื่อผ่านรหัสมันทำให้ฉันจำนวนคงที่วิธีการแบบคงที่ ไม่เพียง แต่วิธีการใช้งานยูทิลิตี้collectionToCsvString(Collection<E> elements)แต่ยังมีตรรกะทางธุรกิจมากมาย เมื่อผมถามคนที่มีความรับผิดชอบสำหรับเหตุผลที่อยู่เบื้องหลังนี้เขาบอกว่ามันเป็นวิธีการหนีออกจากการปกครองแบบเผด็จการของฤดูใบไม้ผลิ มันมีบางสิ่งที่อยู่รอบกระบวนการคิดนี้: เพื่อใช้วิธีการสร้างการรับลูกค้าเราอาจมีบริการ @Service public class CustomerReceiptCreationService { public CustomerReceipt createReceipt(Object... args) { CustomerReceipt receipt = new CustomerReceipt(); // creation logic return receipt; } } ตอนนี้ผู้ชายคนนั้นบอกว่าเขาไม่ชอบที่จะมีคลาสที่จัดการโดยสปริงโดยไม่จำเป็นเพราะมันมีข้อ จำกัด ว่าคลาสไคลเอนต์จะต้องเป็นสปริงบีนเอง เราจบลงด้วยการจัดการทุกอย่างในฤดูใบไม้ผลิซึ่งบังคับให้เราทำงานกับวัตถุไร้สัญชาติอย่างเป็นขั้นตอน มากหรือน้อยที่ระบุไว้ที่นี่https://www.javacodegeeks.com/2011/02/domain-driven-design-spring-aspectj.html ดังนั้นแทนที่จะเป็นรหัสข้างต้นเขามี public class CustomerReceiptCreator { public static CustomerReceipt createReceipt(Object... args) { CustomerReceipt receipt = new CustomerReceipt(); …

13 java  object-oriented  state  static-methods  static 

ฉันเพิ่งดำเนินการ refactoring ของโครงการขนาดกลางใน Java เพื่อกลับไปและเพิ่มการทดสอบหน่วย เมื่อฉันรู้ว่ามันเจ็บปวดแค่ไหนในการล้อเลียนและสถิตยศาสตร์ในที่สุดฉันก็ "ได้รับ" สิ่งที่ฉันได้อ่านเกี่ยวกับพวกเขาตลอดเวลานี้ (ฉันเป็นหนึ่งในคนเหล่านั้นที่ต้องเรียนรู้จากประสบการณ์โอ้สบายดี) ดังนั้นตอนนี้ที่ฉันใช้ Spring เพื่อสร้างวัตถุและโยงเข้าด้วยกันฉันจะกำจัดstaticคำหลักไปทางซ้ายและขวา (ถ้าฉันอาจต้องการเยาะเย้ยมันก็ไม่คงที่ในความหมายเดียวกับที่ Math.abs () ใช่ไหม?) สิ่งนี้คือฉันได้รับนิสัยการใช้staticเพื่อแสดงว่าวิธีการไม่ได้พึ่งพา ในสถานะวัตถุใด ๆ ตัวอย่างเช่น: //Before import com.thirdparty.ThirdPartyLibrary.Thingy; public class ThirdPartyLibraryWrapper { public static Thingy newThingy(InputType input) { new Thingy.Builder().withInput(input).alwaysFrobnicate().build(); } } //called as... ThirdPartyLibraryWrapper.newThingy(input); //After public class ThirdPartyFactory { public Thingy newThingy(InputType input) { …

11 coding-standards  readability  coding-style  static-methods 

ตัวอย่างเช่นคลาสมักจะมีสมาชิกชั้นเรียนและวิธีการเช่น: public class Cat{ private String name; private int weight; private Image image; public void printInfo(){ System.out.println("Name:"+this.name+",weight:"+this.weight); } public void draw(){ //some draw code which uses this.image } } แต่หลังจากอ่านเกี่ยวกับหลักการความรับผิดชอบเดี่ยวและหลักการเปิดแบบปิดฉันชอบแยกคลาสออกเป็น DTO และคลาสตัวช่วยด้วยวิธีสแตติกเท่านั้นเช่น: public class CatData{ public String name; public int weight; public Image image; } public class CatMethods{ public static …

10 object-oriented  static-methods  dto 

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

10 c#  static-methods 

ทำไมจะมีความได้เปรียบในการใช้วิธีการแบบสแตติกและส่งผ่านการอ้างอิงไปยังวัตถุเป็นพารามิเตอร์แทนที่จะเรียกวิธีการบนวัตถุ เพื่อชี้แจงสิ่งที่ฉันหมายถึงพิจารณาชั้นเรียนต่อไปนี้: public class SomeClass { private double someValue; public SomeClass() { // Some constructor in which someValue is set } public void incrementValue() { someValue++; } } เปรียบเทียบกับการใช้ทางเลือกนี้ด้วยวิธีการคงที่: public class SomeClass { private double someValue; public SomeClass() { // Some constructor in which someValue is set } public static …

9 java  object-oriented  static-methods