Configuration means to me:
Having some static class which I can access from all over the application.
public class IBFactsheetsConfiguration
{
public static string FolderWithFactsheets { get; set; }
….
}

Now with an Appconfig I would have to write the Mapping from the xml/ConfigSections by hand(AFAIK). This can be quite tedious.
Considering Linq To XMl I would be best to have some class which would do the mapping itself once for ever. So that the configClass from above would just derive from that basic Mapping class and thats all.
Now as I use only the public static properties of my configuration class, it requires just a reflectional method which gets all those properties. Then as I have them, I only have to persist the data into xml. Vice versa I have to be able to read the config into the class from the xml.
To keep it short, here is the basic Mapping Class:
public class Configuration<T>
{
//load the xml file, uses reflectional method PropertyInfo.SetValue
public static void Initialize(string ConfigFileWithPath)
{
XDocument xmlDoc = new XDocument();
xmlDoc = XDocument.Load(ConfigFileWithPath + typeof(T).Name + “.xml”);
foreach (PropertyInfo info in GetPropertyInfos())
{
info.SetValue(null, (from p in xmlDoc.Descendants(info.Name) select p.Value).First(), null);
}
}

// provides all the static public properties of the class
private static PropertyInfo[] GetPropertyInfos()
{

PropertyInfo[] propertyInfos;
propertyInfos = typeof(T).GetProperties(BindingFlags.Public |
BindingFlags.Static);
// sort properties by name
return propertyInfos.OrderBy(a => a.Name).ToArray();

}

//saves the properties to xml using LinQ to XML
public static void SaveConfigTo(string Path)
{

var custsDoc = new XDocument(
new XDeclaration(”1.0″, “utf-8″, “yes”),
new XComment(typeof(T).FullName),
new XElement(typeof(T).Name,
from row in GetPropertyInfos()
select new XElement(row.Name, row.GetValue(null, null))));
//save the Xdoc to the Xml File
custsDoc.Save(Path + typeof(T).Name + “.xml”);
}
}

Here comes the Configuration class:
public class IBFactsheetsConfiguration : Configuration<IBFactsheetsConfiguration>
{
public static string FolderWithFactsheets { get; set; }
………….
}
this time its derived from Configuration<IBFactsheetsConfiguration>

UsageScenario:

First I have to initialize the static class once before any usage.

public void InitializeConfigOnce()
{
IBFactsheetsConfiguration.Initialize(@”D:\SomePath\”);
}
this Initializes the class from an xmlfile called: “IBFactsheetsConfiguration.xml” in d:\SomePath

Now I can access the Configuration from anywhere with

public void someMethodOrOther()
{
string someConfig = IBFactsheetsConfiguration.FolderWithFactsheets;
}

Now thats it all. One could provide support for hierarchal Config Classes. Now thats left for the future.
Any comments are welcome.

in my last Blog http://www.richter-web.info/Wordpress/?p=132 I explained why I have to use external method created row Ids. So some outside method calculates the Id of the new table row. I assign then the value to the entity.

To convey this to Nhibernate( Fluent NHibernate) one has to do the following:

public class Appendix
{
public virtual int id { get; set; }
public virtual AppendixHierarchy AppendixHierachy { get; set; }
public virtual byte[] appendix { get; set; }
}

public class AppendixMap : ClassMap<Appendix>
{
public AppendixMap ()
{
Id(x => x.id).GeneratedBy.Assigned();
References(x => x.AppendixHierachy).ColumnName(”appendixHierarchyId”);
Map(x => x.appendix);
}
}

Now Nhibernate does know that the Ids will be set by “hand”.

But this approach has disadvantages:

Nhibernate does not know anymore if some object is transient or not, since after the Id is set by my code it has an value. For Nhibernate this value means that this object is already in the db. This means one cannot use SaveOrUpdate() anymore. If I do nevertheless nothing happens. So I have to take care of the Save and Update calls and have to distinguish between both.

Also I discovered that the newly created entities are not saved after calling Save:

using (ISession sess = DBSessionManager.GetDBSessionController(Database).GetDBSession())
{
sess.Save(item);
}

Even the closing of the session does not write the changes. This issue was only solved by call sess.Flush();

