////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public Dictionary <string, string> ProjectPropertiesToDictionary()
{
Dictionary <string, string> evaluatedProperties = new Dictionary <string, string> ();
IPropertyPagesCatalog projectPropertyList = ConfiguredProject.Services.PropertyPagesCatalog.GetCatalog("Project");
IEnumerable <string> projectPropertySchemas = projectPropertyList.GetPropertyPagesSchemas();
foreach (string schema in projectPropertySchemas)
{
IRule schemaRules = projectPropertyList.BindToContext(schema, File, ItemType, ItemName);
foreach (IProperty properties in schemaRules.Properties)
{
try
{
IEvaluatedProperty evaluatedProperty = (IEvaluatedProperty)properties;
string schemaGroupedKey = schema + "." + properties.Name;
evaluatedProperties [schemaGroupedKey] = evaluatedProperty.EvaluatedValueAtEnd;
}
catch (Exception e)
{
LoggingUtils.HandleException(e);
}
}
}
return(evaluatedProperties);
}
/// <summary>
/// Gets the rule(s) that applies to a reference.
/// </summary>
/// <param name="itemType">The item type on the unresolved reference.</param>
/// <param name="resolved">
/// A value indicating whether to return rules for resolved or unresolved reference state.
/// </param>
/// <param name="namedCatalogs">The dictionary of catalogs.</param>
/// <returns>The sequence of matching rules. Hopefully having exactly one element.</returns>
private IEnumerable <Rule> GetSchemaForReference(string itemType,
bool resolved,
IImmutableDictionary <string, IPropertyPagesCatalog> namedCatalogs)
{
Requires.NotNull(namedCatalogs, nameof(namedCatalogs));
// Note: usually for default/generic dependencies we have sets of 2 rule schemas:
// - rule for unresolved dependency, they persist in ProjectFile
// - rule for resolved dependency, they persist in ResolvedReference
// So to be able to find rule for resolved or unresolved reference we need to be consistent there
// and make sure we do set ResolvedReference persistense for resolved dependnecies, since we rely
// on that here when pick correct rule schema.
// (old code used to check if rule datasource has SourceType=TargetResults, which was true for Resolved,
// dependencies. However now we have custom logic for collecting unresolved dependencies too and use
// DesignTime build results there too. Thats why we swicthed to check for persistence).
IPropertyPagesCatalog browseObjectCatalog = namedCatalogs[PropertyPageContexts.BrowseObject];
IReadOnlyCollection <string> schemas = browseObjectCatalog.GetPropertyPagesSchemas(itemType);
return(from schemaName in browseObjectCatalog.GetPropertyPagesSchemas(itemType)
let schema = browseObjectCatalog.GetSchema(schemaName)
where schema.DataSource != null &&
string.Equals(itemType, schema.DataSource.ItemType, StringComparison.OrdinalIgnoreCase) &&
(resolved == string.Equals(schema.DataSource.Persistence,
RuleDataSourceTypes.PersistenceResolvedReference,
StringComparison.OrdinalIgnoreCase))
select schema);
}
public async Task <IRule> GetRuleAsync(IDependency dependency, IProjectCatalogSnapshot catalogs)
{
Requires.NotNull(dependency, nameof(dependency));
ConfiguredProject project = null;
if (dependency.TargetFramework.Equals(TargetFramework.Any))
{
project = ActiveConfiguredProject;
}
else
{
project = await DependenciesHost.GetConfiguredProject(dependency.TargetFramework)
.ConfigureAwait(false) ?? ActiveConfiguredProject;
}
ConfiguredProjectExports configuredProjectExports = GetActiveConfiguredProjectExports(project);
IImmutableDictionary <string, IPropertyPagesCatalog> namedCatalogs = await GetNamedCatalogsAsync(catalogs).ConfigureAwait(false);
Requires.NotNull(namedCatalogs, nameof(namedCatalogs));
IPropertyPagesCatalog browseObjectsCatalog = namedCatalogs[PropertyPageContexts.BrowseObject];
Rule schema = browseObjectsCatalog.GetSchema(dependency.SchemaName);
string itemSpec = string.IsNullOrEmpty(dependency.OriginalItemSpec) ? dependency.Path : dependency.OriginalItemSpec;
var context = ProjectPropertiesContext.GetContext(UnconfiguredProject,
itemType: dependency.SchemaItemType,
itemName: itemSpec);
IRule rule = null;
if (schema != null)
{
if (dependency.Resolved)
{
rule = configuredProjectExports.RuleFactory.CreateResolvedReferencePageRule(
schema,
context,
dependency.Name,
dependency.Properties);
}
else
{
rule = browseObjectsCatalog.BindToContext(schema.Name, context);
}
}
else
{
// Since we have no browse object, we still need to create *something* so
// that standard property pages can pop up.
Rule emptyRule = RuleExtensions.SynthesizeEmptyRule(context.ItemType);
return(configuredProjectExports.PropertyPagesDataModelProvider.GetRule(
emptyRule,
context.File,
context.ItemType,
context.ItemName));
}
return(rule);
}
public static IEnumerable <Rule> GetDebugChildRules(IPropertyPagesCatalog projectCatalog)
{
foreach (string schemaName in projectCatalog.GetPropertyPagesSchemas(itemType: "LaunchProfile"))
{
if (projectCatalog.GetSchema(schemaName) is { PropertyPagesHidden: false, PageTemplate: CommandNameBasedDebuggerPageTemplate } possibleChildRule)
{
yield return(possibleChildRule);
}
}
}
public static IEnumerable <Rule> GetDebugChildRules(IPropertyPagesCatalog projectCatalog)
{
foreach (string schemaName in projectCatalog.GetProjectLevelPropertyPagesSchemas())
{
if (projectCatalog.GetSchema(schemaName) is Rule possibleChildRule &&
!possibleChildRule.PropertyPagesHidden &&
possibleChildRule.PageTemplate == CommandNameBasedDebuggerPageTemplate)
{
yield return(possibleChildRule);
}
}
}
public override async Task <string?> OnSetPropertyValueAsync(string propertyName, string unevaluatedPropertyValue, IProjectProperties defaultProperties, IReadOnlyDictionary <string, string>?dimensionalConditions = null)
{
ConfiguredProject?configuredProject = await _project.GetSuggestedConfiguredProjectAsync();
IPropertyPagesCatalogProvider?catalogProvider = configuredProject?.Services.PropertyPagesCatalog;
if (catalogProvider == null)
{
return(null);
}
IPropertyPagesCatalog catalog = await catalogProvider.GetCatalogAsync(PropertyPageContexts.Project);
Rule?rule = catalog.GetSchema(unevaluatedPropertyValue);
if (rule == null)
{
return(null);
}
if (rule.Metadata.TryGetValue("CommandName", out object pageCommandNameObj) &&
pageCommandNameObj is string pageCommandName)
{
_projectThreadingService.RunAndForget(async() =>
{
// Infinite timeout means this will not actually be null.
ILaunchSettings?launchSettings = await _launchSettingsProvider.WaitForFirstSnapshot(Timeout.Infinite);
Assumes.NotNull(launchSettings);
IWritableLaunchSettings writableLaunchSettings = launchSettings.ToWritableLaunchSettings();
IWritableLaunchProfile?activeProfile = writableLaunchSettings.ActiveProfile;
if (activeProfile != null)
{
activeProfile.CommandName = pageCommandName;
await _launchSettingsProvider.UpdateAndSaveSettingsAsync(writableLaunchSettings.ToLaunchSettings());
}
},
options: ForkOptions.HideLocks,
unconfiguredProject: _project);
}
return(null);
}
private async Task <string> GetPropertyValueAsync()
{
// Infinite timeout means this will not actually be null.
ILaunchSettings?launchSettings = await _launchSettingsProvider.WaitForFirstSnapshot(Timeout.Infinite);
Assumes.NotNull(launchSettings);
string?commandName = launchSettings.ActiveProfile?.CommandName;
if (commandName == null)
{
return(string.Empty);
}
ConfiguredProject?configuredProject = await _project.GetSuggestedConfiguredProjectAsync();
IPropertyPagesCatalogProvider?catalogProvider = configuredProject?.Services.PropertyPagesCatalog;
if (catalogProvider == null)
{
return(string.Empty);
}
IPropertyPagesCatalog catalog = await catalogProvider.GetCatalogAsync(PropertyPageContexts.Project);
foreach (string schemaName in catalog.GetPropertyPagesSchemas())
{
Rule?rule = catalog.GetSchema(schemaName);
if (rule != null &&
string.Equals(rule.PageTemplate, "CommandNameBasedDebugger", StringComparison.OrdinalIgnoreCase) &&
rule.Metadata.TryGetValue("CommandName", out object pageCommandNameObj) &&
pageCommandNameObj is string pageCommandName &&
pageCommandName.Equals(commandName))
{
return(schemaName);
}
}
return(string.Empty);
}
public async Task <ICollection <IEnumValue> > GetListedValuesAsync()
{
var catalogProvider = _configuredProject.Services.PropertyPagesCatalog;
if (catalogProvider == null)
{
return(Array.Empty <IEnumValue>());
}
IPropertyPagesCatalog catalog = await catalogProvider.GetCatalogAsync(PropertyPageContexts.Project);
return(catalog.GetPropertyPagesSchemas()
.Select(catalog.GetSchema)
.WhereNotNull()
.Where(rule => string.Equals(rule.PageTemplate, "CommandNameBasedDebugger", StringComparison.OrdinalIgnoreCase) &&
rule.Metadata.TryGetValue("CommandName", out object pageCommandNameObj))
.Select(rule => new PageEnumValue(new EnumValue
{
Name = rule.Name,
DisplayName = rule.DisplayName
}))
.ToArray <IEnumValue>());
}
private static IPropertyPagesCatalogProvider CreateCatalogProvider(Dictionary <string, IPropertyPagesCatalog> catalogsByContext, IPropertyPagesCatalog catalog)
{
var catalogProvider = new Mock <IPropertyPagesCatalogProvider>();
catalogProvider
.Setup(o => o.GetCatalogsAsync(CancellationToken.None))
.ReturnsAsync(catalogsByContext.ToImmutableDictionary());
catalogProvider
.Setup(o => o.GetMemoryOnlyCatalog(It.IsAny <string>()))
.Returns(catalog);
return(catalogProvider.Object);
}
public async Task <IRule> GetRuleAsync(IDependency dependency, IProjectCatalogSnapshot catalogs)
{
Requires.NotNull(dependency, nameof(dependency));
ConfiguredProject project = dependency.TargetFramework.Equals(TargetFramework.Any)
? ActiveConfiguredProject
: _dependenciesHost.GetConfiguredProject(dependency.TargetFramework) ?? ActiveConfiguredProject;
IImmutableDictionary <string, IPropertyPagesCatalog> namedCatalogs = await GetNamedCatalogsAsync();
Requires.NotNull(namedCatalogs, nameof(namedCatalogs));
IPropertyPagesCatalog browseObjectsCatalog = namedCatalogs[PropertyPageContexts.BrowseObject];
Rule schema = browseObjectsCatalog.GetSchema(dependency.SchemaName);
string itemSpec = string.IsNullOrEmpty(dependency.OriginalItemSpec) ? dependency.Path : dependency.OriginalItemSpec;
var context = ProjectPropertiesContext.GetContext(UnconfiguredProject,
itemType: dependency.SchemaItemType,
itemName: itemSpec);
if (schema == null)
{
// Since we have no browse object, we still need to create *something* so
// that standard property pages can pop up.
Rule emptyRule = RuleExtensions.SynthesizeEmptyRule(context.ItemType);
return(GetActiveConfiguredProjectExports(project).PropertyPagesDataModelProvider.GetRule(
emptyRule,
context.File,
context.ItemType,
context.ItemName));
}
if (dependency.Resolved)
{
return(GetActiveConfiguredProjectExports(project).RuleFactory.CreateResolvedReferencePageRule(
schema,
context,
dependency.Name,
dependency.Properties));
}
return(browseObjectsCatalog.BindToContext(schema.Name, context));
async Task <IImmutableDictionary <string, IPropertyPagesCatalog> > GetNamedCatalogsAsync()
{
if (catalogs != null)
{
return(catalogs.NamedCatalogs);
}
if (_namedCatalogs == null)
{
// Note: it is unlikely that we end up here, however for cases when node providers
// getting their node data not from Design time build events, we might have OnDependenciesChanged
// event coming before initial design time build event updates NamedCatalogs in this class.
// Thus, just in case, explicitly request it here (GetCatalogsAsync will acquire a project read lock)
_namedCatalogs = await ActiveConfiguredProject.Services
.PropertyPagesCatalog
.GetCatalogsAsync(CancellationToken.None);
}
return(_namedCatalogs);
}
}
