1:
2:

var bsp = Beispiel.C | Beispiel.B;
var notIncluded = Enum.GetValues(typeof(Beispiel)).Cast<Beispiel>().Where(b => (b & bsp) == 0)					

1:

Enum.GetValues(typeof(Beispiel)).Cast<int>().Where(b => (b & (int)bsp) == 0)					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

[Flags]
enum Beispiel
{
    None = 0,
    A = 1, 
    B = 2, 
    C = 4, 
    D = 8,
    All = A | B | C | D
}

var bsp = Beispiel.C | Beispiel.B;
var notIncluded = Beispiel.All & ~bsp;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

var bsp = Beispiel.C | Beispiel.B;
var notIncluded2 = Beispiel.All.Without(bsp);

public static class EnumExtensions
{
    public static T Without<T>(this Enum value, T without) where T : struct, IComparable, IFormattable, IConvertible  // genauest mögliche Enum Einschränkung
    {
        if (!typeof(T).IsEnum)
            throw new ArgumentException($"{nameof(T)} is not an enum type.");
        if (!(value is T))
            throw new ArgumentException($"{nameof(value)} is not of type {nameof(T)}");

        return (T)ConvertToUnderlyingType(typeof(T), Convert.ToInt64(value) & ~Convert.ToInt64(without));
    }

    private static object ConvertToUnderlyingType(Type enumType, long value)
    {
        // Drecks Typesystem!!
        switch (Type.GetTypeCode(enumType.GetEnumUnderlyingType()))
        {
            case TypeCode.Byte:
                return Convert.ToByte(value);
            case TypeCode.SByte:
                return Convert.ToSByte(value);
            case TypeCode.UInt16:
                return Convert.ToUInt16(value);
            case TypeCode.Int16:
                return Convert.ToInt16(value);
            case TypeCode.UInt32:
                return Convert.ToUInt32(value);
            case TypeCode.Int32:
                return Convert.ToInt32(value);
            case TypeCode.UInt64:
                return Convert.ToUInt64(value);
            case TypeCode.Int64:
                return Convert.ToInt64(value);
            case TypeCode.Object:
            default:
                throw new InvalidOperationException($"Unknown underlying type of enum {enumType.FullName}");
        }
    }
}