Bookcold's Blog » .Net

《CLR via C#, Third Edition》第三版

bookcold — Sat, 20 Feb 2010 03:41:10 +0000

特大喜讯！！

下载地址：http://www.ppurl.com/2010/02/clr-via-csharp-third-edition.html

主要内容：

Part I CLR Basics

1 The CLR’s Execution Model . 1

Compiling Source Code into Managed Modules . 1

Combining Managed Modules into Assemblies 5

Loading the Common Language Runtime 6

Executing Your Assembly’s Code 9

IL and Verification 15

Unsafe Code 16

The Native Code Generator Tool: NGen.exe . 18

The Framework Class Library . 20

The Common Type System 22

The Common Language Specification . 25

Interoperability with Unmanaged Code 29

2 Building, Packaging, Deploying, and Administering Applications

and Types 31

.NET Framework Deployment Goals 32

Building Types into a Module 33

Response Files . 34

A Brief Look at Metadata . 36

Combining Modules to Form an Assembly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .43

Adding Assemblies to a Project by Using the Visual Studio IDE 49

Using the Assembly Linker 50

Adding Resource Files to an Assembly . 52

Assembly Version Resource Information . 53

Version Numbers 57

Culture . 58

Simple Application Deployment (Privately Deployed Assemblies) . 59

Simple Administrative Control (Configuration) 61

3 Shared Assemblies and Strongly Named Assemblies . 65

Two Kinds of Assemblies, Two Kinds of Deployment 66

Giving an Assembly a Strong Name . 67

The Global Assembly Cache 73

Building an Assembly That References a Strongly Named Assembly 75

Strongly Named Assemblies Are Tamper-Resistant 76

Delayed Signing . 77

Privately Deploying Strongly Named Assemblies 80

How the Runtime Resolves Type References 81

Advanced Administrative Control (Configuration) 84

Publisher Policy Control 87

Part II Designing Types

4 Type Fundamentals 91

All Types Are Derived from System.Object . 91

Casting Between Types . 93

Casting with the C# is and as Operators . 95

Namespaces and Assemblies . 97

How Things Relate at Runtime 102

5 Primitive, Reference, and Value Types . 113

Programming Language Primitive Types 113

Checked and Unchecked Primitive Type Operations . 117

Reference Types and Value Types . 121

Boxing and Unboxing Value Types . 127

Changing Fields in a Boxed Value Type by Using Interfaces (and Why You

Shouldn’t Do This) . 140

Object Equality and Identity 143

Object Hash Codes 146

The dynamic Primitive Type 148

6 Type and Member Basics . 155

The Different Kinds of Type Members . 155

Type Visibility 158

Friend Assemblies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .159

Member Accessibility 160

Static Classes . 162

Partial Classes, Structures, and Interfaces . 164

Components, Polymorphism, and Versioning 165

How the CLR Calls Virtual Methods, Properties, and Events 167

Using Type Visibility and Member Accessibility Intelligently . 172

Dealing with Virtual Methods When Versioning Types . . . . . . . . . . . . . . . . . . . . .175

7 Constants and Fields 181

Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .181

Fields 183

8 Methods . 187

Instance Constructors and Classes (Reference Types) . 187

Instance Constructors and Structures (Value Types) . 191

Type Constructors 194

Type Constructor Performance 198

Operator Overload Methods . 200

Operators and Programming Language Interoperability . 203

Conversion Operator Methods 204

Extension Methods 207

Rules and Guidelines 210

Extending Various Types with Extension Methods 211

The Extension Attribute 213

Partial Methods 213

Rules and Guidelines 216

9 Parameters . 219

Optional and Named Parameters . 219

Rules and Guidelines 220

The DefaultParameterValue and Optional Attributes 222

Implicitly Typed Local Variables 223

Passing Parameters by Reference to a Method 225

Passing a Variable Number of Arguments to a Method . 231

Parameter and Return Type Guidelines . 233

Const-ness 235

10 Properties 237

Parameterless Properties 237

Automatically Implemented Properties . 241

Defining Properties Intelligently 242

Object and Collection Initializers 245

Anonymous Types 247

The System.Tuple Type 250

Parameterful Properties . 252

The Performance of Calling Property Accessor Methods 257

Property Accessor Accessibility . 258

Generic Property Accessor Methods 258

11 Events . 259

Designing a Type That Exposes an Event 260

Step #1: Define a type that will hold any additional information

that should be sent to receivers of the event notification 261

Step #2: Define the event member . 262

Step #3: Define a method responsible for raising the event to

notify registered objects that the event has occurred . 263

Step #4: Define a method that translates the input into the desired event 266

How the Compiler Implements an Event . 266

Designing a Type That Listens for an Event 269

Explicitly Implementing an Event 271

12 Generics . 275

Generics in the Framework Class Library . 280

Wintellect’s Power Collections Library . 281

Generics Infrastructure . 282

Open and Closed Types 283

Generic Types and Inheritance 285

Generic Type Identity 287

Code Explosion . 288

Generic Interfaces 289

Generic Delegates 290

Delegate and Interface Contravariant and Covariant Generic Type Arguments 291

Generic Methods . 293

Generic Methods and Type Inference 294

Generics and Other Members . 296

Verifiability and Constraints . 296

Primary Constraints 299

Secondary Constraints . 300

Constructor Constraints 301

Other Verifiability Issues . 302

13 Interfaces . 307

Class and Interface Inheritance . 308

Defining an Interface 308

Inheriting an Interface 310

More About Calling Interface Methods . 312

Implicit and Explicit Interface Method Implementations (What’s Happening

Behind the Scenes) . 314

