Add error message when Portable Library Tools are not installed.

Allow picking the profile (set of target frameworks) in project upgrade view.

data/templates/project/CSharp/PortableLibrary.xpt

@@ -16,6 +16,10 @@
 	
 	<!-- Template Content -->
 	<Project language="C#">
+		<PreCreateActions>
+			<RunCommand path="/SharpDevelop/BackendBindings/TemplateCommands/CheckPortableLibraryInstalled"/>
+		</PreCreateActions>
+	
 		<PropertyGroup>
 			<OutputType>Library</OutputType>
 			<AppDesignerFolder>Properties</AppDesignerFolder>

data/templates/project/ComplexExample.xpt.test

@@ -124,8 +124,12 @@ End Class
 		</SolutionFolder>
 		
 		<Project name = "${ProjectName}" directory = "." language = "C#">
+			<PreCreateActions>
+				<RunCommand path = "/SharpDevelop/BackendBindings/TemplateCommands/CheckPortableLibraryInstalled"/>
+			</PreCreateActions>
+			
 			<CreateActions>
-				<RunCommand path = "/SharpDevelop/BackendBindings/TemplateCommands/AddDotNet35ReferencesIfTargetFrameworkIs35"/>
+				<RunCommand path = "/SharpDevelop/BackendBindings/TemplateCommands/PostCreationAction_Owner_Is_IProject"/>
 			</CreateActions>
 			
 			<ProjectItems>

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Project/CSharpProject.cs

@@ -80,37 +80,6 @@ namespace CSharpBinding
 			}
 		}
 		
