Melyssa’s Blog

If you're working with CAML, it's good to have available a list of fields, their internal field names, and their data types. I wrote a simple Web part that accepts the display name of a list and returns this information, along with whether or not each field is required or indexed. The code for the Web part can be found below, and can easily be tweaked to include other field data. I went ahead and retrieved the field data for many common lists in SharePoint as a reference, and have included those results in the attached SharePoint Lists Field Data document.

    public class GetListFieldInfo : System.Web.UI.WebControls.WebParts.WebPart
    {
        private const string default_listname = "Documents";
        private string listname;
       
        [Personalizable(PersonalizationScope.Shared), WebBrowsable(true), WebDisplayName("List Name"), WebDescription("Enter the display name of the list.")]
        public string ListName
        {
            get { return listname; }
            set { listname = value; }
        }
       
        public GetListFieldInfo()
        {
            this.ExportMode = WebPartExportMode.All;
            listname = default_listname;
        }

        protected override void CreateChildControls()
        {
            base.CreateChildControls();
        }

        protected override void RenderContents(HtmlTextWriter writer)
        {
            SPWeb web = SPContext.Current.Web;
            if (web != null)
            {
                try
                {
                    SPList list = web.Lists[ListName];
                    if (list != null)
                    {
                        writer.Write("<h2>" + list.Title + "</h2>");
                        writer.Write("<p><strong>Location: </strong>" + list.DefaultViewUrl + "</p>");
                        writer.Write("<table border=\"0\" cellspacing=\"2\" cellpadding=\"2\" style=\"width: 100%;\">");
                        writer.Write("<tr><td><strong>FIELD NAME</strong></td><td><strong>INTERNAL FIELD NAME</strong></td><td><strong>DATA TYPE</strong></td><td><strong>IS REQUIRED</strong></td><td><strong>IS INDEXED</strong></td></tr>");
                        SPFieldCollection fc = list.Fields;
                        foreach (SPField field in fc)
                        {
                            writer.Write("<tr><td>" + field.Title + "</td><td>" + field.InternalName + "</td><td>" + field.TypeAsString + "</td><td>" + field.Required + "</td><td>" + field.Indexed + "</td></tr>");
                        }
                        writer.Write("</table>");
                    }
                }
                catch (Exception x)
                {
                    writer.Write("Error retrieving list information: " + x.Message);
                }
            }
        }
    }

The 2008 Professional Developers Conference introduced several new features that can be expected with the release of Windows 7, one of which is the new support for writing language-aware applications. The presenters of one session pointed out why globalization really matters: over 90% of the world population does not speak English at all, and only 5.1% of the remaining percentage speaks it natively. If a developer provides an application only in English, then the developer is neglecting a vast majority of the population and severely limiting the usage of his or her application.

In the past, it has been cumbersome to say the least to provide support for multiple languages. Developers have had to guess the current language by looking at local settings, or in the case of Web applications, HTTP header information, which could very often provide inaccurate results. Windows 7 will change all of this with a set of APIs, called Extended Linguistic Services, which will initially provide the following features:

·         Language detection: detect the language of a user’s text.

·         Script detection: detect the writing system, or alphabet, of a user’s text (some languages have multiple alphabets).

·         Transliteration: convert text from one writing system to another; i.e., Chinese Simplified to Chinese Traditional.

·         Support for 100+ languages.

·         Support for mixed languages (many users prefer to perform one set of tasks in one language, and another set of tasks in another language).

To access the services, a developer will:

1.       Call enumeration to get the list of available services (i.e., MappingGetServices()).

2.       Pass the text to the selected service (i.e., MappingRecognizeText()).

3.       Do something with the results that are returned by the service based on what it discovered (i.e., text not recognized, text recognized and it is Japanese, text recognized as Chinese Simplified and can be transliterated to Chinese Traditional).

Developers can expect to follow the same general procedure for accessing new services that are added in the future. One of the Windows 7 team’s main goals in providing this set of APIs is to make the experience intuitive and easy to learn, and to not force developers to learn something new each time another service is released, which I’m sure we can all appreciate.

To watch the session, visit Channel 9 on MSDN, Windows 7: Writing World-Ready Applications.

1. Themes. Windows 7 has approached personalization of desktops from a different angle. Users have more control over the look and feel of their desktop with the use of Themes. The control panel for the Themes screen displays available themes in a graphical list, organized by user-created themes, online themes, and built-in system themes. Unique themes can be created by a user and even shared with others. It is very easy to create your own theme – just select one of the existing themes, then change either the desktop background, Windows color, sounds, or screen saver and save the theme as your own.
   
   


