unitbasetable.pas

简单封装数据库表的类的一个简单的例子： http://www.delphifans.com/SoftView/SoftView_1476.html

  //    FreeMem(FPropInfo);
end;

procedure TTableData.SetValues(Name: string; Value: Variant);
begin
  if not VarIsNull(Value) then
    SetpropValue(Self, Name, Value);
end;

class function TTableData.TableName: string;
begin
  result := EmptyStr;
end;

procedure TTableData.UpdateData;
begin
end;

procedure TTableData.UpdateReferenced;
begin
  FReferenced.Clear;
end;

procedure TTableData.UpdateValues(ASource: TDataSet);
var
  I: Integer;
  fName: string;
  fValue: Variant;
begin
  if ASource = nil then Exit;
  
  if not ASource.Active then
    ASource.Open;
  if ASource.Eof then
    raise Exception.CreateFmt('%s.UpdateValues: Not found data', [ClassName]);
  for I := 0 to ASource.FieldCount - 1 do    // Iterate
  begin
    try
      fname := ASource.Fields[i].DisplayName;
      fValue := ASource.Fields[I].Value;
      if UseUniqueID  and SameText(fName, COL_UNIQUEID) and
        VarIsNull(fValue) then
        fValue := GetNewGUID;
  //      {$endif}  // Use_UniqueID
  
      if FFieldList.IndexOf(fName) > -1 then
      begin
        SetValues(fName, fValue);
      end;
    except
      on e: Exception do
      begin
          {$ifdef CodeSite}
        CodeSite.SendFmtMsg('Assign value error:[%s]=[%s],Message:%s',
          [fName, VarToStr(fValue), E.Message]);
          {$endif}  // CodeSite
        raise;
      end;
    end;    // try/except
  end;    // for
end;

class function TTableData.UseUniqueID: Boolean;
begin
  Result := False;
end;

//function TTableData.GetIsNew: Boolean;
//begin
////  result := FIsNew or ( not VarIsNull(KeyValue) or not VarIsEmpty(KeyValue));
//end;

{
******************************** TTableDataList ********************************
}
constructor TTableDataList.Create(AOwner: TComponent; AItemType:
        TTableDataClass);
begin
  inherited Create(AOwner);
  FList := TObjectList.Create(False);
  FItemType := AItemType;
end;

destructor TTableDataList.Destroy;
begin
  FList.Free;
  inherited;
end;

procedure TTableDataList.Add(AValue: TTableData);
begin
  FList.Add(AValue);
end;

procedure TTableDataList.Append(ASource: TTableDataList);
var
  I: Integer;
begin
  for I := 0 to ASOurce.Count - 1 do    // Iterate
  begin
    Add(ASource[I]);
  end;    // for
end;

procedure TTableDataList.Clear;
begin
  FList.Clear;
end;

function TTableDataList.Extract(AObject: TTableData): TTableData;
begin
  result := FList.Extract(Aobject) as TTableData;
end;

function TTableDataList.FindByKeyValue(AOperator: TComponent; Value: Variant):
        TTableData;
begin
  result := FindByKeyValue(Value);
  if (result = nil) and (AOperator is TDataOperator) then
    result := TDataOperator(AOperator).Load(FItemType, Value);
end;

function TTableDataList.FindByKeyValue(Value: Variant): TTableData;
var
  I: Integer;
begin
  for I := 0 to Count - 1 do    // Iterate
  begin
    result := Items[I];
    if result.KeyValue = Value then
      Exit;
  end;    // for
  result := nil;
end;

function TTableDataList.FindByPropertyValue(APropertyName: string; AValue:
        Variant): TTableData;
var
  I: Integer;
begin
  for I := 0 to Count - 1 do    // Iterate
  begin
    if (Items[I].FieldList.IndexOf(APropertyName) > -1) and
      (Items[I].Values[APropertyName] = Avalue) then
    begin
      result := Items[I];
      Exit;
    end;
  end;    // for
  result := nil;
