removeElement() और clear() सरणी संग्रह संपत्ति

Question

के साथ सिद्धांत 2 में काम नहीं करता है, मैं सिद्धांत 2 के साथ कुछ सरल सीआरयूडी प्राप्त करने की कोशिश कर रहा हूं, लेकिन जब एक सरणी संग्रह के रूप में एक प्रॉपर्टी सेट के साथ रिकॉर्ड अपडेट करने का समय हो मुझे लगता है कि इसे हटाने के लिए हटाने() को काम नहीं करना प्रतीत होता है। मैं भी इस हास्यास्पद बदसूरत तरह से यह कर की कोशिश की:

foreach($entity->getCountries() as $c) { 
     $entity->getCountries()->removeElement($c); 
     $this->em->persist($entity); 
     $this->em->flush(); 
} 

और यह काम नहीं किया ... किसी को भी जानता है कि यह कैसे संभाल करने के लिए? मैंने कई अलग-अलग रूपों में इसका समाधान करने के लिए कहा है और अब तक कोई अच्छी प्रतिक्रिया नहीं मिली है ... ऐसा लगता है कि सिद्धांत 2 सीआरयूडी हैंडलिंग के अच्छे उदाहरणों की कमी है। मैं अनुरोध पर अधिक कोड पोस्ट करूंगा।

संपादित

//in user entity 
/** 
* 
* @param \Doctring\Common\Collections\Collection $property 
* @OneToMany(targetEntity="Countries",mappedBy="user", cascade={"persist", "remove"}) 
*/ 
private $countries; 

//in countries entity 
/** 
* 
* @var User 
* @ManyToOne(targetEntity="User", inversedBy="id") 
* @JoinColumns({ 
* @JoinColumn(name="user_id", referencedColumnName="id") 
* }) 
*/ 
private $user; 

Answer 1

मैं ऐसी घटनाओं के साथ एक परियोजना में ऐसा कुछ करता हूं जिसमें प्रतिभागियों को आपके उपयोगकर्ता/देश संबंधों के विपरीत नहीं है। मैं बस प्रक्रिया को प्रस्तुत करूंगा और आप देख सकते हैं कि आप कुछ भी कर रहे हैं या नहीं।

Participant इकाई

/** 
* @ManyToOne(targetEntity="Event", inversedBy="participants", fetch="LAZY") 
* @JoinColumn(name="event_id", referencedColumnName="id", nullable="TRUE") 
* @var Event 
*/ 
protected $event; 

Event इकाई पर:

/** 
* @OneToMany(targetEntity="Participant", mappedBy="event") 
* @var \Doctrine\Common\Collections\ArrayCollection 
*/ 
protected $participants; 

इसके अलावा Event#__constructor में

मैं इस तरह प्रारंभ:

$this->participants = new \Doctrine\Common\Collections\ArrayCollection(); 

यहाँ कैसे मैं एक घटना को अद्यतन है:

public function update(Event $event, Event $changes) 
{ 
    // Remove participants 
    $removed = array(); 
    foreach($event->participants as $participant) 
    { 
     if(!$changes->isAttending($participant->person)) 
     { 
      $removed[] = $participant; 
     } 
    } 

    foreach($removed as $participant) 
    { 
     $event->removeParticipant($participant); 
     $this->em->remove($participant); 
    } 

    // Add new participants 
    foreach($changes->participants as $participant) 
    { 
     if(!$event->isAttending($participant->person)) 
     { 
      $event->addParticipant($participant); 
      $this->em->perist($participant); 
     } 
    } 

    $event->copyFrom($changes); 
    $event->setUpdated(); 
    $this->em->flush(); 
} 

Event इकाई पर तरीके हैं:

public function removeParticipant(Participant $participant) 
{ 
    $this->participants->removeElement($participant); 
    $participant->unsetEvent(); 
} 

public function addParticipant(Participant $participant) 
{ 
    $participant->setEvent($this); 
    $this->participants[] = $participant; 
} 

Participant इकाई पर तरीके हैं:

public function setEvent(Event $event) 
{ 
    $this->event = $event; 
} 

public function unsetEvent() 
{ 
    $this->event = null; 
} 

अद्यतन: isAttending विधि

/** 
* Checks if the given person is a 
* participant of the event 
* 
* @param Person $person 
* @return boolean 
*/ 
public function isAttending(Person $person) 
{ 
    foreach($this->participants as $participant) 
    { 
     if($participant->person->id == $person->id) 
      return true; 
    } 

    return false; 
} 

Answer 2

न्यू जवाब

अपने देशों इकाई में, आप नहीं करना चाहिए था:

@ManyToOne(targetEntity="User", inversedBy="countries") 

inversedBy = "आईडी" के बजाय

?

प्रारंभिक जवाब

आप निकालना झरना के रूप में अपने इकाई के देशों क्षेत्र सेट करना होगा। उदाहरण के लिए, कई रिश्ते के लिए एक द्विदिश एक पर:

class Entity 
{ 
    /** 
    * 
    * @OneToMany(targetEntity="Country", mappedBy="entity", cascade={"remove"}) 
    */ 
    private $countries; 
} 

इस तरह, जब आपके इकाई की बचत, सिद्धांत (जैसे देशों के रूप में) अपने इकाई से जुड़ी संग्रह में परिवर्तन की बचत होगी। अन्यथा आपको उन देशों को स्पष्ट रूप से हटाना होगा जिन्हें आप फ्लश करने से पहले हटाना चाहते हैं, उदा।

$this->em()->remove($aCountry); 

यह लगातार, विलय और अलग-अलग संचालन के लिए भी मान्य है। अधिक जानकारी here।