There is the question also represented: http://stackoverflow.com/questions/1566678/nhibernate-fluent-domain-object-with-idx-x-id-generatedby-assigned-not-savea

another possibility would be to wrap the whole thing into an transaction.

Conclusion: My guess is that the change tracking  in the case of the usage of self assigned Id will not work properly. It works because Flush does the right thing. Nevertheless closing the session should have the same impact If it looks into the change tracking records. In the next time I will try to use a more recent NH version… result I will post here….

Lately I wanted to set up a businesslogic layer with Nhibernate on our legacy database. In that database all the Identifiers of the colums are calculated by some stored procedure which has an Out Parameter. Parsing through some articles in some forum or other I found that this is currently not supported by Nhibernate.

The SQL Stored Procdure would look like:

Create procedure [dbo].[ups_GetNewId]
(

@dbid int=100,
@tableName varchar(512),
@incBy int = 0,
@id int out

) as
//// omitted for brevity

Since I can’t change the legacy database, I had to fall back to pure SQL use. But this was not an issue since I can easily get an ordinary connection out of the Nhibernate session. Having found that it became quite stright forward as one is used to as ADO programmer.

public int CalcNewId(string tableName)
{

using (ISession session = DBSessionManager.GetDBSessionController(Database).GetDBSession())
{
IDbCommand command = new SqlCommand();
command.Connection = session.Connection;
command.CommandType = CommandType.StoredProcedure;
command.CommandText = “dbo.ups_GetNewId”; //this stored Procedure calculates the ID
// Set input parameters
var parm = new SqlParameter(”@tableName”, SqlDbType.VarChar);
parm.Value = tableName;
command.Parameters.Add(parm);
// Set output parameter
var outputParameter = new SqlParameter(”@id”, SqlDbType.Int);
outputParameter.Direction = ParameterDirection.Output;
command.Parameters.Add(outputParameter);
// Set a return value
var returnParameter = new SqlParameter(”@RETURN_VALUE”, SqlDbType.Int);
returnParameter.Direction = ParameterDirection.ReturnValue;
command.Parameters.Add(returnParameter);
// Execute the stored procedure
command.ExecuteNonQuery();
return (int)((SqlParameter)command.Parameters["@id"]).Value;
}

} 

Having done this I just set the newly calculated Id to the Domainobject. So I could keep to the inherited method of identifier creation. Of course this is circumventing NHibernate, there will be no caching and tracking and all the rest of it. but in this case I can live (or have to because of the legacy DB) with it.

But I found that in this case I have to tell Nhibernate that I assign the Id myself. This implicates new issues to obey.
These will be described in another article coming up.

Despite of the all overwhelming workload I managed to produce another Composition.

Nevertheless I realize that maybe I focus too much on overall impressions.  Guess I should rather focus on a smaller snapshot of some scene or other. Then I can fiddle around with all the details and it looks just better. like some of the other contestants in the contest.

http://www.psd-tutorials.de/modules.php?name=BattleVote&d_op=detailansicht&b_id=323

http://www.psd-tutorials.de/modules.php?name=BattleVote&d_op=detailansicht&b_id=324

http://www.psd-tutorials.de/modules.php?name=BattleVote&d_op=detailansicht&b_id=325

credits
http://www.sxc.hu/photo/511436
http://www.sxc.hu/photo/1094060
http://www.sxc.hu/photo/1094062
http://moonchilde-stock.deviantart.com/art/Dragon-s-Lair-Nebula-Stock-84483646
http://fantasystock.deviantart.com/art/Blue-Angels-Air-Show-Flight-04-57551316
http://www.sxc.hu/photo/566719

Flower power

I can out of experience say that yes, mostly the blocks are not technical but organizational.

But then how is SaaS / Cloud computing solving these things? If there are organizational issues hampering the software whatever success, then the conclusion should be for software developers to study psychology and become salesman.
Then software developers would then first sell their solution to some management and afterward bring their airy promises to reality. This sounds a bit ironic, but after being a programmer since 1991 I realize this fact more and more. In this I fully back the notion of how to be successful as a technical guy as in the podcast.

