Istanzia un corso con due genitori

Question

Istanzia un corso con due genitori

#1 da (1 voti)
#2 da (0 voti)

0

Supponiamo di avere classi TypeA e TypeB, che sono totalmente diverse, ma entrambe contengono un elenco di oggetti TypeC.

Class TypeA { List<TypeC> cs; }
Class TypeB { List<TypeC> cs; }

Per tutto il suo ciclo di vita, un'istanza TypeC appartiene a una singola istanza TypeA ea una singola istanza TypeB, che non può essere modificata.

La mia domanda è come creare una nuova istanza di TypeC e associarla alle istanze TypeA e TypeB?

la soluzione semplice sarebbe:

ConstructorOfC(typeA, typeB) {
    typeA.insertC(this);
    typeB.insertC(this);
}

Gli svantaggi di questo approccio sono che C è consapevole e dipende dalle classi TypeA e TypeB. Espongo anche un metodo di inserimento, che non desidero poiché l'inserimento dovrebbe essere solo al momento della creazione, ma questo metodo può essere chiamato in qualsiasi momento.

Un'altra soluzione può essere:

TypeA: createTypeC() {
     this.cs.insert(new TypeC());
}

che funzionerebbe se typeC avesse un solo genitore, ma non è il caso.

design

posta Deer 14.12.2018 - 16:36

fonte

2 risposte

Leggi altre domande sui tag design

Ottimizzazione del protocollo basato su XML Come aggiungere un blocco di dati a dimensione fissa a un file e assicurarti che questo blocco non venga frammentato su disco?

score 1 · Answer 1

Hai bisogno di un repository di C per determinare l'ambito di "Tutti i tipi C" suggerirei

Dictionary<TypeC,Tuple<TypeA,TypeB>> allCs = new Dictionary<TypeC,Tuple<TypeA,TypeB>>();

l'unica domanda è dove metterlo. Dato che non vuoi che TypeC sia dipendente dagli altri tipi, dovrà essere a livello di applicazione.

Vorrei aggiungere una classe Factory per garantire che tutti i nuovi TypeC vengano aggiunti alla raccolta e rendere la raccolta un singleton all'interno della classe factory.

public class CFactory : ICChecker
{
    private static Dictionary<TypeC,Tuple<TypeA,TypeB>> allCs = new Dictionary<TypeC,Tuple<TypeA,TypeB>>();

    public TypeC CreateTypeC(TypeA a, TypeB b)
    {
        var c = new TypeC();
        a.insert(c);
        b.insert(c)
        allCs.AddWithValue(c, new Tuple<TypeA,TypeB>(a,b));
    }

    public bool IsCAlreadyAssigned(TypeC c)
    {
        return allCs.ContainsKey(c);
    }
}

ora in A e B

public class TypeA
{
    private readonly ICChecker checker;
    public TypeA(ICChecker checker) { this.checker = checker; }
    public void insert(TypeC c)
    {
        if(this.checker.IsCAlreadyAssigned(c) { throw new Exception("NO!"); }
    }
}

score 0 · Answer 2

Da quello che hai descritto, penso che questo sia in qualche modo semplice. Per chiarezza, chiamerò ogni tipo un po 'diversamente. Non è chiaro

class Father {
  List<Child> children;

  public void addChild(Child child) {
    if (child.father == this) {
      children.add(child);
    }
  }
}

class Mother {
  List<Child> children;
  public void addChild(Child child) {
    if (child.mother == this) {
      children.add(child);
    }
  }
}

class Child {
  Father father;
  Mother mother;

  public Father getFather() { return this.father; }
  private void setFather(Father f) { 
      if(this.father == null) {
        this.father = f;
        f.addChild(this);
      } // throw an exception if you want
  }
  public Mother getMother() { return this.mother; }
  private void setMother(Mother m) {
     if (this.mother == null) {
       this.mother = m;
       m.addChild(this);
     }
  }

  public Child(Father f, Mother m) {
     this.setFather(f);
     this.setMother(m);
  }
}

Ciò garantisce che solo il bambino possa impostare i suoi genitori e solo una volta, e che i genitori possano aggiungere un figlio solo se tale figlio li ha come genitori.