Posts Tagged ‘Visual Studio’

Visual Studio 2013 March 2014 Update has been released

March 3rd, 2014 by Tobias Zimmergren

Today, Microsoft announced the release of Visual Studio 2013 March 2013 Update which have additional features, project types and support for some of the enhancements that comes with Office 2013 SP1 and Office 365. So if you’re a developer targeting Office 365, Office 2013 or SharePoint Server 2013 it may be a good idea to go grab the update and install it now.

SAP Data Source in your Cloud Business Application

image

As quoted from the Visual Studio blog:

The March 2014 Update also offers first class support for SAP Netweaver Gateway. When connecting CBA to SAP, it honors SAP annotations for Phone, WebAddress, and Email; speeding up your configuration of entities consumed from SAP Netweaver Gateway.

While this may seem like a trivial update, I know this is a popular requirement from a lot of my clients. I don’t think this is the last data source type we’ll see in the list of available types, which is ever growing:

image

Integrating new document features in your Cloud Business Applications

One of the cool features, which I lacked in one of my CBA projects in the past, is the integration of native controls for managing documents in a library that your CBA is connected to. With the latest update, you get the ability to create new documents in your library from the CBA interface.

When you attach your application to a SharePoint host-web document library, the application will be integrated with a set of new document controls, which allows your users to create new Office documents (either blank documents or from document templates that are available in the attached document library), open documents in Office Web App or Office client, and upload existing documents. All of these are provided by the tools without requiring any extra coding from you.

image
Picture from blogs.msdn.com, as per the article mentioned in the introduction.

To add such a control and work with these types of controls, you simply have a new option here in the CBA Screen design interface:

image

Apps for Office Development enhancements

Some of the additions to the Office App development toolset are mentioned:

Office 2013 SP1 and Office 365 supports PowerPoint content apps, Access Web App content apps and allows your mail app to be activated in compose forms (i.e. when users are writing a new email message or creating a new appointment). Office Developer Tools for Visual Studio 2013 – March 2014 Update supports all of these new app types across the development cycle from project creation, manifest editing, programming, debugging to publish.

Apps for SharePoint Development enhancements

There’s some additions to the experiences for developers when creating SharePoint Apps.

With the latest release of the tools, we now can switch the App project to target Office 365 or target an on-premises installation of SharePoint. It’s a new property in the SharePoint project settings dialog:

image

The app for SharePoint tooling now allows you to target your app exclusively to SharePoint Online in Office 365, or target to an on-prem SharePoint Server 2013 (which can also run in SharePoint Online). Through a simple switch in the app for SharePoint project properties page, the tools will update the SharePoint version number and the SharePoint Client Components assembly references used in your project accordingly.

Another pretty neat thing is the support for MVP in client web parts:

To enhance the support with ASP.NET MVC web applications, we added MVC support for client web part pages in this update. If your app for SharePoint project is associated with an ASP.NET MVC application, when you add a client web part and choose to create a new part page in the client web part creation wizard, a client web part controller and a default view will be added, following the MVC pattern.

Wrap up

I’ve been trying these things out really quick now, and I must say the small but constant flow of enhancements and additions with the new update cadence for all Microsoft products is pretty impressive. Visual Studio 2013 hasn’t been around for that long, but we’re still seeing new updates being published frequently. It is easier than ever to keep up with new development techniques and tools, and no need for exhausting waiting periods.

Read the full story on MSDN Blogs: Announcing Office Developer Tools for Visual Studio 2013 – March 2014 Update

Author: Tobias Zimmergren
http://www.zimmergren.net | http://www.tozit.com | @zimmergren

Introduction

A while back an announcement was made that TFSPreview.com had been made available for general testing. Various bloggers at Microsoft put an invitation token in their MSDN blogs so everyone can have a go at it.

In this article series we’ll take a very quick look at what the hosted TFS solution by Microsoft looks like.

Articles currently in the series:


Connect Visual Studio 2010 to your new hosted team project

In order to be able to connect to the hosted TFSPreview team project, you’ll need to comply with the prerequisites I’m listing here.

Prerequisites

Hook up Visual Studio to your new repository/project

Alright, if you’ve downloaded and installed KB2581206 (which means you’re spinning VS2010 SP1 already) you are read to connect. The procedure to connect to the hosted TFS service is basically the same as if you were to connect to any other TFS repository, which is easy and awesome.

