StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
4491727
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
1
CommunityOwnedDate
CreationDate
2010-12-20T16:37:54.157
FavoriteCount
0
LastActivityDate
2010-12-20T17:05:25.520
LastEditDate
2010-12-20T17:05:25.520
LastEditorUserId
486172
OwnerUserId
486172
ParentId
4490806
PostTypeId
2
Score
5
ViewCount
0
LastEditorDisplayName
text
Body
1. foreach and for A <code>foreach</code> loop works with <a href="http://msdn.microsoft.com/en-us/library/system.collections.ienumerator.aspx" rel="noreferrer">IEnumerator</a>, when a <code>for</code> loop works with an index (in <code>object myObject = myListOfObjects[i]</code>, i is the index). There is a big difference between the two: <ul> <li>an index can access directly any object based on its position within a list.</li> <li>an enumerator can only access the first element of a list, and then move to the next element (as described in the previous link from the msdn). It cannot access an element directly, just knowing the index of the element within a list.</li> </ul> So an enumerator may seem less powerful, but: <ul> <li>you don't always know the position of elements in a group, because all groups are not ordered/indexed.</li> <li>you don't always know the number of elements in a list (think about a linked list).</li> <li>even when it's ordered, the indexed access of a list may be based internally on an enumerator, which means that each time you're accessing an element by its position you may be actually enumerating all elements of the list up until the element you want.</li> <li>indexes are not always numeric. Think about <a href="http://msdn.microsoft.com/en-us/library/xfhwa508.aspx" rel="noreferrer">Dictionary</a>.</li> </ul> So actually the big strength of the <code>foreach</code> loop and the underlying use of <code>IEnumerator</code> is that it applies to any type which implements <code>IEnumerable</code> (implementing IEnumerable just means that you provide a method that returns an enumerator). Lists, Arrays, Dictionaries, and all other group types all implement IEnumerable. And you can be sure that the enumerator they have is as good as it gets: you won't find a fastest way to go through a list. So, the <code>for</code> loop can generally be considered as a specialized <code>foreach</code> loop: <pre><code>public void GoThrough(List<object> myList) { for (int i=0; i<myList.Count; i++) { MessageBox.Show(myList[i].ToString()); } } </code></pre> is perfectly equivalent to: <pre><code>public void GoThrough(List<object> myList) { foreach (object item in myList) { MessageBox.Show(item.ToString()); } } </code></pre> I said generally because there is an obvious case when the <code>for</code> loop is necessary: when you need the index (i.e. the position in the list) of the object, for some reason (like displaying it). You will though eventually realize that this happens only in specific cases when you do good .NET programming, and that <code>foreach</code> should be your default candidate for loops over a group of elements. Now to keep comparing the <code>foreach</code> loop, it is indeed just an eye-candy specific while loop: <pre><code>public void GoThrough(IEnumerable myEnumerable) { foreach (object obj in myEnumerable) { MessageBox.Show(obj.ToString()); } } </code></pre> is perfectly equivalent to: <pre><code>public void GoThrough(IEnumerable myEnumerable) { IEnumerator myEnumerator = myEnumerable.GetEnumerator(); while (myEnumerator.MoveNext()) { MessageBox.Show(myEnumerator.Current.ToString()); } } </code></pre> The first writing is a lot simpler though. 2. while and do..while The <code>while (condition) {action}</code> loop and the <code>do {action} while (condition)</code> loop just differ from each other by the fact that the first one tests the condition before applying the action, when the second one applies the action, then tests the condition. The <code>do {..} while (..)</code> loop is used quite marginally compared to the others, since it runs the action at least once even if the condition is initially not met (which can lead to trouble, since the action is generally dependent on the condition). The <code>while</code> loop is more general than the <code>for</code> and <code>foreach</code> ones, which apply specifically to lists of objects. The <code>while</code> loop just has a condition to go on, which can be based on anything. For example: <pre><code>string name = string.empty; while (name == string.empty) { Console.WriteLine("Enter your name"); name = Console.ReadLine(); } </code></pre> asks the user to input his name then press Enter, until he actually inputs something. Nothing to do with lists, as you can see. 3. Conclusion When you are going through a list, you should use <code>foreach</code> unless you need the numeric index, in which case you should use <code>for</code>. When it doesn't have anything to do with list, and it's just a procedural construction, you should use <code>while(..) {..}</code>. Now to conclude with something less restrictive: your first goal with .NET should be to make your code readable/maintainable and make it run fast, in that order of priority. Anything that achieves that is good for you. Personally though, I think the <code>foreach</code> loop has the advantage that potentially, it's the most readable and the fastest. Edit: there is an other case where the <code>for</code> loop is useful: when you need indexing to go through a list in a special way or if you need to modify the list when in the loop. For example, in this case because we want to remove every null element from myList: <pre><code>for (int i=myList.Count-1; i>=0; i--) { if (myList[i] == null) myList.RemoveAt(i); } </code></pre> You need the <code>for</code> loop here because myList cannot be modified from within a <code>foreach</code> loop, and we need to go through it backwards because if you remove the element at the position i, the position of all elements with an index >i will change. But the use for these special constructions have been reduced since LINQ. The last example can be written like this in LINQ for example: <pre><code>myList.RemoveAll(obj => obj == null); </code></pre> LINQ is a second step though, learn the loops first.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POWhen to use each type of loop?
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USEvren Kuzucuoglu
UserOwnerUserId
1. USEvren Kuzucuoglu
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POWhen to use each type of loop?
 singulars
 PostTypePostTypeId
 PTQuestion
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTAcceptedByOriginator
CommentsPostId
1. COI didn't talk about LINQ here, because you said you're just starting, but eventually you will learn LINQ, and your use of all the loop constructions will dramatically drop (but they will still be there). But I think that loops are a very important concept and LINQ should be a second step.
 singulars
 PostPostId
 PO
 UserUserId
 USEvren Kuzucuoglu

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.