.net Bible

2011-03-07T08:19:00.000-08:00

How to retrieve Xml node xPath with c#

public static string GetXPath(this XmlNode node)
   {
   if (node.NodeType == XmlNodeType.Attribute)
   {
   // attributes have an OwnerElement, not a ParentNode; also they have
   // to be matched by name, not found by position
   return String.Format(
   "{0}/@{1}",
   GetXPath(((XmlAttribute)node).OwnerElement),
   node.Name
   );
   }

   if (node.ParentNode == null)
   {
   // the only node with no parent is the root node, which has no path
   return "";
   }

   //get the index of the node
   int iIndex = 1;
   XmlNode xnIndex = node;

   while (xnIndex.PreviousSibling != null)
   {
   iIndex++;
   xnIndex = xnIndex.PreviousSibling;
   }

   // the path to a node is the path to its parent, plus "/node()[n]", where
   // n is its position among its siblings.
   return String.Format(
   "{0}/{1}[{2}]",
   GetXPath(node.ParentNode),
   node.Name,
   iIndex
   );
   }

2011-03-07T08:06:00.000-08:00

Place holder in c# .net - Parser

look on it,

Lets define a place holder as follow : identified string with some meaning.

Identification :

   {placeHolder:property}

e.g.

   Data Source={connection_string:server}

place holder represented by concrete classes, produce by factory, parsed by engine.

lets look on the engine,

public string Parse(string command)
   {
   char[] commandChArray = command.ToCharArray(0, command.Length);

   int index = 0;

   StringBuilder outputMainCommand = new StringBuilder();

   // each place holder command may consist of place holder (aka command name) and property
   // (aka command value).
   StringBuilder executeCommandName = new StringBuilder();
   StringBuilder executeCommandData = new StringBuilder();


   bool isCommandContext = false;
   bool isCommandData = false;
   bool isCommandName = false;

   int closeBracket = 0;
   while (index < commandChArray.Count())
   {
   switch (commandChArray[index])
   {
   // encounter with {
   case START_COMMAND_IDENTIFIER:

   closeBracket++;

   if (!isCommandContext)
   {
   closeBracket = 1;

   executeCommandName.Clear();
   executeCommandData.Clear();

   isCommandContext = true;
   isCommandName = true;
   isCommandData = false;
   }
   else
   {
   if (isCommandName)
   {
   executeCommandName.Append(commandChArray[index]);
   }
   else if (isCommandData)
   {
   executeCommandData.Append(commandChArray[index]);
   }
   }
   break;

     // encounter with }
   case END_COMMAND_IDENTIFIER:

   closeBracket--;

   if (isCommandContext && closeBracket == 0)
   {
   try
   {
   string commandName = string.Empty;

   if (executeCommandName != null)
   {
   commandName = executeCommandName.ToString();
   }

   string commandData = string.Empty;
   if (executeCommandData != null)
   {
   commandData = executeCommandData.ToString();
   }

   if (!string.IsNullOrEmpty(commandName))
   {
   string output = GetPlaceHolderHandler(commandName).FromPlaceHolder(commandData);

   outputMainCommand.Append(output);
   }
   else
   // common
   {
   outputMainCommand.Append(commandChArray[index]);
   }
   }
   finally
   {
   executeCommandName.Clear();
   executeCommandData.Clear();

   isCommandContext = false;
   isCommandName = true;
   isCommandData = false;
   }
   }
   if (isCommandContext)
   {
   if( isCommandName )
   {
   executeCommandName.Append(commandChArray[index]);
   }
   else if( isCommandData)
   {
   executeCommandData.Append(commandChArray[index]);
   }
   }

   break;

   case COMMAND_SEPERATOR_IDENTIFIER:

   if (isCommandContext)
   {
   isCommandName = false;

   if (isCommandData)
   {
   executeCommandData.Append(commandChArray[index]);
   }

   isCommandData = true;

   }
   else
   // common
   {
   outputMainCommand.Append(commandChArray[index]);
   }

   break;

   default:
   if (isCommandContext)
   {
   if( isCommandName )
   {
   executeCommandName.Append(commandChArray[index]);
   }
   else if( isCommandData)
   {
   executeCommandData.Append(commandChArray[index]);
   }
   }
   else
   {
   outputMainCommand.Append(commandChArray[index]);
   }
   break;
   }

   index++;
   }

   return outputMainCommand.ToString();
   }

