AttributeMetadata.CanBeSecuredForCreate Property

public:
 property Nullable<bool> CanBeSecuredForCreate { Nullable<bool> get(); };

[System.Runtime.Serialization.DataMember]
public bool? CanBeSecuredForCreate { get; }

[<System.Runtime.Serialization.DataMember>]
member this.CanBeSecuredForCreate : Nullable<bool>

Public ReadOnly Property CanBeSecuredForCreate As Nullable(Of Boolean)

Property Value

true if the field-level security can be applied; otherwise, false.

Attributes

DataMemberAttribute

Remarks

Learn more about column-level security

Retrieve column security information example

This static DumpColumnSecurityInfo method exports column security information for all entities in the organization to a CSV file:

/// <summary>
/// Exports column security information for all entities in the organization to a 
/// CSV file.
/// </summary>
/// <remarks>This method retrieves metadata about entity attributes, including 
/// security-related properties, and writes the information to a CSV file. The output 
/// file contains details such as whether columns are secured, can be secured for 
/// create, update, or read operations, and other relevant metadata.</remarks>
/// <param name="service">The <see cref="IOrganizationService"/> instance used to 
/// retrieve metadata from the organization.</param>
/// <param name="filepath">The directory path where the CSV file will be saved. This 
/// must be a valid, writable directory.</param>
/// <param name="filename">The name of the CSV file to create. Defaults to 
/// "ColumnSecurityInfo.csv" if not specified.</param>
static internal void DumpColumnSecurityInfo(IOrganizationService service,
 string filepath, string filename = "ColumnSecurityInfo.csv")
{
 EntityQueryExpression query = new()
 {
 Properties = new MetadataPropertiesExpression("SchemaName", "Attributes"),
 Criteria = new MetadataFilterExpression
 {
 FilterOperator = LogicalOperator.And,
 Conditions =
 {
 new MetadataConditionExpression(
 "IsPrivate",
 MetadataConditionOperator.Equals,
 false),
 }
 },
 AttributeQuery = new()
 {
 Properties = new MetadataPropertiesExpression(
 "SchemaName",
 "AttributeTypeName",
 "IsPrimaryName",
 "IsSecured",
 "CanBeSecuredForCreate",
 "CanBeSecuredForUpdate",
 "CanBeSecuredForRead"),
 Criteria = new MetadataFilterExpression()
 {
 Conditions = {
 { // Exclude Virtual columns
 new MetadataConditionExpression(
 "AttributeTypeName",
 MetadataConditionOperator.NotEquals,
 AttributeTypeDisplayName.VirtualType)
 }
 }
 }
 }
 };

 RetrieveMetadataChangesRequest request = new()
 {
 Query = query
 };

 var response = (RetrieveMetadataChangesResponse)service.Execute(request);


 // Create a StringBuilder to hold the CSV data
 StringBuilder csvContent = new();

 string[] columns = {
 "Column",
 "Type",
 "IsPrimaryName",
 "IsSecured",
 "CanBeSecuredForCreate",
 "CanBeSecuredForUpdate",
 "CanBeSecuredForRead" };

 // Add headers
 csvContent.AppendLine(string.Join(",", columns));

 foreach (var table in response.EntityMetadata)
 {
 foreach (AttributeMetadata column in table.Attributes)
 {
 string[] values = {
 $"{table.SchemaName}.{column.SchemaName}",
 column.AttributeTypeName.Value,
 column.IsPrimaryName?.ToString() ?? "False",
 column.IsSecured?.ToString() ?? "False",
 column.CanBeSecuredForCreate?.ToString() ?? "False",
 column.CanBeSecuredForUpdate.ToString() ?? "False",
 column.CanBeSecuredForRead.ToString() ?? "False"
 };

 // Add values
 csvContent.AppendLine(string.Join(",", values));
 }
 }

 File.WriteAllText(
 Path.Combine(filepath, filename),
 csvContent.ToString());
}

This example is part of Sample: Column-level security using Dataverse SDK for .NET.