.NET/ASP.NET/C#/VB.NET PDF Document SDK

It lets that through because it s able to make that behave like we expect. This will in fact modify the Number property of the element in the array. And this is the rather subtle difference between an array and an indexer. With an array you really can work directly with the element inside the array no copying occurs in this example. This works because the C# compiler knows what an array is, and is able to generate code that deals directly with array elements in situ. But there s no way to write a custom indexer that offers the same flexibility. (There are reasons for this, but to explain them would require an exploration of the .NET Framework s type safety rules, which would be lengthy and quite outside the scope of this chapter.) Having established the root of the problem, let s look at what this means for List<T>.

barcode font for excel download, excel 2010 barcode formula, barcode generator excel 2007 free, barcode font in excel 2003, free barcode font excel 2013, free barcode generator excel 2010, how to make barcodes in excel 2016, free barcode font for excel 2003, free excel 2007 barcode add in, download barcode macro for excel,

The List<T> class gets no special privileges it may be part of the .NET Framework class library, but it is subject to the same restrictions as your code. And so it has the same problem just described the following code will produce the same compiler error you saw in the preceding section:

List<CanChange> numbers = new List<CanChange> { new CanChange() }; numbers[0].Number = 42; // Will not compile

Mutexes and read-write locks are good for protecting shared variables and other shared items when the access needs to be serialized. Sometimes your threads need to share not only a variable but also a limited number of resources such as the bytes of a buffer. This is where semaphores come in. A semaphore can be seen as a counting mutex, and a mutex can be seen as a binary semaphore. They are really the same thing, but a semaphore is initialized with a value instead of a single locking bit. When you lock a mutex, you acquire a value from the semaphore, which decreases the value of the semaphore. The value of the semaphore can never be less than zero, so if a thread tries to acquire more resources than the semaphore contains, the thread blocks until the requested amount is available. When you finish with the acquired value, you release it back to the semaphore, which increases the value of the semaphore. By releasing, you can increase the value of the semaphore beyond the initial value of the semaphore.

One way of dealing with this would be to avoid using custom value types in a collection class such as List<T>, preferring custom reference types instead. And that s not a bad rule of thumb reference types are a reasonable default choice for most data types. However, value types do offer one compelling feature if you happen to be dealing with very large volumes of data. As Figure 7-1 showed earlier, an array with reference type elements results in an object for the array itself, and one object for each element in the array. But when an array has value type elements, you end up with just one object the values live inside the array, as Figure 7-3 illustrates. List<T> has similar characteristics because it uses an array internally.

For an array with hundreds of thousands of elements, the simpler structure of Figure 7-3 can have a noticeable impact on performance. For example, I just ran a quick test on my computer to see how long it would take to create a List<CanChange> with 500,000 entries, and then run through the list, adding the Number values together. Example 7-28 shows the code it uses the Stopwatch class from the System.Diagnos tics namespace, which provides a handy way to see how long things are taking.

The ItemView control provides several methods (as shown in Table 8-14). Table 8-14. ItemView Methods

Stopwatch sw = new Stopwatch(); sw.Start(); int itemCount = 500000; List<CanChange> items = new List<CanChange>(itemCount); for (int i = 0; i < itemCount; ++i) { items.Add(new CanChange { Number = i }); } sw.Stop(); Console.WriteLine("Creation: " + sw.ElapsedTicks); sw.Reset(); sw.Start(); int total = 0; for (int i = 0; i < itemCount; ++i) { total += items[i].Number; } sw.Stop(); Console.WriteLine("Total: " + total); Console.WriteLine("Sum: " + sw.ElapsedTicks);