|
I'm not entirely sure, but as far as I know the WebServices also use the .NET remoting framework.
regards
modified 12-Sep-18 21:01pm.
|
|
|
|
|
Thanks Greeeg,
Your point is in essence they are of the same?
regards,
George
|
|
|
|
|
Greeeg wrote: I'm not entirely sure, but as far as I know the WebServices also use the .NET remoting framework.
No, they are two separate technologies. They are similar, and they can use the same protocol for transport, but neither uses the other.
Despite everything, the person most likely to be fooling you next is yourself.
|
|
|
|
|
Thanks Guffa,
1.
"the same protocol for transport" you mean using SOAP or?
2.
After reading the article, could I understand in this way?
The only differences between passing by value and passing by reference in a remote web services call is, if pass by reference, the modified result is copied back? If passed by value, no copy-back?
regards,
George
|
|
|
|
|
George_George wrote: "the same protocol for transport" you mean using SOAP or?
Yes.
George_George wrote: The only differences between passing by value and passing by reference in a remote web services call is, if pass by reference, the modified result is copied back? If passed by value, no copy-back?
Exactly.
Despite everything, the person most likely to be fooling you next is yourself.
|
|
|
|
|
Thanks Guffa,
Your reply is very clear.
regards,
George
|
|
|
|
|
Very nice article you suggested
"The clue train passed his station without stopping." - John Simmons / outlaw programmer
"Real programmers just throw a bunch of 1s and 0s at the computer to see what sticks" - Pete O'Hanlon
"Not only do you continue to babble nonsense, you can't even correctly remember the nonsense you babbled just minutes ago." - Rob Graham
|
|
|
|
|
Hi Paul,
As you read and like the document, then what do you think is the differences between passing by value and passing by reference in a remote web services call?
regards,
George
|
|
|
|
|
George_George wrote: Passing by value means passing a new copy of original object
That only applies to value types. For a reference type you will be passing a copy of the reference, not a copy of the object.
For web services you will always pass a serialised copy of the object, and if it's a ref parameter, it will send back a serialised copy of the updated object which will replace the data in the original object.
Despite everything, the person most likely to be fooling you next is yourself.
|
|
|
|
|
Thanks Guffa,
1.
I understand and agree with what you said. But I am confused about what is your answer to my original question? Could you explicitly point out what do you think are the differences between passing by reference and passing by value of a value type please? After reading your reply, I can not find your points clearly about the differences.
2.
I think you mean only value type is eligible to the discussion of choices of passing by value or passing by reference?
regards,
George
|
|
|
|
|
George_George wrote: Could you explicitly point out what do you think are the differences between passing by reference and passing by value of a value type please?
When a value type is passed by value, the value is simply copied to the stack when doing the call. When passed by reference (using the ref or out keywords), a pointer to the variable is put on the stack when doing the call.
One good thing to know when understanding how reference types and value types are passed, is that a reference is a value type. (pause to let it sink in ) The object itself is a reference type and is stored on the heap, but the reference to the object is a value type. When you pass a reference type as argument, you are actually passing the reference, and as that is a value type it's value is simply copied. When you pass a reference type by reference, it's the reference that is sent by reference, so a pointer to the reference is put on the stack.
George_George wrote: I think you mean only value type is eligible to the discussion of choices of passing by value or passing by reference?
No, I meant that only value types fit your description of how it's sent by reference. Both value types and reference types can be sent by value or by reference. (However, when sending a reference type by reference, you are actually sending the reference to the reference type by reference.)
Despite everything, the person most likely to be fooling you next is yourself.
|
|
|
|
|
Guffa wrote: When you pass a reference type as argument, you are actually passing the reference, and as that is a value type it's value is simply copied.
It's value will be a reference, right?
modified on Sunday, September 28, 2008 1:56 PM
|
|
|
|
|
Right.
Despite everything, the person most likely to be fooling you next is yourself.
|
|
|
|
|
Hi Guffa,
"When you pass a reference type as argument, you are actually passing the reference, and as that is a value type it's value is simply copied." -- I am confused what do you mean. You mean when we pass a reference, we actually just copied the pointer/reference's value? My most confusion is what means "and as that is a value type".
regards,
George
|
|
|
|
|
George_George wrote: You mean when we pass a reference, we actually just copied the pointer/reference's value?
Exactly.
George_George wrote: My most confusion is what means "and as that is a value type".
When you pass a value type by value, it's contents is just copied. A reference variable is a value type, so when it's passed by value (i.e. as usual) it's value is copied. As Navaneeth pointed out, the value of the reference variable is a reference.
Despite everything, the person most likely to be fooling you next is yourself.
|
|
|
|
|
Looks a little confusing about the terms, Guffa.
Let me confirm,
1. "A reference variable is a value type, so when it's passed by value (i.e. as usual) it's value is copied" -- we could understand this in context of C++ that the reference is a pointer and the pointer value is copied?
2. "the value of the reference variable is a reference" -- we could understand this in context of C++ that the value of reference is pointer?
regards,
George
|
|
|
|
|
George_George wrote: "A reference variable is a value type, so when it's passed by value (i.e. as usual) it's value is copied" -- we could understand this in context of C++ that the reference is a pointer and the pointer value is copied?
Yes. A reference is actually a pointer, the only difference is that the garbage collector knows that it's a reference so that the memory management "owns" it.
George_George wrote: "the value of the reference variable is a reference" -- we could understand this in context of C++ that the value of reference is pointer?
Yes, a reference variable in C# works like a pointer variable in C++. The difference is that a reference in C# is automatically dereferenced when you use it, so there is no special syntax to dereference it to access the object that it's pointing to.
Despite everything, the person most likely to be fooling you next is yourself.
|
|
|
|
|
Thanks for your clarification, Guffa!
regards,
George
|
|
|
|
|
George_George wrote: A reference variable is a value type, so when it's passed by value (i.e. as usual) it's value is copied" -- we could understand this in context of C++ that the reference is a pointer and the pointer value is copied?
See the following code,
static void Main(string[] args) {
StringBuilder sb = new StringBuilder();
PassReferenceByValue(sb);
Console.WriteLine(sb);
PassReferenceAsReference(ref sb);
if (sb == null)
Console.WriteLine("SB is NULL");
Console.Read();
}
static void PassReferenceByValue(StringBuilder sb) {
sb.Append("Something");
sb = null;
}
static void PassReferenceAsReference(ref StringBuilder sb) {
sb.Append("Something");
sb = null;
} When PassReferenceByValue is called, it's call stack will get a local copy of variable "SB". Variable "sb"'s value is a pointer to original StringBuilder instance. So adding a new item to it will add to original object. Making it NULL will affect only the local copy.
When PassReferenceAsReference is called, a reference to the original object will be passed. It is same like we pass a double pointer to a method in C++. So equivalant C++ code would be
void PassReferenceByValue(std::string* str){
str = new std::string;
*str = "This will not come";
}
void PassReferenceAsReference(std::string** str){
*str = new std::string;
(*(*str)) = "Hello";
}
int _tmain(int argc, _TCHAR* argv[])
{
std::string str = "From Main";
std::string* strPtr = &str;
PassReferenceAsReference(&strPtr);
std::cout << (*strPtr) << std::endl;
PassReferenceByValue(strPtr);
std::cout << (*strPtr) << std::endl;
return 0;
} Hope that made sense.
|
|
|
|
|
Thanks Navaneeth,
I like your sample so much!
regards,
George
|
|
|
|
|
|
Thanks Guffa,
1.
Guffa wrote: but the reference to the object is a value type
In practice I agree. But is there any officla document mentioning that?
2.
I agree with your points for a local function call. But for a remote call, like calling a remote web services from client proxy, what is the underlying differences between passing a reference type and passing value type? I think your point of passing just a pointer for reference type is meaningless when dealing with remote call, since the pointer value on one machine is not suitable for another difference machine. Any comments?
regards,
George
|
|
|
|
|
Hello everyone,
One question regarding to the wikipedia page for WS-Addressing for routing,
http://en.wikipedia.org/wiki/WS-Addressing
I am confused about what means "The network-level transport is only responsible for delivering that message to a dispatcher capable of reading the WS-Addressing metadata. Once that message arrives at the dispatcher specified in the URI, the job of the network-level transport is done." -- how do you understand this statement?
regards,
George
|
|
|
|
|
Hi all, I have meddled with threads in the past but I can't claim to really unerstand all the ins and outs of it. I'm stuck with a problem now and I'm hoping someone can point me in the right direction.
I have a custom control that's essentially a Panel onto which PictureBox es can be placed at runtime. The important method in the class is public void AddImage(Image newImage) which creates a new PictureBox , calculates what the size of it should be, what the location of it should be etc. and then adds it to the panel.
So far so good. My problem is that this is a rather time consuming operation and in many cases I have a need to call this member several times in a row to add multiple images to my panel. I'd like to do all of this threaded so that:
1. the main form (containing the custom control) can be updated while images are being added to the control
2. the main form can still accept button clicks and what have you while images are being added to the control
I've tried using System.ComponentModel.BackgroundWorker and System.Threading.Thread but in both cases I've run into problems which might be too lengthy to explain here. I'm not looking for specific code but some advice on how threading can be used in this situation would be appreciated.
Some specific requirements that I have are:
1. I need for the pictures to be added to the control in the order in which I'm sending them with AddPicture .
2. I need to be abe to interrupt the sequence of calls to AddPicture at any stage so that the panel is cleared and a new sequence of calls to AddPicture is started.
Any ideas?
|
|
|
|
|
Creating the PictureBoxes and adding them to the Panel must be done on the main UI thread. So there is a limit to how much work you can offload to a worker thread.
If calculating the size and location is taking a long time, maybe you should look at optimising that code. Modern computers are extremely fast at calculations, so I would be surprised if this was the bottleneck.
You could try allowing the UI to process any messages in it's message queue between calls to AddImage by having a queue of images to add and Posting a custom message to the end of the message queue after each addition. Then the custom message handler would be responsible for actually doing the work one image at a time.
Nick
----------------------------------
Be excellent to each other
|
|
|
|