คำถามติดแท็ก dependencies

เมื่อออกแบบระบบฉันมักจะประสบกับปัญหาการมีโมดูลจำนวนมาก (การบันทึก, acces ฐานข้อมูล, ฯลฯ ) ถูกใช้โดยโมดูลอื่น ๆ คำถามคือฉันจะไปเกี่ยวกับการให้ส่วนประกอบเหล่านี้กับส่วนประกอบอื่น ๆ ได้อย่างไร คำตอบสองคำตอบที่ดูเหมือนจะเป็นไปได้คือการฉีดขึ้นรูปหรือใช้รูปแบบของโรงงาน อย่างไรก็ตามทั้งคู่ดูเหมือนผิด: โรงงานทำการทดสอบความเจ็บปวดและไม่อนุญาตให้สลับการใช้งานได้ง่าย พวกเขายังไม่ได้อ้างอิงที่ชัดเจน (เช่นคุณกำลังตรวจสอบวิธีการโดยไม่คำนึงถึงความจริงที่ว่ามันเรียกวิธีการที่เรียกวิธีการที่เรียกวิธีการที่ใช้ฐานข้อมูล) การฉีด Dependecy จะสร้างรายการอาร์กิวเมนต์ตัวสร้างอย่างหนาแน่นและทำให้มีบางแง่มุมทั่วโค้ดของคุณ สถานการณ์ทั่วไปคือที่คอนสตรัคเตอร์ของคลาสมากกว่าครึ่งมีลักษณะเช่นนี้(....., LoggingProvider l, DbSessionProvider db, ExceptionFactory d, UserSession sess, Descriptions d) นี่เป็นสถานการณ์ทั่วไปที่ฉันมีปัญหากับ: ฉันมีคลาสยกเว้นซึ่งใช้คำอธิบายข้อผิดพลาดที่โหลดจากฐานข้อมูลโดยใช้แบบสอบถามที่มีพารามิเตอร์ของการตั้งค่าภาษาผู้ใช้ซึ่งอยู่ในวัตถุเซสชันผู้ใช้ ดังนั้นเพื่อสร้างข้อยกเว้นใหม่ฉันต้องการคำอธิบายซึ่งต้องการเซสชันฐานข้อมูลและเซสชันผู้ใช้ ดังนั้นฉันถึงวาระที่จะลากวัตถุเหล่านี้ทั้งหมดในวิธีการทั้งหมดของฉันในกรณีที่ฉันอาจต้องโยนข้อยกเว้น ฉันจะจัดการปัญหาดังกล่าวได้อย่างไร?

81 design  dependency-injection  dependencies 

ทีมของฉันในการสร้างส่วนประกอบที่พันธมิตรของ บริษัท สามารถใช้เพื่อรวมเข้ากับแพลตฟอร์มของเรา ดังนั้นฉันเห็นด้วยที่เราควรใช้ความระมัดระวังเป็นอย่างยิ่งเมื่อแนะนำบุคคลที่สาม (อ้างอิง) ขณะนี้เราไม่มีการพึ่งพาของบุคคลที่สามและเราต้องอยู่ในระดับ API ต่ำสุดของกรอบงาน ตัวอย่างบางส่วน: เราถูกบังคับให้อยู่ในระดับ API ต่ำสุดของกรอบงาน (. NET Standard) เหตุผลเบื้องหลังสิ่งนี้คือว่าแพลตฟอร์มใหม่อาจมาถึงวันหนึ่งที่รองรับเฉพาะระดับ API ที่ต่ำมากเท่านั้น เราได้ดำเนินการส่วนประกอบของเราเองสำหรับ (de) การทำให้เป็นอันดับ JSON และอยู่ในกระบวนการของการทำเช่นเดียวกันสำหรับ JWT สิ่งนี้มีอยู่ในเฟรมเวิร์ก API ที่สูงขึ้น เราได้นำ wrapper ไปใช้กับเฟรมเวิร์ก HTTP ของไลบรารี่มาตรฐานเพราะเราไม่ต้องการพึ่งพาการใช้ HTTP ของไลบรารี่มาตรฐาน รหัสทั้งหมดสำหรับการจับคู่กับ / จาก XML ถูกเขียน "ด้วยมือ" อีกครั้งด้วยเหตุผลเดียวกัน ฉันรู้สึกว่าเรากำลังจะไปไกลเกินไป ฉันสงสัยว่าจะจัดการกับเรื่องนี้อย่างไรตั้งแต่นี้ฉันคิดว่าสิ่งนี้มีผลกระทบอย่างมากต่อความเร็วของเรา