Parse(string command) input example :  Data Source={connection_string:server}.

How to improve it ?
Add parallel to the parser, split the data to be parsed into command chunks and streaming the command value to the required command place holder, think on command defined from many place holder, all should be parsed.

2011-03-07T07:44:00.000-08:00

Hello,

Some days ago, i was requested to add rules to our project, the rule have some rules: must be configured (outside of code), provide the rule part of the current xml implementation, readable and of course, we dont have such time to do it, we have zero time.

First i decide to have this ability part of our flow xml data.

Rule definition lang should bring the ability to read/change/maintain/update/ add new functionllity in future/ etc the rule.

So, Rule should be xml or something closer.

In order to have within a xml document (my old and pretty xml files) a rule definition language, i had some ideas how to do it,

1. CDATA
2. Regular Expression
3. Json

I decided on json.

Why ?

CData, complex to read and maintains.

Regular expression, hard to maintain/read, not everyone familiar with it (its a pity but this is the reality)

So, i decide to walk on Json,

Using json.net, it was very simple, just having xml with a json string, readable, simple and maintainable,

Before code, the rule should calculate date 30 days ago and 15 days ahead (this may change in production).

Let's code :

this is the json.net impl class

   [JsonObject(MemberSerialization.OptOut)]
   public class DatePlaceHolderDataItem : BasePlaceHolderDataItem
   {
   [JsonProperty]
   public Format Format { get; set; }

   [JsonProperty(PropertyName = "CalcBy")]
   public DateCalculation DateCalculation
   {
   get;
   set;
   }
   }

   [JsonObject(MemberSerialization.OptOut)]
   public class DateCalculateBy
   {
   [JsonProperty]
   public int Value { get; set; }
   }

....

i have defined new class BasePlaceHolderDataItem as follow :

public class BasePlaceHolderDataItem
   {
   protected virtual Formatting SerializeFormattingType
   {
   get { return Formatting.None; }
   }

   public virtual string Serialize()
   {
   try
   {
   return JsonConvert.SerializeObject(this, SerializeFormattingType);
   }
   catch(Exception exception)
   {
   throw new PlaceHolderException("Failed to Serialize place holder object.", exception);
   }
   }

   public static T Deserialize(string jsonDataItem)
   {
   if (string.IsNullOrEmpty(jsonDataItem))
   {
   return default(T);
   }

   try
   {
   return JsonConvert.DeserializeObject(jsonDataItem);
   }
   catch (Exception exception)
   {
   throw new PlaceHolderException( string.Format("Failed to Deserialize place holder string : {0}.", jsonDataItem), exception);
   }
   }
   }

lets examine the impl,

the FromPlaceHolder identify place holder are parse it using the Deserialize method, invoke the ParsePlaceHolderByDataItem, parse the object itself, simple and readable.

   public string FromPlaceHolder(string placeHolderData)

   {
   // DatePlaceHolderDataItem
   if (placeHolderData.StartsWith("{"))
   {
   DatePlaceHolderDataItem datePlaceHolderDataItem = DatePlaceHolderDataItem.Deserialize(placeHolderData);

   if( datePlaceHolderDataItem != null )
   {
   return ParsePlaceHolderByDataItem(datePlaceHolderDataItem);
   }
   }

   return ParsePlaceHolderByFormat(placeHolderData);
   }

   private string ParsePlaceHolderByDataItem(DatePlaceHolderDataItem datePlaceHolderDataItem)
   {
   DateTime dateTime = DateTime.Now;

   if( datePlaceHolderDataItem.DateCalculation != null )
   {
   if( datePlaceHolderDataItem.DateCalculation.Year != null )
   {
   dateTime = dateTime.AddYears(datePlaceHolderDataItem.DateCalculation.Year.Value);
   }
   }

   if (datePlaceHolderDataItem.DateCalculation != null)
   {
   if (datePlaceHolderDataItem.DateCalculation.Month != null)
   {
   dateTime = dateTime.AddMonths(datePlaceHolderDataItem.DateCalculation.Month.Value);
   }
   }

   if (datePlaceHolderDataItem.DateCalculation != null)
   {
   if (datePlaceHolderDataItem.DateCalculation.Day != null)
   {
   dateTime = dateTime.AddDays(datePlaceHolderDataItem.DateCalculation.Day.Value);
   }
   }

   if (datePlaceHolderDataItem.DateCalculation != null)
   {
   if (datePlaceHolderDataItem.DateCalculation.Hour != null)
   {
   dateTime = dateTime.AddHours(datePlaceHolderDataItem.DateCalculation.Hour.Value);
   }
   }

   if (datePlaceHolderDataItem.DateCalculation != null)
   {
   if (datePlaceHolderDataItem.DateCalculation.Minute != null)
   {
   dateTime = dateTime.AddMinutes(datePlaceHolderDataItem.DateCalculation.Minute.Value);
   }
   }

   if (datePlaceHolderDataItem.DateCalculation != null)
   {
   if (datePlaceHolderDataItem.DateCalculation.Second != null)
   {
   dateTime = dateTime.AddSeconds(datePlaceHolderDataItem.DateCalculation.Second.Value);
   }
   }

   if( datePlaceHolderDataItem.Format != null && !string.IsNullOrEmpty(datePlaceHolderDataItem.Format.value) )
   {
   return dateTime.ToString(datePlaceHolderDataItem.Format.value);
   }

   return dateTime.ToString();
   }