In Visual Studio 2010 SP1, simply make these smooth ninja moves and you’re done:
image

Make sure to fetch the URL of your account (As seen in your dashboard, like depicted below):
image

Enter this URL in the Visual Studio 2010 dialogs and we’re ready to kick off:
image

It’ll ask you for your credentials which you need to use to verify your account details:
image

You should now be authenticated and your repository should be available:
image

You’ll go ahead as you normally do and choose the projects that interests you and then you’re basically done:
image

Your Team Explorer should contain your TFS project and you should be able to work with it as you normally would from Visual Studio 2010:
image

This means you’ve got all of your standard tasks and operations available straight from VS 2010 (So you don’t have to go to the website to make changes …):
image

Summary

Easy enough. As soon as you’ve downloaded the required tooling to get connected, you can hook up your new cloud-hosted team project in Visual Studio 2010 without any problems. Give it a spin, it flows quite nicely!

Enjoy.

CKS : Developer Tools – A tool for your toolbox

August 11th, 2010 by Tobias Zimmergren

Author: Tobias Zimmergren
http://www.zimmergren.net | http://www.tozit.com | @zimmergren

Introduction

If you’re a seasoned SharePoint developer, you probably have a good set of tools that you’re working with on a daily basis. Some of my all-time favorites include:

With the addition of new tools to the community basically every week, it could be hard to keep track of all the different extra applications you’d want to use.

CKS:Dev has been released!

If you’ve heard of CKS before (Community Kit for SharePoint), you might know that there’s great support for Blogs (EBE) and other cool things. Actually, this blog is based on the CKS:EBE code. Works like a charm!

Now, if you’ve missed it – there’s a new addition to the CKS-family called the CKS: Developer Tools which is essentially extending the functionality in Visual Studio 2010.

There’s currently two versions released. One for SharePoint Foundation 2010 and one for SharePoint Server 2010.

You can find them here:

What’s in it for me (the developer)?

There’s some really superb additions to Visual Studio 2010 when installing the aforementioned versions of the CKS:Dev project. These include some of my favorites:

  • SharePoint Tab in the References dialog (no need to goof around the filesystem to find the dll’s)
  • Extended SharePoint Explorer
    • See more libraries
    • Activate/Deactivate features directly from the explorer
    • Enable/Disable the Developer Dashboard (yay!)
    • Generate Entity Classes (finally!)
    • <a lot more, but those were my favorites>
  • A bunch of new cool project templates, including some of these jolly good jewels:
    • Basic page
    • Delegate control
    • Master page
    • Custom Action, Custom Action Group, Hide Custom Action (good stuff)
    • Sandbox Full Trust Proxy
    • <the list continues..>
  • Quick Deployment steps
    • Easily deploy your code and files quickly with the WSPBuilder-alike commands like:
      • “Copy to SharePointRoot”
      • “Copy to Bin”
      • “Copy to GAC”
      • “Recycle App Pools”
      • “Attach to worker process”
      • and so on.

Aside from the aforementioned awesomeness, there’s a whole lot of other stuff that I bet I’ve missed out on with this tool. I’d say go and find out yourself if you haven’t already – you  will not want to work without this in your toolset ever again, of that you can be sure!

Summary

The reason for posting some info and selling-points behind the (free) developer tools from the CKS team are foremost that when I’m doing training or when I’m supporting clients in different projects, they always asks me what tools they should have in their toolbox.

I’m surprised that not even 20% of them knows about the CKS:Dev extensions. So with this post I’m hoping to enlighten some of those folks.

Enjoy!

Visual Studio 2010 SharePoint Power Tools – Released

June 18th, 2010 by Tobias Zimmergren

Author: Tobias Zimmergren
http://www.zimmergren.net | http://www.tozit.com | @zimmergren

Introduction

Our good friend Mike Morton over at Microsoft just announced the official release of some great extensions to Visual Studio 2010, called SharePoint Power Tools.

These tools will extend Visual Studio 2010 to give your these additional features:

  • Sandboxed Visual Web Part
  • Compile-time warnings on Sandboxed solutions when trying to use disallowed code

Download

http://visualstudiogallery.msdn.microsoft.com/en-us/8e602a8c-6714-4549-9e95-f3700344b0d9

