NBusiness Forum Rss Feed

New Post: VS2008 Again

justinc — Fri, 02 Jan 2009 20:21:52 GMT

Hello!

Thanks for the feedback, the version in source currently works with 2008 but it isn't quite ready for use yet. I've been stumped for a while on the best way to translate E# into actual code. It turns out that most of the view engines out there (translating meta data into code) have been much too limited for my needs so I've been struggling to complete that final bridge.

However I think I finally have a solution that is well underway and working pretty well, see this blog post for the general idea http://www.justnbusiness.com/Blogs/Template_DSL_with_MGrammar.aspx. Once this evolves a little bit more I will probably make it as a separate CodePlex project and use it in NBusiness for the templating system... which also means I might end up converting the NBusiness parser into an MGrammar DSL. First things first though.

Sorry for how long this is taking, I've found that creating a DSL end-to-end turns out to be an IMMENSE amount of work. Hopefully though this will change in the future with some of the things I've been working on here.

New Post: VS2008 Again

anthyme — Fri, 02 Jan 2009 14:43:05 GMT

Hi,

I just want to say that your project seam to me the best way to create application architecture and the E# is a superb idea between the C# and an elegant descriptive language, XML is at the stone age in comparison !

But I am only in visual studio 2008 so I can't try your projet (that's too bad ! :-( ).

Any news about the visual studio 2008 integration ? Any date ?

And do you plan an integration of Linq ?

Thanks for your great job !

Anthyme

PS : Sorry for my english, it's not my first language.

New Post: CSLA 3.6

justinc — Sun, 05 Oct 2008 23:05:53 GMT

Basically it's just me working on it at this point. Right now the v3 "works" well enough to be a proof of concept but there is a way to go before it's ready for production use. Most of the main features are there but there is a lot of polish and debugging left to go.

I had been making pretty good progress on it but the over the course of the last month I have had wisdom teeth pulled and changed jobs and a variety of other distractions going on. So this project is still "active" but there has been some slow down recently. I have a few CSLA templates banged out, I've been using the Spark View Engine to do this, which has recieved a lot of updates recently. So Spark will probably have to be updated before more templates can be created. If you want to do some work on this I could probably fix up a few things and get you some instructions on how to dive in and contribute. Otherwise the best I can say is to subscribe to the Release RSS feed so you can keep track of progress! There definitely will be more work going on in the future.

New Post: CSLA 3.6

dbilbey — Sun, 05 Oct 2008 18:36:29 GMT

I just found this project, and I love the idea of using a language to define the business objects. Relying on the database as the "source of truth" is not my cup of tea.

How close are the templates to being able to take advantage of the latest CSLA v3.6? Is anyone actively working on this?

New Post: VS2008 Again

tanden — Thu, 07 Aug 2008 16:32:54 GMT

Thanks Justin, I got the Entity item in the list. I'll be playing with it a little this weekend to get a feel for the framework - I may have a small project next week where it might come in handy. In that case, I'll of course produce patches for anything that's changed.

New Post: VS2008 Again

justinc — Tue, 05 Aug 2008 17:20:12 GMT

Ah yes, well there is plenty left to do before it's fully ready but it should work for you in VS 2008. The plugin usability has plenty left to do that's for sure.

However a few things to note:

