|
that's a workaround. not a solution.
Not that, that's a bad thing, but it is important to note the difference. 
|
|
|
|
|
It seems like it is looping through all the values and making the label display all of them. It is probably doing this so fast that you only see the last set value.
If you want to see all the values, maybe try lblCount.Text += i.ToString() + " " to display all the values side by side. If you do this, remember to clear out the label before looping.
|
|
|
|
|
thanks, I'm using the text boxes instead of labels.
|
|
|
|
|
Hello folks, I have a problem (as well as with the English language ^ __ ^) with a web service that I have already created and works fine. Now I have to add a header that contains an ssl certificate (.cer) but do not know how to do. Can anyone help? Place below the important part of the code. Thank you all!
BasicHttpBinding myBinding = new BasicHttpBinding();
myBinding.Security.Mode = System.ServiceModel.BasicHttpSecurityMode.TransportWithMessageCredential;
myBinding.Security.Message.ClientCredentialType = BasicHttpMessageCredentialType.Certificate;
Uri cUri = new Uri("https://Service?wsdl");//reserved data
EndpointAddress ea = new EndpointAddress(cUri);
CVPClient client = new CVPClient(myBinding, ea);
|
|
|
|
|
 The method that has the following signature in the code bellow:
“protected virtual void SetProperty<T>(ref T item, T value, [CallerMember] string propertyName = null)”
What type of method is this. The body of the method is in the code in this post.
Thanks,
Truck
protected virtual void SetProperty<T>(ref T item, T value, [CallerMember] string propertyName = null)
{
if(!EqualityComparer<T>.Default.Equals(item, value))
{
item = value
OnNotifyPropertyChanged(propertyName);
}
}
|
|
|
|
|
It's a virtual Generic method, returning no value.
The Generic bit is the <T> - which means that the type of the parameters "T" is defined by the context in which it is called, not when it is defined.
MSDN[^]
You can call it with integers, or strings, or Buttons - it will work with them all.
The virtual bit allows derived classes to override the method to work differently if they wish.
MSDN[^]
If they override it, then the later version will be used when teh method is called. If they don't, this version will.
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
|
|
|
|
|
|
i like to know in details and want to visualize how memory is allocated in dotnet program. sorry because i will be asking few question. so please answer point wise in detail.
1) suppose i have class called employee which has data member called empNo, Name and Salary. so i like to know when we will create object of employee then how memory will be allocated ?
2) where memory will be allocated for employee object? in heap or stack?
3) why memory is allocated in heap for object and local variable in stack?
4) i hear some time memory is allocated in heap for local variable but when?
5) where actual data is stored like employee name or salary in heap or stack? if in stack why? why not in heap?
6) i heard that memory is allocated for static class in high frequency heap........what is high frequency heap and how it is different than normal heap?
tbhattacharjee
|
|
|
|
|
I'm not going to answer your questions - but not because I'm nasty: because the questions are wrong! 
The distinctions between stack and heap isn't as simple as you might think: and a variable in C# probably isn't what you think it is either - which is at the root of the "wrongness" of your questions.
So: what is a variable?
Simply put, a variable in a method is always allocated on the stack - but it's content may or may not be on the stack, depending on what type of data the variable refers to. If it's a ValueType, then the variable is allocated enough space to hold the whole value: and int is a ValueType, and so is a Point. These are always the same size: you cannot extend the size of a ValueType in any way.
If it's a reference type, then the variable always holds a reference to the actual data, rather than the data itself, and again the variable is a fixed size - only this time it is always either 32 bits or 64 bits depending on the environment your code is executing in. String is a reference type, so is any array.
And that's important: because all reference values are allocated on the Heap: never, ever on the stack.
int i = 6; Integers are ValueTypes, so "i" is on the stack, and is the value of the integer - in this case 6.
Button b = new Button(); Button is a reference type, so the actual data for the new instance is stored on the heap - but "b" is the variable and it is located on the stack, and contains a reference to the actual instance.
But...that doesn't mean that all ValueType instances are on the stack - they aren't: they can be embedded in reference type instances:
public class MyClass
{
public int Value;
}
...
MyClass mc= new MyClass();
mc.Value = 6;
MyClass is a reference type (all classes are reference types, all structs are value types) so the instance data is on the heap, and that includes the value type integer "Value" it contains. "mc" is on the stack and holds a reference to the heap based actual data.
From here it starts to get very, very complicated - there is something called "boxing" to consider as well, where a stack based value is copied to the heap and passed as a reference - far too complicated for a little text box like this one!
Get a c# book - they all explain this with pictures (which helps a lot) and when you've read it have a look at this: Using struct and class - what's that all about?[^] - it explains a bit more about it, but it's not exactly beginner friendly!
[edit]Typos![/edit]
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
modified 26-Feb-15 10:11am.
|
|
|
|
|
+5 !
small typo here:
OriginalGriff wrote: copied to the head
|
|
|
|
|
Fixed! (Along with a couple of others...  )
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
|
|
|
|
|
thanks for your time and answer. you said : that's important: because all reference values are allocated on the Heap: never, ever on the stack.
int i = 6;
Integers are Value types, so "i" is on the stack, and is the value of the integer - in this case 6.
i heard that reference type stored in heap and their corresponding value stored in stack.
you said but this is not very clear MyClass is a reference type (all classes are reference types, all structs are value types) so the instance data is on the heap, and that includes the value type integer "Value" it contains. "mc" is on the stack and holds a reference to the heap based actual data.
is there any book which i can download its pdf version which you read and tell me which chapter discuss memory management related things for c# or any other book which easily help me to understand with picture how and when data stored in heap and stack.
share knowledge if you know what is high frequency heap?
tbhattacharjee
|
|
|
|
|
Tridip Bhattacharjee wrote: is there any book which i can download its pdf version
Do not ask that here again!
Most (if not all) PDF copies of books are in violation of copyright: and we do not support that in any way, shape, or form. Bear in mind that nearly all of the 11 million member here are in the business of getting paid to write something it is very easy to copy and download and you might see part of why! You will not get links to anything illegal or immoral here.
And if you ask again, there is a good chance you may be banned from the site...permanently.
There are several different type of heap in .NET - and it really does get complicated. Seriously, find a book - and buy it - it will be able to go into such things in a lot more detail than we can here.
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
|
|
|
|
|
i am very sorry but it would be helpful if you suggest any book name which help me to understand memory management including heap & stack. looking for help. thanks
tbhattacharjee
|
|
|
|
|
No, since you have already indicated that you are planning on downloading it.
We don't encourage that at all.
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
|
|
|
|
|
OriginalGriff wrote: Most (if not all) PDF copies of books are in violation of copyright:
Eh?
There are most definitely books one can download in pdf format for free which do not violate copyright.
Given the sum total of all books ever in print then one might suppose that pdfs of all of those, percentage wise, would be violating copyrights.
However books published in the past 20 years, either popular ones or those with a low sell rate can be found for free, legally, or for sale, again legally, at various places. All in pdf format.
And this includes programming.
One might hypothesize that most, percentage wise, of the good books on programming would in fact require a payment. But would be downloadable.
And if one expands the definition the percentage is going to go up when one considers content from e-books.
|
|
|
|
|
just tell me a books name which discuss in details how memory is allocated when we run our program. thanks
tbhattacharjee
|
|
|
|
|
Have a search through the MSDN magazine back issues. They have a lot of great information there.
|
|
|
|
|
if possible give me some good link from MSDN magazine which relevant for my question.
tbhattacharjee
|
|
|
|
|
There's a legal PDF Book linked here: http://www.codeproject.com/Messages/4977275/free-introductory-book-on-Csharp-programming-from.aspx[^]
I don't know if it covers memory management but it probably contains other useful stuff.
Tridip Bhattacharjee wrote: share knowledge if you know what is high frequency heap?
The CLR (Common Language Runtime) uses the high frequency heap to store frequently used data required to run a .Net program, e.g. method tables. It's nothing that's particularly important to know for writing a .Net application.
|
|
|
|
|
thanks for your time and explanation. would you mind to discuss briefly what is high frequency heap and how it is different than a normal heap?
i hard the static class related info stored in high frequency heap but not sure is it true or not. why static class related info stored in heap? looking for your guidance.
tbhattacharjee
|
|
|
|
|
Seriously, we aren't here to do your thinking and research for you. I take it you have an interview soon. You cannot possibly cram in enough to bluff your way through based on random questions. You have been posting questions here long enough to have figured out that you need to learn the basics first. Richard has given you a great book to get started with. Beyond this, if you need to know things like the high frequency heap, then you need to learn how to use google and apply some critical thinking. Learning is your responsibility.
|
|
|
|
|
Tridip Bhattacharjee wrote: i heard that reference type stored in heap and their corresponding value stored in stack.
No. The instance (which holds the actual values) is always on the heap: only the reference to the instance is ever on the stack.
Let's think about instances for a moment.
What is an instance?
Basically, it's a specific example of something. "Car" is a generic idea - you know what a car is, it's got an engine, four wheels, that sort of thing. But a generic idea is not something you can drive to the shops in: for that you need "this car", "that car", "your car", "my car" - these are instances of the generic idea. Consider this:
What colour is a Car?
You can't answer, because a generic idea doesn't have a colour.
What colour is your car?
That's a lot easier: "your car is red", or "your car is blue" - because now you are talking about an instance instead of the generic idea.
So in terms of variables all instances of a Car are stored on the Heap, but the references to them are stored on the stack:
Car myCar = new Mercedes("Red");
Car yourCar = new Bugatti("Black"); "myCar" and "yourCar" are the variables and they are on the stack - but the actual Cars the refer to are on the heap.
And when I change cars:
myCar = new BrokenDownHeapOfJunkThatWasABMWOnce(); That only changes the reference that "myCar" held - it doesn't destroy the "old" car I used to have, it just lets it be referenced by it's new owner. If you crash your car, then I could sell you my car, to get a new one myself:
yourCar.Dispose();
yourCar = myCar;
myCar = new BrokenDownHeapOfJunkThatWasABMWOnce(); The variables are the same, but the items they reference have changed.
Make sense?
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
|
|
|
|
|
5+ from me also. 
|
|
|
|
|
See if this helps, click through the various parts
http://blogs.msdn.com/b/ericlippert/archive/2009/04/27/the-stack-is-an-implementation-detail.aspx[^]
1 The OS is asked for memory to be reserved to hold the contents of the object, the object is stored at that address on the heap. As already mentioned, the variable that points to the object is on the stack.
2 Heap
3 Performance. Allocating and deallocating memory is expensive (have a for loop from 1 to 1000000 and in that loop update an int "i = i + 1", do a second loop and in that loop concat a string s = s & "x". Time how long both loops take to execute - the string loop is doing memory allocation, the int loop isn't). With the stack the memory is already allocated, you can put things on the stack and take them off "for free". Every time you put something in the heap you need to request a memory allocation, when you take things off that memory has to eventually be deallocated.
Because the stack is a known fixed size you can't go storing Word documents in it, it would run out (make a function that just calls itself, every call puts an exit reference on the stack, after a second or so you'll get a stack overflow as you will have run out of stack space).
Also things on the stack are "last on first out", they remain in sequential order at known addresses. As the stack is pre-allocated, a "pointer" is held that references the next bit of free space. As you put something on the stack the pointer goes up, you take something off it goes down. If you have, say, an int (10), a string ("ab") and an int (20) on the stack;
Stack add 0 - 10
Stack add 1 - a
Stack add 2 - b
Stack add 3 - 20
Stack add 4 - < stack pointer points here, put something else on and this is where it goes
and then wanted to change the string from "ab" to "abc"...where do you store the "c"? There is no space as your second int is on top of it so to increase the string from "ab" to "abc" would require reordering everything above it. So you can only put things on the stack that don't change in size. An int is always going to be 32 bits for example (depending on os and hardware).
5 Value types, things of known, unchangeable sizes, tend to go on the stack. "objects" of unknown sizes that can grow and shrink go on the heap. Of course value types can end up on the heap too due to things already mentioned, due to boxing, static variables etc, but reference types will never end up on the stack.
Note to everyone: Obviously many things in here are simplified for basic understanding, there's no need to be pedantic
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
