USING CSLA 4 EBOOK SERIES DOWNLOAD

admin Comment(0)

The first ebook in the Using CSLA 4 ebook series is now available. so if you purchased the ebook series you'll be able to download it from. It showed that you Using CSLA eBook 4 Series [ukraine-europe.info] Summary: I * books The using CSLA 4 eBook Series will teach you how to use the. If you purchase, or have purchased, the Using CSLA 4 ebook series, you can also download this new ebook, because it is part of the series.


Author: MELISA FOXMAN
Language: English, Spanish, Hindi
Country: Poland
Genre: Politics & Laws
Pages: 230
Published (Last): 03.01.2016
ISBN: 716-6-71694-424-8
ePub File Size: 25.47 MB
PDF File Size: 14.57 MB
Distribution: Free* [*Free Regsitration Required]
Downloads: 31903
Uploaded by: BENJAMIN

If you purchased the Using CSLA 4 ebook series you already own the book, and can download it now. This ebook (in PDF format) demonstrates how to create a Windows Phone 7 (WP7) application that uses a business layer. If you own the Using CSLA 4 ebook series, you already own this new ebook it from ukraine-europe.info?t=UsingCsla4. NET Ebook series in and apparently lost my log in details somehow. They might be dated but if you download the latest version of Project tracker, we managed to register and purchase the "Using CSLA 4 (all books).

By using our site, you acknowledge that you have read and understand our Cookie Policy , Privacy Policy , and our Terms of Service. CSLA is cool -- the thing I always tell folks to keep in mind is what I see as its central philosophy, that ALL business logic should be encapsulated in business objects to as great an extent as is realistically possible, at least. With this in mind, the CSLA framework gives you lots of tools to help make it less painful to encapsulate this amount of business logic in business objects. As far as resources, I'd recommend checking out the "Dot Net Rocks TV" episodes that Rocky Lhotka has done -- they are screencasts, and he goes through the reference app that he ships with CSLA in the first few, then goes into detailed implementations with specific architectures in later ones. The information on CSLA.

Business Rules Kinds of object relationship 7 Table 3. Scenarios where reflection limitations affect code 10 Table 4. Property getter and setter helper methods 14 Table 6. Elements defined by IPropertyInfo in Csla. Core 16 Table 7. Types directly serialized by MobileFormatter 33 Table 9. Serialization base classes in Csla.

Core 34 Table Metastate properties of CSLA. NET business objects 38 Table Events raised by CSLA. NET business objects 39 Table Typical proejcts in a 4-tier Silverlight Application 50 Table Execution sequence of a command object 71 Table Collection types and UI technologies 79 Table Methods used to manually execute rules 90 Table Techniques for suppressing business rule execution 93 Table Members provided by the RuleContext type 95 Table Members defined in IBusinessRule interface 96 Table Examples of rule: Properties available on a BrokenRule object Table Properties available on a BrokenRulesNode object Table Members defined by the AuthorizationContext type Table Process followed when setting a property value Setting the assembly and namespace names in a.

NET project Setting the assembly and namespace names in a Silverlight project Setting the assembly and namespace names in a Windows Phone project Class library containing code files Add an existing item Adding files as a link Project containing linked files Creating Business Objects Page 1 Rev 1. Creating Business Objects. This book will provide you with the information necessary to use the CSLA. NET framework to create the business domain objects that make up a business layer for your application.

These domain objects encapsulate behavior and contain the state necessary to implement that behavior. This book is part of a multi-part book series, consisting of several related ebooks. While each ebook is separate, they are designed to work together to provide information about CSLA 4.

This book series will show you how to use the CSLA framework to build powerful and scalable applications for Windows, Silverlight and the web. NET Overview ebook. It is assumed that you have an understanding of the content from that ebook. Each ebook is separate, but they are designed to work together in a flexible manner so you can get exactly the information you need for your application or project. All subsequent ebooks in the series assume you have read the first two ebooks: Creating Business Objects this book.

