Implementation of Equals and GetHashCode for base class

//TKey = Type of the Key
//Key of the object, which determine it's uniqueness

If you're going to use comments like these, it's useful to use XML documentation comments instead, so that you can see them in IntelliSense.

Also, you should try to keep your comments grammatically correct, though I understand that's not always easy, especially if you're not a native speaker.

public Entity()
{
    FullClassName = GetType().FullName + "#";
    KeyIsNullable = typeof(TKey).IsAssignableFrom(typeof(Nullable));
    BaseClassType = typeof(Entity<TKey>);
    KeyIsComplex = !typeof(TKey).IsPrimitive;
}

I think it doesn't make much sense to store these in each instance. If your profiling shows that retrieving these values on each call slows down your code, store at least the last three values in static fields (you could initialize them from a static constructor).

Also, KeyIsNullable will be always false, because Nullable is a static class that's distinct from Nullable<T>. (But it doesn't matter anyway, see below.)

bool result = BaseClassType.IsAssignableFrom(obj.GetType());

According to ReSharper, you could instead use BaseClassType.IsInstanceOfType(obj). (I had no idea such method existed.)

But this check means that for example two different types deriving from Entity<int> with the same key will compare as equal. I don't think that's what you want, you should compare the type against GetType() and you should make sure that the types are exactly equal. This is especially true since in such case, the two objects will compare as equal, but will have different hash codes, which makes your code wrong.

Also, your code will throw an exception when obj is null, you should add a check against that.

result
    = result
        && ( …

This monstrous expression doesn't make much sense to me (and that's not just because it's hard to understand). For nullable value types, Equals() works fine, you don't need all this gymnastics.

if ((KeyIsNullable&& Key == null) || (!KeyIsNullable&& Key .Equals(default(TKey))))
{
    return base.GetHashCode();
}

This code indicates that if the Key has its default value, you want to use reference equality. But there is no indication of that in your Equals(). You have to decide what exactly does equal mean for your type and keep that definition consistent across Equals() and GetHashCode().

Also, again, you don't need special code for nullable value types.

string stringRepresentation = FullClassName + ((KeyIsComplex)? Key.GetHashCode().ToString() : Key.ToString());
return stringRepresentation.GetHashCode();

I haven't seen hash code include the type before. It could make sense if you're using hash-based collections that can contain different types with the same key values, though doing that is not very common, I think.

Though if you want to do that, I would use the hash code of GetType() instead of dealing with type name.

Also, there is no reason to use strings here, simply combining the hash codes (e.g. using XOR) is enough.

With all these changes, your code will look like this:

/// <typeparam name="TKey">Type of the Key</typeparam>
public abstract class Entity<TKey>
{
    /// <summary>
    /// Key of the object, which determines its uniqueness
    /// </summary>
    public abstract TKey Key { get; }

    public override bool Equals(object obj)
    {
        if (obj == null)
            return false;

        if (obj.GetType() != GetType())
            return false;

        bool sameKey = Key.Equals(((Entity<TKey>)obj).Key);

        if (sameKey && Key.Equals(default(TKey)))
            return ReferenceEquals(this, obj);

        return sameKey;
    }

    public override int GetHashCode()
    {
        if (Key.Equals(default(TKey)))
            return base.GetHashCode();

        return GetType().GetHashCode() ^ Key.GetHashCode();
    }
}