博客园_OpenSource

ebook site

2010-05-26T11:00:00Z

http://www.wowebook.com/category/e-book/dot-net

XML Namespaces and How They Affect XPath and XSLT

2010-05-26T05:11:00Z

ref:http://msdn.microsoft.com/en-us/library/ms950779.aspx

How to use xpath to query the doc, also including namespace.

<?xml version="1.0" encoding="utf-8"?>
<TestSite xmlns="http://schemas.microsoft.com/windows/ProtocolsTest/2007/07/TestConfig" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://schemas.microsoft.com/windows/ProtocolsTest/2007/07/TestConfig http://schemas.microsoft.com/windows/ProtocolsTest/2007/07/TestConfig.xsd">
  <Properties>
    
    
       <Property name="Path.DataSourceReference.SchemaVersion200310" value="Report\DataSources\DataSource\DataSourceReference" />
    <Property name="Path.DataSets.SchemaVersion200310" value="Report\DataSets" />
    <Property name="Path.DataSet.SchemaVersion200310" value="Report\DataSets\DataSet" />
    <Property name="Path.Fields.SchemaVersion200310" value="Report\DataSets\DataSet\Fields" />
    <Property name="Path.Field.SchemaVersion200310" value="Report\DataSets\DataSet\Fields\Field" />
    <Property name="Path.DataField.SchemaVersion200310" value="Report\DataSets\DataSet\Fields\Field\DataField" />
    <Property name="Path.Value.SchemaVersion200310" value="Report\DataSets\DataSet\Fields\Field\Value" />
    <Property name="Path.Query.SchemaVersion200310" value="Report\DataSets\DataSet\Query" />
    <Property name="Path.DataSourceName.SchemaVersion200310" value="Report\DataSets\DataSet\Query\DataSourceName" />
    <Property name="Path.CommandType.SchemaVersion200310" value="Report\DataSets\DataSet\Query\CommandType" />
    <Property name="Path.CommandText.SchemaVersion200310" value="Report\DataSets\DataSet\Query\CommandText" />
    <Property name="Path.QueryParameters.SchemaVersion200310" value="Report\DataSets\DataSet\Query\QueryParameters" />
    <Property name="Path.QueryParameter.SchemaVersion200310" value="Report\DataSets\DataSet\Query\QueryParameters\QueryParameter" />
    <Property name="Path.Timeout.SchemaVersion200310" value="Report\DataSets\DataSet\Query\Timeout" />
    <Property name="Path.CaseSensitivity.SchemaVersion200310" value="Report\DataSets\DataSet\CaseSensitivity" />
    <Property name="Path.Collation.SchemaVersion200310" value="Report\DataSets\DataSet\Collation" />
    <Property name="Path.AccentSensitivity.SchemaVersion200310" value="Report\DataSets\DataSet\AccentSensitivity" />
    <Property name="Path.KanatypeSensitivity.SchemaVersion200310" value="Report\DataSets\DataSet\KanatypeSensitivity" />
    <Property name="Path.WidthSensitivity.SchemaVersion200310" value="Report\DataSets\DataSet\WidthSensitivity" />
    <Property name="Path.Filters.SchemaVersion200310" value="Report\DataSets\DataSet\Filters" />
    <Property name="Path.Filter.SchemaVersion200310" value="Report\DataSets\DataSet\Filters\Filter" />
    <Property name="Path.FilterExpression.SchemaVersion200310" value="Report\DataSets\DataSet\Filters\Filter\FilterExpression" />
    <Property name="Path.Operator.SchemaVersion200310" value="Report\DataSets\DataSet\Filters\Filter\Operator" />
    <Property name="Path.FilterValues.SchemaVersion200310" value="Report\DataSets\DataSet\Filters\Filter\FilterValues" />
    <Property name="Path.FilterValue.SchemaVersion200310" value="Report\DataSets\DataSet\Filters\Filter\FilterValues\FilterValue" />
    <Property name="Path.Body.SchemaVersion200310" value="Report\Body" />
    <Property name="Path.ReportItems.SchemaVersion200310" value="Report\Body\ReportItems" />
    <Property name="Path.Line.SchemaVersion200310" value="Report\Body\ReportItems\Line" />
    <Property name="Path.Style.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style" />
    <Property name="Path.BorderColor.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BorderColor" />
    <Property name="Path.Default.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BorderColor\Default" />
    <Property name="Path.Left.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BorderColor\Left" />
    <Property name="Path.Right.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BorderColor\Right" />
    <Property name="Path.Top.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BorderColor\Top" />
    <Property name="Path.Bottom.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BorderColor\Bottom" />
    <Property name="Path.BorderStyle.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BorderStyle" />
    <Property name="Path.BorderWidth.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BorderWidth" />
    <Property name="Path.BackgroundColor.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BackgroundColor" />
    <Property name="Path.BackgroundGradientType.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BackgroundGradientType" />
    <Property name="Path.BackgroundGradientEndColor.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BackgroundGradientEndColor" />
    <Property name="Path.BackgroundImage.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BackgroundImage" />
    <Property name="Path.Source.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BackgroundImage\Source" />
    <Property name="Path.MIMEType.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BackgroundImage\MIMEType" />
    <Property name="Path.BackgroundRepeat.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\BackgroundImage\BackgroundRepeat" />
    <Property name="Path.FontStyle.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\FontStyle" />
    <Property name="Path.FontFamily.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\FontFamily" />
    <Property name="Path.FontSize.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\FontSize" />
    <Property name="Path.FontWeight.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\FontWeight" />
    <Property name="Path.Format.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\Format" />
    <Property name="Path.TextDecoration.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\TextDecoration" />
    <Property name="Path.TextAlign.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\TextAlign" />
    <Property name="Path.VerticalAlign.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\VerticalAlign" />
    <Property name="Path.Color.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\Color" />
    <Property name="Path.PaddingLeft.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\PaddingLeft" />
    <Property name="Path.PaddingRight.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\PaddingRight" />
    <Property name="Path.PaddingTop.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\PaddingTop" />
    <Property name="Path.PaddingBottom.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\PaddingBottom" />
    <Property name="Path.LineHeight.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\LineHeight" />
    <Property name="Path.Direction.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\Direction" />
    <Property name="Path.WritingMode.SchemaVersion200310" value="Report\Body\ReportItems\Line\Style\WritingMode" />

  </Properties>
