Take a look at http://www.json.org[^].

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

Phil, OO means object-oriented.

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

I think that you need to stop worrying about the .NET focus and read more on object-oriented design. You can, then, translate that to many different OO languages. Furthermore, it will help your programming more than just learning from .NET-focused studies. Once you do that, harnesses like CSLA.NET will make a lot more sense to you.

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

These are two somewhat orthogonal (or complementary) items. CSLA.NET provides a harness that eases the persistence, state snapshot, and business-rule tracking. This entire harness reflects the methodology that Lhotka uses to create his applcations. You can compare this harness-as-philosophy to Taligent's MVP harness or Clifton's Application Automation Layer. Normally, you have to buy into this lock, stock, and barrel to adopt these types of harnesses. DDD attempts to provide a set of guidelines by which a software development team can produce in anticipated and repeatable ways the decomposition of a business model into an object-oriented structure. My exposure to this started with Coad's Domain-Neutral Component and Modelling in Color, supplemented by Nicola, et. al.'s Streamlined Object Modeling. The most recent valuable entry in this list is Evans' Domain-Driven Design: Tackling Complexity in the Heart of Software. So, CSLA.NET embodies a philosophy regarding application construction. DDD embodies "best practices" for modeling a business domain. The Application Automation Layer: Introduction And Design[^] Modeling in Color[^] Streamlined Object Modeling[^] Domain-Driven Design[^]

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

Follow these easy instructions.

1. Go to http://www.google.com
2. Type opcodes site:microsoft.com for your search criteria.
3. Click the link entitled "OpCodes (System.Reflection.Emit)

That'll list the opcodes for you. If you want to know how each works, read Standard ECMA-335[^].

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

@copec, If you plan on building something with a certain amount of system topological complexity as you're saying, you need more than a cursory understanding of the technological concepts involved. Especially if you plan on supporting this application in the future. Both of these terms (and many more) can be found on the Internet. I suggest some reading on your part to understand the choices of the tools that you'll choose to use in your application. These links will, hopefully, help you in understanding the problems that you're facing: SQLite[^] (Embedded database) FirebirdSql[^] (Open sourced RDBMS) Data Architecture[^] (Challenges of data architecture) Learning more will help you ask better questions. Skaal! Curtis.

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

You can look at the peer-to-peer capabilities in .NET. Here's an article[^] right here on Code Project.

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

The .NET Framework has a profiling API available for just such a thing. Here's a nice introductory article.[^].

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

In Microsoft SQL Server (and probably any other RDBMS that supports transactions), TRANSACTION is a reserved keyword. Change your SQL to read

INSERT INTO TransactionType([Transaction],Description,Category,Active)
VALUES(@Transaction,@Description,@Category,@Active)

The square brackets indicate a name rather than a keyword.

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

Depending on your point of view, fortunately or unfortunately, not all strings in the CLI are interned. Essentially, any string loaded with the MSIL ldstr command is interned, and anything programatically interned is interned. For example, if we run the following code

string interned1 = "hello";
string interned2 = "hello";
string notinterned = new String("hello".ToCharArray());
string interned4 = string.Intern(notinterned);
Console.WriteLine(RuntimeHelpers.GetHashCode(interned1));
Console.WriteLine(RuntimeHelpers.GetHashCode(interned2));
Console.WriteLine(RuntimeHelpers.GetHashCode(notinterned));
Console.WriteLine(RuntimeHelpers.GetHashCode(interned4));

then we get the corresponding output

58225482
58225482
54267293
58225482

As you can see from the output, the interned strings all show the same "memory location" while the programatically constructed string shows a different location. (.NET 3.5) In terms of string equality, though, the override of operator== calls the public static string.Equals(string, string) method which calls a private static method to determine equality. string.Equals(string) calls the private static method directly.

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

Glad I could help!

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

If the chain reads like natural language, then the term for it now-a-days is "fluent programming."

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

I've never tried this with a Web application, but you can create native images of your .NET libraries using NGen.exe[^]. As long as their processor is the same as yours, the DLLs/EXEs will run. Again, don't know how well that works in a Web-based application. YMMV.

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

Is the account that you're using a domain account? If so, you might need

process.StartInfo.UserName = "domain\username";

for it to work properly.

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

No problem! I'm glad I could be of help.

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

Maybe Roy Osherove's Add run-time functionality to your application by providing a plug-in mechanism[^] blog posting? It seems pretty simple...

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

It doesn't look like that you're setting the password on the process.StartInfo.Password property....

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

As far as I'm concerned, the definitive article on finalizers and disposable objects can be found over on Joe Duffy's Blog[^].

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

If you're looking for the C# equivalent to

// in file foo.c

if(fork()) {
// Do parent process stuff here
} else {
// Do child process stuff here
}

then I have to disappoint you by reporting that the .NET runtime supports no such system-like call. However, I would challenge the decision to do this by saying, "Hey, that's provedural code out the yin-yang and, since we're ostensibly using an object-oriented framework, then we should seek object-oriented solutions." Just my 0.02 USD.

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty

Here you go: a link to the Process[^] class.

"we must lose precision to make significant statements about complex systems." -deKorvin on uncertainty