just coding...

Managing Complex CRM Scenarios by Using the SolutionPackager Tool

In enterprise scenarios, it is a common requirement to be able to deliver common or separate CRM modules to separate business units according to an enterprise-level or separate roll-out timeline.

The typical challenges of this scenario result from parallel development tracks and frequent changes to enterprise projects, which require the greatest degree of flexibility in every aspect:

§ Sharing common code/customization base

§ Managing solution layering and dependencies

§ Managing localization

§ Managing changes in layering (moving items to common or back, customizing common elements locally)

§ Versioning common and local solutions

§ Parallel development on multiple solutions, multiple solution-layer setups, and multiple versions of a solution

§ Central repository of every/any solution

§ Test and deploy all possible or required combination of solution layers

§ Managing solution branch and merge

§ Regression testing changes and impacts across solutions and branches

§ Common, single versioning of all solution elements

Development and Version Control

You need streamlined and common techniques of development and repository management for complex enterprise deliveries. The standard features of Microsoft Team Foundation Server serve as the basis of larger application delivery management scenarios:


§ Debugging and diagnostics

§ Testing tools

§ Architecture and modeling

§ Database development

§ Integrated development environment

§ Build management and automation

§ Version control

§ Test case management

§ Work item tracking

§ Reports and dashboards

§ Lab management

When working with multiple development teams developing multiple solutions and versions in parallel on an enterprise delivery, the following base process is minimally recommended:

§ Developers should have isolated VMs to work on either hosted locally or centrally to share infrastructure between team members. Every developer work-item needs to be committed to the TFS environment (integration environment).

§ The development lead is in charge of making sure that the developments (customizations, configurations, and custom source files) can integrate in the integration environment without any side effects.

§ The TFS source control should be considered as the central repository for all solution items:

§ All CRM customizations (Entities, forms, views, workflows, templates, web resources, etc.)

§ Base data

§ Source codes and projects for custom components

o Plug-ins, custom activities

o Custom web applications

o Custom .Net components

o Custom services and other external components

o Web resource files

§ External components and references (SDK, Enterprise Library, etc.)

§ Unit test source codes for above components

§ Automated test sources for the entire application

§ Setup package for the entire application

§ Deployment scripts for the packages

§ Build definition for the entire application

The customer requirements and the work-item break-down should be stored in TFS work-item management. This way the development check-ins can be connected to the work-items, and the built-in development tracking and reporting functions of TFS can be leveraged. You will also be able to use the change-impact analysis functions of TFS for risk analysis and selecting the regression test scenarios for a specific change-set.

In multi-feature and multi-team scenarios you usually need multiple development and test environments, probably using different versions of the application. The TFS build automation and lab management functions provide the necessary toolset for managing daily build and deployment steps. You find more details about the topic in the Build and Test sections.

Version Control Process

The CRM customizations are out-of-the-box bound to a single CRM solution zip file, which requires special techniques to manage as part of a source control system.

The SolutionPackager tool (see Use the SolutionPackager Tool to Compress and Extract a Solution File) is designed to unpack (split) a solution .zip file into a broad set of files within folders by entity name. The breakout into files enables that modifications to different components will not cause changes to occur in the same files. For example, modifying an entity Form and a View would result in changes in different files (hence no conflicts to resolve). Pack will take the files from disk and glue them back together to construct a managed or unmanaged .zip file.

The development process for Solution Packages with the SolutionPackager tool is illustrated in the following graphic.


The developer works on his/her daily environment to work on the CRM development task allocated. Before starting a work item the developer (or the build master) gets the latest version of customization tree from TFS and uses the SolutionPackager tool to create the solution zip file. The developer (or the build master) deploys the latest solution package on the development environment. The same solution can also be deployed to the test CRM environment.

At the end of a day or after finishing a work item, the developer exports the solution zip file from the development environment. Executing the SolutionPackager tool on the zip file will generate the separate customization elements of the entire solution. The customization files need to be checked out and checked-in individually only when changed.