This book walks through the major base classes provided by the CSLA. NET framework. Each base class is designed to support one or more object stereotypes, or basic types of business object useful in most business applications. The base classes provide functionality you will use when building business classes, including: NET framework and related code samples are available from the download page at: Creating Business Objects Page 2 Rev 1.

Additionally, in the Support folder provided as part of the CSLA 4 installation you will find a Templates folder that contains very basic sample code illustrating the structure of each business object stereotype described in this ebook. Any code samples unique to this ebook will be included as a separate download available from http: Creating Business Objects Page 3 Rev 1. Stereotypes Object-oriented design and programming involve the idea of taking similar concepts and implementations and grouping them together into classes and stereotypes.

You know about classes, they are bits of code that organize related behaviors together so you can create individual instances of those classes. Stereotypes are a broader concept that group together broad types of behavior. Not necessarily specific behaviors, but specific types of behavior.

For example, a class might implement a specific business rule, and all instances of that class objects have that rule. Good object-oriented design relies on stereotypes to help organize such broad concepts into classes, allowing developers to combine those classes through composition, inheritance, or other techniques into reusable and comprehensible types.

NET relies on this concept of a stereotype to help define how it supports the creation of powerful and flexible business domain objects that compose a business layer. Creating Business Objects Page 4 Rev 1. CommandBase Unit of Work Object that combines operations against several other business objects. ReadOnlyBase or CommandBase Read-only root Object containing read-only properties; object can be retrieved directly from database.

ReadOnlyBase Read-only child Object containing read-only properties; object is contained within another object and can not be retrieved directly from database. ReadOnlyBase Read-only root list List containing read-only child objects; list can be retrieved directly from database. ReadOnlyListBase ReadOnlyBindingListBase Read-only child list List containing read-only child objects; list is contained within another object and can not be retrieved directly from database.

NameValueListBase Table 1. NET must be serializable. The term serializable means that the. NET frameworks are allowed to pull the field values even if not public from a business object instance, and then use those field values to create an exact clone of the original object, either on the same computer or on a computer across the network. Because mobile objects are a central feature of CSLA.

NET framework has numerous types called serializers or formatters that clone object graphs. Only two are capable of creating true clones of objects: In all cases, to be serializable, you must apply an attribute on your business class to give the runtime permission to serialize your objects. Normally, this is the Serializable attribute. Creating Business Objects Page 5 Rev 1. I recommend against this, because it prevents the use of the BinaryFormatter or MobileFormatter.

That syntax is connected to serialization, and specifically, to the way the MobileFormatter serializer works. Whereas the BinaryFormatter and NDCS are able to use reflection to get and set non-public field values in your objects, that type of reflection is prohibited in Silverlight for security reasons.

The MobileFormatter serializer avoids this issue by not using reflection, and instead relying on active participation from each object to get and set the field values. In that case, you assume responsibility for overriding methods to get and set those field values for serialization. Choosing Serializers When running on the. NET platform, the BinaryFormatter is used for serialization by default. When running on Silverlight or WP7 or if a. NET application server is interacting with a Silverlight client , the MobileFormatter is used for serialization.

NET applications you can choose between the three serializers through configuration. Configuring CSLA. I recommend that you only configure CSLA. To configure CSLA. Creating Business Objects Page 6 Rev 1. The result is that you can use the DataContract attribute instead of, or in combination with, the Serializable attribute in your business classes. NET applications. This is done with the following configuration in your app. That said, the MobileFormatter avoids the use of reflection and so it may work in medium trust environments where the BinaryFormatter is disallowed.

Again, I recommend not overriding the default configuration of the serializer in most application scenarios. Object Lifetime Within the. NET framework all object instances have a lifetime. Typically an object is created using the new keyword, and it is removed from memory by the.

NET garbage collector some time after all references to the object have been removed. Business objects created using CSLA. NET often have a slightly more complex lifetime, because it is assumed that these objects often contain data that must be retrieved from a database and later saved into that database.

Data Access ebook will cover these processes in detail. For now you should understand that most business objects are created using the data portal, not the new keyword. This allows CSLA. Object Relationships An object is a specific instance of a class, or type. Objects can have properties that refer to other objects, creating a relationship between those two objects. It is important to understand that there are different kinds of relationship that can exist between objects.