</TestSite>

Always failed when there the namespace existing.

本文链接

Debugging Applications for Microsoft .NET and Microsoft Windows: Notes-Books

2010-05-24T01:01:00Z

Software Development

Code Complete by Steve McConnell (Microsoft Press, 1993)

This is simply the best book on software construction that I've ever read. Every developer should own a copy and read it cover to cover every year. After reading it annually for nine years, I'm still learning things from this book!

Rapid Development by Steve McConnell (Microsoft Press, 1996)

This book taught me how to manage teams and schedule projects.

Debugging the Development Process by Steve Maguire (Microsoft Press, 1994)

This book is a great introduction to the way Microsoft develops software. Obviously, since Microsoft is the most successful software company on the planet, they must be doing something right. You can learn a great deal from this book.

Dynamics of Software Development by Jim McCarthy (Microsoft Press, 1995)

This book is a very interesting look at software development from the perspective of a manager with a track record for shipping great products. The rules Jim proposes are excellent because they all come from actual experience; he's not just some academic theorizing.

Under Pressure and On Time by Ed Sullivan (Microsoft Press, 2001)

Ed's the great project manager from whom I stole most of my ideas about how to deliver software. This book discusses real-world project management and how Ed built great teams that delivered great products consistently and always on time. Also, the guy who wrote the forward is probably the sexiest developer working today.

he Career Programmer: Guerilla Tactics for an Imperfect World by Christopher Duncan (APress, 2002)

All the books on software development address only the manager's perspective. It's about time someone wrote a book for the developers in the trenches! Chris covers tactics and techniques that enable you to concentrate on getting your job done even when your manager might be an idiot.

Writing Secure Code, Second Edition, by Michael Howard and David LeBlanc (Microsoft Press, 2002)

With security in the forefront of everyone's mind, all developers need to have this book in their collections. Not only does it do a fantastic job of introducing the issues, it's chock full of real-world recommendations and examples of what you need to do in your software.

Don't Make Me Think: A Common Sense Approach to Web Usability by Steve Krug (New Riders, 2000)

Everyone is a user interface expert, and this is especially so the higher up the food chain you go in your development shop. This outstanding book discusses real-world Web page design and shows you the techniques necessary to ensure your designs actually work.

Philip and Alex's Guide to Web Publishing by Philip Greenspun (Morgan Kaufmann, 1999)

If you're designing a Web site, you have to read this book. You might not agree with everything (I sure didn't), but it's one of the most cogent discussions of the issues surrounding how to keep users happy and how to develop Web sites people will come back to. Also, the photographs in the book are excellent. My father, a world class artist, can't seem to figure out why my books don't look so good.

High-Performance Client/Server by Chris Loosley and Frank Douglas (Wiley, 1998)

This is a great book on designing performance into applications and has an especially excellent discussion of high-speed architectures.

Developing International Software, Second Edition by Dr. International (Microsoft Press, 2003)

What's the old joke? A person who speaks three languages is trilingual, a person who speaks two is bilingual, and the person who speaks only one is American. Microsoft makes 60 percent of its revenue from outside the United States and you can too if you plan for it. This book shows you how to develop international applications for all of Microsoft's technologies.

Debugging and Testing

The Practice of Programming by Brian W. Kernighan and Rob Pike (Addison-Wesley, 1999)

This book is a wonderful discussion of developing, debugging, and testing.

Writing Solid Code by Steve Maguire (Microsoft Press, 1993)

Although it focuses mainly on C programming, this book contains excellent advice on interface definitions and avoiding nasty problems in the language.

Managing the Testing Process by Rex Black (Microsoft Press, 1999)

To develop better, you need to know how to test better. This excellent book will change the way you develop and the way you interact with your QA teams.

How Debuggers Work: Algorithms, Data Structures, and Architecture by Jonathan B. Rosenberg (John Wiley & Sons, 1996)

This book is an excellent introduction to how debuggers work and to the issues you need to consider when designing a debugger.

Debugging Windows Programs: Strategies, Tools, and Techniques for Visual C++ Programmers by Everett N. McKay and Mike Woodring (Addison Wesley, 2000)

Right after the first edition of the book you're reading now came out, Everett's and Mike's book showed up. It's a fantastic book, and I wish I'd thought of some of the great ideas they put in there, like how to think about debugging.

.NET Technologies

Applied Microsoft .NET Framework Programming by Jeffrey Richter (Microsoft Press, 2002)

Applied Microsoft .NET Framework Programming in Microsoft Visual Basic .NET by Jeffrey Richter and Francesco Balena (Microsoft Press, 2002)

Simply the best introduction to the insides of .NET. This is what all those thousands of "Introduction to .NET" books strive to do but fail miserably at doing.

Programming Microsoft .NET by Jeff Prosise (Microsoft Press, 2002)

This is the perfect book to follow Jeffrey Richter's. Somehow Jeff managed to anticipate every single question I ever had about Microsoft ASP.NET and answer them all in his outstanding book.

.NET and COM: The Complete Interoperability Guide by Adam Nathan (Sams, 2002)

If your .NET application is going to communicate outside the CLR to the big bad world of Windows or COM applications, this book is the bible you need to ensure that communication works.

Applied XML Programming for Microsoft .NET by Dino Esposito (Microsoft Press, 2002)

XML is everywhere today, and Dino's book is an outstanding reference on digesting and emitting XML with Microsoft .NET.

.NET Enterprise Design with Visual Basic .NET and SQL Server 2000 by Jimmy Nilsson (Sams, 2002)

Jimmy's book is one of the few books out there that concentrates on real-world development issues. It's a joy to read and to learn about how to apply many different aspects of real-world tools to solve problems.

Performance Testing Microsoft .NET Web Applications by Microsoft Application Consulting and Engineering (ACE) Team (Microsoft Press, 2003)

Although .NET takes care of many programming chores for you, you're still responsible for performance. A great introduction to performance testing.

Inside Microsoft .NET IL Assembler by Serge Lidin (Microsoft Press, 2002)

Although you'll probably never program in IL professionally, it sure is cool to know you can.

C/C++ Language

The C Programming Language, Second Edition by Brian W. Kernighan and Dennis M. Ritchie (Prentice Hall, 1988)

