anchor.diff:  end;
   
   function TDUnitXIoC.Resolve<TInterface>(const name: string = ''): TInterface;
  -var
  -  resolveResult: TResolveResult;
  -  errorMsg : string;
  -  pInfo : PTypeInfo;
  -begin
  -  pInfo := TypeInfo(TInterface);
  -  resolveResult := InternalResolve(pInfo, IInterface(Result), name);
  -
  -  //If we don't have a resolution and the caller wants an exception then throw one.
  -  if (Result = nil) and FRaiseIfNotFound then
  -  begin
  -    case resolveResult of
  -      TResolveResult.Success : ;
  -      TResolveResult.InterfaceNotRegistered : errorMsg := Format('No implementation registered for type %s', [pInfo.Name]);
  -      TResolveResult.ImplNotRegistered : errorMsg := Format('The Implementation registered for type %s does not actually implement %s', [pInfo.Name, pInfo.Name]);
  -      TResolveResult.DeletegateFailedCreate : errorMsg := Format('The Implementation registered for type %s does not actually implement %s', [pInfo.Name, pInfo.Name]);
  -    else
  -      //All other error types are treated as unknown until defined here.
  -      errorMsg := Format('An Unknown Error has occurred for the resolution of the interface %s %s. This is either because a new error type isn''t being handled, ' +
  -          'or it''s an bug.', [pInfo.Name, name]);
  -    end;
  -
  -    raise EIoCResolutionException.Create(errorMsg);
  -  end;
  +begin
  +  IInterface(Result) := InternalResolve(TypeInfo(TInterface), name);
   end;
   
   { TDUnitXIoC.TIoCRegistration }
   
   procedure TDUnitXIoC.TIoCRegistration.Initialize(
  -  const delegate: TActivatorDelegate; singleton: Boolean;
  -  const instance: IInterface);
  +  const delegate: TActivatorDelegate; singleton: Boolean);
   begin
     inherited Create;
  -  IsSingleton := singleton;
  -  if Assigned(delegate) and IsSingleton then
  +  if Assigned(delegate) and singleton then
       ActivatorDelegate := CreateSingletonActivator(delegate)
     else
       ActivatorDelegate := delegate;
  -  Self.Instance := instance;
   end;
   
   function TDUnitXIoC.TIoCRegistration.CreateSingletonActivator(
  
positive.code:       class constructor Create;
    public
      class function CreateInstance(const AClass : TClass) : IInterface;
      class function CreateActivatorDelegate(const AClass : TClass; guid: TGuid) : TActivatorDelegate;
    end;
  
  implementation
  
negative.code: begin
    Result := nil;
  
    delegate := CreateActivatorDelegate(AClass, TypeInfo(IInterface), False);
    if Assigned(delegate) then
      Result := delegate();
  end;
  
  class function TClassActivator.CreateActivatorDelegate(
    const AClass : TClass; typeInfo : PTypeInfo; raiseOnError : Boolean): TActivatorDelegate;
  var
    rType : TRttiType;
    method : TRttiMethod;
    guid : TGUID;
    ctor : function(InstanceOrVMT: Pointer; Alloc: ShortInt = 1): Pointer; // constructor signature
  begin
    Result := nil;
  