Table 2 lists some important kinds of relationship. Relationship Description Containment One object contains another object, such that the contained object is part of the containing object.

This is often referred to as a parent-child relationship, because the child is part of the parent. Creating Business Objects Page 7 Rev 1.

In this type of relationship the objects are separate and independent, and neither contains the other. Table 2. Kinds of object relationship The distinction here is important, and both types of relationship are very common in business applications.

Download .NET Rocks! - CSLA with Rockford Lhotka from Official Microsoft Download Center

These are all containment relationships, and all these objects together form something called an object graph. An object graph is a family of related objects that directly rely on each other to implement their respective behaviors. In this example, the OrderEdit object may calculate a TotalAmount value, and that can only be done given access to the LineItemEdit objects it contains. There are some important terms used to describe the objects in a containment relationship: A parent object is an object that contains other objects.

A child object is an object that is contained within a parent object. It is important to realize that an object can be both a parent and a child at the same time. A parent object that is not a child is called a root object. A root object is special, because it is the top of the object graph.

Using A using relationship is quite different. For example, each LineItemEdit object might need to calculate a tax on its price. But the concept of calculating a tax can vary from country to country, and between provinces and states. Rather than embedding the tax calculation in the LineItemEdit class, it is better to have a separate TaxCalculator type, allowing different implementations for different geographic settings.

Download 4 using series csla ebook

Creating Business Objects Page 8 Rev 1. The most obvious type of object identity is that the object consumes physical memory in your computer, and any variable or field referring to that object is a pointer to that area of memory.

You can find out if two objects are literally the same object in memory with the ReferenceEquals method: You can also ask if two objects are equal to each other, but this is a much more complex question. Obviously an object instance is always equal to itself, but what if you have two different instances and therefore consume different memory , but which share exactly the same public property values?

Such objects might be considered equal, but suppose they have different private field values, even though their public properties match?

Your application might need to apply a different definition of equality from other applications for various reasons, and so the. NET framework allows you to override the Equals method in your classes, and to implement the IEquatable interface.

Prior to. NET 3. Now, WPF imposes some very severe restrictions on equality, at least for items contained within collections. For collections to function properly when bound to any WPF UI elements, the items in a collection can implement only a couple forms of equality: This is important for CSLA. NET made it relatively easy for you to override Equals by implementing a method called GetIdValue in your business classes. The GetIdValue method exists only for backward compatibility. Creating Business Objects Page 9 Rev 1.

While not a true subset, it is helpful to think about Silverlight andWP7 as having most of the important parts of. NET, plus a few extra features. There are a couple areas where the differences between the platforms will cause direct differences in your business class code.

Limitations on Reflection On the. NET platform reflection can be used to do many things, even interacting with non-public members of an object. For example, you can use reflection to get or set private field values in an object, or invoke a private method, or even create an instance of an object that has no public constructors.

NET frameworks make use of these capabilities to do things like serialize objects and make dynamic method calls. The CSLA. On the Silverlight and WP7 platforms reflection is restricted for security reasons. It is not possible to use reflection to interact with non-public members of an object. You can use reflection to interact with non-public members in your specific class. Not in a subclass or base class, just your class. And certainly not in other types, which prevents reflection from being useful in any scenario required by CSLA.

Starting with CSLA. Table 3 lists some specific places this affects your code. NET supports two basic ways to implement properties.

The concept of managed backing fields discussed later allows automatic serialization of objects without using reflection. NET code for. Creating Business Objects Page 10 Rev 1. NET I used to recommend that all business classes have a non-public default constructor.

The idea was to remind users of the business class that they should use factory methods, not the new keyword, to create instance of the type.

In Silverlight you must supply a default public constructor for serialization to function. Table 3. This means that I typically have a public default constructor, and all my PropertyInfo fields and other members listed in Table 3 are public. Asynchronous Server Access Most developers build applications assuming synchronous access to servers.

