public static ITaskItem CreateFileItem(string sourcePath, string targetPath, string targetFramework)
{
TaskItem item = new TaskItem(sourcePath);
item.SetMetadata("TargetPath", targetPath);
item.SetMetadata("TargetFramework", targetFramework);
return item;
}
public override bool Execute()
{
ArrayList list = new ArrayList();
foreach (ITaskItem item in AssemblyFiles)
{
AssemblyName an;
try
{
an = AssemblyName.GetAssemblyName(item.ItemSpec);
}
catch (BadImageFormatException e)
{
Log.LogErrorWithCodeFromResources("GetAssemblyIdentity.CouldNotGetAssemblyName", item.ItemSpec, e.Message);
continue;
}
catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e))
{
Log.LogErrorWithCodeFromResources("GetAssemblyIdentity.CouldNotGetAssemblyName", item.ItemSpec, e.Message);
continue;
}
ITaskItem newItem = new TaskItem(an.FullName);
newItem.SetMetadata("Name", an.Name);
if (an.Version != null)
newItem.SetMetadata("Version", an.Version.ToString());
if (an.GetPublicKeyToken() != null)
newItem.SetMetadata("PublicKeyToken", ByteArrayToHex(an.GetPublicKeyToken()));
if (an.CultureInfo != null)
newItem.SetMetadata("Culture", an.CultureInfo.ToString());
item.CopyMetadataTo(newItem);
list.Add(newItem);
}
Assemblies = (ITaskItem[])list.ToArray(typeof(ITaskItem));
return !Log.HasLoggedErrors;
}
/// <summary>
/// Helper function to parse the ParameterEntryElement
/// </summary>
/// <param name="element"></param>
/// <param name="parentItem"></param>
/// <returns></returns>
private Utilities.TaskItem ReadParameterEntryElement(Xml.XmlElement element, Utilities.TaskItem parentItem)
{
Debug.Assert(element != null && parentItem != null);
Utilities.TaskItem taskItem = null;
if (string.Compare(element.Name, "parameterEntry", System.StringComparison.OrdinalIgnoreCase) == 0)
{
taskItem = new Microsoft.Build.Utilities.TaskItem(parentItem);
taskItem.RemoveMetadata("OriginalItemSpec");
foreach (Xml.XmlNode attribute in element.Attributes)
{
if (attribute != null && attribute.Name != null && attribute.Value != null)
{
string value = DisableEscapeMSBuildVariable ? attribute.Value : Utility.EscapeTextForMSBuildVariable(attribute.Value);
taskItem.SetMetadata(attribute.Name, value);
}
}
}
else if (string.Compare(element.Name, "parameterValidation", System.StringComparison.OrdinalIgnoreCase) == 0)
{
taskItem = new Microsoft.Build.Utilities.TaskItem(parentItem);
taskItem.RemoveMetadata("OriginalItemSpec");
taskItem.SetMetadata("Element", "parameterValidation");
foreach (Xml.XmlNode attribute in element.Attributes)
{
if (attribute != null && attribute.Name != null && attribute.Value != null)
{
string value = DisableEscapeMSBuildVariable ? attribute.Value : Utility.EscapeTextForMSBuildVariable(attribute.Value);
taskItem.SetMetadata(attribute.Name, value);
}
}
}
return(taskItem);
}
private static void ResolveSDKFromRefereneAssemblyLocation(string referenceName, string expectedPath)
{
// Create the engine.
MockEngine engine = new MockEngine();
TaskItem taskItem = new TaskItem(referenceName);
taskItem.SetMetadata("SDKName", "FakeSDK, Version=1.0");
TaskItem resolvedSDK = new TaskItem(@"C:\FakeSDK");
resolvedSDK.SetMetadata("SDKName", "FakeSDK, Version=1.0");
resolvedSDK.SetMetadata("TargetedSDKConfiguration", "Debug");
resolvedSDK.SetMetadata("TargetedSDKArchitecture", "X86");
TaskItem[] assemblies = new TaskItem[] { taskItem };
// Now, pass feed resolved primary references into ResolveAssemblyReference.
ResolveAssemblyReference t = new ResolveAssemblyReference();
t.BuildEngine = engine;
t.Assemblies = assemblies;
t.ResolvedSDKReferences = new ITaskItem[] { resolvedSDK };
t.SearchPaths = new String[] { @"C:\SomeOtherPlace" };
bool succeeded = Execute(t);
Assert.True(succeeded);
Assert.Equal(1, t.ResolvedFiles.Length);
Assert.Equal(0, engine.Errors);
Assert.Equal(0, engine.Warnings);
Assert.True(t.ResolvedFiles[0].ItemSpec.Equals(expectedPath, StringComparison.OrdinalIgnoreCase));
}
public void Build()
{
RegexCompiler task = new RegexCompiler();
task.BuildEngine = new MockBuild();
task.OutputDirectory = TaskUtility.TestDirectory;
task.AssemblyName = "MSBuild.Community.RegularExpressions.dll";
task.AssemblyTitle = "MSBuild.Community.RegularExpressions";
task.AssemblyDescription = "MSBuild Community Tasks Regular Expressions";
task.AssemblyCompany = "MSBuildTasks";
task.AssemblyProduct = "MSBuildTasks";
task.AssemblyCopyright = "Copyright (c) MSBuildTasks 2008";
task.AssemblyVersion = "1.0.0.0";
task.AssemblyFileVersion = "1.0.0.0";
task.AssemblyInformationalVersion = "1.0.0.0";
task.AssemblyKeyFile = @"..\..\..\MSBuild.Community.Tasks\MSBuild.Community.Tasks.snk";
List<ITaskItem> expressions = new List<ITaskItem>();
TaskItem item1 = new TaskItem("TextRegex");
item1.SetMetadata("Pattern", @"\G[^<]+");
item1.SetMetadata("Options", "RegexOptions.Singleline | RegexOptions.Multiline");
item1.SetMetadata("IsPublic", "true");
TaskItem item2 = new TaskItem("CommentRegex");
item2.SetMetadata("Pattern", @"\G<%--(([^-]*)-)*?-%>");
item2.SetMetadata("Options", "RegexOptions.Singleline | RegexOptions.Multiline");
item2.SetMetadata("IsPublic", "true");
task.RegularExpressions = new ITaskItem[] {item1, item2};
bool result = task.Execute();
Assert.IsTrue(result);
}
public override bool Execute ()
{
assemblies = new ITaskItem [assembly_files.Length];
for (int i = 0; i < assemblies.Length; i++) {
string file = assembly_files [i].ItemSpec;
AssemblyName an = AssemblyName.GetAssemblyName (file);
TaskItem item = new TaskItem (an.FullName);
item.SetMetadata ("Version", an.Version.ToString ());
byte[] pk = an.GetPublicKeyToken ();
string pkStr = pk != null? ByteArrayToString (pk) : "null";
item.SetMetadata ("PublicKeyToken", pkStr);
CultureInfo culture = an.CultureInfo;
if (culture != null) {
string cn;
if (culture.LCID == CultureInfo.InvariantCulture.LCID)
cn = "neutral";
else
cn = culture.Name;
item.SetMetadata ("Culture", cn);
}
assemblies[i] = item;
}
return true;
}
public override bool Execute()
{
Regex packageNameRegex = new Regex(PackageNameRegex);
List<ITaskItem> packageNameItems = new List<ITaskItem>();
foreach (string packageDrop in PackageDrops)
{
if (!Directory.Exists(packageDrop))
{
Log.LogWarning("PackageDrop does not exist - '{0}'", packageDrop);
continue;
}
IEnumerable<ITaskItem> packages = Directory.GetFiles(packageDrop).Select(f => new TaskItem(Path.GetFileNameWithoutExtension(f)));
foreach (ITaskItem package in packages)
{
Match m = packageNameRegex.Match(package.ItemSpec);
if (m.Success)
{
TaskItem packageName = new TaskItem(m.Groups[0].Value);
packageName.SetMetadata("PackageName", m.Groups[1].Value);
packageName.SetMetadata("PackageVersion", m.Groups[2].Value);
packageName.SetMetadata("PrereleaseVersion", m.Groups[3].Value);
packageNameItems.Add(packageName);
}
}
}
PackageNames = packageNameItems?.OrderBy(an => an.ItemSpec.ToString(), StringComparer.Ordinal)?.ToArray();
return true;
}
public void AppendItemWithMissingAttribute()
{
// Construct the task items.
TaskItem i = new TaskItem();
i.ItemSpec = "MySoundEffect.wav";
i.SetMetadata("Name", "Kenny");
i.SetMetadata("Access", "Private");
TaskItem j = new TaskItem();
j.ItemSpec = "MySplashScreen.bmp";
j.SetMetadata("Name", "Cartman");
j.SetMetadata("HintPath", @"c:\foo");
j.SetMetadata("Access", "Public");
CommandLineBuilderExtension c = new CommandLineBuilderExtension();
c.AppendSwitchIfNotNull
(
"/myswitch:",
new ITaskItem[] { i, j },
new string[] { "Name", "HintPath", "Access" },
null
);
Assert.Equal(@"/myswitch:MySoundEffect.wav,Kenny /myswitch:MySplashScreen.bmp,Cartman,c:\foo,Public", c.ToString());
}
public static ITaskItem CreateDependencyItem(string sourcePath, string version, string targetFramework)
{
TaskItem item = new TaskItem(sourcePath);
if (version != null)
{
item.SetMetadata("Version", version);
}
item.SetMetadata("TargetFramework", targetFramework);
return item;
}
/*
* Method: SetupTaskItem
*
* Creates a valid task item that's modified later
*/
private TaskItem SetupTaskItem()
{
TaskItem item = new TaskItem();
item.SetMetadata(ComReferenceItemMetadataNames.guid, "{5C6D0C4D-D530-4B08-B22F-307CA6BFCB65}");
item.SetMetadata(ComReferenceItemMetadataNames.versionMajor, "1");
item.SetMetadata(ComReferenceItemMetadataNames.versionMinor, "0");
item.SetMetadata(ComReferenceItemMetadataNames.lcid, "0");
item.SetMetadata(ComReferenceItemMetadataNames.wrapperTool, "tlbimp");
return item;
}
public TaskItem ToTaskItem()
{
var item = new TaskItem(OutputFilePath);
// For Fxo we output Link used by <Content> Item
if (!OutputCs)
{
item.SetMetadata("CopyToOutputDirectory", "PreserveNewest");
item.SetMetadata("Link", OutputLink);
}
return item;
}
public override bool Execute()
{
if (Assemblies == null || Assemblies.Length == 0)
return true;
List<ITaskItem> references = new List<ITaskItem>();
List<ITaskItem> nativeLibs = new List<ITaskItem>();
foreach (var assemblyItem in Assemblies)
{
try
{
if (!File.Exists(assemblyItem.ItemSpec))
{
Log.LogError($"File {assemblyItem.ItemSpec} does not exist, ensure you have built libraries before building the package.");
continue;
}
using (PEReader peReader = new PEReader(new FileStream(assemblyItem.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.Read)))
{
MetadataReader reader = peReader.GetMetadataReader();
foreach (var handle in reader.AssemblyReferences)
{
AssemblyReference reference = reader.GetAssemblyReference(handle);
TaskItem referenceItem = new TaskItem(reader.GetString(reference.Name));
assemblyItem.CopyMetadataTo(referenceItem);
referenceItem.SetMetadata("Version", reference.Version.ToString());
referenceItem.SetMetadata("AssemblyVersion", reference.Version.ToString());
references.Add(referenceItem);
}
for (int i = 1, count = reader.GetTableRowCount(TableIndex.ModuleRef); i <= count; i++)
{
var moduleRef = reader.GetModuleReference(MetadataTokens.ModuleReferenceHandle(i));
var moduleName = reader.GetString(moduleRef.Name);
TaskItem nativeLib = new TaskItem(moduleName);
assemblyItem.CopyMetadataTo(nativeLib);
nativeLibs.Add(nativeLib);
}
}
}
catch (InvalidOperationException)
{
// Ignore invalid assemblies
}
}
ReferencedAssemblies = references.ToArray();
ReferencedNativeLibraries = nativeLibs.ToArray();
return true;
}
static internal ITaskItem CreateReferenceItem(string itemSpec, string projectGuid, string package, string name)
{
TaskItem reference = new TaskItem(itemSpec);
if (projectGuid != null)
reference.SetMetadata(attributeProject, projectGuid);
if (package != null)
reference.SetMetadata("Package", package);
if (name != null)
reference.SetMetadata("Name", name);
return reference;
}
public override bool Execute()
{
var artworkWithLogicalNames = new List<ITaskItem> ();
var artwork = new HashSet<string> ();
Log.LogTaskName ("CollectITunesArtwork");
Log.LogTaskProperty ("ITunesArtwork", ITunesArtwork);
if (ITunesArtwork != null) {
foreach (var item in ITunesArtwork) {
// We need a physical path here, ignore the Link element
var path = item.GetMetadata ("FullPath");
string logicalName;
int width, height;
if (!File.Exists (path)) {
Log.LogError (" '{0}' not found.", path);
continue;
}
if (!GetPngImageSize (path, out width, out height) && !GetJpgImageSize (path, out width, out height)) {
Log.LogError (null, null, null, path, 0, 0, 0, 0, "Error loading '{0}': Unknown image format.", path);
return false;
}
if (width != height || (width != 512 && width != 1024)) {
Log.LogError (null, null, null, path, 0, 0, 0, 0, "Invalid iTunesArtwork dimensions ({0}x{1}) for '{2}'.", width, height, path);
return false;
}
logicalName = width == 1024 ? "iTunesArtwork@2x" : "iTunesArtwork";
if (!artwork.Add (logicalName)) {
Log.LogError (null, null, null, path, 0, 0, 0, 0, "Multiple iTunesArtwork files with the same dimensions detected.");
return false;
}
var bundleResource = new TaskItem (item);
bundleResource.SetMetadata ("LogicalName", logicalName);
bundleResource.SetMetadata ("Optimize", "false");
artworkWithLogicalNames.Add (bundleResource);
}
}
ITunesArtworkWithLogicalNames = artworkWithLogicalNames.ToArray ();
return !Log.HasLoggedErrors;
}
public override bool Execute()
{
// read the xml file and populate the JobsFound result
if (File.Exists(ConfigFile)) {
var doc = XDocument.Load(ConfigFile);
var jobs = from wj in doc.Root.Elements("WebJob")
select new {
RelPath = wj.Attribute("RelativePath").Value,
Schedule = wj.Attribute("Schedule").Value
};
var resultList = new List<ITaskItem>();
foreach (var job in jobs) {
var item = new TaskItem(job.RelPath);
item.SetMetadata("Schedule", job.Schedule);
resultList.Add(item);
}
JobsFound = resultList.ToArray();
}
else {
Log.LogMessage("web jobs config file not found at [{0}]", ConfigFile);
}
return !Log.HasLoggedErrors;
}
private static ITaskItem CreateProjectCopyLocal(ProjectCopyLocal projectCopyLocal)
{
var copies = projectCopyLocal.CopyLocals;
var result = new TaskItem(projectCopyLocal.Project);
result.SetMetadata("CopyLocals", string.Join(Environment.NewLine, copies.ToArray()));
return result;
}
private static ITaskItem[] GetSourceFolder(string folder)
{
var folderItem = new TaskItem(folder);
folderItem.SetMetadata("Test-name", "Test-Content");
return new ITaskItem[] { folderItem };
}
public override bool Execute()
{
var results = new List<ITaskItem> ();
Log.LogTaskName ("PackLibraryResources");
Log.LogTaskProperty ("BundleResourcesWithLogicalNames", BundleResourcesWithLogicalNames);
Log.LogTaskProperty ("Prefix", Prefix);
if (BundleResourcesWithLogicalNames != null) {
foreach (var item in BundleResourcesWithLogicalNames) {
var logicalName = item.GetMetadata ("LogicalName");
if (string.IsNullOrEmpty (logicalName)) {
Log.LogError ("Items must have logical names computed.");
return false;
}
var embedded = new TaskItem (item);
embedded.SetMetadata ("LogicalName", "__" + Prefix + "_content_" + EscapeMangledResource (logicalName));
results.Add (embedded);
}
}
EmbeddedResources = results.ToArray ();
return !Log.HasLoggedErrors;
}
public override bool Execute ()
{
if (files == null || files.Length == 0)
//nothing to do
return true;
List<ITaskItem> outFiles = new List<ITaskItem> ();
for (int i = 0; i < files.Length; i ++) {
string file = files [i].ItemSpec;
string link = files [i].GetMetadata ("Link");
string definingProjectPath = files [i].GetMetadata ("DefiningProjectFullPath");
if (String.IsNullOrEmpty (link) && Path.IsPathRooted (file) && !string.IsNullOrEmpty (definingProjectPath)) {
file = Path.GetFullPath (file);
var projectDir = Path.GetFullPath (Path.GetDirectoryName (definingProjectPath));
if (projectDir.Length == 0 || projectDir [projectDir.Length - 1] != Path.DirectorySeparatorChar)
projectDir += Path.DirectorySeparatorChar;
if (file.StartsWith (projectDir)) {
// The file is in the same folder or a subfolder of the project that contains it.
// Use the relative path wrt the containing project as link.
var outFile = new TaskItem (files [i]);
outFile.SetMetadata ("Link", file.Substring (projectDir.Length));
outFiles.Add (outFile);
}
}
}
assignedFiles = outFiles.ToArray ();
return true;
}
public override bool Execute()
{
if (string.IsNullOrEmpty(SourceDirectory))
{
Log.LogError("Argument SourceDirectory is missing.");
return false;
}
if (string.IsNullOrEmpty(StartAppPath))
{
Log.LogError("Argument StartAppPath is missing.");
return false;
}
if (string.IsNullOrEmpty(UniqueSourceDirectoryPath))
{
Log.LogError("Argument UniqueSourceDirectoryPath is missing.");
return false;
}
var orderer = new AppOrderer();
var list = orderer.GetAppBuildOrder(SourceDirectory, StartAppPath, UniqueSourceDirectoryPath, Log);
var returnList = new List<ITaskItem>();
foreach (string app in list)
{
ITaskItem item = new TaskItem(app);
item.SetMetadata("AppPath", app);
returnList.Add(item);
}
AppList = returnList.ToArray();
return true;
}
public override bool Execute()
{
EmbeddedResources = new ITaskItem[BundleResources.Length];
Log.LogTaskName ("CreateEmbeddedResources");
Log.LogTaskProperty ("BundleResources", BundleResources);
Log.LogTaskProperty ("Prefix", Prefix);
for (int i = 0; i < BundleResources.Length; i++) {
var bundleResource = BundleResources[i];
// clone the item
var embeddedResource = new TaskItem (bundleResource.ItemSpec);
bundleResource.CopyMetadataTo (embeddedResource);
// mangle the resource name
var logicalName = "__" + Prefix + "_content_" + EscapeMangledResource (bundleResource.GetMetadata ("LogicalName"));
embeddedResource.SetMetadata ("LogicalName", logicalName);
// add it to the output connection
EmbeddedResources[i] = embeddedResource;
}
return true;
}
private void SetMetaData(TaskItem item, string data, bool set)
{
if (set)
{
item.SetMetadata(TemplateFile.MetadataValueTag, data);
}
}
private ITaskItem ComputeLocalizedResource(ITaskItem xlf)
{
var resxName = xlf.GetMetadata("FileName");
var resxFileName = resxName + ".resx";
var resxPath = Path.Combine(LocalizedResxRoot, resxFileName);
var resxItem = new TaskItem(resxPath);
resxItem.SetMetadata(NeutralResxMetadata, xlf.GetMetadata(NeutralResxMetadata));
resxItem.SetMetadata(ParentXlfMetadata, xlf.ItemSpec);
resxItem.SetMetadata(ComputedCultureCodeMetadata, xlf.GetMetadata(ComputedCultureCodeMetadata));
resxItem.SetMetadata(LogicalNameMetadata, $"{AssemblyName}.{resxName}.resources");
xlf.SetMetadata(ChildResxMetadata, resxPath);
return resxItem;
}
public void CheckForSpecificMetadataOnParent()
{
Reference reference = new Reference(isWinMDFile, fileExists, getRuntimeVersion);
ITaskItem taskItem = new TaskItem("TestReference");
taskItem.SetMetadata("SpecificVersion", "true");
reference.MakePrimaryAssemblyReference(taskItem, true, ".dll");
Assert.True(reference.CheckForSpecificVersionMetadataOnParentsReference(false));
}
private ITaskItem CreateScriptItem(FileInfo arg)
{
var item = new TaskItem(arg.FullName);
item.SetMetadata("Schema", arg.Directory.Name);
return item;
}
public override bool Execute()
{
Log.LogTaskName ("PrepareNativeReferences");
Log.LogTaskProperty ("IntermediateOutputPath", IntermediateOutputPath);
Log.LogTaskProperty ("NativeReferences", NativeReferences);
if (NativeReferences == null || NativeReferences.Length == 0)
return !Log.HasLoggedErrors;
var embeddedResources = new List<ITaskItem> ();
var nativeFrameworks = new List<ITaskItem> ();
var text = new StringBuilder ();
for (int i = 0; i < NativeReferences.Length; i++) {
NativeReferenceKind kind;
string value;
value = NativeReferences[i].GetMetadata ("Kind") ?? string.Empty;
if (!Enum.TryParse (value, out kind)) {
Log.LogError (null, null, null, NativeReferences[i].ItemSpec, 0, 0, 0, 0, "Unknown native reference type: {0}", value);
continue;
}
var path = NativeReferences[i].ItemSpec;
var logicalName = Path.GetFileName (path);
var item = new TaskItem (path);
if (kind == NativeReferenceKind.Framework) {
nativeFrameworks.Add (item);
} else {
item.SetMetadata ("LogicalName", logicalName);
embeddedResources.Add (item);
}
text.AppendFormat ("[assembly: ObjCRuntime.LinkWith (\"{0}\"", logicalName);
AppendLinkTargetProperty (text, NativeReferences[i]);
AppendBooleanProperty (text, NativeReferences[i], "IsCxx");
AppendBooleanProperty (text, NativeReferences[i], "NeedsGccExceptionHandling");
AppendBooleanProperty (text, NativeReferences[i], "SmartLink", true);
AppendBooleanProperty (text, NativeReferences[i], "ForceLoad");
AppendStringProperty (text, NativeReferences[i], "Frameworks");
AppendStringProperty (text, NativeReferences[i], "WeakFrameworks");
AppendStringProperty (text, NativeReferences[i], "LinkerFlags");
text.Append (")]");
text.AppendLine ();
}
var linkWith = Path.Combine (IntermediateOutputPath, "LinkWithAttributes.cs");
Directory.CreateDirectory (Path.GetDirectoryName (linkWith));
File.WriteAllText (linkWith, text.ToString ());
EmbeddedResources = embeddedResources.ToArray ();
NativeFrameworks = nativeFrameworks.ToArray ();
LinkWithAttributes = new TaskItem (linkWith);
return !Log.HasLoggedErrors;
}
protected ITaskItem ConvertPackageElement(ITaskItem project, PackageReference packageReference)
{
var id = packageReference.Id;
var version = packageReference.Version;
var targetFramework = packageReference.TargetFramework;
var isDevelopmentDependency = packageReference.IsDevelopmentDependency;
var requireReinstallation = packageReference.RequireReinstallation;
var versionConstraint = packageReference.VersionConstraint;
var item = new TaskItem(id);
project.CopyMetadataTo(item);
var packageDirectoryPath = GetPackageDirectoryPath(project.GetMetadata("FullPath"), id, version);
item.SetMetadata("PackageDirectoryPath", packageDirectoryPath);
item.SetMetadata("ProjectPath", project.GetMetadata("FullPath"));
item.SetMetadata("IsDevelopmentDependency", isDevelopmentDependency.ToString());
item.SetMetadata("RequireReinstallation", requireReinstallation.ToString());
if (version != null)
item.SetMetadata(Metadata.Version, version.ToString());
if (targetFramework != null)
item.SetMetadata(Metadata.TargetFramework, targetFramework.GetShortFrameworkName());
if (versionConstraint != null)
item.SetMetadata("VersionConstraint", versionConstraint.ToString());
return item;
}
public override bool Execute()
{
ArrayList list = new ArrayList();
foreach (ITaskItem item in this.AssemblyFiles)
{
AssemblyName assemblyName;
try
{
assemblyName = AssemblyName.GetAssemblyName(item.ItemSpec);
}
catch (BadImageFormatException exception)
{
base.Log.LogErrorWithCodeFromResources("GetAssemblyIdentity.CouldNotGetAssemblyName", new object[] { item.ItemSpec, exception.Message });
continue;
}
catch (Exception exception2)
{
if (Microsoft.Build.Shared.ExceptionHandling.NotExpectedException(exception2))
{
throw;
}
base.Log.LogErrorWithCodeFromResources("GetAssemblyIdentity.CouldNotGetAssemblyName", new object[] { item.ItemSpec, exception2.Message });
continue;
}
ITaskItem destinationItem = new TaskItem(assemblyName.FullName);
destinationItem.SetMetadata("Name", assemblyName.Name);
if (assemblyName.Version != null)
{
destinationItem.SetMetadata("Version", assemblyName.Version.ToString());
}
if (assemblyName.GetPublicKeyToken() != null)
{
destinationItem.SetMetadata("PublicKeyToken", ByteArrayToHex(assemblyName.GetPublicKeyToken()));
}
if (assemblyName.CultureInfo != null)
{
destinationItem.SetMetadata("Culture", assemblyName.CultureInfo.ToString());
}
item.CopyMetadataTo(destinationItem);
list.Add(destinationItem);
}
this.Assemblies = (ITaskItem[]) list.ToArray(typeof(ITaskItem));
return !base.Log.HasLoggedErrors;
}
public void References()
{
Vbc t = new Vbc();
TaskItem reference = new TaskItem("System.Xml.dll");
reference.SetMetadata("Alias", "Foo");
t.References = new TaskItem[] { reference };
CommandLine.ValidateHasParameter(t, "/reference:System.Xml.dll");
}
public override bool Execute()
{
// for each marker file, deserialize the JSON data and convert it to a task item
var signTypeItems = new List<Tuple<string, SignTypeItem>>();
foreach (var markerFile in MarkerFiles)
{
if (!File.Exists(markerFile.ItemSpec))
{
Log.LogError("The specified marker file '{0}' doesn't exist.", markerFile.ItemSpec);
return false;
}
using (var streamReader = new StreamReader(File.OpenRead(markerFile.ItemSpec)))
{
using (var jsonReader = new JsonTextReader(streamReader))
{
JsonSerializer jsonSerializer = new JsonSerializer();
var signTypeItem = jsonSerializer.Deserialize<SignTypeItem>(jsonReader);
// the ItemSpec should be the name of the file to sign. by convention the marker
// file is the full path to the file plus a marker extension, so strip the extension.
var itemSpec = markerFile.ItemSpec.Substring(0, markerFile.ItemSpec.LastIndexOf('.'));
signTypeItems.Add(new Tuple<string, SignTypeItem>(itemSpec, signTypeItem));
}
}
}
SigningMetadata = new ITaskItem[signTypeItems.Count];
for (int i = 0; i < signTypeItems.Count; ++i)
{
var taskItem = new TaskItem(signTypeItems[i].Item1);
if (!string.IsNullOrEmpty(signTypeItems[i].Item2.Authenticode))
taskItem.SetMetadata("Authenticode", signTypeItems[i].Item2.Authenticode);
if (!string.IsNullOrEmpty(signTypeItems[i].Item2.StrongName))
taskItem.SetMetadata("StrongName", signTypeItems[i].Item2.StrongName);
SigningMetadata[i] = taskItem;
}
return true;
}
public void SingleAliasUnicodeOnAReference()
{
Csc t = new Csc();
TaskItem reference = new TaskItem("System.Xml.dll");
reference.SetMetadata("Aliases", "?");
t.References = new TaskItem[] { reference };
CommandLine.ValidateHasParameter(t, "/reference:?=System.Xml.dll");
}
/// <summary>
/// Parse the Parameter element
/// </summary>
/// <param name="element"></param>
private void ReadParameterElement(Xml.XmlElement element)
{
Debug.Assert(element != null);
if (string.Compare(element.Name, "parameter", System.StringComparison.OrdinalIgnoreCase) == 0)
{
Xml.XmlAttribute nameAttribute = element.Attributes.GetNamedItem("name") as Xml.XmlAttribute;
if (nameAttribute != null)
{
Utilities.TaskItem taskItem = new Microsoft.Build.Utilities.TaskItem(nameAttribute.Value);
foreach (Xml.XmlNode attribute in element.Attributes)
{
string attributeName = attribute.Name.ToLower(System.Globalization.CultureInfo.InvariantCulture);
if (string.CompareOrdinal(attributeName, "xmlns") == 0 ||
attribute.Name.StartsWith("xmlns:", System.StringComparison.Ordinal) ||
string.CompareOrdinal(attributeName, "name") == 0
)
{
continue;
}
string value = DisableEscapeMSBuildVariable ? attribute.Value : Utility.EscapeTextForMSBuildVariable(attribute.Value);
taskItem.SetMetadata(attribute.Name, value);
}
// work around the MSDeploy.exe limition of the Parameter must have the ParameterEntry.
// m_parametersList.Add(taskItem);
bool fAddNoParameterEntryParameter = true;
foreach (Xml.XmlNode childNode in element.ChildNodes)
{
Xml.XmlElement childElement = childNode as Xml.XmlElement;
if (childElement != null)
{
Utilities.TaskItem childEntry = ReadParameterEntryElement(childElement, taskItem);
if (childEntry != null)
{
fAddNoParameterEntryParameter = false; // we have Parameter entry, supress adding the Parameter with no entry
m_parametersList.Add(childEntry);
}
}
}
if (fAddNoParameterEntryParameter)
{
// finally add a parameter without any entry
m_parametersList.Add(taskItem);
}
}
}
}