TKB HK1(2007-2008) KHÓA 10 – HỆ VĂN BẰNG 2 CHÍNH QUY

dndthanh: em xem cach lau cho bé gái và bé trai nè http://72.14.235.104/search?q=cache:d6mmbUWsvUQJ:www.webtretho.com/news/item_detail.php%3Fc_id%3D23400%26item_id%3D1382+%22b%C3%A9+g%C3%A1i%22+%2B%22lau%22&hl=vi&ct=clnk&cd=1&gl=vn
dndthanh: bà và mẹ nghiên cuứ, tắm cho bé được thì tốt http://www.cpv.org.vn/details.asp?topic=165&subtopic=352&leader_topic=857&id=BT1120775487

A Journey with NHibernate – Part 1
A Journey With NHibernate – Part 2
A Journey With NHibernate (and DDD) – Part 3
A Journey with Domain Driven Design (and NHibernate) – Part 4
A Journey with Domain Driven Design (and NHibernate) – Part 5
A Journey with Domain Driven Design (and NHibernate) – Part 6
A Journey with Domain Driven Design (and NHibernate) – Part 7
http://supinfo-projects.com/en/2006/nhibernate-introduction/conclusion/

So, why should you use any O/R mapping tool? I am not talking about a specific tool but rather all O/R mapping tools in general. There are a number of reasons for using an O/R mapping tool but before I dive into that, let me give you a brief overview of what an O/R mapping tool really is.

An O/R mapping tool generates persistence objects for your .NET application. It is a modeling and code generation tool that connects to your database and reads its schema, then lets you map objects to database tables and views, specify single-row insert, update, load, and delete operations, queries and stored procedure calls, as methods to these objects. And, it also lets you define one-to-one, one-to-many, many-to-one, and many-to-many relationships between objects based on relationships between tables in the database. It then generates fully working persistence objects code for you.

There are many other features that a good O/R mapping tool provides but I’m keeping my description brief so I can talk more about the benefits.

Reason 1: Cuts down your development time

First benefit of an O/R mapping tool is that it saves you a ton of development time (20% to 50% time depending on your situation). Now, O/R mapping tool is not generating any “rocket science” code for you and you could definitely do it manually if you wanted. But, this is a lot of tedious work and you would definitely be happier if you didn’t have to do it yourself. Let’s do some simple math.

A typical application with 15-20 database tables has 30-50 objects (including domain and factory objects) and this is roughly 5000 to 10,000 lines of code. It is likely to take you a few weeks to a couple of months to develop and test this code. And, if your application has more tables than this (which many do), then just multiple the above numbers by that much.

On the other hand, an O/R Mapping tool would generate this code for you in a day or two. Even here, you need these 1-2 days primarily to determine your object mappings to the database. The actual code generation is instantaneous. So, your time saving is tremendous.

Reason 2: Produces better designed code

Second benefit of an O/R mapping tool is that it lets you produce better designed code than doing it yourself by-hand. I know what you’re thinking. You think you can do a better job than an O/R mapping tool because you write every aspect of your code. Some of you definitely can but not everyone. Consider this. An average development team has different levels of expertise and experience and not everybody is a good designer. As a result, they may not follow design patterns in their code and end up with a lesser quality code. And, if multiple developers are writing code, their code is very likely going to be inconsistent with each other. And, inconsistency itself is a big source of poor quality in an application’s code.

On the other hand, a good O/R mapping tool uses code templates that have excellent design because they are very likely designed and created by very senior (architect level) engineers. And, these code templates almost always follow known design patterns. So, the code that you’ll generate from an O/R mapping tool is very likely going to be better designed than code designed by your own development team.

Reason 3: You don’t have to be a .NET expert

Third benefit of using an O/R mapping tool is that you don’t have to be a .NET expert to develop your persistence code. As you know, data access code is critical for the overall performance of your application. If this code is designed and developed poorly, it can severely affect your application. So, if you developed this code by hand, you need to be an export of .NET, COM+, stateless components, and MTS.