The new version doesn't have NBusiness projects! This ends up being a much simpler solution, in the older version you had NBusiness projects with C#/VB partial classes with it which totally eliminated syntax hilighting and intellisense in those code files. That was very painful now E# files can exist in any regular .net project. Try creating a console application in C# (for example) and adding a new item. In your new items list you should see an "Entity". If you don't you can just add a text file and use the .es file extension. Make sure the custom tool ESharpCodeGenerator is applied to your es file. To get the "Entity" to show up in your new items list you might have to run "devenv /rootSuffix exp /ranu /setup" from the visual studio command prompt. Getting those templates registered is sometimes a pain in the butt for the experimental hive.
Templates are sparse right now, that's what I have been working on. Creating templates is time consuming... but you can easily create your own. One new feature of v3 is that you can define templates in the same project that you declare your entities. Just add a reference to NBusiness.Templates then create a class that inherits from TemplateBase or CodeDomTemplatebase. Make sure you build once but then you should be able to use that template to do your code generation.
You can also use Spark or NVelocity to do your code generation, this is heavily under construction right now though. I have created a few "Custom Tools" that you can apply to .spark or .nv files to generate a class that inherits from TemplateBase for you. This is not very pluggable right now but if you want to use a different view engine I can help you figure out how and would be happy to accept patches for new view engines. So far Spark has been treating me pretty well... except that it only works with C# currently :( I've also been toying around with creating a XAML based view engine for generating code... it's pretty cool but might be more work that it's worth at this point.
The default business object framework needs lots of TLC. I've been creating templates targeting CSLA for now. I plan on having templates for both later on. Targeting new frameworks (NHibernate for example) will require a patch to allow you to detect validation rules etc. for intellisense. There is nothing stopping you from targetting them but it won't detect rules automatically (it turns out that is an incredibly hard problem).
Basically, most phases are in process right now. The core functionality "works" now it's just a matter of polishing up the VS integration piece and building templates and generally making the barrier to entry lower.

New Post: VS2008 Again

tanden — Sat, 02 Aug 2008 15:55:43 GMT

Hi,
I have an installation of Visual Studio 2008 with the VS SDK. The latest source from SVN (as of Aug. 2) compiles (almost) cleanly. However, when trying the 'experimental hive' of Visual Studio I still can't get any projects having to do with E# projects. Am I missing something, or is support for VS2008 not ready yet? If not, how would you suggest I proceed in order to test drive NBusiness?

Thanks for your time and efforts!
Yuval

NEW POST: Visual Studio 2008

justinc — Thu, 17 Jan 2008 03:05:36 GMT

I have seen documentation for setting up nBusiness in VS2005 but what about 2008?

I hear you, I have lots of ideas for improving the plugin for VS2008 but at this point it doesnt work. There are a number of feature improvements to I have been coming up with. Meanwhile check out LINQ to SQL, not quite the same thing but so far I am pretty impressed. For some ideas of what is coming up next for NBusiness check out these items:

Entity Inheritance
Entity Models
Entity Attributes
Partial Entities
Entity Reflection

Also the next plugin will probably not be with "Entity Projects" but instead will be more similar to asp.net where you have .aspx pages in C#/VB web applications. That will be the biggest change, I'm hoping this will solve the issue related to missing c#/vb intellisense. It should also make the plugin much more simple and less error prone.

Understanding that E# is more like a domain specific language, rather than an actual programming language helped me to come to some interesting ideas here.

NEW POST: Visual Studio 2008

rclarkson — Wed, 16 Jan 2008 14:36:39 GMT

I have seen documentation for setting up nBusiness in VS2005 but what about 2008?

Links to documentation, or comments would be great. I really want to give this a try because I am not planning on going back to VS2005.

Peace

NEW POST: lazy loading relationships scalability problems

justinc — Sun, 06 Jan 2008 19:49:30 GMT

There is definitely some room for improvement in this system and I"ll put some good thought in it for v3.0 because it would be a good idea but there are currently two ways to handle this two improve performance, one is only sometimes applicable though.

Use a cached collection template
There is a builtin template called CachedCollectionTemplate built into NBusiness that is useful for entities that rarely, if ever change. In this situation, if your categories were largely static then if you used this template it would not hit the database when loading the collection but would instead get it out of the cache. This of course is only applicable for collections that do not really change.

Use a custom fetch handler
By default you will get your fetch methods generated for you and you will get all of your products loaded for you by default in the above situation but you can do a little but of custom code in the ProductCollection.cs custom code beside to get the desired effects with a better performance.

So the real problem is that sometimes you want to get the categories with the products but sometimes you do not, the lazy loading is there because if you didn't have it you would end up fetch the entire database everytime you loaded your products but you can add custom code to tell the entity when to load certain other data. The solution I would reccommend is to first create a new factory method in the method name patterned as [Entity]Collection.FetchBy[X]With[Relationship]();