54 architecture  .net  dependencies  third-party-libraries  code-ownership 

เรามีสองวิกฤตที่เกี่ยวข้องกับการพึ่งพาที่สำคัญสองฐานรหัสที่แตกต่างกัน (Android และเว็บแอป Node.js) repo Android จำเป็นต้องโยกย้ายจาก Flurry ไปยัง Firebase ซึ่งจำเป็นต้องอัปเดตห้องสมุด Google Play Services สี่เวอร์ชันหลัก มีสิ่งที่คล้ายกันเกิดขึ้นกับแอปโหนดที่โฮสต์โดย Heroku ซึ่งสแตกการผลิต (ซีดาร์) ของเราถูกเลิกใช้และจำเป็นต้องได้รับการอัพเกรดเป็นซีดาร์ -14 ฐานข้อมูล PostgreSQL ของเรายังต้องมีการอัพเดทจาก 9.2 เป็น 9.6 แต่ละแอพพลิเคชั่นของแอพเหล่านี้นั่งค้างได้เกือบสองปีและเมื่อแอพบางตัวเลิกใช้งานและเราถึงช่วงเวลา 'พระอาทิตย์ตก' มันเป็นอาการปวดหัวที่สำคัญในการอัปเดตหรือแทนที่ ฉันใช้เวลากว่า 30 ชั่วโมงในช่วงหนึ่งเดือนที่ผ่านมาหรือสองชั่วโมงค่อย ๆ แก้ไขข้อขัดแย้งและรหัสที่เสียหายทั้งหมด เห็นได้ชัดว่าการปล่อยให้สิ่งต่าง ๆ นั่งเป็นเวลาสองปีนั้นยาวนานเกินไป เทคโนโลยีดำเนินไปอย่างรวดเร็วโดยเฉพาะเมื่อคุณใช้ผู้ให้บริการแพลตฟอร์มอย่าง Heroku สมมติว่าเรามีชุดทดสอบเต็มรูปแบบและกระบวนการ CI เช่น Travis CI ซึ่งใช้การคาดเดามากมายในการอัปเดต เช่นถ้าฟังก์ชั่นถูกลบออกหลังจากการอัพเกรดและคุณใช้มันการทดสอบของคุณจะล้มเหลว ควรอัปเดตการอ้างอิงบ่อยเพียงใดหรือควรอัปเดตการอ้างอิงเมื่อใด เราอัปเดตเพราะเราถูกบังคับ แต่ดูเหมือนว่าวิธีการจองล่วงหน้าบางประเภทจะดีกว่า …

30 dependencies  dependency-management 

