Marco André Silva

DevDays 2009

2009-02-23T09:50:49Z

Realizou-se a semana passada o DevDays 2009, o evento anual da Microsoft Portugal destinado a juntar profissionais e curiosos em torno das tecnologias da casa, que este ano foi organizado no campus do Tagus Park do Instituto Superior Técnico.

Para mim foi uma novidade a participação neste tipo de eventos, e logo com a oportunidade de fazer uma sessão sobre a Implementação de Serviços REST sobre WCF, que segundo me disseram ;) , correu bastante bem.

Além de mim, outros três colegas da |create|it| fizeram apresentações no DevDays este ano. Estou a falar do Jota, que já é veterano nestas andanças, e do André e o Raul.

Globalmente o evento correu bem e foi uma boa oportunidade para conhecer pessoas e trocar experiências interessantes.

Posteriormente vou editar este post com a informação que apresentei na sessão.

.NET XML Serialization of CDATA ATTRIBUTE

2008-11-23T19:05:11Z

Recently I needed to create a .NET class (C#) that when serialized should contain a CDATA attribute similar to this:

<?xml version="1.0" encoding="utf-8" ?>

<RootNode Type="zzzzz" Version="1" >

    <CDataAttribute>

        <![CDATA[

         <?xml version="1.0" encoding="utf-8" ?>

]]>

    </CDataAttribute>

</RootNode>

I started by creating a schema for validating this xml that can be (generated with xsd.exe and slightly altered):

<?xml version="1.0" encoding="utf-8"?>

<xs:schema id="Example" xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:element name="RootNode">

    <xs:complexType>

      <xs:sequence>

        <xs:element name="CDataAttribute" type="xs:string" minOccurs="0"/>

      </xs:sequence>

      <xs:attribute name="Type" type="xs:string" />

      <xs:attribute name="Version" type="xs:string" />

    </xs:complexType>

  </xs:element>

  <xs:element name="Example">

    <xs:complexType>

      <xs:choice minOccurs="0" maxOccurs="unbounded">

        <xs:element ref="RootNode" />

      </xs:choice>

    </xs:complexType>

  </xs:element>

</xs:schema>

Note that the CDataAttribute is specified as type string and I could not find any type for referring a CDATA.

Now if you take this schema and generate a class from it (again with xsd.exe) you will see that the CDataAttribute is, as expected, represented by a string.

private string cDataAttributeField;

If you use the generated class and serialize a object from it, the .NET serializer will not encode the CDataAttribute between a CDATA xml structure, but instead will escape all the special characters that you place inside the CDATA.

<?xml version="1.0"?>

<Example xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xmlns:xsd="http://www.w3.org/2001/XMLSchema">

  <RootNode Type="xxxx" Version="1">

    <CDataAttribute>&lt;?xml version="1.0" encoding="utf-8" ?&gt;</CDataAttribute>

  </RootNode>

</Example>

As I really needed it to be placed inside a CData section, I searched on the Internet but did found a satisfying solution for this “problem”, but using the idea behind some of the articles (use XmlNode for the class CDataAttribute member instead of string) my solution was the following.

First I generated my schema class without the CDataAttribute.

<?xml version="1.0" encoding="utf-8"?>

<xs:schema id="Example" xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:element name="RootNode">

    <xs:complexType>

      <xs:sequence>

        <!-- NOTE: We could not generate a CDATA directly from XSD.

             Generated by partial class -->

        <!--<xs:element name="CDataAttribute" type="xs:string" minOccurs="0"/>-->

      </xs:sequence>

      <xs:attribute name="Type" type="xs:string" />

      <xs:attribute name="Version" type="xs:string" />

    </xs:complexType>

  </xs:element>

  <xs:element name="Example">

    <xs:complexType>

      <xs:choice minOccurs="0" maxOccurs="unbounded">

        <xs:element ref="RootNode" />

      </xs:choice>

    </xs:complexType>

  </xs:element>

</xs:schema>

Then I extended the partial generated class with my own implementation of the CDataAttribute.

using System;

using System.Xml;

public partial class RootNode

    private XmlNode cDataAttributeField;

    /// <remarks/>

    [System.Xml.Serialization.XmlElementAttribute(Form = System.Xml.Schema.XmlSchemaForm.Unqualified)]

    public XmlNode CDataAttribute

        get {return this.cDataAttributeField;}

        set {this.cDataAttributeField = value;}

    /// <summary>

    /// Getter/Setter method for the CDATA document content field.

    /// Encapsulates the internal CDATA XmlNode

    /// </summary>

    [System.Xml.Serialization.XmlIgnore()]

    public String CDataAttributeByString

get

        { // Retrieves the content of the encapsulated CDATA

          return cDataAttributeField.Value;

set

        { // Encapsulate in a CDATA XmlNode

          XmlDocument xmlDocument = new XmlDocument();

          this.cDataAttributeField = xmlDocument.CreateCDataSection(value);

Note that I used a XMLNode for representing the class member that will be serialized. For setting this XMLNode I created a property (CDataAttributeByString) that receives a string and places in the XmlNode a CDataSection containing the received string value.

As so I only work with the CDataAttributeByString property, that is excluded from the serialization, and I let the .NET serializer use the CDataAttribute property for properly creating my CDataAttribute.

Using the extended class, the serialized xml will now be:

<?xml version="1.0"?>

<Example xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xmlns:xsd="http://www.w3.org/2001/XMLSchema">

  <RootNode Type="xxxx" Version="1">

    <CDataAttribute>

        <![CDATA[<?xml version="1.0" encoding="utf-8" ?>]]>

    </CDataAttribute>

  </RootNode>

</Example>

I hope that this can help some of you, and if you know a better solution please tell me.

I leave a sample project here.

Architect Forum 2008

2008-11-23T13:38:47Z

This week I participated in the Architect Forum 2008 in Portugal.

The event was all about Cloud Computing and the agenda had two sessions:

Microsoft’s Cloud Computing Platform : What it is and when to use it, by David Chappell
Windows Azure, Padrões de Arquitectura e Caso de Uso, by João Pedro Martins, José António Silva, Nuno Godinho

The first session was more introductory and theoretical serving its purpose of presenting this new computing platform paradigm. What I also liked about it, was that the speaker focused not only on the Microsoft’s platform but on other platforms like the one’s from Amazon and Google, showing their differences and similarities, possible strengths and weaknesses.

Personally it seems that Microsoft’s platform given its “late appearance” (no one is really late) was given more thought and took advantage of the other previous experiments. But everything is right at the beginning and as so I expect everyone to be more or less “on-pair” when these platforms really take off.

The second session made the bridge from the theory to the practice by presenting scenarios where a cloud computing architecture “should” make sense and presenting advantages over “traditional” architectures. They showed a real case scenario with a expense reporting application running in the cloud platform of Microsoft that among other things made use of Live Mesh, .NET Services (e.g. Service Bus) and SQL Services (e.g. Storage).

Overall I really enjoyed the event and look forward to dive deeper and experiment with these cloud platforms.

Calling Excel (Web) Services from WCF

2008-08-01T23:37:42Z

Interfacing with Excel Services by means of WCF can be somewhat difficult at first and very subject to a trial and error experience.

On my development environment I started by generating the Excel Web Services proxy using svcutil.exe. One of the key aspects for success started at this stage by telling svcutil to generate the proxy using the XmlSerializer as opposed to the default DataContractSerializer (.NET 3.5). This is because whenever I tried to use the DataContractSerializer I would get serialization/deserialization errors.

The next step consisted on properly configuring the generated binding and endpoint.

For the binding I used the following configuration:

<binding name="ExcelServicesSoapBindingConfiguration"

         closeTimeout="00:01:00" openTimeout="00:01:00"

         receiveTimeout="00:01:00" sendTimeout="00:01:00"

         allowCookies="false" bypassProxyOnLocal="false"

         hostNameComparisonMode="StrongWildcard"

         maxBufferSize="65536" maxBufferPoolSize="52428"

         maxReceivedMessageSize="65536"

         messageEncoding="Text" textEncoding="utf-8"

         transferMode="Buffered" useDefaultWebProxy="true">

    <readerQuotas maxDepth="32" maxStringContentLength="8192"

                  maxArrayLength="16384" maxBytesPerRead="4096"

                  maxNameTableCharCount="16384" />

    <security mode="TransportCredentialOnly">

        <transport clientCredentialType="Ntlm"

                   proxyCredentialType="None" realm="" />

        <message clientCredentialType="UserName" algorithmSuite="Default" />

    </security>

</binding>

The relevant aspect here was the security with clientCredentialType set to Ntlm. Maybe this can be related with the authentication method that I choose for the SharePoint WebApplication/SiteCollection but I didn’t tested any other way.

The next part consisted on defining a Allow Impersonation behaviour. This behaviour as important in allowing the WCF service to act as the client while performing the operations with Excel Services (using the credentials of the client).

<endpointBehaviors>

    <!-- Impersonation endpoint behavior -->

    <behavior name="AllowImpersonationBehavior">

        <clientCredentials>

            <windows allowedImpersonationLevel="Impersonation"/>

        </clientCredentials>

    </behavior>

</endpointBehaviors>

This behaviour is used by the endpoint together with the binding configuration.

<endpoint address="http://localhost/_vti_bin/excelservice.asmx"

    binding="basicHttpBinding"

    bindingConfiguration="ExcelServicesSoapBindingConfiguration"

    behaviorConfiguration="AllowImpersonationBehavior"

    contract="Excel.WebServices.Proxy.ExcelServiceSoap"

    name="ExcelServiceSoapEndpoint" />

With this WCF configuration I managed to successfully call and use the Excel Web Services, and also to call other SharePoint Web Services from WCF (e.g. lists service).

A final note is related with the readerQuotas and message sizes that you see in the binding configuration. These can be important depending on the amount of information that you exchange with the Web Services. Whenever you start to get deserialization errors or other “unexplainable” errors, always check these parameters because they can be smaller that the message sizes that you are trying to exchange. (It should be noted that this does not only apply to Excel Web Services but to services invocations in general).

Please let me know of your own successes and experiences when using WCF with Excel or SharePoint Web Services.

Developing a WCF Service - Fault Exceptions AND FAULT Contracts

2008-05-18T16:59:54Z

This next post about WCF will show how to integrate Fault Exceptions and Fault Contracts in your service.

As written in MSDN Fault Exceptions are used for "... mapping managed exception objects to SOAP fault objects and SOAP fault objects to managed exception objects ...". This means that if you are looking for interoperability in your service development then you definitely should use this, because no Java client will understand a .NET exception.

You can read some more about it in this link Specifying and Handling Faults in Contracts and Services.

So, when using Fault Exceptions (or SOAP Faults) you have two alternatives:

Normal typed (or "un-typed") - You throw a regular FaultException which only contains general information about the SOAP Fault
Strongly-typed - You define your own SOAP Fault object, which can contain any kind of information you want about the SOAP Fault

Strongly-typed SOAP Faults are then used when you wish to give to the client some more information and context about the cause of the exception. They also couldn't be much easier to define in WCF, because they are no more, no less than another Contract in the service definition, which are semantically called Fault Contracts.

As such, you define a Fault Contract in your service definition in the following way:

/// <summary>

/// Strongly-typed fault.

/// </summary>

[DataContract]

public class ArgumentFault

    #region Get / Set

    /// <summary>

///

    /// </summary>

    [DataMember]

    public String Operation { get; set; }

    /// <summary>

///

    /// </summary>

    [DataMember]

    public String Argument { get; set; }

    /// <summary>

///

    /// </summary>

    [DataMember]

    public String Message { get; set; }

    #endregion

You then define that an operation can throw this type of fault contract by appending the following to your operation:

[FaultContract(typeof(ArgumentFault))]

[OperationContract]

Customer GetCustomer(Int32 customerId);

Now in the service implementation when you want to throw the defined fault contract you do like this:

public Customer GetCustomer(int customerId)

    if (customerId <= 0)

    { // Not possible

        throw new FaultException<ArgumentFault>(new ArgumentFault()

            Operation = MethodBase.GetCurrentMethod().Name,

            Argument = "customerId",

            Message = "Argument must be greater than zero."

});

    return Customers.First(customer =>

        return customer.Id == customerId;

});

This is better than just doing:

throw new FaultException(MethodBase.GetCurrentMethod().Name +

               ": customerId - Argument must be greater than zero.");

In the client application for catching this Fault Exception, you code should be:

try

{    // Get customer

    Customer singleCustomer = proxy.GetCustomer(customers[0].Id);

    Console.WriteLine("SingleCustomer: Id - {0} / Name - {1}.",

                singleCustomer.Id, singleCustomer.Name);

    // Force fault

    singleCustomer = proxy.GetCustomer(0);

catch (FaultException<ArgumentFault> ex)

    Console.WriteLine("FaultException<ArgumentFault>: {0} - {1} - {2}",

            ex.Detail.Operation, ex.Detail.Argument, ex.Detail.Message);

catch (FaultException ex)

    Console.WriteLine("FaultException: {0}", ex.Message);

Again the full code is available here:

Related List of articles

Developing a WCF Service

Developing a WCF Service - Calling the hosted service

2008-04-12T18:03:54Z

In the first part of this topic, I showed you how to develop a WCF service. In this next part I will show how to implement a client application that calls the exposed service methods, and how to make some enhancements to your service hosting.

Ok, so he already have built and deployed our service (either self-hosted, or in IIS for example), and by using a web browser we can see the service welcome page. Now, to call the service methods we must create a client proxy, and to do this we can use the Visual Studio Add Web Reference, which automatically creates the proxy, or we can use the command line svcutil to manually create the proxy. I prefer to do it manually because I like to control things like the generated proxy class namespace.

For example purposes, I created a Console Application that I called Tests.SampleService. There I created a batch file for calling the svcutil with my own parameters, with something similar to this:

svcutil %SERVICE_URL% /namespace:*,%NAMESPACE% /d:%OUT_DIR% /out:%OUT_FILE%

With the service running, I executed the batch file and svcutil generated two files:

output.config - Contains the WCF runtime configurations for calling the service (<system.serviceModel>)
Sample.Service.Proxy.cs - Contains the service proxy class, and any other classes exposed by the service

The contents of the output.config should be placed in the console application App.Config (if you prefer you can just rename the file).

In your console application main file you can place code like the following:

    static void Main(string[] args)

    {

       Console.WriteLine("Press any key to start");

       Console.ReadLine();

       // Build the service proxy object

       ServiceClient proxy = new ServiceClient();

       // Call service methods

       // Get total number of customers

       Int32 totalCustomers = proxy.GetTotalNumberOfCustomers();

       Console.WriteLine("Total Customers: {0}", totalCustomers);

       // Get list of customers

       List<Customer> customers = new List<Customer>(proxy.GetCustomers());

       foreach (Customer customer in customers)

       {

           Console.WriteLine("Customers");

           Console.WriteLine("Customer: Id - {0} / Name - {1}.", customer.Id, customer.Name);

       }

       // Get customer

       Customer singleCustomer = proxy.GetCustomer(customers[0].Id);

       Console.WriteLine("SingleCustomer: Id - {0} / Name - {1}.", singleCustomer.Id, singleCustomer.Name);

       Console.WriteLine("Press any key to exit");

       Console.ReadLine();

    }

You are know ready to start your service and use your client application to call the service methods.

Service Host Enhancements

Regarding the self service hosting there are some steps that you can do to make it more robust to errors and faults. Two of these changes are:

Subscribe the service host Faulted event
Subscribe the service host Unknown Message Received event

This should be done before opening our service hosting, and the new StartServiceHost method should look like this:

    /// <summary>

    /// Creates the service host

    /// </summary>

    private void StartServiceHost()

    {

        Logger.Info("StartServiceHost: Starting service hosting...");

        // Create service host

        _serviceHost = new ServiceHost(typeof(SampleService.Service));

        // Subscribe to the Faulted event of the service host

        _serviceHost.Faulted += new EventHandler(FaultHandler);

        // Subscribe to the Unknown message received event of the service host

        _serviceHost.UnknownMessageReceived += new EventHandler<UnknownMessageReceivedEventArgs>(UnknownMessageHandler);

        try

        { // Open service host

            _serviceHost.Open();

            Logger.Info("StartServiceHost: Service hosting success.");

        }

        catch (Exception ex)

        {

            Logger.Fatal("StartServiceHost: Could not start service hosting.", ex);

        }            

    }

The event handler's code can be:

    /// <summary>

    /// Fault error event handler

    /// </summary>

    private void FaultHandler(Object sender, EventArgs e)

    {

        // Examine the properties of the service host

        // Log reason for fault

        Logger.Error("FaultHandler: Host Fault occured. Aborting and restarting the hosting");

        // Abort the service (Could use Close, but a service in this state does not responde to requests, and Close takes more time)

        _serviceHost.Abort();

        // Re-start service host

        StartServiceHost();

    }

    /// <summary>

    /// Unknown message event handler

    /// </summary>

    private void UnknownMessageHandler(Object sender, UnknownMessageReceivedEventArgs e)

    {

        // Log the unknown message

        Logger.Warn("UnknownMessageHandler: Unknown Message Received");

    }

Take into attention that when the service host goes into a Faulted state, it stops servicing requests. This is why in the FaultHandler we abort the service host and open it again.

You can make a quick test of the event handlers by introducing in your web browser the following address: http://localhost:8080/SampleService/Service.svc.

This makes the service receive an unknown message and the corresponding event handler is called.

I leave here the complete Visual Studio solution.

Log4net Initialization/Configuration alternatives

2008-02-24T16:24:06Z

In a previous post where I talked about using log4net I used one of the alternative ways to initialize and configure the logging services.

This post will summarize these alternatives.

1. Programmatic initialization

The programmatic initialization should be done somewhere in your code.

This was the type of initialization used on the first post and its code is something like this.

using log4net;

using log4net.Config;

public class MyApp
{
    private static readonly ILog log = LogManager.GetLogger(typeof(MyApp));

    static void Main(string[] args)
    {
        // BasicConfigurator replaced with XmlConfigurator.
        XmlConfigurator.Configure(new System.IO.FileInfo(args[0]));

log.Info("Entering application.");

}

2. Assembly attribute initialization

The assembly attribute initialization does not imply the inclusion of any code in your application. Instead, you just have to place an assembly level attribute in some file of your assembly. This way your code could be:

using log4net;

[assembly: log4net.Config.XmlConfigurator()]

public class MyApp
{
    private static readonly ILog log = LogManager.GetLogger(typeof(MyApp));

    static void Main(string[] args)
    {
        log.Info("Entering application.");
    }
}

The assembly level attribute by itself does not mean a instruction to initialize the logging framework. Instead, the logging framework is initialized by the first call that is made to log4net (in the example the log.Info) initialized. This means that when using assembly attributes you should make a logging call as soon as possible and before calling any other external assembly.

Finally, if you are using logger objects defined per-class, a simple way to define a logger object that enables it to be copy-pasted in a very simple way is to do:

private static readonly ILog log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

This instruction uses reflection for determining the class type name that will be used in the logging messages.

For more information please refer to the log4net homepage.

SharePoint Associating a Workflow to a list

2007-12-10T10:07:00Z

Continuing from my last post, one thing that you also may want to do when programmatically creating a list is associating a workflow with a given configuration (e.g. Approval workflow when a new item is created in a document library).
In the SharePoint interface we can do this association very easily but if you want to do it using the object model there are a few steps that you should have into consideration.

First what we need to create is a SPWorkflowAssociation more specifically SPWorkflowAssociation.CreateListAssociation. For this we need to give information like:

Workflow template – Template to use for the workflow (e.g. Approval);
Workflow Title – Name of the workflow;
Workflow task list – Name of the workflow task list (should be based on the Tasks list template);
Workflow history list – Name of the workflow history list (should be based on the Workflow History list template).

After creating the SPWorkflowAssociation we can set general workflow parameters that are nothing more than configurations available in all workflow templates:

AllowManual – Allow manual start of the workflow;
AutoStartCreate – Auto start the workflow on item creation;
AutoStartChange – Auto start the workflow on item change;
AssociationData – Association data to be passed to the workflow instance.

The key parameter here is the AssociationData that contains workflow template specific configurations to be passed to the corresponding workflow instances. For example referring to the out-of-box Approval workflow, its association data is something like this (in XML because the Approval workflow uses an InfoPath form for its configuration page):

<my:myFields xml:lang="en-us" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                        xmlns:my="http://schemas.microsoft.com/office/infopath/2003/myXSD">

    <my:Reviewers>
        <my:Person>
            <my:DisplayName>Administrator</my:DisplayName>
            <my:AccountId>Administrator</my:AccountId>
            <my:AccountType>User</my:AccountType>
        </my:Person>
    </my:Reviewers>

    <my:CC></my:CC>
    <my:DueDate xsi:nil="true"></my:DueDate>
    <my:Description xsi:nil="true"></my:Description>
    <my:Title></my:Title>
    <my:DefaultTaskType>1</my:DefaultTaskType>
    <my:CreateTasksInSerial>true</my:CreateTasksInSerial>
    <my:AllowDelegation>false</my:AllowDelegation>
    <my:AllowChangeRequests>true</my:AllowChangeRequests>
    <my:StopOnAnyReject xsi:nil="true"></my:StopOnAnyReject>
    <my:WantedTasks xsi:nil="true"></my:WantedTasks>
    <my:SetMetadataOnSuccess>false</my:SetMetadataOnSuccess>
    <my:MetadataSuccessField></my:MetadataSuccessField>
    <my:MetadataSuccessValue></my:MetadataSuccessValue>
    <my:ApproveWhenComplete>false</my:ApproveWhenComplete>
    <my:TimePerTaskVal xsi:nil="true"></my:TimePerTaskVal>
    <my:TimePerTaskType xsi:nil="true"></my:TimePerTaskType>
    <my:Voting>false</my:Voting>
    <my:MetadataTriggerField></my:MetadataTriggerField>
    <my:MetadataTriggerValue></my:MetadataTriggerValue>
    <my:InitLock>true</my:InitLock>
    <my:MetadataStop>false</my:MetadataStop>
    <my:ItemChangeStop>false</my:ItemChangeStop>
    <my:GroupTasks>true</my:GroupTasks>
</my:myFields>

As you can see this association data contains the rest of the configuration parameters regarding the workflow template and in the case of the Approval workflow it contains something as important as the Approvers list (Reviewers).

With this you have all the information that is needed to correctly configure and associate an workflow to a list. Just don’t forget in the end to do something like SPList.AddWorkflowAssociation(SPWorkflowAssociation).

I leave you here an example method to accomplish what was described.

public SPWorkflowAssociation AddListWorkflowAssociation(SPWeb parentWeb, SPList parentList, String title, String workflowTemplateName, String workflowTaskListName, String workflowHistoryListName,Boolean workflowAllowManualStart, Boolean workflowAutoStartOnCreate, Boolean workflowAutoStartOnChange, String workflowAssociationData)
{
    // Search for workflow template in site
    foreach (SPWorkflowTemplate workflowTemplate in parentWeb.WorkflowTemplates)
    {
        if (workflowTemplate.Name == workflowTemplateName)
        { // Found

          // Check is task and history lists already exist
        SPList taskList;
        SPList historyList;
        try
        {
            taskList = parentWeb.Lists[workflowTaskListName];
        }
        catch (System.ArgumentException)
        { // Does not exist in site. Add
            taskList = SPHelper.AddList(parentWeb, workflowTaskListName, "Task list for workflow.", "Tasks", false);
        }

        try
        {
            historyList = parentWeb.Lists[workflowHistoryListName];
        }
        catch (System.ArgumentException)
        { // Does not exist in site. Add
        historyList = SPHelper.AddList(parentWeb, workflowHistoryListName, "History list for workflow.", "Workflow History", false);
        }

        // Create workflow list association
        SPWorkflowAssociation workflowAssociation = SPWorkflowAssociation.CreateListAssociation(workflowTemplate, title, taskList, historyList);

        // Set workflow parameters
        workflowAssociation.AllowManual = workflowAllowManualStart;
        workflowAssociation.AutoStartCreate = workflowAutoStartOnCreate;
        workflowAssociation.AutoStartChange = workflowAutoStartOnChange;
        workflowAssociation.AssociationData = workflowAssociationData;

        // Add workflow to list
        workflowAssociation = parentList.AddWorkflowAssociation(workflowAssociation);
        workflowAssociation.Enabled = true;

        // Return workflow object
        return workflowAssociation;
       }
    }

    // Error if reach here
    return null;

}

SharePoint 2007 basics – Add a Folder

2007-11-01T13:40:00Z

Folders can be added under a list or under another folder and the way of adding in each case is very similar. Below another example of sample functions.

public SPFolder AddFolder(SPList parentList, String title)
{
// Enable folder creation on the list
parentList.EnableFolderCreation = true;

    // Add folder
    SPListItem listItem = parentList.Folders.Add("", SPFileSystemObjectType.Folder);
    listItem["Name"] = title;

// Update
listItem.Update();

// Return
return listItem.Folder;
}

public SPFolder AddFolder(SPFolder folder, String title)
{
// Add
SPFolder newFolder = folder.SubFolders.Add(title);

// Return
return newFolder;
}

SharePoint 2007 basics – Add a List

2007-11-01T13:33:00Z

Adding a list is done very much in the same way as a web. You just have to pay attention to were you should get your list template from, because depending if it is a native or a custom list template the place where to get it is different (SPWeb.ListTemplates vs SPSite.GetCustomListTemplates). Of course that a list can only be added to a web.

So a function to add a list could be like the one below.

public SPList AddList(SPWeb parentWeb, String title, String description, String listTemplate, Boolean onQuickLaunch)
{
// Get list template object
SPListTemplate listTemplateSP = null;

    // Try out-of-box list templates first (Not be best way of doing this)
    try
    {
        listTemplateSP = parentWeb.ListTemplates[listTemplate];
    }
    catch (System.ArgumentException)
    { // Try custom site templates
        SPListTemplateCollection customListTemplateCollection = parentWeb.Site.GetCustomListTemplates(parentWeb);
        listTemplateSP = customListTemplateCollection[listTemplate];
    }

    if (listTemplateSP == null)
        // Could not found
        throw new Exception("AddList: Could not found list template");

// Ok. Add list
Guid newListGuid = parentWeb.Lists.Add(title, description, listTemplateSP);

    // Get new list
    SPList newList = parentWeb.Lists[newListGuid];
    newList.OnQuickLaunch = onQuickLaunch;

// Return
return newList;

}

SharePoint 2007 basics - Add a Web

2007-11-01T12:25:00Z

For my first SharePoint post I wanted to start by some of the basics related to working with the SharePoint Object Model. For sure there are other posts about this on the net, but I think that my blog should also reflect my SharePoint learning experience, and maybe by doing this I can show different ways accomplish similar things.

So let’s begin. How do you programmatically add Web’s, List’s and Folder’s to SharePoint?

Add a Web

To add a web I used the SPWebs.Webs property that returns a SPWebCollection where you can Add new Web’s. Of course that this means that you should add a web under another web (the parent web).

So to add a web you have to give parameters like the title, description, relative url name, locale id, template to be used, etc. See http://msdn2.microsoft.com/en-us/library/microsoft.sharepoint.spwebcollection.add.aspx .

With this other things that you have to think about are related with the web permissions and navigation nodes (Quick Launch and Top Link Bar’s).

I finish with a sample function that can be used as a starting point.

public SPWeb AddWeb(SPWeb parentWeb, String title, String description, String relativeUrlName, UInt32 localeId, String template, Boolean useUniquePermissions, Boolean addToTopNavigationBar, Boolean addToSitesQuickLaunch)
{
// Create
SPWeb newWeb = parentWeb.Webs.Add(relativeUrlName, title, description, localeId, template, useUniquePermissions, false);

// Default uses parent navigation
newWeb.Navigation.UseShared = true;

    // Test links to add
    SPNavigationNode navigationNodeToAdd = new SPNavigationNode(title, relativeUrlName, false);
    if (addToTopNavigationBar == true)
    { // Add
        parentWeb.Navigation.TopNavigationBar.AddAsLast(navigationNodeToAdd);
    }
    if (addToSitesQuickLaunch == true)
    { // Add to Quick launch sites section
        foreach (SPNavigationNode navigationNode in parentWeb.Navigation.QuickLaunch)
        { // Search sites
            if (navigationNode.Title == "Sites")
            { // Add here
                navigationNode.Children.AddAsLast(navigationNodeToAdd);
                // Stop searching
                break;
            }
        }
    }
    return newWeb;
}

By the way, the last part to add the navigation node to the Quick Launch Sites section is just an example that may not work if you are using sites in languages other than English.

Debugging Windows Services

2007-08-26T17:36:00Z

Recently I had to develop my first Windows Service in C#. I had already done Services in C++, and I was used to launch and debug the Services thru Visual Studio (just by normally hitting F5).

I was surprised to see that the normal C# Windows Service code base does not allow this to be possible in a "out-of-the-box" experience, and one had to do things like "Attach to Process", and/or put in the source code "System.Diagnostics.Debugger.Launch();".

Not satisfied with these solutions, I searched the web and I found this page that as a "perfect solution".

http://theimes.com/archive/2006/12/28/Debugging-Windows-Services-is-a-Pain.aspx

The author developed a Service Debugger Helper class, that incorporates a GUI for allowing all the expected Start, Stop, etc, interaction with the service. It is also possible to automatically start a service by default, thus allowing the normal F5 experience.

Check out the author article and his source code if you are interested in knowing how he made this. Also this other link could be of interest to someone.

Run a Service without a debugger attached (.NET Windows Service Runner)

http://theimes.com/archive/2007/08/22/net-windows-service-runner.aspx

PS: Regarding the usage of Timers in Windows Services, be careful to use the ones in System.Timers.Timer, or else the timer may never (or stop) be (being) fired.

Using log4net logging services

2007-07-29T15:22:00Z

Whenever you have the need for debugging some application that by whatever reason cannot be properly debugged in Visual Studio, or even because your application requires some kind of logging/auditing functionality, instead of developing your own tool you have the option to use some existent logging frameworks.

One that I have tried and enjoyed its features and ease of use is log4net - http://logging.apache.org/log4net/.

Like they say on their webpage, "log4net is a tool to help the programmer output log statements to a variety of output targets. log4net is a port of the excellent log4j framework to the .NET runtime". Its features are present here: http://logging.apache.org/log4net/release/features.html.

One of its great features is the ability to control and configure the logging framework entirely by an XML file. This allows the building and deployment of applications that at run-time can dynamically change its logging configuration. For this you should initialize to log in the following manner (in the example the XML configuration file is received in the application arguments):

// Import log4net classes.
using log4net;
using log4net.Config;

public class MyApp
{
    private static readonly ILog log = LogManager.GetLogger(typeof(MyApp));

    static void Main(string[] args)
    {
        // BasicConfigurator replaced with XmlConfigurator.
        XmlConfigurator.Configure(new System.IO.FileInfo(args[0]));
    }
}

After this, you can check if the initialization went ok by testing the value of: _log.Logger.Repository.Configured .

Now it is real easy to start logging things. You just have to do:

log.Info("Entering application.");
log.Debug("Entering application.");

and the framework takes care of the rest, logging acording to the configuration that you provided. Note that in the above code I am already logging into two different log levels, just as an example for showing you, that while developing I can have the level configured at DEBUG, and at production I can reduce the level to INFO, or even NONE, if I dont want any logging at all. If a problem occurs in production, I can just as easily change the log level to DEBUG again, and without having to change anything in the application, the logs start being generated.

As a final example of the capabilities of the framework, I just want to show here a possible XML configuration file:

<?xml version="1.0" encoding="utf-8" ?>
<log4net>
    
    <appender name="RollingFileAppender" type="log4net.Appender.RollingFileAppender">
        <file value="log-file.txt" />
        <appendToFile value="true" />
        <maximumFileSize value="1KB" />
        <maxSizeRollBackups value="0" />
        <staticLogFileName value="true" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger - %message%newline" />
        </layout>
    </appender>

    
    <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender">
        <target value="Console.Error" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%message%newline" />
        </layout>
    </appender>

    <root>
        <level value="DEBUG" />
        <appender-ref ref="RollingFileAppender" />
        <appender-ref ref="ConsoleAppender" />
    </root>
</log4net>

In this configuration, I define two different appenders (RollingFile and Console), each with its own configuration. At the root level, I define the logging level at DEBUG (so I want to see everything until this level), and that the logging should be done to the two defined appenders. So, when I log something with this configuration, the log is done to a file and to the application's console.

So, you see that it is easy to add logging capabilities to your application.