using the Object oriented and json (also xml) capability give the developer to design & create generic platform of rule language.

Lets look on the xml :

  command.exe file.xml -s{current_data_time:{"Format":{"value":"MM/dd/yyyy"},"CalcBy":{"Day":{"Value":-30}}}} -e{current_data_time:{"Format":{"value":"MM/dd/yyyy"},"CalcBy":{"Day":{"Value":15}}}}}

Enjoy.

2011-03-03T07:47:00.000-08:00

Interested on parallel, read this http://www.microsoft.com/downloads/en/details.aspx?FamilyID=86b3d32b-ad26-4bb8-a3ae-c1637026c3ee&displaylang=en

2010-08-23T03:53:00.000-07:00

"Exported mappings must come from the same importer" exception

Issue,

Look on the code below,

ServiceDescriptionImporter descriptionImporter = new ServiceDescriptionImporter();
   descriptionImporter.ProtocolName = "Soap";
   descriptionImporter.AddServiceDescription(serviceDescription, null, null);
   descriptionImporter.Style = ServiceDescriptionImportStyle.Client;
   descriptionImporter.CodeGenerationOptions =
   System.Xml.Serialization.CodeGenerationOptions.GenerateProperties;

   foreach(XmlSchema sc in serviceDescription.Types.Schemas.ToList() )
   {
   foreach (XmlSchemaObject service in sc.Includes)
   {
   if( service is XmlSchemaImport)
   {
   XmlSchemaImport schemaImport = service as XmlSchemaImport;


   XmlReader reader = new XmlTextReader(schemaImport.SchemaLocation);

   descriptionImporter.Schemas.Add( XmlSchema.Read(reader, null));

   }
   }
   }

and

