Jag skriver en massa saker med hjälp av en O/R mapping leksak. Fråga: Hur "fult" är det att (eftersom att jag ändå skapar klasser för att spara i db) lägga logiken i de klasserna? Är lite fundersam faktiskt...

Onkel...

Du menar att lägga logik i entiteterna? Ex du har en ArticleInfo med attribut och sedan metoder som Save, Delete etc?

Det är väl inte direkt fult, jag själv bygger inte entiteter på det sättet. Jag brukar oftast ha förmedlare som hantera Entiteterna. Det är mer en smaksak men i mina tankar ingår även versionering och utbyggnad av dessa entiteter som kan bli orsaka problem om de lever sitt egna liv.

TÄnk dig en faktura, det är ett papper med information, i verkliga livet kan inte fakturan uppdatera sig själv, någon måste göra detta. Oftast kastar man gamla fakturan och genererar en ny via förmedlar klasser.

Så här ser min typiska modell ut.

Enitet (innehållande enbart Attribut, bygger dessa med properties. ex. ArticleInfo) Placeras i ett BE lager. Business Entity layer.
ArticleData (innehåller metoder så som Save, Delete etc..) Placeras i DAL lagret. (Data Access Layer)
Det är här i jag kör med mitt O/R ramverk för att hämta, spara data.

Sedan kan jag ha ett affärslager om jag vill utföra vissa business algoritmer. Men kan även gå direkt mot DAL. (Då man på sitt sätt kan se O/R ramverket som ett DAL lager)

PL (Presentation Layer) | BE (Business Entity)
| | Dessa finns genom alla lager.
BOL (Business object Layer) |
| |
DAL (Data Access Layer) |
| |
O/R Mapping (DAL) |


