1. Go to Control Panel and open Windows Firewall.

2. Click on Advanced Settings in the left panel.

3. In the Advanced Settings panel, click on Inbound Rules in the left column.

4. In the Inbound Rules window, click on New Rule in the right column.

5. In the New Inbound Rule Wizard, select Port and click next.

6. In the next window, select the port type (TCP) and enter the port numbers separated by a coma and click Next.

7. In the next window, select Block the Connection and click next.

8. Select all the domains you want to apply this rule to and click next.

9. Enter the name and description of the rule and click Finish. You are done!

Share on Facebook

In some programs, you may need to represent a list of items that share some characteristics. You can declare as many variables as necessary to represent such items. Here is an example of 5 numbers declared in a program:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    int number1 = 266;
    int number1 = -4683;
    int number1 = -364;
    int number1 = 1450;
    int number1 = 8;

    Console::WriteLine();
    return 0;
}

If you want to use a group of objects that are of the same kind, C++ allows you to identify them as one variable. An array is a group of variables that shared the same characteristics.

Note:

Arrays in Managed C++ are a little different than those traditionally used in C++ because the Microsoft .NET Framework introduced a new way of declaring and using arrays, which also has to do with inherited classes. Because this can be a long and arduous subject, we will use arrays only as they are used and implemented in managed classes.

Array Declaration

An array is a group of values of the same kind or the same data type. Because the items are considered in a group, they are declared as one variable but the declaration must indicate that the variable represents various items. The items that are part of the group are also referred to as members of the array. To declare an array, you must give it a name.

In C++, the formula to declare an array is

DataType ArrayName[Dimension];

With this formula, an array would be declared as a value type. C++’ arrays can be declared either on the stack as in the above formula or on the heap. Managed C++ formally introduces the idea of declaring an array on the heap. Based on this, (most) arrays in Managed C++ are referred to as managed arrays. In this case, the formula to declare a managed array is:

DataType ArrayName[] = new DataType[Dimension];

Another equivalent formula is:

DataType ArrayName __gc[] = new DataType __gc[Dimension];

Therefore, the declaration of a managed array starts by specifying a data type, the DataType in our syntax. This indicates the kind of values shared by the members of the array. It also specify the amount of memory space that each member of the array will need to store its value. Like any other variable, an array must have a name, which is the ArrayName in our syntax. The name of the array must be followed by an opening and a closing square brackets "[]". To indicate that you are declaring a managed array, you must assign the same data type as a managed type, using the new keyword. Once again, the data type must be followed by square brackets. This time, inside of the square brackets, you must type the number of items that the array is made of; that is the Dimension in our syntax.

To create a managed array, the data type can be a normal C/C++ data type such as int, double, or .NET value type such as Int32, Double, etc. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double Number[] = new Double[5];

    Console::WriteLine(S"");
    return 0;
}

To re-enforce the idea of declaring a managed array, you can optionally type the __gc keyword to the left of the square brackets. You can type it either on only one side of the assignment operator or on both sides. Therefore, the following declarations are equivalents:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double Number1[]      = new Double[5];
    Double Number2 __gc[] = new Double[5];
    Double Number3[]      = new Double __gc[5];
    Double Number4 __gc[] = new Double __gc[5];

    Console::WriteLine();
    return 0;
}

When declaring a managed array, you must use the new operator to indicate to the compiler that the variable would be declared on the heap. Because the new operator is explicit enough, you can omit the __gc keyword. Also, you don’t have to perform the whole declaration at the same time but you must have requested that memory be allocated to the array before it can be used. Based on this, you can first declare the variable with the left part of the assignment operator. Then, when you are ready, you can allocate memory to the variable and specify the number of members of the array. When doing this, type the name of the variable without the square brackets and type the right side of our syntax. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[];
    // You can't yet use the array

    Console::WriteLine(S"The Wonderful World of Managed C++!");

    number = __gc new Double[5];
    // Now the array is ready

    Console::WriteLine();
    return 0;
}

We mentioned that, when declaring the array, you should specify the number of members of the array with the Dimension in our syntax. After declaring the array, if you want, you can reduce or increase the number of items by simply performing a new assignment to the variable and indicating the new desired Dimension. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[];
    // You can't yet use the array

    Console::WriteLine(S"The Wonderful World of Managed C++!");

    number = __gc new Double[5];
    // Now the array is ready

    // The new dimension of the array
    number = new Double[8];

    Console::WriteLine();
    return 0;
}

Initializing an Array

When declaring an array, before using it, we saw that you must specify the number of members of the array. This declaration allocates an amount of memory space to the variable. The first member of the array takes a portion of this space. The second member of the array occupies memory next to it:

Array Variable

Member1

Member2

Member3

Member4

Member5

Each member of the array can be accessed using its position. The position is also referred to as an index. The members of an array are arranged starting at index 0, followed by index 1, then index 2, etc. This system of counting is referred to as "zero-based" because the counting starts at 0. To locate a member, type the name of the variable followed by an opening and a closing square brackets. Inside the bracket, type the zero-based index of the desired member. After locating the desired member of the array, you can assign it a value, exactly as you would any regular variable. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[] = __gc new Double[5];

    number[0] = 643.18;
    number[1] = 9.64;
    number[2] = 48.05;
    number[3] = 14.26;
    number[4] = 62.55;

    Console::WriteLine(S"");
    return 0;
}

In the same way, you can retrieve the value of a member of an array based on its index. Such a value can be displayed to the user as follows:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[] = __gc new Double[5];

    number[0] = 643.18;
    number[1] = 9.64;
    number[2] = 48.05;
    number[3] = 14.26;
    number[4] = 62.55;

    Console::WriteLine(S"Value 1: {0}", __box(number[0]));
    Console::WriteLine(S"Value 2: {0}", __box(number[1]));
    Console::WriteLine(S"Value 3: {0}", __box(number[2]));
    Console::WriteLine(S"Value 4: {0}", __box(number[3]));
    Console::WriteLine(S"Value 5: {0}", __box(number[4]));

    number = new Double[8];

    Console::WriteLine(S"");
    return 0;
}

This would produce:

Value 1: 643.18
Value 2: 9.64
Value 3: 48.05
Value 4: 14.26
Value 5: 62.55

