Showing posts with label Visual Studio. Show all posts
Showing posts with label Visual Studio. Show all posts

Tuesday, July 24, 2007

Visual Studio Team Edition for Database Professionals Service Release 1 Is Here

Visual Studio Team Edition for Database Professionals Service Release 1 has been Released

Overview
This service release addresses the top issues that were found through feedback from customers and partners. This release includes the following features:

• Cross-database references

Support is improved to enable you to reference objects in different databases by using database project references or referencing a database metafile (.dbmeta). This support will reduce or eliminate the cross database reference warnings within a database project.

• Improved file support within SQL Server file groups

You may define files within file groups as database project properties instead of having to create files and file groups within the pre-deployment storage script.

• Variables

A Variables page is added to the database properties. This new page enables you to define setvar variables for use in the deployment scripts. Additionally, SR1 supports the latest service pack release from Microsoft SQL Server 2005 (SP2). The SR1 also supports the Windows Vista operating system.



The knowledge base (KB) article describing this service release is here http://support.microsoft.com/kb/936612/

The actual download is here:
http://www.microsoft.com/downloads/details.aspx?FamilyID=9810808c-9248-41a5-bdc1-d8210a06ed87&displaylang=en

Wednesday, February 28, 2007

Visual Studio Code Name "Orcas" - March 2007 Community Technology Preview (CTP) Available For Download

Get it here and start messing around with LINQ:

http://www.microsoft.com/downloads/details.aspx?FamilyID=b533619a-0008-4dd6-9ed1-47d482683c78&DisplayLang=en

From the site:


Visual Studio code name “Orcas” delivers on Microsoft’s
vision of smart client applications by enabling developers to rapidly create
connected applications that deliver the highest quality rich user experiences.
This new version enables any size organization to rapidly create more secure,
manageable, and more reliable applications that take advantage of Windows Vista
and the 2007 Office System. By building these new types of applications,
organizations will find it easier than ever before to capture and analyze information
so that they can make effective business decisions.



This download is the March 2007 Community Technology Preview of Microsoft
Visual Studio Code-Named “Orcas”. This CTP is available in English only.



Note: This CTP is available as a Virtual
PC image
or as a self-extracting install. If you wish to use the Virtual PC
image you will need Virtual PC or Virtual Server to run this image. If you wish
to use the self extracting install, we advise that you do not install this on a
production machine. Depending on your hardware the download files make take
between 30-60 minutes to decompress.




This CTP targets early adopters of the Microsoft technology, platform, and
tools offerings. It enables developers to experience the upcoming toolset and
underlying platform improvements. We designed this release to enable developers
to try out new technology and product changes, but not to build production
systems. This limitation is fully covered in the EULA that accompanies this
CTP.



