basic programming question

You guys are truly something. :)

Also, if a component (like Bitmap or Graphics) uses unmanaged resources, when you dereference it you'll get a memory leak because pieces of it are never going to be collected by the garbage collector.

To answer your question, there would only be a single pointer on the stack, and everything else would be on the heap. The uncertainty with C# is that you don't know when the memory is cleaned out, so to be more technically accurate, each time the loop iterates the object is dereferenced and ready for garbage collection, but we don't know when the memory it takes up is returned to the heap. The loop creates an instance of a String every time the program passes over x = "...", but at any point in time at most one instance is actually referenced. This is one of my gripes about automatic garbage collection: You don't know when the garbage collector actually returns the space to the heap. You can assume those instances are gone, but the memory they take up is still there until the garbage collector returns it.

"If it is cleaned out, how could memory rise? I guess that would depend on what you mean by cleaned out. " In my app I had several (some sort of) memory leaks. Wich means that everytime a reference was created and the next loops execution began the resources(memory) the object used was NOT cleared out. This lead to some major increase in memory usage. So as you can see. A newly declared object gets it's own memory allocated. Else the memory wouldn't increase but should stay stable.

myKonian, If it was cleaned out, wouldn't that mean that there would only be one instance? NoBrainer said "Since it is newly declared a new memory location on the heap is allocated for this variable. I've seen this in my apps when sometimes memory rises when big objects are created in a loop with their scope also limited to that loop." If it is cleaned out, how could memory rise? I guess that would depend on what you mean by cleaned out. Oh, and Simon, I didn't mean to offend you or anything by trying to give my knowledge on the subject. I am guessing that you thanking NoBrainer and Mykonian means that you didn't appreciate my input. I hope this isn't the case. I am really just trying to help. Even if I am wrong, others may have been thinking on the same wave-length and the corrections that are posted will help everyone. I wasn't wrong in all aspects and I admitted, as well as showed documentation, on the parts that I was wrong in. I love this site and have learned a lot from the posts. I have been using this site for about 3 months now and thought I could contribute something with the knowledge I have gained. Even if I am wrong on all counts, the documentation of the corrections are a valuable asset to all users, so you're welcome. I'm going to be taking more in-depth C# classes over the next couple of months, so you should be able to count on me to become a reliable source of information. I plan on making Information Systems my lifelong career. :vD

Thanks Nobrainer and Mykonian. Simon

Technicalities... At the beginning of each loop a new instance of a string is created. It's cleaned out and then reinstantiated again at the beginning of the next loop. Basically this is what happens enter while loop new instance delete instance new instance delete instance etc. One must also note that the string class is immutable, so you never actually change the value of a string. You create a new instance and change the reference every time you use the assignment operator.

