Grounding.co.za

Technology information for IT specialists
Welcome to Grounding.co.za Sign in | Join | Help
in Search

Tech Talk with Brett Maytom

May 2008 - Posts

  • SharePoint - Register an assembly as a safe control in the Web.config file

    In order for you to use your own custom assembly with your web parts and other little bits, you will need to add your safe control to the web.config file.  However, you need to think "WEB FARM" with many servers hosting the web application so I will show you a couple ways to do this.

    The entry in the web.config

    You need to place a SaveControl element entry into the web.config file of the web application.  The entry looks like the following:

       1: <configuration>
       2:   <SharePoint>
       3:     <SafeControls>
       4:       <SafeControl Assembly="[Assembly Name]" Namespace="[Namespace]" TypeName="*" Safe="True" />
       5:     </SafeControls>
       6:   </SharePoint>
       7: </configuration>
    Assembly The name of your assembly needs to added to this section. Although you can simply type the name of the DLL hosting the control into the Assembly element, it is important to not that this is not the recommended practice.  Rather, use a full four part name; i.e. [assembly], version=[version], culture=[culture], publickeytoken=[publickeytoken]Namespace The namespace that your web controls are in.  If you have your controls in multiple namespaces, you will need to add one <SafeContol ...> element for each control.TypeName The name of the web control which is allowed to be executed with the SharePoint web application.  Should your namespace have multiple web controls, you do not need to register each control.  You can simply use * (asterisk) to indicate the dll.Safe A boolean flag, indicating whether the control is treated as safe (true) or unsafe (false). AllowRemoteDesignerA boolean flag, indicating whether the control can be loaded by a remote designer, such as SharePoint Designer.

    Sample

       1: <SafeControl Assembly="Brett.DemoParts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f03e5f7a44d50a3a" 
       2:              Namespace="Brett.SharePoint.WebParts" 
       3:              TypeName="*" 
       4:              Safe="True" 
       5:              AllowRemoteDesigner="True" />

    Methods of updating the web.config file

    There are three ways you can update the web.config file,

    • Manually adding the SafeControl to the web.config
    • Adding the SafeControl to the web.config with code
    • Deploy the assembly using a solution package

    Manually editing the web.config (bad)

    This approach may sound the easiest and quickest way as you simply open up your favourite xml editor, find the <SafeControls> element and add your own control into it.

    WARNING!
    If you do it this way, you are looking for trouble in a farm as you will need to remember to change the web.config modification for all your servers in the farm as well as all the web applications on the farm that use the custom control.  So should you have a really awsome web part that is used within 5 web applications hosted on your farm of 3 servers, you will need to make the modification to 15 web.config's .. have fun.

    Also should you add a new server to your farm, please remember to add the entry the web.config.

    Bottom line, this is the worst possible way you can do it  and stay away from doing it this way

    Adding the SafeControl to the web.config with code (good)

    SharePoint provides a class called SPWebConfigModification which has a set of modification commands in a collection.  These modification commands are applied to the default web.config of the Web Application.  These configuration modification commands will also be added and applied to all servers in a farm.   Finally, should a new server be added to the farm, these modifications will also be applied.

    The following code could be added to the FeatureActivated override method in your feature that deploys the web part.

       1: public override void FeatureActivated(SPFeatureReceiverProperties properties) 
       2: {
       3:     // A reference to the features Site Collection
       4:     SPSite site = null;
       5:  
       6:     // Get a reference to the Site Collection of the feature
       7:     if (properties.Feature is SPWeb)
       8:     { site = ((SPWeb)properties.Feature.Parent).Site; }
       9:     else if (properties.Feature.Parent is SPSite)
      10:     { site = properties.Feature.Parent as SPSite; }
      11:  
      12:     if (site != null)
      13:     {
      14:         SPWebApplication webApp = site.WebApplication;
      15:  
      16:         // Create a modification
      17:         SPWebConfigModification mod = new SPWebConfigModification(
      18:             "SafeControl[@Assembly=\"MyAssembly\"][@Namespace=\"My.Namespace\"]"
      19:                 + "[@TypeName=\"*\"][@Safe=\"True\"][@AllowRemoteDesigner=\"True\"]"
      20:             , "/configuration/SharePoint/SafeControls"
      21:             );
      22:  
      23:         // Add the modification to the collection of modifications
      24:         webApp.WebConfigModifications.Add(mod);
      25:  
      26:         // Apply the modification
      27:         webApp.Farm.Services.GetValue<SPWebService>().ApplyWebConfigModifications();
      28:     }
      29: }

    Deploy the assembly using a solution package (best)

    The preferred way to provision your features, web parts and assemblies is by creating a Solution Package (.wsp file).  You will add add your assembly, the manifest.xml file and all your other components and resources into the cabinet.

    You will need to add the following entry into the manifest.xml

       1: <Solution SolutionId="{1E0FDA58-6611-423a-92EC-8E7355810CEE}"
       2:           xmlns="http://schemas.microsoft.com/sharepoint/">
       3:   <FeatureManifests  />
       4:   <ApplicationResourceFiles />
       5:   <CodeAccessSecurity />
       6:   <DwpFiles />
       7:   <Resources />
       8:   <RootFiles />
       9:   <SiteDefinitionManifests />
      10:   <TemplateFiles />
      11:   
      12:    <Assemblies>
      13:       <Assembly DeploymentTarget="WebApplication" Location="Brett.DemoParts.dll">
      14:          <SafeControls>
      15:             <SafeControl Assembly="Brett.DemoParts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f03e5f7a44d50a3a"
      16:                          Namespace="LitwareWebParts" 
      17:                          TypeName="*" 
      18:                          Safe="True"                         
      19:                          />
      20:          </SafeControls>
      21:       </Assembly>
      22:    </Assemblies>
      23: </Solution>
      24:  

    Key highlights

    DeploymentTarget The depoloyment target is location where the assembly will be copied to and can ether be the bin folder of the WebApplication or it could be the GlobalAssemblyCache (GAC)Location The location of the assembly within the cabinet file. SafeControl A SafeControl element entry as described at the beginning of the post.   

    Using this method, your assembly will be correctly deployed the servers in the farm as well as added to the safe controls of the web application.  Again any new server added to the farm will automatically get all the solution packages deployed.

    See

    References

    Posted May 23 2008, 08:30 PM by Brett with 6 comment(s)
    Filed under:
  • Hiding a user name from the Vista welcome screen

    This post is not in line with the technologies and products I normally blog on, however this has been a pet little irritation I have had for some time since I installed Vista. So, my apologies to the mirrors and and RSS feed readers that are not interested in this type of topic and feel it is "off topic".

    On my Vista installation I have installed a several services such as SQL and BizTalk and few other products. Now as a good puppy, I installed these products I have always created specific service accounts for each service and applied security, my reason for this is I want to make sure that I take security into account in my development cycle.  The irritation is that after you boot, the welcome screen comes up showing all the accounts including the service accounts.  Now, I never wanted these to user accounts and images to appear here as I never manually logon with the account.

    For several months, now I have struggled to find out how to remove them from the welcome page and only leaving the account I logon with on the screen.  With some digging and bouncing off many sites I finally found out how it is done.

    1. Open up your registry editor, regedit.exe
    2. Navigate to the [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon]
    3. Create a key SpecialAccounts under Winlogon
    4. Create a key UserList under SpecialAccounts
    5. Add a DWORD Value and set the Value to the User Name.
    6. Set the value to 0 to hide the username and icon from the welcome screen, or 1 to show the username and icon.

    image

    End result was a happy Brett :>>

    Reference

    1. Configure the login and Welcome Screen in Vista 
    Posted May 20 2008, 09:27 AM by Brett with 3 comment(s)
    Filed under:
  • SharePoint : Application Pool accounts and the IIS_WPG Group

    In Internet Information Server 6.0 there is a new user group IIS_WPG which basically gives a minimum set of permissions required to start and run worker processes on a web server.  By default, the group contains the following user accounts

    • Network Service
    • Local Service
    • LocalSystem
    • IWAM_ComputerName

    Before you assign your own service account as a worker process identity for a Web site, make the user a account a member of the IIS_WPG group.  This will make your life easier as you will not have to manually assign permissions and privileges. 

    SharePoint Important If your application pool account is not assigned as a member to this group and you have not manually granted permissions to the account, you should get an error "Service Unavailable".  Rectify this by adding the account to IIS_WPG as well as the SPS_WPG and STS_WPG accounts.  Also, ensure this account is correctly set up on all servers in your farm.

    Default permissions to the account

    On NTFS

    Location Permission

    %windir%\help\iishelp\common

    Read, Execute
    %windir%\IIS Temporary Compressed Files Full control

    %windir%\system32\inetsrv\ASP compiled templates

    Full control

    Inetpub\wwwroot (or content directories)

    Read, Execute

    In the Registry

    Location Permission

    HKLM\System\CurrentControlSet\Services\ASP

    Read
    HKLM\System\CurrentControlSet\Services\HTTP Read
    HKLM\System\CurrentControlSet\Services\IISAdmin Read
    HKLM\System\CurrentControlSet\Services\w3svc Read

    Windows policy rights

    Policy

    Bypass traverse checking

    Impersonate a client after authentication
    Log on as a batch job

    Tips

    1. Remove the IIS_WPG account from the ACL list in the folder with the site content and rather add only the application pool identity to the ACL.
    2. Remember any changes you make should be done on all servers in your farm and some careful thought given to how you will do this.

    References

    Related certifications

    The information in this post is important for the following certification exams

    Posted May 09 2008, 09:09 AM by Brett with no comments
    Filed under: ,
  • Preparing for exam 70-541: TS: Microsoft Windows SharePoint Services 3.0 – Application Development

    Exam news

    The Technology Specialist (TS) exam, Exam 70-541: TS: Microsoft Windows SharePoint Services 3.0 – Application Development, was released in March 2007. This exam is available in English, Chinese [Simplified], French, Japanese, and Spanish.

    Exam topics covered

    The following list includes the topic areas covered on this exam. The percentage indicates the portion of the exam that addresses a particular skill.

    Deploying Windows SharePoint Services and Custom Components (14 percent) Creating Site and Feature Provisioning Components (20 percent) Creating Metadata and Workflow Provisioning Components (15 percent) Developing Windows SharePoint Services Components by Using the .NET Framework (17 percent) Manipulating Site Content by Using the API (20 percent) Manipulating Site Configuration by Using the API (14 percent)

    Audience profile

    This exam is intended for consultants who provide Windows SharePoint Services development or corporate developers who build systems using the Windows SharePoint Services platform. The qualified candidate for this exam typically has:

    • Two to three years of experience working with ASP.NET
    • One to two years of experience developing ASP.NET Web Parts
    • Experience working with Master pages
    • One to two years of experience working with XML documents
    • Two to three years of experience developing and consuming Web services
    • Working knowledge of Windows WorkFlow Foundation

    Credit toward certification

    When you pass this exam, you earn credit toward the following certifications:

    MCTS: Microsoft Windows SharePoint Services 3.0: Application Development

    Code languages

    When the exam begins, you can choose the programming language in which the code segments will appear. The available code languages for this exam are:

    • Microsoft Visual Basic 2005
    • Microsoft Visual C# 2005

    Skills measured

    This certification exam measures your ability to build enterprise portals using Windows SharePoint Services 3.0.

    Before you take the exam, you should be proficient in the job skills listed in the following table. The table lists Official Microsoft Learning Products that can help you reach competency in the skills being tested in the exam.

    Deploying Windows SharePoint Services and Custom Components

    Configure a target computer for Windows SharePoint Services development.

    • Create Windows SharePoint Services service accounts.
    • Configure database rights for Windows SharePoint Services service accounts.
    • DbCreator
    • SecurityAdministrator
    • Configure machine rights.
    • IIS_WPG (learn more)
    • STS_WPG
    • Enable forms authentication on the IIS virtual server.

    Deploy a Web Part to the Windows SharePoint Services server.

    • Register an assembly as a safe control in the Web.config file.  (learn more)
    • Configure Web Part permissions.
    • Enable a Web Part to access resources by creating a custom security policy.

    Create and deploy a Windows SharePoint Services solution package.

    Deploy a site definition to a Windows SharePoint Services front-end Web server.

    • Deploy a site definition manually by copying appropriate files and folders to the server and resetting IIS.

    Deploy a feature to a Windows SharePoint Services front-end Web server

    • Deploy a feature manually by copying appropriate files and folders to the server and resetting IIS
    • Install and activate a feature by using STSADM.

    Deploy a Web service to a Windows SharePoint Services front-end Web server.

    • Deploy a Web service so that it is available within the context of any Windows SharePoint Services site.
    • Deploy a Web service external to the Windows SharePoint Services context.

    Deploy user controls to a Windows SharePoint Services front-end Web server.

    • Deploy a user control so that it can be used by any Windows SharePoint Services component.

    Creating Site and Feature Provisioning Components

    Create a feature definition

    • Specify a feature that depends on another feature to activate
    • Specify an Event Receiver to handle events for a feature
    • Localize a feature using a resource file
    • Create an action to add an option to the site settings menu
    • Add a new master page when a feature is activated
    • Cache the master page in a document library

    Create a site definition

    • Define the top and side navigation areas for a site
    • Specify a list definition to use in a site
    • Hide a list definition from the Create Page

    Specify a Document Template in a site definition

    • Specify a file for use in a Document Template

    Create a site definition module

    • Specify a file to be cached in memory on the front-end server
    • Add a UI element to the beginning of the top navigation area in a module
    • Force a Feature to install when a site is created by using the site definition

    Specify the configurations of lists and modules in a site definition

    • Create multiple configurations for a single site definition
    • Specify that the site created will only exist as the root Web site in a collection

    Create pages and layouts for a site

    • Create a custom Page Layout that has multiple Web part zones
    • Customize the fields that are displayed on the mobile view of a Windows SharePoint Services page
    • Modify the page layout for a site using master pages

    Creating Metadata and Workflow Provisioning Components

    Create a site column

    • Specify a site column in a site definition in a Feature
    • Add a column to a Provisioned Site by using the API

    Create a list definition

    • Prevent a list from being created on a site by hiding it on the list Create Page
    • Add a new view to a list definition
    • Specify a view that shows all files and all subfolders of all folders

    Create a Custom Field Type

    • Define the Custom Field Type to be displayed for inclusion in lists and document libraries
    • Display the Custom Field Type differently for a new item form and an edit form

    Create a Workflow definition

    • Attach a workflow to a list on creation
    • Collect default values for a workflow
    • Package a workflow in a feature

    Create a Content Type

    • Add multiple Content Types to a single list
    • Apply a Content Type to multiple file types
    • Inherit properties from one Content Type to another
    • Update an existing content type

    Developing Windows SharePoint Services Components by Using the .NET Framework

    Implement a business process by using a workflow.

    • Create a basic workflow by using the SharePoint Designer.
    • Call custom services from workflow by using Visual Studio 2005

    Handle Windows SharePoint Services events by developing an event receiver.

    • Handle a list event.
    • Cancel an operation.
    • Handle a feature event.

    Develop a Web Part.

    • Upgrade a Web Part from Windows SharePoint Services-version 2 to version 3.
    • Handle postback data by using the control life cycle.
    • Troubleshoot a Web Part failure.
    • Handle exceptions within a Web Part.
    • Convert a user control into a Web Part.
    • Implement caching by using the Windows SharePoint Services cache.
    • Create a personalized Web Part property.
    • Create a shared Web Part property.
    • Create a Web Part that uses Windows SharePoint Services cascading style sheet (CSS) styles.
    • Enhance the Web Part configuration UI by using a custom tool part.

    Share data between Web Parts.

    • Create a Web Part that is a data provider.
    • Create a Web Part that is a data consumer.
    • Filter information from one Web Part to another.

    Elevate application permissions by using impersonation.

    Enable a custom Windows SharePoint Services administration page to access the Windows SharePoint Services object model.

    Schedule tasks by using the SharePoint Timer service.

    • Create a job by using the SPJobDefinition class.
    • Submit a job to the SharePoint Timer service.

    Manipulating Site Content by using the API

    Manage an alert.

    • Create an alert for a user.
    • Remove an alert from a user.
    • Change the frequency of alerts.

    Enhance the Windows SharePoint Services search service.

    • Create a custom SPQuery object.
    • Perform a cross-site search.

    Customize user access and permissions.

    • Add a user to a site group.
    • Remove a user from a site group.
    • Change a user's permissions to edit a list.

    Manipulate items in lists.

    • Create a list item.
    • Update a list item.
    • Delete a list item.
    • Enumerate list items.
    • Add a photo to a picture library.
    • Add a recurring event to a calendar.
    • Delete a thread in a discussion board.

    Manipulate documents in lists.

    • Upload a document.
    • Copy a document between document libraries.
    • Attach a document to a list item.
    • Move a document across sites.

    Manage records by using the records repository.

    • Enable the records repository for the Send to menu.
    • Submit a file to the records repository.
    • Manipulate source data by using record properties.
    • Retrieve a series on a file from the records repository.

    Manage document versions.

    • Check out a document.
    • Check in a document.
    • Rollback a document version.
    • Display all versions of a document.

    Manipulating Site Configuration by Using the API

    Manipulate a list structure.

    • Dynamically add a custom action to a list.
    • Create a list object and add a column to the list object.
    • Create a custom view for a list.
    • Create a dynamic column type on a list.
    • Create a document template and assign it to a document library.

    Customize Web Part behaviour based on feature availability.

    Dynamically handle events.

    • Dynamically register an event receiver for a site event.
    • Dynamically register an event receiver for a list event.
    • Dynamically register an event receiver for a feature event.

    Manage site hierarchy.

    • List the IIS virtual servers on a Windows SharePoint Services server farm.
    • List the sites available to the current user.
    • Create a site.

    Customize navigation in a Windows SharePoint Services site.

    • Add an item to the QuickLaunch menu.
    • Modify an item on the top navigation menu.

    Manage groups and group membership.

    • Create a custom site group and set permissions for the group.
    • Add a cross-site group to a site group on different site.
    Posted May 08 2008, 10:54 PM by Brett with 7 comment(s)
    Filed under:
  • Preparing for exam 70-536: TS: Microsoft .NET Framework 2.0—Application Development Foundation

    About the exam

    The Technology Specialist (TS) exam 70-536: TS: Microsoft .NET Framework 2.0—Application Development Foundation is one of the core exams for all the .NET Framework 2.0 certifications.

    This exam tests your knowledge of Microsoft .NET Framework 2.0 and the implied knowledge of the Common Language Runtime and basic functionality it provides.

    Once you have mastered this contents of the exam you will truly have a good understanding of the framework and will be able to tackle a large variety of systems.  The content of the exam is intended for developers with experience in developing .NET based applications and is geared to assist them in mastering the framework.

    My personal feeling is any senior developer worth his salt should know this content well and be able to mentor junior programmers and coders through this exam if you are a senior programmer.   For the junior coders and programmers, here is your chance to take a leap to the next level .. just do it!

    This post and acknowledgements

    I have copied information from http://www.microsoft.com/learning/exams/70-536.mspx and have added my three cents worth through the subject matter.  My intent is over time to blog on all the topics making this site a conclusive guide to the .NET Framework and developer skill.

    Ambitious .. I know .. Want to help  Send me a PM and lets do it together.  If not I hope you enjoy the journey learning as I have will enjoy doing this for you.

    Exam objectives

    The following list includes the topic areas covered on this exam. The percentage indicates the portion of the exam that addresses a particular skill.

    Objective 1 - Developing applications that use system types and collections (15 percent)

    This objective is to test your knowledge of data types and how they work within the framework.  That is classes, structures, arrays, collections and generics.  There is a big drive in this section on the various types of collections, know them and all the associated standard interfaces.

    Many core features such as garbage collection, using delegates and events are also covered.

    Objective 2 - Implementing service processes, threading, and application domains in a .NET Framework application (11 percent)

    Now that the basics are over lets get into windows and how processes are loaded, working with threads and creating services. Forget about a simple Windows Forms application, we are talking real applications here.

    Objective 3 - Embedding configuration, diagnostic, management, and installation features into a .NET Framework application (14 percent)

    This section takes configuration to the next level and instead of simply using it, lets program around the configuration model. Part of this section includes understanding custom windows installers and how to develop one. The focus then changes to running your application, managing the processes running, adding diagnostics, implementing tracing and debugging and auditing events .. i.e. application management

    Objective 4 - Implementing serialization and input/output functionality in a .NET Framework application (18 percent)

    Up to know you should have already played with serialisation, streams and general IO. This objective expects you now to master it and know the different types of streams, and the ins and outs of IO management.

    Objective 5 - Improving the security of the .NET Framework applications by using the .NET Framework 2.0 security features (20 percent)

    Now this is were we say goodbye to the want-to-be's and for the rest let really implement security how the .NET Framework expects us to do it. Forget about rolling your own security, learn this and I am sure you will gain a new respect for the MS team and the .NET framework. Security in the framework is powerful when you know what it can do, where to find it and how to use it.

    Objective 6 - Implementing interoperability, reflection, and mailing functionality in a .NET Framework application (11 percent)

    If you have not worked with reflection up to now, you do not know what you are missing ... here is your chance.

    Objective 7 - Implementing globalisation, drawing, and text manipulation functionality in a .NET Framework application (11 percent)

    This is the "Catch All Else" objective with some very useful and good to know topics.

    Audience profile

    Candidates for this exam work on a team in a medium or large development environment that uses Microsoft Visual Studio 2005.

    Candidates learning the materials should have at least two to three years of experience developing Web-based, Microsoft Windows-based, or distributed applications by using the .NET Framework 1.0, the .NET Framework 1.1, and the .NET Framework 2.0. Candidates should have a working knowledge of Visual Studio 2005.

    Credit toward certification

    When you pass Exam 70-536: TS: Microsoft .NET Framework 2.0—Application Development Foundation, you earn credit toward the following certifications:

    • Microsoft Certified Technology Specialist: .NET Framework 2.0 Web Applications
    • Microsoft Certified Technology Specialist: .NET Framework 2.0 Windows Applications
    • Microsoft Certified Technology Specialist: .NET Framework 2.0 Distributed Applications

    Code languages

    When the exam begins, you can choose the programming language in which the code segments will appear. The available code languages for this exam are:

    • Microsoft Visual Basic 2005
    • Microsoft Visual C# 2005
    • Microsoft Visual C++ 2005

    Preparation tools and resources

    To help you prepare for this exam, Microsoft Learning recommends that you have hands-on experience with the product and that you use the following training resources. These training resources do not necessarily cover all of the topics listed in the "Skills measured" section.

    Skills measured

    This certification exam measures your knowledge of the fundamentals of the .NET Framework 2.0. Before taking the exam, you should be proficient in the job skills that are listed in the following table. The table lists Official Microsoft Learning Products that may help you reach competency in the skills being tested in the exam.

    Manage data in a .NET Framework application by using the .NET Framework 2.0 system types. (Refer System namespace)

    • Value types
    • Nullable type
    • Reference types
    • Attributes
    • Generic types
    • Exception classes
    • Boxing and UnBoxing
    • TypeForwardedToAttribute Class

    Manage a group of associated data in a .NET Framework application by using collections. (Refer System.Collections namespace)

    • ArrayList class
    • Collection interfaces
    • ICollection interface and IList interface
    • IComparer interface and IEqualityComparer interface
    • IDictionary interface and IDictionaryEnumerator interface
    • IEnumerable interface and IEnumerator interface
    • Iterators
    • Hashtable class
    • CollectionBase class and ReadOnlyCollectionBase class
    • DictionaryBase class and DictionaryEntry class
    • Comparer class
    • Queue class
    • SortedList class
    • BitArray class
    • Stack class

    Improve type safety and application performance in a .NET Framework application by using generic collections. (Refer System.Collections.Generic namespace)

    • Collection.Generic interfaces
    • Generic IComparable interface (Refer System Namespace)
    • Generic ICollection interface and Generic IList interface
    • Generic IComparer interface and Generic IEqualityComparer interface
    • Generic IDictionary interface
    • Generic IEnumerable interface and Generic IEnumerator interface IHashCodeProvider interface
    • Generic Dictionary
    • Generic Dictionary class and Generic Dictionary.Enumerator structure
    • Generic Dictionary.KeyCollection class and Dictionary.KeyCollection.Enumerator structure
    • Generic Dictionary.ValueCollection class and Dictionary.ValueCollection.Enumerator structure
    • Generic Comparer class and Generic EqualityComparer class
    • Generic KeyValuePair structure
    • Generic List class, Generic List.Enumerator structure, and Generic SortedList class
    • Generic Queue class and Generic Queue.Enumerator structure
    • Generic SortedDictionary class
    • Generic LinkedList
    • Generic LinkedList class
    • Generic LinkedList.Enumerator structure
    • Generic LinkedListNode class
    • Generic Stack class and Generic Stack.Enumerator structure

    Manage data in a .NET Framework application by using specialized collections. (Refer System.Collections.Specialized namespace)

    • Specialized String classes
    • StringCollection class
    • StringDictionary class
    • StringEnumerator class
    • Specialized Dictionary
    • HybridDictionary class
    • IOrderedDictionary interface and OrderedDictionary class
    • ListDictionary class
    • Named collections
    • NameObjectCollectionBase class
    • NameObjectCollectionBase.KeysCollection class
    • NameValueCollection class
    • CollectionsUtil
    • BitVector32 structure and BitVector32.Section structure

    Implement .NET Framework interfaces to cause components to comply with standard contracts. (Refer System namespace)

    • IComparable interface
    • IDisposable interface
    • IConvertible interface
    • ICloneable interface
    • IEquatable interface
    • IFormattable interface

    Control interactions between .NET Framework application components by using events and delegates. (Refer System namespace)

    • Delegate class
    • EventArgs class
    • EventHandler delegates

    Implementing service processes, threading, and application domains in a .NET Framework application Practice questions

    Implement, install, and control a service. (Refer System.ServiceProcess namespace)

    • Inherit from ServiceBase class
    • ServiceController class and ServiceControllerPermission class
    • ServiceInstaller and ServiceProcessInstaller class
    • SessionChangeDescription structure and SessionChangeReason enumeration

    Develop multithreaded .NET Framework applications. (Refer System.Threading namespace)

    • Thread class
    • ThreadPool class
    • ThreadStart delegate and ParameterizedThreadStart delegate
    • Timeout class, Timer class, TimerCallback delegate, WaitCallback delegate, WaitHandle class, and WaitOrTimerCallback delegate
    • ThreadState enumeration and ThreadPriority enumeration
    • ReaderWriterLock class
    • AutoResetEvent class and ManualResetEvent class
    • IAsyncResult interface (Refer System namespace)
    • EventWaitHandle class, RegisterWaitHandle class, SendOrPostCallback delegate, and IOCompletionCallback delegate
    • Interlocked class
    • ExecutionContext class, HostExecutionContext class, HostExecutionContext Manager class, and ContextCallback delegate
    • LockCookie structure, Monitor class, Mutex class, and Semaphore class

    Create a unit of isolation for common language runtime in a .NET Framework application by using application domains. (Refer System namespace)

    • Create an application domain.
    • Unload an application domain.
    • Configure an application domain.
    • Retrieve setup information from an application domain.
    • Load assemblies into an application domain.

    Embedding configuration, diagnostic, management, and installation features into a .NET Framework application Practice questions

    Embed configuration management functionality into a .NET Framework application. (Refer System.Configuration namespace)

    • Configuration class and ConfigurationManager class
    • ConfigurationElement class, ConfigurationElementCollection class, and ConfigurationElementProperty class
    • ConfigurationSection class, ConfigurationSectionCollection class, ConfigurationSectionGroup class, and ConfigurationSectionGroupCollection class
    • Implement ISettingsProviderService interface
    • Implement IApplicationSettingsProvider interface
    • ConfigurationValidatorBase class

    Create a custom Microsoft Windows Installer for the .NET Framework components by using the System.Configuration.Install namespace, and configure the .NET Framework applications by using configuration files, environment variables, and the .NET Framework Configuration tool (Mscorcfg.msc).

    • Installer class
    • Configure which runtime version a .NET Framework application should use.
    • Configure where the runtime should search for an assembly.
    • Configure the location of an assembly and which version of the assembly to use.
    • Direct the runtime to use the DEVPATH environment variable when you search for assemblies.
    • AssemblyInstaller class
    • ComponentInstaller class
    • Configure a .NET Framework application by using the .NET Framework Configuration tool (Mscorcfg.msc).
    • ManagedInstallerClass class
    • InstallContext class
    • InstallerCollection class
    • InstallEventHandler delegate
    • Configure concurrent garbage collection.
    • Register remote objects by using configuration files.

    Manage an event log by using the System.Diagnostics namespace.

    • Write to an event log.
    • Read from an event log.
    • Create a new event log.

    Manage system processes and monitor the performance of a .NET Framework application by using the diagnostics functionality of the .NET Framework 2.0. (Refer System.Diagnostics namespace)

    • Get a list of all running processes.
    • Retrieve information about the current process.
    • Get a list of all modules that are loaded by a process.
    • PerformanceCounter class, PerformanceCounterCategory, and CounterCreationData class
    • Start a process both by using and by not using command-line arguments.
    • StackTrace class
    • StackFrame class

    Debug and trace a .NET Framework application by using the System.Diagnostics namespace.

    • Debug class and Debugger class
    • Trace class, CorrelationManager class, TraceListener class, TraceSource class, TraceSwitch class, XmlWriterTraceListener class, DelimitedListTraceListener class, and EventlogTraceListener class
    • Debugger attributes
    • DebuggerBrowsableAttribute class
    • DebuggerDisplayAttribute class
    • DebuggerHiddenAttribute class
    • DebuggerNonUserCodeAttribute class
    • DebuggerStepperBoundaryAttribute class
    • DebuggerStepThroughAttribute class
    • DebuggerTypeProxyAttribute class
    • DebuggerVisualizerAttribute class

    Embed management information and events into a .NET Framework application. (Refer System.Management namespace)

    • Retrieve a collection of Management objects by using the ManagementObjectSearcher class and its derived classes.
    • Enumerate all disk drivers, network adapters, and processes on a computer.
    • Retrieve information about all network connections.
    • Retrieve information about all services that are paused.
    • ManagementQuery class
    • EventQuery class
    • ObjectQuery class
    • Subscribe to management events by using the ManagementEventWatcher class.

    Implementing serialization and input/output functionality in a .NET Framework application Practice questions

    Serialize or deserialize an object or an object graph by using runtime serialization techniques. (Refer System.Runtime.Serialization namespace)

    • Serialization interfaces
    • IDeserializationCallback interface
    • IFormatter interface and IFormatterConverter interface
    • ISerializable interface
    • Serilization attributes
    • OnDeserializedAttribute class and OnDeserializingAttribute class
    • OnSerializedAttribute class and OnSerializingAttribute class
    • OptionalFieldAttribute class
    • SerializationEntry structure and SerializationInfo class
    • ObjectManager class
    • Formatter class, FormatterConverter class, and FormatterServices class
    • StreamingContext structure

    Control the serialization of an object into XML format by using the System.Xml.Serialization namespace.

    • Serialize and deserialize objects into XML format by using the XmlSerializer class.
    • Control serialization by using serialization attributes.
    • Implement XML Serialization interfaces to provide custom formatting for XML serialization.
    • Delegates and event handlers are provided by the System.Xml.Serialization namespace

    Implement custom serialization formatting by using the Serialization Formatter classes.

    • SoapFormatter class (Refer System.Runtime.Serialization.Formatters.Soap namespace)
    • BinaryFormatter class (Refer System.Runtime.Serialization.Formatters.Binary namespace)

    Access files and folders by using the File System classes. (Refer System.IO namespace)

    • File class and FileInfo class
    • Directory class and DirectoryInfo class
    • DriveInfo class and DriveType enumeration
    • FileSystemInfo class and FileSystemWatcher class
    • Path class
    • ErrorEventArgs class and ErrorEventHandler delegate
    • RenamedEventArgs class and RenamedEventHandler delegate

    Manage byte streams by using Stream classes. (Refer System.IO namespace)

    • FileStream class
    • Stream class
    • MemoryStream class
    • BufferedStream class

    Manage the .NET Framework application data by using Reader and Writer classes. (Refer System.IO namespace)

    • StringReader class and StringWriter class
    • TextReader class and TextWriter class
    • StreamReader class and StreamWriter class
    • BinaryReader class and BinaryWriter class

    Compress or decompress stream information in a .NET Framework application (refer System.IO.Compression namespace), and improve the security of application data by using isolated storage. (Refer System.IO.IsolatedStorage namespace)

    • IsolatedStorageFile class
    • IsolatedStorageFileStream class
    • DeflateStream class
    • GZipStream class

    Improving the security of the .NET Framework applications by using the .NET Framework 2.0 security features Practice questions

    Implement code access security to improve the security of a .NET Framework application. (Refer System.Security namespace)

    • SecurityManager class
    • CodeAccessPermission class
    • Modify the Code Access security policy at the computer, user, and enterprise policy level by using the Code Access Security Policy tool (Caspol.exe).
    • PermissionSet class and NamedPermissionSet class
    • Standard Security interfaces
    • IEvidenceFactory interface
    • IPermission interface

    Implement access control by using the System.Security.AccessControl classes.

    • DirectorySecurity class, FileSecurity class, FileSystemSecurity class, and RegistrySecurity class
    • AccessRule class
    • AuthorizationRule class and AuthorizationRuleCollection class
    • CommonAce class, CommonAcl class, CompoundAce class, GenericAce class, and GenericAcl class
    • AuditRule class
    • MutexSecurity class, ObjectSecurity class, and SemaphoreSecurity class

    Implement a custom authentication scheme by using the System.Security.Authentication classes. (Refer System.Security.Authentication namespace)

    Encrypt, decrypt, and hash data by using the System.Security.Cryptography classes. (Refer System.Security.Cryptography namespace)

    • DES class and DESCryptoServiceProvider class
    • HashAlgorithm class
    • DSA class and DSACryptoServiceProvider class
    • SHA1 class and SHA1CryptoServiceProvider class
    • TripleDES and TripleDESCryptoServiceProvider class
    • MD5 class and MD5CryptoServiceProvider class
    • RSA class and RSACryptoServiceProvider class
    • RandomNumberGenerator class
    • CryptoStream class
    • CryptoConfig class
    • RC2 class and RC2CryptoServiceProvider class
    • AssymetricAlgorithm class
    • ProtectedData class and ProtectedMemory class
    • RijndaelManaged class and RijndaelManagedTransform class
    • CspParameters class
    • CryptoAPITransform class
    • Hash-based Message Authentication Code (HMAC)
    • HMACMD5 class
    • HMACRIPEMD160 class
    • HMACSHA1 class
    • HMACSHA256 class
    • HMACSHA384 class
    • HMACSHA512 class

    Control permissions for resources by using the System.Security.Permission classes. (Refer System.Security.Permission namespace)

    • SecurityPermission class
    • PrincipalPermission class
    • FileIOPermission class
    • StrongNameIdentityPermission class
    • UIPermission class
    • UrlIdentityPermission class
    • PublisherIdentityPermission class
    • GacIdentityPermission class
    • FileDialogPermission class
    • DataProtectionPermission class
    • EnvironmentPermission class
    • IUnrestrictedPermission interface
    • RegistryPermission class
    • IsolatedStorageFilePermission class
    • KeyContainerPermission class
    • ReflectionPermission class
    • StorePermission class
    • SiteIdentityPermission class
    • ZoneIdentityPermission class

    Control code privileges by using System.Security.Policy classes. (Refer System.Security.Policy namespace)

    • ApplicationSecurityInfo class and ApplicationSecurityManager class
    • ApplicationTrust class and ApplicationTrustCollection class
    • Evidence class and PermissionRequestEvidence class
    • CodeGroup class, FileCodeGroup class, FirstMatchCodeGroup class, NetCodeGroup class, and UnionCodeGroup class
    • Condition classes
    • AllMembershipCondition class
    • ApplicationDirectory class and ApplicationDirectoryMembershipCondition class
    • GacInstalled class and GacMembershipCondition class
    • Hash class and HashMembershipCondition class
    • Publisher class and PublisherMembershipCondition class
    • Site class and SiteMembershipCondition class
    • StrongName class and StrongNameMembershipCondition class
    • Url class and UrlMembershipConditon class
    • Zone class and ZoneMembershipCondition class
    • PolicyLevel class and PolicyStatement class
    • IApplicationTrustManager interface, IMembershipCondition interface, and IIdentityPermissionFactory interface

    Access and modify identity information by using the System.Security.Principal classes. (Refer System.Security.Principal namespace)

    • GenericIdentity class and GenericPrincipal class
    • WindowsIdentity class and WindowsPrincipal class
    • NTAccount class and SecurityIdentifier class
    • IIdentity interface and IPrincipal interface
    • WindowsImpersonationContext class
    • IdentityReference class and IdentityReferenceCollection class

    Implementing interoperability, reflection, and mailing functionality in a .NET Framework application Practice questions

    Expose COM components to the .NET Framework and the .NET Framework components to COM. (Refer System.Runtime.InteropServices namespace)

    • Import a type library as an assembly.
    • Add references to type libraries.
    • Type Library Importer (Tlbimp.exe)
    • Generate interop assemblies from type libraries.
    • Imported Library Conversion
    • Imported Module Conversion
    • Imported Type Conversion
    • Imported Member Conversion
    • Imported Parameter Conversion
    • TypeConverter class
    • Create COM types in managed code.
    • Compile an interop project.
    • Deploy an interop application.
    • Qualify the .NET Framework types for interoperation.
    • Apply Interop attributes, such as the ComVisibleAttribute class.
    • Package an assembly for COM.
    • Deploy an application for COM access.

    Call unmanaged DLL functions in a .NET Framework application, and control the marshaling of data in a .NET Framework application. (Refer System.Runtime.InteropServices namespace)

    • Platform Invoke
    • Create a class to hold DLL functions.
    • Create prototypes in managed code.
    • DllImportAttribute class
    • Call a DLL function.
    • Call a DLL function in special cases, such as passing structures and implementing callback functions.
    • Create a new Exception class and map it to an HRESULT.
    • Default marshaling behavior
    • Marshal data with Platform Invoke
    • Marshal data with COM Interop
    • MarshalAsAttribute class and Marshal class

    Implement reflection functionality in a .NET Framework application (refer System.Reflection namespace), and create metadata, Microsoft intermediate language (MSIL), and a PE file by using the System.Reflection.Emit namespace.

    • Assembly class
    • Assembly attributes
    • AssemblyAlgorithmIdAttribute class
    • AssemblyCompanyAttribute class
    • AssemblyConfigurationAttribute class
    • AssemblyCopyrightAttribute class
    • AssemblyCultureAttribute class
    • AssemblyDefaultAliasAttribute class
    • AssemblyDelaySignAttribute class
    • AssemblyDescriptionAttribute class
    • AssemblyFileVersionAttribute class
    • AssemblyFlagsAttribute class
    • AssemblyInformationalVersionAttribute class
    • AssemblyKeyFileAttribute class
    • AssemblyTitleAttribute class
    • AssemblyTrademarkAttribute class
    • AssemblyVersionAttribute class
    • Info classes
    • ConstructorInfo class
    • MethodInfo class
    • MemberInfo class
    • PropertyInfo class
    • FieldInfo class
    • EventInfo class
    • LocalVariableInfo class
    • Binder class and BindingFlags
    • MethodBase class and MethodBody class
    • Builder classes
    • AssemblyBuilder class
    • ConstructorBuilder class
    • EnumBuilder class
    • EventBuilder class
    • FieldBuilder class
    • LocalBuilder class
    • MethodBuilder class
    • ModuleBuilder class
    • ParameterBuilder class
    • PropertyBuilder class
    • TypeBuilder class

    Send electronic mail to a Simple Mail Transfer Protocol (SMTP) server for delivery from a .NET Framework application. (Refer System.Net.Mail namespace)

    • MailMessage class
    • MailAddress class and MailAddressCollection class
    • SmtpClient class, SmtpPermission class, and SmtpPermissionAttribute class
    • Attachment class, AttachmentBase class, and AttachmentCollection class
    • SmtpException class and SmtpFailedReceipientException class
    • SendCompletedEventHandler delegate
    • LinkedResource class and LinkedResourceCollection class
    • AlternateView class and AlternateViewCollection class

    Implementing globalization, drawing, and text manipulation functionality in a .NET Framework application Practice questions

    Format data based on culture information. (Refer System.Globalization namespace)

    • Access culture and region information in a .NET Framework application.
    • CultureInfo class
    • CultureTypes enumeration
    • RegionInfo class
    • Format date and time values based on the culture.
    • DateTimeFormatInfo class
    • Format number values based on the culture.
    • NumberFormatInfo class
    • NumberStyles enumeration
    • Perform culture-sensitive string comparison.
    • CompareInfo class
    • CompareOptions enumeration
    • Build a custom culture class based on existing culture and region classes.
    • CultureAndRegionInfoBuilder class
    • CultureAndRegionModifier enumeration

    Enhance the user interface of a .NET Framework application by using the System.Drawing namespace.

    • Enhance the user interface of a .NET Framework application by using brushes, pens, colors, and fonts.
    • Brush class
    • Brushes class
    • SystemBrushes class
    • TextureBrush class
    • Pen class
    • Pens class
    • SystemPens class
    • SolidBrush class
    • Color structure
    • ColorConverter class
    • ColorTranslator class
    • SystemColors class
    • StringFormat class
    • Font class
    • FontConverter class
    • FontFamily class
    • SystemFonts class
    • Enhance the user interface of a .NET Framework application by using graphics, images, bitmaps, and icons.
    • Graphics class
    • BufferedGraphics class
    • BufferedGraphicsManager class
    • Image class
    • ImageConverter class
    • ImageAnimator class
    • Bitmap class
    • Icon class
    • IconConverter class
    • SystemIcons class
    • Enhance the user interface of a .NET Framework application by using shapes and sizes.
    • Point Structure
    • PointConverter class
    • Rectangle Structure
    • RectangleConverter class
    • Size Structure
    • SizeConverter class
    • Region class

    Enhance the text handling capabilities of a .NET Framework application (refer System.Text namespace), and search, modify, and control text in a .NET Framework application by using regular expressions. (Refer System.RegularExpressions namespace)

    • StringBuilder class
    • Regex class
    • Match class and MatchCollection class
    • Group class and GroupCollection class
    • Encode text by using Encoding classes
    • Encoding class
    • EncodingInfo class
    • ASCIIEncoding class
    • UnicodeEncoding class
    • UTF8Encoding class
    • Encoding Fallback classes
    • Decode text by using Decoding classes.
    • Decoder class
    • Decoder Fallback classes
    • Capture class and CaptureCollection class

    Where to next

    Well keep coming back to this post as I will keep editing links in it as time goes on to content to the topics.

More Posts
Add to Technorati Favorites
Powered by Community Server (Commercial Edition), by Telligent Systems
Afrigator