Windows 7 for Developers

If an application runs on Windows Vista today, there’s a very strong likelihood that the application will run unchanged on Windows 7.There are 3 key steps that every application author has to take care to still further diminish the risk of any application issues:

1. Download (and read!) the
   Windows 7 Application Quality Cookbook. This is the ultimate guide to changes in Windows 7, offering 80+ pages of detailed guidance on the various different edge cases that might cause an issue with your application. (A quick perusal of the document will allay any fears of widespread change – unless the likes of ‘removal of Microsoft Agent’ is of major concern to you.) Using this document as a checklist, you’ll be able to very rapidly identify anything that you should take care of.
   
   Download(and read!) the Windows 7 Developer Guide. This guide helps in building applications on a solid foundation; enable richer application experiences.
2. Install and use the Windows Application Compatibility Toolkit (ACT) 5.5 and Application Verifier 4.0. These tools are valuable both for compatibility and quality, and are particularly helpful to renovate an older application that you never moved up to Windows Vista. The former provides automated tools for developers to check for issues like UAC incompatibility and setup problems, as well as administrative tools that can be used to apply and view other shims that may be in place. The latter tool is a runtime verification tool for applications that can be used to identify issues in the way native code calls into the Win32 API – in some ways, it’s the closest equivalent to FxCop for C++ code.
3. Get your application certified for Windows 7. Applying for a logo for your application has historically been a somewhat painstaking process – it’s involved spending money on submitting the application for manual testing. Now it’s much simpler: we’ve provided an automated toolkit that tests the application for known compatibility issues, targeting application issues that we’ve seen in the wild and providing clear guidance on how to fix your application. And there’s no cost either, beyond signing up for a certificate for WinQual registration. Whether or not you actually care about using the Windows 7 logo for marketing purposes, this is a worthwhile step to validate that your application runs smoothly on Windows 7 and that your customers will get a good experience.

ref:

Tim Sneath's Windows 7 Blog - http://blogs.msdn.com/tims/archive/2009/05/06/a-developer-s-guide-to-preparing-for-windows-7.aspx

Making your application sparkle with Windows 7 -

http://blogs.msdn.com/somasegar/archive/2009/10/02/making-your-application-sparkle-with-windows-7.aspx

Windows Developer's site - http://msdn.microsoft.com/en-us/windows/default.aspx

Windows 7 Developer Guide - http://code.msdn.microsoft.com/Release/ProjectReleases.aspx?ProjectName=Win7DeveloperGuide&ReleaseId=1702

Windows 7 Training Kit For Developers (The Windows 7 Training Kit for Developers includes presentations, hands-on labs, and demos designed to help you learn how to build applications that are compatible with and shine on Windows 7) - http://www.microsoft.com/downloads/details.aspx?FamilyID=1c333f06-fadb-4d93-9c80-402621c600e7&displaylang=en

The Windows Application Quality Cookbook familiarizes developers and test engineers with how to verify the compatibility of their applications with Windows 7 - http://code.msdn.microsoft.com/Windows7AppQuality/Release/ProjectReleases.aspx?ReleaseId=1734

The Windows® API Code Pack for Microsoft® .NET Framework provides a source code library that can be used to access some new Windows 7 features (and some existing features of older versions of Windows operating system) from managed code. These Windows features are not available to developers today in the .NET Framework - http://code.msdn.microsoft.com/WindowsAPICodePack

Sample .Net managed Code that exploits Windows7 features to work on XP, Vista & 7 - http://code.msdn.microsoft.com/XP2Win7/Release/ProjectReleases.aspx?ReleaseId=2977

Windows 7 for developers - http://searchwindevelopment.techtarget.com/news/article/0,289142,sid8_gci1364162,00.html?track=NL-150&ad=721495&Offer=mn_eh081909WDEVUNSC_win7H&asrc=EM_USC_8999108&uid=8777731

Visual Studio News - http://msdn.microsoft.com/en-us/vstudio/default.aspx

Learn Windows from msdn Channel9 Presentations - http://channel9.msdn.com/

Microsoft Windows Opensource Software downloads - http://www.codeplex.com/

Codeplex WPF Projects - http://www.codeplex.com/site/search?projectSearchText=Windows%207&sortBy=Relevance&tagName=,WPF,&licenses=&refinedSearch=true