Generic Interfaces 315

Generics and Interface Constraints 318

Implementing Multiple Interfaces That Have the Same Method Name

and Signature 319

Improving Compile-Time Type Safety with Explicit Interface Method

Implementations 320

Be Careful with Explicit Interface Method Implementations . 322

Design: Base Class or Interface? 325

Part III Essential Types

14 Chars, Strings, and Working with Text 327

Characters . 327

The System.String Type . 330

Constructing Strings 330

Strings Are Immutable . 333

Comparing Strings . 334

String Interning . 340

String Pooling . 343

Examining a String’s Characters and Text Elements . 343

Other String Operations 346

Constructing a String Efficiently 346

Constructing a StringBuilder Object 347

StringBuilder Members 348

Obtaining a String Representation of an Object: ToString 350

Specific Formats and Cultures 351

Formatting Multiple Objects into a Single String . 355

Providing Your Own Custom Formatter . 356

Parsing a String to Obtain an Object: Parse . 359

Encodings: Converting Between Characters and Bytes 361

Encoding and Decoding Streams of Characters and Bytes 367

Base-64 String Encoding and Decoding 368

Secure Strings . 369

15 Enumerated Types and Bit Flags 373

Enumerated Types . 373

Bit Flags . 379

Adding Methods to Enumerated Types . 383

16 Arrays 385

Initializing Array Elements 388

Casting Arrays 390

All Arrays Are Implicitly Derived from System.Array . 392

All Arrays Implicitly Implement IEnumerable, ICollection, and IList 393

Passing and Returning Arrays 394

Creating Non-Zero–Lower Bound Arrays 395

Array Access Performance 396

Unsafe Array Access and Fixed-Size Array 401

17 Delegates . 405

A First Look at Delegates 405

Using Delegates to Call Back Static Methods . 408

Using Delegates to Call Back Instance Methods 409

Demystifying Delegates 410

Using Delegates to Call Back Many Methods (Chaining) . 415

C#’s Support for Delegate Chains . 419

Having More Control over Delegate Chain Invocation . 419

Enough with the Delegate Definitions Already (Generic Delegates) 422

C#’s Syntactical Sugar for Delegates 423

Syntactical Shortcut #1: No Need to Construct a Delegate Object 424

Syntactical Shortcut #2: No Need to Define a Callback Method 424

Syntactical Shortcut #3: No Need to Wrap Local Variables in a Class

Manually to Pass Them to a Callback Method 428

Delegates and Reflection . 431

18 Custom Attributes 435

Using Custom Attributes 435

Defining Your Own Attribute Class . 439

Attribute Constructor and Field/Property Data Types 443

Detecting the Use of a Custom Attribute 444

Matching Two Attribute Instances Against Each Other 448

Detecting the Use of a Custom Attribute Without Creating Attribute-Derived

Objects . 451

Conditional Attribute Classes 454

19 Nullable Value Types 457

C#’s Support for Nullable Value Types . 459

C#’s Null-Coalescing Operator 462

The CLR Has Special Support for Nullable Value Types 463

Boxing Nullable Value Types 463

Unboxing Nullable Value Types . 463

Calling GetType via a Nullable Value Type . 464

Calling Interface Methods via a Nullable Value Type 464

Part IV Core Facilities

20 Exceptions and State Management . 465

Defining “Exception” . 466

Exception-Handling Mechanics 467

The try Block . 468

The catch Block . 469

The finally Block 470

The System.Exception Class 474

FCL-Defined Exception Classes 478

Throwing an Exception . 480

Defining Your Own Exception Class . 481

Trading Reliability for Productivity . 484

Guidelines and Best Practices 492

Use finally Blocks Liberally 492

Don’t Catch Everything 494

Recovering Gracefully from an Exception 495

Backing Out of a Partially Completed Operation When an Unrecoverable

Exception Occurs—Maintaining State 496

Hiding an Implementation Detail to Maintain a “Contract” . 497

Unhandled Exceptions 500

Debugging Exceptions 504

Exception-Handling Performance Considerations 506

Constrained Execution Regions (CERs) . 509

Code Contracts . .512

21 Automatic Memory Management (Garbage Collection) 519

Understanding the Basics of Working in a Garbage-Collected Platform 520

Allocating Resources from the Managed Heap 521

The Garbage Collection Algorithm 523

Garbage Collections and Debugging 527

Using Finalization to Release Native Resources . 530

Guaranteed Finalization Using CriticalFinalizerObject Types . 532

Interoperating with Unmanaged Code by Using SafeHandle Types 535

Using Finalization with Managed Resources 537

What Causes Finalize Methods to Be Called? 540

Finalization Internals . 541

The Dispose Pattern: Forcing an Object to Clean Up 544

Using a Type That Implements the Dispose Pattern . 548

C#’s using Statement . 551

An Interesting Dependency Issue . 554

Monitoring and Controlling the Lifetime of Objects Manually . 555

Resurrection 566

Generations . 568

Other Garbage Collection Features for Use with Native Resources . 574

Predicting the Success of an Operation that Requires a Lot of Memory 578

Programmatic Control of the Garbage Collector 580

Thread Hijacking 583

Garbage Collection Modes 585

Large Objects . 588

Monitoring Garbage Collections 589

22 CLR Hosting and AppDomains . 591

CLR Hosting 592

AppDomains . 594

Accessing Objects Across AppDomain Boundaries 597

AppDomain Unloading . 609

AppDomain Monitoring . 610

AppDomain First-Chance Exception Notifications 612

How Hosts Use AppDomains . 612