end;

function TTableDataList.GetCount: Integer;
begin
  result := FList.Count;
end;

function TTableDataList.GetItem(Index: Integer): TTableData;
begin
  Result := TTableData(FList.Items[Index]);
end;

function TTableDataList.GetModified: Boolean;
var
  I: Integer;
begin
  result := False;
  for I := 0 to Count - 1 do    // Iterate
  begin
    result := Items[I].Modified or (Items[I].IsNew) or (Items[I].DeleteFlag);
    if result then
      Exit;
  end;    // for
end;

procedure TTableDataList.Refresh;
begin
  Clear;
  if Assigned(FOnRefresh) then
    FOnrefresh(Self);
end;

procedure TTableDataList.Remove(AObject: TTableData);
begin
  FList.Remove(AObject);
end;

procedure TTableDataList.SetItem(Index: Integer; Value: TTableData);
begin
  FList.Items[Index] := Value;
end;

//{
//********************************* TObjectPool **********************************
//}
//constructor TObjectPool.Create(AOwner: TComponent);
//begin
//  inherited Create(AOwner);
//  FItems := TObjectList.Create;
//end;
//
//destructor TObjectPool.Destroy;
//begin
//  FItems.Free;
//  inherited Destroy;
//  {$ifdef CodeSite}
//  CodeSite.SendMsg('TObjectPool.Destroy');
//  {$endif}  // CodeSite
//end;
//
//procedure TObjectPool.Add(AObject: TTableData);
//begin
//  FItems.Add(AObject);
//end;
//
//procedure TObjectPool.Clear;
//begin
//  FItems.Clear;
//end;
//
//function TObjectPool.CreateNewObject(AType: TTableDataClass): TTableData;
//begin
//  result := AType.CreateNew(Self);
//  Add(result);
//end;
//
//function TObjectPool.GetCount: Integer;
//begin
//  result := FItems.Count;
//end;


{ TReferenced }

//function TReferenced.GetCount: Integer;
//begin
//  result := Length(FTableList);
//end;
//
//function TReferenced.GetItem(Index: integer): TTableDataClass;
//begin
//  if (Index >= Low(FTableList) ) and (index <= High(FTableList)) then
//    result := FTableList[Index]
//  else
//    result := nil;
//end;
//
//procedure TReferenced.UpdateTableList(AList: array of TTableDataClass);
//var
//  I: Integer;
//begin
//  SetLength(FTableList, Length(AList));
//  for I := Low(AList) to High(AList) do    // Iterate
//  begin
//    FTableList[I] := AList[I];
//  end;    // for
////  FTableList := AList;
//end;

{ TReferenceItem }

{
******************************** TReferenceItem ********************************
}
constructor TReferenceItem.Create(AOwner: TComponent; AItemType:
        TTableDataClass; AReferenceColName: string);
begin
  inherited Create(AOwner);
  FReferenceColName := AReferenceColName;
  FItemType := AItemType;
end;

{ TReferenced }

{
********************************* TReferenced **********************************
}
function TReferenced.Add(AOwner: TComponent; AItemType: TTableDataClass;
        AReferenceColName: string): TReferenceItem;
begin
  result := TReferenceItem.Create(AOwner, AItemType, AReferenceColname);
  inherited Add(result);
end;

function TReferenced.GetItem(Index: Integer): TReferenceItem;
begin
  result := TReferenceItem(inherited GetItem(Index));
end;

procedure TReferenced.SetItem(Index: Integer; const Value: TReferenceItem);
begin
  inherited SetItem(Index, Value);
end;

function TTableDataList.AddFromDataSet(ASource: TDataSet): Integer;
var
  I: Integer;
  fItem: TTableData;
begin
  result := 0;
  with ASource do
  begin
    First;
    while not Eof do
    begin
      fItem := FItemType.Create(Self, ASource);
      Add(fItem);
      Inc(result);
      next;
    end;    // while
  end;    // with
end;

end.