Visual Studio 2010与C# 4, ASP.NET 4, WPF快速入门

需积分: 10 100 浏览量更新于2024-07-29 收藏 9.63MB PDF 举报

"C# 4, ASP.NET 4, 和 WPF 通过 Visual Studio 2010 快速启动" 本资源是一本针对初学者的电子书，主要涵盖了使用Visual Studio 2010进行C# 4、ASP.NET 4和Windows Presentation Foundation (WPF)开发的基础知识。以下是这些技术的关键知识点： **C# 4** 1. **协变与逆变**：C# 4引入了协变和逆变的概念，允许在不破坏类型安全的情况下，更灵活地使用泛型接口和委托。协变允许将派生类型的对象赋值给基类型的引用，而逆变则允许泛型参数在作为输出时接受基类型。 2. **元组(Tuples)**：元组是一种轻量级的数据结构，可以方便地存储多个值，而无需定义新的类或结构。它们在C# 4中得到支持，使得数据的临时组合变得更加简单。 3. **动态类型(Dynamic Type)**：动态类型允许在运行时解析操作，提供了与COM互操作和IronPython/IronRuby等动态语言集成的能力。`dynamic`关键字用于声明变量，该变量的行为直到运行时才被确定。 4. **代码契约(Code Contracts)**：代码契约是.NET框架的一部分，它提供了一种在编译时和运行时验证代码正确性的机制。包括预条件(方法调用前的条件)，后置条件(方法返回后的条件)和不变量(类的内部状态)。 5. **任务(Task)**：任务是异步编程的一个核心概念，允许开发者在后台执行耗时的操作，而不阻塞主线程。`Task`类是异步编程的核心，提供了创建、管理和控制异步操作的方法。 **ASP.NET 4** 6. **任务(Task)**：在ASP.NET 4中，任务也被引入以支持异步Web操作，提高了服务器处理请求的效率。例如，可以使用`Task`来启动异步操作，然后使用`ContinueWith`方法来定义任务完成后的后续操作。 7. **并行类(Parallel Class)**：`System.Threading.Tasks.Parallel`类提供了一组方法，如`Parallel.For`和`Parallel.ForEach`，用于并行处理集合，提高多核处理器环境下的性能。 8. **取消框架(Cancellation Framework)**：ASP.NET 4中的取消框架允许优雅地取消长时间运行的任务或操作，通过`CancellationToken`和`CancellationTokenSource`类实现。 **Windows Presentation Foundation (WPF)** 9. **任务栏和跳转列表(Taskbar and Jump List)**：WPF在Visual Studio 2010中支持Windows 7的新特性，如任务栏缩略图、跳转列表，提供更好的用户界面交互。书中还涉及了其他高级主题，如图表服务器控件、数据库访问、用户体验设计、以及如何利用Visual Studio 2010的调试和性能分析工具。这些内容旨在帮助开发者快速掌握C# 4、ASP.NET 4和WPF的开发技能，充分利用Visual Studio 2010的强大功能。

PROFESSIONAL C# 4 AND .NET 4

❘

IL_0057: ldsfld class [System.Core]System.Runtime.CompilerServices.CallSite`1

<class [mscorlib]System.Action`3

<class [System.Core]System.Runtime.CompilerServices.CallSite,

class [mscorlib]System.Type,object>> DeCompile.Program/’<Main>o__

SiteContainer0’::’<>p__Site1’

IL_005c: ldtoken [mscorlib]System.Console

IL_0061: call class [mscorlib]System.Type [mscorlib]System.

Type::GetTypeFromHandle

(valuetype [mscorlib]System.RuntimeTypeHandle)

IL_0066: ldloc.0

IL_0067: ldfld object DeCompile.DynamicClass::DynValue

