I have generic method that accepts "T" type and this is enumerator. Inside the method I have to call helper class methods and method name depands on type of enumerator.
public Meth<T> (T type) { if (typeof(T) == typeof(FirstEnumType)) { FirstEnumType t = ??? // I somehow need to convert T type to FirstEnumType this.helperFirstCalcBll(t); } else { SecondEnumType t = ??? // I somehow need to convert T type to SecondEnumType this.helperSecondCalcBll(t); } } There is no valid cast from an arbitrary type to an enum type so this is not allowed. You need to cast to object first:
FirstEnumType t = (FirstEnumType)(object)type; This "tricks" the compiler by upcasting to object (which is always valid) then down-casts to the enum type. Assuming you have done a runtime type check, the downcast will never fail. However implementing this in the else branch, as given, isn't guaranteed to work.
One would question why the method is even generic in the first place but that is how you can make this particular method work.
int instead of object IMO.
public void Meth<T>() where T:enum.public void Meth(FirstEnumType type) { this.helperFirstCalcBll(type); } public void Meth(SecondEnumType type) { this.helperSecondCalcBll(type); } 
This is something dynamic is very useful for:
public void Meth<T>(T enumValue) where T : struct { InternalMeth((dynamic)enumValue); } private void InternalMeth(FirstEnumType enumValue) { this.helperFirstCalcBll(enumValue); } private void InternalMeth(SecondEnumType enumValue) { this.helperSecondCalcBll(enumValue); } private void InternalMeth(object enumValue) { // Do whatever fallback you need } This avoids having to write all those if (typeof(T) == typeof(...)) and everything - you let the dynamic dispatch handle picking the best overload at runtime. The object overload is there if all the others fail, so that you can e.g. throw an exception.
Try defining a helper method:
private TOutput Convert<TInput, TOutput>(TInput value) where TInput : struct where TOutput : struct { var matchingValues = Enum.GetValues(typeof(TOutput)) .Cast<int>() .Where(v => System.Convert.ToInt32(value) == v); if(!matchingValues.Any()) { var message = String.Format("No matching value found in enum '{0}' for value '{1}'.", typeof(TOutput).Name, value); throw new ArgumentException(message); } var obj = (object)matchingValues.Single(); return (TOutput)obj; } This would convert values of two enums given that there is a value in the output enum that equals the input value.
And in your code you would call it as follows:
public Meth<T> (T type) { if (typeof(T) == typeof(FirstEnumType)) { FirstEnumType t = Convert(type); this.helperFirstCalcBll(t); } else { SecondEnumType t = Convert(type); this.helperSecondCalcBll(t); } } 
public Meth, not even once.