Microsoft Architecture Journal - http://msdn.microsoft.com/en-us/architecture/bb410935.aspx

Blogs:

Windows 7 Developer Blog - http://windowsteamblog.com/blogs/developers/default.aspx

Windows 7 Team Blog - http://windowsteamblog.com/blogs/windows7/default.aspx

Windows Vista Team Blog - http://windowsteamblog.com/blogs/windowsvista/default.aspx

10 tips for Windows 7 Developers from Scott Hanselman's Blog -http://www.hanselman.com/blog/Top10TipsWorkingDevelopersShouldKnowAboutWindows7.aspx

WPF Lookless Controls

WPF Lookless Control Model = Styles, Templates and Triggers

A WPF control does not include a hardcoded visual representation. Rather, the default visual representation is specified in XAML in a completely separate theme assembly from the class that implements the control's logic. This separation of code-based logic from visual representation (the control's look and feel) is what makes the WPF control model so powerful. We refer to this approach as a "lookless control model".

Why - Two big reasons: design and reusability.

Developers and designers can work side by side to simultaneously create powerful and visually stunning applications, with each person doing what they do best. A developer can implement an application's logic at the same time that a designer creates the application's look and feel. To a great degree, it is the lookless control model that enables this new workflow.By introducing a lookless control model where the visual representation of the control is specified apart from the control's code, we are able to put the visual design into the hands of a qualified UX designer, where it belongs.

The second big reason for separating a control's visuals from its code implementation is reusability. In the past, if you wanted to have two buttons with different visual appearances, you had to create two separate button classes with the correct rendering code baked into each class. Both classes contained the same basic button logic. They both provided a "click" event in response to the appropriate mouse or keyboard user interactions. The only difference between the button classes was in the rendering logic. By moving the visual representation into XAML and out of the control class, we allow a single Button class to be reused wherever we need to support a Click interaction. The button can have whatever visual representation the designer wants to create. The developer no longer needs to be involved in the process of redefining a button's visual representation.

Ref:

Lookless Control Model -

http://www.drwpf.com/blog/Home/tabid/36/EntryID/53/Default.aspx

Top Ten UI Development Breakthroughs In Windows Presentation Foundation -

http://msdn.microsoft.com/en-us/magazine/cc163662.aspx

Styles and triggers in WPF -

http://www.microsoft.com/belux/msdn/nl/community/columns/gillcleeren/wpf_stylesandtriggers.mspx

Using Templates to Customize WPF Controls -

http://msdn.microsoft.com/en-us/magazine/cc163497.aspx

Designing Lookless Controls in Windows Presentation Foundation -

http://www.devx.com/dotnet/Article/34564

WPF Apps With The Model-View-ViewModel Design Pattern -

http://msdn.microsoft.com/en-us/magazine/dd419663.aspx

WPF MultiThreading -

http://www.a2zdotnet.com/View.aspx?id=93

Creating a look-less custom control in WPF -

http://www.codeproject.com/KB/WPF/WPFCustomControl.aspx

Load an assembly at runtime(dynamic loading)

Problem:
1. We need to follow Plugin Architecture. i.e Loading Asseblies at runtime dynamically

2. An assembly that an application must use at runtime is present in some folder on the system, and has to be loaded at runtime.

Solution:
We can use a combination of AssemblyResolve event, Assembly.Load and .Net Reflection.

Please follow the links below for a complete understanding of HOW !

ref:

Assembly.LoadFile versus Assembly.LoadFrom - .NET obscurity at its finest by Josh Fischer -http://www.codeproject.com/KB/dotnet/AssemblyLoadFile.aspx

Rotem Bloom's Blog - http://blogs.microsoft.co.il/blogs/rotemb/archive/2008/07/03/how-to-load-an-assembly-at-runtime-from-specific-location.aspx

Haibo Luo's weblog - http://blogs.msdn.com/haibo_luo/archive/2005/11/17/494009.aspx

Loading and Unloading an Assembly at Runtime -http://www.codeproject.com/KB/cs/Assemblies___Appdomains.aspx

http://www.codeproject.com/KB/dotnet/AssemblyLoadFile.aspx