Press any key to continue

When it comes to initializing a managed array, you don’t have to access each member of the array and initialize them individually. That technique is used if you don’t yet have the values of the items at the time you are declaring the array. If you know the values of the members of the managed array at the time you are declaring its variable, you can declare and initialize the whole array at the same time. The formula you would use is:

DataType VariableName __gc[] = { Values Separated By Commas };

This formula is almost the same used in C/C++ with one difference. If you omit the __gc keyword, the array would be a regular one as used in C/C++. The alternative is to type the __gc keyword to the left of the square brackets. If you do this, two features would automatically be applied to your array. First, the array would be garbage collected, that is, cleaned up by the garbage collector; therefore becoming a managed array. Second, the array becomes automatically derived from the .NET’s Array class, which gives it access to the properties and methods of that class.

If you use the formula we used earlier with the number variable, the data type must be a .NET value type such as Int32, Double, Single, etc. If you use the above formula to declare and initialize your array, the data type can be a regular C/C++ type (such as int, long, or double) or a .NET value type (such as Int32 or Double). Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    double number __gc[] = { 79.31, 47.59, 749.75, 9.07, 9.44 };

    Console::WriteLine(S"Value 1:  {0}", __box(number[0]));
    Console::WriteLine(S"Value 2:  {0}", __box(number[1]));
    Console::WriteLine(S"Value 3:  {0}", __box(number[2]));
    Console::WriteLine(S"Value 4:  {0}", __box(number[3]));
    Console::WriteLine(S"Value 5:  {0}", __box(number[4]));

    Console::WriteLine(S"");
    return 0;
}

This would produce:

Value 1:  79.31
Value 2:  47.59
Value 3:  749.75
Value 4:  9.07
Value 5:  9.44

Press any key to continue

Multidimensional Arrays

Introduction

The arrays we have used so far are referred to as single or one-dimensional arrays because they use a single group of items that can classified in a single column. In some cases, you may want to divided the list in two or more sections. For example, here is a list of numbers divided in various columns:

Sunday

Monday

Tuesday

Wednesday

Thursday

Friday

Saturday

Week 1

1

2

3

4

5

6

7

Week 2

8

9

10

11

12

13

14

Week 3

15

16

17

18

19

20

21

Week 4

22

23

24

25

26

27

28

A multi-dimensional array is one that still includes items of the same type but the group is made of sub-divisions following an arrangement an arrangement of your choice.

Two-Dimensional Arrays

Imagine you create two lists of items declared in two variables as follows:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number1 __gc[] = new Double __gc[5];
    Double number2 __gc[] = new Double __gc[5];

    number1[0] = 643.18;
    number1[1] = 9.64;
    number1[2] = -48.05;
    number1[3] = 14.26;
    number1[4] = 62.55;

    number2[0] = 124.45;
    number2[1] = -62.84;
    number2[2] = 508.06;
    number2[3] = 92.68;
    number2[4] = -44.82;

    Console::WriteLine(S"Value 1:  {0}", __box(number1[0]));
    Console::WriteLine(S"Value 2:  {0}", __box(number1[1]));
    Console::WriteLine(S"Value 3:  {0}", __box(number1[2]));
    Console::WriteLine(S"Value 4:  {0}", __box(number1[3]));
    Console::WriteLine(S"Value 5:  {0}", __box(number1[4]));

    Console::WriteLine(S"Value 6:  {0}", __box(number2[0]));
    Console::WriteLine(S"Value 7:  {0}", __box(number2[1]));
    Console::WriteLine(S"Value 8:  {0}", __box(number2[2]));
    Console::WriteLine(S"Value 9:  {0}", __box(number2[3]));
    Console::WriteLine(S"Value 10: {0}", __box(number2[4]));

    Console::WriteLine(S"");
    return 0;
}

Instead of having two lists that represent the same types of values, you can declare a single array variable and divide its list of items in two. A two-dimensional array is an array made of two lists of items of the same data type. To declare a two-dimensional array, use the following formula:

DataType ArrayName[,] = new DataType[Dimension1,Dimension2];

Once again, you can optionally type the __gc keyword to the left of square brackets. The square brackets to the left of the assignment operator must have only a comma. Inside of the square brackets to the right side of the assignment, you must specify two numbers separated by a comma. The first number indicates the number of lists that the array contains. For a two-dimensional array, this number must be 2. The right value indicates the number of items that each list would contain. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number __gc[,] = new Double __gc[2,5];

    Console::WriteLine(S"");
    return 0;
}

In this case, the number variable is a two-dimensional array. In other words, the variable represents two lists. Each list contains 5 numbers.

To access a member of the array, type the name of the variable followed by the square brackets. Inside of the brackets, type the zero-based index of the desired list. The first list has an index of 0 while the second list has an index of 1. Then type the comma. On the right side of the comma, type the zero-based index of the member you want to access. Once you have accessed a member of the array, you can either assign it a value or retrieve the value it is currently holding. Here are examples:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number __gc[,] = new Double __gc[2,5];

    number[0,0] = 643.18;
    number[0,1] = 9.64;
    number[0,2] = -48.05;
    number[0,3] = 14.26;
    number[0,4] = 62.55;

    number[1,0] = 124.45;
    number[1,1] = -62.84;
    number[1,2] = 508.06;
    number[1,3] = 92.68;
    number[1,4] = -44.82;

    Console::WriteLine(S"Value 1:  {0}", __box(number[0,0]));
    Console::WriteLine(S"Value 2:  {0}", __box(number[0,1]));
    Console::WriteLine(S"Value 3:  {0}", __box(number[0,2]));
    Console::WriteLine(S"Value 4:  {0}", __box(number[0,3]));
    Console::WriteLine(S"Value 5:  {0}", __box(number[0,4]));

    Console::WriteLine(S"Value 6:  {0}", __box(number[1,0]));
    Console::WriteLine(S"Value 7:  {0}", __box(number[1,1]));
    Console::WriteLine(S"Value 8:  {0}", __box(number[1,2]));
    Console::WriteLine(S"Value 9:  {0}", __box(number[1,3]));
    Console::WriteLine(S"Value 10: {0}", __box(number[1,4]));

    Console::WriteLine(S"");
    return 0;
}

