Question

I’m using linq2sql against an old database system. In this system there are three tables, Invoices, Users, and SignupUsers. The Invoices table has a UID field that usually references the UID key on the Users table. BUT, it also has a IsSignup bit field that indicates the UID field should reference the UID key on the SignupUsers table.

I don’t really care about the relationship with the SignupUsers table, but we do have a problem where it is very easy to forget to check the “IsSignup” value when using the linq2sql entities. I’d like to make the Invoices->Users relationship in the entities conditional upon the IsSignup bit field.

I’ve tried a couple of approaches. First I tried setting up OnLoaded:

public partial class Invoice
{
    partial void OnLoaded()
    {
        if (IsSignup)
        {
            InvoiceUser = null;
        }
    }
}

This fails because it tries to actually set the UID field to null when it saves the invoice back– which we cannot do.

I poked around with DataLoadOptions, but couldn’t find a way to make that work either.

I could just change the InvoiceUsers property getter, but then it’d get overwritten every time the dbml gets changed.

Am I just out of luck here?

Answer 1

I’ll put in my solution here, but still hope someone can come up with something better.

I’m using LINQ to SQL templates for T4 to generate the code. I went into the .tt file for this particular .dbml file and found the portion that generates the properties for the relationships. I then hacked in an “if” statement that modified the property if it applied to this particular relationship:

    <#=code.Format(association.MemberAttributes)#><#=association.Type.Name#> <#=association.Member#>
    {
        get {
            <#if(association.Name == "InvoiceUser_Invoice"){#>
                            //HACK IN THE .TT FILE TO ALWAYS INCLUDE THIS CONDITIONAL RELATIONSHIP
            if(IsSignup){return null;}
            <#}#>
            <#if (needsSerializationFlag && serialization) {#>
            if (serializing && !<#=association.Storage#>.HasLoadedOrAssignedValue) {
                return null;
            }
            <#}#>
            return <#=association.Storage#>.Entity;
        }

This makes the generated code for that particular property come out as desired:

    [Association(Name=@"InvoiceUser_Invoice", Storage=@"_InvoiceUser", ThisKey=@"UID", OtherKey=@"UID", IsForeignKey=true)]
    public InvoiceUser InvoiceUser
    {
        get {
            //HACK IN THE .TT FILE TO ALWAYS INCLUDE THIS CONDITIONAL RELATIONSHIP
                            if(IsSignup){return null;}
                            return _InvoiceUser.Entity;
        }
        set {
            InvoiceUser previousValue = _InvoiceUser.Entity;
            if ((previousValue != value) || (!_InvoiceUser.HasLoadedOrAssignedValue)) {
                SendPropertyChanging();
                if (previousValue != null) {
                    _InvoiceUser.Entity = null;
                    previousValue.Invoices.Remove(this);
                }
                _InvoiceUser.Entity = value;
                if (value != null) {
                    value.Invoices.Add(this);
                    _UID = value.UID;
                }
                else {
                    _UID = default(int);
                }
                SendPropertyChanged("InvoiceUser");
            }
        }
    }

So still a nasty hack, but it at least prevents changes to the .dbml file from removing the needed conditional relationship.