The "With[Relationship]" is the relationship implied to be lazy loaded. Or perhaps "For[UseCase]" would be more appropriate? Anyway what this factory method would do woudl be to call the constructor with a new custom Criteria object. You will create that object and have it inherit from the FetchAllCriteria object inside of that collection. Something like:

private class FetchAllWithCategoriesCriteria : FetchAllCriteria
{
   //...
}
 
public static ProductCollection FetchAllWithCategories()
{
     return new ProductCollection(new FetchAllWithCategoriesCriteria);
}

Next you will need to add a handler to the Fetched event in the ProductCollection class and the code to do the forced loading:

public override Initialize()
{
     this.Fetched += new EventHandler<FetchEventArgs>(Products_Fetched);
}
 
private void Products_Fetched(object sender, FetchEventArgs e)
{
     if(e.Criteria is FetchAllWithCategoriesCriteria)  //look for our custom criteria!
     {
          foreach(Product p in this)
          {
               p.LoadCategories(e.Connection); //Use the same connection to load the category objects.
          }
     }
}

And finally all we need is the LoadCriteria method:

private void LoadCategories(DbConnection cn)
{
     _Categories = CategoryCollection.FetchByProduct(cn, _productId);
}

In this situation you will be making 1 query to fetch all of the products and then one more query for each product in your collection to fetch their applicable categories. You could imagine that in the LoadCategories method you could potentially call another "With" factory to cause another layer of implicit loading of a relationship of categories as well. I don't think there is anyway to end up with being able to get away with doing less queries for situations like this other than to perhaps create a stored procedure that uses a cursor to iterate through the selection of products and fetch their relatives then pass the DbCommand object around instead of the DbConnection so you can call NextResult() and load the categories that way. You might actually be able to do that right now by handling the Loaded method of the entity rather than the Fetched method. I cannot remember if not then that is a good feature request candidate for v3.0 (or 2.2).

Does this make sense? It seems to be a fairly involved solution but if you understand the lifecycle of the entity it's not that bad and the amount of code really isn't that much either.

NEW POST: lazy loading relationships scalability problems

justinc — Sun, 06 Jan 2008 19:18:33 GMT

I was trying to speed up the Glitz site and found a fairly significant
bottle neck (I think we had discussed this previously). Anyway, lazy loading
the properties for objects in a collection ends up not being very scalable.

Current:

ProductCollection products = ProductCollection.FetchX(...);

foreach (Product product in products)
{
// doing something here that triggers a hit to the db
// can be very bad and a big perf hit

if (product.Categories.SomethingHere(...))
{
// ...
}
}

Proposed (similar to what they do in LINQ to SQL):

ProductCollection products = ProductCollection.FetchX(...,
PreloadCategories);

foreach (Product product in products)
{
// categories have been already been loaded for each product
// in the current ProductCollection context...

if (product.Categories.SomethingHere(...))
{
// ....
}
}

Doing this, of course, is pretty complex. I believe that LINQ to SQL allows
you to take in a Func<T> to describe the items that need to be preloaded.
That Func<T> then gets translated into SQL. Crazy stuff! But, with
NBusiness, I think there are some things you can come up with in way of code
generating the caching options with, perhaps, a Flags enum that is available
in all Fetch operations. This allows the caller to be in control of the
preloading operation -- as having NBusiness try to infer that would probably
be impossible.

NEW POST: Creating entity Templates

justinc — Wed, 10 Oct 2007 19:47:39 GMT

To create a new template you need to do a few things:

Create a class that implements NBusiness.Templates.ITemplate, or inherit from a class that implements ITemplate (NBusiness.Templates.TemplateBase for example)
Add a reference to the assembly that contains this class. For now you cannot put entity templates into the entity project itself (hopefully in the future this will be available).
Implement the generate method by returning one or more resource files. These files have a byte[] that represents the data for the file, for code files such as C#/VB you can take a string object and convert it into a byte[].
On your entity definition file (es) add a using that matches the namespace of your entity template. For example if the class is Example.Templates.MyExampleTemplate then add "using Example.Templates;" to your entity definition. This will cause your entity to show up with intellisense (hit ctrl + j to force intellisense).
Add your template to the entity for example: "entity ExampleEntity as EntityBase, MyExample" Note: that the postfix 'Template' is missing on the name of the entity template, it is entirely optional