WSPBuilder supports Windows Server 2008

April 18th, 2009 by Tobias Zimmergren

My pal Carsten Keutmann has done some updates with his marvelous tool WSPBuilder to make it support Windows Server 2008 as well.

All my development-machines are running Server 2008 along with Visual Studio 2008 and of course – the latest release of WSPBuilder.

You can download the latest release of WSPBuilder from here

WSPBuilder

For introduction and thorough coverage of the tool and it’s capabilities, check out my previous post on the subject here: "WSPBuilder – Walkthrough of the Visual Studio Add-in".

Have a great weekend, and don’t code too much SharePoint now in this awesome weather!

WSPBuilder – Walkthrough of the Visual Studio Add-in

April 8th, 2009 by Tobias Zimmergren

Author: Tobias Zimmergren
http://www.zimmergren.net

Introduction

Alright. People have approached me lately and asked me if I could give them a brief introduction to the WSPBuilder extensions available for Visual Studio. Instead of taking all those discussions on one by one, I’ve decided to document some of the main features here. If I’m missing out on something, please let me know and I’ll fill it up.

Bil Simser did a survey with the SharePoint MVP’s and summarized the foremost favorite CodePlex projects in this article. 

In this article I will cover one of my favorite tools – WSPBuilder.

WSPBuilder background

A SharePoint Solution Package (WSP) creation tool for WSS 3.0 & MOSS 2007
No more manually creating the manifest.xml file
No more manually specifying the DDF file
No more using the makecab.exe application

Carsten Keutmann, an MVP and friend in Copenhagen is the brilliant mind behind this awesome application.

The idea behind the WSPBuilder add-in for Visual Studio is that it’s based on any normal "Class library" template – which means that you can easily copy your entire WSPBuilder project to a machine that doesn’t have WSPBuilder and still be able to open the project. – This is something you can’t do with a lot of other extension tools (say, the VSeWSS for example)

WSPBuilder Installation

Just download the latest release of the "WSPBuilder Extensions – Visual Studio Addin" and let the installation guide take you through the most simple process ever – clickety click.

Creating a WSPBuilder project

When you have installed the add-in to Visual Studio, you should now be able to create a new project based on the "WSPBuilder" template.

To kick this off, let’s create our WSPBuilder project:
image

Note: You don’t have to create a WSPBuilder template, you can create a normal Class Library as well. The only thing about a WSPBuilder template is that it will automatically create the "12" folder along with a temporary strong-key so you don’t have to do that right now.

When you’ve created the project, you’ll see a structure like this one in your solution explorer:
 image

The WSPBuilder will create the 12-folder, since it’s good practice to start your projects from the 12-root. It will also add the file "solutionid.txt" which contains a GUID to be used on the .wsp package, for easy reference. You will also get a strong-key generated for you so you don’t have to worry about signing your project right now.

Alright, now that we’re up and running with a blank WSPBuilder project – we should start by adding something to the solution.

WSPBuilder Templates – Overview

In an ordinary fashion, right click on the project and choose Add – New item.
image

Choose the "WSPBuilder" node and you will see an overview over the available templates like this:
image

Let’s walk through each and every one of them! The joy! :-)

Blank Feature Template Overview

A blank feature does exactly what the name implies, it creates a blank feature for you!

I’m creating a blank feature, and naming it to "BlankFeature1" so we easily can distinguish it from the other folders created later on.

With WSPBuilder, when you create a new item based on a template, you’ll get a dialog asking you for some variables – and since this is a feature, it’s going to need a Title, Description and of course a Scope:
image

Your solution tree will be populated with a few new things, in this case the BlankFeature1 that we chose to create:
image

As you will see, you get not only the perfectly correct 12-hive structure – you will also get the feature.xml and elements.xml files created for you, and the feature.xml file can look like this:

<?xml version="1.0" encoding="utf-8"?>
<Feature  Id="8e039720-d7df-460a-8d65-c52e47417fdf"
          Title="BlankFeature1"
          Description="Awesome description for BlankFeature1"
          Version="12.0.0.0"
          Hidden="FALSE"
          Scope="Web"
          DefaultResourceFile="core"
          xmlns="http://schemas.microsoft.com/sharepoint/">
  <ElementManifests>
    <ElementManifest Location="elements.xml"/>   
  </ElementManifests>
</Feature>