ในช่วงหลายปีที่ผ่านการใช้ C # /. NET สำหรับโครงการภายในองค์กรเรามีห้องสมุดหนึ่งแห่งที่เติบโตขึ้นอย่างเป็นองค์กร มันถูกเรียกว่า "Util" และฉันแน่ใจว่าพวกคุณหลายคนเคยเห็นสัตว์ร้ายตัวนี้ในอาชีพของคุณ หลายส่วนของไลบรารีนี้เป็นแบบสแตนด์อโลนและสามารถแบ่งออกเป็นโครงการแยกต่างหาก (ซึ่งเราต้องการเปิดแหล่งที่มา) แต่มีปัญหาสำคัญอย่างหนึ่งที่ต้องแก้ไขก่อนที่สิ่งเหล่านี้จะถูกปล่อยเป็นห้องสมุดแยกต่างหาก โดยทั่วไปมีหลายกรณีที่ฉันอาจเรียกว่า"การพึ่งพาเพิ่มเติม"ระหว่างไลบรารีเหล่านี้ เพื่ออธิบายสิ่งนี้ให้ดีขึ้นพิจารณาบางส่วนของโมดูลที่เป็นตัวเลือกที่ดีในการเป็นห้องสมุดแบบสแตนด์อะโลน CommandLineParserใช้สำหรับการแยกบรรทัดคำสั่ง XmlClassifyใช้สำหรับการทำให้คลาสเป็นอนุกรมเป็น XML PostBuildCheckทำการตรวจสอบในแอสเซมบลีที่คอมไพล์แล้วและรายงานข้อผิดพลาดการคอมไพล์ถ้าพวกเขาล้มเหลว ConsoleColoredStringเป็นห้องสมุดสำหรับตัวอักษรสตริงสี Lingoสำหรับแปลอินเทอร์เฟซผู้ใช้ แต่ละไลบรารีเหล่านี้สามารถใช้งานแบบสแตนด์อโลนได้อย่างสมบูรณ์ แต่หากใช้ร่วมกันจะมีคุณสมบัติพิเศษที่มีประโยชน์ ยกตัวอย่างเช่นทั้งสองCommandLineParserและเปิดเผยการทำงานตรวจสอบการโพสต์การสร้างที่ต้องใช้XmlClassify PostBuildCheckในทำนองเดียวกันCommandLineParserช่วยให้เอกสารตัวเลือกที่จะให้ใช้ตัวอักษรของสตริงสีที่กำหนดและสนับสนุนเอกสารแปลผ่านทางConsoleColoredStringLingo ดังนั้นความแตกต่างที่สำคัญคือว่าเหล่านี้เป็นคุณสมบัติเสริม หนึ่งสามารถใช้ตัวแยกวิเคราะห์บรรทัดคำสั่งกับสตริงธรรมดาไม่มีสีโดยไม่ต้องแปลเอกสารหรือดำเนินการตรวจสอบหลังการสร้างใด ๆ หรืออาจทำให้เอกสารแปลได้ แต่ยังคงไม่มีสี หรือทั้งสีและแปลได้ เป็นต้น เมื่อมองผ่านห้องสมุด "Util" นี้ฉันเห็นว่าห้องสมุดที่อาจแยกได้เกือบทั้งหมดมีคุณสมบัติที่เป็นทางเลือกเช่นนี้ซึ่งผูกไว้กับไลบรารีอื่น ๆ ถ้าฉันต้องการห้องสมุดเหล่านั้นจริงๆแล้วการพึ่งพาสิ่งต่าง ๆ นี้ไม่ได้ถูกยกเลิกการผูกมัดจริงๆ: คุณยังคงต้องการไลบรารีทั้งหมดถ้าคุณต้องการใช้เพียงอันเดียว มีวิธีการที่จัดตั้งขึ้นเพื่อจัดการการพึ่งพาทางเลือกเช่นใน.

26 .net  dependencies  modules 

ฉันมีคำถามที่คล้ายกันนี้แต่ไม่เหมือนกัน ฉันต้องการให้ผู้ใช้แอปของฉันติดตั้งด้วยการอ้างอิงอะไรก็ตามที่จำเป็นสำหรับวิธีที่เขาต้องการใช้ ตัวอย่างเช่นหากพวกเขาต้องการคงอยู่กับ MongoDB จะมีการติดตั้งเฉพาะไลบรารีที่เกี่ยวกับ Mongo เท่านั้น แต่หากพวกเขาต้องการที่จะคงอยู่กับ Redis จะมีการติดตั้งเฉพาะไลบรารีที่เกี่ยวข้องกับ Redis เท่านั้น ฉันไม่ต้องการให้พวกเขาดาวน์โหลดและติดตั้งห้องสมุดที่พวกเขาจะไม่ใช้ ฉันรู้ว่าฉันสามารถทำได้เพื่อจุดประสงค์ในการพัฒนาdevDependenciesแต่สิ่งนี้ยิ่งไปกว่านั้น ดังที่คำตอบในคำถามข้างต้นกล่าวว่านี่เกี่ยวข้องกับโปรไฟล์setuptools extras_requireของPython และ Clojure leiningenมากขึ้น มีอะไรแบบนั้นในเวลา 23.00 น. ฉันรู้สึกว่าdevDependenciesควรเป็นdevโปรไฟล์ของวิธีที่หลากหลายในการระบุการพึ่งพา

23 node.js  dependencies 

เมื่อมีคนเขียนโปรเจ็กต์โอเพนซอร์ซและใช้ Google Code หรือ GitHub และต้องการใช้ไลบรารี่อย่าง Lua ควรทำอย่างไร ควรพึ่งพารวมอยู่ในที่เก็บ? ควรพึ่งพาสร้างจากภายในสคริปต์สร้างเดียวกันกับส่วนที่เหลือของโครงการหรือจากสคริปต์สร้างแยกต่างหาก ระบุว่าไลบรารีไม่จำเป็นต้องติดตั้งก่อนการรวบรวม

