On my PC at work I have a license for Visual Studio Ultimate 2012 but at home I am using Visual Basic express, since I don't really need most of the advanced features.
However I was wondering if there is a difference in the VB.NET build that I create with Ultimate versus the build I do with Express.
I thought it was easy enough to test: Just build it with both versions and compare the .EXE files. I noticed that they were pretty much identical, but here and there I found little differences. ~10-12 bytes of the same value were a chain of 10-12 bytes of another value in the other .EXE and so on.
Are these just version identifiers or machine specific parameters or are there actual differences between the versions?
Some examples (same code, compiled on the same machine, just 1 minute apart so everything should be the same, both Release builds. Offsets are decimal.)
The .NET compilers are actually almost open source, via the Microsoft Shared Source Initiative. The compiler has nothing to do with the Visual Studio version you are using. Visual Studio, regardless of its version, it would use the same compiler. Theoretically, another IDE could also use the NET compiler. SharpDevelop is such an example.
The build outcome depends on some local machine properties and therefore you would find differences even if you used Visual Studio Ultimate in both machines.
in reality the differences in your compiled application will not have any difference at the user or operation level - at the binary level they will have different job ids /GUIDS etc.
also possibly defaulting authors (if you do not set the author for the program and you have visual studio set to default to the user's name this could change some visible binary)
overall functionally you should not see any difference as the compilers are compiling to the .net framework using the same final objective.
Related
I was wondering whether there is an easy way to synchronize your preferences/settings across VS Code and VS 2019?
You can go to Tools -> Options -> Environement -> Keyboard
Syncing Settings Across VS Code & VS 2022
I think I have a pretty good idea of what you're asking for, and I would say that they don't have what you are thinking to have. Like, if you wonder that since they are both funded by Microsoft dollars, that there maybe some sort of interoperability, but there's not. Many people have have been hoping for some time to see Visual Studio work in harmony with V.S. Code, but I don't think that will ever happen like many people are hoping it will. The reason is, they are fundamentally — at the very core of what they are — very different beasts. While, as I pointed out, they are both developed by Microsoft dollars, and they are both "Development Environments", they are not both "Integrated Environments", and there in lies the difference that makes them worlds apart.
Visual Studio (the IDE) is considered to be an IDE — integrated is the keyword here — because it integrates into the projects that are built using Visual Studio as the Development Environment. Visual Studio Code does not integrate into projects, instead it allows you to structure the project, provide the compiler, debugger, and things like a build system, RTE, REPL, libraries, modules, plugins, the Languages themselves, etc... You are the master of your own environment with V.S. Code, and where developers have much more control over their projects using a non-integrated dev-env, especially one that's non-proprietary, they also have to put in much more work, to produce many of the same programs that Visual Studio can practically generate for you.
So the point here is, that you can't really swap configurations between the two, not for the majority of configured stuff, however; that's not to say that some settings cannot not be swapped. Any configuration that can have the same values applied to it, whether the configuration is in VS Code, or Visual Studio 2022, would not be unique to Visual Studio, and VS Code, and has nothing to do with the fact that they are both backed by Microsoft. In fact, if you have a group of settings, and those settings exist in both environments, and are able to accept all the same values (they can't accept any different values in any env) then that configuration will port to environments far beyond Visual Studio Code & Visual Studio 2022, and will probably be configurable in over 90% of the Development Environments out there. And this is something that software engineers, programmers & web-developers/designers take advantage of already, and it's referred to by its filename...
Dot-Editor-Config or .editorconfig
"Above is the Dot-Editor-Config Project's Logo."
EditorConfig, is a good gig, but it won't configure entire environments. Like most tools, the more you use it, the better you will get at making use of it. It seems to me that it is more useful across IDE's, as IDEs, as I explained above, work similarly (obviously), so they have more settings in common. Editor config basically creates a medium for setting semantics. Since settings found in different Development Environments are often called something different in each environment, what the .editorconfig file does, is it gives a single name for each of the variation of the setting that ports across environments, and gives a single place to configure the setting, allowing you to take one file from IDE to IDE. Like I said though, there is only so much it will configure, and it works better between IDE's than between IDE and Editor, at least IMHO.
Check Editor Config out, and see what you think.
I used to use it mainly to configure formatting across C++ projects, but CLang's CLang-Format Tool has become such a good tool that I did away with it.
This link will take you to the Dot-Editor-Config GitHub Repository, where you can find the .editorconfig extensions for...
VS Code
Visual Studio
JetBrains
Emacs
Vim
...and probably many more.
I did some research, or lack-of I should say, after authoring this. I couldn't find any other options out there. There really isn't a lot in the way to help in porting configurations, except for .editorconfig, and really .editorconfig won't do much between an IDE & Editor than configure formatting styles. You can get that same functionality with Prettier, CLang, ESLint, and many other tools. Editor-config doesn't just configure its-self though, like a formatter does, so I am sure you can find some extras it targets, but It's not so much that I use it. A lot of people do, though.
Dot Editor Config GitHub Repo
Watching this thought as well. I've been working in VSCode for a few years off and on as needed. But the full VS IDE (2022 currently) is both more complicated and more capable, so I'm running both.
Then realized that many of the extensions may (should?) be cross-usable, but still digging through that to determine what 'reality' looks like.
Sensible question though.
I am dusting off a number of old projects that we have in production and would like to upgrade the vbproj files to the latest version. Currently, ToolsVersion="12.0". New projects created in VS 2019 are using 15.0. My current projects have been repeatedly updated since something like VS 2003. However VS 2019 is not offering to upgrade them further. Although maybe I am missing something.
I plan to set up a side-by-side environment so I can use the designer content. I would really like to begin with project versions that are up-to-date. These current projects have been repeatedly updated since something like VS 2003.
A cursory review shows that the vbproj content is quite different. Is there a recommended way to upgrade? One alternative would be to create new projects using current templates and copy the source over. But there are about 32 projects that include WinForms, Web and class library projects and that's a big task. Another approach would be for me to manually merge the old and new vbproj files, something I am not sure I can safely do.
Any ideas?
VS 2019 - how to upgrade Visual Basic .NET projects
In fact, you have missed too many versions of VS and this document shows that VS2019 will not allow to upgrade VS2003 project directly.
Because there are too many different versions, there have been great changes from the project structure to the construction mechanism to various details, and some have even been removed from the new version VS.
The safest way is to upgrade the project step by step(a version by a version), but it is not unreality since VS2005, VS2008 are no longer maintained by Microsoft.
Or you can try upgrading your project step by step with VS2010 directly as an intermediate, but due to the large gap between the two, there will be various upgrade errors. And there is no such tool or easy approach to upgrade directly.
Actually, the best way is just creating new projects in VS2019 and then migrate your old project content into your new projects.
This is certainly much clearer and easier than if you were to correct errors in more than 30 projects later. And old projects with a gap of 16 years are worth the time it takes to re-create and migrate them in vs2019, which will take a long time but save you unnecessary and tedious errors.
In addition, do not forget to make a backup just in case.
Hope it could help you.
My question is similar to others, but my particular nuance of this problem doesn't appear to have an answer I can find on here so far, so here goes. (edits in italics)
Our company has a deployed application written in VB6. Since VB6 development is no longer officially supported in Windows, our company made the decision to port our VB6 application to VB.NET.
(Prior to this edit, I had mentioned that the project was converted to VB.NET using VS 2015. This was incorrect, I discovered that my coworker had actually performed the conversion using VS 2008, and I was working on the 2008 project in 2015.)
So we are now working with the VB.NET conversion in VS2015. As many of us know, the VS 2008 converter does an incomplete job porting VB6 code to VB.NET code so there are many, many errors to sort through (as of this writing, all compile errors are fixed). In particular, though, I'm trying to open the various forms for the project in the Designer so I can see and work with them. The designer specifically is reporting the error:
Could not resolve mscorlib for target framework '.NETFramework,Version=v2.0'. This can happen if the target framework is not installed or if the framework moniker is incorrectly formatted.
I saw some mention of a 256 character limit on dependency paths. This dependency is met in my case. I have also confirmed that .NET Framework 2.0 is installed and active in my instance of Windows. I have seen the recommendation to upgrade the .NET Framework version as well, which was successful in itself but did not resolve this mscorlib issue.
Full call stack for this error follows:
at Microsoft.VisualStudio.Shell.Design.VsTargetFrameworkUniverse..ctor(IDesignTimeAssemblyLoader assemblyLoader, IVsDesignTimeAssemblyResolution projectAssemblyResolution, IVsSmartOpenScope dispenser)
at Microsoft.VisualStudio.Shell.Design.VsTargetFrameworkUniverse.GetUniverse(IDesignTimeAssemblyLoader assemblyLoader, IVsDesignTimeAssemblyResolution projectAssemblyResolution, IVsSmartOpenScope dispenser)
at Microsoft.VisualStudio.Shell.Design.VsTargetFrameworkProvider..ctor(IVsDesignTimeAssemblyResolution assemblyResolution, IDesignTimeAssemblyLoader assemblyLoader, TypeDescriptionProvider parentProvider, IVsSmartOpenScope openScope)
at Microsoft.VisualStudio.Design.VsTargetFrameworkProviderService.get_TargetFrameworkProvider()
at Microsoft.VisualStudio.Design.VsTargetFrameworkProviderService.GetProvider(Type type)
at System.ComponentModel.Design.Serialization.DesignerSerializationManager.GetType(String typeName)
at System.ComponentModel.Design.Serialization.DesignerSerializationManager.System.ComponentModel.Design.Serialization.IDesignerSerializationManager.GetType(String typeName)
at System.ComponentModel.Design.Serialization.TypeCodeDomSerializer.Deserialize(IDesignerSerializationManager manager, CodeTypeDeclaration declaration)
at System.ComponentModel.Design.Serialization.CodeDomDesignerLoader.PerformLoad(IDesignerSerializationManager manager)
at Microsoft.VisualStudio.Design.Serialization.CodeDom.VSCodeDomDesignerLoader.PerformLoad(IDesignerSerializationManager serializationManager)
at Microsoft.VisualStudio.Design.Serialization.CodeDom.VSCodeDomDesignerLoader.DeferredLoadHandler.Microsoft.VisualStudio.TextManager.Interop.IVsTextBufferDataEvents.OnLoadCompleted(Int32 fReload)
How can I gain the ability to view my project in the Designer?
As far as I know, opening VB6 files in VB.NET will not work. You will have to make modifications in Visual Studio 6.0 or re-write the application in VB.NET/C#.
Older versions of Visual Studio (until 2008) had some converters but they never really worked as expected.
You can take a look at Visual Basic Tools for Visual Studio, it "allows to work with classic VB workspaces and projects within Visual Studio.", this will allow you to modify the VB6 project in a newer version of Visual Studio but the code will remain VB6.
Regarding your exact issue, others have reported that the following worked for them:
Remove and add back project references that have warnings.
Rebuild the project
Remove and add back Microsoft.Office.Core
Good luck!
As someone who has converted a number of VB6 applications to VB.Net, I always advise a full rewrite. The languages are just too different. You waste far too much time trying to resolve issues of this type.
Better still, just leave the VB6 application running as is.
Microsoft's VB6 support statement
I am looking for an interpreter (compiler would work too) for Visual Basic or VBA. I am not looking for any kind of UI support. Basically, I have a series of somewhat complex VBA modules which make no reference to any external DLLs and make no use of any user interfaces. Is there any such tool available short of having Microsoft Office or Microsoft Visual Basic for the Windows operating system?
VBA only exists as an embedded "macro language" inside a host application like Excel. At one time you could even buy the SDK to embed VBA in your own applications, but there was never any "stand alone VBA."
VBScript is close to VBA and VB in syntax and semantics, but it also requires a host. Common desktop hosts include WSH, MSHTA, and the Vista/Win7 "gadget" framework. That's probably your best bet if it meets your needs.
It is remotely possible to do what you want using VB5CCE (Control Creation Edition) if you can find it. This was free, but could not compile to EXEs. It might have worked as an interpreter however by running it with the /run switch. I'm not certain of that though.
There are 3rd party freebies as well such as Jabaco which uses a very VB/VBA-like syntax.
Update: VB5CCE does not support the /run switch.
This might be worth a peek if VB.NET is a fit. Visual Studio Express ... I'm not sure what the free version leaves out though.
http://www.microsoft.com/visualstudio/en-us/products/2010-editions/visual-basic-express
I've written a bare-bones ap in Visual Studio 2010, Express version. It does what I need and several others are using it successfully. I'd like to add features to it, but I don't want to foreclose the ability to make corrections to the present version.
How do I make a fork in the application for this purpose? Google has been no help in this case, and I've tried several incarnations of copy and change names etc etc.
Ensure you have a Source Code Revision Control System in place (Subversion, TFS, Git etc.), and then create a branch. That way all names stay the same.
One technique is to create a branch (from the trunk, or a previous branch from trunk) for each different production version you want to support. That way, merging chnages up/down between versions and current development is (usually) relatively straightforward.
Even if you are not using Subversion, the 'Red Bean' book is a great place to learn about branching strategy.
Visual Studio 2010, Express edition doesn't integrate directly with source control systems. This is one of the product limitations (i.e. what makes it the 'express' license).
I would recommend either:
1. using a product like SVN or Mercurial, which you use outside the Visual Studio IDE
2. depending on the complexity of the changes, you may want to look at conditional compilation. It's kind of like a poor man's code branch.