Executable Applications 612

Microsoft Silverlight Rich Internet Applications . 613

Microsoft ASP.NET Web Forms and XML Web Services Applications 613

Microsoft SQL Server . 614

Your Own Imagination 614

Advanced Host Control 615

Managing the CLR by Using Managed Code 615

Writing a Robust Host Application . 616

How a Host Gets Its Thread Back 617

23 Assembly Loading and Reflection 621

Assembly Loading 621

Using Reflection to Build a Dynamically Extensible Application . . . . . . . . . . . . . . . . . . .626

Reflection Performance 627

Discovering Types Defined in an Assembly . 628

What Exactly Is a Type Object? 628

Building a Hierarchy of Exception-Derived Types 631

Constructing an Instance of a Type 632

Designing an Application That Supports Add-Ins . 634

Using Reflection to Discover a Type’s Members 637

Discovering a Type’s Members 638

BindingFlags: Filtering the Kinds of Members That Are Returned . 643

Discovering a Type’s Interfaces 644

Invoking a Type’s Members 646

Bind Once, Invoke Multiple Times . 650

Using Binding Handles to Reduce Your Process’s Memory Consumption . 658

24 Runtime Serialization . 661

Serialization/Deserialization Quick Start . 662

Making a Type Serializable 667

Controlling Serialization and Deserialization 668

How Formatters Serialize Type Instances 672

Controlling the Serialized/Deserialized Data 673

How to Define a Type That Implements ISerializable when the Base

Type Doesn’t Implement This Interface 678

Streaming Contexts . 680

Serializing a Type as a Different Type and Deserializing an Object as a

Different Object 682

Serialization Surrogates 684

Surrogate Selector Chains 688

Overriding the Assembly and/or Type When Deserializing an Object 689

Part V Threading

25 Thread Basics . 691

Why Does Windows Support Threads? 691

Thread Overhead . 692

Stop the Madness 696

CPU Trends 699

NUMA Architecture Machines . 700

CLR Threads and Windows Threads . 703

Using a Dedicated Thread to Perform an Asynchronous Compute-Bound

Operation . 704

Reasons to Use Threads 706

Thread Scheduling and Priorities 708

Foreground Threads versus Background Threads . 713

What Now? 715

26 Compute-Bound Asynchronous Operations 717

Introducing the CLR’s Thread Pool . 718

Performing a Simple Compute-Bound Operation . 719

Execution Contexts 721

Cooperative Cancellation . 722

Tasks . 726

Waiting for a Task to Complete and Getting Its Result . 727

Cancelling a Task 729

Starting a New Task Automatically When Another Task Completes . 731

A Task May Start Child Tasks 733

Inside a Task 733

Task Factories 735

Task Schedulers . 737

Parallel’s Static For, ForEach, and Invoke Methods 739

Parallel Language Integrated Query 743

Performing a Periodic Compute-Bound Operation 747

So Many Timers, So Little Time 749

How the Thread Pool Manages Its Threads 750

Setting Thread Pool Limits 750

How Worker Threads Are Managed . 751

Cache Lines and False Sharing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .752

27 I/O-Bound Asynchronous Operations . 755

How Windows Performs I/O Operations . 755

The CLR’s Asynchronous Programming Model (APM) 761

The AsyncEnumerator Class 765

The APM and Exceptions 769

Applications and Their Threading Models 770

Implementing a Server Asynchronously 773

The APM and Compute-Bound Operations 774

APM Considerations 776

Using the APM Without the Thread Pool 776

Always Call the EndXxx Method, and Call It Only Once . 777

Always Use the Same Object When Calling the EndXxx Method . 778

Using ref, out, and params Arguments with BeginXxx and

EndXxx Methods 778

You Can’t Cancel an Asynchronous I/O-Bound Operation 778

Memory Consumption 778

Some I/O Operations Must Be Done Synchronously . 779

FileStream-Specific Issues . 780

I/O Request Priorities 780

Converting the IAsyncResult APM to a Task 783

The Event-Based Asynchronous Pattern 784

Converting the EAP to a Task . 786

Comparing the APM and the EAP . 788

Programming Model Soup 788

28 Primitive Thread Synchronization Constructs 791

Class Libraries and Thread Safety . 793

Primitive User-Mode and Kernel-Mode Constructs 794

User-Mode Constructs 796

Volatile Constructs . 797

Interlocked Constructs 803

Implementing a Simple Spin Lock . 807

The Interlocked Anything Pattern . 811

Kernel-Mode Constructs 813

Event Constructs . 817

Semaphore Constructs 819

Mutex Constructs . 820

Calling a Method When a Single Kernel Construct Becomes Available . 822

29 Hybrid Thread Synchronization Constructs 825

A Simple Hybrid Lock 826

Spinning, Thread Ownership, and Recursion 827

A Potpourri of Hybrid Constructs . 829

The ManualResetEventSlim and SemaphoreSlim Classes 830

The Monitor Class and Sync Blocks . 830

The ReaderWriterLockSlim Class . 836

The OneManyLock Class 838

The CountdownEvent Class . 841

The Barrier Class . 841

Thread Synchronization Construct Summary 842

The Famous Double-Check Locking Technique . 844

The Condition Variable Pattern . 848

Using Collections to Avoid Holding a Lock for a Long Time . 851

The Concurrent Collection Classes . 856

Index . 861

.Net中堆（Heap）和栈(Stack)的使用

bookcold — Fri, 22 Jan 2010 09:23:39 +0000

在C-SharpCorner上看到一个系列的文章，还不错！