The Visual Studio project may be created manually. The SolutionPackager tool will automatically create the folder structure below that (the unpack script need to be executed in the solution project folder).

Manual Steps

The current version of SolutionPackager tool provides the basic functionality to convert the packaged customization zip file to a version controllable folder structure. The following manual steps are still needed by the developers or test leads to be able to maintain the source tree:

1.   Check-in check-out of specific customization elements, which will be affected by a work-item change.

2.   Execute the pack/unpack operation manually and selecting the changed customization elements (Note: this can be integrated into the clean and deploy process of the Developer Toolkit).

3.   Taking care of the managed and unmanaged version of components at check-in time.

4.   Managing the assembly versioning (FQ strong names) of plug-ins used by a CRM solution.

5.   Managing RibbonDiffXML (merging changes).

The following techniques may be used to further support the version control process:

§ Removing assembly strong names from customization files to be able to track only the real changes.

§ Some schema parts are reordered randomly during solution import-export; these elements may be ordered alphabetically to more convenient source control tracking.

Localization Challenges

Enterprise CRM projects usually face the requirement of supporting multiple locales. Although CRM has OOB support for localization, it is always a challenge to provide full solution localization because different components required different localization strategies, and the explosion of components may be required.

Localization of some specific CRM components is currently not supported or not applicable. For example:

§ Workflows

§ Dialogs

§ Templates

CRM Developer Toolkit

§ Roles & FLS profiles

§ Plug-in assemblies

The CRM Developer Toolkit may be used for daily developer work for creating streamlined plug-ins, generating codes, solutions, and accessing CRM customization pages. The source code should be checked in directly under TFS. The applied customizations can be exported, unpacked from the CRM organization, and the specific changed elements can be checked in manually.

Note: The Developer Toolkit can support the process of packing and unpacking by turning on the ability to export a CRM Solution as part of the local deployment process.

Sitemap, Ribbon Editor

The CRM customization system only supports editing the sitemap and ribbon definition manually as xml files, after a manual export and followed by an import operation. The SiteMap and Ribbon Editor tools provide a graphical UI for executing these types of customizations.

These tools can be also combined with the unpacked structure:

§ Sitemap.xml is unpacked into a separate xml file and can be directly edited by SiteMap Editor.

§ The Ribbon Editor supports editing directly on a CRM environment, so developers need to edit on the server and then unpack the solution zip file and check-in the changes.

Daily Developer Work

The developers should use unmanaged solutions and shared configuration environments during development time. One developer usually works on one solution (either CRM or other Visual Studio solution), but multiple developers can work on the same solution in parallel.


The developer environments should be typically updated on a per-day basis using the last successful build. You should consider the best environment allocation and setup strategy for your team, depending on the actual project and team setup (see Deployment and Test).

The developers typically use standard CRM customization UI for executing their daily work. They create CRM customization elements (entities, screens, ribbons, views, dialogs, plug-in registrations, etc.). They may use Visual Studio for creating custom developed plug-ins, web applications, or other components, and may also use other external tools such as resource editors, designers, sitemap, ribbon, and metadata editor for CRM.

The editing of external components and resources can be typically executed offline on the developer machine after executing the TFS check-out operation (VS built-in editors usually manages check-out automatically).

Just before the check-in, they need to export the solution from the CRM environment and execute a special batch file per solution, which will unpack the customization file.

Developers need to take care of the actual check-in. They need to be aware of the executed changes and which schema members it affected. Only the changed elements need to be checked-in, and there are also special cases when the check-in elements need also to be merged back or compared to the previous version (for example, ribbonDiffXml).

Before the actual check-in operation, the developer must get the latest sources and create a local build, including a solution package, to deploy and test in the development environment; this is the recommended practice for quality check-ins. This process may be also supported by the Gated Check-in or Continuous Integration feature of TFS.

The daily development process is illustrated in the following figure.


Build Automation

The build process can be automated using the standard TFS build agent. The build agent is a Windows service that executes the processor-intensive and disk-intensive work associated with tasks such as getting files from and checking files into the version control system, provisioning the workspace for the builds, compiling the source code, and running tests.


