C# and AX Development

LC Analyzer for AX

2011-05-02T09:12:00.000-07:00

Loncar Technologies has created an amazing product to improve development and analysis en AX (AX4, AX2009 and now AX2012). Take a look at http://www.loncartechnologies.com.

Also, get some free stuff: LC AOT Browser (browse the AOT filtered by a layer) and LC Project search (search for an object in all projects nodes).

Enjoy it !!!

Updating the caller Form/DataSource

2009-07-17T11:35:00.000-07:00

If we need to notify events to the caller form we can try this pattern:

In the child form, make a method named updateCaller and invoke it when you want to notify the parent:

void updateCaller()
{
    Common common;
    Object dataSource;
    Object caller;
    ;

    //-----------------------------------
    //We are notifying using the dataSource
    common = element.args().record();
    if (common
        && common.isFormDataSource()
        && formDataSourceHasMethod(common.dataSource(), identifierstr(SomethingWasHappend)))
    {
        dataSource = common.dataSource();
        dataSource.SomethingWasHappend();
    }
    //-----------------------------------

    //-----------------------------------
    //We are notifying using the form
    caller = element.args().caller();
    if (caller
        && classidget(caller) == classnum(SysSetupFormRun)
        && formHasMethod(caller, identifierstr(SomethingWasHappend)))
    {
        caller.SomethingWasHappend();
    }
    //-----------------------------------
}

Implement the handling method in the parent form:

void SomethingWasHappend()
{
    ;
    info("Something was happend (Form)");
}

Or if you prefer, in the DataSource:

void SomethingWasHappend()
{
    ;
    info("Something was happend (DataSource)");
}

Invoking it from a simple button inside the child form:

void clicked()
{
    super();

    element.updateCaller();
}

See a pratical sample in the form MarkupTrans (DataSource -> method write).

How to delete AOT nodes by code (UtilIdElements solution)

2009-06-27T10:55:00.000-07:00

In my old post: How to delete AOT objects (AX/Axapta), I have used the TreeNode class. There is another useful method by using the UtilIdElements system table described in the following links:

- MS KB 913530 (CustomerSource)
- forum topic: microsoft.public.axapta.programming - Currupt records in UtilIdElement and UtilElements

Warning: Serious problems might occur if you modify the UtilIdElements table using this or another method. Modify system tables at your own risk.

The code:

static void Job1(Args _args) 
{ 
    UtilIdElements utilElement; 
    ; 

    ttsbegin; 

    select utilElement 
        where utilElement.name == 'myElementName'
        && utilElement.utilLevel == utilEntryLevel::cus // any layer 
        && utilElement.recordType == utilElementType::Table; // object type 

    if (utilelement) 
    { 
        utilElement.delete(); 

        ttscommit; 
        info('Record should be deleted now.'); 
    } 
    else 
    { 
        ttsAbort; 
        info('Could not delete record, or it was not found.'); 
    } 
}

AOS crashed due corrupted node in the AOT

2009-06-27T10:20:00.000-07:00

Warning: this post is only informative, do not try to replicate the problem described here in a production environment. !!!!

The problem:

The problem occurred when we created a 'View' with one circular reference. After that, every time we tried to click over "Data Dictionary\Tables" or "Data Dictionary\Views", the AOS crashes.

How to reproduce the problem:

Warning: this post is only informative, do not try to replicate the problem described here in a production environment. !!!!

0. Make a backup. Also, make a copy of the AxCus.AOD file.
1. Create a simple view (ex. View1).
2. Add a new DataSource manually. Then, open DataSource's properties dialog and specify in the table field the name of the view you have created (ex. View1).
3. STOP at this point if you dont want to crash the AOS !!!.
4. Expand the DataSource node. Drag the field CreatedBy to the view's fields. It will create the CreatedBy1 field.
5. Save it if you are sure you want to continue. After this action, your AOS will crash. (oops !)

You can try to recover the error by deleting the corrupted node (ex. View1 or CreatedBy1 field) using this method: How to delete AOT objects (AX/Axapta) or this other: How to delete AOT nodes by code (UtilIdElements solution). None of them will work!!!.

The solution:

After several tries, the only solution was open the AxCus.AOD file in a binary editor (Visual Studio is enough) and perform the next steps.

Warning: Serious problems might occur if you modify the AxCus.AOD file using this or another method. Modify system files at your own risk.