If you attach an instance of Visual Studio to the instance with the entity project when you build your project it should allow you to step into your custom template during build time. A few things you should know:

Your template will only be called once during build time, all entities defined by this template will be passed in as an argument. This allows you to create multiple files for each entity or 1 file for multiple entities.
The template specifies the names of the classes and files it will be generating. Try to stick with fairly unique naming standards.
Generated files (for now) are placed into the $(ProjectDirectory)\obj\generated\ folder. So if you name your file "MyExample\\" + entity.Name + ".cs" then the file $(ProjectDirectory)\obj\generated\MyExample\ExampleEntity.cs" will be created.

There is a work item related to creating project files for generated files, which should be available for version 3.0 but for now you are able to simply manually navigate to this folder to access the generated files.

NEW POST: Debugging NBusiness

justinc — Wed, 10 Oct 2007 18:59:34 GMT

Ok you need to do a few things to setup:

Download the february 2007 Visual Studio SDK (v4), http://www.microsoft.com/downloads/details.aspx?familyid=51a5c65b-c020-4e08-8ac0-3eb9c06996f4
Get the latest version of the code from this project.

Once you have done this open the solution file found in the branch you wish to work on called NBusiness.VisualStudio.sln. Set the startup project as NBusiness.VisualStudio. This project has everything related to creating the visual studio plugin and such. You may find it easier to uninstall NBusiness using add/remove programs at this point, if you have it installed. This is not exactly necessary but it just adds some confusion sometimes. When you build NBusiness.VisualStudio it does a couple things you should be aware of, though don't worry about memorizing all of this it won't be necessary to know most of this but it is helpful to get the gist just in case.

NBusiness.MSBuild.dll is built and copied to C:\Program Files\MSBuild\NBusiness\... along with some other assemblies
NBusiness.targets is copied to this folder as well. Your entity projects will use this target file to build your entity projects. Everytime you build this project it will replace this file, which is why it's helpful to uninstall NBusiness before hand. This targets file will now point to your debug assemblies.
Zip files with entity project templates are copied to 'C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\ProjectTemplatesExp\' and ItemTemplatesExp.
Registry settings will be added under the key: HKEY_LOCAL_MACHINE\Software\Microsoft\VisualStudio\8.0Exp Note: The 'Exp' at the end