How the Runtime Locates Assemblies - http://msdn.microsoft.com/en-us/library/yx7xezcf.aspx

Loading assemblies (references) during runtime - http://www.danielahill.com/post/Loading-assemblies-(references)-during-runtime.aspx

How to: Load Assemblies into an Application Domain -

http://msdn.microsoft.com/en-us/library/25y1ya39.aspx

http://social.msdn.microsoft.com/Forums/en-US/csharpgeneral/thread/7eba3253-8f4d-4271-a1b1-23989926d5e9

http://social.msdn.microsoft.com/forums/en-US/clr/thread/093c3606-e68e-46f4-98a1-f2396d3f88ca/

StackOverflow.com Articles -

http://stackoverflow.com/questions/465488/c-load-assemblies-at-runtime

http://stackoverflow.com/questions/468243/c-load-assemblies-at-runtime-again

.NET Framework Tools

The Microsoft .NET Framework SDK tools are designed to make it easier for you to create, deploy, and manage applications and components that target the .NET Framework.
You can run all the tools from the command line with the exception of the Assembly Cache Viewer (Shfusion.dll) and the Microsoft CLR Debugger (DbgCLR.exe). You must access Shfusion.dll from Microsoft Windows Explorer. DbgCLR.exe is located in the Microsoft.NET\FrameworkSDK\GuiDebug folder.

Note If you are using the .NET Framework version 1.1, you can run the tools from the command line, but you must set the correct Path, Include, and Lib environment variables in each command prompt session. To set the environment variables, open a command prompt session and run the SDKVars.bat file located in the systemroot\Microsoft.NET\SDK\v1.1\Bin directory.

1. Configuration and Deployment Tools
2. Debugging Tools
3. Security Tools
4. General Tools

Configuration and Deployment Tools

Tool	Description
ASP.NET IIS Registration Tool (Aspnet_regiis.exe)	Allows an administrator or installation program to update the scriptmaps for an ASP.NET application to point to the ASP.NET ISAPI version associated with the tool. You can also use the tool to perform other ASP.NET configuration operations.
Assembly Cache Viewer (Shfusion.dll)	Allows you to view and manipulate the contents of theglobal assembly cache using Windows Explorer.
Assembly Linker (Al.exe)	Generates a file with an assembly manifest from one or more files that are either resource files or Microsoft intermediate language (MSIL) files.
Assembly Registration Tool (Regasm.exe)	Reads the metadata within an assembly and adds the necessary entries to the registry, which allows COM clients to create .NET Framework classes transparently.
Assembly Binding Log Viewer (Fuslogvw.exe)	Displays details for failed assembly binds. This information helps you diagnose why the .NET Framework cannot locate an assembly at run time.
Global Assembly Cache Tool (Gacutil.exe)	Allows you to view and manipulate the contents of the global assembly cache and download cache. While Shfusion.dll provides similar functionality, you can use Gacutil.exe from build scripts, makefile files, and batch files.
Installer Tool (Installutil.exe)	Allows you to install and uninstall server resources by executing the installer components of a specified assembly.
Isolated Storage Tool (Storeadm.exe)	Lists or removes all existing stores for the currently logged-on user.
Native Image Generator (Ngen.exe)	Creates a native image from a managed assembly and installs it in the native image cache on the local computer.
.NET Framework Configuration Tool (Mscorcfg.msc)	Provides a graphical interface for managing .NET Framework security policy and applications that use remoting services. This tool also allows you to manage and configure assemblies in the global assembly cache.
.NET Services Installation Tool (Regsvcs.exe)	Adds managed classes to Windows 2000 Component Services by loading and registering the assembly and generating, registering, and installing the type library into an existing COM+ 1.0 application.
Soapsuds Tool (Soapsuds.exe)	Helps you compile client applications that communicate with XML Web services using a technique called remoting.
Type Library Exporter (Tlbexp.exe)	Generates a type library from a common language runtime assembly.
Type Library Importer (Tlbimp.exe)	Converts the type definitions found within a COM type library into equivalent definitions in managed metadata format.
Web Services Description Language Tool (Wsdl.exe)	Generates code for XML Web services and XML Web services clients from Web Services Description Language (WSDL) contract files, XML Schema Definition (XSD) schema files, and .discomap discovery documents.
Web Services Discovery Tool (Disco.exe)	Discovers the URLs of XML Web services located on a Web server, and saves documents related to each XML Web service on a local disk.
XML Schema Definition Tool (Xsd.exe)	Generates XML schemas that follow the XSD language proposed by the World Wide Web Consortium (W3C). This tool generates common language runtime classes andDataSet classes from an XSD schema file.