23 open-source  version-control  dependencies 

ฉันกำลังมองหาคำตอบใน SO หรือที่นี่ แต่ไม่มีผลลัพธ์ใด ๆ นั่นคือเหตุผลที่ฉันจะถามคุณ สมมติว่าฉันมีสองโครงการที่แตกต่างกัน - ตัวอย่างเช่นส่วนของเซิร์ฟเวอร์และส่วนลูกค้าของแอพ ฉันกำลังพัฒนาส่วนของตัวเองในขณะที่เพื่อนของฉันกำลังสร้างส่วนที่สอง แต่ทั้งสองของเราควรจะใช้อินเตอร์เฟซบางอย่างร่วมกันเช่นUserหรือAccountInfoหรือChangableAccount... สิ่งเพื่อให้แน่ใจว่าการทำงานร่วมกัน ตัวอย่างเช่นหากลูกค้าส่งข้อมูลผู้ใช้ไปยังเซิร์ฟเวอร์เซิร์ฟเวอร์ควรทำงานในคลาสเดียวกัน เหมือนกับอินเทอร์เฟซและอื่น ๆ นอกจากนี้หากมีการเปลี่ยนแปลงใด ๆ ในอินเทอร์เฟซทั่วไปโครงการทั้งสองควรปรับรหัสให้เป็นสถานการณ์ใหม่ ทางออกเดียวที่ฉันเห็นในตอนนี้คือการสร้างโครงการพิเศษหนึ่งโครงการซึ่งกำหนดสิ่งทั่วไปทั้งหมดไว้ เราฉันและเพื่อนของฉันควรเพิ่มโครงการนี้เป็นการอ้างอิงไปยังโครงการหลัก (ไคลเอนต์หรือเซิร์ฟเวอร์) โครงการที่ใช้ร่วมกันสามารถจัดการได้โดยระบบควบคุมเวอร์ชันบางระบบดังนั้นเราจึงมีสถานะที่ทันสมัยที่สุดเสมอ คุณจะแนะนำโซลูชันอื่นใดอีก ปัญหาดังกล่าวได้รับการแก้ไขอย่างไรในแอพมืออาชีพ

17 java  dependencies  integration  dependency-management 

ฉันได้เขียนกรอบ PHP และ CMS ที่ด้านบนของกรอบ CMS นั้นขึ้นอยู่กับเฟรมเวิร์ก แต่มีเฟรมเวิร์กเป็นโฟลเดอร์ที่มีในตัวเองภายในไฟล์ CMS ฉันต้องการรักษาพวกเขาเป็นโครงการแยกต่างหากใน GitHub แต่ฉันไม่ต้องการยุ่งกับการปรับปรุงโครงการ CMS ทุกครั้งที่ฉันปรับปรุงกรอบ โดยหลักการแล้วฉันต้องการให้ CMS ดึงไฟล์เฟรมเวิร์กเพื่อรวมไว้ในไดเรกทอรีย่อยที่กำหนดไว้ล่วงหน้าแทนที่จะทำการคอมไฟล์เหล่านั้น เป็นไปได้ด้วย Git / GitHub? ถ้าเป็นเช่นนั้นฉันต้องรู้อะไรบ้างเพื่อให้ใช้งานได้ โปรดจำไว้ว่าฉันมีประสบการณ์ขั้นพื้นฐานมาก ๆ กับ Git - ฉันสามารถสร้างที่เก็บและคอมมิชชันโดยใช้ปลั๊กอิน Git สำหรับ Eclipse เชื่อมต่อกับ GitHub และนั่นเป็นเรื่องเกี่ยวกับมัน ฉันกำลังทำงานเดี่ยวในโครงการดังนั้นฉันไม่ต้องเรียนรู้มากขึ้นเกี่ยวกับ Git แต่ฉันต้องการเปิดให้ผู้อื่นได้เห็นในอนาคตและฉันต้องการให้แน่ใจว่าฉันทำถูกต้อง นอกจากนี้เวิร์กโฟลว์ในอุดมคติของฉันควรเป็นอย่างไรสำหรับโครงการที่มีการพึ่งพา คำแนะนำใด ๆ เกี่ยวกับเรื่องนั้นก็จะชื่นชมอย่างมาก หากคุณต้องการข้อมูลเพิ่มเติมเกี่ยวกับการตั้งค่าของฉันเพียงแค่ถามในความคิดเห็น

