Is there a better way to optimize these conditionals?

1. Lets kill that giant nest of code. When an Exception is thrown, it interrupts the flow of the program. The code does not continue to execute beyond that point, it is like an early return in that regard. This means we do not need to nest our next statement in the Else block, because if an exception was thrown the program has returned.

2. You should not be throwing Exception, not to say you should throw exceptions, but just not throw the base Exception class. Instead make your own exception class that inherits from Exception. An incredibly simple way of doing this is just...

   Public Class MissingDataException
       Inherits Exception
       Public Sub New(message As String)
               MyBase.New(message)
       End Sub
       Public Sub New(message As String, innerException As Exception)
               MyBase.New(message, innerException)
       End Sub
   End Class
   

3. Lets also use some of .Net's built in features, specifically belonging to the string class.

   String.IsNullOrEmpty(theString)
   

   will replace the condition for checking null-ness and emptyness, I would recommend you look at IsNullOrWhiteSpace as well, this is good if you may be getting some blank spaces newlines or tabs with your data.

4. (Optional) Instead of comparing your Enumeration to 0, implement a MyEnumeration.NoValue value, this way in-case someone ever changes the default values of enum this code will still work. Or if you don't want to change the enum, you could just check to see if the value given is a valid value in your enumeration.

Now your code will look like this

Public Function MyProjectFuncion(firstObject As Object, myEnumeration As Enumeration, theString As String, someCollection As List(Of Object), anotherObject As Object) As String
    If (firstObject Is Nothing) Then
        Throw New MissingDataException("No data was received in 'firstObject'")
    End If
    If (anotherObject Is Nothing) Then
        Throw New MissingDataException("No data was received in 'anotherObject'")
    End If
    If (myEnumeration Is Nothing) OrElse myEnumeration = 0 Then
        Throw New MissingDataException("No data was received in 'myEnumeration'")
    End If
    If String.IsNullOrEmpty(theString) Then
        Throw New MissingDataException("No data was received in 'theString'")
    End If
    If (someCollection Is Nothing) OrElse someCollection.Count = 0 Then
        Throw New MissingDataException("No data was received in 'someCollection'")
    End If
    Return "All the variables have value"
End Function

I do want to address the way this method is functioning. It would appear that you have gotten some data, and now are checking the data. I know you said this is someone else's code, but it should be changed. My assumption is that outside this method call is a try catch statement that is catching the exception and displaying or logging the exception message, otherwise display/logging the "It worked" message. I am guessing this is the case because the person who wrote this code didn't realize how much better it would be to just return two values.

Notice at the end of the method signature is a new parameter called succeeded

Public Function MyProjectFuncion(firstObject As Object, myEnumeration As Enumeration, theString As String, someCollection As List(Of Object), anotherObject As Object, ByRef succeeded As Boolean) As String
    succeeded = False
    If (firstObject Is Nothing) Then
        Return "No data was received in 'firstObject'"
    End If
    If (anotherObject Is Nothing) Then
        Return "No data was received in 'anotherObject'"
    End If
    If (myEnumeration Is Nothing) OrElse myEnumeration = 0 Then
        Return "No data was received in 'myEnumeration'"
    End If
    If String.IsNullOrEmpty(theString) Then
        Return "No data was received in 'theString'"
    End If
    If (someCollection Is Nothing) OrElse someCollection.Count = 0 Then
        Return "No data was received in 'someCollection'"
    End If

    succeeded = True
    Return "All the variables have value"
End Function

Now the succeeded value is available after the method returns, and will only be true if all values past the test, and now there is no nasty exception throwing, which hurts your application's performance and is just bad practice.

You can call the method like this now. WITHOUT a try..catch surrounding it

Dim wasSuccess As Boolean
Dim message As String = MyProjectFuncion(firstObject, myEnumeration, theString, someCollection, anotherObject, wasSuccess)

If wasSuccess Then
    'What you do when it works
Else
    'What you do normally when there is an exception in that method
End If