private Assembly CompileAssembly(ServiceDescriptionImporter descriptionImporter)
   {
   // a namespace and compile unit are needed by importer
   CodeNamespace codeNamespace = new CodeNamespace();
   CodeCompileUnit codeUnit = new CodeCompileUnit();

   codeUnit.Namespaces.Add(codeNamespace);

   ServiceDescriptionImportWarnings importWarnings = descriptionImporter.Import(codeNamespace, codeUnit);

as you can in the first code fragment, i explicitly extracted the imported schema from the service description (wsdl wrapper), once the code did : ServiceDescriptionImportWarnings importWarnings = descriptionImporter.Import(codeNamespace, codeUnit); it throw an error, means 2 imported mapping exist, which one to use ? and it this case it throw an exception, what you should do, is , ignoring this code fragment :

foreach(XmlSchema sc in serviceDescription.Types.Schemas.ToList() )
   {
   foreach (XmlSchemaObject service in sc.Includes)
   {
   if( service is XmlSchemaImport)
   {
   XmlSchemaImport schemaImport = service as XmlSchemaImport;


   XmlReader reader = new XmlTextReader(schemaImport.SchemaLocation);

   descriptionImporter.Schemas.Add( XmlSchema.Read(reader, null));

   }
   }
   }

So, damm, its still not working, once you did nothing and the schema (wsdl) has import to ref schema, its still failed to load ref schema element, why ? the servicedescription importer does not import the schema, you should do it manually, so how to do it, the first example present the way, but its still not working, so here the changes you need to do

   WebClient http = new WebClient();

   if (webServiceHelperData != null &&
   webServiceHelperData.NetworkCredential != null &&
   !string.IsNullOrEmpty(webServiceHelperData.NetworkCredential.UserName))
   {
   http.Credentials = new NetworkCredential(webServiceHelperData.NetworkCredential.UserName,
   webServiceHelperData.NetworkCredential.Password);
   }

   // parse wsdl
   serviceDescription = ServiceDescription.Read(http.OpenRead(url), false);

   // build an importer, that assumes the SOAP protocol, client binding, and generates properties
   ServiceDescriptionImporter descriptionImporter = new ServiceDescriptionImporter();
   descriptionImporter.ProtocolName = "Soap";
   descriptionImporter.AddServiceDescription(serviceDescription, null, null);
   descriptionImporter.Style = ServiceDescriptionImportStyle.Client;
   descriptionImporter.CodeGenerationOptions =
   System.Xml.Serialization.CodeGenerationOptions.GenerateProperties;

   // Download and inject any imported schemas (ie. WCF generated WSDL)
   foreach (XmlSchema wsdlSchema in serviceDescription.Types.Schemas)
   {
   // Loop through all detected imports in the main schema
   foreach (XmlSchemaObject externalSchema in wsdlSchema.Includes)
   {
   // Read each external schema into a schema object and add to importer
   if (externalSchema is XmlSchemaImport)
   {
   Uri baseUri = new Uri(url);
   Uri schemaUri = new Uri(baseUri, ((XmlSchemaExternal)externalSchema).SchemaLocation);

   Stream schemaStream = http.OpenRead(schemaUri);
   System.Xml.Schema.XmlSchema schema = XmlSchema.Read(schemaStream, null);

   descriptionImporter.Schemas.Add(schema);
   }
   }
   }

all we do, is adding the
WebClient.

Enjoy

2008-11-05T06:30:00.000-08:00

How to get the last execution row in sql server and Cross apply

Have you ever think how to program better exception handling in your sql script, so this little article will teach how to do that, let's begin

The following query will give the last executed row in sql server

SELECT top 1 deqs.last_execution_time AS [Time], dest.text AS [Query]
FROM sys.dm_exec_query_stats AS deqs
CROSS APPLY sys.dm_exec_sql_text(deqs.sql_handle) AS dest
ORDER BY deqs.last_execution_time DESC

Notice : You can remove the top 1 and view all the last executed rows.

Cross & Apply Terms

The APPLY term let's you join a table to a table valued function.

No ON cluse used for this joining.

2 types of apply :

1. CROSS
Returns rows from the left side (Customers) if the table-valued-function returns rows.

2. OUTER
Returns all the rows on the left side (Customers) whether they return any rows in the table-valued-function or not. The columns that the table-valued-function returns are null if no rows are returned for the opposite row in the left side.

2007-11-28T06:08:00.000-08:00

Read this article , Dealt with top 20 GC articles.

2007-11-26T00:41:00.000-08:00

Repository, A new pattern

Most of the client -- Server application use a pattern called repository http://en.wikipedia.org/wiki/Repository.

Responsibilities :
- Cache (use it internally).
- reducing calling the server.
- Storage
- Provide base funtionllilty and abstract implementation over the repository,
- Offline warehouse.
- Middle tier between the client and server.

Repository problems,
- Decrease performance.
- Redundant calls to server.
- Not an abstract - Coupled to concrete implication.

The following new design of - ITEM SET repository, Give a new way of repository implementation.

So,

Item set

To be continue...

2007-06-26T08:38:00.000-07:00

Think on public resource file, instead of using the resfgen tool which does no have the advatages of the ResXFileCodeGenerator, Here a link, the ultimate tool of creating resource as strongly type class.

2007-06-20T02:41:00.000-07:00

Check if url is alive, some code

private static bool IsURLAlive(string strURL)
{

using (WebClient myWebClient = new WebClient())
{
char[] buf = new char[128];
try
{
using ( Stream myStream = myWebClient.OpenRead(strURL) )
{
StreamReader sr = new StreamReader(myStream);
sr.ReadBlock(buf , 0 , 127);
myStream.Close();
}
}
catch ( WebException webe )
{
return false;
}
return true;
}

}

2007-06-11T10:18:00.000-07:00

Inter process communication with events and delegates

Architecture Design

The Remote Object Process Requires A Reference To Each Class That Subscribe To The Event. In order for a remote server object to wire up an event (or register a callback) with a client, the server object needs to know a little bit about the client. This requires the server object to have a reference to each client that will subscribe to its events. This seems like a huge limitation for remote events. Imagine creating a server object to be used over remoting from many different types of client objects, and being required to add a reference to each of these client objects in the server object. Additionally, we may want to instantiate remote objects from within a client executable, and have the executable handle the remote event. Unfortunately, we cant add an executable as a reference to our server object.
So, having a client executable subscribe to remote objects events might seem impossible. However, there is a good way to get around this limitation with the use of a small event helper class, or event shim.
The idea is to create a small class that has a basic purpose of subscribing to remote objects events and then raising its own event. At first, this might seem like we are only postponing our event problem by propagating it up one level, but were really not. Remember, the real problem is our server object needs a reference to the client that will be subscribing to its event.
By placing a reference to this small event helper class in both the client and server assemblies, we circumvent the problem.
The server can see the object that will be subscribing to its event (the event helper) so it will know how to wire up the delegate callback for the event, and because our client has a reference to this small helper object it is able to subscribe to events on it.

IPC Event Design

2007-06-11T09:15:00.000-07:00

Command Pattern Example
Recently i asked to add a functionality to an existed code platform, some of the functionality execute before the operational platform and some after.
This leads to massive change all over the code, in order to refine the change i use the command pattern
The Solution
Create an interface which define the command call it IWrapCommand, Define the functions as command, part of the functions refer as before function and the other as after function.
The OperationWrapper use to wrap the code platform with the commands.
The before command execute in the constructor and the after command execute in the dispose.
It preferred to use the using(){} code pattern to wrap the code platform.
Here the code,
namespace OperationWrapping{ public interface IWrapCommand { void Execute(); }}

using System;
using System.Collections.Generic;
using System.Text;

namespace OperationWrapping
{
/// <summary>
/// The class add the abillity of wrapping a operational process with
/// commands before the operation process executin and after.
/// </summary>
public class

OperationWrapper : IDisposable
{
#region Data members
private List< IWrapCommand > m_commandsAfter = null;
#endregion

public OperationWrapper(IWrapCommand i_commandBefore ,
IWrapCommand i_commandAfter)
{
if (i_commandAfter != null)
{
m_commandsAfter = new List< IWrapCommand >();
m_commandsAfter.Add(i_commandAfter);
}

if (i_commandBefore != null)
{
i_commandBefore.Execute();
}
}

public OperationWrapper(List<IWrapCommand> i_commandsBefore ,
List<IWrapCommand> i_commandsAfter)
{
m_commandsAfter = i_commandsAfter;

if (i_commandsBefore != null)
{
foreach (IWrapCommand m_command in i_commandsBefore)
{
m_command.Execute();
}
}
}

///<summary>
///Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
///</summary>
///<filterpriority>2</filterpriority>
public void Dispose()
{
if (m_commandsAfter != null)
{
foreach (IWrapCommand m_command in m_commandsAfter)
{
m_command.Execute();
}
}

GC.SuppressFinalize(this);
}
}
}

namespace OperationWrapping
{
public interface IWrapCommand
{
void Execute();
}
}

AlfaCommand alfaCommand = new AlfaCommand();
DirtyCommand dirtyComamnd = new DirtyCommand();

using (OperationWrapper m_OperationDirty = new OperationWrapperalfaCommand , dirtyComamnd))
{
if (alfaCommand.IsContinue)
{
// the old code wrapped
}
}