A typical build process consists of the following steps:

1.   Getting the build definition (You may have multiple parallel projects/builds.)

2.   Update build number (solution versioning)

3.   Prepare build context

a.   Create drop location

b.   Get build agent

c.Get build directory and initialize workspace

4.   Get source files

5.   Compile sources and create setup packages

6.   Run unit tests

7.   Process test results

8.   Drop build and notify

The build process may be extended further by automated deployment and testing (for more details see the Build, Test and Deployment sections):

§ Rollback test environments

§ Deploying setup packages to test environments

§ Executing automated test steps/schedule manual test scenarios

Offline Build Process

The offline build process is designed as an independent build flow enabled to execute the building of a whole CRM solution package without a running instance of Dynamics CRM. The offline build process leverages the static schema of the solution elements and customization files (see Development and Version Control).


The build process can be easily extended to use the SolutionPackager tool. The CRM Solution Builder project template and target file samples can be used to integrate the pack operation into the daily build process (see CRM Solution Builder).

During the build process, the Visual Studio standard projects will be compiled, built, and dropped as defined in the build and project definitions.

Building the CRM customization project will trigger the pack operation will the up-to-date customization source tree (see solution tree structure above). All customizations will be merged together as a single customization.xml and solution.xml file. The previously built solution resources and assemblies can be included directly in the solution package.

Note: ILMerge operation may be required to make DB-registered assemblies work with referenced assemblies.

Automating Deployment

The deployment automation of packed CRM solution can be executed identically to standard CRM solution deployment.

On enterprise projects the following scenarios can cover the typical deployment requirements:

§ Automated deployment of development environments, test environments, and integration environments

§ Offline setup packages and scripts to enable deployment to acceptance and production environment as a sandbox

§ Rollback environments to a baseline (both CRM components and the CRM database)

o May already contain existing solutions and possible CRM Update Rollups

§ Deploying CRM solutions

§ Deploying CRM base data and custom security roles

§ Additional configuration of the organization, BU, and user settings using the CRM API

Note: For further details on CRM automated deployment process see the Test and Deployment sections.

Managed/Unmanaged Solutions

The version control differences between managed and unmanaged solutions are already described in Managing Version Requirements section. The SolutionPackager tool will process and unpack both types of solutions. The unpack process will create the differencing elements with “managed” postfix for easier version control management.

The general recommendations for using managed or unmanaged solutions:

§ Use unmanaged solutions for development.

§ Use managed solutions for all downstream environments.

§ Use as few solutions as possible for easier management.

§ Customize existing managed solutions as little as possible.

§ Execute integration tests using managed solutions frequently to test and address possible collisions.

§ Test managed solution combinations for every possible or supported scenario.

Avoid selecting all columns via Microsoft Dynamics CRM query APIs

For optimal performance, you should only select the minimum amount of data needed by your application when querying CRM data.  Queries that include a defined ColumnSet where the ColumnSet.AllColumns property is 'true' instruct the CRM data access platform to issue a SELECT * on all physical data included in the query plan.  This scenario should be avoided whenever possible.  

Violation Examples

ColumnSet.AllColumns setter method call

    var columns = new ColumnSet();

    columns.AllColumns = true;


    var query = new QueryExpression("account");

    query.ColumnSet = columns;


    var results = service.RetrieveMultiple(query);

ColumnSet(bool allColumns) constructor overload

    var query = new QueryExpression("account")


        ColumnSet = new ColumnSet(true)



    var results = service.RetrieveMultiple(query);

ColumnSet(bool allColumns) constructor overload for RetrieveRequest

    var entity = service.Retrieve("account"Guid.NewGuid(), new ColumnSet(true));

Guideline Examples 


ColumnSet(param string[] columns) constructor overload for QueryExpression

    var query = new QueryExpression("account")


        ColumnSet = new ColumnSet("name""address1_city")



    var results = service.RetrieveMultiple(query);

ColumnSet(param string[] columns) constructor overload for RetrieveRequest

    var entity = service.Retrieve("account"Guid.NewGuid(), new ColumnSet("name""address1_city"));

