As per best practice I have separated my BizTalk solution into projects based on artifacts (schema, pipelines, maps etc). I've also separated business processes into solution folders. I have created a common project to hold schema that need to be available for each and referenced these when needed... so far so good.
When I deploy it will deploy the common schema and each reference - resulting in multiple schemas. If I try to untick the dependency in the project assembly I get the error
This dependency was added by the project and cannot be removed.
Am I missing something?
Visual Studio 2012, BizTalk Server Dev Ed 2013.
Really, same answer as in the other post.
Consider the Visual Studio Solution as one Deployment Unit and build your processes around that. Meaning, all the Projects, Schemas, Maps, Orchestrations, would always go out together even if only one changed.
I try really hard to not share Schemas across Solutions specifically because of the Deployment issues. I do this even if it means duplicate or essentially duplicate Schemas. 99% of the time, the only thing that breaks is the automatic Schema resolution in the Xml Disassembler and that is easily solvable.
"When I deploy it will deploy the common schema and each reference - resulting in multiple schema"
Sorry, this part doesn't seem right. If you have a common Schema project, there shouldn't be duplicates.
Related
I want to develop an visual studio extension that does some automation for my sql database projects in visual studio. Among those task is adding the database references. I cannot find any way to do this from the extensions code.
I can get the proper project node retrieving ServiceProvider.GlobalProvider.GetService(typeof(DTE)) as EnvDTE80.DTE2;
and than iterating over the project in the solutions. But the project object seems to be of type Microsoft.VisualStudio.Data.Tools.Package.Project.IDatabaseProjectNode Which is marked internal and thus cannot be used by me.
Is there any official way to add database references (and do other sql database project specific things) or do I have to resort to editing the project files directly?
Sorry but the answer could be negative, after discussion with .net and SQL team, adding database reference is not supported for now.
Adding database reference is much more complex than adding normal reference(.dll), there exists no public API for this behavior in VS SDK.
We would like to manage a project structure where individual projects can take a part in a top level project structure sharing a single resource pool. It should be possible for individual authors to work on those individual projects, or possibly the same project, at the same time.
We are familiar with co-authoring in excel, word, etc (through sharepoint) and it works fine. We have licences for MS project 2019. But we can't seem to find a way to set up co-authoring, or find any definite statement as to whether it is even possible with project.
I have seen "Microsoft Project Server 2019" and "Project Online" mentioned, are these different products and are these needed?
Any guidance or info about this would be much appreciated,
Project Online is the Azure based version of the good old Project Server for on-premises. Both are so called Enterprise Project and Portfolio Management Tools. If you are looking for co-authoring in sense of concurrent editing, you will not be satisfied with both of them: You must checkout and checkin a plan for editing. If you are looking for true concurrent co-authoring you should take a look at the oncoming new Project Service. It explicitly allows co-authoring. Nevertheless it starts with very limited features, it is supposed to grow soon and fast.
https://www.microsoft.com/en-us/microsoft-365/blog/2018/09/25/a-new-vision-for-modern-work-management-with-microsoft-project/
https://techcommunity.microsoft.com/t5/Project-Blog/A-letter-to-our-Microsoft-Project-community/ba-p/260891
I am trying to setup an application and database in TFS 2017. For a standard windows application and SQL Database Project.
Should I combine the application project and the SQL Database Project into the same solution and Build together on TFS in the same Build Definition?
I a thinking these should be separate solutions in TFS and separate Build definitions in TFS. We can include multiple artifact references in TFS Release to deploy them both simultaneously.
Does this make sense?
Or does it make more sense to combine the solution and build definition into the same units of work?
Few questions to ask yourself:
Do the database changes need to go out with the code changes?
Probably combine them
Is the DB something maintained by another group that you just keep in sync? Maybe split them up
Is the database build adding a lot of time to your CI? Maybe split them up to improve performance, or cache the DacPac between builds
If they are in separate solutions, how are you planning to do code reviews or branching?
I've usually combined them, but have been thinking about something closer to the 3rd question to speed up builds.
A solution is a structure for organizing projects in Visual Studio. Whether combine the application project and the SQL Database Project into the same solution depends on your projects structure.
On TFS side, it's OK to use one build definition, as if you want to build only one project, you can specify the particular project.
I'm new to Biztalk. I wish to structure my artifacts into applications.
Should I go with one application per artifact type - for example 3 seperate applications, like 'BusinessProcess.Schemas', 'BusinessProcess.Maps', 'BusinessProcess.Maps', with all the assemblies related to these (typically just one), or do you think it best to just have one 'BusinessProcess' application, which would contain all assemblies related to the business process?
Should I go with one application per artifact type
I think in general, you mean one project per artifact type? Although artifacts common to more than one application should be split out into a separate application / solution.
The rationale for splitting BizTalk projects up into component projects (and assemblies) is similar to any other .Net project - separation of concerns, isolation for testing purposes, independent versioning, etc.
Most of these are addressed in Erik Westermann's great answer here
One point that to elaborate on is that the dependency chain usually looks something like this:
Schemas (Internal / Canonical, External)
^
Maps
^
Ports + Pipelines
^
Orchestrations
(plus other miscellaneous .Net assemblies with helpers)
On a server with multiple applications deployed, at some point you'll likely need to have cross-application dependencies (especially if you have chosen to couple to definite schemas and not loosely couple e.g. via multipart messages), usually on Internal / Canonical Schemas which are common to more than one project.
Unless these schemas are separated from the other assemblies, any time a monolithic application changes, you'll need to go through the pain of uninstalling / reinstalling all dependent apps every time any change is made to the monolithic app. Generally because the whole enterprise is dependent on the Canonical schemas, they are carefully deliberated and thus fairly stable, whereas an app's maps and orchestrations are more likely candidates for frequent change.
Here's a structure for this scenario:
Separate Common / Base Solution Projects:
Common internal schemas (event / EDA Meta information , internal
errors etc)
Canonical Domain schemas (i.e. the internal / enterprise
model of Invoices, Claims, Transactions etc of your business)
Helper assemblies for interacting with the above
Your application solution references the above, and then the commonly accepted separation is along the lines of the artifact types:
External system schemas (if more than one, then each in its own assembly)
Maps
Pipelines
Orchestrations
It's really a judgment call. If you have large app with lots of Schemas, Maps, Orchestrations, sure, it makes sense to split them out.
However, small apps, 10 or so artifacts, not so much.
For a new BizTalk Developer, I'd stick with stick with one "MyBusinessProcess" app. At some point, you'll see an when a multi-Project solution starts to make sense, then do it.
I'm doing some work with several shared .NET assemblies and a generic web application that I would like to handle better in our CC.NET/NAnt build environment.
Currently, we have several .NET assemblies (shared common code that we use in client projects) that exist in different .NET solutions within different repositories in our SCM (Vault incidentally). They are all configured under CC.NET separately so we have a decent amount of control over their build and deployment at present.
We have developed a CMS system that uses some of the .NET assemblies and includes a common administration website project and a template website example project. Out of this one solution we have the following elements that need to managed separately:
Admin interface is not tied to .NET so it is template based and we are developing a PHP backend for it currently.
CMS shared assembly build on top of our other common company wide assemblies.
Control over functionality within each major CMS build/release.
I'd like the build output of this solution to be a Visual Studio template, which we can use to develop other client sites and better manage version changes within the CMS itself, as we add features to the codebase.
I have a rough approach for all this and think it is achievable, however, I wanted to open this topic up for discussion and see what everyone else is doing when it comes to managing the build and deployment of multiple solutions.
Main considerations for us are:
Do we make use of the integration queue functionality in CC.NET to ensure a build order and pull together the assemblies we need for the CMS at build time?
Debugging within a CMS client site i.e. stepping into the shared assemblies' code when the client solution is a version of the base CMS system and therefore separate.
Developing and extending the CMS when it uses shared assemblies i.e. do we add the assembly projects to the trunk solution during development (across source control repositories) and then rely on the build to pull it together or do we use a different approach entirely?
Any other issues people might have experienced that could change our way of thinking?
Hopefully this question isn't too vague and some of you will have dealt with these issues. Look forward to hearing everyones experiences.
Many thanks!
Tim
I unfortunately cannot answer all of your points, but let me start with this one:
Do we make use of the integration queue functionality in CC.NET to
ensure a build order and pull together
the assemblies we need for the CMS at
build time?
The short answer is -yes, you should. The queue attribute ensures a build order within the running instance of CC.NET and is gives you serialization of the builds that depend on each other. For specifying which projects depend on each other, you should use project triggers. Do not rely on the queuePriority for this task.
You shold most likely pull the pieces you need to do the build at build time. Unless you have some time constraints on your individual builds.
Re:
Developing and extending the CMS when it uses shared assemblies i.e. do we add the assembly projects to the trunk solution during development (across source control repositories) and then rely on the build to pull it together or do we use a different approach entirely?
I'm fundamentally against distributing binaries in the trunk unless it's some libraries that does not need to be updated/changed on a frequent basis. If you build the shared assemblies yourself, you should consider pulling them from the artifacts on the build server(s).