private void Cleanup(bool cleanSupportingFolderIfNotInProject)
{
if (this.temporaryFolderPlaceholder != null)
{
this.temporaryFolderPlaceholder.Dispose();
this.temporaryFolderPlaceholder = (ProjectPathHelper.TemporaryDirectory)null;
}
if (this.supportingDirectoryPath != null && cleanSupportingFolderIfNotInProject)
{
if (this.ImportContext.ActiveProject.FindItem(DocumentReference.Create(this.supportingDirectoryPath)) == null)
{
try
{
Directory.Delete(this.supportingDirectoryPath);
}
catch (IOException ex)
{
}
}
}
IDisposable disposable = this.asyncHandlerArgument as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
this.asyncHandlerArgument = (object)null;
}
private void ResetInternal()
{
this.hostData.Clear();
this.insertionPoint = (ISceneInsertionPoint)null;
this.initialInsertionPoint = (ISceneInsertionPoint)null;
this.supportingFolderName = (string)null;
this.supportingDirectoryPath = (string)null;
this.asyncHandler = (Action <object, DoWorkEventArgs>)null;
this.asyncHandlerArgument = (object)null;
this.countMessages = 0;
this.completeRatio = 0.0;
this.importContext = (IImportManagerContext)null;
if (this.temporaryFolderPlaceholder != null)
{
this.temporaryFolderPlaceholder.Dispose();
}
this.temporaryFolderPlaceholder = new ProjectPathHelper.TemporaryDirectory(false, true);
this.supportingFiles = (IList <KeyValuePair <string, string> >) new List <KeyValuePair <string, string> >();
}
private void OnWorkerDoWork(object sender, DoWorkEventArgs e)
{
AssemblyAssetAggregator.ProviderWorker providerWorker = sender as AssemblyAssetAggregator.ProviderWorker;
providerWorker.DoWork -= new DoWorkEventHandler(this.OnWorkerDoWork);
List <AssemblyAssetProvider> list = (List <AssemblyAssetProvider>)e.Argument;
if (Enumerable.FirstOrDefault <AssemblyAssetProvider>((IEnumerable <AssemblyAssetProvider>)list) == null)
{
return;
}
AppDomain domain = AppDomain.CreateDomain("AssetToolDomain", (Evidence)null, new AppDomainSetup()
{
DisallowBindingRedirects = true
});
try
{
using (ProjectPathHelper.TemporaryDirectory temporaryDirectory = new ProjectPathHelper.TemporaryDirectory())
{
using (List <AssemblyAssetProvider> .Enumerator enumerator = list.GetEnumerator())
{
while (enumerator.MoveNext())
{
AssemblyAssetProvider provider = enumerator.Current;
if (providerWorker.CancellationPending)
{
break;
}
if (!provider.AsynchronizedInitialize(domain, temporaryDirectory.Path, (IBackgroundWorkerWrapper)providerWorker))
{
providerWorker.InvokeUIThread(DispatcherPriority.Background, (Action)(() => this.RemoveProvider((AssetProvider)provider)));
}
}
}
}
}
finally
{
AppDomain.Unload(domain);
}
}
public IEnumerable <IProjectItem> CreateProjectItems(string name, string targetFolder, IProject project, IEnumerable <TemplateArgument> templateArguments, CreationOptions creationOptions, out List <IProjectItem> itemsToOpen, IServiceProvider serviceProvider)
{
Uri uri;
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
ICodeDocumentType codeDocumentType = base.GetCodeDocumentType(serviceProvider);
if (templateArguments != null)
{
templateArguments = templateArguments.Concat <TemplateArgument>(TemplateManager.GetDefaultArguments(serviceProvider.ExpressionInformationService()));
}
else
{
templateArguments = TemplateManager.GetDefaultArguments(serviceProvider.ExpressionInformationService());
}
IEnumerable <IProjectItem> projectItems = Enumerable.Empty <IProjectItem>();
itemsToOpen = new List <IProjectItem>();
using (ProjectPathHelper.TemporaryDirectory temporaryDirectory = new ProjectPathHelper.TemporaryDirectory(true))
{
Uri uri1 = new Uri(Microsoft.Expression.Framework.Documents.PathHelper.EnsurePathEndsInDirectorySeparator(temporaryDirectory.Path));
List <DocumentCreationInfo> documentCreationInfos = new List <DocumentCreationInfo>();
List <string> strs = new List <string>();
bool flag = false;
foreach (VSTemplateTemplateContentProjectItem templateProjectItem in this.TemplateProjectItems)
{
if (!templateProjectItem.OpenInEditorSpecified)
{
continue;
}
flag = true;
break;
}
bool flag1 = false;
string str = CodeGenerator.MakeSafeIdentifier(codeDocumentType, project.DocumentReference.DisplayNameShort, flag1);
bool flag2 = true;
string str1 = CodeGenerator.MakeSafeIdentifier(codeDocumentType, project.DocumentReference.DisplayNameShort, flag2);
TemplateArgument templateArgument = new TemplateArgument("safeprojectname", str);
TemplateArgument templateArgument1 = new TemplateArgument("safeprojectname", str1);
TemplateArgument templateArgument2 = new TemplateArgument("assemblyname", project.DocumentReference.DisplayNameShort);
TemplateArgument templateArgument3 = new TemplateArgument("safeassemblyname", project.DocumentReference.DisplayNameShort.Replace(' ', '\u005F'));
foreach (VSTemplateTemplateContentProjectItem vSTemplateTemplateContentProjectItem in this.TemplateProjectItems)
{
string targetFileName = vSTemplateTemplateContentProjectItem.TargetFileName;
if (string.IsNullOrEmpty(targetFileName))
{
targetFileName = vSTemplateTemplateContentProjectItem.Value;
}
TemplateArgument[] templateArgumentArray = new TemplateArgument[] { new TemplateArgument("fileinputname", Path.GetFileNameWithoutExtension(name)), new TemplateArgument("fileinputextension", Path.GetExtension(name)) };
IEnumerable <TemplateArgument> templateArguments1 = templateArgumentArray;
targetFileName = TemplateParser.ReplaceTemplateArguments(targetFileName, templateArguments1);
templateArguments1 = templateArguments1.Concat <TemplateArgument>(templateArguments);
bool flag3 = Path.GetExtension(vSTemplateTemplateContentProjectItem.Value).Equals(codeDocumentType.DefaultFileExtension, StringComparison.OrdinalIgnoreCase);
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(Microsoft.Expression.Framework.Documents.PathHelper.GetFileOrDirectoryName(targetFileName));
if (serviceProvider.DocumentTypeManager().DocumentTypes[DocumentTypeNamesHelper.Xaml].IsDocumentTypeOf(fileNameWithoutExtension))
{
fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileNameWithoutExtension);
}
string str2 = CodeGenerator.MakeSafeIdentifier(codeDocumentType, fileNameWithoutExtension, flag3);
IEnumerable <TemplateArgument> templateArguments2 = templateArguments1;
TemplateArgument[] templateArgumentArray1 = new TemplateArgument[] { new TemplateArgument("rootnamespace", project.DefaultNamespaceName), new TemplateArgument("projectname", project.DocumentReference.DisplayNameShort), templateArgument2, templateArgument3, null, null, null, null };
templateArgumentArray1[4] = (flag3 ? templateArgument1 : templateArgument);
templateArgumentArray1[5] = new TemplateArgument("safeitemname", str2);
templateArgumentArray1[6] = new TemplateArgument("safeitemrootname", str2);
templateArgumentArray1[7] = new TemplateArgument("culture", (string.IsNullOrEmpty(project.UICulture) ? CultureInfo.CurrentUICulture.ToString() : project.UICulture));
templateArguments1 = templateArguments2.Concat <TemplateArgument>(templateArgumentArray1);
try
{
uri = base.ResolveFileUri(targetFileName, uri1);
}
catch (UriFormatException uriFormatException)
{
continue;
}
IDocumentType documentType = project.GetDocumentType(targetFileName);
foreach (IDocumentType documentType1 in serviceProvider.DocumentTypeManager().DocumentTypes)
{
if (vSTemplateTemplateContentProjectItem.SubType != documentType1.Name)
{
continue;
}
documentType = documentType1;
}
if (!base.CreateFile(vSTemplateTemplateContentProjectItem.Value, base.TemplateLocation, uri, vSTemplateTemplateContentProjectItem.ReplaceParameters, templateArguments1))
{
continue;
}
string str3 = ProjectItemTemplate.AdjustTargetFolder(targetFolder, uri1.LocalPath, uri.LocalPath);
DocumentCreationInfo documentCreationInfo = new DocumentCreationInfo()
{
SourcePath = uri.LocalPath,
TargetFolder = str3,
DocumentType = documentType,
CreationOptions = creationOptions
};
documentCreationInfos.Add(documentCreationInfo);
if (!flag)
{
if (strs.Count > 0)
{
continue;
}
strs.Add(Path.Combine(str3, Path.GetFileName(uri.LocalPath)));
}
else
{
if (!vSTemplateTemplateContentProjectItem.OpenInEditor)
{
continue;
}
strs.Add(Path.Combine(str3, Path.GetFileName(uri.LocalPath)));
}
}
if (documentCreationInfos.Count > 0)
{
projectItems = project.AddItems(documentCreationInfos);
}
if (projectItems.Any <IProjectItem>())
{
for (int i = 0; i < strs.Count; i++)
{
IProjectItem projectItem = projectItems.FirstOrDefault <IProjectItem>((IProjectItem item) => item.DocumentReference.Path.Equals(strs[i], StringComparison.OrdinalIgnoreCase));
if (projectItem != null)
{
itemsToOpen.Add(projectItem);
}
}
projectItems = projectItems.Concat <IProjectItem>(this.AddAssemblies(project));
}
}
if (base.BuildOnLoad)
{
IProjectManager projectManager = serviceProvider.ProjectManager();
IProjectBuildContext activeBuildTarget = projectManager.ActiveBuildTarget;
projectManager.BuildManager.Build(activeBuildTarget, null, true);
KnownProjectBase knownProjectBase = project as KnownProjectBase;
if (knownProjectBase != null)
{
knownProjectBase.CheckForChangedOrDeletedItems();
}
}
return(projectItems);
}