This book is the definitive guide to C programming and the best-written technical book I've ever read.

Learning C++ by Neill Graham (McGraw-Hill, 1991)

I used this book to learn C++. Unlike other C++ doorstop books, Learning C++ is short, sweet, and to the point.

C++ Programmer's Guide to the Standard Template Library by Mark Nelson (IDG Books, 1995)

I have an intense love-hate relationship with the Standard Template Library. Fortunately, Mark's book does a great job of providing samples and explaining the finer points of using this library.

Windows and Windows Technologies

Programming Windows, Fifth Edition by Charles Petzold (Microsoft Press, 1999)

This one book will teach you everything you need to know about how Windows programs work at the most fundamental level. People could solve many of the problems they ask me about if they only had a better understanding of how message handling, graphics device interface (GDI), and other subjects work at the Microsoft Win32 level.

Programming Applications for Microsoft Windows, Fourth Edition by Jeffrey Richter (Microsoft Press, 1999)

This book covers all the unique aspects of Win32 development. The chapters on DLLs, threads, synchronization, and structured exception handling are the best descriptions available and all relate directly to debugging your problems more quickly and efficiently.

Programming Windows with MFC, Second Edition by Jeff Prosise (Microsoft Press, 1999)

This book is the definitive guide to programming with the Microsoft Foundation Class (MFC) library. If you're using MFC, you must have this book.

Windows++: Writing Reusable Windows Code in C++ by Paul Dilascia (Addison-Wesley, 1992)

Unlike other design books, which have only toy examples, this book produces a strong and viable C++ class library for Windows programming. I learn best by example, and this book taught me how to think in terms of objects.

Essential COM by Don Box (Addison-Wesley, 1998)

In the Disassembly window ("unambiguous mode"), a COM interface is just a pointer to an array of pointers, so COM should be easy to understand. COM is so much more than just a pointer and is so fundamental to programming life, however, that you must understand how it works if you expect to stand a chance of correctly implementing and debugging your code. Don's book will give you a great start along the path of COM enlightenment.

Inside Microsoft Windows 2000, Third Edition by David A. Solomon and Mark E. Russinovich (Microsoft Press, 2000)

The book is the official "big picture" view of the Microsoft Windows 2000 kernel. Although more directly applicable for device driver writers, this book will help you make sense out of how the different parts of the operating system fit together in Windows 2000.

Windows 95 System Programming Secrets by Matt Pietrek (IDG Books, 1995)

Matt's book is out of print, but you should really try to find a copy. Debugging anything more than a simple access violation on Microsoft Windows 95 and Microsoft Windows 98 is an exercise in extreme frustration mainly because Windows 95 and Windows 98 are hybrid 16-bit/32-bit operating systems. Much of the information in the book, such as the Portable Executable (PE) file format chapter, applies to Windows 2000 as well.

ATL Internals by Brent Rector and Chris Sells (Addison-Wesley, 1999)

The Active Template Library (ATL) makes the smallest and fastest COM objects around. To take full advantage of ATL, you have to have this book.

Programming Windows Security by Keith Brown (Addison-Wesley, 2000)

Simply the best book on Windows security programming.

Programming Server-Side Application for Microsoft Windows 2000 by Jeffrey Richter and Jason D. Clark (Microsoft Press, 1999)

If you're doing native server applications, you have to have this book. The section on scalable I/O is the best ever written.

The Intel CPU and Hardware

Structured Computer Organization, Fourth Edition by Andrew S. Tanenbaum (Prentice-Hall, 1998)

An excellent introduction to computer architecture, this book is filled with information that I use to debug problems daily. The book has some typos and technical errors, but if you can get past that you'll be glad you read it.

Intel CPU reference manuals

Intel makes available, for free, the CPU manuals for their processors. If you're doing serious debugging, these manuals are extremely helpful and informative. You can download the Adobe PDF files from Intel's Literature Center at developer.intel.com/design/litcentr/index.htm. Intel also provides the manuals in book form if you prefer having hard copies.

The Indispensable PC Hardware Book, Fourth Edition by Hans-Peter Messmer (Addison-Wesley, 2001)

This book is the best discussion of PC hardware around. When you need to interact with hardware, this book is an invaluable resource.

Software Tools

Whole Tomato's Visual Assist (www.wholetomato.com)

This is an excellent add-in to Microsoft Visual Studio .NET that extends the editor and puts in real IntelliSense and other advanced editing tools.

Source Dynamic's Source Insight (www.sourceinsight.com)

If you need to see how large C++, C#, or Java programs fit together, this is the source browsing tool of choice.

Compuware DevPartner (www.compuware.com/products/numega)

This is the suite that holds BoundsChecker (error detection), TrueTime (profiler), TrueCoverage (code coverage), CodeReview (static analysis), and Distributed Analyzer (cross-machine analysis). These tools all work for .NET as well as native code.

Bullseye Testing Technology's C-Cover (www.bullseye.com)

This is a fantastic native C++ code coverage tool.

JPSoft's 4NT (www.jpsoft.com)

This is the ultimate command shell for Windows machines. It's even got a debugger for batch files! On a fresh operating installation, it's the first program I put on the machine.

Jay Freeman's Anakrino (www.saurik.com/net/exemplar)

This is the easy way to learn about .NET: decompile it!

Luts Roeder's Reflector (www.aisto.com/roeder/DotNet)

Use this for a better ILDASM.

WiseOwl's Demeanor for .NET (www.wiseowl.com)

This is Brent Rector's excellent code obfuscator.

MindReef's SOAPscope (www.mindreef.com)

If you want to see what's happening with your Web services under the hood, you can't get any better than SOAPscope.

VMWare (www.vmware.com)

Instead of having 300 machines in your test lab, buy a few big servers and run VMWare. I've seen several organizations save a ton of money by utilizing VMWare to cut down on hardware costs and yet increase their operating system testing coverage considerably.

Web Sites

MSDN Online (msdn.microsoft.com)

MSDN is the first place to start looking for .NET and Windows information. MSDN Online can be accessed at the address I list as well as through the Microsoft-endorsed magazine MSDN Magazine. Keep in mind that MSDN is partly a marketing organization, so sometimes a little hype creeps into various pieces.

ASP.NET Web (www.asp.net)