2. Snipping Tool. How many times have you needed to take a screen shot of something, only to have to also open that screen shot in some sort of image editing software, clip it accordingly, mark it up with comments, then save the image so that you can email it or include it in a document? If you’re like me, then the answer is more times than you care to think about. Now with the new Snipping Tool in Windows 7, this process has been greatly simplified. With the Snipping Tool, you can select what sort of “snip” you would like to take (free-form, rectangular, window, or full-screen). Once an area is selected, the snip automatically opens in a Snipping Tool window with a few handy tools, including save, copy, email, write, highlight, and erase. When you finish marking up the image, you can click the copy button and paste a flattened version into a document. Or, you may choose to email the image as an attachment. One feature I would add is the ability to type comments, but overall the Snipping Tool is very efficient and much appreciated.
   
   


3. Device Management. No longer do you have to manage your devices from multiple locations. With Windows 7, from one convenient location (Start > Devices and Printers), you can view all of your connected devices, update drivers, connect to new devices, and perform other tasks specific to a particular device with a right-click. In addition, when you plug in a new device to your computer, a new icon will appear in your Task Bar with a screen that provides you with device information and convenient links to common device tasks. This “Device Stage” can be customized by manufacturers to display relevant information about the device, images, and just about anything else they deem helpful to the user.
   
   

If you would like to develop applications that access new Windows 7 features, you will want to download the Windows API Code Pack for Microsoft .NET Framework 3.5. With this code pack (version 0.85, as of this post), you will find support for the following features:

• Common file dialogs
• Direct3D 11.0 and DXGI 1.0/1.1 APIs
• Explorer Browser Control
• Extended Linguistic Services APIs
• Icon Overlay
• Progress Bar
• Sensor Platform APIs
• Shell property system
• Task Dialogs
• Taskbar Jumplists
• Windows Shell namespace objects, Known Folders and non file system containers

Several of my favorite features include the support available for the Taskbar. One such feature is Icon Overlay, which allows developers to add status indicators to the icons in the Taskbar and provide subtle feedback to a user. For instance, it may be appropriate to indicate the current state of an application that is running in the background, but not necessarily viewable in an open window on the user’s desktop. This can be accomplished by adding an image to the application’s icon in the Taskbar as particular events occur within the application. Indicators can also be overlaid while a user interacts directly with the application and can be used to provide another means of communication to the user.

Additionally, the ability to add tasks to Jumplists that are accessible via the Taskbar gives developers the option to provide convenient links to various actions related to the application, all with the right-click of a mouse. As an example, if a function of an application requires the user to frequently upload images for processing, then the developer can provide a quick link that is configured to open the user’s images folder, upload and process a selected image with just one click. The potential for this type of functionality is limitless, and is one of many exciting additions to the Windows 7 development environment through the Windows API Code Pack.