When you use ADO. NET to get data from a database, this is typically a synchronous call. When you use WCF to call a service on an application server, this is typically a synchronous call. Silverlight specifically requires that all server calls be asynchronous. The impact of all server interactions being async is substantial. It affects the way the data portal works, because all calls to an application server are async.

Even more, it affects how business rules work, because some business rules need to interact with an application server. This is where the idea of async business rules comes into the picture. CSLA 4 supports several asynchronous features as listed in Table 4. Feature Description Asynchronous data portal The data portal can be invoked synchronously or asynchronously on. Asynchronous business rules Business and validation rules can be synchronous or asynchronous.

Busy status tracking Business objects have properties such as IsBusy and IsSelfBusy that indicate whether the object or one of its properties is currently executing an async operation.

Table 4. Creating Business Objects Page 11 Rev 1. NET platform. For example: That said, you should keep in mind that asynchronous operations make web development more complex. This is because each web request is a non-interactive request from the browser that normally runs on a single thread. This means you need to write your own synchronization code to prevent that main thread from completing before all your async operations complete.

This leads to complexity, so I recommend avoiding the use of async operations in ASP. NET applications as a general rule. Threading Threading is closely related to asynchronous operations, because the completion callback from a normal async operation in. NET normally occurs on a background thread. You are responsible for moving that callback to the UI thread before interacting with any UI objects, or objects that are data bound to the UI. Silverlight and WP7 avoid this complexity by automatically shifting completion callback calls to the UI thread for you.

This is a pretty significant difference between the. NET and Silverlight platforms. CSLA 4 helps you avoid confusion and complexity by also automatically shifting completion callback calls from the data portal and async business rules to the UI thread for you. The exception to this is in a console application, where. NET, and so it is not possible to write typical data access code in Silverlight.

You can use simple files for data storage through the isolated storage API in Silverlight, but a typical Silverlight application will either use the data portal to interact with a remote application server, or will make remote service calls to a service API by using WCF. Creating Business Objects Page 12 Rev 1. Data Access ebook.

Property Declarations Any. NET developer knows how to declare a standard property using the long and short syntax available in C or VB. The story is very different if you are creating business objects that support data binding, business rules, validation and authorization. In that case, property declarations can become much more complex.

As an example, before returning a value in the property getter, you should check to see if the user is authorized to see this value. Similarly, in the property setter you should do all the following: Creating Business Objects Page 13 Rev 1.

Writing all the code to support these behaviors into every property declaration results in huge class files that are hard to read and hard to maintain. Basic CSLA 4 Property Concepts CSLA 4 provides several more abstract concepts to simplify the declaration and implementation of properties and the associated fields that contain the property values.

The idea behind these concepts is to support the behaviors required to implement a powerful property, without forcing the business developer to always deal with the related complexity. These concepts include a standardized property declaration syntax that includes property metadata description and helper methods that abstract most of the complex behaviors. Additionally, it is possible to implement properties that use private backing fields, or allow CSLA.

NET to automatically manage the value of each property. Some properties reference other objects, implementing containment or using relationships and there are specific property declarations to support those scenarios. Basic Property Implementation For example, to avoid the complexity of implementing a setter as described earlier, CSLA 4 offers an alternative, by providing a more concise and abstract syntax for property declaration. This syntax includes the declaration of a static field that contains metadata about the property helping to miminize or eliminate the use of reflection and helper methods that encapsulate the authorization, validation and other behaviors I listed.

As a result, a typical read-write property looks like this: The SetProperty method does a lot more, including: Creating Business Objects Page 14 Rev 1. These are listed in Table 5. Method Description GetProperty Gets a property value, first checking authorization rules ReadProperty Gets a property value without checking any authorization rules SetProperty Sets a property value performing all processing as discussed in the previous section in this chapter running business rules, etc.

LoadProperty Sets a property value without checking any rules, raising any events or marking the object as having been changed GetPropertyConvert Gets a property value, first checking authorization rules and converting the backing field value to the appropriate property value type ReadPropertyConvert Gets a property value without checking any authorization rules and converting the backing field value to the appropriate property value type SetPropertyConvert Sets a property value performing all processing as discussed in the previous section in this chapter running business rules, etc.

