Microsoft.Net Programming Ebooks

Provides you with ebooks download links of various topics such as NET 2003, .Net Architecture, .Net Framework, .Net Framework 3.5, .Net Interoperability, .Net Optimization, .Net Patterns, .Net Performance, .Net Security, ASP.NET, C#.NET, Spring.Net, VB.Net and more.

A Comparison of Visual Basic .NET and C#

A NUMBER OF LANGUAGES work with the .NET Framework. Microsoft is releasing the following four languages with its Visual Studio .NET product: C#, Visual Basic .NET, JScript.NET, and Managed C++. The languages likely to be the most popular are Visual Basic .NET (which I discuss in this book) and C#. C# (which you pronounce C Sharp) is the language that Microsoft is using for all its own internal development for .NET, so a comparison of C# and Visual Basic .NET is in order. In this appendix, I cover the similarities and differences between C# and Visual Basic .NET. If you want to go over the different concepts in Visual Basic .NET before reading about C#, look at Chapter 2, which is the roadmap for this appendix.

Although by no means an exhaustive list of the differences between C# and Visual Basic .NET, this appendix should give you a good start if you have any interest in programming in C#.

Labels: ,

Visual Basic .NET Tutorial

by Paul Michelbrink

Visual Basic is a programming language that is designed especially for windows programming. This tutorial will step through and demonstrate some of the features of Visual Basic. It will explain most of the tools available for implementing GUI based programs. After introducing the basic facilities and tools provided by Visual Basic, we apply our knowledge to implementing a small VB program. Our program will implement a visual interface for a commonly know “stack” abstract data type.

Following are the visual basic.net topics covered in this VB.Net tutorial document.
  • Programming Tools
  • Tool Bar
  • Tool Box
  • Properties Window
  • How to Begin
  • Implementing the Visual Stack Program
  • Step 1: “The Blank Form Properties”
  • Adding an Icon
  • Step 2: “Adding Objects to Our Form”
  • Step 3: “Changing the Properties of the Controls.”
  • Command Buttons:
  • Pictures:
  • Labels:
  • Text Box:
  • Menus:
  • Adding New Forms
  • Adding the Code to the Forms
  • The Source Code:
  • About Form:
  • Definition Form:
  • Stack Form:
  • Stack Form Code:
  • Text Box Code: Push:
  • Pop:
  • Peek:
  • Initialize:
  • Menu Code 
Read More/Download
Labels:

Visual Basic 6 and Visual Basic .NET: Differences

More than three years ago, the Microsoft Visual Basic team set out to create Visual Basic .NET. At that time managers would kid the development team by saying that they were making only three “simple” changes to Visual Basic 6: a new runtime system, a new development environment, and a new compiler. The Visual Basic development team spent the next three years working on one of these changes: the new compiler. Two other teams provided the development environment and runtime. As we pointed out in Chapter 1, the end result is not a new version of Visual Basic 6 but an entirely new product: Microsoft Visual Basic .NET. The name is important for two reasons. First, Visual Basic is still Visual Basic. Second, Visual Basic .NET is not Visual Basic 7.

This chapter describes the three “simple” changes made to create Visual Basic .NET, including changes to the runtime, the development environment, and the compiler. Microsoft also added other features to Visual Basic .NET along the way, including a new forms package and a new debugger, and these are also discussed in this chapter.

Labels:

ASP.NET 2.0 Web Parts in Action: Portal Management

ASP.NET 2.0 Web Parts in Action is packed with annotated code, diagrams, and crystal-clear discussions. You'll develop a sample project from design to deployment, adding content zones, personalization, and a custom look-and-feel. Since any website is invariably a work-in-progress, you'll appreciate learning how to upgrade your portals on the fly. Along the way you'll pick up handy code instrumentation techniques and a few tricks to help your portals manage themselves. As an added bonus, the book introduces the Microsoft Ajax Library ("Atlas") and shows how you can add Ajax to a web part. You¹ll even create a Live.com gadget.

This book is for web developers familiar with ASP.NET.

ASP.NET Web Parts in Action is a must read book for every developer who wants to extend his knowledge of the ASP.NET framework - Simon Busoli

You will learn
  • Effective portal design strategies
  • Add personalization features
  • Create user-friendly controls
  • Develop custom themes and WebPartChrome
  • Automate site health monitoring
  • Techniques for graceful error recovery
Read More/Download
Labels:

Creating Form Rendering ASP.NET Applications

You can create an ASP.NET application that is able to invoke the Forms service resulting in the ASP.NET application able to render interactive forms to client web browsers and handle form submissions. The Forms service is able to render different interactive form types, such as PDF, HTML, and Form guides (Flash-based forms). For the purpose of this discussion, it is assumed that the Forms service renders interactive PDF forms (interactive means that an end user will be able to enter data into the form’s fields).

The Forms service renders interactive PDF forms to client devices, typically web browsers, to collect information from users. After an interactive form is rendered, a user can enter data into form fields and click a submit button located on the form to send information back to the Forms service. Adobe Reader or Acrobat must be installed on the computer hosting the client web browser in order for an interactive PDF form to be visible.

This document discusses how to create an ASP.NET application that is able to render interactive forms to loan applicants in order to collect information required to process a loan request. This application lets a user fill in a form with data required to secure a loan and then submits data to the ASP.NET application. The following diagram shows the ASP.NET loan application’s logic flow.

Labels:

Macromedia Flash Remoting for ASP.NET: End-to-End Setup Notes

by Ron Zasadzinski

Following are the topics covered in this ASP.Net document.
  • Prerequisites to installing Flash Remoting for .NET:
  • Computer operating system requirements
  • Installing IIS
  • Installing MDAC
  • Installing the .NET framework
  • XP Pro: turn off Simple File Sharing
  • Set up a web site within IIS
  • IIS permissions
  • Directory security (aka NTFS) permissions
  • Flash Remoting for ASP.NET installation and setup
  • Download Flash Remoting for ASP.NET
  • Install Flash Remoting for ASP.NET
  • Install the Flash Remoting for .NET Updater Release 1
  • Enable Flash Remoting for your web site
  • Critical Step: Set Application Name
  • Troubleshooting
Read More/Download
Labels:

Changes between the ASP.NET AJAX (“Atlas”) CTP and the RTM Releases

This document Describes changes to the ASP.NET 2.0 AJAX Extensions and the Microsoft AJAX Library (both products formerly code-named “Atlas” and collectively referred to as ASP.NET AJAX) since the most recent Community Technical Preview (CTP) release.

The ASP.NET team is delivering a framework for generating Web applications that can take advantage of the latest capabilities in client functionality that fall under the general banner of Asynchronous JavaScript and XML (AJAX) and Rich Interactive Applications (RIA). The new Microsoft ASP.NET AJAX addition to the .NET Framework includes a suite of JavaScript libraries (the Client Framework or Client FX) that are the foundation for creating rich behaviors and control-like functionality in the browser. ASP.NET AJAX also includes a set of a server controls and base classes for extender controls (the Server Framework or Server FX) that provides AJAX programming functionality and experiences for ASP.NET Web developers.

ASP.NET AJAX functionality has been available to the public since October 2005 as a series of Community Technology Previews (CTPs), demonstrating everything from rich client behavior and asynchronous Web page postbacks to invoking and consuming Web services through JavaScript proxies.

This paper describes the major differences between the final CTP release (made publicly available in July 2006) and the upcoming Microsoft ASP.NET AJAX v1.0 release (here called the RTM release). It also discusses a "futures" preview version (the Futures release) that adds functionality to the RTM release. (The RTM and the Futures releases together enable the full functionality and customer scenarios that were supported in the early CTP releases.) Further changes to the RTM and Futures releases may occur up to the Release Candidate (RC) version, which will be the final release before RTM.

