ภาพควรจะสามารถปรับขนาดตัวเองใน OOP หรือไม่?

ฉันกำลังเขียนแอพที่จะมีImageเอนทิตีและฉันมีปัญหาในการตัดสินใจว่าควรรับผิดชอบงานใด

ก่อนอื่นฉันมีImageชั้นเรียน มันมีเส้นทางความกว้างและคุณลักษณะอื่น ๆ

แล้วฉันจะสร้างชั้นสำหรับการดึงภาพด้วยวิธีการเดียวและการทดสอบเช่น:ImageRepositoryfindAllImagesWithoutThumbnail()

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

หรืออาจจะเป็น 0K เพื่อให้การImageปรับขนาดตัวเอง หรือปล่อยให้ImageRepositoryและImageManagerเป็นชั้นเดียวกันได้หรือไม่

คุณคิดอย่างไร?

คำถามที่ถามนั้นคลุมเครือเกินไปที่จะมีคำตอบจริง ๆ เพราะขึ้นอยู่กับว่าจะใช้Imageวัตถุอย่างไร

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

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

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

อีกทางเลือกหนึ่งคือการมีImageชั้นเดียวที่ยังคงภาพฐานและมีชั้นที่มีตัวแทนอย่างน้อยหนึ่ง Imageตัวเองจะได้ไม่ต้องมีความสูง / ความกว้าง มันจะเริ่มจากอันImageRepresentationที่มีความสูงและความกว้างแทน คุณวาดการเป็นตัวแทนนี้ หากต้องการ "ปรับขนาด" รูปภาพคุณจะต้องขอการImageเป็นตัวแทนด้วยการวัดความสูง / ความกว้าง นี่จะทำให้มันมีการเป็นตัวแทนใหม่นี้เช่นเดียวกับต้นฉบับ สิ่งนี้ช่วยให้คุณสามารถควบคุมสิ่งที่แขวนอยู่ในหน่วยความจำได้อย่างมากโดยมีความซับซ้อนเป็นพิเศษ

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

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

class Image
{
    public Image createThumbnail(int sizeX, int sizeY)
    {
         // ...
         // later delegate the actual resize operation to a separate component
    }
}

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

จริงๆแล้วฉันจะเริ่มต้นด้วยวิธีแรกและ refactor ในภายหลังเมื่อฉันต้องการมันจริงๆ

ฉันคิดว่ามันจะต้องเป็นส่วนหนึ่งของImageชั้นเรียนเนื่องจากการปรับขนาดในชั้นเรียนภายนอกจะต้องใช้ตัวปรับขนาดเพื่อให้ทราบการใช้งานของImageซึ่งจะเป็นการละเมิด encapsulation ฉันสมมติว่าImageเป็นคลาสพื้นฐานและคุณจะจบลงด้วยคลาสย่อยแยกต่างหากสำหรับประเภทภาพคอนกรีต (PNG, JPEG, SVG และอื่น ๆ ) ดังนั้นคุณจะต้องมีคลาสการปรับขนาดที่สอดคล้องกันหรือ resizer ทั่วไปที่มีswitchคำสั่งที่ปรับขนาดตามคลาสการใช้งาน - กลิ่นการออกแบบคลาสสิก

วิธีการหนึ่งอาจจะทำให้คอนImageสตรัคเตอร์ของคุณใช้ทรัพยากรที่มีรูปภาพและพารามิเตอร์ความสูงและความกว้างและสร้างตัวเองอย่างเหมาะสม จากนั้นการปรับขนาดอาจทำได้ง่ายเพียงแค่สร้างวัตถุใหม่โดยใช้ทรัพยากรดั้งเดิม (แคชภายในรูปภาพ) และพารามิเตอร์ขนาดใหม่ เช่นจะเพียงแค่foo.createThumbnail() return new Image(this.source, 250, 250)(กับImageการเป็นชนิดที่เป็นรูปธรรมของfooของหลักสูตร) สิ่งนี้จะทำให้ภาพของคุณไม่เปลี่ยนรูปและการใช้งานเป็นส่วนตัว

ฉันรู้ว่า OOP เกี่ยวกับการห่อหุ้มข้อมูลและพฤติกรรมด้วยกัน แต่ฉันไม่คิดว่ามันเป็นความคิดที่ดีที่รูปภาพจะมีตรรกะการปรับขนาดที่ฝังอยู่ในกรณีนี้เนื่องจากรูปภาพไม่จำเป็นต้องรู้วิธีปรับขนาดตัวเองให้เป็น รูปภาพ

รูปขนาดย่อเป็นรูปอื่น บางทีคุณอาจมีโครงสร้างข้อมูลที่เก็บความสัมพันธ์ระหว่างรูปถ่ายกับรูปขนาดย่อ (ทั้งคู่เป็นรูป)

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

ดังนั้นไม่รูปภาพไม่ควรมีตรรกะเกี่ยวกับวิธีการสร้างภาพขนาดย่อ ควรมีบริการ ThumbnailGenerator ที่มีวิธีการดังนี้:

Image GenerateThumbnailFrom(Image someImage);

โครงสร้างข้อมูลที่ใหญ่ขึ้นของฉันอาจมีลักษณะเช่นนี้:

class Photograph : Image
{
    public Photograph(Image thumbnail)
    {
        if(thumbnail == null) throw new ArgumentNullException("thumbnail");
        this.Thumbnail = thumbnail;
    }

    public Image Thumbnail { get; private set; }
}

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

class Photograph : Image
{
    private Image thumbnail = null;
    private readonly Func<Image,Image> generateThumbnail;