The last two items here are done with special MSBuild tasks in the NBusiness.VisualStudio.csproj file. So what this translates into roughly is that after building all of the projects you need to make one command line call to get everything setup in visual studio (you'll want to open the visual studio command prompt found in the visual studio start menu folder):

devenv /rootSuffix Exp /setup

You will only need to do this once unless you are working on aspects of the visual studio plugin that require refreshing it in visual studio. Working on NBusiness codegeneration templates for example will not require calling this multiple times. This will set things up in visual studio so you can run NBusiness in "experimental mode". Now you just have to either press the "start debugging" button in visual studio (starting the NBusiness.VisualStudio project will cause a new instance of VisualStudio running in experimental mode to pop up) or in case it complains about not being able to start up a class library (which is some sort of bug I'm not sure how to fix this and it seems sporadic) you can startup a new instance of visual studio manually in experimental mode with this command:

devenv /rootSuffix Exp

There is a shortcut for this in the visual studio sdk folder in the start menu I believe. Now simply attach the instance of visual studio with NBusiness loaded to the process of the new instance and you're ready to go.

To begin debugging something specific you can now go to File->New->Project and create a new entity project. Running this project will allow you to debug the NBusiness visual studio plugin. Building this project will allow you to debug NBusiness itself. To rebuild NBusiness you will need to close the experimental mode of Visual Studio, make your changes, build then start it up again.

So here's a quick recap of what you need to do:

download the sdk
get the latest version of the code
open NBusiness.VisualStudio.sln in the branch you will be working on
build the solution
run devenv /rootSuffix Exp /setup via command prompt
start debugging

or run devenv /rootSuffix Exp via command prompt
attach to the new instance

Good luck!

NEW POST: NBusiness license

justinc — Fri, 05 Oct 2007 14:02:02 GMT

Absolutely. The main section here says this:

"...each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create."

The key there for you is "distribute its contribution", which means you can distribute any NBusiness assembly with your applications. It also says:

"If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution notices that are present in the software."

Which just means don't remove the © information and try to just rebrand it with something else so people think that you created it from scratch. There are some restrictions placed upon distributing the source code or derivative works of NBusiness with custom source code but other than that you should be free to use it in commercial projects as much as you want without it affecting the license of your commercial project.

Furthermore all code generated by NBusiness is completely yours, this license doesn't even affect it in the slightest. NBusiness is a tool and the generated code is essentially code that you have authored and you contain complete ownership of all generated code. This license was selected because I wanted NBusiness to remain as open an free for everyone as possible while doing the bare minimum to protect NBusiness itself from being copywritten or patented out from under our feet. If you have a problem with any specific clause and it poses a conflict with what you need then feel free to post that here and we might be open to updating the license. We want this to be as open and as free as possible!

NEW POST: NBusiness license

PragueProgrammer — Fri, 05 Oct 2007 09:36:26 GMT

Hello,
I really like NBusiness and I would like to use it in my commercial project to generate its data layer.
I would like to ask, does the Microsoft Permissive License (Ms-PL) mentioned on http://www.codeplex.com/NBusiness/Project/License.aspx allow that?
What requirements must my project fulfill to be able to use NBusiness generated code?

Jan

NEW POST: Questions from Chris Russi

justinc — Wed, 05 Sep 2007 01:12:19 GMT

I am curious to know, since you work at Magenic, do you use CSLA in your day-to-day projects?

We use CSLA quite a bit at Magenic, I have personally worked on several projects where we used CSLA and a few that didn't. Of course it helps to have Rocky personally available to answer CSLA questions as you're learning it :)

I know you mentioned in your blog that you were prevented from using CSLA on godaddy because of the medium trust issue. I have also run into that on a similar website for a web project I did once.

Actually I had done some work on a code generator at work that generates CSLA business objects and was about to begin working on a website for my own interests when I came across this limitation. It was a combination of needing a different solution and some of my own thoughts of how to do a better job with code generation that really brought me to create NBusiness. I have had lots of interesting conversations with some coworkers, including Rocky, about creating a traditional style DSL and finally decided to go for it.

Is the framework you came up with similar to CSLA?

The default framework that comes with NBusiness is similar to CSLA in some ways but not so much in other ways. It turns out that the Medium Trust issue is a tough one to work around for some of the features of CSLA. For example, there is no Dataportal. This is a direct to database access layer. I suppose it would probably be possible to work in your own Dataportal type deal... but it's certainly not part of the default framework for now. Addtionally there is no N-level undo... there could be maybe but it's a little harder to do in medium trust.
Also the framework is just one of the several components needed to get this whole thing to work so it doesn't have nearly the level of focus, maturity or number of features that CSLA has. Additionally, I could be a bit naieve about this point, but I don't think that there is formal support for persisting relationship objects in the business base classes, at least to the extent that I would like. So in that way I think it's maybe a little better, though you could certainly get nearly the exact same results with more work in your templates. But in general I would say the "feel" of working with the generated objects is very similar, for example you might create the following code to consume your NBusiness objects:

    Customer c = Customer.CreateNew(); //Factory method for creating a new business object
    c.FirstName = "Justin";
    c.LastName = "Chase";
    Assert.AreEqual(0, c.BrokenRules.Count);
 
    c.Save();
    Assert.IsFalse(c.IsNew);

You've mentioned in your blogs that it shouldn't be that hard to gen CSLA compliant objects from NBusiness; have you actually done this?

No I haven't done this yet but it's a goal of mine. I have however done the templates for generating classes for the default framework and it would simply be a matter of generating code that targeted a different framework. I will say however, that in reality it probably wouldn't be "easy". Rather, it would be easy to do it but it would not be very easy to do it well. As we all know your business objects can get quite complicated and solving the problem in a generic way is even harder, however NBusiness was specifically designed with this in mind and therefore is absolutely possible.

What are your thoughts about using N# instead of other ways to store metadata ( i.e. XML) now that you've had time to work with it?

First off, you probably mean E# rather than N#.
Well I'm obviously biased but if you're willing to overlook that then I think it's absolutely great! I built an entire backend for my blog website in about 10 minutes, no joke, and hooking it up to the front end was very easy as well. This was an extremely simple example but just goes to show you useful it can be for small, medium trust websites at the very least. The jury is definitely still out though! In a lot of ways this project is really still just a hypothesis about what is the best way to express a domain specific language, for entities or anything else for that matter. The theory behind NBusiness is simply that it's most intuitive for coders to think and develop in code than in any other way. For example, I like the class designer that comes with VS 2005 but only for looking at relationships between classes that I have already created, I would never use it to actually author code. The why's behind this are probably beyond the scope of this post but I think most coders probably feel the same way.

How hard was it to develop N#?

VERY. I've been working on it for over a year now (I think) and there is still much to be done!
To elaborate more I'll tell you that there are several components to NBusiness and each one was pretty hard. To give you an idea the various components there is the Compiler/Parser, the Templates, the business object framework, some web controls, MSBuild classes, Example website, visual studio integration and an installer. Each one had it's challenges but without a doubt the visual studio integration was the hardest. Quite possibly the hardest thing I've ever done and that was with virtually copying the IronPython example that came with the SDK. I would absolutely not reccomend ever creating a visual studio integration project unless you're either well financed or extremely sadistic (or you use the DSL tools).
Integrating with visual studio forced me to rewrite the entire parser I had created prior to that point. It was necessary in order to get the information I needed to enable intellisense. It's hard to forsee those types of things when you make a compiler for the first time, that's for sure. I should probably also mention that I'm no compiler expert, I mean it works but it's really the only one I've ever worked on. I've never even taken a compiler course in college so as far as I know it could be an extremely primitive an embarrassing compiler (ignorance is bliss)!

Thanks for making all the source available ... it's going to be fun checking it all out :-)

You're welcome!

NEW POST: Performance & Reporting

Dewey — Thu, 30 Aug 2007 06:54:41 GMT

You got my questions EXACTLY right, and the answers were even more detailed than I expected, which is a pleasant suprise.

I'm pleased that once NBusiness creates the database in it's "ROM" mode, that we are free to optimize SQL Server to our hearts content(within realistic limits of course). However, your detail on the options was a refreshing concession to the realities we developers face working with different customers.

Reporting seems to be a non issue, and I need as many options there as possible(webservices are generally our preference).

Once I get some of these tasks off my plate, I will use NBusiness on a small project to get my feet wet. Good luck, and thanks for dropping this GEM into the open source community.

NEW POST: Performance & Reporting

justinc — Wed, 29 Aug 2007 14:22:42 GMT

Great questions, I'll try to answer them as best as possible. These are things that are sort of hard to answer in a getting started document so this is good to have it in a forum like this. The answers are, of course, more general and open to change as we see how people tend to want to use it.

Performance:
1.) Reflection is definitely heavily used by the compiler. As you build your entities it looks in other assemblies quite a bit to verify that Types exist and to find out what are the Types of parameters and such. So far it seems that the build time, even with reflection, is pretty fast and with some optimization could be faster yet so I'm not really concerned about it at this point.