This would produce:

Value 1:  643.18
Value 2:  9.64
Value 3:  -48.05
Value 4:  14.26
Value 5:  62.55
Value 6:  124.45
Value 7:  -62.84
Value 8:  508.06
Value 9:  92.68
Value 10: -44.82

Press any key to continue

Multi-Dimensional Arrays

A multi-dimensional array is a list of a list of a list, etc. In other words, it is a list that contains other lists while these other lists may contain other lists. For example, a three-dimensional array is one that contains 3 lists; each of the 3 lists contains a certain number of lists; then each list inside contains a list of items.

To declare a multi-dimensional array, in the square brackets, type the number of comma minus the total number of lists. For example, the square brackets of a three-dimensional array would have 2 commas. The square brackets of a 5-dimensional array would have 4 commas. In the square brackets on the right side of the assignment operator must indicate the dimension of each level of list. Consider the following declaration:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double hoursWorked __gc[,,] = new Double[6,3,5];

    Console::WriteLine();
    return 0;
}

In this declaration, the variable represents 6 lists. Each of the 6 lists is made of its own 3 lists. Each of the 3 lists contains 5 items. Another ways to illustrate this is that the array represents 6 months work for a contractor. In each of the six months, the contractor worked for 3 weeks. In each of the 3 weeks, the contractor worked for 5 days.

You can access each member of a multi-dimensional array using its index. In the above example, the first month has an index of 0 while the third month has an index of 2. Everything else is as done for the other dimensional arrays.

The String as an Array and Characters

An Array of Characters

In C/C++, you can declare a string variable as an array of characters. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    char School[] = "American College of Computer & Information Sciences";

    Console::Write("School Name: ");
    Console::WriteLine(School);

    Console::WriteLine(S"");
    return 0;
}

This would produce:

School Name: American College of Computer & Information Sciences

Press any key to continue

In various previous examples, we used the .NET’s String class to declare and process string variables. In some cases, you will need access to one character inside of a string. In C/C++, if you declare a string using an array of characters as done above, to access an individual character, you type the name of the variable followed by square brackets. Inside of the square brackets, you can type the 0-based index of the character you want to access. Remember that the C/C++ char data type is an 8-bit value (to access a character, you should use its Char or __wchar_t type). Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    char School[] = "American College of Computer & Information Sciences";
    Char First    = School[0];
    Char Second   = School[9];
    Char Third    = School[20];
    Char Fourth   = School[31];
    Char Fifth    = School[43];

    Console::Write("School Name: ");
    Console::WriteLine(School);
    Console::WriteLine(S"Abbreviation: {0}{1}{2}{3}{4}",
	              __box(First), __box(Second), __box(Third),
	              __box(Fourth), __box(Fifth));

    Console::WriteLine(S"");
    return 0;
}

This would produce:

School Name: American College of Computer & Information Sciences
Abbreviation: ACCIS

Press any key to continue

The Characters of a String Class Value

Many libraries that feature a string class, such as the ATL’s basic_string class, the MFC’s CString class, or the VCL’s AnsiString class provide you the same mechanism (by overloading the [] operator). The Microsoft .NET Framework’s String class provides a different functionality. If you declare a String variable and want to access any of its characters, the String class provides a Chars property that uses square brackets to locate a character. This is done using the same approach as above except that you must call the Chars property. Here is an example of how this can be done:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    String* School = "American College of Computer & Information Sciences";
    Char First    = School->Chars[0];
    Char Second   = School->Chars[9];
    Char Third    = School->Chars[20];
    Char Fourth   = School->Chars[31];
    Char Fifth    = School->Chars[43];

    Console::Write("School Name: ");
    Console::WriteLine(School);
    Console::WriteLine(S"Abbreviation: {0}{1}{2}{3}{4}",
	              __box(First), __box(Second), __box(Third),
	              __box(Fourth), __box(Fifth));

    Console::WriteLine(S"");
    return 0;
}

It would produce the same result.

Arrays and Functions

An Array as Argument

An array can be passed to a function as argument. An array can also be returned by a function. To specify that a function takes an array as argument, declare the function as you would do for any regular function. In the parentheses of the function, declare the array with the __gc keyword as you have done so far. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

void ShowNumbers(double n __gc[]);

int _tmain()
{
    // TODO: Please replace the sample code below with your own.

    Console::WriteLine(S"");
    return 0;
}

When implementing the function, proceed as you would do normally. If you want to access the members of the array, use the same technique we have used so far, accessing each member of the array by its index. When you call the function from another function, simply pass the name of the array as argument. This would be done as follows:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

void ShowNumbers(double n __gc[]);

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[]= { 643.18, 9.64, 48.05, 14.26, 62.55 };

    ShowNumbers(number);

    Console::WriteLine(S"");
    return 0;
}

void ShowNumbers(double Nbr __gc[])
{
    Console::WriteLine(S"Value 1: {0}", __box(Nbr[0]));
    Console::WriteLine(S"Value 2: {0}", __box(Nbr[1]));
    Console::WriteLine(S"Value 3: {0}", __box(Nbr[2]));
    Console::WriteLine(S"Value 4: {0}", __box(Nbr[3]));
    Console::WriteLine(S"Value 5: {0}", __box(Nbr[4]));
}

This would produce:

Value 1: 643.18
Value 2: 9.64
Value 3: 48.05
Value 4: 14.26
Value 5: 62.55

Press any key to continue

If you create a function that takes a non-managed array as argument, you usually would pass an additional argument that carries the size of the array. On the other hand, if you create a function that takes a managed array as argument, since the array would inherit from the Array class, the argument would automatically carry its dimension from the Length property of the Array class. Therefore, with a managed array as argument, you don’t have to specify the number of members to the function; the compiler would figure that out.

Returning an Array

Whether in C/C++ or Managed C++, an array is (always) passed as a reference. Although in C/C++, there is no formal way to return an array from a function, because an array is passed as a reference, it is very easy to return an array. Actually, this technique is used in C++ as an accessory, not as a means. Managed C++ formal features the idea of returning an array from a function. Although this is a new feature not available in C/C++, it is very easy to use, so easy that there is very little effort to implement this valuable addition.

To indicate that a function would return an array, if you are only declaring the function, type empty square brackets between the function’s parentheses and its semi-colon. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