However, if you use an O/R mapping tool, you can focus primarily on the “logical design” of your persistence objects including object mapping and the different types of interactions with the database including insert, update, load, delete, queries, stored procedure calls, relationships, and more. And, the O/R mapping tool would do the rest for it. It would ensure that the generated code follows all the best practices of writing stateless .NET components to run in COM+ and MTS.

Reason 4: Saves you testing time

Fourth benefit of an O/R mapping tool is that it reduces your testing effort dramatically. If you developed all the persistence code by hand, you would also be responsible for testing it yourself. And, as you know, testing is as much effort as development in any project.

On the other hand, if you generated code from an O/R mapping tool, it is coming from code templates that are very likely thoroughly tested by the software vendor itself (more so than you because it is their primary focus). And, on top of it, most likely hundreds or perhaps thousands of other customers are using this tool and have tested the code generated from this O/R mapping tool. As a result, many of the bugs that you might not find in your own testing have already been found and fixed in the generated code of an O/R mapping tool.

Reason 5: Simplifies your .NET development

If you have to write all the persistence code yourself, you’re bogged down into the details of ADO.NET, COM+, MTS, stateless .NET components, and more. And, you end up spending a lot of time in details that you really don’t need to. On the other hand, if you generate code from an O/R mapping tool, you get well design objects and you only need to deal with their public interface.

Below is an example of code you’ll write if you used an O/R mapping tool.

try {

Employees objInfo = new Employees();
EmployeesFactory objFactory = new EmployeesFactory();

objInfo.EmployeeID = EmployeeID;
objFactory.Load(objInfo);

// code here to use the “objInfo” object
}
catch(Exception ex) {

// code here to handle the exception
return;
}

As you can see, the generated code is very simple to use than actually writing the .NET components yourself.

Many people have never heard of O/R mapping tools and many more have heard of them but are afraid to use them. I hope I have made a strong enough case here for you to give a serious consideration to O/R mapping for your project.

From :

http://www.dnzone.com/ShowDetail.asp?NewsId=1276


| View Show | Create Your Own

It arrived to me to have to convert back to a DataTable the IList result I get from the DataMapper instance.

This is mainly because some asp.net components accepts binding only to dataset or datatable

Here is the code I use if somebody has the same problem.

This code only works in .Net 2.0

public static DataTable GetDataTableFromIList<T>( List<T> aIList)

{

DataTable _returnTable = new DataTable();

if (aIList.Count>0)

{

//Creates the table structure looping in the in the first element of the list

object _baseObj = aIList[0]; Type objectType = _baseObj.GetType(); PropertyInfo[] properties = objectType.GetProperties(); DataColumn _col; foreach (PropertyInfo property in properties){

_col =

new DataColumn();_col.ColumnName = (

string)property.Name;_col.DataType = property.PropertyType;

_returnTable.Columns.Add(_col);

}

//Adds the rows to the table DataRow _row; foreach (object objItem in aIList){

_row = _returnTable.NewRow();

foreach (PropertyInfo property in properties){

_row[property.Name] = property.GetValue(objItem,

null);}

_returnTable.Rows.Add(_row);

}

}

return _returnTable;}

Mua móng heo (đỡ ngấy hơn giò) về hầm cho gần mềm, cho táo đỏ (loại còn hột) vào chừng 10p cho tiếp bạch quả vào hầm, tất cả cũng mềm thì nếm tí xíu muối, tí xíu duocng vào sao cho vua an (an 1 mình, 0 an voi com dau) la duoc

 2. Bạch quả : Co tác dung lam be sổ sữa hơn, đồng thời bổ não cho bé
Bạch qua có vỏ máu tráng giống như hạt dẻ, lấy đồ đập thịt bò, đập bể vỏ, chỉ lấy phần thịt bên trong