But of course you're probably referring to runtime reflection because at runtime is where you really want the performance and I'm glad to say that there is virtually no runtime reflection going on at all, believe it or not. There is the occasional "is" statement or the code generated equivalent but this is pretty minor and very reasonable. There is a "Scaffolding" control that comes with the library which uses quite a bit of public reflection to do various tasks but this control is completely optional and not meant to be public facing necessarily, it is meant to be plopped into an admin portion of a site so data can be accessed fairly easily. Anyway, the reason why the reflection can be kept to a minimum is because of code generation. Typically with hand written code when you want to say, call a method and pass in each property on an object to that method then you will end up using reflection to do this. Your code might look like this:

Alternative 1

foreach(PropertyInfo p in GetType().GetProperties())
{
    DoSomething(p.GetValue(this, null));
}

Alternative 2

DoSomething(Property1);
DoSomething(Property2);
DoSomething(Property3);

Of course alternative 1 uses reflection so it's performance implications are suspect but it is FAR more maintainable and less error prone since, adding or removing or renaming a property will require alternative 2 to be altered as well. But of course this whole problem goes away when code generation comes into the picture! So in the case of NBusiness it uses alternative 2 as often as possible in place of reflection since it is "re-written" every time you build it anyway. So there is virtually no runtime reflection.

