diff --git a/ICD.Common.Utils.Tests/EnumUtilsTest.cs b/ICD.Common.Utils.Tests/EnumUtilsTest.cs
index f472f0e..1af78d2 100644
--- a/ICD.Common.Utils.Tests/EnumUtilsTest.cs
+++ b/ICD.Common.Utils.Tests/EnumUtilsTest.cs
@@ -7,7 +7,7 @@ namespace ICD.Common.Utils.Tests_NetStandard
 	[TestFixture]
     public sealed class EnumUtilsTest
     {
-		private enum eTestEnum
+		public enum eTestEnum
 		{
 			None = 0,
 			A = 1, 
@@ -16,7 +16,7 @@ namespace ICD.Common.Utils.Tests_NetStandard
 		}
 
 		[Flags]
-		private enum eTestFlagsEnum
+		public enum eTestFlagsEnum
 		{
 			None = 0,
 			A = 1,
@@ -208,11 +208,28 @@ namespace ICD.Common.Utils.Tests_NetStandard
 			Assert.IsTrue(EnumUtils.HasMultipleFlags(eTestFlagsEnum.A | eTestFlagsEnum.B));
 		}
 
-		#endregion
+        [TestCase(false, eTestFlagsEnum.None)]
+        [TestCase(true, eTestFlagsEnum.B)]
+        [TestCase(true, eTestFlagsEnum.B | eTestFlagsEnum.C)]
+        public void HasAnyFlagsTest(bool expected, eTestFlagsEnum value)
+        {
+            Assert.AreEqual(expected, value.HasAnyFlags());
+        }
 
-		#region Conversion
+        [TestCase(false, eTestFlagsEnum.None, eTestFlagsEnum.None)]
+        [TestCase(false, eTestFlagsEnum.None, eTestFlagsEnum.B)]
+        [TestCase(true, eTestFlagsEnum.B, eTestFlagsEnum.B)]
+        [TestCase(false, eTestFlagsEnum.None | eTestFlagsEnum.A, eTestFlagsEnum.B | eTestFlagsEnum.C)]
+        public void HasAnyFlagsValueTest(bool expected, eTestFlagsEnum value, eTestFlagsEnum other)
+        {
+            Assert.AreEqual(expected, value.HasAnyFlags(other));
+        }
 
-		[Test]
+        #endregion
+
+        #region Conversion
+
+        [Test]
 		public void ParseGenericTest()
 		{
 			Assert.AreEqual(eTestEnum.A, EnumUtils.Parse<eTestEnum>("A", false));
diff --git a/ICD.Common.Utils/EnumUtils.cs b/ICD.Common.Utils/EnumUtils.cs
index 23f43b6..f7f4703 100644
--- a/ICD.Common.Utils/EnumUtils.cs
+++ b/ICD.Common.Utils/EnumUtils.cs
@@ -342,18 +342,41 @@ namespace ICD.Common.Utils
 			return ((value & (value - 1)) != 0);
 		}
 
-		#endregion
+        /// <summary>
+        /// Returns true if this enum contains any flags.
+        /// </summary>
+        /// <param name=""></param>
+        /// <returns></returns>
+        [PublicAPI]
+        public static bool HasAnyFlags<T>(this T extends)
+        {
+            return GetFlagsExceptNone(extends).Any();
+        }
 
-		#region Conversion
+        /// <summary>
+        /// Returns true if this enum contains any of the given flag values.
+        /// </summary>
+        /// <param name="extends"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        [PublicAPI]
+        public static bool HasAnyFlags<T>(this T extends, T value)
+        {
+            return GetFlagsIntersection(extends, value).HasAnyFlags();
+        }
 
-		/// <summary>
-		/// Shorthand for parsing string to enum.
-		/// </summary>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="data"></param>
-		/// <param name="ignoreCase"></param>
-		/// <returns></returns>
-		public static T Parse<T>(string data, bool ignoreCase)
+        #endregion
+
+        #region Conversion
+
+        /// <summary>
+        /// Shorthand for parsing string to enum.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="data"></param>
+        /// <param name="ignoreCase"></param>
+        /// <returns></returns>
+        public static T Parse<T>(string data, bool ignoreCase)
 		{
 			if (!IsEnumType<T>())
 				throw new ArgumentException(string.Format("{0} is not an enum", typeof(T).Name));