RegisterProperty and PropertyInfo I briefly mentioned a static field containing metadata about a property; its purpose being to minimize or eliminate the use of reflection. It also eliminates the need to use any string literal values to represent the name of a property by providing a strongly typed token that represents the property name.

This static field is declared for any CSLA style property: Creating Business Objects Page 15 Rev 1. NET property management subsystem often referred to as the field manager. RegisterProperty The RegisterProperty method is responsible for registering metadata about a property. Ultimately, RegisterProperty does two basic things. First, it gets or creates an IPropertyInfo from the Csla.

Core namespace instance that contains the property metadata. Typically, this is a PropertyInfo instance as shown in this example. That value is returned as a result of the RegisterProperty method, so you can store the value in a static field for use throughout your code. NET so it is possible for the framework and therefore your code to get a list of all the properties registered for a business class type without the need for reflection.

But the real value here is that this mechanism allows CSLA 4 to automatically serialize and deserialize objects on the Silverlight and WP7 platforms where reflection has restrictions that make it otherwise impractical to create a normal.

NET serialization component. From a day to day practical perspective, the benefit to registering properties like this is that your business code has easy access to a static field that represents the property. This makes it easy to use metadata about the property, or to refer to the property without resorting to the use of the property name in string form.

The important type is IPropertyInfo from the Csla. That said, the generic PropertyInfo is more efficient because it is strongly typed, and it is used whenever possible for performance reasons. Creating Business Objects Page 16 Rev 1.

Table 6 lists the elements defined by IPropertyInfo. Element Description Name Gets the name of the property or method Type Gets the type of the property FriendlyName Gets the human readable friendly display name of the property DefaultValue Gets the default value for a new instance of the property NewFieldData Gets a new field data container for the property; for advanced scenarios only RelationshipType Gets the relationship type for the property Index Gets the index position of the property in the internal field manager data store; for internal CSLA.

NET use only Table 6. NET or your code. For example, you might use the FriendlyName property to get a human readable display name for the property, and then use that value for a label on a form. NET itself. In some cases CSLA. NET data structures. You should avoid using this value for anything within your application code.

The DefaultValue property should only be used for value types or immutable reference types such as the string type. The DefaultValue property is set when the RegisterProperty method is called, and that occurs exactly one time per AppDomain. This means the default value is shared across all instances of the business class. NET business type, because the resulting default value would end up having numerous parent objects. A CSLA. NET business object can have exactly one parent object, and attempting to reuse an object as a child of numerous parent objects will result in runtime errors that can be hard to detect and resolve.

Because this is all interface based, and PropertyInfo is not sealed, it is possible for you to extend the metadata stored for each property. This is an advanced scenario not covered in this book, but if you do wish to maintain extra metadata about each of your properties it is possible.

The NewFieldData method supports that advanced scenario, allowing you to override the behavior that creates a PropertyInfo so you can create your own IPropertyInfo or your own subclass of PropertyInfo when that value is required by the framework. Again, you will typically use the standard metadata fields, including the FriendlyName and Name properties, which provide valuable metadata about each property.

Creating Business Objects Page 17 Rev 1. When using the more compact C or VB syntax for property declaration a field is still declared, but the compiler makes up a name for the field on your behalf.

Even this property has a backing field: CSLA 4 allows you to implement properties using a manual backing field, or with what is called a managed backing field.

In the case of a managed backing field, the CSLA. Examine this property implementation carefully: Instead, the CSLA. NET base class usually BusinessBase is managing the value of the property on your behalf. The advantage of using manual backing fields is that you gain a slight performance benefit, because private fields are directly allocated in memory.

If you are building Silverlight or WP7 applications, the drawback to using these fields is that you must write code to explicitly serialize those property values during all serialization and deserialization processing.

CSLA 4 supports this scenario, but you need to be aware that this extra work is required. The advantage of using managed backing fields is that your code is simpler, and if you are building Silverlight or WP7 applications all managed field values are automatically serialized and deserialized as needed.

RockfordLhotka posted on Monday, November 22, 2010