C# Heap(ing) Vs Stack(ing) in .NET: Part I 第一篇介绍基础知识，比如啥是值类型啥事引用类型

C# Heap(ing) Vs Stack(ing) in .NET: Part II 第二篇介绍了点参数传递，函数调用中堆栈的使用

C# Heap(ing) Vs Stack(ing) in .NET: Part III 第三篇介绍了类的拷贝

C# Heap(ing) Vs Stack(ing) in .NET: Part IV 第四篇介绍了垃圾回收机制

转一下，第三篇的内容，还是挺不错的

A Copy Is Not A Copy.

To clearly define the problem, let’s examine what happens when there is a value type on the heap versus having a reference type on the heap. First we’ll look at the value type. Take the following class and struct. We have a Dude class which contains a Name element and two Shoe(s). We have a CopyDude() method to make it easier to make new Dudes.

[code lang="csharp"]
public struct Shoe{
public string Color;
}

public class Dude
{
public string Name;
public Shoe RightShoe;
public Shoe LeftShoe;

public Dude CopyDude()
{
Dude newPerson = new Dude();
newPerson.Name = Name;
newPerson.LeftShoe = LeftShoe;
newPerson.RightShoe = RightShoe;

return newPerson;
}

public override string ToString()
{
return (Name + " : Dude!, I have a " + RightShoe.Color +
" shoe on my right foot, and a " +
LeftShoe.Color + " on my left foot.");
}

}
[/code]

Our Dude class is a variable type and because the Shoe struct is a member element of the class they both end up on the heap.

When we run the following method:

[code lang="csharp"]
public static void Main()
{
Class1 pgm = new Class1();

Dude Bill = new Dude();
Bill.Name = "Bill";
Bill.LeftShoe = new Shoe();
Bill.RightShoe = new Shoe();
Bill.LeftShoe.Color = Bill.RightShoe.Color = "Blue";

Dude Ted = Bill.CopyDude();
Ted.Name = "Ted";
Ted.LeftShoe.Color = Ted.RightShoe.Color = "Red";

Console.WriteLine(Bill.ToString());
Console.WriteLine(Ted.ToString());
}
[/code]

We get the expected output:

Bill : Dude!, I have a Blue shoe on my right foot, and a Blue on my left foot.
Ted : Dude!, I have a Red shoe on my right foot, and a Red on my left foot.

What happens if we make the Shoe a reference type? Herein lies the problem. If we change the Shoe to a reference type as follows:

[code lang="csharp"]

public class Shoe{

public string Color;

}

[/code]

and run the exact same code in Main(), look how our input changes:

Bill : Dude!, I have a Red shoe on my right foot, and a Red on my left foot
Ted : Dude!, I have a Red shoe on my right foot, and a Red on my left foot

The Red shoe is on the other foot. This is clearly an error. Do you see why it’s happening? Here’s what we end up with in the heap.

Because we now are using Shoe as a reference type instead of a value type and when the contents of a reference type are copied only the pointer is copied (not the actual object being pointed to), we have to do some extra work to make our Shoe reference type behave more like a value type.

Luckily, we have an interface that will help us out: ICloneable. This interface is basically a contract that all Dudes will agree to and defines how a reference type is duplicated in order to avoid our “shoe sharing” error. All of our classes that need to be “cloned” should use the ICloneable interface, including the Shoe class.

ICloneable consists of one method: Clone()

[code lang="csharp"]
public object Clone()
{

}
public class Shoe : ICloneable
{
public string Color;
#region ICloneable Members

public object Clone()
{
Shoe newShoe = new Shoe();
newShoe.Color = Color.Clone() as string;
return newShoe;
}

#endregion
}
[/code]

Inside the Cone() method, we just make a new Shoe, clone all the reference types and copy all the value types and return the new object. You probably noticed that the string class already implements ICloneable so we can call Color.Clone(). Because Clone() returns a reference to an object, we have to “retype” the reference before we can set the Color of the shoe.

Next, in our CopyDude() method we need to clone the shoes instead of copying them

[code lang="csharp"]
public Dude CopyDude()
{
Dude newPerson = new Dude();
newPerson.Name = Name;
newPerson.LeftShoe = LeftShoe.Clone() as Shoe;
newPerson.RightShoe = RightShoe.Clone() as Shoe;

return newPerson;
}

public static void Main()
{
Class1 pgm = new Class1();

Dude Bill = new Dude();
Bill.Name = "Bill";
Bill.LeftShoe = new Shoe();
Bill.RightShoe = new Shoe();
Bill.LeftShoe.Color = Bill.RightShoe.Color = "Blue";

Dude Ted = Bill.CopyDude();
Ted.Name = "Ted";
Ted.LeftShoe.Color = Ted.RightShoe.Color = "Red";

Console.WriteLine(Bill.ToString());
Console.WriteLine(Ted.ToString());

}
[/code]

We get:

Bill : Dude!, I have a Blue shoe on my right foot, and a Blue on my left foot
Ted : Dude!, I have a Red shoe on my right foot, and a Red on my left foot

Which is what we want.

Wrapping Things Up.

So as a general practice, we want to always clone reference types and copy value types. (It will reduce the amount of aspirin you will have to purchase to manage the headaches you get debugging these kinds of errors.)

So in the spirit of headache reduction, let’s take it one step further and clean up the Dude class to implement ICloneable instead of using the CopyDude() method.