The document is organized in sections detailing specific functionality in the CTP release and how the same functionality is achieved with the RTM release. For each change there is a description of the reasons behind the change along with some technical insights.

Labels:

Authentication and Security Mechanisms in ASP.NET Web Applications

Microsoft’s .NET framework provides developers with the ability to build and deploy applications and services via the Web. These services can facilitate communication between clients and .NET application servers (such as database servers and so forth) through the use of XML queries issued by the client. This environment is attractive to developers because it is a language-neutral environment that can deliver content to end-users regardless of the platform in use.

ASP.NET is a part of the framework for developing .NET applications. .NET itself is a model of software development and delivery envisioned by Microsoft. Its goal is to provide the software, develpoment platform, and backend infrastructure for applications that can be distributed across the Internet or other networks to a variety of devices such as Personal Computers (PCs) and Personal Digital Assistants (PDAs).

Although this technology provides powerful functionality to developers, these services can represent a potential threat to the security of a Web server. .NET applications and services can provide potential intruders with a new vector of attack, since many firewalls do not process HTTP traffic at a sufficient level to recognize malicious activity. Furthermore, these applications can possibly be used as a gateway for attackers to communicate with the .NET application servers.

This document discusses some of the security mechanisms and configuration options available to administrators to help secure these applications and reinforce the integrity of the Web server.

Labels:

ASP.NET Ebooks from More-dotnet.blogspot.com

This .net and microsoft visual studio 6 site aims to provide free ebook on vb, vc++, asp.net, visual basic .net, ado.net, c#.net, vb.net, microsoft .net platforms, c net, asp net 2.0, j#.net, .net database, activeX programming, visual j++, microsoft visual interdev, visual basic 2005 and vb.net database,etc


Labels:

VB.NET Ebooks from more-dotnet.blogspot.com

 This .net and microsoft visual studio 6 site aims to provide free ebook on vb, vc++, asp.net, visual basic .net, ado.net, c#.net, vb.net, microsoft .net platforms, c net, asp net 2.0, j#.net, .net database, activeX programming, visual j++, microsoft visual interdev, visual basic 2005 and vb.net database,etc
Labels:

More C# Ebooks: more-csharp.blogspot.com