Event Handler Template Overview

With the Event Handler item template, you will not only get the correct 12-structure in your solution – you will also get the reference to "Microsoft.SharePoint.dll" added automatically, since an event handler requires some talking to the SharePoint Object Model.

We will get our feature.xml and elements.xml as normal – but this time the elements.xml is pre-populated with some tags to hook up our event handler:

<?xml version="1.0" encoding="utf-8" ?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <Receivers ListTemplateId="100">
    <Receiver>
      <Name>AddingEventHandler</Name>
      <Type>ItemAdding</Type>
      <SequenceNumber>10000</SequenceNumber>
      <Assembly>Zimmergren.SharePoint.Demo.WSPBuilder, Version=1.0.0.0, Culture=neutral, PublicKeyToken=b7201b5590fd1fc0</Assembly>
      <Class>Zimmergren.SharePoint.Demo.WSPBuilder.EventHandler1</Class>
      <Data></Data>
      <Filter></Filter>
    </Receiver>
  </Receivers>
</Elements>

As you can see, the elements.xml file is referring to the assembly called Zimmergren.SharePoint.Demo.WSPBuilder and a class called EventHandler1.

With the magic of WSPBuilder, this class has of course also been created for us and will look something similar to this:

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.SharePoint;

namespace Zimmergren.SharePoint.Demo.WSPBuilder
{
    class EventHandler1 : SPItemEventReceiver
    {
        public override void ItemAdded(SPItemEventProperties properties)
        {
            base.ItemAdded(properties);
        } 

        public override void ItemAdding(SPItemEventProperties properties)
        {
            base.ItemAdding(properties);
        } 

        public override void ItemUpdated(SPItemEventProperties properties)
        {
            base.ItemUpdated(properties);
        } 

        public override void ItemUpdating(SPItemEventProperties properties)
        {
            base.ItemUpdating(properties);
        } 
    }
}

Solution Installer Configuration

If you’ve ever used the SharePoint Installer from CodePlex, you know that when you want to use it with your own .wsp file you need to do some adjustments to the configuration xml.

With the Solution Installer Configuration template you will get this configuration automatically created and hooked up with your project. The Setup.exe.config file might look like this:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="BannerImage" value="Default"/>
    <add key="LogoImage" value="None"/>
    <add key="EULA" value="EULA.rtf"/>
    <add key="SolutionId" value="6e23b11d-8460-49a0-b2f1-b8aa78d7c58d"/>
    <add key="FarmFeatureId" value="bb1586eb-3427-483b-baa5-ae5498c47d69"/>
    <add key="SolutionFile" value="Zimmergren.SharePoint.Demo.WSPBuilder.wsp"/>
    <add key="SolutionTitle" value="Zimmergren.SharePoint.Demo.WSPBuilder"/>
    <add key="SolutionVersion" value="1.0.0.0"/>
    <add key="UpgradeDescription" value="Upgrades {SolutionTitle} on all frontend web servers in the SharePoint farm."/>
    <add key="RequireDeploymentToCentralAdminWebApplication" value="true"/>
    <add key="RequireDeploymentToAllContentWebApplications" value="false"/>   
  </appSettings>
</configuration>

Web Part Feature

This is by far one of the most popular templates, as it crates a generic template for your web part and also creates the feature for provisioning the Web Part to the Web Part Gallery.

You will get the elements.xml file configured something like this:

<?xml version="1.0" encoding="utf-8" ?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <Module Name="WebPartPopulation" Url="_catalogs/wp" RootWebOnly="TRUE">
    <File Url="WebPartFeature1.webpart" Type="GhostableInLibrary">
      <Property Name="Group" Value="MyGroup"></Property>
      <Property Name="QuickAddGroups" Value="MyGroup" />
    </File>
  </Module>
</Elements>

and you’ll get the required .webpart file configured something like this:

<?xml version="1.0" encoding="utf-8" ?>
<webParts>
  <webPart xmlns="http://schemas.microsoft.com/WebPart/v3">
    <metaData>
      <type
        name="Zimmergren.SharePoint.Demo.WSPBuilder.WebPartFeature1,
        Zimmergren.SharePoint.Demo.WSPBuilder,
        Version=1.0.0.0,
        Culture=neutral,
        PublicKeyToken=b7201b5590fd1fc0" />
      <importErrorMessage>
            Cannot import WebPartFeature1 Web Part.
      </importErrorMessage>
    </metaData>
    <data>
      <properties>
        <property name="Title" type="string">WebPartFeature1</property>
        <property name="Description" type="string">
            Description for WebPartFeature1
        </property>
      </properties>
    </data>
  </webPart>
