Feeds:
Posts
Comments

Archive for the ‘Code’ Category

In order to replace a text in any section of the header or the footer of a word document, you can use this snippet

doc = Document Object

foreach (Section sec in doc.Sections)
{
foreach (HeaderFooter fot in sec.Footers)
{
fot.Range.Find.Execute(FindText: loc.Key, ReplaceWith: loc.Value,
Replace: WdReplace.wdReplaceAll);
}
}

Read Full Post »

In order to grant authenticated FBA users access to a custom application page (/_layouts page), please follow these steps:

  • The Page should inherit from LayoutsPageBase (Making it inherit from UnsecuredLayoutsPageBase will grant anonymous access to this page).
  • Override the Properties RightsRequired and RequireDefaultLayoutsRights

       protected override SPBasePermissions RightsRequired
       {
           get
           {
               SPBasePermissions permissionRequired = SPBasePermissions.ViewPages;
               return permissionRequired;
           }
       }

       protected override bool RequireDefaultLayoutsRights
       {
           get
           {
               return false;
           }
       }

 

This will grant authenticated FBA users access to this _Layouts page.

Read Full Post »

http://visualstudiogallery.msdn.microsoft.com/en-us/76293c4d-8c16-4f4a-aee6-21f83a571496

Read Full Post »

YouTube just released an .NET SDK for YouTube.
http://apiblog.youtube.com/2010/02/announcing-youtube-sdk-for-net.html
It includes a VS2008 template to develop YouTube Applications as well as some sample applications

Read Full Post »

.NET stock Trader is a sample application showing a host of .NET technologies using Service oriented and N-tier designs:

A set of videos to demonstrate the application are posted to Channel 9: http://channel9.msdn.com/posts/Charles/Greg-Leake-Stocktrader-A-Loosely-coupled-and-Interoperable-NET-Enterprise-Services-Sample-Applic/

An overview about the application can be found at: http://msdn.microsoft.com/en-us/netframework/bb499684.aspx

A discussion forum for .NET StockTrader is available at: http://social.msdn.microsoft.com/forums/en-US/dotnetstocktradersampleapplication/threads/

Read Full Post »

ASP.NET Add-in for best practices analyzer : http://www.codeplex.com/Wiki/View.aspx?ProjectName=BPAEngine

Tool to show useful information about an assembly when right clicking on it  (Debug or release, Version, public token, etc.) : http://www.codeplex.com/AssemblyInformation

Patterns and Practices guidance explorer: http://www.codeplex.com/guidanceExplorer

Patterns and Practices SharePoint guidance:http://spg.codeplex.com/

Tool to visualize the project dependencies in a solution: http://www.codeplex.com/dependencyvisualizer

Read Full Post »

Regionerate: a small add-in that will help you manage the code order and layout: http://visualstudiogallery.msdn.microsoft.com/en-us/800978aa-2aac-4440-8bdf-6d1a76a5c23c

StyleCop: Tool the check code style and consistency: http://code.msdn.microsoft.com/sourceanalysis

Read Full Post »

This tutorial will very quickly walk through creating a VERY SIMPLE  Entity Model. This is a VERY simple tutorial to simply get a taste of EF.

You will need visual Studio 2008 SP1 or later and SQL Server for the database and we will use the Nrothwind sample database.

ScreenHunter_01 Mar. 19 00.09

Open Visual Studio 2008:

ScreenHunter_02 Mar. 19 00.09

Create a new Project: (Make sure you are selecting Framework version 3.5)

ScreenHunter_03 Mar. 19 00.10

Right Click the Project Name and Select “Add Item”, Select ADO.NET Entity Data Model from the “Data” Category and select a name for it

ScreenHunter_05 Mar. 19 00.11