Double GetNumbers()[];

void ShowNumbers(double n __gc[]);

int _tmain()
{
    // TODO: Please replace the sample code below with your own.

    Console::WriteLine(S"");
    return 0;
}

When defining the function, type the square brackets between the function’s parentheses and its opening curly bracket. In the body of the function, you can declare an array, do what you want with it, and then return it as the return value of the function.

When calling a function that returns an array, proceed with the rules you would use for any other function. For example, you can call the function in another and use it as you see fit. You can also assign the function to an array variable in order to initialize the variable. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

Double GetNumbers()[];

void ShowNumbers(double n __gc[]);

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double no __gc[] = GetNumbers();
    ShowNumbers(no);

    Console::WriteLine(S"");
    return 0;
}

Double GetNumbers()[]
{
    Double number[] = { 643.18, 9.64, 48.05, 14.26, 62.55 };

    return number;
}

void ShowNumbers(double Nbr __gc[])
{
    Console::WriteLine(S"Value 1: {0}", __box(Nbr[0]));
    Console::WriteLine(S"Value 2: {0}", __box(Nbr[1]));
    Console::WriteLine(S"Value 3: {0}", __box(Nbr[2]));
    Console::WriteLine(S"Value 4: {0}", __box(Nbr[3]));
    Console::WriteLine(S"Value 5: {0}", __box(Nbr[4]));
}

Share on Facebook

If you need the basic concepts about Ribbon Control, read the first part of my previous post.

1. Download the Ribbon Control binaries here.

2. Create a Windows Forms Visual Studio Project.

3. Add reference to the downloaded System.Windows.Forms.Ribbon.dll

4. Declare a System.Windows.Forms.Ribbon reference in Designer.cs file of your form and create an object (you also need to add some more supporting code). Be sure to include System.Windows.Forms to your code. Your .Designer.cs file should look somewhat like this;

using System.Windows.Forms;

namespace DMProject

{

    partial class Form1

    {

        /// <summary>

        /// Required designer variable.

        /// </summary>

        private System.ComponentModel.IContainer components = null;

        private System.Windows.Forms.Ribbon ribbon1 = null;

        /// <summary>

        /// Clean up any resources being used.

        /// </summary>

        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>

        protected override void Dispose(bool disposing)

        {

            if (disposing && (components != null))

            {

                components.Dispose();

            }

            base.Dispose(disposing);

        }

        #region Windows Form Designer generated code

        /// <summary>

        /// Required method for Designer support - do not modify

        /// the contents of this method with the code editor.

        /// </summary>

        private void InitializeComponent()

        {

            this.ribbon1 = new System.Windows.Forms.Ribbon();

            this.SuspendLayout();

            // 

            // ribbon1

            // 

            // 

            // Form1

            // 

            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);

            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;

            this.ClientSize = new System.Drawing.Size(284, 262);

            this.Controls.Add(this.ribbon1);

            this.Name = "Form1";

            this.Text = "Form1";

            this.ResumeLayout(false);

        }

        #endregion

    }

}

Your Windows Form Should look like this;

From this point onward, adding controls to the ribbon should be easy.

5. To add a tab to your ribbon control, click ‘Add Tab’. I have added three tabs; Home, Data Manipulation and Visualization. As with any control, you can change the properties of the tabs using the properties grid.

You can now compile and run the application, it would look like the screenshot above.

6. The next step is to add a panel to contain the buttons. To do this, click the ‘Add Panel’ button. Change the properties of the panels as desired.

7. Once the panels have been created, click a panel. The property grid shows options for the panel. Besides ‘Add Button’, these options include ‘Add Button List’, ‘Add Item Group’, ‘Add Separator’ etc. Click the ‘Add Button’ command. A button is created. You can use the property grid to set the text, tool tip and image for the button.

To add images to these buttons, you first have add the PNG images to your project resources. To do this, right click on your project and click Properties. In the resources tab, select ‘Add Existing File’ and browse for your PNG icons.

Congratulations! you have successfully added a ribbon control to your Windows Forms Application. You are good to go!

Share on Facebook

Image Courtesy MSDN.

The WPF team is sharing new WPF Ribbon control starting on Monday, October 27, 2008! Binaries and source code for the Ribbon can be downloaded at the Office UI Licensing site.

So, your first step is to go to Office UI Licensing site and get yourself a free WPF ribbon control. You must accept and sign license (it’s not a big deal) and download free WPF ribbon control. Just follow this link.

What is Ribbon Control?

Ribbons are the modern way to help users find, understand, and use commands efficiently and directly—with a minimum number of clicks, with less need to resort to trial-and-error, and without having to refer to Help.

The preview version of the WPF Ribbon includes many of the features which Independent Software Vendors (ISVs) need to add a Ribbon control to their WPF applications. Ribbon is a command bar that organizes a program’s features into a series of tabs at the top of a window. The Ribbon UI was designed by Microsoft Office to increase discoverability of features and functions, enable quicker learning of the program as a whole, and make users feel more in control of their experience with the program. The Ribbon is designed to replace the traditional menu bar and toolbars. The WPF Ribbon will include all of the basic Ribbon features and functionality, including tabs, groups, controls (buttons, split buttons, galleries, etc.), title bar integration of the application menu button and quick access toolbar, and resizing with dynamic layout.

For more information, follow this link.

Step 1: Adding The Ribbon Control to your WPF Application

1. Create a new WPF Project using Visual Studio .NET 2008.

2. Add a reference to “RibbonControlsLibrary.dll” that you downloaded earlier.

3. Add the XAML Reference to the DLL you have just added to your project by adding this line to your XAML code.

xmlns:r="clr-namespace:Microsoft.Windows.Controls.Ribbon;assembly=RibbonControlsLibrary"

4. Change the root element of your XAML code to r:RibbonWindow instead of Window.

   1: <r:RibbonWindow x:Class="FirstRibbonApplication.Window1"

   2:     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   3:     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   4:     xmlns:r="clr-namespace:Microsoft.Windows.Controls.Ribbon;assembly=RibbonControlsLibrary"

   5:     Title="Window1" Height="300" Width="300">

   6:     <Grid>

   7:         

   8:     </Grid>

   9: </r:RibbonWindow>