There are various different ways of implementing the singleton pattern in C#. I shall present them here in reverse order of elegance, starting with the most commonly seen, which is not thread-safe, and working up to a fully lazily-loaded, thread-safe, simple and highly performant version. Note that in the code here, I omit the private modifier, as it is the default for class members. In many other languages such as Java, there is a different default, and private should be used.

All these implementations share four common characteristics, however:

• A single constructor, which is private and parameterless. This prevents other classes from instantiating it (which would be a violation of the pattern). Note that it also prevents subclassing – if a singleton can be subclassed once, it can be subclassed twice, and if each of those subclasses can create an instance, the pattern is violated. The factory pattern can be used if you need a single instance of a base type, but the exact type isn’t known until runtime.
• The class is sealed. This is unnecessary, strictly speaking, due to the above point, but may help the JIT to optimise things more.
• A static variable which holds a reference to the single created instance, if any.
• A public static means of getting the reference to the single created instance, creating one if necessary.

Note that all of these implementations also use a public static property Instance as the means of accessing the instance. In all cases, the property could easily be converted to a method, with no impact on thread-safety or performance.

First version – not thread-safe

// Bad code! Do not use!
public sealed class Singleton
{
    static Singleton instance=null;

    Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            if (instance==null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }
}

As hinted at before, the above is not thread-safe. Two different threads could both have evaluated the test if (instance==null) and found it to be true, then both create instances, which violates the singleton pattern. Note that in fact the instance may already have been created before the expression is evaluated, but the memory model doesn’t guarantee that the new value of instance will be seen by other threads unless suitable memory barriers have been passed.

Second version – simple thread-safety

public sealed class Singleton
{
    static Singleton instance=null;
    static readonly object padlock = new object();

    Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            lock (padlock)
            {
                if (instance==null)
                {
                    instance = new Singleton();
                }
                return instance;
            }
        }
    }
}

This implementation is thread-safe. The thread takes out a lock on a shared object, and then checks whether or not the instance has been created before creating the instance. This takes care of the memory barrier issue (as locking makes sure that all reads occur logically after the lock acquire, and unlocking makes sure that all writes occur logically before the lock release) and ensures that only one thread will create an instance (as only one thread can be in that part of the code at a time – by the time the second thread enters it,the first thread will have created the instance, so the expression will evaluate to false). Unfortunately, performance suffers as a lock is acquired every time the instance is requested.

Note that instead of locking on typeof(Singleton) as some versions of this implementation do, I lock on the value of a static variable which is private to the class. Locking on objects which other classes can access and lock on (such as the type) risks performance issues and even deadlocks. This is a general style preference of mine – wherever possible, only lock on objects specifically created for the purpose of locking, or which document that they are to be locked on for specific purposes (e.g. for waiting/pulsing a queue). Usually such objects should be private to the class they are used in. This helps to make writing thread-safe applications significantly easier.

Third version – attempted thread-safety using double-check locking

