Quick OOAD Question

Ci sono molti modi diversi di guardare a questo. Se fossi in un'intervista, andrei con questo.

Photoshoot shoot = new Photoshoot(
    new Camera("Fuji"),
    new Subject("Bill"),
    new Subject("Dave"),
    new Subject("Claire")
    );

IEnumerable<Photo> photos = shoot.TakeAllPhotos();

Dove

class Photoshoot
{
    private readonly IEnumerable<Subject> _subjects;
    private readonly Camera _camera;

    public Photoshoot(Camera camera, params Subject[] subjects)
    {
        _subjects = subjects;
        _camera = camera;
    }

    public IEnumerable<Photo> TakeAllPhotos()
    {
        List<Photo> photos = new List<Photo>();

        foreach(Subject subject in _subjects)
        {
            // Here is the interaction in question
            Call(subject);
            _camera.TakePhotoOf(subject);
        }

        return photos;
    }
}

Quindi l'interazione è questa:

Il metodo TakeAllPhotos della classe Photoshoot scorre i soggetti del servizio fotografico, chiama un soggetto quindi usa la sua fotocamera per scattare foto di quell'oggetto.

In un giorno diverso, potrei passare la fotocamera al metodo TakeAllPhotos, ma oggi sto sostenendo che la fotocamera appartiene al photoshoot.

Nota anche che sono passato soggetto al metodo Call (ancora non definito) del Photoshoot piuttosto che chiamare un metodo Call sull'argomento. Il soggetto non dovrebbe sapere come chiamare se stesso, a mio parere.

Questi sono i tipi di conversazioni che un intervistatore vuole che tu abbia. L'interazione specifica non sarà così importante.

Photoshoot p = new Photoshoot(new Camera("Name of really expensive camera"));
Subject bob = new Subject("Bob");
Photo photo = p.TakePhotoOf(bob);

È buono?

Non esiste una soluzione preferita. Non importa se hai Camera.TakePhoto (soggetto) o Photoshoot.TakePhoto (soggetto, fotocamera). Anche con una serie completa di requisiti, potrebbe non fare molta differenza. Alcuni progetti potrebbero essere migliori di altri, ma non esiste mai un singolo design "migliore".

tutti questi sono validi; potrebbero esserci anche più modelli, "migliore" dipende da ciò che ti serve per la tua applicazione

//The next subject is called and has their photo taken.

Photo pic = photoSession.Shoot(photoSession.NextSubject);

Photo pic = myCamera.Shoot(photoSession.NextSubject);

Photo pic = photoSession.ShootNextSubject(myCamera);

Assumendo il soggetto Subject , Camera e Photo come classi, TakePhoto come metodo (può essere metodo di estensione) di Subject class e PhotoShoot come metodo statico -

IEnumerable<Subject> SubjectCollection = Factory.SubjectCollectionGenerator();
Camera cam = new Camera("Camera Name");

IEnumerator<Subject> subjectEnumerator = SubjectCollection.GetEnumerator();
subjectEnumerator.MoveNext();
Subject calledSubject = subjectEnumerator.Current;
IEnumerable<Photo> photosTaken = StaticClass
                              .PhotoShoot(SubjectCollection, calledSubject, cam);

Dove PhotoShoot è -

static IEnumerable<Photo> PhotoShoot(Enumerable<Subject> SubjectCollection,
                                     Subject calledSubject,
                                     Camera cam)
{ return SubjectCollection.Select( s => calledSubject.TakePhoto(s, cam)); }

Oppure, per tutti i soggetti il PhotoShoot può essere -

static IEnumerable<Photo> PhotoShoot(Enumerable<Subject> SubjectCollection,
                                     Subject calledSubject,
                                     Camera cam)
{ return
           from calledSubject in SubjectCollection
           from s in SubjectCollection
           select calledSubject.TakePhoto(s, cam));
}

Dalla frase nella tua domanda l'implicazione sembra essere in questo caso che un photoshoot contenga molte foto, ogni foto ha un soggetto e viene scattata con una singola videocamera. Questa non è una soluzione generale, ma per la tua domanda specifica (compiti a casa? :-)) le classi assomigliano a:

class Photoshoot
{
 List<Photo> photos;
 ...
}

Class Photo
{
 Camera camera
 Subject subject;
 ...
}

Class Camera 
{
/* camera properties */
}


Class Subject
{
 /* subject properties */
}

Per una soluzione più generale potresti voler aggiungere più soggetti a una foto e senza dubbio più modifiche, ma per i dati che hai fornito sembra essere l'insieme minimo di classi di cui hai bisogno.

Questa è la mia versione, che è simile alle molte linee di compiti che avevo già inviato prima di fare la domanda, ridacchia:

  public class Camera{
      public event EventHandler<PhotoTakenEventArgs> PhotoTaken;
  }

  public class PhotoTakenEventArgs:EventArgs{
      public string PhotoPath{get;}
  }

  public class Coordinator{
      Camera TheCamera{get;}
      PhotoShoot ActiveShoot{get;set;}

      public void NewPhotoshoot(){
          IEnumerable<Subject> subjects = ImportSubjectList();
          Photoshoot shoot = new Photoshoot(subjects);
      }

      public void CallSubject(int subjectIndex){
          ActiveShoot.CurrentSubject = ActiveShoot.Subjects[subjectIndex];
      }

      private void CameraPhotoTakenHandler(object sender, PhotoTakenEventArgs e){
          Photo photo = new Photo(e.PhotoPath);
          ActiveShoot.CurrentSubject.AddPhoto(photo);
      }
  }