Type Erasure

Say that I have a view model that has a reference to a data source object generated by another object like a factory. In my view model I would have a property that is typed as AnyDataSource. I also have a property that is of type FRCDataSource, this is the object that will be wrapped in the AnyDataSource object.

class AddToDoViewModel {
    var dataSource : AnyDataSource<Item>!
    var frcDataSource : FRCDataSource<Item>!

FRCDataSource is defined as :

class FRCDataSource<T: NSManagedObject> : DataSourceProtocol {

    var fetchedResultsController : NSFetchedResultsController<T>!

    init(fetchedResultsController: NSFetchedResultsController<T>) {
    self.fetchedResultsController = fetchedResultsController
    }
}

The FRCDataSource class is a wrapper around an NSFetchedResultsController type. The generic type constraint on FRCDataSource limits the type of T to be an object that derives from NSManagedObject. Also note that FRCDataSource is specialized by the same type as NSFetchedResultsController. To create an FRCDataSource we do the following in reloadData()

func reloadData() {
    self.frcDataSource = FRCDataSource(fetchedResultsController:self.fetchedResultsController)
}

We create an FRCDataSource, passing in the NSFetchedResultsController class property. Now our frcDataSource property is set to a FRCDataSource instance that internally stores a NSFetchedResultsController instance. In this case, I am creating an instance of FRCDataSource directly, although I could easily delegate this responsibility to another object which would create and return an FRCDataSource.

Once I’ve created an FRCDataSource object from the NSFetchedResultsController, I can now add a method that will create an AnyDataSource derived object and store it in the dataSource property of the view model:

func createDataSource<T: DataSourceProtocol>(dataSource: T) where T.DataSourceItem == Item 
{
    self.dataSource = AnyDataSource(dataSource)
}

The createDataSource() takes an object that adopts the DataSourceProtocol, creates an AnyDataSource object and sets the dataSource property. There are a few things to take note of here:

• The createDataSource method is a generic method and is specialized by an object that must adopt DataSourceProtocol. The input parameter dataSource is of the specialized type.

• A generic constraint is specified which constrains the DataSourceItem associated type of the input parameter to be of type Item. This is done to make sure that the type of the dataSource property matches the type returned by the AnyDataSource(dataSource) init call.
  Now we just have to pass in the frcDataSource property to the createDataSource() method.

  createDataSource(dataSource: self.frcDataSource)

Once the data source is created we will have an AnyDataSource typed object that can be used in place of a DataSourceProtocol type.

Basically what we’ve done is create wrappers for two types

public event EventHandler NotifyClient;

message.NotifyClient += new EventHandler(message_NotifyClient);

static void message_NotifyClient(object sender, EventArgs e)
{
  throw new Exception("The method or operation is not implemented.");
}

protected virtual void OnNotifyClient(EventArgs e)
{
  EventHandler handler = NotifyClient;

  if (handler != null)
      handler(this, e);
}

private void DoSomething()
{
 // Do something...
 OnNotifyClient(new EventArgs());
}

public class Base
{
 public event EventHander NotifyClient;
}

public class Derived : Base
{
 private void DoSomething()
 {
   EventHandler handler = NotifyClient;

   if (handler != null)
       handler(this, new EventArgs());
 }
}

• Define the OnNotifyClient method in the Base class as virtual and then override the OnNotifyClient method in the Derived class
• Declare the event as virtual in the Base class, then override the event in the Derived class

protected override void OnNotifyClient(EventArgs e)
{
 EventHandler handler = NotifyClient;

 if (handler != null)
   handler(this, e);
}

protected void DoSomething()
{
 // Do something Derived-class specific, then call OnNotifyClient
 OnNotifyClient(new EventArgs());
}

public class Base
{
 public virtual event EventHandler NotifyClient;
 ...
}

public class Derived : Base
{
 public override event EventHandler NotifyClient;

 public void DoSomething()
 {
   EventHandler handler = NotifyClient;

   // Here, we can access the NotifyClient directly since we've overridden access
   if (handler != null)
       handler(this, new EventArgs());
 }
}

• Your table column widths and your stored procedure widths match
• You pass the right amount of data from your code to your stored procedure
  

create procedure sp1
as

begin tran
exec sp2

if (@@error <> 0) 
  goto on_error

commit tran

on_error:
rollback tran
 


SP1:
 create procedure sp2
 as
 
 begin tran
insert table values ('sp2')
 
 if (@@error <> 0) 
   goto on_error
 
 commit tran
 
 on_error:
 rollback tran

• Any begin tran statements are ignored, but each begin tran statement does update the @@trancount variable.
  
• Any commit statements executed after the first commit transaction statement are ignored. The transaction is committed only when the outermost commit statement is executed. The @@trancount variable is decremented by one for each commit statement executed.
  
• Any rollback statements executed will rollback the entire transaction and set the @@trancount variable to 0.
  

try
{
    try
    {
       SqlTransaction txn = new SqlTransaction();

       txn.BeginTransaction();

       Data.CallSproc1();
       Data.CallSproc2();  // throws an exception and rolls back the transaction
       txn.CommitTransaction();
    }
    catch(SqlException ex)
    {
        txn.RollbackTransaction();  // If the transaction is already rolled back, this will throw an exception
    }
}
catch(SqlException ex)
{
    // Transaction was already rolled back, do something
}
 }