First “gotcha”: Make sure you set the target .NET Framework to 3.5. By default Visual Studio 2010 is going to select 4.0 and it will then do a bunch of complaining about not finding Microsoft.SharePoint.dll. Yes, the compiler will give a pretty detailed error which may or may not reference the fact that you need to target 3.5, but it had me scratching my head for awhile so I figure its worth capturing.

Second “gotcha”: You need to target x64 platform. I was getting all kinds of crazy behavior when targeting x86. When I would try to create SPSite objects I would get “FileNotFound”. If I would try to use SPWebService.Locate I would get permissions issues. Switch the platform to x64 and everything started working like magic!

That’s it, hope this saves someone some time (preferably me on a later project ).

SPWeb web = null; // works better if you actually set this to a valid instance
// so this property, the __DisplayShowHideRibbonActionId, doesn't exist unless it's set to No!
// so in this instance we are setting it to No, but if you want to set it to Yes you just
// want to clear the value for the property.  make it string.Empty, or just delete the
// property entirely.
web.AllProperties["__DisplayShowHideRibbonActionId"] = "False";
// Update your web, do a jig.
web.Update();

Scenario

As the title suggests, the scenario is that we are adding a ListViewWebPart to a page, utilizing one of the current list views as a “template”, but making some changes for the purposes of this web part.

Solution

I recommend hitting the “view source” button on the syntax highlighter, I really need to switch to a wider blog template . In any event, here is the solution that I employed, I added numerous comments to describe why things were being done. Hopefully it saves someone some time.

            SPLimitedWebPartManager limitedWebPartManager = null;
            ListViewWebPart wp = null;

            try
            {
                // assume that you have a limitedWebPartManager variable containing an
                // instance of a SPLimitedWebPartManager class.  

                // also assume that you have a list variable containing a reference to the
                // SPList that you are pointing this ListViewWebPart at.

                // create an instance of the ListViewWebPart
                wp = new ListViewWebPart();
                // convert the list GUID to a string, must include braces (ToString("B")) and be in uppers (ToUpper())
                wp.ListName = list.ID.ToString("B").ToUpper();
                // optionally set the title of the web part
                wp.Title = "I Love List Views";

                // add the web part to the limited web part manager.  when you do this, a "hidden" view will be created
                // on the list referenced by the list variable.  we will later get a reference to this hidden view and bend it
                // to our will.
                limitedWebPartManager.AddWebPart(wp, "whatever web part zone you want to add it to", 1); // the 1 is the index within the zone
                // you need to update the list because a view was just added to it
                list.Update();

                // now that the web part has been added we need to get a fresh reference to it from the limitedWebPartManager.
                // there are plenty of great ways to do this, in this example i will be using the low-tech approach of enumerating the
                // WebParts collection and checking for the type and title that matches our part.  i am quite positive there are more
                // efficient ways of doing this, but this code gets called exactly once every couple months, so efficiency isn't worth
                // the extra development cycles
                foreach (System.Web.UI.WebControls.WebParts.WebPart webPart in limitedWebPartManager.WebParts)
                {
                    // check to see if the type of the web part is ListViewWebPart, and if so, check if the title matches our guy.
                    if (webPart is ListViewWebPart && webPart.Title.Equals("I Love List Views"))
                    {
                        // cast the web part to a ListViewWebPart so we can start to tweak its properties
                        var listViewWebPart = webPart as ListViewWebPart;

                        // here is some of the magic.  the web part now has its ViewGuid property populated which
                        // contains the Guid of the hidden view.  we get a reference to it here.
                        var view = list.Views[new Guid(listViewWebPart.ViewGuid)];

                        // here we grab a reference to a template view.  this may be the default view of the list,
                        // or maybe you have another view that you created that you want to use.  you don't have to
                        // do this, but in this scenario i wanted to copy the filter and sort settings from an existing view.
                        var templateView = list.Views["Name Of Template View"];

                        // now we drop all of the view fields in the hidden view
                        view.ViewFields.DeleteAll();
                        // now we are going to go through a string array and add each of the strings to the view fields collection.  again,
                        // you don't have to do this, but if you want to change what columns are displayed in your ListViewWebPart, you will
                        // need to muck with the ViewFields of the view.
                        Array.ForEach(new string[] { "First Name", "Last Name", "Address" }, f => view.ViewFields.Add(f));

                        // here we copy the Query straight from the templateView.  if you didn't have a templateView you could always
                        // just create an SPQuery instance and assign it to the view.Query property.  no points will be taken off for doing that.
                        view.Query = templateView.Query;

                        // update our hidden view, and bask in the awesomeness of our customized ListViewWebPart
                        view.Update();
                    }
                }
            }
            finally
            {
                // do some fun cleanup of disposable items.  if you are wondering about the .Web.Dispose() bit look for my
                // blog article on the memory leaks in the SPLimitedWebPartManager.
                if (limitedWebPartManager != null)
                {
                    if (limitedWebPartManager.Web != null)
                    {
                        limitedWebPartManager.Web.Dispose();
                    }

                    limitedWebPartManager.Dispose();
                }

                if (wp != null)
                {
                    wp.Dispose();
                }

                // i probably missed some .Dispose()s since I cobbled this code together in WordPress and not Visual Studio
            }
        }

From my days working with Team Foundation Server I remembered the "Shelving" concept.  Unfortunately, I was using Subversion, not Team Foundation Server.  But isn’t a shelf really just a branch?  So I figured I could do a poor-mans shelf with Subversion, and I was right.  Worked great.

I was going to write up my steps to do so but decided I would do a quick Google sanity check before expending the effort.  Glad I did, cause Mark Phippard did a much better job then I would have done.  Kudos Mark, thanks for the excellent amount of detail.

Give it a shot!  Your eyes will thank you!

class Program
{
    static void Main(string[] args)
    {
        List<Student> studentList = new List<Student>();

        studentList.Add(new Student("Charlie", "Brown"));
        studentList.Add(new Student("Drew", "Carrie"));

        IEnumerable<Student> students =
            from
                Student
            in
                studentList
            where
                Student.LastName.Equals("Brown")
            select
                Student;

        foreach (Student student in students)
        {
            Console.WriteLine(student.FirstName);
        }

        Console.ReadLine();
    }
}

internal class Student
{
    private string _firstName;
    private string _lastName;

    public Student(string firstName, string lastName)
    {
        _firstName = firstName;
        _lastName = lastName;
    }

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

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

 Which when run looks like:

I’m excited by the possibilities this offers, and am anxious to have an opportunity to explore all LINQ has to offer!