2007-05-29T07:26:00.000-07:00

Scroll text into view in Rtf known as Rich Text Box, How to do that ?

1. The simple way, Just set the HideSelection property to false.

2. The geek way, SendMessage(this.Handle, (uint)WM_HSCROLL, (System.UIntPtr)3, (System.IntPtr)0);

The geek way can be implemented in every scrollable control.

2006-11-08T05:38:00.000-08:00

Notes on clickonce,

As Microsoft said clickonce is only attend to support light application - recommended.
Why Microsoft doesn't write it on clickonce abstraction page i know, but, in case you have such big application and you would like to give the user the feeling of web application , so maintenance will more easy, updating and versioning will be support on ease way (almost automatically), SE demand for web application but you have only winform application so click once is the result.

Where is the catch,
Registry, in case your application write to registry or you use file extension then you need to support it on other way, think using files as URL and file extension will be dropped.
Why ? Because registry demand for admin privilege, most of the cases the user is user and not admin, speak on maintenance !.

Shortcut, Forget on customize the shortcut.
You can customize but uninstall the application will not remove the zombie customized shortcut's.

Command line, Supports only with online strategy, forget from being offline and using the query string, why Microsoft does it to us ? why ? there is no technology limit why it does no support but there is no way how to do that so offline will be run with query string, note the only the app ref file can run the application in offline mode.