    public Photograph(Func<Image,Image> generateThumbnail)
    {
        this.generateThumbnail = generateThumbnail;
    }


    public Image Thumbnail
    {
        get
        {
            if(this.thumbnail == null)
            {
                this.thumbnail = this.generateThumbnail(this);
            }
            return this.thumbnail;
        }
    }
}

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

อย่างที่คุณเห็นคลาสอย่างใดอย่างหนึ่งเหล่านี้กำลังถูกสร้างขึ้นโดย PhotographRepository บางชนิดซึ่งอาจมีการอ้างอิงถึง ThumbnailGenerator ที่ผ่านการฉีดพึ่งพา

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

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

ฉันถือว่าข้อเท็จจริงเกี่ยวกับวิธีการที่ปรับขนาดภาพ:

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

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

คลาส Image Processing อาจเหมาะสม (หรือ Image Manager ตามที่คุณเรียกว่า) ส่งรูปภาพของคุณไปยังเมธอด CreateThumbnail ของ Image Processor เช่นเพื่อดึงรูปภาพขนาดย่อ

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

โดยพื้นฐานแล้ว Doc Brown ได้พูดไปแล้ว:

สร้างgetAsThumbnail()วิธีการสำหรับคลาสรูปภาพ แต่วิธีนี้ควรเพียงมอบหมายงานให้กับImageUtilsคลาส ดังนั้นมันจะมีลักษณะดังนี้:

 class Image{
   // ...
   public Thumbnail getAsThumbnail{
     return ImageUtils.convertToThumbnail(this);
   }
   // ...
 }

และ

 class ImageUtils{
   // ...
   public static Thumbnail convertToThumbnail(Image i){
     // ...
   }
   // ...
 }

วิธีนี้จะทำให้โค้ดที่ดูง่ายขึ้น เปรียบเทียบสิ่งต่อไปนี้:

Image i = ...
someComponent.setThumbnail(i.getAsThumbnail());

หรือ

Image i = ...
Thumbnail t = ImageUtils.convertToThumbnail(i);
someComponent.setThumbnail(t); 

หากวิธีหลังดูดีสำหรับคุณคุณสามารถยึดติดกับวิธีสร้างตัวช่วยนี้ได้ที่ใดที่หนึ่ง

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

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

ในแอพขนาดเล็กฉันจะปรับขนาดรูปภาพในเวลาอ่าน ตัวอย่างเช่นฉันอาจมีกฎการเขียนซ้ำ apache ที่มอบหมายให้ php สคริปต์หากภาพ 'http://my.site.com/images/thumbnails/image1.png' ซึ่งไฟล์จะถูกดึงโดยใช้ชื่อ image1.png และปรับขนาดและเก็บไว้ใน 'thumbnails / image1.png' จากนั้นในคำขอถัดไปที่ภาพเดียวกันนี้ Apache จะให้บริการภาพโดยตรงโดยไม่ต้องเรียกใช้สคริปต์ PHP คำถามเกี่ยวกับ findAllmagesWithoutThumbnails ของคุณจะได้รับคำตอบโดยอัตโนมัติจาก Apache เว้นแต่คุณจะต้องทำสถิติหรือไม่

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

คำตอบสั้น ๆ :

การแนะนำของฉันคือการเพิ่มวิธีการนี้ระดับภาพ:

public Image getResizedVersion(int width, int height);
public Image getResizedVersion(double percentage);

วัตถุรูปภาพยังไม่สามารถแก้ไขได้วิธีการเหล่านี้จะส่งคืนรูปภาพใหม่

มีคำตอบที่ดีอยู่แล้วดังนั้นฉันจะอธิบายรายละเอียดเล็กน้อยเกี่ยวกับการวิเคราะห์พฤติกรรมเพื่อระบุวัตถุและความรับผิดชอบของพวกเขา

OOP แตกต่างจากชีวิตจริงในวัตถุนั้นในชีวิตจริงมักจะอยู่เฉยๆและใน OOP พวกมันยังทำงานอยู่ และนี่คือหลักของวัตถุความคิด ตัวอย่างเช่นใครจะปรับขนาดภาพในชีวิตจริง มนุษย์ที่ฉลาดในแง่นั้น แต่ใน OOP นั้นไม่มีมนุษย์ดังนั้นวัตถุจึงฉลาดแทน วิธีที่จะใช้วิธีการ "แบบมนุษย์เป็นศูนย์กลาง" ใน OOP นี้คือการใช้คลาสบริการตัวอย่างเช่นManagerคลาสที่มีชื่อเสียง ดังนั้นวัตถุจึงถูกจัดให้อยู่ในรูปแบบของข้อมูลแฝง มันไม่ใช่วิธี OOP

ดังนั้นจึงมีสองตัวเลือก วิธีแรกสร้างเมธอดImage::createThumbnail()ได้รับการพิจารณาแล้ว อย่างที่สองคือการสร้างResizedImageชั้นเรียน มันสามารถเป็นมัณฑนากรของImage(ขึ้นอยู่กับโดเมนของคุณว่าจะเก็บImageอินเทอร์เฟซหรือไม่) แม้ว่ามันจะส่งผลให้เกิดปัญหาการห่อหุ้มบางอย่างเนื่องจากResizedImageจะต้องมีImageแหล่งที่มาของ แต่Imageจะไม่ถูกครอบงำด้วยรายละเอียดการปรับขนาดปล่อยให้วัตถุโดเมนแยกต่างหากทำหน้าที่ตาม SRP