5. Add the r:Ribbon tag to your XAML code.

<r:Ribbon Title="WPF Ribbon - Document1" x:Name="ribbon" />

Your XAML code should now look like this;

<r:RibbonWindow x:Class="FirstRibbonApplication.Window1"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:r="clr-namespace:Microsoft.Windows.Controls.Ribbon;assembly=RibbonControlsLibrary"

    Title="Window1" Height="300" Width="300">

    <Grid>

       <r:Ribbon Title="WPF Ribbon - Document1" x:Name="ribbon" />

    </Grid>

</r:RibbonWindow>

Congratulations! you have successfully added a ribbon control to your WPF application. Before you can see the control you would need to make a few changes to the accompanying cs file. Open the cs and add the following library and make sure that the partial class inherits from RibbonWindow instead of Window.

using Microsoft.Windows.Controls.Ribbon;

Compile and run the application to see the results.

Step 2: Adding Tabs, Groups and Buttons

As described earlier a ribbon control contains different tabs, each tab contains a groups and groups in turn contain buttons. In this step we would create tabs, groups and buttons.

1. To add tabs to your ribbon control add the r:RibbonTab tag within the r:Ribbon tag you added in the last step.

<r:RibbonTab Label="Home">

</r:RibbonTab><r:RibbonTab Label="Insert">

</r:RibbonTab><r:RibbonTab Label="Help">

</r:RibbonTab>

 

<r:RibbonGroup Name="Clipboard"></r:RibbonGroup><r:RibbonGroup Name="Fonts"></r:RibbonGroup>

<r:RibbonButton ></r:RibbonButton>

<r:RibbonWindow x:Class="FirstRibbonApplication.Window1"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:r="clr-namespace:Microsoft.Windows.Controls.Ribbon;assembly=RibbonControlsLibrary"

    Title="Window1" Height="300" Width="300">

    <Grid>

        <r:Ribbon Title="Window1" x:Name="ribbon">

            <r:RibbonTab Label="Home">

                <r:RibbonGroup Name="Clipboard">

                    <r:RibbonButton ></r:RibbonButton>

                </r:RibbonGroup>

                <r:RibbonGroup Name="Fonts">

                    <r:RibbonButton ></r:RibbonButton>

                </r:RibbonGroup>

            </r:RibbonTab>

            <r:RibbonTab Label="Insert">

            </r:RibbonTab>

            <r:RibbonTab Label="Help">

            </r:RibbonTab>

        </r:Ribbon>

    </Grid>

</r:RibbonWindow>

Step 3: Adding Commands to Ribbon Groups and Ribbon Buttons

<r:RibbonWindow.Resources><ResourceDictionary></ResourceDictionary></r:RibbonWindow.Resources>

<r:RibbonCommand x:Key="ClipboardGroupCommand"CanExecute="OnCanExecute"Executed="OnShowClipboardGroup"LabelTitle="Clipboard"/>

<r:RibbonGroup Name="Clipboard">

<r:RibbonGroup Name="Clipboard" HasDialogLauncher="True" Command="{StaticResource ClipboardGroupCommand}">

Now, we have connected our resource with RibbonGroup. I have added HasDialogLauncher=”True” because that will allow us to fire OnShowClipboardGroup  event when user clicks on dialog launcher.

5. Go to your CS code-behind file and add these lines:

private void OnCanExecute(object target, CanExecuteRoutedEventArgs args){args.CanExecute = true;}

private void OnShowClipboardGroup(object target, ExecutedRoutedEventArgs args){MessageBox.Show("This is the Clipboard!.", "Clipboard Dialog");}

In principal we are done with this step and the essential concepts have been learnt. You can now learn your application and test to see that the message box is displayed.

Similar to step 4 and 5 create another RibbonCommand, add the resource to the Copy Button and write the corresponding cs code.

Creating another RibbonCommand;

<r:RibbonCommandx:Key="CopyCommand"CanExecute="OnCanExecute"Executed="OnCopyCommand"LabelTitle="Copy"LargeImageSource="Images\copy.png"ToolTipTitle="Copy (Ctrl+C)"ToolTipDescription="Copies the selected content on to the clipboard"></r:RibbonCommand>

<r:RibbonButton Name="Copy" Command="{StaticResource CopyCommand}"></r:RibbonButton>

private void OnCopyCommand(object target, ExecutedRoutedEventArgs args){    MessageBox.Show("This is the copy button!.", "Copy Dialog");}

<r:RibbonWindow x:Class="FirstRibbonApplication.Window1"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:r="clr-namespace:Microsoft.Windows.Controls.Ribbon;assembly=RibbonControlsLibrary"

    Title="Window1" Height="600" Width="400">

    <r:RibbonWindow.Resources>

        <ResourceDictionary>

            <r:RibbonCommand x:Key="ClipboardGroupCommand"

                             CanExecute="OnCanExecute"

                             Executed="OnShowClipboardGroup"

                             LabelTitle="Clipboard">

            </r:RibbonCommand>

            <r:RibbonCommand

                x:Key="CopyCommand"

                CanExecute="OnCanExecute"

                Executed="OnCopyCommand"

                LabelTitle="Copy"

                LargeImageSource="Images\copy.png"

                ToolTipTitle="Copy (Ctrl+C)"

                ToolTipDescription="Copies the selected content on to the clipboard">

            </r:RibbonCommand>

        </ResourceDictionary>

    </r:RibbonWindow.Resources>

    <Grid  HorizontalAlignment="Stretch" VerticalAlignment="Top">

        <r:Ribbon Title="Window1" x:Name="ribbon"  VerticalAlignment="Top">

            <r:RibbonTab Label="Home">

                <r:RibbonGroup Name="Clipboard" HasDialogLauncher="True" Command="{StaticResource ClipboardGroupCommand}">

                    <r:RibbonButton Name="Copy" Command="{StaticResource CopyCommand}"></r:RibbonButton>

                </r:RibbonGroup>

                <r:RibbonGroup Name="Fonts">

                    <r:RibbonButton  Name="Paste"></r:RibbonButton>

                </r:RibbonGroup>

            </r:RibbonTab>

            <r:RibbonTab Label="Insert">

            </r:RibbonTab>

            <r:RibbonTab Label="Help">

            </r:RibbonTab>

        </r:Ribbon>

    </Grid>

