I am asking this question since I am new to anksvn. I basically need to checkin code that I wrote in a C# 2010 application into the latest version of anksvn. I have obtained the impression that anksvn is based upon a file directory structure where the solution file is at the highest level and all other folders are at a different directory level.
I have also seen C# apps where the solution file can be the following:
1. The solution file has its project files at a lower level that it is.
2. The solution file has its project files at the same level where the solution file is located.
Thus can you tell me and/or point me to a reference that will verify and/or tell me how the file structure of anksvn is related to visual studio.net 2010?
Related
I'm working ona project containing thousands of solutions (.sln) and tens of thousands of .cs/.cpp/etc files.
How can i find which solution(s) a source file is a part of?
Source files aren't part of a solution. They are part of a project, which in turn is part of a solution. The source file itself has no notion of being part of the project though. The project has a reference to the file but not the other way around. One source file can be part of multiple projects, which might be part of different solutions.
What you could do is parse the SLN and VBPROJ/CSPROJ/whatever files to see which ones refer to a particular source file. Those files are just text and contain various information about the solution or project, including what projects are part of a solution and what files are part of a project. You could recursively parse the files in folder to build up an entire tree representing the files in the projects in the solutions.
Note that most files are going to be referred to by relative paths in the project file.
Start with Visual Commander and then you can programmatically access your solution "DOM-style" using Visual Studio's Automation and Extensibility for Visual Studio API. Write a VS command in a .NET language that traverses a solution into its projects and then into the project items, dumping all files found (project items) into a log file, database, web service, what have you.
See e.g., this article HOWTO: Navigate the files of a solution from a Visual Studio .NET macro or add-in on how to navigate Visual Studio's DTE.
I know SO frowns on answers containing just links and not true help, but the documentation for EnvDTE in its various flavors is extensive and any code sample to demonstrate how to use it would be quite large. So I'm just giving you this strong hint: Look at the Visual Studio extensibility model, and hook into it easily via Visual Commander which does all the hard work of wrapping your code in a Visual Studio extension. From there you can use any reasonable technique (MSBuild, PowerShell, batch files) to load each solution into VS and run your new command.
This actually answers the question: For all source files used by any of my thousands of solutions, which solutions use them. But I see that you (#Sabz), below in a comment, give a reasonable way to answer the question for one source file at a time, which is more precisely what you asked.
N.B.: I have not (yet) used Visual Commander so I'm just assuming it works as advertised.
Our Visual studio project uses source-base with lot of directories and files.
Other programmers use other ides/systems and when they add new files in the source-base, visual-studio users have to re-add those files into corresponding filter directory (that is 1:1 following directory structure).
Isn't there way to say to visual studio, to follow the directory structure automatically? If that isn't possible, is it at least possible to specify filter contents by wildcards?
I didn't find a way to make it work in visual studio, but the workaround that solved it for us is the usage of fastbuild (http://fastbuild.org). Not only it can be used to speed up the compilation, but it can generate the visual studio files. This allows us to remove the visual studio files from the repository and just generate them on the fly. As the files are specified reasonably in fastbuild ([recursive] directories + file list + exluded files/directories), it automatically works when someone using linux just adds new cpp file into it.
I'm trying to view history in Visual Studio 2010 for all files included in a given Solution file via the Solution Explorer View. I use TFS 2010 for source control, and I'm aware that I can get history for a folder recursively in Source Control Explorer. My issue is that we have multiple projects in a root directory, all of which are included in a variety of solution files in that same directory (each solution file represents a deploy-able component, including some "shared code" between them). I just want to view history on all of the files included in a given solution file, and not everything in this root directory. When I right click on a solution or project in Solution Explorer and "View History", I just get history for that solution file or project file, nothing more.
Alas, this cannot be done with TFS as it is.
TFS Source control does not know if a file is a solution file or a text document. It just stores it for you. There is no parsing at all. I can (and do) store Delphi project files in TFS. There is no way for TFS to be able to understand and be smart about every file type that exists.
It would be nice if Solution explorer did this for you (as it is specific to your project). But it does not.
You could create a custom plugin to TFS and Visual Studio to do what you are asking, but it would probably take longer than just manually checking the history of all the files in your solution.
This might help, it's an add-in extension
VS 2010 and VS 2012
Here's my specific scenario: Using VS2010, Pex and TFS2008, generated moles files are getting automatically added to source-control (TFS).
Pex adds a "project_name.moles" file to your test project and then autogenerates 3 files at build time: project_name.Designer.cs, project_name.Moles.dll, and project_name.Moles.xml. I want to keep the *.moles files in TFS (it's source code) but I don't want the 3 generated files to be in TFS (they are still part of the project, but they are generated when first built on a new system).
There are two reasons I need this behavior:
1. It's not a good idea to store generated code in source-control (let's not debate the merits of that here).
2. Specially, the DLL file is BAD because every time someone builds, all moles files are regenerated and thus all files are checked-out and DLL files are checked-out EXCLUSIVELY (non-mergable) and so other people can no longer build on their local box.
The Pex/Moles team are working on this but the solution is still likely several months away.
Is there a csproj property that can be assigned to these project files so that they are in the project but not managed by version control? I don't mind hand-editing the csproj file.
Moles will not be adding any files to the project in the next version (v0.94). It will use MSBuild to generate the assemblies on demand.
I think it depends more on the version control tool than Visual Studio, as usually you can set up some kind of filters in your version control configuration in order to exclude some files/paths.
E.g. if you use Mercurial/Hg, you can (and should) edit your repository .hgignore file and specify e.g. to exclude all *.moles files and the whole sub-tree MolesAssemblies\*. I guess other version control systems have similar options.
Can someone briefly explain to me the difference between Visual Studio's solution file (.sln) and project file (.vcproj).
It seems to me opening either one open the correct solution/project in Visual Studio. Is one the super-set of the other?
Note: I am currently using Visual Studio 2008 working on a project that was brought forward from Visual Studio 2005 (I believe).
A solution is a set of projects. If you need more than one project in your software, then go with solutions. I.E.: A Class Library Project + A Web Application Project.
A project file typically corresponds to a single module: EXE or DLL or LIB. A solution manages a collection of project files.
A solution is a collection of projects. Visual Studio is made so that it cannot function without a solution, so if you open a bare project, it will generate the solution automatically (or try to find one).
One solution can contain zero or more projects. Everything is in projects, so a solution with zero projects doesn't contain anything at all besides the solution properties.
Visual studio keeps track of where the projects are used, so if you open a project file, it will open (IIRC) the last solution where it was used.
When you create a project from scratch, a solution is also created, but it's not shown until you add another project to it. It looks like you have only the project open, but it's actually a solution containing the project that is open.
Specifically project files are intended to contain the data required to build the files in the project into an exe or dll. This file is utilized by the local compilers or with systems such as Team Foundation system and server side build agents.
Solutions are a client (IDE) construct designed to manage collections of projects, which in effect is a collection of different build definitions and associated files.
Solution files are typically made up of multiple project files.