/// <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 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);
}
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);
}
}
}
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>());
}
