利用HTML5、CSS3与JS开发Windows 8应用全攻略

1星需积分: 9 143 浏览量更新于2024-07-27 收藏 11.48MB PDF 举报

《使用HTML5、CSS3和JavaScript编程Windows 8应用：第二版》是一本由Microsoft Press出版的专业书籍，专注于指导开发者如何利用这些先进的Web技术在Windows 8平台开发应用程序。该书的焦点在于实际操作和应用技巧，而非深入探讨HTML5、CSS3和JavaScript的基本理论，因为作者强调的是技术在Windows 8环境中的实际运用。书中作者Kraig Brockschmidt引领读者步入WinRT（Windows Runtime）的世界，这是一种专为Windows 8和Windows Phone 8设计的跨平台开发框架，它允许开发者构建原生性能的应用，同时利用Web技术来简化开发流程。HTML5的特性如离线存储、多媒体支持和设备感知API，CSS3的增强布局和视觉效果，以及JavaScript的强大交互能力，都被巧妙地结合到Windows 8应用的开发过程中。本书可能包含对预发布软件的讨论，这意味着读者可能会接触到一些还未最终发布的功能，这些内容可能会在商业版本发布前有所调整。然而，尽管如此，它仍提供了宝贵的实践经验，适用于那些希望将自己的技能扩展到Windows 8开发领域的前端开发者。值得注意的是，书中涉及的示例、公司、产品、域名和其他标识都是虚构的，旨在演示概念而并非真实存在。读者在学习过程中应理解，书中提供的信息仅供参考，Microsoft不对文档中的内容做出任何保证，包括URL和互联网资源的稳定性。使用本书的风险完全由用户自行承担。《Programming Windows 8 Apps with HTML, CSS, and JavaScript, 2Ed》是一本实用且具有针对性的指南，对于想要利用现代Web技术打造Windows 8应用的开发者来说，无论是初学者还是经验丰富的专业人士，都能从中获得有价值的开发策略和技术细节。

Chapter 1

The Life Story of a WinRT App:

Platform Characteristics

of Windows 8

Paper or plastic? Fish or cut bait? To be or not to be? Standards-based or native? These are the

questions of our time….

Well, OK, maybe most of these aren’t the grist for university-level philosophy courses, but certainly

the last one has been increasingly important for app developers. Standards-based apps are great

because they run on multiple platforms; your knowledge and experience with standards like HTML5

and CSS3 are likewise portable. Unfortunately, because standards generally take a long time to

produce, they always lag behind the capabilities of the platforms themselves. After all, competing

platform vendors will, by definition, always be trying to differentiate! For example, while HTML5 now

has a standard for geolocation/GPS sensors and has started on working drafts for other forms of sensor

input (like accelerometers, compasses, near-field proximity, and so on), native platforms already make

these available. And by the time HTML’s standards are in place and widely supported, the native

platforms will certainly have added another set of new capabilities.

As a result, developers wanting to build apps around cutting-edge features—to differentiate from

their own competitors!—must adopt the programming language and presentation technology

imposed by each native platform or take a dependency on a third-party framework that tries to bridge

the differences.

Bottom line: it’s a hard choice.

Fortunately, Windows 8 provides what I personally think is a brilliant solution for apps. Early on, the

Windows team set out to solve the problem of making native capabilities—the system API, in other

words—directly available to any number of programming languages, including JavaScript. This is

what’s known as the Windows Runtime API, or just WinRT for short.

WinRT APIs are implemented according to a certain low-level structure and then “projected” into

different languages in a way that looks and feels natural to developers familiar with those languages.

This includes how objects are created, configured, and managed; how events, errors, and exceptions

are handled; how asynchronous operations work (to keep the user experience fast and fluid); and even

the casing of names on methods, properties, and events.

The Windows team also made it possible to write native apps that employ a variety of presentation

technologies, including DirectX, XAML, and, in the case of apps written in JavaScript, HTML5 and CSS3.

This means that Windows gives you—a developer already versed in HTML, CSS, and JavaScript

standards—the ability to use what you know to write fully native Windows 8 apps using the WinRT API.

Those apps will, of course, be specific to the Windows 8 platform, but the fact that you don’t have to

learn a completely new programming paradigm is worthy of taking a week off to celebrate—especially

because you won’t have to spend that week (or more) learning a complete new programming

paradigm!

Throughout this book we’ll explore how to leverage what you know of standards-based web

technologies to build great Windows 8 apps. In the next chapter we’ll focus on the basics of a working

app and the tools used to build it. Then we’ll look at fundamentals like the fuller anatomy of an app,

controls, collections, layout, commanding, state management, and input, followed by chapters on

media, animations, contracts through which apps work together, networking, devices, WinRT

components, and the Windows Store (a topic that includes localization and accessibility). There is much

to learn.

For starters, let’s talk about the environment in which apps run and the characteristics of the

platform on which they are built—especially the terminology that we’ll depend on in the rest of the

book (highlighted in italics). We’ll do this by following an app’s journey from the point when it first

leaves your hands, through its various experiences with your customers, to where it comes back home

for rest, renewal, and rebirth. For in many ways your app is like a child: you nurture it through all its

formative stages, doing everything you can to prepare it for life in the great wide world. So it helps to

understand the nature of that world!

Terminology note What we refer to as WinRT apps are those that are acquired from the Windows

Store and for which all the platform characteristics in this chapter (and book) apply. In consumer

contexts these are also known as Windows Store apps, but since we’re primarily interesting in how

they’re written—using the WinRT API—we’ll refer to them as WinRT apps. These are distinctly different

from traditional desktop applications that are acquired through regular retain channels and installed

through their own installer programs. Unless noted, then, an “app” in this book refers to a WinRT app.