To download the Windows API Code Pack, please check out the MSDN Code Gallery (http://code.msdn.microsoft.com/WindowsAPICodePack).

I recently watched a session taken from the Professional Developers Conference 2008 in which they describe the various ways developers can integrate touch into their applications. One of the great things about Windows 7 is the out-of-the-box support it provides for legacy applications that do not include explicit support for touch gestures. For instance, applications running on Windows 7 will automatically receive support for pan, zoom, and right-click gestures, as well as controls with standard scrollbars.

With minimal effort, a developer can include additional features in their applications by taking advantage of the API, such as gesture notifications and events for pan, zoom, and rotate, inertia configuration, and P/Invoke. As an example, you can pass the parameters that you receive from the notification into the WM_GESTURECOMMAND API, and it hands you back a gesture info struct. The struct includes information on the specific command received (was it a zoom, pan, or something else?), arguments that are specific to the type of gesture command (if it was a zoom, how far did the user zoom?), and the location over which the gesture was centered.

And to take it one step further, a developer can build an application with touch in mind from the ground-up, and in so doing, take advantage of features such as raw touch data, manipulation and inertia processors, touch events, and real-time stylus or ink collector classes. Mobile, desktop, and Web applications that incorporate advanced touch features will provide a richer user experience that will set them apart from those applications that do not.

If you want to learn more about developing multi-touch applications for Windows 7, then a great place to start is by watching the Windows 7: Developing Multi-touch Applications session from PDC2008 (http://channel9.msdn.com/pdc2008/PC03/).

Suppose that, during the deletion of an item in List A, you want to first check to see if some condition holds true in List B, and if so, perform some action on List B before actually deleting the item in List A. Normally, workflows created in SharePoint Designer would come in very handy here, but unfortunately, you cannot attach a workflow to the deletion of an item in SharePoint. So, we are stuck with creating our own in Visual Studio and attaching it to the list as a feature.

Now, what I wanted to do seemed straight-forward enough. But, I ran into a lot of the very informational ‘object reference not set to an instance of an object’ errors during the process. Frustrated, I stepped through each line, and finally discovered the culprit. And I was surprised, because the code I was using showed up in several places in other blogs, not to mention on MSDN, so I’m still a little curious as to why it was not working for me. But alas, I must move on and so I found another solution which worked like a charm.

First, the piece of code that my event handler did not seem to like was:

SPContext.Current.Site, SPContext.Current.Web, really anything referencing SPContext.

Essentially, I replaced these occurrences with:

properties.ListItem.ParentList.ParentWeb.Site, properties.ListItem.ParentList.ParentWeb, and so on.

Additionally, I learned that you cannot use SPSecurity.RunWithElevatedPriviliges(delegate() { … }); in event handlers. The replacement I found for this is:

Guid siteId = properties.ListItem.ParentList.ParentWeb.Site.ID;
SPUserToken systemAccountToken = properties.ListItem.ParentList.ParentWeb.Site.System.Account.UserToken;
using (SPSite site = new SPSite(siteId, systemAccountToken) { … }

Below is a watered down version of my code, but it should be functionally complete:

public class DeleteHandler : SPItemEventReceiver
{
  public override void ItemDeleting(SPItemEventProperties properties)
  {
   try
        {
            string error = “”;
            SPListItem item = properties.ListItem;
            int rid = Convert.ToInt32(item["ID"]);

            // just to be on the safe side, let’s make sure we have the right list
            if (item.ParentList.Title.Equals(”List Name Here”))
            {
               string[] authorInfo = item["Author"].ToString().Split(’#');
               if (authorInfo.Length == 2)
               {
                    string creator = authorInfo[1].ToString();

                    // let’s make sure that the current user it the actual creator of the list item
                    if (creator.Equals(properties.UserDisplayName.ToString()))
                    {
                       // delete from Calendar
                       error = DeleteFromCalendar(properties, rid);

                       // if there was a problem with the delete, view the error
                       // and cancel the whole deletion process.
                       if (error.Length > 0)
                       {
                          properties.Cancel = true;
                          properties.ErrorMessage = error;
                       }
                   }
                   else
                   {
                       properties.Cancel = true;
                       properties.ErrorMessage = “You cannot delete another user's post.”;
                   }
                }
           }
           else
           {
                // allow deletion of item
                properties.Cancel = false;
           }
      }
      catch (Exception x)
      {
            properties.Cancel = true;
            properties.ErrorMessage = “Unable to delete post: ” + x.Message.ToString();
      }
  }

                       //build the query
                       query.Query = “<Where><Eq><FieldRef Name=’Description’/><Value Type=’Note’>” + rid.ToString() + “</Value></Eq></Where>”;

                       SPListItemCollection items = list.GetItems(query);
                       int count = items.Count;
                       for (int i = 0; i < count; i++)
                              tems.Delete(i);
                  }
             }
         }
         catch (Exception x)
         {
              error = ” Delete from calendar: ” + x.Message.ToString();
         }

         return error;
     }
}

After a new installation or an upgrade on a MOSS server, you may start receiving a million DCOM errors in your System event logs. Thankfully, these are very easy to clean out. The error will look something like this:

The application-specific permission settings do not grant Local Activation permission for the COM Server application with CLSID {<GUID>} to the user <server>\<service account> SID (S-1-5-21-<service account ID>).  This security permission can be modified using the Component Services administrative tool.

For more information, see Help and Support Center at http://go.microsoft.com/fwlink/events.asp.

1. Highlight and copy the GUID in the error description.
2. Start > Run > regedit
3. Click on the root node: My Computer
4. Edit > Find… and paste the GUID into the textbox. Click Find Next.
5. The right-hand pane should populate with the service information. Make note of the name in the Data field.
6. Start > Administrative Tools > Component Services.
7. Expand Component Services > Computers > My Computer > DCOM Config.
8. Scroll down until you find the service name. Right click > Properties.
9. On the Security tab, under Launch and Activation Permissions, make sure Customize is selected.
10. Click the Edit button.
11. Add the service account that was mentioned in the error description and give it Local Launch and Local Activation. (Some instances may need the remote launch/activation permissions as well.)
12. Apply the changes and do an IISRESET.

1.  Open Visual Studio 2005 and create a new Web Part project.

2.  Add the following two using statements to the .cs file:

using System.ComponentModel;

using System.Net;