It is important to note that there is a small performance impact to using managed backing fields; because the CSLA. NET base class must manage the values in a data structure somewhat like an optimized dictionary. Creating Business Objects Page 18 Rev 1. NET base classes that support each stereotype. These stereotypes interact with property implementations, because different base classes provide different behaviors to support each stereotype. For example, BusinessBase supports the editable object stereotype, and so enables property implementations that utilize authorization, business rules, data binding and so forth.

The CriteriaBase class, on the other hand, is designed to be a very lightweight container for data values, and so has no behaviors around authorization, business rules or data binding.

In all cases, the same basic structure applies: These are listed in Table 7. Declaration type Property gets or sets Read-write property value A primitive or standard. NET type such as string that can can be read or altered Read-write property value with conversion A value where the property type is different from the type of the field containing the property value; the property can be read and altered, and the property value is automatically converted to and from the field type Read-only property value A primitive or standard.

NET type such as string that can be read, and has a non-public setter Read-only property value with conversion A primitive or standard. NET type such as string that can be read, and has a non-public setter, and the property value is automatically converted to and from the field type Child object reference A reference to a child object containment relationship , typically with a public getter and non-public setter Using CSLA 4: Creating Business Objects Page 19 Rev 1.

I will discuss the read-write property in a lot of detail, with a little less focus on the other property types, mostly because once you understand how a read-write property works, the other property types follow the same pattern, with slight variations. Read-Write Perhaps the most common type of property is the read-write property. This is a property with a public getter and setter designed to allow code using the object to get and set the property value, subject to all authorization and business rules, and triggering all appropriate data binding and other behaviors.

MyText ; Notice that the RegisterProperty method is generic, and so it gets the type of the value being stored for the property string in this case. Also notice that a lambda expression is passed as a parameter to RegisterProperty to provide a strongly-typed reference to the property itself: MyText Behind the scenes, the RegisterProperty method takes this lambda expression and uses reflection to get access to the PropertyInfo object from System.

Reflection corresponding to this property. It uses that PropertyInfo object to obtain other metadata about the property. Creating Business Objects Page 20 Rev 1. The RegisterProperty method also looks at the property to see if it has a Display attribute from the System. DataAnnotations namespace. Getting the Value The property getter uses the GetProperty method, which accepts the static metadata field, MyTextProperty, as a parameter.

This metadata field is what tells GetProperty which property value to retrieve. As a first step, any authorization rule associated with this property is checked, and the property value is only returned if the user is authorized to see the value. If the user is not authorized to read the property value, the default value of the property is returned.

No exception is thrown if the user is not authorized to read the value. This is important, because there are numerous data binding scenarios where a UI developer can not prevent data binding from reading the value, and so if the getter threw an exception in that case it may crash the application, or at least cause issues with data binding.

Ebook using series 4 download csla

To support this scenario, every editable business object exposes a public method CanReadProperty that can be invoked by the UI code. Setting the Value The property setter uses the SetProperty method, which accepts the static metadata field, to identitfy the property value to be set, as well as the value parameter that contains the new value for the property.

For simple properties, the SetProperty flow is relatively straightforward and usually involves the following steps: Raise the PropertyChanging event 3. Change the property value 4. Mark the business object as having been changed 5. Creating Business Objects Page 21 Rev 1.

Invoke any business rules for properties associated with this property dependent properties 7. Raise the PropertyChanged event Add a few more elements, and the process can become much more complex, as illustrated in Figure 1. New value different? Ignore input No Unhook any old event handlers child object only Raise PropertyChanging event New value is child object? Mark field as changed? Creating Business Objects Page 22 Rev 1. You should also notice that the SetProperty method is what invokes business rules associated with this property, and with any other properties marked as being dependent on this property.

Finally, notice that SetProperty also interacts with data binding by raising the PropertyChanged event. This is the minimum functionality required by all data binding mechanisms, and is one of several areas of data binding support provided by CSLA.

.NET Rocks! - CSLA with Rockford Lhotka