Debugging Tools

Tool	Description
Microsoft CLR Debugger (DbgCLR.exe)	Provides debugging services with a graphical interface to help application developers find and fix bugs in programs that target the runtime.
Runtime Debugger (Cordbg.exe)	Provides command-line debugging services using the common language runtime Debug API. Used to find and fix bugs in programs that target the runtime.

Security Tools

Tool	Description
Certificate Creation Tool (Makecert.exe)	Generates X.509 certificates for testing purposes only.
Certificate Manager Tool (Certmgr.exe)	Manages certificates, certificate trust lists (CTLs), and certificate revocation lists (CRLs).
Certificate Verification Tool (Chktrust.exe)	Verifies the validity of a file signed with an X.509 certificate.
Code Access Security Policy Tool (Caspol.exe)	Allows you to examine and modify machine, user, and enterprise-level code access security policies.
File Signing Tool (Signcode.exe)	Signs a portable executable (PE) file with an Authenticode digital signature.
Permissions View Tool (Permview.exe)	Displays the minimal, optional, and refused permission sets requested by an assembly. You can also use this tool to view all declarative security used by an assembly.
PEVerify Tool (PEverify.exe)	Performs MSIL type safety verification checks and metadata validation checks on a specified assembly.
Policy Migration Tool (Migpol.exe)	Migrates security policy between two compatible versions of the .NET Framework.
Secutil Tool (Secutil.exe)	Extracts strong name public key information or Authenticode publisher certificates from an assembly, in a format that can be incorporated into code.
Set Registry Tool (Setreg.exe)	Allows you to change the registry settings for the Software Publishing State keys, which control the behavior of the certificate verification process.
Software Publisher Certificate Test Tool (Cert2spc.exe)	Creates, for test purposes only, a Software Publisher's Certificate (SPC) from one or more X.509 certificates.
Strong Name Tool (Sn.exe)	Helps create assemblies with strong names. Sn.exe provides options for key management, signature generation, and signature verification.

General Tools

Tool	Description
Common Language Runtime Minidump Tool (Mscordmp.exe)	Creates a file containing information that is useful for analyzing system issues in the runtime. The Microsoft Dr. Watson tool (Drwatson.exe) invokes this program automatically.
License Compiler (Lc.exe)	Reads text files that contain licensing information and produces a .licenses file that can be embedded in a common language runtime executable.
Management Strongly Typed Class Generator (Mgmtclassgen.exe)	Allows you to quickly generate an early-bound class in C#, Visual Basic, or JScript for a specified Windows Management Instrumentation (WMI) class.
MSIL Assembler (Ilasm.exe)	Generates a PE file from Microsoft intermediate language (MSIL). You can run the resulting executable, which contains MSIL code and the required metadata, to determine whether the MSIL code performs as expected.
MSIL Disassembler (Ildasm.exe)	Takes a PE file that contains MSIL code and creates a text file suitable as input to the MSIL Assembler (Ilasm.exe).
Resource File Generator Tool (Resgen.exe)	Converts text files and .resx (XML-based resource format) files to .NET common language runtime binary .resources files that can be embedded in a runtime binary executable or compiled into satellite assemblies.
Windows Forms ActiveX Control Importer (Aximp.exe)	Converts type definitions in a COM type library for an ActiveX control into a Windows Forms control.
Windows Forms Class Viewer (Wincv.exe)	Finds managed classes matching a specified search pattern, and displays information about those classes using the Reflection API.
Windows Forms Resource Editor (Winres.exe)	Allows you to quickly and easily localize Windows Forms forms.

ref: http://msdn.microsoft.com/en-us/library/d9kh6s92(VS.71).aspx .NET Assemblies, GAC, Versioning, Manifests and Deployment – http://www.thescarms.com/dotnet/assembly.aspx