Syntax meaning

Guest User

Hi,

Given the following code example.

public string AddSomethingMethod(string templateName)

return GetString(new object[] { templateName });

From what I know, object[] is an array of objects.

However the reference being passed in is of type string (singular) and not an array of strings.

The GetString method accepts a parameter of params object[] args.

And the logic does the following:-

for(int i = 0; i < args.Length; i++)

string str1 = args[i] as string;

if(str1 != null) || str1.Length > 0x400

args[i] = str1.Substring(0, 0x3fd) + "...";

return args;

From this I gather that the string being passed in, is broken down into chars hence why the object array is used?

Regards

Steven

12 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes14y ago
Accepted answer
Well, taking this step by step, the AddSomethingMethod returns a string.

The GetString method sounds like it returns a string, so it sounds OK so far.

As string is implicitly convertible to object (all types are), then passing GetString an array of objects (args) with a single string element is no problem either.

The code in the GetString method then seems to be trimming each string in args so that it doesn't exceed 1024 characters in length.

However, there are two things I don't understand:

1. Like you, I don't understand why the parameter to GetString is an object[] rather than a string[] because the snippet you've shown will only work for strings anyway and so a cast is needed.

2. I don't understand the line :

return args;

The return type of GetString is evidently string rather than object[] and there's no need to return 'args' anyway because (as it's a reference type) any changes made to it will automatically be persisted to the calling code in any case.
Vulpes14y ago
Yes, that expression creates a new object and passes it to the GetString method but, as it's not been assigned to a variable, the caller will have no access to that object when the method returns unless it's used as the return value itself.
Guest User14y ago
Understood thanks kindly Vulpes.

And in this case where the expression new object[] { templateName } is being used instead of a reference variable, then a completely new object\instance reference will be created? thus why returning args in my original code snippet would make sense as there is no direct reference between the two object\instance variables anymore?
Vulpes14y ago
I'm talking there about passing an object (i.e. a reference type) by value. In that case, it's the reference that gets copied, not the object itself.

Suppose you do this using a variable rather than an expression. Then, both the parameter and the original variable will refer to the same object.

So, if you've made any changes to that object within the method, those changes will also apply to the object referred to by the original variable as it's the same object.
Guest User14y ago
Vulpes

Could you slightly elaborate on this older post please...

Now, if you had passed an object variable to GetString, then that variable would still point to the same object as it did before the method was called, inclusive of the changes.

This I assume refers to passing a value type object "by value"?

Regards
Vulpes14y ago
That's right Steven, the string parameter is passed by value.

In fact, you can always tell immediately in C# whether a parameter is being passed by reference or not because, if it's the latter, then it must be preceded by 'ref' (or 'out') at the call site as well as within the method's signature.

Also, for a parameter to be passed by reference, you must use a variable - you can't use a literal.
Guest User14y ago
Vulpes

One last ask on this topic if I may please:-

Given a generic statement like the following:-

List string1 = GetInitializedList("SomeName", 1);

Which category for "Passing Parameters" would this fall under? as the SomeName value has been explicitly entered when the GetInitializedList method is invoked.

Given the "SomeName" value of type string (reference-type) is passed then it would be reference-type by value?

Thanks
Guest User14y ago
Perfect thanks kindly Vulpes, case closed : )
Vulpes14y ago
I'll just repeat all that with a correction and some amplifcations highlighted:

All arguments in C# are passed "by value" unless otherwise stated with the ref or out modifiers.

Passing a value-type

When these type of arguments are passed "by value" a copy of the value is created when passed to the method.

Passing a reference-type

When these type of arguments are passed " by value" a copy of the reference is created and not the actual value. Therefore any changes made in the called method are reflected in the calling method.

Passing a value-type with the ref modifier declared

Changing a value in the called method, changes the value in the calling method.

Passing a reference-type with the ref modifier declared

Not only are any changes to the object in the called method persisted in the calling method but you can even change to a different object entirely.

Difference between out and ref

Out is the same as ref, except that the variable passed in need not have been assigned to at that time but the method guarantees that it will have been assigned to by the time the method returns.
Guest User14y ago
Hi Vulpes

Just for my understanding and\or clarification:-

All arguements in C# are passed "by value" unless otherwise stated with the ref modifier.

Passing by value-type

When these type of arguements are passed "by value" a copy of the value is created when passed to the method.

Passing a reference-type

When these type of arguements are passed " by value" a copy of the reference is created and not the actual value. Therefore any changes made in the called method are not reflected in the calling method.

With the ref modifier declared

Changing a value in the called method, changes the value in the calling method.

With regards to the AddSomethingMethod I changed the Return type to be void.

I used a try\catch for when attempting to add the templateName parameter to a collection.

and finally, used a throw new Exception, passing in the GetString method which takes the new object[] { templateName } expression.

The GetString method has a Return type of string and returns a string.Format, which has the "received" args parameter reference passed to it.

Regards

Steven
Vulpes14y ago
When you pass an object 'by value' to a method, then the parameter receives a reference to the object, not a copy of it.

So, if any changes are made to the object's state within the method, then these changes will still be there when the method returns.

Now, if you had passed an object variable to GetString, then that variable would still point to the same object as it did before the method was called, inclusive of the changes.

However, it's just dawned on me that we're not in fact passing an object variable here but the object array created by the constructor expression:

new object[] { templateName }

Whilst this object array will have been changed, there will be no way to access it or the changes from the calling code. As the method doesn't know how it's going to be called, it might therefore make sense to return 'args' to the caller. However, it still doesn't explain how the return type is (apparently) string but an object array is being returned instead :-/
Guest User14y ago
Thanks Vulpes.

Ill look into it further.

Could you elaborate on the following please:-

"there's no need to return 'args' anyway because (as it's a reference type) any changes made to it will automatically be persisted to the calling code in any case"

Regards