Agfdhyk

I have the following collection navigation property on my entity:

public virtual ICollection<OrderIntegrationLogEntry> LogEntries { get; set; }

And the OrderIntegrationLogEntry entity has a little configuration:

this.HasKey(i => new {i.Id, i.IntegrationId});

this.HasRequired(i => i.Integration).WithMany(i => i.LogEntries).HasForeignKey(i => i.IntegrationId).WillCascadeOnDelete(true);

It seems that this line of code:

integration.LogEntries.Add(new OrderIntegrationLogEntry

{

    Id = Guid.NewGuid(),

    CreatedUtc = DateTime.UtcNow,

    Message = message,

    Level = level,

    Detail = detail

});

...results in a query which loads the contents of the collection:

SELECT [Extent1].[Id] AS [Id], [Extent1].[IntegrationId] AS [IntegrationId],

[Extent1].[CreatedUtc] AS [CreatedUtc], [Extent1].[Level] AS [Level],

[Extent1].[Message] AS [Message], [Extent1].[Detail] AS [Detail]

FROM [dbo].[OrderIntegrationLogEntries] AS [Extent1]

WHERE [Extent1].[IntegrationId] = @EntityKeyValue1

I wasn't expecting this: shouldn't it just stage an add? Do I need to configure in some other way?

As noted by Ivan you've called the LogEntries getter, which causes Lazy Loading.

If you don't want to turn off Lazy Loading, then instead of adding the log entity to the navigation property of the parent, just set the IntegrationId of the new entitiy and SaveChanges(). eg

var entry = new OrderIntegrationLogEntry()

{

    Id = Guid.NewGuid(),

    IntegrationId = integration.Id,

    CreatedUtc = DateTime.UtcNow,

    Message = message,

    Level = level,

    Detail = detail

);

db.OrderIntegrationLogEntries.Add(entry);

db.SaveChanges();

Also if this is SQL Server (and probably other platforms too) use sequential GUID generation. Inserting a row with a random guid as its leading key column is needlessly expensive. For SQL Server you can generate sequential GUIDs in the database with the NEWSEQUENTIALID() function as a default, or on the client

  public class SQLGuidUtil

  {

      [DllImport("rpcrt4.dll", SetLastError = true)]

      static extern int UuidCreateSequential(out Guid guid);



      public static Guid NewSequentialId()

      {

        Guid guid;

        UuidCreateSequential(out guid);

        var s = guid.ToByteArray();

        var t = new byte[16];

        t[3] = s[0];

        t[2] = s[1];

        t[1] = s[2];

        t[0] = s[3];

        t[5] = s[4];

        t[4] = s[5];

        t[7] = s[6];

        t[6] = s[7];

        t[8] = s[8];

        t[9] = s[9];

        t[10] = s[10];

        t[11] = s[11];

        t[12] = s[12];

        t[13] = s[13];

        t[14] = s[14];

        t[15] = s[15];

        return new Guid(t);

      }

  }

How to Generate Sequential GUIDs for SQL Server in .NET

You should also consider flipping the order of your key columns if you expect the log entries to be accessed primarily on an Integration-by-Integration basis. That will store the log entries for an Integration together. EG

this.HasKey(i => new {i.IntegrationId, i.Id});

If you're not on Windows you can roll your own sequential GUID generator by starting from a random GUID and incrementing the 4 low-order bytes. The GUIDs would be sequential only within an AppDomain, but that shouldn't matter much.

Something like this:

namespace NewSequentialId

{

    public class SQLGuidUtil

    {

        static object synclock = new object();

        static uint seq = 0;

        static byte seed = Guid.NewGuid().ToByteArray();

        public static Guid NewSequentialId()

        {

            uint nextVal;

            byte buf;



            lock (synclock)

            {

                nextVal = seq++;

                buf = (byte)seed.Clone();



                if (nextVal == 0xFFFFFFFF)

                {

                    seed = Guid.NewGuid().ToByteArray();

                    seq = 0;

                }

            }



            var seqbytes = BitConverter.GetBytes(nextVal);



            if (BitConverter.IsLittleEndian)

            {

                buf[0] = seqbytes[3];

                buf[1] = seqbytes[2];

                buf[2] = seqbytes[1];

                buf[3] = seqbytes[0];

            }

            else

            {

                buf[0] = seqbytes[0];

                buf[1] = seqbytes[1];

                buf[2] = seqbytes[2];

                buf[3] = seqbytes[3];

            }



            return new Guid(buf);

        }

    }

}

In order to enable lazy loading, EF creates proxy-classes derived from your model. In these classes it overrides the navigation properties to implement lazy loading. This is why your navigation properties should be defined virtual so EF can override them.

When you call integration.LogEntries.Add, the getter of your LogEntries property is being called which triggers lazy loading operation.

You can temporarily disable lazy loading using the following code:

context.Configuration.LazyLoadingEnabled = false;