Join Michael Lehman for an in-depth discussion in this video Integrating a version control system with an integrated development environment (IDE), part of Learning Software Version Control.
Two of the most popular development environments, Microsoft's Visual Studio and Apple's Xcode have integration with Source Code Control built right into the IDE. In Xcode, Git is supported natively. In Visual Studio, Microsoft provides support for Team Foundation Server and many third parties provide support for Git Subversion, Perforce, and Mercurial. In many of these integrated development environments, the environment will automatically check files out for you when you begin modifying them and support check in, reverting, branching right within the IDE. So let's take a look at Visual Studio.
Here we have a solution inside Visual Studio, a simple console application which has a main program and two separate features. I've gone ahead and created a project inside the Team Foundation Server on CodePlex and prepared to add this project to TFS. You can see the green plus signs right here and right here, next to each one of these things, indicating that an add is pending. But the code has not yet been checked into TFS, so let's go through that process. As you can see, it's not only here in the Source Code Control Explorer, but also over here in the Solution Explorer, the status of the files within the Version Control system are clearly indicated.
So we'll come over here to the application, and we'll select Check In Pending Changes. First, it asks if you want to save your changes to make sure that the working set on disk is updated with the contents of the working set inside the application, so we'll save that. And now we have a Pending Changes tab over here now in the Team Explorer which has a place for our commit Comment. So we'll say Initial add of ConsoleApplication1. In more sophisticated things, you can actually associate related work items, decide exactly which changes you want.
In this case, we're all set to go, we're going to click Check In. It asks us if we want to continue to check in 9 items, we'll say yes, and you can see now here it says Changeset 18686 successfully checked in. And now if we go over here and look in the Source Control Explorer, we'll see not only the folders, but we can actually see all of the files that are checked in. Here's the Properties folder, the App.config, and all of the files that we checked in. And if we come back to the Solution Explorer, we can now see this little lock icon, which means that these files are actually checked in.
If we open up one of these in order to be able to do some editing, and we start typing, you can see over here in the Solution Explorer that it has a little red check mark, which means it's checked out to me. So that's the power of using a Version Control system integrated into the IDE is you don't have to go separately to your Version Control and think about the process of using Version Control while you're developing. While using a Version Control system in an IDE can be very powerful, don't forget there will be times when it fails, so always keep the command line reference handy.
- Comparing centralized vs. distributed systems
- Saving changes and tracking history
- Using revert or rollback
- Working with the GUI tools
- Using IDE and shell integration
- Installing different systems
- Creating a repository
- Tagging code
- Branching and merging code
- Selecting a software version control system that's right for you