The highlights of this CTP include:



  • LINQ

    The LINQ Project: this CTP represents a major milestone in the LINQ
    project. For more information about LINQ click here.
    • VB 9.0 Language
      Support: This CTP contains the following language features:
      • Query Expressions:
        Basic querying, filtering, and ordering support
      • Object Initializers
      • Extension Methods
      • Local Variable Type
        Inference
      • Anonymous Types
      • XML literals
      • XML properties
      • New Line and
        Expression IntelliSense
    • C# 3.0 Language
      Support: This CTP implements all of the C#3.0 language features from the
      May LINQ CTP including:
      • Query Expressions
      • Object and Collection
        Initializers
      • Extension Methods
      • Local Variable Type
        Inference and Anonymous Types
      • Lambdas bound to
        Delegates and Expression trees
      • Complete design-time
        support: Intellisense, Formatting, Colorization
    • LINQ to ADO.NET
      • ADO.NET is fully
        integrated with LINQ and offers many options for using LINQ in various
        scenarios: LINQ to SQL provides direct access to database tables from
        the programming environment, LINQ to Entities enables developers to use
        LINQ over EDM models, and LINQ to DataSet allows the full expressivity
        of LINQ to be used over DataSets.
      • LINQ to Entities
        enables developers to program against a relational database using a view
        of the data that is appropriate for the application they are building,
        independent of the structure of the underlying database. The use of the
        Entity Data Model (EDM) enables developers to design models that follow
        the concepts built into the application, instead of having to map them
        to constructs available in relational stores. LINQ to Entities is built
        on the ADO.NET Provider model and will support working against different
        back end relational stores in addition to Microsoft SQL Server. This CTP
        includes a LINQ to Entities provider for SQL Server and SQL Server
        Compact Edition.
      • LINQ to SQL (previous
        name DLinq) has enhanced the functionality from the May 2006 LINQ CTP.
        You can find it in System.Data.Linq namespace in System.Data.Linq.dll.
        New in this release is that DataContext provides optimized modes for
        read-only use and serialization . Also new is that DataShape streamlines
        eager loading capabilities and adds the ability to set queries on
        relationships
    • LINQ To SQL Designer
      • Methods can be created
        from stored procedures and functions within the designer.
      • Better handling of
        database schemas.
      • Improved inheritance
        support in the designer.
    • LINQ over XML (XLinq)
      • System.Xml Bridge
        Classes added – There is a set of extension methods allowing XPath /
        XSLT to be used over LINQ to XML trees, allow XSLT transformations to
        produce an LINQ to XML tree, and to validate an XElement tree against an
        XML Schema.
      • Event Model - This
        allows LINQ to XML trees to be efficiently synchronized with a GUI, e.g.
        a Windows Presentation Foundation application
      • Class hierarchy
        changes - XObject class added, XStreamingElement class (temporarily)
        removed
      • Various
        understandability / usability improvements – There have been a number of
        relatively minor changes done in response to internal reviews, usability
        studies, and external feedback to make the API more clean and
        consistent.
    • LINQ to Objects API
      • The LINQ to Objects
        API supports queries over any .NET collection, such as arrays and
        Generic Lists. This API is defined in the System.Linq namespaces inside
        System.Core.dll.


  • ADO.NET
    • Extended, more powerful
      data APIs with the ADO.NET Entity Framework
      • With the ADO.NET
        Entity Framework developers will be able to model the view of the data
        that is appropriate for each one of the applications they are building,
        independently of the structure of the data in the underlying database.
        The use of the Entity Data Model (EDM) enables developers to design
        models that follow the concepts built into the application, instead of
        having to map them to constructs available in relational stores. Once
        the model is in place, the powerful ADO.NET Entity Framework API is used
        to access and manipulate the data as .NET classes or as rows and
        columns, whatever is appropriate for each application.
    • Added paging and stored
      procedures for update (“update customization”) for ADO.NET Entity
      Framework:
      • Paging: the paging
        support in the ADO.NET Entity Framework allows developers to “page” over
        data in a database by indicating the start row and number of rows to be
        included in the result. Paging is available through Entity SQL (using
        the LIMIT AND SKIP keywords) and through the query-builder methods in
        the ObjectQuery &ltT> class (Top and Skip). In a future CTP the
        feature will also be enabled to be used in LINQ queries by means of the
        standard Take and Skip LINQ operators.
      • Stored-procedures for
        update customization: the Entity Framework by default automatically
        generates SQL statements for insert, update and delete operations when
        processing changes to entities in memory to be sent to the database.
        With the stored-procedures update customization feature developers have
        the option to override the automatic SQL generation and instead provide
        stored-procedures that will perform the insert, update and delete
        operations, which the system will call during entity change processing.
        Among other things, this enables scenarios where direct access to tables
        is restricted in the database and the only way to make changes to the
        data is through stored-procedures.
    • Microsoft
      Synchronization Services for ADO.NET
      • Provides an
        application programming interface (API) to synchronize data between data
        services and a local store. The Synchronization Services API is modeled
        after the ADO.NET data access APIs and gives you an intuitive way to
        synchronize data. It makes building applications for occasionally
        connected environments a logical extension of building applications
        where you can depend on a consistent network connection. For details
        please visit http://go.microsoft.com/fwlink/?LinkId=80742
        .


  • Web
    • Improvements for web
      development in this CTP include:
      • New ASP.NET WebForms
        design-surface with advanced XHTML and CSS features
      • JScript intellisense
        for ASP.NET AJAX and browser DOM
      • Multi-targetting for
        .NET Framework 2.0, 3.0, and 3.5 in websites and web applications
      • LINQ to SQL designer
        integration in websites and web applications


  • Client App-Level Services
    • Enable client
      application developers to use the same user profile and login services as
      your Web applications. This enables customers to utilize on set of
      backend storage for user personalization and authentication regardless of
      the applications type.


  • C# Workflow Rules
    • Workflow Rules allows
      users to enter rules (and conditions) in a code-like manner
      • Support the use of the
        new C# Extension methods features in their rules
      • Enable operator
        overloading and the new operators in their rules


  • XML
    • XML Tools: XSLT
      Debugger
      • Enables Input Data
        Breakpoints allowing the user to break the execution of the style-sheet
        whenever a certain node in input document is hit.
    • XML Editor Performance
      Improvements
      • Performance in the Xml
        Editor for Intellisense, schema validation etc is improved by
        implementing incremental parsing of the XML Document.
    • Seamless transition
      between XML Editor and XSD Designer
      • Improves the
        experience a user has when working with an XML Schema in textual and
        graphical mode at the same time.


  • MSBuild
    • Parallel/Multi-Processor
      Builds
      • Building multiple
        projects in parallel, as much as possible based on the use of dependency
        information in projects to parallelize
      • Allowing the
        developer/builder to control the parallelism by providing them the
        ability to specify the number of processors to use for build.


  • UAC Manifests in the Managed Build Process
    • Support for manifests
      that are embedded into the final executable via the Build process.


  • IDE
    • Windows Presentation
      Foundation (WPF) Designer (“Cider”) & Application Tools to deliver
      the ability to:
      • Create, edit, build,
        run and debug WPF projects
      • Use the WPF Designer
        to:
        • Preview any XAML in
          the designer including user defined controls and types
        • Design Windows, Pages
          and UserControls
        • Do basic layout tasks
          in a Grid
        • Do basic property
          editing using the new property browser
        • Easily understand and
          navigate “document structure” using the Document Outli
        • See changes in the
          designer immediately in the XAML
      • Use the XAML Editor
        to:
        • Edit XAML with
          intellisense
        • See changes in the
          XAML immediately in the designer
        • Build design time for
          WPF controls
    • UAC manifests in the
      IDE for Windows Vista applications
      • Enable developers on
        Windows Vista to easily include the UAC manifest as an embedded
        resource.


  • CLR
    • Add IRI support (RFC
      3987) to URI related classes
      • This allows resource
        identifiers to be specified using a character set that supports all
        languages.
    • New Async model on
      Socket class
      • A new Async model is
        reduces the per I/O overhead compared to the current I/O model
    • Peer Networking Classes
      • Delivers a set of
        peer-to-peer network APIs that allow a developer to easily extend an
        application with compelling collaboration functionality.
    • WMI.NET Provider
      Extension 2.0
      • WMI.NET Provider
        Extension 2.0 simplifies and enhances the development of WMI providers
        in the .Net framework to enable the management of the .NET applications
        while minimizing the impact on the development time.
        • Delivers equivalent
          access to WMI features and functions available to native code
          providers.
        • Exposes property
          updates and methods to managed code.
        • Improved scalability
          for large collections of WMI entities.


  • Office
    • Enable ClickOnce deployment
      for Microsoft Office applications
    • Developers now have an
      easy to use and version resilient security model for their applications
      that will exist for future versions of Visual Studio and Office. With
      full support for ClickOnce deployment of all Office 2007 customizations
      and applications, developers and administrators now have the right tools
      and framework for easy deployment and maintenance of their Office
      solutions.


  • Team Architect
    • Top-down service design
      • Top-down system design
        allows an application architect/lead developer to perform the design of
        a business solution without having to be confronted with technology
        decisions. It enables the user to progressively refine a high-level
        system design, designing new sub-systems and applications in the context
        of the system in which they are to be used.
    • Architectural Roles on
      System, Applications and Endpoints
      • Enables an architect,
        while working on the high-level design of a system’s architecture using
        the System Designer, to introduce elements into the design that play a
        specific pre-defined architectural role(s) within architectural
        patterns.


  • Team Developer
    • Profiler Support for
      WCF Applications
      • Enable profiling of
        WCF based applications to improve application performance
    • Customize and extend
      code correctness policies
      • Code Analysis Check-in
        Policy improvements to communicate to a developer why the check-in
        policy failed and to provide guidance on how to pass the policy
        requirements.
    • Customize and extend
      code correctness policies
      • Code Analysis Check-in
        Policy improvements to communicate to a developer why the check-in
        policy failed and to provide guidance on how to pass the policy
        requirements.
    • Performance tune an
      enterprise application
      • Enables developers to
        run profiling during load and test procedures for a system, to see how
        it behaves, and use integrated tools to profile, debug and tune. This
        also enables performance base-lining, so that users can save a baseline
        profile and then, if the performance degrades, compare up-to-date traces
        to identify the source of the regression


  • Team Test
    • Unit Test Generation
      Improvements
      • Improvements to unit
        test generation provide an easy way for the user to specify what methods
        to test, and generate test methods and helper code to do unit testing,
        as well as providing unit test support for generics.
    • Web Test Validation
      Rule Improvements
      • Web Test rules
        improvements enable testers to create more comprehensive validation
        rules for the application being tested. These improvements include the
        following functions:
        • Stop test on error
        • Search request and
          response
        • Add validation rule
          for title
        • Redirect validation
        • Provide test level
          validation rules
        • Expected HTTP code
        • Warning level for
          errors on dependents
    • Better Web Test Data
      Binding
      • This feature allows
        users to data bind .CSV and XML files, as well as databases to a web
        test, using a simple databinding wizard.
    • Improved Load Test
      Results Management
      • With this feature user
        can open or remove an existing load test result from the load test
        repository. User can also import and export load test results files.


  • Team Foundation Server
    • Team Build
      • Support multi-threaded
        builds with the new MSBuild.
      • Continuous Integration
        – There are many components to this, including build queuing and queue management,
        drop management (so that users can set policies for when builds should
        be automatically deleted), and build triggers that allows configuration
        of exactly how when CI builds should be triggered, for example – every
        checkin, rolling build (completion of one build starts the next), etc.
      • Improved ability to
        specify what source, versions of source, etc to include in a build.
      • Improved ability to
        manage multiple build machines.
      • Simplified ability to
        specify what tests get run as part of a build
    • Version Control support
      • Destroy- The version
        control destroy operation provides administrators with the ability to
        remove files and folders from the version control system. The destroyed
        files and folders cannot be recovered once they are destroyed. Destroy
        allows administrators to achieve SQL server disk space usage goals
        without constantly needing to add more disks to the data tier machine.
        Destroy also facilitates removing versioned file contents that must be
        permanently removed from the system for any other reason.
      • Annotate - Annotate is
        a feature that allows developers to inspect a source code file and see
        at line-by-line level of detail who last changed each section of code.
        It brings together changeset data with difference technology to enable
        developers to quickly learn change history inside a source file.
      • Folder Diff - Team
        Foundation Server now supports compare operations on folders, whereby
        the contents of the folder are recursively compared to identify files
        that differ. Folder diff can compare local folders to local folders,
        local folders to server folders, and server folders to server folders.
        It’s a great way of identifying differences between branches, files that
        you’ve changed locally, and files that have changed between two points
        in time.
      • Get Latest on Checkout
        - As an optional setting on a team project or on an individual basis,
        you can have Team Foundation Server always download the latest version
        of a file when you check it out. This helps ensure that you don’t have
        to merge your changes with somebody else’s when you check the file back
        in.
    • Performance and Scale
      • This release includes
        numerous improvements in performance and scalability of Team Foundation
        Server.


  • Visual C++
    • Easily add the Windows
      Vista “Look and Feel” to native C++ applications
      • Developers can use
        Visual Studio to build ISV applications that exhibit the Windows Vista
        “look & feel”. A number of the Windows Vista “look & feel”
        features are available simply by recompiling an MFC application. Deeper
        integration that requires more coding or design work on the part of the
        developer is also simplified with Visual Studio’s integrated support for
        the Windows Vista native APIs.