// Bad code! Do not use!
public sealed class Singleton
{
    static Singleton instance=null;
    static readonly object padlock = new object();

    Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            if (instance==null)
            {
                lock (padlock)
                {
                    if (instance==null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
}

This implementation attempts to be thread-safe without the necessity of taking out a lock every time. Unfortunately, there are four downsides to the pattern:

• It doesn’t work in Java. This may seem an odd thing to comment on, but it’s worth knowing if you ever need the singleton pattern in Java, and C# programmers may well also be Java programmers. The Java memory model doesn’t ensure that the constructor completes before the reference to the new object is assigned to instance. The Java memory model is going through a reworking for version 1.5, but double-check locking is anticipated to still be broken after this. (Note to self: Java 1.5 has been out for a while – I need to check what the memory model changes are…)
• Without any memory barriers, it’s broken in .NET too. Making the instance variable volatile can make it work, as would explicit memory barrier calls, although in the latter case even experts can’t agree exactly which barriers are required. I tend to try to avoid situations where experts don’t agree what’s right and what’s wrong!
• It’s easy to get wrong. The pattern needs to be pretty much exactly as above – any significant changes are likely to impact either performance or correctness.
• It still doesn’t perform as well as the later implementations.

Fourth version – not quite as lazy, but thread-safe without using locks

public sealed class Singleton
{
    static readonly Singleton instance=new Singleton();

    // Explicit static constructor to tell C# compiler
    // not to mark type as beforefieldinit
    static Singleton()
    {
    }

    Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            return instance;
        }
    }
}

As you can see, this is really is extremely simple – but why is it thread-safe and how lazy is it? Well, static constructors in C# are specified to execute only when an instance of the class is created or a static member is referenced, and to execute only once per AppDomain. Given that this check for the type being newly constructed needs to be executed whatever else happens, it will be faster than adding extra checking as in the previous examples. There are a couple of wrinkles, however:

• It’s not as lazy as the other implementations. In particular, if you have static members other than GetInstance, the first reference to those members will involve creating the instance. This is corrected in the next implementation.
• There are complications if one static constructor invokes another which invokes the first again. Look in the .NET specifications (currently section 9.5.3 of partition II) for more details about the exact nature of type initializers – they’re unlikely to bite you, but it’s worth being aware of the consequences of static constructors which refer to each other in a cycle.
• The laziness of type initializers is only guaranteed by .NET when the type isn’t marked with a special flag called beforefieldinit. Unfortunately, the C# compiler (as provided in the .NET 1.1 runtime, at least) marks all types which don’t have a static constructor (i.e. a block which looks like a constructor but is marked static) as beforefieldinit. I now have a discussion page with more details about this issue. Also note that it affects performance, as discussed near the bottom of this article.

One shortcut you can take with this implementation (and only this one) is to just make instance a public static readonly variable, and get rid of the property entirely. This makes the basic skeleton code absolutely tiny! Many people, however, prefer to have a property in case further action is needed in future, and JIT inlining is likely to make the performance identical. (Note that the static constructor itself is still required if you require laziness.)

Fifth version – fully lazy instantiation

public sealed class Singleton
{
    Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            return Nested.instance;
        }
    }

    class Nested
    {
        // Explicit static constructor to tell C# compiler
        // not to mark type as beforefieldinit
        static Nested()
        {
        }

        internal static readonly Singleton instance = new Singleton();
    }
}

Here, instantiation is triggered by the first reference to the static member of the nested class, which only occurs in GetInstance. This means the implementation is fully lazy, but has all the performance benefits of the previous ones. Note that although nested classes have access to the enclosing class’s private members, the reverse is not true, hence the need for instance to be internal here. That doesn’t raise any other problems, though, as the class itself is private. The code is a bit more complicated in order to make the instantiation lazy, however.

Performance vs laziness

In many cases, you won’t actually require full laziness – unless your class initialization does something particularly time-consuming, or has some side-effect elsewhere, it’s probably fine to leave out the explicit static constructor shown above. This can increase performance as it allows the JIT compiler to make a single check (for instance at the start of a method) to ensure that the type has been initialized, and then assume it from then on. If your singleton instance is referenced within a relatively tight loop, this can make a (relatively) significant performance difference. You should decide whether or not fully lazy instantiation is required, and document this decision appropriately within the class. (See below for more on performance, however.)

Exceptions

Sometimes, you need to do work in a singleton constructor which may throw an exception, but might not be fatal to the whole application. Potentially, your application may be able to fix the problem and want to try again. Using type initializers to construct the singleton becomes problematic at this stage. Different runtimes handle this case differently, but I don’t know of any which do the desired thing (running the type initializer again), and even if one did, your code would be broken on other runtimes. To avoid these problems, I’d suggest using the second pattern listed on the page – just use a simple lock, and go through the check each time, building the instance in the method/property if it hasn’t already been successfully built.

Thanks to Andriy Tereshchenko for raising this issue.

A word on performance

