private static IEnumerable <string> EnumeratePackageFullPaths(string fullPath)
{
if (PackageSessionHelper.IsSolutionFile(fullPath))
{
// Solution file: extract projects
var solutionDirectory = Path.GetDirectoryName(fullPath) ?? "";
var solution = SiliconStudio.Core.VisualStudio.Solution.FromFile(fullPath);
foreach (var project in solution.Projects)
{
string packagePath;
if (PackageSessionHelper.IsPackage(project, out packagePath))
{
var packageFullPath = Path.Combine(solutionDirectory, packagePath);
yield return(packageFullPath);
}
}
}
else
{
// Otherwise, let's assume it was a package
yield return(fullPath);
}
}
/// <summary>
/// Loads a package from specified file path.
/// </summary>
/// <param name="filePath">The file path to a package file.</param>
/// <param name="sessionResult">The session result.</param>
/// <param name="loadParameters">The load parameters.</param>
/// <returns>A package.</returns>
/// <exception cref="System.ArgumentNullException">filePath</exception>
/// <exception cref="System.ArgumentException">File [{0}] must exist.ToFormat(filePath);filePath</exception>
public static void Load(string filePath, PackageSessionResult sessionResult, PackageLoadParameters loadParameters = null)
{
if (filePath == null)
{
throw new ArgumentNullException("filePath");
}
if (sessionResult == null)
{
throw new ArgumentNullException("sessionResult");
}
// Make sure with have valid parameters
loadParameters = loadParameters ?? PackageLoadParameters.Default();
// Make sure to use a full path.
filePath = FileUtility.GetAbsolutePath(filePath);
if (!File.Exists(filePath))
{
throw new ArgumentException("File [{0}] must exist".ToFormat(filePath), "filePath");
}
try
{
// Enable reference analysis caching during loading
AssetReferenceAnalysis.EnableCaching = true;
using (var profile = Profiler.Begin(PackageSessionProfilingKeys.Loading))
{
sessionResult.Clear();
sessionResult.Progress("Loading..", 0, 1);
var session = new PackageSession();
var packagePaths = new List <string>();
// If we have a solution, load all packages
if (PackageSessionHelper.IsSolutionFile(filePath))
{
PackageSessionHelper.LoadSolution(session, filePath, packagePaths, sessionResult);
}
else if (PackageSessionHelper.IsPackageFile(filePath))
{
packagePaths.Add(filePath);
}
else
{
sessionResult.Error("Unsupported file extension (only .sln or {0} are supported)", Package.PackageFileExtension);
return;
}
var cancelToken = loadParameters.CancelToken;
// Load all packages
var packagesLoaded = new PackageCollection();
foreach (var packageFilePath in packagePaths)
{
PreLoadPackage(session, sessionResult, packageFilePath, false, packagesLoaded, loadParameters);
// Output the session only if there is no cancellation
if (cancelToken.HasValue && cancelToken.Value.IsCancellationRequested)
{
return;
}
}
// Load all missing references/dependencies
session.LoadMissingReferences(sessionResult, loadParameters);
// Fix relative references
var analysis = new PackageSessionAnalysis(session, GetPackageAnalysisParametersForLoad());
var analysisResults = analysis.Run();
analysisResults.CopyTo(sessionResult);
// Run custom package session analysis
foreach (var type in AssetRegistry.GetPackageSessionAnalysisTypes())
{
var pkgAnalysis = (PackageSessionAnalysisBase)Activator.CreateInstance(type);
pkgAnalysis.Session = session;
var results = pkgAnalysis.Run();
results.CopyTo(sessionResult);
}
// Output the session only if there is no cancellation
if (!cancelToken.HasValue || !cancelToken.Value.IsCancellationRequested)
{
sessionResult.Session = session;
// Defer the initialization of the dependency manager
//session.DependencyManager.InitializeDeferred();
}
// The session is not dirty when loading it
session.IsDirty = false;
}
}
finally
{
// Disable reference analysis caching after loading
AssetReferenceAnalysis.EnableCaching = false;
}
}