Existing CTPs: As Visual Studio code name “Orcas” CTPs are released on a predefined cadence, existing CTPs (such as the LINQ May 2006 CTP) may not yet have been integrated into a given “Orcas” CTP release (This should not be taken as a change in commitment to any existing technology that has been made available as a CTP but instead is just a real world example of how large applications, with many technology areas, are built. We will be integrating this existing functionality into future CTP builds.

Developers using a VPC image can run the CTP on a machine without impacting any existing software installations. The CTP can be removed by deleting the folder and using the Virtual PC application to remove the configuration information.

This image ships with networking set to “local”. This setting enables the virtual machine to think it is connected to a network without actually connecting and exposing the machine to the Internet. We recommend that customers do not modify the networking settings. Customers who wish to turn networking “on” to connect the image to a physical network are advised that they will need to ensure the security of the virtual machine as well as apply any security updates that may have become available since the release of this image.

Saturday, January 13, 2007

Visual Studio Code Name "Orcas" - January Community Technology Preview (CTP) Released

Visual Studio Code Name "Orcas" - January Community Technology Preview (CTP) has been released.
This CTP is available as a Virtual PC image or as a self-extracting install. If you wish to use the Virtual PC image you will need Virtual PC or Virtual Server to run this image. If you wish to use the self extracting install, we advise that you do not install this on a production machine. Depending on your hardware the download files make take between 30-60 minutes to decompress.



The highlights of this CTP include:
  • Extended, more powerful data APIs with the ADO.NET Entity Framework and LINQ to ADO.NET
    • With the ADO.NET Entity Framework developers will be able to model the view of the data that is appropriate for each one of the applications they are building, independently of the structure of the data in the underlying database. The use of the Entity Data Model (EDM) enables developers to design models that follow the concepts built into the application, instead of having to map them to constructs available in relational stores. Once the model is in place, the powerful ADO.NET Entity Framework API is used to access and manipulate the data as .NET classes or as rows and columns, whatever is appropriate for each application.

    • ADO.NET is fully integrated with LINQ and offers many options for using LINQ in various scenarios: LINQ to SQL provides direct access to database tables from the programming environment, LINQ to Entities enables developers to use LINQ over EDM models, and LINQ to DataSet allows the full expressivity of LINQ to be used over DataSets.



  • C# 3.0 Language Support: This CTP implements all of the C#3.0 language features from the May LINQ CTP including:
    • Query Expressions

    • Object and Collection Initializers

    • Extension Methods

    • Local Variable Type Inference and Anonymous Types

    • Lambdas bound to Delegates and Expression trees



  • VB 9.0 Language Support: This CTP implements all of the VB 9.0 language features from the May LINQ CTP including:
    • Query Expressions

    • Object Initializers

    • Extension Methods

    • Local Variable Type Inference

    • Anonymous Types



  • LINQ to Objects API
    • The LINQ to Objects API supports queries over any .NET collection, such as arrays and Generic Lists. This API is defined in the System.Linq namespaces inside System.Core.dll. Click here for more details about LINQ.



  • ClickOnce improvements
    • This CTP delivers ClickOnce improvements for the deployment of Windows Presentation Foundation applications, alternative browser support and ISV rebranding.



  • Managed classes for Elliptic Curve Diffie Hellman and Elliptic Curve Digital Signature Algorithm cryptographic functionality
    • With the addition of these classes, cryptographic developers now have managed classes for Elliptic Curve Diffie Hellman secret agreement and Elliptic Curve Digital Signature Algorithm signing. These classes are built on the new CNG cryptographic libraries in Windows Vista, but still follow the familiar patterns of the cryptographic classes in .NET Framework 2.0.


  • Runtime and design-time support for Office 2007 (including Outlook 2007)
    • Customers can build managed code add-ins with a consistent development experience, regardless of which version of Office they target, which Office application(s) they target, and which programming language they choose. Managed code add-ins enable developers to use strongly-typed class members, with the help of modern development tools, including intellisense and auto-complete. Additionally add-ins can potentially run in multiple versions of Office, enabled by abstracting version-specific code and supported by a version-resilient infrastructure.


  • Support for advanced lifetime management of add-ins and their AppDomains
    • We’ve added the helper classes that manage the lifetime of add-ins, the objects passed between the host and add-ins, and even of the AppDomains the add-ins live in. By using the ContractBase and LifetimeToken handle, pipeline developer can let the hosts and add-ins act as if everything, including the AppDomain the add-in was activated in, was controlled by the garbage collector even though .Net Remoting would normally make that impossible.


  • Client service support for Login/Logout, Role management and Profiles
    • ASP.NET 2.0 shipped with new application services for authentication, authorization and personalization. Most of these services are not tied to ASP.NET and can work in non-web applications. This CTP enables the use of these services in smart client applications for Logon/Logoff, Role management and profiles.


  • A trace listener that logs event to ETW, event tracing for Windows in Vista
    • Event tracing for windows is greatly improved in Vista and the most performant loggings facility available in Windows. The System.Diagnostics.EventProviderTraceListener allows managed tracing to provide events to the Vista’s ETW infrastructure. This is a highly performant, thread-safe listener.


  • Jscript Intellisense support
    • Jscript code formatting and Intellisense support provide developers with a richer editing experience. These improvements enable the IDE to provide statement completion, color syntax highlighting and in-place documentation to Jscript and associated script models such as ASP.NET AJAX.



  • A new numeric type that provides support for very large numbers (Beyond the range of In64)
    • All existing numeric types in the Framework have a limited range. This is the first type that supports arbitrary range and will extend to accommodate any large number as needed. This type lives in the new System.Numeric namespace where all new numeric and arithmetic features are going to reside. It supports all the basic arithmetic operations including things like Pow, DivRem and GreatestCommonDivisor. It implements the following interfaces: IFormattable, IComparable, IComparable<BigInteger> and IEquatable<BigInteger>. It is serliazable and immutable. It has implicit casts from all basic integral types and explicit casts to/from all numeric type. To learn more about this type – please visit the BCL team blog.



  • LINQ over XML (XLinq)
    • Enable further LINQ over XML feature support (in addition to the functionality available in the Oct 2006 CTP) such as the ability to apply XLST to transform into and out of XLinq trees, support for System.XML reader/writer interfaces for improved XML sharing with DOM applications and System.XML schema validation for XLinq nodes.


  • SQL Server Compact Edition (SSCE)
    • SQL Server Compact Edition (SSCE) provides a local relational data store for occasionally connected client applications from desktops to devices. SSCE is light weight, embeddable and is easy to deploy with your client applications without requiring complex administration work from users. Timestamp (row version id) data type, improved table designer, Query processor enhancements and support for local transaction scope are some of the new features you find in this version of SSCE.



Thi CTP is available both as a regular install, and on a virtual machine.

Have fun