- Microsoft Pos .net 1.12 Login
- Microsoft Pos .net 1.12
- Microsoft Pos .net 1.12 Download
- Microsoft Pos .net 1.12 App
- Microsoft Pos .net 1.12 Update
Oct 19, 2013 Microsoft Graph API. Using a Barcode Scanner and POS for.net 1.12. Archived Forums.NET Framework Class Libraries.NET Framework Class Libraries.
- I am on windows 7 64 bit. I am using Visual Basic 2010. I have downloaded the MS POS of.net 1.12 and referenced the application to the MicrosoftPointOfService.dll. Microsoft.PointOfService and system.collections. I have tried to download the OPOS from Symbol - was sure if I have the right one or it is in the right place.
- Hello i am new in develop with pos.net 1.12. I installed the pos.net 1.12 in my windows 7 ultimate and a barcode scanner plug n play lga-960. With vs 2008 i open an new.
Microsoft ships major releases, minor releases, and servicing updates (patches) for .NET 5.0 (and .NET Core) and later versions. This article explains release types, servicing updates, SDK feature bands, support periods, and support options.
Release types
Information about the type of each release is encoded in the version number in the form major.minor.patch.
For example:
- .NET Core 3.0 and NET 5.0 are major releases.
- .NET Core 3.1 is the first minor release after the .NET Core 3.0 major release.
- .NET Core 3.1.7 is the seventh patch for .NET Core 3.1.
Major releases
Major releases include new features, new public API surface area, and bug fixes. Examples include .NET Core 3.0 and .NET 5.0. Due to the nature of the changes, these releases are expected to have breaking changes. Major releases install side by side with previous major releases.
Minor releases
Minor releases also include new features, public API surface area, and bug fixes, and may also have breaking changes. Examples include .NET Core 2.1 and .NET Core 3.1. The difference between these and major releases is that the magnitude of the changes is smaller. An application upgrading from .NET Core 3.0 to 3.1 has a smaller jump to move forward. Minor releases install side by side with previous minor releases.
Servicing updates
Servicing updates (patches) ship almost every month, and these updates carry both security and non-security bug fixes. For example, .NET Core 3.1.8 is the eighth update for .NET Core 3.1. When these updates include security fixes, they're released on 'patch Tuesday', which is always the second Tuesday of the month. Servicing updates are expected to maintain compatibility. Starting with .NET Core 3.1, servicing updates are upgrades that remove the preceding update. For example, the latest servicing update for 3.1 removes the previous 3.1 update upon successful installation.
Feature bands (SDK only)
Versioning for the .NET SDK works slightly differently from the .NET runtime. To align with new Visual Studio releases, .NET SDK updates sometimes include new features or new versions of components like MSBuild and NuGet. These new features or components may be incompatible with the versions that shipped in previous SDK updates for the same major or minor version.
To differentiate such updates, the .NET SDK uses the concept of feature bands. For example, the first .NET Core 3.1 SDK was 3.1.100. This release corresponds to the 3.1.1xx feature band. Feature bands are defined in the hundreds groups in the third section of the version number. For example, 3.1.101 and 3.1.201 are versions in two different feature bands while 3.1.101 and 3.1.199 are in the same feature band. When .NET Core SDK 3.1.101 is installed, .NET Core SDK 3.1.100 is removed from the machine if it exists. When .NET Core SDK 3.1.200 is installed on the same machine, .NET Core SDK 3.1.101 isn't removed.
Runtime roll-forward and compatibility
Major and minor updates install side by side with previous versions. An application built to target a specific major.minor version continues to use that targeted runtime even if a newer version is installed. The app doesn't automatically roll forward to use a newer major.minor version of the runtime unless you opt in for this behavior. An application that was built to target .NET Core 3.0 doesn't automatically start running on .NET Core 3.1. We recommend rebuilding the app and testing against a newer major or minor runtime version before deploying to production. For more information, see Framework-dependent apps roll forward and Self-contained deployment runtime roll forward.
Servicing updates are treated differently from major and minor releases. An application built to target .NET Core 3.1 runs on the 3.1.0 runtime by default. It automatically rolls forward to use a newer 3.1.1 runtime when that servicing update is installed. This behavior is the default because we want security fixes to be used as soon as they're installed without any other action needed. You can opt out from this default roll forward behavior.
Microsoft Pos .net 1.12 Login
.NET Core and .NET 5 version lifecycles
.NET Core, .NET 5, and later versions adopt the modern lifecycle rather than the fixed lifecycle that has been used for .NET Framework releases. Products with fixed lifecycles provide a long fixed period of support, for example, 5 years of mainstream support and another 5 years of extended support. Mainstream support includes security and non-security fixes, while extended support provides security fixes only. Products that adopt a modern lifecycle have a more service-like support model, with shorter support periods and more frequent releases.
Release tracks
There are two support tracks for releases:
Current releases
These versions are supported until 3 months after the next major or minor release ships.
Example:
- .NET Core 3.0 shipped in September 2019 and was followed by .NET Core 3.1 in December 2019.
- .NET Core 3.0 support ended in March 2020, 3 months after 3.1 shipped.
Long Term Support (LTS) releases
These versions are supported for a minimum of 3 years, or 1 year after the next LTS release ships if that date is later.
Example:
- .NET Core 2.1 was released in May 2018 and was deemed an LTS release in August 2018.
- .NET Core 3.1 was the next LTS release and was released in December 2019.
- Because August 2021 (3 years) is later than December 2020 (one year after the 3.1 release), .NET Core 2.1 is supported through August 2021.
Releases alternate between LTS and Current, so it's possible for an earlier release to be supported longer than a later release. For example, .NET Core 2.1 is an LTS release with support through August 2021. The 3.0 release shipped more than a year later but went out of support earlier, in December 2019.
Servicing updates ship monthly and include both security and non-security (reliability, compatibility, and stability) fixes. Servicing updates are supported until the next servicing update is released. Servicing updates have runtime roll forward behavior. That means that applications default to running on the latest installed runtime servicing update.
How to choose a release
If you're building a service and expect to continue updating it on a regular basis, then a Current release like .NET 5.0 may be your best option to stay up to date with the latest features .NET has to offer.
If you're building a client application that will be distributed to consumers, stability may be more important than access to the latest features. Your application might need to be supported for a certain period before the consumer can upgrade to the next version of the application. In that case, an LTS release like .NET Core 3.1 might be the right option.
Servicing updates
.NET servicing updates are supported until the next servicing update is released. The release cadence is monthly.
You need to regularly install servicing updates to ensure that your apps are in a secure and supported state. For example, if the latest servicing update for .NET Core 3.1 is 3.1.8 and we ship 3.1.9, then 3.1.8 is no longer the latest. The supported servicing level for 3.1 is then 3.1.9.
For information about the latest servicing updates for each major and minor version, see the .NET downloads page.
End of support
End of support refers to the date after which Microsoft no longer provides fixes, updates, or technical assistance for a product version. Before this date, make sure you have moved to using a supported version. Versions that are out of support no longer receive security updates that protect your applications and data.
Supported operating systems
.NET 5 (and .NET Core) and later versions can be run on a range of operating systems. Each of these operating systems has a lifecycle defined by its sponsor organization (for example, Microsoft, Red Hat, or Apple). We take these lifecycle schedules into account when adding and removing support for operating system versions.
When an operating system version goes out of support, we stop testing that version and providing support for that version. Users need to move forward to a supported operating system version to get support.
For more information, see the .NET OS Lifecycle Policy.
Microsoft Pos .net 1.12
Get support
You have a choice between Microsoft assisted support and Community support.
Microsoft support
For assisted support, contact a Microsoft Support Professional.
You need to be on a supported servicing level (the latest available servicing update) to be eligible for support. If a system is running 3.1 and the 3.1.8 servicing update has been released, then 3.1.8 needs to be installed as a first step.
Community support
For community support, see the Community page.
See also
For more information, including supported date ranges for each version of .NET Core and for .NET 5, see the Support Policy.
An Microsoft .NET application wishing to utilize retail devices has at least two available approaches.
OPOS via COM Interop
Microsoft .NET's COM interoperability support allows straightforward integration of the OPOS Common Control Objects into .NET applications. One can directly reference COM objects, and Visual Studio will build the required interoperability layer.
Alternatively, available below are OPOS CCO interoperability assemblies created by the Microsoft TLBIMP utility. All use the 'POS.Devices' namespace, and the class names are consistent with the CCO names. Creating an instance of the class will instantiate the corresponding OPOS CCO, after which time one may call OPOS methods and properties, plus add handlers for events.
A typical .NET POS application will include the following in its software stack. Ensure that all of these components are installed, plus registered and/or configured as needed:
- Application. Since the CCOs and and most vendors' Service Objects are 32-bit components, the application's Build Properties must target x86.
- OPOS for .NET Assembly. The application references and creates an instance of the assembly's device class. Creating this class causes an instance of the corresponding OPOS Common Control Object to be created. Adding event handlers to this class will hook into the Control Object's events.
- OPOS Common Control Objects. The Common Control Object lives for as long as the assembly's device class that created it. (The registered CCO version must be greater or equal to the OPOS for .NET Assembly.)
- OPOS Service Object. When the application calls the OPOS for .NET Assembly device class' Open(DeviceName) method, it calls the Control Object's Open method, which looks for the DeviceName in the registry to find and instantiate the appropriate Service Object. (You can manually browse the registry beginning at the key HKLMSOFTWAREOLEforRetailServiceOPOS to find the valid device names.)
The service object must be acquired from the hardware vendor, and must be installed and configured using instructions from the vendor. Most vendor's configuration utilities offer a test option (which often run the OPOS CheckHealth API). During setup, you should try it to make sure that the Service Object is set up and working with the hardware before adding the additional software layers.
The pre-built assemblies plus a sample application may be foundbelow.
POS for .NET
Microsoft's Point of Service for .NET is currently at version 1.12. Excerpting from its home documentation page, POS for .NET 'is a class library that enables POS developers to apply Microsoft .NET technologies in their products. It provides a simple and consistent interface for.NET Framework applications to interact with POS devices, a set of interfaces and classes created to help Vendors write applications for common devices such as Cash Drawers or Line Displays, and support for Windows Plug and Play functionality.'
To download, searchthis page for 'POS for .NET'. The POS for .NET v1.12 download page states that its supported operating systems are 'Windows Embedded for Point of Service; Windows Server 2003 Service Pack 1; Windows Vista Business; Windows Vista Enterprise; Windows XP Service Pack 2'.
The UnifiedPOS specification contains an appendix that describes the POS for .NET relationship to UnifiedPOS.
OPOS Assemblies for .NET
The complete set of OPOS Assemblies are available in a ZIP file, or they may be installed via the CCO 1.13.003 or 1.14.001 Windows Installer file. A simple test program is also available.
- OPOS for .NET Assemblies 1.14.001
This ZIP file contains the following:- One assembly for each of the OPOS device types. As an example, the filename of the POSPrinter assembly is 'POS.Devices.OPOSPOSPrinter.dll'. In addition, for compatibility with applications built against the 1.12.xxx or 1.13.xxx assemblies, publisher policy assemblys are included for each device type.
- An assembly containing the OPOS constants.
- A 'readme' file.
- Two batch files to assist developers in adding or removing the assemblies from the Global Assembly Cache (GAC), if desired. These must be run in adminstrator mode.
- OPOS for .NET Assemblies 1.13.003
This ZIP file contains a similar set of files, but for UnifiedPOS 1.13. - OPOS for .NET Assemblies 1.12.000
This ZIP file contains a similar set of files, but for UnifiedPOS 1.12. - POSPrinter1 Application
This ZIP file contains a C# test application project. It was built against the 1.12.000 OPOS for .NET Assemblies.
Microsoft Pos .net 1.12 Download
Example -- Prepared against the 1.12.000 assemblies and 1.12.000 CCOs.
A screenshot of the POSPrinter1 sample application follows, followed by the NCR Emulator Service Object which was used for this run. (The emulators are not available to the public. You should substitute your own emulators or a vendor's installed and configured device.) The following activities occur while running it:
- Application startup: Instantiate the OPOS POSPrinter assembly's class and wire the StatusUpdateEvents. Display the OPOS Common Control Object's ControlObjectDescription and ControlObjectVersion properties.
- Open: When this button is pressed, the application calls the Open and ClaimDevice methods, and sets the DeviceEnabled property. After opening the device, the application displays the ServiceObjectDescription and ServiceObjectVersion properties.
- Print: When this button is pressed, the application calls the PrintNormal method to print on the receipt station.
- On the emulator, update the Receipt Station's paper status to 'Empty'. A StatusUpdate event is fired; value 24 = PTR_SUE_REC_EMPTY.
- Print when out-of-paper: The print fails with ResultCode 114 = OPOS_E_EXTENDED. (The ResultCodeExtended is not output by this program, but would be 203 = OPOS_EPTR_REC_EMPTY.)
Microsoft Pos .net 1.12 App
The following screen shots are from Visual Studio 2008, with the POSPrinter1 solution loaded. The Solution Explorer shows the references, including references to the POSPrinter and OPOS Constants assemblies:
The Object Browser shows the classes and interfaces in the OPOSPOSPrinter assembly: