Creating a Software Development Kit
A software development kit (SDK) is a collection of APIs that you can reference as a single item in Visual Studio. The Reference Manager dialog box lists all the SDKs that are relevant to the project. When you add an SDK to a project, the APIs are available in Visual Studio.
There are two types of SDKs:
Platform SDKs are mandatory components for developing apps for a platform. For example, the Windows 8 SDK is required to develop Windows Store apps.
Extension SDKs are optional components that extend a platform but aren’t mandatory for developing apps for that platform.
The following sections describe the general infrastructure of SDKs and how to create a platform SDK and an extension SDK.
Platform SDKs are required to develop apps for a platform. For example, the Windows 8 SDK is required to develop apps for Windows 8.
Platform SDKs will have the following layout:
\[InstallationFolder root] SDKManifest.xml \References \[config] \[arch] \DesignTime \[config] \[arch]
Contains binaries that contain APIs that can be coded against. These could include Windows Metadata (WinMD) files or assemblies.
Contains files that are needed only at pre-run/debugging time. These could include XML docs, libraries, headers, Toolbox design-time binaries, MSBuild artifacts, and so forth
There can be only three folders: debug, retail and CommonConfiguration. SDK authors can place their files under CommonConfiguration if the same set of SDK files should be consumed, regardless of the configuration that the SDK consumer will target.
Any supported architecture folder can exist. Visual Studio 2012 supports the following architectures: x86, x64, ARM, and neutral. Note: Win32 maps to x86, and AnyCPU maps to neutral.
MSBuild looks only under \CommonConfiguration\neutral for Platform SDKs.
This file describes how Visual Studio should consume the SDK. Look at the SDK Manifest for Windows 8:
<FileList DisplayName = “Windows” PlatformIdentity = “Windows, version=8.0” TargetFramework = “.NET for Windows Store apps, version=v4.5; .NET Framework, version=v4.5” MinVSVersion = “11.0”> <File Reference = “Windows.winmd”> <ToolboxItems VSCategory = “Toolbox.Default” /> </File> </FileList>
The following sections describe what you need to do to deploy an extension SDK.
Extension SDKs can be installed for a specific user or for all users without specifying a registry key. To install an SDK for all users, use the following path:
%Program Files%\Microsoft SDKs\<target platform>\v<platform version number>\ExtensionSDKs
For a user-specific installation, use the following path:
%USERPROFILE%\AppData\Local\Microsoft SDKs\<target platform>\v<platform version number>\ExtensionSDKs
If you want to use a different location, you must do one of two things:
Specify it in a registry key:
HKLM\Software\Microsoft\Microsoft SDKs\<target platform>\v<platform version number>\ExtensionSDKs\<SDKName>\<SDKVersion>\
and add a (Default) subkey that has a value of <path to SDK>\<SDKName>\<SDKVersion>.
Add the MSBuild property SDKReferenceDirectoryRoot to your project file. The value of this property is a semi colon delimited list of directories in which the Extension SDKs you want to reference reside.
Extension SDKs have the following installation layout:
\<ExtensionSDKs root> \<SDKName> \<SDKVersion> SDKManifest.xml \References \<config> \<arch> \Redist \<config> \<arch> \DesignTime \<config> \<arch>
\<SDKName>\<SDKVersion>: the name and version of the extension SDK is derived from the corresponding folder names in the path to the SDK root. MSBuild uses this identity to find the SDK on disk, and Visual Studio displays this identity in the Properties window and Reference Manager dialog.
References folder: the binaries that contain the APIs. These could be Windows Metadata (WinMD) files or assemblies.
DesignTime folder: the files that are needed at only pre-run/debugging time and shouldn’t be packaged as part of the user’s application. These could be XML docs, libraries, headers, toolbox design-time binaries, MSBuild artifacts, and so forth. Any SDK that is intended for consumption by a native project must have an SDKName.props file. The following shows a sample of this type of file.
<?xml version="1.0" encoding="utf-8"?> <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <PropertyGroup> <ExecutablePath>C:\Temp\ExecutablePath;$(ExecutablePath)</ExecutablePath> <IncludePath>$(FrameworkSDKRoot)\..\v8.0\ExtensionSDKs\cppimagingsdk\1.0\DesignTime\CommonConfiguration\Neutral\include;$(IncludePath)</IncludePath> <AssemblyReferencePath>C:\Temp\AssemblyReferencePath;(AssemblyReferencePath)</AssemblyReferencePath> <LibraryPath>$(FrameworkSDKRoot)\..\v8.0\ExtensionSDKs\cppimagingsdk\1.0\DesignTime\Debug\ARM;$(LibraryPath)</LibraryPath> <SourcePath>C:\Temp\SourcePath\X64;$(SourcePath)</SourcePath> <ExcludePath>C:\Temp\ExcludePath\X64;$(ExcludePath)</ExcludePath> <_PropertySheetDisplayName>DevILSDK, 1.0</_PropertySheetDisplayName> </PropertyGroup> </Project>
XML reference documents are placed alongside the reference file. For example, the XML reference document for the \References\<config>\<arch>\sample.dll assembly is \References\<config>\<arch>\sample.xml, and the localized version of that doc is \References\<config>\<arch>\<locale>\sample.xml.
Configuration folder: three subfolders: Debug, Retail, and CommonConfiguration. SDK authors can place their files under CommonConfiguration when the same set of SDK files should be consumed, regardless of the configuration targeted by the SDK consumer.
Architecture folder: the following architectures are supported: x86, x64, ARM, neutral. Win32 maps to x86, and AnyCPU maps to neutral.
This file describes how Visual Studio should consume the SDK. The following is an example.
<FileList> DisplayName = “My SDK” ProductFamilyName = “My SDKs” TargetFramework = “.NETCore, version=v4.5; .NETFramework, version=v4.5” MinVSVersion = “11.0” AppliesTo = "WindowsAppContainer + WindowsXAML" SupportPrefer32Bit = “True” SupportedArchitectures = “x86;x64;ARM” SupportsMultipleVersions = “Error” CopyRedistToSubDirectory = “.” DependsOn = “SDKB, version=2.0” MoreInfo = “http://msdn.microsoft.com/MySDK”> <File Reference = “MySDK.Sprint.winmd” Implementation = “XNASprintImpl.dll”> <Registration Type = “Flipper” Implementation = “XNASprintFlipperImpl.dll” /> <Registration Type = “Flexer” Implementation = “XNASprintFlexerImpl.dll” /> <ToolboxItems VSCategory = “Toolbox.Default” /> </File> </FileList>
The following list gives the elements of the file.
DisplayName: the value that appears in the Reference Manager, Solution Explorer, Object Browser, and other locations in the user interface for Visual Studio.
FrameworkIdentity: specifies a dependency on one or more Windows component libraries The value of this attribute is put into the consuming app’s manifest. This attribute is applicable only to Windows component libraries.
TargetFramework: specifies the SDKs that are available in the Reference Manager and the toolbox. This is a semicolon-delimited list of target framework monikers, for example “.NET Framework, version=v2.0; .NET Framework, version=v4.5”. If several versions of the same target framework are specified, the Reference Manager uses the lowest specified version for filtering purposes. For example, if “.NET Framework, version=v2.0; .NET Framework, version=v4.5” is specified, Reference Manager will use “.NET Framework, version=v2.0”. If a specific target framework profile is specified, only that profile will be used by the Reference Manager for filtering purposes. For example, when “Silverlight, version=v4.0, profile=WindowsPhone” is specified, Reference Manager filters on only the Windows Phone profile; a project targeting the full Silverlight 4.0 Framework does not see the SDK in the Reference Manager.
MinVSVersion: the minimum Visual Studio version.
WindowsAppContainer identifies projects for Windows Store apps.
SupportPrefer32Bit: Supported values are “True” and “False”. The default is "True". If the value is set to “False”, MSBuild returns an error for Windows Store projects (or a warning for desktop projects) if the project that references the SDK has Prefer32Bit enabled. For more information about Prefer32Bit, see Build Page, Project Designer (C#) or Compile Page, Project Designer (Visual Basic).
SupportedArchitectures: a semi-colon delimited list of architectures that the SDK supports. MSBuild displays a warning if the targeted SDK architecture in the consuming project isn't supported. If this attribute isn't specified, MSBuild never displays this type of warning.
SupportsMultipleVersions: if this attribute is set to Error or Warning, MSBuild indicates that the same project can't reference multiple versions of the same SDK family. If this attribute doesn’t exist or is set to Allow, MSBuild doesn't display this type of error or warning.
AppX: specifies the path to the app packages for the Windows component library on the disk. This value is passed to the registration component of the Windows component library during local debugging. The naming convention for the file name is <Company>.<Product>.<Architecture>.<Configuration>.<Version>.appx. Configuration and Architecture are optional in the attribute name and the attribute value if they don’t apply to the Windows component library. This value is applicable only to Windows component libraries.
CopyRedistToSubDirectory: specifies where the files under the \redist folder should be copied relative to the app package root (that is, the Package location chosen in the Create App Package wizard) and runtime layout root. The default location is the root of the app package and F5 layout.
DependsOn: A list of SDK identities that define the SDKs on which this SDK depends. This attribute appears in the details pane of the Reference Manager.
MoreInfo: the URL to the web page that provides help and more information. This value is used in the More Information link in the right pane of the Reference Manager.
Registration Type: specifies the WinMD registration in the app manifest and is required for native WinMD, which has a counterpart implementation DLL.
File Reference: specified for only those references that contain controls or are native WinMDs. For information about how to specify whether a reference contains controls, see Specifying the Location of Toolbox Items below.
The ToolBoxItems element of the SDKManifest.xml schema specifies the category and location of toolbox items in both platform and extension SDKs. The following examples show how to specify different locations. This is applicable to either WinMD or DLL references.
Place controls in the toolbox default category.
<File Reference = “sample.winmd”> <ToolboxItems VSCategory = “Toolbox.Default”/> </File>
Place controls under a particular category name.
<File Reference = “sample.winmd”> <ToolboxItems VSCategory= “MyCategoryName”/> </File>
Place controls under particular category names.
<File Reference = “sample.winmd”> <ToolboxItems VSCategory = “Graph”> <ToolboxItems/> <ToolboxItems VSCategory = “Data”> <ToolboxItems /> </File>
Place controls under different category names in Blend and Visual Studio.
// Blend accepts a slightly different structure for the category name because it allows a path rather than a single category. <File Reference = “sample.winmd”> <ToolboxItems VSCategory = “Graph” BlendCategory = “Controls/sample/Graph”> <ToolboxItems /> </File>
Enumerate specific controls differently in Blend and Visual Studio.
<File Reference = “sample.winmd”> <ToolboxItems VSCategory = “Graph”> <ToolboxItems/> <ToolboxItems BlendCategory = “Controls/sample/Graph”> <ToolboxItems/> </File>
Enumerate specific controls, and place them under the Visual Studio Common Path or only in the All Controls Group.
<File Reference = “sample.winmd”> <ToolboxItems VSCategory = “Toolbox.Common”> <ToolboxItems /> <ToolboxItems VSCategory = “Toolbox.All”> <ToolboxItems /> </File>
Enumerate specific controls, and show only a specific set in ChooseItems without them being in the toolbox.
<File Reference = “sample.winmd”> <ToolboxItems VSCategory = “Toolbox.ChooseItemsOnly”> <ToolboxItems /> </File>