Now I don’t see how Cloud computing and SaaS would help! sure the approach is different, but again there are organizations having again the thumb on their domain of software carefully shielding it from reuse(misuse). The block is always an organizational or political one.

Is therefore SOA failing? Its failing as every technical approach will if it is not properly sold to all participants and agreed by them. Yes, but agreements are somewhat thin rather often. So its a question of selling a project and coming up with the power and endurance to succeed.

Hmm… Am I as software developer going to become a salesman or some lone fighting bull. So far I tend trying to be the first.

Now some theory about Microsoft Windows Workflow Foundation:

1. got the same work flow engine like MS BizTalk Server and SharePoint
   http://www.dotnetframework.de/lserver/artikeldetails.aspx?b=3773
2. Statemachines(SM) which can start sequential Workflows
3. Sequential Workflows(WF)
4. Activities of which the sequential workflow is build
5. Workflow/ Statemachine services to communicate 2 way to Workflows and Statemachines

Statemachine

The statemachine contains states.  The statemachine can only be in one state. The Initialisation of the state is itself a workflow in which the statemachine can do things. Just drop some StateInitialisationActivity into the State. Following you drag some other activities in the sequential Workflow (created by dragging the SateInitializationActivity on the State). As soon as the state initialisation is finished, the Statemachine is able to listen again. This is important since if some events are fired outside the Statemachine and the Statemachine is still initializing it cannot receive them. In every state the SM can listen to multiple events. The purpose of SM is not to incorporate actions. SM’s just depict some state in which some process is and what is possible logically in that state. If one wants to start methods and so on, its better to Invoke a Workflow which then later can call some activity.(see also section workflow services later )

Sequential Workflows

Sequential Workflows are also hosted in the WF engine. But they get only one WFEngine thread. (this can be a real thread or some virtual, the engine itself decides) They do not have states and therefore no state related activities.  The can only contain activities which have a sequential execution path.

Activities

Activities are representing just an encapsulated bit of code. They have properties and one can override for instance the Excecute method to do some other bytybyte calculations. Some can call some outside code, some are waiting for an event to occur and even some are depicting programming constructs as there is a If else construct.

All these 3, Activities, Statemachines and Workflows can be edited and created with the Visual Studio Designer for Workflows.

Workflow-Events

The Statemachine(or Workflow) only can listen to event of the type: 

public event EventHandler<System.Workflow.Activities.ExternalDataEventArgs> someEvent;

This type contains a receiver InstanceId. otherwise the WF Engine cannot dispatch the event, since it does not know about the destination. Normal events are not receivable by the Workflow engine. Communication to and from the Workflow to some external class can be done with CallExternalMethod Activity and HandleExternalEvent Activity.

Workflow Services

Some other way to communicate duplex  with the Statemachine is with services which implement some public interface decorated with the [DataExchange] attribute.  The pattern would be one Statemachine/Workflow : one service. Through this service the Workflow can trigger some work and wait for an event signaling “work is done”which then is raised later on from within the service. BTW: The Statemachine cannot directly call some method of the service(via activity), since it is then not able to receive the service’s event because the whole call is then synchronous. Therefore the SM has to invoke some Workflow (with InvokeWorkflow Activity) which itself calls the service method. By that the SM is immediately able to listen to events, after invoking some workflow.

As soon one has created a service with methods and events the wca.exe tool can be used on that interface. It creates then activities based on the method/event signature. These automatically produced activities can be used then later in the Workflow designer. the only thing to do, is to fill their properties.

Statemachine/Workflow Properties

One can extend the SM of the WF with properties to bring information into the WF. only programatically this is possible at the time of creation of the workflow. Otherwise one can set or link values to the properties with the Workflow Designer.

Pattern for startup of the Workflow environment

WorkflowRuntime workflowRuntime = new WorkflowRuntime();
// if I want to communicate with the Statemachine or Workflow I have to use some workflowServices
ExternalDataExchangeService eds = new ExternalDataExchangeService();// the general hoster
workflowRuntime.AddService(eds);
eds.AddService(new FactsheetSMService()); // now I add the actual service of the SM