-		static readonly CompilerVersion msbuild20 = new CompilerVersion(new Version(2, 0), "C# 2.0");
-		static readonly CompilerVersion msbuild35 = new CompilerVersion(new Version(3, 5), "C# 3.0");
-		static readonly CompilerVersion msbuild40 = new CompilerVersion(new Version(4, 0), DotnetDetection.IsDotnet45Installed() ? "C# 5.0" : "C# 4.0");
-		
-		public override CompilerVersion CurrentCompilerVersion {
-			get {
-				switch (MinimumSolutionVersion) {
-					case Solution.SolutionVersionVS2005:
-						return msbuild20;
-					case Solution.SolutionVersionVS2008:
-						return msbuild35;
-					case Solution.SolutionVersionVS2010:
-					case Solution.SolutionVersionVS11:
-						return msbuild40;
-					default:
-						throw new NotSupportedException();
-				}
-			}
-		}
-		
-		public override IEnumerable<CompilerVersion> GetAvailableCompilerVersions()
-		{
-			List<CompilerVersion> versions = new List<CompilerVersion>();
-			if (DotnetDetection.IsDotnet35SP1Installed()) {
-				versions.Add(msbuild20);
-				versions.Add(msbuild35);
-			}
-			versions.Add(msbuild40);
-			return versions;
-		}
-		
 		/*
 		protected override void AddOrRemoveExtensions()
 		{
@@ -170,5 +139,36 @@ namespace CSharpBinding
 			else
 				return base.GetDefaultItemType(fileName);
 		}
+		
+		static readonly CompilerVersion msbuild20 = new CompilerVersion(new Version(2, 0), "C# 2.0");
+		static readonly CompilerVersion msbuild35 = new CompilerVersion(new Version(3, 5), "C# 3.0");
+		static readonly CompilerVersion msbuild40 = new CompilerVersion(new Version(4, 0), DotnetDetection.IsDotnet45Installed() ? "C# 5.0" : "C# 4.0");
+		
+		public override CompilerVersion CurrentCompilerVersion {
+			get {
+				switch (Project.MinimumSolutionVersion) {
+					case Solution.SolutionVersionVS2005:
+						return msbuild20;
+					case Solution.SolutionVersionVS2008:
+						return msbuild35;
+					case Solution.SolutionVersionVS2010:
+					case Solution.SolutionVersionVS11:
+						return msbuild40;
+					default:
+						throw new NotSupportedException();
+				}
+			}
+		}
+		
+		public override IEnumerable<CompilerVersion> GetAvailableCompilerVersions()
+		{
+			List<CompilerVersion> versions = new List<CompilerVersion>();
+			if (DotnetDetection.IsDotnet35SP1Installed()) {
+				versions.Add(msbuild20);
+				versions.Add(msbuild35);
+			}
+			versions.Add(msbuild40);
+			return versions;
+		}
 	}
 }

src/Main/Base/Project/ICSharpCode.SharpDevelop.addin

@@ -2332,8 +2332,8 @@
 	</Path>
 	
 	<Path name = "/SharpDevelop/BackendBindings/TemplateCommands">
-		<Class id="AddDotNet35ReferencesIfTargetFrameworkIs35"
+		<Class id="CheckPortableLibraryInstalled"
-		       class="ICSharpCode.SharpDevelop.Project.Commands.AddDotNet35ReferencesIfTargetFrameworkIs35Command"/>
+		       class="ICSharpCode.SharpDevelop.Project.PortableLibrary.CheckPortableLibraryInstalled"/>
 	</Path>
 	
 	<Path name = "/SharpDevelop/Views/ProjectBrowser/ContextSpecificProperties">

src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj

@@ -379,8 +379,11 @@
     <Compile Include="Src\Project\MSBuildEngine\WorkerProcess.cs" />
     <Compile Include="Src\Project\MSBuildFileProject.cs" />
     <Compile Include="Src\Project\MSBuildItemWrapper.cs" />
+    <Compile Include="Src\Project\PortableLibrary\CheckPortableLibraryInstalled.cs" />
     <Compile Include="Src\Project\PortableLibrary\PortableLibraryProjectBehavior.cs" />
+    <Compile Include="Src\Project\PortableLibrary\PortableTargetFramework.cs" />
     <Compile Include="Src\Project\PortableLibrary\Profile.cs" />
+    <Compile Include="Src\Project\PortableLibrary\ProfileList.cs" />
     <Compile Include="Src\Project\PortableLibrary\SupportedFramework.cs" />
     <Compile Include="Src\Project\ProjectChangeWatcher.cs" />
     <Compile Include="Src\Project\ProjectLoadInformation.cs" />

src/Main/Base/Project/Src/Internal/Templates/Project/ProjectDescriptor.cs

@@ -56,6 +56,7 @@ namespace ICSharpCode.SharpDevelop.Internal.Templates
 		List<ProjectItem> projectItems = new List<ProjectItem>();
 		List<ProjectProperty> projectProperties = new List<ProjectProperty>();
 		List<Action<IProject>> createActions = new List<Action<IProject>>();
+		List<Action<ProjectCreateInformation>> preCreateActions = new List<Action<ProjectCreateInformation>>();
 		
 		/// <summary>
 		/// Creates a project descriptor for the project node specified by the xml element.
@@ -109,6 +110,9 @@ namespace ICSharpCode.SharpDevelop.Internal.Templates
 				case "CreateActions":
 					LoadCreateActions(node);
 					break;
+				case "PreCreateActions":
+					LoadPreCreateActions(node);
+					break;
 				case "ProjectItems":
 					LoadProjectItems(node);
 					break;
@@ -151,7 +155,16 @@ namespace ICSharpCode.SharpDevelop.Internal.Templates
 			}
 		}
 		
-		static Action<IProject> ReadAction(XmlElement el)
+		void LoadPreCreateActions(XmlElement preCreateActionsElement)
+		{
+			foreach (XmlElement el in preCreateActionsElement) {
+				Action<ProjectCreateInformation> action = ReadAction(el);
+				if (action != null)
+					preCreateActions.Add(action);
+			}
+		}
+		
+		static Action<object> ReadAction(XmlElement el)
 		{
 			switch (el.Name) {
 				case "RunCommand":
@@ -311,6 +324,8 @@ namespace ICSharpCode.SharpDevelop.Internal.Templates
 				projectCreateInformation.RootNamespace = standardNamespace.ToString();
 				projectCreateInformation.ProjectName = newProjectName;
 				
+				RunPreCreateActions(projectCreateInformation);
+				
 				StringParserPropertyContainer.FileCreation["StandardNamespace"] = projectCreateInformation.RootNamespace;
 				
 				if (File.Exists(projectLocation))
@@ -505,6 +520,13 @@ namespace ICSharpCode.SharpDevelop.Internal.Templates
 			}
 		}
 		
+		void RunPreCreateActions(ProjectCreateInformation projectCreateInformation)
+		{
+			foreach (var action in preCreateActions) {
+				action(projectCreateInformation);
+			}
+		}
+		
 		void RunCreateActions(IProject project)
 		{
 			foreach (Action<IProject> action in createActions) {

src/Main/Base/Project/Src/Project/PortableLibrary/CheckPortableLibraryInstalled.cs

@@ -0,0 +1,34 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using ICSharpCode.Core;
+using ICSharpCode.SharpDevelop.Gui;
+
+namespace ICSharpCode.SharpDevelop.Project.PortableLibrary
+{
+	/// <summary>
+	/// Shows a message box if the portable library is not installed.
+	/// </summary>
+	public class CheckPortableLibraryInstalled : AbstractCommand
+	{
+		public override void Run()
+		{
+			if (!ProfileList.IsPortableLibraryInstalled()) {
+				using (ToolNotFoundDialog dlg = new ToolNotFoundDialog(
+					"Could not find Portable Class Library Tools." + Environment.NewLine + Environment.NewLine +
+					"To install the Portable Class Library Tools without installing Visual Studio, save the download file (PortableLibraryTools.exe) on your computer, and run the installation program from a Command Prompt window. Include the /buildmachine switch on the command line.",
+					"http://go.microsoft.com/fwlink/?LinkId=210823"
+				)) {
+					// our message is long, so make the window bigger than usual
+					dlg.Width += 70;
+					dlg.Height += 70;
+					dlg.ShowDialog();
+				}
+			}
+		}
+	}
+}

src/Main/Base/Project/Src/Project/PortableLibrary/PortableLibraryProjectBehavior.cs

@@ -12,10 +12,6 @@ namespace ICSharpCode.SharpDevelop.Project.PortableLibrary
 {
 	public class PortableLibraryProjectBehavior : ProjectBehavior
 	{
-		public readonly static TargetFramework PortableTargetFramework = new TargetFramework("v4.0Portable", "Portable Library") {
-			MinimumMSBuildVersion = new Version(4, 0)
-		};
-		
 		public override IEnumerable<CompilerVersion> GetAvailableCompilerVersions()
 		{
 			return base.GetAvailableCompilerVersions().Where(c => c.MSBuildVersion == new Version(4, 0));
@@ -23,16 +19,39 @@ namespace ICSharpCode.SharpDevelop.Project.PortableLibrary
 		
 		public override IEnumerable<TargetFramework> GetAvailableTargetFrameworks()
 		{
-			return new[] { PortableTargetFramework };
+			return ProfileList.Instance.AllProfiles.Select(p => new PortableTargetFramework(p)).Union(new[] { this.CurrentTargetFramework });
 		}
 		
 		public override TargetFramework CurrentTargetFramework {
-			get { return PortableTargetFramework; }
+			get {
+				string fxVersion = ((CompilableProject)Project).TargetFrameworkVersion;
+				string fxProfile = ((CompilableProject)Project).TargetFrameworkProfile;
+				Profile profile = Profile.LoadProfile(fxVersion, fxProfile);
+				if (profile != null)
+					return new PortableTargetFramework(profile);
+				else
+					return new PortableTargetFramework(fxVersion, fxProfile);
+			}
 		}
 		
 		public override void UpgradeProject(CompilerVersion newVersion, TargetFramework newFramework)
 		{
-			// can't upgrade portable libraries
+			var project = (CompilableProject)Project;
+			if (project.ReadOnly)
+				return;
+			lock (project.SyncRoot) {
+				if (newVersion != null && GetAvailableCompilerVersions().Contains(newVersion)) {
+					project.SetToolsVersion(newVersion.MSBuildVersion.Major + "." + newVersion.MSBuildVersion.Minor);
+				}
+				var newFx = newFramework as PortableTargetFramework;
+				if (newFx != null) {
+					project.SetProperty(null, null, "TargetFrameworkProfile", newFx.TargetFrameworkProfile, PropertyStorageLocations.Base, true);
+					project.SetProperty(null, null, "TargetFrameworkVersion", newFx.TargetFrameworkVersion, PropertyStorageLocations.Base, true);
+				}
+				Project.Save();
+				ResXConverter.UpdateResourceFiles(project);
+				ProjectBrowserPad.RefreshViewAsync();
+			}
 		}
 	}
 }

src/Main/Base/Project/Src/Project/PortableLibrary/PortableTargetFramework.cs

@@ -0,0 +1,48 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Xml;
+using System.Xml.Linq;
+
+namespace ICSharpCode.SharpDevelop.Project.PortableLibrary
+{
+	public class PortableTargetFramework : TargetFramework
+	{
+		public readonly string TargetFrameworkVersion;
+		public readonly string TargetFrameworkProfile;
+		
+		public PortableTargetFramework(string targetFrameworkVersion, string targetFrameworkProfile)
+			: base(targetFrameworkVersion + "-" + targetFrameworkProfile, ".NET Portable Subset (" + targetFrameworkVersion + "-" + targetFrameworkProfile + ")")
+		{
+			this.TargetFrameworkVersion = targetFrameworkVersion;
+			this.TargetFrameworkProfile = targetFrameworkProfile;
+			this.MinimumMSBuildVersion = new Version(4, 0);
+		}
+		
+		public PortableTargetFramework(Profile profile)
+			: base(profile.TargetFrameworkVersion + "-" + profile.TargetFrameworkProfile, profile.DisplayName)
+		{
+			this.TargetFrameworkVersion = profile.TargetFrameworkVersion;
+			this.TargetFrameworkProfile = profile.TargetFrameworkProfile;
+			this.MinimumMSBuildVersion = new Version(4, 0);
+		}
+		
+		public override bool Equals(object obj)
+		{
+			PortableTargetFramework other = obj as PortableTargetFramework;
+			if (other == null)
+				return false;
+			return this.TargetFrameworkVersion == other.TargetFrameworkVersion && this.TargetFrameworkProfile == other.TargetFrameworkProfile;
+		}
+		
+		public override int GetHashCode()
+		{
+			return this.TargetFrameworkVersion.GetHashCode() ^ this.TargetFrameworkProfile.GetHashCode();
+		}
+	}
+}

src/Main/Base/Project/Src/Project/PortableLibrary/Profile.cs

@@ -5,6 +5,10 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using System.Text;
+using System.Xml;
+using System.Xml.Linq;
 
 namespace ICSharpCode.SharpDevelop.Project.PortableLibrary
 {
@@ -13,26 +17,36 @@ namespace ICSharpCode.SharpDevelop.Project.PortableLibrary
 	/// </summary>
 	public class Profile
 	{
-		#region Load List of Profiles
+		public static Profile LoadProfile(string targetFrameworkVersion, string targetFrameworkProfile)
-		static string GetPortableLibraryPath()
 		{
-			string programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86);
+			string profileDir = Path.Combine(ProfileList.GetPortableLibraryPath(), targetFrameworkVersion, "Profile", targetFrameworkProfile);
-			return Path.Combine(programFiles, @"Reference Assemblies\Microsoft\Framework\.NETPortable");
+			return LoadProfile(targetFrameworkVersion, targetFrameworkProfile, profileDir);
 		}
 		
-		public static IList<Profile> LoadProfiles()
+		internal static Profile LoadProfile(string targetFrameworkVersion, string targetFrameworkProfile, string profileDir)
 		{
-			throw new NotImplementedException();
+			try {
+				List<SupportedFramework> frameworks = new List<SupportedFramework>();
+				foreach (string frameworkFile in Directory.GetFiles(Path.Combine(profileDir, "SupportedFrameworks"), "*.xml")) {
+					XDocument doc = XDocument.Load(frameworkFile);
+					frameworks.Add(new SupportedFramework(doc.Root));
+				}
+				if (frameworks.Count > 0)
+					return new Profile(targetFrameworkVersion, targetFrameworkProfile, frameworks);
+				else
+					return null;
+			} catch (XmlException) {
+				return null;
+			} catch (IOException) {
+				return null;
+			} catch (UnauthorizedAccessException) {
+				return null;
+			}
 		}
 		
-		public static bool IsPortableLibraryInstalled()
-		{
-			return Directory.Exists(GetPortableLibraryPath());
-		}
-		#endregion
-		
 		public readonly string TargetFrameworkVersion;
 		public readonly string TargetFrameworkProfile;
+		public readonly string DisplayName;
 		public readonly IList<SupportedFramework> SupportedFrameworks;
 		
 		public Profile(string targetFrameworkVersion, string targetFrameworkProfile, IList<SupportedFramework> supportedFrameworks)
@@ -40,6 +54,15 @@ namespace ICSharpCode.SharpDevelop.Project.PortableLibrary
 			this.TargetFrameworkVersion = targetFrameworkVersion;
 			this.TargetFrameworkProfile = targetFrameworkProfile;
 			this.SupportedFrameworks = supportedFrameworks;
+			
+			this.DisplayName = ".NET Portable Subset (" + string.Join(", ", supportedFrameworks) + ")";
+		}
+		
+		public bool Supports(IList<SupportedFramework> frameworks)
+		{
+			return frameworks.All(
+				requiredFx => SupportedFrameworks.Any(fx => fx.Identifier == requiredFx.Identifier && fx.MinimumVersion >= requiredFx.MinimumVersion)
+			);
 		}
 	}
 }

src/Main/Base/Project/Src/Project/PortableLibrary/ProfileList.cs

@@ -0,0 +1,105 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Xml;
+using System.Xml.Linq;
+
+namespace ICSharpCode.SharpDevelop.Project.PortableLibrary
+{
+	public class ProfileList
+	{
+		internal static string GetPortableLibraryPath()
+		{
+			string programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86);
+			return Path.Combine(programFiles, @"Reference Assemblies\Microsoft\Framework\.NETPortable");
+		}
+		
+		public static bool IsPortableLibraryInstalled()
+		{
+			return Directory.Exists(GetPortableLibraryPath());
+		}
+		
+		#region LoadProfiles
+		static readonly Lazy<ProfileList> instance = new Lazy<ProfileList>(LoadProfiles);
+		
+		public static ProfileList Instance {
+			get { return instance.Value; }
+		}
+		
+		internal static ProfileList LoadProfiles()
+		{
+			ProfileList result = new ProfileList();
+			string path = GetPortableLibraryPath();
+			result.LoadProfiles("v4.0", Path.Combine(path, @"v4.0\Profile"));
+			result.LoadProfiles("v4.5", Path.Combine(path, @"v4.5\Profile"));
+			return result;
+		}
+		
+		List<Profile> list = new List<Profile>();
+		
+		void LoadProfiles(string targetFrameworkVersion, string profilesDir)
+		{
+			string[] profileDirs;
+			try {
+				profileDirs = Directory.GetDirectories(profilesDir);
+			} catch (IOException) {
+				return;
+			} catch (UnauthorizedAccessException) {
+				return;
+			}
+			foreach (string profileDir in profileDirs) {
+				string targetFrameworkProfile = Path.GetFileName(profileDir);
+				var profile = Profile.LoadProfile(targetFrameworkVersion, targetFrameworkProfile, profileDir);
+				if (profile != null)
+					list.Add(profile);
+			}
+		}
+		#endregion
+		
+		public IEnumerable<Profile> AllProfiles {
+			get { return list; }
+		}
+		
+		public IEnumerable<SupportedFramework> AllFrameworks {
+			get { return list.SelectMany(p => p.SupportedFrameworks).Distinct(); }
+		}
+		
+		/// <summary>
+		/// Retrieves all profiles that support all of the given frameworks.
+		/// </summary>
+		public IEnumerable<Profile> GetProfiles(IList<SupportedFramework> frameworks)
+		{
+			if (frameworks == null)
+				throw new ArgumentNullException("frameworks");
+			return list.Where(p => p.Supports(frameworks));
+		}
+		
+		/// <summary>
+		/// Retrieves the most specific profile that supports all of the given frameworks.
+		/// Returns null if no profile supports the given frameworks.
+		/// </summary>
+		public Profile GetBestProfile(IList<SupportedFramework> frameworks)
+		{
+			var candidates = GetProfiles(frameworks).ToList();
+			for (int i = candidates.Count - 1; i >= 0; i--) {
+				for (int j = 0; j < candidates.Count; j++) {
+					if (i != j) {
+						if (candidates[i].Supports(candidates[j].SupportedFrameworks)) {
+							// i is less specific than j, so remove it
+							candidates.RemoveAt(i);
+							break;
+						}
+					}
+				}
+			}
+			// If the portable library profiles are specified properly, there should be at most one result,
+			// so we'll just return that.
+			return candidates.FirstOrDefault();
+		}
+	}
+}

src/Main/Base/Project/Src/Project/PortableLibrary/SupportedFramework.cs

@@ -16,7 +16,15 @@ namespace ICSharpCode.SharpDevelop.Project.PortableLibrary
 		public readonly Version MinimumVersion;
 		public readonly string DisplayName;
 		
-		public SupportedFramework(XElement framework)
+		public SupportedFramework(string identifier, Version minimumVersion, string profile = null, string displayName = null)
+		{
+			this.Identifier = identifier;
+			this.MinimumVersion = minimumVersion;
+			this.Profile = profile;
+			this.DisplayName = displayName ?? identifier;
+		}
+		
+		internal SupportedFramework(XElement framework)
 		{
 			this.Identifier = (string)framework.Attribute("Identifier");
 			this.Profile = (string)framework.Attribute("Profile");
@@ -32,5 +40,29 @@ namespace ICSharpCode.SharpDevelop.Project.PortableLibrary
 		{
 			return this.DisplayName;
 		}
+		
+		public override bool Equals(object obj)
+		{
+			SupportedFramework other = obj as SupportedFramework;
+			if (other == null)
+				return false;
+			return this.Identifier == other.Identifier && this.Profile == other.Profile && object.Equals(this.MinimumVersion, other.MinimumVersion) && this.DisplayName == other.DisplayName;
+		}
+		
+		public override int GetHashCode()
+		{
+			int hashCode = 0;
+			unchecked {
+				if (Identifier != null)
+					hashCode += 1000000007 * Identifier.GetHashCode();
+				if (Profile != null)
+					hashCode += 1000000009 * Profile.GetHashCode();
+				if (MinimumVersion != null)
+					hashCode += 1000000021 * MinimumVersion.GetHashCode();
+				if (DisplayName != null)
+					hashCode += 1000000033 * DisplayName.GetHashCode();
+			}
+			return hashCode;
+		}
 	}
 }

src/Setup/Files.wxs

@@ -837,7 +837,7 @@
 								</Directory>
 								<Directory Id="ProjectTemplatesFolder" Name="project">
 									<Directory Id="CSharpProjectTemplatesFolder" Name="CSharp">
-										<Component Guid="888085CF-91C6-4669-97AF-BA99B3D9D38B" Id="CSharpProjectTemplates" DiskId="1">
+										<Component Guid="6261E8DA-6374-40B8-93EF-CFE031488C08" Id="CSharpProjectTemplates" DiskId="1">
 											<File Source="..\..\data\templates\project\CSharp\WPFNavigationApplication.xpt" Id="CSharpWPFNavigationApplication.xpt" Name="WPFNavigationApplication.xpt" />
 											<File Source="..\..\data\templates\project\CSharp\ConsoleProject.xpt" Id="CSharpConsoleProject.xpt" Name="ConsoleProject.xpt" />
 											<File Source="..\..\data\templates\project\CSharp\ControlLibrary.xpt" Id="CSharpControlLibrary.xpt" Name="ControlLibrary.xpt" />
@@ -853,6 +853,8 @@
 											<File Source="..\..\data\templates\project\CSharp\WebpageProject.xpt" Id="CSharpWebpageProject.xpt" Name="WebpageProject.xpt" />
 											<File Source="..\..\data\templates\project\CSharp\WPFApplication.xpt" Id="CSharpWPFApplication.xpt" Name="WPFApplication.xpt" />
 											<File Source="..\..\data\templates\project\CSharp\SilverlightApplication.xpt" Id="CSharpSilverlightApplication.xpt" Name="SilverlightApplication.xpt" />
+											<File Id="PortableAssemblyInfo.cs" Name="PortableAssemblyInfo.cs" Source="..\..\data\templates\project\CSharp\PortableAssemblyInfo.cs" />
+											<File Id="PortableLibrary.xpt" Name="PortableLibrary.xpt" Source="..\..\data\templates\project\CSharp\PortableLibrary.xpt" />
 										</Component>
 										<Component Guid="9D156515-C54F-4DAB-AD66-40E44C28E56C" Id="CSharpProjectSharpDevelopCustomToolTemplates" DiskId="1">
 											<File Source="..\..\data\templates\project\CSharp\SharpDevelopCustomTool.xpt" Id="SharpDevelopCustomTool.xpt" Name="SharpDevelopCustomTool.xpt" />