What to do,

Do not use registry at all (clickonce mode), in case you need the application tun also part of clickonce and as common application (winform + msi), so support registration by XML files.
Use shared directory Locate it under user application data (do not use the roaming user application data folder), use the application setting base architecture and provide provider which will read and write from the customize shared place.
In case your application need to support run files (accordance the application spec), then a url refer to shared resources (not part the clickonce deployment) with url to the application can replace the file extension use (in some cases).

Bye.

2006-11-01T23:46:00.000-08:00

Think on mspaint but in 3d, just amazing, this project very similar the MIT project called assit but more powerful.

You can download it and run it, You need jave runtime, simple installtion.

Enjoy.
http://www-ui.is.s.u-tokyo.ac.jp/~takeo/teddy/teddy.htm

2006-11-01T08:31:00.000-08:00

Imperial

2006-11-01T08:02:00.000-08:00

Coke and Mentos - The Show

2006-10-31T07:52:00.000-08:00

Important article on application setting .net 2.0

The old way and the new way.

2006-10-31T07:19:00.000-08:00

COM Self Registration - With interop dll
Referring to interop file with self regitstration ability just refer to the com dll and set the property Isolated to True and press save, then run the tlbimp with the dll and generate the interop file for that com and refer to it, the interop will be self registry for that com object part of the application.

2006-10-30T06:56:00.000-08:00

Click once Part 1

Suppose we have a desktop application(winform) and we need to convert it (get it) worked in web environment, Hard to maintain

Microsoft develop the new platform of having by click application execution, run from the network or install from the network (add shortcut) in local computer or event the legacy way of CDROM.

Called ClickOnce, Microsoft ship those platform with nice tools which ease to develop and handle so migrating your application to click once can be very easy and fun.

Things you need to look for when deploy ClickOnce in (for) your application,

• Security - Its hard to maintain secutiy permission sets acquired for the application deployment because each change in development phase can react on the deployment phase which is too risky.
I prefer to set the fulltrust for the application because my application almost do and will do everythings as ; IO, event log, Env, Registry and etc, So why to become involved in that story.

• Com object - Self registration is the key very simple in .net 2.0 (2005) just change a property and everythings will work, Why to use that / As all you know com object demand registration on local machine registry in order to work (Its a component), Read more on : Deploying COM Components with ClickOnce.

More issues i will update during my research and work on clickonce

2006-10-29T10:10:00.000-08:00

Something I encounter, in case you have got system which have thread on the air run in the background and they have their own mechanism of monitoring, in case the application trying to exit Application.Exit, or application.ExitThread, What you think will be, If you think your application is closing, so you are wrong, open the task manager and its still on the air, in previous 1.1 .Net framework it worked properly and application was really exit but now its not, So what you are going to do is To call Environment.Exit(code) and it will close.

2006-10-29T08:33:00.000-08:00

Hello,

Thought you write code and run it and oppos the computer is shut down, ha !
So its happened to me and I tried to figure out why, what cause to that bug - a critical one, so Here the code who can shut down the computer you on it, Remember, I have no warranty to the code and its conclusions.

So,

Open a modal dialog and write this code, i.e. when the dialog closing event occurred

Win32.SetForegroundWindow(this.Owner.Handle);

this.ShowInTaskbar = false;

(must be in the same order).

Enjoy or not.