[code lang="csharp"]
public class Dude: ICloneable
{
public string Name;
public Shoe RightShoe;
public Shoe LeftShoe;

public override string ToString()
{
return (Name + " : Dude!, I have a " + RightShoe.Color +
" shoe on my right foot, and a " +
LeftShoe.Color + " on my left foot.");
}
#region ICloneable Members

public object Clone()
{
Dude newPerson = new Dude();
newPerson.Name = Name.Clone() as string;
newPerson.LeftShoe = LeftShoe.Clone() as Shoe;
newPerson.RightShoe = RightShoe.Clone() as Shoe;

return newPerson;
}

#endregion
}

public static void Main()
{
Class1 pgm = new Class1();

Dude Bill = new Dude();
Bill.Name = "Bill";
Bill.LeftShoe = new Shoe();
Bill.RightShoe = new Shoe();
Bill.LeftShoe.Color = Bill.RightShoe.Color = "Blue";

Dude Ted = Bill.Clone() as Dude;
Ted.Name = "Ted";
Ted.LeftShoe.Color = Ted.RightShoe.Color = "Red";

Console.WriteLine(Bill.ToString());
Console.WriteLine(Ted.ToString());

}
[/code]
And our final output is: Bill : Dude!, I have a Blue shoe on my right foot, and a Blue on my left foot. Ted : Dude!, I have a Red shoe on my right foot, and a Red on my left foot. So all is well. Something interesting to note is that the assignment operator (the “=” sign) for the System.String class actually clones the string so you don’t have to worry about duplicate references. However you do have to watch our for memory bloating. If you look back at the diagrams, because the string is a reference type it really should be a pointer to another object in the heap, but for simplicity’s sake, it’s shown as a value type. In Conclusion. As a general practice, if we plan on ever copying of our objects, we should implement (and use) ICloneable. This enables our reference types to somewhat mimic the behavior of a value type. As you can see, it is very important to keep track of what type of variable we are dealing with because of differences in how the memory is allocated for value types and reference types.

Lambda表达式对List的处理

bookcold — Wed, 20 Jan 2010 16:11:28 +0000

Lambda表达式使得List的过滤和排序更加简洁！

定义一个Employee类：

   1:  public class Employee

   2:  {

   3:      public string FirstName {set; get;}

   4:      public string LastName {set; get;}

   5:      public decimal Salary {set; get;}

   6:      public bool IsManager {set; get;}

   7:  }

再定义一个Employee的列表：

   1:  List employees = new List( );

1. FindAll()操作

原始的方法：

   1:  foreach (Employee employee in employees)

   2:  {

   3:      if (employee.IsManager == true)

   4:          managers.Add(employee);

   5:  }

Lambda表达式：

   1:  List managers = employees.FindAll(employee => employee.IsManager == true);

2. Where()操作

where()和FindAll()类似，有时候用where能使代码更好理解：

   1:  foreach (Employee employee in employees.Where(e => e.IsManager == true))

   2:  {

   3:      // do something

   4:  }

3. Find()操作

Find()返回列表的第一个对象：

   1:  Employee firstManager = employees.Find(employee => employee.IsManager == true);

   2:  if (firstManager == null)

   3:      Console.WriteLine("No managers found in list.");

4. ForEach( )操作

   1:   employees.ForEach(e => e.Salary += 100);

5. OrderBy( ) and OrderByDescending( )操作

OrderBy()返回一个升序排列的List；OrderByDescending()返回一个降序排列的List：

   1:  List sortedList = employees.OrderBy(e => e.Age).ToList();


 

   1:   List sortedList = employees.OrderByDescending(e => e.Age).ToList();

6. Sort( )

   1:  employees.Sort((e1, e2) => e1.DOB.CompareTo(e2.DOB));

7. Getting Fancy

   1:  public enum SortOrder { Ascending, Decending };

   2:  public static void Sort(ref List list, Func sortKey,

   3:      SortOrder sortOrder)

   4:  {

   5:      if (sortOrder == SortOrder.Ascending)

   6:          list = list.OrderBy(sortKey).ToList();

   7:      else

   8:          list = list.OrderByDescending(sortKey).ToList();

   9:  }

现在可以这样使用：

   1:  Employee.Sort(employees, e => e.Salary, SortOrder.Ascending);

文章来源于：

http://www.c-sharpcorner.com/UploadFile/afenster/LambdaExpressionsAreWonderful12022009002148AM/LambdaExpressionsAreWonderful.aspx

.Net 开发习惯【转】

bookcold — Tue, 19 Jan 2010 15:39:44 +0000

1、不要硬编string/ numeric，可以使用一些常量代替。（提高可读性）

   1:  int Count;

   2:  Count = 100;

   3:  private static const int ZERO  =  0;

   4:  if(  Count  ==  ZERO )

   5:  {

   6:  // 执行一些操作

   7:  }

2、对于字符串比较-使用String. Empty ，而不是”"。

3、不要声明成员变量为 public 或者proteted，尽量使用private 成员变量和public/protected 属性。（修改）

4、当我们要在循环操作字符串，使用StringBuilder，而不是字符串，示例如下。

不好的习惯：

   1:  String  temp = String.Empty;

   2:  for( int i = 0 ; i<= 100; i++)

   3:  {

   4:        temp += i.ToString();

   5:  }

好点的习惯：

   1:  StringBuilder sb = new StringBuilder();

   2:  for ( int i = 0 ; i<= 100; i++)

   3:  {

   4:        sb.Append(i.ToString());

   5:  }

5、简单的操作，比起Collection更倾向使用Array。（视情况，这里是建议）

6、比起ArrayList更倾向使用Generic Collection。（视情况，这里是建议）

7、比起HashTable更倾向使用Generic Dictionary。（视情况，这里是建议）