</r:RibbonWindow>

 

Share on Facebook

Wouldn’t it be nice if all this information were kept in one location? The obvious place to put this information is in the source code itself; this makes it easy to modify the docs along with the code. But it is hard enough to go through someone else’s program when you know how to code, let alone when you are less technically savvy. Also, adding code documentation takes time.
This article will show you how to solve many of those problems using XML comments. Code comments, user manuals, developer manuals, test plans, and many other documents can be generated from a single source using XML tags. I’ll explain how to insert XML comments and enable exportation of these comments to another file. I’ll then discuss each of the available tags and the format of the XML file where the tags are used and walk through an example of using XML comments and XSLT to generate help files.

XML Comments

All XML comments begin with three forward slashes (///). The first two slashes signify a comment and tell the compiler to ignore the text that follows. The third slash tells the parser that this is an XML comment and should be handled appropriately.
      When the developer types the three forward slashes, the Microsoft® Visual Studio® .NET IDE checks to see if it precedes an identifiable type or type member definition. If it is identifiable, then the Visual Studio .NET IDE will automatically insert a few comment tags. The developer then adds additional tags and values as needed. For example, here are the XML tags that are generated when the three forward slashes are entered before this member function that has a parameter:

/// <summary>
///
/// </summary>
/// <param name="strFilePath"></param>
public void LoadXMLFromFile(string strFilePath)

The tags inserted here represent only a couple of many that the Visual Studio .NET IDE already knows.

While the current implementation of IntelliSense® for XML comments does not show all the tags listed in the C# specification, the missing tags can always be inserted manually.

      Once comments are inserted, it would be useful to do something with them. If you set things up correctly (as I’ll explain shortly), this usually just means exporting all the text that comes after the three forward slashes into an external file.

      There are also several predefined XML comment tags that the parser knows. When these tags are encountered (and have been used correctly by the developer), the parser will format the tags’ output to a text file. If a tag that is not predefined is encountered, it is just written verbatim along with any text to the external file. This means that you can make up your own tags or you can even use known tags recognizable from another source (such as HTML) in the comments.

      When exportation is set up correctly, the C# parser extracts the XML comments, does formatting if needed, and places them into an XML file of your choice. You can set the location and file name of the XML document file, and enable exportation, through your project’s property pages. To do this, follow these four steps:

• Open the property page for the project, usually by right-clicking on the project in the Solution Explorer, and click Properties.
• After the dialog has opened, click the Configuration Properties folder.
• Click the Build option.
• In the right pane, there will be a property field called XML Documentation File. Set this to the path and file name of the desired file. The path entered is relative to the project directory, not absolute.

Recognized Tags

I have classified the XML comment tags into two categories. The first set of tags, which I’ll call primary tags, always starts a group of XML comment tags. They are never embedded within other tags. The second set contains tags that are used within primary tags as modifiers to the text. I call them support tags.

here are nine primary tags: <remarks>, <summary>, <example>, <exception>, <param>, <permission>, <returns>, <seealso>, and <include>.

      In this context, the <remarks> tag is used to describe a type such as a class:

/// <remarks>
/// Class that contains functions to do
/// transformations to help files.
/// </remarks>

The C# documentation recommends using <remarks> to describe a type and a <summary> tag to describe a type member.Oddly, if you start a comment before a type using the /// combination, the Visual Studio .NET IDE will still insert a <summary> tag. Therefore, <remarks> tags need to be inserted manually.

The <summary> tag is the tag found most often in a C# source file. This tag is used to describe type members, including methods, properties, and fields:

/// <summary>
/// This XmlDocument based attribute contains the
/// XML documentation for the project.
/// </summary>

The <summary> tag can describe types as well, but it is not recommended. The XML comment documentation recommends that the <remarks> tag be used for describing types.

The <example> tag is used to mark the beginning of an example showing how to use the item. The example can be any valid text, but most often it is a snippet of code:

/// <example>
/// <code>
/// // create the class that does translations
/// GiveHelpTransforms ght = new GiveHelpTransforms();
/// // have it load our XML into the SourceXML property
/// ght.LoadXMLFromFile(
///  "E:\\Inetpub\\wwwroot\\GiveHelp\\GiveHelpDoc.xml");
/// </code>
/// </example>

If code is used, it is usually marked with a <code> tag. The <code> tag will be discussed in the section on support tags.

The <exception> tag documents the exceptions, if any, that the item may throw. If more than one exception may be thrown, then more than one of these tags may be used. Unlike most of the tags, the <exception> tag has one attribute, cref. The value of this attribute is the name of the exception that could be thrown. This must be a valid class because the C# parser will verify it and extract the context information to put into the XML documentation. I will explain this later.

I did not throw any exceptions in the code for this article, but here is an example of how the cref attribute can be used with the <exception> tag:

/// <exception cref="SampleException">
/// Normally, a discussion on any exceptions thrown would go here.
/// </exception>

The <param> tag describes the parameters of a method or property. It is automatically inserted by the IDE when using the three forward slashes before a method. The <param> tag has one attribute, name, which is simply the same name that the parameter has in the source:

/// <param name="strFilePath">The path to the file containing the
/// source XML.</param>

Member access is identified with the <permission> tag. The text that is assigned to it sets permission-related descriptions. There is no requirement for the value for this tag. Permission is one possibility, with values such as public, private, protected, and so on. Scope is another possible value, with information about whether the method is static. However, you are free to put whatever value you must have here.

The <permission> tag has one attribute—cref. The documentation describes the use of cref in this context as "a reference to a member or field that is available to be called from the current compilation environment." It is usually set to System.Security.PermissionSet:

/// <permission cref="System.Security.PermissionSet">Public
/// Access</permission>

The <returns> tag is similar to the <param> tag, but it’s used to describe what the method or property returns:

/// <returns>The HTML for a list of types based on the XML
/// documentation.</returns>

The <seealso> tag specifies "other" links related to the same topic. This tag usually does not include a text value, just a cref attribute that specifies a reference to a symbol. This could be a type, member, field, and so on.

/// <seealso cref="GiveMemberListHTMLHelp"/>

The XML compiler will identify the content of the symbol and use it accordingly in the compiled XML documentation. I’ll discuss this again in the section on the XML documentation file.

When XML comments are extracted from the code by the compiler, any file specified in the <include> tag will be expanded and the comments inside it will be used as if that had been included inline. Because the compiler finds them, you can keep comments in an external file. This can help organize your code, but then the comments are not readily available. I would never use the <include> tag for this reason, but if your comments are lengthy, you may find the trade-off acceptable.

      Several attributes must accompany the <include> tag to specify the external file. The file attribute is the name of the file using relative or fully qualified paths. The include file itself is an XML document that holds XML comments. The path attribute is an XPath statement that points to the parent element of the XML comments in the external document, as you can see here:

/// <include file='MyXMLCommentFile.xml'
/// path='doc/members/member[@name="T:MyExampleClass"]/*'/>
public class MyExampleClass
{
/// <include file='MyXMLCommentFile.xml'
   /// path='doc/members/member[@name="M:MyExampleMethod"]/*'/>
   public string MyExampleMethod(string strReturnThis)
   {
     return strReturnThis;
   }
}

Support Tags

      There are eleven support tags: <c>, <code>, <list>, <listheader>, <item>, <term>, <description>, <para>, <paramref>, <see>, and <value>.

      The <c> tag marks a line of text as code. It is usually used inline in descriptive text.

/// The source XML is loaded into the <see cref="SourceXML"/>
/// property (e.g. <c><I>obj</I>.SourceXML =
/// "<I>XML goes here</I>"</c>).

The <code> tag also defines a section of text as code. It is often used within an <example> tag block (as shown earlier). The <code> tag is similar to the <c> tag, but <c> is used for a single line of code while <code> is used for a block of code. It specifies that the formatting of the text in the comments needs to remain the same:

/// <code>
/// // create the class that does translations
/// GiveHelpTransforms ght = new GiveHelpTransforms();
/// // have it load our XML into the SourceXML property
/// ght.LoadXMLFromFile(
///      "E:\\Inetpub\\wwwroot\\GiveHelp\\GiveHelpDoc.xml");
/// </code>

The <list> tag is used in other comment tags to define a specialized list. The type of list is defined by the type attribute, which can have the values bullet, number, or table. Within the <list> tag, there are tags that denote the components of the list, as you can see in this example:

/// <list type="table">
/// <listheader>
/// <term>Help Page</term>
/// <description>Function to call</description>
/// </listheader>
/// <item><term>List of Types</term>
/// <description>GiveTypeListHTMLHelp</description></item>
/// <item><term>List of members</term>
/// <description>GiveMemberListHTMLHelp</description></item>
/// <item><term>Help for a single member</term>
/// <description>GiveMemberHTMLHelp</description></item>
/// </list>

The <listheader> tag holds header information for the list (see the previous example). It is typically used for a table of list types.

As you probably guessed, the <item> tag identifies each item in the list. It can stand alone or wrap <term> and <description> tags. The <term> and <description> tags are always children tags of the <listheader> tag or <item> tags. They are always used in pairs and their function is obvious.

The <para> tag is used to identify a new paragraph. It is very similar to the <P> tag in HTML. You should definitely use this tag to break up long comment sections:

/// <summary>This is a summary.
/// <para>This is a new paragraph.</para>
/// </summary>

If text within a comment needs to have a parameter specially identified, then <paramref> is the tag to use. It is inserted in the text in the location where the parameter text should appear. The main purpose of this tag is to identify the name of a parameter that should be formatted in a special way. It has one attribute, name, which is the name of the parameter that would appear in the text, usually formatted in a special way:

/// Loads the XML documentation in the file specified by
/// <paramref>strFilePath</paramref>.

The <see> tag is used within the text of other comment tags to specify a hyperlink. It is used inline as part of the text and usually just includes one attribute, cref:

/// One of the associated member functions (<see
/// cref="GiveTypeListHTMLHelp"/>,
/// <see cref="GiveMemberListHTMLHelp"/>, <see
/// cref="GiveMemberHTMLHelp"/>)
/// is called to initiate and then return the transformation.

The cref attribute specifies a reference to an existing symbol. See the description for the <exception> tag for more information.

The <value> tag defines the meaning of a property member. It is used just like the <remarks> tag is used for classes and the <summary> tag is used for other members.

/// <value>
/// The SourceXML property contains the XML that will be used in
/// the transformations by the member functions for this class.
/// </value>

Generating Documentation

Now that you have successfully created an XML file from the comments you need to generate documentation from it. For this purpose you can download and use nDoc.

Once you have downloaded nDoc, you can use its GUI interface to select a binary from your project directory (make sure it is in the debug folder and the .XML is located next to it).

nDoc allows you to create different types of documentations from simple HTML to MSDN style.

If you need anymore help, please feel free to ask.

Related Article;

http://msdn.microsoft.com/en-us/magazine/cc302121.aspx

Share on Facebook

A simple application may be implemented as shown in the following figure.

Figure 1: Simple unified logic that runs in a single process and thread (Courtesy MSDN).

The above pseudo-code takes input from the client and based on the input executed different paths. Note that the input is taken at different points in the code. The state of the application/process is represented here by a simple string. Although this application development style is simple and easy to understand, it is not scalable. Imagine you are using such application logic for a hiring process where the inputs can come after days and even weeks. Your server would have to keep the process alive and running for this whole period. Imagine how much resources it would take to cater for thousands of users. What if the server fails during this period?

Considering these problems, lets look at another solution. This time round we separate the application logic at the freezing points (the input). Breaking the application logic allows the application to run as two different threads. This can solve a few of the problems described above.

Figure 2: Breaking the application logic (Courtesy MSDN).

Note that this time round the state is stored outside of the process in a database. The reason is that whenever the second process starts it needs to get the current state from some “persistent” store. Also note that the two application parts can now run on two different machines. Can you see a problem with this? The problem comes from the fact that it is hard for the second process to know whether the if was executed in the first part or the else (of course you would have to make this a part of the state). The point here is that the state becomes complex and we have to introduce a number of checks in the second part of the application.

The first figure is how our usual desktop applications run. they have their state stored in some memory variables that vanish as soon as the application ends. The applications which remember what you did last time have to save this state in some persistent storage. The second example is how ASP.NET applications work. The application logic is implemented in a distributed manner (on different pages). This not only makes it difficult for people to understand the process but also the programmer has to perform a series of checks whenever a page loads. It is also to be noted that the first type provides us unified logic whereas the second provides us scalability.

The Solution

Using windows workflows can help us solve these problems. WF function just as a normal program providing mechanism for input, output, control flow etc. However, all these are done with the help of activities, see diagram below.

Figure 3: In a workflow all the things are done with the help of activities (Courtesy MSDN)

As you can probably already see that unified logic is provided by workflows, let us see how WF solve the problem of scalability. All the work in the WF is done using activates, and as seen the WF provides all the elements of a usual programming language. The difference however is that all these activities are classes themselves, and they are executed on a WF Runtime which knows how to run these classes (activities).

Figure 3: WF Runtime executes activities in order (Courtesy MSDN).

When it begins the workflow runtime executes the outer most activity first, which in this case is a sequential workflow. Then it executes the activities one after the other in order determined by the workflow. One thing to note here is that the activities are objects, and therefore can be described in any language, making the workflow independent of the language. Also that the WF Runtime does not know anything about the internals of the activity it is executing, allow the programmer to fill in what is to be done. WF provides a Base Activity Library (BAL) from which you can pick activities to include in your workflow. You can also create activates of your own, called custom activities.

The big question arises, why go through all this pain? The first answer to this question has already been answered, it provides unified logic. However, to be scalable the server application cannot be stuck with one process. One solution to this is the ASP.NET way, i.a. to break the application logic down into small chunks, however this is something we are trying to avoid. Moreover, the programmer than has to explicitly deal with state. As you can probably notice this WF is already broken down into chunks, this allows the WF to persist (not block waiting for an event). When at the start of our example workflow, the workflow is waiting for input the WF Runtime realizes this and stores the state of the WF in a persistent storage (we say the WF persists). This allows for the server resources to be used elsewhere. When the input arrives the WF Runtime wakes up the WF.

Figure 5: The workflow can persist (Courtesy MSDN).

Another advantage of the workflow being broken down from the perspective of scalability is the ability of the WF to be run on different machines when it resumes, as shown in the following diagram.

Figure 6 Different parts of a workflow can run on different machines

Other Benefits

Other benefits of using windows workflows include the following

Coordinating Parallel Work

The WF allows you to coordinate parallel work in a better way by using the parallel activity which is part of BAL (More on this in later articles).

Figure 7 Workflows can run parallel activates (Courtesy MSDN).

Providing Tracking

Tracking processes is an important part of any business application. WF makes it extremely easy to do this by providing tracking services. The tracking services are extremely closely linked to persistence (state maintenance) because the state of the WF has all the information one needs for tracking a WF.

Figure 8 You can track the WF using tracking services (Courtesy MSDN).

Creating custom activities

WF allows you to create custom activities that you can re use as is suited to your business application, allowing to use OO concepts in WF.

Figure 9 You can create custom activities (Courtesy MSDN).

Fully Declarative Language

WFs are fully declarative as each workflow is represented by a corresponding XAML file.

Figure 10 WFs are fully declarative (Courtesy MSDN).

Related articles

http://msdn.microsoft.com/en-us/library/dd851337.aspx

Share on Facebook

Handling User Input

This topic describes how you can take input from a user on a windows form and use that input.

Once you have created a Windows Forms Application, add a textbox control to the windows form. You can do this by dragging the control from the toolbox to the windows form and place it wherever you may please. It is always a good idea to place a label (static text box) next to a text box that describes what the text box takes as an input. You can also place this static text control in the same manner. Also add a push button below the two controls.

You can change the text on a control and its identifier (ID) by editing its properties. To do this right click on a control and click properties. The properties panel opens up. The two main properties we will be concerned with are Text and ID. It is highly recommended that you play around with the other properties as well.

I have changed the ID of the textbox to textboxMessage. The ID of the other two controls has not been changed.

Now what we need to do is to create a create a EventHandler for the pushbotton. A EventHandler is a function when an Event occurs. You will become familiar with events as we move further in this tutorial. E.g. the click on a button is an event.

To create an even handler, click on a control and click on the lightning button on the properties panel.

In the push button events, click on the ‘Click’ event. This will create an EventHandler (a function) which is called when the button is pressed.

Once you double click on the event, you would be taken to the code of the event handler. In the event handler function add the following line.

MessageBox::Show(this->textBoxMessage->Text);

Your code should now look like this

   1: private: System::Void button1_Click(System::Object *  sender, System::EventArgs *  e)

   2:          {

   3:              MessageBox::Show(this->textBoxMessage->Text);

   4:          }

The MessageBox is a build in class with a static function Show. This function shows a message box with the given String. We get this string from the textbox we have created.

To get this string we first access the textBoxMessage control from the form class using the this pointer. Once we do this, we then use –> to access its properties. One of these properties is the Text. Again i would recommend that you play around with these properties.

Now compile and run the project, it should do something like this.

Share on Facebook

All the data is courtesy MSDN.

Creating a Windows Forms Project

The foundation of most solutions that involve Windows Forms is the Windows Application project. Creating a project is easy within the integrated development environment (IDE).

To create a Windows Application project

1. On the File menu, point to New, and then select Project.

2. In the Project Types pane, choose the programming language you want to use.

3. In the Templates pane, choose Windows Application for Visual Basic, Visual J#, or Visual C# projects, or choose Windows Forms Application (.NET) for Visual C++ projects. We will mostly concern ourselves with C++.

   The Windows Forms Designer opens, showing Form1 of the project you created.

Display Windows Forms in the Designer

Within the Windows Forms Designer, you can view the forms within your project and their controls.

To view forms in the Windows Forms Designer

• In Solution Explorer, double-click the form. For details, see Windows Forms Overview.

  If Solution Explorer is not visible, select it from the View menu or press CTRL+W, S.

To view the code for a form

• In Solution Explorer, select the form and then click the View Code button. You can also right-click the form in Solution Explorer and choose the View Code item in the shortcut menu.

If the designer has focus, press F7 to switch to the Code Editor.

Next

Share on Facebook