public async Task DeleteReferenceAssembly(int id)
{
ReferenceAssembly matchingAssembly = await this.GetReferenceAssembly(id);
_context.referenceAssemblies.Remove(matchingAssembly);
// _notifier.OnDeleteReferenceAssembly(this, matchingAssembly.Id);
}
public static void TryGetFileName(Type type)
{
#if NETCOREAPP3_0
Assert.Inconclusive("Fix later.");
#endif
Assert.AreEqual(true, ReferenceAssembly.TryGet(Path.GetFileNameWithoutExtension(type.Assembly.Location), out var metadataReference));
StringAssert.Contains("Reference Assemblies", ((PortableExecutableReference?)metadataReference) !.FilePath);
}
public async Task <ReferenceAssembly> GetReferenceAssembly(int id)
{
ReferenceAssembly assembly = _context.referenceAssemblies.FirstOrDefault(RA => RA.Id == id);
if (assembly == null)
{
throw new ControllerNotFoundException($"NotFound - ReferenceAssembly with id: {id}");
}
return(assembly);
}
//
// Generate the necessary file lists and other information required by MarkupCompiler.
//
// Output ArrayLists: localApplicationFile,
// localXamlPageFileList
// referenceList
//
private void PrepareForMarkupCompilation(out FileUnit localApplicationFile, out FileUnit[] localXamlPageFileList, out ArrayList referenceList)
{
Log.LogMessageFromResources(MessageImportance.Low, SRID.PreparingCompile);
Log.LogMessageFromResources(MessageImportance.Low, SRID.OutputType, OutputType);
// Initialize the output parameters
localXamlPageFileList = new FileUnit[0];
localApplicationFile = FileUnit.Empty;
referenceList = new ArrayList();
if (_localApplicationFile != null)
{
// We don't want to support multiple application definition file per project.
localApplicationFile = new FileUnit(_localApplicationFile.FilePath, _localApplicationFile.LinkAlias, _localApplicationFile.LogicalName);
Log.LogMessageFromResources(MessageImportance.Low, SRID.LocalRefAppDefFile, localApplicationFile);
}
// Generate the Xaml Markup file list
if (_localMarkupPages != null && _localMarkupPages.Length > 0)
{
int localFileNum = _localMarkupPages.Length;
localXamlPageFileList = new FileUnit[localFileNum];
for (int i = 0; i < localFileNum; i++)
{
FileUnit localPageFile = new FileUnit(_localMarkupPages[i].FilePath, _localMarkupPages[i].LinkAlias, _localMarkupPages[i].LogicalName);
localXamlPageFileList[i] = localPageFile;
Log.LogMessageFromResources(MessageImportance.Low, SRID.LocalRefMarkupPage, localPageFile);
}
}
//
// Generate the asmmebly reference list.
// The temporay target assembly should have been added into Reference list from target file.
//
if (References != null && References.Length > 0)
{
ReferenceAssembly asmReference;
string refpath, asmname;
for (int i = 0; i < References.Length; i++)
{
refpath = References[i].ItemSpec;
refpath = TaskHelper.CreateFullFilePath(refpath, SourceDir);
asmname = Path.GetFileNameWithoutExtension(refpath);
asmReference = new ReferenceAssembly(refpath, asmname);
referenceList.Add(asmReference);
}
}
}
public void TryGet(Type type)
{
Assert.AreEqual(true, ReferenceAssembly.TryGet(type.Assembly, out var metadataReference));
StringAssert.Contains("Reference Assemblies", ((PortableExecutableReference)metadataReference).FilePath);
Assert.AreEqual(true, ReferenceAssembly.TryGet(type.Assembly.Location, out metadataReference));
StringAssert.Contains("Reference Assemblies", ((PortableExecutableReference)metadataReference).FilePath);
Assert.AreEqual(true, ReferenceAssembly.TryGet(Path.GetFileNameWithoutExtension(type.Assembly.Location), out metadataReference));
StringAssert.Contains("Reference Assemblies", ((PortableExecutableReference)metadataReference).FilePath);
}
public async Task <IActionResult> Edit(ReferenceAssembly assembly)
{
try
{
return(View(await _context.EditReferenceAssembly(assembly)));
}
catch (Exception e) when(e is ControllerNotFoundException || e is ControllerBadRequestException || e is ControllerUnauthorizedException)
{
return(RedirectToAction(nameof(Edit), new { id = assembly.Id }));
}
}
public async Task <ReferenceAssembly> EditReferenceAssembly(ReferenceAssembly assembly)
{
ReferenceAssembly matchingAssembly = await this.GetReferenceAssembly(assembly.Id);
matchingAssembly.Name = assembly.Name;
matchingAssembly.Location = assembly.Location;
matchingAssembly.DotNetVersion = assembly.DotNetVersion;
//_context.ReferenceAssemblies.Update(matchingAssembly);
// _notifier.OnEditReferenceAssembly(this, matchingAssembly);
return(await this.GetReferenceAssembly(matchingAssembly.Id));
}
public async Task <IActionResult> Create(ReferenceAssembly assembly)
{
try
{
ReferenceAssembly createdAssembly = await _context.CreateReferenceAssembly(assembly);
return(RedirectToAction(nameof(Edit), new { Id = createdAssembly.Id }));
}
catch (Exception e) when(e is ControllerNotFoundException || e is ControllerBadRequestException || e is ControllerUnauthorizedException)
{
return(View(new ReferenceAssembly()));
}
}
public async Task <ActionResult <ReferenceAssembly> > EditReferenceAssembly([FromBody] ReferenceAssembly assembly)
{
try
{
return(await _context.EditReferenceAssembly(assembly));
}
catch (ControllerNotFoundException e)
{
return(NotFound(e.Message));
}
catch (ControllerBadRequestException e)
{
return(BadRequest(e.Message));
}
catch (ControllerUnauthorizedException)
{
return(new UnauthorizedResult());
}
}
public async Task <ActionResult <ReferenceAssembly> > CreateReferenceAssembly([FromBody] ReferenceAssembly assembly)
{
try
{
ReferenceAssembly createdAssembly = await _context.CreateReferenceAssembly(assembly);
return(CreatedAtRoute(nameof(GetReferenceAssembly), new { id = createdAssembly.Id }, createdAssembly));
}
catch (ControllerNotFoundException e)
{
return(NotFound(e.Message));
}
catch (ControllerBadRequestException e)
{
return(BadRequest(e.Message));
}
catch (ControllerUnauthorizedException)
{
return(new UnauthorizedResult());
}
}
/// <summary>
/// Writes out the parameters as .csproj properties
/// </summary>
/// <param name="writer">XML writer to generate the .csproj property block</param>
public void ToCsprojProperties(XmlWriter writer)
{
writer.WriteElementString("CodeContractsAssemblyMode", XmlConvert.ToString((int)AssemblyMode));
writer.WriteElementString("CodeContractsEnableRuntimeChecking", XmlConvert.ToString(EnableRuntimeChecking));
writer.WriteElementString("CodeContractsRuntimeOnlyPublicSurface", XmlConvert.ToString(RuntimeOnlyPublicSurface));
writer.WriteElementString("CodeContractsRuntimeThrowOnFailure", XmlConvert.ToString(RuntimeThrowOnFailure));
writer.WriteElementString("CodeContractsRuntimeCallSiteRequires", XmlConvert.ToString(RuntimeCallSiteRequires));
writer.WriteElementString("CodeContractsRuntimeSkipQuantifiers", XmlConvert.ToString(RuntimeSkipQuantifiers));
writer.WriteElementString("CodeContractsRunCodeAnalysis", XmlConvert.ToString(RunCodeAnalysis));
writer.WriteElementString("CodeContractsNonNullObligations", XmlConvert.ToString(NonNullObligations));
writer.WriteElementString("CodeContractsBoundsObligations", XmlConvert.ToString(BoundsObligations));
writer.WriteElementString("CodeContractsArithmeticObligations", XmlConvert.ToString(ArithmeticObligations));
writer.WriteElementString("CodeContractsEnumObligations", XmlConvert.ToString(EnumObligations));
writer.WriteElementString("CodeContractsRedundantAssumptions", XmlConvert.ToString(RedundantAssumptions));
writer.WriteElementString("CodeContractsRunInBackground", XmlConvert.ToString(RunInBackground));
writer.WriteElementString("CodeContractsShowSquigglies", XmlConvert.ToString(ShowSquigglies));
writer.WriteElementString("CodeContractsUseBaseLine", XmlConvert.ToString(UseBaseLine));
writer.WriteElementString("CodeContractsEmitXMLDocs", XmlConvert.ToString(EmitXMLDocs));
writer.WriteElementString("CodeContractsCustomRewriterAssembly", CustomRewriterAssembly);
writer.WriteElementString("CodeContractsCustomRewriterClass", CustomRewriterClass);
writer.WriteElementString("CodeContractsLibPaths", LibPaths);
writer.WriteElementString("CodeContractsExtraRewriteOptions", ExtraRewriteOptions);
writer.WriteElementString("CodeContractsExtraAnalysisOptions", ExtraAnalysisOptions);
writer.WriteElementString("CodeContractsBaseLineFile", BaseLineFile);
writer.WriteElementString("CodeContractsCacheAnalysisResults", XmlConvert.ToString(CacheAnalysisResults));
writer.WriteElementString("CodeContractsRuntimeCheckingLevel", RuntimeCheckingLevel.ToString());
writer.WriteElementString("CodeContractsReferenceAssembly", ReferenceAssembly.ToString());
writer.WriteElementString("CodeContractsAnalysisWarningLevel", XmlConvert.ToString(AnalysisWarningLevel));
writer.WriteElementString("CodeContractsInferRequires", XmlConvert.ToString(InferRequires));
writer.WriteElementString("CodeContractsInferEnsures", XmlConvert.ToString(InferEnsures));
writer.WriteElementString("CodeContractsInferObjectInvariants", XmlConvert.ToString(InferObjectInvariants));
writer.WriteElementString("CodeContractsSuggestAssumptions", XmlConvert.ToString(SuggestAssumptions));
writer.WriteElementString("CodeContractsSuggestRequires", XmlConvert.ToString(SuggestRequires));
writer.WriteElementString("CodeContractsSuggestEnsures", XmlConvert.ToString(SuggestEnsures));
writer.WriteElementString("CodeContractsSuggestObjectInvariants", XmlConvert.ToString(SuggestObjectInvariants));
writer.WriteElementString("CodeContractsDisjunctiveRequires", XmlConvert.ToString(DisjunctiveRequires));
}
public Task <ReferenceAssembly> EditReferenceAssembly(ReferenceAssembly assembly)
{
return(_connection.InvokeAsync <ReferenceAssembly>("EditReferenceAssembly", assembly));
}
//
// Generate the necessary file lists and other information required by MarkupCompiler.
//
// Output ArrayLists: localApplicationFile,
// localXamlPageFileList
// referenceList
//
private void PrepareForMarkupCompilation(out FileUnit localApplicationFile, out FileUnit[] localXamlPageFileList, out ArrayList referenceList)
{
Log.LogMessageFromResources(MessageImportance.Low, SRID.PreparingCompile);
Log.LogMessageFromResources(MessageImportance.Low, SRID.OutputType, OutputType);
// Initialize the output parameters
localXamlPageFileList = new FileUnit[0];
localApplicationFile = FileUnit.Empty;
referenceList = new ArrayList();
if (_localApplicationFile != null)
{
// We don't want to support multiple application definition file per project.
localApplicationFile = new FileUnit(_localApplicationFile.FilePath, _localApplicationFile.LinkAlias, _localApplicationFile.LogicalName);
Log.LogMessageFromResources(MessageImportance.Low, SRID.LocalRefAppDefFile, localApplicationFile);
}
// Generate the Xaml Markup file list
if (_localMarkupPages != null && _localMarkupPages.Length > 0)
{
int localFileNum = _localMarkupPages.Length;
localXamlPageFileList = new FileUnit[localFileNum];
for (int i = 0; i < localFileNum; i++)
{
FileUnit localPageFile = new FileUnit(_localMarkupPages[i].FilePath, _localMarkupPages[i].LinkAlias, _localMarkupPages[i].LogicalName);
localXamlPageFileList[i] = localPageFile;
Log.LogMessageFromResources(MessageImportance.Low, SRID.LocalRefMarkupPage, localPageFile);
}
}
//
// Generate the asmmebly reference list.
// The temporay target assembly should have been added into Reference list from target file.
//
if (References != null && References.Length > 0)
{
ReferenceAssembly asmReference;
string refpath, asmname;
for (int i = 0; i < References.Length; i++)
{
refpath = References[i].ItemSpec;
refpath = TaskHelper.CreateFullFilePath(refpath, SourceDir);
asmname = Path.GetFileNameWithoutExtension(refpath);
asmReference = new ReferenceAssembly(refpath, asmname);
referenceList.Add(asmReference);
//
// If always run the compilation in second appdomain, there is no need to specially
// handle the referenced assemblies.
// Unload the appdomain can unload all the referenced assemblies.
//
if (AlwaysCompileMarkupFilesInSeparateDomain == false)
{
bool bCouldbeChanged = TaskHelper.CouldReferenceAssemblyBeChanged(refpath, KnownReferencePaths, AssembliesGeneratedDuringBuild);
if (bCouldbeChanged)
{
MarkupCompiler.InitializeAssemblyState(asmname);
}
}
}
}
}
public async Task <ReferenceAssembly> CreateReferenceAssembly(ReferenceAssembly assembly)
{
_context.referenceAssemblies.Add(assembly);
// _notifier.OnCreateReferenceAssembly(this, assembly);
return(await this.GetReferenceAssembly(assembly.Id));
}
//Reference Assembly methods
public async Task <ReferenceAssembly> GetReferenceAssemblyByName(string name, Common.DotNetVersion version)
{
ReferenceAssembly assembly = _context.referenceAssemblies.First(asm => asm.Name == name);
return(assembly);
}
public void Add(ReferenceAssembly entity)
{
referenceAssemblies.Add(entity);
}