8、对于字符串的操作和存储，倾向于StringCollection和StringDictionary。（视情况，这里是建议）

9、使用适合的数据类型。

例如：你想要判断状态，使用bool比int要好。

不好的习惯：

   1:  int Check = 0;

   2:  if( Check == 0 )

   3:  {

   4:          // 执行一些操作

   5:  }

好点的习惯：

   1:  bool Check = false;

   2:  if(!Check)

   3:  {

   4:           // 执行一些操作

   5:  }

10、使用as做类型转换的时候，对转换后的值进行null值判断

   1:  class A

   2:  {

3:

   4:  }

   5:  class B : A

   6:  {

7:

   8:  }

   9:  B objB = new B();

  10:  A objA1  = (A) objB;

  11:  A objA2 = objB as A;

  12:  if( objA2 != null)

  13:  {

  14:       //执行所需的操作

  15:  }

11、创建wcf代理，可以使用using表达式。（很多地方可以这样使用）

   1:  using(Cerate the proxy)

   2:  {

   3:           //执行所需的操作

   4:  }

12、对于昂贵的资源(例如Connection, File 等等)，遵照’Acquire late, release early’ (尽量晚的获取，尽量早的释放)准则。

例子：如果你想在数据操作时，使用的SqlConnection对象，请在方法级别，而不是在类级别创建实例。

   1:          class MyData

   2:          {

   3:               public MyData()

   4:              {

   5:              }

   6:              public List GetAllCustomer()

   7:              {

   8:                 using (SqlConnection objConnection = new SqlConnection("Connection string"))

   9:                 {

  10:                     //执行一些操作得到需要的数据

  11:                  }

12:

  13:              }

  14:          }

如果你想创建的类级别SqlConnection实例，确保您的类实现了IDisposable接口，并在Dispose()中清理SqlConnection实例。

   1:          class MyData : IDisposable

   2:          {

   3:              SqlConnection objConnection ;

   4:              public MyData()

   5:              {

   6:                  objConnection = new SqlConnection("Connection string");

   7:              }

   8:              public List GetAllCustomer()

   9:              {

  10:                  //通过objConnection得到需要的数据

  11:              }

  12:              public void Dispose()

  13:              {

  14:                  //清理SqlConnection实例

  15:                  if( objConnection != null )

  16:                  {

  17:                      if( objConnection.State == ConnectionState.Open)

  18:                      {

  19:                         objConnection.Close();

  20:                      }

  21:                  }

  22:              }

  23:          }

13、如果你不想别人扩展你的类功能，使用‘sealed’。

14、避免为每个类都声明‘destructor’ ，因为它会增加不需要常驻内存的类的生命周期。

15、相对manual threading，更倾向用Thread Pool 。

16、在循环内不要去调用其它方法。（call function 有性能损耗）

例如：

不好的习惯：

   1:  for( int i = 0; i<= 100; i++)

   2:  {

   3:      Calculate(i);

   4:  }

 好点的习惯：

   1:  for( int i = 0; i<= 100; i++)

   2:  {

   3:         //直接写Calculate逻辑。

   4:  }

17、不要在循环内处理异常，而是将循环处理的逻辑放在try/catch里面

不好的习惯：

   1:  for(int i = 0 ; i<= 100; i++)

   2:  {

   3:     try

   4:     {

   5:     }

   6:     catch(Exception ex)

   7:     {

   8:      throw ex;

   9:     }

  10:  }

好点的习惯：

   1:     try

   2:     {

   3:       for(int i = 0 ; i<= 100; i++)

   4:       {

   5:       }

   6:     }

   7:     catch(Exception ex)

   8:     {

   9:         throw ex;

  10:     }

18、不用通过异常处理应用程序的逻辑

例如：

不好的习惯：

   1:    try

   2:    {

   3:      int x,y,z;

   4:      x = 0;

   5:      y = 10;

   6:      z = y/x;

   7:     }

   8:     catch(DevideByZeroException ex)

   9:     {

  10:      Throw ex;

  11:     }

好点的习惯：

   1:  try

   2:   {

   3:     int x,y,z;

   4:     x = 0;

   5:     y = 10;

   6:     if( x != 0 )

   7:     {

   8:        z = y/x;

   9:     }

  10:   }

  11:   catch(Exception ex)

  12:   {

  13:   }

19、相对for/while ，倾向使用foreach循环。

20、使用多层架构的系统，层与层之间的交互，比起DataSet/DataTables更倾向于使用对象传递数据。

40条ASP.NET开发Tip

1、在compilation 下，请设置debug=false ，如下：

default Language=”c#” debug=”false”

2、请使用Server.Transfer代替Response.Redirect。

3、使用Validator控件，请要经常检查Page.IsValid。

4、请使用foreach循环，而不是为字符串迭代循环。

5、请使用客户端验证方式(不要每次都在服务端验证)。

6、为了避免重复代码执行，请检查“Page.IsPostBack”。

7、GIF 和PNG类似，但是PNG通常产生一个较小体积的文件。（当然，有些浏览器不支持PNG格式）

8、更新二进制文件时，请使用AppOffline.htm 。

9、除非需要，否则请关闭跟踪。

10、编译页面，请禁用AutoEventWireup。在Machine.config文件中请设置AutoEventWireup为false。

11、如果不需要，请关闭Session会话。

12、在你生成最终版本的应用程序之前，请选择Release模式。默认是Debug。

13、如果不需要请禁用ViewState 。

EnableViewState=”false”

14、请避免频繁的访问数据库。

15、使用缓存提高你的应用程序的性能。

