提升C#编程效率与稳健性：50个实战技巧

Effective

需积分: 9 65 浏览量更新于2024-07-21 收藏 2.1MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

资源详情

资源推荐

List<double> doubleList = new List<double>();

List<int> markers = new List<int>();

List<MyStruct> values = new List<MyStruct>();

This may be interesting, but why should you care? Generic types that will

be used with multiple different reference types do not affect the memory

footprint. All JIT-compiled code is shared. However, when closed generic

types contain value types as parameters, that JIT-compiled code is not shared.

Let’s dig a little deeper into that process to see how it will be affected.

When the runtime needs to JIT-compile a generic deﬁnition (either a

method or a class) and at least one of the type parameters is a value type,

it goes through a two-step process. First, it creates a new IL class that rep-

resents the closed generic type. I’m simplifying, but essentially the run-

time replaces

T with int, or the appropriate value type, in all locations in

the generic deﬁnition. After that replacement, it JIT-compiles the necessary

code into x86 instructions. This two-step process is necessary because the

JIT compiler does not create the x86 code for an entire class when loaded;

instead, each method is JIT-compiled only when ﬁrst called. Therefore, it

makes sense to do a block substitution in the IL and then JIT-compile the

resulting IL on demand, as is done with normal class deﬁnitions.

This means that the runtime costs of memory footprint add up in this

way: one extra copy of the IL deﬁnition for each closed generic type that

uses a value type, and a second extra copy of machine code for each

method called in each different value type parameter used in a closed

generic type.

There is, however, a plus side to using generics with value type parameters:

You avoid all boxing and unboxing of value types, thereby reducing the

size of both code and data for value types. Furthermore, type safety is

ensured by the compiler; thus, fewer runtime checks are needed, and that

reduces the size of the codebase and improves performance. Furthermore,

as discussed in Item 8, creating generic methods instead of generic classes

can limit the amount of extra IL code created for each separate instantia-

tion. Only those methods actually referenced will be instantiated. Generic

methods deﬁned in a nongeneric class are not JIT-compiled.

This chapter discusses many of the ways you can use generics and explains

how to create generic types and methods that will save you time and help

you create usable components. I also cover when and how to migrate .NET

1.x types (in which you use

System.Object) to .NET 2.0 types, in which

you specify type parameters.

Working with Generics

❘

Item 1: Use Generic Replacements of 1.x Framework API Classes

The ﬁrst two releases of the .NET platform did not support generics. Your

only choice was to code against

System.Object and add appropriate run-

time checks to ensure that the runtime type of the object was what you

expected, usually a speciﬁc type derived from

System.Object. This prac-

tice was even more widespread in the .NET Framework, because the

framework designers were creating a library of lower-level components

that would be used by everyone.

System.Object is the ultimate base class for every type you or anyone

else creates. That led to the obvious decision to use

System.Object as a

substitute for “whatever type you want to use in this space.” Unfortunately,

that’s all the compiler knows about your types. This means that you must

code everything very defensively—and so must everyone who uses your

types. Whenever you have

System.Object as a parameter or a return type,

you have the potential to substitute the wrong type. That’s a cause for run-

time errors in your code.

With the addition of generics, those days are gone. If you’ve been using .NET

for any period of time, you’ve probably adopted the habit of using many

classes and interfaces that now should be cast aside in favor of an updated

generic version. You can improve the quality of your code by replacing

System.Object with generic type parameters. Why? It’s because it’s much

harder to misuse generic types by supplying arguments of the wrong type.

If correctness isn’t enough to motivate you to replace your old

Sys-

tem.Object

code with generic equivalents, maybe performance will get

you interested. .NET 1.1 forced you to use the ultimate base class of

Sys-

tem.Object

and dynamically cast objects to the expected type before

using them. The 1.1 versions of any class or interface require that you box

and unbox value types every time you coerce between the value type and

the

System.Object type. Depending on your usage, that requirement may

have a signiﬁcant impact on performance. Of course, it applies only with

value types. But, as I said earlier, the weakly typed systems from the 1.1

days require both you and your users to author defensive code to test the

runtime type of your parameters and return types. Even when that code

functions correctly, it adds runtime performance costs. And it’s worse

when it fails; the runtime costs probably include stack walks and unwind-

ing when casts throw exceptions and the runtime searches for the proper

catch clause. You run the risk of everything from costly application slow-

down to abnormal application termination.

❘

Chapter 1 Working with Generics

A good look at the .NET Framework 2.0 shows you how much you can

transform your code by using generics. The obvious starting point is the

System.Collections.Generics namespace, followed by the System.Col-

lections.ObjectModel

namespace. Every class that is part of the Sys-

tem.Collections

namespace has a new, improved counterpart in

System.Collections.Generics. For example, ArrayList has been

superseded by

List<T>, Stack has been replaced by Stack<T>,

Hashtable has been replaced by Dictionary<K,V>, and Queue has been

replaced by

Queue<T>. In addition, there are a few new collections, such as

SortedList<T> and LinkedList<T>.

The addition of these classes meant the addition of generic interfaces.

Again, the

System.Collections.Generics namespace points to the

obvious examples. The original

IList interface has been extended with

IList<T>. All the collections-based interfaces have been similarly

upgraded:

IDictionary<K,V> replaces IDictionary, IEnumerable<T>

extends IEnumerable, IComparer<T> replaces IComparer, and ICol-

lection<T>

replaces ICollection.

I say “extends” and “replaces” deliberately. Many of the generic interfaces

derive from their nongeneric counterparts, extending the classic capabil-

ity with upgraded, type-speciﬁc versions. Other classic interfaces are not

part of the signature of the newer interfaces. For a variety of reasons, the

newer interface method signatures aren’t consistent with the classic inter-

faces. When that happened, the framework designers chose not to tie the

new interface deﬁnitions to an outdated interface.

The .NET 2.0 Framework has added an

IEquatable<T> interface to min-

imize the potential errors involved in overriding

System.Object.Equals:

public interface IEquatable<T>

{

bool Equals(T other);

}

You should add support for this interface wherever you would have over-

written

System.Object.Equals.

If you need to perform comparisons on a type deﬁned in another library,

the .NET 2.0 Framework has also added a new equality interface in the

generic collections namespace:

IEqualityComparer<T>. This interface

has two methods:

Equals and GetHashCode.

Item 1: Use Generic Replacements of 1.x Framework API Classes

❘

剩余308页未读，继续阅读

llq910215

粉丝: 0
资源: 1

提升C#编程效率与稳健性：50个实战技巧

More Effective C#: 50 Specific Ways to Improve Your C#

More Effective c# 清晰版

More Effective C#中文版.pdf

more effective c++第三版 pdf下载

more effective c++ 中文版 2011pdf

effective c# pdf

more effective c++ pdf

more effective c++pdf

侯捷 more effective c++下载

more effective c++:35个改善编程与设计的有效方法(中文版) .pdf

more effective c++中文版目录

more effective c++第三版下载

c#方向比较著名的文献

<input type="date" class="form-control" runat="server" id="EffectiveDate" clientidmode="static">後端C#怎麼把日期傳回來這個id為EffectiveDate的控件綁定

moreeffective c++

more effective c++

如何理解less is more？give a example

<input type="date" class="form-control" runat="server" id="EffectiveDate" clientidmode="static">後端C#怎麼把日期傳回來綁定

c# with open

effective c++ pdf csdn

最新资源