|Publication number||US7685563 B2|
|Application number||US 10/790,663|
|Publication date||Mar 23, 2010|
|Priority date||Mar 1, 2004|
|Also published as||US20050193383|
|Publication number||10790663, 790663, US 7685563 B2, US 7685563B2, US-B2-7685563, US7685563 B2, US7685563B2|
|Inventors||Rahul Kumar, Joshua Shepard, Kevin Perry, Diane Melde, Izydor Gryko, C. Douglas Hodges, Jemy Huang, Christopher Joseph Burrows, Svetlozar Keremidarski|
|Original Assignee||Microsoft Corporation|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (7), Non-Patent Citations (3), Referenced by (7), Classifications (10), Legal Events (4)|
|External Links: USPTO, USPTO Assignment, Espacenet|
This invention relates in general to the field of project development systems. More particularly, this invention relates to project development systems which can be reused in several environments and easily customized for such reuse.
To develop a software project, the developer(s) may use several development tools. Some tools may be used to assist in writing code for the software project. Tools for building the code, running the code, and debugging the code may also be useful. These tools may be separate or they may be packaged together into an integrated development environment (IDE). Additional tools included in an IDE may include file and library management, among others. An integral part of an IDE is a project system, which is used to tie the tools together.
While a software project is being developed, certain parameters must be known regarding the use of the resulting software project in order for the project system to provide the correct tools and properties. For example, consider the case in which a software project is developed for use with a particular target architecture or platform. The target architecture or platform which the software project is intended to be used with affects many facets of the software project. For example, one architecture currently in use is a 64-bit® architecture known as IA-64®. If the project is being developed for use on an IA-64 platform, there may be a specific IA-64® programming stylesheet which should be followed for the project. This stylesheet should be accessible to the project system so the project system can guide the developer in developing code according to the stylesheet's dictates. Additionally, the developer can use certain tools or toolsets specific to the IA-64®(or to a set of platforms including the IA-64®). For example, the debugger used to debug the project while in development will be specific to the IA-64®. Additionally, tools for running the code in the IA-64 environment may be required by the developer.
Once a project has been developed, if the developer wants to develop a similar project for use on a different architecture, a different project system must be created for developing software for that new architecture, one which includes the correct resources for the architecture, such as stylesheets and debuggers. Development must then occur using the new project system in order to accommodate the change in architecture.
Generally, this reduplication of effort in creation of a new project system occurs whenever a software project is required for a new purpose, even if there had been a previous similar project. One example of a new purpose, as described above, may the use of a different architecture. Other different purposes which may be required include different platforms, components, assemblies, or uses (e.g. use as a web service). The reduplication of effort needed to develop a software package for the new purpose entails a substantial cost of time and other resources.
One way to reduce reduplication of effort is to use templates, for example, enterprise templates as used in MICROSOFT VISUAL STUDIO.NET®. Software architects frequently evaluate new technologies, explore possible ways to use them, and recommend best practices. Through the use of enterprise templates, software architects can provide guidance to development teams about how to work within an architecture by eliminating many decisions involving component and item choices that should not be part of the developer's burden. Enterprise templates simplifies these choices by dynamically modifying certain integrated development environment (IDE) features in VISUAL STUDIO NET®. Enterprise templates can provide certain beginning project structures and continuous development guidance as components are added, properties exposed, and values assigned.
However, these enterprise templates are limited in their application because of their implementation. First, only one template can be applied at a time. Second, the templates have only limited utility. A template can modify or limit the use of existing functionality in the project system, but it can not add new functionality to the project system. For example, a template can disable or enable toolbox items or menu items which are provided in the project system. A template can also assign a value to a property which can be used in the project system. For example, the background color of a form can be assigned using a template. A template can limit the range of allowed values for a property, such as timeout values. However, no additional functionality can be supplied by use of a template. An additional limitation is that design-time properties (such as Locked or Modifiers in VISUAL STUDIO .NET) can not be controlled through a template.
In view of the foregoing there is a need for a system that overcomes the drawbacks of the prior art.
A “flavor” may be applied to a software development system. Each “flavor” of project corresponds to a different purpose. A project flavor provides the ability to customize parts of the project system given a priori knowledge that output (the project) will be used in a particular way.
More than one flavor may be applied. For example, one project flavor for a base project system might deal with the target database which the project being developed will run on. As another example, another project flavor may not be specific to a target database, but may provide extensions to the project system that are particularly useful in database development. A policy may influence the development of the project, and there may be a project flavor for the policy. By applying the flavor for the correct target database and the flavor for the project policy, a project system can be customized for the purpose of the project. When the project system needs to be reused with a different purpose, new flavors may be applied to the base project system. Thus, flexibility in creating new project systems from a base project system is achieved.
Other features of the invention are described below.
The foregoing summary, as well as the following detailed description of preferred embodiments, is better understood when read in conjunction with the appended drawings. For the purpose of illustrating the invention, there is shown in the drawings example constructions of the invention; however, the invention is not limited to the specific methods and instrumentalities disclosed. In the drawings:
In order to provide platform extensibility for project systems, component object model (COM)-type aggregation may be used. A base project object includes interfaces for the project system. These interfaces may be overridden or enhanced by including the same interface on a flavor object. The flavor object is aggregated with the base project object, with the flavor object as a wrapper. In addition to COM-type aggregation to override or enhance interfaces, a property of the project system is made modifiable by a flavor by inclusion in an interface to the base project object. The flavor object can then change the property by changing the interface, thereby modifying the property. In addition, delegation is used to allow the extension of additional project objects such as project configuration objects and property browser objects. Additional detail is provided below.
Exemplary Computing Environment
The invention is operational with numerous other general purpose or special purpose computing system environments or configurations. Examples of well known computing systems, environments, and/or configurations that may be suitable for use with the invention include, but are not limited to, personal computers, server computers, hand-held or laptop devices, multiprocessor systems, microprocessor-based systems, set top boxes, programmable consumer electronics, network PCs, minicomputers, mainframe computers, embedded systems, distributed computing environments that include any of the above systems or devices, and the like.
The invention may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The invention may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network or other data transmission medium. In a distributed computing environment, program modules and other data may be located in both local and remote computer storage media including memory storage devices.
With reference to
Computer 110 typically includes a variety of computer readable media. Computer readable media can be any available media that can be accessed by computer 110 and includes both volatile and nonvolatile media, removable and non-removable media. By way of example, and not limitation, computer readable media may comprise computer storage media and communication media. Computer storage media includes both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CDROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can accessed by computer 110. Communication media typically embodies computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media. Combinations of any of the above should also be included within the scope of computer readable media.
The system memory 130 includes computer storage media in the form of volatile and/or nonvolatile memory such as read only memory (ROM) 131 and random access memory (RAM) 132. A basic input/output system 133 (BIOS), containing the basic routines that help to transfer information between elements within computer 110, such as during start-up, is typically stored in ROM 131. RAM 132 typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by processing unit 120. By way of example, and not limitation,
The computer 110 may also include other removable/non-removable, volatile/nonvolatile computer storage media. By way of example only,
The drives and their associated computer storage media discussed above and illustrated in
The computer 110 may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 180. The remote computer 180 may be a personal computer, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to the computer 110, although only a memory storage device 181 has been illustrated in
When used in a LAN networking environment, the computer 110 is connected to the LAN 171 through a network interface or adapter 170. When used in a WAN networking environment, the computer 110 typically includes a modem 172 or other means for establishing communications over the WAN 173, such as the Internet. The modem 172, which may be internal or external, may be connected to the system bus 121 via the user input interface 160, or other appropriate mechanism. In a networked environment, program modules depicted relative to the computer 110, or portions thereof, may be stored in the remote memory storage device. By way of example, and not limitation,
Reusable Customized Project System
In order to customize a project system based on prior knowledge that the output will be used for a particular purpose, according to one embodiment, component object aggregation is used. Object models, such as Microsoft Corporation's Component Object Model (“COM”), facilitate the implementation of complex systems by allowing the use of objects as reusable components. COM is more fully described in “Inside COM” by Dale Rogerson and published by Microsoft Press in 1997. COM specifies that each object is to implement a certain interface referred to as the IUnknown interface. The IUnknown interface in COM provides a query interface function, an add reference function, and a release function. The query interface function is passed the identifier of an interface and returns a reference to that interface. The add reference and the release functions are used for reference counting the object. Each object that conforms to COM implements the IUnknown interface. While the invention will be described with reference to COM, it is contemplated that any object technology can be used.
COM aggregation occurs with cooperation between two or more COM objects. One COM object is the controlling object. The other COM objects are participating objects. The controlling object and the participating objects work together. The controlling object can replace or enhance interfaces of the participating objects. The controlling object passes selected interfaces from the participating objects to the client. Thus, when a call is made which requires an interface provided by a participating object, the client can use the interface from the participating objects. This is contrasted with COM containment, in which the call would be handled by the controlling object and passed to the participating object, resulting in a slight performance loss and other consequences. While there are several objects being used in the aggregation, the client sees the aggregation as one unit.
In one embodiment, a flavor is implemented in a COM object, as is the base project. The base project COM object contains basic project system information. The flavor COM object implements interfaces (application programming interfaces, or APIs). One or more interfaces in the flavor COM object may be duplicative of an interface provided by the base project COM object. In such cases, COM aggregation will determine which implementation of the interface will be used, generally allowing the flavor object to override the base project object.
When a method of the IVsHierarchy interface is called by an action of a developer using the base project object 200, in the absence of an added flavor, the interface used would be IVsHierarchy interface 210(a). However, client flavor object 220 is being used with the base project object 200. Client flavor 220 is also a COM object, and the client flavor object 220 and the base project object 200 have been aggregated in such a way so as to allow the client flavor object 220 to override or enhance the capabilities of the base project object 200. For example, as shown in
Third interface 210(c) provided by base project object 200 is not also provided by client flavor 220. Because of COM aggregation, this interface is provided by client flavor object 220 to the client. Thus, client flavor object 220 provides a way for the client to directly access some functionality of the base project object 200 (by providing the interface 210(c), enhances or overrides some of the base project object 200 functionality (by providing IVsHierarchy interface 230(a), and IOleCommandTarget/IVsUIHierarchy interface 230(b)), and adds to the functionality of the base project object 200 by providing interfaces such as IPersistXMLFragment 230(c) and interfaces 230(d) and 230(e).
In addition, multiple flavors can be applied, with a hierarchical ordering.
In a third COM aggregation, not shown, a policy object has also been applied. Generally, as many layers of aggregation as are required may be applied. The result of the multiple aggregations is the project system which will be used. The flavor being applied will be able to change a number of key project system features and functions. For example and without limitation, a project flavor may be able to do the following, some of which may be specific to VISUAL STUDIO IDEs, and others of which are generally applicable:
Other Extensions to Base Project Object Functionality—Properties in Base Project Interface
In addition to the changes to interfaces described above, the base project object 300 can use properties to enable the project flavor to control various features. In one embodiment, for example, the base project can provide a default value for properties such as a platform name to be used for configuration objects. In order to provide for modification of these properties, the properties to be modified are included in an interface in the base project. For example, these properties may be included in an interface IVsHierarchy 310(a) in the base project. These properties are obtained via query interface (QI) for the IVsHierachy interface. Because the IVsHierarchy interface 310(a) of the base project 300 is overridden by flavors applied, the flavors can alter the behavior of the project as set in such properties.
Other Extensions to Base Project Object Functionality—Extensibility through Delegation
Another way to extend base project object functionality is through new APIs which are implemented in flavors and which provide for extensions of the functionality of the project system. In some project system, the project system object creates other objects (delegate objects) which are also used to provide user functionality. In one embodiment, the flavor can affect and enhance these objects as well.
In order to allow the flavor to also affect the properties which are defined in the project configuration object, the IVsFlavorCfgProvider interface 430(a) is used to provide a flavor-specific project configuration object FlavorProjectCfg object 450. The base project configuration object delegates to this FlavorProjectCfg object 450, allowing the flavor object 420 to extend the ProjectCfg object 440. The IVsFlavorCfgProvider interface 430(a) functions as a factory for project flavor's configuration objects. The base project system asks the project flavor to create an IVsFlavorCfg object 450 corresponding to each one of its configuration objects. The FlavorCfg object(s) 450 can implement an interface (IPersistXMLFragment interface 455(b)) which manages persistence into the project file.
As discussed above, FlavorProjectCfg object 450 enhances the base project configuration object. For example, as shown in
Creation of a Flavored System
Object aggregation using additional flavors may be used. For example, if Flavor A has purpose A, and Flavor B has purpose B, a project system adapted for both purposes A and B may be created by aggregating a flavor object for Flavor B as the controlling object with the project system as the participating object. The resulting object is then used as the participating object with the flavor object for Flavor A as the controlling object in a second aggregation. The order of the aggregation may be significant, for example, if both Flavor A and Flavor B change a value for a specific property, the Flavor A's change may override Flavor B's change if the aggregation proceeds as in the example above.
Initialization of a Flavored System
In one embodiment, in order to add one or more flavors to a project, the flavors to be added are identified inside of the project file. For example, a unique GUID corresponding to each flavor to be used in the project system may be stored inside of the project file. The project is then created as usual, however, when the GUIDs of project flavors are encountered, they are used to create the aggregated project.
For example, in VISUAL STUDIO, a ProjectFactory is used to create the project, and when CreateProject is called, the project GUID and extension will be located. However, when CreateProject is called and discovers that there are flavors to be aggregated, a new global service CreateAggregatedProject is called. The CreateAggregatedProject service constructs the appropriately aggregated project using the project GUID and the GUIDs of the flavors.
If a flavored system has already been created, the flavoring of the system may be changed. GUIDs are stored in the project file. A method on IVsAggregatableProject allows the list of project flavor GUIDs to be changed. The new project can then be saved, unloaded and reloaded, which results in a recreated project with the new set of flavors in effect.
It is noted that the foregoing examples have been provided merely for the purpose of explanation and are in no way to be construed as limiting of the present invention. While the invention has been described with reference to various embodiments, it is understood that the words which have been used herein are words of description and illustration, rather than words of limitations. Further, although the invention has been described herein with reference to particular means, materials and embodiments, the invention is not intended to be limited to the particulars disclosed herein; rather, the invention extends to all functionally equivalent structures, methods and uses, such as are within the scope of the appended claims. Those skilled in the art, having the benefit of the teachings of this specification, may effect numerous modifications thereto and changes may be made without departing from the scope and spirit of the invention in its aspects.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US5710925 *||Jun 7, 1995||Jan 20, 1998||Microsoft Corporation||Method and system for aggregating objects|
|US5805885 *||Jan 24, 1994||Sep 8, 1998||Microsoft Corporation||Method and system for aggregating objects|
|US6256780 *||Sep 10, 1998||Jul 3, 2001||Microsoft Corp.||Method and system for assembling software components|
|US6412020 *||Jun 16, 1998||Jun 25, 2002||Microsoft Corporation||Method and system for aggregating objects|
|US6754885 *||Nov 23, 1999||Jun 22, 2004||Invensys Systems, Inc.||Methods and apparatus for controlling object appearance in a process control configuration system|
|US20050177818 *||Feb 5, 2004||Aug 11, 2005||Huene Peter C.||Integration of external tools into an existing design environment|
|US20060095441 *||Oct 28, 2004||May 4, 2006||Microsoft Corporation||Project property sheets|
|1||"Features overview for visual C# .NET 202," downloaded from the Internet on Feb. 22, 2006, http://msdn.microsoft.com/vcsharp/previous/2002/features/default.aspx, 2 pages.|
|2||"What's new in visual studio.NET 2002," downloaded from the Internet on Feb. 22, 2006, http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vsintro7/html/vxriWhatsNewInVisualStudioNET2002.asp , including Application Template section, 6 pages.|
|3||*||Atul Gupta, "Building a Custom Project Wizard in Visual Studio .NET", May 2003, Infosys Technologies Limited, pp. 1-10.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US8141041 *||Jan 7, 2008||Mar 20, 2012||International Business Machines Corporation||Automated configuration updater and method for code builder|
|US8307339 *||Nov 6, 2012||Ramco Systems Limited||Software reuse in model based software systems|
|US8572563 *||Sep 26, 2008||Oct 29, 2013||Ramco Systems Limited||User interfaces and software reuse in model based software systems|
|US20050203942 *||Feb 24, 2005||Sep 15, 2005||Ramco Systems Limited||User interfaces and software reuse in model based software systems|
|US20090024657 *||Sep 26, 2008||Jan 22, 2009||Ramco Systems Limited||User interfaces and software reuse in model based software systems|
|US20090177684 *||Jan 7, 2008||Jul 9, 2009||International Business Machines Corporation||Automated configuration updater|
|US20100223594 *||Sep 2, 2010||Infragistics Inc.||Method and apparatus for implementing a composable control architecture|
|U.S. Classification||717/107, 717/120, 717/108, 717/121, 717/116|
|Cooperative Classification||G06F8/36, G06F9/4433|
|European Classification||G06F8/36, G06F9/44F2B|
|Mar 1, 2004||AS||Assignment|
Owner name: MICROSOFT CORPORATION, WASHINGTON
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:GRYKO, IZYDOR;HODGES, C. DOUBLAS;HUANG, JEMY;AND OTHERS;REEL/FRAME:015042/0557;SIGNING DATES FROM 20040226 TO 20040227
Owner name: MICROSOFT CORPORATION,WASHINGTON
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:GRYKO, IZYDOR;HODGES, C. DOUBLAS;HUANG, JEMY;AND OTHERS;SIGNING DATES FROM 20040226 TO 20040227;REEL/FRAME:015042/0557
|Oct 26, 2004||AS||Assignment|
Owner name: MICROSOFT CORPORATION, WASHINGTON
Free format text: RECORD TO CORRECT THE 2ND CONVEYING PARTY S NAME, PREVIOUSLY RECORDED AT REEL 015042, FRAME 0557.;ASSIGNORS:GRYKO, IZYDOR;HODGES, C. DOULGAS;HUANG, JEMY;AND OTHERS;REEL/FRAME:015954/0001;SIGNING DATES FROM 20040226 TO 20040227
Owner name: MICROSOFT CORPORATION,WASHINGTON
Free format text: RECORD TO CORRECT THE 2ND CONVEYING PARTY S NAME, PREVIOUSLY RECORDED AT REEL 015042, FRAME 0557;ASSIGNORS:GRYKO, IZYDOR;HODGES, C. DOULGAS;HUANG, JEMY;AND OTHERS;SIGNING DATES FROM 20040226 TO 20040227;REEL/FRAME:015954/0001
|Aug 26, 2013||FPAY||Fee payment|
Year of fee payment: 4
|Dec 9, 2014||AS||Assignment|
Owner name: MICROSOFT TECHNOLOGY LICENSING, LLC, WASHINGTON
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MICROSOFT CORPORATION;REEL/FRAME:034541/0477
Effective date: 20141014