Leaving Home: Onboarding to the Store

For WinRT apps, there’s really one port of entry into the world: customers always acquire, install, and

update apps through the Windows Store. Developers and enterprise users can side-load apps, but for

the vast majority of the people you care about, they go to the Windows Store and the Store alone.

This obviously means that an app—the culmination of your development work—has to get into the

Store in the first place. This happens when you take your pride and joy, package it up, and upload it to

the Store by using the Store/Upload App Package command in Visual Studio.

The package itself is an

To do this you’ll need to create a developer account with the Store by using the Store/Open Developer Account command in

Visual Studio Express. Visual Studio Express and Expression Blend, which we’ll be using as well, are free tools that you can obtain

appx file (.appx)—see Figure 1-1—that contains your app’s code, resources, libraries, and a manifest.

The manifest describes the app (names, logos, etc.), the capabilities it wants to access (such as areas of

the file system or specific devices like cameras), and everything else that’s needed to make the app

work (such as file associations, declaration of background tasks, and so on). Trust me, we’ll become

great friends with the manifest!

FIGURE 1-1 An appx package is simply a zip file that contains the app’s files and assets, the app manifest, a

signature, and a sort of table-of-contents called the blockmap. When uploading an app, the initial signature is

provided by Visual Studio; the Windows Store will re-sign the app once it’s certified. The blockmap, for its part,

describes how the app’s files are broken up into 64K blocks. In addition to providing certain security functions (like

detecting whether a package has been tampered with) and performance optimization, the blockmap is used to

determine exactly what parts of an app have been updated between versions so the Windows Store only needs to

download those specific blocks rather than the whole app anew.

The upload process will walk you through setting your app’s name, choosing selling details

(including price tier, in-app purchases, and trial periods), providing a description and graphics, and also

providing notes to manual testers. After that, your app essentially goes through a series of job

interviews, if you will: background checks (malware scans and GeoTrust certification) and manual

testing by a human being who will read the notes you provide (so be courteous and kind!). Along the

way you can check your app’s progress through the Windows Store Dashboard.

from http://dev.windows.com. This also works in Visual Studio Ultimate, the fuller, paid version of this flagship development

environment.

All of the automated tests except the malware scans are incorporated into the Windows App Certification Kit, affectionately

known as the WACK. This is part of the Windows SDK that is itself included with the Visual Studio Express/Expression Blend

The overarching goal with these job interviews (or maybe it’s more like getting through airport

security!) is to help users feel confident and secure in trying new apps, a level of confidence that isn’t

generally found with apps acquired from the open web. As all apps in the Store are certified, signed,

and subject to ratings and reviews, customers can trust all apps from the Store as they would trust

those recommended by a reliable friend. Truly, this is wonderful news for most developers, especially

those just getting started—it gives you the same access to the worldwide Windows market that has

been previously enjoyed only by those companies with an established brand or reputation.

It’s worth noting that because you set up pricing, trial versions, and in-app purchases during the

on-boarding process, you’ll have already thought about your app’s relationship to the Store quite a bit!

After all, the Store is where you’ll be doing business with your app, whether you’re in business for fame,

fortune, fun, or philanthropy.

As a developer, indeed, this relationship spans the entire lifecycle of an app—from planning and

development to distribution, support, and servicing. This is, in fact, why I’ve started this life story of an

app with the Windows Store, because you really want to understand that whole lifecycle from the very

beginning of planning and design. If, for example, you’re looking to turn a profit from a paid app or

in-app purchases, perhaps also offering a time-limited or feature-limited trial, you’ll want to engineer

your app accordingly. If you want to have a free, ad-supported app, or if you want to use a third-party

commerce solution for in-app purchases (bypassing revenue sharing with the Store), these choices also

affect your design from the get-go. And even if you’re just going to give the app away to promote a

cause or to just share your joy, understanding the relationship between the Store and your app is still

important. (For all these reasons, you might want to skip ahead read the first parts of Chapter 17,

"Apps for Everyone," before you start writing your app in earnest.)

Anyway, if your app hits any bumps along the road to certification, you’ll get a report back with all

the details, such as any violations of the Certification requirements for Windows apps (part of the

Windows Store agreements section). Otherwise, congratulations—your app is ready for customers!

Sidebar: The Store API and Product Simulator

The Windows.ApplicationModel.Store.CurrentProduct class in WinRT provides the ability for

apps to retrieve their product information from the store (including in-app purchases), check

license status, and prompt the user to make purchases (such as upgrading a trial or making an

in-app purchase).

Of course, this begs a question: how can an app test such features before it’s even in the

Store? The answer is that during development, you use these APIs through the

Windows.ApplicationModel.Store.CurrentProductSimulator class instead. This is entirely

identical to CurrentProduct except that it works against local data in an XML file rather than live

Store data in the cloud. This allows you to simulate the various conditions that your app might

download. If you can successfully run the WACK during your development process, you shouldn’t have any problem passing the

first stage of onboarding.

剩余536页未读，继续阅读

takizawajin001

粉丝: 0
资源: 2

利用HTML5、CSS3与JS开发Windows 8应用全攻略

Programming Windows 8 Apps with HTML CSS and JavaScript

Programming Windows 8 Apps with HTML CSS and JavaScript PDF

html css js MYSQL PHP

programming web applications with node, express and pug

javascript DOM

programming windows by charles petzold 第五版 pdf

8 Good Programming Practice

What are the key programming component of a basic web page? Give one example for each of them.

Initialize in c programming language 2 dimentianal array 4 rows 24 columns with values from 0 to 96

请分别生成几篇python的MySQL操作、scoket通信、flask框架、html、css、javas的参考文献，请以标准格式给出

最新资源