Hi. When debugging the program, it only shows one x variable at any given time during the loop. This display is misleading, as it is actually creating a new instance of the string x every time through the loop. That's why I originally thought that there was only one instance being created. Here is the information that I am using from the MSDN library: (NOTE THE INFORMATION I RETYPED IN ALL UPPERCASE) "A local variable is declared by a local-variable-declaration, which may occur in a block, a for-statement, a switch-statement, or a using-statement. The lifetime of a local variable is the portion of program execution during which storage is guaranteed to be reserved for it. This lifetime extends from entry into the block, for-statement, switch-statement, or using-statement with which it is associated, until execution of that block, for-statement, switch-statement, or using-statement ends in any way. (Entering an enclosed block or calling a method suspends, but does not end, execution of the current block, for-statement, switch-statement, or using-statement.) IF THE PARENT BLICK, FOR-STATEMENT, SWITCH-STATEMENT, OR USING-STATEMENT IS ENTERED RECURSIVELY, A NEW INSTANCE OF THE LOCAL VARIABLE IS CREATED EACH TIME, AND ITS LOCAL-VARIABLE-INITILIZER, IF ANY, IS EVALUATED EACH TIME. A local variable is not automatically initialized and thus has no default value. For the purpose of definite assignment checking, a local variable is considered initially unassigned. A local-variable-declaration may include a local-variable-initializer, in which case the variable is considered definitely assigned in its entire scope, except within the expression provided in the local-variable-initializer. Within the scope of a local variable, it is a compile-time error to refer to that local variable in a textual position that precedes its local-variable-declarator. The actual lifetime of a local variable is implementation-dependent. For example, a compiler might statically determine that a local variable in a block is only used for a small portion of that block. Using this analysis, the compiler could generate code that results in the variable's storage having a shorter lifetime than its containing block. The storage referred to by a local reference variable is reclaimed independently of the lifetime of that local reference variable (Section 3.9). A local variable is also declared by a foreach-statement and by a specific-catch-clause for a try-statement. For a foreach-statement, the local variable is an iteration variable (Section 8.8.4). For a specific-catch-clause, the local variable is an exception variable (Section 8.10). A local variable declared by a foreach-statement or specific-catch-clause is considered definitely assigned in its entire scope." Note that, the only time this will occur is when the variable is being initialized recursively, which is why I came to the (logical) conclusion that there be an exception thrown. (I actually wasn't sure if it would be a compile error or an exception. I didn't test it at all and wasn't sure if the debugger would pick up on the problem since it technically was only showing one initialization, although it was in a loop.) If you take away the while statement and add another string x = "Text Here"; line, you will immediately receive a compile error letting you know that a local variable x has already been defined in this scope. Since the string x in the loop didn't cause a compile error and the debugger only showed the one instance, I naturally thought that there was only one instance. I suppose that I should do some research before I give a reply, but, at the same time, all readers and posters have become more familiar with this concept as a result of me replying without researching first. I'm no professional in this field, but I was at the top of my C# class. I have created a program that has 10,200+ lines of code (Budget Wizard), and that was my first real program. Go to my website and check it out, if you want to see some of my work. Check the readme for details. Cheers

blueGohan? Where did you get this information? I'm interested. To my believes, each time the loop is executed a new string variable is declared. Since it is newly declared a new memory location on the heap is allocated for this variable. I've seen this in my apps when sometimes memory rises when big objects are created in a loop with their scope also limited to that loop.

You're right. It doesn't throw an exception. I do have the correct answer now. It creates only one instance of the string x and makes it equal to that text. Since the variable is contained within the scope of a method instead of being declared public or private, it is considered temporary. This allows for changes to be made to it within the loop. Each time through the loop the temporary string s is given a value. Since the loop will never end, it is hard to tell what is happening. If you apply a breakpoint, you can see that there is only one instance of x no matter how many times the loop is cycled. Its value is being changed each time through the loop, even though the value it is being changed to is the same value as before. As far as garbage collection is concerned, that only occurs when the garbage collector has been called, such as the exit of an application or when code referencing it has been written, right? Since the string x is referring to a location in memory, the memory location is simply given a different value to hold. I thought garbage collection was used to reopen memory locations that were being used by the program and to clear the data they contained. The garbage collector would be called at the end of the method after the loop ends and all code contained in the method was executed. THEN, the garbage collector would remove the temporary string x from memory and flush the location of its data. Like I said in my last post, there is only one instance of the string x created, which was correct.

Hi blueGohan Your answer is not correct. An exception will not be thrown. -> Please read the answers above (nobrainer and me). Simon

You can only initialize a variable once. The first time through the loop it would initialize the variable as a string. The second time through, it would try to initialize it again and throw an exception. I'm not 100% sure on this, but it just seems (logical). In answer to the original question, it would create one instance. :vD

One more (logical) thing. The datatype string is a reference type. That means it's memory it's not allocated on the stack but the heap.

Hi Simon, Finally a logical answer! It makes sense now. Thanks! JJ

Hi while(true) { // A string instance (s) is created, and initialized with a string. string s = "a string"; // If the instance is leaving it's scope, it will be marked for garbage collection. // The scope is in this case one round of the while loop. } So, to answer your question: It will create instances of s as long as the loop is running. But, there is only one valid instance per round. The other instances (the old one), will be garbage collected, if garbage collection is doing the work. Simon

duh nobrainer. ;) You didn't help me and this is not something I can easily google if you're going to respond me back in the next response. :) JJ

It will return an error saying this loop will never exit :)