c# - por - ¿Algún truco para definir una enumeración como banderas/potencias de 2 sin que finalmente necesite una calculadora?

concepto de bandera en c

Question

Sé que puedo multiplicar pero siendo la programación perezosa que soy, no quiero.

¿Alguien ha ideado un poco de hechicería para numerar automáticamente las enumeraciones como potencias de dos?

Aquí está el ejemplo que tengo solo para hacerlo concreto:

[Flags]
private enum Targets : uint
{
None = 0,
Campaigns = 1,
CampaignGroups = 2,
Advertisers = 4,
AdvertiserGroups = 8,
AffiliateGroups = 16,
Affiliates = 32,
Creatives = 64,
DetailedLeads = 128,
DetailedSales = 256,
ProgramLeads = 512,
CreativeDeployments = 1024,
CampaignCategories = 2048,
Payouts = 4096,
All = uint.MaxValue
}

Answer 1

Aquí hay otro enfoque alternativo:

[Flags]
public enum COURSECOMPONENT_T : int
{
Everything = -1,
Nothing = 0,
AttendanceRegisters = 1,
Checklists = 2 * AttendanceRegisters,
Competencies = 2 * Checklists,
Content = 2 * Competencies,
CourseFiles = 2 * Content,
Discussions = 2 * CourseFiles,
DisplaySettings = 2 * Discussions,
Dropbox = 2 * DisplaySettings,
Faq = 2 * Dropbox,
Forms = 2 * Faq,
Glossary = 2 * Forms,
Grades = 2 * Glossary,
GradesSettings = 2 * Grades,
Groups = 2 * GradesSettings,
Homepages = 2 * Groups,
IntelligentAgents = 2 * Homepages,
Links = 2 * IntelligentAgents,
LtiLink = 2 * Links,
LtiTP = 2 * LtiLink,
Navbars = 2 * LtiTP,
News = 2 * Navbars,
QuestionLibrary = 2 * News,
Quizzes = 2 * QuestionLibrary,
ReleaseConditions = 2 * Quizzes,
Rubrics = 2 * ReleaseConditions,
Schedule = 2 * Rubrics,
SelfAssessments = 2 * Schedule,
Surveys = 2 * SelfAssessments,
ToolNames = 2 * Surveys,
Widgets = 2 * ToolNames,
}

Answer 2

Avancemos cinco años en el futuro y, a partir de C # 7.0, puede utilizar el nuevo literal binario numérico para simplificar la declaración de indicadores de enumeración.

[Flags]
private enum Targets : uint
{
None = 0,
Campaigns = 0b0000_0000_0000_0001,
CampaignGroups = 0b0000_0000_0000_0010,
Advertisers = 0b0000_0000_0000_0100,
AdvertiserGroups = 0b0000_0000_0000_1000,
AffiliateGroups = 0b0000_0000_0001_0000,
Affiliates = 0b0000_0000_0010_0000,
Creatives = 0b0000_0000_0100_0000,
DetailedLeads = 0b0000_0000_1000_0000,
DetailedSales = 0b0000_0001_0000_0000,
ProgramLeads = 0b0000_0010_0000_0000,
CreativeDeployments = 0b0000_0100_0000_0000,
CampaignCategories = 0b0000_1000_0000_0000,
Payouts = 0b0001_0000_0000_0000,
All = uint.MaxValue
}

https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7#numeric-literal-syntax-improvements

Answer 3

Escribe los valores como bits desplazados y deja que el compilador haga los cálculos:

[Flags]
private enum Targets : uint
{
None = 0,
Campaigns = 1,
CampaignGroups = 2 << 0,
Advertisers = 2 << 1,
AdvertiserGroups = 2 << 2,
AffiliateGroups = 2 << 3,
Affiliates = 2 << 4,
Creatives = 2 << 5,
DetailedLeads = 2 << 6,
DetailedSales = 2 << 7,
ProgramLeads = 2 << 8,
CreativeDeployments = 2 << 9,
CampaignCategories = 2 << 10,
Payouts = 2 << 11,
// etc.
}

La sugerencia de James también es buena. De hecho me gusta así aún mejor. También podrías escribirlo así:

[Flags]
private enum Targets : uint
{
None = 0,
Campaigns = 1 << 0,
CampaignGroups = 1 << 1,
Advertisers = 1 << 2,
AdvertiserGroups = 1 << 3,
AffiliateGroups = 1 << 4,
// etc.
}

Answer 4

Usar la notación hexadecimal es un poco más simple que la notación decimal (no se requiere calculadora):

[Flags]
private enum Targets : uint
{
None = 0,
Campaigns = 0x01,
CampaignGroups = 0x02,
Advertisers = 0x04,
AdvertiserGroups = 0x08,
AffiliateGroups = 0x10,
Affiliates = 0x20,
Creatives = 0x40,
DetailedLeads = 0x80,
DetailedSales = 0x100,
ProgramLeads = 0x200,
CreativeDeployments = 0x400,
CampaignCategories = 0x800,
Payouts = 0x1000,
// and the pattern of doubling continues
// 0x2000
// 0x4000
// 0x8000
// 0x10000
}

No es tan elegante como las soluciones de Cody y James, pero no requiere calculadora.