You should be aware that the PropertyChanged event is handled differently by Windows Forms, and if you are building a Windows Forms user interface you should set Csla. PropertyChangedMode to Windows, instead of Xaml the default. At this point, you should have an understanding of the property registration process and how property getters and setters work with read-write properties.

The other types of property implementation are mostly variations on this same set of concepts. Read-Write with No Rules A scenario closely related to the standard read-write property is where you need a read-write property, but without any authorization or business rule processing. While you can use private fields for. Sometimes this is a requirement of a business stereotype or CSLA. NET base class. Creating Business Objects Page 23 Rev 1. When implementing read-write properties in classes other than those inheriting from BusinessBase, this is the syntax you should use.

You may choose to make the metadata field private in scope, but this will block certain data access models. Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Already on GitHub? Sign in to your account. I bought the CSLA. NET Ebook series in and apparently lost my log in details somehow. I would like to purchase the ebooks again,my question have the ebooks been updated to reflected the changes in the csla. The books are now available from http: Rocky, at this point, would you consider open-sourcing those old ebooks?

Maybe hosting them online so they can be updated by the community? They are still quite useful and I find myself referring to them every now and then. A consultant recommended your system, and I remembered reading your first book many years ago, so I thought that I would take a look. Unfortunately, there is no clear explanation on the Wiki or website about what it actually is and any business case.

The link to the White paper just goes to your consulting practice. If you actually want this project to succeed, I would strongly recommend you listen to these requests and at least put some information in the public domain.

I always keep a copy on my machine. They might be dated but if you download the latest version of Project tracker, you can learn the current version of CSLA while reading the books. This forum post is just a heads-up that I'll be doing one of these "pre-draft drops" of the ebook this week, so if you purchased the ebook series you'll be able to download it from http: I'll be interested to see whether anyone finds this useful, or anti-useful - in other words, I'm hoping to find out whether this is worth my time to do the periodic drops or not, because that'll affect how I handle the other 5 ebooks in the series.

Creating Business Objects is online now - for ebook series purchasers only. As I mentioned in my previous post, I'm going to do weekly drops or so of this ebook as I work on it, and these will be available to series purchasers.

The ebook should be available for individual purchase around the end of December.

Rockford Lhotka's Blog

I know you are an avid Kindle user and I must say I'm fairly addicted to mine now as well. While it was annoying to re-type my email address everytime I opened the last ebook I purchased it was on the PC so not really a big deal. I don't think I want to do that on the Kindle. You must be thinking of the Apress book.

The ebooks I've directly published have never been password protected. I honestly find the experience a little underwhelming, but it does work. I've done some research into getting the ebook content into actual Kindle format, but that turns out to be really quite hard they don't understand fonts, tables or do a good job with figures - and of course a programming book has lots of all three.

I tabled the Kindle format idea so I could focus on getting the ebooks actually written. I might revisit the formatting idea in the future, or for future books - but for the time being PDF will have to be good enough. I would assume it's not bad on a DX. That makes some pages a bit empty when a couple of graphics in a row won't fit, but at least the code samples are readable. I've seen some direct conversions that look like crap as far as code samples are concerned. I haven't tried on a DX.

I have a colleague with a DX, but he doens't live near me, and he wasn't impressed. The DX is big enough physically, that his thought is you are just as well off using a laptop since you are probably carrying one anyway: I prefer the eInk display for reading - especially for prolonged periods of time.

I tried with my laptop and eyestrain kicked in pretty quickly. Not to mention that a 17" laptop is a bit overkill when all you want to do is read quickly gets heavy, and battery life is rather limited. The characters are a bit small because of the wide blank margins. I read somewhere that there's something that can be done about that. It does help if I redo the page layout to remove margins and use a more correct page size. Of course that messes up other typesetting in the document, so it is basically a one-way process of taking the existing document and re-typesetting it for the Kindle.

At least that gets us closer - but it also is something that takes time to do, so it isn't as simple as print-to-pdf or print-to-kindle A friend of mine sent me a novel he wrote and I had to play quite a bit before I got it to display properly on the Kindle. Interestingly the automatic Amazon conversion from. But that was all text - I doubt it would work well with a technical book. Creating Business Objects ebook on the download page.