</webParts>

and you will get the WebPartFeature1.cs file created automatically (or whatever you choose to name it) and it usually look like this:

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Web.UI;
using System.Web.UI.WebControls.WebParts;

namespace Zimmergren.SharePoint.Demo.WSPBuilder
{
    [Guid("a043d73d-7418-4918-baed-828a2bc77019")]
    public class WebPartFeature1 : Microsoft.SharePoint.WebPartPages.WebPart
    {
        private bool _error = false;
        private string _myProperty = null; 

        [Personalizable(PersonalizationScope.Shared)]
        [WebBrowsable(true)]
        [System.ComponentModel.Category("My Property Group")]
        [WebDisplayName("MyProperty")]
        [WebDescription("Meaningless Property")]
        public string MyProperty
        {
            get
            {
                if (_myProperty == null)
                {
                    _myProperty = "Hello SharePoint";
                }
                return _myProperty;
            }
            set { _myProperty = value; }
        } 

        public WebPartFeature1()
        {
            this.ExportMode = WebPartExportMode.All;
        } 

        /// <summary>
        /// Create all your controls here for rendering.
        /// Try to avoid using the RenderWebPart() method.
        /// </summary>
        protected override void CreateChildControls()
        {
            if (!_error)
            {
                try
                { 

                    base.CreateChildControls(); 

                    // Your code here…
                    this.Controls.Add(new LiteralControl(this.MyProperty));
                }
                catch (Exception ex)
                {
                    HandleException(ex);
                }
            }
        } 

        /// <summary>
        /// Ensures that the CreateChildControls() is called before events.
        /// Use CreateChildControls() to create your controls.
        /// </summary>
        /// <param name="e"></param>
        protected override void OnLoad(EventArgs e)
        {
            if (!_error)
            {
                try
                {
                    base.OnLoad(e);
                    this.EnsureChildControls(); 

                    // Your code here…
                }
                catch (Exception ex)
                {
                    HandleException(ex);
                }
            }
        } 

        /// <summary>
        /// Clear all child controls and add an error message for display.
        /// </summary>
        /// <param name="ex"></param>
        private void HandleException(Exception ex)
        {
            this._error = true;
            this.Controls.Clear();
            this.Controls.Add(new LiteralControl(ex.Message));
        }
    }
}

Web Service Template

The following files will be automatically created for you:

  • 12LAYOUTSWebService1.asmx
  • WebServiceCodeWebService1.cs

WebService1.asmx may look like this:

<%@ WebService Language="C#"
Class="Zimmergren.SharePoint.Demo.WSPBuilder.WebService1,
Zimmergren.SharePoint.Demo.WSPBuilder,
Version=1.0.0.0,
Culture=neutral,
PublicKeyToken=b7201b5590fd1fc0"  %>

WebService1.cs may look like this:

using System;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;