0. Make a backup. Also, make a copy of the AxCus.AOD file.
1. Stop the AOS and open the AxCus.AOD in a binary editor.
2. Locate the "CreatedBy1" field data (or your corrupted node's name). Normally, it should be near to the end of the file. (Look at pictures for details).
3. Change the reference data. It is above the field's name. Put the value FF FF (65,535) in the parent and field ids.
4. Save the file.
5. Delete the index file axapd.aoi.
6. Start the AOS again.
7. Delete the corrupted view.

Image with the corrupted node:

Image with the fixed node:

It is probable the corrupted node stays alive in the AOT, so you can try the following code to remove it:

static void Job1(Args _args) 
{ 
    UtilIdElements utilElement; 
    ; 

    ttsbegin; 

    select utilElement 
        where utilElement.id == 65535; // Invalid ID we have writed in the AxCus.AOD file 

    if (utilelement) 
    { 
        utilElement.delete(); 

        ttscommit; 
        info('Record should be deleted now.'); 
    } 
    else 
    { 
        ttsAbort; 
        info('Could not delete record, or it was not found.'); 
    } 
}

Posting a ledger journal

2009-03-17T08:27:00.000-07:00

Here is the adapted example for posting a ledger journal line. Simply replace values between #s (#value#):

static void ExampleLedgerJournal(Args _args)
{
    LedgerJournalTable      ledgerJournalTable;
    LedgerJournalTrans      ledgerJournalTrans;
    LedgerJournalCheckPost  ledgerJournalCheckPost;
    NumberSeq               numberSeq;
    ;

    ttsbegin;

    // Journal name
    ledgerJournalTable.JournalName = "#JOURNALNAME#"; // ex. Daily, daytrans, etc.
    ledgerJournalTable.initFromLedgerJournalName();
    ledgerJournalTable.Name = "#DESCRIPTION#";  // description for this journal
    ledgerJournalTable.insert();

    // Voucher
    numberSeq = NumberSeq::newGetVoucherFromCode(LedgerJournalName::find(ledgerJournalTable.JournalName).VoucherSeries);
    ledgerJournalTrans.Voucher = numberSeq.voucher();

    // Lines
    ledgerJournalTrans.JournalNum = ledgerJournalTable.JournalNum;
    ledgerJournalTrans.CurrencyCode = CompanyInfo::standardCurrency();
    ledgerJournalTrans.ExchRate = Currency::exchRate(ledgerJournalTrans.CurrencyCode);
    ledgerJournalTrans.AccountNum = "#ACCOUNT#";
    ledgerJournalTrans.AccountType = LedgerJournalACType::Ledger;
    ledgerJournalTrans.AmountCurDebit = #VALUE#;
    ledgerJournalTrans.TransDate = systemDateGet(); //Avoid the Today function
    ledgerJournalTrans.OffsetAccount = "#OFFSET ACCOUNT#";
    ledgerJournalTrans.Txt = "#TXT#";
    ledgerJournalTrans.insert();

    //Posting the Journal
    ledgerJournalCheckPost = LedgerJournalCheckPost::newLedgerJournalTable(ledgerJournalTable, NoYes::Yes);
    ledgerJournalCheckPost.run();
    
    ttscommit;
}

Note: you can expand to include more than one line. Enjoy!

Delivering large strings through WCF

2009-02-06T08:18:00.000-08:00

If you have trouble sending large strings through WCF (more than 8192 bytes), it is probable you need to configure the parameter ReaderQuotas.MaxStringContentLength (default value is 8192). This parameter should be configured in both sides (client and server) as needed.

Set this by code:

NetTcpBinding tcp = new NetTcpBinding();
tcp.ReaderQuotas.MaxStringContentLength = 65535;

or modifying the config file:

...
<binding name="myTcpBinding">
    <readerQuotas maxStringContentLength="65535" />
    ...
</binding>
...

MG Instant Messaging for AX (Freeware)

2009-01-14T16:38:00.001-08:00

Based in MeetGate, I've developed this simple messaging system for use in DAX. This is not a fully Instant Messaging system yet, but provides a simple and efficient chat for improve co-workers communication, and the best part, is freeware.

The server includes only a small subset of MeetGate's features and was developed using .NET Framework 3.5 (WCF). I hope someday I could improve it with others important services like the "File Publication" for automatic distribution of files using the Presence Indicator.

You can use it for free under terms of The Microsoft Public License (Ms-PL).

Installation

Copy the server's files anywhere and install the windows service by running the command line: MGServerSvc /install. For uninstall it, simply run in the command line: MGServerSvc /uninstall.

The server's address can be configured by creating or editing the MGServerSvc.exe.config file as:

<configuration>
  <appSettings>
    <add key="BaseAddress" value="net.tcp://localhost:8000/MGServerService"/>
  </appSettings>
</configuration>

You need to copy the following files to the DAX client's directory, usually located in C:\Program Files\Microsoft Dynamics AX\40\Client\Bin:

MGControlAX.dll
MGLibrary.dll
MGClientLibrary.dll

For the Dynamics AX client, you need to install the ActiveX MGControlAX.dll. Dynamics AX cannot process events from managed components so the only way to notify events in DAX is by building an ActiveX control. In my case, I developed the MGControlAX.dll and before use it, you must register it as:

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\RegAsm MGControlAX.dll /tlb /codebase

NOTE: Remember the parameters: /tlb /codebase.

After that, you can import the .XPO project and edit the login method in the form MGToolbar. This form runs as a DAX toolbar so you can always access its buttons: login/logout, contacts and close.

void Login()
{
    UserId      currentUserId = curuserid();
    UserInfo    userInfo;
    ;

    select firstonly userInfo
        where userInfo.id == currentUserId;

    if (userInfo.name != "")
        MGControlX.UserName(userInfo.name);
    else
        MGControlX.UserName(userInfo.Id);

    MGControlX.Domain(userInfo.networkDomain);

    MGControlX.BaseAddress("net.tcp://localhost:8000/MGServerService/MGServerService");

    MGControlX.Login();
}

If you press the button contacts and it will show you the list of available contacts (This version is NOT users limited). If you make double click over an online contact you can start chatting with him. All changes in any contact's status is notified (Online/Offline) and you can see the icon as green or red respectively.

Files for download:

Server's files
The XPO file
Client's files

WCF interface for Dynamics AX

2008-12-29T21:48:00.000-08:00

In DAX you must implement a lot of interfaces, some of them using ADO, AIF, WS, MSMQ, etc. I have developed my own interface using WCF (.NET Framework 3.5).

In this interface, I built two applications: the server that interacts with DAX by using the Business Connector and the client that is a standalone application that doesn't need ADSI and can run outside of the organization, for example, to send or receive data from partners automatically.

The example bellow includes the source code for Visual Studio 2008 and the DAX project (.xpo). In this project, I transport data from a local database (MyTable) to an owner table in DAX: WCFMyTable. Also, I can detect changes from any DAX table and send data to the client. For example: when any customer is added, I can replicate this data to legacy systems.

The DAX project includes the following elements:

WCFMyTable: this is a sample table for receive data from the client side.

WCFConnTest: this class is used to test the connection with DAX. The method getCustomer can be used for retrieve the first customer in the table CustTable.

WCFTask: is a class that encapsulates the access to any table we want to send to the client.

    getRecord - returns a common record.
    getRecordAxXml - returns the xml representation for the record this task is belong to.
    MarkAsOK - update the task with a successful result when the client has processed it.
    MarkAsFAILED - update the task as "failed" when the client has processed it and an error was raised. Tasks with errors are not removed from the table for debugging purposes.

WCFSender: this is the class that can be used for create a task for deliver to the client. You must override the update, insert and delete methods in the table you want to send. Here are the insert and update methods from the Dimensions table:

public void insert()
{
    super();

    // Send this task
    WCFSender::SendThisRecord(this);
    // End
}

public void update()
{
    DimensionSetCombination dimensionSetCombination;
    ;

    ttsbegin;

    if (this.Closed != this.orig().Closed)
    {
        update_recordset dimensionSetCombination
            setting active = !this.Closed
            where dimensionSetCombination.Dimension[Dimensions::code2ArrayIdx(this.DimensionCode)] == this.Num;
    }

    super();

    ttscommit;

    // Send this task
    WCFSender::SendThisRecord(this);
    // End
}

WCFTasks: this table store all tasks pending for deliver to the client. The table only store the reference to the record by tableId and recId.

WCFInterface: this is the main class that is used for read tasks from server (method getNextTask) and send data to server (method ProcessTask).

getNextTask: with this method we can get the next task for processing in the client side and at the same time, we can update the previous one. By using the Company and previousCompany parameters, we can read tasks from several companies.

ProcessTask: this is the method called when we want to send data back to DAX. We can also send multi-company data by specifying the Company parameter.

Here are the files for download:

Visual Studio 2008 project (AXInterface.zip)
The DAX project: WCFInterface.xpo
MyTable.sql definition

License: The Microsoft Public License (Ms-PL)

Truncated real fields (ex. LineNum) when table is exported as XML

2008-12-28T20:24:00.000-08:00

When you are using the method xml() for exporting records from any table in DAX you could get inconsistency data for real fields.

The problem is located inside the method Global::xmlstring. In this method, the real type is exported only with 2 decimals. You must override this method in the appropiated layer to export reals with 8, 10, 12 or more number of decimals.

// Returns a XML string describing the given value of the given type.
static str xmlString(anytype value, Types theType, int indent=0)
{
    str r;
    Object o;
    Common record;

    ...

    r = strrep(' ', indent);

    switch (theType)
    {

    ...
    
    // Modified: original allows only 2 decimals,
    // now, we allow 12
    case Types::Real:       r += num2str(value,
                                        /* min chars */ 1,
                                        /* decimals */  12,  // Original = 2
                                        /* decimals = point */ 1,
                                        /* no thousand sep */ 0); break;

    ...

    }
    return r;
}

Some features in .NET Framework 3.0

2008-12-13T14:41:00.000-08:00

Implicitly typed variables and arrays

Implicit variables are useful for improve writing and reading code (not in all cases) and they are key for LINQ query expressions:

Before:

Dictionary<string, string> dict = new Dictionary<string, string>();
int[] Numbers = new int[] { 1, 2, 3, 4, 5 };
string[] s = new string[] { "a", "b", "c", "d" };

Now:

var dict = new Dictionary<string, string>();
var Numbers = new[] { 1, 2, 3, 4, 5 };
var s = new[] { "a", "b", "c", "d" };

Extensions Methods

That's an amazing feature for extend interfaces and classes that we don't have the source code or we don't want to modify directly.

Example: Suppose you have an interface that has two properties: Name and Age. Also, it has a method that display its data as 'Name=NameValue Age=AgeValue':

public interface ITestClass
{
    string Name { get; set; }
    int Age { get; set; }

    void Show();
}

But, we need to show this data in a different way in several parts of our code, for example: 'NameValue (AgeValue)'. By extending this interface we can simply invoke the method as 'tc.ShowCustom();' like if ShowCustom is part of this interface:

public static class TestClassExtension
{
    public static void ShowCustom(this ITestClass tc)
    {
        MessageBox.Show(tc.Name + " (" + tc.Age.ToString() + ")");
    }
}

...

ITestClass tc = GetTestClassInteface();
tc.Name = "Oscar";
tc.Age = 36;

tc.Show();
tc.ShowCustom(); // Now it appears like if this method is part of ITestClass (!!! amazing !!!)

NOTE: You can extend standard and base classes/interfaces like String, IEnumerator, etc.

Lambda Expressions

They are key for LINQ expressions and for reduce the use of delegates, here a little example:

var list = new List<string>();

list.Add("one");
list.Add("two");
list.Add("three");

bool bExist = list.Exists(delegate(string s) { return s == "two"; });

And using Lambda Expressions:

bool bExist = list.Exists(s => s == "two");

Anonymous types

Allows the on-the-fly creation of structures:

var person = new { Name = "Oscar", Age = 36 };

MessageBox.Show(person.Name + "(" + person.Age + ")");

Object/Collection Initializers

We can now initialize any property when we are creating some instance for objects or collections:

Timer t = new Timer() { Interval = 30000, Enabled = true };

var list = new List<string> { "one", "two", "three" };

References:

C# 3.0 Tutorial By Jonathan Worthington

C# Version 3.0 Specification MSDN

Error: "The element beneath element is unrecognized..."

2008-11-14T20:32:00.000-08:00

When you try to compile a workflow project (WWF) you got an error like this one: Error 1 The element <WFCompilationResourcesWithNoCulture> beneath element <ItemGroup> is unrecognized.

Solution:

Open the project's file (.csproj) using the Notepad and change the framework version from 3.5 to 3.0, it must look as shown below:

  <Import Project="$(MSBuildExtensionsPath)\Microsoft\Windows Workflow Foundation\v3.0\Workflow.Targets" />

Drawing objects in .NET (C#)

2008-10-24T18:53:00.000-07:00

Here is a little example of using some available objects for drawing in .NET (namespace System.Drawing):

private void Form1_Paint(object sender, PaintEventArgs e)
{
    // Create a graphics object from the form
    Graphics g = this.CreateGraphics();
    
    // Create a pen object
    Pen p = new Pen(Color.Red, 7);
    
    // Draw one horizontal line line
    g.DrawLine(p, new Point(10, 10), new Point(100, 10));

    // Drawing an image
    Image img = Image.FromFile("C:\\MyPicture.jpg");
    g.DrawImage(img, 120, 20, img.Width, img.Height); 

    // Array of points for some polygon
    Point[] points = new Point[]
    {
        new Point(20, 20),
        new Point(20, 100),
        new Point(50, 65),
        new Point(100, 100),
        new Point(85, 40)
    };

    Brush bs = new SolidBrush(Color.Aquamarine);

    // Fill a shape
    g.FillPolygon(bs, points);

    // Draw a shape defined by the array of points
    g.DrawPolygon(new Pen(Color.Black, 2), points);

    // Draw a text
    Font f = new Font("Arial", 40, FontStyle.Bold);
    g.DrawString("Hello, World!", f, Brushes.Blue, 10, 200);

    // Draw a icon
    g.DrawIcon(SystemIcons.Question, 260, 40);
    g.DrawIcon(SystemIcons.Shield, 260, 80);
}

Another way for drawing a picture is using the Bitmap object that provides methods for save it:

private void Form1_Paint(object sender, PaintEventArgs e)
{
    // Create a graphics object from the form
    Graphics g = this.CreateGraphics();

    // Read and draw the bitmap
    Bitmap bmp = new Bitmap("C:\\MyPicture.jpg");

    g.DrawImage(bmp, 10, 10, bmp.Width, bmp.Height);
}

Saving a modified bitmap:

private void button3_Click(object sender, EventArgs e)
{
    // Read the bitmap
    Bitmap bmp = new Bitmap("C:\\MyPicture.jpg");

    // Create a graphics from this bitmap
    Graphics g = Graphics.FromImage(bmp);

    // Draw a watermark
    Font f = new Font("Arial", 2, FontStyle.Bold);
    g.DrawString("That's me", f, Brushes.White, 10, 10);

    // Finally, save the bitmap in any available format from ImageFormat
    bmp.Save("c:\\MyPicture2.jpg", ImageFormat.Jpeg);
}

Or you can create a new bitmap for drawing inside it:

private void button3_Click(object sender, EventArgs e)
{
    // Create a new bitmap of 100x140 pixels
    Bitmap bmp = new Bitmap(100, 140);

    // Create a graphics from this bitmap
    Graphics g = Graphics.FromImage(bmp);
    
    // Fill its background with white color
    g.FillRectangle(new SolidBrush(Color.White), 0, 0, bmp.Width, bmp.Height);
    
    // Draw some objects
    Pen p = new Pen(Color.Blue, 8);
    g.DrawLine(p, 10, 10, 10, 80);
    g.DrawIcon(SystemIcons.Shield, 40, 40);
    
    // Save the bitmap
    bmp.Save("c:\\MyPicture3.jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
}

Anyway, there are a lot of objects and techniques for drawing in .NET, please refer to MSDN for more samples and documentation.

Encoding classes

2008-10-24T15:43:00.000-07:00

"Encoding is the process of transforming a set of Unicode characters into a sequence of bytes. In contrast, decoding is the process of transforming a sequence of encoded bytes into a set of Unicode characters."... (MSDN)

ASCIIEncoding (7-bit ASCII characters. ATENTION: this is NOT a 8-bit ASCII characters conversion!!!)
UTF7Encoding
UTF8Encoding
UnicodeEncoding (UTF-16)
UTF32Encoding

Here an example how to convert one string from Unicode to UTF-8 and back again.

// Create a string that contains Unicode characters.
String unicodeString =
    "This Unicode string contains two characters " +
    "with codes outside the traditional ASCII code range, " +
    "Pi (\u03a0) and Sigma (\u03a3).";

MessageBox.Show(unicodeString);

// Getting unicode string converted to UTF-8 as bytes values
UTF8Encoding utf8Encoding = new UTF8Encoding();
Byte[] utf8Bytes = utf8Encoding.GetBytes(unicodeString);

// These bytes are ready for deliver them through a socket port (TCP/IP)
// or for convert them to one encoded base64 string
string base64string = Convert.ToBase64String(utf8Bytes);
MessageBox.Show(base64string);

// Decode bytes back to string.
// Notice Pi and Sigma characters are still present.
String decodedString = utf8Encoding.GetString(utf8Bytes);
MessageBox.Show(decodedString);

RegEx brief

2008-10-24T12:56:00.000-07:00

For a complete explanation about using Regular Expressions please take a look to this great article by Jim Hollenhorst.

You can use the Expresso tool for build and test regular expressions.

Special characters:

.   Match any character except newline 
\w  Match any alphanumeric character 
\s  Match any whitespace character 
\d  Match any digit 
\b  Match the beginning or end of a word 
^   Match the beginning of the string 
$   Match the end of the string

Repetitions:

*     Repeat any number of times 
+     Repeat one or more times 
?     Repeat zero or one time 
{n}   Repeat n times 
{n,m} Repeat at least n, but no more than m times 
{n,}  Repeat at least n times

Ranges samples:

[aeiou]  matches any vowel
[.?!]    matches the punctuation
[a-z0-9] match any lowercase letter of the alphabet, or any digit

Negations:

\W       Match any character that is NOT alphanumeric 
\S       Match any character that is NOT whitespace 
\D       Match any character that is NOT a digit 
\B       Match a position that is NOT the beginning or end of a word 
[^x]     Match any character that is NOT x 
[^aeiou] Match any character that is NOT one of the characters aeiou

Some samples (there are a lot of best and optimal samples on Internet, look for them or use Expresso to build them):

\b\d\d\d-\d\d\d\d     Find seven-digit phone number
\b\d{3}-\d{4}         Find seven-digit phone number a better way
^\d{3}-\d{4}$         Validate a seven-digit phone number
\d{3}-\d{2}-\d{4}     Social security number



\ba\w*\b              Find words that start with the letter a
\b\w{6}\b             Find six letter words
\b\w{5,6}\b           Find all five and six letter words



(\d{1,3}\.){3}\d{1,3} A simple IP address finder

For more information about grouping, positive and negative lookarounds, Greedy and Lazy, please please take a look to this great article by Jim Hollenhorst.

Finally Certified !!!

2008-10-15T19:03:00.000-07:00

Yahooo,

Finally I finished my DAX certification, Microsoft Certified Business Management Solutions Professional - Development for Microsoft Dynamics AX.

Now, looking for a job here in Montreal, Canada. If someone knows where can I apply, please write me a comment.

Tks

How to print a different Sales Invoice per company in AX

2008-08-26T07:02:00.000-07:00

If you want to print a different Sales Invoice per every company you have, you must change the method printJournal in the table CustInvoiceJour and the form CustInvoiceJournal (MenuButton "SalesInvoiceShow" -> Copy, Original and Original print):

Modified method printJournal for the table CustInvoiceJour:

server void  printJournal(SalesFormLetter      salesFormLetter = null,
                          RecordSortedList     journalList     = null,
                          NoYes                copy            = NoYes::No)
{
    Args                parameters = new Args();
    MenuFunction        salesInvoiceMenu;
    ;

    // Show the correct report for the every company
    switch (strupr(curExt()))
    {
        case "OPP":
            salesInvoiceMenu = new MenuFunction(menuitemoutputstr(OPPSalesInvoice),MenuItemType::Output);
            break;
        
        default:
            salesInvoiceMenu = new MenuFunction(menuitemoutputstr(SalesInvoice),MenuItemType::Output);
    }
    // End

    parameters.caller(salesFormLetter);

    if (journalList)
        parameters.object(journalList);
    else
        parameters.record(this);

    salesInvoiceMenu.run(parameters);
}

For every MenuItemButton below the SalesInvoiceShow, you must override the clicked method as follows:

void clicked()
{
    Args                parameters = new Args();
    MenuFunction        salesInvoiceMenu;
    ;

    // Let the menuItemButton as this, with original parameters but
    // don't call super, to avoid call directly the report SalesInvoice
    //super();

    switch (strupr(curExt()))
    {
        case "OPP":
            salesInvoiceMenu = new MenuFunction(menuitemoutputstr(OPPSalesInvoiceCopy),MenuItemType::Output);
            break;

        default:
            salesInvoiceMenu = new MenuFunction(menuitemoutputstr(SalesInvoiceCopy),MenuItemType::Output);
    }

    parameters.caller(this);
    parameters.record(CustInvoiceJour);

    salesInvoiceMenu.run(parameters);
    // End
}

NOTE: You must use SalesInvoiceCopy, SalesInvoiceOriginal and SalesInvoice por Copy, Original and Original print respectively.

Rounding in AX (real to integer)

2008-08-12T10:24:00.000-07:00

How to perform a successful round in AX from real to integer?...
Well, the answer is: use the function decround.

static void Job1(Args _args)
{
    int i, ii;
    real r = 334.55, r2 = 334.14;
    ;

    i = decround(r, 0);
    ii = decround(r2, 0);

    // It shows 335, 334
    info(strfmt("%1, %2", i, ii));
}

Dynamics AX 2009 - Installation

2008-08-08T07:27:00.000-07:00

Here are the links for downloading Dynamics AX 2009 and its demo data. (Customer logon required).

https://mbs.microsoft.com/customersource/downloads/servicepacks/dynamicsax2009release.htm?printpage=false

https://mbs.microsoft.com/customersource/downloads/servicepacks/AX2009DemoData.htm

Download the database backup either with transactions or without them. But this method provides you with a demo license until june 9th, 2009.

First impressions:

The same core from Dynamics AX 4.0 but improved with a good additions like Workflow for example.

Running batch jobs automatically in Dynamics AX

2008-08-04T19:39:00.000-07:00

For learning how to create and launch batch jobs in Dynamics AX, please take a look to all topics in http://msdn.microsoft.com/en-us/library/aa549082(AX.10).aspx.

If we want to configure an automatic batch job server, we need to modify the class SysStartupCmdBatchRun, method infoRun, as follows:

void infoRun()
{
    batchRun batchRun = new batchRun();
    ;

    batchRun.parmUseForm(true);
    batchRun.parmGroupId(parm); // added
    batchRun.run();
}

And for a batch group named "myGroup" for example, we can use the Microsoft Dynamics AX Configuration Utility to specify the "Command to run at application startup:" as Batch_myGroup. This enable the AX client to run every batch job in this group.

We can also use the command line as {path}\ax32.exe startupcmd=batch_myGroup.

Creating a batch class in Dynamics AX

2008-08-04T17:46:00.000-07:00

For creating a batch class in Dynamics AX we can start from the Tutorial_RunbaseBatch class, but here is the explanation for understanding all its methods:

In the classDeclaration, we declare any variable that contains user's selection or preferences (for example, the customer account for launch a customer report). Also, we declare other variables like dialog fields, auxiliar variables, etc. But, the most important feature here, is the #localmacro.CurrentList declaration. This macro helps you to define which variables you want to save for running the class in batch mode (when not user interaction is available).

class Tutorial_RunbaseBatch extends RunBaseBatch
{
    // Packed variables
    TransDate       transDate;
    CustAccount     custAccount;

    // Dialog fields
    DialogField     dlgCustAccount;
    DialogField     dlgTransDate;

    // Current version
    // We can have different versions for different purposes
    #define.CurrentVersion(1)
    #define.Version1(1)
    #localmacro.CurrentList  // Our current variable list for save user's selected values
        transDate,
        custAccount
    #endmacro
}

The macro #define.CurrentVersion(1) and #define.Version1(1) are useful for scaling our class when we need to change/upgrade it preserving compatibility.

Now two methods: pack and unpack. These methods are used for store and retrieve user's preferences and perform the batch operation when none user are available (in batch mode). Here is the point where we use the macro defined previously:

public container pack()
{
    return [#CurrentVersion,#CurrentList];
}

public boolean unpack(container packedClass)
{
    Version version = RunBase::getVersion(packedClass);
;
    switch (version)
    {
        case #CurrentVersion:
            [version,#CurrentList] = packedClass;
            break;
        //case #otherVersion:
            //[version,#CurrentList, #otherList] = packedClass;
            //break;
        default:
            return false;
    }

    return true;
}

Bacause we need to ask the user about preferences for run this object (report, process, query, etc.), we must implement some methods:

- dialog: for build the custom dialog for prompting user's preferences.
- dialogPostRun: after dialog was created, you can perform other UI tasks here.
- getFromDialog: used for retrive user's preferences (dialog values).
- validate: here, you can perform a validation for any data entered by the user.

public Object dialog()
{
    DialogRunbase       dialog = super();
    ;
 
    // Creation of our custom dialog fields/controls to ask user for preferences
    dlgTransDate = dialog.addFieldValue(typeid(TransDate),transDate);
    dlgCustAccount = dialog.addFieldValue(typeid(CustAccount),custAccount);

    return dialog;
}

public void dialogPostRun(DialogRunbase dialog)
{
;
    super(dialog);
}

public boolean getFromDialog()
{
    ;

    // Retrieving user's preferences
    transDate   = dlgTransDate.value();
    custAccount = dlgCustAccount.value();

    return super();
}

public boolean validate()
{
    // We can perform some validations here
    if (false)
        return checkFailed("");

    return true;
}

Finally, the main method constructs the object from this batch class, and after prompting user and validation was successful, the run method is called to perform some task (in batch mode if it was selected):

server static Tutorial_RunbaseBatch construct()
{
    return new Tutorial_RunbaseBatch();
}

public void run()
{
    try
    {
        // Obviously, this code is silly, why show something to nobody?
        // remember, this code is running in batch without user interaction
        info(strfmt("Parameters: %1 for %2", transDate, custAccount));
    }
    catch(Exception::Deadlock)
    {
        retry;
    }
    catch(Exception::UpdateConflict)
    {
        throw Exception::UpdateConflict;
    }
    catch
    {
        throw Exception::Error;
    }
}

static void main(Args args)
{
    Tutorial_RunbaseBatch    tutorial_RunBase;
    ;

    // Instanciating this batch class
    tutorial_RunBase = Tutorial_RunbaseBatch::construct();

    // Prompting user and run if all is ok
    if (tutorial_RunBase.prompt())
        tutorial_RunBase.run();
}

Using ADO for interfacing AX with an external database

2008-08-04T16:43:00.000-07:00

If we need to interface any external database with Dynamics AX, we can achieve this task by using ADO and its AX available classes: CCADOConnection, CCADORecordSet, CCADOFields, CCADOField and CCADOCommand. Here an example:

static void ADOTestJob(Args _args)
{
    CCADOConnection     ccConnection;
    CCADOCommand        ccCommand;
    CCADORecordSet      ccRecordset;
    CCADOFields         ccFields;
    str                 st;
    str                 data1;
    int                 data2;
    ;

    ccConnection = new CCADOConnection();

    // Setting the connection string
    ccConnection.connectionString(StrFmt('Provider=SQLOLEDB.1;Persist Security Info=False;User ID=%3;Password=%4;Initial Catalog=%2;Data Source=%1'
            , 'servername'  // Server's IP or name
            , 'database'    // Database or catalog
            , 'user'        // Username
            , 'pwd'         // Password
            ));

    // Open the connection
    ccConnection.open();

    // Preparing the query
    st = "SELECT * FROM mytable";

    // Recordset object creation
    ccRecordset = new CCADORecordSet();

    // Executing the query
    ccRecordset.open( st, ccConnection );

    // Reading data
    while (!ccRecordset.EOF())
    {
        ccFields = ccRecordset.fields();
        
        // We can access fields either by name or by Index
        data1 = ccFields.itemName("FIELD1").value();
        data2 = ccFields.itemIdx(1).value();

        info(strfmt("Data %1, %2", data1, data2));
        
        // Read next record
        ccRecordset.moveNext();
    }

    // Closing the connection
    ccRecordset.close();
    ccConnection.close();
}

If we need to execute something (an UPDATE, DELETE, etc.), we can use the CCADOCommand:

void ExecuteSQLExt(str sql)
{
    // Creating the ADO Command object
    ccCommand = new CCADOCommand();

    // Associate it with an existing opened connection
    ccCommand.activeConnection(ccConnection);

    // Executing the command
    ccCommand.commandText(SQL);

    ccCommand.execute();
}

NOTE: For working with ADO constants like cursor types (adOpenForwardOnly, adOpenKeyset, adOpenDynamic, adOpenStatic), we only need to include the macro CCADO (#CCADO) where they are defined.

SQL 2005 to Linked SQL Server 7.0/2000 error

2008-08-04T09:39:00.000-07:00

If you get this error trying to access a linked server (7.0/2000) from an SQL 2005 64-bits:

The stored procedure required to complete this operation could not be found on the server. Please contact your system administrator. Msg 7311, Level 16, State 2, Line 1 Cannot obtain the schema rowset "DBSCHEMA_TABLES_INFO" for OLE DB provider "SQLNCLI" for linked server "<LinkedServerName>". The provider supports the interface, but returns a failure code when it is used.

It is probable that the linked server is missing the stored procedure "sp_tables_info_rowset_64", so, run the following script for the master database:

CREATE PROCEDURE [sp_tables_info_rowset_64] 
@table_name sysname, 
@table_schema sysname = NULL, 
@table_type nvarchar(255) = null 
AS 
DECLARE @Result int
SELECT @Result = 0

EXEC @Result = sp_tables_info_rowset @table_name, @table_schema, @table_type 
GO

More information: http://support.microsoft.com/default.aspx?scid=kb;en-us;906954

Tips for Upgrade Axapta 3.0 to Dynamics AX 4.0

2008-08-03T17:41:00.000-07:00

- Be careful with table's conversion. If you had modified methods or fields, is probable that table will be converted losing functionality like standard methods, delete actions, indexes, fields, etc.

For example, when we converted the VendTable, the field CountryId wasn't properly converted (renamed as CountryRegionId) because we had modifications in this field and a lot of compilation errors was raised, so, we removed all modifications before upgrade this table to AX 4.0, then, we applied all changes before make the database conversion.

To ensure a successful conversion, you need to compare every modified table between your layer (CUS, VAR, etc.) and any system layer (SYS, SYP, etc.) Verifying that you are not losing fields, indexes, methods, delete actions, etc.

- Forms must be converted manually because you can lose a lot of functionality. You can use this tip: make the upgrade not matter about errors, then make a copy of the converted form, delete your custom layer (CUS, VAR, etc.) and use drag and drop to pass controls and methods from the copied form to the standard form until you complete the customization you want to have.

Don't forget to compare layers to avoid losing of standard functionality, specially with methods and events.

- Reports has changed in architecture. In Axapta 3.0 you had an auxiliar/helper class that was responsible for prompting query's values and other tasks. In AX 4.0, that functionality was included inside the class Report, so you need to pass manually any change made in reports preserving the new architecture.

- RecIds are now long integers (64-bits). Any field or EDT that references RecIds must be converted to 64-bits.

- Left justified fields offers a better performance with SQL Server 2005.

- If you have a partner's logon, read the following article: https://mbs.microsoft.com/customersource/documentation/whitepapers/AX40_UpgradeOptimization_SQL

- Fix tempdb and MaxDegree for Parallelism as explained in http://blogs.msdn.com/axperf/archive/2008/03/10/welcome-database-configuration-checklist-part-1.aspx

- Execute AxDbUpgrade.exe using the /P # parameter (where # = number of physical processors)

- You are going to lose some permissions and groups. Take your time for rebuild them.

- OLAP configuration for SQL Server 2005 is required. See my other post Configuring Analysis Services 2005 for AX for details.

- Sending e-mails from a client using Windows Vista could raise an error. You must use an Outlook 2007 client.

More details in Experiences upgrading Axapta 3.0 to Dynamics AX 4.0

- Follow the upgrade flowchart step by step:

Experiences upgrading Axapta 3.0 to Dynamics AX 4.0

2008-08-03T12:04:00.000-07:00

Some notes from my experience upgrading Axapta 3.0 to Dynamics AX 4.0 in Transportes Botero Soto, Colombia.

- Any modification in system classes must be removed before make the upgrade. After that, you can apply changes manually. (ex. Avoiding users to open more than one session in Axapta (Dynamics AX))

- In Axapta 3.0, we had created a CustomerRef field in the SalesLine table. In AX, this field was created by Microsoft. So, to avoid conflict, we need delete it before perform the AOT conversion.

- For releasing disk space, we can delete data in tables like sysDatabaseLog, sysUserLog, axOldRecIds, axOldToNewRecIds, OlapAmount. Also, we can truncate the transaction log before conversion. See How to truncate any Database's log file.

- The class ledgerJournal not exist anymore in AX 4.0 and if you are using it for generate a ledger journal number, you must change the code ledgerJournal.newJournalNum(true); by NumberSeq::newGetNum(LedgerParameters::numRefJournalNum(), true).num();

- The class Specification was changed in 4.0. Now, we must set the reference table id parameter.

  - Instancing before: specification = new Specification_OffsetVoucher(vendTable.tableId, vendTable.recId); now, specification = Specification::construct(SpecType::OffsetVoucher, vendTable.tableId, vendTable.recId);

  - For the specification creation now we must include the table's id: specification.create(vendSettlement.TableId, vendSettlement.recId, vendSettlement.settleAmountCur, _vendTrans.currencyCode);

  - For delete one specification (marked open transactions), before: specification.deleteTransact() and now specification.deleteSpecifications()

  - The field specTrans.RefId not exist anymore, now it is called RefRecId and also, we must set the field RefTableId. - RecIds in AX 4.0 are long-integers (64-bits), for that reason, any assignment with an integer variable will lose precision/accuracy, so we must ensure that any custom field related to RecIds, is large as 64-bits.

- If we have modified Forms in Axapta 3.0, we must make the conversion manually, we can use this technique for optimize the copy of tabs, controls, buttons, methods, etc. Duplicate the converted form, delete it from the custom layer (in our case: CUS), then use drag and drop for any custom control and owner method.

- Good coding practices make easiest the conversion:

   - Put comments at the starting and ending block of source code modified (//Ini TBS … // End TBS…) and always try to write a good explaination for reasons you had made the change (that is not obvious for anyone different than you).

   - Use braces "{}" to identify correctly blocks of source code, no matter if the instruction only takes one line. This provide a good "eagle view" for any change and inherent logic, avoiding waste of time.

   - Use spaces with assignment or logic operators ("x = y" instead of "x=y"). Again, this provide an "eagle view" because the brain doesn't need to separate every instruction's member.

   - Use four (4) spaces indentation (recommended).

   - Use parenthesis "()" when logic instructions comes, ex. if (x==y && z!=w || x!=w is less visible than if ( (x == y) && (z != w) || (x != w)) … in the last one, you can identify operators quickly.

   - Use two or more lines for "select" instructions putting the "index", the "where" and logic instructions in their own indented line. This show the real objective of the "select" instruction.

- When we need to hide/remove an user control, the best choice is doing it by code (element.control.visible(false);).

- If you need to change standard code, you must enclosed it with comments and work with a copy to avoid lose of tracing.

- Any custom menu must be added manually, to avoid lose of properties like icon, help text, ext.

- EDTs in version 4.0 should be left aligned instead of right aligned like in version 3.0. You must review custom tables to get a better performance from SQL Server.

- Reference to non-existing labels can be found looking from the root node every item that contents data like "@GLxxxx".

- If you need to change a base enum, the new items can produce conflicts with new standard items in future versions. To avoid this, you can set the value for new custom items starting from a none typical value like 50, 51, 52, etc.

- In the conversion, post-syncrhonization, if you get an error from SalesTable and SalesLine (fields ShippingDateRequested and ShippingDateConfirmed), is probable that you have records in SalesTable without lines in SalesLines. Then, you need to remove that records.

- The upgrade process for the database could raise an error with the table AxOldToNewRecIds. In several groups, I found that this table can be deleted without problem. After upgrade, you can copy the table manually.

- If you have SQL Server 2005 for Axapta 3.0, it is probable that you get some errors with SysDiagrams and dt.Properties. You can delete those objects before use the tool AxDBUpgrade.

- You got the error: Insufficient rights to execute Method … : you must delete all data from SysConfig table (license data table). It will be filled with the correct licenses code when needed.

- Invalid license code for this language. If you have a license for a language different than english, you need to change the value "en-us" by the correct value (ex. "es") for the Administrator user. (Tables dbo.USERINFO and dbo.SYSUSERINFO)

- Error synchronizing the table SalesParmTable because it has duplicated keys. This is an "intermediated" table, so, you can delete its contents(?).

- Synchronization error: "The total, internal size of the records in your joined SELECT statement is 26208 bytes, but Microsoft Dynamics is by default performance-tuned not to exceed 24576 bytes." You need to specify a bigger value in the tab 'SQL in the Dynamics AX Server Configuration tool (Administrative tools). My upgrade value was 49152.

- If you have custom fields in tables smmQuotationLine and smmQuotationTable, you need to change the code in the class ReleaseUpdateDB39_Smm to include all custom fields when upgrading data.

Configuring Analysis Services 2005 for AX

2008-08-03T10:54:00.000-07:00

For use Analysis Services 2005 with Dynamics AX, we need to ensure that DSO (Decision Support Objects) is well configured. Take a look to the following post for more information (NOTE: this post refers to Project 2007 but it is applicable to AX):

http://www.pptspaces.com/msprojectreporterblog/Lists/Posts/Post.aspx?ID=25

Important steps:

1. Ensure you have installed the following components:
  - Microsoft SQL Server Native Client
  - Microsoft SQL Server 2005 Management Objects Collection
  - Microsoft SQL Server 2005 Backward Compatibility Components

2. Create the old style shared folder (MSOLAPRepository$), normally in C:\Program Files\Microsoft SQL Server\MSSQL.2\OLAP\DSO9 for example.

  - Share this folder as MSOLAPRepository$.
  - Se permissions for EveryOne or any OLAP users group as Change (they need permissions to modify folder's content).
  - Set Full control to SQLServer2005MSOLAPUser$SERVERNAME$MSSQLSERVER. This user can be located in the ServerName instance.

3. Copy msmdrep.mdb to this location (DSO9). You can get a copy of this file from http://www.pptspaces.com/msprojectreporterblog/Shared%20Files/msmdrep.zip

4. Configure data access connection and locks folders: (Open the Analysis Services's properties dialog using the SQL Server Mananagement studio and selection the option "Show Advance (All) properties")

  - Configure the DSO\LocksDirectory property with the correct path, ex. C:\Program Files\Microsoft SQL Server\MSSQL.2\OLAP\DSO9

  - Configure the DSO\ RemoteLocksDirectory property as \\ServerName\MSOLAPRepository$\. Here is the tip different from the original post.

  - Configure the DSO\ RemoteRepositoryConnectionString selecting the Microsoft Jet 4.0 OLE DB Provider but setting the path as \\ServerName\MSOLAPRepository$\msmdrep.mdb. Here is another difference from the original post.

  - Configure the DSO\ RepositoryConnectionString property but in this case, use the full local path for the msmdrep.mdb file, ex. C:\Program Files\Microsoft SQL Server\MSSQL.2\OLAP\DSO9\msmdrep.mdb

Thats all, try it, transfer and process some cubes.

NOTE: Remember define use'r permissions (for cubes) and administrator's permissions (for server/system).

AX Database Performance

2008-08-03T07:55:00.000-07:00

Here is an excellent post about AX database performance applying a checking list:

http://blogs.msdn.com/axperf/archive/2008/03/10/welcome-database-configuration-checklist-part-1.aspx

Some tips:

- Max Degree of Parallelism (MAXDOP instance-wide)
- OLTP (normal operations0: Set Max Degree of Parallelism to 1)
- Upgrade: set to # of physical processor cores, ...
- Activate AWE only for 32-bits systems
- Separate log and data files
- Configure several temp DBs
- Set Read-Committed Snapshot Isolation = true

ALTER DATABASE <ax database name>

    SET READ_COMMITTED_SNAPSHOT ON;

- Physical storage configuration (RAID, separate logs and data files, etc.)

AX user cannot make login

2008-07-25T15:42:00.000-07:00

Sometimes, an user cannot make login with AX 4.0. It happen if user was moved or any change in the Active Directory was performed.

Solution: disable the user, save the record. Then, re-enable the user and save again.

AX refresh the user's SID executing this action.

How to enable or disable joined dataSources

2008-06-18T13:06:00.001-07:00

Here the problem: I need a method to enable or disable an exist join link between two datasources, so, I found two practical solutions:

1. Using only X++ code:

- The init method (in this sample, I'm using the vendTrans datasource):

void init()
{
    super();

    ...

    // Here starts my code
    myDS = this.query().dataSourceTable(tableNum(VendTrans)).addDataSource(tableNum(myTable));
    myDS.joinMode(JoinMode::ExistsJoin);
    myDS.addLink(fieldNum(VendTrans, DocumentNum), fieldNum(myTable, DocumentNum));
    myQueryRange = myDS.addRange(fieldnum(myTable, anyField));
    myDS.enabled(false);  // Disabled until we need it
    // End
}

- Then, in anywhere:

    if ((myFilterValue == "") || (myFilterValue == "*"))
    {
        myDS.enabled(false);  // Disable the DS, then none filter is applied
    }
    else
    {
        ...

        myQueryRange.value(myFilterValue);
        myDS.enabled(true);  // Enable DS, then any filter is applied with the existing join link
    }
    
    VendTrans_ds.executeQuery();

2. Using DataSources in design mode:

- If the DataSource was added in design mode, we need to change the previous code as this:

    if ((myFilterValue == "") || (myFilterValue == "*"))
    {
        myTable_ds.query().dataSourceTable(tablenum(myTable)).enabled(false);  // Disable the DS, then none filter is applied
    }
    else
    {
        ...

        myQueryRange.value(myFilterValue);
        myTable_ds.query().dataSourceTable(tablenum(myTable)).enabled(true);  // Enable DS, then any filter is applied with the existing join link
    }
    
    VendTrans_ds.executeQuery();

NOTE: myQuery value must be initialized in the init method from myTable datasource and the relation between tables must be specified (In this sample, myTable.myField = vendTrans.DocumentNum).

I'm back

2008-06-03T11:45:00.000-07:00

Hi everyone!

I'm back. I was moving to Canada with all my family. Now, here we are, in Montreal, QC, Canada.

Comming soon: SharePoint, .NET windows applications, Dynamics AX improvements, and more.

Printing directly to PDF in AX

2008-03-17T14:46:00.000-07:00

References: AxaptaPedia

To achieve this task, we need to set some values to the printing settings before running the report like this:

// Variables
PrintJobSettings    printJobSettings;
ReportRun           myReportRun;

...


// Getting the report settings
printJobSettings = myReportRun.printJobSettings();

// Setting our parameters
printJobSettings.setTarget(PrintMedium::File);
printJobSettings.preferredTarget(PrintMedium::File);

printJobSettings.format(PrintFormat::PDF);
printJobSettings.preferredFileFormat(PrintFormat::PDF);

printJobSettings.fileName("c:\\attachment.pdf");

// Saving values
myReportRun.unpackPrintJobSettings(printJobSettings.packPrintJobSettings());

// Running the report
myReportRun.run();

Before running the report, we can set query's values:

query = myReportRun.query();
qbds = query.dataSourceNo(1);

qbds.range(1).value(_custTable.CustAccount);
qbds.range(2).value("");
qbds.range(3).value(queryvalue(NoYes::Yes));

myReportRun.run();

NOTE: For using a PDF Printer like "PDFCreator", simply set the deviceName like this:

myReportRun.deviceName("PDFCreator");

Complex Queries in AX

2008-03-05T08:11:00.000-08:00

Overview from Axaptapedia - Expressions in query ranges

For build complex queries, we can use any field, but normally, DataAreaId is used.

query = new Query();
dsInventTable = query.addDataSource(tableNum(InventTable));

// Add our range
queryBuildRange = dsInventTable.addRange(fieldNum(InventTable, DataAreaId));

Query values:

queryBuildRange.value(strFmt('((ItemType == %1) || (ItemId == "%2"))', 
    any2int(ItemType::Service),
    queryValue("B-R14")));

Working with dates:

queryBuildRange.value(strFmt('(ModifiedDate > %1)', Date2StrXpp(01012000)));

Complex queries with relations:

query = new Query();
dsInventTable = query.addDataSource(tableNum(InventTable), tableStr(InventTable));
dsInventItemBarCode = dsInventTable.addDataSource(tableNum(InventItemBarCode), tableStr(InventItemBarCode));
dsInventItemBarCode.relations(true);
dsInventItemBarCode.joinMode(JoinMode::ExistsJoin);
 
// Add our two ranges
queryBuildRange1 = dsInventTable.addRange(fieldNum(InventTable, DataAreaId));
queryBuildRange2 = dsInventItemBarCode.addRange(fieldNum(InventItemBarCode, DataAreaId));

queryBuildRange2.value(strFmt('(ModifiedDate > InventTable.ModifiedDate)'));

queryBuildRange2.value(strFmt('((%1.%2 == %3) || ((%1.%2 == %4) && (%1.%5 == %6)))',
    query.dataSourceTable(tableNum(InventTable)).name(), // InventTable %1
    fieldStr(InventTable, ItemType), // ItemType %2
    any2int(ItemType::Service), // %3
    any2int(ItemType::Item), // %4
    fieldStr(InventTable, ItemId), // ItemId %5
    fieldStr(InventItemBarCode, ItemId))); // %6

Dimensions: Corrected. Thanks Alex.

queryBuildRange = dsLedgerTrans.addRange(fieldId2Ext(fieldNum(LedgerTrans, Dimension),1)); 

queryBuildRange.value("some value");

Displaying the traditional Main Menu in AX

2008-03-01T07:12:00.000-08:00

If you don't like the new Navigation Pane from Dynamics AX, you can turn on the traditional Main Menu dialog by changing the SysUserSetup form that allows you to specify the Startup Menu item. Open the SysUserSetup form from the AOT, go to method buildStartupMenuCombo, line 56, and change it as:

//if( ! mainMenuItems.in(object.treeNodeName()) )
if ((!mainMenuItems.in(object.treeNodeName())) || (object.AOTname() == "MainMenu"))

Now, you can open the Options dialog and set the Main Menu as the Startup Menu item.

Sending mail using SmtpClient

2008-02-09T08:51:00.000-08:00

Self explained sample:

// Mail message construction
MailMessage mm = new MailMessage("youraccount@gmail.com", "destination@mail.com");

// content
mm.Subject = "testing message";
mm.Body = "hello... from .net c# mailmessage";
mm.CC.Add("copycc@mail.com");
mm.CC.Add("copycc2@mail.com");
mm.Bcc.Add("copybcc@mail.com");

// some attachments
mm.Attachments.Add(new Attachment("c:\\filename.txt"));

// Sending message
SmtpClient sc = new SmtpClient("smtp.gmail.com", 587);

// our account credentials
sc.Credentials = new NetworkCredential("youraccount@gmail.com", "yourpassword", "");
sc.EnableSsl = true;

// Catching result
try
{
    sc.Send(mm);
    MessageBox.Show("Message sent");
}
catch (Exception ex)
{
    MessageBox.Show("Error: " + ex.Message);
}

For send HTML content and pictures, we need to use Alternated views with LinkedResource instead of the Body property.

// Mail message construction
MailMessage mm = new MailMessage("youraccount@gmail.com", "destination@mail.com");

// content
mm.Subject = "testing message";

//mm.Body = "hello... from .net c# mailmessage"; // deprecated, now we're using alternate views

mm.CC.Add("copycc@mail.com");
mm.CC.Add("copycc2@mail.com");
mm.Bcc.Add("copybcc@mail.com");

// some attachments
mm.Attachments.Add(new Attachment("c:\\filename.txt"));

// An HTML message body including one image
string htmlBody = "<html><body>hello... from .net c# mailmessage<br><img src=\"cid:MyPicture\"></body></html>";

AlternateView avHtml = AlternateView.CreateAlternateViewFromString(htmlBody, null, MediaTypeNames.Text.Html);

// Now, linking our image as an embedded resource
LinkedResource MyPicture = new LinkedResource("c:\\MyPicture.jpg", MediaTypeNames.Image.Jpeg);
MyPicture.ContentId = "MyPicture";

avHtml.LinkedResources.Add(MyPicture); // Linking the image

// For clients that do not support HTML content
string textBody = "hello... from .net c# mailmessage... You're missing my picture.";

AlternateView avText = AlternateView.CreateAlternateViewFromString(textBody, null, MediaTypeNames.Text.Plain);

// Add the alternate views
mm.AlternateViews.Add(avHtml);
mm.AlternateViews.Add(avText);


// Sending message
SmtpClient sc = new SmtpClient("smtp.gmail.com", 587);

// our account credentials
sc.Credentials = new NetworkCredential("youraccount@gmail.com", "yourpassword", "");
sc.EnableSsl = true;

// Catching result
try
{
    sc.Send(mm);
    MessageBox.Show("Message sent");
}
catch (Exception ex)
{
    MessageBox.Show("Error: " + ex.Message);
}

For asynchronous operations:

// Mail message construction
MailMessage mm = new MailMessage("youraccount@gmail.com", "destination@mail.com");

// content
mm.Subject = "testing message";
mm.Body = "hello... from .net c# mailmessage";
mm.CC.Add("copycc@mail.com");
mm.CC.Add("copycc2@mail.com");
mm.Bcc.Add("copybcc@mail.com");

// some attachments
mm.Attachments.Add(new Attachment("c:\\filename.txt"));

// Sending message
SmtpClient sc = new SmtpClient("smtp.gmail.com", 587);

// our account credentials
sc.Credentials = new NetworkCredential("youraccount@gmail.com", "yourpassword", "");
sc.EnableSsl = true;

// Asynchronous sending
sc.SendCompleted += new SendCompletedEventHandler(sc_SendCompleted);

sc.SendAsync(mm, null);

void sc_SendCompleted(object sender, AsyncCompletedEventArgs e)
{
    if (e.Cancelled)
        MessageBox.Show("Message cancelled");
    else if (e.Error != null)
        MessageBox.Show("Error: " + e.Error.ToString());
    else
        MessageBox.Show("Message sent");
}

Creating Code at Runtime (Part 3)

2008-02-08T18:28:00.000-08:00

See Creating Code At Runtime - Part 1
See Creating Code At Runtime - Part 2

I want to change our previous delegate for one more standard, like EventHandler. The new class must looks like:

public delegate void BeforeBuildFullNameHandler(object sender, EventArgs e);

public class Person
{
    private string _firstname;
    private string _lastname;

    public event BeforeBuildFullNameHandler BeforeBuildFullName;

    public string FirstName
    {
        get { return _firstname; }
        set { _firstname = value; }
    }

    public string LastName
    {
        get { return _lastname; }
        set { _lastname = value; }
    }

    public Person()
    {
        _firstname = "";
        _lastname = "";
    }

    public Person(string firstname, string lastname)
    {
        FirstName = firstname;
        LastName = lastname;
    }

    public string GetFullName()
    {
        DispatchBeforeBuildFullName();

        return FirstName + " " + LastName;
    }

    public void DispatchBeforeBuildFullName()
    {
        if (BeforeBuildFullName != null)
            BeforeBuildFullName(this, new EventArgs());
    }
}

Steps: 1. We need to change the Invoke, BeginInvoke and EndInvoke methods:

// Now, we need to implement three methods:
// Invoke, BeginInvoke and EndInvoke
MethodBuilder methodBuilder;

// Because we are using a delegate with parameters,
// then, we need to declare four parameters for 
// asynchronous operations: AsyncCallback and object (any)
Type[] beginParameters = new Type[4];

beginParameters[0] = typeof(object);
beginParameters[1] = typeof(EventArgs);
beginParameters[2] = typeof(AsyncCallback);
beginParameters[3] = typeof(object);

// BeginInvoke for Asynchronous call
methodBuilder = delegateBuilder.DefineMethod("BeginInvoke", maDelegate, typeof(IAsyncResult), beginParameters);
methodBuilder.SetImplementationFlags(mia);

// EndInvoke for Asynchronous call
methodBuilder = delegateBuilder.DefineMethod("EndInvoke", maDelegate, typeof(void), new Type[] { typeof(IAsyncResult) });
methodBuilder.SetImplementationFlags(mia);

// Invoke for Synchronous call
methodBuilder = delegateBuilder.DefineMethod("Invoke", maDelegate, typeof(void), new Type[] { typeof(object), typeof(EventArgs) });
methodBuilder.DefineParameter(1, ParameterAttributes.In, "sender");
methodBuilder.DefineParameter(2, ParameterAttributes.In, "e");
methodBuilder.SetImplementationFlags(mia);

2. Also, we need to change the Dispath method:

// And here, the code for the dispatchMethod
ilgen = dispatchMethodBuilder.GetILGenerator();

LocalBuilder local = ilgen.DeclareLocal(typeof(bool));
System.Reflection.Emit.Label label = ilgen.DefineLabel();

ilgen.Emit(OpCodes.Nop);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldfld, eventFieldBuilder);    // Asking for the event field
ilgen.Emit(OpCodes.Ldnull);                        // is null ?
ilgen.Emit(OpCodes.Ceq);
ilgen.Emit(OpCodes.Stloc_0);
ilgen.Emit(OpCodes.Ldloc_0);
ilgen.Emit(OpCodes.Brtrue_S, label);            // if null, return

ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldfld, eventFieldBuilder);    // call the event

ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Newobj, typeof(EventArgs).GetConstructor(Type.EmptyTypes)); // Now, we include a new empty EventArgs object

ilgen.Emit(OpCodes.Callvirt, delegateType.GetMethod("Invoke"));

ilgen.Emit(OpCodes.Nop);
ilgen.MarkLabel(label);
ilgen.Emit(OpCodes.Ret);

Creating Code at Runtime (Part 2)

2008-02-08T17:46:00.000-08:00

See Creating Code At Runtime - Part 1
See Creating Code At Runtime - Part 3

If we need to handle events and delegates, as the following sample:

public delegate void BeforeBuildFullNameHandler();

public class Person
{
    private string _firstname;
    private string _lastname;

    public event BeforeBuildFullNameHandler BeforeBuildFullName;

    public string FirstName
    {
        get { return _firstname; }
        set { _firstname = value; }
    }

    public string LastName
    {
        get { return _lastname; }
        set { _lastname = value; }
    }

    public Person()
    {
        _firstname = "";
        _lastname = "";
    }

    public Person(string firstname, string lastname)
    {
        FirstName = firstname;
        LastName = lastname;
    }

    public string GetFullName()
    {
        DispatchBeforeBuildFullName();

        return FirstName + " " + LastName;
    }

    public void DispatchBeforeBuildFullName()
    {
        if (BeforeBuildFullName != null)
            BeforeBuildFullName();
    }
}

Steps: 1. Define our dispatching method early, before the GetFullName method.

// Early definition of this method because we use it in GetFullName.
MethodBuilder dispatchMethodBuilder = personBuilder.DefineMethod("DispatchBeforeBuildFullName", MethodAttributes.Private, typeof(void), Type.EmptyTypes);

2. Change the GetFullName method:

// Now, a custom method named GetFullName that concatenates FirstName and LastName properties
MethodBuilder mGetFullNameBuilder = personBuilder.DefineMethod("GetFullName", MethodAttributes.Public, typeof(string), Type.EmptyTypes);

// Code generation
ilgen = mGetFullNameBuilder.GetILGenerator();
ilgen.Emit(OpCodes.Ldarg_0);

ilgen.Emit(OpCodes.Nop);
ilgen.Emit(OpCodes.Call, dispatchMethodBuilder); // Now, we include the call to the Dispatch method
ilgen.Emit(OpCodes.Nop);

ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Call, mGetFirstNameBuilder); // getting the firstname
ilgen.Emit(OpCodes.Ldstr, " "); // an space
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Call, mGetLastNameBuilder); // getting the lastname

// We need the 'Concat' method from string type
MethodInfo concatMethod = typeof(String).GetMethod("Concat", new Type[] { typeof(string), typeof(string), typeof(string) });

ilgen.Emit(OpCodes.Call, concatMethod); // calling concat and returning the result
ilgen.Emit(OpCodes.Ret);

3. The delegate declaration

// Building a delegate and it's constructor
TypeBuilder delegateBuilder = modBuilder.DefineType("PeopleLibrary.BeforeBuildFullNameHandler", TypeAttributes.Public | TypeAttributes.AutoClass | TypeAttributes.Sealed, typeof(MulticastDelegate));

ConstructorBuilder delegateCtorBuilder = delegateBuilder.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, new Type[] { typeof(object), typeof(IntPtr) });
delegateCtorBuilder.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);

// Method attributes flags
MethodAttributes maDelegate = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual;
MethodImplAttributes mia = MethodImplAttributes.Runtime | MethodImplAttributes.Managed;

// Now, we need to implement three methods:
// Invoke, BeginInvoke and EndInvoke
MethodBuilder methodBuilder;

// Because we are using a delegate without parameters,
// then, we need to declare only two parameters for 
// asynchronous operations: AsyncCallback and object (any)
Type[] beginParameters = new Type[2];
beginParameters[0] = typeof(AsyncCallback);
beginParameters[1] = typeof(object);

// BeginInvoke for Asynchronous call
methodBuilder = delegateBuilder.DefineMethod("BeginInvoke", maDelegate, typeof(IAsyncResult), beginParameters);
methodBuilder.SetImplementationFlags(mia);

// EndInvoke for Asynchronous call
methodBuilder = delegateBuilder.DefineMethod("EndInvoke", maDelegate, typeof(void), new Type[] { typeof(IAsyncResult) });
methodBuilder.SetImplementationFlags(mia);

// Invoke for Synchronous call
methodBuilder = delegateBuilder.DefineMethod("Invoke", maDelegate, typeof(void), Type.EmptyTypes);
methodBuilder.SetImplementationFlags(mia);

// Now, we can create this delegate
Type delegateType = delegateBuilder.CreateType();

// Event declaration.  
// The internal event container and the event handler
FieldBuilder eventFieldBuilder = personBuilder.DefineField("BeforeBuildFullName", delegateType, FieldAttributes.FamORAssem);
EventBuilder _eventBuilder = personBuilder.DefineEvent("BeforeBuildFullName", EventAttributes.None, delegateType);

// Event methods attributes
MethodAttributes eventMethodAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;
MethodImplAttributes eventMethodImpAtr = MethodImplAttributes.Managed | MethodImplAttributes.Synchronized;

// We need to implement the add_EVENTNAME
MethodBuilder addMethodBuilder = personBuilder.DefineMethod("add_BeforeBuildFullName", eventMethodAttr, null, new Type[] { delegateType });
addMethodBuilder.SetImplementationFlags(eventMethodImpAtr);

// We need the 'Combine' method from the Delegate type
MethodInfo combineInfo = typeof(Delegate).GetMethod("Combine", new Type[] { typeof(Delegate), typeof(Delegate) });

// Code generation
ilgen = addMethodBuilder.GetILGenerator();
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldfld, eventFieldBuilder);    // the event container
ilgen.Emit(OpCodes.Ldarg_1);                    // the new event parameter (argument 1)
ilgen.Emit(OpCodes.Call, combineInfo);            // the Combine method call
ilgen.Emit(OpCodes.Castclass, delegateType);    // casting the return value 
ilgen.Emit(OpCodes.Stfld, eventFieldBuilder);  // saving into the event container
ilgen.Emit(OpCodes.Ret);

10.

// We need to implement the remove_EVENTNAME
MethodBuilder removeMethodBuilder = personBuilder.DefineMethod("remove_BeforeBuildFullName", eventMethodAttr, null, new Type[] { delegateType });
removeMethodBuilder.SetImplementationFlags(eventMethodImpAtr);

// We need the 'Remove' method from the Delegate type
MethodInfo removeInfo = typeof(Delegate).GetMethod("Remove", new Type[] { typeof(Delegate), typeof(Delegate) });

// Code generation
ilgen = removeMethodBuilder.GetILGenerator();
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldfld, eventFieldBuilder);    // the event container
ilgen.Emit(OpCodes.Ldarg_1);                    // the event parameter (argument 1) for removing
ilgen.Emit(OpCodes.Call, removeInfo);            // the Remove method call
ilgen.Emit(OpCodes.Castclass, delegateType);   // casting the return value 
ilgen.Emit(OpCodes.Stfld, eventFieldBuilder);  // saving into the event container
ilgen.Emit(OpCodes.Ret);

11.

// Finally, setting the AddOn and RemoveOn methods for our event
_eventBuilder.SetAddOnMethod(addMethodBuilder);
_eventBuilder.SetRemoveOnMethod(removeMethodBuilder);

12.

// And here, the code for the dispatchMethod
ilgen = dispatchMethodBuilder.GetILGenerator();

LocalBuilder local = ilgen.DeclareLocal(typeof(bool));
System.Reflection.Emit.Label label = ilgen.DefineLabel();

ilgen.Emit(OpCodes.Nop);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldfld, eventFieldBuilder);    // Asking for the event field
ilgen.Emit(OpCodes.Ldnull);                    // is null ?
ilgen.Emit(OpCodes.Ceq);
ilgen.Emit(OpCodes.Stloc_0);
ilgen.Emit(OpCodes.Ldloc_0);
ilgen.Emit(OpCodes.Brtrue_S, label);            // if null, return

ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldfld, eventFieldBuilder);    // call the event
ilgen.Emit(OpCodes.Callvirt, delegateType.GetMethod("Invoke"));
ilgen.Emit(OpCodes.Nop);
ilgen.MarkLabel(label);
ilgen.Emit(OpCodes.Ret);