14 php  git  github  dependencies 

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

12 architecture  dependencies  layers 

เมื่อวานนี้ฉันกำลังทำงานกับโครงการ Rails 5 API ซึ่งใช้ห้องสมุดทำหน้าที่เป็นแท็กableบนอนุญาตให้สิ่งต่าง ๆ มีแท็ก (เช่นคำถามใน SE) Rails 5 รองรับการใช้งานในตอนนี้ ขณะนี้มี PR เพื่อแก้ไขข้อผิดพลาดที่รอการรวมเข้ากับต้นแบบ ข้อผิดพลาดทำให้สาขาคุณลักษณะของฉันหยุดชะงักไปครึ่งทางจนเสร็จ - ฉันไม่สามารถใช้งานฟังก์ชั่นใด ๆ ของห้องสมุดได้เนื่องจากการโหลดไม่สมบูรณ์ เป็นการแก้ไขด่วนฉันเพียงโคลน repo แก้ไขปัญหาด้วยรหัสเดียวกันกับที่ PR มีและชี้ Gemfile ของฉัน (ไฟล์อ้างอิงเวอร์ชันการควบคุม) ไปยัง Github fork ของฉันเองจนกว่าข้อผิดพลาดจะรวมกันกลับเป็นหลัก ฉันโชคดีที่การแก้ไขนั้นง่าย ( และมีคนทำไปแล้ว ) ดังนั้นฉันจึงสามารถแก้ไขปัญหาได้ แต่ถ้าห้องสมุดนี้มีความสำคัญต่อการพัฒนาแอปพลิเคชันของฉัน จะเกิดอะไรขึ้นถ้าการแก้ไขข้อผิดพลาดที่หยุดการพัฒนาของฉันไม่ใช่ปัญหาที่แพร่หลายสำหรับคนอื่นดังนั้นการแก้ไขจึงไม่เกิดขึ้นอย่างรวดเร็วเหมือนครั้งนี้ ลองนึกภาพว่าคุณสมบัตินี้จำเป็นต้องทำให้เสร็จก่อนที่จะพัฒนาคุณสมบัติที่ต้องพึ่งพาอื่น ๆ - คุณทำอะไรในสถานการณ์นั้น จะเกิดอะไรขึ้นถ้าสำหรับฉันการติดแท็กนั้นมีความสำคัญอย่างยิ่งต่อวลีถัดไปของการพัฒนาซึ่งทุกอย่างจะขึ้นอยู่กับมัน - แต่การพึ่งพาการติดแท็กนั้นมีข้อบกพร่อง เราจะทำอย่างไรเมื่อการทำงานที่สำคัญของการพึ่งพาเป็นอุปสรรคต่อการพัฒนาคุณสมบัติ (a) และแน่นอนว่าการฟันดาบบนเก้าอี้สำนักงานหลายชั่วโมงหรือหลายวันก็ไม่ใช่ทางเลือก ...

12 project-management  dependencies  time-management 

