Question

my issue is that I have an attribute as ‘attribute’ coming in from entity framework.
So I retrieve this object which has a list of attribute tags, they are accessible via attribute.AttributeTags. Now I have a asp:TextBox where users can edit, remove and add new tags (comma separated). (On page load I am adding the attribute tags to this TextBox)

After a postback on the page I am returning the user input and splitting it into an array of strings and storing it in a variable called AttributeTags.

Now, I would like to add new tags that are not contained in the original attributes list coming from EF and would like to remove the ones that are contained in attributes but not found in the user input string array AttributeTags.

I am doing something like this:

        BusinessObjects.Attribute attribute = db.Attributes.FirstOrDefault(a => a.attribute_id == AttributeID);
        string[] AttributeTags = txtAttributeTags.Text.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
        foreach (var item in AttributeTags)
        {
            if (!attribute.AttributeTags.Any(t => t.value == item))
            {
                AttributeTag tag = new AttributeTag { value = item, timestamp = DateTime.Now };
                attribute.AttributeTags.Add(tag);
            }
            else
            {
                AttributeTag tag = attribute.AttributeTags.FirstOrDefault(t => t.value == item);
            }
        }

But I’m sort of stuck here since i’m fairly new to LINQ and EF.

Answer 1

I have two solution of this situations.

---

First Solution

We can create an ExcepWith method that will allow us to remove all the items in a ICollection<T> that are already in give a IEnumerable<T>. The code for such method follows:

public static int ExceptWith<TItem>
(
    this ICollection<TItem> collection,
    IEnumerable<TItem> other
)
{
    if (ReferenceEquals(collection, null))
    {
        throw new ArgumentNullException("collection");
    }
    else if (ReferenceEquals(other, null))
    {
        throw new ArgumentNullException("other");
    }
    else
    {
        int count = 0;
        foreach (var item in other)
        {
            while (collection.Remove(item))
            {
                count++;
            }
        }
        return count;
    }
}

Now you have an string[] with the input of the user, that array is an IEnumerable<string> but not an an ICollection<string>… that is easily solved as follows:

Instead of this:

string[] AttributeTags =
    txtAttributeTags.Text.Split
    (
        new string[] { "," },
        StringSplitOptions.RemoveEmptyEntries
    );

You do this:

var AttributeTags =
    new List<string>
    (
        txtAttributeTags.Text.Split
        (
            new string[] { "," },
            StringSplitOptions.RemoveEmptyEntries
        )
    );

Or even this:

var AttributeTags =
    txtAttributeTags.Text.Split
    (
        new string[] { "," },
        StringSplitOptions.RemoveEmptyEntries
    ).ToList();

Now you can do this:

AttriuteTags.ExceptWith(existingTags);

Since the type of attribute.AttributeTag is not IEnumerable<string> you use Select:

AttriuteTags.ExceptWith(attribute.AttributeTag.Select(item => item.value));

And that leaves only the new tags in the list.

---

Note: this method depends on the implementation of Remove, if you need to do an special comparison, then you are out of luck with this method.

---

Second Solution

There is another way. You can use the Except from the Enumerable class.

string[] AttributeTags =
    txtAttributeTags.Text.Split
    (
        new string[] { "," },
        StringSplitOptions.RemoveEmptyEntries
    );
var newTags = AttributeTags.Except(existingTags);

Since the type of attribute.AttributeTag is not IEnumerable<string> you use Select:

string[] AttributeTags =
    txtAttributeTags.Text.Split
    (
        new string[] { "," },
        StringSplitOptions.RemoveEmptyEntries
    );
var newTags = AttributeTags.Except
(
    attribute.AttributeTag.Select(item => item.value)
);

And that puts in newTags, well, the new tags.

---

Note: If you need to do an special comparison, then you should use the other overload of the method:

string[] AttributeTags =
    txtAttributeTags.Text.Split
    (
        new string[] { "," },
        StringSplitOptions.RemoveEmptyEntries
    );
var newTags = AttributeTags.Except(attribute.AttributeTag, equalityComparer);

Sadly the equalityComparer is an object of a class that implements IEqualityComparer, meaning that you can’t use lambdas there. For that you can add this class:

public class CustomEqualityComparer<T> : IEqualityComparer<T>
{
    private Func<T, T, bool> _comparison;
    private Func<T, int> _getHashCode;

    public CustomEqualityComparer
    (
        Func<T, T, bool> comparison,
        Func<T, int> getHashCode
    )
    {
        if (ReferenceEquals(comparison, null))
        {
            throw new ArgumentNullException("comparison");
        }
        else if (ReferenceEquals(getHashCode, null))
        {
            throw new ArgumentNullException("getHashCode");
        }
        else
        {
           _comparison = comparison;
           _getHashCode = getHashCode;
        }
    }

    public bool Equals(T x, T y)
    {
        return _comparison.Invoke(x, y);
    }

    public int GetHashCode(T obj)
    {
        return _getHashCode.Invoke(obj);
    }
}

And now invoke like this (for example):

string[] AttributeTags =
    txtAttributeTags.Text.Split
    (
        new string[] { "," },
        StringSplitOptions.RemoveEmptyEntries
    );
var newTags = AttributeTags.Except
(
    existingTags,
    new CustomEqualityComparer<string>
    (
        (a, b) => 1, //your custom comparison here
        str => str.GetHashCode()
    )
);

Since the type of attribute.AttributeTag is not IEnumerable<string> you use Select:

string[] AttributeTags =
    txtAttributeTags.Text.Split
    (
        new string[] { "," },
        StringSplitOptions.RemoveEmptyEntries
    );
var newTags = AttributeTags.Except
(
    attribute.AttributeTag.Select(item => item.value),
    new CustomEqualityComparer<string>
    (
        (a, b) => 1, //your custom comparison here
        str => str.GetHashCode()
    )
);

---

Adding the new tags

Now that you have the new tags, let’s say in newTags, you can iterate it to add the new tags:

var now = DateTime.Now;
foreach (var item in newTags)
{
    AttributeTag tag = new AttributeTag { value = item, timestamp = now };
    attribute.AttributeTags.Add(tag);
}

---

Comparing the Solutions

What’s the difference of these methods?

• The first requires less memory
• The first requires to define a new method.
• The first doesn’t allow for a custom IEqualityComparer<T>
• The second allows for deferred execution.
• The second uses (not needed) a helper class.