Also it's worth noting that NBusiness is a template driven code generator and that the business objects that it generates by default are merely the default templates that will get people going but there is nothing stopping you from code generating your own business objects for a more popular 3rd party business object / data access framework (CSLA, NHibernate, etc.). I would love to have more templates available, so that people have that that flexibility right away but 1 set is enough to keep me busy full time for now. Ideally this will grow as the community grows.

2.) The system I have gone with for NBusiness is to create the database schema based on the entities (or ROM, relational object mapping) vs. creating the entities based on the database shcema (or ORM, object relational mapping). BUT there is nothing forcing you to do this, this is merely a way to enable users to rapidly develop new applications. There are 3 possible scenarios I'll outline and I'll tell you how I envision them to work in the real world. Also, I should note that there is a work item for the next version posted about creating a way to generate entities based on an existing database but it has not been completed yet. To hear some more of my thoughts on this subject you can read this blog.

Database Options

You can use the built-in script template and scheme updater to build your database for you based on your entity schema.

Pro: Very useful for rapid development.
Con: Not exactly realistic in a serious production environment.
Reality: In reality it's great for small and medium projects where you're starting from scratch. If you're building a version 2 of an NBusiness project you will be able to just continue to use the system but when it comes to deploying the changes to your production database you will need to either use a tool (Red Gates SQL compare for example) or manually write a script to merge changes into your database without losing any data.
After you have settled on your entities there is nothing stopping you from going into the database and optimizing it with indexes and whatnot. All of the default entities interact with the database through stored procedures and there is nothing stopping you from altering those stored procedures to be more effiecient. In that case you might end up with two scripts, one generated that gets you 90% of the way there then another that is handwritten with your various customizations and they are both deployed in turn to the production server.

Completely ignore the generated scripts and schema updater

Pro: Complete control over your database.
Con: Lots of manual work, not very rapid.
Reality: For large projects where the developer most likely does not have control over the database anyway this will probably be the route that needs to be taken. In this case NBusiness default entities simply require certain stored procedures with specific inputs and outputs be created, a developer could manually create these stored procedures that end up interacting with any sort of underlying database schema. In this way your entities could represent a fraction of the scope of the entire database and they could represent a completely different object model. It is the responsibility of the developer to create stored procedures as the bridge between the objects and the relational model.
Also, I'd like to say that I have the ability to create a dynamic sql solution foremost in my mind as well. For situations where it is not possible to even create stored procedures or for people who really don't want to use them, this will be essential. This is not currently a feature and is going to be tricky but it is on the horizon. I also plan to study the new .net Entity framework stuff to see how the two might be able to live in harmony. For now it seems like it might be possible to rely on the entity framework for data-access while still using NBusiness for "Business Objects" (the differences of which are beyond the scope of this discussion probably).

Custom templates