namespace Zimmergren.SharePoint.Demo.WSPBuilder
{
    [WebService(Namespace = "http://schemas.microsoft.com/sharepoint/">
  <ElementManifests>
    <ElementManifest Location="elements.xml"/>
  </ElementManifests>
</Feature>

FeatureWithReceiver1.cs might look like this:

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.SharePoint;

namespace Zimmergren.SharePoint.Demo.WSPBuilder
{
    class FeatureWithReceiver1 : SPFeatureReceiver
    {
        public override void FeatureActivated(SPFeatureReceiverProperties properties)
        {
            throw new Exception("The method or operation is not implemented.");
        } 

        public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
        {
            throw new Exception("The method or operation is not implemented.");
        } 

        public override void FeatureInstalled(SPFeatureReceiverProperties properties)
        {
            throw new Exception("The method or operation is not implemented.");
        } 

        public override void FeatureUninstalling(SPFeatureReceiverProperties properties)
        {
            throw new Exception("The method or operation is not implemented.");
        }
    }
}

Sequential Workflow Feature and State Machine Workflow Feature Templates

Creates the necessary files to get started with your Sequential Workflow code.

  • 12TEMPLATESequentialWorkflowFeature1elements.xml
  • 12TEMPLATESequentialWorkflowFeature1feature.xml
  • WorkflowCodeSequentialWorkflowFeature1.cs
  • WorkflowCodeSequentialWorkflowFeature1.designer.cs

The same routine applies to the State Machine Workflow Feature template.

 

Web Part Without Feature

Finally, you can create a Web Part without the feature – basically just creating the .webpart file and the .cs file.

  • 80wpcatalogWebPart1.webpart
  • WebPartCodeWebPart1.cs

Solution tree overview

Since I’ve been bashing all kinds of templates in here, you’ll see that there’s a huge tree of files – all automatically created in less than 1 minute.

image

Template Overview Summary

Alright, the templates I’ve been mentioning before are great to get rolling with a new SharePoint project. But what about deployment of this solution? How do we create our .wsp file, and how do we choose where the files should land (Global Assembly Cache – GAC – or the /bin folder?)

That’s what the next section is all about – bringing some clarification to how the WSPBuilder creates your packages.

WSP Creation and Deployment with WSPBuilder

So, when we’re satisfied with our awesome project and want to build a .wsp package from it – we can simply choose to right click the project -> WSPBuilder -> Build WSP and it will automatically create the .wsp for us:
image

This will create a .wsp file in your project folder like so:
image

Now, if you want to check the contents of the .wsp package, you simply rename the .wsp file to .cab and open it, like so:
image

Manifest.xml

In the cabinet (.wsp package) you will find the file called Manifest.xml - this is the file that tells SharePoint where to actually deploy the solution – GAC or BIN.

If you don’t do any changes at all, this file will look something like this:
image

As you can see, the DeploymentTarget is set to "GlobalAssemblyCache"  and your dll will go into the GAC.

Now, in this particular case we can not deploy to the /bin folder anyway – as we have types in our assembly that MUST go into the GAC (Workflows and EventReceivers are two of those types).

But if we were to have a Web Part project or what not – and we want to deploy it only to the /bin folder, follow along with the next few steps.

Scoping the assembly for BIN instead of GAC (including Code Access Security generation)

Okay. So you don’t want it in the GAC, but in your BIN folder instead. That’s okay, just follow along with these few simple steps:

  • Remove your /bin/debug folder entirely from your solution (make sure the .dll gets wiped)
  • If the 80-folder in your project root isn’t created – create it
    • Create a folder called "bin" folder in the 80 folder
    • Your solution tree should look something similar to this:
      image
    • Right click your project and choose "Properties"
    • Choose the "Build" tab
    • Change the Output path from "binDebug" to "80bin":
      image

When you build your project now, your .dll should pop into the "80bin" folder in your solution tree like this:
image

Ready to Rock – Scoping the assembly for the /bin folder

If we go about building our .WSP package again (right click project – WSPBuilder – Build WSP) and rename the .wsp to .cab and check the manifest.xml file – we should see two things done different:

  • DeploymentTarget is set to WebApplication (any chosen WebApp, e.g. /bin)
    image
  • Some general CAS (Code Access Security) permissions has been automatically added to make your assembly run:
    image

Deployment with WSPBuilder

Okay. So we’ve created our project, scoped it either for GAC (do nothing) or for /bin (make the changes in the previous section) – and we want to deploy it. What do we do?

  • Right Click the Project -> WSPBuilder -> Deploy
    Your output window will show something like this:
    image

Check your Solution Management in Central Administration under the tab "Operations" and make sure it’s successfully deployed:
image

Conclusion and Summary

This post simply walks through some of the more popular features of the WSPBuilder created by my pal Carsten Keutmann in Copenhagen.

If there’s any questions or comments – please add them in the comments section below.

Thanks

VSeWSS v1.3 – Feb 2009 CTP released

February 21st, 2009 by Tobias Zimmergren

As I know this is a popular tool for some of you guys reading this blog (I’ll leave my own comments on the tool unsaid for now) – you can now download the latest February CTP from the Microsoft Download site.

VSeWSS 1.3 February 2009 CTP has been released, go on and grab it here: Visual Studio 2008 Extensions for Windows SharePoint Services 3.0, v1.3 – Feb 2009 CTP

Some of the highlighted features include, but are not limited to:

  • Can be installed on x64 Server OS machines running SharePoint x64. Previously only x86 Server OS could be used
  • Separate build commands for package, deploy and retract are added as Visual Studio menu items
  • WSP View improvements for consistency of deleting feature elements, merging features and adding event receivers to features
  • Command line build, package and retract commands are included enabling continuous integration and build servers. Previously command line build of SharePoint projects was very difficult
  • Refactoring support for renaming of Web Parts. Previously renaming a web part required changes in several files in the project
  • Solution Generator can now generate solutions from publishing sites. Previously only regular sites could be generated
  • Allowing partial trust BIN deployments of web parts
  • New project item template for SharePoint RootFiles items
  • Deployment will now optionally remove conflicting existing features on the development server prior to redeployment. Previously any feature name conflicts would result in an error
  • Ancillary assemblies such as for business logic can now be added to the SharePoint Solution WSP
  • Hidden features related to Site Definition projects are now shown in WSP View. They are no longer hidden
  • For advanced users a fast deploy is included to update only the compiled assembly on the SharePoint development installation
  • Deployment step logging is included
  • The List Definition from Content Type template now allows for the creation of a List Definition Event Receiver
  • The User Guide is now installed with the extensions instead of being a separate download

Note: This release is not officially supported by Microsoft (Being a CTP), so if you bump into trouble – you don’t really have any official support from Microsoft on your related issues.

Technorati Tags: ,,

Author: Tobias Zimmergren
Url:
http://www.zimmergren.net

What is VSeWSS?

VSeWSS is a plugin to Visual Studio that adds a set of functionality which may help you in your daily tasks as a SharePoint developer. The plugin comes with a basic set of templates, and a great set of functionality which I’ll try to outline here.

Overview of the main functionality

Project Templates
  • Team Site Definition
  • Blank Site Definition
  • List Definition
  • Web Parts
  • Empty project

image

 

Item Templates (which you can add to the project templates)
  • List Definition (+ from Content Type)
  • Content Type
  • Field Control
  • Web part
  • Module
  • Root File
  • Event Receiver
  • List Instance

image

SharePoint Solution Generator 1.3

A new version of the SharePoint Solution Generator is also being published along with this tool, which adds some functionality to it’s predecessor.

WSP View

WSP View is a functionality which helps you with the manifest and gives you a visual overview over the contents of the *.WSP file.

image

That being said, you don’t need to create those manual manifest.xml and .ddf files anymore (but then again, if you’re using the “sent-from-above” tool WSP Builder by my Danish MVP colleague – Carsten Keutmann – then you’re probably already free from that hassle!

Automatic deployment (on your dev-machine)

You can develop your stuff, and use the “click-once” deployment method to get your stuff hooked up on your local development environment with no hassle at all.

Bin / GAC deployment now an active choice

When you create e.g. a Web Part project, you’ll be presented with this nifty query:
image
Note: At the time of this release, the CAS permissions that are automatically presented and hooked up for your assembly are “a few standard ones” – it doens’t nessecarily mean that your application will work unless you add additional CAS statements. You’ll have to make sure of that yourself!

Basically, put all things in the bin folder if you can, and secure it with proper CAS!

Alternatives to VSeWSS

Of course, I’ll have to mention some of the alternatives to using VSeWSS as well, as all tools doesn’t fit in every mans hand.

Summary

That’s a wrap for today, just a little peak at the 1.3 version of the VSeWSS for Visual Studio 2008.

Myself, I usually do things more controlled than letting this tool manipulate and create all the stuff – but for someone beginning SharePoint development and don’t have the time and/or need to know where all the configs and files should go – give it a shot, it’ll save you tons of time!

Have a good day,

Cheers,
Z

Technorati Tags: ,,,

 

What is this?

You can now download a CTP of Visual Studio 2010 and .NET 4.0 from Microsoft’s download center. Fetch the link in the bottom of this article to download!

“Microsoft Visual Studio 2010 and the .NET Framework 4.0 are the next generation development tools and platform for Windows Vista, the 2007 Office System, and the Web.”

Most people already know what this means, so I’m not going to bother talking about it in detail here – go try it for yourself, I know I will :-)

Download

http://www.microsoft.com/downloads/details.aspx?familyid=922b4655-93d0-4476-bda4-94cf5f8d4814&displaylang=en&tm

Have a good play!