16、验证所有的用户输入。

17、请最后释放所有资源。

18、String 和Stringbuilder。

修改字符串时，使用Stringbuilder而不是String ，在每次字符串修改的时候，String都会占据不同的内存空间，而Stringbuilder只使用同一个内存空间

19、切勿直接使用对象的值，先从本地变量获取对象的值，然后再使用。因为直接读取对象的值比读取变量更花时间。

20、避免异常：使用if。

21、代码优化：避免使用：x = x +1，而是使用x+=1比较好。

22、数据访问技术：DataReaders提供快速有效的数据检索方法。在性能方面，DataReader是速度远远超过DataSets 。

23、在做一个笨重的ASP代码的处理之前，你进行检查以确保Response.IsClientConnected。

24、避免session变量，因为每个ASP页面是在不同的线程运行和session调用将会被逐一序列化。这样会降低应用程序。你可以使用QueryString集合或者表单上面的hidden变量来保存值。

25、使buffer有效，能提高性能，如：

<% response.buffer=true %>

接着使用：

<% response.flush=true %>

26、使用Repeater控件代替DataGrid，DataList，因为它是高效的，可定制的，和可编程的。

27、在数据库中检索大量数据，数据列表消耗更多的时间。

分页将显示特定的数据，但是要考虑所有数据负载。只取当前页需要的数据。

28、避免内嵌JavaScript和CSS。

29、使用单个的css文件，而不是多个css文件。

请尽量将您所有的css合并成一个css的类文件，不管文件大小，大量的.css文件会造成大量的请求。.css文件通常是由浏览器缓存，这样一个单一的沉重的.css文件不会导致在每个页面请求时会有漫长的等待。

内嵌.CSS类导致HTML沉重，因此我觉得：首先考虑一个single.css文件。

30、减少cookie的大小。

31、压缩CSS, JavaScript 和Images。

可以使用在线的压缩，压缩文件，将下列网页和优化的代码替换为您的文件内容。

http://iceyboard.no-ip.org/projects/css_compressor[^] CSS 压缩

www.xtreeme.com/javascript-optimizer/[^] . JS 压缩

32、适当地使用缓存。

i、页面输出缓存：

<%@ OutputCache Duration=”3600″ VaryByParam=”none” %>

ii、页片段缓存：

在每个用户控件中写页面输出缓存

iii、数据缓存：

1:

33、服务器端使用诸如Port80s压缩软件http://www.port80software.com/products/httpzip/[^]。

34、使用了“using”。

35、不要声明成员变量为 public 或者proteted，尽量使用private 成员变量和public/protected 属性。

36、使用strString=string.Empty 代替 strString=”" 。

37、请尽可能减轻你的页面文件，尽量避免不必要的标签，例如使用div代替table。

38、在div中写静态的消息，必要的时候才显示出来。这比你设置服务端的label和div的text属性快。

39、如果可能的话，一次性检索数据库中的数据。尽可能不要添加数据库的访问。因此，整合来自不同表datafields和选择它们。

40、给WebControl取个简短的名字。

转载自：http://zhuqil.cnblogs.com

.Net下基于AOP的角色权限控制

bookcold — Sat, 16 Jan 2010 08:52:17 +0000

几篇相当不错的文章：

1. AOP技术基础

2. 在.Net中关于AOP的实现

3. 在.Net中关于AOP的实现（补遗）

ps：张逸真是神啊！

4. Aspect Oriented Programming using .NET

5. 利用 AOP 实现 .NET 上完整的基于角色的访问控制（RBAC）模型

12+ open source projects for .NET you probably didn’t know about.(12个.NET的开源项目)

bookcold — Fri, 08 Jan 2010 07:14:24 +0000

Umbraco

URL: http://www.umbraco.org

Source Code: Grab the source code here.

I’ve mentioned umbraco as an open source system to keep an eye on before, in our compilation of open source CMS systems.

It impresses me on each release, and has just put together an awesome sample site that is well worth a look, and will enable developers to get up to speed quickly and easily.

i386 Newsletter System

URL: http://www.i386.com/Products/Newsletter.aspx

Source Code: Grab the source code here

I came across Austrian company i386 when doing a bit of a scout around for some open source email marketing solutions. Its a C# system that could probably do with some community support, with the last checkin April 2008. They need a bit of a hand out with some language translation, so if any of you guys are german speakers, (Austrian German) maybe you could be of use.

The application can run on MSDE/MS SQL and Access, and is on version 2.0 of the framework.

YetAnotherForum

URL: http://www.yetanotherforum.net/

Source Code: Grab the source code here.

YAF was introduced to me through Michael at Codefixer. It seems like a pretty solid, well architected system, and has a vibrant and active open source community contributing to it’ success. In addition to a stand alone system, it also has a DotNetNuke and Rainbow Portal, which I’ve mentioned here.

If you haven’t already guessed YAF is a Open Source discussion forum or bulletin board system for web sites running ASP.NET. The latest production version runs on ASP.NET v2.0 with a Microsoft SQL Server backend. It is licensed under the GPL.

DotNetNuke

URL: http://www.dotnetnuke.com

Source Code: Grab the source code here

DotNetNuke is an open source web application framework ideal for creating, deploying and managing interactive web, intranet, and extranet sites securely.

It has received it’s criticisms, including being accused of being bloated and a bit of a hungry beast, however over the last five years, DotNetNuke has established itself as a force to be reconned with. It has become an essential framework within many business environments, and has released a professional commercial product which is a testament to the community achievement.

The quality and flexibility of the code base, combined with a very active and supportive community, has resulted in hundreds of thousands of deployments.