A lot of the reason for this page stemmed from people trying to be clever, and thus coming up with the double-checked locking algorithm. There is an attitude of locking being expensive which is common and misguided. I’ve written a very quick benchmark which just acquires singleton instances in a loop a billion ways, trying different variants. It’s not terribly scientific, because in real life you may want to know how fast it is if each iteration actually involved a call into a method fetching the singleton, etc. However, it does show an important point. On my laptop, the slowest solution (by a factor of about 5) is the locking one (solution 2). Is that important? Probably not, when you bear in mind that it still managed to acquire the singleton a billion times in under 40 seconds. That means that if you’re “only” acquiring the singleton four hundred thousand times per second, the cost of the acquisition is going to be 1% of the performance – so improving it isn’t going to do a lot. Now, if you are acquiring the singleton that often – isn’t it likely you’re using it within a loop? If you care that much about improving the performance a little bit, why not declare a local variable outside the loop, acquire the singleton once and then loop. Bingo, even the slowest implementation becomes easily adequate.

I would be very interested to see a real world application where the difference between using simple locking and using one of the faster solutions actually made a significant performance difference.

Conclusion (modified slightly on January 7th 2006)

There are various different ways of implementing the singleton pattern in C#. A reader has written to me detailing a way he has encapsulated the synchronization aspect, which while I acknowledge may be useful in a few very particular situations (specifically where you want very high performance, and the ability to determine whether or not the singleton has been created, and full laziness regardless of other static members being called). I don’t personally see that situation coming up often enough to merit going further with on this page, but please mail me if you’re in that situation.

My personal preference is for solution 4: the only time I would normally go away from it is if I needed to be able to call other static methods without triggering initialization, or if I needed to know whether or not the singleton has already been instantiated. I don’t remember the last time I was in that situation, assuming I even have. In that case, I’d probably go for solution 2, which is still nice and easy to get right.

Solution 5 is elegant, but trickier than 2 or 4, and as I said above, the benefits it provides seem to only be rarely useful.

(I wouldn’t use solution 1 because it’s broken, and I wouldn’t use solution 3 because it has no benefits over 5.)

http://www.yoda.arachsys.com/csharp/singleton.html

Implicit Contracts

Typically, if you’re not using DBC techniques, comments are (hopefully) included to describe to the client how the code should be used and any caveats to be expected. (The “client” could be a third party calling your API, another developer on your own team, or, most often the case, another bit of code you’re writing yourself.) As an example of an implicit contract – read “not DBC” – the following method fully describes the “contractual obligations” of the calling code:

/// <summary>Gets the user for the given ID.</summary>

/// <param name=”id”>Should be > 0</param>

public User GetUserWithIdOf(int id,

UserRepository userRepository) {

return userRepository.GetById(id);

}

The developer of this code has documented the restrictions for using the method – the “calling contract” – and, implicitly, has promised to return a User. There are a few problems with this:

• If the client didn’t pay attention to the comments, there’s nothing to stop the client from passing in an invalid ID of 0.
• The client could easily pass null for userRepository. This would result in an “object reference” exception.
• Since the returned User may be null, the client will have to check for this possibility or also risk an “object reference” exception. In other words, the target method has not obligated itself to any sort of “response contract.”
• What if, down the road, it becomes OK to pass 0 to the method. If the developer neglects to update the comment, then the stated business rule will conflict with the inherit business rule within the code itself.

Explicit Contracts

Design by Contract allows you to transform the implicit contract, described above, into an explicit bidirectional contract. The bidirectional contract obligates both the client to invoke the method in a particular way and for the target method to guarantee a particular result. If the contract is broken, then the breaking party will be severely chastised (conditionally…more on this soon). The calling contract is expressed with one or more “pre-conditions” while the response contract is expressed with one or more “post-conditions.” A pre-condition states “this is your end of the bargain which must be adhered to to call me.” A post-condition states “this is my end of the bargain which you can count on me to enforce.” What follows is a very explicit, and very inflexible, bidirectional contract:

/// <summary>Gets the user for the given ID.</summary>