This Web site is the official home of the ASP.NET team at Microsoft. For the life of me, I can't figure out why Microsoft has this site outside of the MSDN umbrella.

Google Microsoft Search (www.google.com/microsoft.html)

Although MSDN is the place to read about Microsoft technologies, its searching capabilities leave something to be desired. Fortunately, Google has a special search site that focuses only on Microsoft technologies. If you'd like to use the vaunted Google search on only the MSDN site, specify site:msdn.microsoft.com in your search string.

Sysinternals (www.sysinternals.com)

Mark Russinovich and Bryce Cogswell have some of the best native debugging utilities around: Regmon, Filemon, DebugView, Process Explorer, and many more. Many utilities come with full source code, and all are free! I check Mark and Bryce's site at least once a week so that I can keep my competitive edge.

Russ Osterlund's SmidgeonSoft (www.smidgeonsoft.com)

Russ has a collection of fantastic and free tools that rival those at Sysinternals. Not only is his PEBrowse Professional Interactive a native code debugger, it handles .NET debugging as well. If you want to see the insides of the operating system, Russ has you covered.

Code Project (www.codeproject)

This is a great community site for both .NET and native development.

CodeGuru (www.codeguru.com)

This is the granddaddy of Windows programming help sites. Now it does .NET, too!

VB2TheMax (www.vb2themax.com)

This is the place to learn about Microsoft Visual Basic .NET.

Wintellect (www.wintellect.com)

This is where I and all my Wintellectual friends hang out and answer (and post!) questions on our forums.

本文链接

Debugging Applications for Microsoft .NET and Microsoft Windows: Notes-Prerequisites to Debugging

2010-05-24T00:33:00Z

Your project

Knowing your project is the first line of defense for user interface, logic, and performance bugs. By knowing how and where features are implemented in the various source files, you can quickly narrow down who is doing what to whom.

Your language

Knowing the language (or languages) your project uses is more difficult than it sounds. I'm referring to knowing what your language is doing behind the scenes as well as knowing how to program in it.

Your technology/tools

Getting a handle on the technologies you're using is the first big step to tackling the harder bugs.

Your operating system/environment

Knowing the basics of how your operating system or operating environment goes about doing its work can make the biggest difference between solving a bug and just floundering around.

My friend Matt Pietrek, who taught me a great deal about debugging, maintains that knowing the operating system/environment and the CPU is what separates the debugging gods from mere mortals.

Your CPU

This brings me to the last thing you must know to be a debugging god for native code: the CPU. You must know a little about the CPU to solve most of the nastiest bugs you'll encounter.

Learning the Skill Set

Bringing a portfolio of the work you did on your own time at home shows that you can complete work independently and that you have a passion for software engineering, and it will almost immediately put you in the top 20 percent of engineers.

Another practice that has helped me a great deal, especially when it comes to learning more about languages, technologies, and the operating system, is to look at other engineers' code.

Another technique I would recommend to learn more about technologies, the operating system, and the virtual machine (CPU) is to do some reverse engineering. It will help get you up to speed with assembly language and the advanced features in the debugger.

Reading books and magazines, writing utilities, reviewing other engineers' code, and doing reverse engineering are all great ways to improve your debugging skills. However, your greatest resources are your engineering friends and coworkers. Never be afraid to ask them how they did something or how something works; unless they are in the middle of a deadline crunch, they should be happy to help. I enjoy it when people ask me questions because I end up learning more than the individuals who ask the questions! Programming newsgroups are also excellent places to pose questions. I read them all the time because their responses are so good, especially from those folks Microsoft has designated MVPs (Most Valuable Professionals).

本文链接

Debugging Applications for Microsoft .NET and Microsoft Windows: Notes-The Debugging Process

2010-05-24T00:24:00Z

The Debugging Process

Step 1: Duplicate the bug

The most critical step in the debugging process is the first one: duplicating the bug.

My definition is duplicating the bug on a single machine once in a 24-hour period.

Once you've duplicated the bug by using one general set of steps, you should evaluate whether you can duplicate the bug through a different set of steps.You can get to some bugs via one code path only, but you can get to other bugs through multiple paths. The idea is to try to see the behavior from all possible angles. By duplicating the bug from multiple paths, you have a much better sense of the data and boundary conditions that are causing the problems.

Even if you can't duplicate the bug, you should still log it into your bug tracking system. If I have a bug that I can't duplicate, I always log it into the system anyway, but I leave a note that says I couldn't duplicate it.

Step 2: Describe the bug

In the real world, your writing skills are almost more important than your engineering skills because you need to be able to describe your bugs, both verbally and in writing. When faced with a tough bug, you should always stop right after you duplicate it and describe it.

Step 3: Always assume that the bug is yours

Reading the code will force you to take the extra time to look at the problem. Starting with the state of the machine at the time of the crash or problem, work through the various scenarios that could cause you to get to that section of code.

Step 4: Divide and conquer

Step 5: Think creatively

If the bug you're trying to eliminate is one of those nasty ones that happens only on certain machines or is hard to duplicate, start looking at the bug from different perspectives. This is the step in which you should start thinking about version mismatches, operating system differences, problems with your program's binaries or its installation, and other external factors.

Step 6: Leverage tools

Step 7: Start heavy debugging

Just as when you're doing light debugging, when you're doing heavy debugging, you should have an idea of where you think your bug is before you start using the debugger, and then use the debugger to prove or disprove your hypothesis.

Step 8: Verify that the bug is fixed

When testing your fix, especially in critical code, you should verify that it works with all data conditions, good and bad. Nothing is worse than a fix for one bug that causes two other bugs.

Step 9: Learn and share

Each time you fix a "good" bug (that is, one that was challenging to find and fix), you should take the time to quickly summarize what you learned.You learn the most about development when you're debugging, so you should take every opportunity to learn from it.

Final Debugging Process Secret

Again, I'm suggesting that you need to have a hypothesis in mind—something you want to prove or disprove—before the debugger can help you.As I recommended earlier in Step 7 I write out my hypothesis before I ever touch the debugger to ensure that I have a purpose each time I use it.

本文链接

NET垃圾回收机制

2010-05-23T02:46:00Z

http://www.shehui001.com/map.asp?pid=306

http://social.microsoft.com/Forums/zh-CN/visualcshartzhchs/thread/6591f09d-4f74-40fa-9243-1373f1be273d

