Flexibility and extensibility

Oct 13, 2025 by sorusgentrification.com 140 views

Understanding Trigger.new in Apex Triggers

In Salesforce, Apex triggers are a powerful tool for automating business processes and workflows. One of the key concepts in Apex triggers is the Trigger.new object, which represents the records that triggered the trigger. However, many developers have noticed that Trigger.new is a list, not a single sObject. In this article, we will explore the reasons behind this design decision and its implications for Apex trigger development.

What is Trigger.new?

Trigger.new is a list of sObject records that triggered the Apex trigger. It is a read-only collection that contains the records that were inserted, updated, or deleted in the current transaction. The Trigger.new list is populated by the Salesforce platform and is available to Apex triggers for processing.

Why is Trigger.new a list and not a sObject?

There are several reasons why Trigger.new is a list and not a single sObject:

Multiple records: In many cases, Apex triggers need to process multiple records that were inserted, updated, or deleted in a single transaction. By making Trigger.new a list, Salesforce provides a convenient way to access and process multiple records in a single iteration.
Efficient processing: When Trigger.new is a list, Salesforce can optimize the processing of multiple records by reusing the same Apex trigger instance. This approach reduces the overhead of creating and managing multiple Apex trigger instances for each record.
Flexibility and extensibility: By making Trigger.new a list, Salesforce provides a flexible and extensible framework for Apex trigger development. Developers can easily add or remove records from the Trigger.new list, making it easier to implement complex business logic.

Implications for Apex Trigger Development

The fact that Trigger.new is a list and not a single sObject has several implications for Apex trigger development:

Iterating over records: When working with Trigger.new, developers need to iterate over the list of records using a for loop or a for loop with a sObject variable.
Accessing record properties: To access the properties of a record in the Trigger.new list, developers need to use the sObject variable and access its properties using the dot notation (e.g., record.Id, record.Name, etc.).
Processing multiple records: When processing multiple records in the Trigger.new list, developers need to be mindful of the order in which the records are processed. The order of the records in the Trigger.new list is not guaranteed and may vary depending on the underlying database implementation.

Example Use Case: Processing Multiple Records

Suppose we have an Apex trigger that needs to process multiple records that were inserted in a single transaction. We can use the following code to iterate over the Trigger.new list and process each record:

trigger MyTrigger on MyObject (after insert) {
    for (MyObject record : Trigger.new) {
        // Process the record
        System.debug('Processing record: ' + record.Id);
        // ...
    }
}

In this example, we use a for loop to iterate over the Trigger.new list and access each record using the sObject variable record. We can then process each record as needed.

Conclusion

In conclusion, Trigger.new is a list and not a single sObject because it provides a convenient way to access and process multiple records in a single iteration. By making Trigger.new a list, Salesforce provides a flexible and extensible framework for Apex trigger development. While this design decision has implications for Apex trigger development, it also provides a powerful tool for automating business processes and workflows in Salesforce.

Frequently Asked Questions

Q: What is the difference between `Trigger.new` and `Trigger.old`?

A: Trigger.new represents the records that triggered the Apex trigger, while Trigger.old represents the records that were updated or deleted.

Q: Can I access the properties of a record in the `Trigger.new` list using the dot notation?

A: Yes, you can access the properties of a record in the Trigger.new list using the dot notation (e.g., record.Id, record.Name, etc.).

Q: How do I iterate over the `Trigger.new` list?

A: You can iterate over the Trigger.new list using a for loop or a for loop with a sObject variable.

Q: What happens if I try to access a record in the `Trigger.new` list that does not exist?

A: If you try to access a record in the Trigger.new list that does not exist, you will get a NullPointerException. To avoid this, you should always check if the record exists before trying to access its properties.

Q: Can I use the `Trigger.new` list to process records that were deleted?

Q: What is the difference between Trigger.new and Trigger.old?

A: Trigger.new represents the records that triggered the Apex trigger, while Trigger.old represents the records that were updated or deleted. In other words, Trigger.new contains the new values of the records, while Trigger.old contains the old values of the records.

Q: Can I access the properties of a record in the Trigger.new list using the dot notation?

A: Yes, you can access the properties of a record in the Trigger.new list using the dot notation (e.g., record.Id, record.Name, etc.). However, you should be aware that the properties of a record in the Trigger.new list are read-only and cannot be modified.

Q: How do I iterate over the Trigger.new list?

A: You can iterate over the Trigger.new list using a for loop or a for loop with a sObject variable. Here is an example:

trigger MyTrigger on MyObject (after insert) {
    for (MyObject record : Trigger.new) {
        // Process the record
        System.debug('Processing record: ' + record.Id);
        // ...
    }
}

Q: What happens if I try to access a record in the Trigger.new list that does not exist?

Q: Can I use the Trigger.new list to process records that were deleted?

A: Yes, you can use the Trigger.new list to process records that were deleted. However, you should be aware that the Trigger.new list only contains records that were deleted in the current transaction. If you need to process records that were deleted in a previous transaction, you will need to use a different approach.

Q: How do I handle errors that occur when processing records in the Trigger.new list?

A: You can handle errors that occur when processing records in the Trigger.new list using a try-catch block. Here is an example:

trigger MyTrigger on MyObject (after insert) {
    try {
        for (MyObject record : Trigger.new) {
            // Process the record
            System.debug('Processing record: ' + record.Id);
            // ...
        }
    } catch (Exception e) {
        // Handle the error
        System.debug('Error processing record: ' + e.getMessage());
    }
}

Q: Can I use the Trigger.new list to process records that were inserted or updated?

A: Yes, you can use the Trigger.new list to process records that were inserted or updated. The Trigger.new list contains all records that were inserted or updated in the current transaction.

Q: How do I access the properties of a record in the Trigger.new list that was inserted or updated?

A: You can access the properties of a record in the Trigger.new list that was inserted or updated using the dot notation (e.g., record.Id, record.Name, etc.).

Q: Can I use the Trigger.new list to process records that were deleted in a previous transaction?

A: No, you cannot use the Trigger.new list to process records that were deleted in a previous transaction. The Trigger.new list only contains records that were deleted in the current transaction.

Q: How do I access the properties of a record in the Trigger.new list that was deleted in a previous transaction?

A: You cannot access the properties of a record in the Trigger.new list that was deleted in a previous transaction. The Trigger.new list only contains records that were deleted in the current transaction.

Q: Can I use the Trigger.new list to process records that were inserted or updated in a previous transaction?

A: No, you cannot use the Trigger.new list to process records that were inserted or updated in a previous transaction. The Trigger.new list only contains records that were inserted or updated in the current transaction.

Q: How do I access the properties of a record in the Trigger.new list that was inserted or updated in a previous transaction?

A: You cannot access the properties of a record in the Trigger.new list that was inserted or updated in a previous transaction. The Trigger.new list only contains records that were inserted or updated in the current transaction.

Conclusion

In conclusion, the Trigger.new list is a powerful tool for processing records in Apex triggers. By understanding how to use the Trigger.new list, you can write more efficient and effective Apex triggers that automate business processes and workflows in Salesforce.