public User GetUserWithIdOf(int id,

UserRepository userRepository) {

// Pre-conditions

if (userRepository == null)

throw new ArgumentNullException(

“userRepository”);

if (id <= 0)

throw new ArgumentOutOfRangeException(

“id must be > 0″);

User foundUser = userRepository.GetById(id);

// Post-conditions

if (foundUser == null)

throw new KeyNotFoundException(“No user with “ +

“an ID of “ + id.ToString() +

” could be located.”);

return foundUser;

}

With the bidirectional contract now in place, almost all of the previous drawbacks have been addressed. Furthermore, the code is much more self-documenting and requires very few comments to be explicit. But a few drawbacks still exist:

• The contract is a bit verbose and easily blends in with the surrounding code. Preferably, the contract should be more concise and easily spotted.
• The contract above always throws exceptions. It should be simpler to conditionally turn on exceptions for debug vs. release mode. Furthermore, it should be simpler to always throw exceptions for pre-conditions, but only throw exceptions for post-conditions in debug mode.
• What if we want to extend contracts to the class level, and not just on individual methods? The above technique is difficult to extend for these purposes.
• What if we want class level contracts to be extended (or restricted) within inherited classes? Again, the above technique would become cumbersome – read “fragile and difficult to maintain” – when inheritance is involved.

Design-by-Contract Class Library

Fortunately, a light-weight class library has been written for the .NET environment which addresses these issues: http://www.codeproject.com/csharp/designbycontract.asp [1]. With this library in place, the previous example could be expressed as follows:

/// <summary>Gets the user for the given ID.</summary>

public User GetUserWithIdOf(int id,

UserRepository userRepository) {

Check.Require(userRepository != null,

“userRepository may not be null”);

Check.Require(id > 0, “id must be > 0″);

User foundUser = userRepository.GetById(id);

Check.Ensure(foundUser != null, “No user with an “ +

“ID of “ + id.ToString() + ” could be located.”);

return foundUser;

}

Now, the contract is concise, explicit and easy to spot. The library also provides for inheritance, allowing you to (only) weaken preconditions and (only) strengthen postconditions in overriding methods. (As an exercise for the reader, you’ll also want to explore this library’s inclusion of an “invariant” which allows contracts to be applied to the class level.) Finally, a few conditional compilation constants are provided to vary behavior between debug and release mode. I recommend not varying the conditional compilation constants regardless of the compilation mode. As commenters have noted, and as I have seen from using the library, behavior should not vary between debug in release mode. A contract is always a contract. Furthermore, variations in behavior may lead to difficult-to-reproduce bugs. In my own, modified version of the DBC library, I have removed all capabilities of varying the contractual behavior based on compilation mode and, therefore, have all conditions turned on at all times.

Day-to-Day Use & Benefits

From a practical standpoint, once you have the DBC class library in place, you’ll find the “Check.Require” to be, by far, the most useful addition to your coding arsenal. In my projects, I find myself having one or two of these at the top of every method. They only take a few seconds to write and save many hours in the debugger. In fact I haven’t used, or needed, the debugger since adopting the principles of design-by-contract in earnest. The benefits of Design-by-Contract [2] include:

• A better understanding of the method and how the software is constructed.
• A systematic approach to building bug-free systems.
• An effective framework for debugging, testing, and more generally, quality assurance.
• A method for self-documenting software components.

I hope this give a hint behind the benefits of design-by-contract…they’ll certainly become apparent the very first day you include the DBC class library in your own project.

References and Additional Resources

• [1] A simple class library for brining DBC to .NET: http://www.codeproject.com/csharp/designbycontract.asp
• [2] Eiffel’s Introduction to DBC: http://archive.eiffel.com/doc/manuals/technology/contract/
• Design by Contract by Example by Mitchell and McKim (Although I haven’t yet read this, it looks to be a strong overview of the subject.)

Source from : http://devlicio.us/blogs/billy_mccafferty/archive/2006/09/22/Design_2D00_by_2D00_Contract_3A00_-A-Practical-Introduction.aspx

Code : http://www.codeproject.com/csharp/designbycontract.asp