一下回复节选自《程序员面试指南》，你可以检查一下这些方面的问题，你的问题很可能是不断地创建新对象，而垃圾回收器来不及回收导致的，你看看是否有在循环中不断创建新对象的情况：

在一些不规范的编码情况下，即使是拥有垃圾回收和内存管理机制的托管堆上，仍然可能出现内存泄漏。首先读者需要了解什么是内存泄漏。
    内存泄漏是指内存空间上产生了不再被实际使用却又不能被分配的内存，内存泄漏的意义很广泛，例如程序无意义地保持对象内存、内存碎片、不彻底的对象释放等都属于内存泄漏现象。内存泄漏将导致主机的内存随程序的运行而逐渐减少，无论内存泄漏的具体形式如何，它的危害都是显而易见的，所有的内存泄漏都是需要程序员努力避免的。
按照内存泄漏的定义，大部分时候.NET的托管堆中存在着短暂的内存泄漏情况，那是因为对象一旦不被使用后，需要等到下一个GC 时才能被释放。这里，笔者将举出其他几种对系统危害更大的内存泄漏情况：
1）大对象的分配
.NET中所有的大对象将分配在托管堆内一个特殊的区域，这里暂时称呼它为“大对象堆”。在回收大对象堆内的对象时，其他的大对象不会被移动，这是考虑到大规模地移动对象需要耗费过多的资源。这样，在程序过多地分配和释放大对象之后，就会产生很多内存碎片。
，随着对象的分配和释放不断进行，在不进行对象移动的大对象堆内，将不可避免地产生小的内存碎片。程序员对此能做的就是尽量减少大对象的分配次数，尤其是那些作为局部变量的，将被大规模分配和释放的大对象，典型的例子就是String类型，关于String的使用在后续章节将有详细的叙述。
2）不恰当地保存根引用
最简单也最常见的错误做法可能就是不恰当地把一个对象申明为公共静态变量，一个公共的静态变量将一直被GC视为一个在使用的根引用，而更糟糕的情况是，当这个对象内部还包含更多的对象引用时，这些对象同样不会被释放。看一段简单的代码：代码3-19。
代码3-19 保存根引用：RefRoot.cs
namespace NET.MST.Third.RootRef
{
    public class RefRoot
    {
        //这里是一个占用大量内存的成员
        public String[] BigMembor;
        public RefRoot(String content)
        {
            //初始化大对象
            BigMembor = new String[1000];
            for (int i = 0; i < BigMembor.Length; i++)
                BigMembor[i] = content;
        }
    }
    public class MainClass
    {
       //公共静态大对象
        public static RefRoot bigobject = new RefRoot("aaa");
        static void Main()
        {
            Console.Read();
        }
    }
}
在代码3-19中，MainClass定义了一个公共静态的大对象，这个对象将直至程序运行结束后才会被GC释放。这一段代码的设计是否成功将取决于这个公共静态变量被使用的频率以及业务逻辑，如果在整个程序中各个类型不断地使用这个静态成员，那这样的设计有助于减少大对象堆内的内存碎片，但如果整个程序极少地甚至于只有一次使用了这个成员，那考虑到它占用的内存会影响整体系统的性能，设计时应该考虑把他设计成实例变量，以便于GC 能够及时地释放它。
这里仍然只从性能的角度考虑问题，实际的设计情况不仅需要考虑性能，还需要考虑程序的和架构和可扩展性。
3)3）不正确的Finalize方法
在前述章节中笔者已经介绍了，Finalize方法由一个专用的线程进行调用，微软并没有公开这部分具体的调度算法，但是有一点却是肯定的，不正确的Finalize方法将导致Finalize方法不能被正确执行，系统中所有的Finalize方法不能被正确执行时，包含它们的对象也只能驻留在托管堆内不能被释放，这样的情况将会导致严重的后果。
Finalize方法应该只致力于快速而简单地释放非托管资源，并且尽可能快地返回。不正确的Finalize方法可能包含这样的代码：
?   没有保护地写文件日志
?   访问数据库
?   访问网络
?   把当前对象赋给某个存活的引用
当Finaize方法访问文件系统、数据库系统或者网络时，将会有资源争用和等待的潜在危险。试想一个试图不断尝试访问离线数据库的Finalize方法，将会在长时间内不会返回，这不仅影响了本身对象的释放，也使得排在 Finalize方法队列中的所有后续对象得不到释放，这个连锁反应将很快造成内存耗尽。

而另外一种危险的代码是在Finalize方法中把对象自身又赋给了另外一个存活的引用，这时对象内的一部分资源已经被释放了，而另外一部分则没有，这样一个对象被再次激活后，将导致不可预知的后果。

本文链接

A Software Developer’s Reading Plan

2010-04-23T09:23:00Z

I got this list from 《Code Complete》 Book：

1.Introductory Level

To move beyond “introductory” level at Construx, a developer must read the following books.

《A Guide to Better Ideas, 4th ed》Adams, James L. Conceptual Blockbusting: Cambridge, Mass.: Perseus Publishing.

《Programming Pearls, 2d Ed》

Bentley, Jon. . Reading, Mass.: Addison-Wesley, 2000. Glass, Robert L. , Boston, Mass.: Addison Wesley, 2003.

《Facts and Fallacies of Software Engineering》

McConnell, Steve. . Redmond, WA: Microsoft Press, 1998.

《Software Project Survival Guide》

McConnell, Steve. .. Redmond, WA: Microsoft Press, 2004.

《Code Complete, 2d Ed》

2.Practitioner Level

To achieve “intermediate” status at Construx, a programmer needs to read the following additional materials.

《Software Configuration Management Patterns: Effective Teamwork, Practical Integration》

Berczuk, Stephen P. and Brad Appleton. , Boston, Mass.: Addison Wesley, 2003.

《A Brief Guide to the Standard Object Modeling Language, 3d Ed》

Fowler, Martin. UML Distilled: , Boston, Mass.: Addison Wesley, 2003.

《Software Creativity, Reading, Mass》

Glass, Robert L. .: Addison Wesley, 1995.

《Testing Computer Software, 2d Ed》

Kaner, Cem, Jack Falk, Hung Q. Nguyen. ., New York: John Wiley & Sons, 1999.

《An Introduction to Object-Oriented Analysis and Design and the Unified Process, 2d Ed. 》