13.

// Finally, create the type and save the assembly
personBuilder.CreateType();

asmBuilder.Save("PeopleLibrary.dll");

14. Using the library:

private void button1_Click(object sender, EventArgs e)
{
    Person p = new Person("oscar", "londono");

    p.BeforeBuildFullName += new BeforeBuildFullNameHandler(p_BeforeBuildFullName);

    MessageBox.Show(p.GetFullName());
}

void p_BeforeBuildFullName()
{
    MessageBox.Show("Before build full name");
}

References:

Business Logic Toolkit for .NET
Emit: 9. Event by yuhen

Creating Code at Runtime / System.Reflection.Emit

2008-02-08T16:53:00.000-08:00

Here an example how we can create code at runtime. In this sample, I try to create the following class at runtime:


public class Person
{
    private string _firstname;
    private string _lastname;

    public string FirstName
    {
        get { return _firstname; }
        set { _firstname = value; }
    }

    public string LastName
    {
        get { return _lastname; }
        set { _lastname = value; }
    }

    public Person()
    {
        _firstname = "";
        _lastname = "";
    }

    public Person(string firstname, string lastname)
    {
        FirstName = firstname;
        LastName = lastname;
    }

    public string GetFullName()
    {
        return FirstName + " " + LastName;
    }
}

First of all, I'm going to implement the class as simple as posible, avoiding delegates an events. Here the result: 1.

// Our intermediate language generator
ILGenerator ilgen;

// The assembly builder
AssemblyBuilder asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("PeopleLibrary"), AssemblyBuilderAccess.RunAndSave);

// The module builder
ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule("PeopleLibrary", "PeopleLibrary.dll");

// The person class builder
TypeBuilder personBuilder = modBuilder.DefineType("PeopleLibrary.Person", TypeAttributes.Class | TypeAttributes.Public);

// The default constructor
ConstructorBuilder ctorBuilder = personBuilder.DefineDefaultConstructor(MethodAttributes.Public);

// Two fields: m_firstname, m_lastname
FieldBuilder fBuilderFirstName = personBuilder.DefineField("m_firstname", typeof(string), FieldAttributes.Private);
FieldBuilder fBuilderLastName = personBuilder.DefineField("m_lastname", typeof(string), FieldAttributes.Private);

// Two properties for this object: FirstName, LastName
PropertyBuilder pBuilderFirstName = personBuilder.DefineProperty("FirstName", System.Reflection.PropertyAttributes.HasDefault, typeof(string), null);
PropertyBuilder pBuilderLastName = personBuilder.DefineProperty("LastName", System.Reflection.PropertyAttributes.HasDefault, typeof(string), null);

// Custom attributes for get, set accessors
MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName;

// get,set accessors for FirstName
MethodBuilder mGetFirstNameBuilder = personBuilder.DefineMethod("get_FirstName", getSetAttr, typeof(string), Type.EmptyTypes);

// Code generation
ilgen = mGetFirstNameBuilder.GetILGenerator();
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldfld, fBuilderFirstName); // returning the firstname field
ilgen.Emit(OpCodes.Ret);

MethodBuilder mSetFirstNameBuilder = personBuilder.DefineMethod("set_FirstName", getSetAttr, null, new Type[] { typeof(string) });

// Code generation
ilgen = mSetFirstNameBuilder.GetILGenerator();
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldarg_1);
ilgen.Emit(OpCodes.Stfld, fBuilderFirstName); // setting the firstname field from the first argument (1)
ilgen.Emit(OpCodes.Ret);

// get,set accessors for LastName
MethodBuilder mGetLastNameBuilder = personBuilder.DefineMethod("get_LastName", getSetAttr, typeof(string), Type.EmptyTypes);

// Code generation
ilgen = mGetLastNameBuilder.GetILGenerator();
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldfld, fBuilderLastName); // returning the firstname field
ilgen.Emit(OpCodes.Ret);

MethodBuilder mSetLastNameBuilder = personBuilder.DefineMethod("set_LastName", getSetAttr, null, new Type[] { typeof(string) });

// Code generation
ilgen = mSetLastNameBuilder.GetILGenerator();
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldarg_1);
ilgen.Emit(OpCodes.Stfld, fBuilderLastName); // setting the firstname field from the first argument (1)
ilgen.Emit(OpCodes.Ret);

// Assigning get/set accessors
pBuilderFirstName.SetGetMethod(mGetFirstNameBuilder);
pBuilderFirstName.SetSetMethod(mSetFirstNameBuilder);

pBuilderLastName.SetGetMethod(mGetLastNameBuilder);
pBuilderLastName.SetSetMethod(mSetLastNameBuilder);

// Now, a custom method named GetFullName that concatenates FirstName and LastName properties
MethodBuilder mGetFullNameBuilder = personBuilder.DefineMethod("GetFullName", MethodAttributes.Public, typeof(string), Type.EmptyTypes);

// Code generation
ilgen = mGetFullNameBuilder.GetILGenerator();
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Call, mGetFirstNameBuilder); // getting the firstname
ilgen.Emit(OpCodes.Ldstr, " "); // an space
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Call, mGetLastNameBuilder); // getting the lastname

// We need the 'Concat' method from string type
MethodInfo concatMethod = typeof(String).GetMethod("Concat", new Type[] { typeof(string), typeof(string), typeof(string) });

ilgen.Emit(OpCodes.Call, concatMethod); // calling concat and returning the result
ilgen.Emit(OpCodes.Ret);

// Another constructor that initializes firstname and lastname
ConstructorBuilder ctorBuilder2 = personBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(string), typeof(string) });
ctorBuilder2.DefineParameter(1, ParameterAttributes.In, "firstname");
ctorBuilder2.DefineParameter(2, ParameterAttributes.In, "lastname");

// Code generation
ilgen = ctorBuilder2.GetILGenerator();

// First of all, we need to call the base constructor, 
// the Object's constructor in this sample
Type objType = Type.GetType("System.Object");
ConstructorInfo objCtor = objType.GetConstructor(Type.EmptyTypes);

ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Call, objCtor); // calling the Object's constructor

ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldarg_1);
ilgen.Emit(OpCodes.Call, mSetFirstNameBuilder); // setting the firstname field from the first argument (1)
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldarg_2);
ilgen.Emit(OpCodes.Call, mSetLastNameBuilder);  // setting the lastname field from the second argument (2)
ilgen.Emit(OpCodes.Ret);

