How to get unused data in C#

Then you have a list of names of days, filled with only 3 names and need all the other days

First of all, You are trying to compare string values to WeekDays values, where the strings are supposed to be names of the WeekDays values.

List<string> days = new List<string>();
days.Add(WeekDays.Sunday.ToString());
days.Add(WeekDays.Monday.ToString());
days.Add(WeekDays.Wednesday.ToString());

You cannot compare them without a conversion. The conversion can be either direction, depending on reuse chances.
- You can gather the names of all WeekDays values, using Enum.GetNames, in case storing in a temporary variable or in a static field to avoid repeating the operation.
- You can convert names of days list to WeekDays values, using Enum.Parse or Enum.tryParse, and store in a temporary variable; in this case, remember that Enum.Parse will throw on unrecognized/bad names.
In both cases you can use System.Linq.Enumerable.Except extension method.

Get all missing names as array, then convert them to values:

var missingNames = Enum.GetNames(typeof(WeekDays)).Except(days).ToArray();
var missingValues = Array.ConvertAll(missingNames, value => (WeekDays)Enum.Parse(typeof(WeekDays), value, true));

Converts used names to values as enumerable sequence, then get all missing values as array:

var daysValues = days.Select(value => (WeekDays)Enum.Parse(typeof(WeekDays), value, true));
var missingValues = ((WeekDays[])Enum.GetValues(typeof(WeekDays))).Except(daysValues).ToArray();

These are the most compact solutions, but I would break them into their composing steps, both for readability and maintenability purposes.
I suggest you to look into online help contents and local documentation for all the methods (Enum.Parse, Enum.TryParse, Enum.GetNames, Enum.GetValues, Array.ConvertAll, Enumerable.Select, Enumerable.Except, Enumerable.ToArray).
Keep in mind that these solutions produce array results, that are best suited in case you will perform several operations on them, and to debug them; if you will iterate only once, than at least the last ToArray invocation is not needed.

For Except method to work, you have to add using System.Linq; on top of the source file.

If you are working with Enums a lot, you can use Extension Methods to hide complexity, and to develop and test separately from your main app code.

The two methods shown here extend either a string, or a Type; this is how they are called:

WeekDays monday = "Monday".ToEnum<WeekDays>();

WeekDays friday = typeof(WeekDays).ToEnum<WeekDays>("friday");

Once you have these "atomic methods," it is trivial to add other extensions that perform operations on collections using Linq.

imho, you do pay a price for either one: the first example extends string; I think extending basic types is generally a mistake. In the second example, you pay a price for the rather awkward structure of the calling format.

public static class EnumExtensions
{
    // string => Enum value
    public static TEnum ToEnum<TEnum>(this string str)
    where TEnum : struct, IConvertible
    {
        Type tenum = typeof(TEnum);

        if (! tenum.IsEnum)
            throw new ArgumentException("TEnum must be an Enum type");

        if (!Enum.IsDefined(tenum, str))
        {
            throw new ArgumentException($"{str} is not a valid string for conversion to {tenum.FullName}");
        }

        return (TEnum)Enum.Parse(tenum, str);
    }

    // Enum Type, string, optional bool => Enum value
    public static TEnum ToEnum<TEnum>(this Type tenum, string str, bool ignorecase = false)
        where TEnum : struct, IConvertible
    {
        if (! tenum.IsEnum)
            throw new ArgumentException("TEnum must be an Enum type");

        TEnum result;

        // note ignore case parameter
        if (Enum.TryParse<TEnum>(str, ignorecase, out result))
        {
            return result;
        }

        throw new ArgumentException($"{str} is not a valid string for conversion to {tenum.FullName}");
    }
}