Ibland är det svårt att veta vart man skall dra grännserna för hur nära DAL man skall arbeta när man kör O/R Mappings. För ett mapping verktyg är mer en broker (förmedlare) du säger åt den Hämta Faktura 3, då kan det i många fall vara onödigt att först säga till BOL (GetInvoice(3) sedan den till DAL (GetInvoice(3) och till slut den till O/R ramverket. (FillObject(Invoice(3)) eller hur dess interface nu ser ut.

Jag är lite nyfiken på hur adra strukturerar sina skikt när de nyttjar O/R verktyg. Någon kanske Nils? kan ge en förklaring hur du gör i din värld?

mvh Johan

Just nu kör jag bara med följande:
Presentationslager
|
affärlogik-klasser
|
datalager

datalagret och affärslogiken är i princip samma sak just nu pga. att affärslogik-klasserna ärver ifrån några klasser. I princip så innehåller klasserna databas-biten, det är bara det att de är ärvda som sagt så att det finns ingen db-kod i min kod.

Blev en grötig formulering det där, men aja...

Ett ex. på en klass jag har (måste säga att jag är lite fundersam på att ha "oql"-frågorna i de här klasserna, men jag har ingen bra idé på var jag ka ha dem utan att skapa dubbla uppsättningar av alla klasser + att skriva en massa kod för att synka + att sänka prestandan pga. dubbla objekt av allt):
<code>
public abstract class DbText_Texts : DbItem //DbItem är bara en klass som innehåller ett guid. den klassen ärver ifrån den klass som allt som ska sparas i databasen ärver ifrån
{
/// <summary>
/// The localized text
/// </summary>
[Do.Attributes.SqlType(Do.SqlType.Text),
Do.Attributes.LoadOnDemand]
public abstract string Text{get; set;}

/// <summary>
/// The text-elemet for this text
/// </summary>
public abstract DbText_TextElements TextElement{get; set;}

/// <summary>
/// The language for the text. If it's null, it's a fallback
/// if the wanted language wasn't found. If there is only one
/// text of the text-element, that item is allways used.
/// </summary>
public abstract DbLanguage Language{get; set;}

/// <summary>
/// The country for the text. Only used(otherwise null) if there
/// is need for a special text in a country. Used to avoid problems
/// with the law etc. If the specific country isn't found, the one
/// with null her is used.
/// </summary>
public abstract DbCountry Country{get; set;}

/// <summary>
/// Gets all the avaiable texts there is.
/// </summary>
/// <param name="Session">The session to use</param>
/// <param name="TextTypeShortName">The short name for the text-type to search for</param>
/// <param name="TextElementShortName">The short name for the text-element to search for</param>
/// <returns>An arraylist with texts</returns>
public static System.Collections.ArrayList GetTexts(Do.Session Session, string TextTypeShortName, string TextElementShortName)
{
System.Collections.ArrayList al;
Do.Query q = new DataObjects.NET.Query(Session, "Select DbText_Texts instances where {TextElement.TextType.ShortNameStored} like @TextTypeShortName and {TextElement.ShortNameStored} like @TextElementShortName");
q.Parameters.Add("@TextTypeShortName", TextTypeShortName);
q.Parameters.Add("@TextElementShortName", TextElementShortName);
Do.QueryResult qr = q.Execute();
al = new System.Collections.ArrayList(qr);
return al;
}

/// <summary>
/// Gets a text by short name
/// </summary>
/// <param name="Session">The session to use</param>
/// <param name="TextTypeShortName">The short name for the text-type to search for</param>
/// <param name="TextElementShortName">The short name for the text-element to search for</param>
/// <param name="Country">The country for the text to search for</param>
/// <param name="Language">The language for the text to search for</param>
/// <returns>A text or null</returns>
public static DbText_Texts GetText(Do.Session Session, string TextTypeShortName, string TextElementShortName, DbLanguage Language, DbCountry Country)
{
Do.Query q = new DataObjects.NET.Query(Session, "Select DbText_TextElements instances where {TextElement.TextType.ShortNameStored} like @TextTypeShortName and {TextElement.ShortNameStored} like @TextElementShortName and {Language} like @Language and {Country} like @Country");
q.Parameters.Add("@TextTypeShortName", TextTypeShortName);
q.Parameters.Add("@TextElementShortName", TextElementShortName);
q.Parameters.Add("@Language", Language);
q.Parameters.Add("@Country", Country);
Do.QueryResult qr = q.Execute(1);
if(qr.Count>0)
{
return (DbText_Texts)qr[0];
}
return null;
}

/// <summary>
/// Creates a new text-type
/// </summary>
/// <param name="Session">The session to use</param>
/// <returns>a new text-type</returns>
public static DbText_TextElements CreateTextElement(Do.Session Session)
{
DbText_TextElements t = (DbText_TextElements)DbItem.CreateNewItem(typeof(DbText_TextElements), Session);
return t;
}
}
</code>

Hej

Jag vill gärna ha 4 lager. Ett gränssnittslager, ett appliktionslager, ett dal lager och sen ett logiklager.

Applikationslagret är det som arbetar i systemet å där gui’t hämtar data och avslutar ett usecase. Logiklagret är helt fristående från dataacesslagret genom applikationslagret och till gränssnittet genom interfaces. Logiklagret innehåller samtliga affärsregler som finns i systemet. Eftersom alla logikklasser harhar interface så kan jag lätt byta ut mina egna klasser mot exempelvis datasets, som sedan drar in affärsreglerna genom att använda ett plugin system.
Tar lite längre tid å få till allt men när det väl är gjort så har man ett väldigt flexibelt system.

Hej,

Svårt att besvara en fråga en så genrell fråga. Det är kraven som måste styra detta. Hur mycket tid/pengar finns? Vilken belastning kommer systemet att ha? Hur kommer framtida utveckling av systemet att se ut? Ska det integreras med andra system osv? Det går inte att säga att man SKA göra si eller så...det är som sagt kravställningen som styr. Men visst...i ett mindre projekt kanske det kan lämpa sig.

/Nils

Ursäkta att jag inte kommer med nått svar här utan mer en följdfråga.
Var kan man läsa mer om sånt här på nätet, alltså hur och vad man bör tänka på när man bygger flerlagerlösningar.
Helt nån bra sida på nätet skulle vara intressant.

BjörnJ...

Denna fråga ställdes i ett annat inlägg under C# forumet. Ta en titt där så finner du nog en del svar.
http://www.pellesoft.se/communicate/forum/view.aspx?msgid=147670&forumid=44&sum=0

Mvh Johan

Finns en hel del här men kika också i asp.net forum. I synnerhet arkitektforumet kan vara mycket intressant.

Här finns en ok text om detta:

http://www.2xsundblad.com/Descriptions/Sample_Chapter_-_2_The_Enterprise_Application_Design_Pattern.pdf