// Create the workflow’s parameters collection
Dictionary<string, object> parameters = new Dictionary<string, object>();
parameters.Add(”ItemsToProcess”, queue); // set the ItemsToProcess Property of the Statemachine
//get the actual real instance of the statemachine
WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(FactsheetSM), parameters);
FactSheetSMService es = workflowRuntime.GetService<FactSheetSMService>(); // retrieve the SMService
// fire the first event with the destination
es.OnRcpGetChangedSelected(new FactsheetSMServiceEventArgs(instance.instanceId));

now the SM is alive. One can even debug the SM or the workflows in the Workflow designer and see what is happening.

Conclusion

At the first glance the workflow foundation looks very promising.
Now If I would use WF I would hope:

• not anymore to care about the multithreading models, the workflow runtime would just take care of that
• get the process tracking out of the box
• get an easy adaptable tool to change the Workflow according to changed requirements with the workflow designer
• Better access to the state of some processing for the UI(with WF I would just display the state of the Statemachine or the current activity in the Sequential Workflow)
• ability to hibernate the process and proceed later.

All the entities used in Workflow Foundation are rather common sense for someone with IT background. So in some next article I will write my experiences with converting an existing app into Workflow application.

Some book on the matter which I can recommend: essential Windows Workflow Communication by Dharma shukla and Bob Schmidt ISBN 0-321-39983-8

First the table:
create table #Hierarchies (documentId int not null, publishedDate datetime not null, ComplianceId tinyint, languageId tinyint, instId int not null, HierarchyName varchar(255) not null)
– HierarchyName would be the folder  the document belongs to
– instId is just some Tag as ComplianceId

Here would be the data:
documentId  publishedDate    ComplianceId  languageId   instId      HierarchyName

———– ———————– —————– ———- ———– ———-

368334      2009-04-15 17:15:11.000 110               102        302371      Corporate

368335      2009-04-15 17:15:11.000 110               101        302371      Corporate

370644      2009-05-05 09:46:08.000 110               102        302371      Corporate

370645      2009-05-05 09:46:08.000 110               101        302371      Corporate

379675      2009-07-23 13:51:25.000 110               102        302371      Corporate

379676      2009-07-23 13:51:25.000 110               101        302371      Corporate

382243      2009-08-13 04:30:34.000 110               102        302371      Corporate

382244      2009-08-13 04:30:34.000 110               101        302371      Corporate

383903      2009-08-27 17:07:41.000 110               102        302371      Corporate

383904      2009-08-27 17:07:41.000 110               101        302371      Corporate

First I find the duplicates and put them in an quasi temporary table:
With Duplicates( instId, HierarchyName, languageId, ComplianceId, MaxDate) AS
(
select distinct
h.instId, h.HierarchyName, h.languageId, h.ComplianceId, Max(publishedDate) as MaxDate
from #Hierarchies h
group By h.instId, h.HierarchyName , h.languageId, h.ComplianceId
having Count(documentId) >1
)

This gives me for the document distinction criteria as there are instId, HierarchyName, LanguageId and ComplianceId a list of all the documents which do not differ within the grouping criteria, but  have more than one occurrence which does differ in documentId or in PublishedDate. Also I get the most recent date with MAX(publishedDate).

Now I want to get all the documentIds of the older documents, in order to delete them.
Or one could get the DocumentId of the most recent document and then delete all the other older documents.
Unfortunately one cannot put a not grouped column after the select, in my case documentId. But how could I get to those DocumentIds?! I need those to delete the documents!!

After a bit of thinking the solution was pretty straightforward:
Join the Duplicates with #Hierarchies on the former grouping criterias and there the publishedDate is not as the most recent date.

select h.documentID from #Hierarchies h, Duplicates d
where h.publishedDate <> d.MaxDate
AND d. ComplianceId = h. ComplianceId
AND d.languageId = h.languageId
AND d.instId = h.instId
AND d.HierarchyName = h.HierarchyName

So that was the solution to get column values of group by selects which are not in the grouping.
Most probably there is a better solution. I would highly appreciate if someone lets me know or has any comments about the issue…

First I looked in EF for posibilities to construct something like that:

Sample 1:

public class ServiceContractImplementingClass
{

static EFEntities entities;

ServiceContractImplementingClassCtor()
{
        if entities == null
       entities = new EFEntites(”Databaseconnectionstring”); //creates the in EF OR mapper instance 

}

//[OperationContract]
Location[] GetBusinessLocations()
{
    // create a low cost Database object from the ObjectContext
    var locs = from a in entities.GetNewSession().Locations select a;
   ———-
   return locations;

}
———–….————

}

Here in general I have one ObjectContext. For each stateless call to the OperationContract a lightweight Session would be created. The ObjectContext would be created once, the sessions more than once.
After long deep search I found no supporting constructs wether in EF 1.0 nor in EF 2.0.
Now I told myself, maybe that could be solved using somthing like that in the ServiceContract Implementing class:

Sample 2:

// only for readonly scenarios!!!
public class ServiceContractImplementingClass
{

static EFEntities entities;
private static EFEntites GetEFEntities()
{
     if entities == null
     entities = new EFEntites(”Databaseconnectionstring”); //creates the in EF OR mapper instance
     return entities;

}
//[OperationContract]
Location[] GetBusinessLocations()
{
    var locs = from a in GetEFEntities().Locations select a;
   ——————–
    return locations;

}
———–
}

This approach made sure that no costly intialisation of the ObjectContext was to perform at every call of the operation contract. Of course the ObjectContext is not threadsafe. I am aware of that being very seldom, but I have  in my scenario only read operations no write accesses, so I should not mind Mutlithreading, stale data …. After having written an out of the box stresstest with Visualstudio accessing one static instance of EFEntities, I found I run into problems. There was an exception, stating that some column of table x in the database could not be accessed. Mind, I was only reading all myself alone the database. In that case I would have to make sure by hand that the EFEntities accesses are synchronized(with Locks) even if I have only read access. Wow! Eventually I would end up with serial access to the db even for read operations. Please mind that for read/write scenarios that sample 2 is of course not approbiate and you would end up wit sample 3!
BTW: this method was almost as fast as the good old create DatabaseConnection–> DataAdapter.Fill(Dataset) approach.

So I went back to the Microsoft backed pattern:

Sample 3:

public class ServiceContractImplementingClass
{

//[OperationContract]
Location[] GetBusinessLocations()
{

using (var db = new EFEntities(”DBConnectionString”))
{
        var locs = from a in db.Locations select a;
}

………………. return…
}
—————————–
}

Now that creates for every ServiceContractImplementingClass calls a new ObjectContext. I found after stress testing that somhow the db creation gets faster after the first call due to caching, but is was still slower than my second solution. unacceptable slow since with every call the ObjectContext had to created!
Now I asked for advice in some forum or other. In the MS Forum there was not really help available. More or less they were using EF in Desktop apps, there the application holds an ObjectContext refernce as long as the app is executed.
BTW: In that scenario EF is excellent, most of all because of the rather good LinqToEF implementation(better than LinqToNHibernate).

In the Wrox forum of (by the way very comprehensive) WROX book Professional ADO.NET 3.5 with LINQ and the Entity Framework ISBN: 978-0-470-22988-0 from Jennings, I got some valuable feedback: http://p2p.wrox.com/book-professional-ado-net-3-5-linq-entity-framework-isbn-978-0-470-22988-0/72707-comparing-performance-linq-entities-outofband-sql-updates.html

So thats that! I was downloading beta of VS 2010 with .NET 4.0 later then and found no extended ObjectContext -no POCOS, I admit I did not delve too much into that… but I gave up with EF for my intended scenario..

If there is someone who knows there I am possibly mistaken, I would appreciate any comment. We are very much .NET in the Company but we found ourselves forced to go for NHibernate.

This year I tortured myself at the Eigerbike Challenge in Grindelwald 55km 2500hm. Its been fun though I was not as trained as one could have expected, after finishing a Alps traversal. Due to a tonsilitis I could not train for over 3 weeks. However I found myself finsihing in the last third with a 5:48.09,5 time, but important: I was not the last! This was just a bit more than double so long as the winners. BTW: The mighty Christoph Sauser was also competing although at the long 80 km distance.

a very good shot dearly paid

This is my very first 2D Composing! As soon as it got posted, I saw lots of bad details in it..

so there is room for improvement…

http://www.psd-tutorials.de/modules.php?name=BattleVote&d_op=detailansicht&b_id=315