ColumnSet.AddColumn(string column) method call

    var query = new QueryExpression("account");




    var results = service.RetrieveMultiple(query);

ColumnSet.AddColumns(param string[] columns) method call

    var query = new QueryExpression("account");



    var results = service.RetrieveMultiple(query);

Usage of the Retrieve method should set the columnSet parameter to a ColumnSet instance with specified columns.  Usage of QueryExpression should set the  QueryBase.ColumnSet property with the required attributes. 

The following messages contain reference a ColumnSet instance:


ConvertQuoteToSalesOrderRequest Class 

ConvertSalesOrderToInvoiceRequest Class 

GenerateInvoiceFromOpportunityRequest Class 

GenerateQuoteFromOpportunityRequest Class 

GenerateSalesOrderFromOpportunityRequest Class 

QueryByAttribute Class 

QueryExpression Class 

RetrieveAllChildUsersSystemUserRequest Class 

RetrieveBusinessHierarchyBusinessUnitRequest Class 

RetrieveMembersTeamRequest Class 

RetrieveRequest Class 

RetrieveSubsidiaryTeamsBusinessUnitRequest Class 

RetrieveSubsidiaryUsersBusinessUnitRequest Class 

RetrieveTeamsSystemUserRequest Class 

RetrieveUnpublishedRequest Class 

RetrieveUserSettingsSystemUserRequest Class 

ReviseQuoteRequest Class 

SearchByBodyKbArticleRequest Class


Build queries with QueryExpression

In Microsoft Dynamics 365 (online & on-premises), you can use the QueryExpression class to programmatically build a query containing data filters and search conditions that define the scope of a database search. A query expression is used for single-object searches. For example, you can create a search to return all accounts that match certain search criteria. The QueryBase class is the base class for query expressions. There are two derived classes: QueryExpression and QueryByAttribute. The QueryExpression class supports complex queries. The QueryByAttribute class is a simple means to search for entities where attributes match specified values.

Query expressions are used in methods that retrieve more than one record, such as the IOrganizationService.RetrieveMultiple method, in messages that perform an operation on a result set specified by a query expression, such as BulkDeleteRequest and when the ID for a specific record is not known.

In addition, there is a new attribute on the organization entity, Organization.QuickFindRecordLimitEnabled. When this Boolean attribute is true, a limit is imposed on quick find queries. If a user provides search criteria in quick find that is not selective enough, the system detects this and stops the search. This supports a faster form of quick find and can make a big performance difference.


Use the QueryExpression Class

ColumnSet Class

Use of the ColumnSet Class

Automating CRM Test Cases

The first level of CRM automated test cases consists of the database and schema unit tests that validate the general structure and data of a deployed CRM solution. 

The second level of CRM tests should include more extensive API tests to check the consistency of CRM query and update operations and test the functionalities of deployed plug-ins and workflows. Negative and positive test scenarios should also be included to test the error and exception branches of the application. 

The third level of automated CRM tests consists of the functional tests. Functional testing of CRM solutions are similar to any ASP.NET or other web applications testing methods, leveraging the web testing framework of Visual Studio environment. 

Two possible automation techniques are available using Visual Studio for automated UI tests: Captured web tests and Coded UI tests. 

The first scenario is recommended to quickly capture and create automated test cases for a specific CRM form or functionality. The captured test scenario will contain all web requests and responses executed by the client browser. Visual Studio test framework provides a lot of tools to pre- and post- process the tests; however, to be able to rerun a captured Web Test, a lot of manual work is still required (for example, extracting CRM view IDs, entity IDs, parameterizing data entries, and randomizing search clauses and data). The captured and parameterized Web Tests can usually support only a specific functional version of a CRM form. After changing the flow of the tested functionality, a recapture of the test is usually be required. 

Creating coded UI tests usually requires more effort for developers but can be more general, making it possible to support even larger structural changes on the tested forms. Coded UI tests can be created either by converting a captured Web Test, or by reusing the existing samples and common components provided by the CRM 2011 Performance Toolkit. 

