Popularity
0.6
Declining
Activity
0.0
Declining
0
0
0

Programming language: C#
Tags: Misc     C     Enum     Enums    

FlexEnum alternatives and similar packages

Based on the "Misc" category.
Alternatively, view FlexEnum alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of FlexEnum or a related project?

Add another 'Misc' Package
Pixel-Perfect Multi-Platform Applications with C# and XAML
Sponsored platform.uno

Popular Comparisons

SaaSHub - Software Alternatives and Reviews
Sponsored www.saashub.com

README

FlexEnum

BaseEnum

public sealed class Month : BaseEnum<string>
{
  public static readonly Month September = new Month("Sept");
  public static readonly Month December = new Month("Dec");
  public static readonly Month October = new Month("Octob");
  public static readonly Month November = new Month("Novemb");

  private Month(string val) : base(val)
  {
  }
}

Assert.Equal(Month.September, Month.September);
Assert.NotEqual(Month.September, Month.October);
Assert.True(Month.September == Month.September);
Assert.True(Month.September != Month.October);
Assert.Equal("Sept", Month.September);

BaseFlagEnum

public sealed class Brace : BaseFlagEnum<string>
{
  public static readonly Brace Start = new Brace(1, "{");
  public static readonly Brace End = new Brace(2, "}");
  public static readonly Brace StartEnd = new Brace(Start | End, "{}");
  public static readonly Brace None = new Brace(int.MinValue, string.Empty);

  private Brace(int i, string val) : base(i, val)
  {
  }
}

Assert.Equal(Brace.Start, Brace.Start);
Assert.NotEqual(Brace.Start, Brace.End);
Assert.True(Brace.Start == Brace.Start);
Assert.True(Brace.Start != Brace.End);
Assert.Equal("[1, {]", Brace.Start);
Assert.True(((Brace.Start | Brace.End) & Brace.End) == Brace.End);
Assert.True(Brace.StartEnd.HasFlag(Brace.End));
Assert.False(Brace.StartEnd.HasFlag(Brace.None));

FlexEnum

IsDefune
Assert.Equal(false, Util.FlexEnum.IsDefined<Brace>(null));
Assert.Equal(true, Util.FlexEnum.IsDefined<Brace>(Brace.Start));

var ctor = typeof(Month).GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new []{typeof(string)}, null);
var anotherObj = (Month)ctor.Invoke(new []{"NOT ENUM VALUE"});
Assert.Equal(false, Util.FlexEnum.IsDefined<Brace>(anotherObj));
TryParseTest
Brace parseVal;
Assert.Equal(false, Util.FlexEnum.TryParse("NOTCONTAIN", out parseVal));
Assert.Equal(true, Util.FlexEnum.TryParse("[1, {]", out parseVal));
ParseTest
Assert.Equal(null, Util.FlexEnum.Parse<Brace>("NOTCONTAIN"));
Assert.Equal(Brace.Start, Util.FlexEnum.Parse<Brace>("[1, {]"));

Flag auto generate value

public sealed class StepGenerator1 : BaseFlagEnum<string>
{
  public static StepGenerator1 Step1;
  public static StepGenerator1 Step2;
  public static StepGenerator1 Step3;

  static StepGenerator1()
  {
    StartValue = 5;

    Step1 = new StepGenerator1(string.Empty);
    Step2 = new StepGenerator1(string.Empty);
    Step3 = new StepGenerator1(string.Empty);
  }

  private StepGenerator1(string val2) : base(val2)
  {
  }
}

Assert.Equal(5, StepGenerator1.Step1.Value);
Assert.Equal(6, StepGenerator1.Step2.Value);
Assert.Equal(7, StepGenerator1.Step3.Value);

Flag value generator value

public sealed class StepGenerator2 : BaseFlagEnum<string>
{
  public static StepGenerator2 Step1;
  public static StepGenerator2 Step2;
  public static StepGenerator2 Step3;

  static StepGenerator2()
  {
    StartValue = 0;
    var gen = new Generator();
    Step1 = new StepGenerator2(string.Empty, gen);
    Step2 = new StepGenerator2(string.Empty, gen);
    Step3 = new StepGenerator2(string.Empty, gen);
  }

  private StepGenerator2(string val2, IEnumStepGenerator enumStepGenerator) 
    : base(val2, enumStepGenerator)
  {
  }

  private sealed class Generator : IEnumStepGenerator
  {
    public int NextStep(int curVal)
    {
      return 1 << curVal;
    }
  }
}
}

Assert.Equal(1, StepGenerator2.Step1.Value);
Assert.Equal(2, StepGenerator2.Step2.Value);
Assert.Equal(4, StepGenerator2.Step3.Value);