// Finally, create the type and save the assembly
personBuilder.CreateType();

asmBuilder.Save("PeopleLibrary.dll");

10. Using the library in another project that refereces PeopleLibrary.dll:

Person p = new Person("oscar", "londono");

MessageBox.Show(p.GetFullName());

See Part 2 and Part 3.

Dynamic Code (Using Reflection)

2008-02-08T09:06:00.000-08:00

We can use reflection to invoke code dynamically. Here a little sample creating an Stack object from the assembly mscorlib.dll.

// Loading the assembly
string path = @"C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\mscorlib.dll";
Assembly asm = Assembly.LoadFile(path);
 
// Getting a stack object type
Type stackType = asm.GetType("System.Collections.Stack");
 
// Building the constructor call
Type[] argumentTypes = Type.EmptyTypes;
ConstructorInfo ctor = stackType.GetConstructor(argumentTypes);
 
object stackObj = ctor.Invoke(new object[] { });
 
// Calling the Push method and passing by parameters the value 
// we want to push in the stack
MethodInfo mpush = stackType.GetMethod("Push");
mpush.Invoke(stackObj, new object[] { "One" });
mpush.Invoke(stackObj, new object[] { "Two" });
mpush.Invoke(stackObj, new object[] { "Three" });
 
// Getting a property value (Count)
PropertyInfo propInfo = stackType.GetProperty("Count");
int count = (int)propInfo.GetValue(stackObj, null);
 
MessageBox.Show(count.ToString());
 
// Getting values using the Pop method
string s;
 
MethodInfo mpop = stackType.GetMethod("Pop");
s = mpop.Invoke(stackObj, null) as string;
MessageBox.Show(s);
s = mpop.Invoke(stackObj, null) as string;
MessageBox.Show(s);
s = mpop.Invoke(stackObj, null) as string;
MessageBox.Show(s);

We can also create the object by using the Activator object:

object stackObj = Activator.CreateInstance(stackType);

If we need to create the object using another constructor different from the default constructor, we can achieve this:

int initialCapacity = 10;
 
// Building the constructor call with one parameter type of integer
Type[] argumentTypes = new Type[] { typeof(int) };
ConstructorInfo ctor = stackType.GetConstructor(argumentTypes);
 
// Creating the object
object stackObj = ctor.Invoke(new object[] { initialCapacity });

Or using the Activator:

int initialCapacity = 10;
 
object stackObj = Activator.CreateInstance(stackType, new object[] { initialCapacity });

For calling static methods, we need to pass null as object paramenter when using the Invoke method, here an example calling the MessageBox.Show method:

// Loading the assembly
string path = @"C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\System.Windows.Forms.dll";
Assembly myAsm = Assembly.LoadFile(path);
 
// Getting the type MessageBox
Type msgBox = myAsm.GetType("System.Windows.Forms.MessageBox");
 
// Invoking the static method 'Show'
MethodInfo showMethod = msgBox.GetMethod("Show", new Type[] { typeof(string) });
showMethod.Invoke(null, new object[] { "Hello world!" });

How show a popup menu in AX/Axapta

2008-02-07T07:24:00.000-08:00

In the following sample, I have duplicated the sysAOT form, and I have overrode the context method for the tree control. Here the code to show the system context menu for any selected treeNode.

PopupMenu       popupMenu;
SysContextMenu  sysContextMenu;
int idx = tree.getFirstSelected();
TreeNode treeNode = tree.getItem(idx).data();
 
// add some custom menu items
int editMenu;
int choice;
;
 
// current selected treeNode is valid ?
if (treeNode == null)
    return;
 
// create the SysContextMenu for this TreeNode
sysContextMenu = new SysContextMenuTreeNode(treeNode);
 
// System API call to build the popup menu
popupMenu = sysContextMenu.buildMenu(this.hWnd());
 
// Add a custom edit menu
popupMenu.insertBreak();
editMenu = popupMenu.insertItem("Edit");
 
// showing menu
choice = popupMenu.draw();
 
// Showing and processing this popupMenu
if (!sysContextMenu.runMenu(choice, sysContextMenu))
{
    if (choice == editMenu)
    {
        SysInfoAction_Editor::newOpen(treeNode.treeNodePath()).run();
    }
}

But, looking in depth, I found that the sysAotFind form can be used to get some practical sample on how we can create our custom popup menu. Here an adapted version of that code to the previous SysAOT2 form(method context within control tree):

// current selected treeNode
int idx = tree.getFirstSelected();
TreeNode treeNode = tree.getItem(idx).data();
 
// We want to build, a popup menu, with a custom submenu and another
// sysContextMenu as submenu (add-ins menu item)
PopupMenu       popupMenu      = new PopupMenu(this.hWnd());
PopupMenu       copyMenu       = new PopupMenu(this.hWnd(), popupMenu);
PopupMenu       subSysContextMenu;
SysContextMenu  sysContextMenu;
 
// Menu options
int             open;
int             editMethod;
int             copyName;
int             copyPath;
int             copyFullPath;
int             copyAll;
int             choice;
int             find;
;
 
// current selected treeNode is valid ?
if (treeNode == null)
    return;
 
// create the SysContextMenu for this TreeNode
sysContextMenu = new SysContextMenuTreeNode(treeNode);
 
//---------------------------------
// Building the menu
open = popupMenu.insertItem("Open");
popupMenu.insertBreak();
editMethod = popupMenu.insertItem("Edit");
 
copyName        = copyMenu.insertItem("Copy Name");
copyPath        = copyMenu.insertItem("Copy Path");
copyFullPath    = copyMenu.insertItem("Copy FullPath");
copyAll         = copyMenu.insertItem("Copy All");
 
popupMenu.insertPopupMenu("Copy", copyMenu);
popupMenu.insertBreak();
 
find = popupMenu.insertItem("Find");
popupMenu.insertBreak();
 
subSysContextMenu = sysContextMenu.buildMenu(this.hWnd(), popupMenu);
popupMenu.insertPopupMenu("Add-ins", subSysContextMenu);
//---------------------------------
 
// Now, showing the popup menu
choice = popupMenu.draw();
 
// processing option
if (!sysContextMenu.runMenu(choice, sysContextMenu))
{
    switch (choice)
    {
        case open:
            // to implement
            break;
 
        case editMethod:
            SysInfoAction_Editor::newOpen(treeNode.treeNodePath()).run();
            break;
 
        case find:
            // to implement
            break;
 
        case copyName, copyPath, copyFullPath, copyAll:
            // to implement
            break;
    }
}

Reflection

2008-01-30T14:49:00.000-08:00

// Loading the current assembly
Assembly myAsm = Assembly.GetExecutingAssembly();
 
// Showing some properties
MessageBox.Show(myAsm.FullName);
MessageBox.Show(myAsm.Location);
 
// Getting some assembly attribute
Type attrType = typeof(AssemblyDescriptionAttribute);
object[] attrs = myAsm.GetCustomAttributes(attrType, false);
foreach (Attribute attr in attrs)
{
    AssemblyDescriptionAttribute desc = attr as AssemblyDescriptionAttribute;
    MessageBox.Show(desc.Description);
}
 
// Getting types in this assembly
Type[] types = myAsm.GetTypes();
foreach (Type t in types)
    MessageBox.Show(t.ToString());
 
// Getting more information about an object
MemberInfo[] minfos = typeof(Person).GetMembers();
foreach (MemberInfo mi in minfos)
    MessageBox.Show(mi.ToString());
 
// Getting attributes for an object
Type tstring = typeof(string);
foreach (Attribute attr in tstring.GetCustomAttributes(false))
    MessageBox.Show(attr.ToString()); //.GetType().Name);

Assembly static methods:

GetAssembly
GetCallingAssembly
GetEntryAssembly
GetExecutingAssembly
Load
LoadFile
LoadFrom
ReflectionOnlyLoad
ReflectionOnlyLoadFrom

Some useful methods: Location
FullName
GetCustomAttributes
GetExportedTypes
GetModules/GetModule
GetTypes

Type class properties:

Assembly
Attributes
IsClass
IsEnum
IsInterface
IsPrimitive
... and others

Type class methods:

GetConstructor/GetConstructors
GetEvent/GetEvents
GetField/GetFields
GetMember/GetMembers
GetMethod/GetMethods
GetProperty/GetProperties
... and others

MemberInfo derived classes:

ConstructorInfo
EventInfo
FieldInfo
LocalVariableInfo
MethodBase
MethodInfo
PropertyInfo

BindingFlags enumeration:

DeclaredOnly - Members directly declared on the specific type are included. Inherited members are ignored.
FlattenHierarchy - Declared and inherited members should be returned, but also returns protected members.
IgnoreCase - A case-insensitive matching of the member name should be used.
Instance - Members that are part of an instance of type will be included.
NonPublic - Members that are not public are included.
Public - Members that are public are included.
Static - Members that are defined as static are included.
Sample:

Type tperson = typeof(Person);
 
BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
 
MemberInfo[] members = tperson.GetMembers(flags);
foreach (MemberInfo member in members)
    MessageBox.Show(member.Name);

More information: Attributes (An example)

A simple activities manager

P/Invoke - Platform Invoke

2008-01-29T18:32:00.000-08:00

We encapsulates API calls by using a class and declaring static methods with the DllImport Attribute. For data convertion with use the MarshalAs attribute. For structures, we use the LayoutKind attribute (normally the Layout.Sequential is used). Here an example how we can invoke the API MessageBox:

// API class declaration
public class Win32Api
{
    [DllImport("user32.dll")]
    public static extern IntPtr MessageBox(IntPtr hWnd, String text, String caption, uint type);
}

private void button1_Click(object sender, EventArgs e)
{
    // Calling the API Messagebox
    Win32Api.MessageBox(this.Handle, "test Message", "caption", 64);
}

Some fields for DllImport attribute:

CallingConvention - (Winapi, Cdecl, StdCall, ThisCall, FastCall). Winapi is default por windows APIs and Cdecl for Windows CE.NET.

CharSet - How string arguments should be marshaled (Ansi, Unicode, None, Auto)

EntryPoint - DLL entry point, this allows us for use a different name for the API in our class. See bellow

PreserveSig - The signature should be transformed into an unmanaged signature that returns an HRESULT and has an additional [out, retval] argument for the return value. This mean, the function will return an HRESULT instead of thrown an exception when an error occurs. More information see MSDN.

SetLastError - Enable the caller to use the Marshal.GetLasWin32Error API function to determine whether an error ocurred while executing the method.

Samples:

[DllImport("msvcrt.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
public static extern int printf(String format, int i, double d);

[DllImport("user32.dll", CharSet = CharSet.Auto, EntryPoint = "MessageBox")]
public static extern int MyNewMessageBoxMethod(IntPtr hWnd, String text, String caption, uint type);

More about PreserveSig: Unlike COM Interop scenarios, PInvoke signatures have PreserveSig semantics by default. For example, in the IOleClientSite interface, we need to preserve the signature:

[ComVisible(true), Guid("00000118-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleClientSite
{

    [return: MarshalAs(UnmanagedType.I4)]
    [PreserveSig]
    int SaveObject();

    [return: MarshalAs(UnmanagedType.I4)]
    [PreserveSig]
    int GetMoniker(
        [In, MarshalAs(UnmanagedType.U4)]          int dwAssign,
        [In, MarshalAs(UnmanagedType.U4)]          int dwWhichMoniker,
        [Out, MarshalAs(UnmanagedType.Interface)] out object ppmk);
        
    [return: MarshalAs(UnmanagedType.I4)]
    [PreserveSig]
    int GetContainer([MarshalAs(UnmanagedType.Interface)] out IOleContainer container);

    [return: MarshalAs(UnmanagedType.I4)]
    [PreserveSig]
    int ShowObject();

    [return: MarshalAs(UnmanagedType.I4)]
    [PreserveSig]
    int OnShowWindow(
        [In, MarshalAs(UnmanagedType.I4)] int fShow);

    [return: MarshalAs(UnmanagedType.I4)]
    [PreserveSig]
    int RequestNewObjectLayout();
}

More about PreserveSig in the Adam Nathan's Blog.

Passing structures:

When passing structures or classes to unmanaged code using platform invoke, you must provide additional information to preserve the original layout and alignment. Here some examples from MSDN:

[StructLayout(LayoutKind.Sequential)]
public struct Point
{
    public int x;
    public int y;
}  

[StructLayout(LayoutKind.Explicit)]
public struct Rect
{
    [FieldOffset(0)] public int left;
    [FieldOffset(4)] public int top;
    [FieldOffset(8)] public int right;
    [FieldOffset(12)] public int bottom;
}  

class Win32API
{
    [DllImport("User32.dll")]
    public static extern bool PtInRect(ref Rect r, Point p);
}

Callback functions:

For invoking API functions that are expecting a callback function, we need to declare one delegate function and one method conforms the delegate declaration. Here an example from MSDN that enumerates every opened window in the system:

// The callback delegate declaration
public delegate bool theCallBack(int hwnd, int lParam);

// The API wrapper
public class EnumReportApp
{
    [DllImport("user32")]
    public static extern int EnumWindows(theCallBack x, int y);

    public static void Run()
    {
        // Here our callback
        theCallBack myCallBack = new theCallBack(EnumReportApp.Report);
        EnumWindows(myCallBack, 0);
    }

    // This is the callback that EnumWindows will call
    public static bool Report(int hwnd, int lParam)
    {
        Console.Write("Window handle is ");
        Console.WriteLine(hwnd);
        
        return true;
    }
}

// Main program
class Program
{
    public static void Main()
    {
        EnumReportApp.Run();
    }
}

Marshaling:

For APIs returning string values, is a best practice use the StringBuilder instead of normal strings classes when they expect a reference string type.

public class Win32Api
{
    [DllImport("user32.dll")]
    private static extern IntPtr GetForegroundWindow();
    
    [DllImport("user32.dll")]
    private static extern Int32 GetWindowText(IntPtr hWnd, StringBuilder textValue, Int32 counter);

    public static string GetForegroupWindowText()
    {
        // Our string builder prefixed to 256 characters
        StringBuilder sb = new StringBuilder(256);
        IntPtr hwnd = GetForegroundWindow();

        GetWindowText(hwnd, sb, 256);

        return sb.ToString();
    }
}

"For example, you can marshal a string to unmanaged code as either a LPStr, a LPWStr, a LPTStr, or a BStr. By default, the common language runtime marshals a string parameter as a BStr to COM methods. You can apply the MarshalAsAttribute attribute to an individual field or parameter to cause that particular string to be marshaled as a LPStr instead of a BStr." - from MSDN

[DllImport("user32.dll")]
public static extern int MessageBoxW(
    IntPtr hWnd,
    [MarshalAs(UnmanagedType.LPWStr)] String text,
    [MarshalAs(UnmanagedType.LPWStr)] String caption,
    int type);

More information about Marshaling with P/Invoke in MSDN.

COM Interop

2008-01-29T14:47:00.000-08:00

For exposing .NET classes as COM objects: 1. Set the assembly attribute ComVisible equals true:

[assembly: ComVisible(true)]

2. Set the project for "Register for COM Interop": Project's Properties -> Build tab -> Output group -> check box: Register for COM Interop.

3. Create public classes and use the ComVisible attribute to hide some members and functions.

[ComVisible(true)]
public class Person : IPerson
{
    [ComVisible(true)]
    public string Name { get; set; }
 
    [ComVisible(true)]
    public string LastName { get; set; }
 
    [ComVisible(true)]
    public DateTime BirthDay { get; set; }
 
    [ComVisible(false)]
    public int Age { get; set; }
 
    public Person()
    {
    }
 
    [ComVisible(true)]
    public string GetFullName()
    {
        return getFullNameInt();
    }
 
    private string getFullNameInt()
    {
        return Name + " " + LastName;
    }
 
    [ComVisible(false)]
    public int GetAge()
    {
        Age = DateTime.Now.Year - BirthDay.Year - 1;
        
        return Age;
    }
}

You can use this class for Late Bounding.

And, what about Early Bounding?

If we want to expose our classes for Early Bounding, the best practice is:

1. Declare interfaces that represents our objects.
2. Implement interfaces in public classes.
3. Set some attributes for better COM objects exposing:
3.a Use an specific Guid for every interface and every class
3.b Declare the interface as InterfaceIsDual
3.c Qualify every member and function with its DispId
3.d Implement the class with the ClassInterfaceType=None
3.e Set the ProgId for the class

Example:

[Guid("568680FF-FBF8-4b84-A8D6-F430197870F9")]
[InterfaceType(ComInterfaceType.InterfaceIsDual)]
public interface IPerson
{
    [DispId(1)]
    string Name{get;set;}
 
    [DispId(2)]
    string LastName{get;set;}
 
    [DispId(3)]
    DateTime BirthDay { get; set; }
 
    [DispId(4)]
    string GetFullName();
 
    [DispId(5)]
    int GetAge();
}
 
[Guid("D798A2FC-01A6-4c97-AC0F-703C3B2DBC81"),
ProgId("ComTestLibrary.Person"),
ClassInterface(ClassInterfaceType.None)]
public class Person : IPerson
{
    public string Name { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDay { get; set; }
    public int Age { get; set; }
 
    public Person()
    {
    }
 
    public string GetFullName()
    {
        return getFullNameInt();
    }
 
    private string getFullNameInt()
    {
        return Name + " " + LastName;
    }
 
    public int GetAge()
    {
        Age = DateTime.Now.Year - BirthDay.Year - 1;
 
        return Age;
    }
}

This is old-versions compatible and we are able to add more properties and methods with its own DispId, so we don't need to recompile old consumers for this COM component.

NOTE: Avoid use the ClassInterfaceType.AutoDual attribute because it is not old-versions compatible. Every time you change your .NET class, you must recompile COM clients.

Exposing .NET Events to COM:

For exposing events from .NET to COM, we need to add a new interface that define the events we want to dispatch. Then, we need to change the class according to the events we are exposing (the name must be equals), take a look:

// The new interface declaration
[Guid("866226CC-679E-4ce7-B527-5A80D6950278")]
[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface IPersonEvents
{
    [DispId(1)]
    void BeforeGetFullName(string name, string lastname); // Event declaration
 
    [DispId(2)]
    void OtherEventWithoutParameters(); // Event declaration
}

[Guid("D798A2FC-01A6-4c97-AC0F-703C3B2DBC81"),
ProgId("ComTestLibrary.Person"),
ComSourceInterfaces(typeof(IPersonEvents)), // Events interface implementation
ClassInterface(ClassInterfaceType.None)]
public class Person : IPerson
{
    // Delegates declaration
    [ComVisible(false)]
    public delegate void BeforeGetFullNameHandler(string name, string lastname);
    [ComVisible(false)]
    public delegate void OtherEventWithoutParametersHandler();
 
    ...
 
    // Our events. The name must match to the definition in 
    // the interface we are implementing
    public event BeforeGetFullNameHandler BeforeGetFullName;
    public event OtherEventWithoutParametersHandler OtherEventWithoutParameters;
 
    ...
 
    public string GetFullName()
    {
        // Launching events
        if (BeforeGetFullName != null)
            BeforeGetFullName(Name, LastName);
 
        if (OtherEventWithoutParameters != null)
            OtherEventWithoutParameters();
 
        return getFullNameInt();
    }
 
    ...
}

We can consume events in some languaje like VB 6.0:

Dim WithEvents c As ComTestLibrary.Person
 
Private Sub c_BeforeGetFullName(ByVal Name As String, ByVal LastName As String)
    MsgBox "Name = " & Name & " LastName = " & LastName
End Sub
 
Private Sub c_OtherEventWithoutParameters()
    MsgBox "Event without parameters"
End Sub
 
Private Sub Command1_Click()
    If (c Is Nothing) Then
        Set c = New ComTestLibrary.Person
    End If
     
    c.Name = "oscar"
    c.LastName = "londono"
     
    MsgBox c.GetFullName
     
End Sub

Encrypting and Decrypting Data

2008-01-28T14:47:00.001-08:00

Encrypting and decrypting data:

// Test data
string data = "testing data for encryption-12356";
byte[] utfdata = Encoding.UTF8.GetBytes(data);
byte[] saltBytes = Encoding.UTF8.GetBytes("this my salt");
 
// Our symmetric encryption algorithm
RijndaelManaged aes = new RijndaelManaged();
 
// We're using the PBKDF2 standard for password-based key generation
Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes("password", saltBytes);
 
// Setting our parameters
aes.BlockSize = aes.LegalBlockSizes[0].MaxSize;
aes.KeySize = aes.LegalKeySizes[0].MaxSize;
 
aes.Key = rfc.GetBytes(aes.KeySize / 8);
aes.IV = rfc.GetBytes(aes.BlockSize / 8);
 
// Encryption
ICryptoTransform encryptTransf = aes.CreateEncryptor();
 
// Output stream, can be also a FileStream
MemoryStream encryptStream = new MemoryStream();
CryptoStream encryptor = new CryptoStream(encryptStream, encryptTransf, CryptoStreamMode.Write);
 
encryptor.Write(utfdata, 0, utfdata.Length);
encryptor.FlushFinalBlock();
encryptor.Close();
 
// Showing our encrypted content
byte[] encryptBytes = encryptStream.ToArray();
MessageBox.Show(UTF8Encoding.UTF8.GetString(encryptBytes));
 
// Now, decryption
ICryptoTransform decryptTrans = aes.CreateDecryptor();
 
// Output stream, can be also a FileStream
MemoryStream decryptStream = new MemoryStream();
CryptoStream decryptor = new CryptoStream(decryptStream, decryptTrans, CryptoStreamMode.Write);
 
decryptor.Write(encryptBytes, 0, encryptBytes.Length);
decryptor.Flush();
decryptor.Close();
 
// Showing our decrypted content
byte[] decryptBytes = decryptStream.ToArray();
MessageBox.Show(UTF8Encoding.UTF8.GetString(decryptBytes));

Encrypting and decrypting files:

// Test data
byte[] saltBytes = Encoding.UTF8.GetBytes("this my salt");
 
// Our symmetric encryption algorithm
RijndaelManaged aes = new RijndaelManaged();
 
// We're using the PBKDF2 standard for password-based key generation
Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes("password", saltBytes);
 
// Setting our parameters
aes.BlockSize = aes.LegalBlockSizes[0].MaxSize;
aes.KeySize = aes.LegalKeySizes[0].MaxSize;
 
aes.Key = rfc.GetBytes(aes.KeySize / 8);
aes.IV = rfc.GetBytes(aes.BlockSize / 8);
 
//----------------------------------------
// Encryption
ICryptoTransform encryptTransf = aes.CreateEncryptor();
 
// Input file
FileStream infile = File.OpenRead("c:\\filename.txt");
BinaryReader br = new BinaryReader(infile);
 
// Output file (encrypted)
FileStream outfile = File.Create("c:\\filenameEnc.bin");
CryptoStream encryptor = new CryptoStream(outfile, encryptTransf, CryptoStreamMode.Write);
 
// Now, encrypting
byte[] b = br.ReadBytes(1000);
while (b.Length > 0)
{    
    encryptor.Write(b, 0, b.Length);
    b = br.ReadBytes(1000);
}
 
// Final
encryptor.FlushFinalBlock();
encryptor.Close();
br.Close();
//----------------------------------------
 
//----------------------------------------
// Now, decryption
ICryptoTransform decryptTrans = aes.CreateDecryptor();
 
// Input encrypted file
infile = File.OpenRead("c:\\filenameEnc.bin");
 
// Output, decrypted file
outfile = File.Create("c:\\filenameDec.txt");
BinaryWriter bw = new BinaryWriter(outfile);
 
CryptoStream decryptor = new CryptoStream(infile, decryptTrans, CryptoStreamMode.Read);
 
// Now, decrypting
int bytes = 1000;
b = new byte[bytes];
do
{
    bytes = decryptor.Read(b, 0, b.Length);
    bw.Write(b, 0, bytes);
 
} while (bytes > 0);
 
// Final
decryptor.Close();
bw.Close();
//----------------------------------------

Encrypting using Asymmetric algorithms:

// Csp: Crytographic Service Provider
// Create a CspParameters object to store our keys permanently in this machine
CspParameters persistantCsp = new CspParameters();
persistantCsp.KeyContainerName = "myAsymmetricKey";
 
// Create an instance of the RSA algorithm object
RSACryptoServiceProvider myRSA = new RSACryptoServiceProvider(persistantCsp);
 
// Specify that the private key should be stored in the CSP
myRSA.PersistKeyInCsp = true;
 
// Create a new RSAParameters object with the private key
RSAParameters privateKey = myRSA.ExportParameters(true);
 
// Showing keys
MessageBox.Show(myRSA.ToXmlString(true));
 
// Now, encrypting some test data
string data = "testing data for encryption-12356";
byte[] encBytes = Encoding.Unicode.GetBytes(data);
 
// Encrypt
byte[] encData = myRSA.Encrypt(encBytes, false);
 
// Decrypt
byte[] decBytes = myRSA.Decrypt(encData, false);
 
// Showing results
MessageBox.Show(Encoding.Unicode.GetString(decBytes));

Calculating hashes:

// SHA1 hash provider
SHA1 myHash = new SHA1CryptoServiceProvider();
 
// Input file
FileStream file = File.OpenRead("c:\\filename.txt");
 
// computing the hash
myHash.ComputeHash(file);
 
// Showing results
MessageBox.Show(Convert.ToBase64String(myHash.Hash));

Using keyed hashes:

// Test data
byte[] saltValueBytes = Encoding.ASCII.GetBytes("This is my sa1t");
 
// We're using the PBKDF2 standard for password-based key generation
Rfc2898DeriveBytes passwordKey = new Rfc2898DeriveBytes("password", saltValueBytes);
byte[] secretKey = passwordKey.GetBytes(16);
 
// SHA1 keyed hash
HMACSHA1 myHash = new HMACSHA1(secretKey);
 
// Input data
FileStream file = File.OpenRead("c:\\filename.txt");
BinaryReader reader = new BinaryReader(file);
 
// Setting data
myHash.ComputeHash(reader.ReadBytes((int)file.Length));
 
// Showing results
MessageBox.Show(Convert.ToBase64String(myHash.Hash));

Signing data:

//---------------------------------------------
// Signing provider
DSACryptoServiceProvider signer = new DSACryptoServiceProvider();
 
// Input data
FileStream file = File.OpenRead("c:\\filename.txt");
BinaryReader reader = new BinaryReader(file);
byte[] data = reader.ReadBytes((int)file.Length);
 
// Getting signature
byte[] signature = signer.SignData(data);
 
// Exporting our public key to share with someone
string publicKey = signer.ToXmlString(false);
 
// Showing results
MessageBox.Show("Signature: " + Convert.ToBase64String(signature));
 
reader.Close();
//---------------------------------------------
 
//---------------------------------------------
// Verifying signature
DSACryptoServiceProvider verifier = new DSACryptoServiceProvider();
 
// Importing our public key
verifier.FromXmlString(publicKey);
 
// Getting original data
FileStream file2 = File.OpenRead("c:\\filename.txt");
BinaryReader reader2 = new BinaryReader(file2);
byte[] data2 = reader2.ReadBytes((int)file2.Length);
 
// Showing results
if (verifier.VerifyData(data2, signature))
    MessageBox.Show("Signature OK");
else
    MessageBox.Show("Bad Signature");
 
reader2.Close();
//---------------------------------------------

Other providers:

Symmetric algorithms:

RijndaelManaged (AES)
RC2
DES
TripleDES

Asymmetric algorithms:

RSACryptoServiceProvider
DSACryptoServiceProvider

Hash algorithms:

MD5
RIPEMD160
SHA1
SHA256
SHA384
SHA512

Keyed hash algorithms:

HMACSHA1
MACTripleDESC

ACL's

2008-01-27T18:03:00.000-08:00

Working with files:

// Our file security object
FileSecurity fs = File.GetAccessControl("c:\\filename.txt", AccessControlSections.All);
 
// Showing access rules data
AuthorizationRuleCollection arc = fs.GetAccessRules(true, true, typeof(NTAccount));
foreach (FileSystemAccessRule ar in arc)
{
    MessageBox.Show("Access to: " + ar.IdentityReference.Value);
    MessageBox.Show("Access to: " + ar.AccessControlType.ToString());
    MessageBox.Show("Access to: " + ar.FileSystemRights.ToString());
}
 
// Showing audit rules data
arc = fs.GetAuditRules(true, true, typeof(NTAccount));
foreach (FileSystemAuditRule ar in arc)
{
    MessageBox.Show("Audit to: " + ar.IdentityReference.Value);
    MessageBox.Show("Audit to: " + ar.AuditFlags.ToString());
    MessageBox.Show("Audit to: " + ar.FileSystemRights.ToString());
}

Working with directories:

// Our file security object
DirectorySecurity ds = Directory.GetAccessControl("c:\\temp");
 
// Showing access rules data
AuthorizationRuleCollection arc = ds.GetAccessRules(true, true, typeof(NTAccount));
foreach (FileSystemAccessRule ar in arc)
{
    MessageBox.Show("Access to: " + ar.IdentityReference.Value);
    MessageBox.Show("Access to: " + ar.AccessControlType.ToString());
    MessageBox.Show("Access to: " + ar.FileSystemRights.ToString());
}

Performing changes in file ACL's:

// Our file security object
FileSecurity fs = File.GetAccessControl("c:\\filename.txt", AccessControlSections.All);
 
// Add a new rule
fs.AddAccessRule(new FileSystemAccessRule("Guests", FileSystemRights.Read, AccessControlType.Allow));
 
// Save changes
File.SetAccessControl("c:\\filename.txt", fs);

For directories:

// Our file security object
DirectorySecurity ds = Directory.GetAccessControl("c:\\temp", AccessControlSections.All);
 
// Add a new rule
ds.AddAccessRule(new FileSystemAccessRule("Guests", FileSystemRights.Read, AccessControlType.Allow));
 
// Save changes
Directory.SetAccessControl("c:\\temp", ds);

Creating directories with initial permissions:

// Our file security object
DirectorySecurity ds = new DirectorySecurity();
 
// Setting the rule
ds.AddAccessRule(new FileSystemAccessRule("Guests", FileSystemRights.FullControl, AccessControlType.Allow));
 
// Creating the directory with our ACL's
Directory.CreateDirectory("c:\\guests", ds);

Removing ACL's:

// Our file security object
FileSecurity fs = File.GetAccessControl("c:\\filename.txt", AccessControlSections.All);
 
// Add a new rule
fs.RemoveAccessRuleAll(new FileSystemAccessRule("Guests", FileSystemRights.Read, AccessControlType.Allow));
//fs.RemoveAccessRule(new FileSystemAccessRule("Guests", FileSystemRights.Read, AccessControlType.Allow));
 
// Save changes
File.SetAccessControl("c:\\filename.txt", fs);

Other Access Rules classes:

EventWaitHandleAccessRule
MutexAccessRule
RegistryAccessRule
SemaphoreAccessRule

User Permissions

2008-01-27T14:30:00.000-08:00

After getting the current logged user, we can achieve tasks like ask for user's groups belong to, or use the declarative and imperative permission demand:

// Define the security policy in use as Windows security
AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
 
try
{
    // User must belong to Administrators group
    PrincipalPermission pp = new PrincipalPermission(null, "Administrators");
    pp.Demand();
 
    // User is an administrator
    MessageBox.Show("Only administrators can see this message.");
}
catch (SecurityException)
{
    MessageBox.Show("Access denied");
}
catch(Exception ex)
{
    MessageBox.Show(ex.Message);
}

Using declarative demand:

[PrincipalPermission(SecurityAction.Demand, Role = "Administrators")]
void AdministratorsOnlyMethod()
{
    // User is an administrator
    MessageBox.Show("Only administrators can see this message.");
}

NOTE: The PrincipalPermission only exposes three properties: Authenticated, Name and Role.

WindowsIdentity and WindowsPrincipal classes

The WindowsIdentity class has several methods for getting identities and their properties: GetAnonymous, GetCurrent, Impersonate.

Properties: AuthenticationType, IsAnonymous, IsAuthenticated, IsGuest, IsSystem, Name ("DOMAIN\Username"), Token.

The WindowsPrincipal provides information about groups the user is belong to.

// Getting the current identity and principal representation
WindowsIdentity wi = WindowsIdentity.GetCurrent();
WindowsPrincipal wp = new WindowsPrincipal(wi);
 
// Showing some properties
MessageBox.Show(wi.AuthenticationType);
 
MessageBox.Show(wp.IsInRole(WindowsBuiltInRole.Administrator).ToString());
MessageBox.Show(wp.IsInRole(WindowsBuiltInRole.Guest).ToString());
MessageBox.Show(wp.IsInRole("Administrators").ToString());

If we need authenticate users agaings a custom database, we must implement our custom identity and principal classes from IIdentity and IPrincipal interfaces. Also, we can extend properties and funcionality from classes like WindowsIdentity, WindowsPrincipal, GenericIdentity and GenericPrincipal.

public class myIdentity : IIdentity
{
    private string _name, _password;
 
    // Custom constructor
    public myIdentity(string name, string password)
    {
        _name = name;
        _password = password;
    }
 
    #region IIdentity Members
 
    public string AuthenticationType
    {
        get { return "custom"; }
    }
 
    public bool IsAuthenticated
    {
        get 
        { 
            // Our custom validation, like getting passwords
            // from a local database could be here
            return (_password == _name + "123");
        }
    }
 
    public string Name
    {
        get { return _name; }
    }
 
    #endregion
}

public class myPrincipal: IPrincipal
{
    private myIdentity _identity;
    private string[] _roles;
 
    public myPrincipal(myIdentity identity, string[] roles)
    {
        _identity = identity;
        _roles = roles;
    }
 
    #region IPrincipal Members
 
    public IIdentity Identity
    {
        get { return _identity; }
    }
 
    public bool IsInRole(string role)
    {
        // Here, we can search for identity's roles
        // in our custom database
        foreach (string s in _roles)
        {
            if (s.ToLower() == role.ToLower())
                return true;
        }
   
        return false;
    }
 
    #endregion
}

Using our custom identity and principal:

// validate our user
myIdentity mi = new myIdentity("john", "john123");
if (!mi.IsAuthenticated)
{
    MessageBox.Show("Invalid username/password");
    return;
}
 
// Set some roles
myPrincipal mp = new myPrincipal(mi, new string[] {"users", "accounting"});
 
// Assign to the thread's current principal
Thread.CurrentPrincipal = mp;
 
try
{
    PrincipalPermission pp = new PrincipalPermission("john", "accounting");
    pp.Demand();
 
    MessageBox.Show("performing some accounting code");
}
catch(Exception ex)
{
    MessageBox.Show(ex.Message);
}

Code Access Security (CAS)

2008-01-26T14:07:00.000-08:00

Evidence: represents the origin of code (Application Directory, Hash, Permission Request, Publisher, Site Web, Strong Name, URL, Zone).

NOTE: For configuring the .NET Framework security we use the mscorcfg.msc.

Policy Levels

Enterprise (%Systemroot%\Microsoft.NET\Framework\version\Config\enterprise.config)
Machine (%Systemroot%\Microsoft.NET\Framework\version\Config\security.config)
User (%UserProfile%\Application Data\Microsoft\CLR Security Config\version\security.config)
AppDomain

For every Policy Level we have the All_Code group and several Permissions Sets. From the All_Code group, we can get others code groups specific for every Zone we have (Internet, Intranet, Restricted, Trusted, My_Computer, ...).

We can create our custom Code Group and assign to them our custom Permission Set.

Here one practical sample from developer.com

Sample:
- Create the strong naming key: "sn.exe -k mycas.snk"
- Assign it to our project: Project Properties\Signing or setting the option [assembly: AssemblyKeyFile(@"..\..\mycas.snk")] in AssemblyInfo.cs.
- Create a new Code Group below the User Policy level. For the membership condition, use the Strong Name and import it from the assembly.
- Create a new Permission set for this group and specify permissions like [File IO, C:\, Read only], [File Dialog, Open only], [User Interface, Unrestricted access] and [Security, Enable Assembly Execution].

IMPORTANT: For the new created group ensure that you have checked the option: This policy level will only have the permissions from the permission set associated with this code group

Running the following code will thrown an exception because we dont have write access to c:\.

private void button1_Click(object sender, EventArgs e)
{
    try
    {
        StreamWriter sw = File.CreateText(@"c:\filename.txt");
        sw.WriteLine("test line");
        sw.Close();
    }
    catch (SecurityException securityEx)
    {
        MessageBox.Show(securityEx.Message, "Security Exception");
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message, "Exception");
    }
}

Using imperative security check:

private void button1_Click(object sender, EventArgs e)
{
    FileIOPermission filePermission = new FileIOPermission(FileIOPermissionAccess.Write, @"c:\filename.txt");
    try
    {
        filePermission.Demand(); // Permission demand
 
        StreamWriter sw = File.CreateText(@"c:\filename.txt");
        sw.WriteLine("test line");
        sw.Close();
    }
    catch (SecurityException securityEx)
    {
        MessageBox.Show(securityEx.Message, "Security Exception");
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message, "Exception");
    }
}

We can also use the Security Manager to verify we have permissions before demand it.

private void button1_Click(object sender, EventArgs e)
{
    FileIOPermission filePermission = new FileIOPermission(FileIOPermissionAccess.Write, @"c:\filename.txt");
    try
    {
        if (SecurityManager.IsGranted(filePermission))
        {
            filePermission.Demand(); // Permission 
 
            StreamWriter sw = File.CreateText(@"c:\filename.txt");
            sw.WriteLine("test line");
            sw.Close();
        }
        else
            MessageBox.Show("You don't have access to c:\\filename.txt", "Access Denied");
    }
    catch (SecurityException securityEx)
    {
        MessageBox.Show(securityEx.Message, "Security Exception");
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message, "Exception");
    }
}

Using Declarative security check:

An exception is thrown before the application run the code, so our method is more simple now:

[FileIOPermission(SecurityAction.Demand, Write=@"C:\filename.txt")]
private void button1_Click(object sender, EventArgs e)
{
    try
    {
        StreamWriter sw = File.CreateText(@"c:\filename.txt");
        sw.WriteLine("test line");
        sw.Close();
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message, "Exception");
    }
}

Bypass check using Assert:

private void button1_Click(object sender, EventArgs e)
{
    FileIOPermission filePermission = new FileIOPermission(FileIOPermissionAccess.AllAccess, @"c:\filename.txt");
    
    try
    {
        filePermission.Assert(); // Bypass permission
 
        StreamWriter sw = new StreamWriter(@"c:\filename.txt");
        sw.WriteLine("test line");
        sw.Close();
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message, "Exception");
    }
}

Assembly Declarations:

The following declaration checks if we have access to c:\temp\filename.txt, otherwise an exception is thrown:

[assembly: FileIOPermission(SecurityAction.RequestMinimum, ViewAndModify=@"c:\temp\filename.txt")]

If we want to allow only access to specific resources, we should use RequestOptional. Example, by using the following declaration, if we try to access other file than c:\temp\filename.txt, an exception will be thrown.

[assembly: FileIOPermission(SecurityAction.RequestOptional, ViewAndModify=@"c:\temp\filename.txt")]

For refuse access to specific resources, we can use RequestRefuse:

[assembly: FileIOPermission(SecurityAction.RequestRefuse, ViewAndModify = @"c:\windows\")]

Permission Requests:

Assert: Bypass permission check. Assemblies must have the Assert Any Permission That Has Been Granted security permission setting.

Demand: Instructs the runtime to throw an exception if the caller and all callers higher in the stack lack the specified permission.

Deny: Causes the runtime to reduce the method’s access by removing the specified permission.

InheritanceDemand: Instructs the runtime to throw an exception if the assembly inheriting from the class lacks the specified permission.

LinkDemand: Causes the runtime to throw an exception if the immediate caller, but not callers higher in the stack, lack the specified permission.

PermitOnly: Instructs the runtime to reduce the method’s access by removing all permissions except for the specified permission.

References:

Code Access Security with Microsoft .NET Framework, Part 2
Managing .NET Code Access Security (CAS) Policy
Configuring .NET Code Access Security
Code Access Security / .NET Reference Guide
Code Access Security in the .NET Framework

How-To write XML "plain" document, without namespaces and header

2008-01-24T17:10:00.000-08:00

Here the XmlTextWriterFormattedNoDeclaration class definition:

public class XmlTextWriterFormattedNoDeclaration : System.Xml.XmlTextWriter
{
      public XmlTextWriterFormattedNoDeclaration(System.IO.TextWriter w) : base(w)
      {
            //Formatting = System.Xml.Formatting.Indented;
      }
  
      public override void WriteStartDocument()
      {
            // suppress
      }
}

And here, how we can use it:

// Create an instance for namespace class
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("", "");
 
// now, serialize the object
XmlSerializer xmlr = new XmlSerializer(typeof(Docs));
StringWriter sw = new StringWriter();
XmlTextWriter tw = new XmlTextWriterFormattedNoDeclaration(sw);
 
xmlr.Serialize(tw, docs, ns);
  
MessageBox.Show(sw.ToString());

For deserialization we have:

// Deserializing the object
StringReader sr = new StringReader(sw.ToString());
Docs docs2 = (Docs) xmlr.Deserialize(sr);
 
MessageBox.Show(docs2.ToString());

Xml Serialization

2008-01-24T15:52:00.001-08:00

The Xml serialization is the most compatible and versatile serialization technique. We can set attributes for the class we want to serialize for produccing the output we want. Here an example:

Serializing:

// Building the object instance
Person p = new Person("Oscar", "L", new DateTime(1972, 6, 16));
 
// Now, the Person class includes a List named Friends
p.Friends.Add(new Person("John", "T", new DateTime(1970, 1, 25)));
p.Friends.Add(new Person("Mary", "Z", new DateTime(1975, 12, 1)));
 
// Our target file stream
FileStream fs = File.Create("c:\\filename.xml");
 
// The xml serializer
XmlSerializer xs = new XmlSerializer(typeof(Person));
 
// Serializing the person object
xs.Serialize(fs, p);
 
fs.Close();  // Don't forget to close the file stream

Deserializing:

// Our source file stream
FileStream fs = File.OpenRead("c:\\filename.xml");
 
// The xml serializer
XmlSerializer xs = new XmlSerializer(typeof(Person));
 
// Deserializing the object
Person p = (Person)xs.Deserialize(fs);
 
fs.Close();  // Don't forget to close the file stream
 
// Showing results
MessageBox.Show(p.FirstName + " " + p.Age.ToString());
MessageBox.Show("Number of friends: " + p.Friends.Count.ToString());

And here the Person class definition:

[XmlRoot(ElementName="thisPerson")]
public class Person
{
    [XmlElement(ElementName="Name")]
    public string FirstName;
    public string LastName;
 
    [XmlAttribute]
    public DateTime BirthDay;
 
    [XmlIgnore]
    public int Age;
 
    [XmlArray("myFriends")]
    [XmlArrayItem("myFriend")]
    public People Friends = new People();
 
    public Person()
    {
    }
 
    public Person(string _firstName, string _lastName, DateTime _birthDay)
    {
        FirstName = _firstName;
        LastName = _lastName;
        BirthDay = _birthDay;
 
        Age = DateTime.Now.Year - BirthDay.Year - 1;
    }
}
 
public class People : List<Person>
{
}

Notice how I named the root node as 'thisPerson' and the element FirstName as 'Name'. I also set the BirthDay for serializing as an XmlAttribute instead of an XmlElement. And I set the Age for ignoring it (XmlIgnore attribute) so it will not included into the output.

For the list named Friends, I apply the XmlArray attribute to named it as 'myFriends' and every item in the collection as 'myFriend'.

This will produce the following output:

<?xml version="1.0"?>
<thisPerson xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" BirthDay="1972-06-16T00:00:00">
  <Name>Oscar</Name>
  <LastName>L</LastName>
  <myFriends>
    <myFriend BirthDay="1970-01-25T00:00:00">
      <Name>John</Name>
      <LastName>T</LastName>
      <myFriends />
    </myFriend>
    <myFriend BirthDay="1975-12-01T00:00:00">
      <Name>Mary</Name>
      <LastName>Z</LastName>
      <myFriends />
    </myFriend>
  </myFriends>
</thisPerson>

If we want to control errors, we need to handle some events:

// Event handlers
xs.UnknownAttribute += new XmlAttributeEventHandler(xs_UnknownAttribute);
xs.UnknownElement += new XmlElementEventHandler(xs_UnknownElement);
xs.UnknownNode += new XmlNodeEventHandler(xs_UnknownNode);
xs.UnreferencedObject += new UnreferencedObjectEventHandler(xs_UnreferencedObject);

void xs_UnreferencedObject(object sender, UnreferencedObjectEventArgs e)
{
    // something happen
}
 
void xs_UnknownNode(object sender, XmlNodeEventArgs e)
{
    // something happen
}
 
void xs_UnknownElement(object sender, XmlElementEventArgs e)
{
    // something happen
}
 
void xs_UnknownAttribute(object sender, XmlAttributeEventArgs e)
{
    // something happen
}

Implementing the IXmlSerializable:

If we want more control over serialization, we need to implement the interface IXmlSerializable as bellow:

[XmlRoot(ElementName = "thisPerson")]
public class Person : IXmlSerializable
{
    public string FirstName;
    public string LastName;
    public DateTime BirthDay;
 
    public int Age;
 
    public People Friends = new People();
 
    public Person()
    {
    }
 
    public Person(string _firstName, string _lastName, DateTime _birthDay)
    {
        FirstName = _firstName;
        LastName = _lastName;
        BirthDay = _birthDay;
 
        Age = DateTime.Now.Year - BirthDay.Year - 1;
    }
 
    #region IXmlSerializable Members
 
    public System.Xml.Schema.XmlSchema GetSchema()
    {
        return (null);
    }
 
    public void ReadXml(System.Xml.XmlReader reader)
    {
        reader.MoveToContent();
 
        BirthDay = DateTime.Parse(reader.GetAttribute("BirthDay"));
 
        FirstName = reader.ReadElementString();
        LastName = reader.ReadElementString();
        Age = int.Parse(reader.ReadElementString());
 
        // Reading friends collection
        Friends.Clear();
 
        int depth = reader.Depth;  // actual depth
        bool read = reader.Read(); // next read
        while ((read) && (reader.Depth > depth))
        {
            reader.MoveToContent(); 
 
            if (reader.IsStartElement())
            {
                Person p = new Person();
                p.ReadXml(reader);
                Friends.Add(p);
            }
 
            read = reader.Read();
        }
    }
 
    public void WriteXml(System.Xml.XmlWriter writer)
    {
        writer.WriteAttributeString("BirthDay", BirthDay.ToString());
        writer.WriteElementString("Name", FirstName);
        writer.WriteElementString("LastName", LastName);
        writer.WriteElementString("Age", Age.ToString());
 
        writer.WriteStartElement("myFriends");
        foreach (Person p in Friends)
        {
            writer.WriteStartElement("myFriend");
            p.WriteXml(writer);
            writer.WriteEndElement();
        }
        writer.WriteEndElement();
    }
 
    #endregion
}    
 
public class People : List<Person>
{
}

And here the output it produces:

<?xml version="1.0"?>
<thisPerson BirthDay="6/16/1972 12:00:00 AM">
  <Name>Oscar</Name>
  <LastName>L</LastName>
  <Age>35</Age>
  <myFriends>
    <myFriend BirthDay="1/25/1970 12:00:00 AM">
      <Name>John</Name>
      <LastName>T</LastName>
      <Age>37</Age>
      <myFriends />
    </myFriend>
    <myFriend BirthDay="12/1/1975 12:00:00 AM">
      <Name>Mary</Name>
      <LastName>Z</LastName>
      <Age>32</Age>
      <myFriends />
    </myFriend>
  </myFriends>
</thisPerson>

Binary and Soap serialization

2008-01-24T08:21:00.000-08:00

We can serialize objects as a binary representation of them, by using the BinaryFormatter class, like this:

// Some objects to serialize
string str = "test line";
DateTime dt = DateTime.Now;
 
// Our target file stream
FileStream fs = File.Create("c:\\filename.dat");
 
// The binary formatter
BinaryFormatter bf = new BinaryFormatter();
 
// Serializing multiple objects
bf.Serialize(fs, str);
bf.Serialize(fs, dt);
 
fs.Close(); // Don't forget to close the file stream

Deserializing:

// Our source file stream
FileStream fs = File.OpenRead("c:\\filename.dat");
 
// The binary formatter
BinaryFormatter bf = new BinaryFormatter();
 
// Deserializing objects
string str = (string)bf.Deserialize(fs);
DateTime dt = (DateTime)bf.Deserialize(fs);
 
fs.Close();  // Don't forget to close the file stream
 
// Showing results
MessageBox.Show(str);
MessageBox.Show(dt.ToString());

We can set preferences for serializing objects by using Serialize Attributes. Also, if we need to perform some task after deserializing was performed, we need to implement the IDeserializationCallback interface.

Here an example using a person class that will not serialize the Age property, cause it is a calculated property.

[Serializable]
public class Person : IDeserializationCallback
{
    public string FirstName;
    public string LastName;
 
    public DateTime BirthDay;
 
    [NonSerialized]
    public int Age;
 
    [OptionalField]
    public string Alias;
 
    public Person()
    {
    }
 
    public Person(string _firstName, string _lastName, DateTime _birthDay)
    {
        FirstName = _firstName;
        LastName = _lastName;
        BirthDay = _birthDay;
 
        Age = DateTime.Now.Year - BirthDay.Year - 1;
 
        Alias = "";
    }
 
    #region IDeserializationCallback Members
 
    public void OnDeserialization(object sender)
    {
        Alias = "";
        Age = DateTime.Now.Year - BirthDay.Year - 1;
    }
 
    #endregion
}

NOTE: The OptionalField attribute has the property VersionAdded. This is reserved but we can set this with the correct version for our object, starting from 2. Example: [OptionalField(VersionAdded=2)], [OptionalField(VersionAdded=3)], and so on.

Serializing:

// Building the object instance
Person p = new Person("Oscar", "L", new DateTime(1972, 6, 16));
 
// Our target file stream
FileStream fs = File.Create("c:\\filename.dat");
 
// The binary formatter
BinaryFormatter bf = new BinaryFormatter();
 
// Serializing the person object
bf.Serialize(fs, p);
 
fs.Close(); // Don't forget to close the file stream

Deserializing:

// Our source file stream
FileStream fs = File.OpenRead("c:\\filename.dat");
 
// The binary formatter
BinaryFormatter bf = new BinaryFormatter();
 
// Deserializing the object
Person p = (Person)bf.Deserialize(fs);
 
fs.Close();  // Don't forget to close the file stream
 
// Showing results
MessageBox.Show(p.FirstName + " " + p.Age.ToString());

The code above will invoke the Person.OnDeserialization callback, so we can perform some tasks after deserialization was performed, such as, recalculate fields.

The SoapFormatter class

The SoapFormatter class works in the same way as the BinaryFormatter, except that it produces an XML Soap output, so it could be used to transport objects across the network boundaries (over Internet).

// Building the object instance
Person p = new Person("Oscar", "L", new DateTime(1972, 6, 16));
 
// Our target file stream
FileStream fs = File.Create("c:\\filename.soap");
 
// The soap formatter
SoapFormatter sf = new SoapFormatter();
 
// Serializing the person object
sf.Serialize(fs, p);
 
fs.Close(); // Don't forget to close the file stream

Here the output it produces:

<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas.microsoft.com/soap/encoding/clr/1.0" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
<a1:Person id="ref-1" xmlns:a1="http://schemas.microsoft.com/clr/nsassem/WindowsFormsApplication6/WindowsFormsApplication6%2C%20Version%3D1.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3Dnull">
<FirstName id="ref-3">Oscar</FirstName>
<LastName id="ref-4">L</LastName>
<BirthDay>1972-06-16T00:00:00.0000000-05:00</BirthDay>
<Alias id="ref-5"></Alias>
</a1:Person>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>

And here, how we can read back the object:

// Our source file stream
FileStream fs = File.OpenRead("c:\\filename.soap");
 
// The soap formatter
SoapFormatter sf = new SoapFormatter();
 
// Deserializing the object
Person p = (Person)sf.Deserialize(fs);
 
fs.Close();  // Don't forget to close the file stream
 
// Showing results
MessageBox.Show(p.FirstName + " " + p.Age.ToString());

NOTE: For using the SoapFormatter, you need to add the reference to the System.Runtime.Serialization.Formatters.Soap library.

Implementing a custom serialization:

If we want to implement our custom serialization, we need to implement the ISerializable interface and write data when the GetObjectData is called and implement a new constructor conforms with the ISerializable specification, like this:

// New class declaration
 
[Serializable]
public class Person : IDeserializationCallback, ISerializable
{
 
...
 
// New constructor
protected Person(SerializationInfo info, StreamingContext context)
{
    this.FirstName = info.GetString("FirstName");
    this.LastName = info.GetString("LastName");
    this.BirthDay = info.GetDateTime("BirthDay");
 
    // Custom and calculated methods can be processed here    
    string another = info.GetString("another");
}
 
// Implementing the GetObjectData method
 
#region ISerializable Members
 
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
    info.AddValue("FirstName", this.FirstName);
    info.AddValue("LastName", this.LastName);
    info.AddValue("BirthDay", this.BirthDay);
 
    // Custom and other values can be writed here
    info.AddValue("another", "another value");
}
 
#endregion
 
...
 
} // End of class

Another way for controlling our serialization, can be achieve by using custom methods with serialization attributes (they transform the method in a callback that serialization will call):

[Serializable]
public class Person : IDeserializationCallback, ISerializable
{
 
...
 
[OnSerializing()]
internal void OnSerializingMethod(StreamingContext context)
{
    // During serialization
}
 
[OnSerialized()]
internal void OnSerializedMethod(StreamingContext context)
{
    // After serialization
}
 
[OnDeserializing()]
internal void OnDeserializingMethod(StreamingContext context)
{
    // During deserialization
}
 
[OnDeserialized()]
internal void OnDeserializedMethod(StreamingContext context)
{
    // After deserialization
}
 
...
 
} // End of class

NOTE: The StreamingContext object can be used to pass some important information to serialization methods (StreamingContext.Context as object) and can be used to get information about the destination (StreamingContext.State as StreamingContextStates enumeration).

// The binary formatter
StreamingContext sc = new StreamingContext(myCustomObject);
BinaryFormatter bf = new BinaryFormatter(null, sc);

Working with IsolatedStorage class

2008-01-23T16:07:00.000-08:00

Creating a file in our isolated store:

// Create our isolated store with Machine/Assembly scope
// Also, we can create one with User/Assembly scope and others.
IsolatedStorageFile isf = IsolatedStorageFile.GetMachineStoreForAssembly();
 
// Open our stream for writing to it
IsolatedStorageFileStream isfs = new IsolatedStorageFileStream("filename.txt", FileMode.Create, isf);
 
// Using StreamWriter to write
StreamWriter sw = new StreamWriter(isfs);
sw.WriteLine("test line");
 
sw.Flush();
sw.Close(); // Close the stream
 
isf.Close();

The isolated store will be created on C:\Documents and Settings\All Users\Application Data\IsolatedStorage\..\..\..\AssemFiles. Reading files from our isolated store:

// Create our isolated store with Machine/Assembly scope
IsolatedStorageFile isf = IsolatedStorageFile.GetMachineStoreForAssembly();
 
// Open our stream for reading from it
IsolatedStorageFileStream isfs = new IsolatedStorageFileStream("filename.txt", FileMode.Open, isf);
 
// Using StreamReader to read
StreamReader sr = new StreamReader(isfs);
MessageBox.Show(sr.ReadToEnd());
 
sr.Close(); // Close the stream
 
isf.Close();

Using directories:

// Create our isolated store with Machine/Assembly scope
IsolatedStorageFile isf = IsolatedStorageFile.GetMachineStoreForAssembly();
 
// Create one directory
isf.CreateDirectory("Temp");
 
// Open our stream for writing to it
IsolatedStorageFileStream isfs = new IsolatedStorageFileStream(@"Temp\filename.txt", FileMode.Create, isf);
 
// Using StreamWriter to write
StreamWriter sw = new StreamWriter(isfs);
sw.WriteLine("another line");
 
sw.Flush();
sw.Close();  // Close the stream
 
isf.Close();

Also, we can remove our isolated store:

// Create our IsolatedStorage with Machine/Assembly scope
IsolatedStorageFile isf = IsolatedStorageFile.GetMachineStoreForAssembly();
 
// Removing our isolated store
isf.Remove();

Other useful methods: GetFileNames GetDirectoryNames DeleteDirectory DeleteFile

Streams 2

2008-01-23T15:48:00.000-08:00

There are other useful stream and reader/writer classes.

For working with strings, we can use StringReader and StringWriter. Also, remember the StringBuilder class, but the last one isn't an stream.

TextReader and TextWriter are abstract base class that StreamReader, StreamWriter, StringReader, and StringWriter derive from.

For binary tasks, we can use BinaryReader and BinaryWriter. Here another approach for reading compressed binary files:

// Open the stream we want to decompress
FileStream fs = File.OpenRead(@"c:\temp\filename.zip");
 
// Creates the GZipStream
GZipStream gzip = new GZipStream(fs, CompressionMode.Decompress);
 
// We want to read binary content into one memory stream
// This could be also a FileStream object
MemoryStream ms = new MemoryStream();
 
// We use the binary reader for improve the performance
BinaryReader br = new BinaryReader(gzip);
 
byte[] b = br.ReadBytes(1000);
while (b.Length > 0)
{
    ms.Write(b, 0, b.Length);
    b = br.ReadBytes(1000);
}
 
// Show read content's length
MessageBox.Show(ms.Length.ToString());
ms.Close(); // Close our target stream
 
br.Close(); // This also closes the GZipStream and the FileStream (the underlying stream)*/

Streams

2008-01-23T08:16:00.000-08:00

Some interesting properties and methods for the Stream class:

Length: Gets the length (in bytes) of the stream.
Position: Gets or sets the current position in the stream for reading and writing operations.
Seek(): Sets the position within the stream.
Flush(): Clears any buffers within the stream and forces changes to be written to the underlying system or device. Some streams have the AutoFlush property for flushing automatically any change.
Close(): Closes the stream and releases any resources associated with it. !!! Remember always close the stream !!!
Read(): Performs a sequential read of a specified number of bytes from the current position and updates the position to the end of the read upon completion of the operation.
ReadByte(): Performs the read of a single byte and updates the position by moving it by one.
Write(): Writes information to the stream as a number of bytes and updates the current position to reflect the new write position.
WriteByte(): Writes a single byte to the stream and updates the position.

There are a lot of streams, some of them:

FileStream
MemoryStream
CryptoStream
NetworkStream
GZipStream

The File class

The File class provides methods for easy writing and reading operations.

Copy(): Copies a file to a new file. !!! The new file must not exist or an event will be thrown. !!!
Move(): Moves a file from one place to another. !!! The target file must not exist or an event will be thrown. !!!
Delete(): Deletes a file. !!! None exception is throw if file doesn't exists !!!
Exists(): Returns true if a file exists.
AppendText(): Opens a file (or creates a new file if one does not exist) and returns a StreamWriter that is prepared to allow text to be appended to the file.
CreateText(): Creates or opens a file and returns a StreamWriter object that is ready to have text written into it.
OpenText(): Opens an existing file and returns a StreamReader object.
Open(): Opens an existing file and returns a FileStream object. We can specify the file mode and the file access type.
OpenRead(): Opens an existing file and returns a read-only FileStream object.
OpenWrite(): Opens an existing file for writing and returns a FileStream object.
Create(): Creates a new file and returns a FileStream object.
ReadAllBytes(): Opens a file, reads the contents of it into a byte array, and closes the file.
ReadAllLines(): Opens a file, reads the contents of it into an array of strings (one per line), and closes the file.
ReadAllText(): Opens a file, reads the contents of it into a string, and closes the file.
WriteAllBytes(): Opens a file, writes the contents of a byte array into it (overwriting any existing data), and closes the file.
WriteAllLines(): Opens a file, writes the contents of a string array into it (overwriting any existing data), and closes.
WriteAllText(): Opens a file, writes the contents of a string into it (overwriting any existing data), and closes the file.

// Reading some bytes
FileStream fs = File.OpenRead("c:\\temp\\filename.txt");
int b = fs.ReadByte();
fs.Close();
 
MessageBox.Show(b.ToString());

// Reading using the StreamReader
StreamReader sr = File.OpenText("c:\\temp\\filename.txt");
 
MessageBox.Show(sr.ReadToEnd());
 
sr.Close(); // Dont forget to close the stream

// Reading all text at once (The easy way!!!)
MessageBox.Show(File.ReadAllText("c:\\temp\\filename.txt"));

// Reading all lines at once
string[] lines = File.ReadAllLines("c:\\temp\\filename.txt");
 
foreach(string s in lines)
    MessageBox.Show(s);

The FileAccess enumeration:

Read
Write
ReadWrite

The FileMode enumeration:

Append
Create
CreateNew: An exception is thrown if file exists.
Open: An exception is thrown if file does not exist.
OpenOrCreate
Truncate

NOTE: The FileStream also has the Lock and Unlock methods to prevent other process from changing all or part of the file.

The StreamReader and StreamWriter are classes for easy writing and reading operations with streams. We can use the property AutoFlush for automatically flushing the content to the stream.

// Writing with StreamWriter
StreamWriter sw = File.CreateText(@"c:\temp\filename2.txt");
sw.WriteLine("test line");
sw.Flush(); // Or set sw.AutoFlush = true; to avoid calling this method
sw.Close(); // Dont forget to close the stream

// Reading with StreamReader
StreamReader sr = File.OpenText(@"c:\temp\filename2.txt");
 
MessageBox.Show(sr.ReadLine());
 
sr.Close(); // Dont forget to close the stream

If we are looking for performance, we can use the MemoryStream and the BufferedStream.

// Creating the MemoryStream object
MemoryStream ms = new MemoryStream();
 
// Using one StreamWriter for access the MemoryStream
StreamWriter sw = new StreamWriter(ms);
sw.WriteLine("test line");
sw.Flush();
 
// Now, we can use the MemoryStream to flush the content to a file at once
FileStream fs = File.Create(@"c:\temp\filename2.txt");
ms.WriteTo(fs);
fs.Close();
 
sw.Close(); // This also closes the MemoryStream (the underlying stream)

// Open the stream we want to buffer
FileStream fs = File.Create(@"c:\temp\filename2.txt");
 
// Creates the BufferedStream
BufferedStream bs = new BufferedStream(fs);
 
// Now, perform some writing operation
StreamWriter sw = new StreamWriter(bs);
sw.WriteLine("test line");
sw.Close(); // This also closes the BufferedStream and the FileStream (the underlying stream)

// Open the stream we want to buffer
FileStream fs = File.OpenRead(@"c:\temp\filename2.txt");
 
// Creates the BufferedStream
BufferedStream bs = new BufferedStream(fs);
 
// Now, perform some reading operation
StreamReader sr = new StreamReader(bs);
MessageBox.Show(sr.ReadLine());
sr.Close(); // This also closes the BufferedStream and the FileStream (the underlying stream)

Compressing and Decompressing streams

We can use the GZipStream and DeflateStream classes for performing compression and decompression of streams:

// Open the stream we want to compress
FileStream fs = File.Create(@"c:\temp\filename.zip");
 
// Creates the GZipStream
GZipStream gzip = new GZipStream(fs, CompressionMode.Compress);
 
// Reading the content to compress
string s = File.ReadAllText(@"c:\temp\filename.txt");
 
// Writing compressed content
StreamWriter sw = new StreamWriter(gzip);
sw.Write(s);
sw.Close();  // This also closes the GZipStream and the FileStream (the underlying stream)

Binary compression, using bytes:

// Open the stream we want to compress
FileStream fs = File.Create(@"c:\temp\filename.zip");
 
// Creates the GZipStream
GZipStream gzip = new GZipStream(fs, CompressionMode.Compress);
 
// Reading the content to compress
byte[] bytes = File.ReadAllBytes(@"c:\temp\filename.txt");
 
// Writing compressed content
gzip.Write(bytes, 0, bytes.Length);
gzip.Close();  // This also closes the FileStream (the underlying stream)

Decompression

// Open the stream we want to decompress
FileStream fs = File.OpenRead(@"c:\temp\filename.zip");
 
// Creates the GZipStream
GZipStream gzip = new GZipStream(fs, CompressionMode.Decompress);
 
// Reading the uncompressed content
StreamReader sr = new StreamReader(gzip);
MessageBox.Show(sr.ReadToEnd());
sr.Close();  // This also closes the GZipStream and the FileStream (the underlying stream)

Binary decompression, using bytes:

// Open the stream we want to decompress
FileStream fs = File.OpenRead(@"c:\temp\filename.zip");
 
// Creates the GZipStream
GZipStream gzip = new GZipStream(fs, CompressionMode.Decompress);
 
// We want to read binary content into one memory stream
// This could be also a FileStream object
MemoryStream ms = new MemoryStream();
 
// Reading the uncompressed content
int c = gzip.ReadByte();
while (c != -1)
{
    ms.WriteByte((byte)c);
    c = gzip.ReadByte();
}
 
// Show read content's length
MessageBox.Show(ms.Length.ToString());
ms.Close(); // Close our target stream
 
gzip.Close();  // This also closes the FileStream (the underlying stream)

The FileSystemWatcher class

2008-01-23T07:27:00.000-08:00

By using the FileSystemWatcher we can monitor the activity in our disks.

// Create our file system watcher
FileSystemWatcher fsw = new FileSystemWatcher(@"C:\temp");
 
// Also, we want to include subdirectories
fsw.IncludeSubdirectories = true;
 
// Subscribing to events
fsw.Changed += new FileSystemEventHandler(fsw_Changed);
fsw.Created += new FileSystemEventHandler(fsw_Created);
fsw.Renamed += new RenamedEventHandler(fsw_Renamed);
fsw.Deleted += new FileSystemEventHandler(fsw_Deleted);
 
// Enabling raising events
fsw.EnableRaisingEvents = true;
 
...
 
// Here the events handlers
void fsw_Deleted(object sender, FileSystemEventArgs e)
{
    MessageBox.Show("Deleted " + e.FullPath);
}
 
void fsw_Renamed(object sender, RenamedEventArgs e)
{
    MessageBox.Show("Renamed " + e.OldName + " to " + e.Name);
}
 
void fsw_Created(object sender, FileSystemEventArgs e)
{
    MessageBox.Show("Created " + e.Name);
}
 
void fsw_Changed(object sender, FileSystemEventArgs e)
{
    MessageBox.Show("Changed " + e.Name);
}

We can polling for changes detection:

// Creating our file system watcher
FileSystemWatcher fsw = new FileSystemWatcher(@"C:\temp");
fsw.NotifyFilter = NotifyFilters.Attributes | NotifyFilters.FileName;
 
// Creating our waiting handler
// We set 100 seconds for timeout and
// we are waiting for all kind of changes
WaitForChangedResult wfcr = fsw.WaitForChanged(WatcherChangeTypes.All, 100000);
 
// Showing the result
MessageBox.Show(wfcr.ChangeType.ToString());
MessageBox.Show(wfcr.Name);

FileInfo, DirectoryInfo and DriveInfo classes

2008-01-22T19:21:00.001-08:00

FileSystemInfo is the base class of FileInfo and DriveInfo. Here, some important properties and methods:

Attributes: Gets or sets FileAttributes of the current file or directory.
Name: Gets the simple name for the file or directory. For a file, this is the name within the directory. For a directory, this is the last directory name in the directory hierarchy.
FullName: Gets the full path to the file or directory.
Extension: Gets a string representation of the extension part of the file or directory.
LastWriteTime: (!) Gets or sets the time the file or directory was last written to.
Exists: Determines whether the file or directory exists.
Delete(): Removes the file or directory from the file system.

The FileInfo also has also some interesting properties and methods:

Directory: (!) Gets the DirectoryInfo object that represents the directory that this file is stored within.
DirectoryName: Gets the name of the directory that this file is stored within.
Length: Gets the length of the file.
AppendText(): Creates a new StreamWriter that will allow appending text to the file. !!! Default Encoding is UTF-8 !!!
CreateText(): Creates a new StreamWriter and a new file for writing text. !!! Default Encoding is UTF-8 !!!
OpenText(): Opens the file and returns a StreamReader to allow reading of text within the file. !!! Default Encoding is UTF-8 !!!
Open(): Opens the file with specific privileges (read, read/write, and so on). Returns a new FileStream object.
OpenRead(): Opens the file with read-only access. Returns a new FileStream object.
OpenWrite(): Opens the file with write-only access. Returns a new FileStream object.
CopyTo(): Makes a copy of the file in a new location. MoveTo Moves the file to a new location.
Replace(): Replaces a file with the information in the current FileInfo object.
Create(): Creates a file based on the current file information. Returns a new FileStream object.
Decrypt(): Decrypts a file that was encrypted by the current user.
Encrypt(): Encrypts a file so that only the current user can decrypt the

// Getting information from a file
FileInfo fi = new FileInfo(@"C:\temp\filename.txt");
 
MessageBox.Show(fi.LastWriteTime.ToString());

// Append text to one existing file
FileInfo fi = new FileInfo(@"C:\temp\filename.txt");
 
StreamWriter sw = fi.AppendText();
sw.WriteLine("another line");
sw.Flush(); // If we don't want to flush manually, set the AutoFlush property as true
sw.Close(); // don't forget to close the stream

// Reading content from a file
FileInfo fi = new FileInfo(@"C:\temp\filename.txt");
 
StreamReader sr = fi.OpenText();
MessageBox.Show(sr.ReadToEnd());
sr.Close(); // don't forget to close the stream

The DirectoryInfo also has also some interesting properties and methods:

Parent: Gets the DirectoryInfo object for the parent directory of the current directory in the directory hierarchy
Root: Gets the root part of the directory’s path as a string
Create(): Creates the directory described in the current DirectoryInfo object
CreateSubdirectory(): (!) Creates a new directory as a child directory of the current directory in the directory hierarchy
GetDirectories(): Retrieves an array of DirectoryInfo objects that represent subdirectories of the current directory
GetFiles(): (!) Retrieves an array of FileInfo objects that represent all the files in the current directory

// Getting directory information
DirectoryInfo di = new DirectoryInfo(@"C:\temp");
 
MessageBox.Show(di.Parent.Name);
 
// Get all txt files from directory
FileInfo[] fis = di.GetFiles("*.txt");
 
foreach (FileInfo fi0 in fis)
    MessageBox.Show(fi0.Name);

And finally, for the DriveInfo also has also some interesting properties and methods:

AvailableFreeSpace: Gets the amount of available space on the drive. The amount might be different from the amount returned by TotalFreeSpace, depending on disk quotas or depending on the IsolatedStore we are working on.
TotalFreeSpace: Gets the total amount of free space on the drive.
TotalSize: Gets the total size of the drive.
DriveType: Gets the type of drive in the form of the DriveType enumeration
IsReady: Gets the status of the drive, indicating whether it is ready to be accessed.
RootDirectory: Gets a DirectoryInfo object that represents the root directory of the drive.
GetDrives(): A static method that returns all the drives on the current system.

The DriveType enumeration:

CDRom: An optical drive. It can be CD-ROM, DVD, and so on.
Fixed: A fixed disk.
Network: A network mapped drive.
NoRootDirectory: A drive that does not have a root directory.
Ram: A RAM drive.
Removable: A drive that has removable media.
Unknown: The drive could not be determined.

// Getting some information from drive
DriveInfo dri = new DriveInfo("C");
 
MessageBox.Show("Total Space=" + dri.TotalSize.ToString()
    + " TotalFreeSpace=" + dri.TotalFreeSpace.ToString()
    + " AvailableFreeSpace=" + dri.AvailableFreeSpace.ToString());

// Reading all drives we have
DriveInfo[] dris = DriveInfo.GetDrives();
foreach (DriveInfo dri0 in dris)
    MessageBox.Show(dri0.Name + " type=" + dri0.DriveType.ToString());

Here the Path class methods and properties:

GetFileName(): Returns the name of the file in the specified path.
GetDirectoryName(): Returns the name of the directory in the specified path.
GetExtension(): Returns the name of the file extension in the specified path.
GetFileNameWithoutExtension(): Returns the file name without the extension in the specified path.
ChangeExtension(): Takes a path and returns a new path with the file name’s extension changed.
GetFullPath(): Returns a full path to the specified path. This method can be used to resolve relative paths.
GetPathRoot(): Returns the root directory name in the specified path.
GetRandomFileName(): Generates a random file name. !!! Without path !!!
GetTempFileName(): Generates a temporary file in the file system and returns the full path to the file.
GetTempPath(): Returns the path to the temporary file directory for the current user or system.

// Getting some information from files
MessageBox.Show(Path.GetDirectoryName("c:\\temp\\filename.txt"));
MessageBox.Show(Path.GetFileName("c:\\temp\\filename.txt"));
MessageBox.Show(Path.ChangeExtension("c:\\temp\\filename.txt", ".ccc"));
 
// Getting random and temporary filenames
MessageBox.Show(Path.GetRandomFileName());
MessageBox.Show(Path.GetTempFileName());
MessageBox.Show(Path.GetTempPath());

Windows Management Instrumentation

2008-01-21T16:59:00.000-08:00

Getting information from WMI objects:

ManagementObjectSearcher s = new ManagementObjectSearcher("SELECT * FROM Win32_Service WHERE Started = TRUE");
foreach (ManagementObject service in s.Get())
{
    // Show some information
    MessageBox.Show(service["Caption"].ToString());
}

Or using the SelectQuery object:

SelectQuery query = new SelectQuery("Win32_Service", "State='Running'");
 
ManagementObjectSearcher s = new ManagementObjectSearcher(query);
foreach (ManagementObject service in s.Get())
{
    MessageBox.Show(service.Properties["Caption"].Value.ToString());
}

Changing some properties:

ManagementObjectSearcher s = new ManagementObjectSearcher("SELECT * FROM Win32_Service WHERE Name = 'InfonetSvc'");
foreach (ManagementObject service in s.Get())
{
    if (service["StartMode"].ToString() == "Manual")
        service.InvokeMethod("ChangeStartMode", new object[] { "Automatic" });
    else
        service.InvokeMethod("ChangeStartMode", new object[] { "Manual" });
}

Or, if property is Read/write access type we can use the Put method directly:

ManagementObjectSearcher s = new ManagementObjectSearcher("SELECT * FROM Win32_Environment WHERE Name = 'myVar'");
 
foreach (ManagementObject env in s.Get())
{
    // show the instance
    MessageBox.Show(env["VariableValue"].ToString());
 
    env["VariableValue"] = "new value";
    env.Put();
}

Subscribing to events:

// Our event query
EventQuery query = new EventQuery();
query.QueryString = "SELECT * FROM __InstanceCreationEvent WITHIN 1 WHERE TargetInstance isa \"Win32_Process\"";
 
// Initialize an event watcher and subscribe to events 
// that match this query
ManagementEventWatcher watcher = new ManagementEventWatcher(query);
 
// times out watcher.WaitForNextEvent in 50 seconds
watcher.Options.Timeout = new TimeSpan(0, 0, 50);
 
// Block until the next event occurs 
// Note: this can be done in a loop if waiting for 
//        more than one occurrence
MessageBox.Show("Open an application (notepad.exe) to trigger an event.");
ManagementBaseObject e = watcher.WaitForNextEvent();
 
//Display information from the event
MessageBox.Show(string.Format(
    "Process {0} has been created, path is: {1}",
    ((ManagementBaseObject)e
    ["TargetInstance"])["Name"],
    ((ManagementBaseObject)e
    ["TargetInstance"])["ExecutablePath"]));
 
//Cancel the subscription
watcher.Stop();

If we need user's credentials:

ConnectionOptions connOptions = new ConnectionOptions();
connOptions.Username = "username";
connOptions.Password = "password";
ManagementScope mScope = new ManagementScope("\\machinename", connOptions);
 
ObjectQuery oQuery = new ObjectQuery("SELECT Size, Name FROM Win32_LogicalDisk where DriveType=3");
 
ManagementObjectSearcher s = new ManagementObjectSearcher(mScope, oQuery);
ManagementObjectCollection AllObjects = s.Get();
 
foreach (ManagementObject mObject in AllObjects)
{
    MessageBox.Show("Resource Name: " + mObject["Name"].ToString());
    MessageBox.Show("Resource Size: " + mObject["Size"].ToString());
}

More information on MSDN Available WMI classes in MSDN

Performance Counters

2008-01-21T10:32:00.000-08:00

Creating a counter:

// Creating our category
PerformanceCounterCategory.Create("MyCategory", // category name
    "My New Perf Category Description",  // category help
    PerformanceCounterCategoryType.SingleInstance, // single instance
    "MyCounter", // counter name
    "My New Perf Counter Desc");  // counter help

We can set the Multiple Instance property if we want to reuse the same counter from differences sources. Example; in a multiprocessor environment, we can name instances for every processor we have: processor 1, processor 2, etc.

We can also create multiple categories at once by using the CounterCreationDataCollection parameter in the method PerformanceCounterCategory.Create.

Deleting one category:

PerformanceCounterCategory.Delete("MyCategory");

Asking for one counter:

if (PerformanceCounterCategory.Exists("MyCategory"))
{
    PerformanceCounterCategory pcat = new PerformanceCounterCategory("MyCategory");
    if (pcat.CounterExists("myCounter"))
    {
        ...
    }
    else
        MessageBox.Show("Counter doesn't exists");
}
else
    MessageBox.Show("Category doesn't exists");

We can get multiple categories and counters:

PerformanceCounterCategory[] pcats = PerformanceCounterCategory.GetCategories();
PerformanceCounter[] pcount = pcat.GetCounters();

Reading a counter's value:

PerformanceCounter pc = new PerformanceCounter("MyCategory", "myCounter");
MessageBox.Show(pc.CounterName + " value=" + pc.NextValue().ToString());

Increasing a counter:

// get an instance of our perf counter
PerformanceCounter counter = new PerformanceCounter("MyCategory", "myCounter");
 
counter.ReadOnly = false; // Set false for writing to it
 
// increment and close the perf counter
counter.Increment();
counter.Close();

We can set data directly by using the property RawValue.

If we are using multiple instances, we need to specify which instance is the counter related to:

counter.InstanceName = "testt";

Process management

2008-01-20T18:10:00.000-08:00

// Getting information about the current process
Process cp = Process.GetCurrentProcess();
MessageBox.Show(cp.Id.ToString());

// Getting a process by it's Id
try
{
    Process pid = Process.GetProcessById(3660);
 
    MessageBox.Show(pid.ProcessName);
}
catch(ArgumentException)
{
    // Process with this Id was not found
}

// Getting all process by name
Process[] pcol = Process.GetProcessesByName("iexplore");
foreach (Process p in pcol)
    MessageBox.Show(p.Id.ToString());

// Getting all process in another computer
Process[] pcol = Process.GetProcesses("pcname");
foreach (Process p in pcol)
    MessageBox.Show(p.ProcessName);

// Launching a new process
Process p2 = new Process();
ProcessStartInfo psi = new ProcessStartInfo("notepad.exe");
p2.StartInfo = psi;
p2.Start();

For launch a process with user's credentials, we can use:

// Launching a new process
Process p2 = new Process();
ProcessStartInfo psi = new ProcessStartInfo("notepad.exe");
p2.StartInfo = psi;
 
// Setting the username and password
psi.UserName = "username";
psi.Domain = "domain";
 
// Password must be secured
string pwd = "password";
char[] cpwd = pwd.ToCharArray();
 
SecureString ss = new SecureString();
 
foreach (char c in cpwd)
    ss.AppendChar(c);
 
psi.Password = ss;
 
// UseShellExecute must be false if we want to execute the process with user's credentials
psi.UseShellExecute = false;
 
p2.Start();
 
// Waiting until the program finishes
p2.WaitForExit();

Or simply:

// Password must be secured
string pwd = "password";
char[] cpwd = pwd.ToCharArray();
 
SecureString ss = new SecureString();
 
foreach (char c in cpwd)
    ss.AppendChar(c);
 
// Launch the process with user's credentials
Process.Start("notepad.exe", "username", ss, "domain");

Other useful methods and properties:

WaitForExit
WaitForInputIdle
Kill
ExitCode
HasExited
Threads

About Trace Listeners

2008-01-20T13:19:00.000-08:00

By using trace listeners we can achieve debugging and tracing tasks in the easy way. We can configure trace listeners by source code or at runtime using the application config file (app.config).

The source code method:

// First step: create the trace source object
TraceSource ts = new TraceSource("myTraceSource");
 
// Second step: create some trace listeners
TextWriterTraceListener tr = new TextWriterTraceListener("C:\\outfile.txt");
XmlWriterTraceListener xt = new XmlWriterTraceListener("C:\\outfile.xml");
DelimitedListTraceListener dt = new DelimitedListTraceListener("C:\\outfile.csv.txt");
EventLogTraceListener et = new EventLogTraceListener("myappp");
 
// Third step: configuring our trace source and trace listeners
ts.Switch = new SourceSwitch("mySwitch", "my switch");
ts.Switch.Level = SourceLevels.Warning; // Enable only warning, error and critical events
 
// Configuring trace listeners
dt.Delimiter = "|";
dt.TraceOutputOptions = TraceOptions.DateTime | TraceOptions.Timestamp;
xt.TraceOutputOptions = TraceOptions.DateTime | TraceOptions.Timestamp;
tr.TraceOutputOptions = TraceOptions.DateTime | TraceOptions.Timestamp | TraceOptions.Callstack;
 
// Adding our trace listeners
ts.Listeners.Clear();
ts.Listeners.Add(et);
ts.Listeners.Add(dt);
ts.Listeners.Add(tr);
ts.Listeners.Add(xt);
 
// Setting autoflush to save files automatically
Trace.AutoFlush = true;
 
// Writing out some events
ts.TraceEvent(TraceEventType.Warning, 0, "warning message");
ts.TraceEvent(TraceEventType.Error, 0, "error message");
ts.TraceEvent(TraceEventType.Information, 0, "information message");
ts.TraceEvent(TraceEventType.Critical, 0, "critical message");

The application configuration file method:

We can achieve the same task above using the application configuration file. This allow you to change settings at runtime when you need some tracing information.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.diagnostics>
    <trace autoflush="true"/>
    <sources>
      <source name="myTraceSource"
              switchName="mySwitch"
              switchType="System.Diagnostics.SourceSwitch" >
        <listeners>
          <clear/>
          <add name="evengloglistener"
            type="System.Diagnostics.EventLogTraceListener"
            initializeData="myApp" />
          <add name="delimitedListener"
            type="System.Diagnostics.DelimitedListTraceListener"
            delimiter="|"
            initializeData="c:\outfile.csv.txt"
            traceOutputOptions="ProcessId, DateTime" />
          <add name="textwriterListener"
            type="System.Diagnostics.TextWriterTraceListener"
            initializeData="c:\outfile.txt"
            traceOutputOptions="ProcessId, DateTime, Callstack" />
          <add name="xmlListener"
            type="System.Diagnostics.XmlWriterTraceListener"
            initializeData="c:\outfile.xml"
            traceOutputOptions="ProcessId, DateTime" />
        </listeners>
      </source>
    </sources>
    <switches>
      <add name="mySwitch" value="Warning" />
    </switches>
  </system.diagnostics>
</configuration>

The source code now looks simple like this:

// First step: create the trace source object
TraceSource ts = new TraceSource("myTraceSource");
 
// Writing out some events
ts.TraceEvent(TraceEventType.Warning, 0, "warning message");
ts.TraceEvent(TraceEventType.Error, 0, "error message");
ts.TraceEvent(TraceEventType.Information, 0, "information message");
ts.TraceEvent(TraceEventType.Critical, 0, "critical message");

CorrelationManager

We can use the CorrelationManager to group correlated traces. The switch level must include the LogicalOperationStack option.

Using source code configuration:

tr.TraceOutputOptions = TraceOptions.DateTime | TraceOptions.Timestamp | TraceOptions.LogicalOperationStack;

Or using the Application configuration file:

<add name="textwriterListener"
  type="System.Diagnostics.TextWriterTraceListener"
  initializeData="c:\outfile.txt"
  traceOutputOptions="ProcessId, DateTime, LogicalOperationStack" />

And the code must looks like:

// Start the first logical operation
Trace.CorrelationManager.StartLogicalOperation("first logical operation");
 
ts.TraceEvent(TraceEventType.Warning, 0, "warning message");
ts.TraceEvent(TraceEventType.Error, 0, "error message");
 
// Start a nested logical operation
Trace.CorrelationManager.StartLogicalOperation("second logical");
 
ts.TraceEvent(TraceEventType.Information, 0, "information message");
 
// Stop the second logical operation
Trace.CorrelationManager.StopLogicalOperation();
 
ts.TraceEvent(TraceEventType.Critical, 0, "critical message");
 
// Stop the first logical operation
Trace.CorrelationManager.StopLogicalOperation();

Another useful technique is filter some kind of events and redirect them to one specific listener, for example, critical errors must be logged to a file and warning events to the event log only.

tr.Filter = new EventTypeFilter(SourceLevels.Error);

<add name="textwriterListener"
  type="System.Diagnostics.TextWriterTraceListener"
  initializeData="c:\outfile.txt"
  traceOutputOptions="ProcessId, DateTime, LogicalOperationStack">
  <filter type="System.Diagnostics.EventTypeFilter"
    initializeData="Error"/>
</add>

NOTE: you can have more than one trace source, for example, one for normal data and another for critical and private data.

By using the shareListeners setting you can add global listeners:

<sharedListeners>
  <add name="myListener" 
    type="System.Diagnostics.TextWriterTraceListener" 
    initializeData="myListener.log">
    <filter type="System.Diagnostics.EventTypeFilter" 
      initializeData="Error"/>
</add>

The Debugger and Debug classes

2008-01-19T19:43:00.000-08:00

Using the debugger is very easy:

int x = 0;
 
// Attach debugger at runtime
if (!Debugger.IsAttached)
    Debugger.Launch();
 
// Logging something
Debugger.Log(0, "category 1", "Debugging starts now");
 
// Conditional breakpoint
if (x == 0)
    Debugger.Break();

By using the Debug class we can perform several debugging tasks like make assertions, write more detailed information about our objects, add a custom trace listener, etc.

// Adding a custom listener
Debug.Listeners.Add(new TextWriterTraceListener("C:\\debug.txt"));
 
// Assertions
Debug.Assert(x == 0, "x != 0\n");
 
// Printing values
x = 10;
Debug.Print("x value={0}", x);
 
// Writing something to output
Debug.WriteLine("testing message");
Debug.WriteLineIf(x == 0, "x is equal to 0");
 
// Finally, we need to flush data out
Debug.Flush();

Debug attributes can be used to improve our code readability on debug mode. In the following example I use some attributes to hide elements, show collection elements at root, avoid entering to debug internal methods and display a custom formatted attributes when we are debugging some Person object:

[DebuggerDisplay("Person Name={Name} LastName={LastName} Friends={Friends.Count}")]
class Person
{
    public string Name { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
 
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private int _realAge;
 
    [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
    private List<string> Friends = new List<string>() {"friend 1", "friend 2", "friend 3"};
 
    public Person()
    {
    }
 
    // Debugger won't stop in this method
    [DebuggerStepThrough()]
    public string BuildFullName()
    {
        return Name + " " + LastName;
    }
}

The Installer class

2008-01-19T15:56:00.000-08:00

Creating our custom installer class:

[RunInstaller(true)]
public class myCustomInstaller : Installer
{
    public myCustomInstaller()
    {
        // Handling some events
        this.BeforeInstall += new InstallEventHandler(myCustomInstaller_BeforeInstall);
        this.Committed += new InstallEventHandler(myCustomInstaller_Committed);
        this.Committing += new InstallEventHandler(myCustomInstaller_Committing);
    }
 
    void myCustomInstaller_BeforeInstall(object sender, InstallEventArgs e)
    {
        Console.WriteLine("Before installing Event occured.");
    }
 
    private void MyInstaller_Committing(object sender, InstallEventArgs e)
    {
        Console.WriteLine("Committing Event occured.");
    }
 
    private void MyInstaller_Committed(object sender, InstallEventArgs e)
    {
        Console.WriteLine("Committed Event occured.");
    }
 
    // Overriding some methods
    public override void Install(IDictionary stateSaver)
    {
        base.Install(stateSaver);
    }
 
    public override void Commit(IDictionary savedState)
    {
        base.Commit(savedState);
    }
 
    public override void Rollback(IDictionary savedState)
    {
        base.Rollback(savedState);
    }
 
}

This class can be used by the InstallUtil.exe tool or one Setup Project for our application.

Other installation classes:

AssemblyInstaller
ComponentInstaller
    EventLogInstaller
    PerformanceCounterInstaller
    MessageQueueInstaller
    ServiceInstaller
    ServiceProcessInstaller
ManagedInstaller
InstallerCollection
TransactedInstaller

More source code at Self Installing service.

EventLog management

2008-01-19T14:16:00.000-08:00

Writing to the Event Log:

// Creating the event source
EventSourceCreationData escd = new EventSourceCreationData("mySourceName", "myLogName");
EventLog.CreateEventSource(escd);
 
..
 
// We can also create the event source directly
EventLog.CreateEventSource("mySourceName", "myLogName");
 
// Opening the event log for writing to it
EventLog el = new EventLog("myLogName");
el.Source = "mySourceName";
 
// Writing something
el.WriteEntry("testing message", EventLogEntryType.Information);
 
// Or, writing directly
EventLog.WriteEntry("mySourceName", "direct testing message", EventLogEntryType.Information);

NOTE: for writing to one system's log, we can use set the log's name as Application, System or Security. Deleting logs:

// Deleting the source
if (EventLog.SourceExists("mySourceName"))
    EventLog.DeleteEventSource("mySourceName");
 
// Deleting the log
if (EventLog.Exists("myLogName"))
    EventLog.Delete("myLogName");

Reading logs:

// Getting all available logs
EventLog[] els = EventLog.GetEventLogs();
foreach (EventLog log in els)
    MessageBox.Show("Log: " + log.Log + " - Display Name: " + log.LogDisplayName);
 
// Reading all entries from one log
EventLog el = new EventLog("Application");
 
EventLogEntryCollection elec = el.Entries;
foreach (EventLogEntry ele in elec)
    MessageBox.Show(ele.Message);

Other classes:

EventLogInstaller
EventLogPermission
EventLogPermissionAttribute
EventLogTraceListener
EventLogEntry

More information MSDN

Error installing Visual Studio Express 2008 (C#)

2008-01-09T14:18:00.000-08:00

I had errors installing VS 2008 Express (C#), when I reviewed log files, I found the error description: "Error: Installation failed for component Microsoft .NET Framework 2.0a. MSI returned error code 1603"

Solution:

I tried to uninstall the .NET Framework 2.0 Service Pack 1, but none results. So, I used the "Windows Install Clean Up" utility to remove the .NET Framework 2.0 Service Pack 1. The installer ran well after that.

Conversion between ANSI and Unicode

2008-01-08T12:19:00.000-08:00

We can read ANSI files using the system's current ANSI code page:

StreamReader sr = new StreamReader("C:\\filename.txt", Encoding.Default);
string str = sr.ReadToEnd();
sr.Close();

We can select one custom code page by using the GetEncoding method:

StreamReader sr = new StreamReader("C:\\filename.txt", Encoding.GetEncoding(1252));
string str = sr.ReadToEnd();
sr.Close();

In the similar way we can convert from Unicode to ANSI using Default encoding or a custom code page:

StreamWriter sw = new StreamWriter("C:\\filename.txt", false, Encoding.Default);
sw.Write(str);
sw.Close();

StreamWriter sw = new StreamWriter("C:\\filename.txt", false, Encoding.GetEncoding(1252));
sw.Write(str);
sw.Close();

Advanced .NET Configuration techniques

2008-01-07T15:12:00.000-08:00

We can create custom configuration sections:

public class myConfigurationSection : ConfigurationSection
{
    public myConfigurationSection()
    {
    }
 
    [ConfigurationProperty("validateActions", IsRequired = false)]
    public bool ValidateActions
    {
        get { return (bool)this["validateActions"]; }
        set { this["validateActions"] = value; }
    }
     
    [ConfigurationProperty("users", IsRequired=false, IsDefaultCollection=true)]
    public myUsersCollection Users
    {
        get { return (myUsersCollection) this["users"]; }
    }
}

Using our configuration section:

// Open the configuration
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
        
// Reading our configuration section
myConfigurationSection mcs = config.Sections["myConfiguration"] as myConfigurationSection;
if (mcs == null)
{
    // Create the configuration section if it doesn't exist
    mcs = new myConfigurationSection();
    config.Sections.Add("myConfiguration", mcs);
}
 
// Add some users
if (mcs.Users["john"] == null)
    mcs.Users.Add(new myUserElement("john", "pass"));
if (mcs.Users["mary"] == null)
    mcs.Users.Add(new myUserElement("mary", "pass"));
 
// Save the configuration
config.Save(ConfigurationSaveMode.Modified);

The example above will produce the following result:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <section name="myConfiguration" type="WindowsFormsApplication1.myConfigurationSection, WindowsFormsApplication3, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
 
...
 
  </configSections>
  <myConfiguration>
    <users>
      <add name="john" pwd="pass" />
      <add name="mary" pwd="pass" />
    </users>
  </myConfiguration>
 
...

Some points of interest:

- We can use the configuration property attribute to set some constraints and preferences with values, like IsRequired by example: [ConfigurationProperty("validateActions", IsRequired = false)]

- If we don't want to use the named collection property ("users" in this example), we need to change the Users property to include the IsDefaultCollection property and set the property's name to an empty string:

[ConfigurationProperty("", IsRequired=false, IsDefaultCollection=true)]
public myUsersCollection Users
{
    get { return (myUsersCollection) this[""]; }
}

This will produce the following result:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <section name="myConfiguration" type="WindowsFormsApplication1.myConfigurationSection, WindowsFormsApplication3, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
 
...
 
  </configSections>
  <myConfiguration>
    <add name="john" pwd="pass" />
    <add name="mary" pwd="pass" />
  </myConfiguration>
 
...

Here is myUserElement declaration:

public class myUserElement: ConfigurationElement
{
    public myUserElement()
    {
    }
 
    public myUserElement(string name, string pwd)
    {
        Name = name;
        Pwd = pwd;
    }
 
    [ConfigurationProperty("name", IsRequired = true)]
    public string Name
    {
        get { return (string)this["name"]; }
        set { this["name"] = value; }
    }
 
    [ConfigurationProperty("pwd", IsRequired = true)]
    public string Pwd
    {
        get { return (string)this["pwd"]; }
        set { this["pwd"] = value; }
    }
 
    [ConfigurationProperty("lastVisit", IsRequired = false)]
    public string LastVisit
    {
        get { return (string)this["lastVisit"]; }
        set { this["lastVisit"] = value; }
    }
 
    [ConfigurationProperty("permissions", IsRequired = false)]
    public myPermissionsCollection Permissions
    {
        get { return (myPermissionsCollection)this["permissions"]; }
    }
}

Configuration Element collection

I need to create a class from ConfigurationElementCollection and override the CreateNewElement and the GetElementKey methods. Also, I have to implement some helper methods like Add, Remove, the indexer [], etc.

[ConfigurationCollection(typeof(myUserElement), 
    CollectionType = ConfigurationElementCollectionType.AddRemoveClearMap)]
public class myUsersCollection: ConfigurationElementCollection
{
    protected override ConfigurationElement CreateNewElement()
    {
        return new myUserElement();
    }
 
    protected override object GetElementKey(ConfigurationElement element)
    {
        myUserElement melement = element as myUserElement;
        return melement.Name;
    }
 
    public myUserElement this[int index]
    {
        get
        {
            return (myUserElement)BaseGet(index);
        }
        set
        {
            // If it exists, remove first, then add
            if (BaseGet(index) != null)
                BaseRemoveAt(index);
 
            BaseAdd(index, value);
        }
    }
 
    new public myUserElement this[string Name]
    {
        get
        {
            return (myUserElement)BaseGet(Name);
        }
        set
        {
            // If it exists, remove first, then add
            if (BaseGet(Name) != null)
                BaseRemove(Name);
 
            BaseAdd(value);
        }
    }
 
    public void Add(myUserElement element)
    {
        BaseAdd(element);
    }
 
    public void Add(string name, string pwd)
    {
        myUserElement element = new myUserElement(name, pwd);
 
        BaseAdd(element);
    }
 
    public void Remove(myUserElement element)
    {
        Remove(element.Name);
    }
 
    public void Remove(string name)
    {
        BaseRemove(name);
    }
 
    public void RemoveAt(int index)
    {
        BaseRemoveAt(index);
    }
 
    public int IndexOf(myUserElement element)
    {
        return BaseIndexOf(element);
    }
 
    public void Clear()
    {
        BaseClear();
    }
}

The CollectionType property indicates how we want to map this collection, by default the AddRemoveClearMap is used. It says that the <add.../> element is expected, and also, the <clear> element can be used to avoid inherite configuration values from the configuration file parent. We can change the element by a custom one simply adding the AddItemName="newAddName" attribute to the collection declaration.

[ConfigurationCollection(typeof(myUserElement),
    AddItemName="myAdd", 
    CollectionType = ConfigurationElementCollectionType.AddRemoveClearMap)]
public class myUsersCollection: ConfigurationElementCollection
{
...
}

Here is our Permission element and the collection declaration:

public class myPermissionElement: ConfigurationElement
{
    public myPermissionElement()
    {
    }
 
    public myPermissionElement(string action, string acl)
    {
        Action = action;
        Acl = acl;
    }
 
    [ConfigurationProperty("action", IsKey=true, IsRequired=true)]
    public string Action
    {
        get { return (string)this["action"]; }
        set { this["action"] = value; }
    }
 
    [ConfigurationProperty("acl", IsRequired=true)]
    public string Acl
    {
        get { return (string)this["acl"]; }
        set { this["acl"] = value; }
    }
}
 
[ConfigurationCollection(typeof(myPermissionElement), 
    CollectionType = ConfigurationElementCollectionType.AddRemoveClearMap)]
public class myPermissionsCollection: ConfigurationElementCollection
{
    protected override ConfigurationElement CreateNewElement()
    {
        return new myPermissionElement();
    }
 
    protected override object GetElementKey(ConfigurationElement element)
    {
        myPermissionElement melement = element as myPermissionElement;
        return melement.Action;
    }
 
    public myPermissionElement this[int index]
    {
        get
        {
            return (myPermissionElement)BaseGet(index);
        }
        set
        {
            // If it exists, remove first, then add
            if (BaseGet(index) != null)
                BaseRemoveAt(index);
 
            BaseAdd(index, value);
        }
    }
 
    new public myPermissionElement this[string Name]
    {
        get { return (myPermissionElement)BaseGet(Name); }
        set
        {
            // If it exists, remove first, then add
            if (BaseGet(Name) != null)
                BaseRemove(Name);
 
            BaseAdd(value);
        }
    }
 
    public void Add(myPermissionElement element)
    {
        BaseAdd(element);
    }
 
    public void Add(string action, string acl)
    {
        myPermissionElement element = new myPermissionElement(action, acl);
 
        BaseAdd(element);
    }
 
    public void Add(myUserElement element)
    {
        BaseAdd(element);
    }
 
    public void Remove(string name)
    {
        BaseRemove(name);
    }
 
    public void RemoveAt(int index)
    {
        BaseRemoveAt(index);
    }
 
    public int IndexOf(myUserElement element)
    {
        return BaseIndexOf(element);
    }
 
    public void Clear()
    {
        BaseClear();
    }
}

Configuration validator

We can use one of the standards validator classes like IntegerValidator, TimeSpanValidator, StringValidator, RegexStringValidator, etc.

If we want to create a custom validator for our configuration elements, we need to implement a class from the ConfigurationValidatorBase or use the CallbackValidator attribute with our callback delegate method [CallbackValidator("myDelegateMethod")]:

public class myCustomValidator: ConfigurationValidatorBase
{
    public override void Validate(object value)
    {
        switch ((string)value)
        {
            case "add":
                break;
            case "remove":
                break;
            case "edit":
                break;
            case "":
                break;
            default:
                throw new ArgumentOutOfRangeException("Invalid Action name: " + (string)value);
        }
    }
 
    public override bool CanValidate(Type type)
    {
        if (type == typeof(string))
            return true;
 
        return false;
    }
}

Using our validator:

[ConfigurationProperty("action", IsKey=true, IsRequired=true),
ConfigurationValidator(typeof(myCustomValidator))]
public string Action
{
    get { return (string)this["action"]; }
    set { this["action"] = value; }
}

The ConfigurationValidatorAttribute can be implemented for exposing the validator attribute with custom parameters, such as, initial values, ranges or constraints.

Configuration Section Groups

They can be implemented for managing custom section groups, example:

public class myConfigurationGroup: ConfigurationSectionGroup
{
    [ConfigurationProperty("myConfigSec")]
    public myConfigurationSection myConfigSec
    {
        get { return (myConfigurationSection)base.Sections["myConfigSec"]; }
    }
 
    [ConfigurationProperty("anotherSec")]
    public anotherCustomConfigSection anotherSec
    {
        get { return (anotherCustomConfigSection)base.Sections["anotherSec"]; }
    }
}
 
public class anotherCustomConfigSection: ConfigurationSection
{
}

Using configuration groups:

// Open the configuration
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
 
//-----------------------------------
// Reading our configuration group section
myConfigurationGroup cg = config.SectionGroups["myConfigGroup"] as myConfigurationGroup;
if (cg == null)
{
    // Create the configuration group section if it doesn't exist
    cg = new myConfigurationGroup();
    config.SectionGroups.Add("myConfigGroup", cg);
}
//-----------------------------------
 
//-----------------------------------
// Reading our configuration section inside the group section
myConfigurationSection mcs = cg.myConfigSec;
if (mcs == null)
{
    // Create the configuration section if it doesn't exist
    mcs = new myConfigurationSection();
    cg.Sections.Add("myconfig", mcs);
}
//-----------------------------------
 
//-----------------------------------
// Adding some users
myUserElement ue = mcs.Users["john"];
if (ue == null)
{
    ue = new myUserElement("john", "pass");
    mcs.Users.Add(ue);
}
 
ue.Permissions.Add("add", "grant");
ue.Permissions.Add("edit", "grant");
ue.Permissions.Add("remove", "denied");
 
// Adding another user
ue = mcs.Users["mary"];
if (ue == null)
{
    ue = new myUserElement("mary", "pass");
    mcs.Users.Add(ue);
}
 
ue.Permissions.Add("add", "grant");
ue.Permissions.Add("edit", "grant");
ue.Permissions.Add("remove", "grant");
//-----------------------------------
 
// Saving the configuration
config.Save(ConfigurationSaveMode.Modified);

This will produce the following result:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
 
...
 
    <sectionGroup name="myConfigGroup" type="WindowsFormsApplication1.myConfigurationGroup, WindowsFormsApplication3, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" >
      <section name="myconfig" type="WindowsFormsApplication1.myConfigurationSection, WindowsFormsApplication3, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
    </sectionGroup>
  </configSections>
 
...
 
  <myConfigGroup>
    <myconfig>
      <add name="john" pwd="pass">
        <permissions>
          <add action="add" acl="grant" />
          <add action="edit" acl="grant" />
          <add action="remove" acl="denied" />
        </permissions>
      </add>
      <add name="mary" pwd="pass">
        <permissions>
          <add action="add" acl="grant" />
          <add action="edit" acl="grant" />
          <add action="remove" acl="grant" />
        </permissions>
      </add>
    </myconfig>
  </myConfigGroup>
</configuration>

The .NET Configuration (app.config)

2008-01-07T08:16:00.000-08:00

The easiest way to read and write to the app.config file is using the AppSettings:

// Open the app.config file (from this executable)
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
 
// Reading our setting (both are the same but the first is preferred)
MessageBox.Show(ConfigurationManager.AppSettings["mySetting1"]);
MessageBox.Show(config.AppSettings.Settings["mySetting1"].Value);
 
// Writing some setting
config.AppSettings.Settings.Add("mySetting2", "myValue2");
 
// Saving the file
config.Save(ConfigurationSaveMode.Modified);
 
// Reloading the modified section
ConfigurationManager.RefreshSection("appSettings");
 
// Reading again
MessageBox.Show(ConfigurationManager.AppSettings["mySetting2"]);
MessageBox.Show(config.AppSettings.Settings["mySetting2"].Value);

Reading and writing connection strings:

//---------------------------------------
// Reading all connection strings
ConnectionStringSettingsCollection csCol = ConfigurationManager.ConnectionStrings;
 
if (csCol != null)
{
    StringBuilder sb = new StringBuilder();
    foreach (ConnectionStringSettings cs in csCol)
    {
        sb.Append("Full Connection String: " + cs.ConnectionString + "\r\n");
        sb.Append("Provider Name: " + cs.ProviderName + "\r\n");
        sb.Append("Section Name: " + cs.Name + "\r\n");
    }
 
    MessageBox.Show(sb.ToString());
}
//---------------------------------------
 
//---------------------------------------
// Reading only one connection string by name
ConnectionStringSettings csOracle = ConfigurationManager.ConnectionStrings["OracleConnectionString"];
 
if (csOracle != null)
    MessageBox.Show(csOracle.ConnectionString);
//---------------------------------------
 
//---------------------------------------
// Reading the default database connection with
// the Enterprise Library Data Access Application Block
DatabaseSettings ds = ConfigurationManager.GetSection("dataConfiguration") as DatabaseSettings;
 
if (ds != null)
    MessageBox.Show(ds.DefaultDatabase);
//---------------------------------------
 
//---------------------------------------
// Creating a new connection string
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
 
ConnectionStringsSection csSection = config.ConnectionStrings;
 
csSection.ConnectionStrings.Add(new ConnectionStringSettings("myNewConnection", "Data Source=localhost;Initial Catalog=AdventureWorks; Integrated Security=true", "System.Data.SqlClient"));
 
config.Save(ConfigurationSaveMode.Modified);
//---------------------------------------

Protecting sensitive data by encrypting configuration sections

We can use the "RsaProtectedConfigurationProvider" or the "DataProtectionConfigurationProvider/DpapiProtectedConfigurationProvider" to protect or unprotect our configuration sections:

// Open the configuration
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
 
// Get the connection strings section
ConnectionStringsSection csSection = config.ConnectionStrings;
 
// Protect this section by using the DpapiProtectedConfigurationProvider a.k.a. DataProtectionConfigurationProvider
if (!csSection.SectionInformation.IsProtected)
    csSection.SectionInformation.ProtectSection("DataProtectionConfigurationProvider");
 
// Save the configuration section within protected data
csSection.SectionInformation.ForceSave = true;
config.Save();

For unprotect sections, we use the UnprotectSection() method.

Self installing service

2008-01-06T08:05:00.001-08:00

To make a self installing service, we need to change the Main function into the Program.cs file to look like this:

/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main(string[] args)
{
    // Reading command line options
    string opt = "";
    if (args.Length > 0)
        opt = args[0];
 
    if (opt.ToLower() == "/install")
    {
        TransactedInstaller ti = new TransactedInstaller();
        ProjectInstaller pi = new ProjectInstaller();
        ti.Installers.Add(pi);
 
        string path = string.Format("/assemblypath={0}",
            System.Reflection.Assembly.GetExecutingAssembly().Location);
 
        string[] cmdline = { path };
        InstallContext ctx = new InstallContext("", cmdline);
        ti.Context = ctx;
        ti.Install(new Hashtable());
 
        MessageBox.Show("Service was successfully installed", "My Service", 
            MessageBoxButtons.OK, MessageBoxIcon.Information);
    }
    else if (opt.ToLower() == "/uninstall")
    {
        TransactedInstaller ti = new TransactedInstaller();
        ProjectInstaller pi = new ProjectInstaller();
        ti.Installers.Add(pi);
 
        string path = string.Format("/assemblypath={0}",
            System.Reflection.Assembly.GetExecutingAssembly().Location);
 
        string[] cmdline = { path };
        InstallContext ctx = new InstallContext("", cmdline);
        ti.Context = ctx;
        ti.Uninstall(null);
 
        MessageBox.Show("Service was successfully uninstalled", "My Service",
            MessageBoxButtons.OK, MessageBoxIcon.Information);
    }
    else if (opt != "")
    {
        // Attach to debugger at runtime
        if (!System.Diagnostics.Debugger.IsAttached)
            System.Diagnostics.Debugger.Launch();
 
        // ignore it
        MessageBox.Show("Invalid option !!!", "My Service",
            MessageBoxButtons.OK, MessageBoxIcon.Warning);
    }
    else
    {
        ServiceBase[] ServicesToRun;
 
        // More than one user Service may run within the same process. To add
        // another service to this process, change the following line to
        // create a second service object. For example,
        //
        //   ServicesToRun = new ServiceBase[] {new Service1(), new MySecondUserService()};
        //
        ServicesToRun = new ServiceBase[] { new Service1() };
 
        ServiceBase.Run(ServicesToRun);
    }            
}

Remember to add references and using statements to:

using System.Configuration.Install;
using System.Collections;
using System.Windows.Forms;

More information Self Installing Service [Craig Andera]

Creating Windows Services

2008-01-06T07:48:00.000-08:00

Today is very easy to create Windows Services with Visual Studio 2005/2008. Simply, create a new Windows Service project, implement OnStart/OnStop methods and create the service's installer... voila!... you got your Windows Service.

public partial class Service1 : ServiceBase
{
    // A simple timer
    Timer myTimer;
 
    public Service1()
    {
        InitializeComponent();
 
        // Initialize my timer
        myTimer = new Timer(10000);
        myTimer.Enabled = false;
        myTimer.Elapsed += new ElapsedEventHandler(myTimer_Elapsed);
    }
 
    void myTimer_Elapsed(object sender, ElapsedEventArgs e)
    {
        // Write to the Event Log is very easy, like this
        EventLog.WriteEntry(this.ServiceName, string.Format("Timer elapsed at {0}", DateTime.Now.ToShortTimeString()), EventLogEntryType.Information);
    }
 
    protected override void OnStart(string[] args)
    {
        // OnStart: with start the timer to perform 
        // some timed task.  Also, we can start threads,
        // subscribe to object's events, etc.
        myTimer.Enabled = true;
    }
 
    protected override void OnStop()
    {
        // OnStop: we stop the timer or the thread,
        // and we can also release some resources
        myTimer.Enabled = false;
    }
}

In the designer, we can specify properties that tell to the service manager if we want to handle other events and actions like Power event, Session Changed event, Pause and Resume, etc.

To add an installer to our windows service, simply make right click over the Service Designer and choose the option from the popup menu: "Add Installer". This, will create a class like this:

[RunInstaller(true)]
public partial class ProjectInstaller : Installer
{
    public ProjectInstaller()
    {
        InitializeComponent();
    }
}

We can specify in the installer's properties, the account for run our service and the display name, etc.

See my other post for Self Installing service.

Attach the Visual Studio Debugger at runtime

2008-01-06T07:41:00.000-08:00

I have been working in an HTML page that needs to launch an external application (the executable file) and pass it arguments in the command line. Also, I have been created a Windows Service that I need to debug in some line of source code.

How to debug this application or the Windows Service ?

Solution: Call the Debugger.Launch() method before the first line you wish to start debugging the project, like this:

...
#if DEBUG 
 
if (!System.Diagnostics.Debugger.IsAttached)
    System.Diagnostics.Debugger.Launch(); 
 
#endif 
...

This method will launch the debugger selection dialog, so I can choose the Visual Studio instance on which I have the project opened.

Creating an object instance from an external assembly

2008-01-05T16:21:00.000-08:00

For the following examples, I've created a class library for declaring the interface that I had implemented into an application named WindowsFormsApplication1. Interface declaration:

public interface myInterface
{
    void callMe(string message);
}

The Remote Object was declared as:

public class RemoteObject : System.MarshalByRefObject, myInterface
{
    public RemoteObject()
    {
        Console.WriteLine("Hello, World! (RemoteObject Constructor)");
    }
 
    #region myInterface Members
 
    public void callMe(string message)
    {
        Console.WriteLine("callMe was called !!!");
        Console.WriteLine(message);
    }
 
    #endregion
}

Method 1: using reflection to load and execute code into the same application domain.

// Loading the assembly
Assembly asm = Assembly.LoadFrom(@"C:\TempDev\WindowsFormsApplication1.exe");
 
// Creating the instance we want to access
myInterface obj = asm.CreateInstance("WindowsFormsApplication1.RemoteObject") as myInterface;
 
// Executing some methods using the Interface
obj.callMe("testing message!");

Method 2: using application domains to load an execute code into a different domain:

// Creating the domain
AppDomain domain = AppDomain.CreateDomain("myDomain");
 
// Creating the instance we want to access
myInterface obj = domain.CreateInstanceFromAndUnwrap(@"C:\TempDev\WindowsFormsApplication1.exe", "WindowsFormsApplication1.RemoteObject") as myInterface;
 
// Executing some methods using the Interface
obj.callMe("testing message!");
 
// Unloading the domain
AppDomain.Unload(domain);

Application Domains

2008-01-05T14:24:00.000-08:00

"Application domains provide a flexible and secure method of isolating running applications." -- MSDN They provide reliability, efficiency and security.

// Creating the domain
AppDomain domain = AppDomain.CreateDomain("myDomain");
 
// Access some domain's properties
Console.Write("{0} {1}", domain.BaseDirectory, domain.FriendlyName);
 
// Executing another assembly into the new application domain
domain.ExecuteAssembly(@"C:\TempDev\WindowsFormsApplication1.exe");
 
// Unloading the domain
AppDomain.Unload(domain);

Ensuring security with application domains:

// We can use the Internet Zone, My Computer Zone, Untrusted Zone, etc.
object[] hostEvidence = { new Zone(System.Security.SecurityZone.Internet) };
Evidence myEvidence = new Evidence(hostEvidence, null);
 
// Executing the assembly with our evidence
domain.ExecuteAssembly(@"C:\TempDev\WindowsFormsApplication1.exe", myEvidence);

IAsyncResult interface

2007-12-30T20:05:00.000-08:00

There are a lot of asynchronous operations (APM: Asynchronous Programming Model) that we can perform using the .NET Framework. Normally, they start by BeginXXX and EndXXX. Here a little sample using an asynchronous operation to read a file stream.

In this code, we launch the "asynchronous" operation and wait until it finished polling the .IsCompleted property of IAsyncResult.

byte[] b = new byte[1000];
 
// Open the stream
FileStream fs = new FileStream("C:\\ike.zip", FileMode.Open, FileAccess.Read);
 
// Start the asynchronous operation
IAsyncResult ar = fs.BeginRead(b, 0, b.Length, null, null);
 
// Wait until task is completed
while (!ar.IsCompleted)
{
    Thread.Sleep(1000);
    MessageBox.Show("not yet");
}
 
MessageBox.Show("Completed" + fs.EndRead(ar).ToString());
 
fs.Close();

But, we really want to perform some asynchronous operation, so, we need to declare the asynchronous callback method like this:

private void MyAsyncCallback(IAsyncResult ar)
{
    FileStream fs = ar.AsyncState as FileStream;
 
    try
    {
        MessageBox.Show("Completed" + fs.EndRead(ar).ToString());
    }
    catch (Exception ex)
    {
        MessageBox.Show("Error: "  + ex.Message);
    }
    finally
    {
        fs.Close();
    }
}

And call the BeginRead as:

byte[] b = new byte[1000];
 
FileStream fs = new FileStream("C:\\ike.zip", FileMode.Open, FileAccess.Read);
 
IAsyncResult ar = fs.BeginRead(b, 0, b.Length, new AsyncCallback(MyAsyncCallback), fs);

Points of interest:

- We use the AsyncState parameter to pass some important object to the callback method.

- Also, if some exception is thrown in the asynchronous operation, we'll be notified only when we call the EndRead method, so, we catch the exception in the callback.

Synchronizing UI Elements:

If we try to access UI elements in another thread than they were created, an exception will be raised, to avoid that, we can ask for the property InvokeRequired in some UI elements such as forms, text boxes, list views, etc. When this property is true, we need to call the appropriated Invoke method as follows:

// Delegate declaration
public delegate void ShowResult(string message);
 
// Callback method
private void MyAsyncCallback(IAsyncResult ar)
{
    FileStream fs = ar.AsyncState as FileStream;
 
    try
    {
        ShowResultInt("Completed" + fs.EndRead(ar).ToString());
    }
    catch (Exception ex)
    {
        MessageBox.Show("Error: " + ex.Message);
    }
    finally
    {
        fs.Close();
    }
}
 
private void ShowResultInt(string message)
{
    if (txtResult.InvokeRequired)
        // Invoke is required, we are in another thread than UI elements
        txtResult.Invoke(new ShowResult(ShowResultInt), message);
    else
        // Not invoke required, then we can access UI elements directly
        txtResult.Text = message;
}

Using the ThreadPool.RegisterWaitForSingleObject

2007-12-30T15:16:00.000-08:00

For creating threads in the ThreadPool, we use the QueueUserWorkItem:

ThreadPool.QueueUserWorkItem(new WaitCallback(FunctionCall), PersonalizeDataForTherad);

Or, for creating a timed thread in the ThreadPool, we use RegisterWaitForSingleObject:

ThreadPool.RegisterWaitForSingleObject(AutoResetEventObject, new WaitOrTimerCallback(FunctionCall), PersonalizeData, TimeOut, false);

This method is useful for performing timed or event signed tasks. The RegisteredWaitHandle can be used to unregister the callback.

// Declaring our handle.  It could be declared alone or as part of 
// the state class we can pass to the RegisterWaitForSingleObject method.
RegisteredWaitHandle rwh;
AutoResetEvent arevent = new AutoResetEvent(false);
 
...
 
// Our callback procedure
private void wit(object state, bool btimeOut)
{
    if (btimeOut)
    {
        // Perform some timed task
        MessageBox.Show("1: " + DateTime.Now.ToShortTimeString());
    }
    else
    {
        // Perform some signed task or unregister the WaitHandle
        rwh.Unregister(null);
    }
}
 
...
 
// Now, we can create the WaitHandle
// We can use the state object to pass more information to the callback
rwh = ThreadPool.RegisterWaitForSingleObject(arevent, new WaitOrTimerCallback(wit), null, 2000, false);
 
...
 
// After we were used the callback, we can sign the finished event
arevent.Set();

An util use of this pattern, can be achieved by cancelling asynchronous delegates when time out.

// Declaring our handle.
RegisteredWaitHandle rwh;
 
...
 
// Creating some asynchronous operation
IAsyncResult result = someobject.BeginGetResponse(new AsyncCallback(someAsyncMethod), state);
 
...
 
// Creating the waiting callback
rwh = ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, new WaitOrTimerCallback(ScanTimeoutCallback), result, 30000, true);
 
...
 
// Timeout callback
private void ScanTimeoutCallback (object state, bool timedOut) 
{ 
    if (timedOut) 
    {
        // Cancel the asynchronous operation by timeout
        RequestState reqState = (RequestState)result.AsyncState;
        if (reqState != null) 
            reqState.request.Abort();
    }
    else
    {
        // Unregister the WaitHandle
        rwh.Unregister(null);
    }
}

References:

How do I use ThreadPool in C# and .NET? by Ashish Singhal Asynchronous HttpWebRequest by stevencohn
RegisterWaitForSingleObject in ThreadPool By Ashish Singhal
Multithreading Part 4: The ThreadPool, Timer Classes and Asynchronous Programming By Manisha Mehta

EventHandler delegate

2007-12-30T13:12:00.000-08:00

MSDN Says: "The advantage of using EventHandler<(Of <(TEventArgs>)>) is that you do not need to code your own custom delegate if your event generates event data. Additionally, the .NET Framework needs only one implementation to support EventHandler<(Of <(TEventArgs>)>) regardless of the event data type you substitute for the generic type parameter."

// Here, MyEventArgs class declaration
public class MyEventArgs : EventArgs
{
    private string msg;
 
    public MyEventArgs(string messageData)
    {
        msg = messageData;
    }
 
    public string Message
    { 
        get { return msg; } 
        set { msg = value; }
    }
}
 
...
 
// Declaring the event property
public event EventHandler<MyEventArgs> SampleEvent;
 
...
 
// Invoking the event
if (SampleEvent != null)
    SampleEvent(this, new MyEventArgs(val));
 
...
 
// Subscribing to the event 
MyClass.SampleEvent += new EventHandler<MyEventArgs>(SampleEventHandler);
 
...
 
// Where SampleEventHandler was implemented as
private void SampleEventHandler(object src, MyEventArgs mea)
{
    Console.WriteLine(mea.Message);
}