Is it possible to call a method on a null object reference? Of course, not!
static void Main( string[] args )
{ Foo _foo = null; // will throw NullReferenceException Console.WriteLine( _foo.Bar() );
Console.ReadLine();
}
Oh, really?
Your goal is to provide all necessary auxiliary definitions and implementations so that the code above not only does not throw NullReferenceException but also writes “Hello world” at the console.
Suppose you are writing a class for a generic vector and you want to naively implement a method to add two vectors:
public class Vec<T>
{ public T x { get; set; } public T y { get; set; } public Vec() { } public Vec( T x, T y ) { this.x = x; this.y = y; }
public static Vec<T> Add( Vec<T> v1, Vec<T> v2 ) { return new Vec<T>( v1.x + v2.x, v1.y + v2.y );
}
}
This won’t work. The compiler is unable to interpret the “+” for type T so v1.x + v2.x cannot be compiled.
One of possible approaches could be to restrict possible Ts with a type constraint so that “+” can be replaced with a method of an interface implemented by T. Such approach, however, does not take you anywhere since you cannot impose an interface on an existing type and thus, Vec<int> or Vec<double> would still fail to compile.
Another common approach is to define an auxiliary interface:
public interface IAdder<T>
{ T Add( T t1, T t2 );
}
so that Vec::Add can be now implemented as:
public static Vec<T> Add( Vec<T> v1, Vec<T> v2, IAdder<T> Adder ) { return new Vec<T>( Adder.Add( v1.x, v2.x ), Adder.Add( v1.y, v2.y ) );
}
and used:
public class IntAdder : IAdder<int>
{ public int Add( int t1, int t2 )
{ return t1 + t2; }
}
class Program { static void Main( string[] args )
{ Vec<int> v1 = new Vec<int>( 4, 5 );
Vec<int> v2 = new Vec<int>( 6, 7 );
Vec<int> v3 = Vec<int>.Add( v1, v2, new IntAdder() );
Console.ReadLine();
}
}
While this works, there are obvious drawbacks – an extra implementation of the auxiliary interface has to be provided for any T you want to use your Vec class with. Also, the signature of the Add method is now rather clumsy.
Let’s then just start again:
public class Vec<T>
{ public T x { get; set; } public T y { get; set; } public Vec() { } public Vec( T x, T y ) { this.x = x; this.y = y; }
public static Vec<T> Add( Vec<T> v1, Vec<T> v2 )
{ // ??? }
}
A lack of support for LINQ’s Skip has been a huge drawback of the XPO implementation. I am glad to confirm that Skip is finally there. I test it with Microsoft SQL Server 2008 where Skip is evaluated using row_number. For example, a simple query:
new XPQuery<D_Grupa_Roli>( Global.Model ) .Where( o => o.Oid > 0 )
.OrderBy( o => o.Nazwa )
.Skip( 2 )
.Take( 3 )
.ToList()
.ForEach( rola => Console.WriteLine( rola.Nazwa ) );
is evaluated as
exec sp_executesql N'select resultSet.F0, resultSet.F1, resultSet.F2, resultSet.F3, resultSet.F4, resultSet.F5, resultSet.F6 from(select N0."OID" as F0, N0."ModifyDate" as F1, N0."ModifyUser" as F2, N0."ID_GLOBAL_DICT" as F3,
N0."Nazwa" as F4, N0."OptimisticLockField" as F5, N0."GCRecord" as F6,
row_number() over(order by N0."Nazwa" asc) as ''rowNumber''
from "dbo"."D_Grupa_Roli" N0
where (N0."GCRecord" is null and (N0."OID" > @p0))) resultSet
where resultSet.rowNumber > 2 and resultSet.rowNumber <= 2 + 3',N'@p0 int',@p0=0What’s interesting is that skipping throws an exception for an unordered query:
new XPQuery<D_Grupa_Roli>( Global.Model )
.Where( o => o.Oid > 0 ) //.OrderBy( o => o.Nazwa ) ordering is missing .Skip( 2 )
.Take( 3 )
.ToList()
.ForEach( rola => Console.WriteLine( rola.Nazwa ) );
If you think about it, that sounds reasonable as the row_number requires an explicit order.
How’s that possible then that Linq2Sql will not throw an exception for such query? Well, it seems that if the ordering is missing from the query tree, Linq2Sql will …………… .
I am sure the curious reader will find the answer on his/her own.
One of the interesting features of XPO is the Deferred Deletion. Basically, instead of physically removing rows from your database, XPO marks them as deleted. Not only this can speed up the deletion but also helps to avoid some subtle concurrency issues.
One of our critical applications uses XPO as the ORM engine. As rows are deleted from the database, I never run a Purge mechanism which is designed to physically remove rows marked as deleted. My intention is simple – because all rows are kept in my database, I can always track any changes made by an end user. Even when a row is deleted, I can always peek into the database and conclude “you see, it’s not that our application deletes your data, in fact it’s been Mr.X/Mrs.Y who deleted it” (I mark every single row with the name of the last user who modifies the record).
There’s unfortunately an inconvenient issue with Deferred Deletion. Suppose you have a class (the class code has been simplified):
public class Person {
public int Oid { get; set; } // primary key
public string Name { get; set; }
public int ID_CITY { get; set; } // foreign key
}
What does it mean?
Well, suppose you have a row in your database (NULL, 1, ‘The name’, 1) : (GCRecord, Oid, Name, ID_CITY). When XPO “deletes” it, the row becomes (11442123, 1, ‘The name’, NULL). The GCRecord column marks the row as deleted (with a random not null value) but in the same time the reference to the parent row is cleared.
How that’s possible – you ask – if the ID_CITY has the int type? Well, it does not matter whether you have int or int? in your model, XPO will always create a reference column as INT NULL (sic!).
Ok. So far, so good. Since Deferred Deletion is not designed to restore rows, it may not matter that the record has been altered in a way that it becomes an orphan (parent reference is gone!).
But now, you have a problem if you ever try to access such deleted record (and XPO allows that!) – your model insists that the ID_CITY has an int type, while the database holds a NULL value. XPO is then unable to create an instance of your business class.
Possible solutions?
First solution could be to alter your business classes so that all reference fields would always be of type int?. This does not seem acceptable, since it’s you to decide wheter a reference is required (int) or can be empty (int?) and XPO should not force you to stick with the only possibility.
Second, which works for me is to change the way you handle such reference properties in your business classes. It seems that before a query is sent to the database to update the GCRecord, XPO automatically invokes the setters of all reference properties (and sets them to null). Let’s then change the setter to handle this:
public class Child {
public Parent TheParent
{
get { ... }
set
{
// add this to prevent setting NULL value for your reference property
if ( this.IsDeleted ) return;
...
}
}
}