เรากำลังทำโครงการ แต่เราใช้รหัสจำนวนมากระหว่างโครงการและมีห้องสมุดจำนวนมากที่มีรหัสทั่วไปของเรา ในขณะที่เราใช้งานโครงการใหม่เราค้นหาวิธีเพิ่มเติมในการแยกตัวประกอบของรหัสทั่วไปและใส่ลงในไลบรารี ห้องสมุดขึ้นอยู่กับแต่ละอื่น ๆ และโครงการขึ้นอยู่กับห้องสมุด แต่ละโปรเจ็กต์และไลบรารีทั้งหมดที่ใช้ในโปรเจ็กต์นั้นจำเป็นต้องใช้เวอร์ชันเดียวกันกับไลบรารีทั้งหมดที่อ้างถึง ถ้าเราปล่อยชิ้นส่วนของซอฟต์แวร์เราจะต้องแก้ไขข้อบกพร่องและอาจเพิ่มคุณสมบัติใหม่เป็นเวลาหลายปีบางครั้งก็เป็นเวลาหลายทศวรรษ เรามีห้องสมุดประมาณหนึ่งโหลการเปลี่ยนแปลงมักจะถูกตัดข้ามมากกว่าสองรายการและหลายทีมทำงานในหลายโครงการพร้อมกันโดยทำการเปลี่ยนแปลงพร้อมกันกับไลบรารีทั้งหมดเหล่านี้ เมื่อเร็ว ๆ นี้เราได้เปลี่ยนเป็นคอมไพล์และตั้งค่าที่เก็บสำหรับแต่ละไลบรารีและแต่ละโครงการ เราใช้ที่เก็บของเป็นที่เก็บข้อมูลทั่วไปทำสิ่งใหม่ ๆ ในฟีเจอร์สาขาจากนั้นทำการร้องขอการดึงและรวมเข้าด้วยกันหลังจากตรวจสอบแล้ว ปัญหาหลายอย่างที่เราต้องจัดการในโครงการต้องการให้เราทำการเปลี่ยนแปลงในหลาย ๆ ไลบรารีและรหัสเฉพาะของโครงการ สิ่งเหล่านี้มักจะรวมถึงการเปลี่ยนแปลงอินเทอร์เฟซของไลบรารีซึ่งบางอย่างไม่เข้ากัน (ถ้าคุณคิดว่ามันฟังดูแปลก ๆ : เราเชื่อมต่อกับฮาร์ดแวร์และซ่อนฮาร์ดแวร์ที่เฉพาะเจาะจงไว้ข้างหลังอินเตอร์เฟสทั่วไปเกือบทุกครั้งที่เรารวมฮาร์ดแวร์ของผู้ขายรายอื่นที่เราพบในกรณีที่อินเทอร์เฟซปัจจุบันของเราไม่ได้คาดหวัง ตัวอย่างเช่นสมมติว่าโครงการที่P1ใช้ห้องสมุดL1, และL2 ยังใช้และ, และใช้เช่นกัน กราฟการพึ่งพามีลักษณะดังนี้:L3L1L2L3L2L3 <-------L1<--+ P1 <----+ ^ | <-+ | | | | +--L2 | | ^ | | | | +-----L3---+ ตอนนี้คิดคุณลักษณะสำหรับโครงการนี้ต้องมีการเปลี่ยนแปลงในP1และที่เปลี่ยนอินเตอร์เฟซของL3 L3ตอนนี้เพิ่มโปรเจ็กต์P2และP3ลงในแบบผสมซึ่งยังอ้างถึงไลบรารีเหล่านี้ เราไม่สามารถเปลี่ยนทุกสิ่งให้เป็นอินเทอร์เฟซใหม่ทำการทดสอบทั้งหมดและปรับใช้ซอฟต์แวร์ใหม่ …

11 git  branching  dependencies  scm  tagging 

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

10 java  patterns-and-practices  versioning  project-structure  dependencies 

ฉันมีชั้นเรียนที่มีวิธีการสาธารณะหนึ่งวิธีSend()และวิธีส่วนตัวสองสามวิธี มันเรียกสองเว็บเซอร์และประมวลผล reponse การประมวลผลจะทำในวิธีการส่วนตัว ฉันต้องการหน่วยทดสอบรหัส ความเข้าใจของฉันคือการทดสอบหน่วยควรทดสอบรหัสของฉันแยก (เช่นจำลองคำตอบของซัพพลายเออร์) ฉันยังเชื่อว่าวิธีการส่วนตัวไม่ควรต้องผ่านการทดสอบหน่วยแต่ถ้าฉันเพิ่งทดสอบเมธอด Send () โค้ดของฉันไม่ได้รับการทดสอบแยกและขึ้นอยู่กับผู้จัดหา resonse ฉันควรทำให้วิธีการส่วนตัวของฉันเป็นแบบสาธารณะหรือไม่เพื่อให้ฉันสามารถทดสอบพวกเขาด้วยคำตอบที่จำลองได้ ดูเหมือนว่าเป็นการปฏิบัติที่ไม่ถูกต้องเนื่องจากฉันมีเพียงห้องเรียนเท่านั้นที่ต้องเรียกพวกเขา ขออภัยถ้าเป็นคำถามพื้นฐานฉันค่อนข้างใหม่สำหรับการทดสอบหน่วย ฉันใช้ c # และ VS2010

10 unit-testing  dependencies