3.  Add the following using statement to the AssemblyInfo.cs file:

using System.Security;

4.  Add the following line at the end of the AssemblyInfo.cs file:

[assembly: AllowPartiallyTrustedCallers()]

5.  Your Web Part should include a pre-assigned Guid.  Add the ToolboxData and XmlRoot Namespace after the Guid and remember to replace ‘YourClassName’ where appropriate, like so:

[Guid("3854adbc-d5ac-47bd-885a-af46cc0f35d5"),

  ToolboxData("<{0}:YourClassName runat=server></{0}:YourClassName>"),

   XmlRoot(Namespace = "YourClassName")]

6.  Your Web Part class should be inheriting from the System.Web.UI.WebControls.WebParts.WebPart class.

7.  Add your code to the Render method, et al.

8.  In Solution Explorer, rename the folder that is automatically created and named YourClassName to Solution and move the .cs file up one out of the Solution folder.

9.  Add a manifest.xml file to the solution folder and place the following inside (remember to replace the instances of solution and class names, the solution id, and public key token with your own):

<Solution xmlns=”http://schemas.microsoft.com/sharepoint/” SolutionId=”ef5784a3-4970-459c-9397-57a95496f002“>

            <Assemblies>

                        <Assembly Location=”YourSolutionName.dll” DeploymentTarget=”WebApplication“>

                                    <SafeControls>

                                                <SafeControl                                                   Assembly=”YourSolutionName, Version=1.0.0.0, Culture=neutral, PublicKeyToken=9f4da00116c38ec5” Namespace=”YourNamespace” TypeName=”*” Safe=”True” />

                                    </SafeControls>

                        </Assembly>

            </Assemblies>

            <DwpFiles>

                        <DwpFile Location=”YourClassName.webpart“/>

            </DwpFiles>

            <CodeAccessSecurity>

                        <PolicyItem>

                                    <PermissionSet class=”NamedPermissionSet” version=”1” Description=”Permission set for YourNamespace“>

                                                <IPermission class=”AspNetHostingPermission” version=”1” Level=”Minimal” />

                                                <IPermission class=”SecurityPermission” version=”1” Flags=”Execution” />

                                                <IPermission class=”Microsoft.SharePoint.Security.SharePointPermission, Microsoft.SharePoint.Security, version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c” version=”1” ObjectModel=”True” />

                                    </PermissionSet>

                                    <Assemblies>

                                                <Assembly Name=”YourSolutionName“/>

                                    </Assemblies>

                        </PolicyItem>

            </CodeAccessSecurity>

</Solution>

10.Right-click on your project file and open the properties. Click on the SharePoint Solution tab to get your solution id. Copy and paste the solution id into the manifest.xml file, top line, SolutionId attribute.

11.Add another .xml file called YourClassName.webpart to your Solution folder (be sure to change the .xml extension to .webpart), and place the following inside:

<webParts>

            <webPart xmlns=”http://schemas.microsoft.com/WebPart/v3“>

                        <metaData>

                                    <type name=”YourNamespace.YourClassName,

                                                YourSolutionName,

                                                Version=1.0.0.0,

                                                Culture=neutral,

                                                PublicKeyToken=9f4da00116c38ec5” />

                                    <importErrorMessage>

                                                YourSolutionName Cannot import YourWebPartName Web Part.

                                    </importErrorMessage>

                        </metaData>

                        <data>

                                    <properties>

                                                <property name=”Title” type=”string“>A title for your Web Part</property>

                                                <property name=”Description” type=”string“>A description for your Web Part</property>

                                                <property name=”AllowClose” type=”bool“>FALSE</property>

                                    </properties>

                        </data>

            </webPart>

</webParts>

12.Add a text file called WSP.ddf to your Solution folder (be sure to change the .txt extension to .ddf), and place the following inside:

.Set CabinetNameTemplate=YourSolutionName.wsp ;Specifies the name of the output file
.Set DiskDirectoryTemplate=CDROM ;Indicates that all of the CAB goes into a single directory
.Set CompressionType=MSZIP ;Indicates that all of the files will be compressed into CAB files
.Set UniqueFiles=”ON” ;Indicates that all of the files referenced must be unique
.Set Cabinet=On ;Use cabinet files
.Set DiskDirectory1=. ;Use the current directory for the output CAB file

“C:\…Your Path…\Solution\manifest.xml”
“C:\ …Your Path…\bin\release\YourClassName.dll”
“C:\…Your Path…\Solution\YourClassName.webpart”

13.Compile the solution.

14.Create the cab file: From the directory in which you want the cab file saved, run the following command:

makecab /f “C:\…path to .ddf file…\WSP.ddf”

15.Open a command prompt from the server on which the Web Part is to be installed and change directory to the 12 hive bin directory:

cd “C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\BIN\”

16.Run the following commands:

stsadm –o addsolution –filename “C:\…path to your file…\YourSolutionName.wsp”

 

stsadm –o deploysolution –name YourSolutionName.wsp –url [http://YourServerName OR –allcontenturls] –immediate –allowcaspolicies –force 

17.Your .dll should be in the bin directory of the Web App you specified in the deploysolution command (or in all bin directories of all Web Apps if you used the –allcontenturls switch). It should NOT be in the GAC.

18.Visit the Solution Management page in Central Admin under the Operations tab. Your solution should be listed with a status of Deployed.

19.Visit one of your Front-end Web Servers to which the solution was deployed. Edit a page and click to add a Web Part to the page. Scroll down to the Miscellaneous category and you should fine your Web Part there.

There are several posts on this out there already, but I thought I’d add mine as well, just to have it down. If you have ForeFront managing your virus scanning for your SharePoint environment, then you may at some point receive some close resemblance of the following error when you navigate to your site:

Exception from HRESULT: 0×80041050

(I’ve also seen this error ending in a 4).

#1: This is a known bug with ForeFront mistakenly flagging SharePoint pages as a virus, and Microsoft does have a hotfix for this issue (see KB943221; however in my case, the issue resurfaced several months after applying the hotfix).

#2: To quickly get your site back up, (then worry about applying the hotfix), run the following query on each content database:

select * from AllDocs where (VirusStatus > 0) and (VirusStatus is not null)

 If anything is returned, AND you are sure these files do not in fact contain a virus, then run the following query:

update AllDocs set VirusStatus = null where (VirusStatus > 0) and (VirusStatus is not null)

Your site should be back up in a jiffy. Also note that you will likely not find any events logged in ForeFront regarding these virus flags.

1. Start a new Web Site in Visual Studio.

2. Add a new user control page to the project - you may either include the code inline or as code-behind.

3. Create the user control and place all code between the script tags on the page (inline) or in the code-behind file.

4. For inline code, references to other assemblies should be placed outside the script tags and take the format:

• <%@ Import Namespace=”System” %>

5. Custom assemblies (class libraries, etc.) should be placed in the bin directory of the Web application hosting the user control.

6. Save/compile the .ascx file (and .cs file if code-behind), then copy and paste it/them into the following location: C:/Program Files/Common Files/Microsoft Shared/web server extensions/12/TEMPLATE/CONTROLTEMPLATES/

7. Create a new folder in the features directory and give it the same name as your user control: C:/Program Files/Common Files/Microsoft Shared/web server extensions/12/TEMPLATE/FEATURES/

8. Create two new files inside this new folder. Name one feature.xml and the other elements.xml.

9. Open feature.xml for editing. Add the following xml to the file (replace the red bold text with the user control information):

• <?xml version=”1.0″ encoding=”utf-8″ ?>
  <Feature Id=”5DD8CC0A-0EF5-4c14-8052-573E14021D7A”
    Title=”User Control Title”
    Description=”User control description.”
    Version=”1.0.0.0″
    Scope=”WebApplication“  xmlns=”http://schemas.microsoft.com/sharepoint/“>
    <ElementManifests>
      <ElementManifest Location=”elements.xml” />
    </ElementManifests>
  </Feature>

10. Open elements.xml for editing. Add the following xml to the file (replace the red bold text with the user control information):

• <?xml version=”1.0″ encoding=”utf-8″ ?>
  <Elements xmlns=”http://schemas.microsoft.com/sharepoint/“>
    <Control
      Id=”aUniqueId”
      Sequence=”100″ ControlSrc=”~/_controltemplates/Filename.ascx”>
    </Control>
  </Elements>

11. Install the feature. Run the following command from the console (you must be in the “C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\BIN\” directory first; replace the red bold text with the user control information):

• stsadm -o installfeature -filename FolderName\feature.xml

12. Activate the feature. Run the following command from the console (you must be in the “C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\BIN\” directory first; replace the red bold text with the user control and scope information):

• stsadm -o activatefeature -filename FolderName\feature.xml -url http://servername

13. Start SharePoint Designer. Open your Web site and the page on which you want to add the user control.

14. Add the following line of code to the PlaceHolderMain content place holder (replace the red bold text with the user control information):

• <SharePoint:DelegateControl runat=”server” ControlId=”theUniqueId“></SharePoint:DelegateControl>

15. Save the file and open in browser.