Style Works XT Universal 3.7 Working Version
Rubie Mccloughan
Copyright 1995-2018 by The Writing Lab & The OWL at Purdue and Purdue University. All rights reserved. This material may not be published, reproduced, broadcast, rewritten, or redistributed without permission. Use of this site constitutes acceptance of our terms and conditions of fair use.
MLA is a style of documentation that may be applied to many different types of writing. Since texts have become increasingly digital, and the same document may often be found in several different sources, following a set of rigid rules no longer suffices.
Thus, the current system is based on a few guiding principles, rather than an extensive list of specific rules. While the handbook still describes how to cite sources, it is organized according to the process of documentation, rather than by the sources themselves. This gives writers a flexible method that is near-universally applicable.
When deciding how to cite your source, start by consulting the list of core elements. These are the general pieces of information that MLA suggests including in each Works Cited entry. In your citation, the elements should be listed in the following order:
Each element should be followed by the corresponding punctuation mark shown above. Earlier editions of the handbook included the place of publication and required different punctuation (such as journal editions in parentheses and colons after issue numbers) depending on the type of source. In the current version, punctuation is simpler (only commas and periods separate the elements), and information about the source is kept to the basics.
The eighth edition of the MLA handbook introduced what are referred to as "containers," which are the larger wholes in which the source is located. For example, if you want to cite a poem that is listed in a collection of poems, the individual poem is the source, while the larger collection is the container. The title of the container is usually italicized and followed by a comma, since the information that follows next describes the container.
In some cases, a container might be within a larger container. You might have read a book of short stories on Google Books, or watched a television series on Netflix. You might have found the electronic version of a journal on JSTOR. It is important to cite these containers within containers so that your readers can find the exact source that you used.
In addition to the author, there may be other contributors to the source who should be credited, such as editors, illustrators, translators, etc. If their contributions are relevant to your research, or necessary to identify the source, include their names in your documentation.
The publisher produces or distributes the source to the public. If there is more than one publisher, and they are all are relevant to your research, list them in your citation, separated by a forward slash (/).
A DOI, or digital object identifier, is a series of digits and letters that leads to the location of an online source. Articles in journals are often assigned DOIs to ensure that the source is locatable, even if the URL changes. If your source is listed with a DOI, use that instead of a URL.
Again, your goal is to attribute your source and provide a reference without interrupting your text. Your readers should be able to follow the flow of your argument without becoming distracted by extra information.
Purdue OWL is a registered trademark. Copyright 2024 by The On-Campus Writing Lab & The OWL at Purdue and Purdue University. This material may not be published, reproduced, broadcast, rewritten, or redistributed without permission. This website collects and publishes the ideas of individuals who have contributed those ideas in their capacities as faculty-mentored student scholars. The materials collected here do not express the views of, or positions held by, Purdue University. Use of this site constitutes acceptance of our terms and conditions of fair use. Privacy policy.
When you target a framework in an app or library, you're specifying the set of APIs that you'd like to make available to the app or library. You specify the target framework in your project file using a target framework moniker (TFM).
An app or library can target a version of .NET Standard. .NET Standard versions represent standardized sets of APIs across all .NET implementations. For example, a library can target .NET Standard 1.6 and gain access to APIs that function across .NET Core and .NET Framework using the same codebase.
An app or library can also target a specific .NET implementation to gain access to implementation-specific APIs. For example, an app that targets Xamarin.iOS (for example, Xamarin.iOS10) has access to Xamarin-provided iOS API wrappers for iOS 10, or an app that targets Universal Windows Platform (UWP, uap10.0) has access to APIs that compile for devices that run Windows 10.
The following table defines the most common target frameworks, how they're referenced, and which version of .NET Standard they implement. These target framework versions are the latest stable versions. Prerelease versions aren't shown. A target framework moniker (TFM) is a standardized token format for specifying the target framework of a .NET app or library.
A target framework is typically referenced by a TFM. The following table shows the target frameworks supported by the .NET SDK and the NuGet client. Equivalents are shown within brackets. For example, win81 is an equivalent TFM to netcore451.
The net5.0, net6.0, net7.0, and net8.0 TFMs include technologies that work across different platforms. Specifying an OS-specific TFM makes APIs that are specific to an operating system available to your app, for example, Windows Forms or iOS bindings. OS-specific TFMs also inherit every API available to their base TFM, for example, the net6.0 TFM.
.NET 5 introduced the net5.0-windows OS-specific TFM, which includes Windows-specific bindings for WinForms, WPF, and UWP APIs. .NET 6 and later versions have additional OS-specific TFMs, for example, net6.0-ios.
To make your app portable across different platforms but still have access to OS-specific APIs, you can target multiple OS-specific TFMs and add platform guards around OS-specific API calls using #if preprocessor directives. For a list of the available symbols, see Preprocessor symbols.
Cross-platform application models (Xamarin Forms, ASP.NET Core) and bridge packs (Xamarin Essentials) should at least target the base TFM, for example, net8.0, but might also target additional platform-specific flavors to light-up more APIs or features.
You can also specify an optional OS version at the end of an OS-specific TFM, for example, net6.0-ios15.0. The version indicates which APIs are available to your app or library. It doesn't control the OS version that your app or library supports at run time. It's used to select the reference assemblies that your project compiles against, and to select assets from NuGet packages. Think of this version as the "platform version" or "OS API version" to disambiguate it from the run-time OS version.
When an OS-specific TFM doesn't specify the platform version explicitly, it has an implied value that can be inferred from the base TFM and platform name. For example, the default platform value for iOS in .NET 6 is 15.0, which means that net6.0-ios is shorthand for the canonical net6.0-ios15.0 TFM. The implied platform version for a newer base TFM may be higher, for example, a future net8.0-ios TFM could map to net8.0-ios16.0. The shorthand form is intended for use in project files only, and is expanded to the canonical form by the .NET SDK's MSBuild targets before being passed to other tools, such as NuGet.
The .NET SDK is designed to be able to support newly released APIs for an individual platform without a new version of the base TFM. This enables you to access platform-specific functionality without waiting for a major release of .NET. You can gain access to these newly released APIs by incrementing the platform version in the TFM. For example, if the iOS platform added iOS 15.1 APIs in a .NET 6.0.x SDK update, you could access them by using the TFM net6.0-ios15.1.
If your app references a package that has multiple assets for different TFMs, the assets that are closer in version number are preferred. For example, if your app targets net6.0-ios and the package offers assets for net6.0 and net5.0-ios, the net6.0 assets are used. For more information, see Precedences.
Although a platform-specific app or library is compiled against APIs from a specific version of that OS, you can make it compatible with earlier OS versions by adding the SupportedOSPlatformVersion property to your project file. The SupportedOSPlatformVersion property indicates the minimum OS version required to run your app or library. If you don't explicitly specify this minimum run-time OS version in the project, it defaults to the platform version from the TFM.
For your app to run correctly on an older OS version, it can't call APIs that don't exist on that version of the OS. However, you can add guards around calls to newer APIs so they are only called when running on a version of the OS that supports them. This pattern allows you to design your app or library to support running on older OS versions while taking advantage of newer OS functionality when running on newer OS versions.
The SupportedOSPlatformVersion value (whether explicit or default) is used by the platform compatibility analyzer, which detects and warns about unguarded calls to newer APIs. It's burned into the project's compiled assembly as an UnsupportedOSPlatformAttribute assembly attribute, so that the platform compatibility analyzer can detect unguarded calls to that assembly's APIs from projects with a lower SupportedOSPlatformVersion value. On some platforms, the SupportedOSPlatformVersion value affects platform-specific app packaging and build processes, which is covered in the documentation for those platforms.
Here is an example excerpt of a project file that uses the TargetFramework and SupportedOSPlatformVersion MSBuild properties to specify that the app or library has access to iOS 15.0 APIs but supports running on iOS 13.0 and above:
b1e95dc632