Etydhv

I’m I created a class that consolidates SObject updates in my triggers. An issue that I am having is that when I call DynamicSObjectUpdater.getSObject(ID), it does not pass the SObject by reference. Is there something that I am missing here? What I am thinking is that when you return a Superclass (i.e. the SObject), it does not pass by reference.

The issue may lie in the following.

targetSObject = sObjectID.getSobjectType().newSobject(sObjectID);

I basically want to do the following:

Contact con = new Contact(ID=sObjectID);

OR

Account acc = new Account(ID=sObjectID);

OR
etc...

I was under the impression that

targetSObject = sObjectID.getSobjectType().newSobject(sObjectID); 

Would do this for me. How do I go about achieving this? –

public with sharing class DyanmicSObjectUpdater 

 Map<SObjectType, Map<Id, sObject>> sorToUpdate = new Map<SObjectType, Map<Id, sObject>>();

public SObject getSObject(ID sObjectID)

 SObjectType sot = sObjectID.getSobjectType();
 if(!sorToUpdate.containsKey(sot))
 
 sorToUpdate.put(sot, new Map<Id, SObject>());
 
 SObject targetSObject = sorToUpdate.get(sot).get(sObjectID);
 if(targetSObject == null)
 
 targetSObject = sObjectID.getSobjectType().newSobject(sObjectID);
 sorToUpdate.get(sot).put(sObjectID, targetSObject);
 
 return targetSObject;
 
 public void updateSObjects()
 
 List<SObject> sObjectsToUpdate = new List<SObject>();
 if(sorToUpdate.size() > 0)
 
 for(SObjectType sorType: sorToUpdate.keySet())
 
 sObjectsToUpdate.addAll( sorToUpdate.get(sorType).values() );
 
 
 System.debug(sObjectsToUpdate);
 if(sObjectsToUpdate.size()>0) update sObjectsToUpdate;
 
 

This is the class that calls the SObject Updater.

trigger Opportunity_Trigger on Opportunity (before insert, before update, after insert, after update) 

DynamicSObjectUpdater sObjectUpdater = new DynamicSObjectUpdater();

if(Trigger.OperationType == TriggerOperation.AFTER_UPDATE)

 UpdateOpportunityContacts.handleTrigger(Trigger.newMap, sObjectUpdater);


sObjectUpdater.updateSObjects();

Then the UpdateOpportunityContacts class

 public with sharing class UpdateOpportunityContacts 
{
public static void handleTrigger(Map<Id, Opportunity> newOppsMap, DynamicSObjectUpdater sObjectUpdater) 


 Map<Id, List<OpportunityContactRole>> conIdsWOpportunityContactRole = new Map<Id, List<OpportunityContactRole>>();

 for(OpportunityContactRole oppCon : [SELECT id, ContactId , Opportunity.StageName, OpportunityId, Role, Opportunity.Deal_Velocity__c FROM OpportunityContactRole WHERE OpportunityId in : newOppsMap.keyset()])
 
 if(!conIdsWOpportunityContactRole.containsKey(oppCon.ContactId))
 
 conIdsWOpportunityContactRole.put( oppCon.ContactId, New List<OpportunityContactRole>());
 

 conIdsWOpportunityContactRole.get(oppCon.ContactId).add(oppCon);
 

 List<Contact> cons = QuerySelector.dynamicQuerySelector(conIdsWOpportunityContactRole.keyset());


 updateContactOutreachStatus(cons, conIdsWOpportunityContactRole, sObjectUpdater);


 


public static void updateContactOutreachStatus(List<Contact> cons, Map<Id, List<OpportunityContactRole>> conIdsWOpportunityContactRole, DynamicSObjectUpdater sObjectUpdater)


 for(Contact con: cons)
 
 conIdsWOpportunityContactRole.get(con.Id)[0].Opportunity.StageName == 'Closed Won (Non-Annual Contract)')
 
 conToUpdate.Outreach_Status__c = 'Current Client';
 conToUpdate.Deal_Velocity__c = conIdsWOpportunityContactRole.get(con.Id)[0].Opportunity.Deal_Velocity__c;
 
 else if(conIdsWOpportunityContactRole.get(con.Id)[0].Opportunity.StageName == 'Closed Lost')
 
 conToUpdate.Outreach_Status__c = 'Closed Lost';
 conToUpdate.Deal_Velocity__c = conIdsWOpportunityContactRole.get(con.Id)[0].Opportunity.Deal_Velocity__c;
 
 else
 
 conToUpdate.Outreach_Status__c = 'Opportunity';
 
 




 public static void updateContactOutreachStatus(List<Contact> cons, Map<Id, List<OpportunityContactRole>> conIdsWOpportunityContactRole, DynamicSObjectUpdater sObjectUpdater)

 for(Contact con: cons)
 

According to this post, SObjects (and other non-primitives) are actually passed by value but happen to behave like pass by reference, unless you call new or the equivalent:

Non-primitive data type arguments, such as sObjects, are also passed into methods by value. This means that when the method returns, the passed-in argument still references the same object as before the method call, and can’t be changed to point to another object. However, the values of the object’s fields can be changed in the method.

The behavior nearly always appears like non-primitives are passed by reference, and you would rarely notice that they are actually not passed by reference. However, when you act on the variable itself in the method, like calling “new” on it, you will notice that things do not behave in pass-by-reference fashion.

I believe this line of code is giving the pass by value behavior:

targetSObject = sObjectID.getSobjectType().newSobject(sObjectID);

The premise of this question seems to me to be mistaken in identifying the issue as pass-by-reference semantics.

I pasted the DyanmicSObjectUpdater class unaltered in my Developer Edition and ran the following Anonymous Apex:

Id contactId = '0033600001gyv5BAAQ'; // This is a real Contact
DyanmicSObjectUpdater s = new DyanmicSObjectUpdater();
Contact c = (Contact)s.getSObject(contactId);
c.FirstName = 'TestSobjectUpdater';

s.updateSObjects();

Contact 0033600001gyv5BAAQ was updated exactly as expected.

My suspicion is that the updates you believe are being lost are not being persisted because you are holding a reference to an instance of DyanmicSObjectUpdater in a static variable somewhere but don't call updateSobjects() at the right point, resulting in your instance being reset at a transaction boundary - or at least a problem similar to that structure.

(Also, Dynamic is misspelled - this drives me crazy in my own code).