IL_006c: callvirt instance void class [mscorlib]System.Action`3

<class [System.Core]System.Runtime.CompilerServices.CallSite, class

[mscorlib]System.Type,object>::Invoke(!0,!1,!2)

IL_0071: nop

IL_0072: call string [mscorlib]System.Console::ReadLine()

IL_0077: pop

IL_0078: ret

} // end of method Program::Main

So it’s safe to say that the C# compiler is doing a little extra work to support the dynamic type.

Looking at the generated code, you can see references to

System.Runtime.CompilerServices.

CallSite

and System.Runtime.CompilerServices.CallSiteBinder.

The

CallSite is a type that handles the lookup at runtime. When a call is made on a dynamic

object at runtime, something has to go and look at that object to see if the member really exists. The

call site caches this information so the lookup doesn’t have to be performed repeatedly. Without this

process, performance in looping structures would be questionable.

After the

CallSite does the member lookup, the CallSiteBinder is invoked. It takes the information

from the call site and generates an expression tree representing the operation the binder is bound to.

There is obviously a lot going on here. Great care has been taken to optimize what would appear to

be a very complex operation. It should be obvious that while using the

dynamic type can be useful,

it does come with a price.

CODE CONTRACTS

Design-by-contracts is an idea from the Eiffel programming language. Now .NET 4 includes classes

for static and runtime checks of code within the namespace

System.Diagnostics.Contracts that

can be used by all .NET languages.

With this functionality you can deﬁne preconditions, postconditions, and invariants within a

method. The preconditions lists what requirements the parameters must fulﬁll, the postconditions

deﬁne the requirements on returned data, and the invariants deﬁne the requirements of variables

within the method itself.

Contract information can be compiled both into the debug and the release code. It is also possible to

deﬁne a separate contract assembly, and many checks can also be made statically without running

the application. You can also deﬁne contracts on interfaces that cause the implementations of the

interface to fulﬁll the contracts. Contract tools can rewrite the assembly to inject contract checks

PROFESSIONAL C# 4 AND .NET 4

❘

ContractFailedEventArgs parameter e stops the standard behavior of failures that would throw

an exception.

Contract.ContractFailed += (sender, e) =>

{

Console.WriteLine(e.Message);

e.SetHandled();

};

Pro C# 4 9780470502259 code snippet CodeContractsSamples/Program.cs

Preconditions

Preconditions check the parameters that are passed to a method. Requires() and

Requires<TException>() are preconditions that can be deﬁned with the Contract class. With

the

Requires() method, a Boolean value must be passed, and an optional message string with the

second parameter that is shown when the condition does not succeed. The following sample requires

that the argument

min be lower than or equal to the argument max.

static void MinMax(int min, int max)

{

Contract.Requires(min <= max);

//...

}

Pro C# 4 9780470502259 code snippet CodeContractsSamples/Program.cs

The following contract throws an ArgumentNullException if the argument o is null. The exception

is not thrown if an event handler that sets the

ContractFailed event to handled. Also, if the Assert

on Contract Failure is conﬁgured,

Trace.Assert() is done to stop the program instead of throwing

the exception deﬁned.

static void Preconditions(object o)

{

Contract.Requires<ArgumentNullException>(o != null,

“Preconditions, o may not be null”);

//...

Requires<TException>() is not annotated with the attribute [Conditional(“CONTRACTS_

FULL“)]

, and it also doesn’t have a condition on the DEBUG symbol, so this runtime check is done

in any case.

Requires<TException>() throws the deﬁned exception if the condition is not fulﬁlled.

With a lot of legacy code, arguments are often checked with

if statements and throw an exception

if a condition is not fulﬁlled. With code contracts, it is not necessary to rewrite the veriﬁcation; just

add one line of code:

static void PrecondtionsWithLegacyCode(object o)

{

if (o == null) throw new ArgumentNullException(“o”);

Contract.EndContractBlock();

The EndContractBlock() deﬁnes that the preceding code should be handled as a contract. If other

contract statements are used as well, the

EndContractBlock() is not necessary.

PROFESSIONAL C# 4 AND .NET 4

❘

For checking collections that are used as arguments, the Contract class offers Exists() and

ForAll() methods. ForAll() checks every item in the collection if the condition succeeds. In the

example, it is checked if every item in the collection has a value smaller than 12. With the

Exists()

method, it is checked if any one element in the collection succeeds the condition.

static void ArrayTest(int[] data)

{

Contract.Requires(Contract.ForAll(data, i => i < 12));

Both the methods Exists() and ForAll() have an overload where you can pass two integers,

fromInclusive and toExclusive, instead of IEnumerable<T>. A range from the numbers (exclud-

ing

toExclusive) is passed to the delegate Predicate<int> deﬁned with the third parameter.

Exists() and ForAll() can be used with preconditions, postconditions, and also invariants.

Postconditions

Postconditions deﬁne guarantees about shared data and return values after the method has com-

pleted. Although they deﬁne some guarantees on return values, they must be written at the begin-

ning of a method; all contract requirements must be at the beginning of the method.

Ensures() and EnsuresOnThrow<TException>() are postconditions. The following contract

ensures that the variable

sharedState is lower than 6 at the end of the method. The value can

change in between.

private static int sharedState = 5;

static void Postcondition()

{

Contract.Ensures(sharedState < 6);

sharedState = 9;

Console.WriteLine(“change sharedState invariant {0}”, sharedState);

sharedState = 3;

Console.WriteLine(“before returning change it to a valid value {0}”,

sharedState);

}

Pro C# 4 9780470502259 code snippet CodeContractsSamples/Program.cs

With EnsuresOnThrow<TException>(), it is guaranteed that a shared state succeeds a condition if

a speciﬁed exception is thrown.

To guarantee a return value, the special value

Result<T> can be used with an Ensures() contract.

Here, the result is of type

int as is also deﬁned with the generic type T for the Result() method.

The

Ensures() contract guarantees that the return value is lower than 6.

static int ReturnValue()

{

Contract.Ensures(Contract.Result<int>() < 6);

return 3;

}

You can also compare a value to an old value. This is done with the OldValue<T>() method that

returns the original value on method entry for the variable passed. The following ensures that the

PROFESSIONAL C# 4 AND .NET 4

❘

contract deﬁnes that the result returned (Contract.Result<int>()) is larger than the old value

from the argument

x (Contract.OldValue<int>(x)).

static int ReturnLargerThanInput(int x)

{

Contract.Ensures(Contract.Result<int>() > Contract.OldValue<int>(x));

return x + 3;

}

If a method returns values with the out modiﬁer instead of just with the return statement, condi-

tions can be deﬁned with

ValueAtReturn(). The following contract deﬁnes that the x variable must

be larger than 5 and smaller than 20 on return, and with the y variable modulo 5 must equal 0 on

return.

static void OutParameters(out int x, out int y)

{

Contract.Ensures(Contract.ValueAtReturn<int>(out x) > 5 &&

Contract.ValueAtReturn<int>(out x) < 20);

Contract.Ensures(Contract.ValueAtReturn<int>(out y) % 5 == 0);

x = 8;

y = 10;

}

Invariants

Invariants deﬁne contracts for variables during the method lifetime. Contract.Requires()

deﬁnes input requirements,

Contract.Ensures() deﬁnes requirements on method end. Contract.

Invariant()

deﬁnes conditions that must succeed during the whole lifetime of the method.

static void Invariant(ref int x)

{

Contract.Invariant(x > 5);

x = 3;

Console.WriteLine(“invariant value: {0}”, x);

x = 9;

}

Pro C# 4 9780470502259 code snippet CodeContractsSamples/Program.cs

Contracts for Interfaces

With interfaces you can deﬁne methods, properties, and events that a class that derives from the

interface must implement. With the interface declaration you cannot deﬁne how the interface must

be implemented. Now this is possible using code contracts.

Take a look at the following interface. The interface

IPerson deﬁnes FirstName, LastName,

and

Age properties, and the method ChangeName(). What’s special with this interface is just the

attribute

ContractClass. This attribute is applied to the interface IPerson and deﬁnes that the

PersonContract class is used as the code contract for this interface.

[ContractClass(typeof(PersonContract))]

public interface IPerson

{

string FirstName { get; set; }

剩余129页未读，继续阅读

xqzl

粉丝: 4
资源: 3

Visual Studio 2010与C# 4, ASP.NET 4, WPF快速入门

Visual Studio 2010与C# 4, ASP.NET 4, WPF开发入门

Visual Studio 2010 Web开发新特性：C++, C#与ASP.NET4

.NET框架与C#入门：Visual Studio与首个应用程序

Wrox.C#.4.ASP.NET.4.and.WPF.with.Visual.Studio.2010.Jump.Start

C# ，asp.net，Microsoft Visual Studio

《wpf编程宝典—c#2010版》针对了解.net平台、c#语言以及visual studio开发环境的专业开发人员

C＃/ VB.Net中的高级WPF TreeViews第5部分，共n部分

Visual Studio 2010与C# 4, ASP.NET 4, WPF快速入门

.NET入门教程：C#与Visual Studio的使用

Introducing .net 4.0 with visual studio 2010

最新资源

　《wpf编程宝典—c#2010版》针对了解.net平台、c#语言以及visual studio开发环境的专业开发人员