Pro: Even more control over how the entities interact with the database.
Con: Even more work.
Reality: In reality people probably will end up working on their own templates from time to time, NBusiness has a unique ( I think?) system of templating. It is an object oriented template system and it is possible to inherit your templates from existing templates and override key methods to selectively alter certain output as well as a "Dependency" mechanism to customize code created in dependent templates. I can go into this in more detail if needed.

Reporting:
Three solutions come to mind here though I'm not 100% on your question I must admit. Also this is assuming that you use the auto-generated database features. You could (as outlined above) use existing databases if you so choose and do reporting as you always have.

Continue to write reports that interact with the database directly, if you release updates later on you'll probably have to alter your reports as well. You may find that the database that is generated from NBusiness is actually pretty simple and easy to report on.
If it's possible for your preferred method of reporting to use web services as a datasource you could easily expose your entities through a webservice and report using that. There is a script called "EntityInfoTemplate" that was specifically created with webservices in mind because they are, essentially, XML serializable versions of their corresponding entities. This script is also a good example of template Dependencies, because, for example, an entity that has both the EntityInfoTemplate and the EntityBaseCollectionTemplate will have a method "GetInfoArray()" on the generated collection. You can use these info objects to pass out of a web service and use them to load entites from incoming method calls.
A standard webform using databinding to bind to your objects and display the data you are looking for. Take a look at the EntityDataSource control found in the NBusiness.Data.Web namespace.

Thanks for the questions! It helps me to put words to things and hopefully it will help answer other peoples questions as they come up. And of course I love feedback and the direction of NBusiness can still be altered as discussions about these things come up, feel free to let loose with opinions and ideas.

NEW POST: Performance & Reporting

Dewey — Tue, 28 Aug 2007 18:22:15 GMT

First let me say that this is something I've been looking for, and I think you are on solid ground technically. However, I do have some questions that I've had to deal with using my own ORM and others. I apologize in advance if you've answered these question, but I got so excited by what you've produced here that I didn't read too deeply in this pass ( real work interfers :( )

Performance:
1. There are two areas where performance could be affected. The amount and ways that refelection is used. While this is not a big concern, I ask about it for completeness.
2. Database Performance is the other concern since the user is no longer in complete control. In the real world, optimizing the database is a big concern once the project starts to have many users.

Reporting:
I almost never use ORM to do reporting, but with the ORM model, I still have an intimate connection with the database. How does this work with NBusiness, especially since the database is created for you.

NEW POST: Dynamic access and authorization

justinc — Thu, 09 Aug 2007 17:22:24 GMT

Actually I was just talking about this with someone else yesterday. We were talking about a slightly different problem though which is to have dynamic authorization based on the values of the entity. For example if you had a State field, you might want to say "When the entity is in this state only allow these users to update it". Which is dynamic beyond simply roles and users... So just as I was reading your post here I had an idea of how to do this.

You could have a system sort of like the validation rules, where you have the ability to create custom validation rules and pick which one to use for each validation case. In your case what we might end up with is something like "RoleAuthorizationRule" and "UserAuthorizationRule" classes and in the case I outlined above you might need a "ValueRoleAuthorizationRule" class. Your E# syntax would look like this:

Example

using NBusiness.Data.Authorization;
//...
authorize allow fetch role "*";
authorize allow fetch user "justinc";
 
authorize allow update valuerole State, 1, "Admin";
authorize allow update valuerole State, 2, "Users";

The third parameter would be the authorization rule to use, the following parameters would be the values to submit to authorization rule as arguments. How does this sound? NBusiness would come with the most common authorization rules but it would be extensible to any developer by simply adding a reference to an assembly (or creating one in your entity library) and adding the correct "using" statement above the entity that needs the rule.

What do you think about having ( ) around the parameters? Also should those rules be role or Role, ValueRole or valuerole? I'm debating against the all lowercase vs. the Pascal case because I wanted it to seem more like a keyword than an object... but perhaps it would make more sense as an object and Pascal casing.

authorize allow fetch role("*");
authorize allow fetch valuerole(State, 1, "Administrators");

Either way I would want to trim down the name similar to the way Attribute names are trimmed down in C#.