Larman, Craig. Applying UML and Patterns: , Englewood Cliffs, N.J.: Prentice Hall, 2001. 238

《Rapid Development》 McConnell, Steve. . Redmond, WA: Microsoft Press, 1996.

《Software Requirements, 2d Ed》Wiegers, Karl. . Redmond, WA: Microsoft Press, 2003.

《“Manager’s Handbook for Software Development”》,

NASA Goddard Space Flight Center. Downloadable from sel.gsfc.nasa.gov/website/documents/online-doc.htm.

3.Professional Level

A software developer must read the following materials to achieve full professional

standing at Construx (“leadership” level). Additional requirements are tailored to each individual developer;

this section describes the generic requirements.

《Software Architecture in Practice, Second Edition》

Bass, Len, Paul Clements, and Rick Kazman. Boston, Mass.: Addison Wesley, 2003.

《Improving the Design of Existing Code, Reading》

Fowler, Martin. Refactoring: Mass.: Addison Wesley, 1999.

《Design Patterns, Reading, Mass》

Gamma, Erich, et al. Design Patterns, Reading, Mass.: Addison Wesley, 1995.

《Principles of Software Engineering Management》

Gilb, Tom. Wokingham, Eng-land: Addison-Wesley.

《Writing Solid Code》

Maguire, Steve. . Redmond, WA: Microsoft Press, 1993.

《Object-Oriented Software Construction, 2d Ed》

Meyer, Bertrand. Object-Oriented Software Construction, 2d Ed. New York: Prentice Hall PTR, 1997.

《“Software Measurement Guidebook”》

“Software Measurement Guidebook”, NASA Goddard Space Flight Center. Available from sel.gsfc.nasa.gov/website/documents/online-doc.htm.

For more details on this professional development program, as well as for up-to-date reading lists,

see our professional development website at www.construx.com/professionaldev/.

本文链接

浅析.NET中的Serialization

2010-04-21T10:49:00Z

Serialization的概念

　　Serialization是.NET中一种实现对象持久性（Persistent）的机制。它是一个将对象中的数据转换成一个单一元素（通常是Stream）的过程。它的逆过程是Deserialization。Serialization的核心概念是将一个对象的所有数据看作一个独立的单元。

　　一般说来，在两种情况下非常需要Serialization：1）当我们希望能够将对象当前的状态完整地保存到存储介质中，以便我们以后能够精确地还原对象时；2）当我们希望将对象从一个应用程序空间（Application domain）传递到另一个应用程序空间时。例如，Windows Form程序就是利用Serialization机制来实现剪贴板的copy & paste的。

　　.NET Framework支持两种类型的Serialization：Shallow Serialization和Deep Serialization。

　　所谓Shallow Serialization是将对象的可读写（read-write）属性的值转换成字节流，而对象内部的数据（没有通过read-write属性暴露出来的数据）则不被转换。XmlSerializer以及Web Services就使用这种技术。

　　Deep Serialization比Shallow Serialization更加彻底，因为它是将存储在对象私有变量里的实际值拷贝到字节流里。而且Deep Serialization还将serialize整个object graph。也就是说，如果你的对象持有其他对象的引用，或者其他对象引用的集合，那么所有这些对象都将被Serialize。BinaryFormatter和SoapFormatter以及.NET Remoting都使用Deep Serialization技术，它甚至被有限地用于LosFormatter来产生存储在Web Form页中的状态数据。

　　本文将着重于Deep Serialization。

　　Serialization的过程

　　.NET Framework通过Reflection提供自动Serialization的机制。当一个对象被序列化（Serialized）的时候，它的类名，Assembly，以及类实例的所有数据成员都将被写入存储介质中。Serialization引擎保持对所有已经被序列化的对象引用的追踪，以确保相同的对象引用最多只被序列化一次。

　　通常，一个Serialization过程会由formatter（例如BinaryFormatter）的Serialize方法引发。对象的Serialization过程按照以下规则进行：

　　1、检测以确保formatter是否拥有一个代理选择器（surrogate selector）。如果有，检查代理选择器是否持有给定的对象类型。如果有，ISerializable.GetObjectData被调用。

　　2、如果formatter没有代理选择器，或者代理选择器没有对象类型，检查对象是否被用Serializable属性标记。如果没有，则抛出SerializationException异常。

　　3、如果对象被标记为Serializable，检查对象是否实现了ISerializable接口。如果实现了此接口，则GetObjectData被调用。

4、如果对象没有实现ISerializable接口，则使用默认的序列化策略，来序列化没有用NonSerialized属性标记的域。

使你的class能够被序列化

　　通过上面对Serialization过程的分析，我们可以看出，有两种方式可以使一个class能够被序列化：1）将此class简单地标记为Serializable；2）为此class实现ISerializable接口，并将此class标记为Serializable。

　　1、标记Serializable属性

　　标记Serializable属性的方式是实现Serialization的基本方法。举个简单的例子：

　　[Serializable]

　　public class Person

　　{

　　public string name = null;

　　public int age = 0;

　　}

　　你可以使用BinaryFormatter来将上面的class序列化：

　　Person sam = new Person();

　　sam.name = "sam";

　　sam.age = 24;

　　IFormatter formatter = new BinaryFormatter();

　　Stream stream = new FileStream("sam.dat",

　　FileMode.Create, FileAccess.Write, FileShare.None);

　　formatter.Serialize(stream, sam);

　　stream.Close();

　　就是这么简单，你所要做的就是创建一个Stream和一个formatter的实例，然后调用formatter的Serialize方法。经过BinaryFormatter serialize的数据仍然能够通过BinaryFormatter deserialize回来，方法与serialize同样简单，这里就不赘述了。

　　如果你不想将类里的所有域都序列化，可以使用NonSerialized属性进行选择。如：

　　[Serializable]

　　public class Person

　　{

　　public string name = null;

　　[NonSerialized]

　　public int age = 0;

　　}

　　这样，age域就不会被序列化了。

　　需要注意的是，Serializable属性并不能被继承。也就是说如果你希望Person的派生类也能够被Serialize的话，那么这个派生类也必须被Serializable标记。否则将得到SerializationException异常。