Using automated tests and Visual Studio for tracking requirements and connecting work-items to check-ins provides the ability for bugs and resolution check-ins to be traced back to the specific requirement and test scenario. In fact, with the Visual Studio test framework, it is possible to track code changes and their impacts through to the application and test suites, including which test cases are required to be re-run. 

Note: To have this experience across all aspects of an enterprise Dynamics CRM delivery (including CRM customizations) requires an offline build process using the unpacked customization source tree. 

Azure Export Service ile SQL Server arasinda yasanan DB Link hatasinin cozumu

Data Export Servisi, Dynamics 365 verilerini bir Microsoft Azure aboneliğinde Microsoft Azure SQL Veritabanına kopyalayabilen  bir eklenti hizmetidir. Desteklenen hedef yerler Microsoft Azure SQL Veritabanı ve Microsoft Azure sanal makinelerinde Microsoft Azure SQL Server'dır. Data Export, başlangıçta tüm Dynamics 365 şemasını ve verilerini akıllı bir şekilde senkronize eder ve ardından Microsoft Dynamics 365 (çevrimiçi) sistemindeki değişiklikler (delta değişiklikleri) gibi sürekli olarak senkronize olur.

Bu servis hizmetinden yararlanabilmeniz icin asagidaki scripti Azure SQL Server ya da Sanal Makinadaki SQL Server bilgisi ile birlikte Dynamics 365 Hizmetinisin bilgilerini de icercek sekilde doldurup calistirmaxiz gerekmekte.

Data Export Servisinin nasıl yapilandiracagi ile ilgili bilgiye su adresten ulaşabilirsiniz : 

# -------------------------------------------------------------------------------- #

#  Provide the value for the following parameters before executing the script

$subscriptionId #burasi belirtilmeli#

$keyvaultName #burasi belirtilmeli#'

 $secretName #burasi belirtilmeli#'

 $resourceGroupName #burasi belirtilmeli#'

$location #burasi belirtilmeli#'

$connectionString #burasi belirtilmeli#'

$organizationIdList #burasi belirtilmeli#'

$tenantId #burasi belirtilmeli#'


# -------------------------------------------------------------------------------- #


# Login to Azure account, select subscription and tenant Id


Set-AzureRmContext -TenantId $tenantId -SubscriptionId$subscriptionId


# Create new resource group if not exists.

$rgAvail Get-AzureRmResourceGroup -Name $resourceGroupName-Location $location -ErrorAction SilentlyContinue


    New-AzureRmResourceGroup -Name $resourceGroupName-Location $location



# Create new key vault if not exists.

$kvAvail Get-AzureRmKeyVault -VaultName $keyvaultName -ResourceGroupName$resourceGroupName -ErrorAction SilentlyContinue


    New-AzureRmKeyVault -VaultName $keyvaultName -ResourceGroupName$resourceGroupName -Location $location

    # Wait few seconds for DNS entry to propagate

    Start-Sleep -Seconds15



# Create tags to store allowed set of Organizations.

$secretTags =@{}

foreach($orgId in $organizationIdList.Split(',')) {




# Add or update a secret to key vault.

$secretVaule ConvertTo-SecureString $connectionString -AsPlainText -Force

$secret Set-AzureKeyVaultSecret-VaultName $keyvaultName -Name $secretName -SecretValue$secretVaule -Tags $secretTags


# Authorize application to access key vault.

$servicePrincipal 'b861dbcc-a7ef-4219-a005-0e4de4ea7dcf'

Set-AzureRmKeyVaultAccessPolicy -VaultName $keyvaultName -ServicePrincipalName$servicePrincipal -PermissionsToSecrets get


# Display secret url.

Write-Host "Connection key vault URL is "$$secret.Version)""  

Benim değinmek istediğim konu ise bundan farklı. Bir sekilde bu hizmeti aktif hale getirdini ama burada oluşturulan verilere DB Link mantigi içerisinde ulaşmak istediğinizde;