A Wizard will start, Please select “Generate from Database” (Note: Though theoretically, you can start with the Model and the Later on map it to the a database, The Visual studio tools for EF are best designed in this current release to generate the mode from the database.

ScreenHunter_06 Mar. 19 00.11

The Next form will ask you to create the connection to the database Or choose from an existing connection in the project if one exists:

ScreenHunter_07 Mar. 19 00.11

Create the connection. Note that the wizard automatically creates a key in the web.config or app.config with the connection string inside it (nice feature)

Next you will be asked To select the Tables/Views/Procedures that you want to include in the Entity Data Model and to se a namespace for the Model Classes:

ScreenHunter_09 Mar. 19 00.13

In Our case we will simply Select the “products” and “Categories” Tables from the List of tables available in the Northwind database. (This is just for simplicity).

Based on the choice, the Wizard will generate the Entity data model.

ScreenHunter_10 Mar. 19 00.17

To make the Model more easy to understand and more natural, you can set the name for the Entity (Product as opposed to products like the table name in the database) and the Name of the Entity Set (we can make it Products or ProductSet or whatever)

ScreenHunter_11 Mar. 19 00.28

You can also change the Class properties, For example, you can rename ProductName (as in the column name in the DB) to be “Name” to be more natural to write code like productObj.Name rather than productObj.ProductName for example.

 

Now the model is ready we can start retrieving data.

A very simple code to load all products will look like this:

using (NorthwindDBConn context = new NorthwindDBConn())
{
    foreach (Product prod in context.Products)
    {
        Console.WriteLine(prod.Name);
    }
}

Important Note: Though prod Object has a category property, due to Lazy loading by the EF it will e initialized as null and wont be fetched from the database.

In order to read it from the database and make sure it is initialized, you need to add the line “ prod.CategoryReference.Load(); “ so the code will look like :

 

using (NorthwindDBConn context = new NorthwindDBConn())
{
    foreach (Product prod in context.Products)
    {
        prod.CategoryReference.Load();
        Console.WriteLine(prod.Name);
    }
}

 

That is All you need to retrieve elements from EF. To use more sophisticated queries, EF allows you to use LINQ to build queries.

 

In order to save an Product object for example, all you nee to do is:

using (NorthwindDBConn context = new NorthwindDBConn())
    {
        Product x = new Product();
        x.Name = "New Product";

        context.AddToProducts(x);

        context.SaveChanges();
    }

 

That is all you need to get started with the EF.

For more information you can refer to:

Read Full Post »

SharePoint Code Optimization

Although SharePoint objects (SPSite, SPWeb, etc. ) are essentially managed code, they internally invoke unmanaged code (COM objects to handle database connections). As a direct result, if these objects are not explicitly disposed correctly, they will cause memory leaks that may eventually cause out of memory errors or make the application unstable. it is estimated that each un-disposed instance of SPSite or SPWeb consumes 1 to 2 MB of unmanaged resources.

 

A background about Memory Management:

In a 32 bit machine, the maximum amount of memory that a process can address is 2GB. This memory is partitioned into chunks of 64MB (on average, as this number slightly changes between the different versions of .NET Frameworks). Being in chunks, it means that a 3KB DLL will still occupy a 64MB slot.  For ASP.NET applications (including SharePoint), their memory ceiling is even lower than that 2GB since they live inside the w3wp process. The w3wp process loads some ISAPI DLLs and some IIS related DLLs in addition to the ASP.NET application. This explains why, for example, a server can throw out of memory exceptions while it has more than 5GB of free RAM. A good analogy can be found at (http://blogs.msdn.com/tess/archive/2006/09/06/net-memory-usage-a-restaurant-analogy.aspx)

 

Back to SharePoint, it means that all un-disposed objects are occupying memory within the 2GB w3wp and will eventually cause the application to crash, become unstable or starts throwing exceptions. Usually an application pool recycle or iisreset will be needed in order to get rid of these objects. Another major problem with un-disposed objects in SharePoint is that the unmanaged COM objects that are not disposed and that remain in memory are responsible for connecting to the back end database. By remaining un-disposed, the connection to the database remain open. Other that affecting performance, a machine can only have a certain number of connections open to the database (per machine overall , not per process). If the number of open connections remaining open reaches this limit, other processes that need to connect to the database will not be able to open new connections and will start to throw exceptions or behave strangely. This applies to 64 bits machines as well, even though memory might not be clogged, but connections will be clogged.

 

SharePoint v3.0 ULS Logging systems logs the SP objects that are not disposed at the end of the the thread. In order to pinpoint what code is causing such memory leaks, you need to:

  • Set the Logging level to Warning / Medium
  • create a registry key at HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Shared Tools\Web Server Extensions\HeapSettings. Then create a new DWORD named SPRequestStackTrace with the value 1 under this key.

This will add the stack trace of the thread that is not disposing SP objects correctly to the logs, thus helping developers find out which part of the code is the problem. In the ULS logs, you will find something similar to: General                               8l1n       High       An SPRequest object was not disposed before the end of this thread.

 

Some general recommendations to avoid running out of memory:

  • Do not force more than one web application to use the same application pool. This will mean that more applications will be squeezed within the same 2GB that this process can address.
  • Do not run production code in debug mode. Running in debug mode means that each page’s code behind will be compiled into a separate DLL and therefore heavily fragmenting the memory. (use debug=false)
  • If possible, move to a 64bit architecture.

 

Some recommendations for building custom code for SharePoint (controls, web parts,  Event handlers, etc.)

  • First and foremost, Do not build your own controls unless you have to. Try first to customize out-of-the-box components.
  • If you have to use Code, check it with the SPDispose Check tool (http://code.msdn.microsoft.com/SPDisposeCheck) this tool will review the Code to help developers identify objects that are not correctly disposed.
  • Follow the best practices for using SP objects as Listed in http://msdn.microsoft.com/en-us/library/aa973248.aspx. This pretty much summarizes how to dispose SP objects correctly.
  • Common alternatives to explicitly calling Dispose() include using the SP object inside a try/catch/finally or using a “using” block. In fact the MSIL transforms using blocks to try/finally. Please note that you need a using block per object. for example, if you create SPSite then SPWeb, you need to call then like this

    using (SPSite siteCollection = new SPSite(“http://moss”))
    {
        using (SPWeb web = siteCollection.OpenWeb())
        {
              //…
        } // SPWeb object web.Dispose() automatically called
    }  // SPSite object siteCollection.Dispose() automatically called

  • Do NOT Dispose objects referenced from SPContext. These objects are managed by the SharePoint runtime and should not be disposed from your code. For example, do NOT dispose SPSite object you get through SPContext.Current.Site.
  • Same for references obtained through list handlers like SPListEventProperties.Web.
  • Do not nest the creation of SP objects in one line as it will become tricky when disposing them.  for example:
using (SPWeb web = new SPSite(http://shareoint).OpenWeb()) 
as in such case you wont have reference to the SPSite object in order to dispose it
  • When looping through Web.Webs for example, make sure to dispose every SPWeb created inside the loop.
  • Do NOT store SPSite or SPWeb objects in session or application variables. You can cache or Store the GUID, URL, whatever you can use to rebuild the SP object. You cannot cache the SP object itself.

 

References:

http://blogs.msdn.com/rogerla/archive/2009/01/14/try-finally-using-sharepoint-dispose.aspx 

http://blogs.msdn.com/rogerla/archive/2008/02/12/sharepoint-2007-and-wss-3-0-dispose-patterns-by-example.aspx

http://blogs.technet.com/stefan_gossner/archive/2007/11/26/dealing-with-memory-pressure-problems-in-moss-wss.aspx

http://blogs.msdn.com/steveshe/archive/2007/12/17/overlapped-recycling-and-sharepoint-why-sharepoint-requires-it.aspx

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

http://blogs.technet.com/stefan_gossner/archive/2008/12/05/disposing-spweb-and-spsite-objects.aspx

http://solutionizing.net/2008/12/06/the-new-definitive-spsitespweb-disposal-article/

Read Full Post »

Best Practices for disposing windows SharePoint objects: http://msdn.microsoft.com/en-us/library/aa973248.aspx

Using Solution Packages to Deploy Features and Content in Windows SharePoint Services 3.0: http://msdn.microsoft.com/en-us/library/dd348394.aspx

Troubleshooting SPSite/SPWeb leaks in WSS v3 and MOSS 2007 :  http://blogs.technet.com/stefan_gossner/archive/2008/05/07/troubleshooting-spsite-spweb-leaks-in-wss-v3-and-moss-2007.aspx

SharePoint Dispose() patterns by example: http://blogs.msdn.com/rogerla/archive/2008/02/12/sharepoint-2007-and-wss-3-0-dispose-patterns-by-example.aspx

Read Full Post »

Older Posts »