　　同样的，Person类中的所有对其他类的引用，其所引用的类都应该是能够被Serialize的。.NET Framework中的大部分class都实现了ISerializable接口，但有些class没有实现，例如ImageList。可以通过MSDN Library的到一个实现了ISerializable接口的class列表。对那些没有实现此接口的class，使用的时候要当心。

2、实现ISerializable接口

　　Serializable属性的功能非常强大，它使得Serialize和Deserialize变得十分简单。但凡事有利必有弊，由Serializable实现的自动序列化方法有时不够灵活。我们并不能完全控制Serialize和Deserialize的行为，而有些时候它们的行为对我们来说很重要。那么我们通过何种方法能够控制Serialize和Deserialize的行为呢？答案就是，自己来实现ISerializable接口。ISerializable接口给予我们更大的自由来控制Serialize和Deserialize，但是无疑我们将不得不写更多的代码L。

　　下面我们来看看如何实现ISerializabe接口。ISerializable接口位于System.Runtime.Serialization名字空间中，声明如下：

　　public inferface ISerializable

　　{

　　void GetObjectData(SerializationInfo info,

　　StreamingContext context);

　　}

　　它只有一个方法GetObjectData。因此，像实现其他接口一样，我们必须实现此方法。但与其他接口不同的是，为了Deserialization，我们还必须实现一个特殊的构造函数（我称此构造函数为“序列化构造函数”），此构造函数具有与GetObjectData相同的参数列表。由于此构造函数专门用于.NET Framework在Deserialize时的Reflection机制，因此我们通常将它声明为保护或私有模式。如下：（当然，如果你的class只需要Serialize而不需要Deserialize的话，也可以不实现这个特殊的构造函数）

　　[Serializable]

　　public class Person : ISerializable

　　{

　　public string name = null;

　　public int age = 0;

　　public Person()

　　{

　　}

　　protected Person(SerializationInfo info, StreamingContext context)

　　{

　　name = info.GetString("name");

　　age = info.GetInt32("age");

　　}

　　void ISerializable.GetObjectData(SerializationInfo info,

　　StreamingContext context)

　　{

　　info.AddValue("name", name);

　　info.AddValue("age", age);

　　}

　　}

　　通过实现ISerializable接口，使得我们有机会在ISerializable.GetObjectData中控制Serialize的行为，在“序列化构造函数”中控制Deserialize的行为。这个接口提供给我们的信息非常全面而灵活，以致于我们甚至可以在这两个方法中耍些花招。比如，我们可以在Deserialize的时候，籍由改变info.FullTypeName来得到一种与被Serialize的对象不同类型的另一个对象等。

本文链接

#if (C# Reference)

2010-04-16T05:13:00Z

ref:http://msdn.microsoft.com/en-us/library/4y6tbswk.aspx

1 // preprocessor_if.cs
2 #define DEBUG
3 #define MYTEST
4 using System;
5 public class MyClass
6 {
7     static void Main()
8     {
9 #if (DEBUG && !MYTEST)
10         Console.WriteLine("DEBUG is defined");
11 #elif (!DEBUG && MYTEST)
12         Console.WriteLine("MYTEST is defined");
13 #elif (DEBUG && MYTEST)
14         Console.WriteLine("DEBUG and MYTEST are defined");
15 #else
16         Console.WriteLine("DEBUG and MYTEST are not defined");
17 #endif
18     }
19 }

本文链接

VS 2008 常用快捷键！

2010-04-12T05:30:00Z

左缩进：（支持多行操作）

Ctrl + TAB；

右缩进：（支持多行操作）

TAB； .

快捷键功能
CTRL + SHIFT + B生成解决方案
CTRL + F7 生成编译
CTRL + O 打开文件
CTRL + SHIFT + O打开项目
CTRL + SHIFT + C显示类视图窗口
F4 显示属性窗口
SHIFT + F4显示项目属性窗口
CTRL + SHIFT + E显示资源视图
F12 转到定义
CTRL + F12转到声明
CTRL + ALT + J对象浏览
CTRL + ALT + F1帮助目录
CTRL + F1 动态帮助
F1 帮助
SHIFT + F1当前窗口帮助
CTRL + ALT + F3帮助-搜索
SHIFT + ALT + ENTER全屏显示
CTRL + -向后定位
CTRL + SHIFT + -向前定位
CTRL + F4关闭文档窗口
CTRL + PAGE DOWN光标定位到窗口上方
CTRL + PAGE UP光标定位到窗口下方
CTRL + F6
CTRL + TAB下一个文档窗口
CTRL + SHIFT + F6
CTRL + SHIFT + TAB上一个文档窗口
ALT + F6下一个面板窗口
CTRL + K, CTRL + L取消remark
CTRL + K, CTRL + C注释选择的代码
CTRL + K, CTRL + U取消对选择代码的注释
CTRL + M, CTRL + O折叠代码定义
CTRL + M, CTRL + L展开代码定义
CTRL + DELETE删除至词尾
CTRL + BACKSPACE删除至词头
SHIFT + TAB取消制表符
CTRL + U转小写
CTRL + SHIFT + U转大写
CTRL + SHIFT + END选择至文档末尾
CTRL + SHIFT + HOME选择至文档末尾开始
SHIFT + END选择至行尾
SHIFT + HOME选择至行开始处
SHIFT + ALT + END垂直选择到最后尾
SHIFT + ALT + HOME垂直选择到最前面
CTRL + A全选
CTRL + W选择当前单词
CTRL + SHIFT + PAGE UP选择至本页前面
CTRL + SHIFT + PAGE DOWN选择至本页后面
CTRL + END文档定位到最后
CTRL + HOME文档定位到最前
CTRL + G转到…
CTRL + K, CTRL + P上一个标签
CTRL + K, CTRL + N下一个标签
ALT + F10调试-ApplyCodeChanges
CTRL + ALT+ Break停止调试
CTRL + SHIFT + F9 取消所有断点
CTRL + F9允许中断
CTRL + SHIFT + F5调试-重新开始
F5运行调试
CTRL + F5运行不调试
F10跨过程序执行
F11单步逐句执行
CTRL + J列出成员
CTRL + PAGE DOWN下一个视图
CTRL + B格式-粗体
CTRL + SHIFT + T格式-文字缩进

调试快捷键