"OLE DB provider "SQLNCLI11" for linked server "#########.DATABASE.WINDOWS.NET" returned message "Unspecified error". Msg 40515, Level 16, State 2, Line 1 Reference to database and/or server name in 'AdventureWorks2012.sys.sp_tables_info_90_rowset_64' is not supported in this version of SQL Server."

ya da 

"Failed to retrieve data for this request. (Microsoft.SqlServer.Management.Sdk.Sfc) Reference to database and/or server name in 'AdventureWorks2012.sys.sp_tables_rowset2' is not supported in this version of SQL Server. (Microsoft SQL Server, Error: 40515)"

seklinde hatalar ile karsılaşabilirsiniz. Iste bu sorunu çözmek icin mevcut DB Link baglantisini silmeniz ve asagidaki scripti kullanarak yeniden oluşturmanız gerekmekte. Bu islemi yaptiginizda sorun çözülecektir.

'database name'

@rmtsrvname = 
@useself = 
@rmtuser = 
'Azure login',
@rmtpassword = 

EXECsp_serveroption 'PROD','rpc out', true

Dynamics 365 CRM egitimi

Dynamics CRM, Dynamics 365 CRM’e dönüştü.  Bu dönüşümün detaylarını  CRM MVP'si olan uzman eğitmenlerimizden öğrenmek ister misiniz?

-Dynamics 365 sertifikasyon sınavlarına hazırlananlar,
-Dynamics 365 CRM geliştiricileri,
-Proje Yöneticileri
-Kullanıcılara yönelik hazırladığımız sertifikalı uzman eğitmenlerimizin vereceği eğitimleri kaçırmayın. 

Omerd CRM Eğitim serisi ile farklı seviyelerdeki profesyonellere uygun olarak planlanan eğitimlerimizin tüm detaylarına ve kayıt formuna buradan ulaşabilirsiniz. 

Eğitim Yeri : Wissen Akademi – Beşiktaş / İstanbul

Eğitim Konuları ve Ücretler:

14-15 Mayıs : Uygulama/Application – 2 Gün   
$399 + KDV

(Kimler Katılabilir: Her seviyedeki CRM kullanıcıları)

16-17 Mayıs : Özelleştirme/Customization 2 Gün 
$399 + KDV

(Kimler Katılabilir: Sistem Yöneticileri, Orta ve İleri Düzey CRM kullanıcıları)

21-23 Mayıs : Geliştirme/Extending – 3 Gün  
$499 +KDV

(Kimler Katılabilir: Yazılım Geliştiriciler)

14-23 Mayıs Tarihleri arasında Gerçekleştireceğimiz Eğitimimize Siz de Katılmak İsterseniz Lütfen "Kayıt Olun" Butonundan Rezervasyon Yaptırın.

Kayıt Olun!

CRM Solution Concepts

Solutions and layering are fundamental concepts within CRM that need to be fully appreciated and understood to construct an approach to lifecycle management for Dynamics CRM applications. There are three key concepts that need to be introduced:

§   Solution Packages: Act as containers for functionality required to be deployed as a unit

§   Layers: The consequence of a specific component being affected by change within one or more solutions

§   Managed Properties: The mechanism to control how layers interact with each other

Note: This appendix provides a “quick reference” overview of more detailed information that is presented in the Dynamics CRM 2011 SDK, in the section Package and Distribute Extensions.

Solution Packages

Solution packages are the container mechanism to transport Dynamics CRM configuration and customization between organizations. There are two types, unmanaged and managed.


§   Contains only customizations from the unmanaged layer

§   Will not include dependent components

§   Imports only into the unmanaged layer:

       Ideal during development

       Everything within could be changed

       Overwrites existing customizations

§   Contains a complete copy of each component


§   Will get its own layer on import.

§   Analogous to an installer “.msi” file; it is a distribution package.

§   Contents cannot be directly changed.

o    This does not mean DRM.

§   Components may be customized where managed properties allow.

§   Contains only deltas for component that supports merging (FormXML, Ribbon & Sitemap).