Rainbow Portal

URL: http://www.rainbowportal.net/

Source Code: Grab the source code here

Rainbow Portal is the rebel breakaway / fork project from DotNetNuke. They were the underdogs in the portal wars. That said however, their systems are built in C# as opposed to VB, and things are done a bit differently, depending on your needs that might be ok. There is always things to be learned from other people’s coding examples.

My own thoughts are that it may suit you if you are using C# to code, however the alternative MojoPortal project seems to be gaining traction. The last release of Rainbow was way back in 2006. Mojo Portal’s last release was 26th Feb 2009.

MojoPortal

URL: http://www.mojoportal.com/

Source Code: Grab the source code here

Mojo Portal appears to be receiving alot of attention recently. This can probably be attributed partially to the wide variety of database platforms which it runs on.

Separation of database concerns is one sign of a well architected project, and whilst I can’t personally vouch for the code, it looks like one to keep an eye on. They have a focus on creating standards compliant frontend HTML, and for that reason, they get my thumbs up. Both Rainbow Portal and DNN tended to create code which was very heavily table based, which lead to skinning difficulty. This seems to have been addressed within Mojo Portal.

Oxite

URL: http://visitmix.com/Lab/Oxite

Source Code: Grab the source code here

Oxite is an open source, web standards compliant, blog engine built on ASP.NET MVC. It is fully featured and includes support for all the blogging features you would expect.

Born out of a necessity to showcase Microsoft’s muscle in the blogging scene, Oxite provides example of ‘core blog functionality’ in a reusable way. The entire VisitMIX site runs on Oxite, which just shows the potential quality of the finished product. I love the effort that they have put into the design of MIX, and for once, we are able to show others a production Microsoft site running a Microsoft product that really shines visually.

nopCommerce

URL: http://www.nopcommerce.com/

Source Code: Grab the source code here

Running on C# nopCommerce is a fully customizable shopping cart. It’s stable and highly usable. nopCommerce is a open source e-commerce solution that is ASP.NET 3.5 based with a MS SQL 2005 backend database.

It is pretty feature packed when you take a look around the system, and should serve as a good platform to build on for some developers. Whilst they aren’t over on the MVC system they have taken care of some of the problems with querystrings, and include a URL rewrite module.

Most developers should be able to get up and running quickly, simply change your web.config in a few places and the autoinstaller should get you going. well worth investigating if you are a .NET developer with a background in e-commerce.

Kigg

URL: http://www.codeplex.com/Kigg

Source Code: Grab the source code here

KiGG is a Web 2.0 style social news web application developed in Microsoft supported technologies. It is an alternative to Pligg, which has gained significant niche adoption on the web.

It utilises the MVC pattern, and a number of other open source libraries – including the Microsoft Patterns and Practises library for it’s logging and caching. I’m a big fan of the Enterprise library, and I’ve used the security module for a few projects myself. Kigg has been developed with a TDD approach and uses xUnit.Net for it’s unit testing framework and Moq as a mocking library. DotNetShoutout amongst other’s uses it extensively as the framework to run the site.

SharpWebMail

URL: http://anmar.eu.org/projects/sharpwebmail/

Source Code: Grab the source code here.

Whilst it aint the prettiest in the group – SharpWebMail is an established project which is written in C#, it uses a POP3 or IMAP servers as the mailstore and sends mail through a SMTP server. It is the only open source webmail solution for the .NET platform that I am aware of.

If you are a good user interface designer, and have never contributed to an open source project before, this would offer a great way to establish a name for yourself. Alternatively, adding a skinning engine to the project would probably be a help.

SharpWebMail is Licensed under GNU GPL.

DotNetShoppingCart

URL: http://www.dotshoppingcart.com/

Source Code: Grab the source code here.

DotShoppingCart is an ASP.NET open source CMS & eCommerce software. It enables businesses to manage site content and sell products and services through an online storefront. Unfortunately this was one of the ones I missed on my open source e-commerce post.

DotShoppingCart open source edition is licensed under DotShoppingCart Public License. It’s basically a MPL 1.1 plus the DotShoppingCart powered logo requirement on every single page.

If you are a developer looking to customise this one extensively, you will have to shell out for a Commercial license. That said, if you are looking for a cost effective route to market this one is worth examining a bit closer. As with nopCommerce, the feature list seems pretty extensive.

BlogEngine.NET

URL: http://dotnetblogengine.net

Source Code: Grab the source code here

BlogEngine.NET is an stable open source .NET blogging project. Touted as the next alternative to WordPress for .NET developers it integrates the best features of the .NET platform into its offering. It also has received backing from Redmond, and is featured on the Microsoft.NET website as a Starter Kit.

Personally, I haven’t used it much – the sheer amount of plugins for WordPress in comparison dwarf the project, and even for a code head like myself, it isn’t as appealing. That said, it may offer a way of integrating an existing .NET solution with a blogging engine. All the controls in BlogEngine.NET are 100% XHTML 1.0 compliant, which is great. The code base is C# ASP.NET 2.0.

Best of the Rest.

DasBlog - Open Source blogging Engine

Starter Kits and Community Projects – Microsoft ASP.NET projects, good collection of Open source systems here.

SubText – Another blog Engine

Hydrogen CMS – A .NET Open source System

DotNETKicks – Similar to KIGG, only not.

EvolUtility – A CRUD Framework

Suteki Shop – Another e-commerce open source MVC app.

转载自：http://blog.webdistortion.com/2009/03/06/12-open-source-projects-for-net-you-probably-didn%E2%80%99t-know-about/