This c# and c# net site aims to provide free ebook on c# datagrid, c# array, c# xml, msdn c#, c# application, c# example, c# form, c# sample, c# programming, asp net c#, c# database, c# console, c# library, c# file, c# enum, c# switch and c# code, etc.

    Labels:

    Visual Basic.Net - An Introduction

    By Vijay Mukhi, Deepak N. Ramchand, and Sonal Mukhi

    The .NET Framework, encompassing a great new product called Visual Studio.NET, is tipped to spur a revolution in the software industry. This is because, the .Net Framework and Visual Stodio.Net have been designed with the Internet as their epicentre.

    Visual Basic has been the most widely accepted programming language in the world, and also enjoys the distinction of having the largest band of loyal programmers. Thus, Microsoft was left with no choice but to integrate this product into the .NET Framework in the form of VB.NET. In order to accommodate the large troupe of existing VB developers within this framework, Microsoft has introduced a number of contemporary features to VB.NET, and greatly ameliorated its web design facilities. VB.NET is also regarded as the easiest entry-point into the .Net world, that provides succour to those who are terrified of biting the bullet of the Brave New World of technology.

    Microsoft has retained the heart and soul of the original VB product, while simultaneously embellishing it with the latest developments available in software technology. This forms the genesis of VB.NET. As a result, Visual Basic.NET is primarily an extension of the Visual Basic programming language, which is shipped with the Visual Basic product. However, it is a significant upgrade or improvement over VB and is far more flexible and powerful.

    This book is for the dilettante, and aimed at anyone who is interested in learning VB.NET. The approach that has been followed here is that simple applications are built first, and then, the code is deciphered to unveil the internal workings of the product.

    However, in order to thoroughly appreciate the internal execution of the programs, there are certain significant concepts of the language that need to be discerned first. We have ferreted out the relevant concepts and presented them in the most elementary manner.

    This book converges predominantly around the language aspect, to provide enhanced insights to the programmer into the innovative and improved features of VB.Net. We are of the opinion that on learning the language, large applications can be designed with effortless ease.

    This book is also endowed with a generous sprinkling of error messages, since we believe that by studying the cause of the errors that are generated by programming languages, programmers are bound to become more astute.

    We have ensured that your interest does not evaporate, by making the book as entertaining and informative as possible. We have done our best to bring our aim of making you a good VB.NET programmer, to fruition.

    Finally, we leave it to you to decide whether the VB.NET product has really lived up its expectations or not.

    Labels:

    Application Interoperability: Microsoft .NET and J2EE

    Application Interoperability: Microsoft .NET and J2EE presents interoperability best practices, and illustrates these approaches with a functional sample application. It shows how to link Microsoft .NET and J2EE, using Web services, runtime bridges, and asynchronous techniques.

    This guide is aimed at developers who are responsible for creating and implementing enterprise level business applications based on either Microsoft .NET or on J2EE and where interoperability between the two platforms is a requirement.

    This guide is written for readers in one or more of the following categories:
    • The sections targeted at .NET developers assume an understanding of the development process for distributed applications and familiarity with the Microsoft Visual Studio.NET programming tools. The sample applications are in C# (C Sharp), so development experience in this language is essential. Experience with the .NET Framework SDK and the MSDN Library are also of benefit.
    • The sections targeted at Java developers assume a familiarity with Java programming methods and tools, in particular Enterprise Java Beans (EJB) and Java APIs such as Java Naming and Directory Interface (JNDI) and the Java Messaging Service (JMS).
     Read More/Download
    Labels:

    ASP.Net With C#

     By Vijay Mukhi, Sonal Mukhi and Neha Kotecha

    ASP.Net provides the most powerful environment for development of sophisticated, real-life business applications. It was only natural for us to get sucked into the vortex of the exciting opportunity that this language provides, to satiate our technical appetite. This book presents a realistic tableau of the vast repertoire of features of the ASP.Net language. We have scythed through the maze of technological jargon to present to you, in a simple yet comprehensive manner, all the salient features of the language.

    The book commences with the assumption that you are a programming tyro, with no previous knowledge of ASP.Net or C#. It however, expects you to have a working knowledge of the Hyper Text Markup Language (HTML). The book covers the length and breadth of the ASP.Net framework. Since the C# language has been used for programming, the fundamentals of this language have also been covered.

    The book begins with the basics of the ASP.Net and C#. Thereafter, it moves on to the built-in controls of ASP.Net. Next, it demonstrates how you can build your own custom controls. The text then veers on to the concepts of the built-in C# classes, and shows you how to build your own custom classes. It also covers the myriad aspects of handling databases, advanced concepts of controls, mysteries of Cookies, CGI Progamming and state management,Web Services and finally a Class Browser Application. It finally winds up with a peek into the security issues of designing an Internet application using ASP.Net. Thus, you’ll be able to appreciate, that a vast array of technical concepts of ASP.Net have been covered by this book.

    This book is teeming with examples and explanations that discuss each concept threadbare. The various disparate concepts have been woven together to create a beautiful tapestry of the ASP.Net language. It has always been our modus operandi to break up large programs into smaller fragments, comprehend each fragment thoroughly and subsequently, synthesize all the fragments together to retrieve the original program. The same strategy has been employed in this book also. Each concept has been substantiated with examples so that you can see how each concept is implemented in real-life applications.

    In our books, we have presented examples that emulate a concept supplied in the documentation, or some idea we found on the Internet. However, some of the concepts introduced are purely ours, and thus original. As far as we are concerned, you are free to use our accepted wisdom, as long as someone somewhere in the world benefits from it.

    We are sanguine that this book will go a long way in providing ample food for thought, to sate the technological hunger of your minds. We implore you to put in sedulous effort in mastering this language, by reading all the material provided to you in this book with sincerity, and also by trying out all the examples that have been presented. We are confident that on doing so, you will be able to scale dizzying heights in the world of Internet programming.

    Labels: ,

    Visual Studio.Net with C#

    By Vijay Mukhi, Suraj Godhwani, Sonal Mukhi
    This book on Visual Studio.Net is a trailblazer, since it is extremely innovative in its approach.  It is a screen-based book, which suggests that the entire book is packed with screens, making it very easy and intuitive for a reader to grasp the explanations accompanying them.  It makes for an interesting reading, and also does away with the requirement of sitting in front of a computer while reading this book.

    Visual Studio.Net facilitates a paradigm shift in the programming world.  It has alleviated the task of software development considerably, by synthesizing all applications into a single product.  Earlier, every product had its own User Interface, and programmers had very strong loyalties towards specific products.  This prevented their smooth migration from existing products to the newer products, which emerged with systematic regularity.   

    In the Visual Studio.Net environment, building complex applications is a breeze.  The switch over from one runtime to another, is also considerably smooth and effortless.

    During our perambulation through the various facets of this fascinating product, we have adopted a 'step-by-step' approach to unravel the various features.  We have pared down the irrelevant details, and converged only on the most pertinent areas.  We have systematically built-up on own our earlier explanations incrementally. For instance, after ensuring that the reader is comfortable with building various types of applications, we have graduated onto the topic of deployment, so that the reader can then, transport his application with ease.

    Readers are well advised to peruse the text thoroughly, enter the code as demonstrated, and run the applications, to get a hands-on experience of the product. This is the best available approach to master this product.

    For those with an insatiable appetite for technical knowledge, we have exhumed the surface, in order to disinter and explore the workings of the C# language. The latter chapters expound the C# code, generated by the framework for applications built in the earlier chapters.

    The three-pronged novel approach of firstly, adding visual appeal by incorporating a plenitude of screens, secondly, of providing simple and complex applications to illustrate various concepts, and finally, of going behind the scenes to explore the c++ code generated by the application, is the linchpin of this book.

    We have persevered to simplify the preplanning concepts and have percolated the grain from the chaff.  The perspicacity of the text is an important feature implemented by us.

    This book contains a plethora of information about Visual Studio.Net and the C# language. We have focussed our attention on Visual Studio.Net, since it is going to play an increasingly important role in the field of computer programming, and its ramifications are going to be far-reaching.  So, you would be well-advised to climb onto this bandwagon and scale the heights with us, without much ado.

    Labels:

    The Spring.NET Framework

    Developing software applications is hard enough even with good tools and technologies. Spring provides a light-weight solution for building enterprise-ready applications. Spring provides a consistent and transparent means to configure your application and integrate AOP into your software. Highlights of Spring's functionality are providing declarative transaction management for your middle tier as well as a full-featured ASP.NET framework.

    Spring could potentially be a one-stop-shop for many areas of enterprise application development; however, Spring is modular, allowing you to use just those parts of it that you need, without having to bring in the rest. You can use just the IoC container to configure your application and use traditional ADO.NET based data access code, but you could also choose to use just the Hibernate integration code or the ADO.NET abstraction layer. Spring has been (and continues to be) designed to be non-intrusive, meaning dependencies on the framework itself are generally none (or absolutely minimal, depending on the area of use).

    This document provides a reference guide to Spring's features. Since this document is still to be considered very much work-in-progress, if you have any requests or comments, please post them on the user mailing list or on the support forums at forum.springframework.net.

    Before we go on, a few words of gratitude are due to Christian Bauer (of the Hibernate team), who prepared and adapted the DocBook-XSL software in order to be able to create Hibernate's reference guide, thus also allowing us to create this one. Also thanks to Russell Healy for doing an extensive and valuable review of some of the material.

    Enterprise applications typically are composed of a number of a variety of physical tiers and within each tier functionality is often split into functional layers. The business service layer for example typically uses a objects in the data access layer to fulfill a use-case. No matter how your application is architected, at the end of the day there are a variety of objects that collaborate with one another to form the application proper. The objects in an application can thus be said to have dependencies between themselves.

    The .NET platform provides a wealth of functionality for architecting and building applications, ranging all the way from the very basic building blocks of primitive types and classes (and the means to define new classes), to rich full-featured application servers and web frameworks. One area that is decidedly conspicuous by its absence is any means of taking the basic building blocks and composing them into a coherent whole; this area has typically been left to the purvey of the architects and developers tasked with building an application (or applications). Now to be fair, there are a number of design patterns devoted to the business of composing the various classes and object instances that makeup an all-singing, all-dancing application. Design patterns such as Factory, Abstract Factory, Builder, Decorator, and Service Locator (to name but a few) have widespread recognition and acceptance within the software development industry (presumably that is why these patterns have been formalized as patterns in the first place). This is all very well, but these patterns are just that: best practices given a name, typically together with a description of what the pattern does, where the pattern is typically best applied, the problems that the application of the pattern addresses, and so forth. Notice that the last paragraph used the phrase “... a description of what the pattern does...”; pattern books and wikis are typically listings of such formalized best practice that you can certainly take away, mull over, and then implement yourself in your application.

    The Spring Framework takes best practices that have been proven over the years in numerous applications and formalized as design patterns, and actually codifies these patterns as first class objects that you as an architect and developer can take away and integrate into your own application(s). This is a Very Good Thing Indeed as attested to by the numerous organizations and institutions that have used the Spring Framework to engineer robust, maintainable applications. For example, the IoC component of the Spring Framework addresses the enterprise concern of taking the classes, objects, and services that are to compose an application, by providing a formalized means of composing these various disparate components into a fully working application ready for use.

    Labels: ,

    A Guide to .NET Framework

    You can use different programming languages such as C#, VBScript, VB.NET, Managed C++ for developing your applications in .NET Framework, as the .NET Framework is not dependent on one particular language or platform and can support many kinds of platforms and programming languages that are in use today. Further, you can use .NET Framework for running your applications in almost all platforms such as Linux, Macintosh and Unix without any hitches.

    The presence of many off-the-shelf libraries in .NET Framework can assist you in developing your applications in a faster, cheaper and easier manner. The most recent .Net Framework version is capable of supporting over 20 different programming languages today.

    The functionality of .Net Framework supporting many programming languages is due to the use of the powerful CLR, the Common Language Runtime engine. The application programming codes are first compiled by CLR into a Microsoft Intermediate Language (MSIL) code instead of native codes and the MSIL, which is nothing but an instruction set, in turn creates the native code for running the application.

    The main advantage of language and platform independent feature of .NET Framework can be attributed to CLR and the same CLR also takes care of run-time services such as memory processes, security enforcement, integration of language, and thread management. Hence, you can make use of the various infrastructures that have been provided in .NET Framework for creating your web-applications.

    As per the classification by the Microsoft, there are two categories of .NET Framework and they are CLR and .Net Framework class library.

    Common Language Runtime: The CLR is responsible for providing a common runtime environment or services with which all .NET applications can run. Further, the various capabilities of CLR can enable any developer to write even big applications with ease using the features such as strong type naming, life-cycle management, dynamic binding that is capable of making any business logic into re-usable component and finally the cross-language exception handling.

    .Net Framework class library: This class library constitutes various predefined functional sets that are very useful while developing the applications by developers. There are three main components in this class library and they are:
    • ASP.NET.
    • Windows Forms.
    • ADO.NET.
    With the .Net Framework you can make your codes written in fewer lines and other favourable features such as easy web settings, easy deployment of applications, easy compilation procedures, easy Web configuration makes the .NET Framework a great platform to work with. In an overall scenario, the developers will be able to concentrate more on Web controls and spend an efficient time in application design and implementation and to have an effective control over the flow of the application sequence.
    Labels:

    Upgrading Microsoft Visual Basic 6.0 to Microsoft Visual Basic .NET

    Upgrading Microsoft Visual Basic 6.0 to Microsoft Visual Basic .NET is the complete technical guide to upgrading Visual Basic 6 applications to Visual Basic .NET, covering all upgrade topics from APIs to ZOrders. It shows how to fix upgrade issues with forms, language, data access, and COM+ Services, and how to upgrade applications with XML Web services, ADO.NET, and .NET remoting. It also provides big-picture architectural advice, a reference of function and object model changes, hundreds of before-and-after code samples, and a CD packed with useful examples.

    Following are the topics covered in this vb.Net book.
    • Introduction to Upgrading
    • Visual Basic 6 and Visual Basic .NET Differences
    • Upgrading Options
    • Preparing Your Project for the Upgrade to Visual Basic .NET
    • Your First Upgrade
    • Common Tasks in Visual Basic .NET
    • Upgrading Wizard Ins and Outs
    • Errors, Warnings, and Issues
    • Using Visual Basic 6 with Visual Basic .NET: COM Interop
    • Ten Common Upgrade Problems
    • Resolving Issues with Language
    • Resolving Issues with Forms
    • Upgrading ActiveX Controls and Components
    • Resolving Data Access Issues
    • Problems That Require Redesign
    • Upgrading COM+ Components
    • Upgrading VB Application Wizard Projects
    • Adding Value to Your Applications
    • Replacing ActiveX Controls with Windows Forms Controls
    • Moving from ADO to ADO.NET
    • Upgrading Distributed Applications
    Read More/Download

    Labels:

    ASP.NET Web Developer’s Guide

    Since 1996, ASP programmers have faced one upgrade after another, often with no extremely visible advantages until version 3.x—it’s been quite a wild ride. Now we have the first significant improvement in ASP programming within our grasp— ASP.NET.Our reliance on a watered-down version of Visual Basic has been alleviated now that ASP.NET pages may be programmed in both Microsoft’s new and more powerful version of Visual Basic or the latest version of C++: C#, which is more Web friendly.ASP.NET allows programmers and developers to work with both VB.NET and C# within the same ASP.NET page. .NET itself is a milestone for Microsoft; it marks Microsoft’s entry into the “run once, run everywhere” compiler market alongside Java and Ruby. .NET is also notable for its extreme flexibility; unlike the other choices available, .NET allows the programmer to use any number of .NET-compliant languages to create its code (however, as of this writing, only VB.NET and C# are allowed for ASP.NET) and have it run anywhere through the robust .NET Framework.Visual Basic and C++ have undergone changes as well; Visual Basic was already somewhat Web-oriented through its sibling,Visual Basic Script (VBS).

    Since VBS was not visually orientated, like Visual Basic, this meant that a lot of the prewritten code employed by Visual Basic did not create performance issues.This did mean, however, that VBS was not graced with an IDE to debug or troubleshoot with, making the server logs and the browser error messages a programmer’s only hope of figuring out what went wrong and where.The lack of an IDE led to several complications and eventually programmers had to create their own error-handling system, usually consisting of a log file and e-mail notification.

    VBS had another obstacle to overcome in attempting to offer programmers more than what originally was basically a scaled-down version of Visual Basic.VBS lacked many of Visual Basic’s strong features due to the way that the IIS was limited at the time, especially with object creation and cleanup. Programmers experienced code or objects locking up before destruction, rampant memory leaks, and even buffer overflows that were caused by IIS, not by the code itself.

    With .NET in general,Visual Basic and VBS are now one and the same. All of the Web-oriented abilities of VBS have been given to Visual Basic and it has received a significant retooling of the language and syntax. Many previous problems, such as poor memory management and object control, have been resolved by the .NET Common Language Runtime (CLR) and internal programming additions, such as the inclusion of the Try/Catch error-handling system and more low-level abilities than before. All in all,Visual Basic can now be called a true programming language. C++ retained all the aspects that made it a powerful programming language, such as its excellent object control and error-handling techniques, in its new version, C#. It has now gained a very good IDE as well as being more Web-based, a trait that can be attributed to the .NET Framework and ASP.NET. It is expected that many programmers will still use C# for object control while combining it with Visual Basic’s ease of use for GUI and presentation.

    This book is meant to show all ASP programmers, new and old, just how powerful ASP.NET now is. Unlike ASP 1.x through 3.x, which worked in Windows 95 through the Personal Web Server tool, you will need at least Windows 2000, all the latest service packs, Internet Explorer 6, IIS 5.x (up to date), and the .NET SDK installed. As of this writing, the latest version of .NET is Beta 2, which covers the framework,ASP, and its programming languages. Remember, this book is meant to be an introduction to ASP.NET, not VB.NET or C#. If you need a good book on VB.NET or C#, I recommend looking to two other books published by Syngress Publishing: The VB.NET Developer’s Guide (ISBN 1-928994-48-2) and The C#.NET Web Developer’s Guide (ISBN 1-928994-50-4).

    Labels:

    COM and .NET Interoperability

    By Andrew Troelsen


    Apress Publishing has provided TheServerSide.NET with COM and .NET Interoperability for free download.

    "COM and .NET Interoperability" covers working with COM components in .NET and .NET components in COM from basic topics like Runtime Callable Wrappers to advanced topics such as manual marshaling of data types between .NET and COM. This book is available in its entirety as a download to registered TSS.NET readers.

    The book starts off with an introduction/review of COM concepts such as IUnknown, IClassFactory, and IDispatch interfaces as well as Active Template Library and IDL.

    COM servers also support a special sort of COM type termed a class factory (also termed a class object). COM class factories also support the mandatory IUnknown, as well as another standard interface named IClassFactory. This interface allows the COM client to create a given coclass in a language- and locationneutral manner. As you may be aware, it is possible for a COM class factory to support the IClassFactory2 interface (which derives from ClassFactory).

    The book moves on to cover the basics of .NET to COM interoperability before building on that with more advanced topics such as handling Variants and manually destroying a COM object.

    The COM VARIANT data type is one of the most useful (and most hated) constructs of classic COM. The VARIANT structure is useful in that it is able to assume the identity of any [oleautomation]-compliant IDL type, which may be reassigned after the initial declaration. VARIANTs are hated for much the same reason, given that these dynamic transformations take time. Nevertheless, you are bound to run into a coclass that makes use of this type, and you would do well to understand how it maps into terms of .NET.

    Labels:

    Sams Teach Yourself Visual Studio .NET 2003 in 21 Days

    By Jason Beres

    Sams Teach Yourself Visual Studio .NET in 21 Days will help developers that are new to application development and experienced developers understand how to use the .NET Framework and Visual Studio .NET to rapidly develop any type of computer application. The Visual Studio .NET development environment is the most comprehensive developer tool ever created, putting that together with the .NET Frameworks' Class Libraries, the developer has everything he or she needs to get up-to-speed on Microsoft's latest revolution in application development. This book will guide the developer through using the VS .NET IDE, the Visual Basic .NET and C# language, and the supporting tools available from Microsoft to create Windows and Web-based applications. The market is full of books that pretty much say the same thing, which is already available in the help files, the author of this book has written and deployed over a dozen successful applications using Visual Studio .NET and the .NET Framework. All of his expertise and experience is used to give you the most comprehensive title on using Visual Studio .NET.

    WEEK 1. AT A GLANCE.
    Day 1. Introduction to the Microsoft .NET Framework.
    What Is .NET? Windows of the Past. The Common Language Runtime. Understanding the Common Language Specification. Understanding the Common Type System. Handling Memory and Garbage. The .NET Framework Class Library. .NET Servers and the Future of .NET.

    Day 2. Introduction to Visual Studio .NET.
    Introducing the Start Page. Using Dynamic Help. The New Projects Dialog. Exploring the Visual Studio .NET IDE. Using the Project Menu. Using the Build Menu. Managing Code Windows and Designers. Getting the Right Toolbars. Customizing Your Environment.

    Day 3. Writing Windows Forms Applications.
    Hello .NET! Understanding Windows Forms. Working with Controls Dynamically in Code. Using Menus and MDI Forms. Using Inheritance in Windows Forms. Using Common Dialog Controls. More About Controls. Making Your Forms Look Pretty. Advanced Windows Forms.

    Day 4. Deploying Windows Forms Applications.
    Introduction to Application Deployment. Introduction to the Microsoft Windows Installer Service. Understanding the Deployment Projects Templates. Creating a Windows Installer Package. Adding Merge Modules to Your Setup.

    Day 5. Writing ASP.NET Applications.
    Introduction to ASP.NET. Hello ASP.NET! Using Validation Controls. Managing State in ASP.NET Web Applications. Understanding the Web.Config File.

    Day 6. Deploying ASP.NET Applications.
    Introduction to ASP.NET Deployment. Creating an ASP.NET Application for Deployment. Deploying ASP.NET Applications Using Copy Project. Deploying ASP.NET Applications Using Copy. Deploying ASP.NET Applications with Windows Installer.

    Day 7. Exceptions, Debugging, and Tracing.
    Why Errors Happen. Understanding Exceptions in .NET. Using Structured Exception Handling. Using Visual Studio .NET to Debug Applications.
    Week 1. In Review.

    WEEK 2. AT A GLANCE.
    Day 8. Core Language Concepts in Visual Basic .NET and C#.
    Languages in the .NET Framework. Understanding CLS Data Types in Visual Basic .NET and C#. Declaring Variables in Visual Basic .NET and C#. Understanding Operators. Using Decision Structures.

    Day 9. Using Namespaces in .NET.
    What Are Namespaces? Finding the Information You Need About Namespaces. Using Namespaces in Your Applications. Working with Your Environment. Working with Files and Directories.

    Day 10. Accessing Data with ADO.NET.
    Looking Inside ADO.NET. Connecting to a Database. Using the Command Object and DataReaders. Using Windows Controls with DataReaders and Command Objects. Using DataAdapters and DataSets. Using Databinding with DataSets. Binding to a DataGrid Control.

    Day 11. Understanding Visual Database Tools.
    Managing Databases with the Server Explorer. Building Data-Driven Forms with the Server Explorer. Using the DataForm Wizard to Create Data Entry Forms. Understanding Databinding.

    Day 12. Accessing XML in .NET.
    What Is XML? XML in .NET. Using the XML and Schema Designers. Reading and Writing XML Files.

    Day 13. XML Web Services in .NET.
    What Are XML Web Services? Creating Your First Web Service. Consuming XML Web Services.

    Day 14. Components and .NET.
    Introduction to Components. Understanding the Component Types. Creating a Class Library Application. Interoperating with Unmanaged Code.
    Week 2. In Review.

    WEEK 3. AT A GLANCE.
    Day 15. Writing International Applications.
    Introduction to Globalization. Using the CultureInfo Class. Writing the Culture Info Browser Application. Managing Resource Files with Visual Studio .NET.

    Day 16. Using Macros in Visual Studio .NET.
    Introducing Extensibility. Introducing Macros in Visual Studio .NET. Using the Macro Explorer. Recording a Macro. Using the Macros IDE. Examining the Macro Recorder Code. Creating a Macros Toolbar. More Cool Macro Ideas.

    Day 17. Automating Visual Studio .NET.
    Introducing Add-ins. Creating Your First Add-in. Understanding the Life Cycle of an Add-in. Writing Your First Add-in. Taking the Next Step with Add-ins.

    Day 18. Using Crystal Reports.

    Why Use Crystal Reports? Creating a Windows Forms Report. Using the Windows Forms Report Viewer. How to Programmatically Load a Report. Printing a Report Without the Viewer Control. Exporting a Report Programmatically. Viewing Reports in Web Forms.

    Day 19. Understanding Microsoft Application Center Test.

    Introduction to Application Center Test. Understanding ACT Projects, Users, Tests, and Connections. Using the ACT Standalone Application. Walking Through the ACT Script. Understanding the ACT Test Results.

    Day 20. Using Visual SourceSafe.
    Introducing Visual SourceSafe. Installing VSS. Using the Visual SourceSafe Administrator. Using the Visual SourceSafe Explorer. Creating Your First VSS Project. Using the Integrated SourceSafe Tools in Visual Studio .NET. Viewing the History of a File in SourceSafe. Opening an Existing SourceSafe Project. Adding New Project Items or Projects. Renaming Projects or Projeact Items.

    Day 21. Object Role Modeling with Visio.
    Introducing Object Role Modeling. Using Visio to Create an ORM Model. Adding ORM Facts to the Data Model. Creating a Database Diagram from the Conceptual Model.
    Week 3. In Review.

    Labels:

    Improving .NET Application Performance and Scalability

    This guide provides end-to-end guidance for managing performance and scalability throughout your application life cycle to reduce risk and lower total cost of ownership. It provides a framework that organizes performance into a handful of prioritized categories where your choices heavily impact performance and scalability success. The logical units of the framework help integrate performance throughout your application life cycle. Information is segmented by roles, including architects, developers, testers, and administrators, to make it more relevant and actionable. This guide provides processes and actionable steps for modeling performance, measuring, testing, and tuning your applications. Expert guidance is also provided for improving the performance of managed code, ASP.NET, Enterprise Services, Web services, remoting, ADO.NET, XML, and SQL Server.

    This guide covers Microsoft's recommendations on how to build .NET applications that meet your performance objectives. The guidelines in this guide applies to various roles involved in the life cycle, including architects, designers, developers, testers, and administrators.

    The guidance is organized by categories, principles, roles, and stages of the life cycle:
    • Performance objectives enable you to know when your application meets your performance goals.
    • Performance modeling provides a structured and repeatable approach to meeting your performance objectives.
    • Architecture and design guidelines enable you to engineer for performance from an early stage.
    • A performance and scalability frame enables you to organize and prioritize performance issues.
    • Measuring lets you see whether your application is trending toward or away from the performance objectives.

    Part I, Introduction to Engineering for Performance
    This part shows you how to apply performance considerations throughout your application life cycle and introduces fundamental performance and scalability concepts and terminology.

    Part II, Designing for Performance
    Performance modeling helps you assess your design choices before committing to a solution. By considering from the start your performance objectives, workload, and metrics for your scenarios, you reduce risk. Use the design guidelines chapter to learn practices, principles, patterns, and anti-patterns that will help you to make informed choices.

    Part III, Application Performance and Scalability
    This part provides a series of chapters that provide deep platform knowledge across the .NET Framework technologies. Use these chapters to learn about the key performance and scalability considerations for the various .NET technologies, and to improve the efficiency of your code in these areas.

    Part IV, Database Server Performance and Scalability
    This part shows how to improve SQL Server performance.

    Part V, Measuring, Testing, and Tuning
    This part shows which metrics monitor and analyze for specific performance aspects. It also explains how to load, stress, and capacity test your applications and how you can tune performance with appropriate application, platform, and system configuration.

    Labels:

    Building Secure ASP.NET Applications: Authentication, Authorization, and Secure Communication

    This guide presents a practical, scenario driven approach to designing and building secure ASP.NET applications for Windows 2000 and version 1.0 of the .NET Framework. It focuses on the key elements of authentication, authorization, and secure communication within and across the tiers of distributed .NET Web applications.

    This guide focuses on:
    • Authentication (to identify the clients of your application)
    • Authorization (to provide access controls for those clients)
    • Secure communication (to ensure that messages remain private and are not altered by unauthorized parties)
    Why authentication, authorization, and secure communication?
    Security is a broad topic. Research has shown that early design of authentication and authorization eliminates a high percentage of application vulnerabilities. Secure communication is an integral part of securing your distributed application to protect sensitive data, including credentials, passed to and from your application, and between application tiers.

    There are many technologies used to build .NET Web applications. To build effective application-level authentication and authorization strategies, you need to understand how to fine-tune the various security features within each product and technology area, and how to make them work together to provide an effective, defense-in-depth security strategy. This guide will help you do just that.

    The guide is divided into four parts.

    Part I, Security Models
    Part I of the guide provides a foundation for the rest of the guide. Familiarity with the concepts, principles, and technologies introduced in Part I will allow you to extract maximum value from the remainder of the guide.

    Part II, Application Scenarios
    Most applications can be categorized as intranet, extranet, or Internet applications. This part of the guide presents a set of common application scenarios, each of which falls into one of those categories. The key characteristics of each scenario are described and the potential security threats analyzed.

    Part III, Securing the Tiers
    This part of the guide contains detailed drill-down information that relates to the individual tiers and technologies associated with secure .NET Web applications.

    Part IV, Reference
    This reference part of the guide contains supplementary information to help further your understanding of the techniques, strategies, and security solutions presented in earlier chapters.

    Who Should Read This Guide?
    If you are a middleware developer or architect, who plans to build, or is currently building .NET Web applications using one or more of the following technologies, you should read this guide.
    • ASP.NET
    • Web services
    • Enterprise Services
    • Remoting
    • ADO.NET
    Labels:

    Improving Web Application Security: Threats and Countermeasures

    This guide gives you a solid foundation for designing, building, and configuring secure ASP.NET Web applications. Whether you have existing applications or are building new ones, you can apply the guidance to help you make sure that your Web applications are hack-resilient.

    This guide helps you build hack-resilient applications. A hack-resilient application is one that reduces the likelihood of a successful attack and mitigates the extent of damage if an attack occurs. A hack-resilient application resides on a secure host (server) in a secure network and is developed using secure design and development guidelines.

    Web application security must be addressed across the tiers and at multiple layers. A weakness in any tier or layer makes your application vulnerable to attack. Figure 1 shows the scope of the guide and the three-layered approach that it uses: securing the network, securing the host, and securing the application. It also shows the process called threat modeling, which provides a structure and rationale for the security process and allows you to evaluate security threats and identify appropriate countermeasures. If you do not know your threats, how can you secure your system?

    The guide addresses security across the three physical tiers. It covers the Web server, remote application server and database server. At each tier, security is addressed at the network layer, host layer, and application layer. Figure 1 also shows the configuration categories that the guide uses to organize the various security configuration settings that apply to the host and network, and the application vulnerability categories, used to structure application security considerations.

    The guide is divided into five parts. The aim is to provide a logical partitioning, which will help you to more easily digest the content.

    Part I, Introduction to Threats and Countermeasures
    This part identifies and illustrates the various threats facing the network, host, and application layers. By using the threat modeling process, you can identify the threats that are relevant to your application. This sets the stage for identifying effective countermeasures. This part includes:
    • Foreword by Mark Curphey
    • Foreword by Joel Scambray
    • Foreword by Erik Olson
    • Foreword by Michael Howard
    • Introduction
    • Solutions at a Glance
    • Fast track
    • Chapter 1, Web Application Security Fundamentals
    • Chapter 2, Threats and Countermeasures
    • Chapter 3, Threat Modeling

    Part II, Designing Secure Web Applications
    This part provides the guidance you need to design your Web applications securely. Even if you have an existing application, you should review this section and then revisit the concepts, principles, and techniques that you used during your application design. This part includes:
    • Chapter 4, Design Guidelines for Secure Web Applications
    • Chapter 5, Architecture and Design Review
    Part III, Building Secure Web Applications
    This part helps you to apply the secure design practices and principles covered in the previous part to create a solid and secure implementation. You'll learn defensive coding techniques that make your code and application resilient to attack. Chapter 6 presents an overview of the .NET Framework security landscape so that you are aware of the numerous defensive options and tools that are at your disposal. Part III includes:
    • Chapter 6, .NET Security Fundamentals
    • Chapter 7, Building Secure Assemblies
    • Chapter 8, Code Access Security in Practice
    • Chapter 9, Using Code Access Security with ASP.NET
    • Chapter 10, Building Secure ASP.NET Pages and Controls
    • Chapter 11, Building Secure Serviced Components
    • Chapter 12, Building Secure Web Services
    • Chapter 13, Building Secure Remoted Components
    • Chapter 14, Building Secure Data Access
    Part IV, Securing Your Network, Host and Application
    This part shows you how to apply security configuration settings to secure the interrelated network, host, and application levels. Rather than applying security randomly, you'll learn the reasons for the security recommendations. Part IV includes:
    • Chapter 15, Securing Your Network
    • Chapter 16, Securing Your Web Server
    • Chapter 17, Securing Your Application Server
    • Chapter 18, Securing Your Database Server
    • Chapter 19, Securing Your ASP.NET Application and Web Services
    • Chapter 20, Hosting Multiple ASP.NET Applications
    Part V: Assessing Your Security
    This part provides you with the tools you need to evaluate the success of your security efforts. It shows you how to evaluate your code and design and also how to review your deployed application, to identify potential vulnerabilities:
    • Chapter 21, Code Review
    • Chapter 22, Deployment Review
    Checklists
    This section contains printable, task-based checklists, which are printable quick-reference sheets to help you turn information into action. This section includes the following checklists:
    • Checklist: Architecture and Design Review
    • Checklist: Security Review for Managed Code
    • Checklist: Securing ASP.NET
    • Checklist: Securing Enterprise Services
    • Checklist: Securing Web Services
    • Checklist: Securing Remoting
    • Checklist: Securing Data Access
    • Checklist: Securing Your Network
    • Checklist: Securing Your Web Server
    • Checklist: Securing Your Database Server
    Read More/Download

    Labels:

    Enterprise Solution Patterns Using Microsoft .NET

    This document provides a brief overview of Enterprise Solution Patterns Using Microsoft .NET, which embraces existing work in the patterns community, contributes new patterns, and shows how to implement these patterns in .NET. Included in the guide are an introduction to patterns and a catalog of 32 architecture, design, and implementation patterns.

    Who Should Read This Guide
    • This guide is written for readers in one or more of the following categories:
    • Architects, designers, and developers who are new to patterns
    • Architects and designers who are already experienced in using patterns to build enterprise solutions
    • System architects and system engineers who architect or design systems infrastructure

    Foreword by Ward Cunningham
    This is a collection of patterns that will help you use Microsoft .NET, which contains many objects that follow patterns we've found useful. These objects are brought to life by the common language runtime which makes for strongly-patterned objects. An easy way to think about this is that the runtime takes care of so many aspects of an object that just the pattern parts are left. Patterns were important before the common language runtime, but now they are even more important.

    You will find here a collection of patterns that you will see in most every transaction-processing Web application. These sorts of applications are really important to enterprise developers who are important to this book's authors. This is an important focus in the here and now. Of all the pattern books that could have been written about .NET, this is the most likely to be important to you today. Thank you, authors.

    I could go on about Web applications but I wanted to point out an even more interesting thing about this collection. Whenever we pull patterns together our choices say something important about how we work. Our philosophy of work runs through our selections. For example, in the Design Patterns book, [Gamma, et. al, Addison-Wesley], the philosophy was to make programs flexible. This is important, of course, and some of those patterns are included here. But there are two other philosophies present in this volume worth mentioning.

    One philosophy is that in a continuously evolving environment like the enterprise, every complexity has a cost. You'll find a variety of patterns here that at first seem contradictory. That's because the authors know that successful enterprise applications start simple and grow over time. Something simple works for a while then it needs to be replaced. You'll find patterns here for both the simple and its replacement. This isn't the same as doing it wrong and then making it right. Both patterns are right, just not at the same time on a given project.

    Another philosophy that runs through these patterns is that different people in the enterprise use different patterns for different purposes. Some patterns are more about the user experience than anything else. We can say that these patterns, and the people that apply them, are working in service of the user. The more these folks understand their users, the better they will be able to apply these patterns and the better their programs will be for their effort. Contrast this to classic concerns of the enterprise: efficiency, security, reliability, and so on. This collection includes patterns about these problems, too. When you apply them you will be working in service of the enterprise. It is also likely that you personally won't apply all the patterns in this book. That doesn't mean that you can't read them and understand more about how at least some of your colleagues think.

    Many of the patterns are backed up by specific objects already available in .NET. For these, you will find implementations that tell you how to use these objects rather than telling you how to make these objects from scratch. Traditionally, implementation examples have been included as just one section of a pattern. These are just examples meant to be understood and emulated. The implementation "patterns" included in this volume are much more. They describe the practical experience the authors have had with using specific capabilities of .NET and, as such, amount to their best advice on how to proceed.

    When you find a pattern that you need and follow it to the implementation in .NET, you are using this volume as an index into the .NET libraries. The authors have organized all the patterns on a grid that categorizes the patterns according to levels of abstraction and viewpoints. Use this grid to find patterns that should be familiar. From there, you can find .NET capabilities that apply to the work you already do. You can also look around at patterns in neighboring parts of the grid. If these are familiar, move a little further. Soon you'll find the unfamiliar and can start benefiting from the experience of others. This works even if you know more about .NET than you do about patterns. Find the patterns that talk about sections of .NET that you use, find them on the grid, and then look around.

    This work is very much about helping you use the technology built into .NET. There is a temptation to enumerate the features of .NET in a work like this. The authors have worked hard to avoid this. When they did slip into a little bit of proud boasting, the reviewers, myself included, insisted that the patterns be rewritten to be the simplest advice you can use.

    I'll close by mentioning two more ways this work is important. The pattern community has invested a decade finding, writing, and reviewing patterns in what would have to be called an academic tradition of impartiality. This work is different. It is clearly in the sponsor's interest to have .NET well understood and this volume has that goal. However, that the sponsor would invest effort writing patterns is their acknowledgment that the decade of work has merit. The pattern community should be proud and should respond by reading, reviewing, debating, and enlarging this work.

    Finally, enterprise developers and administrators should study these and other patterns not just because they offer advice that can be applied immediately, but because they provide a vocabulary to talk about intellectual property independent of that property. Consider this work a first step in a new conversation with a company that wants to succeed by serving you. Your participation in a public dialog represents a sweet-spot for interacting with a vendor that lies somewhere between focus groups and the traditional code release cycle. It is a new way for a big corporation to listen.

    Labels:

    .NET Framework 3.5

    Welcome to the Microsoft .NET Framework version 3.5. The .NET Framework is an integral Windows component that supports building and running the next generation of applications and Web services. The key components of the .NET Framework are the common language runtime (CLR) and the .NET Framework class library, which includes ADO.NET, ASP.NET, Windows Forms, and Windows Presentation Foundation (WPF). The .NET Framework provides a managed execution environment, simplified development and deployment, and integration with a wide variety of programming languages. For a brief introduction to the architecture of the .NET Framework, see .NET Framework Conceptual Overview. For a discussion of .NET Framework version 3.5 and its relationship to previous versions of the .NET Framework, see .NET Framework 3.5 Architecture.

    The documentation for the .NET Framework includes an extensive class library reference, conceptual overviews, step-by-step procedures, and information about samples, compilers, and command-line tools. To locate the information that interests you, see the following list of main topic areas.

    .NET Framework Class Library
    Supplies syntax, code examples, and related information for each class contained in the .NET Framework namespaces.

    Quick Technology Finder
    Provides a table of links to the main technology areas of the .NET Framework.

    What's New in the .NET Framework
    Describes key features that have been added or modified in the latest versions of the .NET Framework.

    Overview of the .NET Framework
    Describes key .NET Framework concepts such as the common language runtime, the common type system (CTS), cross-language interoperability, managed execution, assemblies, and security.

    Core Development Technologies
    Explains common programming tasks that apply to a range of .NET Framework applications. Includes topics such as accessing data, file and stream I/O, configuration, encoding, deployment, and debugging.

    Advanced Development Technologies
    Provides information about sophisticated development tasks and techniques in the .NET Framework.

    Security in the .NET Framework
    Provides information about the classes and services in the .NET Framework that facilitate secure application development.

    ASP.NET Portal
    Provides links to documentation about ASP.NET applications, Web Forms, and Web services.

    Windows Forms Portal
    Provides links to documentation about common programming tasks in Windows Forms applications.

    .NET Compact Framework
    Introduces the .NET Framework-based, hardware-independent environment for running applications on resource-constrained computing devices.

    Windows Presentation Foundation
    Provides information about developing applications using Windows Presentation Foundation (WPF).

    Windows Communication Foundation for Applications
    Provides information on the Windows Communication Foundation (WCF) programming model for building service-oriented applications.

    Windows CardSpace
    Provides information about CardSpace, which is Microsoft's implementation of an identity metasystem.

    Windows Workflow Foundation
    Provides information on the framework, programming model, and tools for Windows Workflow Foundation (WF).

    General Reference for the .NET Framework
    Provides reference information related to the .NET Framework. Includes sections on languages and compilers, tools, technical references, and a glossary of terms.

    Tools (.NET Framework)
    Provides information about tools that make it easier for you to create, deploy, and manage applications and components that target the .NET Framework.

    Samples (.NET Framework Technologies)
    Provides samples that illustrate various aspects of the .NET Framework.

    Labels:

    Application Architecture for .NET: Designing Applications and Services

    This guide is for you if you are an architect or developer lead or need to:
    • Determine how an application will be split into components,
    • Choose what technologies will be used in a transactional line of business application or service,
    • Design what management and security policies should be applied, and
    • Decide how the application will be deployed.
    This guide applies to transactional or OLTP applications that follow a layered design and can be distributed across many physical tiers by using the following technologies: ASP.NET, Web Services, Enterprise Services (COM+), Remoting, ADO.NET, and SQL Server. Some design principles presented in this guide may be useful on other similar scenarios.

    What Is in This Guide?
    Chapter 1: Introduction
    This first chapter presents the overall goal of distributed application design, presents how services and service integration relates to traditional application development, and presents a simple retail scenario that is used as a theme for examples in the guide.

    Chapter 2: Designing the Components of an Application or Service
    This chapter walks you through a distributed application, starting at the user interface, and identifies different types of components or layers commonly used in successful applications. It describes the major technology or design decisions that must be made and the guiding principles for the design of these components.

    Chapter 3: Security, Operational Management, and Communications Policies
    In this chapter, you learn how different aspects–such as authorization and exception management–affect the design of the application layers, and how design decisions in these areas can permeate through your application. This chapter also discusses the choice of communication mechanisms.

    Chapter 4: Physical Deployment and Operational Requirements
    This chapter explains how the logical component layers presented above should be deployed in an infrastructure built of many physical tiers and shows common successful deployment patterns that arise when combining the logical component layers, physical tiers, and operational requirements.

    Chapter 5: Appendices
    The appendices include a glossary, a map of Microsoft products and technologies that allow you to implement or enhance the application component layers discussed in Chapter 2 and a list of related patterns and names applied in the industry to these layers.

    Labels:

    Foundations of Programming Building Better Software (Using .Net)

    By Karl Seguin

    A few years ago I was fortunate enough to turn a corner in my programming career. The opportunity for solid mentoring presented itself, and I took full advantage of it. Within the space of a few months, my programming skills grew exponentially and over the last couple years, I’ve continued to refine my art. Doubtless I still have much to learn, and five years from now I’ll look back on the code I write today and feel embarrassed. I used to be confident in my programming skill, but only once I accepted that I knew very little, and likely always would, did I start to actually understand.

    My Foundations of Programming series is a collection of posts which focus on helping enthusiastic programmers help themselves. Throughout the series we’ll look at a number of topics typically discussed in far too much depth to be of much use to anyone except those who already know about them. I’ve always seen two dominant forces in the .NET world, one heavily driven by Microsoft as a natural progression of VB6 and classic ASP (commonly referred to as The MSDN Way) and the other heavily driven by core object oriented practices and influenced by some of the best Java projects/concepts (known as ALT.NET).

    In reality, the two aren’t really comparable. The MSDN Way loosely defines a specific way to build a system down to each individual method call (after all, isn’t the API reference documentation the only reason any of us visit MSDN?) Whereas ALT.NET focuses on more abstract topics while providing specific implementation. As Jeremy Miller puts it: the .Net community has put too much focus on learning API and framework details and not enough emphasis on design and coding fundamentals. For a relevant and concrete example, The MSDN Way heavily favors the use of DataSets and DataTables for all database communication. ALT.NET however, focuses on discussions about persistence design patterns, object-relational impendence mismatch as well as specific implementations such as NHibernate (O/R Mapping), MonoRail (ActiveRecord) as well as DataSets and DataTables. In other words, despite what many people think, ALT.NET isn’t about ALTernatives to The MSDN Way, but rather a belief that developers should know and understand alternative solutions and approaches of which The MSDN Way is part of.

    Of course, it’s plain from the above description that going the ALT.NET route requires a far greater commitment as well as a wider base of knowledge. The learning curve is steep and helpful resources are just now starting to emerge (which is the reason I decided to start this series). However, the rewards are worthwhile; for me, my professional success has resulted in greater personal happiness.

    Labels:

    Microsoft Application Architecture Guide

    This guide is primarily written for developers and solution architects who are looking for guidance on architecting and designing applications on the Microsoft platform and the .NET Framework. However, this guide will benefit any technologist who is generally interested in the field of application architecture and design, wishes to understand the underlying patterns and principles behind good application design on the .Microsoft platform or the .NET Framework, or is new to the Microsoft platform or the .NET Framework.


    The goal of this guide is to help developers and solution architects build effective, high quality applications on the Microsoft platform and the .NET Framework more quickly and with less risk by leveraging tried and trusted architecture and design principles and patterns.

    The guide provides an overview of the underlying principles and patterns that provide a solid foundation for good application architecture and design. On top of this foundation, the guide provides generally applicable guidance for partitioning an application’s functionality into layers, components, and services. It goes on to provide guidance on identifying and addressing the key design characteristics of the solution and the key quality attributes (such as performance, security, and scalability) and crosscutting concerns (such as caching and logging). The guide builds still further and provides guidance that is more specific on the architecture and design of the most common application types, such as Web, rich Internet applications (RIA), rich client, services, and mobile applications.

    The guidance is presented in parts that correspond to major architecture and design focus points. It is designed to be used as a reference resource, or it can be read from beginning to end.

    The guide will help you to:
    • Understand the underlying architecture and design principles and patterns for developing successful solutions on the Microsoft platform.
    • Identify appropriate strategies and design patterns that will help you design your solution’s layers, components, and services.
    • Identify and address the key engineering decision points for your solution.
    • Identify and address the key quality attributes and crosscutting concerns for your solution.
    • Choose the right technologies for your solution.
    • Create a candidate baseline architecture for your solution.
    • Identify patterns & practices solution assets and further guidance that will help you to implement your solution.
    Note that while the guide is extensive, it is should not be considered a complete and comprehensive treatise on the field of application architecture and design. The guide is intended to serve as a practical and convenient overview of and reference to the general principles of architecture and design on the Microsoft platform and the .NET Framework.

    Labels:

    The .NET Developer's Guide to Windows Security

    By Keith Brown

    This book was written for the many thousands of people involved in designing and writing software for the Microsoft .NET platform. It is chock-full of tips and insights about user-based security, which I like to term "Windows security" because it's been around in one form or another since Windows NT first shipped. Given the plethora of books that cover the new security features in the .NET Framework, such as code access security and ASP.NET forms authentication, I decided to write a book to help folks with the basics of Windows security, a topic that most other books miss entirely or get subtly or blatantly wrong. This book is in some sense a second edition of my first security book, Programming Windows Security, but I hope that you will find it immensely more approachable and practical. I've tried to distill the Zen of these topics into small tidbits of information— items that link to one another— allowing you to read the book in any order that suits you. I hope that you’ll find the format of 75 concise tidbits of information helpful as a reference. The “what is” items focus on explaining concepts, while the “how to” items focus on helping you perform a common task.

    Within these pages I cover security features in various versions of Windows based on Windows NT. This includes Windows 2000, Windows XP Professional, and Windows Server 2003, but does not include 16-bit Windows or any of the Win9X flavors (Windows 95/98, Windows ME, Windows XP Home edition). So, when I talk about "Windows" I'm referring to the versions based on Windows NT. Whenever I talk about the file system, I'm assuming that you're using NTFS, not FAT partitions. Whenever I talk about domains, I'm assuming Windows 2000 or greater. If you're still living with a Windows NT 4 domain, you have my sincere condolences!

    Many people have expressed surprise that I occasionally talk about Win32 APIs and refer to Win32 header files in a book for .NET programmers. I wish I didn’t have to do this, but as anyone who has experience with the .NET Framework knows, the framework class library wraps only a fraction of the functionality of the Windows platform as of this writing. The coverage will get better over time, but to do many things in Windows (including security programming), you often need to call native Win32 APIs. Even as version 2.0 of the framework is being revealed in beta 1, you can see that coverage increasing, but it’s still not complete. In any case, I’ve tried to make it clear in the prose when I’m talking about a Win32 API versus a .NET Framework class, and I’ve provided lots of sample code and helper classes written in Managed C++ that you can leverage to avoid having to call those APIs yourself.

    This book can be found online (in its entirety) in hyperlinked form on the Web at winsecguide.net, where I believe you'll find it to be a great reference when you're connected. I plan to continue filling in more items over time, so subscribe to the RSS feed on the book for news. You can also download samples and tools that I mention in the book from this Web site. Errata will be posted to this site as well, so if you find a problem please let me know.

    Labels:
    Subscribe to: Posts (Atom)
    Privacy Policy
     We use third-party advertising companies to serve ads when you visit our website. They uses cookies to serve ads on our site. These companies may use information (not including your name, address, email address, or telephone number) about your visits to this and other websites in order to provide advertisements about goods and services of interest to you. If you would like more information about this practice and to know your choices about not having this information used by these companies, click here
    Disclaimer
    Copyright of books and articles goes to its respective owners. In this blog, i am writing reviews about articles & books and giving free links available in world wide web. Intention of this blog is educative purpose and using contents from other sites as it is fair use. So if you have any complaints regarding books copyright, please contact book hosting servers for the removal of the book. we got all download links from the search engines and so we are not responsible for any damage due to the links given here. This is only for education purpose.