F6: 生成解决方案
Ctrl+F6: 生成当前项目
F7: 查看代码
Shift+F7: 查看窗体设计器
F5: 启动调试
Ctrl+F5: 开始执行(不调试)
Shift+F5: 停止调试
Ctrl+Shift+F5: 重启调试
F9: 切换断点
Ctrl+F9: 启用/停止断点
Ctrl+Shift+F9: 删除全部断点
F10: 逐过程
Ctrl+F10: 运行到光标处
F11: 逐语句
编辑快捷键

Shift+Alt+Enter: 切换全屏编辑
Ctrl+B,T / Ctrl+K,K: 切换书签开关
Ctrl+B,N / Ctrl+K,N: 移动到下一书签
Ctrl+B,P: 移动到上一书签
Ctrl+B,C: 清除全部标签
Ctrl+I: 渐进式搜索
Ctrl+Shift+I: 反向渐进式搜索
Ctrl+F: 查找
Ctrl+Shift+F: 在文件中查找
F3: 查找下一个
Shift+F3: 查找上一个
Ctrl+H: 替换
Ctrl+Shift+H: 在文件中替换
Alt+F12: 查找符号(列出所有查找结果)
Ctrl+Shift+V: 剪贴板循环
Ctrl+左右箭头键: 一次可以移动一个单词
Ctrl+上下箭头键: 滚动代码屏幕，但不移动光标位置。
Ctrl+Shift+L: 删除当前行
Ctrl+M,M: 隐藏或展开当前嵌套的折叠状态
Ctrl+M,L: 将所有过程设置为相同的隐藏或展开状态
Ctrl+M,P: 停止大纲显示
Ctrl+E,S: 查看空白
Ctrl+E,W: 自动换行
Ctrl+G: 转到指定行
Shift+Alt+箭头键: 选择矩形文本
Alt+鼠标左按钮: 选择矩形文本
Ctrl+Shift+U: 全部变为大写
Ctrl+U: 全部变为小写

代码快捷键

Ctrl+J / Ctrl+K,L: 列出成员
Ctrl+Shift+空格键 / Ctrl+K,P: 参数信息
Ctrl+K,I: 快速信息
Ctrl+E,C / Ctrl+K,C: 注释选定内容
Ctrl+E,U / Ctrl+K,U: 取消选定注释内容
Ctrl+K,M: 生成方法存根
Ctrl+K,X: 插入代码段
Ctrl+K,S: 插入外侧代码
F12: 转到所调用过程或变量的定义

窗口快捷键

Ctrl+W,W: 浏览器窗口
Ctrl+W,S: 解决方案管理器
Ctrl+W,C: 类视图
Ctrl+W,E: 错误列表
Ctrl+W,O: 输出视图
Ctrl+W,P: 属性窗口
Ctrl+W,T: 任务列表
Ctrl+W,X: 工具箱
Ctrl+W,B: 书签窗口
Ctrl+W,U: 文档大纲
Ctrl+D,B: 断点窗口
Ctrl+D,I: 即时窗口
Ctrl+Tab: 活动窗体切换
Ctrl+Shift+N: 新建项目
Ctrl+Shift+O: 打开项目
Ctrl+Shift+S: 全部保存
Shift+Alt+C: 新建类
Ctrl+Shift+A: 新建项

VS2005的隐藏快捷键

这里我将会把一些无意中发现的VS2005中没有明确指出的快捷键共享出来，并不是所有的快捷键，或者常见的一些快捷键。
1、Ctrl+Space直接完成类或函数（本来这个并不算隐藏的快捷键，但是因为中文输入法抢占这个快捷键，所以。。。，替代的快捷键是Alt+Right）
2、Shift+Delete整行删除，并且将这一行放到剪贴板（这时候不能选中一段内容）
3、Shift+Insert粘贴，有点匪夷所思，Ctrl+V就可以了，大概是为了和Shift+Delete对应吧
4、Ctrl+Up，Ctrl+Down滚动编辑器，但尽量不移动光标，光标保证在可见范围内
5、Ctrl+BackSpace，Ctrl+Delete整词删除，有的时候很有用
6、Ctrl+Left，Ctrl+Right按整词移动光标（不算隐藏，和前面几条加起来就是Ctrl光标控制套件了）
7、Alt+Shift+F10打开执行改名，实现接口和抽象类的小窗口（还可以用Ctrl+.，不过有的中文输入法用到这个）
8、Shift+F9调试是打开QuickWatch，内容是当前光标所在处的内容
9、F12转跳到定义，很有用的快捷键
10、Shift+F12查找所有引用
11、Ctrl+F10=F5，开始Debug
12、Ctrl+F6循环察看代码窗口，有点Ctrl+Tab的感觉
13、Ctrl+F3查找当前光标选中的内容，可以和F3配合使用
14、Ctrl+F2将焦点转移到类的下拉框上
15、Alt+F7=Ctrl+Tab
16、Alt+F11新开VS2005并编辑宏
17、Alt+F12查找=Ctrl+F

快捷键功能

Ctrl+Space 直接完成类或函数（替代的快捷键是Alt+Right）

Shift+Delete 整行删除，并且将这一行放到剪贴板（这时候不能选中一段内容）

Ctrl+Up，Ctrl+Down 滚动编辑器，但尽量不移动光标，光标保证在可见范围内

Ctrl+BackSpace，Ctrl+Delete 整词删除，有的时候很有用

Alt+F8 快速整理源代码

CTRL + F7 生成编译

F12 转到定义

CTRL + F12 转到声明

CTRL + F4 关闭文档窗口

TAB 制表符，可以整体缩排

SHIFT + TAB 取消制表符

CTRL + U 转小写

CTRL + SHIFT + U 转大写

CTRL + A 全选

CTRL + W 选择当前单词

Shift+F5 停止调试

Alt+ F9 显示所有断点

F5 运行调试

CTRL + F5 运行不调试

F10 跨过程序执行

F11 单步逐句执行，进入函数内部执行

F6: 生成解决方案

Ctrl+F6: 生成当前项目

F5: 启动调试

Ctrl+F5: 开始执行(不调试)

Shift+F5: 停止调试

Ctrl+Shift+F5: 重启调试

F9: 切换断点

Ctrl+F9: 启用/停止断点

Ctrl+F: 查找

Ctrl+H: 替换

Ctrl+Shift+L: 删除当前行

Shift+F12 查找所有引用

本文链接