Layers should be considered on a per-component basis. Although typically drawn to convey the effect of a solution on another solution, this is always at a component level.


§   There is only one. It always exists.

§   All customizations made on this server/organization will reside here.

§   “Solutions” exist here as containers.

       Ownership by solutions is weak; by-reference only.

       No independence between solutions. If one component exists in two solutions, they both see the current state of the component equally.

§   New customizations made will trump all prior customizations. (They override the lower layers.)

§   Customizations cannot be undone, but they can be deleted.



§   There can be many:

o    Always one for the “system” solution.

o    Discrete layer for each managed solution package imported (at a per-component level).

§   Only created by importing a managed solution.

§   Time of import sets order of precedence.

§   You cannot customize components inside the layer.*

§   They can be deleted, replaced, and versioned.

§   Deleting a layer may delete data.

Managed Properties

Managed properties control how layers interact with each other; they control the level of customization achievable on top of components from a managed solution that has been imported. After releasing a managed solution, the managed properties can only be changed to reduce how restrictive they are.

§   Control order of precedence (which customizations to allow on top of an imported solution’s managed layer).

§   The ability to customize cannot be removed or disabled during solution update.

§   The ability to customize can be enabled during solution update.

§   The default ability to customize is fully customizable.

In general, if the consumers of the solution are not known or trusted or the changes that may be made could break the solution, it is recommended to lock down the managed properties for the solution. These managed properties can be opened back up to enable specific components to be customized at a later date as needed.

Merge Behavior


New customizations trump all prior customizations, overriding the lower layers.

Important: Changes applied by importing an unmanaged solution cannot be uninstalled. Do not install an unmanaged solution if you want to roll back the changes.

Managed (No Overwrite)

§   Customizations in unmanaged layer are preserved.

§   Importing newer versions creates new managed layers directly above the previous version’s managed layer.

§   Importing the same version replaces contents within the existing layer.

§   Importing cannot remove pre-existing components.

§   Generate and import a minimal solution to “hotfix” a larger solution.

§   Reports, E-mail templates, and plug-in assemblies skip updates if they are not the “top” layer.

Managed (Overwrite)

The recommended approach is to always preserve customizations (no overwrite). If the updates are mandatory for the solution to function appropriately, then overwrite is needed:

§   Replaces the content of the “unmanaged” layer and makes the managed solution the top layer.

§   Ensures that updates included in the solution are effective.

§   Overwrites all customizations and should be used with caution.

§   Greater use of managed properties makes this approach less necessary.

Dependency Tracking

The solutions framework automatically tracks dependencies across components.

§   The following operations perform dependency checks/operations:

       Individual components: CRUD, Add Existing (to a solution).

       Solution: Import, Export, Delete (uninstall).

§   Dependencies are version agnostic. As long as the unique name/id of the component and the package type matches, a dependency is considered valid.

       Managed components cannot depend on unmanaged components.

Shared Publishers

§   Components in managed layers will be owned by the solution publisher.

§   Publisher owns the component, not the solution.

§   Components with same name and publisher will be considered the same thing.

§   Removing a solution does not remove a component when it is referenced by another solution using the same, shared publisher.

§   Be wary of predictable names and collisions.

       For web-resources, create names that imply virtual directories


14 Nisan Microsoft Turkiye Dijital Donusum etkinligi "Turkiye Dijital Donusumun Neresinde?"

Bir etkinlikle daha yine karsinizdayiz. 14 Nisan gunu Microsoft Turkiye ofisinde sevgili Zehra Öney, Dr. Serhat TATLI, Murat Erdör, Mustafa Kara, Volkan Türkyılmaz ve Serkan Esen ile birlikte muthis bir etkinlik gerceklestirecegiz. "Turkiye Dijital Donusumun Neresinde?" isimli etkinligimizde Turkiye'de dijital donusum projelerini nasil yaptigimizi ya da yapamadigimizi irdeleyecegiz. adresinden etkinlige kayit olabilirsiniz.  Bu etkinligi kacirmayin uzulursunuz benden soylemesi...