hexsha
stringlengths 40
40
| size
int64 5
1.04M
| ext
stringclasses 6
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 3
344
| max_stars_repo_name
stringlengths 5
125
| max_stars_repo_head_hexsha
stringlengths 40
78
| max_stars_repo_licenses
sequencelengths 1
11
| max_stars_count
int64 1
368k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 3
344
| max_issues_repo_name
stringlengths 5
125
| max_issues_repo_head_hexsha
stringlengths 40
78
| max_issues_repo_licenses
sequencelengths 1
11
| max_issues_count
int64 1
116k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 3
344
| max_forks_repo_name
stringlengths 5
125
| max_forks_repo_head_hexsha
stringlengths 40
78
| max_forks_repo_licenses
sequencelengths 1
11
| max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 5
1.04M
| avg_line_length
float64 1.14
851k
| max_line_length
int64 1
1.03M
| alphanum_fraction
float64 0
1
| lid
stringclasses 191
values | lid_prob
float64 0.01
1
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
472b37969f0bc78457868723b702892eb394a9c1 | 466 | md | Markdown | src/projects/compile.md | alarisprime/alarisprime.com | c1e5702b1dfdcd3c288d1651b8e50c64fcf5d58b | [
"CC0-1.0"
] | 1 | 2017-05-18T08:16:26.000Z | 2017-05-18T08:16:26.000Z | src/projects/compile.md | alarisprime/alarisprime.com | c1e5702b1dfdcd3c288d1651b8e50c64fcf5d58b | [
"CC0-1.0"
] | 19 | 2016-05-22T14:23:41.000Z | 2020-10-29T19:45:31.000Z | src/projects/compile.md | alarisprime/alarisprime.com | c1e5702b1dfdcd3c288d1651b8e50c64fcf5d58b | [
"CC0-1.0"
] | 11 | 2016-05-22T10:39:32.000Z | 2019-02-05T01:19:51.000Z | ---
country: India
date: 2015-06-15
projectUrl: https://www.compile.com
title: Compile.com
company: Compile Inc.
companyUrl: https://www.compile.com
---
<p>Saneef, together with Enakshi, helped in the concept, design, and development of Compile’s website. He also provided a study on improving the quality of data given to clients through regular end-user feedback. Saneef designed and developed a unified interface for Compile’s various products.</p>
| 42.363636 | 311 | 0.757511 | eng_Latn | 0.972671 |
472b94726fbd40ab27d3e6f1ac463c59de04b0f7 | 2,005 | md | Markdown | src/collections/resources/algorithmic-fair-use-pdf-article.md | inclusive-design/wecount.inclusivedesign.ca | 825d07037bf4d0ffbd923d757b5b34733fdcf800 | [
"BSD-3-Clause"
] | 8 | 2019-12-13T20:26:36.000Z | 2021-04-20T03:44:10.000Z | src/collections/resources/algorithmic-fair-use-pdf-article.md | inclusive-design/wecount.inclusivedesign.ca | 825d07037bf4d0ffbd923d757b5b34733fdcf800 | [
"BSD-3-Clause"
] | 557 | 2019-12-13T22:15:47.000Z | 2022-02-22T18:16:16.000Z | src/collections/resources/algorithmic-fair-use-pdf-article.md | inclusive-design/wecount.inclusivedesign.ca | 825d07037bf4d0ffbd923d757b5b34733fdcf800 | [
"BSD-3-Clause"
] | 19 | 2019-12-13T20:44:57.000Z | 2021-08-12T05:51:21.000Z | ---
title: "Algorithmic Fair Use"
focus: "Bias"
source: "University of Chicago Law Review"
readability: ["E"]
type: "PDF Article"
toolPurpose: []
toolAccessibilityIssues: []
openSource: false
sharePointUrl: "https://ocaduniversity.sharepoint.com/teams/Team_WeCount/Shared%20Documents/Resources%20and%20Tools/Literature%20(curated)/Algorithmic%20Fair%20Use.pdf"
keywords: []
learnTags: ["bias","methods","ethics","fairness","government"]
summary: "This article discusses the legal challenges that have developed around using algorithms, which are subject to bias decisions and biased data, to detect copyright infringement in a multimedia environment and the subjectiveness in judging \"fair use.\" "
---
Legal governance and regulation are becoming increasingly reliant on datacollection and algorithmic data processing. In the area of copyright, online protec-tion of digitized works is frequently mediated by algorithmic enforcement systemsintended to purge illicit content and limit the liability of YouTube, Facebook, andother content platforms. But unauthorized content is not necessarily illicit content.Many unauthorized digital postings may claim legitimacy under statutory excep-tions like the legal balancing standard known as fair use. Such exceptions exist toameliorate the negative effects of copyright on public discourse, personal enrichment,and artistic creativity. Consequently, it may seem desirable to incorporate fair usemetrics into copyright policing algorithms, both to protect against automated over-deterrence and to inform users of their compliance with copyright law. In this Essay,I examine the prospects for algorithmic mediation of copyright exceptions, warningthat the design values embedded in algorithms will inevitably become embedded inpublic behavior and consciousness. Thus, algorithmic fair use carries with it thevery real possibility of habituating new media participants to its own biases and soprogressively altering the fair use standard it attempts to embody.
| 125.3125 | 1,299 | 0.826933 | eng_Latn | 0.99385 |
472bc62fee94dd0e2784a055c82615ac80179168 | 7,711 | md | Markdown | content/chapter6/chapter6-3-chinese.md | Zoupers/CPP-17-STL-cookbook | f047533cb7e87acb5f33168895a2b0f6834f20a8 | [
"Apache-2.0"
] | 873 | 2018-03-28T05:41:28.000Z | 2022-03-30T02:18:50.000Z | content/chapter6/chapter6-3-chinese.md | mapleFU/CPP-17-STL-cookbook | c827a95e67a61edfa24a8b1f048a0bc7578c1aaf | [
"Apache-2.0"
] | 6 | 2018-05-16T15:13:04.000Z | 2021-01-15T02:39:44.000Z | content/chapter6/chapter6-3-chinese.md | mapleFU/CPP-17-STL-cookbook | c827a95e67a61edfa24a8b1f048a0bc7578c1aaf | [
"Apache-2.0"
] | 209 | 2018-04-05T14:26:13.000Z | 2022-03-27T08:45:25.000Z | # 使用STL数值算法实现傅里叶变换
信号处理领域傅里叶变换是非常重要和著名的公式。这个公式发现于200年前，其计算机用例实很多了。傅里叶变换可以用于音频/图像/视频压缩、音频滤波、医疗图像设备和用于辨识声音的手机引用。
因为其应用领域广泛，STL也试图将其用在数值计算领域。傅里叶变换只是其中一个例子，同样也是非常棘手的一个。其公式如下所示：
公式基于累加和的变换。累加中的每个元素是输入信号向量中的一个数据点和表达式`exp(-2 * i * ...)`的乘积。这里需要一些工程数学的知识，你需要简单的了解复数的概念，如果你没有相关的知识，了解概念就可以了。仔细观察这个公式，其就是将信号中的所有数据点进行加和(信号数据的长度为N)，其循环索引值为j。其中k是另一个循环变量，因为傅里叶变换计算出的是一组值。在这组值中，每一个数据点都表示着一段重复波形的幅值和相位，这些信息不包含在原始数据中。当使用循环对其进行实现时，代码可能就会写成下面这样：
```c++
csignal fourier_transform(const csignal &s) {
csignal t(s.size());
const double pol {-2.0 * M_PI / s.size()};
for (size_t k {0}; k < s.size(); ++k) {
for (size_t j {0}; j < s.size(); ++j) {
t[k] += s[j] * polar(1.0, pol * k * j);
}
}
return t;
}
```
这里`csignal`的类型可能是`std::vector`，其每个元素都是一个复数。对于复数而言，STL中已经有了对应的数据结构可以对其进行表示——`std::complex`。`std::polar`函数计算得是`exp(-2 * i * ...)`部分。
这样实现看起来也挺好，不过本节中我们将使用STL工具对其进行实现。
## How to do it...
本节，我们将实现傅里叶变换和逆变换，然后会对一些信号进行转换：
1. 首先，包含必要的头文件和声明所使用的命名空间：
```c++
#include <iostream>
#include <complex>
#include <vector>
#include <algorithm>
#include <iterator>
#include <numeric>
#include <valarray>
#include <cmath>
using namespace std;
```
2. 信号点的值一个复数，我们使用`std::complex`来表示，并使用`double`进行特化。我们可以对类型进行别名操作，使用`cmple`表示两个`double`值，这两个`double`值分别表示复数的实部和虚部。使用`csdignal`来别名相应的`vector`对象：
```c++
using cmplx = complex<double>;
using csignal = vector<cmplx>;
```
3. 我们需要使用数值指针遍历数值序列。公式中的变量k和j就会随着序列进行累加：
```c++
class num_iterator {
size_t i;
public:
explicit num_iterator(size_t position) : i{position} {}
size_t operator*() const { return i; }
num_iterator& operator++() {
++i;
return *this;
}
bool operator!=(const num_iterator &other) const {
return i != other.i;
}
};
```
4. 傅里叶变换需要接收一个信号，并返回一个新的信号。返回的信号表示已经经过傅里叶变换的信号。通过傅里叶逆变换，我们可以将一个经过傅里叶变换的信号，还原成原始信号，这里我们会提供一个可选的`bool`参数，其会决定变换的方向。`bool`参数作为参数是一种不好习惯，特别是在一个函数的签名中出现多次。我们这有个很简洁的例子。我们做的第一件事，是使用原始信号的尺寸来分配新的信号数组：
```c++
csignal fourier_transform(const csignal &s, bool back = false)
{
csignal t (s.size());
```
5. 公式中有两个因子，其看起来是相同的。让我们将其打包成一个变量：
```c++
const double pol {2.0 * M_PI * (back ? -1.0 : 1.0)};
const double div {back ? 1.0 : double(s.size())};
```
6. `std::accumulate`很适合用来执行公式中的累加部分，我们将对一个范围内的数值使用`accumulate`。对于每个值，我们将逐步的进行单个相加。`std::accumulate`算法会调用一个二元函数。该函数的第一个参数为目前为止我们所累加的变量`sum`，第二个参数为范围内下一个要累加的值。我们会在信号`s`中对当前为止的值进行查找，并且会将其和复数因子`pol`相乘。然后，我们返回新的`sum`。这里的二元函数，使用Lambda表达式进行包装，因为我们将在每次`accumulate`的调用时，`j`变量的值是不同的。因为其是二维循环算法，所以内层Lambda做内部的循环，外层Lambda做外层的循环：
```c++
auto sum_up ([=, &s] (size_t j) {
return [=, &s] (cmplx c, size_t k) {
return c + s[k] *
polar(1.0, pol * k * j / double(s.size()));
};
});
```
7. 傅里叶的内部循环，现在使用`std::accumulate`进行，算法中每个位置都会进行加和。我们使用Lambda表达式来实现，这样我们就能计算出傅里叶变换数组中的每个数据点的值：
```c++
auto to_ft ([=, &s](size_t j){
return accumulate(num_iterator{0},
num_iterator{s.size()},
cmplx{},
sum_up(j))
/ div;
});
```
8. 目前位置，还没有执行傅里叶变换的代码。我们会准备大量的功能性代码，他们会帮助我们完成很多事情。`std::transform`的调用将会使j的值在[0, N)间变换(这步是在外层循环完成)。变换之后的值将全部放入`t`中，`t`就是我们要返回给用户的值：
```c++
transform(num_iterator{0}, num_iterator{s.size()},
begin(t), to_ft);
return t;
}
```
9. 我们将会实现一些辅助函数帮助我们生成信号。首先实现的是一个余弦信号生成器，其会返回一个Lambda表达式，这个表达式通过传入的长度参数，产生对应长度的余弦信号数据。信号本身的长度是不固定的，但是其有固定的周期。周期为N，意味着该信号会在N步之后重复。返回的Lambda表达式不接受任何参数。我们可以重复的对其进行调用，并且每次调用表达式将会返回给我们下一个时间点的信号值：
```c++
static auto gen_cosine (size_t period_len){
return [period_len, n{0}] () mutable {
return cos(double(n++) * 2.0 * M_PI / period_len);
};
}
```
10. 我们所要生成另一个波形是方波。该波形会在`-1`和`+1`两值间震荡，其中不会有其他的值。公式看起来有点复杂，但是其变换非常简单，也就是将值n置为`+1`或`-1`，并且其震荡周期为`period_len`。这里要注意，我们没有使用0对n进行初始化。这样，我们的方波的其实位置就在`+1`上：
```c++
static auto gen_square_wave (size_t period_len)
{
return [period_len, n{period_len*7/4}] () mutable {
return ((n++ * 2 / period_len) % 2) * 2 - 1.0;
};
}
```
11. 产生实际信号可以通过`vector`和信号生成器联合进行，使用重复调用信号生成器对`vector`数组进行填充。`std::generate`就用来完成这个任务的。其接受一组`begin/end`迭代器组和一个生成函数。对于每个合法的迭代器，都会进行`*it = gen()`。通过将这些代码包装成一个函数，我们可以很容易的生成一个信号数组：
```c++
template <typename F>
static csignal signal_from_generator(size_t len, F gen)
{
csignal r (len);
generate(begin(r), end(r), gen);
return r;
}
```
12. 最后，我们需要将信号的结果进行打印。我们可以将数组中的值拷贝到输出流迭代器中进行输出，不过我们需要先将数据进行变换，因为我们的信号数据都是复数对。这样，我们只需要在意每个点的实部就好；所以，我们可以将数组扔到`std::transform`中进行变换，然后将实部提取出来：
```c++
static void print_signal (const csignal &s)
{
auto real_val ([](cmplx c) { return c.real(); });
transform(begin(s), end(s),
ostream_iterator<double>{cout, " "}, real_val);
cout << '\n';
}
```
13. 目前为止，傅里叶公式就已经实现了，不过现在还没有信号进行变换。这个工作我们将在主函数中完成。我们先来定义信号数据的长度：
```c++
int main()
{
const size_t sig_len {100};
```
14. 现在来生成信号数据，转换他们，然后进行打印。首先，生成一个余弦信号和一个方波信号。这两组信号的长度和周期数相同：
```c++
auto cosine (signal_from_generator(sig_len,
gen_cosine( sig_len / 2)));
auto square_wave (signal_from_generator(sig_len,
gen_square_wave(sig_len / 2)));
```
15. 那么现在有了两个波形信号。为了生成第三个信号，我们对方波信号进行傅里叶变换，并且保存在`trans_sqw`数组中。方波的傅里叶变换有些特殊，我们在后面会进行介绍。索引从10到`(signal_length - 10)`都设置为0.0。经过傅里叶变换之后，原始信号将发生很大的变化。我们将在最后看到结果：
```c++
auto trans_sqw (fourier_transform(square_wave));
fill (next(begin(trans_sqw), 10), prev(end(trans_sqw), 10), 0);
auto mid (fourier_transform(trans_sqw, true));
```
16. 现在，我们有三个信号：余弦、mid和方波。对于每个信号，我们将会打印其原始波形，和傅里叶变换过后的波形。输出将有六条曲线组成：
```c++
print_signal(cosine);
print_signal(fourier_transform(cosine));
print_signal(mid);
print_signal(trans_sqw);
print_signal(square_wave);
print_signal(fourier_transform(square_wave));
}
```
17. 编译并运行程序，终端上会打印出大量的数据。如果这里使用绘图输出，就可以看到如下的结果：
## How it works...
这段代码又两个比较难理解的部分。第一个是傅里叶变换本身，另一个是使用可变Lambda表达式生成信号数据。
首先，我们来看一下傅里叶变换。其核心部分在循环中实现(虽然没有在我们实现中这样做，但可以结合代码看下介绍中的公式)，可能会以如下方式实现：
```c++
for (size_t k {0}; k < s.size(); ++k) {
for (size_t j {0}; j < s.size(); ++j) {
t[k] += s[j] * polar(1.0, pol * k * j / double(s.size()));
}
}
```
基于STL算法`std::transform`和`std::accumulate`，我们完成了自己的例子，总结一下就类似如下的伪代码：
```
transform(num_iterator{0}, num_iterator{s.size()}, ...
accumulate((num_iterator0}, num_iterator{s.size()}, ...
c + s[k] * polar(1.0, pol * k * j / double(s.size()));
```
和循环相比，结果完全一样。当然，使用STL算法也可以产生不太好的代码。不管怎么样吧，这个实现是不依赖所选用的数据结构。其对于列表也起作用(虽然这没有太大的意义)。另一个好处是，在C++17中STL很容易并行(将在本书的另一个章节进行介绍)，当需要并行的时候，我们就需要对纯循环进行重构和拆分，将其放入指定的线程中(除非使用类似OpenMP这样的并发库，其会自动的将循环进行重构)。
下一个难点是信号生成。让我来看一下另一个`gen_cosine`:
```c++
static auto gen_cosine (size_t period_len)
{
return [period_len, n{0}] () mutable {
return cos(double(n++) * 2.0 * M_PI / period_len);
};
}
```
每一个Lambda表达式代表一个函数对象，其会在每次调用时改变自身的状态。其状态包含两个变量`period_len`和`n`。变量n会在每次调用时，进行变更。在不同的时间点上，得到的是不同的信号值，并且在时间增加时会使用`n++`对`n`的值进行更新。为了获得信号值的数组，我们创建了辅助函数`signal_from_generator`：
```c++
template <typename F>
static auto signal_from_generator(size_t len, F gen)
{
csignal r (len);
generate(begin(r), end(r), gen);
return r;
}
```
这个函数会通过所选长度创建一个信号`vector`，并且调用`std::generate`对数据点进行填充。数组r中的每一个元素，都会调用一个`gen`函数。`gen`函数是是一种自修改函数对象，我们使用相同的方式创建了`gen_cosine`对象。
> Note：
>
> 本节例子中，STL没有让代码更加的优雅。如果将范围库添加入STL(希望在C++20时加入)，那么可能就会有改观。 | 29.319392 | 316 | 0.65439 | yue_Hant | 0.228885 |
472c33164c2a2e657f9ef9b1ef6cac1c66431894 | 1,548 | md | Markdown | README.md | AlanTurist/quadratic_equation | 90220c1831a8711e1a91cf81fc0e283d793e37c9 | [
"MIT"
] | null | null | null | README.md | AlanTurist/quadratic_equation | 90220c1831a8711e1a91cf81fc0e283d793e37c9 | [
"MIT"
] | null | null | null | README.md | AlanTurist/quadratic_equation | 90220c1831a8711e1a91cf81fc0e283d793e37c9 | [
"MIT"
] | null | null | null | <!DOCTYPE HTML>
<html>
<body>
<head>
<h1>Algebra Quadratic Equation</h1>
<center><i><img src="https://www.python.org/static/apple-touch-icon-72x72-precomposed.png"></i></center>
</head>
<br>
<br>
<body>
<center>It's a script that calculates the solutions of every quadratic equation of the types:
<br>
<b> ax<sup>2</sup> + bx + c = 0, ax<sup>2</sup> + bx = 0 and ax<sup>2</sup> + c = 0 </b></center>
<br>
<br>
If you like to test the script, just download quadratic_equation.exe and run it.
<br>
<br>
<center>Output:</center>
<br>
<br>
<img src="https://github.com/AlanTurist/quadratic_equation/blob/master/images/1.jpg" " width="500" height="333">
<br>
<img src="https://github.com/AlanTurist/quadratic_equation/blob/master/images/2.jpg" " width="500" height="333">
<br>
<img src="https://github.com/AlanTurist/quadratic_equation/blob/master/images/3.jpg" " width="500" height="333">
<br>
<img src="https://github.com/AlanTurist/quadratic_equation/blob/master/images/4.jpg" " width="500" height="333">
<br>
<img src="https://github.com/AlanTurist/quadratic_equation/blob/master/images/5.jpg" " width="500" height="333">
<br>
<img src="https://github.com/AlanTurist/quadratic_equation/blob/master/images/6.jpg" " width="500" height="333">
<br>
<a href="https://sites.google.com/view/alanturista/videotutorial/python/equazione-quadratica" target="_blank">Documentazione</a>
</body>
</html>
| 40.736842 | 135 | 0.641473 | kor_Hang | 0.173365 |
472d2f6637db32179528b2bdcabc7288786a6342 | 6,410 | md | Markdown | _posts/2016-08-03-hide-slow-splits-garmin-connect-extension.md | g3rv4/g3rv4.com | 95b6a6edc9a61967aaf321cb132a58fea4250bb0 | [
"MIT"
] | 2 | 2017-02-02T03:49:24.000Z | 2018-10-23T18:05:25.000Z | _posts/2016-08-03-hide-slow-splits-garmin-connect-extension.md | g3rv4/g3rv4.com | 95b6a6edc9a61967aaf321cb132a58fea4250bb0 | [
"MIT"
] | 1 | 2020-05-23T19:18:16.000Z | 2020-05-23T19:18:16.000Z | _posts/2016-08-03-hide-slow-splits-garmin-connect-extension.md | g3rv4/g3rv4.com | 95b6a6edc9a61967aaf321cb132a58fea4250bb0 | [
"MIT"
] | 1 | 2020-05-23T19:14:45.000Z | 2020-05-23T19:14:45.000Z | ---
layout: post
title: Hiding resting splits on Garmin Connect
subtitle: (aka injecting JS and messing with an existing site via a Chrome Extension)
description: "I started running, and I built a Chrome Extension that changes the data the Garmin Connect webapp shows, by modifying the content of the XHR the server returns."
date: '2016-08-03T18:49:00.003-03:00'
tags:
- garmin connect
- extension
- activity
- chrome
- running
modified_time: '2016-08-03T19:21:05.880-03:00'
priority: 0.5
---
A quick tail of how I started running and built a Chrome Extension that modifies the XHR requests/responses to trick the Garmin Connect web application to show me what I want to see... extensions have _so much power_ over what we see.
<!--more-->
In October 2015, I was diagnosed with hypertriglyceridemia... basically, I wasn't eating healthy and I wasn't doing enough (ehem... any) exercise.
I started a serious diet (one provided by a doctor) and a serious training plan... I started doing spinning but then I tried running... in 3 months all my blood tests were great and I was on a healthy weight... but the best part of this experience is... I discovered a new passion... RUNNING!
Since then, I joined a running team, I'm beating my records and I'm enjoying it a lot. My coach is great and the training plan I'm following is pretty standard. As the good nerd I am, I bought a running watch (because... what good is running if I don't have METRICS???). I started with the Fitbit Surge but I soon found its limitations unbearable... that's why I bought a Garmin Forerunner 630, and I'm super happy with it.
One of the coolest features it has is giving you the chance to do interval training, and setting up a plan on the computer that you can send to the watch so that when you're running it vibrates and tells you to run, rest, or whatever you planned to do. BUT... and there's always a but... all the resting activities are stored as "splits" then lowering your numbers.
Here's an example... I had to run 12 1km intervals (0.62 miles) resting 1:30
You can see that all the even numbers last 1:30, have a crappy Avg Pace (because I was resting) and basically screw my activity numbers... because it says that my Average Page was 9:21 minutes/mile... I was super frustrated by this... so instead of just doing the numbers in excel... I developed an extension that hides those splits and updates the numbers for me :) you can [view its source code here](https://github.com/g3rv4/hide-slow-splits) (I took it down from the store after... not really using it). Basically, you define the criteria of which laps you want to hide and it converts that table to this (now satisfying) one:
Yayyy!!! 7:33 minutes/mile!!! now we're talking :)
I was able to build this in 3 days, basically extensions are just HTML/JS pages so you can leverage a lot of that knowledge. I also found the documentation super straightforward... so let's start digging into the meaty parts of this:
* I wanted to make it configurable per activity (I don't want it to hide ALL the splits that are below a given threshold, sometimes it's part of the training to run slow)
* I wanted to pick up from the garmin website if the user uses miles or kms (I use kms, but I really think this extension could be useful for people all over the world)
* I wanted all the numbers in the activity page to be updated (not just the splits and their averages)
* I wanted to make it easy to set up
You can see the activity I used for this screenshot [here](https://connect.garmin.com/modern/activity/1278494312). Basically, if you check the source code and the DOM, you'll see it's using backbone.js. Honestly, I didn't feel particularly inclined to learn that... I was hoping there would be some kind of global object where I would be able to see all the data and basically just tweak it... but... nope... all what backbone exposes are functions that the Garmin people is calling with well defined parameters (sometimes, even deleting the global variables once they've been used to initialize their objects).
So... not really understanding how their webapp works (and not feeling particularly curious about it) I started checking out other options... I checked the XHR requests and I noticed they were querying `https://connect.garmin.com/modern/proxy/activity-service/activity/1278494312/splits?_=1470259487305` which includes the laps info... eureka! that's it... all I needed then was to have a way for my extension to tweak this XHR response so that Garmin's webapp would show my injected version instead of their own.
Thanks to a Stack Overflow answer I lost, I found out this a blog post (now deleted) at https://izaakschroeder.wordpress.com that explains clearly how to achieve that (so all props to that guy... minus the points he looses for posting how to exploit a vulnerability before letting the company know about it). So with that, I was able to easily modify any request and tweak it... and the webapp would consider my data the truth... yay!!
Well, then an interesting thing happened... the webapp does a request to an activity url (`https://connect.garmin.com/modern/proxy/activity-service/activity/1278494312?_=1470259487283`) that contains the summary BEFORE requesting the splits data... so what I ended up doing was intercepting that request as well, fetching the splits, filtering them and updating the summary (you can [see that here](https://github.com/g3rv4/hide-slow-splits/blob/master/bg.js#L100)).
Once I had that ready, I wanted to pick up the units the user was using... I found out that the HTML of the page declares a global variable `VIEWER_USERPREFERENCES` with that info... but in the `common.js` file, I saw that they're deleting it after using it... so I ended up doing something waaay uglier (but that gets the job done). On the background script, I just give it 5 seconds (so that the DOM elements get initialized) and then just get an element that contains the distance :)
The hardest part of this project was letting go my initial idea... I really wanted to see the backbone data somewhere. Once I broke free from that and found an easy way to modify the XHR responses, it all flowed naturally... so if you're on the fence about writing a chrome extension, by all means give it a try!
| 116.545455 | 630 | 0.769267 | eng_Latn | 0.999652 |
472dab8e6c63fde66cf7cd9b4f3855d9853e95f3 | 10,676 | md | Markdown | articles/virtual-machines/linux/configure-raid.md | salem84/azure-docs.it-it | 3ec6a13aebb82936591c7fc479f084be9bb8776d | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/virtual-machines/linux/configure-raid.md | salem84/azure-docs.it-it | 3ec6a13aebb82936591c7fc479f084be9bb8776d | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/virtual-machines/linux/configure-raid.md | salem84/azure-docs.it-it | 3ec6a13aebb82936591c7fc479f084be9bb8776d | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: Configurare RAID software in una macchina virtuale che esegue Linux | Microsoft Docs
description: Informazioni su come usare mdadm per configurare RAID in Linux in Azure.
services: virtual-machines-linux
documentationcenter: na
author: rickstercdn
manager: gwallace
editor: tysonn
tag: azure-service-management,azure-resource-manager
ms.assetid: f3cb2786-bda6-4d2c-9aaf-2db80f490feb
ms.service: virtual-machines-linux
ms.workload: infrastructure-services
ms.tgt_pltfrm: vm-linux
ms.topic: article
ms.date: 02/02/2017
ms.author: rclaus
ms.subservice: disks
ms.openlocfilehash: d0658af090d9a3f39bee69f5103a78a329fe189c
ms.sourcegitcommit: 44e85b95baf7dfb9e92fb38f03c2a1bc31765415
ms.translationtype: MT
ms.contentlocale: it-IT
ms.lasthandoff: 08/28/2019
ms.locfileid: "70083798"
---
# <a name="configure-software-raid-on-linux"></a>Configurare RAID software in Linux
I RAID software vengono spesso usati nelle macchine virtuali Linux in Azure per presentare più dischi dati collegati come se si trattasse di un singolo dispositivo RAID. In genere questa configurazione consente di migliorare le prestazioni e la velocità effettiva rispetto all'utilizzo di un unico disco.
## <a name="attaching-data-disks"></a>Collegamento di dischi dati
Per configurare un dispositivo RAID sono necessari due o più dischi dati vuoti. Il dispositivo RAID viene creato principalmente per migliorare le prestazioni dell'I/O su disco. In base alle esigenze di I/O, è possibile scegliere di collegare dischi che sono archiviati nell'archiviazione Standard con un massimo di 500 IO/ps per ogni disco o nell'archiviazione Premium con un massimo di 5.000 IO/ps per ogni disco. In questo articolo non verrà illustrato in dettaglio come eseguire il provisioning e collegare dischi dati a una macchina virtuale Linux. Per istruzioni dettagliate su come collegare un disco dati vuoto a una macchina virtuale Linux in Azure, vedere l'articolo di Microsoft Azure relativo al [collegamento di dischi](add-disk.md?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
## <a name="install-the-mdadm-utility"></a>Installazione dell'utility mdadm
* **Ubuntu**
```bash
sudo apt-get update
sudo apt-get install mdadm
```
* **CentOS e Oracle Linux**
```bash
sudo yum install mdadm
```
* **SLES e openSUSE**
```bash
zypper install mdadm
```
## <a name="create-the-disk-partitions"></a>Creazione delle partizioni del disco
In questo esempio verrà creata una singola partizione del disco in /dev/sdc. La nuova partizione del disco verrà denominata /dev/sdc1.
1. Avviare `fdisk` per iniziare la creazione delle partizioni
```bash
sudo fdisk /dev/sdc
Device contains neither a valid DOS partition table, nor Sun, SGI or OSF disklabel
Building a new DOS disklabel with disk identifier 0xa34cb70c.
Changes will remain in memory only, until you decide to write them.
After that, of course, the previous content won't be recoverable.
WARNING: DOS-compatible mode is deprecated. It's strongly recommended to
switch off the mode (command 'c') and change display units to
sectors (command 'u').
```
1. Premere 'n' al prompt per creare una **n**uova partizione:
```bash
Command (m for help): n
```
1. Successivamente, premere 'p' per creare una partizione **p**rimaria:
```bash
Command action
e extended
p primary partition (1-4)
```
1. Premere '1' per selezionare la partizione numero 1:
```bash
Partition number (1-4): 1
```
1. Selezionare il punto di inizio della nuova partizione oppure premere `<enter>` per accettare le impostazioni predefinite, che prevedono il posizionamento della partizione all'inizio dello spazio libero nell'unità:
```bash
First cylinder (1-1305, default 1):
Using default value 1
```
1. Selezionare le dimensioni della partizione, ad esempio digitare '+10G' per creare una partizione da 10 gigabyte. In alternativa, premere `<enter>` per creare un'unica partizione che occupa l'intera unità:
```bash
Last cylinder, +cylinders or +size{K,M,G} (1-1305, default 1305):
Using default value 1305
```
1. Successivamente, modificare l'ID e il **t**ipo della partizione dal valore predefinito '83' (Linux) a 'fd' (rilevamento automatico RAID Linux):
```bash
Command (m for help): t
Selected partition 1
Hex code (type L to list codes): fd
```
1. Infine, scrivere la tabella delle partizioni sull'unità e chiudere fdisk:
```bash
Command (m for help): w
The partition table has been altered!
```
## <a name="create-the-raid-array"></a>Creazione dell'array RAID
1. Nell'esempio seguente verrà eseguito lo striping (livello RAID 0) di tre partizioni situate in tre dischi dati separati (sdc1, sdd1, sde1). Dopo l'esecuzione del comando verrà creato un nuovo dispositivo RAID denominato **/dev/md127** . Si noti anche che se i dischi dati facevano precedentemente parte di una matrice RAID inattiva, può essere necessario aggiungere il parametro `--force` al comando `mdadm`:
```bash
sudo mdadm --create /dev/md127 --level 0 --raid-devices 3 \
/dev/sdc1 /dev/sdd1 /dev/sde1
```
1. Creare il file system nel nuovo dispositivo RAID
**CentOS, Oracle Linux, SLES 12, openSUSE e Ubuntu**
```bash
sudo mkfs -t ext4 /dev/md127
```
**SLES 11**
```bash
sudo mkfs -t ext3 /dev/md127
```
**SLES 11**: abilitare boot.md e creare mdadm.conf
```bash
sudo -i chkconfig --add boot.md
sudo echo 'DEVICE /dev/sd*[0-9]' >> /etc/mdadm.conf
```
> [!NOTE]
> Dopo aver apportato queste modifiche nei sistemi SUSE può essere necessario il riavvio. Questo passaggio *non* è obbligatorio su SLES 12.
>
## <a name="add-the-new-file-system-to-etcfstab"></a>Aggiungere il nuovo file a /etc/fstab
> [!IMPORTANT]
> Se il file /etc/fstab non viene modificato in modo corretto, il sistema potrebbe diventare instabile. In caso di dubbi, fare riferimento alla documentazione della distribuzione per informazioni su come modificare correttamente questo file. È inoltre consigliabile creare una copia di backup del file /etc/fstab prima della modifica.
1. Creare il punto di montaggio desiderato per il nuovo file system, ad esempio:
```bash
sudo mkdir /data
```
1. Quando si modifica /etc/fstab è consigliabile utilizzare l' **UUID** anziché il nome del dispositivo per fare riferimento al file system. Usare l'utilità `blkid` per determinare l'UUID per il nuovo file system:
```bash
sudo /sbin/blkid
...........
/dev/md127: UUID="aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" TYPE="ext4"
```
1. Aprire /etc/fstab in un editor di testo e aggiungere una voce per il nuovo file system, ad esempio:
```bash
UUID=aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee /data ext4 defaults 0 2
```
In alternativa, in **SLES 11**:
```bash
/dev/disk/by-uuid/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee /data ext3 defaults 0 2
```
Salvare e chiudere /etc/fstab.
1. Verificare che la voce /etc/fstab sia corretta:
```bash
sudo mount -a
```
Se questo comando genera un messaggio di errore, verificare la sintassi nel file /etc/fstab file.
Eseguire quindi il comando `mount` per assicurarsi che il file system venga montato:
```bash
mount
.................
/dev/md127 on /data type ext4 (rw)
```
1. (Facoltativo) Parametri di avvio alternativo
**Configurazione di fstab**
Molte distribuzioni includono i parametri di montaggio `nobootwait` o `nofail`, che è possibile aggiungere al file /etc/fstab. Tali parametri consentono di ignorare gli errori durante il montaggio di uno specifico file system. Consentono pertanto di proseguire l'avvio del sistema Linux anche se non è possibile montare correttamente il file system RAID. Per altre informazioni su questi parametri, fare riferimento alla documentazione della distribuzione.
Esempio (Ubuntu):
```bash
UUID=aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee /data ext4 defaults,nobootwait 0 2
```
**Parametri di avvio di Linux**
Oltre ai parametri precedenti, il parametro del kernel "`bootdegraded=true`" consente di avviare il sistema anche se il RAID viene percepito come danneggiato o con funzionalità ridotte, ad esempio se un'unità dati viene rimossa accidentalmente dalla macchina virtuale. Per impostazione predefinita, questa situazione può rendere impossibile l'avvio del sistema.
Per informazioni sulla corretta modifica dei parametri del kernel, fare riferimento alla documentazione della distribuzione. Ad esempio, in molte distribuzioni (CentOS, Oracle Linux, SLES 11) è possibile aggiungere manualmente tali parametri al file "`/boot/grub/menu.lst`". In Ubuntu è possibile aggiungere il parametro `GRUB_CMDLINE_LINUX_DEFAULT` alla variabile in "/etc/default/grub".
## <a name="trimunmap-support"></a>Supporto per TRIM/UNMAP
Alcuni kernel di Linux supportano operazioni TRIM/UNMAP allo scopo di rimuovere i blocchi inutilizzati sul disco. Nel servizio di archiviazione standard, queste operazioni sono particolarmente utili per informare Azure che le pagine eliminate non sono più valide e possono essere rimosse. L'eliminazione delle pagine consente di risparmiare sui costi quando si creano file di grandi dimensioni per poi eliminarli.
> [!NOTE]
> RAID non può inviare comandi di rimozione se le dimensioni del blocco per la matrice sono impostate su un valore inferiore a quello predefinito di 512 KB. Questo perché anche la granularità di annullamento del mapping nell'host è di 512 KB. Se le dimensioni del blocco della matrice sono state modificate tramite il parametro `--chunk=` di mdadm, il kernel può ignorare le richieste TRIM/UNMAP.
Esistono due modi per abilitare la funzione TRIM in una VM Linux. Come di consueto, consultare la documentazione della distribuzione per stabilire l'approccio consigliato:
- Usare l'opzione di montaggio `discard` in `/etc/fstab`, ad esempio:
```bash
UUID=aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee /data ext4 defaults,discard 0 2
```
- In alcuni casi l'opzione `discard` può avere implicazioni sulle prestazioni. In alternativa, è possibile eseguire il comando `fstrim` manualmente dalla riga di comando oppure aggiungerlo a crontab per eseguirlo a intervalli regolari:
**Ubuntu**
```bash
# sudo apt-get install util-linux
# sudo fstrim /data
```
**RHEL/CentOS**
```bash
# sudo yum install util-linux
# sudo fstrim /data
```
| 44.115702 | 799 | 0.730611 | ita_Latn | 0.996706 |
472dd58c82ae179a3bd57b425842b9a0687418a9 | 2,459 | md | Markdown | src/nl/2021-04/12/05.md | ArthurMota9/sabbath-school-lessons | a51fcdecb05cfbbfdacf201ccba9ba768b245885 | [
"MIT"
] | 68 | 2016-10-30T23:17:56.000Z | 2022-03-27T11:58:16.000Z | src/nl/2021-04/12/05.md | ArthurMota9/sabbath-school-lessons | a51fcdecb05cfbbfdacf201ccba9ba768b245885 | [
"MIT"
] | 367 | 2016-10-21T03:50:22.000Z | 2022-03-28T23:35:25.000Z | src/nl/2021-04/12/05.md | ArthurMota9/sabbath-school-lessons | a51fcdecb05cfbbfdacf201ccba9ba768b245885 | [
"MIT"
] | 109 | 2016-08-02T14:32:13.000Z | 2022-03-31T10:18:41.000Z | ---
title: Een profeet uit uw midden
date: 15/12/2021
---
Keer op keer had Israël de waarschuwing gekregen van de Heer om naburige volkeren niet na te doen. Ze moesten juist een voorbeeld zijn voor hen. In Deuteronomium 18:9-14 waarschuwt Mozes hen opnieuw voor hun ‘verfoeilijke praktijken’. Vervolgens laat hij het volk weten dat ze ‘volledig op de HEER, uw God, gericht moeten zijn’ (Deuteronomium 4:6-8; 18:12-13).
`Lees Deuteronomium 18:15-19; vergelijk Handelingen 3:22 en 7:37. Wat zegt Mozes hier tegen het volk? Hoe passen Petrus en Stefanus Deuteronomium 18:18 toe?`
Als het verbond bij de Sinai ter sprake komt, vertelt Mozes dat de kinderen van Israël, toen Gods wet werd geopenbaard, hem vroegen om als tussenpersoon op te treden. Hij was een middelaar tussen God en hen (Exodus 20:18-21). Op dat moment belooft Mozes hun tot tweemaal toe dat de Heer een profeet zal opwekken zoals Mozes (Deuteronomium 18:15,18). Daarbij gaat het er vooral om dat deze profeet, net als Mozes, onder andere ook een middelaar zal zijn tussen het volk en de Heer. Vele eeuwen later citeren zowel Petrus als Stefanus dit vers om naar Jezus te verwijzen. Voor Petrus was Jezus de vervulling van de dingen waar ‘zijn heilige profeten’ over hadden gesproken. De leiders moeten Hem en wat Hij zei gehoorzamen. Petrus gebruikt dit vers, dat de Joden goed kenden, en paste het rechtstreeks toe op Jezus om te benadrukken dat ze berouw moesten hebben over wat ze Hem hadden aangedaan (Handelingen 3:19-21).
Stefanus verkondigt Jezus, maar hij doet dat wel in een hele andere situatie dan die van Petrus. In Handelingen 7:37 verwijst ook hij terug naar die welbekende belofte. Hij legt het ook zo uit dat het op Jezus wijst. Hij legde uit dat Mozes een voorafschaduwing van Jezus was, door de rol die hij speelt in de geschiedenis en doordat Hij de leider was van de Joden. Net als Petrus probeerde Stefanus het volk er dus op te wijzen dat Jezus de profetie vervulde en dat ze naar Hem moesten luisteren. Stefanus werd ervan beschuldigd dat hij ‘Mozes en God lasterde’ (Handelingen 6:11). Hij verkondigde dat Jezus de Messias was en een rechtstreekse vervulling van wat God door Mozes had beloofd.
`Hoe maken deze teksten duidelijk dat Jezus het middelpunt is van de hele Bijbel? Waarom moeten we de Bijbel begrijpen op een manier die Christus centraal stelt?`
`Deuteronomium 18:15-19; Handelingen 3:22; 7:37 Hoe passen Petrus en Stefanus Deuteronomium 18:18 toe?` | 153.6875 | 915 | 0.791379 | nld_Latn | 1.000005 |
472eccd984b792bd52374772a5c89dc9482af352 | 52,401 | md | Markdown | articles/azure-monitor/app/api-custom-events-metrics.md | cmendible/azure-docs.es-es | c54d7a105f61abea6c67790e28944a7c6d636b9e | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/azure-monitor/app/api-custom-events-metrics.md | cmendible/azure-docs.es-es | c54d7a105f61abea6c67790e28944a7c6d636b9e | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/azure-monitor/app/api-custom-events-metrics.md | cmendible/azure-docs.es-es | c54d7a105f61abea6c67790e28944a7c6d636b9e | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: API de Application Insights para eventos y métricas personalizados | Microsoft Docs
description: Inserte unas cuantas líneas de código en su aplicación de dispositivo o de escritorio, página o servicio web, para realizar el seguimiento del uso y diagnosticar problemas.
services: application-insights
documentationcenter: ''
author: mrbullwinkle
manager: carmonm
ms.assetid: 80400495-c67b-4468-a92e-abf49793a54d
ms.service: application-insights
ms.workload: tbd
ms.tgt_pltfrm: ibiza
ms.topic: conceptual
ms.date: 03/27/2019
ms.author: mbullwin
ms.openlocfilehash: cdc16c2ea01d14edc236d0d6a0897e0dd9578924
ms.sourcegitcommit: d70c74e11fa95f70077620b4613bb35d9bf78484
ms.translationtype: HT
ms.contentlocale: es-ES
ms.lasthandoff: 09/11/2019
ms.locfileid: "70909812"
---
# <a name="application-insights-api-for-custom-events-and-metrics"></a>API de Application Insights para eventos y métricas personalizados
Inserte unas cuantas líneas de código en la aplicación para averiguar qué uso hacen de ella los usuarios o para ayudarle a diagnosticar problemas. Puede enviar datos de telemetría desde aplicaciones de escritorio y de dispositivo y desde clientes y servidores web. Use la API de telemetría principal de [Azure Application Insights](../../azure-monitor/app/app-insights-overview.md) para enviar métricas y eventos personalizados, así como sus propias versiones de telemetría estándar. Esta API es la misma que usan los recopiladores de datos estándar de Application Insights.
> [!NOTE]
> `TrackMetric()` ya no es el método preferido para enviar métricas personalizadas para sus aplicaciones .NET. En la [versión 2.60 beta 3](https://github.com/Microsoft/ApplicationInsights-dotnet/blob/develop/CHANGELOG.md#version-260-beta3) del SDK de Application Insights para .NET, se ha incorporado un nuevo método, [`TelemetryClient.GetMetric()`](https://docs.microsoft.com/dotnet/api/microsoft.applicationinsights.telemetryclient.getmetric?view=azure-dotnet). A partir de la [versión 2.72](https://docs.microsoft.com/dotnet/api/microsoft.applicationinsights.telemetryclient.getmetric?view=azure-dotnet) del SDK de Application Insights para .NET, esta funcionalidad forma parte de la versión estable.
## <a name="api-summary"></a>API summary
La API central es uniforme en todas las plataformas, excepto por algunas pequeñas variaciones como `GetMetric` (solo .NET).
| Método | Usado para |
| --- | --- |
| [`TrackPageView`](#page-views) |Páginas, pantallas, hojas o formularios. |
| [`TrackEvent`](#trackevent) |Acciones de usuario y otros eventos. Se usa para realizar el seguimiento del comportamiento de los usuarios o para supervisar el rendimiento. |
| [`GetMetric`](#getmetric) |Cero y métricas multidimensionales, agregación configurada de forma centralizada, solo en C#. |
| [`TrackMetric`](#trackmetric) |Las medidas de rendimiento, como las longitudes de cola, no están relacionadas con eventos específicos. |
| [`TrackException`](#trackexception) |Excepciones de registro para diagnóstico. Permite realizar el seguimiento del lugar donde se producen en relación con otros eventos y examinar los seguimientos de pila. |
| [`TrackRequest`](#trackrequest) |Registro de la frecuencia y duración de las solicitudes de servidor para el análisis de rendimiento. |
| [`TrackTrace`](#tracktrace) |Mensajes de registro de diagnóstico. También puede capturar registros de terceros. |
| [`TrackDependency`](#trackdependency) |Registro de la duración y frecuencia de las llamadas a componentes externos de los que depende la aplicación. |
Puede [adjuntar propiedades y métricas](#properties) a la mayoría de estas llamadas de telemetría.
## <a name="prep"></a>Antes de comenzar
Si aún no tiene una referencia en el SDK de Application Insights:
* Agregue el SDK de Application Insights a su proyecto:
* [Proyecto de ASP.NET](../../azure-monitor/app/asp-net.md)
* [Proyecto de ASP.NET Core](../../azure-monitor/app/asp-net-core.md)
* [Proyecto de Java](../../azure-monitor/app/java-get-started.md)
* [Proyecto de Node.js](../../azure-monitor/app/nodejs.md)
* [JavaScript en cada página web](../../azure-monitor/app/javascript.md)
* En el código de servidor web o de dispositivo, incluya:
*C#:* `using Microsoft.ApplicationInsights;`
*Visual Basic:* `Imports Microsoft.ApplicationInsights`
*Java:* `import com.microsoft.applicationinsights.TelemetryClient;`
*Node.js:* `var applicationInsights = require("applicationinsights");`
## <a name="get-a-telemetryclient-instance"></a>Obtención de una instancia de TelemetryClient
Obtenga una instancia de `TelemetryClient` (excepto en JavaScript en páginas web):
*C#*
```csharp
private TelemetryClient telemetry = new TelemetryClient();
```
*Visual Basic*
```vb
Private Dim telemetry As New TelemetryClient
```
*Java*
```java
private TelemetryClient telemetry = new TelemetryClient();
```
*Node.js*
```javascript
var telemetry = applicationInsights.defaultClient;
```
TelemetryClient es seguro para subprocesos.
Para proyectos ASP.NET y Java, las solicitudes HTTP entrantes se capturan automáticamente. Puede que quiera crear instancias adicionales de TelemetryClient para otro módulo de la aplicación. Por ejemplo, puede tener una instancia de TelemetryClient en la clase de middleware para notificar eventos de la lógica de negocios. Puede establecer propiedades como UserId y DeviceId para identificar la máquina. Esta información se adjunta a todos los eventos enviados por la instancia.
*C#*
```csharp
TelemetryClient.Context.User.Id = "...";
TelemetryClient.Context.Device.Id = "...";
```
*Java*
```java
telemetry.getContext().getUser().setId("...");
telemetry.getContext().getDevice().setId("...");
```
En proyectos de Node.js, puede usar `new applicationInsights.TelemetryClient(instrumentationKey?)` para crear una nueva instancia, pero esto solo se recomienda para escenarios que requieren configuración aislada del singleton `defaultClient`.
## <a name="trackevent"></a>TrackEvent
En Application Insights, un *evento personalizado* es un punto de datos que se puede mostrar en el [Explorador de métricas](../../azure-monitor/app/metrics-explorer.md) como recuento agregado, y como repeticiones individuales en [Búsqueda de diagnóstico](../../azure-monitor/app/diagnostic-search.md). (No está relacionado con MVC ni con "eventos" de otro marco).
Inserte llamadas a `TrackEvent` en el código para contabilizar diversos eventos: la frecuencia con la que los usuarios eligen una determinada característica, con la que logran unos determinados objetivos o con la que cometen determinados tipos de errores.
Por ejemplo, en una aplicación de juego, envíe un evento cada vez que un usuario gane el juego:
*JavaScript*
```javascript
appInsights.trackEvent("WinGame");
```
*C#*
```csharp
telemetry.TrackEvent("WinGame");
```
*Visual Basic*
```vb
telemetry.TrackEvent("WinGame")
```
*Java*
```java
telemetry.trackEvent("WinGame");
```
*Node.js*
```javascript
telemetry.trackEvent({name: "WinGame"});
```
### <a name="custom-events-in-analytics"></a>Eventos personalizados en Analytics
La telemetría está disponible en la tabla `customEvents` de [Analytics de Application Insights](analytics.md). Cada fila representa una llamada a `trackEvent(..)` en la aplicación.
Si el [muestreo](../../azure-monitor/app/sampling.md) está en uso, en la propiedad itemCount se muestra un valor mayor que 1. Por ejemplo, itemCount==10 significa que de cada 10 llamadas a trackEvent(), el proceso de muestreo solo transmite una. Para obtener un recuento correcto de eventos personalizados, debería usar código como `customEvents | summarize sum(itemCount)`.
## <a name="getmetric"></a>GetMetric
### <a name="examples"></a>Ejemplos
*C#*
```csharp
namespace User.Namespace.Example01
{
using System;
using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.DataContracts;
/// <summary>
/// Most simple cases are one-liners.
/// This is all possible without even importing an additional namespace.
/// </summary>
public class Sample01
{
/// <summary />
public static void Exec()
{
// *** SENDING METRICS ***
// Recall how you send custom telemetry with Application Insights in other cases, e.g. Events.
// The following will result in an EventTelemetry object to be sent to the cloud right away.
TelemetryClient client = new TelemetryClient();
client.TrackEvent("SomethingInterestingHappened");
// Metrics work very similar. However, the value is not sent right away.
// It is aggregated with other values for the same metric, and the resulting summary (aka "aggregate" is sent automatically every minute.
// To mark this difference, we use a pattern that is similar, but different from the established TrackXxx(..) pattern that sends telemetry right away:
client.GetMetric("CowsSold").TrackValue(42);
// *** MULTI-DIMENSIONAL METRICS ***
// The above example shows a zero-dimensional metric.
// Metrics can also be multi-dimensional.
// In the initial version we are supporting up to 2 dimensions, and we will add support for more in the future as needed.
// Here is an example for a one-dimensional metric:
Metric animalsSold = client.GetMetric("AnimalsSold", "Species");
animalsSold.TrackValue(42, "Pigs");
animalsSold.TrackValue(24, "Horses");
// The values for Pigs and Horses will be aggregated separately from each other and will result in two distinct aggregates.
// You can control the maximum number of number data series per metric (and thus your resource usage and cost).
// The default limits are no more than 1000 total data series per metric, and no more than 100 different values per dimension.
// We discuss elsewhere how to change them.
// We use a common .NET pattern: TryXxx(..) to make sure that the limits are observed.
// If the limits are already reached, Metric.TrackValue(..) will return False and the value will not be tracked. Otherwise it will return True.
// This is particularly useful if the data for a metric originates from user input, e.g. a file:
Tuple<int, string> countAndSpecies = ReadSpeciesFromUserInput();
int count = countAndSpecies.Item1;
string species = countAndSpecies.Item2;
if (!animalsSold.TrackValue(count, species))
{
client.TrackTrace($"Data series or dimension cap was reached for metric {animalsSold.Identifier.MetricId}.", SeverityLevel.Error);
}
// You can inspect a metric object to reason about its current state. For example:
int currentNumberOfSpecies = animalsSold.GetDimensionValues(1).Count;
}
private static void ResetDataStructure()
{
// Do stuff
}
private static Tuple<int, string> ReadSpeciesFromUserInput()
{
return Tuple.Create(18, "Cows");
}
private static int AddItemsToDataStructure()
{
// Do stuff
return 5;
}
}
}
```
## <a name="trackmetric"></a>TrackMetric
> [!NOTE]
> Microsoft.ApplicationInsights.TelemetryClient.TrackMetric no es el método preferido para el envío de métricas. Las métricas deben agregarse previamente siempre durante un tiempo antes de enviarse. Use una de las sobrecargas GetMetric(..) para obtener un objeto de métrica para acceder a funcionalidades de agregación previa del SDK. Si va a implementar su propia lógica de agregación previa, puede usar el método TrackMetric() para enviar los agregados resultantes. Si su aplicación requiere el envío de un elemento de telemetría independiente en cada ocasión sin agregación a lo largo del tiempo, es probable que en su caso haya que usar la telemetría de eventos; consulte TelemetryClient.TrackEvent (Microsoft.ApplicationInsights.DataContracts.EventTelemetry).
Application Insights puede crear gráficos de métricas que no estén conectadas a eventos concretos. Por ejemplo, puede supervisar una longitud de cola a intervalos regulares. En el caso de las métricas, las mediciones individuales tienen menos interés que las variaciones y tendencias; por tanto, los gráficos estadísticos resultan útiles.
Para enviar las métricas a Application Insights, puede usar la API `TrackMetric(..)`. Hay dos formas de enviar una métrica:
* Valor único. Cada vez que realiza una medición en la aplicación, envía el valor correspondiente a Application Insights. Por ejemplo, suponga que cuenta con una métrica que describe el número de elementos de un contenedor. Durante un período determinado, primero coloca tres elementos en el contenedor y seguidamente retira dos. En consecuencia, llamaría a `TrackMetric` dos veces: la primera, para pasar el valor `3` y a continuación el valor `-2`. Application Insights almacena ambos valores en su nombre.
* Agregación. Al trabajar con métricas, las mediciones individuales pocas veces resultan de interés. En su lugar, lo importante son los resúmenes de acontecimientos durante un período determinado. Los resúmenes de este tipo se denominan _agregaciones_. En el ejemplo anterior, la suma de las métricas agregadas del período correspondiente es de `1` y el recuento de los valores de las métricas es de `2`. Al usar el método de agregación, solo invocará `TrackMetric` una vez por período y enviará los valores agregados. Este es el método que se recomienda usar, ya que puede reducir significativamente los costos y la sobrecarga de rendimiento gracias a que envía menos puntos de datos a Application Insights, a pesar de seguir recopilado toda la información pertinente.
### <a name="examples"></a>Ejemplos
#### <a name="single-values"></a>Valores únicos
Para enviar un único valor de métrica:
*JavaScript*
```javascript
appInsights.trackMetric("queueLength", 42.0);
```
*C#*
```csharp
var sample = new MetricTelemetry();
sample.Name = "metric name";
sample.Value = 42.3;
telemetryClient.TrackMetric(sample);
```
*Java*
```java
telemetry.trackMetric("queueLength", 42.0);
```
*Node.js*
```javascript
telemetry.trackMetric({name: "queueLength", value: 42.0});
```
### <a name="custom-metrics-in-analytics"></a>Métricas personalizadas en Analytics
La telemetría está disponible en la tabla `customMetrics` de [Analytics de Application Insights](analytics.md). Cada fila representa una llamada a `trackMetric(..)` en la aplicación.
* `valueSum`: es la suma de las medidas. Para obtener el valor medio, divídalo por `valueCount`.
* `valueCount`: el número de medidas que se agregaron en esta llamada a `trackMetric(..)`.
## <a name="page-views"></a>Vistas de página
En una aplicación de dispositivo o de página web, se envían datos de telemetría de la vista de página de forma predeterminada cuando se carga cada pantalla o página. Sin embargo, puede cambiar esta frecuencia para que se realice el seguimiento de las vistas de página en momentos diferentes o adicionales. Por ejemplo, en una aplicación que muestra pestañas u hojas, quizás quiera realizar el seguimiento de una página siempre que el usuario abra una nueva hoja.
Los datos de usuario y de sesión se envían como propiedades junto con las vistas de página, por lo que los gráficos de usuario y de sesión se activan cuando hay datos de telemetría de vistas de página.
### <a name="custom-page-views"></a>Vistas de página personalizadas
*JavaScript*
```javascript
appInsights.trackPageView("tab1");
```
*C#*
```csharp
telemetry.TrackPageView("GameReviewPage");
```
*Visual Basic*
```vb
telemetry.TrackPageView("GameReviewPage")
```
*Java*
```java
telemetry.trackPageView("GameReviewPage");
```
Si tiene varias fichas dentro de páginas HTML diferentes, puede especificar también la dirección URL:
```javascript
appInsights.trackPageView("tab1", "http://fabrikam.com/page1.htm");
```
### <a name="timing-page-views"></a>Cronometrar las vistas de página
De forma predeterminada, los tiempos notificados como **Tiempo de carga de la vista de página** se miden desde que el explorador envía la solicitud hasta que se llama al evento de carga de página del explorador.
En su lugar, puede:
* Establecer una duración explícita en la llamada [trackPageView](https://github.com/Microsoft/ApplicationInsights-JS/blob/master/API-reference.md#trackpageview): `appInsights.trackPageView("tab1", null, null, null, durationInMilliseconds);`.
* Usar las llamadas para cronometrar la vista de página `startTrackPage` y `stopTrackPage`.
*JavaScript*
```javascript
// To start timing a page:
appInsights.startTrackPage("Page1");
...
// To stop timing and log the page:
appInsights.stopTrackPage("Page1", url, properties, measurements);
```
El nombre que use como primer parámetro asocia las llamadas inicial y final. El valor predeterminado es el nombre de la página actual.
Las duraciones de carga de página resultantes que se muestran en el Explorador de métricas se derivan del intervalo que media entre las llamadas inicial y final. Depende del usuario qué intervalo se cronometra realmente.
### <a name="page-telemetry-in-analytics"></a>Telemetría de páginas en Analytics
En [Analytics](analytics.md) hay dos tablas en las que se muestran datos de operaciones de explorador:
* La tabla `pageViews` contiene datos sobre la URL y el título de la página.
* La tabla `browserTimings` contiene datos sobre el rendimiento del cliente, como el tiempo que se tarda en procesar los datos entrantes.
Para averiguar cuánto tarda el explorador en procesar diferentes páginas:
```kusto
browserTimings
| summarize avg(networkDuration), avg(processingDuration), avg(totalDuration) by name
```
Para descubrir la popularidad de distintos exploradores:
```kusto
pageViews
| summarize count() by client_Browser
```
Para asociar las vistas de página a las llamadas AJAX, realice una combinación con dependencias:
```kusto
pageViews
| join (dependencies) on operation_Id
```
## <a name="trackrequest"></a>TrackRequest
El SDK del servidor usa TrackRequest para registrar las solicitudes de HTTP.
También puede llamarlo usted mismo si quiere simular solicitudes en un contexto en el que no se está ejecutando el módulo de servicio web.
Sin embargo, lo que se recomienda para enviar telemetría de solicitudes es que la solicitud actúe como <a href="#operation-context">contexto de operación</a>.
## <a name="operation-context"></a>Contexto de operación
Puede correlacionar los elementos de telemetría juntos mediante su asociación con el contexto de la operación. El módulo de seguimiento de solicitud estándar realiza esta operación para excepciones y otros eventos enviados al procesar una solicitud HTTP. En [Búsqueda](../../azure-monitor/app/diagnostic-search.md) y [Análisis](analytics.md), puede encontrar fácilmente cualquier evento asociado a la solicitud mediante su identificador de operación.
Para más información sobre la correlación, vea [Correlación de telemetría en Application Insights](../../azure-monitor/app/correlation.md).
Al realizar el seguimiento de la telemetría manualmente, la forma más fácil de garantizar la correlación de telemetría es mediante el uso de este patrón:
*C#*
```csharp
// Establish an operation context and associated telemetry item:
using (var operation = telemetryClient.StartOperation<RequestTelemetry>("operationName"))
{
// Telemetry sent in here will use the same operation ID.
...
telemetryClient.TrackTrace(...); // or other Track* calls
...
// Set properties of containing telemetry item--for example:
operation.Telemetry.ResponseCode = "200";
// Optional: explicitly send telemetry item:
telemetryClient.StopOperation(operation);
} // When operation is disposed, telemetry item is sent.
```
Junto con la configuración de un contexto de la operación, `StartOperation` crea un elemento de telemetría del tipo que especifique. Envía el elemento de telemetría al eliminar la operación, o si llama explícitamente a `StopOperation`. Si usa `RequestTelemetry` como tipo de telemetría, su duración se establece en el intervalo cronometrado entre el inicio y la detención.
Los elementos de telemetría notificados dentro de un ámbito de operación se convierten en "elementos secundarios" de dicha operación. Los contextos de operación pueden estar anidados.
En la Búsqueda, el contexto de la operación se utiliza para crear la lista de **Elementos relacionados**:
Consulte [Seguimiento de las operaciones personalizadas con el SDK de .NET para Application Insights](../../azure-monitor/app/custom-operations-tracking.md) para más información sobre el seguimiento de las operaciones personalizadas.
### <a name="requests-in-analytics"></a>Solicitudes en Analytics
En [Analytics de Application Insights](analytics.md), las solicitudes aparecen en la tabla `requests`.
Si el [muestreo](../../azure-monitor/app/sampling.md) está en uso, en la propiedad de itemCount se mostrará un valor superior a 1. Por ejemplo, itemCount==10 significa que de cada 10 llamadas a trackRequest(), el proceso de muestreo solo transmite una. Para obtener un recuento correcto de solicitudes y la duración media segmentada por nombres de solicitudes, use código como el siguiente:
```kusto
requests
| summarize count = sum(itemCount), avgduration = avg(duration) by name
```
## <a name="trackexception"></a>TrackException
Enviar excepciones a Application Insights:
* Para [contarlas](../../azure-monitor/app/metrics-explorer.md), como indicación de la frecuencia de un problema.
* Para [examinar los casos individuales](../../azure-monitor/app/diagnostic-search.md).
Los informes incluyen los seguimientos de la pila.
*C#*
```csharp
try
{
...
}
catch (Exception ex)
{
telemetry.TrackException(ex);
}
```
*Java*
```java
try {
...
} catch (Exception ex) {
telemetry.trackException(ex);
}
```
*JavaScript*
```javascript
try
{
...
}
catch (ex)
{
appInsights.trackException(ex);
}
```
*Node.js*
```javascript
try
{
...
}
catch (ex)
{
telemetry.trackException({exception: ex});
}
```
Los SDK capturan muchas excepciones automáticamente, por lo que no siempre es necesario llamar explícitamente a TrackException.
* ASP.NET: [escritura de código para detectar excepciones](../../azure-monitor/app/asp-net-exceptions.md).
* Java EE: [las excepciones se detectan automáticamente](../../azure-monitor/app/java-get-started.md#exceptions-and-request-failures).
* JavaScript: las excepciones se detectan automáticamente. Si desea deshabilitar la colección automática, agregue una línea al fragmento de código que se inserta en las páginas web:
```javascript
({
instrumentationKey: "your key",
disableExceptionTracking: true
})
```
### <a name="exceptions-in-analytics"></a>Excepciones en Analytics
En [Analytics de Application Insights](analytics.md), las excepciones aparecen en la tabla `exceptions`.
Si el [muestreo](../../azure-monitor/app/sampling.md) está en uso, en la propiedad `itemCount` se muestra un valor mayor que 1. Por ejemplo, itemCount==10 significa que de cada 10 llamadas a trackException(), el proceso de muestreo solo transmite una. Para obtener un recuento correcto de excepciones segmentadas por tipo de excepción, use código como el siguiente:
```kusto
exceptions
| summarize sum(itemCount) by type
```
La mayor parte de la información importante sobre pilas ya se extrajo en variables independientes, pero puede desmontar la estructura `details` para obtener más. Puesto que se trata de una estructura dinámica, debería convertir el resultado al tipo que espere. Por ejemplo:
```kusto
exceptions
| extend method2 = tostring(details[0].parsedStack[1].method)
```
Para asociar las excepciones a sus respectivas solicitudes, use una combinación:
```kusto
exceptions
| join (requests) on operation_Id
```
## <a name="tracktrace"></a>TrackTrace
Use TrackTrace para ayudar a diagnosticar problemas mediante el envío de una ''ruta de exploración'' a Application Insights. Puede enviar fragmentos de datos de diagnóstico e inspeccionarlos en [Búsqueda de diagnóstico](../../azure-monitor/app/diagnostic-search.md).
Los [adaptadores de registro](../../azure-monitor/app/asp-net-trace-logs.md) de .NET usan esta API para enviar registros de terceros al portal.
En Java, para [registradores estándar como Log4J o Logback](../../azure-monitor/app/java-trace-logs.md), utilice los appenders de Log4j o Logback de Application Insights para enviar registros de terceros al portal.
*C#*
```csharp
telemetry.TrackTrace(message, SeverityLevel.Warning, properties);
```
*Java*
```java
telemetry.trackTrace(message, SeverityLevel.Warning, properties);
```
*Node.js*
```javascript
telemetry.trackTrace({
message: message,
severity: applicationInsights.Contracts.SeverityLevel.Warning,
properties: properties
});
```
*JavaScript del lado cliente/explorador*
```javascript
trackTrace(message: string, properties?: {[string]:string}, severityLevel?: AI.SeverityLevel)
```
Registre un evento de diagnóstico, como la entrada o la salida de un método.
Parámetro | DESCRIPCIÓN
---|---
`message` | Datos de diagnóstico. Puede ser mucho más largo que un nombre.
`properties` | Asignación de cadena a cadena: Datos adicionales que se usan para [filtrar excepciones](https://azure.microsoft.com/documentation/articles/app-insights-api-custom-events-metrics/#properties) en el portal. El valor predeterminado es vacío.
`severityLevel` | Valores admitidos: [SeverityLevel.ts](https://github.com/microsoft/ApplicationInsights-JS/blob/17ef50442f73fd02a758fbd74134933d92607ecf/shared/AppInsightsCommon/src/Interfaces/Contracts/Generated/SeverityLevel.ts)
Puede buscar en el contenido del mensaje, pero (a diferencia de los valores de propiedad) no puede filtrar por él.
El límite de tamaño en `message` es mucho mayor que el límite en propiedades.
Una ventaja de TrackTrace es que puede colocar datos relativamente largos en el mensaje. Por ejemplo, aquí puede codificar datos POST.
Además, puede agregar un nivel de gravedad al mensaje. Y, al igual que con otra telemetría, puede agregar valores de propiedad para ayudar a filtrar o buscar distintos conjuntos de seguimientos. Por ejemplo:
*C#*
```csharp
var telemetry = new Microsoft.ApplicationInsights.TelemetryClient();
telemetry.TrackTrace("Slow database response",
SeverityLevel.Warning,
new Dictionary<string,string> { {"database", db.ID} });
```
*Java*
```java
Map<String, Integer> properties = new HashMap<>();
properties.put("Database", db.ID);
telemetry.trackTrace("Slow Database response", SeverityLevel.Warning, properties);
```
En [Búsqueda](../../azure-monitor/app/diagnostic-search.md), puede filtrar fácilmente todos los mensajes de un determinado nivel de gravedad relativos a una determinada base de datos.
### <a name="traces-in-analytics"></a>Seguimientos en Analytics
En [Analytics de Application Insights](analytics.md), las llamadas a TrackTrace aparecen en la tabla `traces`.
Si el [muestreo](../../azure-monitor/app/sampling.md) está en uso, en la propiedad itemCount se muestra un valor mayor que 1. Por ejemplo, itemCount==10 significa que de cada 10 llamadas a `trackTrace()`, el proceso de muestreo solo transmite una. Para obtener un recuento correcto de llamadas de seguimiento, debería codificar por tanto como `traces | summarize sum(itemCount)`.
## <a name="trackdependency"></a>TrackDependency
Utilice la llamada de TrackDependency para realizar un seguimiento de los tiempos de respuesta y las tasas de éxito de las llamadas a un fragmento de código externo. Los resultados se muestran en los gráficos de dependencia del portal.
*C#*
```csharp
var success = false;
var startTime = DateTime.UtcNow;
var timer = System.Diagnostics.Stopwatch.StartNew();
try
{
success = dependency.Call();
}
catch(Exception ex)
{
success = false;
telemetry.TrackException(ex);
throw new Exception("Operation went wrong", ex);
}
finally
{
timer.Stop();
telemetry.TrackDependency("DependencyType", "myDependency", "myCall", startTime, timer.Elapsed, success);
}
```
*Java*
```java
boolean success = false;
long startTime = System.currentTimeMillis();
try {
success = dependency.call();
}
finally {
long endTime = System.currentTimeMillis();
long delta = endTime - startTime;
RemoteDependencyTelemetry dependencyTelemetry = new RemoteDependencyTelemetry("My Dependency", "myCall", delta, success);
telemetry.setTimeStamp(startTime);
telemetry.trackDependency(dependencyTelemetry);
}
```
*JavaScript*
```javascript
var success = false;
var startTime = new Date().getTime();
try
{
success = dependency.Call();
}
finally
{
var elapsed = new Date() - startTime;
telemetry.trackDependency({
dependencyTypeName: "myDependency",
name: "myCall",
duration: elapsed,
success: success
});
}
```
Recuerde que los SDK del servidor incluyen un [módulo de dependencia](../../azure-monitor/app/asp-net-dependencies.md) que detecta y realiza automáticamente el seguimiento de ciertas llamadas de dependencia; por ejemplo, a bases de datos y API de REST. Debe instalar un agente en el servidor para que el módulo funcione.
En Java, es posible realizar el seguimiento de ciertas llamadas de dependencia automáticamente mediante el [agente de Java](../../azure-monitor/app/java-agent.md).
Utilizará esta llamada si desea hacer un seguimiento de las llamadas no captadas por el seguimiento automatizado, o bien si no desea instalar el agente.
Para desactivar el módulo de seguimiento de dependencias estándar en C#, edite [ApplicationInsights.config](../../azure-monitor/app/configuration-with-applicationinsights-config.md) y elimine la referencia a `DependencyCollector.DependencyTrackingTelemetryModule`. En Java, no instale al agente de Java si no quiere recopilar dependencias estándar automáticamente.
### <a name="dependencies-in-analytics"></a>Dependencias en Analytics
En [Analytics de Application Insights](analytics.md), las llamadas de trackDependency aparecen en la tabla `dependencies`.
Si el [muestreo](../../azure-monitor/app/sampling.md) está en uso, en la propiedad itemCount se muestra un valor mayor que 1. Por ejemplo, itemCount==10 significa que de cada 10 llamadas a trackDependency(), el proceso de muestreo solo transmite una. Para obtener un recuento correcto de dependencias segmentadas por componente de destino, use código como el siguiente:
```kusto
dependencies
| summarize sum(itemCount) by target
```
Para asociar las dependencias a sus respectivas solicitudes, use una combinación:
```kusto
dependencies
| join (requests) on operation_Id
```
## <a name="flushing-data"></a>Datos de vaciado
Normalmente, el SDK envía datos a intervalos fijos (normalmente 30 segundos) o cuando el búfer está lleno (normalmente 500 elementos). Sin embargo, en algunos casos puede que desee vaciar el búfer: por ejemplo, si usa el SDK en una aplicación que se apaga.
*C#*
```csharp
telemetry.Flush();
// Allow some time for flushing before shutdown.
System.Threading.Thread.Sleep(5000);
```
*Java*
```java
telemetry.flush();
//Allow some time for flushing before shutting down
Thread.sleep(5000);
```
*Node.js*
```javascript
telemetry.flush();
```
La función es asincrónica para el [canal de telemetría del servidor](https://www.nuget.org/packages/Microsoft.ApplicationInsights.WindowsServer.TelemetryChannel/).
Lo ideal es que se utilice el método flush() en la actividad de cierre de la aplicación.
## <a name="authenticated-users"></a>Usuarios autenticados
En una aplicación web, los usuarios se identifican por cookies (de manera predeterminada). Se puede contar al usuario más de una vez si accede a la aplicación desde un equipo o explorador diferente, o si elimina las cookies.
Si los usuarios inician sesión en su aplicación, puede obtener un recuento más preciso estableciendo el identificador del usuario autenticado en el código del explorador:
*JavaScript*
```javascript
// Called when my app has identified the user.
function Authenticated(signInId) {
var validatedId = signInId.replace(/[,;=| ]+/g, "_");
appInsights.setAuthenticatedUserContext(validatedId);
...
}
```
En una aplicación MVC web de ASP.NET, por ejemplo:
*Razor*
```cshtml
@if (Request.IsAuthenticated)
{
<script>
appInsights.setAuthenticatedUserContext("@User.Identity.Name
.Replace("\\", "\\\\")"
.replace(/[,;=| ]+/g, "_"));
</script>
}
```
No es necesario usar el nombre de inicio de sesión real del usuario. Solo tiene que ser un identificador único para ese usuario. No debe incluir espacios ni ninguno de los caracteres `,;=|`.
El identificador de usuario también se establece en una cookie de sesión y se envía al servidor. Si está instalado el SDK del servidor, el identificador de usuario autenticado se envía como parte de las propiedades de contexto tanto de la telemetría del cliente como del servidor. A continuación, puede filtrar y buscar en ella.
Si su aplicación agrupa a los usuarios en cuentas, también puede pasar un identificador de la cuenta (con las mismas restricciones de caracteres).
```javascript
appInsights.setAuthenticatedUserContext(validatedId, accountId);
```
En el [Explorador de métricas](../../azure-monitor/app/metrics-explorer.md), puede crear un gráfico que cuente los **Usuarios autenticados** y las **Cuentas de usuario**.
También puede [buscar](../../azure-monitor/app/diagnostic-search.md) puntos de datos de cliente con cuentas y nombres de usuario específicos.
## <a name="properties"></a>Filtrado, búsqueda y segmentación de los datos mediante el uso de propiedades
Puede asociar propiedades y medidas a los eventos (y también a las métricas, vistas de página, excepciones y otros datos de telemetría).
*propiedades* son valores de cadena que se pueden usar para filtrar los datos de telemetría en los informes de uso. Por ejemplo, si su aplicación proporciona varios juegos, puede adjuntar el nombre del juego a cada evento para así poder ver cuáles son los juegos más populares.
Hay un límite de aproximadamente 8192 en la longitud de cadena. (Si quiere enviar fragmentos grandes de datos, use el parámetro de mensaje de TrackTrace).
*métricas* son valores numéricos que se pueden presentar de forma gráfica. Por ejemplo, puede que quiera ver si hay un aumento gradual en las puntuaciones que alcanzan sus jugadores. Los gráficos se pueden segmentar por las propiedades enviadas con el evento, así que puede separar o apilar los gráficos para diferentes juegos.
Para que valores de métricas se muestren correctamente, deben ser mayores o iguales que 0.
Hay algunos [límites en el número de propiedades, valores de propiedad y métricas](#limits) que puede usar.
*JavaScript*
```javascript
appInsights.trackEvent
("WinGame",
// String properties:
{Game: currentGame.name, Difficulty: currentGame.difficulty},
// Numeric metrics:
{Score: currentGame.score, Opponents: currentGame.opponentCount}
);
appInsights.trackPageView
("page name", "http://fabrikam.com/pageurl.html",
// String properties:
{Game: currentGame.name, Difficulty: currentGame.difficulty},
// Numeric metrics:
{Score: currentGame.score, Opponents: currentGame.opponentCount}
);
```
*C#*
```csharp
// Set up some properties and metrics:
var properties = new Dictionary <string, string>
{{"game", currentGame.Name}, {"difficulty", currentGame.Difficulty}};
var metrics = new Dictionary <string, double>
{{"Score", currentGame.Score}, {"Opponents", currentGame.OpponentCount}};
// Send the event:
telemetry.TrackEvent("WinGame", properties, metrics);
```
*Node.js*
```javascript
// Set up some properties and metrics:
var properties = {"game": currentGame.Name, "difficulty": currentGame.Difficulty};
var metrics = {"Score": currentGame.Score, "Opponents": currentGame.OpponentCount};
// Send the event:
telemetry.trackEvent({name: "WinGame", properties: properties, measurements: metrics});
```
*Visual Basic*
```vb
' Set up some properties:
Dim properties = New Dictionary (Of String, String)
properties.Add("game", currentGame.Name)
properties.Add("difficulty", currentGame.Difficulty)
Dim metrics = New Dictionary (Of String, Double)
metrics.Add("Score", currentGame.Score)
metrics.Add("Opponents", currentGame.OpponentCount)
' Send the event:
telemetry.TrackEvent("WinGame", properties, metrics)
```
*Java*
```java
Map<String, String> properties = new HashMap<String, String>();
properties.put("game", currentGame.getName());
properties.put("difficulty", currentGame.getDifficulty());
Map<String, Double> metrics = new HashMap<String, Double>();
metrics.put("Score", currentGame.getScore());
metrics.put("Opponents", currentGame.getOpponentCount());
telemetry.trackEvent("WinGame", properties, metrics);
```
> [!NOTE]
> Tenga cuidado de no registrar información de identificación personal en las propiedades.
>
>
### <a name="alternative-way-to-set-properties-and-metrics"></a>Método alternativo para establecer propiedades y métricas
Si le resulta más cómodo, puede recopilar los parámetros de un evento en un objeto independiente:
```csharp
var event = new EventTelemetry();
event.Name = "WinGame";
event.Metrics["processingTime"] = stopwatch.Elapsed.TotalMilliseconds;
event.Properties["game"] = currentGame.Name;
event.Properties["difficulty"] = currentGame.Difficulty;
event.Metrics["Score"] = currentGame.Score;
event.Metrics["Opponents"] = currentGame.Opponents.Length;
telemetry.TrackEvent(event);
```
> [!WARNING]
> No vuelva a usar la misma instancia de elemento de telemetría (`event` en este ejemplo) para llamar a Track*() varias veces. Esto puede hacer que se envíe la telemetría con una configuración incorrecta.
>
>
### <a name="custom-measurements-and-properties-in-analytics"></a>Mediciones y propiedades personalizadas en Analytics
En [Analytics](analytics.md), las métricas y propiedades personalizadas aparecen en los atributos `customMeasurements` y `customDimensions` de cada registro de telemetría.
Por ejemplo, si agregó una propiedad llamada "game" a la telemetría de solicitudes, esta consulta cuenta el número de apariciones de diferentes valores de "game" y muestra la media de la métrica personalizada "score":
```kusto
requests
| summarize sum(itemCount), avg(todouble(customMeasurements.score)) by tostring(customDimensions.game)
```
Tenga en lo siguiente:
* Al extraer un valor de los elementos de JSON customDimensions o customMeasurements, es de tipo dinámico, por lo que debe convertirlo a `tostring` o `todouble`.
* Para tener en cuenta la posibilidad de [muestreo](../../azure-monitor/app/sampling.md), debería usar `sum(itemCount)`, no `count()`.
## <a name="timed"></a> Eventos de temporización
Seguro que en ocasiones le gustaría representar el tiempo que se tarda en realizar alguna acción. Por ejemplo, puede que quiera saber cuánto tiempo tardan los usuarios en considerar las opciones de un juego. Puede usar el parámetro de medida para ello.
*C#*
```csharp
var stopwatch = System.Diagnostics.Stopwatch.StartNew();
// ... perform the timed action ...
stopwatch.Stop();
var metrics = new Dictionary <string, double>
{{"processingTime", stopwatch.Elapsed.TotalMilliseconds}};
// Set up some properties:
var properties = new Dictionary <string, string>
{{"signalSource", currentSignalSource.Name}};
// Send the event:
telemetry.TrackEvent("SignalProcessed", properties, metrics);
```
*Java*
```java
long startTime = System.currentTimeMillis();
// Perform timed action
long endTime = System.currentTimeMillis();
Map<String, Double> metrics = new HashMap<>();
metrics.put("ProcessingTime", (double)endTime-startTime);
// Setup some properties
Map<String, String> properties = new HashMap<>();
properties.put("signalSource", currentSignalSource.getName());
// Send the event
telemetry.trackEvent("SignalProcessed", properties, metrics);
```
## <a name="defaults"></a>Propiedades predeterminadas para la telemetría personalizada
Si quiere establecer valores de propiedad predeterminados para algunos de los eventos personalizados que escriba, puede hacerlo en una instancia de TelemetryClient. Se adjuntarán a cada elemento de telemetría enviado desde ese cliente.
*C#*
```csharp
using Microsoft.ApplicationInsights.DataContracts;
var gameTelemetry = new TelemetryClient();
gameTelemetry.Context.Properties["Game"] = currentGame.Name;
// Now all telemetry will automatically be sent with the context property:
gameTelemetry.TrackEvent("WinGame");
```
*Visual Basic*
```vb
Dim gameTelemetry = New TelemetryClient()
gameTelemetry.Context.Properties("Game") = currentGame.Name
' Now all telemetry will automatically be sent with the context property:
gameTelemetry.TrackEvent("WinGame")
```
*Java*
```java
import com.microsoft.applicationinsights.TelemetryClient;
import com.microsoft.applicationinsights.TelemetryContext;
...
TelemetryClient gameTelemetry = new TelemetryClient();
TelemetryContext context = gameTelemetry.getContext();
context.getProperties().put("Game", currentGame.Name);
gameTelemetry.TrackEvent("WinGame");
```
*Node.js*
```javascript
var gameTelemetry = new applicationInsights.TelemetryClient();
gameTelemetry.commonProperties["Game"] = currentGame.Name;
gameTelemetry.TrackEvent({name: "WinGame"});
```
Las llamadas de telemetría individuales pueden invalidar los valores predeterminados en los diccionarios de propiedad.
*Para los clientes web de JavaScript*, use los inicializadores de telemetría de JavaScript.
*Para agregar propiedades a toda la telemetría*, incluidos los datos de los módulos de recopilación estándar, [implemente `ITelemetryInitializer`](../../azure-monitor/app/api-filtering-sampling.md#add-properties).
## <a name="sampling-filtering-and-processing-telemetry"></a>Muestreo, filtrado y procesamiento de telemetría
Puede escribir código para procesar la telemetría antes de que se envíe desde el SDK. El procesamiento incluye los datos enviados desde los módulos de telemetría estándar, como la recopilación de solicitudes HTTP y de dependencias.
[Agregue propiedades](../../azure-monitor/app/api-filtering-sampling.md#add-properties) a la telemetría mediante la implementación de `ITelemetryInitializer`. Por ejemplo, puede agregar números de versión o valores calculados a partir de otras propiedades.
El [filtrado](../../azure-monitor/app/api-filtering-sampling.md#filtering) puede modificar o descartar la telemetría antes de que se envíe desde el SDK, mediante la implementación de `ITelemetryProcessor`. Puede controlar qué se envía y qué se descarta, pero debe tener en cuenta el efecto en las métricas. Según la forma en que se descarten los elementos, podría perder la capacidad de navegar entre elementos relacionados.
El [muestreo](../../azure-monitor/app/api-filtering-sampling.md) es una solución empaquetada para reducir el volumen de datos enviado desde la aplicación al portal. Lo hace sin que las métricas mostradas resulten afectadas. Y sin repercutir tampoco sobre capacidad para diagnosticar problemas navegando entre elementos relacionados, como excepciones, solicitudes y vistas de página.
[Más información](../../azure-monitor/app/api-filtering-sampling.md).
## <a name="disabling-telemetry"></a>Deshabilitación de la telemetría
Para *iniciar y detener dinámicamente* la recopilación y la transmisión de telemetría:
*C#*
```csharp
using Microsoft.ApplicationInsights.Extensibility;
TelemetryConfiguration.Active.DisableTelemetry = true;
```
*Java*
```java
telemetry.getConfiguration().setTrackingDisabled(true);
```
Para *deshabilitar los recopiladores estándar seleccionados* (por ejemplo, contadores de rendimiento, solicitudes HTTP o dependencias), elimine o convierta en comentarios las líneas correspondientes en [ApplicationInsights.config](../../azure-monitor/app/configuration-with-applicationinsights-config.md). Puede hacer esto, por ejemplo, si quiere enviar sus propios datos de TrackRequest.
*Node.js*
```javascript
telemetry.config.disableAppInsights = true;
```
Para *deshabilitar los recopiladores estándar seleccionados* (por ejemplo, los contadores de rendimiento, las solicitudes HTTP o las dependencias) en el tiempo de inicialización, encadene métodos de configuración a su código de inicialización de SDK:
```javascript
applicationInsights.setup()
.setAutoCollectRequests(false)
.setAutoCollectPerformance(false)
.setAutoCollectExceptions(false)
.setAutoCollectDependencies(false)
.setAutoCollectConsole(false)
.start();
```
Para deshabilitar estos recopiladores después de la inicialización, utilice el objeto de configuración: `applicationInsights.Configuration.setAutoCollectRequests(false)`
## <a name="debug"></a>Modo de programador
Durante la depuración, resulta útil enviar los datos de telemetría por la canalización para así poder ver los resultados inmediatamente. También puede recibir mensajes adicionales que le ayuden a realizar el seguimiento de los posibles problemas con la telemetría. Desactívelo en producción, ya que puede ralentizar la aplicación.
*C#*
```csharp
TelemetryConfiguration.Active.TelemetryChannel.DeveloperMode = true;
```
*Visual Basic*
```vb
TelemetryConfiguration.Active.TelemetryChannel.DeveloperMode = True
```
*Node.js*
Para Node.js, puede habilitar el modo de desarrollador habilitando el registro interno a través de `setInternalLogging` y estableciendo `maxBatchSize` en 0, lo que hace que la telemetría se envíe tan pronto como se recopile.
```js
applicationInsights.setup("ikey")
.setInternalLogging(true, true)
.start()
applicationInsights.defaultClient.config.maxBatchSize = 0;
```
## <a name="ikey"></a> Establecimiento de la clave de instrumentación para datos de telemetría personalizados seleccionados
*C#*
```csharp
var telemetry = new TelemetryClient();
telemetry.InstrumentationKey = "---my key---";
// ...
```
## <a name="dynamic-ikey"></a> Copia de la clave de instrumentación
Para evitar la mezcla de telemetría de entornos de desarrollo, pruebas y producción, puede [crear recursos separados de Application Insights](../../azure-monitor/app/create-new-resource.md ) y cambiar sus claves en función del entorno.
En lugar de obtener la clave de instrumentación del archivo de configuración, puede establecerla en el código. Establezca la clave en un método de inicialización, como global.aspx.cs en un servicio de ASP.NET:
*C#*
```csharp
protected void Application_Start()
{
Microsoft.ApplicationInsights.Extensibility.
TelemetryConfiguration.Active.InstrumentationKey =
// - for example -
WebConfigurationManager.Settings["ikey"];
...
}
```
*JavaScript*
```javascript
appInsights.config.instrumentationKey = myKey;
```
En una página web, podría configurarla a partir del estado del servidor web, en lugar de codificarla literalmente en el script. Por ejemplo, en una página web generada en una aplicación ASP.NET:
*JavaScript en Razor*
```cshtml
<script type="text/javascript">
// Standard Application Insights webpage script:
var appInsights = window.appInsights || function(config){ ...
// Modify this part:
}({instrumentationKey:
// Generate from server property:
@Microsoft.ApplicationInsights.Extensibility.
TelemetryConfiguration.Active.InstrumentationKey;
}) // ...
```
```java
String instrumentationKey = "00000000-0000-0000-0000-000000000000";
if (instrumentationKey != null)
{
TelemetryConfiguration.getActive().setInstrumentationKey(instrumentationKey);
}
```
## <a name="telemetrycontext"></a>TelemetryContext
TelemetryClient tiene una propiedad de Context, que contiene valores que se envían junto con todos los datos de telemetría. Normalmente, se establecen mediante los módulos de telemetría estándar, pero también los puede establecer usted mismo. Por ejemplo:
```csharp
telemetry.Context.Operation.Name = "MyOperationName";
```
Si establece cualquiera de estos valores manualmente, considere la posibilidad de quitar la línea pertinente de [ApplicationInsights.config](../../azure-monitor/app/configuration-with-applicationinsights-config.md), de modo que no se confundan sus valores con los valores estándar.
* **Component**: la aplicación y su versión.
* **Device**: datos sobre el dispositivo donde se ejecuta la aplicación. (En aplicaciones web, se trata del servidor o el dispositivo de cliente desde el que se envía la telemetría).
* **InstrumentationKey**: el recurso de Application Insights en Azure donde aparece la telemetría. Normalmente, se selecciona de ApplicationInsights.config.
* **Location**: la ubicación geográfica del dispositivo.
* **Operation**: en las aplicaciones web, es la solicitud HTTP actual. En otros tipos de aplicaciones, puede establecer este valor para agrupar los eventos juntos.
* **ID**: valor generado que correlaciona distintos eventos, de modo que cuando usted inspeccione cualquier evento en Búsqueda de diagnóstico, puede encontrar elementos relacionados.
* **Name**: un identificador, generalmente la dirección URL de la solicitud HTTP.
* **SyntheticSource**: si no es un valor nulo ni está vacío, esta cadena indica que el origen de la solicitud se ha identificado como un robot o una prueba web. De forma predeterminada, se excluye de cálculos en el Explorador de métricas.
* **Properties**: propiedades que se envían con todos los datos de telemetría. Se pueden invalidar en llamadas de seguimiento* individuales.
* **Sesión**: sesión del usuario. El identificador se establece en un valor generado, que cambia cuando el usuario lleva un tiempo sin estar activo.
* **User**: información del usuario.
## <a name="limits"></a>límites
[!INCLUDE [application-insights-limits](../../../includes/application-insights-limits.md)]
Para evitar llegar al límite de velocidad de datos, utilice el [muestreo](../../azure-monitor/app/sampling.md).
Para determinar cuánto tiempo se conservan los datos, consulte el artículo sobre [retención de datos y privacidad](../../azure-monitor/app/data-retention-privacy.md).
## <a name="reference-docs"></a>Documentos de referencia
* [Referencia de ASP.NET](https://msdn.microsoft.com/library/dn817570.aspx)
* [Referencia de Java](http://dl.windowsazure.com/applicationinsights/javadoc/)
* [Referencia de JavaScript](https://github.com/Microsoft/ApplicationInsights-JS/blob/master/API-reference.md)
* [SDK de Android](https://github.com/Microsoft/ApplicationInsights-Android)
* [SDK de iOS](https://github.com/Microsoft/ApplicationInsights-iOS)
## <a name="sdk-code"></a>Código del SDK
* [SDK básico de ASP.NET](https://github.com/Microsoft/ApplicationInsights-aspnetcore)
* [ASP.NET 5](https://github.com/Microsoft/ApplicationInsights-dotnet)
* [Paquetes de Windows Server](https://github.com/Microsoft/applicationInsights-dotnet-server)
* [SDK de Java](https://github.com/Microsoft/ApplicationInsights-Java)
* [SDK de Node.js](https://github.com/Microsoft/ApplicationInsights-Node.js)
* [SDK de JavaScript](https://github.com/Microsoft/ApplicationInsights-JS)
* [Todas las plataformas](https://github.com/Microsoft?utf8=%E2%9C%93&query=applicationInsights)
## <a name="questions"></a>Preguntas
* *¿Qué excepciones pueden iniciar las llamadas de seguimiento_()?*
Ninguno. No es necesario agruparlas en cláusulas try-catch. Si el SDK encuentra problemas, registrará los mensajes en la salida de la consola de depuración, y, si los mensajes pasan, en la Búsqueda de diagnóstico.
* *¿Hay una API de REST para obtener datos desde el portal?*
Sí, la [API de acceso a datos](https://dev.applicationinsights.io/). Otras maneras de extraer datos son [exportar desde Analytics a Power BI](../../azure-monitor/app/export-power-bi.md ) y la [exportación continua](../../azure-monitor/app/export-telemetry.md).
## <a name="next"></a>Pasos siguientes
* [Búsqueda de eventos y registros](../../azure-monitor/app/diagnostic-search.md)
* [Solución de problemas](../../azure-monitor/app/troubleshoot-faq.md)
| 43.092928 | 769 | 0.759909 | spa_Latn | 0.936137 |
472ed4c1553cc8d6994ccc5d5009d0916b400aeb | 3,045 | md | Markdown | docs/debugger/error-web-site-worker-process-has-been-terminated-by-iis.md | MicrosoftDocs/visualstudio-docs.es-es | 9d654c35ecad85edadd91aefb49b7bd0ebd2eee2 | [
"CC-BY-4.0",
"MIT"
] | 6 | 2020-05-20T07:48:51.000Z | 2022-03-09T07:27:32.000Z | docs/debugger/error-web-site-worker-process-has-been-terminated-by-iis.md | MicrosoftDocs/visualstudio-docs.es-es | 9d654c35ecad85edadd91aefb49b7bd0ebd2eee2 | [
"CC-BY-4.0",
"MIT"
] | 30 | 2018-10-02T15:11:15.000Z | 2021-12-17T11:02:02.000Z | docs/debugger/error-web-site-worker-process-has-been-terminated-by-iis.md | MicrosoftDocs/visualstudio-docs.es-es | 9d654c35ecad85edadd91aefb49b7bd0ebd2eee2 | [
"CC-BY-4.0",
"MIT"
] | 25 | 2018-01-24T17:02:46.000Z | 2022-03-04T14:06:19.000Z | ---
description: El depurador detuvo la ejecución del código en el sitio web.
title: IIS ha interrumpido el proceso de trabajo del sitio web | Microsoft Docs
ms.date: 11/04/2016
ms.topic: error-reference
f1_keywords:
- vs.debug.error.web_server_process_terminated
dev_langs:
- CSharp
- VB
- FSharp
- C++
author: mikejo5000
ms.author: mikejo
manager: jmartens
ms.technology: vs-ide-debug
ms.workload:
- multiple
ms.openlocfilehash: d8fce93b1bd55930b518d21921557b4ac58e8576
ms.sourcegitcommit: 68897da7d74c31ae1ebf5d47c7b5ddc9b108265b
ms.translationtype: HT
ms.contentlocale: es-ES
ms.lasthandoff: 08/13/2021
ms.locfileid: "122074343"
---
# <a name="error-web-site-worker-process-has-been-terminated-by-iis"></a>Error: IIS ha interrumpido el proceso de trabajo del sitio web
El depurador detuvo la ejecución del código en el sitio web. Esto hizo que Internet Information Services (IIS) creyera que el proceso de trabajo había dejado de responder. Por consiguiente, IIS finalizaron el proceso de trabajo.
Para seguir depurando, debe configurar IIS para permitir que continúe el proceso de trabajo. Este mensaje de error no aparece con las versiones de IIS anteriores a IIS 7.
### <a name="to-configure-iis-7-to-allow-the-worker-process-to-continue"></a>Para configurar IIS 7 de manera que el proceso de trabajo pueda continuar
1. Abra la ventana **Herramientas administrativas**.
1. Haga clic en **Inicio** y después elija **Panel de control**.
2. En el **Panel de control**, elija **Cambiar a Vista clásica** si es necesario y, a continuación, haga doble clic en **Herramientas administrativas**.
2. En la ventana **Herramientas administrativas**, haga doble clic en **Administrador de Internet Information Services (IIS)** .
Se abrirá el Administrador de IIS.
3. En el panel **Conexiones**, expanda el nodo \<computer name> si es necesario.
4. En el nodo \<computer name>, haga clic en **Grupos de aplicaciones**.
5. En la lista **Grupos de aplicaciones**, haga clic con el botón derecho en el nombre del grupo en el que se ejecuta la aplicación y, a continuación, haga clic en **Configuración avanzada**.
6. En el cuadro de diálogo **Configuración avanzada**, busque la sección **Modelo de proceso** y realice una de las acciones siguientes:
- Establezca **Ping habilitado** en **False**.
- Establezca **Tiempo máximo de respuesta de ping** en un valor mayor de 90 segundos.
Si establece **Ping habilitado** en **False**, IIS dejará de comprobar si el proceso de trabajo todavía se está ejecutando y lo mantendrá activo hasta que detenga el proceso depurado. Establecer **Tiempo máximo de respuesta de ping** en un valor grande permite a IIS seguir supervisando el proceso de trabajo.
7. Haga clic en **Aceptar** para cerrar el cuadro de diálogo **Configuración avanzada**.
8. Cierre el Administrador de IIS y la ventana **Herramientas administrativas**.
## <a name="see-also"></a>Vea también
- [Errores de la depuración remota y sus soluciones](../debugger/remote-debugging-errors-and-troubleshooting.md)
| 48.333333 | 314 | 0.764532 | spa_Latn | 0.9865 |
472f826bb1bc1e71012e0b3ce7a6cc04a35f7724 | 663 | md | Markdown | device-collection/HADIS-Solo/README.md | HADIS-Home-Automation/HADIS-Devices | b6f4274d230a1115dd8e661fe75db0bb6f7701c1 | [
"MIT"
] | null | null | null | device-collection/HADIS-Solo/README.md | HADIS-Home-Automation/HADIS-Devices | b6f4274d230a1115dd8e661fe75db0bb6f7701c1 | [
"MIT"
] | null | null | null | device-collection/HADIS-Solo/README.md | HADIS-Home-Automation/HADIS-Devices | b6f4274d230a1115dd8e661fe75db0bb6f7701c1 | [
"MIT"
] | null | null | null | # HADIS - Solo
MQTT relay switch.
Start setup mode by pressing the button for approximately 6sec.
## Electronics
* Device: [Sonoff Basic R2](https://sonoff.tech/product/wifi-diy-smart-switches/basicr2)
## Pins
* Button: GPIO 0
* Relay: GPIO 12
* Indicator LED: GPIO 13
## MQTT topics
* HADIS/*deviceName*/SWITCH -> handle relay state
* HADIS/*deviceName*/SETUP -> handle setup mode activation
* HADIS/*deviceName*/STATUS -> handle device status (ONLINE/OFFLINE)
*deviceName* is a placeholder for specific topics
## Pictures
Switch with case
Switch without case
| 22.1 | 88 | 0.739065 | eng_Latn | 0.472004 |
4730655936fb1470e608f7858e8f4e3420f7af72 | 15,723 | md | Markdown | docs/c-runtime-library/reference/setlocale-wsetlocale.md | OpenLocalizationTestOrg/cpp-docs.it-it | 05d8d2dcc95498d856f8456e951d801011fe23d1 | [
"CC-BY-4.0"
] | 1 | 2020-05-21T13:09:13.000Z | 2020-05-21T13:09:13.000Z | docs/c-runtime-library/reference/setlocale-wsetlocale.md | OpenLocalizationTestOrg/cpp-docs.it-it | 05d8d2dcc95498d856f8456e951d801011fe23d1 | [
"CC-BY-4.0"
] | null | null | null | docs/c-runtime-library/reference/setlocale-wsetlocale.md | OpenLocalizationTestOrg/cpp-docs.it-it | 05d8d2dcc95498d856f8456e951d801011fe23d1 | [
"CC-BY-4.0"
] | null | null | null | ---
title: setlocale, _wsetlocale | Microsoft Docs
ms.custom:
ms.date: 11/04/2016
ms.reviewer:
ms.suite:
ms.technology:
- devlang-cpp
ms.tgt_pltfrm:
ms.topic: article
apiname:
- _wsetlocale
- setlocale
apilocation:
- msvcrt.dll
- msvcr80.dll
- msvcr90.dll
- msvcr100.dll
- msvcr100_clr0400.dll
- msvcr110.dll
- msvcr110_clr0400.dll
- msvcr120.dll
- msvcr120_clr0400.dll
- ucrtbase.dll
- api-ms-win-crt-locale-l1-1-0.dll
apitype: DLLExport
f1_keywords:
- _wsetlocale
- _tsetlocale
- setlocale
dev_langs:
- C++
- C
helpviewer_keywords:
- wsetlocale function
- setlocale function
- tsetlocale function
- locales, defining
- _tsetlocale function
- defining locales
- _wsetlocale function
ms.assetid: 3ffb684e-5990-4202-9553-b5339af9520d
caps.latest.revision: 31
author: corob-msft
ms.author: corob
manager: ghogen
translation.priority.ht:
- cs-cz
- de-de
- es-es
- fr-fr
- it-it
- ja-jp
- ko-kr
- pl-pl
- pt-br
- ru-ru
- tr-tr
- zh-cn
- zh-tw
translationtype: Human Translation
ms.sourcegitcommit: 3168772cbb7e8127523bc2fc2da5cc9b4f59beb8
ms.openlocfilehash: 848104d4f6afbf70b501918563ee58085024e11e
---
# setlocale, _wsetlocale
Sets or retrieves the run-time locale.
## Syntax
```
char *setlocale(
int category,
const char *locale
);
wchar_t *_wsetlocale(
int category,
const wchar_t *locale
);
```
#### Parameters
`category`
Category affected by locale.
`locale`
Locale specifier.
## Return Value
If a valid `locale` and `category` are given, returns a pointer to the string associated with the specified `locale` and `category`. If the `locale` or `category` is not valid, returns a null pointer and the current locale settings of the program are not changed.
For example, the call
`setlocale( LC_ALL, "en-US" );`
sets all categories, returning only the string
`en-US`
You can copy the string returned by `setlocale` to restore that part of the program's locale information. Global or thread local storage is used for the string returned by `setlocale`. Later calls to `setlocale` overwrite the string, which invalidates string pointers returned by earlier calls.
## Remarks
Use the `setlocale` function to set, change, or query some or all of the current program locale information specified by `locale` and `category`. `locale` refers to the locality (country/region and language) for which you can customize certain aspects of your program. Some locale-dependent categories include the formatting of dates and the display format for monetary values. If you set `locale` to the default string for a language that has multiple forms supported on your computer, you should check the `setlocale` return value to see which language is in effect. For example, if you set `locale` to "chinese" the return value could be either "chinese-simplified" or "chinese-traditional".
`_wsetlocale` is a wide-character version of `setlocale`; the `locale` argument and return value of `_wsetlocale` are wide-character strings. `_wsetlocale` and `setlocale` behave identically otherwise.
### Generic-Text Routine Mappings
|TCHAR.H routine|_UNICODE & _MBCS not defined|_MBCS defined|_UNICODE defined|
|---------------------|------------------------------------|--------------------|-----------------------|
|`_tsetlocale`|`setlocale`|`setlocale`|`_wsetlocale`|
The `category` argument specifies the parts of a program's locale information that are affected. The macros used for `category` and the parts of the program they affect are as follows:
`LC_ALL`
All categories in the following list.
`LC_COLLATE`
The `strcoll`, `_stricoll`, `wcscoll`, `_wcsicoll`, `strxfrm`, `_strncoll`, `_strnicoll`, `_wcsncoll`, `_wcsnicoll`, and `wcsxfrm` functions.
`LC_CTYPE`
The character-handling functions (except `isdigit`, `isxdigit`, `mbstowcs`, and `mbtowc`, which are unaffected).
`LC_MONETARY`
Monetary-formatting information returned by the `localeconv` function.
`LC_NUMERIC`
Decimal-point character for the formatted output routines (such as `printf`), for the data-conversion routines, and for the non-monetary formatting information returned by `localeconv`. In addition to the decimal-point character, `LC_NUMERIC` also sets the thousands separator and the grouping control string returned by [localeconv](../../c-runtime-library/reference/localeconv.md).
`LC_TIME`
The `strftime` and `wcsftime` functions.
This function validates the category parameter. If the category parameter is not one of the values given in the previous table, the invalid parameter handler is invoked, as described in [Parameter Validation](../../c-runtime-library/parameter-validation.md). If execution is allowed to continue, the function sets `errno` to `EINVAL` and returns `NULL`.
The `locale` argument is a pointer to a string that specifies the locale. For information about the format of the `locale` argument, see [Locale Names, Languages, and Country/Region Strings](../../c-runtime-library/locale-names-languages-and-country-region-strings.md). If `locale` points to an empty string, the locale is the implementation-defined native environment. A value of `C` specifies the minimal ANSI conforming environment for C translation. The `C` locale assumes that all `char` data types are 1 byte and that their value is always less than 256.
At program startup, the equivalent of the following statement is executed:
`setlocale( LC_ALL, "C" );`
The `locale` argument can take a locale name, a language string, a language string and country/region code, a code page, or a language string, country/region code, and code page. The set of available locale names, languages, country/region codes, and code pages includes all those supported by the Windows NLS API except code pages that require more than two bytes per character, such as UTF-7 and UTF-8. If you provide a code page value of UTF-7 or UTF-8, `setlocale` will fail, returning NULL. The set of locale names supported by `setlocale` are described in [Locale Names, Languages, and Country/Region Strings](../../c-runtime-library/locale-names-languages-and-country-region-strings.md). The set of language and country/region strings supported by `setlocale` are listed in [Language Strings](../../c-runtime-library/language-strings.md) and [Country/Region Strings](../../c-runtime-library/country-region-strings.md). We recommend the locale name form for performance and for maintainability of locale strings embedded in code or serialized to storage. The locale name strings are less likely to be changed by an operating system update than the language and country/region name form.
A null pointer that's passed as the `locale` argument tells `setlocale` to query instead of to set the international environment. If the `locale` argument is a null pointer, the program's current locale setting is not changed. Instead, `setlocale` returns a pointer to the string that's associated with the `category` of the thread's current locale. If the `category` argument is `LC_ALL`, the function returns a string that indicates the current setting of each category, separated by semicolons. For example, the sequence of calls
`// Set all categories and return "en-US"`
`setlocale(LC_ALL, "en-US");`
`// Set only the LC_MONETARY category and return "fr-FR"`
`setlocale(LC_MONETARY, "fr-FR");`
`printf("%s\n", setlocale(LC_ALL, NULL));`
returns
`LC_COLLATE=en-US;LC_CTYPE=en-US;LC_MONETARY=fr-FR;LC_NUMERIC=en-US;LC_TIME=en-US`
which is the string that's associated with the `LC_ALL` category.
The following examples pertain to the `LC_ALL` category. Either of the strings ".OCP" and ".ACP" can be used instead of a code page number to specify use of the user-default OEM code page and user-default ANSI code page, respectively.
`setlocale( LC_ALL, "" );`
Sets the locale to the default, which is the user-default ANSI code page obtained from the operating system.
`setlocale( LC_ALL, ".OCP" );`
Explicitly sets the locale to the current OEM code page obtained from the operating system.
`setlocale( LC_ALL, ".ACP" );`
Sets the locale to the ANSI code page obtained from the operating system.
`setlocale( LC_ALL, "<localename>" );`
Sets the locale to the locale name that's indicated by *\<localename>*.
`setlocale( LC_ALL, "<language>_<country>" );`
Sets the locale to the language and country/region indicated by *\<language>* and *\<country>*, together with the default code page obtained from the host operating system.
`setlocale( LC_ALL, "<language>_<country>.<code_page>" );`
Sets the locale to the language, country/region, and code page indicated by the *\<language>*, *\<country>*, and *<code_page>* strings. You can use various combinations of language, country/region, and code page. For example, this call sets the locale to French Canada with code page 1252:
`setlocale( LC_ALL, "French_Canada.1252" );`
This call sets the locale to French Canada with the default ANSI code page:
`setlocale( LC_ALL, "French_Canada.ACP" );`
This call sets the locale to French Canada with the default OEM code page:
`setlocale( LC_ALL, "French_Canada.OCP" );`
`setlocale( LC_ALL, "<language>" );`
Sets the locale to the language that's indicated by *\<language>*, and uses the default country/region for the specified language and the user-default ANSI code page for that country/region as obtained from the host operating system. For example, the following calls to `setlocale` are functionally equivalent:
`setlocale( LC_ALL, "en-US" );`
`setlocale( LC_ALL, "English" );`
`setlocale( LC_ALL, "English_United States.1252" );`
We recommend the first form for performance and maintainability.
`setlocale( LC_ALL, ".<code_page>" );`
Sets the code page to the value indicated by *<code_page>*, together with the default country/region and language (as defined by the host operating system) for the specified code page.
The category must be either `LC_ALL` or `LC_CTYPE` to effect a change of code page. For example, if the default country/region and language of the host operating system are "United States" and "English," the following two calls to `setlocale` are functionally equivalent:
`setlocale( LC_ALL, ".1252" );`
`setlocale( LC_ALL, "English_United States.1252");`
For more information, see the [setlocale](../../preprocessor/setlocale.md) pragma directive in the [C/C++ Preprocessor Reference](../../preprocessor/c-cpp-preprocessor-reference.md).
The function [_configthreadlocale](../../c-runtime-library/reference/configthreadlocale.md) is used to control whether `setlocale` affects the locale of all threads in a program or only the locale of the calling thread.
## Requirements
|Routine|Required header|
|-------------|---------------------|
|`setlocale`|\<locale.h>|
|`_wsetlocale`|\<locale.h> or \<wchar.h>|
For additional compatibility information, see [Compatibility](../../c-runtime-library/compatibility.md) in the Introduction.
## Example
```css
// crt_setlocale.c
//
// This program demonstrates the use of setlocale when
// using two independent threads.
//
#include <locale.h>
#include <process.h>
#include <windows.h>
#include <stdio.h>
#include <time.h>
#define BUFF_SIZE 100
// Retrieve the date in the current
// locale's format.
int get_date(unsigned char* str)
{
__time64_t ltime;
struct tm thetime;
// Retrieve the current time
_time64(<ime);
_gmtime64_s(&thetime, <ime);
// Format the current time structure into a string
// "%#x" is the long date representation in the
// current locale
if (!strftime((char *)str, BUFF_SIZE, "%#x",
(const struct tm *)&thetime))
{
printf("strftime failed!\n");
return -1;
}
return 0;
}
// This thread sets its locale to the argument
// and prints the date.
uintptr_t __stdcall SecondThreadFunc( void* pArguments )
{
unsigned char str[BUFF_SIZE];
char * locale = (char *)pArguments;
// Set the thread locale
printf("The thread locale is now set to %s.\n",
setlocale(LC_ALL, locale));
// Retrieve the date string from the helper function
if (get_date(str) == 0)
{
printf("The date in %s locale is: '%s'\n", locale, str);
}
_endthreadex( 0 );
return 0;
}
// The main thread sets the locale to English
// and then spawns a second thread (above) and prints the date.
int main()
{
HANDLE hThread;
unsigned threadID;
unsigned char str[BUFF_SIZE];
// Configure per-thread locale to cause all subsequently created
// threads to have their own locale.
_configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
// Set the locale of the main thread to US English.
printf("The thread locale is now set to %s.\n",
setlocale(LC_ALL, "en-US"));
// Create the second thread with a German locale.
// Our thread function takes an argument of the locale to use.
hThread = (HANDLE)_beginthreadex( NULL, 0, &SecondThreadFunc,
"de-DE", 0, &threadID );
if (get_date(str) == 0)
{
// Retrieve the date string from the helper function
printf("The date in en-US locale is: '%s'\n\n", str);
}
// Wait for the created thread to finish.
WaitForSingleObject( hThread, INFINITE );
// Destroy the thread object.
CloseHandle( hThread );
}
```
```Output
The thread locale is now set to en-US.
The time in en-US locale is: 'Wednesday, May 12, 2004'
The thread locale is now set to de-DE.
The time in de-DE locale is: 'Mittwoch, 12. Mai 2004'
```
## .NET Framework Equivalent
[System::Globalization::CultureInfo Class](https://msdn.microsoft.com/en-us/library/system.globalization.cultureinfo.aspx)
## See Also
[Locale Names, Languages, and Country/Region Strings](../../c-runtime-library/locale-names-languages-and-country-region-strings.md)
[_configthreadlocale](../../c-runtime-library/reference/configthreadlocale.md)
[_create_locale, _wcreate_locale](../../c-runtime-library/reference/create-locale-wcreate-locale.md)
[Locale](../../c-runtime-library/locale.md)
[localeconv](../../c-runtime-library/reference/localeconv.md)
[_mbclen, mblen, _mblen_l](../../c-runtime-library/reference/mbclen-mblen-mblen-l.md)
[strlen, wcslen, _mbslen, _mbslen_l, _mbstrlen, _mbstrlen_l](../../c-runtime-library/reference/strlen-wcslen-mbslen-mbslen-l-mbstrlen-mbstrlen-l.md)
[mbstowcs, _mbstowcs_l](../../c-runtime-library/reference/mbstowcs-mbstowcs-l.md)
[mbtowc, _mbtowc_l](../../c-runtime-library/reference/mbtowc-mbtowc-l.md)
[_setmbcp](../../c-runtime-library/reference/setmbcp.md)
[strcoll Functions](../../c-runtime-library/strcoll-functions.md)
[strftime, wcsftime, _strftime_l, _wcsftime_l](../../c-runtime-library/reference/strftime-wcsftime-strftime-l-wcsftime-l.md)
[strxfrm, wcsxfrm, _strxfrm_l, _wcsxfrm_l](../../c-runtime-library/reference/strxfrm-wcsxfrm-strxfrm-l-wcsxfrm-l.md)
[wcstombs, _wcstombs_l](../../c-runtime-library/reference/wcstombs-wcstombs-l.md)
[wctomb, _wctomb_l](../../c-runtime-library/reference/wctomb-wctomb-l.md)
<!--HONumber=Jan17_HO2-->
| 44.667614 | 1,195 | 0.701584 | eng_Latn | 0.974232 |
4730c8b30ebab14b293949c7669a8fa3ebfbf534 | 250 | md | Markdown | README.md | johnstarmer/documentationdemo | 558e57267dc192e7a8b1525300779ddc301648b0 | [
"Apache-2.0"
] | null | null | null | README.md | johnstarmer/documentationdemo | 558e57267dc192e7a8b1525300779ddc301648b0 | [
"Apache-2.0"
] | null | null | null | README.md | johnstarmer/documentationdemo | 558e57267dc192e7a8b1525300779ddc301648b0 | [
"Apache-2.0"
] | null | null | null | # Documentation Demo Site
This is a demonstration website to use for exploring the capability of the Hugo static site generator.
## Running the website locally
Once you've cloned the site repo, from the repo root folder, run:
```
hugo server
```
| 20.833333 | 102 | 0.76 | eng_Latn | 0.998614 |
4730fe9441d38c8d70fcc62d42ebaab17baf0506 | 5,600 | md | Markdown | docs/extensibility/registering-verbs-for-file-name-extensions.md | ManuSquall/visualstudio-docs.fr-fr | 87f0072eb292673de4a102be704162619838365f | [
"CC-BY-4.0",
"MIT"
] | 1 | 2021-08-15T11:25:55.000Z | 2021-08-15T11:25:55.000Z | docs/extensibility/registering-verbs-for-file-name-extensions.md | ManuSquall/visualstudio-docs.fr-fr | 87f0072eb292673de4a102be704162619838365f | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/extensibility/registering-verbs-for-file-name-extensions.md | ManuSquall/visualstudio-docs.fr-fr | 87f0072eb292673de4a102be704162619838365f | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: Inscription de verbes pour les extensions de nom de fichier | Microsoft Docs
description: Découvrez comment inscrire un verbe qui est associé à un identificateur programmatique pour une extension de nom de fichier à l’aide d’une clé de Shell.
ms.custom: SEO-VS-2020
ms.date: 11/04/2016
ms.topic: how-to
helpviewer_keywords:
- verbs, registering
ms.assetid: 81a58e40-7cd0-4ef4-a475-c4e1e84d6e06
author: leslierichardson95
ms.author: lerich
manager: jmartens
ms.workload:
- vssdk
ms.openlocfilehash: c223dea7e265d8d040d502c99ded09380e89690f
ms.sourcegitcommit: bab002936a9a642e45af407d652345c113a9c467
ms.translationtype: MT
ms.contentlocale: fr-FR
ms.lasthandoff: 06/25/2021
ms.locfileid: "112901225"
---
# <a name="register-verbs-for-file-name-extensions"></a>Verbes Register pour les extensions de nom de fichier
L’Association d’une extension de nom de fichier à une application a généralement une action préférée qui se produit lorsqu’un utilisateur double-clique sur un fichier. Cette action par défaut est liée à un verbe, par exemple Open, qui correspond à l’action.
Vous pouvez inscrire des verbes associés à un identificateur programmatique (ProgID) pour une extension à l’aide de la clé de Shell située dans **HKEY_CLASSES_ROOT \{ ProgID} \shell**. Pour plus d’informations, consultez [types de fichiers](/windows/desktop/shell/fa-file-types).
## <a name="register-standard-verbs"></a>Inscrire les verbes standard
Le système d’exploitation reconnaît les verbes standard suivants :
- Ouvrir
- Modifier
- Lire
- Impression
- Préversion
Dans la mesure du possible, inscrivez un verbe standard. Le choix le plus courant est le verbe Open. Utilisez le verbe Edit uniquement s’il existe une différence nette entre l’ouverture du fichier et la modification du fichier. Par exemple, l’ouverture d’un fichier *.htm* l’affiche dans le navigateur, tandis que la modification d’un fichier *.htm* démarre un éditeur HTML. Les verbes standard sont localisés avec les paramètres régionaux du système d’exploitation.
> [!NOTE]
> Lors de l’inscription des verbes standard, ne définissez pas la valeur par défaut de la clé ouverte. La valeur par défaut contient la chaîne d’affichage dans le menu. Le système d’exploitation fournit cette chaîne pour les verbes standard.
Les fichiers projet doivent être inscrits pour démarrer une nouvelle instance de [!INCLUDE[vsprvs](../code-quality/includes/vsprvs_md.md)] lorsqu’un utilisateur ouvre le fichier. L’exemple suivant illustre une inscription de verbe standard pour un [!INCLUDE[csprcs](../data-tools/includes/csprcs_md.md)] projet.
```
[HKEY_CLASSES_ROOT\.csproj]
@="VisualStudio.csproj.8.0"
[HKEY_CLASSES_ROOT\.csproj\OpenWithList]
[HKEY_CLASSES_ROOT\.csproj\OpenWithList\VSLauncher.exe]
@=""
[HKEY_CLASSES_ROOT\.csproj\OpenWithProgids]
"VisualStudio.csproj.8.0"=""
[HKEY_CLASSES_ROOT\Applications\VSLauncher.exe]
[HKEY_CLASSES_ROOT\Applications\VSLauncher.exe\Shell]
[HKEY_CLASSES_ROOT\Applications\VSLauncher.exe\Shell\Open]
[HKEY_CLASSES_ROOT\Applications\VSLauncher.exe\Shell\Open\Command]
@="C:\\Program Files\\Common Files\\Microsoft Shared\\MSEnv\\VSLauncher.exe \"%1\""
[HKEY_CLASSES_ROOT\VisualStudio.csproj.8.0]
@="C# Project file"
[HKEY_CLASSES_ROOT\VisualStudio.csproj.8.0\DefaultIcon]
@="C:\\VisualStudioPath\\VC#\\VCSPackages\\csproj.dll,0"
[HKEY_CLASSES_ROOT\VisualStudio.csproj.8.0\shell]
[HKEY_CLASSES_ROOT\VisualStudio.csproj.8.0\shell\Open]
[HKEY_CLASSES_ROOT\VisualStudio.csproj.8.0\shell\Open\Command]
@="\"C:\\Program Files\\Common Files\\Microsoft Shared\\MSEnv\\VSLauncher.exe\" \"%1\""
```
Pour ouvrir un fichier dans une instance existante de [!INCLUDE[vsprvs](../code-quality/includes/vsprvs_md.md)] , inscrivez une clé DDEEXEC. L’exemple suivant illustre une inscription de verbe standard pour un [!INCLUDE[csprcs](../data-tools/includes/csprcs_md.md)] fichier *. cs* .
```
[HKEY_CLASSES_ROOT\.cs]
@="VisualStudio.cs.8.0"
[HKEY_CLASSES_ROOT\.cs\OpenWithList]
[HKEY_CLASSES_ROOT\.cs\OpenWithList\devenv.exe]
@=""
[HKEY_CLASSES_ROOT\.cs\OpenWithProgids]
"VisualStudio.cs.8.0"=""
[HKEY_CLASSES_ROOT\VisualStudio.cs.8.0]
@="C# Source file"
[HKEY_CLASSES_ROOT\VisualStudio.cs.8.0\DefaultIcon]
@="C:\\VisualStudioPath\\VC#\\VCSPackages\\csproj.dll,1"
[HKEY_CLASSES_ROOT\VisualStudio.cs.8.0\shell]
[HKEY_CLASSES_ROOT\VisualStudio.cs.8.0\shell\Open]
[HKEY_CLASSES_ROOT\VisualStudio.cs.8.0\shell\Open\Command]
@="\"C:\\VisualStudioPath\\Common7\\IDE\\devenv.exe\" /dde \"%1\""
[HKEY_CLASSES_ROOT\VisualStudio.cs.8.0\shell\Open\ddeexec]
@="Open(\"%1\")"
[HKEY_CLASSES_ROOT\VisualStudio.cs.8.0\shell\Open\ddeexec\Application]
@="VisualStudio.8.0"
[HKEY_CLASSES_ROOT\VisualStudio.cs.8.0\shell\Open\ddeexec\Topic]
@="system"
```
## <a name="set-the-default-verb"></a>Définir le verbe par défaut
Le verbe par défaut est l’action qui est exécutée lorsqu’un utilisateur double-clique sur un fichier dans l’Explorateur Windows. Le verbe par défaut est le verbe spécifié comme valeur par défaut pour l’HKEY_CLASSES_ROOT clé de **\\ \Shell *ProgID*** . Si aucune valeur n’est spécifiée, le verbe par défaut est le premier verbe spécifié dans la liste de clés de **HKEY_CLASSES_ROOT \\ *ProgID*\Shell** .
> [!NOTE]
> Si vous envisagez de modifier le verbe par défaut pour une extension dans un déploiement côte à côte, prenez en compte l’impact sur l’installation et la suppression. Pendant l’installation, la valeur par défaut d’origine est remplacée.
## <a name="see-also"></a>Voir aussi
- [Gérer les associations de fichiers côte à côte](../extensibility/managing-side-by-side-file-associations.md)
| 47.457627 | 468 | 0.780357 | fra_Latn | 0.769829 |
473129c7887c112c456ec0f3e106932adc027e71 | 22,675 | md | Markdown | Current/markdown/classHack_1_1Chips_1_1Mux8Way16.md | CharlesCarley/HackComputer | 2f29ec7929ef08f295b5be5810f324acc99604e0 | [
"MIT"
] | null | null | null | Current/markdown/classHack_1_1Chips_1_1Mux8Way16.md | CharlesCarley/HackComputer | 2f29ec7929ef08f295b5be5810f324acc99604e0 | [
"MIT"
] | null | null | null | Current/markdown/classHack_1_1Chips_1_1Mux8Way16.md | CharlesCarley/HackComputer | 2f29ec7929ef08f295b5be5810f324acc99604e0 | [
"MIT"
] | null | null | null | <a id="mux8way16"></a>
<h1>Mux8Way16</h1>
<a id="classhack_1_1chips_1_1mux8way16"></a>
<a href="https://github.com/CharlesCarley/HackComputer#~">~</a>
<a href="index.md#index">HackComputer</a>
<span class="inline-text">/</span>
<a href="namespaceHack.md#hack">Hack</a>
<span class="inline-text">::</span>
<a href="namespaceHack_1_1Chips.md#chips">Chips</a>
<span class="inline-text">::</span>
<span class="bold-text"><b>Mux8Way16</b></span>
<br/>
<br/>
<a id="derived-from"></a>
<h4>Derived From</h4>
<div class="icon-link">
<img src="../images/class.svg"/><a href="classHack_1_1Chips_1_1Chip.md#chip">Hack::Chips::Chip< uint8_t, 8 ></a>
</div>
<img src="../images/dot/internal-diagram-23.dot.svg"/><br/>
<a id="private-members"></a>
<h2>Private Members</h2>
<span class="icon-list-item"><a href="#_in" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">_in</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#_out" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">_out</span>
</a>
</span>
<br/>
<a id="private-methods"></a>
<h2>Private Methods</h2>
<span class="icon-list-item"><a href="#evaluate" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">evaluate</span>
</a>
</span>
<br/>
<a id="public-methods"></a>
<h2>Public Methods</h2>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#getout" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">getOut</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#seta" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">setA</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#setb" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">setB</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#setc" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">setC</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#setd" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">setD</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#sete" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">setE</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#setf" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">setF</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#setg" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">setG</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#seth" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">setH</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#setsel" class="icon-list-item"><img src="../images/class.svg" class="icon-list-item"/><span class="icon-list-item">setSel</span>
</a>
</span>
<br/>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L28" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<a id="_in"></a>
<h2>_in</h2>
<a href="unionHack_1_1Chips_1_1bit64__t.md#bit64_t">bit64_t</a>
<span class="bold-text"><b>_in</b></span>
<br/>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L32" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
<a id="_out"></a>
<h2>_out</h2>
<span class="bold-text"><b>uint16_t</b></span>
<span class="bold-text"><b>_out</b></span>
<br/>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L33" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
<a id="evaluate"></a>
<h2>evaluate</h2>
<span class="inline-text">void</span>
<span class="bold-text"><b>evaluate</b></span>
<span class="italic-text"><i>(</i></span>
<span class="italic-text"><i>)</i></span>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L30" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.cpp#L102" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.cpp</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
<a id="mux8way16"></a>
<h2>Mux8Way16</h2>
<span class="bold-text"><b>Mux8Way16</b></span>
<span class="italic-text"><i>(</i></span>
<span class="italic-text"><i>)</i></span>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L36" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.cpp#L32" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.cpp</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
<a id="getout"></a>
<h2>getOut</h2>
<span class="bold-text"><b>uint16_t</b></span>
<span class="bold-text"><b>getOut</b></span>
<span class="italic-text"><i>(</i></span>
<span class="italic-text"><i>)</i></span>
<a id="references"></a>
<h4>References</h4>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="classHack_1_1Chips_1_1Chip.md#getbit">getBit</a>
</span>
</div>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L56" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.cpp#L95" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.cpp</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
<a id="seta"></a>
<h2>setA</h2>
<span class="inline-text">void</span>
<span class="bold-text"><b>setA</b></span>
<span class="italic-text"><i>(</i></span>
<div class="paragraph">
<span class="paragraph"><img src="../images/horSpace24px.svg"/><span class="inline-text">const </span>
<span class="bold-text"><b>uint16_t</b></span>
<span class="inline-text"> &</span>
<span class="inline-text">a</span>
</span>
</div>
<span class="italic-text"><i>)</i></span>
<a id="references"></a>
<h4>References</h4>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="unionHack_1_1Chips_1_1bit64__t.md#s">s</a>
</span>
</div>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="classHack_1_1Chips_1_1Chip.md#setbit">setBit</a>
</span>
</div>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L38" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.cpp#L39" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.cpp</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
<a id="setb"></a>
<h2>setB</h2>
<span class="inline-text">void</span>
<span class="bold-text"><b>setB</b></span>
<span class="italic-text"><i>(</i></span>
<div class="paragraph">
<span class="paragraph"><img src="../images/horSpace24px.svg"/><span class="inline-text">const </span>
<span class="bold-text"><b>uint16_t</b></span>
<span class="inline-text"> &</span>
<span class="inline-text">b</span>
</span>
</div>
<span class="italic-text"><i>)</i></span>
<a id="references"></a>
<h4>References</h4>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="unionHack_1_1Chips_1_1bit64__t.md#s">s</a>
</span>
</div>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="classHack_1_1Chips_1_1Chip.md#setbit">setBit</a>
</span>
</div>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L40" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.cpp#L45" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.cpp</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
<a id="setc"></a>
<h2>setC</h2>
<span class="inline-text">void</span>
<span class="bold-text"><b>setC</b></span>
<span class="italic-text"><i>(</i></span>
<div class="paragraph">
<span class="paragraph"><img src="../images/horSpace24px.svg"/><span class="inline-text">const </span>
<span class="bold-text"><b>uint16_t</b></span>
<span class="inline-text"> &</span>
<span class="inline-text">c</span>
</span>
</div>
<span class="italic-text"><i>)</i></span>
<a id="references"></a>
<h4>References</h4>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="unionHack_1_1Chips_1_1bit64__t.md#s">s</a>
</span>
</div>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="classHack_1_1Chips_1_1Chip.md#setbit">setBit</a>
</span>
</div>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L42" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.cpp#L51" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.cpp</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
<a id="setd"></a>
<h2>setD</h2>
<span class="inline-text">void</span>
<span class="bold-text"><b>setD</b></span>
<span class="italic-text"><i>(</i></span>
<div class="paragraph">
<span class="paragraph"><img src="../images/horSpace24px.svg"/><span class="inline-text">const </span>
<span class="bold-text"><b>uint16_t</b></span>
<span class="inline-text"> &</span>
<span class="inline-text">d</span>
</span>
</div>
<span class="italic-text"><i>)</i></span>
<a id="references"></a>
<h4>References</h4>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="unionHack_1_1Chips_1_1bit64__t.md#s">s</a>
</span>
</div>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="classHack_1_1Chips_1_1Chip.md#setbit">setBit</a>
</span>
</div>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L44" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.cpp#L57" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.cpp</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
<a id="sete"></a>
<h2>setE</h2>
<span class="inline-text">void</span>
<span class="bold-text"><b>setE</b></span>
<span class="italic-text"><i>(</i></span>
<div class="paragraph">
<span class="paragraph"><img src="../images/horSpace24px.svg"/><span class="inline-text">const </span>
<span class="bold-text"><b>uint16_t</b></span>
<span class="inline-text"> &</span>
<span class="inline-text">e</span>
</span>
</div>
<span class="italic-text"><i>)</i></span>
<a id="references"></a>
<h4>References</h4>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="unionHack_1_1Chips_1_1bit64__t.md#s">s</a>
</span>
</div>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="classHack_1_1Chips_1_1Chip.md#setbit">setBit</a>
</span>
</div>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L46" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.cpp#L63" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.cpp</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
<a id="setf"></a>
<h2>setF</h2>
<span class="inline-text">void</span>
<span class="bold-text"><b>setF</b></span>
<span class="italic-text"><i>(</i></span>
<div class="paragraph">
<span class="paragraph"><img src="../images/horSpace24px.svg"/><span class="inline-text">const </span>
<span class="bold-text"><b>uint16_t</b></span>
<span class="inline-text"> &</span>
<span class="inline-text">f</span>
</span>
</div>
<span class="italic-text"><i>)</i></span>
<a id="references"></a>
<h4>References</h4>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="unionHack_1_1Chips_1_1bit64__t.md#s">s</a>
</span>
</div>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="classHack_1_1Chips_1_1Chip.md#setbit">setBit</a>
</span>
</div>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L48" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.cpp#L69" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.cpp</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
<a id="setg"></a>
<h2>setG</h2>
<span class="inline-text">void</span>
<span class="bold-text"><b>setG</b></span>
<span class="italic-text"><i>(</i></span>
<div class="paragraph">
<span class="paragraph"><img src="../images/horSpace24px.svg"/><span class="inline-text">const </span>
<span class="bold-text"><b>uint16_t</b></span>
<span class="inline-text"> &</span>
<span class="inline-text">g</span>
</span>
</div>
<span class="italic-text"><i>)</i></span>
<a id="references"></a>
<h4>References</h4>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="unionHack_1_1Chips_1_1bit64__t.md#s">s</a>
</span>
</div>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="classHack_1_1Chips_1_1Chip.md#setbit">setBit</a>
</span>
</div>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L50" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.cpp#L75" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.cpp</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
<a id="seth"></a>
<h2>setH</h2>
<span class="inline-text">void</span>
<span class="bold-text"><b>setH</b></span>
<span class="italic-text"><i>(</i></span>
<div class="paragraph">
<span class="paragraph"><img src="../images/horSpace24px.svg"/><span class="inline-text">const </span>
<span class="bold-text"><b>uint16_t</b></span>
<span class="inline-text"> &</span>
<span class="inline-text">h</span>
</span>
</div>
<span class="italic-text"><i>)</i></span>
<a id="references"></a>
<h4>References</h4>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="unionHack_1_1Chips_1_1bit64__t.md#s">s</a>
</span>
</div>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="classHack_1_1Chips_1_1Chip.md#setbit">setBit</a>
</span>
</div>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L52" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.cpp#L81" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.cpp</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
<a id="setsel"></a>
<h2>setSel</h2>
<span class="inline-text">void</span>
<span class="bold-text"><b>setSel</b></span>
<span class="italic-text"><i>(</i></span>
<div class="paragraph">
<span class="paragraph"><img src="../images/horSpace24px.svg"/><span class="inline-text">const </span>
<span class="bold-text"><b>uint8_t</b></span>
<span class="inline-text"> &</span>
<span class="inline-text">selection</span>
</span>
</div>
<span class="italic-text"><i>)</i></span>
<a id="references"></a>
<h4>References</h4>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="classHack_1_1Chips_1_1Chip.md#applybit">applyBit</a>
</span>
</div>
<div class="paragraph">
<span class="paragraph"><img src="../images/class.svg"/><a href="classHack_1_1Chips_1_1Chip.md#setbit">setBit</a>
</span>
</div>
<a id="defined-in"></a>
<h4>Defined in</h4>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.h#L54" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.h</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="https://github.com/CharlesCarley/HackComputer/blob/master/Source/Chips/Mux8Way16.cpp#L87" class="icon-list-item"><img src="../images/file.svg" class="icon-list-item"/><span class="icon-list-item">Mux8Way16.cpp</span>
</a>
</span>
<br/>
<span class="icon-list-item"><a href="#mux8way16" class="icon-list-item"><img src="../images/jumpToTop.svg" class="icon-list-item"/><span class="icon-list-item">top</span>
</a>
</span>
<br/>
</div>
</div>
</body>
</html>
| 43.355641 | 255 | 0.680221 | yue_Hant | 0.58083 |
47316810b23910afd66a47097b8700e588dd7e4a | 1,532 | md | Markdown | clinical-learning/IABP/What is IABP.md | BevalZ/Medical-notes | e550e9700f789c292805205c99adfd0af8c6818e | [
"MIT"
] | null | null | null | clinical-learning/IABP/What is IABP.md | BevalZ/Medical-notes | e550e9700f789c292805205c99adfd0af8c6818e | [
"MIT"
] | null | null | null | clinical-learning/IABP/What is IABP.md | BevalZ/Medical-notes | e550e9700f789c292805205c99adfd0af8c6818e | [
"MIT"
] | null | null | null | # [Intra-aortic Ballon Pump](https://en.wikipedia.org/wiki/Intra-aortic_balloon_pump)
```
Increase cardiac output --> Increase coronary blood flow --> Increase myocadial oxygen perfusion
```
pproximately 2 centimeters (0.79 in)
## Mechanism
### Actively deflates in systole
Increasing forward blood flow by reducing afterload through a vacuum effect.
### Actively inflates in diastole
Increasing blood flow to the coronary arteries via retrograde flow.
## Indications
- Cardiogenic shock(心源性休克)
- Reversible intracardial mechanical defects complicating infarction（反流性心脏缺陷合并梗死，如二尖瓣反流、室间隔穿孔）
- unstable angina pectoris（不稳定性心绞痛）
- post cardiothoracic surgery（心胸手术术后，最常用于心肺搭桥手术）
- Preoperative use is suggested for high-risk patients such as those with unstable angina with stenosis greater than 70% of main coronary artery, in ventricular dysfunction with an ejection fraction less than 35%.
- Percutaneous coronary angioplasty
- In high risk coronary artery bypass graft surgery where cardiopulmonary bypass time was shortened, as well as during intubation period and hospital stay.
- Thrombolytic therapy of acute myocardial infarction
## contraindication
### absolute contraindication
- Sever aortic valve insufficienty
- Aortic dissection
- Severe aortoiliac occlusive disease and bilateral carotid stenosis
### relative contraindication
- Prosthetic vascular grafts in the aorta
- Aortic aneurysm
- Aortofemoral grafts
- Sepsis
| 33.304348 | 213 | 0.804178 | eng_Latn | 0.953524 |
473180136d88f7c9699890d96c1f5d757c9de791 | 185 | md | Markdown | docs/src/index.md | DomagojGalic/MyExample | 5420e1153fbeb84d22f7e2ff5779b91881bcbe3d | [
"MIT"
] | null | null | null | docs/src/index.md | DomagojGalic/MyExample | 5420e1153fbeb84d22f7e2ff5779b91881bcbe3d | [
"MIT"
] | 1 | 2021-04-29T04:43:06.000Z | 2021-04-29T04:53:20.000Z | docs/src/index.md | DomagojGalic/MyExample | 5420e1153fbeb84d22f7e2ff5779b91881bcbe3d | [
"MIT"
] | null | null | null | ```@meta
CurrentModule = MyExample
```
# MyExample
Documentation for [MyExample](https://github.com/DomagojGalic/MyExample.jl).
```@index
```
```@autodocs
Modules = [MyExample]
```
| 12.333333 | 76 | 0.681081 | eng_Latn | 0.278097 |
4731bb6e0b136ca455319a8f4064570a775fa0b8 | 1,127 | md | Markdown | docs/manual.md | singleron-RD/AccuraCode | 5bf3832a7cb0dfbab298b7406de734e062417e5d | [
"MIT"
] | 2 | 2021-11-17T06:55:36.000Z | 2022-02-21T03:10:55.000Z | docs/manual.md | singleron-RD/AccuraCode | 5bf3832a7cb0dfbab298b7406de734e062417e5d | [
"MIT"
] | null | null | null | docs/manual.md | singleron-RD/AccuraCode | 5bf3832a7cb0dfbab298b7406de734e062417e5d | [
"MIT"
] | 2 | 2022-02-14T06:41:19.000Z | 2022-03-15T14:21:50.000Z | ## Introduction
AccuraCode is a bioinfomatics analysis pipeline developed at Singleron to AccuraCode sequencing data generated with Singleron products. These pipelines take paired-end FASTQ files as input and generate output files which can be used for downstream data analysis.
Each pipeline consists of several steps and they all have two identical pre-processing steps: `barcode` and `cutadapt`. `barcode`step is used for barcode demupltiplexing, correction and read filtering. `cutadapt`step calls [Cutadapt](https://cutadapt.readthedocs.io/en/stable/) for read trimming.
Currently, AccuraCode includes the follwing pipelines:
- `accuracode accura` for Multi samples RNA-seq data generated with AccuraCode kits. It performs preprocessing, genome alignment, feature counting, expression matrix generation.
## [Quick start](quick_start.md)
## [Change log](CHANGELOG.md)
## Pre-processing
- [barcode](tools/barcode.md)
- [cutadapt](tools/cutadapt.md)
## accura
- [mkref](accura/mkref.md)
- [star](accura/star.md)
- [featureCounts](tools/featureCounts.md)
- [count](tools/count.md)
- [multi_rna](accura/multi_rna.md)
| 41.740741 | 296 | 0.783496 | eng_Latn | 0.935506 |
4731c44a146a4817a3fa6daed874bd10bacf3119 | 11,780 | md | Markdown | translations_exported/ru/docs_exported/crafttweaker/docs/vanilla/api/BracketHandlers.md | GregTechCEu/CraftTweaker-Documentation | c2c98f81dd5f9b089c695bee5ac2547831c19818 | [
"MIT"
] | 1 | 2022-01-16T03:07:14.000Z | 2022-01-16T03:07:14.000Z | translations_exported/ru/docs_exported/crafttweaker/docs/vanilla/api/BracketHandlers.md | friendlyhj/CraftTweaker-Documentation | 520fee16271b669722b47a7604a2187ac403c641 | [
"MIT"
] | null | null | null | translations_exported/ru/docs_exported/crafttweaker/docs/vanilla/api/BracketHandlers.md | friendlyhj/CraftTweaker-Documentation | 520fee16271b669722b47a7604a2187ac403c641 | [
"MIT"
] | null | null | null | # BracketHandlers
This class contains the "simple" Bracket handlers from CraftTweaker. However, some Bracket handlers, like for recipeTypes, tags, tagManagers, won't be shown here as they use a different internal structure.
## Импорт класса
It might be required for you to import the package if you encounter any issues (like casting an Array), so better be safe than sorry and add the import at the very top of the file.
```zenscript
import crafttweaker.api.BracketHandlers;
```
## Static Methods
:::group{name=getAttribute}
Return Type: [Attribute](/vanilla/api/entity/Attribute)
```zenscript
BracketHandlers.getAttribute(tokens as string) as Attribute
```
| Параметр | Тип | Description |
| -------- | ------ | ----------------------- |
| tokens | string | No Description Provided |
:::
:::group{name=getBiome}
Gets a Biome based on the tokens. <br /> Throws an error if it can't get the biome
Returns: The found biome
Return Type: [MCBiome](/vanilla/api/world/MCBiome)
```zenscript
<biome:minecraft:plain>
// BracketHandlers.getBiome(tokens as string) as MCBiome
BracketHandlers.getBiome("minecraft:plain");
```
| Параметр | Тип | Description |
| -------- | ------ | ----------------------------- |
| tokens | string | The biome's resource location |
:::
:::group{name=getBlock}
Gets the give [MCBlock](/vanilla/api/block/MCBlock). Throws an Exception if not found
Returns: The found [MCBlock](/vanilla/api/block/MCBlock)
Return Type: [MCBlock](/vanilla/api/block/MCBlock)
```zenscript
<block:minecraft:dirt>
// BracketHandlers.getBlock(tokens as string) as MCBlock
BracketHandlers.getBlock("minecraft:dirt");
```
| Параметр | Тип | Description |
| -------- | ------ | ---------------------------------------- |
| tokens | string | То, что вы можете написать в BEP вызове. |
:::
:::group{name=getBlockMaterial}
Gets the given [MCMaterial](/vanilla/api/block/material/MCMaterial). Throws an Exception if not found.
Returns: The found [MCMaterial](/vanilla/api/block/material/MCMaterial)
Return Type: [MCMaterial](/vanilla/api/block/material/MCMaterial)
```zenscript
<blockmaterial:earth>
// BracketHandlers.getBlockMaterial(tokens as string) as MCMaterial
BracketHandlers.getBlockMaterial("earth");
```
| Параметр | Тип | Description |
| -------- | ------ | ---------------------------------------- |
| tokens | string | То, что вы можете написать в BEP вызове. |
:::
:::group{name=getBlockState}
Creates a Blockstate based on the given inputs. <br /> Returns `null` if it cannot find the block, ignored invalid variants
Returns: The found BlockState
Return Type: [MCBlockState](/vanilla/api/block/MCBlockState)
```zenscript
<blockstate:minecraft:acacia_planks>
<blockstate:minecraft:furnace:facing=north,lit=false>
// BracketHandlers.getBlockState(tokens as string) as MCBlockState
BracketHandlers.getBlockState("minecraft:acacia_planks");
BracketHandlers.getBlockState("minecraft:furnace:facing=north,lit=false");
```
| Параметр | Тип | Description |
| -------- | ------ | ------------------------------------------ |
| tokens | string | The block's resource location and variants |
:::
:::group{name=getDamageSource}
Gets a damage source based on type. <br /> If the damage source is not pre-registered, it will create a new one with the given name
Returns: The found pre-registered damage source or a new one
Return Type: [DamageSource](/vanilla/api/util/DamageSource)
```zenscript
<damagesource:magic>
// BracketHandlers.getDamageSource(tokens as string) as DamageSource
BracketHandlers.getDamageSource("magic");
```
| Параметр | Тип | Description |
| -------- | ------ | ------------------------ |
| tokens | string | the damage sources' type |
:::
:::group{name=getDirectionAxis}
Gets the direction Axis based on name. Throws an error if it can't find the direction Axis.
Returns: The found direction Axis
Return Type: [DirectionAxis](/vanilla/api/util/DirectionAxis)
```zenscript
<directionaxis:x>
// BracketHandlers.getDirectionAxis(tokens as string) as DirectionAxis
BracketHandlers.getDirectionAxis("x");
```
| Параметр | Тип | Description |
| -------- | ------ | -------------------------------------- |
| tokens | string | The direction Axis's resource location |
:::
:::group{name=getEffect}
Gets the effect based on registry name. Throws an error if it can't find the effect.
Returns: The found effect
Return Type: [MCPotionEffect](/vanilla/api/potions/MCPotionEffect)
```zenscript
<effect:minecraft:haste>
// BracketHandlers.getEffect(tokens as string) as MCPotionEffect
BracketHandlers.getEffect("minecraft:haste");
```
| Параметр | Тип | Description |
| -------- | ------ | ------------------------------ |
| tokens | string | The effect's resource location |
:::
:::group{name=getEnchantment}
Gets the enchantment based on registry name. Throws an error if it can't find the enchantment.
Returns: The found enchantment
Return Type: [MCEnchantment](/vanilla/api/enchantment/MCEnchantment)
```zenscript
<enchantment:minecraft:riptide>
// BracketHandlers.getEnchantment(tokens as string) as MCEnchantment
BracketHandlers.getEnchantment("minecraft:riptide");
```
| Параметр | Тип | Description |
| -------- | ------ | ------------------------------- |
| tokens | string | The enchantment's registry name |
:::
:::group{name=getEntityClassification}
Gets the entityClassification based on registry name. Logs an error and returns `null` if it can't find the entityClassification.
Returns: The found entityClassification
Return Type: [MCEntityClassification](/vanilla/api/entity/MCEntityClassification)
```zenscript
<entityclassification:monster>
// BracketHandlers.getEntityClassification(tokens as string) as MCEntityClassification
BracketHandlers.getEntityClassification("monster");
```
| Параметр | Тип | Description |
| -------- | ------ | -------------------------------------------- |
| tokens | string | The entityClassification's resource location |
:::
:::group{name=getEntityType}
Gets the entityType based on registry name. Throws an exception if it can't find the entityType.
Returns: The found entityType
Return Type: [MCEntityType](/vanilla/api/entities/MCEntityType)
```zenscript
<entitytype:minecraft:pig>
// BracketHandlers.getEntityType(tokens as string) as MCEntityType
BracketHandlers.getEntityType("minecraft:pig");
```
| Параметр | Тип | Description |
| -------- | ------ | ---------------------------------- |
| tokens | string | The entityType's resource location |
:::
:::group{name=getEquipmentSlotType}
Gets the equipment slot type based on name. Throws an error if it can't find the equipment slot type.
Returns: The found equipment slot type
Return Type: [MCEquipmentSlotType](/vanilla/api/util/MCEquipmentSlotType)
```zenscript
<equipmentslottype:mainhand>
// BracketHandlers.getEquipmentSlotType(tokens as string) as MCEquipmentSlotType
BracketHandlers.getEquipmentSlotType("mainhand");
```
| Параметр | Тип | Description |
| -------- | ------ | ------------------------------ |
| tokens | string | The equipment slot type's name |
:::
:::group{name=getFluidStack}
Gets the fluid Stack based on registry name. Throws an error if it can't find the fluid.
Returns: A stack of the liquid with amount == 1mb
Return Type: [IFluidStack](/vanilla/api/fluid/IFluidStack)
```zenscript
<fluid:minecraft:water>
// BracketHandlers.getFluidStack(tokens as string) as IFluidStack
BracketHandlers.getFluidStack("minecraft:water");
```
| Параметр | Тип | Description |
| -------- | ------ | ----------------------------- |
| tokens | string | The Fluid's resource location |
:::
:::group{name=getItem}
Gets the item based on registry name. Throws an error if it can't find the item.
Returns: The found item
Return Type: [IItemStack](/vanilla/api/items/IItemStack)
```zenscript
<item:minecraft:dirt>
// BracketHandlers.getItem(tokens as string) as IItemStack
BracketHandlers.getItem("minecraft:dirt");
```
| Параметр | Тип | Description |
| -------- | ------ | ---------------------------- |
| tokens | string | The item's resource location |
:::
:::group{name=getPotion}
Return Type: [MCPotion](/vanilla/api/potions/MCPotion)
```zenscript
BracketHandlers.getPotion(tokens as string) as MCPotion
```
| Параметр | Тип | Description |
| -------- | ------ | ----------------------- |
| tokens | string | No Description Provided |
:::
:::group{name=getProfession}
Gets the villager profession based on registry name. Throws an exception if it can't find the profession.
Returns: The found profession
Return Type: [MCVillagerProfession](/vanilla/api/villager/MCVillagerProfession)
```zenscript
<profession:minecraft:armorer>
// BracketHandlers.getProfession(tokens as string) as MCVillagerProfession
BracketHandlers.getProfession("minecraft:armorer");
```
| Параметр | Тип | Description |
| -------- | ------ | ---------------------------------- |
| tokens | string | The profession's resource location |
:::
:::group{name=getRecipeManager}
Gets the recipeManager based on registry name. Throws an error if it can't find the recipeManager. <br /> Throws an exception if the given recipeType is not found. <br /> <br /> This will always return IRecipeManager.<br> <br /> There is also a BEP for that but that works differently so it can't be automatically added to the docs here. <br /> But the BEP looks the same as the other ones: `<recipetype:minecraft:crafting>`
Returns: The found recipeManager
Return Type: [IRecipeManager](/vanilla/api/managers/IRecipeManager)
```zenscript
// BracketHandlers.getRecipeManager(tokens as string) as IRecipeManager
BracketHandlers.getRecipeManager("minecraft:crafting");
```
| Параметр | Тип | Description |
| -------- | ------ | ------------------------------------- |
| tokens | string | The recipeManager's resource location |
:::
:::group{name=getResourceLocation}
Creates a Resource location based on the tokens. <br /> Throws an error if the tokens are not a valid location.
Returns: The location
Return Type: [MCResourceLocation](/vanilla/api/util/MCResourceLocation)
```zenscript
<resource:minecraft:dirt>
// BracketHandlers.getResourceLocation(tokens as string) as MCResourceLocation
BracketHandlers.getResourceLocation("minecraft:dirt");
```
| Параметр | Тип | Description |
| -------- | ------ | --------------------- |
| tokens | string | The resource location |
:::
:::group{name=getTextFormatting}
Return Type: [TextFormatting](/vanilla/api/util/text/TextFormatting)
```zenscript
BracketHandlers.getTextFormatting(tokens as string) as TextFormatting
```
| Параметр | Тип | Description |
| -------- | ------ | ----------------------- |
| tokens | string | No Description Provided |
:::
:::group{name=getToolType}
Gets a tool type by name. <br /> If the tool type doesn't exist yet, this will create a new one with the given name
Returns: The found tool type or a new one
Return Type: [ToolType](/vanilla/api/tool/ToolType)
```zenscript
<tooltype:shovel>
// BracketHandlers.getToolType(tokens as string) as ToolType
BracketHandlers.getToolType("shovel");
```
| Параметр | Тип | Description |
| -------- | ------ | -------------------- |
| tokens | string | the tool type's name |
:::
| 27.142857 | 430 | 0.650255 | eng_Latn | 0.61741 |
473219660903c4aaa31e72ad9d18c730afa2a4a9 | 2,995 | md | Markdown | notes/testing-library.md | Uvacoder/abcnotez4-code | 6e6475368219ac8e6f002ffce2a0dd496ddc7ec4 | [
"MIT"
] | 46 | 2020-03-09T13:28:15.000Z | 2021-11-08T08:46:58.000Z | notes/testing-library.md | Uvacoder/abcnotez4-code | 6e6475368219ac8e6f002ffce2a0dd496ddc7ec4 | [
"MIT"
] | 9 | 2021-09-14T18:16:56.000Z | 2022-02-27T18:16:44.000Z | notes/testing-library.md | Uvacoder/abcnotez4-code | 6e6475368219ac8e6f002ffce2a0dd496ddc7ec4 | [
"MIT"
] | 20 | 2020-05-28T16:23:39.000Z | 2021-06-27T18:23:48.000Z | ---
title: Testing library
tags:
- testing
emoji: 🧪
link: 'https://testing-library.com'
created: 2020-03-25T17:00:14.000Z
modified: 2020-05-11T11:47:16.000Z
---
## DOM
https://testing-library.com/docs/dom-testing-library/intro
### Queries
https://testing-library.com/docs/dom-testing-library/api-queries
#### Variants
##### getBy
`getBy*` queries return the first matching node for a query, and throw an error
if no elements match or if more than one match is found (use `getAllBy`
instead).
##### getAllBy
`getAllBy*` queries return an array of all matching nodes for a query, and throw
an error if no elements match.
##### queryBy
`queryBy*` queries return the first matching node for a query, and return `null`
if no elements match. This is useful for asserting an element that is not
present. This throws if more than one match is found (use `queryAllBy` instead).
##### queryAllBy
`queryAllBy*` queries return an array of all matching nodes for a query, and
return an empty array (`[]`) if no elements match.
##### findBy
`findBy*` queries return a promise which resolves when an element is found which
matches the given query. The promise is rejected if no element is found or if
more than one element is found after a default timeout of `4500`ms. If you need
to find more than one element, then use `findAllBy`.
> Note, this is a simple combination of `getBy*` queries and
> [`waitForElement`](/docs/api-async#waitforelement). The `findBy*` queries
> accept the `waitForElement` options as the last argument. (i.e.
> `findByText(container, 'text', queryOptions, waitForElementOptions)`)
##### findAllBy
`findAllBy*` queries return a promise which resolves to an array of elements
when any elements are found which match the given query. The promise is rejected
if no elements are found after a default timeout of `4500`ms.
## React
https://testing-library.com/docs/react-testing-library/intro
```js
import React from 'react'
import { render, fireEvent } from '@testing-library/react'
import { Button } from './Button'
describe('Given a Button component', () => {
describe('when it is rendered', () => {
test('should have the text `This is a button`', () => {
// Arrange
const { getByText } = render(<Button>This is a button</Button>)
// Act
fireEvent.click(getByText('This is a button'))
// Assert
expect(getByText('This is a button')).toHaveTextContent(
'This is a button'
)
})
})
})
```
## Cypress
https://testing-library.com/docs/cypress-testing-library/intro
```js
cy.findAllByText('Jackie Chan').click()
cy.findByText('Button Text').should('exist')
cy.findByText('Non-existing Button Text').should('not.exist')
cy.findByLabelText('Label text', { timeout: 7000 }).should('exist')
// findAllByText _inside_ a form element
cy.get('form').findByText('Button Text').should('exist')
cy.get('form').then((subject) => {
cy.findByText('Button Text', { container: subject }).should('exist')
})
```
| 28.52381 | 80 | 0.709182 | eng_Latn | 0.948971 |
47322544e2c14c8f7de5f7c397cc135377440ba1 | 14 | md | Markdown | _includes/04-lists.md | vilijajoyce/markdown-portfolio | 0642a1120094270ee84644bc5bd942c8a9c6f050 | [
"MIT"
] | null | null | null | _includes/04-lists.md | vilijajoyce/markdown-portfolio | 0642a1120094270ee84644bc5bd942c8a9c6f050 | [
"MIT"
] | 5 | 2021-07-22T18:51:18.000Z | 2021-07-22T19:13:31.000Z | _includes/04-lists.md | vilijajoyce/markdown-portfolio | 0642a1120094270ee84644bc5bd942c8a9c6f050 | [
"MIT"
] | null | null | null | * cats
* dogs
| 4.666667 | 6 | 0.571429 | eng_Latn | 0.977129 |
473236ec1bfe0f71a0d4ad4d9cfb4e20dfc0782b | 663 | md | Markdown | indigo_drivers/mount_pmc8/README.md | polakovic/indigo | 177cb9cd02cff2f7193df653e7ff5ea9ea3e7093 | [
"RSA-MD"
] | null | null | null | indigo_drivers/mount_pmc8/README.md | polakovic/indigo | 177cb9cd02cff2f7193df653e7ff5ea9ea3e7093 | [
"RSA-MD"
] | 1 | 2022-03-09T08:57:08.000Z | 2022-03-09T08:57:08.000Z | indigo_drivers/mount_pmc8/README.md | polakovic/indigo | 177cb9cd02cff2f7193df653e7ff5ea9ea3e7093 | [
"RSA-MD"
] | null | null | null | # PMC Eight mount driver
## Supported devices
* ExploreScientific iEXOS-100, iEXOS-300 and EXOS2-GT,
* Losmandy G11 and Titan with PMC Eight controller
Connection over serial port, UDP and TCP.
Single device is present on the first startup (no hot-plug support). Additional devices can be configured on runtime.
## Supported platforms
This driver is platform independent
## License
INDIGO Astronomy open-source license.
## Use
indigo_server indigo_mount_pmc8
## Comments
Use URL in form tcp://host:port or udp://host:port to connect to the mount over network (default port is 54372).
## Status: Stable
Driver is developed and tested with iEXOS-100
| 21.387097 | 117 | 0.769231 | eng_Latn | 0.986991 |
47344cbc481b0aa12f32b411a12e029e2a722bee | 790 | md | Markdown | docs/framework/wcf/diagnostics/etw/707-httpsendstop.md | adamsitnik/docs.cs-cz | 7c534ad2e48aa0772412dc0ecf04945c08fa4211 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/framework/wcf/diagnostics/etw/707-httpsendstop.md | adamsitnik/docs.cs-cz | 7c534ad2e48aa0772412dc0ecf04945c08fa4211 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/framework/wcf/diagnostics/etw/707-httpsendstop.md | adamsitnik/docs.cs-cz | 7c534ad2e48aa0772412dc0ecf04945c08fa4211 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: 707 – HttpSendStop
ms.date: 03/30/2017
ms.assetid: 5c8a607a-be7a-4e36-a885-67746f03cae6
ms.openlocfilehash: b24d5284b3812efd37d6958fb328a9613c30cc56
ms.sourcegitcommit: 9b552addadfb57fab0b9e7852ed4f1f1b8a42f8e
ms.translationtype: MT
ms.contentlocale: cs-CZ
ms.lasthandoff: 04/23/2019
ms.locfileid: "61953007"
---
# <a name="707---httpsendstop"></a>707 – HttpSendStop
## <a name="properties"></a>Vlastnosti
|||
|-|-|
|ID|707|
|klíčová slova|HTTP|
|úroveň|Podrobnosti|
|Kanál|Aplikace Microsoft Windows Server – aplikace/Debug|
## <a name="description"></a>Popis
Tato událost je vygenerován při odeslání požadavku Http je zastavená.
## <a name="message"></a>Zpráva
Byl ukončen požadavek Send protokolu HTTP.
## <a name="details"></a>Podrobnosti
| 27.241379 | 72 | 0.727848 | ces_Latn | 0.69915 |
473462e07b6d4133bc90a4d421c14b3e2b9323c5 | 229 | md | Markdown | README.md | Anne898/Profesiones | 0ff89c1b38441bc62e5d20d0a6cd63c1d3f92ee5 | [
"MIT"
] | 1 | 2020-02-26T18:31:31.000Z | 2020-02-26T18:31:31.000Z | README.md | Anne898/Profesiones | 0ff89c1b38441bc62e5d20d0a6cd63c1d3f92ee5 | [
"MIT"
] | null | null | null | README.md | Anne898/Profesiones | 0ff89c1b38441bc62e5d20d0a6cd63c1d3f92ee5 | [
"MIT"
] | null | null | null | # Profesiones
Crear una estructura de clases para representar personas con nombre, apellido y profesión. Cada persona puede decir su nombre, su apellido y su profesión. - Crear (3) personas distintas con profesiones distintas.
| 76.333333 | 214 | 0.803493 | spa_Latn | 0.999729 |
473469bc7afb06033fe1ea505a4fbca603c0c417 | 619 | md | Markdown | README.md | Koenkk/Phalcon-Uploader | 60ab490537960d6c98fd8113273fe5e586936dc8 | [
"MIT"
] | null | null | null | README.md | Koenkk/Phalcon-Uploader | 60ab490537960d6c98fd8113273fe5e586936dc8 | [
"MIT"
] | null | null | null | README.md | Koenkk/Phalcon-Uploader | 60ab490537960d6c98fd8113273fe5e586936dc8 | [
"MIT"
] | null | null | null | # Phalcon-Uploader
File upload handler for the Phalcon Framework.
## Introduction
This package provides a file upload service.
You can use it as follows:
```php
// Assuming uploader is registered in dependency injector.
$this->uploader->add("file", [
"name" => "path/and/name/of/file.ext",
"required" => false,
]);
$result = $this->uploader->save();
if ($result) {
print_r($result);
}
```
## Requirements
* PHP 7.2 or later.
* Phalcon Framework 4.0 or later.
## Installation
Install this dependency using `composer require basilfx/phalcon-uploader`.
## License
See the `LICENSE` file (MIT license).
| 19.34375 | 74 | 0.696284 | eng_Latn | 0.837485 |
4734b54201d36ece6089aede796aa4b114c1ef00 | 271 | md | Markdown | src/Swap_Nodes_in_Pairs/Readme.md | lizij/Leetcode | ee97d6bffcef43947701e6a9883be9672ee92a73 | [
"Unlicense"
] | 1 | 2018-04-17T13:49:41.000Z | 2018-04-17T13:49:41.000Z | src/Swap_Nodes_in_Pairs/Readme.md | lizij/Leetcode | ee97d6bffcef43947701e6a9883be9672ee92a73 | [
"Unlicense"
] | null | null | null | src/Swap_Nodes_in_Pairs/Readme.md | lizij/Leetcode | ee97d6bffcef43947701e6a9883be9672ee92a73 | [
"Unlicense"
] | null | null | null | Given a linked list, swap every two adjacent nodes and return its head.
For example,
Given 1->2->3->4, you should return the list as 2->1->4->3.
Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed. | 38.714286 | 123 | 0.749077 | eng_Latn | 0.999659 |
47357be20ca2dddc02ea0de4b1474cbcab344ab6 | 28 | md | Markdown | README.md | NildoQs/teste | 99c7ae8607c825f97241826fe03f56a780d8f8e6 | [
"MIT"
] | null | null | null | README.md | NildoQs/teste | 99c7ae8607c825f97241826fe03f56a780d8f8e6 | [
"MIT"
] | null | null | null | README.md | NildoQs/teste | 99c7ae8607c825f97241826fe03f56a780d8f8e6 | [
"MIT"
] | null | null | null | # Meu repositório de testes
| 14 | 27 | 0.785714 | por_Latn | 0.999951 |
473622b9a3adf2673cb7a0f39284f527142991a8 | 2,024 | md | Markdown | _posts/4/2021-04-06-tim-armstrong.md | chito365/ukdat | 382c0628a4a8bed0f504f6414496281daf78f2d8 | [
"MIT"
] | null | null | null | _posts/4/2021-04-06-tim-armstrong.md | chito365/ukdat | 382c0628a4a8bed0f504f6414496281daf78f2d8 | [
"MIT"
] | null | null | null | _posts/4/2021-04-06-tim-armstrong.md | chito365/ukdat | 382c0628a4a8bed0f504f6414496281daf78f2d8 | [
"MIT"
] | null | null | null | ---
id: 3113
title: Tim Armstrong
date: 2021-04-06T02:48:35+00:00
author: Laima
layout: post
guid: https://ukdataservers.com/tim-armstrong/
permalink: /04/06/tim-armstrong
tags:
- Is Married?
- Is Single?
- Relationships
category: Family Guides
---
* some text
{: toc}
## Who is Tim Armstrong
Grammy Award-winning punk and ska guitarist with the bands Rancid and Transplants. His first well-known band was Operation Ivy, in which he was known as Lint.
## Prior to Popularity
He was in a short-lived band called Basic Radio.
## Random data
He started doing stripped down versions of songs and releasing them on his website under the name Tim Timebomb.
## Family & Everyday Life of Tim Armstrong
His father, Don Armstrong, died in 2012; he has dedicated numerous songs to him. He married Brody Dalle in 1997 and they divorced in 2003.
## People Related With Tim Armstrong
He has been longtime friends with Green Day frontman Billie Joe Armstrong, whom he also shares the same last name with.
| 21.763441 | 158 | 0.376976 | eng_Latn | 0.998719 |
4737954bdf40c6231bf91874e78e14e06ddb7e73 | 1,262 | md | Markdown | business-central/admin-feature-management.md | AleksanderGladkov/dynamics365smb-docs | f061beeb61260d6b78df86334a7a8c50be2bb8d4 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | business-central/admin-feature-management.md | AleksanderGladkov/dynamics365smb-docs | f061beeb61260d6b78df86334a7a8c50be2bb8d4 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | business-central/admin-feature-management.md | AleksanderGladkov/dynamics365smb-docs | f061beeb61260d6b78df86334a7a8c50be2bb8d4 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: Enabling upcoming features ahead of time
description: Learn how to enable select, optional features before they become mandatory.
author: mikebcMSFT
ms.service: dynamics365-business-central
ms.topic: article
ms.search.keywords: administration, admin, key, optional, feature management, early access, preview
ms.date: 10/01/2020
ms.author: mikebc
---
# Enabling Upcoming Features Ahead of Time
Some new features can be enabled ahead of time, letting you take advantage of them as early as possible. Enabling features early gives you the time to test and prepare your organization for change.
When Microsoft releases features or feature design improvements as part of minor updates, some of the features aren't immediately enabled. Administrators can enable each feature from the **Feature Management** page. After a feature is enabled, it becomes available for all users on that environment no matter how they access [!INCLUDE[prodshort](includes/prodshort.md)]. Features can be safely turned off again. These features are only optional for a while.
Learn more about [Feature Management](/dynamics365/business-central/dev-itpro/administration/feature-management).
## See also
[New and planned features](https://aka.ms/Dynamics365ReleasePlan)
| 54.869565 | 457 | 0.801902 | eng_Latn | 0.996784 |
4737b294543c42a160e1b8d08740f6e0b1cd513f | 1,979 | md | Markdown | Skype/SfbServer/schema-reference/call-detail-recording-cdr-database-schema/dialogs.md | GiantCrocodile/OfficeDocs-SkypeForBusiness.de-DE | 78f0bf23e8587090de05a337cb8a3700a0ce9036 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | Skype/SfbServer/schema-reference/call-detail-recording-cdr-database-schema/dialogs.md | GiantCrocodile/OfficeDocs-SkypeForBusiness.de-DE | 78f0bf23e8587090de05a337cb8a3700a0ce9036 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | Skype/SfbServer/schema-reference/call-detail-recording-cdr-database-schema/dialogs.md | GiantCrocodile/OfficeDocs-SkypeForBusiness.de-DE | 78f0bf23e8587090de05a337cb8a3700a0ce9036 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: Tabelle "Dialogfelder" in Skype for Business Server 2015
ms.reviewer: ''
ms.author: v-lanac
author: lanachin
manager: serdars
ms.date: 3/9/2015
audience: ITPro
ms.topic: article
ms.prod: skype-for-business-itpro
f1.keywords:
- NOCSH
localization_priority: Normal
ms.assetid: 487a430b-af66-4ea6-b28e-4e33cfdb7f9e
description: Die Tabelle Dialogfelder ist eine unterstützende Tabelle, in der die Informationen zu DialogIDs für Peer-to-Peer-Sitzungen gespeichert werden.
ms.openlocfilehash: f6cfc3e078ee8f4492d6f5baf65f66df77d7aedf
ms.sourcegitcommit: e64c50818cac37f3d6f0f96d0d4ff0f4bba24aef
ms.translationtype: MT
ms.contentlocale: de-DE
ms.lasthandoff: 02/06/2020
ms.locfileid: "41815273"
---
# <a name="dialogs-table-in-skype-for-business-server-2015"></a>Tabelle "Dialogfelder" in Skype for Business Server 2015
Die Tabelle Dialogfelder ist eine unterstützende Tabelle, in der die Informationen zu DialogIDs für Peer-to-Peer-Sitzungen gespeichert werden.
|**Spalte**|**Datentyp**|**Schlüssel/Index**|**Details**|
|:-----|:-----|:-----|:-----|
|**SessionID** <br/> |datetime <br/> |Primary <br/> |Uhrzeit der Sitzungsanforderung; wird in Verbindung mit SessionIDSeq verwendet, um eine Sitzung eindeutig zu identifizieren. <br/> |
|**SessionIdSeq** <br/> |int <br/> |Primary <br/> |Die ID-Nummer, um die Sitzung zu identifizieren. Wird in Verbindung mit SessionID-Mal verwendet, um eine Sitzung eindeutig zu identifizieren. <br/> |
|**ExternalChecksum** <br/> |int <br/> | <br/> |Prüfsumme der externen-Nr. Dieses Feld wird verwendet, um die Geschwindigkeit von Datenbanksuchen zu erhöhen. <br/> |
|**ExternalId** <br/> |varbinary (775) <br/> | <br/> |SIP-Dialogfeld-ID, als Binärdatei gespeichert. Das Format der Binärdatei lautet wie folgt: <br/> Dialogfeld; from-Tag; to-Tag <br/> Diese Daten können mithilfe der folgenden Syntax in das Text Format konvertiert werden: <br/> `cast(cast(ExternalId as varbinary(max)) as varchar(max))` <br/> |
| 56.542857 | 351 | 0.748863 | deu_Latn | 0.866735 |
47385d726ba37b75a47bc09ba8ef03c3fe339e3b | 2,471 | md | Markdown | docker/images/dev-docker/README.md | SolarBankers/Solar-Bankers-Coin | a7c6652020de0267ca4eacd8fbc97687a58ef372 | [
"MIT"
] | 4 | 2018-09-16T03:01:21.000Z | 2019-10-31T13:34:06.000Z | docker/images/dev-docker/README.md | SolarBankers/Solar-Bankers-Coin | a7c6652020de0267ca4eacd8fbc97687a58ef372 | [
"MIT"
] | null | null | null | docker/images/dev-docker/README.md | SolarBankers/Solar-Bankers-Coin | a7c6652020de0267ca4eacd8fbc97687a58ef372 | [
"MIT"
] | 1 | 2018-12-13T22:20:04.000Z | 2018-12-13T22:20:04.000Z | # Supported tags and respective `Dockerfile` links
## Simple Tags
- [`dind` (*docker/images/devdocker/Dockerfile*)](https://github.com/skycoin/skycoin/tree/develop/docker/images/devdocker/Dockerfile)
# Skycoin development image including [docker in docker](https://hub.docker.com/_/docker/)
This image has the necessary tools to build, test, edit, lint and version the Skycoin
source code. It comes with the Vim editor installed, along with some plugins
to ease go development and version control with git, besides it comes with docker installed.
# How to use this image
## Initialize your development environment.
```sh
$ mkdir src
$ docker run --privileged --rm \
-v src:/go/src skycoin/skycoindev-cli:dind \
go get github.com/skycoin/skycoin
$ sudo chown -R `whoami` src
```
This downloads the skycoin source to src/skycoin/skycoin and changes the owner
to your user. This is necessary, because all processes inside the container run
as root and the files created by it are therefore owned by root.
If you already have a Go development environment installed, you just need to
mount the src directory from your $GOPATH in the /go/src volume of the
container.
## Running commands inside the container
You can run commands by just passing them to the image. Everything is run
in a container and deleted when finished.
### Running tests
```sh
$ docker run --rm \
-v src:/go/src skycoin/skycoindev-cli:dind \
sh -c "cd skycoin; make test"
```
### Running lint
```sh
$ docker run --rm \
-v src:/go/src skycoin/skycoindev-cli:dind \
sh -c "cd skycoin; make lint"
```
### Editing code
```sh
$ docker run --rm \
-v src:/go/src skycoin/skycoindev-cli:dind \
vim
```
## How to use docker in docker image
### Start a daemon instance
```sh
$ docker run --privileged --name some-name -d skycoin/skycoindev-cli:dind
```
### Where to store data
Create a data directory on the host system (outside the container) and mount this to a directory visible from inside the container.
The downside is that you need to make sure that the directory exists, and that e.g. directory permissions and other security mechanisms on the host system are set up correctly.
1. Create a data directory on a suitable volume on your host system, e.g. /my/own/var-lib-docker.
2. Start your docker container like this:
```sh
$ docker run --privileged --name some-name -v /my/own/var-lib-docker:/var/lib/docker \
-d skycoin/skycoindev-cli:dind
```
| 29.070588 | 176 | 0.732902 | eng_Latn | 0.989079 |
4738f1d039c7467a15938c560c00725fd15ceaf1 | 32,906 | md | Markdown | README.md | G3F4/warsawjs-workshop-47-reactive-snake | fec634cf3a6fbc7ef7d8bd2a569f5fee3a0bdb16 | [
"MIT"
] | 2 | 2020-08-19T08:11:34.000Z | 2020-08-23T20:11:31.000Z | README.md | G3F4/warsawjs-workshop-47-reactive-snake | fec634cf3a6fbc7ef7d8bd2a569f5fee3a0bdb16 | [
"MIT"
] | null | null | null | README.md | G3F4/warsawjs-workshop-47-reactive-snake | fec634cf3a6fbc7ef7d8bd2a569f5fee3a0bdb16 | [
"MIT"
] | null | null | null | # warsawjs-workshop-47-reactive-snake
WarsawJS Workshop 47 training repo
## Opis warsztatu
Celem warsztatu jest poznanie biblioteki React.\
Warsztat skupia się wyłącznie na czysto funkcyjnym aspekcie tworzenia UI (komponenty funkcyjne i hooki).\
Poznamy następujące zagadnienia:
* hook `useState` - do obsługi stanu
* hook `useEffect` - do obsługi efektów oraz synchronizacji
* hook `useRef` - do obsługi zmiennych wartości
* hook `useContext` - do obsługi kontekstu
* hook `useCallback` - do memoizacji funckji
* hook `useMemo` - do memoizacji wartości
* hook `useLayoutEffect` - do obsługi efektów wymagających wyrenderowanych elementów HTML
* hook `useReducer` - do obsługi skomplikowanych stanów aplikacji
* pisanie własnych hooków
* kompozycja hooków
Podczas warsztatów stworzymy klasyczną grę — Snake.\
Środowiskiem będzie Node z menadżerem pakietów NPM lub Yarn (w opisach będzie wykorzystywany Yarn).
## Przygotowanie
* Zweryfikować wymagane środowisko Node
```shell script
node -v
```
przykładowy output:
```shell script
v12.16.3
```
* Przygotować repozytorium na Github\
Stworzyć nowe repozytorium o nazwie `warsawjs-workshop-47-reactive-snake`.\
Pobrać repozytorium.
## Kroki
Poniżej znajdują się opisy zadań oraz szczegółowe kroki do wykonania w ramach warsztatu.
Cały warsztat został podzielony w taki sposób, że każde zadanie to pojedyncze funkcjonalność dodana do aplikacji.
Na początku każdego rozdziału jest opis zadania oraz hooka, który należy wykorzystać podczas realizacji zadania.
Osoby czujące się na siłach pracować bardziej samodzielnie mogą korzystać jedynie z opisów, natomiast nie korzystać z kawałków kodu.
### Stworzenie aplikacji React
Pierwszym krokiem, jest stworzenie nowej aplikacji React.\
W tym celu należy wykorzystać paczkę NPM `create-react-app`.\
Przechodzimy do folderu z repozytorium i wykonujemy poniższy skrypt w terminalu.
```shell script
npx create-react-app warsawjs-workshop-47-reactive-snake
```
Wynikiem działania będzie nowy folder `warsawjs-workshop-47-reactive-snake` wewnątrz folderu z repozytorium.\
Kasujemy z niego pliki `README.md` and `.gitignore` a następnie pozostałą zawartość przenosimy do folderu repozytorium.
```shell script
mv warsawjs-workshop-47-reactive-snake/* ./ && rm -rf warsawjs-workshop-47-reactive-snake/
```
Odpalamy aplikację i weryfikujemy działanie w przeglądarce.
```shell script
yarn start
```
Kolejnym krokiem jest wyczyszczenie zawartości obecnej aplikacji przykładowej.\
W tym celu otwieramy plik `src/App.js`.\
Kasujemy zawartość `div` z klasą `App` i wstawiamy tekst `tutaj będzie gra`.\
Kod pliku powinien wyglądać jak poniżej:
```jsx
import React from 'react';
function App() {
return (
<div>
tutaj będzie gra
</div>
);
}
export default App;
```
Kasujemy plik `src/App.css`.\
Otwieramy plik `index.css` i dodajemy poniższe style do kontenera aplikacji:
```css
#root {
display: flex;
justify-content: center;
align-items: center;
height: 100vh;
}
```
Dzięki stylom powyżej zawartość aplikacji będzie wyśrodkowana w pionie i poziomie.
Na koniec weryfikujemy czy aplikacja dalej działa prawidłowo i w przeglądarce widzimy napis na środku okna.
### Wyświetlenie siatki gry
Podstawą gry będzie siatka, która będzie prezentować aktualny stan rozgrywki.\
Siatka gry będzie posiadać tyle samo kolumn co wierszy.\
Elementami siatki będą komórki, które będziemy identyfikować po współrzędnych `x` oraz `y`.
Cały kod związany z grą umieścimy w folderze `src/game`.\
Utwórz folder.
```shell script
mkdir src/game
```
Na potrzeby zaprezentowania siatki gry stworzyć komponent `GameGrid`.\
Rozpocznij od stworzenia pliku o nazwie `GameGrid.jsx`.
```shell script
touch src/game/GameGrid.jsx
```
Każdy plik z kodem JSX musi importować `React`.\
Dodaj import React na początku pliku `GameGrid.jsx`.
```js
import React from 'react';
```
Następnie w pliku stwórz domyślnie eksportowaną funkcję o nazwie `GameGrid`, która będzie naszym komponentem.\
Każdy komponent funkcyjny jako pierwszy argument otrzymuje obiekt reprezentujący propsy komponentu przekazane przez rodzica.\
Komponent `GameGrid` powinien przyjmować jeden prop: `gridSize`.\
Deklaracja powinna wyglądać jak poniżej:
```jsx
export default function GameGrid({ gridSize }) {
return <></>;
}
```
Następnie wewnątrz komponentu należy stworzyć tablicę zawierającą indeksy wierszy i komórek w wierszach.\
Poprzez indeks rozumiemy tutaj liczbę od `0` do `n`.\
Ponieważ ilość wierszy jest równa ilości komórek w wierszu, wykorzystamy tablicę z indeksami do stworzenia wierszy i komórek wewnątrz.\
Czyli po prostu chcemy stworzyć `n` elementów typu `div`, z których każdy posiada `n` dzieci.
Tablica z indeksami powinna zawierać `gridSize` elementów.\
Aby utworzyć tablicę na bazie liczby, możemy wykorzystać funkcję `Array.from`.\
Jako argument przekazujemy obiekt z jednym kluczem `length` o wartości `gridSize`.\
Wynikiem będzie tablica z pustymi elementami.\
Następnie należy przeiterować się po utworzonej tablicy i wykorzystać podczas iteracji drugi argument, który reprezentuje indeks aktualnie iterowanego elementu do wypełnienia elementów tablicy.
```js
const indexes = Array
.from({ length: gridSize })
.map((_, index) => index);
```
Po utworzeniu tablicy z indeksami możemy stworzyć zawartość siatki.\
Komponent `GameGrid` zwraca `div`, wewnątrz którego wykonujemy iterację po tablicy indeksów.\
Dla każdego indeksu tworzymy `div` z klasą `gridRow`.\
Pamiętać o nadaniu `key` dla każdego wiersza.\
Każdy wiersz zawiera komórki.\
Wewnątrz `div` reprezentującego wiersz wykonujemy jeszcze raz iterację po tablicy indeksów.\
Podczas wewnętrznej iteracji tworzymy `div` z klasą `gridCell`.\
Pamiętać o nadaniu `key` dla każdej komórki.\
Każda komórka na razie prezentuje tekst, który jest konkatenacją indeksu wiersza i komórki, połączone znakiem `x`.\
Efektem działań powinien być kod analogiczny:
```jsx
<div className="grid">
{indexes.map((x) => (
<div className="gridRow" key={x}>
{indexes.map((y) => (
<div className="gridCell" key={`${x}x${y}`}>
{`${x}x${y}`}
</div>
))}
</div>
))}
</div>
```
Komponent będzie posiadał własne style, więc obok stwórzmy też plik `GameGrid.css`.
```shell script
touch src/game/GameGrid.css
```
Następnie uzupełnij arkusz styli poniższymi stylami:
```css
.grid {
border: solid 30px darkgray;
}
.gridRow {
display: flex;
}
.gridCell {
width: 30px;
height: 30px;
background-color: azure;
}
```
Dodać import arkusza styli w pliku z komponentem.
```js
import './GameGrid.css';
```
Tak stworzony komponent możemy wykorzystać w `src/App.js`.\
Dodaj import komponentu w `src/App.js`.
```js
import GameGrid from './game/GameGrid';
```
Jednak do dziania siatka gry potrzebuje zdefiniowanego rozmiaru.\
Dodajmy stałą reprezentującą wielkość siatki w pliku `src/App.js` na poziomie całego pliku, nie wewnątrz komponentu `App`.
```js
const GridSize = 10;
```
Następnie zmieniamy kod komponentu `App` tak, aby zamiast `div` zwracał `GameGrid`.
```jsx
return (
<GameGrid gridSize={GridSize} />
);
```
W efekcie powinniśmy zobaczyć na ekranie przeglądarki wyśrodkowany kwadrat z szarym obramowaniem, wewnątrz którego jest wyświetlona siatka.
### Wyświetlanie węża i owocu
Kolejnym zadaniem jest wyświetlenie węża i owocu na siatce.\
W tym celu wykorzystamy pierwszy hook `useState`.\
Pozwala on przechowywać stan komponentu i go zmieniać.\
Każda zmiana stanu komponentu skutkuje przerenderowaniem komponentu.\
Hook `useState` jako argument czeka na stan inicjalny.\
Może to być wartość albo funkcja zwracająca wartość (leniwa inicjalizacja).\
Hook zwraca tablicę z dwoma elementami.\
Pierwszy to aktualna wartość stanu.\
Drugi to funkcja do aktualizacji stanu.
```js
const [state, setState] = useState(init);
```
Dodajemy import `useState` do istniejącego importu Reacta.\
Wykorzystamy ten hook to przechowywania pozycji węża i owocu.\
Stany te zdefiniujemy w komponencie `App`.\
Osobny stan dla pozycji węża i osobny dla pozycji owocu.\
Inicjalna pozycja węża powinna być w środku siatki.\
Początkowo wąż składa się z trzech elementów.\
Każdy z elementów to obiekt reprezentujący punkt na siatce.\
Obiekt reprezentujący punkt posiada pola: `x` oraz `y`.\
Inicjalna pozycja owocu powinna być losowa.\
Owoc jest pojedynczym punktem na siatce.
```js
const [snake, setSnake] = useState([
{ x: GridSize / 2, y: GridSize / 2 },
{ x: GridSize / 2, y: GridSize / 2 + 1 },
{ x: GridSize / 2, y: GridSize / 2 + 2 },
]);
const [fruit, setFruit] = useState({
x: randomIndex(GridSize),
y: randomIndex(GridSize),
});
```
Teraz brakuje nam losowanie indeksu. W tym celu dodajmy funkcję pomocniczą:
```js
function randomIndex(n) {
return Math.floor(Math.random() * n);
}
```
Tak przygotowane dane możemy przekazać do komponentu siatki.
```jsx
<GameGrid gridSize={GridSize} fruit={fruit} snake={snake} />
```
Następnie przechodzimy do komponentu siatki `GameGrid`.\
Najpierw dodajemy w deklaracji komponentu dwa nowe propsy: `fruit` i `snake`:
```jsx
export default function GameGrid({ gridSize, fruit, snake }) {
// ...
}
```
Aby na siatce wyświetlić węża i owoc będziemy dodawać do odpowiedniej komórki odpowiednie klasy css.\
Do pliku ze stylami dodać poniższe style:
```css
.snakeCell {
width: 30px;
height: 30px;
background-color: black;
}
.fruitCell {
width: 30px;
height: 30px;
background-color: green;
}
```
Następnie w komponencie `GameGrid` dodamy funkcję `getCellClass`.\
Funkcja powinna przyjmować dwa argumenty: `x` i `y`, które reprezentują punkt siatki, dla którego chcemy wyliczyć klasę.\
Zwracać powinna klasę komórki siatki.\
Jeśli komórka jest na tej samej pozycji do owoc zwracamy `fruitCell`.\
Jeśli komórka jest w zbiorze komórek węża zwracamy `snakeCell`.\
Inaczej zwracamy `gridCell`.\
Po przygotowaniu wszystkiego, zamieniamy `div` reprezentujący komórkę na:
```jsx
<div
className={getCellClass(x, y)}
key={`${x}x${y}`}
/>
```
#### Zadania dodatkowe
* Zadbać, aby owoc nie mógł zostać wylosowany w pozycji aktualnie zajmowanej przez węża.
* Wyróżnij stylami głowę węża.
### Pętla gry i ruch węża
Kolejną rzeczą, jaką dodamy, jest ruch węża.\
Na początek, bez możliwości zmiany kierunku.\
W tym celu wykorzystamy kolejny hook o nazwie `useEffect`.\
Służy on do obsługi zdarzeń, które powodują, tak zwane „efekty".\
Efektem jest taki fragment kodu, który modyfikuje w jakiś sposób stan aplikacji.\
W przypadku naszej aplikacji efektem będzie tick gry.\
Przez tick rozumiemy pojedynczą klatkę gry, czyli odświeżenie.\
Gra działa w określonej prędkości.\
Co jakiś czas, chcemy obliczyć nową pozycję węża.
Hook `useEffect` przyjmuje dwa argumenty.\
Pierwszy to funkcja bez argumentów, która reprezentuje kod efektu.\
Drugi to tablica zależności efektu.\
```js
useEffect(() => {
// kod efektu
},
[
// lista zależności
]);
```
Efekt jest odpalany zawsze inicjalne oraz gdy jakikolwiek z elementów tablicy zależności się zmienił.\
W naszej aplikacji chcemy, aby co określony czas nasz efekt się wykonał i zaktualizował pozycję węża.\
Będziemy potrzebować po pierwsze określić prędkość i kierunek ruchu węża.\
Zdefiniujmy na poziomie komponentu `App` dwie stałe reprezentujące te dane:
```js
const direction = 'up';
const speed = 500;
```
Następnie dodajemy import `useEffect` do istniejącego importu Reacta i wykorzystujemy go wewnątrz komponentu `App`.\
Zależnością naszego efektu będzie pozycja węża.\
Następnie wewnątrz efektu, chcemy stworzyć interwał, który będzie odpalał się w odstępach, które reprezentuje stała `speed` (jest to czas w ms pomiędzy kolejnymi wyliczeniami pozycji węża).
```js
const interval = setInterval(() => {
// wyliczenia nowej pozycji węża w zależności od kierunku
}, speed);
```
Ważnym aspektem działania efektów jest sprzątanie po nich. W naszej aplikacji za każdym razem, gdy zmieni się pozycja węża, będziemy tworzyć nowy interwał.\
Stary interwał należy wyczyścić, inaczej każde kolejne odświeżenie efektu, spowoduje stworzenie kolejnego, nowego interwału, co w efekcie spowoduje powielenie odświeżeń aplikacji.\
Aby posprzątać po efekcie, należy zwrócić z efektu funkcję.\
Funkcja zwrócona z efektu, jest wykonywana zawsze, kiedy efekt przestaje być potrzebny — czyli kiedy go ponownie wywołujemy, wcześniej wywołamy sprzątanie.\
Nasz efekt powinien wyczyścić wcześniej stworzony interwał.\
W tym celu skorzystać możemy z funkcji `clearInterval`, która jako argument przyjmuje obiekt, zwrócony podczas tworzenia interwału.\
Nasz efekt powinien wyglądać tak:
```js
useEffect(() => {
const interval = setInterval(() => {
// tutaj wyliczymy nową pozycję węża
}, speed);
return () => {
clearInterval(interval);
};
}, [snake]);
```
Aby wyliczyć nową pozycję węża, musimy po pierwsze wyliczyć pozycję nowej głowy, oraz usunąć ostatnią cześć ciała węża.\
Aby pobrać pierwszy element z tablicy, możemy skorzystać z destrukcji tablic:
```js
const [snakeHead] = snake;
```
Następnie potrzebujemy kopii głowy, która będzie reprezentować nową głowę węża.\
Do wykonania prostej kopii możemy wykorzystać destrukcję obiektu:
```js
const newSnakeHead = { ...snakeHead };
```
Następnie w zależności od kierunku zmieniamy odpowiednio obiekt reprezentujący pozycję nowej głowy.\
Jeśli kierunek to `up` zmniejszamy `x` głowy o 1.\
Jeśli kierunek to `down` zwiększamy `x` głowy o 1.\
Jeśli kierunek to `left` zmniejszamy `y` głowy o 1.\
Jeśli kierunek to `right` zwiększamy `y` głowy o 1.\
Następnie tworzymy `const` do którego przypiszemy tablicę reprezentującą węża w nowej pozycji.
```js
const newSnake = [newSnakeHead, ...snake.slice(0, snake.length - 1)];
```
Na koniec aktualizujemy stan pozycji węża, co spowoduje odświeżenie ekranu.
```js
setSnake(newSnake);
```
Sprawdź w przeglądarce działanie aplikacji.\
Wąż powinien poruszać się w kierunku określonym w stałej `direction`;\
Przetestuj ruch we wszystkich kierunkach zmieniając wartość stałej `direction`.
#### Zadanie dodatkowe
* Wykryj wyjście poza ekran — w reakcji możesz resetować stan gry do inicjalnego.
### Zmiana kierunku ruchu węża
Następnym zadaniem jest obsługa zmiany kierunku ruchu węża w odpowiedzi na wciśnięcie na klawiaturze strzałek.\
Zmiana kierunku węża, nie powinna powodować odświeżenia ekranu.\
W tym celu wykorzystamy kolejny hook `useRef`.\
Jest to hook pozwalający przechowywać dane, analogicznie jak `useState`, z tą różnicą, że zmiana wartości nie będzie powodować przerenderowania aplikacji.\
Wartość zmiennej przechowywanej przez `useRef` możemy zmienić przez referencję.\
Hook `useRef` zwraca jedną wartość, jest to obiekt z pojedynczym polem `current`, w którym jest dostępna aktualnie przechowywana wartość.\
```js
const mutableValue = useRef(initialValue);
// ...
mutableValue.current = newValue;
```
W naszej aplikacji wykorzystanie `useState` do obsługi zmiany kierunku, powodowałoby, że po wciśnięciu strzałki od razu nastąpiłoby odświeżenie pozycji węża z nowym kierunkiem.\
Dodajemy import `useRef` do istniejącego importu Reacta.\
Rozpoczniemy od zmiany stałej `direction`, tak aby jej wartość była przechowywana jako zmienna przez hook `useRef`.
```js
const direction = useRef('up');
```
Następnie musimy poprawić kod w miejscach gdzie wcześniej wykorzystaliśmy `direction`, tak aby teraz zamiast bezpośrednio odnosić się do `direction` teraz odnosić się do `diretion.currect`.\
Po zmianach aplikacja powinna działać bez różnicy.\
Następnie dodamy obsługę zmiany kierunku, po naciśnięciu jednej ze strzałek na klawiaturze.\
W tym celu znowu wykorzystamy hook `useEffect`.\
Aby obsłużyć zdarzenie klawiatury, dodamy nasłuchiwanie na dokumencie.
```js
useEffect(() => {
document.addEventListener('keydown', handleKeyDown);
return () => {
document.removeEventListener('keydown', handleKeyDown);
};
}, []);
```
Brakuje nam teraz funkcji `handleKeyDown`.
```js
function handleKeyDown(event) {
// ustalenie jaki klawisz został wciśnięty i zmiana odpowiednio wartości `direction.current`
}
```
Wewnątrz funkcji w zależności od tego, jaka strzałka została wciśnięta, chcemy odpowiednio zmodyfikować kierunek ruchu węża.\
Po zaimplementowaniu tej funkcji, sprawdź aplikację w przeglądarce, wąż powinien reagować na wciśnięcie strzałek.\
#### Zadania dodatkowe
* Zadbaj, aby wąż, gdy trafi na własne ciało, gra to obsługiwała — może być reset stanu analogicznie jak przy kontakcie ze ścianą. Dla ułatwienia dodaj więcej elementów do węża inicjalnie.
### Zjadanie owocu i zwiększanie prędkości
Kolejną funkcjonalnością, jaką dodamy, jest możliwość zjedzenia owocu.\
Po zjedzeniu owocu, owoc powinien pojawić się w nowym losowym miejscu.\
Długość węża wzrasta o 1 po zjedzeniu owocu.\
Prędkość gry wzrasta po zjedzeniu owocu.\
Pracę rozpoczniemy od zdefiniowania na poziomie pliku `App.js` stałej reprezentującej mnożnik prędkości.
```js
const SpeedMultiplier = 0.8;
```
Następnie stałą `speed` zamienimy na stan wykorzystując `useState`:
```js
const [speed, setSpeed] = useState(500);
```
Teraz w efekcie odpowiedzialnym za aktualizacją pozycji węża, dodamy sprawdzenie, czy nowa głowa nie jest w tej samej pozycji co owoc.\
Jeśli owoc jest na tej samej pozycji do głowa węża, wiemy, że wąż właśnie zjadł owoc.\
Wartość tego wyliczenia przypiszemy do stałej:
```js
const fruitEaten = fruit.x === newSnakeHead.x && fruit.y === newSnakeHead.y;
```
Następnie w przypadku gdy owoc został zjedzony, chcemy ustalić nową pozycję owocu oraz zwiększyć prędkość.\
Nową pozycję owocu wyliczamy analogicznie do inicjalizacji hooka przechowującego stan owocu.\
Aby zwiększyć prędkość, mnożymy aktualną prędkość razy `SpeedMultiplier` i aktualizujemy stan prędkości.\
Na koniec zostaje nam dodanie nowego elementu węża w przypadku gdy zjadł owoc.\
Aktualnie podczas zmiany pozycji węża, po dodaniu nowej głowy, skracamy węża o jeden element (ostatni).\
W przypadku gdy wąż zje owoc, po prostu nie skracamy węża po dodaniu nowej głowy.
#### Zadanie dodatkowe
* Dodaj bardziej płynną zmiannę prędkości. Aktalnie gra przyszpiesza dosyć szybko. Wymyśl własny wzór na obliczanie prędkości. Wzór może bazowac na długości węża.
### Wydzielenie logiki gry do własnego hooka
Największą zaletą hooków jest możliwość tworzenia własnych hooków.\
Dzięki temu enkapsulacja oraz reużywalność kodu jest o wiele łatwiejsza i przyjemniejsza.\
Każdy hook musi zachować odpowiednie nazewnictwo, czyli zaczynać się od prefixa `use`.\
```js
function useCustomHook(args) {
// logika hooka
}
```
Pierwszym hookiem, jakiego stworzymy będzie hook `useGame`.\
Hook ten będzie zawierał całą logikę naszej gry.\
Dzięki temu kompletnie oddzielimy szablon od logiki.\
W folderze `game` stwórz plik `useState`.\
Plik ten eksportuje domyślnie funkcję o nazwie `useState`.\
Funkcja ta czeka na jeden argument w postaci obiektu zawierającego na razie pola: `gridSize`, `speed` oraz `increaseSpeed`.\
Zwraca obiekt z polami: `fruit` i `snake`.
```js
export default function useGame({ gridSize, speed, increaseSpeed }) {
// logika gry przeniesiona z pliku App.js
}
```
Do utworzonego hooka przenosimy całą logikę z komponentu `App`.\
Zostawiamy jedynie stan prędkości.\
Potrzebujemy także funkcji do zwiększania prędkości, której oczekuje hook.\
Definiujemy ją na poziomie komponentu `App` i przekazujemy do wywołania hooka `useGame` razem z prędkością i wielkością siatki.\
Następnie po przekopiowaniu kodu logiki z komponentu `App` do hooka `useGame`, dostosowujemy kod.\
Zmieniamy wszystkie odwołania do `GridSize` na `gridSize`.\
Linijkę odpowiedzialną za zwiększenie prędkości zamieniamy wywołaniem funkcji `increaseSpeed`.\
Kasujemy nieużywany stan prędkości.\
Stan prędkości zostawiamy w komponencie `App`.\
Po prawidłowo przeprowadzonej operacji aplikacja powinna działać bez zmian.
### Rozbicie logiki na wyspecjalizowane hooki
Kolejną właściwością hooków jest możliwość kompozycji logiki.\
Nasz główny hook, przechowujący logikę gry posiada wymieszaną logikę.\
Wydzielimy z niego kod reprezentujący pętlę gry oraz obsługę zmiany kierunku.\
W tym celu utworzymy dwa nowe hooki i wykorzystamy je wewnątrz hooka `useGame`.
Pierwszym będzie hook `useGameDirection`.\
Utwórz w folderze `game` plik o nazwie `useGameDirection.js`.\
Plik ten eksportuje domyślnie jedną funkcję o nazwie `useGameDirection`.\
Przenieś do niego tworzenie zmiennej `direction` oraz kod związany z obsługą zdarzenia klawiatury.\
Hook ma zwracać aktualny kierunek.
```js
return direction.current;
```
Wykorzystaj hook w `useGame`.\
Zwróć uwagę, że hook `useDirection` nie zwraca obiektu z kluczem `current` tylko płasko aktualny kierunek.\
Popraw odpowiednio kod w `useGame`.
Następnie utwórz plik `useGameLoop`.\
Wydzielimy do niego logikę związaną z pętlą gry.\
Plik jak każdy inny hook, eksportuje domyślnie funkcję o nazwie `useGameLoop`.\
Jako argument przyjmuje obiekt z polami: `speed` oraz `onTick`.\
Hook nic nie zwraca.
```js
export default function useGameLoop({ onTick, speed }) {
useEffect(() => {
const interval = setInterval(onTick, speed);
return () => {
clearInterval(interval);
};
}, [speed, onTick]);
}
```
Hook wykona w odpowiednim interwale kod przekazany w polu `onTick`.\
Następnie wewnątrz hooka `useGame`, stworzyć funkcję `handleGameTick`.\
Funkcja nie przyjmuje żadnych argumentów oraz nic nie zwraca.\
W jej ciele umieść kod, który dotychczas był wykonywany podczas interwału.
### Stworzenie kontekstu gry
W bardziej złożonych aplikacjach często przekazujemy głęboko propsy.\
Może to powodować, że komponenty przyjmują bardzo dużo propsów, co utrudnia utrzymanie komponentów.\
Jednym z rozwiązań tego problemu jest wykorzystanie kontekstu.\
Kontekst jest abstrakcją, która umożliwia przechowywaniu danych w łatwo dostępnym miejscu.\
Do kontekstu mają dostęp wszystkie komponenty potomne.\
Kontekst zawsze występuje w parze.\
Pierwszym elementem jest tak zwany `Provider`, odpowiedzialny na przechowywanie danych, które będę udostępnione komponentom pochodnym.\
Drugi jest tak zwany `Consumer`. Ten występuje w 2 postaciach: komponentu oraz hooka.\
Podczas warsztatów wykorzystamy `Consumer` w postaci hooka.\
W naszej aplikacji wydzielimy dwie dane jako kontekst aplikacji: prędkość gry oraz wielkość siatki.\
Zaczniemy od utworzenie pliku `GameContext.js`, w którym zdefiniujemy nowy kontekst.\
Do stworzenia kontekstu potrzebna jest funkcja pomocnicza z biblioteki `React` o nazwie `createContext`.\
Funkcja przyjmuje jeden argument, który reprezentuje inicjalny stan kontekstu.
```js
import { createContext } from 'react';
const GameContext = createContext({ gridSize: 0, speed: 0, increaseSpeed: () => {} });
export default GameContext;
```
Następnie stworzymy nowy komponent `Game`.\
Jego zadaniem będzie wywołanie hooka `useGame` oraz wyświetlenie komponentu `GameGrid`.\
Aby pobrać dane z kontekstu potrzebny będzie kolejny hook `useContext`.\
Jako argument czeka na obiekt kontekstu.\
Zwraca wartość udostępnianą przez kontekst.
```jsx
export default function Game() {
const { gridSize, speed, increaseSpeed } = useContext(GameContext);
const { fruit, snake } = useGame({ gridSize, speed, increaseSpeed });
return (
<GameGrid gridSize={gridSize} fruit={fruit} snake={snake} />
)
}
```
Następnie w komponencie `App` dodajemy `Provider` kontekstu.
```jsx
return (
<GameContext.Provider value={{ speed, gridSize, increaseSpeed }}>
<Game />
</GameContext.Provider>
);
```
Od tej pory komponent `Game` oraz wszystkie potomne mają dostęp do danych przechowywanych w kontekście.\
Hook `useGame` może pobrać sam wartości z kontekstu, zamiast czekać na przekazanie w argumencie.\
Skasujmy argumenty i zamieńmy je wywołaniem kontekstu na poziomie hooka.
### Pauzowanie gry i menu
Dodamy do gry menu oraz zatrzymamy ruch węża podczas wyświetlania menu.\
Na początek rozszerz kontekst gry o nowe pola: `pause`, `pauseGame`, `unpauseGame` i nadaj im inicjalne wartości:
```js
const GameContext = createContext({
gridSize: 0,
speed: 0,
paused: true,
pauseGame: () => {},
unpauseGame: () => {},
increaseSpeed: () => {},
});
```
Następnie a komponencie `App` dodajemy nowy stan reprezentujący czy gra jest w stanie pauzy.\
Inicjalnie gra jest zapauzowana.
```js
const [paused, setPaused] = useState(true);
```
Potrzebne będą także dwie funkcje pomocnicze do aktualizacji pauzy:
```js
function pauseGame() {
setPaused(true);
}
function unpauseGame() {
setPaused(false);
}
```
Przekaż nowe wartości do kontekstu.\
Następnie stwórz plik `GameMenu.js` a wewnątrz komponent z menu:
```jsx
import React, { useContext } from 'react';
import GameContext from './GameContext';
import './GameGrid.css';
export default function GameMenu() {
const { unpauseGame } = useContext(GameContext);
return (
<div className="gameMenu">
<div className="gameMenuOverlay" />
<div className="gameMenuContent">
<button onClick={unpauseGame}>PLAY</button>
</div>
</div>
);
}
```
Komponent wykorzystuje arkusz styli. Dodaj go:
```css
.gameMenu {
position: absolute;
width: 100%;
height: 100%;
display: flex;
justify-content: center;
align-items: center;
}
.gameMenuOverlay {
position: absolute;
width: 100%;
height: 100%;
display: flex;
justify-content: center;
align-items: center;
background-color: black;
opacity: .5;
}
.gameMenuContent {
z-index: 1;
display: flex;
align-items: center;
justify-content: center;
background-color: white;
padding: 50px;
}
```
Na ten moment brakuje możliwości włączenia pauzy.\
Zrealizujemy to za pomocą wykrywania wciśnięcia klawisza spacji.\
W tym celu stworzymy kolejny hook `useSpaceDownEvent`.\
Stwórz plik `useSpaceDownEvent.js` a wewnątrz niego dodaj kod:
```js
import { useEffect } from 'react';
export default function useSpaceDownEvent(handler) {
useEffect(() => {
function handleKeyDown(event) {
if (event.keyCode === 32) {
handler();
}
}
document.addEventListener('keydown', handleKeyDown);
return () => {
document.removeEventListener('keydown', handleKeyDown);
};
}, [handler]);
}
```
Hook jako argument czeka na handler, który zostanie wywołany w przypadku gdy zostanie wciśnięta spacja.\
Wywołujemy hook na poziomie `useGame`.\
Ostatnią rzeczą jest zablokowanie ruchu węża, gdy stan gry to pauza.\
W tym celu owrapuj logikę porusza węża w `if` gdzie warunkiem jest to czy gra jest niezapuzowana.
### Małe usprawnienia dzięki kolejnych hookom
Na koniec poznamy jeszcze trzy hooki na bazie małych przykładów usprawniających kod aplikacji.\
Zaczniemy od dodania efektu animacji owocu po pojawieniu się na siatce.\
W tym celu wykorzystamy hook `useLayoutEffect`.\
Od zwykłego hooka `useEffect` różni się tym że jest wywoływany po tym jak zmiany w drzewie DOM zostaną wykonane.\
Dzięki temu możemy powyrenderowaniu strony wpłynąć jakoś na strukturę HTML dokumentu.
```js
useLayoutEffect(() => {
// kod efektu wykorzystującego wyrenderowany dokument
}, [
// zależności
]);
```
W naszym przypadku będziemy wpływać na `div`, w którym aktualnie jest wyrenderowana głowa węża.\
W hooku `useGame` wykorzystajmy `useLayoutEffect`.\
Jego składnia jest analogiczna do `useEffect`.\
W ciele efektu znajdź element z klasą `fruitCell`.\
Do znalezienia elementu wykorzystaj `document.querySelector`.\
Zmodyfikuj style elementu poniższym:
```css
transition: transform 0.5s;transform: rotate3d(1, 1, 1, 360deg);
```
Zależnością efektu powinien być stan owocu.
Kolejną rzeczą, którą poprawimy będzie nadmiarowe odświeżanie kontekstu powodowane przekazywaniem do niej każdorazowo tworzonych funkcji.
W pliku `App.js` tworzymy funkcje: `increaseSpeed`, `pauseGame`, `unpauseGame` za każdym razem.\
Powoduje to, że każdorazowo jest też tworzony kontekst.\
W przypadku naszej aplikacji jest to optymalizacja czysto dla sztuki.\
Aby rozwiązać ten problem, wykorzystamy kolejny hook `useCallback`.\
Czeka na dwa argumenty.\
Pierwszy to funkcja, którą chcemy zmemoizować.\
Drugi to tablica zależności, po których zmianie zmemoizowana funkcja zostanie ponownie stworzona i zmemoizowana.\
Zwraca zmemoizowaną funckję.\
```js
const memoizedFunction = useCallback(() => {
// kod
}, [
// zależności
]);
```
Wykorzystaj `useCallback` do zmemoizowania funkcji tworzonych w komponencie `App`.
Ostatnią mini optymalizacją na potrzeby poznania kolejnego hooka będzie zmemoizowanie wyliczania tablicy indeksów w komponencie `GameGrid`.
Wykorzystamy do tego hook `useMemo`.\
Pierwszy to funkcja, którą chcemy zmemoizować.\
Drugi to tablica zależności, po których zmianie zmemoizowana funkcja zostanie ponownie stworzona i zmemoizowana.\
Zwraca zmemoizowaną wartość.\
```js
const memoizedValue = useMemo(() => {
// funkcja zwracająca wartość do zmemoizowania
}, [
// zależności
]);
```
Wykorzystaj `useMemo` do memoizacji wyliczenia indeksów w komponencie `GameGrid`.
### Obsługa stanu kontekstu gry z wykorzystaniem reducera
Ostatnim hookiem, jaki poznamy jest `useReducer`.\
Służy do obsługi skomplikowanych stanów aplikacji.\
Posiada API analogiczne do biblioteki `Redux`.\
Hook czeka na trzy argumenty.\
Pierwszy to funkcja redukująca stan w odpowiedzi na akcję — inaczej reducer.\
Drugi to obiekt reprezentujący inicjalny stan.\
Trzeci to funkcja zwracająca stan inicjalny.\
Zwraca tablicę z dwoma argumentami:\
Pierwszy element to aktualny stan.\
Drugi element to funkcja do wywoływania akcji na reducerze.
```js
const initialState = { count: 0 };
function reducer(state, action) {
switch (action.type) {
case 'increment':
return { count: state.count + 1 };
case 'decrement':
return { count: state.count - 1 };
default:
throw new Error();
}
}
function Counter() {
const [state, dispatch] = useReducer(reducer, initialState);
return (
<>
Licznik: {state.count}
<button onClick={() => dispatch({ type: 'decrement' })}>-</button>
<button onClick={() => dispatch({ type: 'increment' })}>+</button>
</>
);
}
```
Stwórz plik `gameContextStateReducer`.\
Plik będzie domyślnie eksportował funkcję reducera.\
Funkcja reducera posiada dwa argumenty.\
Pierwszy to aktualny stan reducera.\
Drugi to obiekt reprezentujący akcję, która została wysłana do reducera.\
Obiekt akcji posiada dwa pola: `type` oraz `payload`.\
Funckja zwraca nowy stan.\
Wykorzystując przykład stwórz reducer, który będzie obsługiwał trzy akcje:
* `increaseSpeed` - po wywołaniu, której zostanie zwiększona prędkość gry
* `pauseGame` - po wywołaniu, której gra zostanie zatrzymana
* `unpauseGame` - po wywołaniu, której gra zostanie wznowiona
Następnie zmodyfikuj komponent `App`, aby korzystał ze stworzonego reducera.\
Kod wynikowy komponentu `App` powinien być analogiczny do poniższego:
```jsx
import React, { useCallback, useReducer } from 'react';
import GameContext from './game/GameContext';
import Game from './game/Game';
import gameContextStateReducer, { initGameContextState, InitialGameContextState } from './game/gameContextStateReducer';
const GridSize = 10;
const SpeedMultiplier = 0.8;
function App() {
const [gameContextState, dispatchGameContextAction] = useReducer(
gameContextStateReducer,
InitialGameContextState,
initGameContextState,
);
const { paused, speed } = gameContextState;
const increaseSpeed = useCallback(() => {
dispatchGameContextAction({ type: 'increaseSpeed', payload: SpeedMultiplier });
}, []);
const pauseGame = useCallback(() => {
dispatchGameContextAction({ type: 'pauseGame' });
}, []);
const unpauseGame = useCallback(() => {
dispatchGameContextAction({ type: 'unpauseGame' });
}, []);
return (
<GameContext.Provider value={{ speed, gridSize: GridSize, paused, increaseSpeed, pauseGame, unpauseGame }}>
<Game/>
</GameContext.Provider>
);
}
export default App;
```
### Wystawianie aplikacji na gh-pages
Dzięki wykorzystaniu `creact-react-app` i `gh-pages` możemy w łatwy sposób wystawić naszą aplikację na serwer Github.\
W tym celu najpierw stronę z repozytorium.\
Stwórz branch o nazwie `gh-pages`.\
Przejdź do ustawień repozytorium i znajdź sekcję `GitHub Pages`.\
Jeśli jeszcze nie jest wybrany `gh-pages` ustaw go.\
Następnie zainstaluj paczkę `gh-pages`.\
Dodaj do `package.json` dwa skrypty oraz odpowiedni homepage.
```json
"predeploy": "yarn run build",
"deploy": "gh-pages -d build",
```
```json
"homepage": "https://twoja-nazwa-github.github.io/warsawjs-workshop-47-reactive-snake/",
```
Odpal skrypt `deploy`.\
Po chwili aplikacja powinna być dostępna pod adresem podanym w polu `homepage` w `package.json`.
### Zadanie dodatkowe
* Dodać w menu opcję rozpoczynania gry od nowa
* Dodać punktację
* Dodać możliwość zmiany rozmiaru siatki — opcja w menu?
* Dodać animację ruchu węża — płynne przesuwanie głowy i ogonu
* Dodać poziomy gry — co pewną ilość zjedzonych owoców zmienia się kolorystyka gry, co nam da wrażenie, że zmienił się poziom gry
| 38.758539 | 193 | 0.762688 | pol_Latn | 0.999852 |
473921bd52059393f40fdc5acd1c111d7464fb46 | 2,389 | md | Markdown | mac/keyboard-shortcuts.md | B4V/visualstudio-docs.ru-ru | c9c85cb0972b8eed68c78fd1a8be2410700da449 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | mac/keyboard-shortcuts.md | B4V/visualstudio-docs.ru-ru | c9c85cb0972b8eed68c78fd1a8be2410700da449 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | mac/keyboard-shortcuts.md | B4V/visualstudio-docs.ru-ru | c9c85cb0972b8eed68c78fd1a8be2410700da449 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: Распространенные сочетания клавиш в редакторе исходного кода
description: В этой статье описываются некоторые распространенные сочетания клавиш в редакторе исходного кода Visual Studio для Mac
author: conceptdev
ms.author: crdun
ms.date: 05/06/2018
ms.assetid: 48E06A61-7294-4EC8-A09D-1763C32AD910
ms.openlocfilehash: 3aea39862ee2221454a337d7c50defd41319623b
ms.sourcegitcommit: 2597236a481afbaf1ad4915743898ee1aee49760
ms.translationtype: HT
ms.contentlocale: ru-RU
ms.lasthandoff: 08/10/2018
ms.locfileid: "43224232"
---
# <a name="common-keyboard-shortcuts-in-visual-studio-for-mac"></a>Распространенные сочетания клавиш в Visual Studio для Mac
## <a name="show-code-generation-window"></a>Отражение окна создания кода
Эта команда создает код в зависимости от контекста:
`⌘ + 1`
## <a name="search-files-symbols-and-commands"></a>Поиск файлов, символов и команд
`control + .`
## <a name="autocomplete"></a>Автозавершение
`control + /`
## <a name="quick-fixes-and-actions"></a>Быстрые исправления и действия
Отображает контекстные действия [рефакторинга](refactoring.md):
`option + enter`
## <a name="find-in-files"></a>Поиск в файлах
`⌘ + shift + F`
## <a name="file-switcher"></a>Переключатель файлов
Обеспечивает быстрое переключение между файлами:
`control + tab`
## <a name="move-lines-around-in-editor"></a>Перемещение строк в редакторе
`alt + up/down`
Используйте команду **ALT+СТРЕЛКА ВВЕРХ** для перемещения текущей или выбранных строк вверх, а команду **ALT+СТРЕЛКА ВНИЗ** — для перемещения этих строк вниз. Если надстройка языка поддерживает это, для строк будет повторно установлен отступ, чтобы соответствовать контексту при перемещении в область и из нее.
## <a name="word-navigation"></a>Навигация по словам
Перемещает курсор к следующему или предыдущему слову:
`option + left/right`
## <a name="line-navigation"></a>Навигация по строкам
Перемещает курсор в начало или конец строки:
`⌘ + left/right`
## <a name="expands-the-selection"></a>Развертывание выбранного фрагмента
Логически развертывает выбор слова, вложенных выражений, оператора и элемента строки:
`alt + shift + up` для выбора, `alt + shift + down` для отмены выбора | 32.726027 | 310 | 0.768941 | rus_Cyrl | 0.856511 |
47394480836e6cb7abed96a181fa834fc8f82791 | 78 | md | Markdown | README.md | Robot-Grimpeur/dev-os | f38afd18038a8017890df27a741216d3a7e945c4 | [
"MIT"
] | null | null | null | README.md | Robot-Grimpeur/dev-os | f38afd18038a8017890df27a741216d3a7e945c4 | [
"MIT"
] | null | null | null | README.md | Robot-Grimpeur/dev-os | f38afd18038a8017890df27a741216d3a7e945c4 | [
"MIT"
] | null | null | null | # dev-os
Ceci est le système d'exploitation de développement de notre robot.
| 19.5 | 67 | 0.782051 | fra_Latn | 0.99506 |
4739619996e863d5bd9064dc2c673167113b9c21 | 21,725 | md | Markdown | docs/api-reference/soap/Services87/Document/SubstituteTemplateVariablesEx.md | SuperOfficeDocs/data-access | f0a7033b0f43c4b60921885c7cebde9b789f4487 | [
"MIT"
] | null | null | null | docs/api-reference/soap/Services87/Document/SubstituteTemplateVariablesEx.md | SuperOfficeDocs/data-access | f0a7033b0f43c4b60921885c7cebde9b789f4487 | [
"MIT"
] | 59 | 2021-04-28T07:02:54.000Z | 2022-02-03T13:08:46.000Z | docs/api-reference/soap/Services87/Document/SubstituteTemplateVariablesEx.md | SuperOfficeDocs/data-access | f0a7033b0f43c4b60921885c7cebde9b789f4487 | [
"MIT"
] | 2 | 2021-07-01T10:19:20.000Z | 2021-08-12T09:41:30.000Z | ---
title: Services87.DocumentAgent.SubstituteTemplateVariablesEx SOAP
generated: 1
uid: Services87-Document-SubstituteTemplateVariablesEx
---
# Services87 Document SubstituteTemplateVariablesEx
SOAP request and response examples **Remote/Services87/Document.svc**
Implemented by the <see cref="M:SuperOffice.Services87.IDocumentAgent.SubstituteTemplateVariablesEx">SuperOffice.Services87.IDocumentAgent.SubstituteTemplateVariablesEx</see> method.
## SubstituteTemplateVariablesEx
Parse the source string, and replace any template variable tags with their values, based on the identities, custom values and entities specified in the other parameters.
* **parameters:** Name of culture to be used for culture-sensitive data, such as dates or multi-language texts. Use a blank string to accept whatever current culture is set on the server (possibly not a good choice in multinational organizations with a single server).
**Returns:** Source string with templates substituted, using the same encoding as for the source (binary data will be returned in Base64).
[WSDL file for Services87/Document](../Services87-Document.md)
Obtain a ticket from the [Services87/SoPrincipal.svc](../SoPrincipal/index.md)
Application tokens must be specified if calling an Online installation. ApplicationTokens are not checked for on-site installations.
## SubstituteTemplateVariablesEx Request
```xml
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope
xmlns:SOAP-ENV="http://www.w3.org/2003/05/soap-envelope"
xmlns:SOAP-ENC="http://www.w3.org/2003/05/soap-encoding"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:NetServerServices872="http://schemas.microsoft.com/2003/10/Serialization/Arrays"
xmlns:NetServerServices871="http://schemas.microsoft.com/2003/10/Serialization/"
xmlns:Document="http://www.superoffice.net/ws/crm/NetServer/Services87">
<Document:ApplicationToken>1234567-1234-9876</Document:ApplicationToken>
<Document:Credentials>
<Document:Ticket>7T:1234abcxyzExample==</Document:Ticket>
</Document:Credentials>
<SOAP-ENV:Body>
<Document:SubstituteTemplateVariablesEx>
<Document:Parameters xsi:type="Document:TemplateVariablesParameters">
<Document:SourceInput xsi:type="xsd:string"></Document:SourceInput>
<Document:Encoding xsi:type="Document:GeneratorEncoding">Text</Document:Encoding>
<Document:CultureName xsi:type="xsd:string"></Document:CultureName>
<Document:ContactId xsi:type="xsd:int">0</Document:ContactId>
<Document:PersonId xsi:type="xsd:int">0</Document:PersonId>
<Document:ProjectId xsi:type="xsd:int">0</Document:ProjectId>
<Document:SelectionId xsi:type="xsd:int">0</Document:SelectionId>
<Document:AppointmentId xsi:type="xsd:int">0</Document:AppointmentId>
<Document:DocumentId xsi:type="xsd:int">0</Document:DocumentId>
<Document:SaleId xsi:type="xsd:int">0</Document:SaleId>
<Document:QuoteLineId xsi:type="xsd:int">0</Document:QuoteLineId>
<Document:QuoteAlternativeId xsi:type="xsd:int">0</Document:QuoteAlternativeId>
<Document:ProductKey xsi:type="xsd:string"></Document:ProductKey>
<Document:CustomTags xsi:type="NetServerServices872:ArrayOfArrayOfstring">
<NetServerServices872:ArrayOfstring xsi:type="NetServerServices872:ArrayOfstring">
<NetServerServices872:string xsi:type="xsd:string"></NetServerServices872:string>
</NetServerServices872:ArrayOfstring>
</Document:CustomTags>
<Document:DocumentEntity xsi:type="Document:DocumentEntity">
<Document:DocumentId xsi:type="xsd:int">0</Document:DocumentId>
<Document:UpdatedBy xsi:type="Document:Associate">
<Document:AssociateId xsi:type="xsd:int">0</Document:AssociateId>
<Document:Name xsi:type="xsd:string"></Document:Name>
<Document:PersonId xsi:type="xsd:int">0</Document:PersonId>
<Document:Rank xsi:type="xsd:short">0</Document:Rank>
<Document:Tooltip xsi:type="xsd:string"></Document:Tooltip>
<Document:Type xsi:type="Document:UserType">Unknown</Document:Type>
<Document:GroupIdx xsi:type="xsd:int">0</Document:GroupIdx>
<Document:FullName xsi:type="xsd:string"></Document:FullName>
<Document:FormalName xsi:type="xsd:string"></Document:FormalName>
<Document:Deleted xsi:type="xsd:boolean">false</Document:Deleted>
<Document:EjUserId xsi:type="xsd:int">0</Document:EjUserId>
<Document:UserName xsi:type="xsd:string"></Document:UserName>
</Document:UpdatedBy>
<Document:CreatedBy xsi:type="Document:Associate">
<Document:AssociateId xsi:type="xsd:int">0</Document:AssociateId>
<Document:Name xsi:type="xsd:string"></Document:Name>
<Document:PersonId xsi:type="xsd:int">0</Document:PersonId>
<Document:Rank xsi:type="xsd:short">0</Document:Rank>
<Document:Tooltip xsi:type="xsd:string"></Document:Tooltip>
<Document:Type xsi:type="Document:UserType">Unknown</Document:Type>
<Document:GroupIdx xsi:type="xsd:int">0</Document:GroupIdx>
<Document:FullName xsi:type="xsd:string"></Document:FullName>
<Document:FormalName xsi:type="xsd:string"></Document:FormalName>
<Document:Deleted xsi:type="xsd:boolean">false</Document:Deleted>
<Document:EjUserId xsi:type="xsd:int">0</Document:EjUserId>
<Document:UserName xsi:type="xsd:string"></Document:UserName>
</Document:CreatedBy>
<Document:Attention xsi:type="xsd:string"></Document:Attention>
<Document:Header xsi:type="xsd:string"></Document:Header>
<Document:Name xsi:type="xsd:string"></Document:Name>
<Document:OurRef xsi:type="xsd:string"></Document:OurRef>
<Document:YourRef xsi:type="xsd:string"></Document:YourRef>
<Document:CreatedDate xsi:type="xsd:dateTime">2021-11-30T13:23:13Z</Document:CreatedDate>
<Document:UpdatedDate xsi:type="xsd:dateTime">2021-11-30T13:23:13Z</Document:UpdatedDate>
<Document:Description xsi:type="xsd:string"></Document:Description>
<Document:DocumentTemplate xsi:type="Document:DocumentTemplate">
<Document:DocumentTemplateId xsi:type="xsd:int">0</Document:DocumentTemplateId>
<Document:Name xsi:type="xsd:string"></Document:Name>
<Document:Tooltip xsi:type="xsd:string"></Document:Tooltip>
<Document:SaveInDb xsi:type="xsd:short">0</Document:SaveInDb>
<Document:Filename xsi:type="xsd:string"></Document:Filename>
<Document:DefaultOref xsi:type="xsd:string"></Document:DefaultOref>
<Document:RecordType xsi:type="Document:DocTmplType">Unknown</Document:RecordType>
<Document:Deleted xsi:type="xsd:short">0</Document:Deleted>
<Document:Direction xsi:type="Document:DocTmplDirection">Unknown</Document:Direction>
<Document:AutoeventId xsi:type="xsd:int">0</Document:AutoeventId>
<Document:QuoteDocType xsi:type="Document:DocTmplQuoteType">None</Document:QuoteDocType>
</Document:DocumentTemplate>
<Document:Person xsi:type="Document:Person">
<Document:Position xsi:type="xsd:string"></Document:Position>
<Document:PersonId xsi:type="xsd:int">0</Document:PersonId>
<Document:Mrmrs xsi:type="xsd:string"></Document:Mrmrs>
<Document:Firstname xsi:type="xsd:string"></Document:Firstname>
<Document:Lastname xsi:type="xsd:string"></Document:Lastname>
<Document:MiddleName xsi:type="xsd:string"></Document:MiddleName>
<Document:Title xsi:type="xsd:string"></Document:Title>
<Document:Description xsi:type="xsd:string"></Document:Description>
<Document:Email xsi:type="xsd:string"></Document:Email>
<Document:FullName xsi:type="xsd:string"></Document:FullName>
<Document:DirectPhone xsi:type="xsd:string"></Document:DirectPhone>
<Document:FormalName xsi:type="xsd:string"></Document:FormalName>
<Document:CountryId xsi:type="xsd:int">0</Document:CountryId>
<Document:ContactId xsi:type="xsd:int">0</Document:ContactId>
<Document:ContactName xsi:type="xsd:string"></Document:ContactName>
<Document:Retired xsi:type="xsd:short">0</Document:Retired>
<Document:Rank xsi:type="xsd:short">0</Document:Rank>
<Document:ActiveInterests xsi:type="xsd:short">0</Document:ActiveInterests>
<Document:ContactDepartment xsi:type="xsd:string"></Document:ContactDepartment>
<Document:ContactCountryId xsi:type="xsd:int">0</Document:ContactCountryId>
<Document:ContactOrgNr xsi:type="xsd:string"></Document:ContactOrgNr>
<Document:FaxPhone xsi:type="xsd:string"></Document:FaxPhone>
<Document:MobilePhone xsi:type="xsd:string"></Document:MobilePhone>
<Document:ContactPhone xsi:type="xsd:string"></Document:ContactPhone>
<Document:AssociateName xsi:type="xsd:string"></Document:AssociateName>
<Document:AssociateId xsi:type="xsd:int">0</Document:AssociateId>
<Document:UsePersonAddress xsi:type="xsd:boolean">false</Document:UsePersonAddress>
<Document:ContactFax xsi:type="xsd:string"></Document:ContactFax>
<Document:Kanafname xsi:type="xsd:string"></Document:Kanafname>
<Document:Kanalname xsi:type="xsd:string"></Document:Kanalname>
<Document:Post1 xsi:type="xsd:string"></Document:Post1>
<Document:Post2 xsi:type="xsd:string"></Document:Post2>
<Document:Post3 xsi:type="xsd:string"></Document:Post3>
<Document:EmailName xsi:type="xsd:string"></Document:EmailName>
<Document:ContactFullName xsi:type="xsd:string"></Document:ContactFullName>
<Document:ActiveErpLinks xsi:type="xsd:int">0</Document:ActiveErpLinks>
<Document:TicketPriorityId xsi:type="xsd:int">0</Document:TicketPriorityId>
<Document:SupportLanguageId xsi:type="xsd:int">0</Document:SupportLanguageId>
<Document:SupportAssociateId xsi:type="xsd:int">0</Document:SupportAssociateId>
<Document:CategoryName xsi:type="xsd:string"></Document:CategoryName>
</Document:Person>
<Document:Associate xsi:type="Document:Associate">
<Document:AssociateId xsi:type="xsd:int">0</Document:AssociateId>
<Document:Name xsi:type="xsd:string"></Document:Name>
<Document:PersonId xsi:type="xsd:int">0</Document:PersonId>
<Document:Rank xsi:type="xsd:short">0</Document:Rank>
<Document:Tooltip xsi:type="xsd:string"></Document:Tooltip>
<Document:Type xsi:type="Document:UserType">Unknown</Document:Type>
<Document:GroupIdx xsi:type="xsd:int">0</Document:GroupIdx>
<Document:FullName xsi:type="xsd:string"></Document:FullName>
<Document:FormalName xsi:type="xsd:string"></Document:FormalName>
<Document:Deleted xsi:type="xsd:boolean">false</Document:Deleted>
<Document:EjUserId xsi:type="xsd:int">0</Document:EjUserId>
<Document:UserName xsi:type="xsd:string"></Document:UserName>
</Document:Associate>
<Document:Contact xsi:type="Document:Contact">
<Document:ContactId xsi:type="xsd:int">0</Document:ContactId>
<Document:Name xsi:type="xsd:string"></Document:Name>
<Document:OrgNr xsi:type="xsd:string"></Document:OrgNr>
<Document:Department xsi:type="xsd:string"></Document:Department>
<Document:URL xsi:type="xsd:string"></Document:URL>
<Document:City xsi:type="xsd:string"></Document:City>
<Document:DirectPhone xsi:type="xsd:string"></Document:DirectPhone>
<Document:AssociateId xsi:type="xsd:int">0</Document:AssociateId>
<Document:CountryId xsi:type="xsd:int">0</Document:CountryId>
<Document:EmailAddress xsi:type="xsd:string"></Document:EmailAddress>
<Document:Kananame xsi:type="xsd:string"></Document:Kananame>
<Document:EmailAddressName xsi:type="xsd:string"></Document:EmailAddressName>
<Document:URLName xsi:type="xsd:string"></Document:URLName>
<Document:AssociateFullName xsi:type="xsd:string"></Document:AssociateFullName>
<Document:BusinessName xsi:type="xsd:string"></Document:BusinessName>
<Document:CategoryName xsi:type="xsd:string"></Document:CategoryName>
<Document:CountryName xsi:type="xsd:string"></Document:CountryName>
<Document:Address xsi:type="Document:Address">
<Document:Wgs84Latitude xsi:type="xsd:double">0.0</Document:Wgs84Latitude>
<Document:Wgs84Longitude xsi:type="xsd:double">0.0</Document:Wgs84Longitude>
<Document:LocalizedAddress xsi:type="Document:ArrayOfArrayOfLocalizedField">
<Document:ArrayOfLocalizedField xsi:type="Document:ArrayOfLocalizedField">
<Document:LocalizedField xsi:nil="true"></Document:LocalizedField>
</Document:ArrayOfLocalizedField>
</Document:LocalizedAddress>
<Document:Street xsi:type="Document:StructuredAddress">
<Document:AtypeIdx xsi:type="Document:AddressType">Unknown</Document:AtypeIdx>
<Document:Address1 xsi:type="xsd:string"></Document:Address1>
<Document:Address2 xsi:type="xsd:string"></Document:Address2>
<Document:Address3 xsi:type="xsd:string"></Document:Address3>
<Document:City xsi:type="xsd:string"></Document:City>
<Document:County xsi:type="xsd:string"></Document:County>
<Document:State xsi:type="xsd:string"></Document:State>
<Document:Zipcode xsi:type="xsd:string"></Document:Zipcode>
<Document:Formatted xsi:type="xsd:string"></Document:Formatted>
</Document:Street>
<Document:Postal xsi:type="Document:StructuredAddress">
<Document:AtypeIdx xsi:type="Document:AddressType">Unknown</Document:AtypeIdx>
<Document:Address1 xsi:type="xsd:string"></Document:Address1>
<Document:Address2 xsi:type="xsd:string"></Document:Address2>
<Document:Address3 xsi:type="xsd:string"></Document:Address3>
<Document:City xsi:type="xsd:string"></Document:City>
<Document:County xsi:type="xsd:string"></Document:County>
<Document:State xsi:type="xsd:string"></Document:State>
<Document:Zipcode xsi:type="xsd:string"></Document:Zipcode>
<Document:Formatted xsi:type="xsd:string"></Document:Formatted>
</Document:Postal>
<Document:Formatted xsi:type="xsd:string"></Document:Formatted>
</Document:Address>
<Document:FormattedAddress xsi:type="xsd:string"></Document:FormattedAddress>
<Document:FullName xsi:type="xsd:string"></Document:FullName>
<Document:IsOwnerContact xsi:type="xsd:boolean">false</Document:IsOwnerContact>
<Document:ActiveErpLinks xsi:type="xsd:int">0</Document:ActiveErpLinks>
</Document:Contact>
<Document:Project xsi:type="Document:Project">
<Document:ProjectId xsi:type="xsd:int">0</Document:ProjectId>
<Document:Name xsi:type="xsd:string"></Document:Name>
<Document:Description xsi:type="xsd:string"></Document:Description>
<Document:URL xsi:type="xsd:string"></Document:URL>
<Document:Type xsi:type="xsd:string"></Document:Type>
<Document:AssociateId xsi:type="xsd:int">0</Document:AssociateId>
<Document:AssociateFullName xsi:type="xsd:string"></Document:AssociateFullName>
<Document:TypeId xsi:type="xsd:int">0</Document:TypeId>
<Document:Updated xsi:type="xsd:dateTime">2021-11-30T13:23:13Z</Document:Updated>
<Document:StatusId xsi:type="xsd:int">0</Document:StatusId>
<Document:Status xsi:type="xsd:string"></Document:Status>
<Document:TextId xsi:type="xsd:int">0</Document:TextId>
<Document:PublishTo xsi:type="xsd:dateTime">2021-11-30T13:23:13Z</Document:PublishTo>
<Document:PublishFrom xsi:type="xsd:dateTime">2021-11-30T13:23:13Z</Document:PublishFrom>
<Document:IsPublished xsi:type="xsd:boolean">false</Document:IsPublished>
<Document:URLName xsi:type="xsd:string"></Document:URLName>
<Document:ProjectNumber xsi:type="xsd:string"></Document:ProjectNumber>
<Document:ActiveErpLinks xsi:type="xsd:int">0</Document:ActiveErpLinks>
</Document:Project>
<Document:Date xsi:type="xsd:dateTime">2021-11-30T13:23:13Z</Document:Date>
<Document:ExternalRef xsi:type="xsd:string"></Document:ExternalRef>
<Document:Completed xsi:type="Document:ActivityStatus">Unknown</Document:Completed>
<Document:ActiveLinks xsi:type="xsd:int">0</Document:ActiveLinks>
<Document:Type xsi:type="Document:AppointmentType">Unknown</Document:Type>
<Document:Links xsi:type="Document:ArrayOfLink">
<Document:Link xsi:type="Document:Link">
<Document:EntityName xsi:type="xsd:string"></Document:EntityName>
<Document:Id xsi:type="xsd:int">0</Document:Id>
<Document:Description xsi:type="xsd:string"></Document:Description>
<Document:ExtraInfo xsi:type="xsd:string"></Document:ExtraInfo>
<Document:LinkId xsi:type="xsd:int">0</Document:LinkId>
</Document:Link>
</Document:Links>
<Document:LockSemantics xsi:type="Document:DocumentLockSemantics">None</Document:LockSemantics>
<Document:Sale xsi:type="Document:Sale">
<Document:ContactName xsi:type="xsd:string"></Document:ContactName>
<Document:SaleDate xsi:type="xsd:dateTime">2021-11-30T13:23:13Z</Document:SaleDate>
<Document:SaleId xsi:type="xsd:int">0</Document:SaleId>
<Document:Probability xsi:type="xsd:short">0</Document:Probability>
<Document:Title xsi:type="xsd:string"></Document:Title>
<Document:Amount xsi:type="xsd:double">0.0</Document:Amount>
<Document:Currency xsi:type="xsd:string"></Document:Currency>
<Document:ProjectName xsi:type="xsd:string"></Document:ProjectName>
<Document:AssociateFullName xsi:type="xsd:string"></Document:AssociateFullName>
<Document:Description xsi:type="xsd:string"></Document:Description>
<Document:Status xsi:type="Document:SaleStatus">Unknown</Document:Status>
<Document:WeightedAmount xsi:type="xsd:double">0.0</Document:WeightedAmount>
<Document:ProjectId xsi:type="xsd:int">0</Document:ProjectId>
<Document:EarningPercent xsi:type="xsd:double">0.0</Document:EarningPercent>
<Document:Earning xsi:type="xsd:double">0.0</Document:Earning>
<Document:ContactId xsi:type="xsd:int">0</Document:ContactId>
<Document:AssociateId xsi:type="xsd:int">0</Document:AssociateId>
<Document:PersonId xsi:type="xsd:int">0</Document:PersonId>
<Document:SaleTypeId xsi:type="xsd:int">0</Document:SaleTypeId>
<Document:SaleTypeName xsi:type="xsd:string"></Document:SaleTypeName>
<Document:PersonFullName xsi:type="xsd:string"></Document:PersonFullName>
<Document:Completed xsi:type="Document:ActivityStatus">Unknown</Document:Completed>
<Document:ActiveErpLinks xsi:type="xsd:int">0</Document:ActiveErpLinks>
<Document:NextDueDate xsi:type="xsd:dateTime">2021-11-30T13:23:13Z</Document:NextDueDate>
</Document:Sale>
<Document:SuggestedDocumentId xsi:type="xsd:int">0</Document:SuggestedDocumentId>
<Document:Snum xsi:type="xsd:int">0</Document:Snum>
<Document:UserDefinedFields xsi:type="Document:StringDictionary">
<Document:StringKeyValuePair>
<Document:Key xsi:type="xsd:string"></Document:Key>
<Document:Value xsi:type="xsd:string"></Document:Value>
</Document:StringKeyValuePair>
</Document:UserDefinedFields>
<Document:ExtraFields xsi:type="Document:StringDictionary">
<Document:StringKeyValuePair>
<Document:Key xsi:type="xsd:string"></Document:Key>
<Document:Value xsi:type="xsd:string"></Document:Value>
</Document:StringKeyValuePair>
</Document:ExtraFields>
<Document:CustomFields xsi:type="Document:StringDictionary">
<Document:StringKeyValuePair>
<Document:Key xsi:type="xsd:string"></Document:Key>
<Document:Value xsi:type="xsd:string"></Document:Value>
</Document:StringKeyValuePair>
</Document:CustomFields>
<Document:PublishEventDate xsi:type="xsd:dateTime">2021-11-30T13:23:13Z</Document:PublishEventDate>
<Document:PublishTo xsi:type="xsd:dateTime">2021-11-30T13:23:13Z</Document:PublishTo>
<Document:PublishFrom xsi:type="xsd:dateTime">2021-11-30T13:23:13Z</Document:PublishFrom>
<Document:IsPublished xsi:type="xsd:boolean">false</Document:IsPublished>
<Document:VisibleFor xsi:type="Document:ArrayOfVisibleFor">
<Document:VisibleFor xsi:type="Document:VisibleFor">
<Document:VisibleId xsi:type="xsd:int">0</Document:VisibleId>
<Document:Visibility xsi:type="Document:Visibility">All</Document:Visibility>
<Document:DisplayValue xsi:type="xsd:string"></Document:DisplayValue>
</Document:VisibleFor>
</Document:VisibleFor>
</Document:DocumentEntity>
</Document:Parameters>
</Document:SubstituteTemplateVariablesEx>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
```
## SubstituteTemplateVariablesEx Response
```xml
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope
xmlns:SOAP-ENV="http://www.w3.org/2003/05/soap-envelope"
xmlns:SOAP-ENC="http://www.w3.org/2003/05/soap-encoding"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:NetServerServices872="http://schemas.microsoft.com/2003/10/Serialization/Arrays"
xmlns:NetServerServices871="http://schemas.microsoft.com/2003/10/Serialization/"
xmlns:Document="http://www.superoffice.net/ws/crm/NetServer/Services87">
<SOAP-ENV:Body>
<Document:SubstituteTemplateVariablesExResponse>
<Document:Response xsi:type="xsd:string"></Document:Response>
</Document:SubstituteTemplateVariablesExResponse>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
```
| 62.249284 | 268 | 0.720092 | yue_Hant | 0.990287 |
47396efccc568fa07265a6a971a20667fd927cfc | 191 | md | Markdown | domain/eqworks.com/index.md | billfitzgerald/smmd | 9af567b54b39dc2872cf0ee6c3ada27627490c42 | [
"CC-BY-4.0",
"MIT"
] | 2 | 2020-12-20T19:10:17.000Z | 2021-07-18T22:32:37.000Z | domain/eqworks.com/index.md | billfitzgerald/smmd | 9af567b54b39dc2872cf0ee6c3ada27627490c42 | [
"CC-BY-4.0",
"MIT"
] | 8 | 2020-06-19T16:02:03.000Z | 2021-08-24T16:49:39.000Z | domain/eqworks.com/index.md | billfitzgerald/smmd | 9af567b54b39dc2872cf0ee6c3ada27627490c42 | [
"CC-BY-4.0",
"MIT"
] | 1 | 2020-06-29T20:36:31.000Z | 2020-06-29T20:36:31.000Z | ---
company-name: "EQ Works (formerly Cyberplex)"
domain: eqworks.com
home: https://www.eqworks.com/
privacy-policy: https://www.eqworks.com/privacy-policy/
email: [email protected]
---
| 17.363636 | 55 | 0.727749 | yue_Hant | 0.426154 |
4739f0df82f7ee2177c285622562921072f984b0 | 34,146 | md | Markdown | EssentialsDocs/install/Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md | ilchiodi/windowsserverdocs.it-it | c9a108584b6430aed06a10c888377ec29480fd01 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | EssentialsDocs/install/Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md | ilchiodi/windowsserverdocs.it-it | c9a108584b6430aed06a10c888377ec29480fd01 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | EssentialsDocs/install/Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md | ilchiodi/windowsserverdocs.it-it | c9a108584b6430aed06a10c888377ec29480fd01 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: Distribuire Esperienza Windows Server Essentials come server ospitato
description: Viene descritto come usare Windows Server Essentials
ms.date: 10/03/2016
ms.prod: windows-server
ms.topic: article
ms.assetid: a455c6b4-b29f-4f76-8c6b-1578b6537717
author: nnamuhcs
ms.author: coreyp
manager: dongill
ms.openlocfilehash: 9ddeaedb09346216585b2eb1237ed9340da59756
ms.sourcegitcommit: b00d7c8968c4adc8f699dbee694afe6ed36bc9de
ms.translationtype: MT
ms.contentlocale: it-IT
ms.lasthandoff: 04/08/2020
ms.locfileid: "80817974"
---
# <a name="deploy-windows-server-essentials-experience-as-a-hosted-server"></a>Distribuire Esperienza Windows Server Essentials come server ospitato
>Si applica a: Windows Server 2016 Essentials, Windows Server 2012 R2 Essentials, Windows Server 2012 Essentials
Questo documento contiene informazioni specifiche per i provider di hosting che intendono distribuire Microsoft Windows Server 16 con il ruolo esperienza Windows Server Essentials (denominato Windows Server Essentials nella parte restante del documento) installato nel proprio Lab e si intende offrire esperienza Windows Server Essentials come servizio ai propri clienti. In questo documento sono incluse le sezioni seguenti:
- [Panoramica di esperienza Windows Server Essentials](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_WSEEOverview)
- [Vantaggi dell'hosting di esperienza Windows Server Essentials](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_Benefits)
- [Opzioni di distribuzione supportate](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_SupportedDeployment)
- [Topologie di rete supportate](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_SupportedToplogy)
- [Personalizzare l'immagine del ruolo esperienza Windows Server Essentials](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_CustomizeImage)
- [Automatizzare la distribuzione dell'esperienza Windows Server Essentials](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_AutomateDeployment)
- [Eseguire la migrazione dei dati da Windows Small Business Server a esperienza Windows Server Essentials](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_Migrate)
- [Eseguire attività comuni usando Windows PowerShell](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_PowerShell)
- [Integrazione della posta elettronica con Windows Server Essentials](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_EmailIntegration)
- [Monitorare e gestire mediante strumenti nativi](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_Monitoring)
- [Scenari di test](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_Scenarios)
- [Informazioni di supporto](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_Support)
- [Panoramica di esperienza Windows Server Essentials](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_WSEEOverview)
- [Vantaggi dell'hosting di esperienza Windows Server Essentials](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_Benefits)
- [Opzioni di distribuzione supportate](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_SupportedDeployment)
- [Topologie di rete supportate](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_SupportedToplogy)
- [Personalizzare l'immagine del ruolo esperienza Windows Server Essentials](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_CustomizeImage)
- [Automatizzare la distribuzione dell'esperienza Windows Server Essentials](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_AutomateDeployment)
- [Eseguire la migrazione dei dati da Windows Small Business Server a esperienza Windows Server Essentials](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_Migrate)
- [Eseguire attività comuni usando Windows PowerShell](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_PowerShell)
- [Integrazione della posta elettronica con Windows Server Essentials](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_EmailIntegration)
- [Monitorare e gestire mediante strumenti nativi](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_Monitoring)
- [Scenari di test](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_Scenarios)
- [Informazioni di supporto](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_Support)
## <a name="windows-server-essentials-experience-overview"></a><a name="BKMK_WSEEOverview"></a>Panoramica di esperienza Windows Server Essentials
L'esperienza Windows Server Essentials è un ruolo del server disponibile in Windows Server 2012 R2 Standard e Windows Server 2012 R2 Datacenter. Quando il ruolo esperienza Windows Server Essentials è installato in un server che esegue Windows Server 2012 R2, il cliente può usufruire di tutte le funzionalità disponibili in Windows Server Essentials senza i blocchi e i limiti. L'esperienza Windows Server Essentials Abilita le soluzioni cross-premise seguenti per le aziende di piccole e medie dimensioni:
- **Archiviazione e protezione dei dati** È possibile archiviare i dati del cliente in una posizione centralizzata e proteggere i dati del server e del client eseguendo il backup dei computer server e client (meno di 75) all'interno della rete.
- **Gestione degli utenti** È possibile gestire utenti e gruppi tramite il dashboard del server semplificato. Inoltre, l'integrazione con Microsoft Azure Active Directory (Azure AD) consente di accedere facilmente ai dati per Microsoft Servizi online (ad esempio, Office 365, Exchange Online e SharePoint Online) per gli utenti usando le proprie credenziali di dominio.
- **Integrazione del servizio** È possibile integrare il server con Microsoft Servizi online (ad esempio Office 365, SharePoint Online e Backup di Microsoft Azure). È anche possibile integrare il server con i propri servizi o con servizi forniti da provider di terze parti.
- **Accesso remoto via Internet** I clienti possono accedere al server, ai computer della rete e ai dati pressoché da qualunque luogo e con qualunque dispositivo, purché sia disponibile una connessione Internet. La funzionalità Accesso Web remoto consente di accedere ad applicazioni e dati con un'esperienza di esplorazione semplificata e ottimizzata per il tocco. L'app My Server consente loro di accedere ai dati da un'app Windows Phone o Microsoft Store.
- **Flussi multimediali** Se si installa il pacchetto multimediale in un server con esperienza Windows Server Essentials abilitata, il cliente finale può archiviare musica, video e fotografie in cartelle condivise e quindi accedere a questi file multimediali da computer in rete o Accesso Web remoto.
- **Monitoraggio dello stato** È possibile monitorare lo stato della rete e ottenere rapporti di stato personalizzati.
## <a name="benefits-of-hosting-windows-server-essentials-experience"></a><a name="BKMK_Benefits"></a>Vantaggi dell'hosting di esperienza Windows Server Essentials
Esperienza Windows Server Essentials è un ruolo di Windows Server, pertanto è possibile riutilizzare il Framework di distribuzione e gestione esistente in Windows Server per distribuire e configurare il ruolo esperienza Windows Server Essentials. L'hosting del ruolo esperienza Windows Server Essentials offre i vantaggi seguenti:
- **Distribuzione semplificata** Semplicemente attivando il ruolo esperienza Windows Server Essentials, alcuni dei ruoli e delle funzionalità di uso più comune vengono attivati e configurati con le procedure consigliate per le aziende di piccole e medie dimensioni. È possibile personalizzare le funzionalità di Windows Server Essentials o nascondere alcune delle funzionalità locali. Se si usa il Windows Azure Pack, è possibile scaricare il modello di raccolta per esperienza Windows Server Essentials in Windows Server 2012 R2.
- **Dashboard semplificato** Il dashboard di Windows Server Essentials semplifica le attività comuni quali la gestione di cartelle del server, archiviazione sul server, backup e ripristino, account utente o di gruppo, dispositivi, accesso remoto e posta elettronica. I clienti aziendali di piccole e medie dimensioni possono eseguire attività di gestione quotidiane anziché rivolgersi all'Help Desk per il supporto tecnico.
- **Estendibilità** Il dashboard e il software Connettore di Windows Server Essentials Dashboard sono estendibili. È possibile aggiungere personalizzazioni e integrazione dei servizi, in modo che i clienti dispongano di un punto di ingresso unico per tutti gli elementi del propri server e servizi.
- **Monitoraggio** È disponibile una nuova versione di System Center Monitoring Pack per monitorare e gestire più server che eseguono Windows Server Essentials. Per scaricare il Management Pack, vedere [System Center Management Pack per Windows Server Essentials](https://www.microsoft.com/download/details.aspx?id=40809).
## <a name="supported-deployment-options"></a><a name="BKMK_SupportedDeployment"></a>Opzioni di distribuzione supportate
L'esperienza Windows Server Essentials può essere distribuita come controller di dominio in un nuovo ambiente di Active Directory; oppure può essere distribuito in un ambiente di Active Directory esistente come membro del dominio.
Si consiglia di distribuire prima Windows Server 2012 R2 Standard o Windows Server 2012 R2 Datacenter, quindi installare il ruolo esperienza Windows Server Essentials. Con questo metodo di distribuzione, si ottengono tutte le funzionalità di Windows Server Essentials Edition senza i blocchi e i limiti.
Per altre informazioni sull'installazione di Windows Server 2012 R2 con il ruolo esperienza Windows Server Essentials, vedere [installare e configurare Windows Server Essentials](Install-and-Configure-Windows-Server-Essentials-or-Windows-Server-Essentials-Experience.md).
## <a name="supported-network-topologies"></a><a name="BKMK_SupportedToplogy"></a>Topologie di rete supportate
Per usare esperienza Windows Server Essentials da un client di roaming, è necessario abilitare la VPN. Per abilitare l'accesso remoto al server dai client in roaming, è necessario aprire le porte 443 e 80 sul server.
Di seguito sono riportate due tipiche topologie di rete lato server e un esempio di configurazione VPN/Accesso Web remoto:
- **Topologia 1** (si tratta della topologia preferita, che inserisce tutti i server e l'intervallo di indirizzi IP della VPN nella stessa subnet):
- Configurare il server in una rete virtuale distinta su un dispositivo NAT.
- Abilitare il servizio DHCP nella rete virtuale oppure assegnare al server un indirizzo IP statico.
- Inoltrare la porta 443 con IP pubblico sul router all'indirizzo di rete locale del server.
- Consentire il passthrough VPN per la porta 443.
- Includere il pool di indirizzi IPv4 della VPN nella stesso intervallo di subnet dell'indirizzo del server
- Assegnare a ogni secondo server un indirizzo IP statico nell'ambito della stessa subnet, ma al di fuori del pool di indirizzi della VPN.
- **Topologia 2**:
- Assegnare al server un indirizzo IP privato.
- Consentire alla porta 443 del server di raggiungere una porta 443 con indirizzo IP pubblico.
- Consentire il passthrough VPN per la porta 443.
- Assegnare al pool di indirizzi IPv4 della VPN un intervallo diverso rispetto all'indirizzo del server.
Con la topologia 2 gli scenari con un secondo server non sono supportati, in quanto non è possibile aggiungere un altro server allo stesso dominio.
È possibile abilitare la VPN durante una distribuzione automatica usando l'apposito script di Windows PowerShell oppure è possibile configurarla tramite procedura guidata dopo la configurazione iniziale.
Per abilitare la VPN usando Windows PowerShell, eseguire il comando seguente con privilegi amministrativi nel server che esegue Windows Server Essentials e inserire tutte le informazioni necessarie.
```
##
## To configure external domain and SSL certificate (if not yet done in unattended Initial Configuration).
##
$myExternalDomainName = 'remote.contoso.com'; ## corresponds to A or AAAA DNS record(s) that can be resolved on Internet and routed to the server
$mySslCertificateFile = 'C:\ssl.pfx'; ## full path to SSL certificate file
$mySslCertificatePassword = ConvertTo-SecureString œAsPlainText œForce '******'; ## password for private key of the SSL certificate
$skipCertificateVerification = $true; ## whether or not, skip verification for the SSL certificate
Set-WssDomainNameConfiguration œDomainName $myExternalDomainName œCertificatePath $mySslCertificateFile œCertificateFilePassword $mySslCertificatePassword œNoCertificateVerification
##
## To install VPN with static IPv4 pool (and allow all existing users to establish VPN).
##
Install-WssVpnServer -IPv4AddressRange ('192.168.0.160','192.168.0.240') -ApplyToExistingUsers;
```
> [!NOTE]
> Se non è possibile fornire una connessione VPN prima di consegnare il server ai clienti, verificare che la porta server 3389 sia disponibile su Internet in modo che i clienti possano usare Remote Desktop Protocol per connettersi al server e configurarlo.
## <a name="customize-the-image-of-windows-server-essentials-experience-role"></a><a name="BKMK_CustomizeImage"></a>Personalizzare l'immagine del ruolo esperienza Windows Server Essentials
È possibile personalizzare l'immagine prima di configurare il ruolo Esperienza Windows Server Essentials. Per informazioni sul processo Sysprep standard di Windows Server, vedere [Windows Assessment and Deployment Kit](https://msdn.microsoft.com/library/hh825420.aspx). Dopo aver preparato l'immagine usando Sysprep, è possibile usarla oppure sigillarla nel file Install.wim per una nuova distribuzione.
Se si usa Virtual Machine Manager, è possibile creare un modello usando l'istanza corrente. Questo processo usa Sysprep per preparare l'istanza e spegne il computer. Dopo aver archiviato il modello nella libreria, sarà possibile usare l'istanza caso per caso.
Dopo aver installato il ruolo esperienza Windows Server Essentials, è possibile personalizzare le funzionalità in Windows Server Essentials. Una delle personalizzazioni più importanti è la chiave del Registro di sistema **IsHosted** : **HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows Server\Deployment\IsHosted**.
Se questa chiave è impostata su 0x1, il comportamento di alcune delle funzionalità locali verrà modificato. Le modifiche delle funzionalità includono:
- **Backup client** Il backup del client verrà disattivato per impostazione predefinita per i nuovi computer client aggiunti.
- **Servizio Ripristino client** Il servizio Ripristino client verrà disabilitato e la relativa interfaccia utente verrà nascosta dal Dashboard.
- **Cronologia file** Le impostazioni di cronologia file per i nuovi account utente creati non verranno gestite automaticamente dal server.
- **Backup server** Il servizio Backup server verrà disabilitato e la relativa interfaccia utente verrà nascosta dal dashboard.
- **Spazi di archiviazione** L'interfaccia utente per la creazione o la gestione degli spazi di archiviazione verrà nascosta dal dashboard.
- **Accesso remoto via Internet** La configurazione del router e della VPN verrà ignorata per impostazione predefinita quando si esegue la procedura guidata Configura Accesso remoto via Internet.
Se si vuole controllare il comportamento delle funzionalità elencate, è possibile impostare la chiave del Registro di sistema corrispondente per ognuna di esse. Per informazioni su come impostare la chiave del Registro di sistema, vedere [Personalizzare e distribuire Windows Server Essentials in Windows Server 2012 R2](https://technet.microsoft.com/library/dn293241.aspx)
## <a name="automate-the-deployment-of-windows-server-essentials-experience"></a><a name="BKMK_AutomateDeployment"></a>Automatizzare la distribuzione dell'esperienza Windows Server Essentials
Per automatizzare la distribuzione, è necessario innanzitutto distribuire il sistema operativo e quindi installare il ruolo esperienza Windows Server Essentials.
- Per distribuire automaticamente Windows Server 2012 R2 Standard o Windows Server 2012 R2 Datacenter, seguire le istruzioni riportate in [Windows Assessment and Deployment Kit](https://msdn.microsoft.com/library/hh825420.aspx).
- Per informazioni su come installare il ruolo esperienza Windows Server Essentials usando Windows PowerShell, vedere [installare e configurare Windows Server Essentials](https://technet.microsoft.com/library/dn281793.aspx).
> [!NOTE]
> Verificare che le impostazioni del fuso orario della macchina virtuale host e dell'esperienza Windows Server Essentials siano le stesse. In caso contrario potrebbero verificarsi diversi errori, Tra cui: la configurazione iniziale del server potrebbe non avere esito positivo nelle attività relative ai certificati, il certificato potrebbe non funzionare per alcune ore dopo l'installazione del ruolo esperienza Windows Server Essentials e le informazioni sul dispositivo non verranno aggiornate correttamente.
Dopo la distribuzione, usare il cmdlet di Windows PowerShell **Get-WssConfigurationStatus** per verificare che la configurazione iniziale sia stata eseguita correttamente. Lo stato restituito deve essere uno dei seguenti: **Notstarted**, **FinishedWithWarning**, **Running**, **Finished**, **Failed**o **PendingReboot**.
Il server verrà riavviato durante la configurazione iniziale. Se è necessario impedire il riavvio automatico, è possibile usare il comando seguente per aggiungere una chiave del Registro di sistema prima di avviare la configurazione iniziale:
```
New-ItemProperty "HKLM:\Software\Microsoft\Windows Server\Setup" -Name "WaitForReboot" -Value 1 -PropertyType "DWord" -Force -Confirm:$false
```
Dopo l'avvio della configurazione iniziale, è possibile usare **Get-WssConfigurationStatus** per controllare lo stato di configurazione iniziale e, quando lo stato è **PendingReboot**, è possibile riavviare il server.
## <a name="migrate-data-from-windows-small-business-server-to-windows-server-essentials-experience"></a><a name="BKMK_Migrate"></a>Eseguire la migrazione dei dati da Windows Small Business Server a esperienza Windows Server Essentials
È possibile eseguire la migrazione dei dati da server che eseguono Windows Small Business Server 2011, Windows Small Business Server 2008, Windows Small Business Server 2003 o Windows Server Essentials al server che esegue Windows Server Essentials. Esaminare la guida alla migrazione [di Windows Server Essentials](../migrate/Migrate-from-Previous-Versions-to-Windows-Server-Essentials-or-Windows-Server-Essentials-Experience.md) per la le migrazioni locale e apportare le necessarie personalizzazioni in base all'ambiente di hosting.
> [!NOTE]
> È consigliabile includere il server di origine e il server di destinazione nella stessa subnet. Se questo non è possibile, verificare se:
>
> - Il server di origine e il server di destinazione possono accedere reciprocamente "¢ s internal Domain Names.
> - Tutte le porte necessarie sono aperte.
Dopo la migrazione, è possibile aggiornare le licenze per rimuovere i blocchi e limiti. Per altre informazioni, vedere [transizione da Windows Server Essentials a Windows server 2012 standard](https://technet.microsoft.com/library/jj247582.aspx).
## <a name="perform-common-tasks-by-using-windows-powershell"></a><a name="BKMK_PowerShell"></a>Eseguire attività comuni usando Windows PowerShell
Questa sezione illustra alcune delle attività comuni che è possibile eseguire usando Windows PowerShell.
### <a name="enable-remote-web-access"></a>Abilita Accesso Web remoto
**Sintassi**:
Enable-WssRemoteWebAccess [-SkipRouter] [-DenyAccessByDefault] [-ApplyToExistingUsers]
**Esempio**:
$Enable-WssRemoteWebAccess œDenyAccessByDefault œApplyToExistingUsers
Questo comando consente di abilitare Accesso Web remoto con il router configurato automaticamente e modifica le autorizzazione di accesso predefinite per tutti gli utenti esistenti.
### <a name="add-user"></a>Aggiungere un utente
**Sintassi**:
Add-WssUser [-name] < stringa\> [-password] < SecureString\> [-AccessLevel < String\> {user | Administrator}] [-FirstName < String\>] [-LastName < String\>] [-AllowRemoteAccess] [-AllowVpnAccess] [< parametricomuni\>]
**Esempio**:
$password = ConvertTo-SecureString "Passw0rd!" -AsPlainText œforce $ Add-WssUser-Name User2Test-password $password-AccessLevel Administrator-FirstName User2-LastName test
Con questo comando verrà aggiunto un amministratore denominato User2Test con password Passw0rd!.
### <a name="add-server-folder"></a>Aggiungi cartella server
**Sintassi**:
Add-WssFolder [-name] < stringa\> [-path] < stringa\> [[-Description] < stringa\>] [-KeepPermissions] [< Parametricomuni\>]
**Esempio**:
$Add-WssFolder -Name "MyTestFolder" -Path "C:\ServerFolders\MyTestFolder"
Tramite questo comando verrà aggiunta una cartella del server denominata MyTestFolder nel percorso specificato.
## <a name="email-integration-with-windows-server-essentials"></a><a name="BKMK_EmailIntegration"></a>Integrazione della posta elettronica con Windows Server Essentials
È possibile integrare esperienza Windows Server Essentials con Office 365 o Exchange Server ospitato. Se si vuole che i clienti usino la propria soluzione di posta elettronica su host, è necessario sviluppare un componente aggiuntivo per integrare Esperienza Windows Server Essentials in questa soluzione. Per altre informazioni, vedere [Windows Server Essentials SDK](https://msdn.microsoft.com/library/gg513877.aspx).
## <a name="monitor-and-manage-by-using-native-tools"></a><a name="BKMK_Monitoring"></a>Monitorare e gestire mediante strumenti nativi
In questa sezione vengono illustrati gli strumenti nativi disponibili in Windows Server 2012 R2 per il monitoraggio e la gestione del server.
### <a name="group-policy"></a>Criteri di gruppo
Esperienza Windows Server Essentials si avvale del supporto nativo per la Criteri di gruppo in Windows Server 2012 R2 e fornisce un'interfaccia utente per configurare le impostazioni di Reindirizzamento cartelle e sicurezza.
> [!NOTE]
> In un ambiente ospitato, se è abilitato il reindirizzamento delle cartelle per un profilo utente, in presenza di notevoli quantità di dati gli utenti finali potrebbero riscontrare tempi di accesso più lunghi.
### <a name="system-center-monitoring-pack"></a>System Center Monitoring Pack
System Center Monitoring Pack per l'esperienza Windows Server Essentials monitora il sistema di avvisi sull'integrità per semplificare la gestione di un numero elevato di server che eseguono Windows Server Essentials dedicati a piccole aziende. Per ulteriori informazioni, vedere [System Center Management Pack per Windows Server Essentials](https://www.microsoft.com/download/details.aspx?id=40809).
### <a name="backup-and-restore"></a>Backup e ripristino
Windows Server 2012 R2 con esperienza Windows Server Essentials consente di eseguire il backup dei computer server e client nella rete.
#### <a name="server-backup"></a>Backup del server
Windows Server Essentials supporta due tipi di backup del server: backup locale e backup remoto. Se si desidera distribuire la propria soluzione di backup del server, è possibile personalizzare queste opzioni.
- **Backup locale** Consente di eseguire backup incrementali a livello di blocco a intervalli regolari su un disco separato. Il provider di servizi di hosting può collegare un disco rigido virtuale alla macchina virtuale che esegue Windows Server Essentials e configurare il backup del server su questo disco virtuale. Il disco rigido virtuale deve trovarsi su un disco fisico diverso rispetto a quello della macchina virtuale che esegue Windows Server Essentials.
> [!NOTE]
> Se si dispone di altre soluzioni di backup per le macchine virtuali e non si vuole che gli utenti vedano la funzionalità Backup server nativa di Windows Server Essentials, è possibile disattivarla e rimuovere tutte le interfacce utente correlate dal dashboard. Per altre informazioni, vedere la sezione [Personalizzare il backup del server](https://technet.microsoft.com/library/dn293413.aspx) di [Personalizzare e distribuire Windows Server Essentials in Windows Server 2012 R2](https://technet.microsoft.com/library/dn293241.aspx).
- **Backup remoto** Consente di eseguire periodicamente il backup dei dati del server su un servizio basato su cloud. È possibile scaricare e installare il modulo di integrazione Backup di Microsoft Azure per Windows Server Essentials per sfruttare il backup di Azure fornito da Microsoft.
Per ulteriori informazioni, vedere la sezione integrare Windows Azure Backup con Windows Server Essentials in [gestire il backup del server](../manage/Manage-Server-Backup-in-Windows-Server-Essentials.md).
Se si preferisce usare un altro servizio cloud, è necessario considerare quanto segue:
- Aggiornare l'interfaccia utente del dashboard in modo che venga collegata al servizio cloud preferito anziché al backup di Azure predefinito.
- (Facoltativo) Sviluppare un componente aggiuntivo per il dashboard per configurare e gestire il servizio di backup basato su cloud.
#### <a name="client-computer-backup"></a>Backup computer client
Esperienza Windows Server Essentials supporta due tipi di backup dei dati client: backup completo del client e cronologia file.
> [!NOTE]
> Il backup del client può impattare sulle prestazioni, in quanto i dati devono essere trasferiti dal client al server tramite la VPN.
##### <a name="full-client-backup"></a>Backup completo del client
Il backup completo del client è attivato per impostazione predefinita per tutti i dispositivi client connessi alla rete Windows Server Essentials. Esegue il backup completo di tutte le informazioni di sistema e dei dati del client e supporta la deduplicazione dei dati. I dati di backup verranno archiviati nel server che esegue Windows Server Essentials. In questo modo, un client in errore potrà recuperare i dati da un punto di backup precedente.
Ecco alcune considerazione sul backup completo del client:
- **Prestazioni** Il primo backup del client può richiedere molto tempo a causa della notevole quantità di dati da caricare.
- **Stabilità** A volte la connessione a Internet non è stabile sul lato client. Il backup del client è progettato per riprendere automaticamente e il database di backup del client crea un checkpoint ogni volta che viene eseguito il backup di 40 GB di dati. È possibile ridurre questo valore, se si prevede che la connessione a Internet possa non essere affidabile.
- Per abilitare un punto di controllo: Nel server, impostare la chiave del Registro di sistema **HKLM\Software\Microsoft\Windows Server\Backup\GetCheckPointJobs** su 1.
- Per modificare la soglia del punto di controllo: Nel client, modificare il valore predefinito di 40 GB di **HKLM\Software\Microsoft\Windows Server\Backup\CheckPointThreshold** .
- **Ripristino bare metal del client** Poiché l'ambiente di preinstallazione di Windows non supporta la connessione VPN, il ripristino bare metal del client non è supportato. È consigliabile nascondere l'attività Servizio Ripristino client seguendo i passaggi descritti in [Personalizzare e distribuire Windows Server Essentials in Windows Server 2012 R2](https://technet.microsoft.com/library/dn293241.aspx).
##### <a name="file-history"></a>Cronologia file
Cronologia file è una funzionalità di Windows 8.1 e Windows 8 per il backup dei dati dei profili (raccolte, desktop, contatti e preferiti) in una condivisione di rete. È possibile gestire centralmente l'impostazione Cronologia file di tutti i computer che eseguono Windows 8.1 o Windows 8 che fanno parte della rete Windows Server Essentials. I dati di backup vengono archiviati nel server che esegue Windows Server Essentials. È consigliabile nascondere l'attività Servizio Ripristino client seguendo i passaggi descritti in [Personalizzare e distribuire Windows Server Essentials in Windows Server 2012 R2](https://technet.microsoft.com/library/dn293241.aspx)
### <a name="storage-management"></a>Gestione dell'archiviazione
La funzionalità Spazi di archiviazione consente di aggregare la capacità di archiviazione fisica di unità disco rigido diverse, di aggiungere dinamicamente altre unità disco rigido e di creare volumi di dati con i livelli di resilienza specificati. Queste operazioni possono essere eseguite sull'host o sulla macchina virtuale. Se si vuole nascondere questa funzionalità in una macchina virtuale che esegue Windows Server Essentials, seguire le istruzioni in [Personalizzare e distribuire Windows Server Essentials in Windows Server 2012 R2](https://technet.microsoft.com/library/dn293241.aspx).
## <a name="test-scenarios"></a><a name="BKMK_Scenarios"></a>Scenari di test
Dal punto di vista dell'hosting, è consigliabile testare gli scenari seguenti:
- [Distribuzione server](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_ServerDeploy)
- [Configurazione del server](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_ServerConfig2)
- [Gestione server](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_ServerManage)
- [Esperienza client](Deploy-Windows-Server-Essentials-Experience-as-a-Hosted-Server.md#BKMK_ClientXP)
### <a name="server-deployment"></a><a name="BKMK_ServerDeploy"></a>Distribuzione server
È possibile testare gli scenari di distribuzione server seguenti:
- Distribuire un server che esegue Windows Server 2012 R2 come controller di dominio nell'ambiente lab e quindi installare il ruolo esperienza Windows Server Essentials.
- Distribuire un server che esegue Windows Server 2012 R2 nell'ambiente lab, aggiungere il server a un dominio esistente e quindi installare il ruolo esperienza Windows Server Essentials.
- Personalizzare l'immagine di Windows Server Essentials in base alle proprie esigenze.
- Automatizzare la distribuzione di Windows Server Essentials con il file di installazione automatica e Windows PowerShell.
- Eseguire la migrazione di server locali che eseguono Windows Small Business Server su server ospitati che eseguono Windows Server Essentials.
### <a name="server-configuration"></a><a name="BKMK_ServerConfig2"></a>Configurazione del server
È possibile testare gli scenari di configurazione server seguenti:
- Configurare Accesso remoto via Internet (VPN, Accesso Web remoto e DirectAccess).
- Configurare le cartelle di archiviazione e server.
- Attivare BranchCache.
- (Se applicabile) Configurare Backup server, Online Backup, Backup client e Cronologia file.
- (Se applicabile) Configurare e gestire gli spazi di archiviazione.
- (Se applicabile) Configurare l'integrazione della soluzione di posta elettronica (Office 365 ed Exchange Server ospitato).
- (Se applicabile) Configurare l'integrazione con altri servizi online Microsoft.
- (Se applicabile) Configurare il server dei contenuti multimediali.
### <a name="server-management"></a><a name="BKMK_ServerManage"></a>Gestione server
È possibile testare gli scenari di gestione server seguenti:
- Gestire utenti e gruppi.
- Configurare e ricevere la notifica degli avvisi di posta elettronica-
- Eseguire Best Practices Analyzer per verificare la presenza di messaggi di errore o avviso.
- Configurare il pacchetto System Center Operations Manager.
- Configurare il ripristino del server, in caso di danneggiamento del sistema operativo.
### <a name="client-experience"></a><a name="BKMK_ClientXP"></a>Esperienza client
È possibile testare gli scenari utente finale seguenti:
- Distribuire i client via Internet (sistemi operativi PC o Mac).
- Usare la finestra di avvio sul client per accedere alle cartelle condivise.
- Accedere alle risorse del server tramite Accesso Web remoto da diversi dispositivi (PC, telefono e tablet).
- Accedere all'app My Server per Windows Phone.
- (Se applicabile) Accedere a Cronologia file, Backup e ripristino client e Reindirizzamento cartelle.
- (Se applicabile) Verificare l'esperienza di integrazione della posta elettronica.
## <a name="support-information"></a><a name="BKMK_Support"></a>Informazioni di supporto
È possibile scaricare il Software Development Kit (SDK) di Windows Server Essentials e Windows Server Essentials Assessment and Deployment Kit (ADK):
- [Software Development Kit di Windows Server Essentials](https://msdn.microsoft.com/library/gg513877.aspx) SDK
- [Personalizzare e distribuire Windows Server Essentials in Windows Server 2012 R2](https://technet.microsoft.com/library/dn293241.aspx)
## <a name="see-also"></a>Vedere anche
- [Novità di Windows Server Essentials](../get-started/what-s-new.md)
- [Installare Windows Server Essentials](Install-Windows-Server-Essentials.md)
- [Introduzione a Windows Server Essentials](../get-started/get-started.md)
| 83.691176 | 664 | 0.787179 | ita_Latn | 0.995004 |
473a017d3f72ae16a422120a5f12c43792cd2398 | 537 | md | Markdown | README.md | Schaeff/ethereum-bls12.rs | d4ed6e830c83103300331c062058158af29f3bb8 | [
"Apache-2.0"
] | 12 | 2018-09-15T10:40:58.000Z | 2021-11-22T04:52:35.000Z | README.md | Schaeff/ethereum-bls12.rs | d4ed6e830c83103300331c062058158af29f3bb8 | [
"Apache-2.0"
] | 3 | 2018-12-22T14:57:25.000Z | 2018-12-22T16:07:19.000Z | README.md | Schaeff/ethereum-bls12.rs | d4ed6e830c83103300331c062058158af29f3bb8 | [
"Apache-2.0"
] | 3 | 2018-11-25T01:05:18.000Z | 2021-11-22T04:52:25.000Z | # ethereum-bls12.rs
This is an experiment to make [BLS12-381](https://blog.z.cash/new-snark-curve/) elliptic curve operations available on Ethereum as a precompiles.
Inspired from [ethereum-bn128.rs](https://github.com/ewasm/ethereum-bn128.rs).
The encoding used is the one suggested at page 66 of [the sapling spec](https://github.com/zcash/zips/blob/9515d73aac0aea3494f77bcd634e1e4fbd744b97/protocol/protocol.pdf), which differs [from the one used in Ethereum for bn128](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-197.md)
| 76.714286 | 289 | 0.791434 | eng_Latn | 0.86382 |
473a05be190324649afcc5d0d35d144b4c65c57f | 1,344 | md | Markdown | 2020/12/27/2020-12-27 07:00.md | zhzhzhy/WeiBoHot_history | 32ce4800e63f26384abb17d43e308452c537c902 | [
"MIT"
] | 3 | 2020-07-14T14:54:15.000Z | 2020-08-21T06:48:24.000Z | 2020/12/27/2020-12-27 07:00.md | zhzhzhy/WeiBoHot_history | 32ce4800e63f26384abb17d43e308452c537c902 | [
"MIT"
] | null | null | null | 2020/12/27/2020-12-27 07:00.md | zhzhzhy/WeiBoHot_history | 32ce4800e63f26384abb17d43e308452c537c902 | [
"MIT"
] | null | null | null | 2020年12月27日07时数据
Status: 200
1.郑爽要退出追光吧哥哥
微博热度:1131879
2.摄影师9年前曾拍下孩童时期丁真
微博热度:899148
3.华为智慧屏新品开售
微博热度:874948
4.王一博被报假警
微博热度:806071
5.河北大学
微博热度:439053
6.长大以后会好吗
微博热度:438177
7.李维嘉回应
微博热度:428095
8.快乐大本营
微博热度:379779
9.追光吧哥哥
微博热度:337902
10.低龄未成年人刑责范围再调整
微博热度:321697
11.北京多家顶全便利店已暂停营业
微博热度:317435
12.苏醒倒数第一
微博热度:317339
13.重庆沙坪坝
微博热度:274033
14.杨幂看杜淳脱衣服跳舞的表情
微博热度:262382
15.日本28日起全面暂停新入境
微博热度:255623
16.广西毒贩开枪拒捕致民警中弹
微博热度:255418
17.阳光之下
微博热度:255400
18.李一桐 喜欢就要追跟性别没关系
微博热度:255393
19.唐迟
微博热度:200428
20.为什么美国企业逃离硅谷
微博热度:196723
21.谢霆锋一脚踢碎玻璃好A
微博热度:194675
22.伴侣是扶弟魔该不该分手
微博热度:171026
23.秦岚刘以豪签补充协议
微博热度:136048
24.印小天伍嘉成丁泽仁MAMA好炸
微博热度:122121
25.大连10岁遇害女童家属将重新提交材料
微博热度:120099
26.陈卓璇周六野健身Vlog
微博热度:119270
27.我也不知道叫什么了向屈楚萧道歉
微博热度:116855
28.羽生结弦赛季首冠
微博热度:109420
29.闫军
微博热度:108861
30.刑法最新修改内容
微博热度:108668
31.假装叫错男朋友名字
微博热度:108631
32.陈志朋瘦了10公斤
微博热度:107101
33.哲仁王后
微博热度:101921
34.姜振宇辩论能力
微博热度:88499
35.2021两会召开时间
微博热度:88424
36.我和妈妈的砍价区别
微博热度:88383
37.天真带小哥回家
微博热度:86097
38.故宫日月同辉奇景
微博热度:84311
39.禽流感蔓延至日本首都圈
微博热度:76431
40.高三男生见义勇为徒手挡刀
微博热度:75296
41.杨超越侯明昊互怼太好笑了
微博热度:69199
42.2020无价的你
微博热度:68663
43.终极笔记
微博热度:67057
44.虞书欣古装面纱造型
微博热度:66601
45.大江大河
微博热度:64867
46.王一博银发撕漫感大片
微博热度:63326
47.奇葩说
微博热度:61874
48.考研
微博热度:52551
49.抢公交车方向盘入刑
微博热度:50542
50.WE晋级决赛
微博热度:48683
| 6.588235 | 21 | 0.772321 | yue_Hant | 0.375151 |
473ac0e9347127bcf2fbf3ba9f493d2e0b40586c | 34 | md | Markdown | README.md | SophiaSilveira/Atvd_Dupla | 20242e4143f530f9838cd69a27d798474cc35ddd | [
"MIT"
] | null | null | null | README.md | SophiaSilveira/Atvd_Dupla | 20242e4143f530f9838cd69a27d798474cc35ddd | [
"MIT"
] | null | null | null | README.md | SophiaSilveira/Atvd_Dupla | 20242e4143f530f9838cd69a27d798474cc35ddd | [
"MIT"
] | null | null | null | # Atvd_Dupla
atividade valendo 3p
| 11.333333 | 20 | 0.823529 | por_Latn | 0.996938 |
473c90a4471ef292c6e71667b6fcc85fbfc3960b | 588 | md | Markdown | README.md | NAFedosov/Charity_tokens | da09bd5f6b454ba6de7dd736714bc080b3758898 | [
"Apache-2.0"
] | null | null | null | README.md | NAFedosov/Charity_tokens | da09bd5f6b454ba6de7dd736714bc080b3758898 | [
"Apache-2.0"
] | null | null | null | README.md | NAFedosov/Charity_tokens | da09bd5f6b454ba6de7dd736714bc080b3758898 | [
"Apache-2.0"
] | 1 | 2020-11-18T09:39:39.000Z | 2020-11-18T09:39:39.000Z | # charity-token
## address
https://etherscan.io/address/0xd80f47b5ab209feee27cd4467499a79d010bb948
## description and functionality
1. The value of charity tokens is ensured by human, social, natural capitals, which is accounted for per capita of the country, for each user of the social network open-fund.site.
2. Turnover of charity tokens creates anti-crisis economic relations in the digital ecosystem of the social network, solves personal and general problems of users.
3. The nominal value of 1 charity token is 100 Russian rubles
Total supply 30 trillions tokens (3*(10^13))
| 42 | 179 | 0.80102 | eng_Latn | 0.994307 |
473cc47b846ffa4d23c6b2880f3fdc5db5520e53 | 117 | md | Markdown | .changeset/modern-cameras-fetch.md | PH4NTOMiki/kit | 4e4625ea6d9a084bc767ae216704aacd95fe8730 | [
"MIT"
] | 9 | 2021-12-25T06:02:20.000Z | 2022-01-23T09:59:40.000Z | .changeset/modern-cameras-fetch.md | PH4NTOMiki/kit | 4e4625ea6d9a084bc767ae216704aacd95fe8730 | [
"MIT"
] | 31 | 2021-12-27T11:31:37.000Z | 2022-01-06T06:26:18.000Z | .changeset/modern-cameras-fetch.md | PH4NTOMiki/kit | 4e4625ea6d9a084bc767ae216704aacd95fe8730 | [
"MIT"
] | 7 | 2021-12-27T10:58:06.000Z | 2022-01-22T01:12:02.000Z | ---
'@sveltejs/kit': patch
---
allow files and directories named `__tests__` and `__test__` in the routes directory
| 19.5 | 84 | 0.726496 | eng_Latn | 0.99582 |
473cf06c66a26abca16774641fb93554adb2b289 | 1,218 | md | Markdown | CuratedContent/HowToEnablePerfPortabilityForCseApps.md | rinkug/bssw.io | 2bf279fb89806355e8948a23924edead081e3c79 | [
"MIT"
] | 81 | 2017-02-03T13:23:03.000Z | 2020-07-11T18:06:15.000Z | CuratedContent/HowToEnablePerfPortabilityForCseApps.md | rinkug/bssw.io | 2bf279fb89806355e8948a23924edead081e3c79 | [
"MIT"
] | 455 | 2017-02-09T05:11:08.000Z | 2020-08-07T23:24:43.000Z | CuratedContent/HowToEnablePerfPortabilityForCseApps.md | rinkug/bssw.io | 2bf279fb89806355e8948a23924edead081e3c79 | [
"MIT"
] | 73 | 2017-02-15T19:48:22.000Z | 2020-07-24T22:06:08.000Z | ### How to Enable Performance Portability for CSE Applications?
<!-- deck text start -->
Performance portability is an increasing concern for CSE applications. This *How To* document is a good resource on understanding how to enable performance portability in applications.
<!-- deck text end -->
#### Contributed by [Anshu Dubey](https://github.com/adubey64)
#### Publication date: August 06, 2019
Resource information | Details
:--- | :---
Article title | [How to Enable Performance Portability for CSE Applications](https://ideas-productivity.org/wordpress/wp-content/uploads/2016/04/IDEAS-PerformanceHowToEnablePerformancePortability-V0.2.pdf)
Authors | [Anshu Dubey](https://github.com/adubey64)
Focus | Performance portability
Achieving good performance across a range of platforms is an important goal for high-performance CSE software. This *[HowTo doc](https://ideas-productivity.org/wordpress/wp-content/uploads/2016/04/IDEAS-PerformanceHowToEnablePerformancePortability-V0.2.pdf)* provides strategies for working toward performance portability.
<!---
Publish: yes
Categories: performance
Topics: performance portability
Tags: document, howto
Level: 1
Prerequisites: defaults
Aggregate: none
--->
| 45.111111 | 323 | 0.784893 | eng_Latn | 0.677217 |
473cfd5acee4b4a3bec682a5d64e1fcd6bee3a00 | 2,453 | md | Markdown | articles/cognitive-services/whats-new-docs.md | GordenW/azure-docs.zh-cn | 2b69134b6401663a0fe76e07cd81d97da080bda1 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/cognitive-services/whats-new-docs.md | GordenW/azure-docs.zh-cn | 2b69134b6401663a0fe76e07cd81d97da080bda1 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/cognitive-services/whats-new-docs.md | GordenW/azure-docs.zh-cn | 2b69134b6401663a0fe76e07cd81d97da080bda1 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: 认知服务文档：2020年7月1日（年7月31日2020）的新增功能
description: 2020年7月1日（年7月31日2020）认知服务文档的新增功能。
author: erhopf
manager: nitinme
ms.topic: conceptual
ms.author: erhopf
ms.service: cognitive-services
ms.date: 08/03/2020
ms.openlocfilehash: eda90a430d96d43d052a603f82832aef6c0facdb
ms.sourcegitcommit: 1b2d1755b2bf85f97b27e8fbec2ffc2fcd345120
ms.translationtype: MT
ms.contentlocale: zh-CN
ms.lasthandoff: 08/04/2020
ms.locfileid: "87553353"
---
# <a name="cognitive-services-docs-whats-new-for-july-1-2020---july-31-2020"></a>认知服务文档：2020年7月1日（年7月31日2020）的新增功能
欢迎使用2020年7月1日至年7月 2020 31 日的认知服务文档中的新增功能。 本文列出了在此期间对文档进行的一些重大更改。
## <a name="form-recognizer"></a>表单识别器
### <a name="new-articles"></a>新文章
- [教程：使用 AI 生成器创建窗体处理应用](/azure/cognitive-services/form-recognizer/tutorial-ai-builder)
## <a name="personalizer"></a>个性化体验创建服务
### <a name="new-articles"></a>新文章
- [教程：在 .NET 聊天机器人中使用个性化体验创建服务](/azure/cognitive-services/personalizer/tutorial-use-personalizer-chat-bot)
## <a name="qna-maker"></a>QnA Maker
### <a name="new-articles"></a>新文章
- [规划 QnA Maker 应用](/azure/cognitive-services/qnamaker/concepts/plan)
## <a name="speech-service"></a>语音服务
### <a name="new-articles"></a>新文章
- [对静态数据的自定义命令加密](/azure/cognitive-services/speech-service/custom-commands-encryption-of-data-at-rest)
- [自定义关键字基础知识](/azure/cognitive-services/speech-service/custom-keyword-basics)
- [通过自定义语音使用自定义命令](/azure/cognitive-services/speech-service/how-to-custom-commands-use-custom-voice)
- [用于语音容器的批处理工具包](/azure/cognitive-services/speech-service/speech-container-batch-processing)
## <a name="text-analytics"></a>文本分析
### <a name="new-articles"></a>新文章
- [如何：将文本分析用于运行状况 (预览版) ](/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health)
## <a name="community-contributors"></a>社区参与者
在此期间，以下人员参与认知服务文档。 谢谢！ 了解如何通过以下 "[新增功能" 登录页](index.yml)中的 "获取内容" 下的链接进行参与。
- [milestonedev](https://github.com/milestonedev) -Justin 英里 (2)
- [felixvanleeuwen](https://github.com/felixvanleeuwen) (1)
- [LoicB](https://github.com/LoicB) -Loic Beylot (1)
- [nkgami](https://github.com/nkgami) -Hiroki Nakagami (1)
- [RussellJQA](https://github.com/RussellJQA) -Russell Johnson (1)
- [ryotokuro](https://github.com/ryotokuro) -Taiyue Tan (1)
- [smorcuend](https://github.com/smorcuend) -Sergio Morcuende (1)
- [swildermann](https://github.com/swildermann) -Sven Wildermann (1)
[!INCLUDE [Service specific updates](./includes/service-specific-updates.md)] | 36.61194 | 114 | 0.747656 | yue_Hant | 0.310634 |
473d78abb5ead6c6d2e5f75970fd47d09e50656f | 1,368 | md | Markdown | desktop-src/DevNotes/ctl3dsubclassctl.md | citelao/win32 | bf61803ccb0071d99eee158c7416b9270a83b3e4 | [
"CC-BY-4.0",
"MIT"
] | 2 | 2022-03-18T02:46:08.000Z | 2022-03-18T03:19:15.000Z | desktop-src/DevNotes/ctl3dsubclassctl.md | citelao/win32 | bf61803ccb0071d99eee158c7416b9270a83b3e4 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | desktop-src/DevNotes/ctl3dsubclassctl.md | citelao/win32 | bf61803ccb0071d99eee158c7416b9270a83b3e4 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
Description: Subclasses an individual control unless the control appears in a dialog box.
ms.assetid: 07a2bce1-4c69-4f8d-bb24-b17351f5e771
title: Ctl3dSubclassCtl function
ms.topic: reference
ms.date: 05/31/2018
topic_type:
- APIRef
- kbSyntax
api_name:
- Ctl3dSubclassCtl
api_type:
- DllExport
api_location:
- Ctl3d32.dll
---
# Ctl3dSubclassCtl function
Subclasses an individual control unless the control appears in a dialog box.
## Syntax
```C++
BOOL Ctl3dSubclassCtl(
HWND hwnd
);
```
## Parameters
<dl> <dt>
*hwnd*
</dt> <dd>
A handle to the control window.
</dd> </dl>
## Return value
Returns **TRUE** if the control is successfully subclassed; otherwise, it returns **FALSE**.
## Remarks
This function has no associated import library or header file; you must call it using the [**LoadLibrary**](/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibrarya) and [**GetProcAddress**](/windows/win32/api/libloaderapi/nf-libloaderapi-getprocaddress) functions.
## Requirements
| | |
|----------------|----------------------------------------------------------------------------------------|
| DLL<br/> | <dl> <dt>Ctl3d32.dll</dt> </dl> |
## See also
<dl> <dt>
[**Ctl3dUnsubclassCtl**](ctl3dunsubclassctl.md)
</dt> </dl>
| 19.267606 | 269 | 0.606725 | eng_Latn | 0.657624 |
473da5a31e8a57b9f43fa4415a30502446f2e308 | 9,575 | md | Markdown | README.md | ripley-labs/onboarding | 2ce03febd986b07847fd3edfc73bdbdbfc31f894 | [
"MIT"
] | null | null | null | README.md | ripley-labs/onboarding | 2ce03febd986b07847fd3edfc73bdbdbfc31f894 | [
"MIT"
] | null | null | null | README.md | ripley-labs/onboarding | 2ce03febd986b07847fd3edfc73bdbdbfc31f894 | [
"MIT"
] | 1 | 2020-05-18T13:30:36.000Z | 2020-05-18T13:30:36.000Z | # Advanced Curriculum For The Software Craftsman
This document is intended as a guidance for new developers joining our teams at [FLYERALARM](https://flyeralarm.com).
Because we think it might help others as well we open-sourced it. If you know something that's missing feel free to send us a Pull-Request.
## Basics
* [The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets](http://www.joelonsoftware.com/articles/Unicode.html)
* [What Every Programmer Should Know About Memory](https://www.akkadia.org/drepper/cpumemory.pdf)
* [What Every Developer Should Know About Time](https://unix4lyfe.org/time/?v=1)
* [A story about an angry carrot and a floating point fairy](http://blog.ruslans.com/2014/12/a-story-about-angry-carrot-and-floating.html)
* [How The Web Works](https://developer.mozilla.org/en-US/docs/Learn/Getting_started_with_the_web/How_the_Web_works)
* [HTTP on Wikipedia](https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol)
* [An Introduction To HTTP Basics](https://www.ntu.edu.sg/home/ehchua/programming/webprogramming/HTTP_Basics.html)
* [Choosing an HTTP Status Code — Stop Making It Hard](http://racksburg.com/choosing-an-http-status-code/)
* [TCP/IP Protocol Fundamentals Explained with a Diagram](http://www.thegeekstuff.com/2011/11/tcp-ip-fundamentals)
* [Google Developer Training For The Web](https://developers.google.com/training/web/)
* [Visualising data structures and algorithms through animation](https://visualgo.net/)
* [Algorithms, Data Structures, and Design Patterns for Self-Taught Developers](https://antjanus.com/blog/web-development-tutorials/learn-the-unlearned-algorithms-data-structures-and-design-patterns/)
* [A Gentle Introduction to Algorithms for Web Developers](http://giocc.com/a-gentle-introduction-to-algorithms-for-web-developers.html)
* [HTTP: The Protocol Every Web Developer Must Know](https://code.tutsplus.com/tutorials/http-the-protocol-every-web-developer-must-know-part-1--net-31177)
* [An Introduction to Networking Terminology, Interfaces, and Protocols](https://www.digitalocean.com/community/tutorials/an-introduction-to-networking-terminology-interfaces-and-protocols)
* [How Browser Caching Works](https://thesocietea.org/2016/05/how-browser-caching-works/)
## Design And Architecture Of Software
* [Clean Code](https://www.amazon.com/gp/product/0132350882/ref=as_li_qf_sp_asin_il_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0132350882&linkCode=as2&tag=sdrl-20)
* [DesignPatternsPHP](https://github.com/domnikl/DesignPatternsPHP)
* [All the cool kids...](https://www.youtube.com/watch?v=EDXgNA_pXX0)
* [18 must-watch PHP architecture talks](https://www.reddit.com/r/PHP/comments/3kklt5/18_mustwatch_php_architecture_talks_13hrs/)
* [Practical Object-Oriented Design in Ruby](https://www.amazon.de/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330/ref=sr_1_1?s=books-intl-de&ie=UTF8&qid=1476881380&sr=1-1&keywords=practical+object-oriented+design+in+ruby)
* [Patterns of Enterprise Application Architecture](https://www.amazon.de/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420/ref=sr_1_1?ie=UTF8&qid=1476887236&sr=8-1&keywords=patterns+of+enterprise+application+architecture)
* [Domain Driven Design](https://www.amazon.de/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215/ref=sr_1_1?ie=UTF8&qid=1476887211&sr=8-1&keywords=domain+driven+design)
* [Introduction to CQRS](http://www.codeproject.com/Articles/555855/Introduction-to-CQRS)
* [CQRS and Event Sourcing](https://www.youtube.com/watch?v=JHGkaShoyNs)
* [Your Code as a Crime Scene](https://pragprog.com/book/atcrime/your-code-as-a-crime-scene)
## PHP
* [PHP The Right Way](http://www.phptherightway.com/)
* [PHP The Wrong Way](http://www.phpthewrongway.com/)
* [A response to PHP The Wrong Way](https://medium.com/@jon.lemaitre/a-response-to-php-the-wrong-way-fe7bb253e295)
* [PHP Framework Interoperability Group](http://www.php-fig.org/)
* [PSR - PHP Standard Recommendation](https://en.wikipedia.org/wiki/PHP_Standard_Recommendation)
* [PHP Library Discovery](https://www.youtube.com/watch?v=3kD9t0GVGGY&feature=youtu.be)
* [PHP Logging Basics](https://www.loggly.com/ultimate-guide/php-logging-basics/)
* [Awesome PHP (A curated list of amazingly awesome PHP libraries, resources and shiny things)](https://github.com/ziadoz/awesome-php)
* [Efficient Data structures for PHP 7](https://medium.com/@rtheunissen/efficient-data-structures-for-php-7-9dda7af674cd)
## Tools
* [git](https://git-scm.com/)
* [Atlassian git Tutorials](https://www.atlassian.com/git/tutorials/)
* [Interactive git Cheatsheet](http://ndpsoftware.com/git-cheatsheet.html)
* [Composer - Dependency Manager For PHP](https://getcomposer.org/)
* [Packagist - The PHP Package Repository](https://packagist.org/)
* [PHPUnit](https://phpunit.de/)
* [Introduction to PHP Unit](https://jtreminio.com/2013/03/unit-testing-tutorial-introduction-to-phpunit/)
* [Twelve Benefits of Writing Unit Tests First](http://sd.jtimothyking.com/2006/07/11/twelve-benefits-of-writing-unit-tests-first/)
* [A Beginner's Guide to npm](https://www.sitepoint.com/beginners-guide-node-package-manager/)
## Environment
* [Basic UNIX commands](http://mally.stanford.edu/~sr/computing/basic-unix.html)
* [Explain Shell - Let it explain you what's going on](http://explainshell.com/)
* [Docker Docs](https://docs.docker.com/)
* [How to write Anible Playbooks](https://www.digitalocean.com/community/tutorials/configuration-management-101-writing-ansible-playbooks)
* [Ansible Docs](https://docs.ansible.com/)
## Persistence
* [SQL Performance Explained - Short and useful book about SQL performance for developers](https://www.amazon.de/SQL-Performance-Explained-Entwickler-SQL-Performance/dp/3950307818)
* [Use the index, Luke - a guide to database performance for developers](http://use-the-index-luke.com/)
* [The Little Redis Book](http://openmymind.net/redis.pdf)
* [Building an Event Storage](https://cqrs.wordpress.com/documents/building-event-storage/)
## Monitoring & Alerting
* [How to monitor system metrics with the TICK stack - Can also be used for gathering business metrics](https://www.digitalocean.com/community/tutorials/how-to-monitor-system-metrics-with-the-tick-stack-on-centos-7)
* [How to setup & use Icinga2](https://www.digitalocean.com/community/tutorials/how-to-monitor-hosts-and-services-with-icinga-on-ubuntu-16-04)
* [Using InfluxDB with Grafana](http://docs.grafana.org/features/datasources/influxdb/)
* [Grafana Docs](http://docs.grafana.org/)
* [InfluxDB Docs](http://docs.influxdata.com/influxdb/v1.6/)
## Processes & Culture
* [The Agile Manifesto](http://agilemanifesto.org/)
* [Agile Retrospectives](https://pragprog.com/book/dlret/agile-retrospectives)
* [Team Geek - A Software Developer's Guide to Working Well with Others](https://www.amazon.com/Team-Geek-Software-Developers-Working/dp/1449302440/ref=sr_1_1?ie=UTF8&qid=1477633184&sr=8-1&keywords=team+geek)
## Frontend & UI/UX
* [MDN - Mozilla Developer Network](https://developer.mozilla.org/de/)
* [Talks To Help You Become A Better Front-End Engineer](https://www.smashingmagazine.com/2012/12/talks-to-help-you-become-a-better-front-end-engineer-in-2013/)
* [Netflix UI Engineers Youtube Channel](https://www.youtube.com/channel/UCGGRRqAjPm6sL3-WGBDnKJA)
* [Twitter Bootstrap](http://getbootstrap.com)
* [Don't make me think - Web Usability](https://www.amazon.de/Dont-make-think-Usability-intuitive/dp/3826697057/ref=sr_1_1?ie=UTF8&qid=1476888649&sr=8-1&keywords=dont+make+me+think)
## JavaScript
* [Learn JavaScript Essentials](https://medium.com/javascript-scene/learn-javascript-b631a4af11f2#.ggqhkheuz)
* [Awesome JavaScript](https://github.com/sorrycc/awesome-javascript)
* [You don't know JS](https://github.com/getify/You-Dont-Know-JS)
* [JavaScript reference - MDN (Mozilla Developer Network)](https://developer.mozilla.org/en-US/docs/Web/JavaScript)
* [Eloquent Javascript](http://eloquentjavascript.net/)
* [Babel.js - ES6 today](https://babeljs.io/)
* [Essential Javascript Patterns](https://addyosmani.com/resources/essentialjsdesignpatterns/book/)
## Web Security
* [OWASP - Open Web Application Security Project](https://www.owasp.org/index.php/Main_Page)
* [A Gentle Introduction to Application Security](https://paragonie.com/blog/2015/08/gentle-introduction-application-security)
## API
* [Awesome API](https://github.com/Kikobeats/awesome-api)
* [An introduction to APIs](https://restful.io/an-introduction-to-api-s-cee90581ca1b#.it7afo95l)
## Best Practices
* [The Best Code is No Code At All](https://blog.codinghorror.com/the-best-code-is-no-code-at-all/)
* [The Pragmatic Programmer](https://pragprog.com/book/tpp/the-pragmatic-programmer)
* [Simple Made Easy](https://www.youtube.com/watch?v=rI8tNMsozo0)
* [Refactoring: Improving the Design of Existing Code](https://www.amazon.com/exec/obidos/ASIN/0201485672/codihorr-20)
* [The full stackoverflow developer](https://www.christianheilmann.com/2015/07/17/the-full-stackoverflow-developer/)
* [Measure anything, measure everything](https://codeascraft.com/2011/02/15/measure-anything-measure-everything/)
* [Papers from the computer science community to read and discuss](https://github.com/papers-we-love/papers-we-love)
* Go to a local user group
* Read open-source code on [GitHub](https://www.github.com)
* Never stop building stuff
On a side note: [We are searching for talented people to join our various teams of developers in multiple locations](https://karriere.flyeralarm.com/jobs)
| 70.925926 | 241 | 0.776397 | yue_Hant | 0.437152 |
473dd2a99fd8f1c5c8ac23228160bf94054b4f01 | 2,612 | md | Markdown | articles/vmware-cloudsimple/delete-private-cloud.md | R0bes/azure-docs.de-de | 24540ed5abf9dd081738288512d1525093dd2938 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/vmware-cloudsimple/delete-private-cloud.md | R0bes/azure-docs.de-de | 24540ed5abf9dd081738288512d1525093dd2938 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/vmware-cloudsimple/delete-private-cloud.md | R0bes/azure-docs.de-de | 24540ed5abf9dd081738288512d1525093dd2938 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: Löschen einer privaten Cloud in Azure VMware Solution by CloudSimple
description: Hier erfahren Sie, wie Sie eine private CloudSimple-Cloud löschen. Wenn Sie eine private Cloud löschen, werden alle Cluster gelöscht.
author: shortpatti
ms.author: v-patsho
ms.date: 08/06/2019
ms.topic: article
ms.service: azure-vmware-cloudsimple
ms.reviewer: cynthn
manager: dikamath
ms.openlocfilehash: 8ff5d251daca97ab5f0557f016ef47c7d77c2b2e
ms.sourcegitcommit: 516eb79d62b8dbb2c324dff2048d01ea50715aa1
ms.translationtype: HT
ms.contentlocale: de-DE
ms.lasthandoff: 04/28/2021
ms.locfileid: "108182370"
---
# <a name="delete-a-cloudsimple-private-cloud"></a>Löschen einer privaten CloudSimple-Cloud
CloudSimple bietet die Flexibilität, eine private Cloud zu löschen. Eine private Cloud besteht aus einem oder mehreren vSphere-Clustern. Jeder Cluster kann 3 bis 16 Knoten enthalten. Wenn Sie eine private Cloud löschen, werden alle Cluster gelöscht.
## <a name="before-you-begin"></a>Voraussetzungen
Beim Löschen einer privaten Cloud wird die gesamte private Cloud gelöscht. Alle Komponenten der privaten Cloud werden gelöscht. Wenn Sie einige Daten beibehalten möchten, müssen Sie sicherstellen, dass Sie diese Daten im lokalen Speicher oder in Azure Storage gesichert haben.
Zu den Komponenten einer privaten Cloud gehören:
* CloudSimple-Knoten
* Virtuelle Computer
* VLANs/Subnetze
* Alle Benutzerdaten, die in der privaten Cloud gespeichert sind
* Alle Firewallregelanlagen für ein VLAN/Subnetz
## <a name="sign-in-to-azure"></a>Anmelden bei Azure
Melden Sie sich unter [https://portal.azure.com](https://portal.azure.com) beim Azure-Portal an.
## <a name="delete-a-private-cloud"></a>Löschen einer privaten Cloud
1. [Rufen Sie das CloudSimple-Portal auf](access-cloudsimple-portal.md).
2. Öffnen Sie die Seite **Ressourcen**.
3. Klicken Sie auf die zu löschende private Cloud.
4. Klicken Sie auf der Zusammenfassungsseite auf **Löschen**.
5. Geben Sie auf der Bestätigungsseite den Namen der privaten Cloud ein, und klicken Sie auf **Löschen**.
Die private Cloud wird zum Löschen markiert. Der Löschvorgang beginnt nach drei Stunden und löscht die private Cloud.
> [!CAUTION]
> Knoten müssen nach dem Löschen der privaten Cloud gelöscht werden. Die Abrechnung der Knoten wird fortgesetzt, bis die Knoten aus Ihrem Abonnement gelöscht wurden.
## <a name="next-steps"></a>Nächste Schritte
* [Löschen von Knoten](delete-nodes.md)
| 42.129032 | 278 | 0.789051 | deu_Latn | 0.956985 |
473f6ca508da404c1e0ff0aa631a3f83b1cd4b8f | 654 | md | Markdown | Python/Collatz Conjecture/README.md | CaptainSora/synaptic-twilight | 5f5f29f783e22fd91e9a0567eecc4461376d51bd | [
"MIT"
] | null | null | null | Python/Collatz Conjecture/README.md | CaptainSora/synaptic-twilight | 5f5f29f783e22fd91e9a0567eecc4461376d51bd | [
"MIT"
] | null | null | null | Python/Collatz Conjecture/README.md | CaptainSora/synaptic-twilight | 5f5f29f783e22fd91e9a0567eecc4461376d51bd | [
"MIT"
] | null | null | null | # Collatz Conjecture
The [Collatz Conjecture](https://en.wikipedia.org/wiki/Collatz_conjecture) is a conjecture in mathematics that describes a sequence of numbers defined as follows:
1. Start with any positive integer *n*
2. If *n* is even, the next term is *n/2*
3. If *n* is odd, the next term is *3n+1*
The conjecture is that regardless of the value of *n*, the sequence will always reach 1.
The code in this folder represents multiple attempts to code an algorithm to count the number of steps until *n* reaches 1 in the fewest lines.
The requirements are that it must print very value of *n* as well as the number of steps required to reach 1. | 50.307692 | 162 | 0.762997 | eng_Latn | 0.999819 |
47400815cf537089f1563ce707e85ed051f0794c | 14,190 | md | Markdown | articles/stream-analytics/stream-analytics-machine-learning-integration-tutorial.md | gustavodelima/azure-docs.pt-br | 07f02d5a6f3328b5b720c3091518e805d37590b8 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/stream-analytics/stream-analytics-machine-learning-integration-tutorial.md | gustavodelima/azure-docs.pt-br | 07f02d5a6f3328b5b720c3091518e805d37590b8 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/stream-analytics/stream-analytics-machine-learning-integration-tutorial.md | gustavodelima/azure-docs.pt-br | 07f02d5a6f3328b5b720c3091518e805d37590b8 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: Integração do Azure Stream Analytics com o Azure Machine Learning Studio (clássico)
description: Este artigo descreve como configurar rapidamente um trabalho simples de Azure Stream Analytics que integra Azure Machine Learning Studio (clássico), usando uma função definida pelo usuário.
author: krishna0815
ms.author: krishmam
ms.service: stream-analytics
ms.topic: how-to
ms.date: 08/12/2020
ms.custom: seodec18
ms.openlocfilehash: d7d74887b4b4e205645a45fa7e07768a1af73940
ms.sourcegitcommit: 42a4d0e8fa84609bec0f6c241abe1c20036b9575
ms.translationtype: MT
ms.contentlocale: pt-BR
ms.lasthandoff: 01/08/2021
ms.locfileid: "98015293"
---
# <a name="do-sentiment-analysis-with-azure-stream-analytics-and-azure-machine-learning-studio-classic"></a>Fazer análise de sentimentos com Azure Stream Analytics e Azure Machine Learning Studio (clássico)
Este artigo mostra como configurar um trabalho simples de Azure Stream Analytics que usa Azure Machine Learning Studio (clássico) para análise de sentimentos. Você usa um modelo de análise de sentimentos de estúdio (clássico) do Cortana Intelligence Gallery para analisar dados de texto de streaming e determinar a pontuação de sentimentos.
> [!TIP]
> É altamente recomendado usar [UDFs do Azure Machine Learning](machine-learning-udf.md) em vez de UDFs do Azure Machine Learning Studio (clássico) para melhorar o desempenho e a confiabilidade.
Você pode aplicar o que aprendeu com este artigo a cenários como estes:
* Analisar sentimento em tempo real no streaming de dados do Twitter.
* Analisar registros de conversas do cliente com a equipe de suporte.
* Avaliar comentários em fóruns, blogs e vídeos.
* Muitos outros cenários de pontuação preditiva em tempo real.
O trabalho de Stream Analytics que você cria aplica o modelo de análise de sentimento como uma UDF (função definida pelo usuário) nos dados de texto de exemplo do repositório de blob. A saída (o resultado da análise de sentimento) é gravada no mesmo repositório de blob em um arquivo CSV diferente.
## <a name="prerequisites"></a>Pré-requisitos
Antes de começar, verifique se você tem:
* Uma assinatura ativa do Azure.
* Um arquivo CSV com alguns dados do Twitter. Você pode baixar um arquivo de exemplo do [GitHub](https://github.com/Azure/azure-stream-analytics/blob/master/Sample%20Data/sampleinput.csv)ou pode criar seu próprio arquivo. Em um cenário do mundo real, você deve obter os dados diretamente de um fluxo de dados do Twitter.
## <a name="create-a-storage-container-and-upload-the-csv-input-file"></a>Criar um contêiner de armazenamento e carregar o arquivo de entrada CSV
Nesta etapa, você carrega um arquivo CSV em seu contêiner de armazenamento.
1. Na portal do Azure, selecione **criar um recurso** > **armazenamento** > **conta de armazenamento**.
2. Preencha a guia *noções básicas* com os seguintes detalhes e deixe os valores padrão para os campos restantes:
|Campo |Valor |
|---------|---------|
|Subscription|Escolha sua assinatura.|
|Resource group|Escolha seu grupo de recursos.|
|Nome da conta de armazenamento|Insira um nome para a conta de armazenamento. O nome deve ser exclusivo em todo o Azure.|
|Location|Escolha um local. Todos os recursos devem usar o mesmo local.|
|Tipo de conta|BlobStorage|
3. Selecione **Examinar + criar**. Em seguida, selecione **criar** para implantar sua conta de armazenamento.
4. Quando a implantação for concluída, navegue até sua conta de armazenamento. Em **Serviço Blob**, selecione **Contêineres**. Em seguida, selecione **+ contêiner** para criar um novo contêiner.
5. Forneça um nome para o contêiner e verifique se o **nível de acesso público** está definido como **privado**. Quando terminar, selecione **Criar**.
6. Navegue até o contêiner recém-criado e selecione **carregar**. Carregue o arquivo de **sampleinput.csv** que você baixou anteriormente.
## <a name="add-the-sentiment-analytics-model-from-the-cortana-intelligence-gallery"></a>Adicione o modelo de análise de sentimento da Galeria do Cortana Intelligence
Agora que os dados de exemplo estão em um blob, você pode habilitar o modelo de análise de sentimento na Galeria do Cortana Intelligence.
1. Acesse a página [modelo preditivo de análise de sentimento](https://gallery.cortanaintelligence.com/Experiment/Predictive-Mini-Twitter-sentiment-analysis-Experiment-1) da Galeria do Cortana Intelligence.
2. Selecione **abrir no Studio (clássico)**.
3. Entre para acessar o workspace. Selecione uma localização.
4. Selecione **executar** na parte inferior da página. O processo é executado, o que leva cerca de um minuto.
5. Depois que o processo tiver sido executado com êxito, selecione **Implantar serviço Web** na parte inferior da página.
6. Para validar que o modelo de análise de sentimentos está pronto para uso, selecione o botão **testar** . Forneça entrada de texto, como "Eu amo a Microsoft".
Se o teste funcionar, você verá um resultado semelhante ao exemplo a seguir:
7. Na coluna **aplicativos** , selecione o link do **Excel 2010 ou da pasta de trabalho anterior** para baixar uma pasta de trabalho do Excel. A pasta de trabalho contém a chave de API e a URL de que você precisará mais tarde para configurar o trabalho do Stream Analytics.
## <a name="create-a-stream-analytics-job-that-uses-the-studio-classic-model"></a>Criar um trabalho de Stream Analytics que usa o modelo de estúdio (clássico)
Agora você pode criar um trabalho do Stream Analytics que leia os tweets de exemplo do arquivo CSV no armazenamento de blobs.
### <a name="create-the-job"></a>Criar o trabalho
Vá para a [portal do Azure](https://portal.azure.com) e crie um trabalho de Stream Analytics. Se você não estiver familiarizado com esse processo, consulte [criar um Stream Analytics trabalho usando o portal do Azure](stream-analytics-quick-create-portal.md).
### <a name="configure-the-job-input"></a>Configurar a entrada do trabalho
O trabalho obtém sua entrada do arquivo CSV que você carregou anteriormente para o armazenamento de blobs.
1. Navegue até o trabalho do Stream Analytics. Em **topologia do trabalho**, selecione a opção **entradas** . Selecione **Adicionar fluxo** > **armazenamento de blob** de entrada.
2. Preencha os detalhes do **armazenamento de blob** com os seguintes valores:
|Campo |Valor |
|---------|---------|
|Alias de entrada|Dê um nome à sua entrada. Lembre-se de que esse alias é quando você escreve sua consulta.|
|Subscription|Selecione sua assinatura.|
|Conta de armazenamento|Selecione a conta de armazenamento que você criou na etapa anterior.|
|Contêiner|Selecione o contêiner que você criou na etapa anterior.|
|Formato de serialização do evento|CSV|
3. Selecione **Salvar**.
### <a name="configure-the-job-output"></a>Configurar a saída do trabalho
O trabalho envia resultados para o mesmo armazenamento de blobs do qual ele obtém a entrada.
1. Navegue até o trabalho do Stream Analytics. Em **topologia do trabalho**, selecione a opção **saídas** . Selecione **Adicionar** > **armazenamento de BLOBs**.
2. Preencha o formulário de **armazenamento de blob** com estes valores:
|Campo |Valor |
|---------|---------|
|Alias de entrada|Dê um nome à sua entrada. Lembre-se de que esse alias é quando você escreve sua consulta.|
|Subscription|Selecione sua assinatura.|
|Conta de armazenamento|Selecione a conta de armazenamento que você criou na etapa anterior.|
|Contêiner|Selecione o contêiner que você criou na etapa anterior.|
|Formato de serialização do evento|CSV|
3. Selecione **Salvar**.
### <a name="add-the-studio-classic-function"></a>Adicionar a função Studio (clássico)
Anteriormente, você publicou um modelo de estúdio (clássico) em um serviço Web. Nesse cenário, quando o trabalho de Stream Analysis é executado, ele envia cada tweet de exemplo da entrada para o serviço Web para análise de sentimento. O serviço Web Studio (clássico) retorna um sentimentos ( `positive` , `neutral` ou `negative` ) e uma probabilidade de o tweet ser positivo.
Nesta seção, você define uma função no trabalho de análise de fluxo. A função pode ser invocada para enviar um tweet ao serviço Web e retornar a resposta.
1. Verifique se que você tem a URL do serviço Web e a chave de API baixada anteriormente na pasta de trabalho do Excel.
2. Navegue até o trabalho do Stream Analytics. Em seguida, selecione **funções** > **+ Adicionar** > **Azure ml Studio**
3. Preencha o formulário de **função Azure Machine Learning** com os seguintes valores:
|Campo |Valor |
|---------|---------|
| Alias da função | Use o nome `sentiment` e selecione **fornecer Azure Machine Learning configurações de função manualmente**, o que lhe dá uma opção para inserir a URL e a chave. |
| URL| Cole a URL do serviço Web.|
|Chave | Cole a chave de API. |
4. Selecione **Salvar**.
### <a name="create-a-query-to-transform-the-data"></a>Criar uma consulta para transformar os dados
O Stream Analytics usa uma consulta declarativa baseada em SQL para examinar a entrada e processá-la. Nesta seção, você cria uma consulta que lê cada tweet da entrada e, em seguida, invoca a função Studio (clássico) para executar a análise de sentimentos. A consulta então envia o resultado para a saída definida (armazenamento de blobs).
1. Retorne para a visão geral do trabalho de Stream Analytics.
2. Em **Topologia do trabalho**, selecione **Consulta**.
3. Insira a consulta a seguir:
```SQL
WITH sentiment AS (
SELECT text, sentiment1(text) as result
FROM <input>
)
SELECT text, result.[Score]
INTO <output>
FROM sentiment
```
A consulta invoca a função que você criou anteriormente ( `sentiment` ) para executar a análise de sentimentos em cada tweet na entrada.
4. Selecione **salvar** para salvar a consulta.
## <a name="start-the-stream-analytics-job-and-check-the-output"></a>Iniciar o trabalho do Stream Analytics e verificar a saída
Agora você pode iniciar o trabalho do Stream Analytics.
### <a name="start-the-job"></a>Iniciar o trabalho
1. Retorne para a visão geral do trabalho de Stream Analytics.
2. Selecione **Iniciar** na parte superior da página.
3. Em **Iniciar trabalho**, selecione **personalizado** e, em seguida, selecione um dia antes de quando você carregou o arquivo CSV no armazenamento de BLOBs. Quando terminar, selecione **Iniciar**.
### <a name="check-the-output"></a>Verifique a saída
1. Deixe o trabalho ser executado por alguns minutos até ver a atividade na caixa **Monitoramento**.
2. Se você tiver uma ferramenta que normalmente usa para examinar o conteúdo do armazenamento de BLOBs, use essa ferramenta para examinar o contêiner. Como alternativa, siga estas etapas no portal do Azure:
1. No portal do Azure, localize sua conta de armazenamento e, dentro da conta, localize o contêiner. Você ver dois arquivos no contêiner: o arquivo que contém os tweets de exemplo e um arquivo CSV gerado pelo trabalho do Stream Analytics.
2. Clique com o botão direito do mouse no arquivo gerado e, em seguida, selecione **Baixar**.
3. Abra o arquivo CSV gerado. Você verá algo parecido com o exemplo a seguir:
### <a name="view-metrics"></a>Métricas de exibição
Você também pode exibir as métricas relacionadas à função do Studio (clássico). As seguintes métricas relacionadas à função são exibidas na caixa **monitoramento** da visão geral do trabalho:
* **Solicitações de função** indica o número de solicitações enviadas a um serviço Web de estúdio (clássico).
* **Eventos de função** indica o número de eventos na solicitação. Por padrão, cada solicitação para um serviço Web Studio (clássico) contém até 1.000 eventos.
## <a name="next-steps"></a>Próximas etapas
* [Introdução ao Stream Analytics do Azure](stream-analytics-introduction.md)
* [Referência de Linguagem de Consulta do Stream Analytics do Azure](/stream-analytics-query/stream-analytics-query-language-reference)
* [Integrar API REST e Machine Learning Studio (clássico)](stream-analytics-how-to-configure-azure-machine-learning-endpoints-in-stream-analytics.md)
* [Referência da API REST do Gerenciamento do Azure Stream Analytics](/rest/api/streamanalytics/) | 61.428571 | 375 | 0.764693 | por_Latn | 0.99856 |
47406559bd5e03a893dc06d9f570df3d43279982 | 917 | md | Markdown | src/safe-guides/coding_practice/memory/lifetime.md | TENX-S/rust-coding-guidelines-zh | 5ed5615307f4950980f8c91f20ee20e91d1d3718 | [
"MIT"
] | 1 | 2021-11-02T00:49:35.000Z | 2021-11-02T00:49:35.000Z | src/safe-guides/coding_practice/memory/lifetime.md | TENX-S/rust-coding-guidelines-zh | 5ed5615307f4950980f8c91f20ee20e91d1d3718 | [
"MIT"
] | null | null | null | src/safe-guides/coding_practice/memory/lifetime.md | TENX-S/rust-coding-guidelines-zh | 5ed5615307f4950980f8c91f20ee20e91d1d3718 | [
"MIT"
] | 1 | 2021-11-09T08:59:51.000Z | 2021-11-09T08:59:51.000Z | # 生存期
生存期（lifetime），也被叫做 生命周期。
---
## P.MEM.Lifetime.01 生命周期参数命名尽量简单
**【描述】**
生命周期参数的命名应该尽量简单，用 `'a/ 'b/ 'c` 即可，不要将其命名为带语义的名称。
因为生命周期参数的目的是给编译器使用，用于防止函数中出现悬垂引用。
生命周期参数越简单，越没有语义，就越不会影响到其他业务代码，作为开发者可以做到无视这些生命周期参数，而只有在需要的时候才检查它们。
如果加上语义的话，就会影响代码可读性。
【正例】
```rust
fn the_longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
if s1.len() > s2.len() { s1 } else { s2 }
}
```
【反例】
```rust
fn the_longest<'strlife>(s1: &'strlife str, s2: &'strlife str) -> &'strlife str {
if s1.len() > s2.len() { s1 } else { s2 }
}
```
## P.MEM.Lifetime.02 在需要的时候，最好显式地标注生命周期，而非利用编译器推断
**【描述】**
编译器可以推断你的代码做了什么，但它不知道你的意图是什么。
编译器对生命周期参数有两种单态化方式（生命周期参数也是一种泛型）：
- Early bound。一般情况下，`'a: 'b` 以及 `impl<'a'>` 这种方式是 early bound，意味着这些生命周期参数会在当前作用域单态化生命周期实例。
- Late bound。默认的 `'a` 或 `for<'a>` 是在实际调用它们的地方才单态化生命周期实例。
在不同的场景下，需要指定合适的单态化方式，才能让编译器明白你的意图。
在使用匿名生命周期 `'_` 的时候需要注意，如果有多个匿名生命周期，比如 `('_ ，'_)` ，每个匿名生命周期都会有自己的单独实例。
| 18.34 | 91 | 0.668484 | yue_Hant | 0.628217 |
47407f0feb0ec94f7301d9dbbea6fc4721e80076 | 3,430 | md | Markdown | articles/azure-monitor/app/java-standalone-troubleshoot.md | daixijun/mc-docs.zh-cn | 1303fd33ba04b2881651e18d9db6a28d907f99e3 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/azure-monitor/app/java-standalone-troubleshoot.md | daixijun/mc-docs.zh-cn | 1303fd33ba04b2881651e18d9db6a28d907f99e3 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/azure-monitor/app/java-standalone-troubleshoot.md | daixijun/mc-docs.zh-cn | 1303fd33ba04b2881651e18d9db6a28d907f99e3 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: 对适用于 Java 的 Azure Monitor Application Insights 进行故障排除
description: 了解如何对 Azure Monitor Application Insights 的 Java 代理进行故障排除
ms.topic: conceptual
ms.author: v-johya
ms.date: 01/12/2021
ms.custom: devx-track-java
ms.openlocfilehash: 79977e2ea4734432b5acacfa528289acae299288
ms.sourcegitcommit: c8ec440978b4acdf1dd5b7fda30866872069e005
ms.translationtype: HT
ms.contentlocale: zh-CN
ms.lasthandoff: 01/15/2021
ms.locfileid: "98231159"
---
# <a name="troubleshooting-guide-azure-monitor-application-insights-for-java"></a>故障排除指南：适用于 Java 的 Azure Monitor Application Insights
本文介绍了使用 Application Insights 的 Java 代理来检测 Java 应用程序时可能会遇到的一些常见问题。 本文还介绍了解决这些问题的步骤。 Application Insights 是 Azure Monitor 平台服务的一项功能。
## <a name="check-the-self-diagnostic-log-file"></a>检查自诊断日志文件
默认情况下，Application Insights 的 Java 3.0 代理在 `applicationinsights-agent-3.0.0.jar` 文件所在的目录中生成名为 `applicationinsights.log` 的日志文件。
针对你可能遇到的问题查找线索时，此日志文件是要检查的第一个位置。
## <a name="upgrade-from-the-application-insights-java-2x-sdk"></a>从 Application Insights Java 2.x SDK 进行升级
如果你已在应用程序中使用 Application Insights Java 2.x SDK，则可以继续使用它。 Java 3.0 代理会检测到它。 有关详细信息，请参阅[从 Java 2.x SDK 进行升级](./java-standalone-upgrade-from-2x.md)。
## <a name="upgrade-from-application-insights-java-30-preview"></a>从 Application Insights Java 3.0 预览版进行升级
如果要从 Java 3.0 预览版代理进行升级，请仔细检查所有[配置选项](./java-standalone-config.md)。 JSON 结构在 3.0 正式发布版 (GA) 中已完全更改。
这些更改包括：
- 配置文件名称已从 `ApplicationInsights.json` 更改为 `applicationinsights.json`。
- `instrumentationSettings` 节点不再存在。 `instrumentationSettings` 中的所有内容已移动到根级别。
- `sampling`、`jmxMetrics`、`instrumentation` 和 `heartbeat` 等配置节点已从 `preview` 移出到根级别。
## <a name="some-logging-is-not-auto-collected"></a>某些日志记录不是自动收集的
仅当日志记录首先满足日志记录框架的配置阈值，并且还满足 Application Insights 的配置阈值时，才会捕获日志记录。
若要了解某个特定的日志记录语句是否满足日志记录框架的已配置阈值，最好的方法是确认它是否显示在正常的应用程序日志（例如文件或控制台）中。
有关更多详细信息，请参阅[自动收集的日志记录配置](./java-standalone-config.md#auto-collected-logging)。
## <a name="import-ssl-certificates"></a>导入 SSL 证书
如果使用的是默认的 Java 密钥存储，则它已具有所有 CA 根证书。 你应当不需要导入更多的 SSL 证书。
如果使用的是自定义 Java 密钥存储，则你可能需要将 Application Insights 终结点 SSL 证书导入其中。
### <a name="key-terminology"></a>关键术语
“密钥存储”是证书、公钥和私钥的存储库。 通常，Java 开发工具包发行版具有用于管理它们的可执行文件：`keytool`。
下面的示例是一个简单的命令，用于将 SSL 证书导入到密钥存储：
`keytool -importcert -alias your_ssl_certificate -file "your downloaded SSL certificate name".cer -keystore "Your KeyStore name" -storepass "Your keystore password" -noprompt`
### <a name="steps-to-download-and-add-an-ssl-certificate"></a>下载和添加 SSL 证书的步骤
1. 打开你习惯使用的浏览器，然后转到用于检测应用程序的连接字符串中存在的 `IngestionEndpoint` URL。
:::image type="content" source="media/java-ipa/troubleshooting/ingestion-endpoint-url.png" alt-text="屏幕截图显示了 Application Insights 连接字符串。":::
2. 选择浏览器中的“查看站点信息”（锁）图标，然后选择“证书”选项。
:::image type="content" source="media/java-ipa/troubleshooting/certificate-icon-capture.png" alt-text="屏幕截图显示了站点信息中的“证书”选项。":::
3. 转到“详细信息”选项卡，然后选择“复制到文件”。
4. 选择“下一步”按钮，选择“Base-64 编码的 X.509 (.CER)”格式，然后再次选择“下一步”。
:::image type="content" source="media/java-ipa/troubleshooting/certificate-export-wizard.png" alt-text="证书导出向导的屏幕截图，其中选择了一种格式。":::
5. 指定要在其中保存 SSL 证书的文件。 然后，选择“下一步” > “完成”。 应该会看到“导出成功”消息。
6. 获得证书后，即可将证书导入到 Java 密钥存储中。 使用[前面的命令](#key-terminology)来导入证书。
> [!WARNING]
> 在当前证书到期之前，你需要重复这些步骤以获取新证书。 可以在“证书”对话框的“详细信息”选项卡上找到到期信息。
>
> :::image type="content" source="media/java-ipa/troubleshooting/certificate-details.png" alt-text="屏幕截图显示了 SSL 证书详细信息。":::
| 41.325301 | 175 | 0.774344 | yue_Hant | 0.399197 |
4740b8c7a873476b9be5d447320b3d446202d9a0 | 136 | md | Markdown | _pages/our-style/index.md | michelle-rago/content-guide-uswds | 6c753bc240016067ed61a728ec36deeec3220c90 | [
"CC0-1.0"
] | null | null | null | _pages/our-style/index.md | michelle-rago/content-guide-uswds | 6c753bc240016067ed61a728ec36deeec3220c90 | [
"CC0-1.0"
] | null | null | null | _pages/our-style/index.md | michelle-rago/content-guide-uswds | 6c753bc240016067ed61a728ec36deeec3220c90 | [
"CC0-1.0"
] | null | null | null | ---
layout: post
title: Our style
permalink: /our-style/
sidenav: our-style
sticky_sidenav: true
---
Grammar, spelling, and mechanics. | 15.111111 | 33 | 0.735294 | eng_Latn | 0.742409 |
4740cd25a4b1d0122389fec83494ec764ef41d17 | 2,262 | md | Markdown | README.md | activeshadow/modbus | 3c5065946beed839a9d472cdb7132e77843aaa34 | [
"BSD-3-Clause"
] | 1 | 2021-04-28T16:27:05.000Z | 2021-04-28T16:27:05.000Z | README.md | activeshadow/modbus | 3c5065946beed839a9d472cdb7132e77843aaa34 | [
"BSD-3-Clause"
] | null | null | null | README.md | activeshadow/modbus | 3c5065946beed839a9d472cdb7132e77843aaa34 | [
"BSD-3-Clause"
] | null | null | null | [](https://travis-ci.com/activeshadow/modbus)
[](https://pkg.go.dev/actshad.dev/modbus?tab=doc)
[](https://github.com/activeshadow/modbus/blob/master/LICENSE)
Golang Modbus Client (Master)
=============================
Fault-tolerant, fail-fast implementation of Modbus protocol in Go.
Supported functions
-------------------
Bit access:
* Read Discrete Inputs
* Read Coils
* Write Single Coil
* Write Multiple Coils
16-bit access:
* Read Input Registers
* Read Holding Registers
* Write Single Register
* Write Multiple Registers
* Read/Write Multiple Registers
* Mask Write Register
* Read FIFO Queue
Supported formats
-----------------
* TCP
* Serial (RTU, ASCII)
Usage
-----
Basic usage:
```go
// Modbus TCP
client := modbus.TCPClient("localhost:502")
// Read input register 9
results, err := client.ReadInputRegisters(8, 1)
// Modbus RTU/ASCII
// Default configuration is 19200, 8, 1, even
client = modbus.RTUClient("/dev/ttyS0")
results, err = client.ReadCoils(2, 1)
```
Advanced usage:
```go
// Modbus TCP
handler := modbus.NewTCPClientHandler("localhost:502")
handler.Timeout = 10 * time.Second
handler.SlaveId = 0xFF
handler.Logger = log.New(os.Stdout, "test: ", log.LstdFlags)
// Connect manually so that multiple requests are handled in one connection session
err := handler.Connect()
defer handler.Close()
client := modbus.NewClient(handler)
results, err := client.ReadDiscreteInputs(15, 2)
results, err = client.WriteMultipleRegisters(1, 2, []byte{0, 3, 0, 4})
results, err = client.WriteMultipleCoils(5, 10, []byte{4, 3})
```
```go
// Modbus RTU/ASCII
handler := modbus.NewRTUClientHandler("/dev/ttyUSB0")
handler.BaudRate = 115200
handler.DataBits = 8
handler.Parity = "N"
handler.StopBits = 1
handler.SlaveId = 1
handler.Timeout = 5 * time.Second
err := handler.Connect()
defer handler.Close()
client := modbus.NewClient(handler)
results, err := client.ReadDiscreteInputs(15, 2)
```
References
----------
- [Modbus Specifications and Implementation Guides](http://www.modbus.org/specs.php)
| 27.253012 | 133 | 0.708665 | kor_Hang | 0.282669 |
4740e9d243607044c88437cce96dafd64fe76f57 | 4,803 | md | Markdown | content/portfolio/cv-cli.md | samrobbins85/tailwind-developer-portfolio | 51bb96fc1b3cf8e6441db2069915e6059332f7d4 | [
"CC-BY-4.0"
] | 2 | 2021-01-03T09:58:04.000Z | 2021-02-20T14:05:33.000Z | content/portfolio/cv-cli.md | samrobbins85/tailwind-developer-portfolio | 51bb96fc1b3cf8e6441db2069915e6059332f7d4 | [
"CC-BY-4.0"
] | 8 | 2020-09-08T09:38:53.000Z | 2020-11-30T08:30:45.000Z | content/portfolio/cv-cli.md | samrobbins85/tailwind-developer-portfolio | 51bb96fc1b3cf8e6441db2069915e6059332f7d4 | [
"CC-BY-4.0"
] | null | null | null | ---
categories:
- web-dev
title: CV CLI
date: 2020-12-13T00:00:00.000+00:00
description: A command line CV made with Node.js
coders: []
image: "/img/portfolio_cover/cli.svg"
github:
- https://github.com/samrobbins85/cli-cv
tech:
- name: Ink
logo: "/img/logos/ink.png"
url: https://www.npmjs.com/package/ink
- name: React
logo: "/img/logos/react.svg"
url: https://reactjs.org/
- name: Node.js
logo: "/img/long_logos/nodejs.svg"
url: https://nodejs.org/en/
site: https://www.npmjs.com/package/samrobbins
---
This was initially inspired by a project I saw on dev.to to [create a personal npm card](https://dev.to/cdthomp1/create-your-own-npm-card-ejp), this was a great project, and I followed it through and loved the result, but thought I could expand on the idea.
If you look at my portfolio you can see I like to experiment with different ways to make and present a CV, so I thought this could add to that theme by creating a npm CV.
Using a couple of lightweight node packages was good for the card, but to build a CV I would need more complex layout features, so I decided to use [ink](https://www.npmjs.com/package/ink), which allows you to use React to create a CLI. Notably it uses Yoga to build flexbox layouts, which would be very useful to get everything laid out as I wanted.
First up was to create a box in which my CV would sit, for this I used the `Box` component, along with specifying `borderStyle="double"` to give a nice border.
Then was adding a title at the top, for this I found the [ink-big-text](https://github.com/sindresorhus/ink-big-text) library, which allows for creating ASCII art titles. However, one problem I ran into was that my title would then be too big on narrow terminals and so not display properly. To fix this, I used the value `process.stdout.colums`, which tells you how many columns the terminal has, and so I could use this to change the font to a smaller one if the terminal was narrow.
Next was the main content of the CV, for this I created a few components to allow for a more consistent layout.
## Section
For each section of the CV, I had a component, this would just pass through the children, but would also take a title prop which created an ASCII art title for each section, this looked like this
```react
function Section(props) {
return (
<Box flexDirection="column">
<BigText text={props.title} font="tiny" />
{props.children}
</Box>
);
}
```
## Skill
For the skills section, I use a slightly different component as it is more of a list format, and so the component looks like this
```react
function Skill(props) {
return (
<Box>
<Box width={25}>
<Text bold>{props.name}</Text>
</Box>
<Text>{props.children}</Text>
</Box>
);
}
```
## Item
For most sections, I have the format of a title, with the date on the same line but right aligned, with a description beneath, and so this component allowed for that design.
```react
function Item(props) {
return (
<Box flexDirection="column" marginBottom={1}>
<Box justifyContent="space-between">
<Text bold>{props.title}</Text>
<Text italic>{props.date}</Text>
</Box>
<Text>{props.children}</Text>
</Box>
);
}
```
## JSON
To make future manipulation easier, I wanted to have the CV as a JSON file, which would then work to populate the code. Getting this in the main file was easy, by just using the line
```js
const config = require("./config.json");
```
Then for each section, I would use conditional rendering using the pattern
```jsx
{config.skills ? (<Code /> ) : undefined}
```
This meant that if the key `skills` wasn't there, then the section wouldn't render, and if it was, then it would.
I could then use `map`s to add each bit of content, with the skills section being slightly more complicated because I wanted the user to be able to specify the title for each category using the JSON keys, which looks like this
```jsx
<Section title="Skills">
{Object.keys(config.skills).map((title) => (
<Skill name={title}>{config.skills[title].join(", ")}</Skill>
))}
</Section>
```
Whereas the rest were more simple in mapping over a list of objects
```jsx
<Section title="Qualifications">
{config.qualifications.map((item) => (
<Item title={item.title} date={item.date}>
{item.description}
</Item>
))}
</Section>
```
Then was the case of allowing this to be executed in the terminal, the suggested way is to use `importJsx` to import the file that uses React
```js
#!/usr/bin/env node
"use strict";
const React = require("react");
const importJsx = require("import-jsx");
const { render } = require("ink");
const cv = importJsx("./ink");
render(React.createElement(cv));
```
It is also possible to do this using Babel, but this worked for me | 35.316176 | 485 | 0.711847 | eng_Latn | 0.997868 |
474245d212bd56278c58234bd5c639eab76dcffd | 2,800 | md | Markdown | docs/gettingstarted.md | easyjitsi/easyjitsi | b791ac79760842620df4edcb9f0b5076840b7f3f | [
"Apache-2.0"
] | 174 | 2020-04-14T17:15:59.000Z | 2022-03-05T11:20:13.000Z | docs/gettingstarted.md | easyjitsi/easyjitsi | b791ac79760842620df4edcb9f0b5076840b7f3f | [
"Apache-2.0"
] | 12 | 2020-04-15T07:14:11.000Z | 2021-07-19T18:21:14.000Z | docs/gettingstarted.md | easyjitsi/easyjitsi | b791ac79760842620df4edcb9f0b5076840b7f3f | [
"Apache-2.0"
] | 23 | 2020-04-15T15:40:39.000Z | 2022-03-05T11:20:17.000Z | ---
id: gettingstarted
title: Starting Out
---
In this section [Easy Jitsi](https://easyjitsi.com) will guide you through the process of setting up an Ubuntu 18.04 LTS server for Jitsi Meet.
## Prerequisites
- An Ubuntu 18.04 LTS x64 server with an [IPv4 address](https://en.wikipedia.org/wiki/IPv4).
- [Openssh](https://www.openssh.com/)
- A domain name for your server(The example domain we're going to be using is **easyjitsi.com**)
### Ubuntu Server Specific Prerequisites
- A root user
- A sub domain **jitsimeet.easyjitsi.com** being pointed to the server mentioned above.
NB: **_Our example server will be using 2GB of RAM_**
## Setting Up The Server
On our local system, we login into our Ubuntu server
```bash
ssh [email protected] -p 22
```
Since our machine has 2GB of memory, it's recommended to setup a 2GB (2048M) swap partition in order to improve system performance. For more information about recommended swap sizes depending on ram size visit [here](https://askubuntu.com/questions/49109/i-have-16gb-ram-do-i-need-32gb-swap)
We configure our swap partition
```bash
dd if=/dev/zero of=/swapfile count=2048 bs=1M
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile
echo '/swapfile noneswapsw0 0' |tee -a /etc/fstab
free -m
```
We setup a hostname and a [FQDN](https://en.wikipedia.org/wiki/Fully_qualified_domain_name) for the machine before we can enable HTTPS security by deploying a Let's Encrypt HTTPS certificate.
We then run the following command to setup a hostname, jitsimeet, and an FQDN, jitsimeet.easyjitsi.com, for the machine:
```bash
hostnamectl set-hostname jitsimeet
sed -i 's/^127.0.1.1.*$/127.0.1.1 jitsimeet.easyjitsi.com jitsimeet/g' /etc/hosts
```
To verify it was set properly we run these commands
```bash
hostname
hostname -f
```
We then ensure the firewall is allowed for OpenSSH, HTTP, and HTTPS traffic, along with inbound UDP traffic on port 10000:
We do that by running the following commands:
<details>
<summary>If you do not have UFW:</summary>
Install it like so:
```bash
apt install ufw -y
```
Once it's done installing enable it
```bash
ufw enable
```
</details>
```bash
ufw enable
ufw allow OpenSSH
ufw allow http
ufw allow https
ufw allow in 10000/udp
ufw start
```
There may be a prompt that will ask `Command may disrupt existing ssh connections. Proceed with operation (y|n)?`, type `y` and then press `Enter`.
We Update and upgrade our packages and Reboot our server
NB: **_This will log us out of the Ubuntu server: We wait for a few seconds and login into the server again._**
```bash
apt update
apt upgrade -y && shutdown -r now
```
| 28.571429 | 291 | 0.748929 | eng_Latn | 0.944911 |
474248b0076efe62b19eefc74c11203604c07166 | 381 | md | Markdown | docs/arrow-meta/arrow-meta/arrow.common.utils/-processor-utils/has-no-companion.md | nomisRev/ArrowDokkaTest | 507f6addb1e379f84aa4257d14b002fc4fcfac7f | [
"Apache-2.0"
] | null | null | null | docs/arrow-meta/arrow-meta/arrow.common.utils/-processor-utils/has-no-companion.md | nomisRev/ArrowDokkaTest | 507f6addb1e379f84aa4257d14b002fc4fcfac7f | [
"Apache-2.0"
] | null | null | null | docs/arrow-meta/arrow-meta/arrow.common.utils/-processor-utils/has-no-companion.md | nomisRev/ArrowDokkaTest | 507f6addb1e379f84aa4257d14b002fc4fcfac7f | [
"Apache-2.0"
] | null | null | null | //[arrow-meta](../../../index.md)/[arrow.common.utils](../index.md)/[ProcessorUtils](index.md)/[hasNoCompanion](has-no-companion.md)
# hasNoCompanion
[jvm]\
open val [Element](https://docs.oracle.com/javase/8/docs/api/javax/lang/model/element/Element.html).[hasNoCompanion](has-no-companion.md): [Boolean](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-boolean/index.html)
| 54.428571 | 221 | 0.734908 | yue_Hant | 0.56886 |
4742537c0adf79d34a67f7eb8315e715d69fce5d | 3,879 | md | Markdown | client/CHANGELOG.md | smallp/vscode-ci | 4c2a3a8343219020a1d1c21017f2668f8507fafc | [
"MIT"
] | 35 | 2017-01-27T19:20:48.000Z | 2022-01-29T08:28:10.000Z | client/CHANGELOG.md | smallp/vscode-ci | 4c2a3a8343219020a1d1c21017f2668f8507fafc | [
"MIT"
] | 61 | 2017-02-05T02:18:45.000Z | 2022-01-04T01:47:51.000Z | client/CHANGELOG.md | smallp/vscode-ci | 4c2a3a8343219020a1d1c21017f2668f8507fafc | [
"MIT"
] | 14 | 2018-11-26T15:32:08.000Z | 2022-01-14T08:51:13.000Z | # Change Log
## 0.4.2 (2021/01/19)
* Fix: onSignatureHelp & onHover failed if there is subfolder.[#54](https://github.com/smallp/vscode-ci/issues/54)
## 0.4.0 (2020/12/07)
* Fix: No error if `CI.other` has invalid file.[#42](https://github.com/smallp/vscode-ci/issues/42)
* Feature: Enable to go to definition for "view" files. Thanks `aswinkumar863` for contribute.[#46](https://github.com/smallp/vscode-ci/issues/46)
## 0.3.9 (2020/04/07)
* Fix: Use vscode-uri again for Windows.
* Fix: No error for `->->`.[#39](https://github.com/smallp/vscode-ci/issues/39)
## 0.3.7 (2020/04/02)
* Fix: follow vscode guide, remove unneed resolveProvider. [#35](https://github.com/smallp/vscode-ci/issues/37)
* Minimize server with webpack.
## 0.3.5 (2020/01/08)
* Fix: works fine when model in subfolder. [#35](https://github.com/smallp/vscode-ci/issues/35)
* Feature: allow space between `->` and words. [#36](https://github.com/smallp/vscode-ci/issues/36)
## 0.3.5 (2019/12/16)
* Fix: Correct case in model and library.
## 0.3.4 (2019/11/28)
* The way dealing with case of model now is the same with CI. [#34](https://github.com/smallp/vscode-ci/issues/34)
* Remove the setting `capitalize`.
* `ignoreSymbols` affects more.
## 0.3.3 (2019/11/04)
* Fix bug in complete. [#33](https://github.com/smallp/vscode-ci/issues/33)
## 0.3.2 (2019/10/05)
* Add more debug info. If there are any caught error, the output channal would show more debug info. You can push these info as an issue. [#31](https://github.com/smallp/vscode-ci/issues/31)
* Enable capitalize. [#16](https://github.com/smallp/vscode-ci/issues/16)
* Add feature: now code completion and definition supports variables.
## 0.3.1(0.2.12) (2019/07/12)
* Add feature: support `$CI` or `$this->CI`. [#19](https://github.com/smallp/vscode-ci/issues/19)
* Try to run `CI: refresh Model` command to figure out if this extension starts.
## 0.2.10 (2018/03/15)
* Fix bug: No more errors. [#15](https://github.com/smallp/vscode-ci/issues/15)
* Keep the setting of model when you refresh the models.
## 0.2.9 (2018/03/09)
* Add config of library. [#11](https://github.com/smallp/vscode-ci/issues/11)
* Enable alias in config. [#14](https://github.com/smallp/vscode-ci/issues/14)
## 0.2.8 (2017/11/17)
* Fix bug: Work fine in windows.
## 0.2.7 (2017/11/15)
* Fix bug: change way get path to adapt windows.
## 0.2.5 (2017/11/12)
* Fix bug: extension crashed.
* Do not load this extension if no system folder.
* Show more info in methods of model.
## 0.2.3 (2017/11/11)
* add support for Multi-root workspaces
* be able to set system and application folders.
## 0.2.2 (2017/7/31)
* fix bug in autoComplete
## 0.2.1 (2017/6/24)
* Class name now becomes case sensitivity. See [#3](https://github.com/smallp/vscode-ci/issues/3).
* Going to definition works fine for `self::`
* Add commend `CI:refresh Model` to refresh the model folder if you add or delete model files.
## 0.2.0 (2017/6/16)
* fix bug in Signature
* add definition for $this->method()
## 0.1.9 (2017/5/4)
* fix bug in goto definition
* Add hover.
* Finish the extension.
## 0.1.6 (2017/4/26)
* fix bug in parsing const
## 0.1.5 (2017/4/26)
* Work fine in `$this->db->query($this->)`
* fix bug in loading loader class.
* Work fine in signature.
## 0.1.4 (2017/4/22)
* Refactor the whole project.
* Add const and static support for `self::`
* Add function hints for `$this->` as VScode still not support this feature.
## 0.1.3 (2017/2/28)
* change to Snippet in autoComplete
* fix bug when there is sub-folder in model
## 0.1.2 (2017/2/15)
* Add setting support.
* code optimize
## 0.1.1 (2017/2/13)
* Add const and static support.
## 0.0.10 (2017/2/11)
* bug fix - Path error in Windows. See [#1](https://github.com/smallp/vscode-ci/issues/1).
* known issue fix - When going to the definition of a class, it can jump to the right position.
* code optimize | 35.916667 | 191 | 0.691673 | eng_Latn | 0.809482 |
47427d3859acde96742ffb4f043efbedb009f44f | 86 | md | Markdown | manual/data-aggregation.md | marbug/mongodb | 04b16b7b7556d728b241304083820f7878fdf9ed | [
"MIT"
] | null | null | null | manual/data-aggregation.md | marbug/mongodb | 04b16b7b7556d728b241304083820f7878fdf9ed | [
"MIT"
] | null | null | null | manual/data-aggregation.md | marbug/mongodb | 04b16b7b7556d728b241304083820f7878fdf9ed | [
"MIT"
] | null | null | null | # Data aggregation #
TODO https://docs.mongodb.com/manual/core/aggregation-pipeline/
| 21.5 | 63 | 0.77907 | yue_Hant | 0.597468 |
4742a8cb4849d43eb82687e5ab14f37ae7575101 | 2,524 | md | Markdown | docs/2014/relational-databases/clr-integration/assemblies-getting-information.md | brunom/sql-docs | d80aaa52562d828f9bfb932662ad779432301860 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/2014/relational-databases/clr-integration/assemblies-getting-information.md | brunom/sql-docs | d80aaa52562d828f9bfb932662ad779432301860 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/2014/relational-databases/clr-integration/assemblies-getting-information.md | brunom/sql-docs | d80aaa52562d828f9bfb932662ad779432301860 | [
"CC-BY-4.0",
"MIT"
] | 1 | 2021-04-05T00:11:33.000Z | 2021-04-05T00:11:33.000Z | ---
title: "Getting Information About Assemblies | Microsoft Docs"
ms.custom: ""
ms.date: "03/06/2017"
ms.prod: "sql-server-2014"
ms.reviewer: ""
ms.suite: ""
ms.technology: clr
ms.tgt_pltfrm: ""
ms.topic: "reference"
helpviewer_keywords:
- "assemblies [CLR integration], metadata"
- "status information [SQL Server], assemblies"
- "metadata [SQL Server], assemblies"
ms.assetid: 6aa7f18e-baad-4481-9777-8c3b230b392f
caps.latest.revision: 19
author: rothja
ms.author: jroth
manager: craigg
---
# Getting Information About Assemblies
The following catalog views and functions can be queried for metadata about assemblies.
**To get information about individual assemblies**
- [ASSEMBLYPROPERTY (Transact-SQL)](/sql/t-sql/functions/assemblyproperty-transact-sql)
**To get information about all assemblies in the database**
- [sys.assemblies (Transact-SQL)](/sql/relational-databases/system-catalog-views/sys-assemblies-transact-sql)
**To get information about assembly files, including assembly binaries, source files, and debug files**
- [sys.assembly_files (Transact-SQL)](/sql/relational-databases/system-catalog-views/sys-assembly-files-transact-sql)
**To get information about cross-assembly references**
- [sys.assembly_references (Transact-SQL)](/sql/relational-databases/system-catalog-views/sys-assembly-references-transact-sql)
**To get assembly information about user-defined types**
- [sys.assembly_types (Transact-SQL)](/sql/relational-databases/system-catalog-views/sys-assembly-types-transact-sql)
- [sys.types (Transact-SQL)](/sql/relational-databases/system-catalog-views/sys-types-transact-sql)
**To get assembly information about common language runtime (CLR) stored procedures, triggers, and functions**
- [sys.assembly_modules (Transact-SQL)](/sql/relational-databases/system-catalog-views/sys-assembly-modules-transact-sql)
**To get information about non-CLR objects**
- [sys.sql_modules (Transact-SQL)](/sql/relational-databases/system-catalog-views/sys-sql-modules-transact-sql)
## See Also
[Assemblies (Database Engine)](../../relational-databases/clr-integration/assemblies-database-engine.md)
[Designing Assemblies](../../relational-databases/clr-integration/assemblies-designing.md)
[Implementing Assemblies](assemblies-implementing.md)
| 42.066667 | 140 | 0.720681 | eng_Latn | 0.248838 |
4742aba9f27ebd88921046e32c1e8b62d42da674 | 215 | md | Markdown | src/documents/demos/FlxSpriteFilters.html.md | Ohmnivore/haxeflixel.com | 0b8fdd4eae36ee55800f9277a96a7c06fe3797f0 | [
"MIT"
] | 46 | 2015-01-31T02:22:44.000Z | 2022-03-23T08:41:55.000Z | src/documents/demos/FlxSpriteFilters.html.md | gamedevsam/haxeflixel.com | e23fb8bb7ff52f449b40dad8154fe4b4e74a42c4 | [
"MIT"
] | 85 | 2015-01-30T23:21:50.000Z | 2022-03-28T19:22:34.000Z | src/documents/demos/FlxSpriteFilters.html.md | gamedevsam/haxeflixel.com | e23fb8bb7ff52f449b40dad8154fe4b4e74a42c4 | [
"MIT"
] | 60 | 2015-01-22T22:21:09.000Z | 2022-03-18T15:13:04.000Z | ```
title: "FlxSpriteFilters"
layout: demo
source: "Effects/FlxSpriteFilters"
targets: ['flash', 'html5']
```
This demo shows bitmap filters being applied and updated on FlxSprites using the FlxSpriteFilter class.
| 23.888889 | 103 | 0.767442 | eng_Latn | 0.653276 |
4742df8e9a155459e497f4cccd7049bc479851e6 | 2,225 | md | Markdown | includes/migration-guide/retargeting/wpf/nullreferenceexception-exception-handling-code-from.md | TomekLesniak/docs.pl-pl | 3373130e51ecb862641a40c5c38ef91af847fe04 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | includes/migration-guide/retargeting/wpf/nullreferenceexception-exception-handling-code-from.md | TomekLesniak/docs.pl-pl | 3373130e51ecb862641a40c5c38ef91af847fe04 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | includes/migration-guide/retargeting/wpf/nullreferenceexception-exception-handling-code-from.md | TomekLesniak/docs.pl-pl | 3373130e51ecb862641a40c5c38ef91af847fe04 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
ms.openlocfilehash: 9c9c4ec55143ef991e9b69a389e0f3368263bb4e
ms.sourcegitcommit: e02d17b2cf9c1258dadda4810a5e6072a0089aee
ms.translationtype: MT
ms.contentlocale: pl-PL
ms.lasthandoff: 07/01/2020
ms.locfileid: "85614847"
---
### <a name="nullreferenceexception-in-exception-handling-code-from-imagesourceconverterconvertfrom"></a>NullReferenceException w kodzie obsługującym wyjątek z ImageSourceConverter. ConvertFrom
#### <a name="details"></a>Szczegóły
Błąd w kodzie obsługi wyjątku dla <xref:System.Windows.Media.ImageSourceConverter.ConvertFrom(System.ComponentModel.ITypeDescriptorContext,System.Globalization.CultureInfo,System.Object)> spowodowany błędem <xref:System.NullReferenceException?displayProperty=fullName> został zgłoszony, zamiast zamierzonego wyjątku ( <xref:System.IO.DirectoryNotFoundException?displayProperty=fullName> lub <xref:System.IO.FileNotFoundException?displayProperty=fullName> ). Ta zmiana koryguje ten błąd, aby Metoda teraz wyrzucał właściwy wyjątek. <p/>Domyślnie wszystkie aplikacje ukierunkowane na .NET Framework 4.6.2 i poprzednie nadal generują <xref:System.NullReferenceException?displayProperty=fullName> zgodność. Deweloperzy ukierunkowani na .NET Framework 4,7 i nowsze powinny zobaczyć właściwe wyjątki.
#### <a name="suggestion"></a>Sugestia
Deweloperzy, którzy chcą wrócić do uzyskania, <xref:System.NullReferenceException?displayProperty=fullName> gdy celem .NET Framework 4,7 lub nowszym będzie Dodawanie/scalanie następujących elementów w pliku App.config aplikacji:
<pre><code class="lang-xml"><configuration> <runtime> <AppContextSwitchOverrides value="Switch.System.Windows.Media.ImageSourceConverter.OverrideExceptionWithNullReferenceException=true"/> </runtime> </configuration> </code></pre>
| Nazwa | Wartość |
|:--------|:------------|
| Zakres | Brzeg |
| Wersja | 4,7 |
| Typ | Przekierowanie |
#### <a name="affected-apis"></a>Dotyczy interfejsów API
- <xref:System.Windows.Media.ImageSourceConverter.ConvertFrom(System.ComponentModel.ITypeDescriptorContext,System.Globalization.CultureInfo,System.Object)?displayProperty=nameWithType>
| 74.166667 | 794 | 0.792809 | pol_Latn | 0.857169 |
47432d321548ae747cdc29c8088e689d400ad936 | 6,732 | md | Markdown | articles/cost-management-billing/reservations/troubleshoot-product-not-available.md | tsunami416604/azure-docs.hu-hu | aeba852f59e773e1c58a4392d035334681ab7058 | [
"CC-BY-4.0",
"MIT"
] | 7 | 2017-08-28T07:44:33.000Z | 2021-04-20T21:12:50.000Z | articles/cost-management-billing/reservations/troubleshoot-product-not-available.md | tsunami416604/azure-docs.hu-hu | aeba852f59e773e1c58a4392d035334681ab7058 | [
"CC-BY-4.0",
"MIT"
] | 412 | 2018-07-25T09:31:03.000Z | 2021-03-17T13:17:45.000Z | articles/cost-management-billing/reservations/troubleshoot-product-not-available.md | tsunami416604/azure-docs.hu-hu | aeba852f59e773e1c58a4392d035334681ab7058 | [
"CC-BY-4.0",
"MIT"
] | 13 | 2017-09-05T09:10:35.000Z | 2021-11-05T11:42:31.000Z | ---
title: Nem elérhető Azure foglalási típussal kapcsolatos problémák elhárítása
description: Ez a cikk segítséget nyújt az Azure Portalon nem elérhetőként megjelenő fenntartott példányokkal kapcsolatos problémák megértéséhez és elhárításához.
author: bandersmsft
ms.service: cost-management-billing
ms.subservice: reservations
ms.author: banders
ms.reviewer: yashar
ms.topic: troubleshooting
ms.date: 10/27/2020
ms.openlocfilehash: 8575d9d86d8e720122a295cf92fa571ef33d5b4c
ms.sourcegitcommit: 400f473e8aa6301539179d4b320ffbe7dfae42fe
ms.translationtype: HT
ms.contentlocale: hu-HU
ms.lasthandoff: 10/28/2020
ms.locfileid: "92798190"
---
# <a name="troubleshoot-reservation-type-not-available"></a>Nem elérhető foglalási típussal kapcsolatos problémák elhárítása
Ez a cikk segítséget nyújt az Azure Portalon nem elérhetőként megjelenő fenntartott példányokkal kapcsolatos problémák megértéséhez és elhárításához.
## <a name="symptoms"></a>Hibajelenségek
1. Jelentkezzen be az [Azure Portalra](https://portal.azure.com/), és lépjen a **Foglalások** területre.
2. Válassza a **+ Hozzáadás** elemet, majd válasszon ki egy terméket.
3. Válassza a **Minden termék** lapot.
4. Válasszon ki egy terméket a terméklistából. Az alábbi üzenetek valamelyikét láthatja:
- `Product unavailable for the selected subscription or region. Contact support.`
:::image type="content" source="./media/troubleshoot-product-not-available/product-unavailable-message.png" alt-text="Példa arra az üzenetre, amely azt jelzi, hogy a termék nem érhető el a kiválasztott előfizetés vagy régió esetében" lightbox="./media/troubleshoot-product-not-available/product-unavailable-message.png" :::
- `The selected subscription does not have enough core quota remaining to purchase this product. Request quota increase`
:::image type="content" source="./media/troubleshoot-product-not-available/not-enough-core-quota-message.png" alt-text="Példa arra az üzenetre, amely azt jelzi, hogy a termék nem érhető el a kiválasztott előfizetés vagy régió esetében" lightbox="./media/troubleshoot-product-not-available/not-enough-core-quota-message.png" :::
## <a name="cause"></a>Ok
Egyes foglalások nem vásárolhatók meg, mert:
- Egyes fenntartottpéldány-termékek nem vásárolhatók meg minden régióban
- Az előfizetésre kvótakorlátozás érvényes
### <a name="cause-1"></a>1\. ok
Nem mindegyik fenntartottpéldány-termék vásárolható meg. Az Azure az ügyfelek számára biztosított pénzügyi kedvezmények nyújtásával járó költségek alapján dönt arról, hogy egyes termékek megvásárolhatók-e vagy sem. Más esetekben az Azure az adott adatközpontok kapacitásfeltételei miatt nem kínál bizonyos termékeket. Emellett előfordulhat, hogy az egyes Azure-termékek fejlesztéséért felelős csapatok nem engedélyezik bizonyos termékek megvásárlását, mert ki szeretnének vezetni egy régebbi terméket.
Más esetekben az Azure kapacitáskorlátozásokat vezet be különféle termékekre vonatkozóan az egyes régiókban az adott erőforrások iránt jelentkező kereslet alapján. Ilyen korlátozást vezethet be például akkor, ha a kereslet miatt egy adott virtuálisgép-méret elfogyott az adatközpontban. Ebben az esetben az Azure nem tudja garantálni a kapacitást azon ügyfelek számára, akik az adott régióban vásároltak foglalást a kérdéses méretre vonatkozóan. Végül vannak olyan termékek, amelyek különféle okok miatt egyedinek számítanak. Ezek a termékek csak kis számú, kiválasztott ügyfél számára érhetők el.
Ha nem vásárolhatók meg, akkor miért jelennek meg mégis egyes foglalások az Azure Portalon? Azért, mert a felhasználók támogatási kéréseket hoznak létre, jelezve, hogy nem találják a kívánt termékeket. Az Azure Reservations fejlesztői csapata úgy látta, hogy kevesebb támogatási kéréssel jár az, ha az összes termék megjelenik az esetleges `Product unavailable` üzenettel, mintha nem lennének láthatók.
### <a name="cause-2"></a>2\. ok
Az előfizetésre kvótakorlátozás érvényes. Az előfizetések esetében korlátozva van a használható processzormagok száma. A korlátozás bizonyos fenntartottpéldány-termékekre is érvényes, különösen a virtuális gépekre. Az Azure biztosítani szeretné, hogy a fenntartott példányt vásárló személyek használni is tudják a terméket. Az Azure egyszerű, futólagos ellenőrzést végez az Azure Portalon annak meghatározására, hogy rendelkezik-e az ügyfél az előfizetésében elegendő szabad maggal a virtuális gép üzembe helyezéséhez, és valóban előnnyel jár-e számára a foglalás megvásárlása.
Az ellenőrzés, amely lehetővé teszi egy adott terméknek a kosárhoz való hozzáadását és a foglalás megvásárlását, egyszerű. Az Azure felméri az előfizetés számára elérhető processzormagok teljes számát, és ellenőrzi, hogy ez a szám nagyobb-e a kiválasztott tételhez tartozó magok számánál.
Az Azure nem ellenőrzi a **megosztott** hatókörű fenntartott példányokhoz kapcsolódó kvótát. A megosztott hatókör esetén a fenntartott példánnyal járó előny a regisztráció mindegyik előfizetésére érvényes. Az Azure nem tudja megállapítani, hogy az ügyfél rendelkezik-e elegendő szabad maggal az erőforrás üzembe helyezéséhez az összes előfizetést figyelembe véve. Az Azure a kvótától függetlenül mindig lehetővé teszi a virtuálisgép-méret kiválasztását, ha a kiválasztott hatókör megosztott.
Az Azure emellett nem végez kvótaellenőrzést a **javasolt** vásárlásokra vonatkozóan sem. A javaslatok az aktív használaton alapulnak. Az Azure feltételezi, hogy az ügyfél rendelkezik elegendő maggal az adott virtuálisgép-méret futtatásához, mert az ügyfél esetében már megvalósult a javaslat létrehozásához szükséges használat.
## <a name="solution"></a>Megoldás
A kapott hibaüzenettől függően az alábbi megoldások valamelyikével háríthatja el a problémát.
### <a name="solution-1"></a>1\. megoldás
Ha arra vonatkozó üzenet jelenik meg, hogy a _termék nem érhető el_ , kattintson a hibaüzenetben található **Kapcsolatfelvétel a támogató szolgálattal** hivatkozásra, és kérje egy kivételnek az előfizetéshez való hozzáadását. A kivételek azonban nem mindig engedélyezhetők.
### <a name="solution-2"></a>2\. megoldás
Ha arra vonatkozó üzenet jelenik meg, hogy _nincs elegendő magkvóta_ , módosíthatja a hatókört a **megosztott** hatókörre. A foglalás megvásárlását követően módosíthatja a foglalás hatókörét a **megosztott** hatókörről az **egyetlen előfizetésre kiterjedő** hatókörre.
Másik megoldásként kattintson a hibaüzenetben található **Kvótanövelés kérése** hivatkozásra, és igényeljen további processzormagkvótát az előfizetés számára.
## <a name="next-steps"></a>Következő lépések
- A foglalásihatókör-beállításokkal kapcsolatos további információkért lásd: [A foglalások hatókörének beállítása](prepare-buy-reservation.md#scope-reservations). | 90.972973 | 597 | 0.81833 | hun_Latn | 1.00001 |
47437e52a95b83b6c57d7b0a3f27078939ad17e8 | 1,398 | md | Markdown | CONTRIBUTING.md | divergentdave/citation | 061446acea464ffbb640c5cafbe8d465542d49c1 | [
"CC0-1.0"
] | 127 | 2015-01-02T12:29:29.000Z | 2022-02-19T04:41:33.000Z | CONTRIBUTING.md | divergentdave/citation | 061446acea464ffbb640c5cafbe8d465542d49c1 | [
"CC0-1.0"
] | 52 | 2015-01-31T20:19:32.000Z | 2020-06-07T14:23:15.000Z | CONTRIBUTING.md | divergentdave/citation | 061446acea464ffbb640c5cafbe8d465542d49c1 | [
"CC0-1.0"
] | 36 | 2015-02-25T00:32:57.000Z | 2022-02-10T04:35:09.000Z | ## Public domain
The project is in the public domain within the United States, and copyright and related rights in the work worldwide are waived through the [CC0 1.0 Universal public domain dedication][CC0].
All contributions to this project will be released under the CC0 dedication. By submitting a pull request, you are agreeing to comply with this waiver of copyright interest.
[CC0]: http://creativecommons.org/publicdomain/zero/1.0/
## Browser Builds
`citation` uses `gulp` and `browserify` and a few other tools to create browser-ready builds.
If you modify any `citation` code and want to send a pull request, please update the browser builds (located in the `browser` folder) by running `gulp`. (Install `gulp` first by running `npm install gulp -g`.)
If you are unable to do this, you should still contribute! Just make a note of this in the text of the pull request.
Currently three different files are created for browser use:
1. `browser/citation.js`: an unminified, uncompressed version. Good for development, and includes a (large) source map so that debugging references the original files and line numebrs. Very unideal for production **>1 MB**.
2. `browser/citation.min.js`: a minified, uncompressed version. Decent for production, does not include a source map. **~200 KB**.
3. `browser/citation.min.js.gz`: a minified, gzipped version. Best for production. **~50 KB**. | 63.545455 | 223 | 0.76824 | eng_Latn | 0.998256 |
47441fb934d1da0db2e19f688b79376c0b71b2d8 | 2,256 | md | Markdown | docs/debug.md | joepvd/special-resource-operator | 0deed37c7c85d3e578d26cdda2260008c054005a | [
"Apache-2.0"
] | null | null | null | docs/debug.md | joepvd/special-resource-operator | 0deed37c7c85d3e578d26cdda2260008c054005a | [
"Apache-2.0"
] | null | null | null | docs/debug.md | joepvd/special-resource-operator | 0deed37c7c85d3e578d26cdda2260008c054005a | [
"Apache-2.0"
] | null | null | null | # How to debug recipes
The Special Resource Operatore (SRO) can read the states either from the local,
http or a ConfigMap resource.
To create the states in the template directory as a CM we can run the
following:
```bash
VERSION=0.0.1 REPO=example SPECIALRESOURCE=multi-build make chart
```
This command will create a CM with all the states and SRO will use them in the
next reconcilation loop. This makes it easy to override manifests during
development without rebuilding SRO.
To update the CR one can run:
```bash
SPECIALRESOURCE=multi-build REPO=example VERSION=0.0.1 make chart
```
```bash
VERSION=0.0.1 REPO=example SPECIALRESOURCE=multi-build make
```
ConfigMap is a protocol handler to Helm. Charts can now also be indexed from a ConfigMap.
The command above creates a CM with the chart embedded as binaryData.
Update the CR to use `cm://` protocol handler in SRO. URL schema is
`cm://<NAMESPACE>/<SPECIALRESOURCE>-chart`
```yaml=
spec:
chart:
name: multi-build
repository:
caFile: ""
certFile: ""
insecure_skip_tls_verify: false
keyFile: ""
name: example
password: ""
url: cm://multi-build/multi-build-chart
```
Another field was added to the CR, namely `debug` that can be set to true to get
all the manifests, hooks and values printed on the console. Can be valuable for
verifying if all `Values` are set and correclty interpreted.
```yaml=
apiVersion: sro.openshift.io/v1beta1
kind: SpecialResource
metadata:
name: multi-build
spec:
debug: false
namespace: multi-build
chart:
name: multi-build
version: 0.0.1
repository:
name: example
url: file:///charts/example
set:
kind: Values
apiVersion: sro.openshift.io/v1beta1
pushSecret: openshift-psap-multibuild-pull-secret
imageToSign: docker.io/zvonkok/{{.Values.specialresource.metadata.name}}-{{.Values.groupName.driverContainer}}:v{{.Values.kernelFullVersion}}
cosignPassword: strongpassword
buildArgs:
- name: "KMODVER"
value: "{{ .Values.kernelFullVersion }}"
driverContainer:
source:
git:
ref: "master"
uri: "https://github.com/openshift-psap/kvc-simple-kmod.git"
```
SRO will print each complete state the corresponding values.
| 27.512195 | 145 | 0.718528 | eng_Latn | 0.92748 |
47445600bd3ccfc26bd350b0e3c9a3b654210628 | 13,939 | md | Markdown | docs/framework/wpf/advanced/graphics-rendering-tiers.md | felipealbuquerq/docs.pt-br | 6808f7d63212e650a0ecadd7f5cd058594fd0d38 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/framework/wpf/advanced/graphics-rendering-tiers.md | felipealbuquerq/docs.pt-br | 6808f7d63212e650a0ecadd7f5cd058594fd0d38 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/framework/wpf/advanced/graphics-rendering-tiers.md | felipealbuquerq/docs.pt-br | 6808f7d63212e650a0ecadd7f5cd058594fd0d38 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: Camadas de renderização de gráficos
ms.date: 03/30/2017
helpviewer_keywords:
- graphics [WPF], performance
- rendering graphics [WPF]
- rendering tiers [WPF]
- graphics rendering tiers [WPF]
- graphics [WPF], rendering tiers
ms.assetid: 08dd1606-02a2-4122-9351-c0afd2ec3a70
ms.openlocfilehash: 9da519f8d258673498f45a425c13863437cac597
ms.sourcegitcommit: 68653db98c5ea7744fd438710248935f70020dfb
ms.translationtype: MT
ms.contentlocale: pt-BR
ms.lasthandoff: 08/22/2019
ms.locfileid: "69937526"
---
# <a name="graphics-rendering-tiers"></a>Camadas de renderização de gráficos
Um nível de renderização define um nível de funcionalidade de hardware de gráficos e de desempenho para um dispositivo que executa um aplicativo [!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)].
<a name="graphics_hardware"></a>
## <a name="graphics-hardware"></a>Hardware de gráficos
Os recursos do hardware gráfico que mais afetam os níveis de camada de renderização são:
- **RAM de Vídeo** A quantidade de memória de vídeo no hardware gráfico determina o tamanho e o número de buffers que podem ser usados para compor gráficos.
- **Sombreador de Pixel** Um sombreador de pixel é uma função de processamento gráfico que calcula efeitos por pixel. Dependendo da resolução dos gráficos exibidos, pode haver muitos milhões de pixels que precisam ser processados para cada quadro de vídeo.
- **Sombreador de Vértice** O sombreador de vértice é uma função de processamento gráfico que realiza operações matemáticas nos dados de vértice do objeto.
- **Suporte Multitextura** Suporte multitextura refere-se à capacidade de aplicar duas ou mais texturas distintas durante uma operação de mesclagem em um objeto gráfico 3D. O grau de suporte a multitextura é determinado pelo número de unidades de multitextura no hardware gráfico.
<a name="rendering_tier_definitions"></a>
## <a name="rendering-tier-definitions"></a>Definições da camada de processamento
Os recursos do hardware gráfico determinam a capacidade de renderização de um aplicativo [!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)]. O sistema [!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)] define três camadas de renderização:
- **Camada de Renderização 0** Sem aceleração de hardware gráfico. Todos os recursos gráficos usam a aceleração de software. O nível de versão do DirectX é menor que a versão 9,0.
- **Camada de Renderização 1** Alguns recursos gráficos usam aceleração de hardware gráfico. O nível de versão do DirectX é maior ou igual à versão 9,0.
- **Camada de Renderização 2** A maioria dos recursos gráficos usa aceleração de hardware gráfico. O nível de versão do DirectX é maior ou igual à versão 9,0.
A <xref:System.Windows.Media.RenderCapability.Tier%2A?displayProperty=nameWithType> propriedade permite que você recupere a camada de renderização no tempo de execução do aplicativo. Você pode usar o nível de renderização para determinar se o dispositivo dá suporte a certas características aceleradas por hardware. Seu aplicativo então pode adotar diferentes caminhos de código no tempo de execução, dependendo da camada de renderização que tem suporte no dispositivo.
### <a name="rendering-tier-0"></a>Camada de renderização 0
Um valor de nível de renderização 0 significa que não há nenhum gráficos aceleração de hardware disponível para o aplicativo no dispositivo. Nesse nível, você deve assumir que todos os gráficos serão renderizados por software sem aceleração de hardware. A funcionalidade dessa camada corresponde a uma versão do DirectX inferior a 9,0.
### <a name="rendering-tier-1-and-rendering-tier-2"></a>Camada de Renderização 1 e Camada de Renderização 2
> [!NOTE]
> A partir do .NET Framework 4, a camada de renderização 1 foi redefinida para incluir apenas hardware de gráficos que ofereça suporte a DirectX 9,0 ou superior. O hardware gráfico que dá suporte ao DirectX 7 ou 8 agora está definido como camada de renderização 0.
Um valor da camada de renderização de 1 ou 2 significa que a maioria dos recursos gráficos do [!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)] usará a aceleração de hardware se os recursos de sistema necessários estiverem disponíveis e não forem esgotados. Isso corresponde a uma versão do DirectX maior ou igual a 9,0.
A tabela a seguir mostra as diferenças nos requisitos de hardware de gráficos para o processamento da camada 1 e renderização camada 2:
|Recurso|Camada 1|Camada 2|
|-------------|------------|------------|
|Versão do DirectX|Deve ser maior ou igual a 9,0.|Deve ser maior ou igual a 9,0.|
|RAM de vídeo|Deve ser maior ou igual a 60 MB.|Deve ser maior ou igual a 120 MB.|
|Sombreador de pixel|O nível de versão deve ser maior ou igual a 2,0.|O nível de versão deve ser maior ou igual a 2,0.|
|Sombreador de vértice|Nenhum requisito.|O nível de versão deve ser maior ou igual a 2,0.|
|Unidades multitexturas|Nenhum requisito.|Número de unidades deve ser maior ou igual a 4.|
Os seguintes recursos e capacidades são acelerados por hardware para camada de renderização 1 e 2:
|Recurso|Observações|
|-------------|-----------|
|Renderização 2D|A maioria das renderizações 2D tem suporte.|
|Rasterização 3D|A maioria das rasterizações 3D tem suporte.|
|Filtro anisotrópico 3D|[!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)] tenta usar o filtro anisotrópico quando renderiza conteúdo 3D. O filtro anisotrópico se refere a melhorar a qualidade da imagem de texturas em superfícies distantes e profundamente angular em relação a câmera.|
|Mapeamento de MIP 3D|[!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)] tenta utilizar mapeamento MIP quando renderiza conteúdo 3D. O mapeamento MIP melhora a qualidade da renderização de textura quando uma textura ocupa um campo menor de exibição <xref:System.Windows.Controls.Viewport3D>em um.|
|Gradientes radiais|Embora tenha suporte, evite o uso <xref:System.Windows.Media.RadialGradientBrush> de em objetos grandes.|
|Cálculos de iluminação 3D|[!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)] realiza iluminação por vértice, o que significa que uma intensidade de luz precisa ser calculada a cada vértice para cada material aplicado a uma malha.|
|Renderização de texto|Renderização de texto sub-pixel utiliza sombreadores de pixel disponíveis no hardware gráfico.|
Os seguintes recursos e capacidades são acelerados por hardware apenas para a camada de renderização 2:
|Recurso|Observações|
|-------------|-----------|
|Suavização 3D|Suavização 3D tem suporte apenas em sistemas operacionais que oferecem suporte a WDDM Windows Display Driver Model (WDDM), como [!INCLUDE[TLA2#tla_winvista](../../../../includes/tla2sharptla-winvista-md.md)] e [!INCLUDE[win7](../../../../includes/win7-md.md)].|
Os seguintes recursos e capacidades **não** são acelerados por hardware:
|Recurso|Observações|
|-------------|-----------|
|Conteúdo impresso|Todo conteúdo impresso é renderizado utilizando o [!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)] pipeline de software.|
|Conteúdo rasterizado que usa<xref:System.Windows.Media.Imaging.RenderTargetBitmap>|Qualquer conteúdo renderizado usando o <xref:System.Windows.Media.Imaging.RenderTargetBitmap.Render%2A> método de <xref:System.Windows.Media.Imaging.RenderTargetBitmap>.|
|Conteúdo ao lado do ladrilho que usa<xref:System.Windows.Media.TileBrush>|Qualquer conteúdo em ladrilho no qual <xref:System.Windows.Media.TileBrush.TileMode%2A> a propriedade <xref:System.Windows.Media.TileBrush> de está definida como <xref:System.Windows.Media.TileMode.Tile>.|
|Superfícies que excedam o tamanho máximo de textura do hardware de gráficos|Para a maioria dos hardwares gráficos, superfícies grandes tem 2048x2048 ou 4096x4096 pixels de tamanho.|
|Qualquer operação cujo requisito de RAM de vídeo excede a memória do hardware de gráficos|Você pode monitorar o uso de memória RAM de vídeo do aplicativo usando a ferramenta Perforator incluída no [pacote de desempenho WPF](https://docs.microsoft.com/previous-versions/dotnet/netframework-4.0/aa969767(v=vs.100)) no SDK do Windows.|
|Janelas em camadas|Janelas em camadas permitem que [!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)] aplicativos renderizem o conteúdo na tela em uma janela não retangular. Em sistemas operacionais que oferecem suporte a WDDM Windows Display Driver Model (WDDM), como [!INCLUDE[TLA2#tla_winvista](../../../../includes/tla2sharptla-winvista-md.md)] e [!INCLUDE[win7](../../../../includes/win7-md.md)] em janelas em camadas são aceleradas por hardware. Em outros sistemas, como [!INCLUDE[winxp](../../../../includes/winxp-md.md)], janelas em camadas são renderizadas por software sem aceleração de hardware.<br /><br /> Você pode habilitar janelas em camadas no [!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)] definindo as seguintes <xref:System.Windows.Window> Propriedades:<br /><br /> - <xref:System.Windows.Window.WindowStyle%2A> = <xref:System.Windows.WindowStyle.None><br />- <xref:System.Windows.Window.AllowsTransparency%2A> = `true`<br />- <xref:System.Windows.Controls.Control.Background%2A> = <xref:System.Windows.Media.Brushes.Transparent%2A>|
<a name="other_resources"></a>
## <a name="other-resources"></a>Outros recursos
Os recursos a seguir podem ajudá-lo a analisar as características de desempenho de seu aplicativo [!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)].
### <a name="graphics-rendering-registry-settings"></a>Configurações do Registro de renderização dos elementos gráficos
[!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)] fornece quatro configurações do Registro para controlar a renderização [!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)]:
|Configuração|Descrição|
|-------------|-----------------|
|**Desabilitar Opção de Aceleração de hardware**|Especifica se a aceleração de hardware deve ser habilitada.|
|**Valor máximo de Multisample**|Especifica o grau de multiamostragem para conteúdo de anti-aliasing 3-D.|
|**Driver de vídeo configuração de data necessário**|Especifica se o sistema desabilita a aceleração de hardware para drivers lançados antes de novembro de 2004.|
|**Use a opção de rasterizador de referência**|Especifica se [!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)] deve utilizar o rasterizador de referência.|
Essas configurações podem ser acessadas por qualquer utilitário de configuração externo que sabe como referenciar as configurações do Registro de [!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)]. Essas configurações também podem ser criadas ou modificadas acessando os valores diretamente usando o editor do registro do Windows. Para obter mais informações, consulte as [configurações de Registro de renderização de gráficos](../graphics-multimedia/graphics-rendering-registry-settings.md).
### <a name="wpf-performance-profiling-tools"></a>Ferramentas de criação de perfil de desempenho do WPF
O [!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)] fornece um pacote de ferramentas de criação de perfil de desempenho que permitem analisar o comportamento de tempo de execução do aplicativo e determinar os tipos de otimização de desempenho que você pode aplicar. A tabela a seguir lista as ferramentas de criação de perfil de desempenho incluídas na ferramenta de SDK do Windows, o conjunto de desempenho do WPF:
|Ferramenta|Descrição|
|----------|-----------------|
|Perforator|Use para analisar o comportamento de renderização.|
|Visual Profiler|Utilize para criar perfil do uso de [!INCLUDE[TLA2#tla_winclient](../../../../includes/tla2sharptla-winclient-md.md)] serviços, como layout e manipulação de eventos, pelos elementos na árvore visual.|
O pacote de desempenho WPF fornece uma exibição gráfica rica em dados de desempenho. Para obter mais informações sobre ferramentas de desempenho do WPF, consulte [Pacote de desempenho WPF](https://docs.microsoft.com/previous-versions/dotnet/netframework-4.0/aa969767(v=vs.100)).
### <a name="directx-diagnostic-tool"></a>Ferramenta de diagnóstico do DirectX
A ferramenta de diagnóstico do DirectX, Dxdiag. exe, foi projetada para ajudá-lo a solucionar problemas relacionados ao DirectX. A pasta de instalação padrão para a ferramenta de diagnóstico do DirectX é:
`~\Windows\System32`
Quando você executa a ferramenta de diagnóstico do DirectX, a janela principal contém um conjunto de guias que permitem exibir e diagnosticar informações relacionadas ao DirectX. Por exemplo, a guia **sistema** fornece informações do sistema sobre seu computador e especifica a versão do DirectX instalada no seu computador.
![Screenhot: Ferramenta]de diagnóstico do DirectX(./media/directxdiagnostictool-01.png "DirectXDiagnosticTool_01")
Janela principal da Ferramenta de diagnóstico do DirectX
## <a name="see-also"></a>Consulte também
- <xref:System.Windows.Media.RenderCapability>
- <xref:System.Windows.Media.RenderOptions>
- [Otimizando o desempenho do aplicativo WPF](optimizing-wpf-application-performance.md)
- [Pacote de desempenho WPF](https://docs.microsoft.com/previous-versions/dotnet/netframework-4.0/aa969767(v=vs.100))
- [Configurações do Registro de renderização dos elementos gráficos](../graphics-multimedia/graphics-rendering-registry-settings.md)
- [Dicas e truques de animação](../graphics-multimedia/animation-tips-and-tricks.md)
| 101.007246 | 1,128 | 0.764546 | por_Latn | 0.995547 |
47447ce5b98936b1eb45e7ebdd7441af67cd5518 | 19,351 | md | Markdown | articles/machine-learning/concept-model-management-and-deployment.md | jobailla/azure-docs.fr-fr | 8c7734bc0d6ffaa8f9f2a39982929b8d9fc8235e | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/machine-learning/concept-model-management-and-deployment.md | jobailla/azure-docs.fr-fr | 8c7734bc0d6ffaa8f9f2a39982929b8d9fc8235e | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/machine-learning/concept-model-management-and-deployment.md | jobailla/azure-docs.fr-fr | 8c7734bc0d6ffaa8f9f2a39982929b8d9fc8235e | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: 'MLOps : Gestion des modèles ML'
titleSuffix: Azure Machine Learning
description: 'Apprenez-en plus sur la gestion des modèles avec Azure Machine Learning (MLOps). Déployez, gérez et surveillez vos modèles afin de les améliorer en permanence. '
services: machine-learning
ms.service: machine-learning
ms.subservice: core
ms.topic: conceptual
ms.reviewer: jmartens
author: jpe316
ms.author: jordane
ms.date: 03/17/2020
ms.custom: seodec18
ms.openlocfilehash: 6f03a1e44fdb62570b693753f5e01c7ab0f53e78
ms.sourcegitcommit: 829d951d5c90442a38012daaf77e86046018e5b9
ms.translationtype: HT
ms.contentlocale: fr-FR
ms.lasthandoff: 10/09/2020
ms.locfileid: "91302415"
---
# <a name="mlops-model-management-deployment-and-monitoring-with-azure-machine-learning"></a>MLOps : Gestion, déploiement et surveillance des modèles avec Azure Machine Learning
Dans cet article, découvrez comment utiliser Azure Machine Learning pour gérer le cycle de vie de vos modèles. Azure Machine Learning utilise une approche d’Opérations de Machine Learning (MLOps). MLOps améliore la qualité et la cohérence de vos solutions de Machine Learning.
## <a name="what-is-mlops"></a>Qu’est-ce que MLOps ?
Les opérations de Machine Learning (MLOps) sont basées sur les principes et pratiques de [DevOps](https://azure.microsoft.com/overview/what-is-devops/), qui augmentent l’efficacité des workflows. Par exemple, l’intégration, la livraison et le déploiement continus. MLOps applique ces principes au processus Machine Learning avec l’objectif suivant :
* Expérimentation et développement plus rapides de modèles
* Déploiement plus rapide de modèles en production
* Assurance qualité
Azure Machine Learning propose les fonctionnalités MLOps suivantes :
- **Créer des pipelines ML reproductibles**. Les pipelines Machine Learning vous permettent de définir des étapes reproductibles et réutilisables pour vos processus de préparation des données, de formation et de scoring.
- **Créer des environnements logiciels réutilisables** pour la formation et le déploiement de modèles.
- **Inscrire, empaqueter et déployer des modèles à partir de n’importe quel emplacement**. Vous pouvez également suivre les métadonnées associées requises pour utiliser le modèle.
- **Capturer les données de gouvernance nécessaires pour le cycle de vie ML de bout en bout**. Les informations journalisées peuvent inclure qui publie des modèles, pourquoi des modifications ont été apportées et quand les modèles ont été déployés ou utilisés en production.
- **Notifier et alerter sur des événements du cycle de vie ML**. Par exemple, la fin d’une expérience, l’inscription de modèles, le déploiement de modèles et la détection d’une dérive de données.
- **Superviser les applications ML pour détecter des problèmes de fonctionnement et liés à ML**. Comparez les entrées de modèle entre l’entraînement et l’inférence, explorez les métriques spécifiques du modèle et fournissez des alertes et une supervision pour votre infrastructure ML.
- **Automatiser le cycle de vie ML de bout en bout avec Azure Machine Learning et Azure Pipelines**. L’utilisation de pipelines vous permet de mettre fréquemment à jour les modèles, tester de nouveaux modèles et déployer en permanence de nouveaux modèles ML en même temps que vos autres applications et services.
## <a name="create-reproducible-ml-pipelines"></a>Créer des pipelines ML reproductibles
Utilisez des pipelines ML d’Azure Machine Learning pour réunir toutes les étapes impliquées dans votre processus d’entraînement de modèle.
Un pipeline ML peut contenir des étapes allant de la préparation des données à l’extraction de fonctionnalité, pour le réglage d’hyperparamètre sur l’évaluation du modèle. Pour plus d’informations, consultez [Pipelines ML](concept-ml-pipelines.md).
Si vous utilisez le [Concepteur](concept-designer.md) pour créer vos pipelines ML, vous pouvez à tout moment cliquer sur **« ... »** en haut à droite de la page du Concepteur, puis sélectionner **Cloner**. Le clonage de votre pipeline vous permet d’itérer votre conception de pipeline sans perdre vos anciennes versions.
## <a name="create-reusable-software-environments"></a>Créer des environnements logiciels réutilisables
Les environnements Azure Machine Learning vous permettent de suivre et de reproduire les dépendances logicielles de vos projets au fil de leur évolution. Ils vous permettent de vous assurer que les builds sont reproductibles sans configuration manuelle des logiciels.
Les environnements décrivent les dépendances pip et Conda de vos projets et peuvent être utilisés à la fois pour la formation et le déploiement de modèles. Pour plus d’informations, consultez [Présentation des environnements Azure Machine Learning](concept-environments.md).
## <a name="register-package-and-deploy-models-from-anywhere"></a>Inscrire, empaqueter et déployer des modèles à partir de n’importe quel emplacement
### <a name="register-and-track-ml-models"></a>Inscrire et suivre des modèles ML
L’inscription de modèle vous permet de stocker vos modèles dans le cloud Azure, au sein de votre espace de travail, et d’en gérer les versions. Le registre de modèle facilite l’organisation et le suivi de vos modèles entraînés.
> [!TIP]
> Un modèle inscrit est un conteneur logique pour un ou plusieurs fichiers qui composent votre modèle. Par exemple, si vous avez un modèle qui est stocké dans plusieurs fichiers, vous pouvez inscrire ces derniers en tant que modèle unique dans votre espace de travail Azure Machine Learning. Après l’inscription, vous pouvez ensuite télécharger ou déployer le modèle inscrit et recevoir tous les fichiers qui ont été inscrits.
Les modèles inscrits sont identifiés par leur nom et par leur version. Chaque fois que vous inscrivez un modèle portant le même nom qu’un modèle existant, le registre incrémente la version. Des balises de métadonnées supplémentaires peuvent être fournies lors de l’inscription. Ces balises sont ensuite utilisées lors de la recherche d’un modèle. Azure Machine Learning prend en charge tous les modèles pouvant être chargés avec Python 3.5.2 ou version ultérieure.
> [!TIP]
> Vous pouvez également inscrire des modèles formés en dehors d'Azure Machine Learning.
Vous ne pouvez pas supprimer un modèle inscrit qui est utilisé dans un déploiement actif.
Pour plus d’informations, consultez la section consacrée à l’inscription d’un modèle dans l’article [Déployer des modèles](how-to-deploy-and-where.md#registermodel).
### <a name="profile-models"></a>Modèles de profil
Azure Machine Learning peut vous aider à comprendre les besoins en processeur et en mémoire du service qui sera créé lors du déploiement de votre modèle. Le profilage teste le service qui exécute votre modèle et retourne des informations telles que l’utilisation de l’UC, l’utilisation de la mémoire et la latence de la réponse. Il fournit également une recommandation pour l’UC et la mémoire en fonction de l’utilisation des ressources.
Pour plus d’informations, voir la section consacrée au déploiement dans [Déployer des modèles](how-to-deploy-profile-model.md).
### <a name="package-and-debug-models"></a>Empaqueter et déboguer des modèles
Avant de déployer un modèle en production, il est empaqueté dans une image Docker. Dans la plupart des cas, la création d’image a lieu automatiquement en arrière-plan pendant le déploiement. Vous pouvez spécifier l’image manuellement.
Si vous rencontrez des problèmes avec le déploiement, vous pouvez déployer sur votre environnement de développement local pour la résolution des problèmes et le débogage.
Pour plus d’informations, consultez [Déployer des modèles](how-to-deploy-and-where.md#registermodel) et [Résolution des problèmes liés aux déploiements](how-to-troubleshoot-deployment.md).
### <a name="convert-and-optimize-models"></a>Convertir et optimiser les modèles
La conversion de votre modèle en ONNX ([Open Neural Network Exchange](https://onnx.ai)) peut améliorer les performances. En moyenne, la conversion en ONNX peut doubler les performances.
Pour plus d’informations sur ONNX avec Azure Machine Learning, consultez l’article [Créer et accélérer des modèles ML](concept-onnx.md).
### <a name="use-models"></a>Utiliser des modèles
Les modèles Machine Learning entraînés sont déployés en tant que services web dans le cloud ou localement. Vous pouvez également déployer les modèles sur des appareils Azure IoT Edge. Les déploiements utilisent un processeur, un processeur graphique ou des tableaux FPGA (Field-Programmable Gate Array) pour l’inférence. Vous pouvez également utiliser des modèles de Power BI.
Lorsque vous utilisez un modèle comme un service web ou un appareil IoT Edge, vous fournissez les éléments suivants :
* Modèles utilisés pour noter les données envoyées vers le service/l’appareil.
* Script d’entrée. Ce script accepte les demandes, utilise les modèles pour noter les données et renvoie une réponse.
* Environnement Azure Machine Learning qui décrit les dépendances pip et Conda requises par les modèles et le script d’entrée.
* Autres ressources, telles que le texte ou les données, entre autres, qui sont requises par les modèles et le script d’entrée.
Vous fournissez également la configuration de la plateforme de déploiement cible, par exemple le type de famille de machines virtuelles, la mémoire disponible et nombre de cœurs lors du déploiement sur Azure Kubernetes Service.
Lorsque l’image est créée, les composants requis par Azure Machine Learning sont également ajoutés, par exemple les ressources nécessaires pour exécuter le service web et interagir avec IoT Edge.
#### <a name="batch-scoring"></a>Scoring par lot
La notation par lots est prise en charge via des pipelines ML. Pour plus d’informations, consultez [Prédictions par lots sur le Big Data](how-to-use-parallel-run-step.md).
#### <a name="real-time-web-services"></a>Services web en temps réel
Vous pouvez utiliser vos modèles dans les **services web** avec les cibles de calcul suivantes :
* Azure Container Instance
* Azure Kubernetes Service
* Environnement de développement local
Pour déployer le modèle comme un service web, vous devez fournir les éléments suivants :
* Modèle ou ensemble de modèles.
* Dépendances requises pour utiliser le modèle, par exemple un script qui accepte les demandes et appelle le modèle, les dépendances conda, etc.
* Configuration de déploiement qui décrit comment et où déployer le modèle.
Pour plus d’informations, consultez [Déployer des modèles](how-to-deploy-and-where.md).
#### <a name="controlled-rollout"></a>Lancement contrôlé
Lors d'un déploiement sur Azure Kubernetes Service, vous pouvez utiliser le lancement contrôlé pour activer les scénarios suivants :
* Créer plusieurs versions d’un point de terminaison pour un déploiement
* Effectuer des tests A/B en acheminant le trafic vers différentes versions du point de terminaison.
* Basculer entre différentes versions d’un point de terminaison en mettant à jour le pourcentage de trafic dans la configuration du point de terminaison.
Pour plus d’informations, consultez [Lancement contrôlé des modèles ML](how-to-deploy-azure-kubernetes-service.md#deploy-models-to-aks-using-controlled-rollout-preview).
#### <a name="iot-edge-devices"></a>Appareils IoT Edge
Vous pouvez utiliser des modèles avec les appareils IoT via des **modules Azure IoT Edge**. Les modules IoT Edge sont déployés sur un périphérique matériel, ce qui permet l’inférence, ou le scoring de modèles, sur l’appareil.
Pour plus d’informations, consultez [Déployer des modèles](how-to-deploy-and-where.md).
### <a name="analytics"></a>Analytics
Microsoft Power BI prend en charge l’utilisation de modèles Machine Learning pour l’analytique données. Pour plus d’informations, consultez [Intégration d’Azure Machine Learning dans Power BI (préversion)](https://docs.microsoft.com/power-bi/service-machine-learning-integration).
## <a name="capture-the-governance-data-required-for-capturing-the-end-to-end-ml-lifecycle"></a>Capturer les données de gouvernance nécessaires pour la capture du cycle de vie ML de bout en bout
Azure ML vous donne la possibilité d’effectuer le suivi de la piste d’audit de bout en bout de toutes vos ressources ML à l’aide de métadonnées.
- Azure ML [s’intègre à Git](how-to-set-up-training-targets.md#gitintegration) pour le suivi des informations sur le dépôt / la branche / la validation d’où provient votre code.
- Les [jeux de données Azure ML](how-to-create-register-datasets.md) vous aident à suivre, à profiler et à gérer la version des données.
- [L’interprétabilité](how-to-machine-learning-interpretability.md) vous permet d’expliquer vos modèles, de respecter la conformité réglementaire, et de comprendre comment les modèles arrivent à un résultat pour une entrée donnée.
- L’historique des exécutions Azure ML stocke une capture instantanée du code, des données et des calculs utilisés pour effectuer l’apprentissage d’un modèle.
- Le registre de modèles Azure ML capture toutes les métadonnées associées à votre modèle (l’expérience qui l’a entraîné, où il est déployé, si ses déploiements sont sains).
- [L’intégration à Azure](how-to-use-event-grid.md) vous permet d’agir sur les événements du cycle de vie ML. Par exemple, l’inscription du modèle, le déploiement, la dérive des données et les événements d’apprentissage (exécution).
> [!TIP]
> Bien que certaines informations sur les modèles et les jeux de données soient capturées automatiquement, vous pouvez ajouter des informations supplémentaires à l’aide de __balises__. Lorsque vous recherchez des modèles inscrits et des jeux de données dans votre espace de travail, vous pouvez utiliser des balises comme filtre.
>
> L’association d’un jeu de données à un modèle inscrit est une étape facultative. Pour plus d’informations sur le référencement d’un jeu de données lors de l’inscription d’un modèle, consultez la référence de classe [Modèle](https://docs.microsoft.com/python/api/azureml-core/azureml.core.model%28class%29?view=azure-ml-py&preserve-view=true).
## <a name="notify-automate-and-alert-on-events-in-the-ml-lifecycle"></a>Notifier, automatiser et alerter sur des événements du cycle de vie ML
Azure ML publie des événements clés dans Azure EventGrid, qui peuvent être utilisés pour notifier et automatiser des événements du cycle de vie ML. Pour plus d’informations, consultez [ce document](how-to-use-event-grid.md).
## <a name="monitor-for-operational--ml-issues"></a>Superviser les problèmes opérationnels et Machine Learning
La supervision vous permet de comprendre les données envoyées à votre modèle et les prédictions qu’il retourne.
Ces informations vous aident à comprendre l’utilisation de votre modèle. Les données d’entrée collectées peuvent également être utiles dans l’entraînement des futures versions du modèle.
Pour plus d’informations, consultez [Guide pratique pour activer la collecte des données de modèle](how-to-enable-data-collection.md).
## <a name="retrain-your-model-on-new-data"></a>Réentraîner votre modèle sur de nouvelles données
Vous souhaiterez souvent valider votre modèle, le mettre à jour, ou même le réentraîner depuis le début, à mesure que vous recevrez de nouvelles informations. Parfois, la réception de nouvelles données est une partie attendue du domaine. Dans d’autres cas, comme indiqué dans [Détecter une dérive de données (préversion) sur des jeux de données](how-to-monitor-datasets.md), les performances du modèle peuvent se dégrader en fonction de modifications apportées à un capteur particulier, de modifications de données naturelles telles que l’impact des saisons, ou de fonctionnalités qui évoluent dans leur relation avec d’autres fonctionnalités.
Il n’y a aucune réponse universelle à la question « Comment savoir si je dois réentraîner ? » mais les outils de supervision et d’événements Azure ML étudiés précédemment constituent de bons points de départ pour l’automatisation. Une fois que vous avez décidé de réentraîner, vous devez :
- Prétraiter vos données à l’aide d’un processus reproductible et automatisé
- Entraîner votre nouveau modèle
- Comparer les sorties de votre nouveau modèle à celles de votre ancien modèle
- Utiliser des critères prédéfinis pour choisir de remplacer ou non votre ancien modèle
Un thème des étapes ci-dessus est que votre nouvel entraînement doit être automatisé et non ad hoc. Les [pipelines Azure Machine Learning](concept-ml-pipelines.md) sont une bonne réponse pour créer des workflows relatifs à la préparation des données, à l’entraînement, à la validation et au déploiement. Lisez [Reformer des modèles à l’aide du concepteur Azure Machine Learning](how-to-retrain-designer.md) pour voir comment les pipelines et le concepteur Azure Machine Learning s’intègrent dans un scénario de nouvelle formation.
## <a name="automate-the-ml-lifecycle"></a>Automatiser le cycle de vie ML
Vous pouvez utiliser GitHub et Azure Pipelines pour créer un processus d’intégration continue qui entraîne un modèle. Dans un scénario classique, quand un scientifique des données vérifie une modification dans le dépôt Git pour un projet, Azure Pipelines démarre une exécution d’entraînement. Les résultats de l’exécution peuvent ensuite être examinés pour afficher les caractéristiques de performances du modèle entraîné. Vous pouvez également créer un pipeline qui déploie le modèle comme un service web.
L’[extension Azure Machine Learning](https://marketplace.visualstudio.com/items?itemName=ms-air-aiagility.vss-services-azureml) facilite l’utilisation d’Azure Pipelines. Elle offre les améliorations suivantes à Azure Pipelines :
* Permet la sélection de l’espace de travail lors de la définition d’une connexion de service.
* Permet le déclenchement des pipelines de mise en production par les modèles entraînés créés dans un pipeline d’entraînement.
Pour plus d’informations sur l’utilisation d’Azure Pipelines avec Azure Machine Learning, consultez les liens suivants :
* [Intégration et déploiement continus de modèles ML avec Azure Pipelines](/azure/devops/pipelines/targets/azure-machine-learning)
* Dépôt [MLOps Azure Machine Learning](https://aka.ms/mlops).
* Dépôt [MLOpsPython Azure Machine Learning](https://github.com/Microsoft/MLOpspython).
Vous pouvez également utiliser Azure Data Factory pour créer un pipeline d’ingestion des données qui prépare les données à utiliser dans le cadre de la formation. Pour plus d’informations, consultez [Pipeline d’ingestion des données](how-to-cicd-data-ingestion.md).
## <a name="next-steps"></a>Étapes suivantes
Découvrez plus d’informations en lisant et en explorant les ressources suivantes :
+ [Comment et où déployer des modèles](how-to-deploy-and-where.md) avec Azure Machine Learning
+ [Tutoriel : Déployer un modèle de classification d’images dans ACI](tutorial-deploy-models-with-aml.md)
+ [Dépôt d’exemples MLOps de bout en bout](https://github.com/microsoft/MLOps)
+ [CI/CD de modèles ML avec Azure Pipelines](/azure/devops/pipelines/targets/azure-machine-learning)
+ Créer des clients qui [consomment un modèle déployé](how-to-consume-web-service.md)
+ [Machine Learning à l’échelle](/azure/architecture/data-guide/big-data/machine-learning-at-scale)
+ [Dépôt des architectures de référence et des bonnes pratiques d’Azure AI](https://github.com/microsoft/AI)
| 86.775785 | 644 | 0.801509 | fra_Latn | 0.987276 |
4744aafdb01121f1f952e55b5fcae81cc8fa7be6 | 7,473 | md | Markdown | articles/virtual-network/ipv6-add-to-existing-vnet-powershell.md | Ysp9714/azure-docs.ko-kr | d49c83bd81a83882c7c238a95f098d7c30f4843d | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/virtual-network/ipv6-add-to-existing-vnet-powershell.md | Ysp9714/azure-docs.ko-kr | d49c83bd81a83882c7c238a95f098d7c30f4843d | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/virtual-network/ipv6-add-to-existing-vnet-powershell.md | Ysp9714/azure-docs.ko-kr | d49c83bd81a83882c7c238a95f098d7c30f4843d | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: Azure Virtual Network에서 IPv6로 IPv4 응용 프로그램 업그레이드-PowerShell
titlesuffix: Azure Virtual Network
description: 이 문서에서는 Azure PowerShell를 사용 하 여 Azure 가상 네트워크의 기존 응용 프로그램에 IPv6 주소를 배포 하는 방법을 보여 줍니다.
services: virtual-network
documentationcenter: na
author: KumudD
manager: mtillman
ms.service: virtual-network
ms.devlang: na
ms.topic: how-to
ms.tgt_pltfrm: na
ms.workload: infrastructure-services
ms.date: 03/31/2020
ms.author: kumud
ms.openlocfilehash: 9c2ea7cae26ac00c9c647704de8de1f39ebce8f0
ms.sourcegitcommit: 829d951d5c90442a38012daaf77e86046018e5b9
ms.translationtype: MT
ms.contentlocale: ko-KR
ms.lasthandoff: 10/09/2020
ms.locfileid: "90600826"
---
# <a name="upgrade-an-ipv4-application-to-ipv6-in-azure-virtual-network---powershell"></a>Azure virtual network에서 IPv4 응용 프로그램을 IPv6로 업그레이드-PowerShell
이 문서에서는 표준 Load Balancer 및 공용 IP를 사용 하 여 Azure 가상 네트워크의 기존 IPv4 응용 프로그램에 IPv6 연결을 추가 하는 방법을 보여 줍니다. 전체 업그레이드에는 다음이 포함 됩니다.
- 가상 네트워크 및 서브넷에 대 한 IPv6 주소 공간
- IPv4 및 IPV6 프런트 엔드 구성을 모두 사용 하는 표준 Load Balancer
- IPv4 + IPv6 구성이 모두 포함 된 Nic가 있는 Vm
- 부하 분산 장치에서 인터넷 연결 IPv6 연결을 위한 IPv6 공용 IP
[!INCLUDE [cloud-shell-try-it.md](../../includes/cloud-shell-try-it.md)]
PowerShell을 로컬로 설치하고 사용하도록 선택하는 경우, 이 문서에는 Azure PowerShell 모듈 버전 6.9.0 이상이 필요합니다. 설치되어 있는 버전을 확인하려면 `Get-Module -ListAvailable Az`을 실행합니다. 업그레이드해야 하는 경우 [Azure PowerShell 모듈 설치](/powershell/azure/install-Az-ps)를 참조하세요. 또한 PowerShell을 로컬로 실행하는 경우 `Connect-AzAccount`를 실행하여 Azure와 연결해야 합니다.
## <a name="prerequisites"></a>필수 구성 요소
이 문서에서는 [빠른 시작: 표준 Load Balancer Azure PowerShell 만들기](../load-balancer/quickstart-load-balancer-standard-public-powershell.md)에 설명 된 대로 표준 Load Balancer를 배포 했다고 가정 합니다.
## <a name="retrieve-the-resource-group"></a>리소스 그룹 검색
이중 스택 가상 네트워크를 만들려면 먼저 [AzResourceGroup](/powershell/module/az.resources/get-azresourcegroup)를 사용 하 여 리소스 그룹을 검색 해야 합니다.
```azurepowershell-interactive
$rg = Get-AzResourceGroup -ResourceGroupName "myResourceGroupSLB"
```
## <a name="create-an-ipv6-ip-addresses"></a>IPv6 IP 주소 만들기
표준 Load Balancer에 대 한 [AzPublicIpAddress](/powershell/module/az.network/new-azpublicipaddress) 를 사용 하 여 공용 IPv6 주소를 만듭니다. 다음 예제에서는 *Myresourcegroupslb* 리소스 그룹에 *PublicIP_v6* 이라는 IPv6 공용 IP 주소를 만듭니다.
```azurepowershell-interactive
$PublicIP_v6 = New-AzPublicIpAddress `
-Name "PublicIP_v6" `
-ResourceGroupName $rg.ResourceGroupName `
-Location $rg.Location `
-Sku Standard `
-AllocationMethod Static `
-IpAddressVersion IPv6
```
## <a name="configure-load-balancer-frontend"></a>부하 분산 장치 프런트 엔드 구성
기존 부하 분산 장치 구성을 검색 한 후 다음과 같이 [AzLoadBalancerFrontendIpConfig](/powershell/module/az.network/Add-AzLoadBalancerFrontendIpConfig) 를 사용 하 여 새 IPv6 IP 주소를 추가 합니다.
```azurepowershell-interactive
# Retrieve the load balancer configuration
$lb = Get-AzLoadBalancer -ResourceGroupName $rg.ResourceGroupName -Name "MyLoadBalancer"
# Add IPv6 components to the local copy of the load balancer configuration
$lb | Add-AzLoadBalancerFrontendIpConfig `
-Name "dsLbFrontEnd_v6" `
-PublicIpAddress $PublicIP_v6
#Update the running load balancer with the new frontend
$lb | Set-AzLoadBalancer
```
## <a name="configure-load-balancer-backend-pool"></a>부하 분산 장치 백 엔드 풀 구성
부하 분산 장치 구성의 로컬 복사본에 백 엔드 풀을 만들고 다음과 같이 새 백 엔드 풀 구성을 사용 하 여 실행 중인 부하 분산 장치를 업데이트 합니다.
```azurepowershell-interactive
$lb | Add-AzLoadBalancerBackendAddressPoolConfig -Name "LbBackEndPool_v6"
# Update the running load balancer with the new backend pool
$lb | Set-AzLoadBalancer
```
## <a name="configure-load-balancer-rules"></a>부하 분산 장치 규칙 구성
기존 부하 분산 장치 프런트 엔드 및 백 엔드 풀 구성을 검색 한 다음 [AzLoadBalancerRuleConfig](/powershell/module/az.network/Add-AzLoadBalancerRuleConfig)를 사용 하 여 새 부하 분산 규칙을 추가 합니다.
```azurepowershell-interactive
# Retrieve the updated (live) versions of the frontend and backend pool
$frontendIPv6 = Get-AzLoadBalancerFrontendIpConfig -Name "dsLbFrontEnd_v6" -LoadBalancer $lb
$backendPoolv6 = Get-AzLoadBalancerBackendAddressPoolConfig -Name "LbBackEndPool_v6" -LoadBalancer $lb
# Create new LB rule with the frontend and backend
$lb | Add-AzLoadBalancerRuleConfig `
-Name "dsLBrule_v6" `
-FrontendIpConfiguration $frontendIPv6 `
-BackendAddressPool $backendPoolv6 `
-Protocol Tcp `
-FrontendPort 80 `
-BackendPort 80
#Finalize all the load balancer updates on the running load balancer
$lb | Set-AzLoadBalancer
```
## <a name="add-ipv6-address-ranges"></a>IPv6 주소 범위 추가
다음과 같이 Vm을 호스트 하는 가상 네트워크 및 서브넷에 IPv6 주소 범위를 추가 합니다.
```azurepowershell-interactive
#Add IPv6 ranges to the VNET and subnet
#Retreive the VNET object
$vnet = Get-AzVirtualNetwork -ResourceGroupName $rg.ResourceGroupName -Name "myVnet"
#Add IPv6 prefix to the VNET
$vnet.addressspace.addressprefixes.add("ace:cab:deca::/48")
#Update the running VNET
$vnet | Set-AzVirtualNetwork
#Retrieve the subnet object from the local copy of the VNET
$subnet= $vnet.subnets[0]
#Add IPv6 prefix to the Subnet (subnet of the VNET prefix, of course)
$subnet.addressprefix.add("ace:cab:deca::/64")
#Update the running VNET with the new subnet configuration
$vnet | Set-AzVirtualNetwork
```
## <a name="add-ipv6-configuration-to-nic"></a>NIC에 IPv6 구성 추가
다음과 같이 [AzNetworkInterfaceIpConfig](/powershell/module/az.network/Add-AzNetworkInterfaceIpConfig) 를 사용 하 여 IPv6 주소를 사용 하 여 모든 VM nic를 구성 합니다.
```azurepowershell-interactive
#Retrieve the NIC objects
$NIC_1 = Get-AzNetworkInterface -Name "myNic1" -ResourceGroupName $rg.ResourceGroupName
$NIC_2 = Get-AzNetworkInterface -Name "myNic2" -ResourceGroupName $rg.ResourceGroupName
$NIC_3 = Get-AzNetworkInterface -Name "myNic3" -ResourceGroupName $rg.ResourceGroupName
#Add an IPv6 IPconfig to NIC_1 and update the NIC on the running VM
$NIC_1 | Add-AzNetworkInterfaceIpConfig -Name MyIPv6Config -Subnet $vnet.Subnets[0] -PrivateIpAddressVersion IPv6 -LoadBalancerBackendAddressPool $backendPoolv6
$NIC_1 | Set-AzNetworkInterface
#Add an IPv6 IPconfig to NIC_2 and update the NIC on the running VM
$NIC_2 | Add-AzNetworkInterfaceIpConfig -Name MyIPv6Config -Subnet $vnet.Subnets[0] -PrivateIpAddressVersion IPv6 -LoadBalancerBackendAddressPool $backendPoolv6
$NIC_2 | Set-AzNetworkInterface
#Add an IPv6 IPconfig to NIC_3 and update the NIC on the running VM
$NIC_3 | Add-AzNetworkInterfaceIpConfig -Name MyIPv6Config -Subnet $vnet.Subnets[0] -PrivateIpAddressVersion IPv6 -LoadBalancerBackendAddressPool $backendPoolv6
$NIC_3 | Set-AzNetworkInterface
```
## <a name="view-ipv6-dual-stack-virtual-network-in-azure-portal"></a>Azure Portal에서 IPv6 이중 스택 가상 네트워크 보기
다음과 같이 Azure Portal에서 IPv6 이중 스택 가상 네트워크를 볼 수 있습니다.
1. 포털의 검색 창에서 *Myvnet*을 입력 합니다.
2. 검색 결과에 **Myvnet** 이 표시 되 면 선택 합니다. 그러면 *Myvnet*이라는 이중 스택 가상 네트워크의 **개요** 페이지가 시작 됩니다. 이중 스택 가상 네트워크는 *Mysubnet*이라는 이중 스택 서브넷에 있는 IPv4 및 IPv6 구성을 모두 사용 하 여 세 개의 nic를 표시 합니다.
## <a name="clean-up-resources"></a>리소스 정리
더 이상 필요하지 않은 경우 [Remove-AzResourceGroup](/powershell/module/az.resources/remove-azresourcegroup) 명령을 사용하여 리소스 그룹, VM 및 모든 관련 리소스를 제거할 수 있습니다.
```azurepowershell-interactive
Remove-AzResourceGroup -Name MyAzureResourceGroupSLB
```
## <a name="next-steps"></a>다음 단계
이 문서에서는 IPv4 프런트 엔드 IP 구성을 사용 하 여 기존 표준 Load Balancer를 이중 스택 (IPv4 및 IPv6) 구성으로 업데이트 했습니다. 또한 백 엔드 풀에 있는 Vm의 Nic와 이들을 호스트 하는 Virtual Network에 IPv6 구성을 추가 했습니다. Azure virtual network의 IPv6 지원에 대 한 자세한 내용은 [azure Virtual Network에 대 한](ipv6-overview.md) i p v 6을 참조 하세요.
| 42.460227 | 289 | 0.767563 | kor_Hang | 0.998644 |
4744d026f98eb73b332a8c8d41fe0a122322855c | 2,964 | md | Markdown | 2108XX/210824.md | kimyerimweb/TIL | 5b16b0a8c2741765df987f83b63ed109a344a7e6 | [
"MIT"
] | null | null | null | 2108XX/210824.md | kimyerimweb/TIL | 5b16b0a8c2741765df987f83b63ed109a344a7e6 | [
"MIT"
] | null | null | null | 2108XX/210824.md | kimyerimweb/TIL | 5b16b0a8c2741765df987f83b63ed109a344a7e6 | [
"MIT"
] | null | null | null | ## 210814~24 TIL
### 10일간 배운 것
1. class, Hooks
- class가 먼저 나왔으나 Hooks를 이용하면 함수형 컴포넌트로 작성할 수 있으며, 페이스북에서도 권장했음.
- class로 작성한 코드를 만날 수 있으니 알아는 둬야함!
- 함수형 컴포넌트 자체가 hooks가 아니라 useState,useEffect등이 hooks
2. 라이프 사이클, useEffect
- class에서는 라이프 사이클에 관련된 함수로 componentDidMount, componentDidUpdate, componentWillUnmount가 있음.
- 순서대로 최초 render전 1회 실행, 설정해놓은 변수가 변하면 render후 1회 실행, 컴포넌트가 없어지기 전 1회 실행함
- 보통 비동기처리를 해야하는 경우에 componentDidMount에 시작 처리를 하고 componentWillUnmount에 종료처리함.
- hooks에는 라이프 사이클에 직접 관련된 함수는 없지만 useEffect라는 hooks로 대체한다.
```javascript
// prettier-ignore
useEffect(() => {
//최소 실행 + 이후 등록해놓은 변수가 변하면 실행할 코드
return () => {
/*컴포넌트가 사라질 때 실행할 코드 */
};
},[/* 상태 변화를 감지할 변수 */]);
```
3. useState, useRef
- useState로 등록한 state는 값이 변화하면 화면이 리렌더링된다.
- useState의 initialState는 이후 렌더링에서 무시되므로 계산량이 많은 함수를 넣어도 된다.
- 조심해야할 점: initialState로 함수를 넣었을 때, 최초에 한번만 실행되도록 함수의 이름만 쓰도록 한다. 함수이름()로 소괄호를 붙이면 자동 실행되기때문에 리렌더링할 때마다 적용되지도 않고 버려질 값들이 새롭게 계산된다.
```javascript
const [numbers, setNumbers] = useState(getNumber); //getNumber기 최초 한번 실행
const [numbers, setNumbers] = useState(getNumber()); //getNumber가 매 리렌더링때마다 계산된다. 리턴값이 numbers에 대입되진 않는다.
```
- useState와 setState는 모두 이벤트 핸들러 안에서는 비동기적인 함수이다. 모든 컴포넌트의 이벤트 핸들러 내부의 setState가 호출되어 각 state마다 발생한 모든 변화를 한방에 업데이트하는 방식으로 성능을 향상시킨다. 그리고 props가 렌더링이 끝난 이후에 값을 새롭게 업데이트할 수 있는데, 동기적으로 state를 관리하면 props가 중구난방이 될 수 있기 때문에 비동기적으로 업데이트된다.
- useRef로 등록한 ref는 값이 변해도 화면이 리렌더링되지 않는다.
- useRef는 함수 이름만 넣거나 콜백함수를 넣는 경우에는 함수가 실행되지 않는다. (공식문서에도 함수를 넣어서 값을 설정할 수 있다는 얘기가 없음) 뒤에 소괄호를 붙여서 자동실행을 하지 않으면 함수를 통해서 값을 얻을 수 없다.
- 그러므로 렌더링에 딱히 영향을 끼칠 요소는 아니지만 연산이 복잡한 함수를 렌더링할 때마다 연산하고 싶지 않으면 그냥 useState로 만드는게 평화로워 보인다.
4. useMemo, useCallback
- useMemo는 함수를 실행하고 나온 결과값을 저장한다. 결과가 변하면 함수를 재실행한다.
- useCallback은 함수 그 자체를 저장한다.
- 모두 리렌더링이 되는 과정에서 불필요하게 함수를 실행하거나 써내려가는 과정을 없애기 위해서이다.
- 리액트에서는 불변성이 원칙이기 때문에 useMemo로 저장해놓은 값 중 프리미티브 타입이 아닌 값은 변화를 감지하기 어렵다. (변화 감지하려면 다른 조치 필요)
- 함수를 props로 넘겨줄 경우에는 함수를 useCallback으로 감싸는 것이 좋다. 리렌더링 과정에서 새롭게 써지면서 함수가 계속 바뀐다고 감지하기 때문에
함수에 관한 것은 아무것도 바뀌지 않은 상황에서도 자식 컴포넌트가 계속 리렌더링을 할 수 있다. (memo를 사용해도 소용없다.)
5. memo, PureComponent, shouldcomponentupdate
- memo는 동일 props의 동일 렌더링 결과 상황일 때 메모이제이션된 마지막 렌더링 결과를 재사용한다.(리렌더링 안함) Hooks에서 주로 사용.
- PureComponent는 class에서 사용한다. props와 state의 변화를 감지해 memo와 같은 기능을 한다.
- PureComponent를 사용하면 각각 컴포넌트가 shouldComponentUpdate를 가지는데, 디폴트로는 props와 state가 바뀌면 바뀌도록 true를 반환한다. 하지만 바꾸고 싶지 않을 경우도 있으니, 이 경우에는 false를 반환해서 바꾸지 않도록 한다.
```javascript
shouldComponentUpdate(nextProps,nextState){ //첫번째는 props들이 있고 두번째는 state가 들어있음.
if(this.state.value !== nextState.value){
return false
} //value가 변해도 넘긴다!
}
```
### 느낀점
<p>리액트의 문법 몇 가지를 간신히 익혔을 뿐이지, 이것으로 어떤 어플리케이션을 만들어낼 때 전체적인 구조나 진행 순서를 알 수 있는 것은 아니었다.<br/>
앞으로는 게시판을 만들기 위해 어떻게 리액트를 활용해야할지를 익히는 방향으로 가야겠다.
</p>
### 앞으로의 계획
- 리액트로 쇼핑몰 만들기
| 41.746479 | 236 | 0.689271 | kor_Hang | 1.00001 |
4745023db294fe9e5c8c7210244a8a5f23cc2702 | 30 | md | Markdown | README.md | unapu-go/error-utils | 96d02b69ab2aca29ed05d6dc752c271810291c55 | [
"MIT"
] | null | null | null | README.md | unapu-go/error-utils | 96d02b69ab2aca29ed05d6dc752c271810291c55 | [
"MIT"
] | null | null | null | README.md | unapu-go/error-utils | 96d02b69ab2aca29ed05d6dc752c271810291c55 | [
"MIT"
] | null | null | null | # error-utils
Error Utilities
| 10 | 15 | 0.8 | eng_Latn | 0.701442 |
4745e29d2bc5a684d6f47e7854d3be2f3d6ed482 | 5,803 | md | Markdown | .github/CONTRIBUTING.md | greenkeytech/FDC3 | f09f5596dccb6765250681735947ac08472027f1 | [
"Apache-2.0"
] | 1 | 2019-03-06T12:33:56.000Z | 2019-03-06T12:33:56.000Z | .github/CONTRIBUTING.md | greenkeytech/FDC3 | f09f5596dccb6765250681735947ac08472027f1 | [
"Apache-2.0"
] | null | null | null | .github/CONTRIBUTING.md | greenkeytech/FDC3 | f09f5596dccb6765250681735947ac08472027f1 | [
"Apache-2.0"
] | null | null | null | # Contributing to FDC3
:+1: First off, thanks for taking the time to contribute! :+1:
# Contributor License Agreement (CLA)
A CLA is a document that specifies how a project is allowed to use your
contribution; they are commonly used in many open source projects.
**_All_ contributions to _all_ projects hosted by [FINOS](https://www.finos.org/)
must be made with a
[Foundation CLA](https://finosfoundation.atlassian.net/wiki/spaces/FINOS/pages/83034172/Contribute)
in place, and there are [additional legal requirements](https://finosfoundation.atlassian.net/wiki/spaces/FINOS/pages/75530375/Legal+Requirements)
that must also be met.**
As a result, PRs submitted to the FDC3 project cannot be accepted until you have a CLA in place with the Foundation.
# Contributing Issues
## Prerequisites
* [ ] Have you [searched for duplicates](https://github.com/FDC3/FDC3/issues?utf8=%E2%9C%93&q=)? A simple search for exception error messages or a summary of the unexpected behaviour should suffice.
* [ ] Are you running the latest version?
* [ ] Are you sure this is a bug or missing capability?
## Raising an Issue
* Create your issue [here](https://github.com/FDC3/FDC3/issues/new).
* New issues contain two templates in the description: bug report and enhancement request. Please pick the most appropriate for your issue, **then delete the other**.
* Please also tag the new issue with either "Bug" or "Enhancement".
* Please use [Markdown formatting](https://help.github.com/categories/writing-on-github/)
liberally to assist in readability.
* [Code fences](https://help.github.com/articles/creating-and-highlighting-code-blocks/) for exception stack traces and log entries, for example, massively improve readability.
# Contributing Pull Requests (Code & Docs)
To make review of PRs easier, please:
* Please make sure your PRs will merge cleanly - PRs that don't are unlikely to be accepted.
* For code contributions, follow the existing code layout.
* For documentation contributions, follow the general structure, language, and tone of the [existing docs](https://github.com/FDC3/FDC3/wiki).
* Keep commits small and cohesive - if you have multiple contributions, please submit them as independent commits (and ideally as independent PRs too).
* Reference issue #s if your PR has anything to do with an issue (even if it doesn't address it).
* Minimise non-functional changes (e.g. whitespace shenanigans).
* Ensure all new files include a header comment block containing the [Apache License v2.0 and your copyright information](http://www.apache.org/licenses/LICENSE-2.0#apply).
* If necessary (e.g. due to 3rd party dependency licensing requirements), update the [NOTICE file](https://github.com/FDC3/FDC3/blob/master/NOTICE) with any new attribution or other notices
## Commit and PR Messages
* **Reference issues, wiki pages, and pull requests liberally!**
* Use the present tense ("Add feature" not "Added feature")
* Use the imperative mood ("Move button left..." not "Moves button left...")
* Limit the first line to 72 characters or less
* Please start the commit message with one or more applicable emoji:
| Emoji | Raw Emoji Code | Description |
|:---:|:---:|---|
| :tada: | `:tada:` | **initial** commit |
| :construction: | `:construction:` | **WIP** (Work In Progress) commits |
| :ambulance: | `:ambulance:` | when fixing a **bug** |
| :bug: | `:bug:` | when **identifying a bug**, via an inline comment (please use the `@FIXME` tag in the comment) |
| :new: | `:new:` | when introducing **new** features |
| :art: | `:art:` | when improving the **format** / structure of the code |
| :pencil: | `:pencil:` | when **performing minor changes / fixing** the code or language |
| :ballot_box_with_check: | `:ballot_box_with_check:` | when completing a task |
| :arrow_up: | `:arrow_up:` | when upgrading **dependencies** |
| :arrow_down: | `:arrow_down:` | when downgrading **dependencies** |
| :racehorse: | `:racehorse:` | when improving **performance** |
| :fire: | `:fire:` | when **removing code** or files |
| :speaker: | `:speaker:` | when adding **logging** |
| :mute: | `:mute:` | when reducing **logging** |
| :books: | `:books:` | when writing **docs** |
| :bookmark: | `:bookmark:` | when adding a **tag** |
| :gem: | `:gem:` | new **release** |
| :zap: | `:zap:` | when introducing **backward incompatible** changes or **removing functionality** |
| :bulb: | `:bulb:` | new **idea** identified in the code, via an inline comment (please use the `@IDEA` tag in the comment) |
| :snowflake: | `:snowflake:` | changing **configuration** |
| :lipstick: | `:lipstick:` | when improving **UI** / cosmetic |
| :umbrella: | `:umbrella:` | when adding **tests** |
| :green_heart: | `:green_heart:` | when fixing the **CI** build |
| :lock: | `:lock:` | when dealing with **security** |
| :shirt: | `:shirt:` | when removing **linter** / strict / deprecation / reflection warnings |
| :fast_forward: | `:fast_forward:` | when **forward-porting features** from an older version/branch |
| :rewind: | `:rewind:` | when **backporting features** from a newer version/branch |
| :wheelchair: | `:wheelchair:` | when improving **accessibility** |
| :globe_with_meridians: | `:globe_with_meridians:` | when dealing with **globalisation** / internationalisation |
| :rocket: | `:rocket:` | anything related to deployments / **DevOps** |
| :non-potable_water: | `:non-potable_water:` | when plugging memory leaks
| :penguin: | `:penguin:` | when fixing something on **Linux** |
| :apple: | `:apple:` | when fixing something on **Mac OS** |
| :checkered_flag: | `:checkered_flag:` | when fixing something on **Windows** |
| :handbag: | `:handbag:` | when a commit contains multiple unrelated changes that don't fit into any one category (but please try not to do this!) |
| 64.477778 | 199 | 0.708599 | eng_Latn | 0.986739 |
474608d89b8ed4797ed3fb41dea41a2bd509a9be | 1,760 | md | Markdown | docs/output.md | rigzba21/conda-lock | a22ce5aba75685d01b0333f2d320865a1a0bde9b | [
"MIT"
] | null | null | null | docs/output.md | rigzba21/conda-lock | a22ce5aba75685d01b0333f2d320865a1a0bde9b | [
"MIT"
] | null | null | null | docs/output.md | rigzba21/conda-lock | a22ce5aba75685d01b0333f2d320865a1a0bde9b | [
"MIT"
] | null | null | null | # Output formats
## Unified lockfile
Conda lock's default output format is a unified multi-platform lockfile.
This is defined by a [pydantic](https://pydantic-docs.helpmanual.io/usage/models/) model
[here](https://github.com/conda-incubator/conda-lock/blob/main/conda_lock/src_parser/__init__.py#L126)
In order to explicitly use this format
```shell
conda-lock --kind lockfile
```
To install from one of these lockfiles
```bash
conda-lock install conda-lock.yml
```
### Render
The unified lockfile can be rendered into the various other lockfile formats
Generate both formats using
```shell
conda-lock render --kind explicit --kind env
```
## Explicit lockfile
The legacy format that conda lock supports. This was the default format prior to conda-lock 1.0.
This format is understood natively by both conda and mamba. If your lock contains pip solved packages
these can only be installed by conda-lock
```bash
conda-lock --kind explicit --platform
```
To install from this lockfile you can aither use conda/mamba directly
```shell
conda create --name YOURENV --file conda-linux-64.lock
```
or
```shell
conda-lock install --name YOURENV conda-linux-64.lock
```
## Environment lockfile
This format is itself a conda [environment.yml][envyaml] that can be installed by `conda env create`.
This format does have the drawback that using it will invoke a new solve unlike the explicit format.
To install from this lockfile you can aither use conda/mamba directly
```shell
conda env create --name YOURENV --file conda-linux-64.lock.yml
```
or
```shell
conda-lock install --name YOURENV conda-linux-64.lock.yml
```
[envyaml]: https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html#create-env-file-manually | 24.109589 | 124 | 0.761364 | eng_Latn | 0.985922 |
474685ad13021c3927c2cea275cd8fee2bac1c0f | 2,956 | md | Markdown | README.md | jdglaser/fast_to_SQL | 71b38ef8df7e7efeb79793394e94ca3988601140 | [
"MIT"
] | 20 | 2019-09-04T10:15:20.000Z | 2022-02-26T12:04:39.000Z | README.md | jdglaser/fast_to_SQL | 71b38ef8df7e7efeb79793394e94ca3988601140 | [
"MIT"
] | 16 | 2019-04-23T07:49:11.000Z | 2021-07-26T15:28:56.000Z | README.md | jdglaser/fast_to_SQL | 71b38ef8df7e7efeb79793394e94ca3988601140 | [
"MIT"
] | 6 | 2019-07-30T10:33:53.000Z | 2021-05-13T20:55:40.000Z | # fast_to_sql
## Introduction
`fast_to_sql` is an improved way to upload pandas dataframes to Microsoft SQL Server.
`fast_to_sql` takes advantage of pyodbc rather than SQLAlchemy. This allows for a much lighter weight import for writing pandas dataframes to sql server. It uses pyodbc's `executemany` method with `fast_executemany` set to `True`, resulting in far superior run times when inserting data.
## Installation
```python
pip install fast_to_sql
```
## Requirements
* Written for Python 3.8+
* Requires pandas, pyodbc
## Example
```py
from datetime import datetime
import pandas as pd
import pyodbc
from fast_to_sql import fast_to_sql as fts
# Test Dataframe for insertion
df = pd.DataFrame({
"Col1": [1, 2, 3],
"Col2": ["A", "B", "C"],
"Col3": [True, False, True],
"Col4": [datetime(2020,1,1),datetime(2020,1,2),datetime(2020,1,3)]
})
# Create a pyodbc connection
conn = pyodbc.connect(
"""
Driver={ODBC Driver 17 for SQL Server};
Server=localhost;
Database=my_database;
UID=my_user;
PWD=my_pass;
"""
)
# If a table is created, the generated sql is returned
create_statement = fts.fast_to_sql(df, "my_great_table", conn, if_exists="replace", custom={"Col1":"INT PRIMARY KEY"}, temp=False)
# Commit upload actions and close connection
conn.commit()
conn.close()
```
## Usage
### Main function
```python
fts.fast_to_sql(df, name, conn, if_exists="append", custom=None, temp=False, copy=False)
```
* ```df```: pandas DataFrame to upload
* ```name```: String of desired name for the table in SQL server
* ```conn```: A valid pyodbc connection object
* ```if_exists```: Option for what to do if the specified table name already exists in the database. If the table does not exist a new one will be created. By default this option is set to 'append'
* __'append'__: Appends the dataframe to the table if it already exists in SQL server.
* __'fail'__: Purposely raises a `FailError` if the table already exists in SQL server.
* __'replace'__: Drops the old table with the specified name, and creates a new one. **Be careful with this option**, it will completely delete a table with the specified name in SQL server.
* ```custom```: A dictionary object with one or more of the column names being uploaded as the key, and a valid SQL column definition as the value. The value must contain a type (`INT`, `FLOAT`, `VARCHAR(500)`, etc.), and can optionally also include constraints (`NOT NULL`, `PRIMARY KEY`, etc.)
* Examples:
`{'ColumnName':'varchar(1000)'}`
`{'ColumnName2':'int primary key'}`
* ```temp```: Either `True` if creating a local sql server temporary table for the connection, or `False` (default) if not.
* ```copy```: Defaults to `False`. If set to `True`, a copy of the dataframe will be made so column names of the original dataframe are not altered. Use this if you plan to continue to use the dataframe in your script after running `fast_to_sql`.
| 33.213483 | 295 | 0.714141 | eng_Latn | 0.978897 |
4746b84340235ba064338835d3d16e86754fedc1 | 149 | md | Markdown | _posts/0000-01-02-abhishek85gupta.md | abhishek85gupta/github-slideshow | 93d4e7e3d1253e051757fc06a454f2f5462012a5 | [
"MIT"
] | null | null | null | _posts/0000-01-02-abhishek85gupta.md | abhishek85gupta/github-slideshow | 93d4e7e3d1253e051757fc06a454f2f5462012a5 | [
"MIT"
] | 3 | 2020-10-17T14:52:15.000Z | 2020-10-17T15:34:28.000Z | _posts/0000-01-02-abhishek85gupta.md | abhishek85gupta/github-slideshow | 93d4e7e3d1253e051757fc06a454f2f5462012a5 | [
"MIT"
] | null | null | null | ---
layout: slide
title: "Welcome to our second slide!"
---
Your text => modified text as part of pull request review
Use the left arrow to go back!
| 21.285714 | 57 | 0.718121 | eng_Latn | 0.99757 |
4746f4234969678ca56ab8ee9ec5c2723867c8ce | 653 | md | Markdown | CHANGELOG.md | alumarcu/querymap | bf6b8573357129aa2c216831ada78b28018083c8 | [
"MIT"
] | null | null | null | CHANGELOG.md | alumarcu/querymap | bf6b8573357129aa2c216831ada78b28018083c8 | [
"MIT"
] | null | null | null | CHANGELOG.md | alumarcu/querymap | bf6b8573357129aa2c216831ada78b28018083c8 | [
"MIT"
] | null | null | null | CHANGELOG
=========
* 1.1.1 (2016-06-15)
* changed interface to a single method: query
* removed dependency on sql-formatter
* updated unit tests to single method and asserts on DQL
* 1.1.0
* QueryMap bundle added for simple integration with doctrine
* dropped support for Zend 1 - to be done by a separate fork
* removed requirement for labeling all properties with @QM\Filter since it's automatically inferred with doctrine annotations data
* initial GitHub release
* 1.0.2 (2016-02-18)
* added resetBuffer and clear methods
* 1.0.0 (2016-02-10)
* Initial release
* fixed issue with DoctrineAdapter::dumpSql
| 32.65 | 134 | 0.710567 | eng_Latn | 0.989043 |
4746fa1ee7c0708b082f06c16615962923aa5e9e | 1,642 | md | Markdown | posts/news/2009/11/28/razrabotan-klient-kde-dlya-raboty-s-servisom-ubuntu-one.md | BaryshevRS/ubuntunews.ru | 5f1cffb7e28405c57da412db31fa091f00ee0f28 | [
"MIT"
] | null | null | null | posts/news/2009/11/28/razrabotan-klient-kde-dlya-raboty-s-servisom-ubuntu-one.md | BaryshevRS/ubuntunews.ru | 5f1cffb7e28405c57da412db31fa091f00ee0f28 | [
"MIT"
] | 1 | 2021-11-30T22:21:52.000Z | 2021-11-30T22:22:06.000Z | posts/news/2009/11/28/razrabotan-klient-kde-dlya-raboty-s-servisom-ubuntu-one.md | BaryshevRS/ubuntunews.ru | 5f1cffb7e28405c57da412db31fa091f00ee0f28 | [
"MIT"
] | null | null | null | ---
title: 'Разработан клиент KDE для работы с сервисом Ubuntu One'
date: '2009-11-28T20:37:59+03:00'
uri: 'news/razrabotan-klient-kde-dlya-raboty-s-servisom-ubuntu-one'
alias:
- 'news/213.html'
tags: 'KDE,Ubuntu One'
source: 'http://www.opennet.ru/opennews/art.shtml?num=24434'
unixtime: 1259429879
visits: 1505
---
[Ведется работа](http://thomas.apestaart.org/log/?p=1074) по адаптации [пакета](http://launchpadlibrarian.net/34588054/bug462828.debdiff) для использования в Fedora Linux online-хранилища Ubuntu One, в рамках которого любому пользователю предоставляется 2 Гб бесплатного дискового пространства на серверах компании Canonical. Хранилище позволяет организовать размещение данных на внешнем сервере, выполнять операции резервного копирования, обеспечить возможность синхронизации между несколькими машинами адресной книги, заметок Tomboy и закладок Firefox. При подключении хранилища в домашнем каталоге пользователя создается директория “Ubuntu One” данные из которой в асинхронном режиме синхронизируются с внешним хранилищем Ubuntu One.
Изначально для управления взаимодействием с Ubuntu One был создан специальный GNOME-апплет, поддерживающий синхронизацию данных из таких приложений как Tomboy и Evolution. Пользователи Kubuntu до настоящего времени были лишены возможности использовать Ubuntu One, но несколько дней назад данная недоработка была устранена - [вышла](http://apachelog.blogspot.com/2009/11/ubuntu-one-kde-tech-preview.html) первая тестовая версия пакета ubuntuone-kde, в которой реализованы базовые возможности по синхронизации данных из KDE PIM и менеджера управления персональной информацией Akonadi.
| 109.466667 | 736 | 0.825213 | rus_Cyrl | 0.924607 |
4746fc36ea90e61cafe2a75e76bf8c774bba50cb | 7,582 | md | Markdown | docs/build/reference/clr-common-language-runtime-compilation.md | FlorianHaupt/cpp-docs.de-de | 0ccd351cf627f1a41b14514c746f729b778d87e3 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/build/reference/clr-common-language-runtime-compilation.md | FlorianHaupt/cpp-docs.de-de | 0ccd351cf627f1a41b14514c746f729b778d87e3 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/build/reference/clr-common-language-runtime-compilation.md | FlorianHaupt/cpp-docs.de-de | 0ccd351cf627f1a41b14514c746f729b778d87e3 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: /clr (Common Language Runtime-Kompilierung)
ms.date: 09/18/2018
f1_keywords:
- /CLR
- VC.Project.VCNMakeTool.CompileAsManaged
- VC.Project.VCCLCompilerTool.CompileAsManaged
helpviewer_keywords:
- cl.exe compiler, common language runtime option
- -clr compiler option [C++]
- clr compiler option [C++]
- /clr compiler option [C++]
- Managed Extensions for C++, compiling
- common language runtime, /clr compiler option
ms.assetid: fec5a8c0-40ec-484c-a213-8dec918c1d6c
ms.openlocfilehash: 9e9867e5cea8d45aefa0901798b86557b05693f5
ms.sourcegitcommit: 6052185696adca270bc9bdbec45a626dd89cdcdd
ms.translationtype: MT
ms.contentlocale: de-DE
ms.lasthandoff: 10/31/2018
ms.locfileid: "50528036"
---
# <a name="clr-common-language-runtime-compilation"></a>/clr (Common Language Runtime-Kompilierung)
Ermöglicht Anwendungen und Komponenten, Funktionen aus der Common Language Runtime (CLR) zu verwenden.
## <a name="syntax"></a>Syntax
> **"/ CLR"**[**:**_Optionen_]
## <a name="arguments"></a>Argumente
*options*<br/>
Einer oder mehrere der folgenden Schalter, durch Komma getrennt.
- Keine
Ohne Optionen **"/ CLR"** erstellt Metadaten für die Anwendung. Die Metadaten können von anderen CLR-Anwendungen genutzt werden, und ermöglichen, dass eine Anwendung Typen und Daten in den Metadaten anderer CLR-Komponenten nutzt. Weitere Informationen finden Sie unter [gemischte (Native und verwaltete) Assemblys](../../dotnet/mixed-native-and-managed-assemblies.md).
- **reine**
**/ CLR: pure ist veraltet**. Die Option ist in Visual Studio 2017 entfernt. Es wird empfohlen, dass Sie Code, der reines MSIL sein muss, nach C# portieren.
- **safe**
**/ CLR: safe ist veraltet**. Die Option ist in Visual Studio 2017 entfernt. Es wird empfohlen, dass Sie Code portieren, der sichere MSIL in c# werden muss.
- **noAssembly**
**/ CLR: noAssembly ist veraltet**. Verwenden Sie stattdessen [/LN (Create MSIL Module)](../../build/reference/ln-create-msil-module.md) .
Legt fest, dass ein Assemblymanifest nicht in die Ausgabedatei eingefügt wird. Standardmäßig ist die **noAssembly** -Option nicht wirksam.
Ein verwaltetes Programm, das keine Assemblymetadaten im Manifest aufweist, wird als ein *Modul*bezeichnet. Die **noAssembly** -Option kann nur zum Erzeugen eines Moduls verwendet werden. Wenn Sie bei der Kompilierung [/c](../../build/reference/c-compile-without-linking.md) und **/clr:noAssembly**verwenden, geben Sie die Option [/NOASSEMBLY](../../build/reference/noassembly-create-a-msil-module.md) in der Linkerphase ein, um ein Modul zu erstellen.
Vor Visual C++ 2005 war bei Verwendung von **/clr:noAssembly** die Angabe von **/LD**erforderlich. **/LD** ist jetzt bei der Angabe von **/clr:noAssembly**impliziert.
- **initialAppDomain**
Ermöglicht Visual C++-Anwendung auf Version 1 der CLR ausgeführt. Eine Anwendung, die mit **initialAppDomain** kompiliert wurde, sollte nicht mit einer Anwendung verwendet werden, die ASP.NET verwendet, da Version 1 von CLR die Unterstützung hierfür fehlt.
- **nostdlib**
Weist den Compiler an, das Standardverzeichnis für \clr zu ignorieren. Der Compiler erzeugt Fehler, wenn Sie mehrere Versionen einer DLL wie „System.dll“ einschließen. Mit dieser Option können Sie angeben, welches Framework während der Kompilierung verwendet wird.
## <a name="remarks"></a>Hinweise
Verwalteter Code ist Code, der überprüft und von der CLR verwaltet werden kann. Verwalteter Code kann auf verwaltete Objekte zugreifen. Weitere Informationen finden Sie unter [/clr Restrictions](../../build/reference/clr-restrictions.md).
Informationen zum Entwickeln von Anwendungen, die verwaltete Typen definieren und verwenden, finden Sie unter [Component Extensions for Runtime Platforms](../../windows/component-extensions-for-runtime-platforms.md).
Eine mithilfe von **/clr** kompilierte Anwendung kann verwaltete Daten enthalten.
Debuggen einer verwalteten Anwendung aktivieren, finden Sie unter [ASSEMBLYDEBUG (DebuggableAttribute hinzufügen)](../../build/reference/assemblydebug-add-debuggableattribute.md).
Auf dem Heap der Garbage Collection werden nur CLR-Typen instanziiert. Weitere Informationen finden Sie unter [Klassen und Strukturen](../../windows/classes-and-structs-cpp-component-extensions.md). Um eine Funktion in systemeigenem Code zu kompilieren, verwenden Sie das `unmanaged` -Pragma. Weitere Informationen finden Sie unter [verwaltete, unverwaltete](../../preprocessor/managed-unmanaged.md).
In der Standardeinstellung ist **/clr** nicht aktiv. Wenn **/clr** aktiviert ist, ist auch **/MD** aktiv. Weitere Informationen finden Sie unter [/MD, /MT, /LD (Laufzeitbibliothek verwenden)](../../build/reference/md-mt-ld-use-run-time-library.md). **/MD** stellt sicher, dass die dynamisch verknüpften Multithread-Versionen der Laufzeitroutinen aus den standardmäßigen Headerdateien (. h) ausgewählt werden. Multithreading ist für die verwaltete Programmierung erforderlich, da der CLR-Garbage Collector Finalizer in einem Hilfsthread ausführt.
Wenn Sie mit der Kompilierung **/c**, Sie können angeben, die CLR-Typ der generierten Ausgabedatei mit [/CLRIMAGETYPE](../../build/reference/clrimagetype-specify-type-of-clr-image.md).
**/clr** impliziert **/EHa**, und keine anderen **/EH** -Optionen werden für **/clr**unterstützt. Weitere Informationen finden Sie unter [/EH (Ausnahmebehandlungsmodell)](../../build/reference/eh-exception-handling-model.md).
Weitere Informationen zum Bestimmen des CLR-Imagetyps einer Datei finden Sie unter [/CLRHEADER](../../build/reference/clrheader.md).
Alle an einen bestimmten Aufruf des Linkers übergebenen Module müssen mit derselben Compileroption für die Laufzeitbibliothek kompiliert werden (**/MD** oder **/LD**).
Verwenden Sie die [/ASSEMBLYRESOURCE](../../build/reference/assemblyresource-embed-a-managed-resource.md) -Linkeroption, um eine Ressource in eine Assembly einzubetten. Mit den Linkeroptionen[/DELAYSIGN](../../build/reference/delaysign-partially-sign-an-assembly.md), [/KEYCONTAINER](../../build/reference/keycontainer-specify-a-key-container-to-sign-an-assembly.md)und [/KEYFILE](../../build/reference/keyfile-specify-key-or-key-pair-to-sign-an-assembly.md) können Sie auch anpassen, wie eine Assembly erstellt wird.
Wenn **/clr** verwendet wird, ist das `_MANAGED` -Symbol mit 1 definiert. Weitere Informationen finden Sie unter [Predefined Macros](../../preprocessor/predefined-macros.md).
Die globalen Variablen in einer systemeigenen Objektdatei werden zuerst initialisiert (während DllMain, wenn die ausführbare Datei eine DLL ist), und anschließend werden die globalen Variablen im verwalteten Abschnitt initialisiert (bevor verwalteter Code ausgeführt wird). `#pragma` [Init_seg](../../preprocessor/init-seg.md) wirkt sich nur auf die Reihenfolge der Initialisierung in den verwalteten und nicht verwalteten Kategorien.
## <a name="metadata-and-unnamed-classes"></a>Metadaten und unbenannte Klassen
Unbenannte Klassen erscheinen in Metadaten mit folgendem Namen: `$UnnamedClass$`*crc-of-current-file-name*`$`*index*`$`, wobei *index* eine sequenzieller Zähler für die unbenannten Klassen in der Kompilierung ist. Im folgenden Codebeispiel wird z. B. eine unbenannte Klasse in den Metadaten generiert.
```cpp
// clr_unnamed_class.cpp
// compile by using: /clr /LD
class {} x;
```
Mithilfe von ildasm.exe können Sie Metadaten anzeigen.
## <a name="see-also"></a>Siehe auch
[Compileroptionen](../../build/reference/compiler-options.md)<br/>
[Festlegen von Compileroptionen](../../build/reference/setting-compiler-options.md) | 69.559633 | 545 | 0.773674 | deu_Latn | 0.985876 |
474721594b0af4ebf0667339266195a6e8cfdcc6 | 4,043 | md | Markdown | docs/framework/network-programming/using-a-synchronous-client-socket.md | eOkadas/docs.fr-fr | 64202ad620f9bcd91f4360ec74aa6d86e1d4ae15 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/framework/network-programming/using-a-synchronous-client-socket.md | eOkadas/docs.fr-fr | 64202ad620f9bcd91f4360ec74aa6d86e1d4ae15 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/framework/network-programming/using-a-synchronous-client-socket.md | eOkadas/docs.fr-fr | 64202ad620f9bcd91f4360ec74aa6d86e1d4ae15 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: Utilisation d’un socket client synchrone
ms.date: 03/30/2017
dev_langs:
- csharp
- vb
helpviewer_keywords:
- application protocols, sockets
- sending data, sockets
- data requests, sockets
- requesting data from Internet, sockets
- synchronous client sockets
- Socket class, synchronous client sockets
- receiving data, sockets
- sockets, synchronous client sockets
- protocols, sockets
- Internet, sockets
- client sockets
ms.assetid: 945d00c6-7202-466c-9df9-140b84156d43
ms.openlocfilehash: fdecd18dc5975cd469e49de0eb0b55081e738cd8
ms.sourcegitcommit: 289e06e904b72f34ac717dbcc5074239b977e707
ms.translationtype: MT
ms.contentlocale: fr-FR
ms.lasthandoff: 09/17/2019
ms.locfileid: "71047076"
---
# <a name="using-a-synchronous-client-socket"></a>Utilisation d’un socket client synchrone
Un socket client synchrone interrompt l’exécution de l’application durant l’opération réseau. Les sockets synchrones ne sont pas appropriés pour les applications dont l’exécution nécessite une utilisation intensive du réseau, mais ils facilitent l’accès aux services réseau pour les autres applications.
Pour envoyer les données, passez un tableau d’octets à l’une des méthodes d’envoi de données de la classe <xref:System.Net.Sockets.Socket> (<xref:System.Net.Sockets.Socket.Send%2A> et <xref:System.Net.Sockets.Socket.SendTo%2A>). L’exemple suivant encode une chaîne dans une mémoire tampon de tableau d’octets à l’aide de la propriété <xref:System.Text.Encoding.ASCII%2A?displayProperty=nameWithType>, puis transmet la mémoire tampon à l’appareil réseau avec la méthode **Send**. La méthode **Send** retourne le nombre d’octets envoyés à l’appareil réseau.
```vb
Dim msg As Byte() = _
System.Text.Encoding.ASCII.GetBytes("This is a test.")
Dim bytesSent As Integer = s.Send(msg)
```
```csharp
byte[] msg = System.Text.Encoding.ASCII.GetBytes("This is a test");
int bytesSent = s.Send(msg);
```
La méthode **Send** supprime les octets dans la mémoire tampon et les met en file d’attente dans l’interface réseau pour l’envoi à l’appareil réseau. L’interface réseau peut ne pas envoyer les données immédiatement, mais les envoyer plus tard, dès que la connexion sera fermée normalement avec la méthode <xref:System.Net.Sockets.Socket.Shutdown%2A>.
Pour recevoir les données d’un appareil réseau, passez une mémoire tampon à l’une des méthodes de réception de données de la classe **Socket** (<xref:System.Net.Sockets.Socket.Receive%2A> et <xref:System.Net.Sockets.Socket.ReceiveFrom%2A>). Les sockets synchrones interrompent l’exécution de l’application jusqu’à la réception des octets du réseau ou la fermeture du socket. L’exemple suivant reçoit les données du réseau, puis les affiche sur la console. L’exemple suppose que les données provenant du réseau sont encodées en texte ASCII. La méthode **Receive** retourne le nombre d’octets reçus du réseau.
```vb
Dim bytes(1024) As Byte
Dim bytesRec = s.Receive(bytes)
Console.WriteLine("Echoed text = {0}", _
System.Text.Encoding.ASCII.GetString(bytes, 0, bytesRec))
```
```csharp
byte[] bytes = new byte[1024];
int bytesRec = s.Receive(bytes);
Console.WriteLine("Echoed text = {0}",
System.Text.Encoding.ASCII.GetString(bytes, 0, bytesRec));
```
Quand le socket n’est plus nécessaire, vous devez le libérer en appelant la méthode <xref:System.Net.Sockets.Socket.Shutdown%2A>, puis la méthode **Close**. L’exemple suivant libère un **Socket**. L’énumération <xref:System.Net.Sockets.SocketShutdown> définit les constantes qui indiquent si le socket doit être fermé pour l’envoi et/ou la réception des données.
```vb
s.Shutdown(SocketShutdown.Both)
s.Close()
```
```csharp
s.Shutdown(SocketShutdown.Both);
s.Close();
```
## <a name="see-also"></a>Voir aussi
- [Utilisation d’un socket client asynchrone](using-an-asynchronous-client-socket.md)
- [Écoute avec des sockets](listening-with-sockets.md)
- [Exemple de socket client synchrone](synchronous-client-socket-example.md)
| 51.833333 | 610 | 0.757606 | fra_Latn | 0.836952 |
47474416e2f8a6adc7af2216b7ad0a27abf004b2 | 12,751 | md | Markdown | articles/site-recovery/site-recovery-workload.md | OpenLocalizationTestOrg/azure-docs-pr15_el-GR | 9f7579626c9f63b39b5039748978ac36e4d54ebc | [
"CC-BY-3.0",
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/site-recovery/site-recovery-workload.md | OpenLocalizationTestOrg/azure-docs-pr15_el-GR | 9f7579626c9f63b39b5039748978ac36e4d54ebc | [
"CC-BY-3.0",
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/site-recovery/site-recovery-workload.md | OpenLocalizationTestOrg/azure-docs-pr15_el-GR | 9f7579626c9f63b39b5039748978ac36e4d54ebc | [
"CC-BY-3.0",
"CC-BY-4.0",
"MIT"
] | null | null | null | <properties
pageTitle="Τι φόρτους εργασίας να προστατεύσετε με την ανάκτηση Azure τοποθεσίας;"
description="Azure Επαναφορά τοποθεσίας προστατεύει του όγκου εργασίας και εφαρμογών με το συντονισμό την αναπαραγωγή, ανακατεύθυνσης και αποκατάστασης εικονικές μηχανές εσωτερικής εγκατάστασης και φυσική διακομιστών Azure ή μια δευτερεύουσα τοποθεσία εσωτερικής"
services="site-recovery"
documentationCenter=""
authors="rayne-wiselman"
manager="cfreeman"
editor=""/>
<tags
ms.service="site-recovery"
ms.devlang="na"
ms.topic="get-started-article"
ms.tgt_pltfrm="na"
ms.workload="storage-backup-recovery"
ms.date="10/10/2016"
ms.author="raynew"/>
# <a name="what-workloads-can-you-protect-with-azure-site-recovery"></a>Τι φόρτους εργασίας να προστατεύσετε με την ανάκτηση Azure τοποθεσίας;
Σε αυτό το άρθρο περιγράφει φόρτους εργασίας και τις εφαρμογές που μπορείτε να αναπαραγάγετε με την υπηρεσία Azure Επαναφορά τοποθεσίας.
Δημοσίευση σχόλια ή ερωτήσεις στο κάτω μέρος αυτού του άρθρου ή στο [Φόρουμ υπηρεσίες ανάκτησης Azure](https://social.msdn.microsoft.com/forums/azure/home?forum=hypervrecovmgr).
## <a name="overview"></a>Επισκόπηση
Οι οργανισμοί πρέπει επιχειρήσεις συνέχειας και καταστροφή (BCDR) στρατηγική αποκατάστασης για να διατηρήσετε όγκου εργασίας και δεδομένων ασφαλείς και διαθέσιμα κατά τη διάρκεια του χρόνου εκτός λειτουργίας προγραμματισμένες και μη προγραμματισμένες και ανακτήσετε όσο το δυνατόν πιο σύντομα σε κανονική συνθήκες εργασίας.
Επαναφορά τοποθεσίας είναι μια υπηρεσία Azure συνεισφοράς σε της στρατηγικής BCDR. Χρησιμοποιώντας την αποκατάσταση τοποθεσίας, μπορείτε να αναπτύξετε εφαρμογή υπόψη αναπαραγωγής στο cloud ή σε μια δευτερεύουσα τοποθεσία. Εάν οι εφαρμογές σας είναι Windows ή Linux, εκτελείται σε φυσική διακομιστές, VMware ή Hyper-V, μπορείτε να χρησιμοποιήσετε Επαναφορά τοποθεσίας για να οργανώσετε αναπαραγωγής, εκτέλεση καταστροφής δοκιμές ανάκτησης, και εκτέλεση ανακατευθύνσεις και επιστροφή σε αυτόν.
Επαναφορά τοποθεσίας ενοποιείται με τις εφαρμογές της Microsoft, συμπεριλαμβανομένου του SharePoint, Exchange, Dynamics, SQL Server και υπηρεσίας καταλόγου Active Directory. Η Microsoft συνεργάζεται επίσης στενά με αρχικών προμηθευτές, συμπεριλαμβάνοντας Oracle, SAP, IBM και καπέλο κόκκινο χρώμα. Μπορείτε να προσαρμόσετε λύσεις αλληλεπίδραση με βάση μια εφαρμογή από την εφαρμογή.
## <a name="why-use-site-recovery-for-application-replication"></a>Γιατί να χρησιμοποιήσετε Επαναφορά τοποθεσίας για την αναπαραγωγή της εφαρμογής;
Επαναφορά τοποθεσίας συμβάλλει στην προστασία σε επίπεδο εφαρμογής και αποκατάστασης ως εξής:
- Εφαρμογή-agnostic, παρέχοντας αναπαραγωγής για οποιαδήποτε φόρτους εργασίας εκτελούνται σε έναν υπολογιστή που υποστηρίζονται.
- Κοντά σύγχρονη αναπαραγωγής, με RPOs μέχρι 30 δευτερόλεπτα για να ανταποκρίνονται στις ανάγκες των πιο κρίσιμων επιχειρηματικών εφαρμογών.
- Εφαρμογή συνεπή στιγμιότυπα, για μία ή πολλαπλών επιπέδων εφαρμογές.
- Ενοποίηση με το SQL Server AlwaysOn και συνεργασία με άλλα επίπεδο εφαρμογής τεχνολογίες αναπαραγωγής, συμπεριλαμβανομένων AD αναπαραγωγή, SQL AlwaysOn, Exchange βάσης δεδομένων διαθεσιμότητας ομάδες (DAGs) και Επιφυλακή δεδομένων Oracle.
- Ευέλικτη σχέδια ανάκτησης, που σας επιτρέπουν να ανακτήσετε μια στοίβα ολόκληρη την εφαρμογή με ένα μόνο κλικ, και συμπεριλάβετε για να συμπεριλάβετε εξωτερικές δέσμες ενεργειών και των μη αυτόματων ενεργειών στο πρόγραμμα.
- Διαχείριση του δικτύου για προχωρημένους στο Επαναφορά τοποθεσίας και Azure για να απλοποιήσετε εφαρμογή τις απαιτήσεις του δικτύου, συμπεριλαμβανομένης της δυνατότητας να δεσμεύσετε διευθύνσεις IP, ρύθμιση παραμέτρων εξισορρόπησης φόρτου και την ενοποίηση με το Azure κίνηση Manager, για χαμηλή switchovers δικτύου RTO.
- Μια βιβλιοθήκη εμπλουτισμένου αυτοματισμού που παρέχει παραγωγής ετοιμότητα, συγκεκριμένη εφαρμογή δεσμών ενεργειών που μπορούν να έχουν ληφθεί και ενσωματωμένο με σχέδια ανάκτησης.
## <a name="workload-summary"></a>Φόρτο εργασίας σύνοψης
Επαναφορά τοποθεσίας να αναπαραγάγετε οποιαδήποτε εφαρμογή που εκτελούνται σε έναν υπολογιστή που υποστηρίζονται. Επιπλέον μας έχετε συνεργαστεί με ομάδες προϊόντων για την εκτέλεση πρόσθετο έλεγχο συγκεκριμένης εφαρμογής.
**Φόρτο εργασίας** | **Αναπαραγωγή ΣΠΣ Hyper-V σε μια δευτερεύουσα τοποθεσία** | **Αναπαραγωγή ΣΠΣ Hyper-V σε Azure** | **Αναπαραγωγή ΣΠΣ VMware σε μια δευτερεύουσα τοποθεσία** | **Αναπαραγωγή ΣΠΣ VMware σε Azure**
---|---|---|---|---
Υπηρεσία καταλόγου Active Directory, DNS | Y | Y | Y | Y
Εφαρμογές Web (IIS, SQL) | Y | Y | Y | Y
System Center Operations Manager | Y | Y | Y | Y
Του SharePoint | Y | Y | Y | Y
SAP<br/><br/>Αναπαραγωγή τοποθεσία SAP σε Azure για μη συμπλέγματος | Y (ελεγχθεί από τη Microsoft) | Y (ελεγχθεί από τη Microsoft) | Y (ελεγχθεί από τη Microsoft) | Y (ελεγχθεί από τη Microsoft)
Exchange (μη DAG) | Y | Έρχομαι σύντομα | Y | Y
Απομακρυσμένη επιφάνεια εργασίας/VDI | Y | Y | Y | Δ/Υ
Linux (λειτουργικό σύστημα και εφαρμογές) | Y (ελεγχθεί από τη Microsoft) | Y (ελεγχθεί από τη Microsoft) | Y (ελεγχθεί από τη Microsoft) | Y (ελεγχθεί από τη Microsoft)
Dynamics AX | Y | Y | Y | Y
Dynamics CRM | Y | Έρχομαι σύντομα | Y | Έρχομαι σύντομα
Oracle | Y (ελεγχθεί από τη Microsoft) | Y (ελεγχθεί από τη Microsoft) | Y (ελεγχθεί από τη Microsoft) | Y (ελεγχθεί από τη Microsoft)
Διακομιστή αρχείων των Windows | Y | Y | Y | Y
## <a name="replicate-active-directory-and-dns"></a>Αναπαραγωγή υπηρεσίας καταλόγου Active Directory και το DNS
Μια υπηρεσία καταλόγου Active Directory και την υποδομή DNS είναι απαραίτητες για τα περισσότερα εταιρικών εφαρμογών. Κατά την αποκατάσταση, θα πρέπει να προστατεύσετε και να ανακτήσετε τα στοιχεία αυτά υποδομή πριν από την ανάκτηση του όγκου εργασίας και εφαρμογών.
Μπορείτε να χρησιμοποιήσετε Επαναφορά τοποθεσίας για να δημιουργήσετε ένα πρόγραμμα αποκατάστασης ολοκλήρωσης αυτοματοποιημένη καταστροφής για την υπηρεσία καταλόγου Active Directory και το DNS. Για παράδειγμα, εάν θέλετε να αποτύχει πάνω από το SharePoint και SAP από έναν πρωτεύοντα σε μια δευτερεύουσα τοποθεσία, μπορείτε να ρυθμίσετε ένα σχέδιο αποκατάστασης που αποτυγχάνει πρώτα πάνω από την υπηρεσία καταλόγου Active Directory και, στη συνέχεια ένα πρόγραμμα επιπλέον συγκεκριμένη εφαρμογή αποκατάστασης αποτυχία επάνω από τις άλλες εφαρμογές που βασίζονται στην υπηρεσία καταλόγου Active Directory.
[Μάθετε περισσότερα](site-recovery-active-directory.md) σχετικά με την προστασία της υπηρεσίας καταλόγου Active Directory και το DNS.
## <a name="protect-sql-server"></a>Προστασία του SQL Server
SQL Server παρέχει μια βάση δεδομένων υπηρεσιών για υπηρεσίες δεδομένων για πολλές επιχειρηματικών εφαρμογών σε ένα κέντρο δεδομένων εσωτερικής εγκατάστασης. Επαναφορά τοποθεσίας μπορεί να χρησιμοποιηθεί μαζί με τις τεχνολογίες SQL Server HA/DR, για να προστατεύσετε εφαρμογές πολλαπλών επιπέδων για μεγάλες επιχειρήσεις που χρησιμοποιούν το SQL Server. Επαναφορά τοποθεσίας παρέχει:
- Μια λύση αποκατάστασης από καταστροφή απλές και οικονομικός για τον SQL Server. Αναπαραγωγή πολλών εκδόσεων και τις εκδόσεις του SQL Server μεμονωμένη διακομιστές και συμπλεγμάτων, για να Azure ή σε μια δευτερεύουσα τοποθεσία.
- Ενοποίηση με τις ομάδες διαθεσιμότητας AlwaysOn SQL, για να διαχειριστείτε ανακατεύθυνσης και επιστροφή σε αυτόν με σχέδια ανάκτησης Azure Επαναφορά τοποθεσίας.
- Σχέδια για ολοκληρωμένες ανάκτησης για όλα τα επίπεδα σε μια εφαρμογή, συμπεριλαμβανομένων των βάσεων δεδομένων SQL Server.
- Κλιμάκωση του SQL Server για κορύφωσης φορτώνει με Επαναφορά τοποθεσίας, από την "πλούσια" τους σε μεγαλύτερα μεγέθη εικονική μηχανή IaaS στο Azure.
- Εύκολη δοκιμές του SQL Server αποκατάσταση. Μπορείτε να εκτελέσετε ανακατευθύνσεις δοκιμή για ανάλυση δεδομένων και την εκτέλεση ελέγχων συμμόρφωσης, χωρίς να επηρεάζονται περιβάλλον παραγωγής σας.
[Μάθετε περισσότερα](site-recovery-sql.md) σχετικά με την προστασία του SQL server.
##<a name="protect-sharepoint"></a>Προστασία του SharePoint
Azure Επαναφορά τοποθεσίας συμβάλλει στην προστασία αναπτύξεις του SharePoint, ως εξής:
- Αποκλείει την ανάγκη και σχετική υποδομή κόστους για ένα σύμπλεγμα αναμονής για αποκατάσταση. Χρησιμοποιούν Επαναφορά τοποθεσίας για την αναπαραγωγή ένα ολόκληρο το σύμπλεγμα (βαθμίδες Web, εφαρμογών και βάση δεδομένων) για να Azure ή σε μια δευτερεύουσα τοποθεσία.
- Απλοποιεί την ανάπτυξη εφαρμογών και διαχείρισης. Ενημερώσεις που έχουν αναπτυχθεί σε κύρια τοποθεσία αναπαράγονται αυτόματα και, επομένως, είναι διαθέσιμες μετά την ανακατεύθυνση και αποκατάστασης μιας συστοιχίας σε μια δευτερεύουσα τοποθεσία. Μειώνει επίσης την πολυπλοκότητα διαχείρισης και το κόστος που σχετίζεται με την ενημέρωση μια συστοιχία αναμονής.
- Απλοποιεί την ανάπτυξη εφαρμογών του SharePoint και τη δοκιμή, δημιουργώντας ένα περιβάλλον ρεπλίκα στη ζήτηση αντίγραφο μοιάζει με παραγωγής για τον έλεγχο και τον εντοπισμό σφαλμάτων.
- Απλοποιεί μετάβασης στο cloud χρησιμοποιώντας Επαναφορά τοποθεσίας για τη μετεγκατάσταση αναπτύξεων του SharePoint στο Azure.
[Μάθετε περισσότερα](https://gallery.technet.microsoft.com/SharePoint-DR-Solution-f6b4aeae) σχετικά με την προστασία του SharePoint.
## <a name="protect-dynamics-ax"></a>Προστασία Dynamics AX
Azure Επαναφορά τοποθεσίας συμβάλλει στην προστασία σας λύση Dynamics AX ERP, με:
- Orchestrating αναπαραγωγή της ολόκληρο Dynamics AX το περιβάλλον σας (βαθμίδες Web και AOS, βαθμίδες βάσης δεδομένων, SharePoint) Azure ή σε μια δευτερεύουσα τοποθεσία.
- Απλοποίηση της μετεγκατάστασης του Dynamics AX αναπτύξεις στο cloud (Azure).
- Απλοποίηση ανάπτυξη εφαρμογών Dynamics AX και έλεγχος, δημιουργώντας ένα αντίγραφο μοιάζει με παραγωγής στην ' απαίτηση, για τον έλεγχο και τον εντοπισμό σφαλμάτων.
[Μάθετε περισσότερα](https://gallery.technet.microsoft.com/Dynamics-AX-DR-Solution-b2a76281) σχετικά με την προστασία δυναμικής AX.
## <a name="protect-rds"></a>Προστασία RDS
Υπηρεσίες απομακρυσμένης επιφάνειας εργασίας (RDS) επιτρέπει υποδομή εικονικού υπολογιστή (VDI), με βάση την περίοδο λειτουργίας υπολογιστών και εφαρμογές, επιτρέποντας στους χρήστες να εργαστείτε από οπουδήποτε. Με την Επαναφορά τοποθεσίας Azure μπορείτε να:
- Αναπαραγωγή διαχειριζόμενη ή μη διαχειριζόμενη συνδυασμένου εικονικών επιφανειών εργασίας σε μια δευτερεύουσα τοποθεσία, και απομακρυσμένο εφαρμογές και περιόδους λειτουργίας σε μια δευτερεύουσα τοποθεσία ή Azure.
- Εδώ θα βρείτε τι μπορείτε να αναπαραγάγετε:
**RDS** | **Αναπαραγωγή ΣΠΣ Hyper-V σε μια δευτερεύουσα τοποθεσία** | **Αναπαραγωγή ΣΠΣ Hyper-V σε Azure** | **Αναπαραγωγή ΣΠΣ VMware σε μια δευτερεύουσα τοποθεσία** | **Αναπαραγωγή ΣΠΣ VMware σε Azure** | **Αναπαραγωγή φυσικής διακομιστές σε μια δευτερεύουσα τοποθεσία** | **Αναπαραγωγή φυσικής διακομιστές σε Azure**
---|---|---|---|---|---|---
**Συνδυασμένου εικονική επιφάνεια εργασίας (μη διαχειριζόμενου)** | Ναι | Όχι | Ναι | Όχι | Ναι | Όχι
**Συνδυασμένου εικονική επιφάνεια εργασίας (διαχειριζόμενων και χωρίς UPD)** | Ναι | Όχι | Ναι | Όχι | Ναι | Όχι
**Απομακρυσμένη εφαρμογές και περιόδους λειτουργίας επιφάνειας εργασίας (χωρίς UPD)** | Ναι | Ναι | Ναι | Ναι | Ναι | Ναι
[Μάθετε περισσότερα](https://gallery.technet.microsoft.com/Remote-Desktop-DR-Solution-bdf6ddcb) σχετικά με την προστασία RDS.
## <a name="protect-exchange"></a>Προστασία του Exchange
Επαναφορά τοποθεσίας συμβάλλει στην προστασία Exchange, ως εξής:
- Για μικρή αναπτύξεις του Exchange, όπως ένα μονό ή αυτόνομη έκδοση διακομιστές, Επαναφορά τοποθεσίας μπορεί να αναπαραγάγετε και ανακατευθύνει Azure ή μια δευτερεύουσα τοποθεσία.
- Για μεγαλύτερες αναπτύξεις, Επαναφορά τοποθεσίας ενοποιείται με το Exchange DAGS.
- Exchange DAGs είναι η προτεινόμενη λύση για το Exchange αποκατάσταση σε μια επιχείρηση. Σχέδια ανάκτησης αποκατάστασης τοποθεσίας μπορούν να περιλαμβάνουν DAGs, για να οργανώσετε DAG ανακατεύθυνση σε τοποθεσίες.
[Μάθετε περισσότερα](https://gallery.technet.microsoft.com/Exchange-DR-Solution-using-11a7dcb6) σχετικά με την προστασία του Exchange.
## <a name="protect-sap"></a>Προστασία SAP
Χρησιμοποιήστε Επαναφορά τοποθεσίας για να προστατεύσετε την ανάπτυξη SAP, ως εξής:
- Ενεργοποίηση προστασίας της ολόκληρο ανάπτυξης SAP, κατά την αναπαραγωγή ανάπτυξης διαφορετικά επίπεδα Azure ή σε μια δευτερεύουσα τοποθεσία.
- Απλοποίηση της μετεγκατάστασης cloud, με τη χρήση Επαναφορά τοποθεσίας για τη μετεγκατάσταση του ανάπτυξη SAP στο Azure.
- Απλοποίηση της ανάπτυξης εφαρμογών SAP και δοκιμές, δημιουργώντας μια παραγωγής μοιάζει με αντιγραφή σε απαιτήσεων για τον έλεγχο και τον εντοπισμό σφαλμάτων σε εφαρμογές.
[Μάθετε περισσότερα](http://aka.ms/asr-sap) σχετικά με την προστασία SAP.
## <a name="next-steps"></a>Επόμενα βήματα
[Προετοιμασία για ανάπτυξη Επαναφορά τοποθεσίας](site-recovery-best-practices.md)
| 83.888158 | 606 | 0.80629 | ell_Grek | 0.999993 |
4747cec8273e7565a76c27d9a784e7bc84629e30 | 5,895 | md | Markdown | practices/ungoogle/theme_logo/README.md | GitCodeview/lrn_chromium | 9f0b93c5a936a16e14eed094bbbd4e37de63c985 | [
"MIT"
] | null | null | null | practices/ungoogle/theme_logo/README.md | GitCodeview/lrn_chromium | 9f0b93c5a936a16e14eed094bbbd4e37de63c985 | [
"MIT"
] | null | null | null | practices/ungoogle/theme_logo/README.md | GitCodeview/lrn_chromium | 9f0b93c5a936a16e14eed094bbbd4e37de63c985 | [
"MIT"
] | null | null | null | # theme resource
theme root directory:
`src/chrome/app/theme`
## product logo
`src\chrome\app\theme\theme_resources.grd`
```xml
<if expr="not _google_chrome">
<structure type="chrome_scaled_image" name="IDR_PRODUCT_LOGO_16" file="chromium/product_logo_16.png" />
<structure type="chrome_scaled_image" name="IDR_PRODUCT_LOGO_32" file="chromium/product_logo_32.png" />
<structure type="chrome_scaled_image" name="IDR_PRODUCT_LOGO_WHITE" file="chromium/product_logo_white.png" />
<structure type="chrome_scaled_image" name="IDR_PRODUCT_LOGO_NAME_22" file="chromium/product_logo_name_22.png" />
</if>
```
### title logo
`src\chrome\browser\ui\views\frame\browser_view.cc`
```c++
// [@LT](START): add title icon header
#include "ui/views/view.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/views/background.h"
#include "base/strings/utf_string_conversions.h"
#include "base/threading/scoped_blocking_call.h"
#include "base/files/file_util.h"
#include "ui/base/resource/resource_bundle.h"
#include "chrome/grit/theme_resources.h"
#include "base/logging.h" // for debug
// [@LT](END): add title icon header
...
void BrowserView::InitViews() {
...
// [@LT](START): add title logo image view
views::ImageView* title_logo_view = new views::ImageView();
title_logo_view->SetBounds(8, 1, 32, 32);
ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
title_logo_view->SetImage(rb.GetNativeImageNamed(IDR_PRODUCT_LOGO_32).ToImageSkia());
AddChildView(title_logo_view);
// [@LT](END): add title logo image view
...
```
`src\chrome\browser\profiles\profile_shortcut_manager_win.cc`
```c++
// Incrementing this number will cause profile icons to be regenerated on
// profile startup (it should be incremented whenever the product/avatar icons
// change, etc).
- const int kCurrentProfileIconVersion = 6;
+ const int kCurrentProfileIconVersion = 7;
```
`src\chrome\browser\ui\views\frame\browser_view_layout.h`
```c++
// [@LT](START): add const variable of title logo width
const int kTitleLogoWidth = 40;
// [@LT](END): add const variable of title logo width
```
`src\chrome\browser\ui\views\frame\browser_view_layout.cc`
```c++
...
//////////////////////////////////////////////////////////////////////////////
// BrowserViewLayout, private:
int BrowserViewLayout::LayoutTabStripRegion(int top) {
if (!delegate_->IsTabStripVisible()) {
tab_strip_region_view_->SetVisible(false);
tab_strip_region_view_->SetBounds(0, 0, 0, 0);
return top;
}
// This retrieves the bounds for the tab strip based on whether or not we show
// anything to the left of it, like the incognito avatar.
gfx::Rect tab_strip_region_bounds(
delegate_->GetBoundsForTabStripRegionInBrowserView());
// [@LT](START): move tab strip by title logo width
tab_strip_region_bounds.set_x(
tab_strip_region_bounds.x() + kTitleLogoWidth);
tab_strip_region_bounds.set_width(
tab_strip_region_bounds.width() - kTitleLogoWidth);
// [@LT](END): move tab strip by title logo width
...
}
int BrowserViewLayout::LayoutWebUITabStrip(int top) {
if (!webui_tab_strip_ || !webui_tab_strip_->GetVisible())
return top;
constexpr int kWebUiTabStripHeightDp = 262;
// [@LT](START): Move Tab strip to get space of title logo
webui_tab_strip_->SetBounds(vertical_layout_rect_.x() + kTitleLogoWidth, top,
vertical_layout_rect_.width() - kTitleLogoWidth,
kWebUiTabStripHeightDp);
// webui_tab_strip_->SetBounds(vertical_layout_rect_.x(), top,
// vertical_layout_rect_.width(),
// kWebUiTabStripHeightDp);
// [@LT](END): Move Tab strip to get space of title logo
return webui_tab_strip_->bounds().bottom();
}
...
```
## Default browser popup icon
`src/chrome/app/vector_icons/chromium/product.icon`
```c
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
CANVAS_DIMENSIONS, 366,
MOVE_TO, 269.3f, 218.35f,
ARC_TO, 91.06f, 91.06f, 0, 0, 1, 186.66f, 275.24f,
R_CUBIC_TO, -50.21f, 1, -92.12f, -39.5f, -92.82f, -89.72f,
R_ARC_TO, 91, 91, 0, 0, 1, 175, -36.56f,
R_ARC_TO, 5.68f, 5.68f, 0, 0, 0, 5.22f, 3.48f,
R_H_LINE_TO, 83.19f,
R_ARC_TO, 5.69f, 5.69f, 0, 0, 0, 5.55f, -6.89f,
CUBIC_TO, 345.75f, 64.24f, 274.41f, 2.93f, 188.45f, 1.24f,
CUBIC_TO, 85.8f, -0.71f, 1.46f, 83.35f, 3.09f, 186,
R_CUBIC_TO, 1.6f, 99, 82.36f, 178.8f, 181.76f, 178.8f,
ARC_TO, 181.85f, 181.85f, 0, 0, 0, 362.55f, 221.61f,
R_ARC_TO, 5.66f, 5.66f, 0, 0, 0, -5.55f, -6.81f,
H_LINE_TO, 274.55f,
ARC_TO, 5.65f, 5.65f, 0, 0, 0, 269.3f, 218.35f,
CLOSE
// CANVAS_DIMENSIONS, 24,
// MOVE_TO, 12, 7.5f,
// R_H_LINE_TO, 8.9f,
// CUBIC_TO, 19.3f, 4.2f, 15.9f, 2, 12, 2,
// CUBIC_TO, 8.9f, 2, 6.1f, 3.4f, 4.3f, 5.6f,
// R_LINE_TO, 3.3f, 5.7f,
// R_CUBIC_TO, 0.3f, -2.1f, 2.2f, -3.8f, 4.4f, -3.8f,
// CLOSE,
// R_MOVE_TO, 0, 9,
// R_CUBIC_TO, -1.7f, 0, -3.1f, -0.9f, -3.9f, -2.3f,
// LINE_TO, 3.6f, 6.5f,
// CUBIC_TO, 2.6f, 8.1f, 2, 10, 2, 12,
// R_CUBIC_TO, 0, 5, 3.6f, 9.1f, 8.4f, 9.9f,
// R_LINE_TO, 3.3f, -5.7f,
// R_CUBIC_TO, -0.6f, 0.2f, -1.1f, 0.3f, -1.7f, 0.3f,
// CLOSE,
// R_MOVE_TO, 4.5f, -4.5f,
// R_CUBIC_TO, 0, 0.8f, -0.2f, 1.6f, -0.6f, 2.2f,
// LINE_TO, 11.4f, 22,
// R_H_LINE_TO, 0.6f,
// R_CUBIC_TO, 5.5f, 0, 10, -4.5f, 10, -10,
// R_CUBIC_TO, 0, -1.2f, -0.2f, -2.4f, -0.6f, -3.5f,
// R_H_LINE_TO, -6.6f,
// R_CUBIC_TO, 1, 0.8f, 1.7f, 2.1f, 1.7f, 3.5f,
// CLOSE,
// CIRCLE, 12, 12, 3.5
```
具体参考链接：[[chromium docs] vector icons tutorials](https://chromium.googlesource.com/chromium/src/+/master/components/vector_icons/README.md#why-do-we-need-multiple-sizes-of-vector-icons) | 36.165644 | 184 | 0.67447 | yue_Hant | 0.264337 |
47488307d3f7c043699e9f4e0124dbcf10fc0be2 | 733 | md | Markdown | api/Project.Application.WindowSplit.md | ahkon/VBA-Docs | c047d7975de2b0949b496af150d279c505a8595b | [
"CC-BY-4.0",
"MIT"
] | 4 | 2019-09-07T04:44:48.000Z | 2021-12-16T15:05:50.000Z | api/Project.Application.WindowSplit.md | ahkon/VBA-Docs | c047d7975de2b0949b496af150d279c505a8595b | [
"CC-BY-4.0",
"MIT"
] | 1 | 2021-06-13T09:32:15.000Z | 2021-06-13T09:32:15.000Z | api/Project.Application.WindowSplit.md | ahkon/VBA-Docs | c047d7975de2b0949b496af150d279c505a8595b | [
"CC-BY-4.0",
"MIT"
] | 1 | 2021-06-23T03:40:08.000Z | 2021-06-23T03:40:08.000Z | ---
title: Application.WindowSplit method (Project)
keywords: vbapj.chm2073
f1_keywords:
- vbapj.chm2073
ms.prod: project-server
api_name:
- Project.Application.WindowSplit
ms.assetid: cbdea999-4692-a10d-80e3-ae6b4407eebc
ms.date: 06/08/2017
localization_priority: Normal
---
# Application.WindowSplit method (Project)
Creates a lower pane for the active window. Closes the lower pane, if it already exists.
## Syntax
_expression_. `WindowSplit`
_expression_ A variable that represents an **[Application](Project.Application.md)** object.
## Return value
**Boolean**
## Remarks
The lower pane contains the default details view for the active window.
[!include[Support and feedback](~/includes/feedback-boilerplate.md)] | 20.361111 | 92 | 0.773533 | eng_Latn | 0.684382 |
4748861afe428de0fad321fff240bdb121db54d0 | 30,183 | md | Markdown | frontend/README.md | raguay/WebPageRenumberer | c703bebfbe59591a3c12f8729b690968f699ff4a | [
"MIT"
] | 3 | 2022-01-24T13:44:53.000Z | 2022-02-05T03:35:44.000Z | frontend/README.md | raguay/WebPageRenumberer | c703bebfbe59591a3c12f8729b690968f699ff4a | [
"MIT"
] | null | null | null | frontend/README.md | raguay/WebPageRenumberer | c703bebfbe59591a3c12f8729b690968f699ff4a | [
"MIT"
] | null | null | null | 
This project is for creating a file manager using web technologies. It is designed to run as a NW.js application. Node.js is the main language used with Svelte for the frontend UI.
Currently, it can`t transfer files to other programs with Drag and Drop due to a limitation of the NW.js program that is based on the Chrome browser. I should be able to get past this limitation soon by using lower level commands to the operating system.
This file manager is designed around the same principle as Vim: a state controled keyboard actions. The number of states isn't fixed, but very programmable. Therefore, an infinite number of keyboard configurations can be created and used. This is the main difference from other file managers.
# Disclamer: Beta level software. Use at your own risk! I accept no liability for lost information from the use of this software. User beware! But, if you have a major problem, please let me know so that I can look for solutions. This file manager is built using command line commands (rm, cp, mv, etc). Deletions currently default to moving to the trashcan on new installations.
The low level interface is still being mapped out and changes are happening. This means that extensions made using the current API will most likely need changes as the project moves forward.
## Table of Contents
- [Philosophy](#philosophy)
- [Current Feature Set](#current-feature-set)
- [Some Limitations](#some-limitations)
- [Installation](#installation)
- [Upgrading](#upgrading)
- [Command Line Programs Used](#command-line-programs-used)
- [Configuration Files](#configuration-files)
- [Source File Layout](#source-file-layout)
- [Editing Files](#editing-files)
- [Preferences](#preferences)
- [Things in the Works](#things-in-the-works)
- [Default Key Bindings](#default-key-bindings)
- [Normal Mode](#normal-mode)
- [Visual Mode](#visual-mode)
- [Insert Mode](#insert-mode)
- [Command Prompt Commands](#command-prompt-commands)
- [Extension Commands](#extension-commands)
- [Creating Themes](#creating-themes)
- [Creating Extensions](#creating-extensions)
- [Tutorials on Modal File Manager](#tutorials-on-modal-file-manager)
- [Adding Video Preview on Extra Panel](#adding-video-preview-on-extra-panel)
- [Icon](#icon)
## Philosophy
I started my programming career with Emacs as my main text editor on a main frame computer in college. I really loved Emacs, but had a very hard time remembering all the key commands. I ended up using Vim once for a class I had (the teacher loved Vim) and hit the perverbial Vim wall -- How do I exit this thing! I finally had to kill the process. So, I went back to Emacs.
With Spacemacs and Doom-emacs, I learned that the Vim style keyboard was much more efficient. But, I kept going back to the Emacs key memory. I finally decided to really give Vim a run with neovim on my MacBook Air. I even installed Spacevim and really liked it. Now, I'm fully comfortable in the Vim style keyboard (but far from mastering it completely) and have adapted it to many other programs along the way. My current editor of choice is [OniVim2](https://github.com/onivim/oni2) which is the fastest programming editor I've ever used. It is great!
But, I've never been happy with the file managers I've used. [fman](https://fman.io/) is great, but not actively being maintained and expanded upon. I also don't really like python, it's API language. So, I decided to jump in and make one to suit me better. This is how Modal File Manager was started. I wanted something that was as configurable as TkDesk was, but with a modal keyboard model for hotkeys. To take it even further, new modes and keymaps can be added with extensions. Along with anything else you can do with a full Node.js backend.
Modal File Manager is also somewhat minimal in the UI. Many graphical file managers have buttons, shelves, etc. all over the place with information everywhere. I decided to make the main interface as low keyed as possible with all other information in the status line or extras panel. Extra file information is on the status line for the current cursor location. More information is displayed in extras panel as well.
Since there are so many dual pane file managers available, I knew this would never be a marketable product (and I did not want the hassle of endless customer complaint over a feature not working the way they want it). Therefore, I'm making this an open source project to hopefully get some help from other to really making this thing shine.
Therefore, I hope you enjoy this little program as much as I have. Feel free to sponsor the project, help code some of it (just send in the pull requests), or just give me some tips along the way. Any help is appreciated.
I've created multiple open source resources (I have around 80 GitHub repositories), but this is the first full product. Therefore, please bear with me as I learn about maintaining and supporting an open source project.
## Current Feature Set
- Dual pane file manager with vim style model hotkeys for navigation and action launching.
- Drag and Drop works for copying or moving the current cursor and all selected files or directories (the current cursor location) within the application itself. If no keys pressed, it will be copied. If shift key is pressed, it will be moved. The drag begins with the current cursor.
- Command Prompt for executing commands (`:` in any mode or `<ctrl>p` in normal mode).
- Fully extendable with extensions using the extensions API
- Fully theme-able.
- A file details side panel can be shown to overlay the panel not currently focused (`toggleExtraPanel` command). It shows video previews and stats with the ffmpeg programs installed. Extensions can place special content in this panel as well.
- Themes and extensions are explorable and downloadable from GitHub inside the program.
- Hot keys are programmable
- A number before a hot key runs it's associated command that many times (ex: `5j` will move the cursor 5 entries down the list).
- Watches for changes in the current directory and updates accordingly.
- Changing directories in the Directory Bar (normal mode `q`) shows a list of matching entries from history and then below the current directory.
- File editor is configurable by the `~/.myeditorchoice` file (see `Editing Files` below). Otherwise, the system editor for the file type will be used.
- Integrated with ScriptPad - another project of mine coming soon!
- Quick Search - a input to type text so that any entry at that level is removed that doesn't have that text in it. Just refresh the pane to get back to normal. I think of it as a quick filter more than a quic search.
- Toggle System files/folders visibility
- Optionally deletes to the OS's trashcan (external program has to be installed)
- Change the environment used to execute external programs using the `Show Preferences` Command Prompt command.
- Theme Creator/Editor
- Extension Creator/Editor with template.
- Extensions controled content in the Extras Panel.
- Extensions currently created and downloadable from GitHub:
- [Copy to Clipboard](https://github.com/raguay/CopyToClipboard-ModalFileManagerExtension): copy file name or path to clipboard with command prompt.
- [Alfred](https://github.com/raguay/Alfred-ModalFileManager): Launch Afred Browser on the current cursor location
- [Move to Dir](https://github.com/raguay/moveToDir-ModalFileManagerExtension): Selected files are moved to the folder under the cursor in the same panel
- [iTerm](https://github.com/raguay/iTerm-ModalFileManagerExtension): open the current cursor directory in iTerm2
- [Favorites](https://github.com/raguay/Favorites-ModalFileManagerExtension): An extension to mark favorite directories to be able to go back to easily, back up directories previously entered, six directory registers to quickly hop around using the `fav` mode, and much more.
- [User Scripts](https://github.com/raguay/runScripts-ModalFileManagerExtension): Create and run scripts from mfm.
- [Project Manager](https://github.com/raguay/ProjectManager-mfm): A set of functions to work with projects, project templates, run project scripts for npm and mask, and creating/editing of project notes.
- Themes currently created and downloadable from GitHub:
- [Dracula Pro](https://github.com/raguay/dracula-ThemeModalFileManager)
- [Dracula "Buffy"](https://github.com/raguay/dracula-buffy-ThemeModalFileManager)
- [Dracula "Van Helsing"](https://github.com/raguay/Dracula-Van-Helsing-ThemeModalFileManager)
All Dracula based themes are here with permission from the author. Please support his great work at [Dracula Themes](https://draculatheme.com/). The Dracula "Buffy" theme is my preferred theme for everything. I'm having many issues with my eyes having light sensitivity and this theme allows me to keep working longer than other themes.
## Some Limitations
Because this is a web technologies application, there are certain things that it just can't do and I'm not sure if they can be done at this level. Therefore, this will not completely remove your dependency on using the Finder application. But, these instances are not everyday items for which we use a file manager. As I see it, these items are not doable, but I would love for someone to prove me wrong:
- Install applications that the macOS Gatekeeper will allow.
## Installation
These directions currently work for the macOS. I haven't tested the Linux or Windows installation. All external programs should be installed before first running the Modal File Manager. Otherwise, you will have to modify the path used to execute external programs to find them.
I have a run script made with [Mask](https://github.com/jakedeichert/mask) and [Node.js](https://nodejs.org/en/). You have to put a copy of [NW.js](https://nwjs.io/) in the 'misc' directory as `nwjs.app`. Or, you can change the script. I'm assuming you aren't changing the script in the following. Also, the scripts in the mask file are running in a [fish shell](https://github.com/fish-shell/fish-shell). If you don't have fish shell on your system, you will need to either install it or convert the script to run in zsh or sh.
So, download the repository, create the `misc` directory, put nwjs.app in the `misc` directory. On the command line, run the following commands to compile and run the program:
```sh
git clone https://github.com/raguay/ModalFileManager.git
cd ModalFileManager
mkdir misc
npm install
```
This will install all the libraries for building the project. Then run:
```sh
mask build
```
which will build the project. To run the project, run this command:
```sh
mask launch
```
If everything is in place okay, it should then show you the file manager opened to your home directory. Dive in and have fun.
If you are interested in running in development mode, you have to have the NW.js SDK in the `misc` directory named `nwjs-sdk`. Then you can run:
```sh
mask launch -d
```
which will launch the sdk version of NW.js with full development tools.
If you just want to download a program to use, check the releases. I'm currently releasing beta level macOS binaries in the releases. A step by step installing using the releases is discussed in my tutorial [Modal File Manager: Update and Extensions](https://blog.customct.com/modal-file-manager-update-and-extensions). This version isn't complete in that when you run a program to view processes, the processes will say `nwjs`, but the icon will be for mfm (Modal File Manager).
## Upgrading
If a new version comes out with new default key mappings, you will either have to manually alter the key maps or delete the `keyMaps` directory in the Modal File Manager configuration directory.
## Command Line Programs Used
There are a few non-standard command line programs I use with Modal File Manager. They are:
- [ffmpeg](https://ffmpeg.org/) for getting and using video information in the Extra Panel.
- [fd](https://github.com/sharkdp/fd) for quick file finding. It's a `find` replacement written in Rust.
- For using the macOS trashcan, you have to have (`trash`)[https://github.com/andreafrancia/trash-cli] command line program installed using `brew install trash-cli`. If the program isn't installed before installing mfm, then you will need to adjust the environment variable for PATH in the preferences to make sure it is in the path.
I also use the standard `cp`, `mv`, `mkdir`, and `rm` commands on the command line. These still run faster than rewriting them in the scripting language. The major drawback is there isn't a backup method. Once deleted with `rm`, it will always be deleted. The `rm` command is used only if the user sets the `Trashcan` general preference to off (unchecked). On a new install, this is usually set to on (checked) even if the `trash-cli` isn't installed. In that case, nothing get deleted. This is for safety of the user files and directories.
All of the programs should be downloaded and in your shell's path. Modal File Manager doesn't assume location for anything except or it's own configuration files. But, if Modal File Manager can't find the program, you can adjust the path used in the preferences general tab (Command Prompt command is `Show Preferences`).
## Configuration Files
All extensions, themes, keyboard layouts, and anything else for configuring the Modal File Manager is found in it's main configuration directory. On Linux and macOS, it is located at: `~/.config/modalfilemanager`. It will be in the Windows User directory, but I haven't really looked at Windows functionality yet.
In this configuration directory, there are the `themes`, `extensions`, and `keyMaps` directories that contain their respective subfolders and files. Please refer the specific section for each directory for more details.
There is the `history.json` file, `config.json` file, and the `theme.json` files in the configuration directory. Also, extensions will create and store their configuration files in this directory as well (at least, that is what I advise extension authors).
The `history.json` file contains a list of directories that the Modal File Manager has visited. I use this to quickly pull up possible paths to go to in the file manager.
The `config.json` file contains the environment variables used to launch command line commands and whether or not to use the `trash-cli` program to delete files and directories.
Modal File Manager doesn't use the actual theme files downloaded from GitHub. Those are stored in the `themes` directory and are just referenced. All actually used theming is in the `theme.json` file. When a user changes themes, that file is changed. Therefore, be careful if you manually change this file and want to keep it. It is best to create a theme in the theme directory and load it in the program. My tutorial [Modal File Manager: Update and Extensions](https://blog.customct.com/modal-file-manager-update-and-extensions) walks through creating a theme using the Preferences Panel.
All configuration files should be edited from the `Show Preferences` command prompt command.
## Source File Layout
The directory structure is:
```
- modalfilemanager
|
- src
|
- components Here are all the Svelte components for the UI
- modules These are JavaScript Helper files with the data structures used.
- stores This directory contains all the Svelte Store items
- FileManager.svelte This is the main program
- main.js This installs the main program into the HTML
```
All low level functions are in the `modules/macOS.js`, `modules/linux.js`, and `modules/windows.js` for the particular operating system. This is the initial breakdown and will be added upon in the future as needed.
## Editing files
Files will be edited (normal mode key `e`) using editor specified in the [xBar](https://xbarapp.com/) plugin [currentFiles.1h.rb](https://xbarapp.com/plugins/System/currentFiles.1h.rb).
To use with the **xBar** plugin, you will need to have [xBar](https://xbarapp.com/) installed and the [currentFiles.1h.rb](https://xbarapp.com/docs/plugins/System/currentFiles.1h.rb.html) plugin installed and configured. You can also use the [Alfred BitBar Workflow](https://github.com/raguay/MyAlfred/blob/master/Alfred%203/BitBarWorkflow.alfredworkflow) to control the plugin.
Alternatively, you can use the [TextBar](http://richsomerfield.com/apps/textbar/) program with the [Current Files and Editor](https://github.com/raguay/TextBarScripts/blob/master/Current%20Files%20and%20Editor.textbar) plugin installed. You can use the [Alfred](https://www.alfredapp.com/) with the [My Editor Workflow](https://github.com/raguay/MyAlfred/blob/master/Alfred%203/My%20Editor%20Workflow.alfredworkflow) to control the editor and edit files.
If the above editor setup isn't on the system, it will use the operating system to open the
file in the default file editor.
## Preferences
With the command prompt command of `Show Preferences`, you can now open a new panel over the filemanager that shows all the program preferences. It is setup as a tab system with a General, Theme, and Extension tab.
The General tab allows the user to delete, edit, or add environment variables to the running of command line programs. This give the user complete control over the environment variables used in launching commands from Modal File Manager. You can also turn on/off the use of the trashcan for deletions.
The Theme tab allows you to create, update, and delete themes from the Modal File Manager. My tutorial [Modal File Manager: Update and Extensions](https://blog.customct.com/modal-file-manager-update-and-extensions) walks through creating a theme using the Preferences Panel.
The Extension tab allows you to create, edit, and delete extensions from the Modal File Manager. The creation and editing of an extension will open the main file for the extension in the code editor that has been setup and moves the Modal File Manager to the extension's directory in the pane opposite the current cursor.
## Things in the Works
- Translating my fman extensions to work with Modal File Manager
- Dropbox File System
- Regular Expression selection
- Zip Selected Entries
- Drag and drop with external programs
- Add more file views for the Extra Panel
- Multiple windows
- Get Windows working
- Get Linux tested and working
- Get audio listening in the Extras Panel.
- Documentation!
- Of course, bug fixing!
## Default Key Bindings
### Normal Mode
| Key Press | Command Executed |
| --- | ------ |
| `r` | reloadPane |
| `p` | swapPanels |
| `d` | duplicateEntry |
| `e` | editEntry |
| `m` | moveEntries |
| `c` | copyEntries |
| `x` | deleteEntries |
| `g` | goTopFile |
| `G` | goBottomFile |
| `ArrowDown` | moveCursorDown |
| `ArrowUp` | moveCursorUp |
| `l` | goDownDir |
| `h` | goUpDir |
| `Enter` | actionEntry |
| `Tab` | cursorToNextPane |
| `k` | moveCursorUp |
| `j` | moveCursorDown |
| `i` | changeModeInsert |
| `v` | changeModeVisual |
| `/` | toggleQuickSearch |
| `s` | toggleExtraPanel |
| `<cmd>p` | toggleCommandPrompt |
| `:` | toggleCommandPrompt |
| `.` | reRunLastCommand |
| `,` | toggleFilter |
| `O` | openOppositePanel |
### Visual Mode
| Key Press | Command Executed |
| --- | ------ |
| `Escape` | changeModeNormal |
| `k` | moveCursorUpWithSelect |
| `j` | moveCursorDownWithSelect |
| `ArrowDown` | moveCursorDown |
| `ArrowUp` | moveCursorUp |
| `:` | toggleCommandPrompt |
### Insert Mode
| Key Press | Command Executed |
| --- | ------ |
| `Escape` | changeModeNormal |
| `d` | newDirectory |
| `f` | newFile |
| `r` | renameEntry |
| `:` | toggleCommandPrompt |
## Command Prompt Commands
These commands can be ran from the command prompt. They all act upon the current cursor.
| Command Name | Command Description | Command Function Name |
|:--------------------------------- |:-------------------------------------------------------------------------- | ------------------------ |
| `Move Cursor Up` | This will move the cursor up one line | moveCursorUp |
| `Move Cursor Up with Selection` | This will move select the current entry and move the cursor up one line. | moveCursorUpWithSelect | |
| `Change Mode to Normal` | Set the normal mode. | changeModeNormal | |
| `Change Mode to Insert` | Set the insert mode. | changeModeInsert | |
| `Change Mode to Visual` | Set the visual mode. | changeModeVisual | |
| `Cursor to Next Pane` | This will move the cursore to the opposite pane. | cursorToNextPane | |
| `Action Entry` | This will open a file or go into a directory. | actionEntry | |
| `Go Up a Directory` | Go to the parent directory. | goUpDir | |
| `God Down a Directory` | If the current entry is a directory go to it. | goDownDir | |
| `Go to Bottom File` | Move the cursor to the bottom most file. | goBottomFile | |
| `Go to Top File` | Move the cursor to the top most file. | goTopFile | |
| `Delete Entries` | Delete all selected entries or the one under the cursor | deleteEntries | |
| `Copy Entries` | Copy the selected entries or the one under the cursor to the other pane. | copyEntries | |
| `Move Entries` | Move the selected entries or the one under the cursor to the other pane. | moveEntries | |
| `Edit Entry` | Opens the file under the cursor in the editor specified. | editEntry | |
| `Duplicate Entry` | Make a copy of the current entry with "\_copy" added to it. | duplicateEntry | |
| `New File` | Create a new file in the current pane. | newFile | |
| `New Directory` | Create a new directory in the current pane. | newDirectory | |
| `Rename Entry` | Rename the current entry. | renameEntry | |
| `Swap Panels` | Swap the panel contents. | swapPanels | |
| `Toggle Quick Search` | Show/Hide the Quick Search panel. | toggleQuickSearch | |
| `Reload Pane` | Reload the Current Pane. | reloadPane | |
| `Toggle Extra Panel` | Show/Hide the extra panel. | toggleExtraPanel |
| `Edit Directory` | Open the Edit Directory for the current panel.| editDirectory |
| `Toggle Command Prompt` | Show/Hide the command prompt. | toggleCommandPrompt |
| `Toggle GitHub Importer` | Show/Hide the GitHub importer panel for searching for themes and extensions on GitHub and installing them. | toggleGitHub |
| `Refresh Panes` | This will reload files in both the left and right pane. | refreshPanes |
| `Refresh Left Pane` | This will reload the files in the Left Pane. | refreshLeftPane |
| `Refresh Right Pane` | This will reload the files in the Right Pane. | refreshRightPane |
| `Rerun Last Command` | This will rerun the last command along with it the number of times it was ran. | reRunLastCommand |
|`Toggle Filter` | Toggles the show all and default filters. | toggleFilter |
| `Show All Filter` | Sets to show all Entries. | setShowAllFilter |
| `Show Only Non-System Files/Folders` | Sets the default filter of not showing system files/folders. | setDefaultFilter |
| `Open in Opposite Panel` | Opens the directory the cursor is on or the directory the cursor is in in the opposite panel. | openOppositePanel |
| `Reload Extensions` | Reload all the extensions, keyboard maps, and theme. | reloadExtensions |
### Extension Commands
These commands require inputs and supply results. Therefore these commands can`t be used in hotkeys or the command prompt. They are loaded and used in a different way as well. Please refer to the [Creating Extensions Section](#creating-extensions) for more details.
| Function Name | Description |
| --- | ---------- |
| `setCursor` | Set the cursor to the file name given in the current panel. |
| `getCursor` | Get the current cursor. |
| `cursorToPane` | Set the cursor to the pane given. Either "left" or "right" |
| `changeDir` | Change the directory of a pane and make it the current. |
| `addKeyboardShort` | A a shortcut for a keyboard map. |
| `getLeftFile` | Get the current file for the left pane. |
| `getRightFile` | Get the current file for the right pane. |
| `getTheme` | Get the current values for the theme. |
| `setTheme` | Set the values for the current theme. |
| `getOS` | Get the local OS name. |
| `addDirectoryListener` | Add a listener to directory changes. |
| `getLastError` | returns the last error. |
| `getSelectedFiles` | Returns a list of Entries that have been selected. |
| `getCurrentFile` | Get the current file. |
| `getCurrentPane` | Get the pane that is currently active. |
| `addSpinner` | Add a message box spinner value. |
| `updateSpinner` | Update a message box spinner value. |
| `removeSpinner` | Remove a message box spinner value. |
| `keyProcessor` | Send a keystroke to be processed. |
| `stringKeyProcessor` | Send a string of keystrokes to be processed. |
| `askQuestion` | Ask a question and get the response. |
| `pickItem` | Choose from a list of items. |
| `showMessage` | Show a message to the user. |
| `createNewMode` | Allows the creation of a new mode for keyboard commands. |
| `changeMode` | Change to mode given. |
| `switchView` | Change to new program view. Currently `filemanager` or `preferences`. |
| `copyEntriesCommand` | Copy the entry list to the destination entry. |
| `moveEntriesCommand` | Move the entry list to the destination entry. |
| `deleteEntriesCommand` | Delete the entry list |
| `editEntryCommand` | Edit the entry |
| `getRightDir` | Get the directory path for the right panel. |
| `getLeftDir` | Get the directory path for the left panel. |
| `addExtraPanelProcessor` | Add a object for processing extra panel informaiton. |
## Creating Themes
A theme is a GitHub repository or a repository on your system. It is setup as a normal npm project with a `package.json` file. The `package.json` file should be similar to this:
```json
{
"name": "dracula-ThemeModalFileManager",
"version": "1.0.0",
"description": "The Dracula theme for Modal File Manager.",
"keywords": [
"modalfilemanager"
],
"author": "Richard Guay",
"license": "MIT",
"mfmtheme": {
"name": "dracula-ThemeModalFileManager",
"description": "Dracula theme for Modal File Manager.",
"type": 0,
"github": "",
"main": "dracula.json"
}
}
```
The subheading `mfmtheme` contains the information the program will use to load the theme. The `main` is set to the path of the JSON file containing the themes values. If it's in the top of the directory, then use just the file name as seen above.
The `type` is 0 for local only and 1 for a GitHub download. The `github` value is the URL to the repository on GitHub. The `description` is shown to the user that should accurately describe the theme.
The Theme JSON file is like this one:
```json
{
"font":"Fira Code, Menlo",
"fontSize":"12pt",
"cursorColor": "#363443",
"selectedColor": "#FFCA80",
"backgroundColor": "#22212C",
"textColor": "#F8F8F2",
"borderColor": "#1B1A23",
"normalbackgroundColor": "#80FFEA",
"insertbackgroundColor": "#8AFF80",
"visualbackgroundColor": "#FF80BF",
"Cyan": "#80FFEA",
"Green": "#8AFF80",
"Orange": "#FFCA80",
"Pink": "#FF80BF",
"Purple": "#9580FF",
"Red": "#FF9580",
"Yellow": "#FFFF80"
}
```
It should be a proper JSON structure with these definitions. Change the color values as you want.
## Creating Extensions
TODO: Documentation Coming Soon.
## Tutorials on Modal File Manager
- [My Side Project: Modal File Manager](https://blog.customct.com/my-side-project-modal-file-manager)
- [Modal File Manager: Update and Extensions](https://blog.customct.com/modal-file-manager-update-and-extensions)
## Adding Video Preview on Extra Panel
The normal copy of NW.js doesn't come with the codeces for displaying videos. In order for this feature, you will have to download the dynamically loaded library for your system from here: https://github.com/iteufel/nwjs-ffmpeg-prebuilt/releases.
Then place this in your copy of NW.js as described in step 5 here: http://docs.nwjs.io/en/latest/For%20Developers/Enable%20Proprietary%20Codecs/#enable-proprietary-codecs-in-nwjs
With this library in place, the Extra Panel will run mp4 files just fine. I haven't testing other versions since that what I mostly use.
## Icon
I finally made my first attempt at an icon for Modal File Manager. The files are in the `icons` directory. Any constructive criticizm is welcome.
| 68.910959 | 590 | 0.712719 | eng_Latn | 0.992342 |
4748c67a28ad51e7d88a3fe074bc6d2dff7acf60 | 5,740 | md | Markdown | workshop-one-service/2-docker.md | viniciusfcf/cloud-native-starter | e32d263cbcde7bac1e0b01595558dfadd11a0457 | [
"Apache-2.0"
] | null | null | null | workshop-one-service/2-docker.md | viniciusfcf/cloud-native-starter | e32d263cbcde7bac1e0b01595558dfadd11a0457 | [
"Apache-2.0"
] | null | null | null | workshop-one-service/2-docker.md | viniciusfcf/cloud-native-starter | e32d263cbcde7bac1e0b01595558dfadd11a0457 | [
"Apache-2.0"
] | 2 | 2020-12-29T03:34:59.000Z | 2021-02-20T18:55:02.000Z | # Lab 2 - Running the Java Microservice locally
> _Note:_ This lab is structured in **understanding** and **hands-on tasks**.
The hands-on tasks are starting from chapter [Hands-on tasks - Run the container locally](#lab-hands-on) in that lab.
In this workshop we run a microservice that has been implemented with Java EE and [Eclipse MicroProfile](https://microprofile.io/).
The microservice has been kept as simple as possible, so that it can be used as a starting point for other microservices. It contains the following functionality:
* Image with OpenJ9, OpenJDK, Open Liberty and MicroProfile: [Dockerfile](../Dockerfile)
* Maven project: [pom.xml](../pom.xml)
* Open Liberty server configuration: [server.xml](../liberty/server.xml)
* Health endpoint: [HealthEndpoint.java](../src/main/java/com/ibm/authors/HealthEndpoint.java)
* Kubernetes yaml files: [deployment.yaml](../deployment/deployment.yaml) and [service.yaml](../deployment/service.yaml)
* Sample REST GET endpoint: [AuthorsApplication.java](../src/main/java/com/ibm/authors/AuthorsApplication.java), [GetAuthor.java](../src/main/java/com/ibm/authors/GetAuthor.java) and [Author.java](../src/main/java/com/ibm/authors/Author.java)
This service provides a REST API 'getauthor'. Normally we would use a database but in this example we just simulate with local sample data. With this small example we touch the following topics:
* Usage of [Maven](https://maven.apache.org/) for Java
* Configuration of an [OpenLiberty Server](https://openliberty.io)
* Implementation of a [REST GET endpoint with MicroProfile](https://openliberty.io/blog/2018/01/31/mpRestClient.html)
* [Health check](https://openliberty.io/guides/kubernetes-microprofile-health.html#adding-a-health-check-to-the-inventory-microservice) implementation using a MicroProfile for Kubernetes
* Definition of a [Dockerfile](https://docs.docker.com/engine/reference/builder/) with the reuse for existing containers from [Dockerhub](https://hub.docker.com)
## Definition of the Image
For the image we use a stack of open source components to run the Java microservice on Open Liberty.
* OpenJ9 0.12.1
* OpenJDK 8u202-b08 from AdoptOpenJDK
* Open Liberty 18.0.0.4
* MicroProfile 3.0
Read the article [How to build and run a Hello World Java Microservice](http://heidloff.net/article/how-to-build-and-run-a-hello-world-java-microservice/) to learn more.
In the [Dockerfile](../authors-java-jee/Dockerfile) we define how to build the container image. For detailed information check the [Dockerfile documentation](https://docs.docker.com/engine/reference/builder/)
When we build a new container image we usually start with an existing container image that already contains a minimum of the configuration we need, for example the OS, the Java version or even more. For this we search [DockerHub](https://hub.docker.com/search?q=maven&type=image&image_filter=official) or on the internet to find a starting point which fits to our needs.
Using a [multi-stage build](https://docs.docker.com/develop/develop-images/multistage-build/).
Inside of our Dockerfile we use two stages to build the container image . The reason for the two stages is that we want to be independend of an existing local environment when we build our production services. With this concept we don't have to ensure that e.g. Java and Maven or correct versions of them are installed on the local machine of the developers.
With this two stage approach there is one container responsible to build the microservice, let us call this container build environment container, and another container will contain the microservice itself, we call this the production container. Only this production container is later used.
### Build environment container
In the following Dockerfile sample we can see how we create our build environment container based on the maven 3.5 image from [DockerHub](https://hub.docker.com/_/maven/).
We use the pom file that we defined before to build our Authors service with `RUN mvn -f /usr/src/app/pom.xml clean package`.
```dockerfile
FROM maven:3.5-jdk-8 as BUILD
COPY src /usr/src/app/src
COPY pom.xml /usr/src/app
RUN mvn -f /usr/src/app/pom.xml clean package
```
### Production container
The starting point for the Production container is an [OpenLiberty container](https://hub.docker.com/_/open-liberty).
We copy the Authors service code together with the server.xml for the OpenLiberty server to this container.
_Note:_ The service.xml **defines** `port 3000` as the port where we can reach the Authors microservice. That port must be exposed with `EXPOSE 3000` in the Dockerfile.
```dockerfile
FROM open-liberty:19.0.0.9-kernel-java11
COPY liberty/server.xml /config/
COPY --from=0 /usr/src/app/target/authors.war /config/apps/
# This script will add the requested XML snippets, grow image to be fit-for-purpose and apply interim fixes
# https://github.com/WASdev/ci.docker
RUN configure.sh
EXPOSE 3000
```
### Hands-on tasks - Run the container locally <a name="lab-hands-on"></a>
That lab needs a local Docker installation and a terminal session on your local machine.
#### Step 1: To test and see how the code works you can run the code locally as a Docker container
```
$ git clone https://github.com/IBM/cloud-native-starter
$ cd cloud-native-starter
$ ROOT_FOLDER=$(pwd)
$ cd $ROOT_FOLDER/authors-java-jee
$ docker build -t authors .
$ docker run -i --rm -p 3000:3000 authors
```
#### Step 2: Open the Swagger UI of the mircoservice in a browser.
```
http://localhost:3000/openapi/ui/
```
---
:star: __Continue with [Lab 3 - Understanding the Java Implementation](./3-java.md#lab-3---understanding-the-java-implementation)__ | 52.66055 | 371 | 0.769512 | eng_Latn | 0.951638 |
4748fd1e69c76bc387c722ae141beefa61094875 | 384 | md | Markdown | CHANGELOG.md | vonsogt/laravel-form-template | d3e6a039a1e0bbdabaa2077bc06ca28ca5606733 | [
"MIT"
] | 7 | 2020-06-08T09:11:09.000Z | 2021-02-05T09:44:50.000Z | CHANGELOG.md | vonsogt/laravel-form-template | d3e6a039a1e0bbdabaa2077bc06ca28ca5606733 | [
"MIT"
] | null | null | null | CHANGELOG.md | vonsogt/laravel-form-template | d3e6a039a1e0bbdabaa2077bc06ca28ca5606733 | [
"MIT"
] | 2 | 2021-02-08T02:56:37.000Z | 2021-12-23T08:20:52.000Z | # Changelog
All notable changes to this package will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
## [1.0.0] - 2020-06-05
- initial release
[1.0.0]: http://gitlab.medianet.lan/medianet_interne/mobilityapp_backend/commits/1.0.0
| 29.538462 | 87 | 0.742188 | eng_Latn | 0.780684 |
4748fd7b615ccbf6247825907b9e7e368b590728 | 1,395 | md | Markdown | docs/2014/ssms/solution/change-the-connection-associated-with-a-query.md | cawrites/sql-docs | 58158eda0aa0d7f87f9d958ae349a14c0ba8a209 | [
"CC-BY-4.0",
"MIT"
] | 2 | 2020-05-07T19:40:49.000Z | 2020-09-19T00:57:12.000Z | docs/2014/ssms/solution/change-the-connection-associated-with-a-query.md | cawrites/sql-docs | 58158eda0aa0d7f87f9d958ae349a14c0ba8a209 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/2014/ssms/solution/change-the-connection-associated-with-a-query.md | cawrites/sql-docs | 58158eda0aa0d7f87f9d958ae349a14c0ba8a209 | [
"CC-BY-4.0",
"MIT"
] | 2 | 2020-03-11T20:30:39.000Z | 2020-05-07T19:40:49.000Z | ---
title: "Change the Connection Associated with a Query | Microsoft Docs"
ms.custom: ""
ms.date: "06/13/2017"
ms.prod: "sql-server-2014"
ms.reviewer: ""
ms.technology: ssms
ms.topic: conceptual
helpviewer_keywords:
- "connections [SQL Server Management Studio], query associations"
- "projects [SQL Server Management Studio], connections"
- "projects [SQL Server Management Studio], query connections"
- "query associations [SQL Server Management Studio]"
ms.assetid: 7b8851b8-eccb-4e6c-944a-68fa90fc5870
author: stevestein
ms.author: sstein
manager: craigg
---
# Change the Connection Associated with a Query
A query can be executed against several different servers or databases by changing the connection used by the query.
### To change the connection associated with a query
1. In Query Editor, right-click a blank area of Query Editor, point to **Connection**, and then click **Change Connection**.
2. In the **Connect to Database Engine** dialog box, provide the new connection information, and then click **Connect**.
## See Also
[Solution Explorer](solution-explorer.md)
[Associate a Query with a Connection in a Project](associate-a-query-with-a-connection-in-a-project.md)
[View or Change the Properties of a Connection in a Project](view-or-change-the-properties-of-a-connection-in-a-project.md)
| 41.029412 | 128 | 0.726165 | eng_Latn | 0.946859 |
474925ee457cdf3ac90fe52dc78080b960370bd4 | 341 | md | Markdown | README.md | oeg-upm/ORSD-template | 8530fa59fb82835a6cc7fb45897b214b30e62f44 | [
"Apache-2.0"
] | 1 | 2017-05-14T11:16:36.000Z | 2017-05-14T11:16:36.000Z | README.md | oeg-upm/ORSD-template | 8530fa59fb82835a6cc7fb45897b214b30e62f44 | [
"Apache-2.0"
] | 1 | 2021-04-15T13:45:19.000Z | 2021-06-10T09:02:58.000Z | README.md | oeg-upm/ORSD-template | 8530fa59fb82835a6cc7fb45897b214b30e62f44 | [
"Apache-2.0"
] | 1 | 2021-05-29T17:41:44.000Z | 2021-05-29T17:41:44.000Z | # ORSD-template
This file contains a LaTeX template for defining the [Ontology Requirements Specification (ORSD)](http://www.neon-project.org/web-content/media/book-chapters/Chapter-05.pdf) file, as specified by the NeOn Methodology.
NOTE: this repository is archived as the resources are moved to https://github.com/oeg-upm/LOT-resources
| 56.833333 | 217 | 0.797654 | eng_Latn | 0.735174 |
474ad2a91d17591f6d0e0030d78e0646b2501393 | 885 | md | Markdown | _posts/2022-01-18-ST-MinioGuide.md | JeongJaeyoung0/JeongJaeyoung0.github.io2 | c99353a5ac7158d24a55e452e2604e1bde7e8b7e | [
"MIT"
] | null | null | null | _posts/2022-01-18-ST-MinioGuide.md | JeongJaeyoung0/JeongJaeyoung0.github.io2 | c99353a5ac7158d24a55e452e2604e1bde7e8b7e | [
"MIT"
] | null | null | null | _posts/2022-01-18-ST-MinioGuide.md | JeongJaeyoung0/JeongJaeyoung0.github.io2 | c99353a5ac7158d24a55e452e2604e1bde7e8b7e | [
"MIT"
] | 1 | 2021-09-08T02:12:39.000Z | 2021-09-08T02:12:39.000Z | ---
layout: post
title: "[Storage] miniO 가이드"
subtitle: "MinioGuide"
categories: other
tags: minio
comments: true
---
# miniO guide
## miniO 설치 및 설정
1. minio server 폴더 생성
```
mkdir D:/minio
cd D:/minio
```
2. miniO 다운로드
- https://min.io/download#/windows
- D:\minio 에 다운로드
3. miniO 설정
```
D:\minio\minio.exe server D:\minio --console-address ":9001"
```
4. API 주소에 들어가서 로그인
- API: {http://192...}
- RootUser: minioadmin
- RootPass: minioadmin
5. Create Bucket
6. Create User
- 권한 부여(Policy)
* * *
## 데이터 송수신 방법
1. S3 Browser 설치
2. Account 추가
- Accounts > Add new accounts
- Display name: {name 입력}
- Account type: S3 Compatible Storage
- REST Endpoint: {minio 4번의 API 주소 입력}
- Access Key ID: {User ID}
- Secret Access Key: {Use Key}
- Use secure transfer (SSL/TLS): 체크 여부 확인 {test용 pc는 해제해도 됨}
3. Account > Display name 클릭 | 17.352941 | 64 | 0.630508 | kor_Hang | 0.987374 |
474af4577c9dc01b0f3ea0fa3902c2e8c98b1220 | 10,124 | markdown | Markdown | README.markdown | helloandrey/vim-wordy-rus | bee071d3969dcb23e8716d9cf6ee5da9607d974a | [
"MIT"
] | null | null | null | README.markdown | helloandrey/vim-wordy-rus | bee071d3969dcb23e8716d9cf6ee5da9607d974a | [
"MIT"
] | null | null | null | README.markdown | helloandrey/vim-wordy-rus | bee071d3969dcb23e8716d9cf6ee5da9607d974a | [
"MIT"
] | null | null | null | # vim-wordy
> Uncover usage problems in your writing
<br/>
- - -
- - -
## Features of the _wordy_ plugin
* Pure Vimscript; no external services or libraries needed
* Uses Vim’s native spell-check engine
* Includes 16 dictionaries covering different types of word usage
* Buffer-scoped configuration (leaves your global settings alone)
* Unicode-friendly, including support for ‘typographic quotes’
* User-configurable ring of dictionaries
* *NEW* adjectives and adverbs, to help you detect overuse
## What is _wordy_?
_wordy_ is not a grammar checker. Nor is it a guide to proper word usage.
Rather, _wordy_ is a lightweight tool to assist you in identifying
those words and phrases known for their history of misuse, abuse, and
overuse, at least according to usage experts.
For example, if _wordy_ highlights `moreover` in your document, a word for
which no good usage exists, you should consider a rewrite to eliminate it.
But if _wordy_ highlights `therefore` in a sentence where you can demonstrate
the usage is sound, you can elect to keep it —_wordy_ be damned.
## Why _wordy_?
Off-the-shelf proofreading software can scan your text for potential problems
and provide comprehensive feedback. However, it may require a complex
software installation or transmission of your work to a remote server for
checking.
_wordy_ stands ready as a simple alternative to these comprehensive tools,
focusing narrowly on identifying potential problems that might otherwise
be missed. To compensate for _wordy_’s bare-bones approach, it’s best used
in concert with the [literature on usage][lit] (Strunk and White, e.g.)
and websites like the [English Language & Usage Stack Exchange][ese].
[lit]: http://www.amazon.com/s/ref=nb_sb_noss_2?url=search-alias%3Dstripbooks&field-keywords=English+Usage
[ese]: http://english.stackexchange.com
## Requirements
_wordy_ may require a recent version of Vim.
## Installation
_wordy_ is best installed using a Vim package manager, such as
[Vundle][vnd], [Plug][plg], [NeoBundle][nbn], or [Pathogen][pth].
[vnd]: https://github.com/gmarik/Vundle.vim
[plg]: https://github.com/junegunn/vim-plug
[nbn]: https://github.com/Shougo/neobundle.vim
[pth]: https://github.com/tpope/vim-pathogen
## Configuration
### On demand
Using this plugin’s commands does not require any special configuration.
Important note: on the first use of each of the plugin’s dictionaries,
a spell file will be built. This produces a message that resembles:
```
Reading word file /Users/reede/.vim/bundle/vim-wordy/data/en/weasel.dic ...
Compressing word tree...
Compressed 618 of 1738 nodes; 1120 (64%) remaining
Writing spell file /Users/reede/.vim/bundle/vim-wordy/spell/weasel.en.utf-8.spl ...
Done!
Estimated runtime memory use: 5600 bytes
Press ENTER or type command to continue
```
As instructed, press the enter key and it will disturb you no longer, at
least until _wordy_ feels the urge to build again.
### Ring navigation
Define your own ring of dictionaries, overriding the default one in your
`.vimrc`:
```vim
let g:wordy#ring = [
\ 'weak',
\ ['being', 'passive-voice', ],
\ 'business-jargon',
\ 'weasel',
\ 'puffery',
\ ['problematic', 'redundant', ],
\ ['colloquial', 'idiomatic', 'similies', ],
\ 'art-jargon',
\ ['contractions', 'opinion', 'vague-time', 'said-synonyms', ],
\ 'adjectives',
\ 'adverbs',
\ ]
```
You can navigate the ring with the following commands:
```vim
:NextWordy
:PrevWordy
```
Optionally map a key in your `.vimrc` to rapidly cycle through the
ring's dictionaries:
```vim
noremap <silent> <F8> :<C-u>NextWordy<cr>
xnoremap <silent> <F8> :<C-u>NextWordy<cr>
inoremap <silent> <F8> <C-o>:NextWordy<cr>
```
You can browse through a flattened list of dictionaries
specified in your ring with:
```vim
:Wordy <tab>
```
and optionally map a key such as `\w` in your `.vimrc` to it by
```vim
if !&wildcharm | set wildcharm=<C-z> | endif
execute 'nnoremap <leader>w :Wordy<space>'.nr2char(&wildcharm)
```
## Using _wordy_
You’ll use the commands that follow to enable _wordy_. To disable it and
restore your previous spell environment, enter the command:
```vim
:NoWordy
```
Use Vim’s _Normal_ mode commands for navigating misspelled words to
go to those words flagged by _wordy_.
* `]s` - Move to next misspelled word after the cursor.
* `[s` - Like `]s` but search backwards
### Weak and lazy usage
```vim
:Wordy weak
```
Weak and lazy words are common in first drafts.
We sabotage our writing though weak language, kicking the legs out from
beneath our verbs and tearing at the foundations of our nouns, watering
down the very points that we are trying to drive home.
* “I _got_ up at precisely 8 AM.” (weak)
* “I woke up at precisely 8 AM.” (better)
We diminish the weight of our ideas by adding modifiers and fillers.
* “That night was _perhaps_ the most important moment of my life, and I don't _think_ I'll ever forget it.” (weak)
* “That night was the most important moment of my life, and I'll never forget it.” (better)
Words can also be weakened through overuse.
* “He _actually_ drove to work in the blizzard.” (weak)
* “He drove to work in spite of the blizzard.” (better)
When using this dictionary, scrutinize each highlighted word or phrase,
asking whether it detracts from the point you are trying to make.
### Redundant and problematic usage
```vim
:Wordy redundant
:Wordy problematic
```
Did you ever receive an ‘advance warning’ when a mere warning would do?
Why plan when you can ‘plan ahead’? Why need a thought to ‘occur to you’
when the thought can merely ‘occur’?
But redundancies may not actually be redundant: ‘invited guests’ may not
if some of the guests have crashed your event. Or dialect differences can
erase redundancies, as the British will ‘protest against’ where Americans
will simply ‘protest’.
See [50 Problem Words and Phrases][1] for more detail on those issues
targeted by _problematic_.
[1]: http://www.dailywritingtips.com/50-problem-words-and-phrases/
### Puffery and Jargon
> “The man embodies _authenticity_; his _disruptive_ ideas on
> _self-actualization_ reflect his _dynamic_ and _transformative_
> personality.” (puffery and jargon)
```vim
:Wordy puffery
:Wordy business-jargon
:Wordy art-jargon
```
Instead of puffery, demonstrate through details.
* “The Empire State Building is _breathtakingly_ tall.” (puffery)
* “My ears popped several times during the rapid ascent to the 80th
floor.” (better)
### Manipulative language
```vim
:Wordy weasel
```
Words can be used to hide or obscure a weak position, or to cast doubt on
a strong one. They can be used to mislead, to evade blame, or to claim credit
where none has been earned.
* “mistakes were made”
* “discounted up to 50% off”
* “most voters feel that my opponent can’t be trusted”
Assuming that you’re not intentionally trying to manipulate others, you
will seek to purge such loaded language from your writing.
### To be and the passive voice
```vim
:Wordy being
:Wordy passive-voice
```
You may find this dictionary useful in avoiding overuse of the many forms
of the verb to be, often found in overly-passive sentences.
### Colloquialisms, Idioms, and Similies
```vim
:Wordy colloquial
:Wordy idiomatic
:Wordy similies
```
Dictionaries for uncovering the tired cliché, including colloquial and
idiomatic phrases scraped from Wiktionary and Wikipedia.
### Adjectives and Adverbs
```vim
:Wordy adjectives
:Wordy adverbs
```
Dictionaries to help you detect the overuse of modifiers.
### Miscellaneous
```vim
:Wordy said-synonyms
:Wordy opinion
:Wordy contractions
:Wordy vague-time
```
A few dictionaries to serve specific needs.
If you’re writing to be neutral, you will want to avoid editorializing
(`opinion`) and loaded use of ‘said’ (`said-synonyms`).
If you’re writing formally, you’ll want to identify unintentional
contractions with `contractions`. A warning that it’s not yet capturing most
instances of “’s”, such as “Joe’s not here.”
And finally, `vague-time` finds where you are using vague descriptions of
time where you could be more specific.
## See also
* [danielbmarques/vim-ditto][vd] - new plugin to highlight repeated words
* [Words To Avoid in Creative Writing][wa] - a brief guide to usage by writer Cary Morton
[vd]: https://github.com/danielbmarques/vim-ditto
[wa]: http://darlingmionette.deviantart.com/art/Words-To-Avoid-152886782
If you find this plugin useful, you may want to check out these others by
[@reedes][re]:
* [vim-colors-pencil][cp] - color scheme for Vim inspired by IA Writer
* [vim-lexical][lx] - building on Vim’s spell-check and thesaurus/dictionary completion
* [vim-litecorrect][lc] - lightweight auto-correction for Vim
* [vim-one][vo] - make use of Vim’s _+clientserver_ capabilities
* [vim-pencil][pn] - rethinking Vim as a tool for writers
* [vim-textobj-quote][qu] - extends Vim to support typographic (‘curly’) quotes
* [vim-textobj-sentence][ts] - improving on Vim's native sentence motion command
* [vim-thematic][th] - modify Vim’s appearance to suit your task and environment
* [vim-wheel][wh] - screen-anchored cursor movement for Vim
* [vim-wordchipper][wc] - power tool for shredding text in Insert mode
[re]: https://github.com/reedes
[cp]: http://github.com/reedes/vim-colors-pencil
[lx]: http://github.com/reedes/vim-lexical
[lc]: http://github.com/reedes/vim-litecorrect
[vo]: http://github.com/reedes/vim-one
[pn]: http://github.com/reedes/vim-pencil
[ts]: http://github.com/reedes/vim-textobj-sentence
[qu]: http://github.com/reedes/vim-textobj-quote
[th]: http://github.com/reedes/vim-thematic
[wh]: http://github.com/reedes/vim-wheel
[wc]: http://github.com/reedes/vim-wordchipper
## Future development
This early version targets English usage issues and utf-8 encoding.
Support for other languages will be added if there’s interest. (Hint: pull
requests!)
_wordy_ is a work in progress. If you’ve spotted a problem or have an idea
on improving this plugin, please post it to the github project issue page.
Contributions are welcome.
<!-- vim: set tw=74 :-->
| 30.586103 | 114 | 0.747432 | eng_Latn | 0.988484 |
474afd6e8ab0cb466eb6f4e54319a4110cf81b83 | 3,965 | md | Markdown | docs/access/desktop-database-reference/relation-foreigntable-property-dao.md | isabella232/office-developer-client-docs.de-DE | f244ed2fdf76004aaef1de6b6c24b8b1c5a6942e | [
"CC-BY-4.0",
"MIT"
] | 2 | 2020-05-19T18:52:16.000Z | 2021-04-21T00:13:46.000Z | docs/access/desktop-database-reference/relation-foreigntable-property-dao.md | MicrosoftDocs/office-developer-client-docs.de-DE | f244ed2fdf76004aaef1de6b6c24b8b1c5a6942e | [
"CC-BY-4.0",
"MIT"
] | 2 | 2021-12-08T03:25:19.000Z | 2021-12-08T03:43:48.000Z | docs/access/desktop-database-reference/relation-foreigntable-property-dao.md | isabella232/office-developer-client-docs.de-DE | f244ed2fdf76004aaef1de6b6c24b8b1c5a6942e | [
"CC-BY-4.0",
"MIT"
] | 5 | 2018-07-17T08:19:45.000Z | 2021-10-13T10:29:41.000Z | ---
title: Relation.ForeignTable-Eigenschaft (DAO)
TOCTitle: ForeignTable Property
ms:assetid: 3f896433-2962-1c7c-f5a2-4e030ba8d4a0
ms:mtpsurl: https://msdn.microsoft.com/library/Ff192853(v=office.15)
ms:contentKeyID: 48544401
ms.date: 09/18/2015
mtps_version: v=office.15
f1_keywords:
- dao360.chm1052989
f1_categories:
- Office.Version=v15
ms.localizationpriority: medium
ms.openlocfilehash: 1b07593eb696a15cb37383ff81f03fbc1a35509a
ms.sourcegitcommit: a1d9041c20256616c9c183f7d1049142a7ac6991
ms.translationtype: MT
ms.contentlocale: de-DE
ms.lasthandoff: 09/24/2021
ms.locfileid: "59617517"
---
# <a name="relationforeigntable-property-dao"></a>Relation.ForeignTable-Eigenschaft (DAO)
**Gilt für**: Access 2013, Office 2013
Legt den Namen der Fremdtabelle in einer Beziehung fest oder gibt den Namen zurück (gilt nur für Microsoft Access-Arbeitsbereiche).
## <a name="syntax"></a>Syntax
*Ausdruck* . ForeignTable
*Ausdruck* Eine Variable, die ein **Relation -Objekt** darstellt.
## <a name="remarks"></a>Bemerkungen
Für diese Eigenschaft besteht bei einem neuen **[Relation](relation-object-dao.md)** -Objekt, das noch keiner Auflistung angefügt wurde, Lese-/Schreibzugriff, und bei einem vorhandenen **Relation**-Objekt in der **[Relations](relations-collection-dao.md)** -Auflistung ist sie schreibgeschützt.
Die Einstellung der **ForeignTable**-Eigenschaft eines **Relation**-Objekts ist die Einstellung der **[Name](connection-name-property-dao.md)** -Eigenschaft des **[TableDef](tabledef-object-dao.md)** - oder **[QueryDef](querydef-object-dao.md)** -Objekts, das die Fremdtabelle oder Abfrage darstellt. Die Einstellung der **[Table](relation-table-property-dao.md)** -Eigenschaft ist die Einstellung der **Name**-Eigenschaft des **TableDef**- oder **QueryDef**-Objekts, das die Primärtabelle oder Abfrage darstellt.
For example, if you had a list of valid part codes (in a field named PartNo) stored in a ValidParts table, you could establish a relationship with an OrderItem table such that if a part code were entered into the OrderItem table, it would have to already be in the ValidParts table. If the part code didn't exist in the ValidParts table and you had not set the **[Attributes](field-attributes-property-dao.md)** property of the **Relation** object to **dbRelationDontEnforce**, a trappable error would occur.
In this case, the ValidParts table is the primary table, so the **Table** property of the **Relation** object would be set to ValidParts and the **ForeignTable** property of the **Relation** object would be set to OrderItem. The **Name** and **ForeignName** properties of the **Field** object in the **Relation** object's **Fields** collection would be set to PartNo.
## <a name="example"></a>Beispiel
In diesem Beispiel wird gezeigt, wie die Eigenschaften **Table**, **ForeignTable** und **ForeignName** die Beziehungen eines **Relation**-Objekts zwischen zwei Tabellen definieren.
```vb
Sub ForeignNameX()
Dim dbsNorthwind As Database
Dim relLoop As Relation
Set dbsNorthwind = OpenDatabase("Northwind.mdb")
Debug.Print "Relation"
Debug.Print " Table - Field"
Debug.Print " Primary (One) ";
Debug.Print ".Table - .Fields(0).Name"
Debug.Print " Foreign (Many) ";
Debug.Print ".ForeignTable - .Fields(0).ForeignName"
' Enumerate the Relations collection of the Northwind
' database to report on the property values of
' the Relation objects and their Field objects.
For Each relLoop In dbsNorthwind.Relations
With relLoop
Debug.Print
Debug.Print .Name & " Relation"
Debug.Print " Table - Field"
Debug.Print " Primary (One) ";
Debug.Print .Table & " - " & .Fields(0).Name
Debug.Print " Foreign (Many) ";
Debug.Print .ForeignTable & " - " & _
.Fields(0).ForeignName
End With
Next relLoop
dbsNorthwind.Close
End Sub
```
| 47.771084 | 513 | 0.727112 | deu_Latn | 0.368814 |
474b87fa8208706c6c0a96b7809d433a2b4446b5 | 3,834 | md | Markdown | docs/pipelines/artifacts/pypi.md | malyons/vsts-docs | c7e66e44dc14f046ecb4e7cfd5cd145613fac58f | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/pipelines/artifacts/pypi.md | malyons/vsts-docs | c7e66e44dc14f046ecb4e7cfd5cd145613fac58f | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/pipelines/artifacts/pypi.md | malyons/vsts-docs | c7e66e44dc14f046ecb4e7cfd5cd145613fac58f | [
"CC-BY-4.0",
"MIT"
] | 2 | 2021-12-06T12:36:31.000Z | 2022-02-16T08:48:36.000Z | ---
title: Publish packages to PyPI
ms.custom: seodec18
description: Publish Python packages to PyPI or Azure Artifacts feeds via builds with Azure Pipelines
services: vsts
ms.prod: devops
ms.technology: devops-cicd
ms.topic: conceptual
ms.manager: jillfra
ms.author: elbatk
ms.date: 10/31/2018
monikerRange: 'azure-devops'
---
# Publish Python packages in Azure Pipelines
**Azure Pipelines**
> [!NOTE]
> Python package publishing in Azure Pipelines is currently in public preview.
You can publish Python packages produced by your build to:
* Azure Artifacts
* Other repositories such as `https://pypi.org/`
To publish Python packages produced by your build, you'll use [twine](https://pypi.org/project/twine/), a widely used tool for publishing Python packages. This guide covers how to do the following in your pipeline:
0. Install `twine` on your build agent
1. Authenticate `twine` with your Azure Artifacts feeds
2. Use a custom task that invokes `twine` to publish your Python packages
## Install twine
First, you'll need to run `pip install twine` to ensure the build agent has `twine` installed.
#### [YAML](#tab/yaml/)
```yaml
- script: 'pip install twine'
```
Check out the [script YAML task reference](../yaml-schema.md#script) for the schema for this command.
#### [Classic](#tab/classic/)
 **Utility: Powershell**
* Type
```
inline
```
* Script
```
pip install twine
```
* * *
## Authenticate Azure Artifacts with twine
To use `twine` to publish Python packages, you first need to set up authentication. The [Python Twine Authenticate](../tasks/package/twine-authenticate.md) task stores your authentication credentials in an environment variable (`PYPIRC_PATH`). `twine` will reference this variable later.
# [YAML](#tab/yaml)
To authenticate with `twine`, add the following snippet to your _azure-pipelines.yml_ file.
```yaml
- task: TwineAuthenticate@0
inputs:
artifactFeeds: 'feed_name1, feed_name2'
externalFeeds: 'feed_name1, feed_name2'
```
* **artifactFeeds**: the name of one or more Azure Artifacts feeds within your organization
* **externalFeeds**: the name of one or more [external connection endpoints](/azure/devops/pipelines/library/service-endpoints), including PyPI or feeds in other organizations in Azure DevOps
# [Classic](#tab/classic)
 **Package: Python Twine Upload Authenticate**
* My feeds
Select feeds that you want to authenticate with `twine`.
* Feeds from external organizations
Select feeds from outside the organization that you want to authenticate with `twine`.
---
## Use a custom twine task to publish
After you've set up authentication with the preceding snippet, you can use `twine` to publish your Python packages. The following example uses a custom command-line task.
# [YAML](#tab/yaml)
```yaml
- script: 'twine upload -r {feedName/EndpointName} --config-file $(PYPIRC_PATH) {package path to publish}'
```
Check out the [script YAML task reference](../yaml-schema.md#script) for the schema for this command.
# [Classic](#tab/classic)
 **Utility: Powershell**
* Type:
```
inline
```
* Script:
```
twine upload -r {feedName/EndpointName} --config-file $(PYPIRC_PATH) dist/*
```
---
## Tips and FAQs
* The authentication credentials written into the `PYPIRC_PATH` environment variable supersede those in your .ini and .conf files.
2. If you add multiple Python Twine Authenticate tasks at different times in your pipeline steps, each additional build task execution will extend (not override) the existing `PYPIRC_PATH` environment variable.
3. Lastly, we strongly recommend **NOT** checking into source control any credentials or tokens.
| 29.953125 | 287 | 0.742045 | eng_Latn | 0.983565 |
474bb71afc98ac79c290184ddbaf31ebe36fa5c6 | 328 | md | Markdown | _posts/pubs/2016-02-25-electron.md | cherylepatrick/cpatrick-website | 6162aa1a098a336c54917832f14488de201fb807 | [
"MIT"
] | null | null | null | _posts/pubs/2016-02-25-electron.md | cherylepatrick/cpatrick-website | 6162aa1a098a336c54917832f14488de201fb807 | [
"MIT"
] | null | null | null | _posts/pubs/2016-02-25-electron.md | cherylepatrick/cpatrick-website | 6162aa1a098a336c54917832f14488de201fb807 | [
"MIT"
] | null | null | null | ---
title: "Measurement of Electron Neutrino Quasielastic and Quasielasticlike Scattering on Hydrocarbon at E$_ν$ = 3.6 GeV"
by: "J. Wolcott et al (MINERvA collaboration)"
date: 2016-02-25 00:00:00 +0000
arxiv: 1509.05729
doi: 10.1103/PhysRevLett.116.081802
journal: "Phys. Rev. Lett. 116, 081802"
categories: papers
---
| 27.333333 | 121 | 0.731707 | eng_Latn | 0.192094 |
474be02fcf0ce6d9a6d1b757cb44b2184909370c | 64 | md | Markdown | stories/LayoutComponent/docs/Esempi.md | Pratyush1197/design-react-kit | bf6a874bf103abf7076f03465187a945452e03d7 | [
"BSD-3-Clause"
] | 119 | 2018-04-18T09:35:37.000Z | 2022-03-31T11:54:07.000Z | stories/LayoutComponent/docs/Esempi.md | Pratyush1197/design-react-kit | bf6a874bf103abf7076f03465187a945452e03d7 | [
"BSD-3-Clause"
] | 656 | 2018-05-21T08:29:36.000Z | 2022-03-31T18:12:20.000Z | stories/LayoutComponent/docs/Esempi.md | Pratyush1197/design-react-kit | bf6a874bf103abf7076f03465187a945452e03d7 | [
"BSD-3-Clause"
] | 96 | 2018-04-18T09:35:38.000Z | 2022-02-16T19:39:58.000Z | A depiction of Layout Components such as Row, Col and Container. | 64 | 64 | 0.8125 | eng_Latn | 0.999709 |
474c0d9b15313129afb77967741adc1c13d9dce2 | 4,344 | md | Markdown | docs/2014/reporting-services/report-server-web-service-net-framework-soap-headers/setting-the-item-namespace-for-the-getproperties-method.md | moonloverx2/sql-docs.zh-cn | cf2b82125dc2651da559e4f5e5805f1766f0e71a | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/2014/reporting-services/report-server-web-service-net-framework-soap-headers/setting-the-item-namespace-for-the-getproperties-method.md | moonloverx2/sql-docs.zh-cn | cf2b82125dc2651da559e4f5e5805f1766f0e71a | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/2014/reporting-services/report-server-web-service-net-framework-soap-headers/setting-the-item-namespace-for-the-getproperties-method.md | moonloverx2/sql-docs.zh-cn | cf2b82125dc2651da559e4f5e5805f1766f0e71a | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: 为 GetProperties 方法设置项命名空间 | Microsoft Docs
ms.custom: ''
ms.date: 06/13/2017
ms.prod: sql-server-2014
ms.reviewer: ''
ms.technology:
- docset-sql-devref
- reporting-services-native
ms.topic: reference
helpviewer_keywords:
- item properties [Reporting Services]
- ItemNamespaceHeader SOAP header
- GetProperties method
ms.assetid: b0a08639-3101-40a2-abe2-3a41753826d1
author: markingmyname
ms.author: maghan
manager: craigg
ms.openlocfilehash: 3f8c3926da14f0b00c0b62b8dd8597867186d0bc
ms.sourcegitcommit: 3da2edf82763852cff6772a1a282ace3034b4936
ms.translationtype: MT
ms.contentlocale: zh-CN
ms.lasthandoff: 10/02/2018
ms.locfileid: "48206077"
---
# <a name="setting-the-item-namespace-for-the-getproperties-method"></a>为 GetProperties 方法设置项命名空间
可以根据两个不同的项标识符在 [!INCLUDE[ssRSnoversion](../../includes/ssrsnoversion-md.md)] 中使用 <xref:ReportService2010.ItemNamespaceHeader> SOAP 标头：项的完整路径或项的 ID。
当您调用 <xref:ReportService2010.ReportingService2010.GetProperties%2A> 方法时，通常将要检索其属性的项的完整路径作为参数传递。 使用 <xref:ReportService2010.ItemNamespaceHeader>，您可以为方法调用设置 SOAP 标头，以便通过将项的 ID 作为标识符传递来使用 <xref:ReportService2010.ReportingService2010.GetProperties%2A>。
以下代码示例根据项的 ID 检索项属性的值。
> [!NOTE]
> 默认情况下，如果您将完整路径名称作为项标识符传递到 <xref:ReportService2010.ItemNamespaceHeader> 方法，则不需要为 <xref:ReportService2010.ReportingService2010.GetProperties%2A> 设置值。
```vb
Imports System
Imports System.Collections
Class Sample
Sub Main()
Dim rs As New ReportingService2010()
rs.Credentials = System.Net.CredentialCache.DefaultCredentials
rs.Url = "http://<Server Name>/reportserver/ReportService2010.asmx"
Dim items() As CatalogItem
Try
' Need the ID property of items. Normally, you would already have
' this stored somewhere.
items = rs.ListChildren("/AdventureWorks Sample Reports", False)
' Set the item namespace header to be GUID-based
rs.ItemNamespaceHeaderValue = New ItemNamespaceHeader()
rs.ItemNamespaceHeaderValue.ItemNamespace = ItemNamespaceEnum.GUIDBased
' Call GetProperties with item ID.
If Not (items Is Nothing) Then
Dim item As CatalogItem
For Each item In items
Dim properties As [Property]() = rs.GetProperties(item.ID, Nothing)
Dim property As [Property]
For Each property In properties
Console.WriteLine(([property].Name + ": " + [property].Value))
Next property
Console.WriteLine()
Next item
End If
Catch e As Exception
Console.WriteLine((e.Message + ": " + e.StackTrace))
End Try
End Sub 'Main
End Class 'Sample
```
```csharp
using System;
using System.Collections;
class Sample
{
static void Main()
{
ReportingService2010 rs = new ReportingService2010();
rs.Credentials = System.Net.CredentialCache.DefaultCredentials;
rs.Url = "http://<Server Name>/reportserver/ReportService2010.asmx";
CatalogItem[] items;
try
{
// Need the ID property of items. Normally, you would already have
// this stored somewhere.
items = rs.ListChildren("/AdventureWorks Sample Reports", false);
// Set the item namespace header to be GUID-based
rs.ItemNamespaceHeaderValue = new ItemNamespaceHeader();
rs.ItemNamespaceHeaderValue.ItemNamespace = ItemNamespaceEnum.GUIDBased;
// Call GetProperties with item ID.
if (items != null)
{
foreach( CatalogItem item in items)
{
Property[] properties = rs.GetProperties(item.ID, null);
foreach (Property property in properties)
{
Console.WriteLine(property.Name + ": " + property.Value);
}
Console.WriteLine();
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
```
## <a name="see-also"></a>请参阅
[技术参考 (SSRS)](../technical-reference-ssrs.md)
[使用 Reporting Services SOAP 标头](using-reporting-services-soap-headers.md)
| 33.674419 | 251 | 0.644337 | yue_Hant | 0.654758 |
474c4e9c54daaf6690760308f45d3c85b9ee7730 | 5,339 | md | Markdown | daprdocs/content/en/reference/components-reference/supported-bindings/http.md | jasonviviano/docs | a941868ca1b4590c690f84bc9a949ba097fce2fa | [
"MIT"
] | null | null | null | daprdocs/content/en/reference/components-reference/supported-bindings/http.md | jasonviviano/docs | a941868ca1b4590c690f84bc9a949ba097fce2fa | [
"MIT"
] | null | null | null | daprdocs/content/en/reference/components-reference/supported-bindings/http.md | jasonviviano/docs | a941868ca1b4590c690f84bc9a949ba097fce2fa | [
"MIT"
] | null | null | null | ---
type: docs
title: "HTTP binding spec"
linkTitle: "HTTP"
description: "Detailed documentation on the HTTP binding component"
aliases:
- "/operations/components/setup-bindings/supported-bindings/http/"
---
## Setup Dapr component
```yaml
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
name: <NAME>
namespace: <NAMESPACE>
spec:
type: bindings.http
version: v1
metadata:
- name: url
value: http://something.com
```
## Spec metadata fields
| Field | Required | Binding support | Details | Example |
|--------------------|:--------:|--------|--------|---------|
| url | Y | Output |The base URL of the HTTP endpoint to invoke | `http://host:port/path`, `http://myservice:8000/customers`
## Binding support
This component supports **output binding** with the folowing [HTTP methods/verbs](https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html):
- `create` : For backward compatability and treated like a post
- `get` : Read data/records
- `head` : Identical to get except that the server does not return a response body
- `post` : Typically used to create records or send commands
- `put` : Update data/records
- `patch` : Sometimes used to update a subset of fields of a record
- `delete` : Delete a data/record
- `options` : Requests for information about the communication options available (not commonly used)
- `trace` : Used to invoke a remote, application-layer loop- back of the request message (not commonly used)
### Request
#### Operation metadata fields
All of the operations above support the following metadata fields
| Field | Required | Details | Example |
|--------------------|:--------:|---------|---------|
| path | N | The path to append to the base URL. Used for accessing specific URIs | `"/1234"`, `"/search?lastName=Jones"`
| Headers* | N | Any fields that have a capital first letter are sent as request headers | `"Content-Type"`, `"Accept"`
#### Retrieving data
To retrieve data from the HTTP endpoint, invoke the HTTP binding with a `GET` method and the following JSON body:
```json
{
"operation": "get"
}
```
Optionally, a path can be specified to interact with resource URIs:
```json
{
"operation": "get",
"metadata": {
"path": "/things/1234"
}
}
```
### Response
The response body contains the data returned by the HTTP endpoint. The `data` field contains the HTTP response body as a byte slice (Base64 encoded via curl). The `metadata` field contains:
| Field | Required | Details | Example |
|--------------------|:--------:|---------|---------|
| statusCode | Y | The [HTTP status code](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html) | `200`, `404`, `503`
| status | Y | The status description | `"200 OK"`, `"201 Created"`
| Headers* | N | Any fields that have a capital first letter are sent as request headers | `"Content-Type"`
#### Example
**Requesting the base URL**
{{< tabs Windows Linux >}}
{{% codetab %}}
```bash
curl -d "{ \"operation\": \"get\" }" \
http://localhost:<dapr-port>/v1.0/bindings/<binding-name>
```
{{% /codetab %}}
{{% codetab %}}
```bash
curl -d '{ "operation": "get" }' \
http://localhost:<dapr-port>/v1.0/bindings/<binding-name>
```
{{% /codetab %}}
{{< /tabs >}}
**Requesting a specific path**
{{< tabs Windows Linux >}}
{{% codetab %}}
```bash
curl -d "{ \"operation\": \"get\", \"metadata\": { \"path\": \"/things/1234\" } }" \
http://localhost:<dapr-port>/v1.0/bindings/<binding-name>
```
{{% /codetab %}}
{{% codetab %}}
```bash
curl -d '{ "operation": "get", "metadata": { "path": "/things/1234" } }' \
http://localhost:<dapr-port>/v1.0/bindings/<binding-name>
```
{{% /codetab %}}
{{< /tabs >}}
### Sending and updating data
To send data to the HTTP endpoint, invoke the HTTP binding with a `POST`, `PUT`, or `PATCH` method and the following JSON body:
{{% alert title="Note" color="primary" %}}
Any metadata field that starts with a capital letter is passed as a request header.
For example, the default content type is `application/json; charset=utf-8`. This can be overriden be setting the `Content-Type` metadata field.
{{% /alert %}}
```json
{
"operation": "post",
"data": "content (default is JSON)",
"metadata": {
"path": "/things",
"Content-Type": "application/json; charset=utf-8"
}
}
```
#### Example
**Posting a new record**
{{< tabs Windows Linux >}}
{{% codetab %}}
```bash
curl -d "{ \"operation\": \"post\", \"data\": \"YOUR_BASE_64_CONTENT\", \"metadata\": { \"path\": \"/things\" } }" \
http://localhost:<dapr-port>/v1.0/bindings/<binding-name>
```
{{% /codetab %}}
{{% codetab %}}
```bash
curl -d '{ "operation": "post", "data": "YOUR_BASE_64_CONTENT", "metadata": { "path": "/things" } }' \
http://localhost:<dapr-port>/v1.0/bindings/<binding-name>
```
{{% /codetab %}}
{{< /tabs >}}
## Related links
- [Basic schema for a Dapr component]({{< ref component-schema >}})
- [Bindings building block]({{< ref bindings >}})
- [How-To: Trigger application with input binding]({{< ref howto-triggers.md >}})
- [How-To: Use bindings to interface with external resources]({{< ref howto-bindings.md >}})
- [Bindings API reference]({{< ref bindings_api.md >}})
| 29.826816 | 190 | 0.61903 | eng_Latn | 0.7617 |
474cfb37db0714da230f49c0f6f06eb197aaa10e | 122 | md | Markdown | README.md | sidemt/js-calculator | fecda89175a081cd525a746203e222a3a21bb101 | [
"MIT"
] | null | null | null | README.md | sidemt/js-calculator | fecda89175a081cd525a746203e222a3a21bb101 | [
"MIT"
] | null | null | null | README.md | sidemt/js-calculator | fecda89175a081cd525a746203e222a3a21bb101 | [
"MIT"
] | null | null | null | # js-calculator
Visit [https://sidemt.github.io/js-calculator/](https://sidemt.github.io/js-calculator/) to view the page
| 40.666667 | 105 | 0.754098 | kor_Hang | 0.387378 |
474d5939d9e3c74583be8e5bc9f85d7a6f6782e3 | 6,397 | md | Markdown | articles/service-fabric/how-to-deploy-service-fabric-application-system-assigned-managed-identity.md | chclaus/azure-docs.de-de | 38be052bda16366997a146cf5589168d6c6f3387 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/service-fabric/how-to-deploy-service-fabric-application-system-assigned-managed-identity.md | chclaus/azure-docs.de-de | 38be052bda16366997a146cf5589168d6c6f3387 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | articles/service-fabric/how-to-deploy-service-fabric-application-system-assigned-managed-identity.md | chclaus/azure-docs.de-de | 38be052bda16366997a146cf5589168d6c6f3387 | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
title: 'Azure Service Fabric: Bereitstellen einer Azure Service Fabric-Anwendung mit einer systemseitig zugewiesenen verwalteten Identität | Microsoft-Dokumentation'
description: In diesem Artikel erfahren Sie, wie Sie einer Azure Service Fabric-Anwendung eine systemseitig zugewiesene verwaltete Identität zuweisen.
services: service-fabric
author: athinanthny
ms.service: service-fabric
ms.topic: article
ms.date: 07/25/2019
ms.author: atsenthi
ms.openlocfilehash: cf04efd8dac3ba4d252701d79c65b1bf56619fe0
ms.sourcegitcommit: fbea2708aab06c19524583f7fbdf35e73274f657
ms.translationtype: HT
ms.contentlocale: de-DE
ms.lasthandoff: 09/13/2019
ms.locfileid: "70968239"
---
# <a name="deploy-service-fabric-application-with-system-assigned-managed-identity-preview"></a>Bereitstellen einer Service Fabric-Anwendung mit einer systemseitig zugewiesenen verwalteten Identität (Vorschau)
Um auf das Feature für verwaltete Identitäten für Azure Service Fabric-Anwendungen zugreifen zu können, müssen Sie zunächst den Tokendienst für verwaltete Identitäten im Cluster aktivieren. Dieser Dienst ist für die Authentifizierung von Service Fabric-Anwendungen anhand ihrer verwalteten Identitäten und für den Abruf von Zugriffstoken in deren Auftrag zuständig. Nachdem der Dienst aktiviert wurde, wird er in Service Fabric Explorer im Abschnitt **System** im linken Bereich unter dem Namen **fabric:/System/ManagedIdentityTokenService** neben anderen Systemdiensten angezeigt.
> [!NOTE]
> Die Bereitstellung von Service Fabric-Anwendungen mit verwalteten Identitäten wird ab der API-Version `"2019-06-01-preview"` unterstützt. Die gleiche API-Version kann auch für Anwendungstyp, Anwendungstypversion und die Dienstressourcen verwendet werden. Die unterstützte Mindestversion der Service Fabric-Runtime ist 6.5 CU2.
## <a name="system-assigned-managed-identity"></a>Systemseitig zugewiesene verwaltete Identität
### <a name="application-template"></a>Anwendungsvorlage
Wenn Sie eine Anwendung mit einer systemseitig zugewiesenen verwalteten Identität aktivieren möchten, fügen Sie der Anwendungsressource die Eigenschaft **identity** mit dem Typ **systemAssigned** hinzu, wie im folgenden Beispiel zu sehen:
```json
{
"apiVersion": "2019-06-01-preview",
"type": "Microsoft.ServiceFabric/clusters/applications",
"name": "[concat(parameters('clusterName'), '/', parameters('applicationName'))]",
"location": "[resourceGroup().location]",
"dependsOn": [
"[concat('Microsoft.ServiceFabric/clusters/', parameters('clusterName'), '/applicationTypes/', parameters('applicationTypeName'), '/versions/', parameters('applicationTypeVersion'))]"
],
"identity": {
"type" : "systemAssigned"
},
"properties": {
"typeName": "[parameters('applicationTypeName')]",
"typeVersion": "[parameters('applicationTypeVersion')]",
"parameters": {
}
}
}
```
Diese Eigenschaft deklariert (gegenüber Azure Resource Manager sowie gegenüber dem Anbieter der verwalteten Identität bzw. dem Service Fabric-Ressourcenanbieter), dass diese Ressource über eine implizite verwaltete Identität (vom Typ `system assigned`) verfügen soll.
### <a name="application-and-service-package"></a>Anwendungs- und Dienstpaket
1. Aktualisieren Sie das Anwendungsmanifest, um im Abschnitt **Principals** ein Element vom Typ **ManagedIdentity** mit einem einzelnen Eintrag hinzuzufügen, wie im Anschluss zu sehen:
**ApplicationManifest.xml**
```xml
<Principals>
<ManagedIdentities>
<ManagedIdentity Name="SystemAssigned" />
</ManagedIdentities>
</Principals>
```
Dadurch wird die der Anwendung zugewiesene Identität als Ressource einem Anzeigenamen zugeordnet, um die weitere Zuweisung zu den Diensten zu ermöglichen, aus denen sich die Anwendung zusammensetzt.
2. Fügen Sie im Abschnitt **ServiceManifestImport** für den Dienst, dem die verwaltete Identität zugewiesen wird, ein Element vom Typ **IdentityBindingPolicy** hinzu, wie hier gezeigt:
**ApplicationManifest.xml**
```xml
<ServiceManifestImport>
<Policies>
<IdentityBindingPolicy ServiceIdentityRef="WebAdmin" ApplicationIdentityRef="SystemAssigned" />
</Policies>
</ServiceManifestImport>
```
Dieses Element weist die Identität der Anwendung dem Dienst zu. Ohne diese Zuweisung kann der Dienst nicht auf die Identität der Anwendung zugreifen. Im obigen Codeausschnitt wird die Identität `SystemAssigned` (reserviertes Schlüsselwort) der Definition des Diensts unter dem Anzeigenamen `WebAdmin` zugeordnet.
3. Aktualisieren Sie das Dienstmanifest, um im Abschnitt **Resources** ein Element vom Typ **ManagedIdentity** hinzuzufügen, dessen Name dem Wert der Einstellung `ServiceIdentityRef` aus der Definition `IdentityBindingPolicy` im Anwendungsmanifest entspricht:
**ServiceManifest.xml**
```xml
<Resources>
...
<ManagedIdentities DefaultIdentity="WebAdmin">
<ManagedIdentity Name="WebAdmin" />
</ManagedIdentities>
</Resources>
```
Dies ist die gleiche Zuordnung einer Identität zu einem Dienst, die oben beschrieben wurde, diesmal allerdings aus der Perspektive der Dienstdefinition. Auf die Identität wird hier anhand ihres im Anwendungsmanifest deklarierten Anzeigenamens (`WebAdmin`) verwiesen.
## <a name="next-steps"></a>Nächste Schritte
* Machen Sie sich mit der [Unterstützung der verwalteten Identität](./concepts-managed-identity.md) in Azure Service Fabric vertraut.
* [Bereitstellen eines neuen](./configure-new-azure-service-fabric-enable-managed-identity.md) Azure Service Fabric-Clusters mit Unterstützung verwalteter Identitäten
* [Aktivieren von verwalteten Identitäten](./configure-existing-cluster-enable-managed-identity-token-service.md) in einem vorhandenen Azure Service Fabric-Cluster
* Nutzen Sie die [verwaltete Identität einer Service Fabric-Anwendung aus dem Quellcode](./how-to-managed-identity-service-fabric-app-code.md).
* [Stellen Sie eine Azure Service Fabric-Anwendung mit einer benutzerseitig zugewiesenen verwalteten Identität bereit.](./how-to-deploy-service-fabric-application-user-assigned-managed-identity.md)
* [Gewähren Sie einer Azure Service Fabric-Anwendung Zugriff auf andere Azure-Ressourcen.](./how-to-grant-access-other-resources.md)
| 62.715686 | 581 | 0.769423 | deu_Latn | 0.977927 |
474db4d1c4660454c24aad430cc77c85f98844e5 | 566 | md | Markdown | docs/Rules/AvoidUsingEmptyCatchBlock.md | rjmholt/PSScriptAnalyzer | 27b44e70572b7784eaf543fb1ef1fdcb47d611dc | [
"MIT"
] | null | null | null | docs/Rules/AvoidUsingEmptyCatchBlock.md | rjmholt/PSScriptAnalyzer | 27b44e70572b7784eaf543fb1ef1fdcb47d611dc | [
"MIT"
] | 4 | 2021-04-29T22:16:12.000Z | 2021-04-29T22:16:32.000Z | docs/Rules/AvoidUsingEmptyCatchBlock.md | rjmholt/PSScriptAnalyzer | 27b44e70572b7784eaf543fb1ef1fdcb47d611dc | [
"MIT"
] | 1 | 2021-05-15T20:15:48.000Z | 2021-05-15T20:15:48.000Z | # AvoidUsingEmptyCatchBlock
**Severity Level: Warning**
## Description
Empty catch blocks are considered a poor design choice because any errors occurring in a
`try` block cannot be handled.
## How
Use `Write-Error` or `throw` statements within the catch block.
## Example
### Wrong
```powershell
try
{
1/0
}
catch [DivideByZeroException]
{
}
```
### Correct
```powershell
try
{
1/0
}
catch [DivideByZeroException]
{
Write-Error "DivideByZeroException"
}
try
{
1/0
}
catch [DivideByZeroException]
{
throw "DivideByZeroException"
}
```
| 11.55102 | 88 | 0.696113 | eng_Latn | 0.593391 |
474e2d3a52eb1928ac58b6202b1322edc68b3964 | 1,456 | md | Markdown | doc/web/content/comics/ComicFury_ChristianHumberReloaded_edit.md | yasen-m/dosage | 81fe088621ad335cac2a53fcbc7b9b37f49ddce2 | [
"MIT"
] | null | null | null | doc/web/content/comics/ComicFury_ChristianHumberReloaded_edit.md | yasen-m/dosage | 81fe088621ad335cac2a53fcbc7b9b37f49ddce2 | [
"MIT"
] | null | null | null | doc/web/content/comics/ComicFury_ChristianHumberReloaded_edit.md | yasen-m/dosage | 81fe088621ad335cac2a53fcbc7b9b37f49ddce2 | [
"MIT"
] | null | null | null | title: Edit ComicFury/ChristianHumberReloaded
url: "/comics/ComicFury_ChristianHumberReloaded_edit.html"
---
Edit info for comic ComicFury/ChristianHumberReloaded
<form name="comic" action="http://gaepostmail.appspot.com/comic/" method="post">
<table class="comicinfo">
<tr>
<th>Description</th><td><textarea name="description" cols="40" rows="3">Once upon a time, an unpopular kid in a boarding school had his anime taken away and he turned to writing. He created what is simultaneously the worst and the best story ever created. This is that story's comic-book interpretation. You have been warned. Christian Humber Reloaded rips off/steals from every video game and anime ever made. Yes, even that one. It also has Bionicles. And Hitler. And it's supposed to be serious.</textarea></td>
</tr>
<tr>
<th>Website</th><td><input type="text" name="url" value="http://ChristianHumberReloaded.webcomic.ws/" size="40"/></td>
</tr>
<tr>
<th>Genre</th><td><input type="text" name="genre" value="Other" size="40"/></td>
</tr>
<tr>
<th>Language</th><td><input type="text" name="language" value="English" size="40"/></td>
</tr>
<tr>
<th>Adult content</th><td><input type="checkbox" name="adult" value="adult" /></td>
</tr>
<tr>
<th></th><td>
<input type="hidden" name="comic" value="ComicFury_ChristianHumberReloaded" />
<input type="submit" name="submit" value="Submit" />
</td>
</tr>
</table>
</form>
Back to the [comic](ComicFury_ChristianHumberReloaded.html).
| 44.121212 | 514 | 0.725962 | eng_Latn | 0.855105 |
474f33ff3ff751d77beca8d5a190de3f41d44da1 | 3,137 | md | Markdown | articles/fin-and-ops/get-started/client-faq.md | blackjoker17/dynamics-365-unified-operations-public | 7f588035158082e5f1acebd92402f19f5952fccb | [
"CC-BY-4.0",
"MIT"
] | 1 | 2020-12-03T17:44:14.000Z | 2020-12-03T17:44:14.000Z | articles/fin-and-ops/get-started/client-faq.md | blackjoker17/dynamics-365-unified-operations-public | 7f588035158082e5f1acebd92402f19f5952fccb | [
"CC-BY-4.0",
"MIT"
] | 1 | 2020-04-15T12:55:28.000Z | 2020-04-15T12:55:28.000Z | articles/fin-and-ops/get-started/client-faq.md | blackjoker17/dynamics-365-unified-operations-public | 7f588035158082e5f1acebd92402f19f5952fccb | [
"CC-BY-4.0",
"MIT"
] | 2 | 2018-08-05T21:52:13.000Z | 2018-12-07T20:45:08.000Z | ---
# required metadata
title: Finance and Operations client FAQ
description: This article provides answers to frequently asked questions about the Microsoft Dynamics 365 for Finance and Operations client.
author: jasongre
manager: AnnBe
ms.date: 10/23/2017
ms.topic: article
ms.prod:
ms.service: dynamics-ax-applications
ms.technology:
# optional metadata
# ms.search.form:
# ROBOTS:
audience: Application User
# ms.devlang:
ms.reviewer: sericks
ms.search.scope: Core, Operations
# ms.tgt_pltfrm:
ms.custom: 12334
ms.assetid: a9a57f0e-a67c-46b1-83c9-5d6350fb3b86
ms.search.region: Global
# ms.search.industry:
ms.author: jasongre
ms.search.validFrom: 2016-02-28
ms.dyn365.ops.version: AX 7.0.0
---
# Finance and Operations client FAQ
[!include[banner](../includes/banner.md)]
This article provides answers to frequently asked questions about the Microsoft Dynamics 365 for Finance and Operations client.
Why aren't symbols loaded when I use Finance and Operations?
-----------------------------------------------------------------
The security settings on your browser might prevent the symbols from being loaded correctly. To resolve this issue, try the following steps:
- If you're experiencing this issue in Internet Explorer, click **Tools**, and then click **Internet Options**. In the Internet Options dialog box, on the **Privacy** tab, click **Custom level**, and make sure the **Font download** option is selected.
- Otherwise, you might have to add the Finance and Operations site to the list of trusted sites.
## I miss the ribbon from Dynamics AX 2012. Can I keep Action Pane tabs open all the time?
We are planning to implement this feature soon. Users will then be able to choose to keep the tabs on Action Panes open all the time. Otherwise, the tabs will be collapsed when they aren't being used, to gain more screen space for the page.
## Why do I sometimes see different shortcut menus when I right click?
If you right-click in an editable field (or if text is selected), the browser's shortcut menu is displayed. This menu gives you access to the **Cut**, **Copy**, and **Paste** commands. We can't embed these commands into the Finance and Operations shortcut menus because, for security reasons, browsers don’t allow us to programmatically access the system clipboard.
If you right-click a field label or the value of a read-only control, you'll see the Finance and Operations shortcut menu.
To make keyboard access easier, we plan to implement a keyboard shortcut in the future that will open the Finance and Operations shortcut menu.
## Where is the View details functionality in Finance and Operations?
The **View details** option is available in a couple of ways:
- If a control has **View details** capabilities, and if the control has a value, that value is displayed as a hyperlink. You can click the hyperlink to open a page that contains additional details.
- **View details** is also an option on Finance and Operations shortcut menus. For more information about when Finance and Operations shortcut menus are displayed when you right-click, see the previous section.
| 46.820896 | 365 | 0.759005 | eng_Latn | 0.996715 |
474f53666390f7151d6419eaab7aa628755254a6 | 15,345 | md | Markdown | docs/standard-library/utility-operators.md | LouisJustinTALLOT/cpp-docs.fr-fr | 1e9a7185459b26b2a69659615453d9eda6a2f2db | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/standard-library/utility-operators.md | LouisJustinTALLOT/cpp-docs.fr-fr | 1e9a7185459b26b2a69659615453d9eda6a2f2db | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/standard-library/utility-operators.md | LouisJustinTALLOT/cpp-docs.fr-fr | 1e9a7185459b26b2a69659615453d9eda6a2f2db | [
"CC-BY-4.0",
"MIT"
] | null | null | null | ---
description: 'En savoir plus sur < : > opérateurs d’utilitaire'
title: '<utility>, opérateurs'
ms.date: 11/04/2016
f1_keywords:
- utility/std::operator!=
- utility/std::operator>
- utility/std::operator>=
- utility/std::operator<
- utility/std::operator<=
- utility/std::operator==
ms.assetid: a6617109-2cec-4a69-948f-6c87116eda5f
helpviewer_keywords:
- std::operator!= (utility)
- std::operator> (utility)
- std::operator>= (utility)
- std::operator< (utility)
- std::operator<= (utility)
- std::operator== (utility)
ms.openlocfilehash: 0db6f5b18708052964353687190295084886c928
ms.sourcegitcommit: d6af41e42699628c3e2e6063ec7b03931a49a098
ms.translationtype: MT
ms.contentlocale: fr-FR
ms.lasthandoff: 12/11/2020
ms.locfileid: "97153458"
---
# <a name="ltutilitygt-operators"></a><utility>, opérateurs
> [!NOTE]
> Les opérateurs utilisant `Type&` sont inclus sous `namespace rel_ops` .
## <a name="operator"></a><a name="op_neq"></a> opérateur ! =
Teste si l'objet pair situé à gauche de l'opérateur n'est pas égal à l'objet pair situé à droite.
```cpp
template <class Type>
constexpr bool operator!=(const Type& left, const Type& right);
template <class T, class U>
constexpr bool operator!=(const pair<T, U>& left, const pair<T, U>& right);
```
### <a name="parameters"></a>Paramètres
*gauche*\
Objet de type `pair`.
*Oui*\
Objet de type `pair`.
### <a name="return-value"></a>Valeur renvoyée
**`true`** Si les paires ne sont pas égales ; **`false`** si les paires sont égales.
### <a name="remarks"></a>Notes
Une paire est égale à une autre paire si chacun de leurs éléments respectifs sont égaux. Deux paires sont inégales si le premier ou le deuxième élément de l'une n'est pas égal à l'élément correspondant de l'autre paire.
### <a name="example"></a>Exemple
```cpp
// utility_op_ne.cpp
// compile with: /EHsc
#include <utility>
#include <iomanip>
#include <iostream>
int main( )
{
using namespace std;
pair <int, double> p1, p2, p3;
p1 = make_pair ( 10, 1.11e-1 );
p2 = make_pair ( 1000, 1.11e-3 );
p3 = make_pair ( 10, 1.11e-1 );
cout.precision ( 3 );
cout << "The pair p1 is: ( " << p1.first << ", "
<< p1.second << " )." << endl;
cout << "The pair p2 is: ( " << p2.first << ", "
<< p2.second << " )." << endl;
cout << "The pair p3 is: ( " << p3.first << ", "
<< p3.second << " )." << endl << endl;
if ( p1 != p2 )
cout << "The pairs p1 and p2 are not equal." << endl;
else
cout << "The pairs p1 and p2 are equal." << endl;
if ( p1 != p3 )
cout << "The pairs p1 and p3 are not equal." << endl;
else
cout << "The pairs p1 and p3 are equal." << endl;
}
```
```Output
The pair p1 is: ( 10, 0.111 ).
The pair p2 is: ( 1000, 0.00111 ).
The pair p3 is: ( 10, 0.111 ).
The pairs p1 and p2 are not equal.
The pairs p1 and p3 are equal.
```
## <a name="operator"></a><a name="op_eq_eq"></a> opérateur = =
Teste si l'objet pair situé à gauche de l'opérateur est égal à l'objet pair situé à droite.
```cpp
template <class T, class U>
constexpr bool operator==(const pair<T, U>& left, const pair<T, U>& right);
```
### <a name="parameters"></a>Paramètres
*gauche*\
Objet de type `pair`.
*Oui*\
Objet de type `pair`.
### <a name="return-value"></a>Valeur renvoyée
**`true`** Si les paires sont égales ; **`false`** si les `pair` s ne sont pas égaux.
### <a name="remarks"></a>Notes
Une paire est égale à une autre paire si chacun de leurs éléments respectifs sont égaux. La fonction retourne `left`. **tout d’abord** == `right` . **tout d’abord** && `left` . **seconde** == `right` . **seconde**. Deux paires sont inégales si le premier ou le deuxième élément de l'une n'est pas égal à l'élément correspondant de l'autre paire.
### <a name="example"></a>Exemple
```cpp
// utility_op_eq.cpp
// compile with: /EHsc
#include <utility>
#include <iomanip>
#include <iostream>
int main( )
{
using namespace std;
pair <int, double> p1, p2, p3;
p1 = make_pair ( 10, 1.11e-1 );
p2 = make_pair ( 1000, 1.11e-3 );
p3 = make_pair ( 10, 1.11e-1 );
cout.precision ( 3 );
cout << "The pair p1 is: ( " << p1.first << ", "
<< p1.second << " )." << endl;
cout << "The pair p2 is: ( " << p2.first << ", "
<< p2.second << " )." << endl;
cout << "The pair p3 is: ( " << p3.first << ", "
<< p3.second << " )." << endl << endl;
if ( p1 == p2 )
cout << "The pairs p1 and p2 are equal." << endl;
else
cout << "The pairs p1 and p2 are not equal." << endl;
if ( p1 == p3 )
cout << "The pairs p1 and p3 are equal." << endl;
else
cout << "The pairs p1 and p3 are not equal." << endl;
}
```
## <a name="operatorlt"></a><a name="op_lt"></a> and<
Teste si l'objet pair situé à gauche de l'opérateur est inférieur à l'objet pair situé à droite.
```cpp
template <class T, class U>
constexpr bool operator<(const pair<T, U>& left, const pair<T, U>& right);
```
### <a name="parameters"></a>Paramètres
*gauche*\
Objet de type `pair` situé à gauche de l'opérateur.
*Oui*\
Objet de type `pair` situé à droite de l'opérateur.
### <a name="return-value"></a>Valeur renvoyée
**`true`** Si le `pair` à gauche de l’opérateur est strictement inférieur à l' `pair` extrémité droite de l’opérateur ; sinon, **`false`** .
### <a name="remarks"></a>Notes
On dit que l' `left` `pair` objet est strictement inférieur à l' `right` `pair` objet si *Left* est inférieur à et différent de *Right*.
Dans une comparaison de paires, le premier élément des valeurs des deux paires a la priorité la plus élevée. Si elles diffèrent, le résultat de leur comparaison est pris comme résultat de la comparaison de la paire. Si les valeurs des premiers éléments ne sont pas différentes, les valeurs des deuxièmes éléments sont comparées et le résultat de leur comparaison est pris comme résultat de la comparaison de la paire.
### <a name="example"></a>Exemple
```cpp
// utility_op_lt.cpp
// compile with: /EHsc
#include <utility>
#include <iomanip>
#include <iostream>
int main( )
{
using namespace std;
pair <int, double> p1, p2, p3;
p1 = make_pair ( 10, 2.22e-1 );
p2 = make_pair ( 100, 1.11e-1 );
p3 = make_pair ( 10, 1.11e-1 );
cout.precision ( 3 );
cout << "The pair p1 is: ( " << p1.first << ", "
<< p1.second << " )." << endl;
cout << "The pair p2 is: ( " << p2.first << ", "
<< p2.second << " )." << endl;
cout << "The pair p3 is: ( " << p3.first << ", "
<< p3.second << " )." << endl << endl;
if ( p1 < p2 )
cout << "The pair p1 is less than the pair p2." << endl;
else
cout << "The pair p1 is not less than the pair p2." << endl;
if ( p1 < p3 )
cout << "The pair p1 is less than the pair p3." << endl;
else
cout << "The pair p1 is not less than the pair p3." << endl;
}
```
```Output
The pair p1 is: ( 10, 0.222 ).
The pair p2 is: ( 100, 0.111 ).
The pair p3 is: ( 10, 0.111 ).
The pair p1 is less than the pair p2.
The pair p1 is not less than the pair p3.
```
## <a name="operatorlt"></a><a name="op_lt_eq"></a> and<=
Teste si l'objet pair situé à gauche de l'opérateur est inférieur ou égal à l'objet pair situé à droite.
```cpp
template <class Type>
constexpr bool operator<=(const Type& left, const Type& right);
template <class T, class U>
constexpr bool operator<=(const pair<T, U>& left, const pair<T, U>& right);
```
### <a name="parameters"></a>Paramètres
*gauche*\
Objet de type `pair` situé à gauche de l'opérateur.
*Oui*\
Objet de type `pair` situé à droite de l'opérateur.
### <a name="return-value"></a>Valeur renvoyée
**`true`** Si le `pair` à gauche de l’opérateur est inférieur ou égal à l’extrémité `pair` droite de l’opérateur ; sinon, **`false`** .
### <a name="remarks"></a>Notes
Dans une comparaison de paires, le premier élément des valeurs des deux paires a la priorité la plus élevée. Si elles diffèrent, le résultat de leur comparaison est pris comme résultat de la comparaison de la paire. Si les valeurs des premiers éléments ne sont pas différentes, les valeurs des deuxièmes éléments sont comparées et le résultat de leur comparaison est pris comme résultat de la comparaison de la paire.
### <a name="example"></a>Exemple
```cpp
// utility_op_le.cpp
// compile with: /EHsc
#include <utility>
#include <iomanip>
#include <iostream>
int main( )
{
using namespace std;
pair <int, double> p1, p2, p3, p4;
p1 = make_pair ( 10, 2.22e-1 );
p2 = make_pair ( 100, 1.11e-1 );
p3 = make_pair ( 10, 1.11e-1 );
p4 = make_pair ( 10, 2.22e-1 );
cout.precision ( 3 );
cout << "The pair p1 is: ( " << p1.first << ", "
<< p1.second << " )." << endl;
cout << "The pair p2 is: ( " << p2.first << ", "
<< p2.second << " )." << endl;
cout << "The pair p3 is: ( " << p3.first << ", "
<< p3.second << " )." << endl;
cout << "The pair p4 is: ( " << p4.first << ", "
<< p4.second << " )." << endl << endl;
if ( p1 <= p2 )
cout << "The pair p1 is less than or equal to the pair p2." << endl;
else
cout << "The pair p1 is greater than the pair p2." << endl;
if ( p1 <= p3 )
cout << "The pair p1 is less than or equal to the pair p3." << endl;
else
cout << "The pair p1 is greater than the pair p3." << endl;
if ( p1 <= p4 )
cout << "The pair p1 is less than or equal to the pair p4." << endl;
else
cout << "The pair p1 is greater than the pair p4." << endl;
}
```
```Output
The pair p1 is: ( 10, 0.222 ).
The pair p2 is: ( 100, 0.111 ).
The pair p3 is: ( 10, 0.111 ).
The pair p4 is: ( 10, 0.222 ).
The pair p1 is less than or equal to the pair p2.
The pair p1 is greater than the pair p3.
The pair p1 is less than or equal to the pair p4.
```
## <a name="operatorgt"></a><a name="op_gt"></a> and>
Teste si l'objet pair situé à gauche de l'opérateur est supérieur à l'objet pair situé à droite.
```cpp
template <class Type>
constexpr bool operator>(const Type& left, const Type& right);
template <class T, class U>
constexpr bool operator>(const pair<T, U>& left, const pair<T, U>& right);
```
### <a name="parameters"></a>Paramètres
*gauche*\
Objet de type `pair` situé à gauche de l'opérateur.
*Oui*\
Objet de type `pair` situé à droite de l'opérateur.
### <a name="return-value"></a>Valeur renvoyée
**`true`** Si le `pair` à gauche de l’opérateur est strictement supérieur à l' `pair` extrémité droite de l’opérateur ; sinon, **`false`** .
### <a name="remarks"></a>Notes
On dit que l' `left` `pair` objet est strictement supérieur à l' `right` `pair` objet si *Left* est supérieur et différent de *Right*.
Dans une comparaison de paires, le premier élément des valeurs des deux paires a la priorité la plus élevée. Si elles diffèrent, le résultat de leur comparaison est pris comme résultat de la comparaison de la paire. Si les valeurs des premiers éléments ne sont pas différentes, les valeurs des deuxièmes éléments sont comparées et le résultat de leur comparaison est pris comme résultat de la comparaison de la paire.
### <a name="example"></a>Exemple
```cpp
// utility_op_gt.cpp
// compile with: /EHsc
#include <utility>
#include <iomanip>
#include <iostream>
int main( )
{
using namespace std;
pair <int, double> p1, p2, p3, p4;
p1 = make_pair ( 10, 2.22e-1 );
p2 = make_pair ( 100, 1.11e-1 );
p3 = make_pair ( 10, 1.11e-1 );
p4 = make_pair ( 10, 2.22e-1 );
cout.precision ( 3 );
cout << "The pair p1 is: ( " << p1.first << ", "
<< p1.second << " )." << endl;
cout << "The pair p2 is: ( " << p2.first << ", "
<< p2.second << " )." << endl;
cout << "The pair p3 is: ( " << p3.first << ", "
<< p3.second << " )." << endl;
cout << "The pair p4 is: ( " << p4.first << ", "
<< p4.second << " )." << endl << endl;
if ( p1 > p2 )
cout << "The pair p1 is greater than the pair p2." << endl;
else
cout << "The pair p1 is not greater than the pair p2." << endl;
if ( p1 > p3 )
cout << "The pair p1 is greater than the pair p3." << endl;
else
cout << "The pair p1 is not greater than the pair p3." << endl;
if ( p1 > p4 )
cout << "The pair p1 is greater than the pair p4." << endl;
else
cout << "The pair p1 is not greater than the pair p4." << endl;
}
```
```Output
The pair p1 is: ( 10, 0.222 ).
The pair p2 is: ( 100, 0.111 ).
The pair p3 is: ( 10, 0.111 ).
The pair p4 is: ( 10, 0.222 ).
The pair p1 is not greater than the pair p2.
The pair p1 is greater than the pair p3.
The pair p1 is not greater than the pair p4.
```
## <a name="operatorgt"></a><a name="op_gt_eq"></a> and>=
Teste si l'objet pair situé à gauche de l'opérateur est supérieur ou égal à l'objet pair situé à droite.
```cpp
template <class Type>
constexpr bool operator>=(const Type& left, const Type& right);
template <class T, class U>
constexpr bool operator>=(const pair<T, U>& left, const pair<T, U>& right);
```
### <a name="parameters"></a>Paramètres
*gauche*\
Objet de type `pair` situé à gauche de l'opérateur.
*Oui*\
Objet de type `pair` situé à droite de l'opérateur.
### <a name="return-value"></a>Valeur renvoyée
**`true`** Si le `pair` à gauche de l’opérateur est supérieur ou égal à l’extrémité `pair` droite de l’opérateur ; sinon, **`false`** .
### <a name="remarks"></a>Notes
Dans une comparaison de paires, le premier élément des valeurs des deux paires a la priorité la plus élevée. Si elles diffèrent, le résultat de leur comparaison est pris comme résultat de la comparaison de la paire. Si les valeurs des premiers éléments ne sont pas différentes, les valeurs des deuxièmes éléments sont comparées et le résultat de leur comparaison est pris comme résultat de la comparaison de la paire.
### <a name="example"></a>Exemple
```cpp
// utility_op_ge.cpp
// compile with: /EHsc
#include <utility>
#include <iomanip>
#include <iostream>
int main( )
{
using namespace std;
pair <int, double> p1, p2, p3, p4;
p1 = make_pair ( 10, 2.22e-1 );
p2 = make_pair ( 100, 1.11e-1 );
p3 = make_pair ( 10, 1.11e-1 );
p4 = make_pair ( 10, 2.22e-1 );
cout.precision ( 3 );
cout << "The pair p1 is: ( " << p1.first << ", "
<< p1.second << " )." << endl;
cout << "The pair p2 is: ( " << p2.first << ", "
<< p2.second << " )." << endl;
cout << "The pair p3 is: ( " << p3.first << ", "
<< p3.second << " )." << endl;
cout << "The pair p4 is: ( " << p4.first << ", "
<< p4.second << " )." << endl << endl;
if ( p1 >= p2 )
cout << "Pair p1 is greater than or equal to pair p2." << endl;
else
cout << "The pair p1 is less than the pair p2." << endl;
if ( p1 >= p3 )
cout << "Pair p1 is greater than or equal to pair p3." << endl;
else
cout << "The pair p1 is less than the pair p3." << endl;
if ( p1 >= p4 )
cout << "Pair p1 is greater than or equal to pair p4." << endl;
else
cout << "The pair p1 is less than the pair p4." << endl;
}
```
```Output
The pair p1 is: ( 10, 0.222 ).
The pair p2 is: ( 100, 0.111 ).
The pair p3 is: ( 10, 0.111 ).
The pair p4 is: ( 10, 0.222 ).
The pair p1 is less than the pair p2.
Pair p1 is greater than or equal to pair p3.
Pair p1 is greater than or equal to pair p4.
```
| 30.69 | 417 | 0.620072 | fra_Latn | 0.660814 |
474f9d593eeb43473f422d40f076e39a8ef03c0f | 4,847 | md | Markdown | java/basic/DeclaredMethod.md | fulln/TIL | a3ab5bb2e91f92b3d1bd201fb5f96e2ad4985b5f | [
"Apache-2.0"
] | null | null | null | java/basic/DeclaredMethod.md | fulln/TIL | a3ab5bb2e91f92b3d1bd201fb5f96e2ad4985b5f | [
"Apache-2.0"
] | null | null | null | java/basic/DeclaredMethod.md | fulln/TIL | a3ab5bb2e91f92b3d1bd201fb5f96e2ad4985b5f | [
"Apache-2.0"
] | null | null | null | ## java反射使用getDeclaredMethods
最近在使用`getDeclaredMethods`方法获取类中的方法时碰到奇怪的问题，先来看看`getDeclaredMethods`方法的注释：
```java
/**
*
* Returns an array containing {@code Method} objects reflecting all the
* declared methods of the class or interface represented by this {@code
* Class} object, including public, protected, default (package)
* access, and private methods, but excluding inherited methods.
*
* <p> If this {@code Class} object represents a type that has multiple
* declared methods with the same name and parameter types, but different
* return types, then the returned array has a {@code Method} object for
* each such method.
*
* <p> If this {@code Class} object represents a type that has a class
* initialization method {@code <clinit>}, then the returned array does
* <em>not</em> have a corresponding {@code Method} object.
*
* <p> If this {@code Class} object represents a class or interface with no
* declared methods, then the returned array has length 0.
*
* <p> If this {@code Class} object represents an array type, a primitive
* type, or void, then the returned array has length 0.
*
* <p> The elements in the returned array are not sorted and are not in any
* particular order.
*
* @return the array of {@code Method} objects representing all the
* declared methods of this class
* @throws SecurityException
* If a security manager, <i>s</i>, is present and any of the
* following conditions is met:
*
* <ul>
*
* <li> the caller's class loader is not the same as the
* class loader of this class and invocation of
* {@link SecurityManager#checkPermission
* s.checkPermission} method with
* {@code RuntimePermission("accessDeclaredMembers")}
* denies access to the declared methods within this class
*
* <li> the caller's class loader is not the same as or an
* ancestor of the class loader for the current class and
* invocation of {@link SecurityManager#checkPackageAccess
* s.checkPackageAccess()} denies access to the package
* of this class
*
* </ul>
*
* @jls 8.2 Class Members
* @jls 8.4 Method Declarations
* @since JDK1.1
* 1.返回一个包含Method对象的数组，该对象反映了此Class对象表示的类或接口的所有声明方法，包括公共、受保护、默认（包）访问和私有方法，但不包括继承的方法。
* 2.如果此Class对象表示一个类型，该类型具有多个具有相同名称和参数类型但返回类型不同的声明方法，则 返回的数组对于每个此类方法都有一个Method对象。
* 3.如果此Class对象表示具有类初始化方法的类型<clinit>则 返回的阵列不具有相应的Method的对象。(不返回构造参数)
* 4.如果此Class对象表示没有声明方法的类或接口，则返回的数组长度为 0。
* 5.如果此Class对象表示数组类型、基本类型或 void，则返回的数组长度为 0。
* 6.返回的数组中的元素没有排序，也没有任何特定的顺序。
* 返回：
* 表示此类的所有声明方法的Method对象数组
* 抛出：
* SecurityException – 如果存在安全管理器s并且满足以下任何条件：
* 调用者的类加载器与此类的类加载器不同，并且使用RuntimePermission("accessDeclaredMembers")调用s.checkPermission方法拒绝访问此类中的声明方法
* 调用者的类加载器与当前类的类加载器不同，或者不是该类加载器的祖先，并且调用s.checkPackageAccess()拒绝访问此类的包
* 自从：JDK1.1
* 外部注释：@org.jetbrains.annotations.NotNull @org.jetbrains.annotations.Contract(pure = true)
*/
@CallerSensitive
public Method[] getDeclaredMethods() throws SecurityException {
checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
return copyMethods(privateGetDeclaredMethods(false));
}
```
### 顺序问题
在JDK的API文档里明确标注了(第6点)：不能保证getDeclaredFields()/getDeclaredMethods()返回的Fields[] 和 Methods[] 的顺序。注意是不能保证返回顺序，而不是返回是乱序：它完全可能是乱序，也还可能是按照声明顺序排布。
这是因为，JVM有权在编译时，自行决定类成员的顺序，不一定要按照代码中的声明顺序来进行编译。因此返回的顺序其实是class文件中的成员正向顺序，只不过在编译时这个顺序不一定等于声明时的顺序。
### 额外方法问题
JDK文档标明的第一点说不包括继承方法,但是在实际使用中,还是会发现有包含父类方法的情况,下面用案例展示
- 正常例子
```java
public class {
class A {
void add(Object obj) {
}
}
class B extends A{
void add(Object obj) {
}
}
public static void main(String[] args) {
for (Method method : B.class.getDeclaredMethods()) {
System.out.println(method.toString());
}
}
}
```
这里执行结果为
```java
void com.fcbox.member.service.rights.domain.C$B.add(java.lang.Object)
```
正常的只获取了子类中的methon
- 非正常例子
```java
public class C{
class A<T> {
void add(T t) {
}
}
class B extends A<String>{
void add(String obj) {
}
}
public static void main(String[] args) {
for (Method method : B.class.getDeclaredMethods()) {
System.out.println(method.toString());
}
}
}
```
这里执行结果为
```java
void com.fcbox.member.service.rights.domain.C$B.add(java.lang.String)
void com.fcbox.member.service.rights.domain.C$B.add(java.lang.Object)
```
发现把父类的方法也给查出来了
- 解决办法
手动判断`method.isBridge()`来判断是不是继承了父类的方法的method
### 总结
使用反射的方法的时候,需要注意下对应api上面的描述,不然写了bug都不自知
- 参考
> https://www.dazhuanlan.com/wangpine/topics/1571580
>
> https://blog.csdn.net/Shenpibaipao/article/details/78510849
| 28.85119 | 138 | 0.681865 | eng_Latn | 0.795182 |
474f9e478d4b655730a86888079ce1f2305cf4d6 | 68 | md | Markdown | README.md | Emjayekanem/Bookeet | db8af8e43b280e8e319cf09440542ddea3d451c0 | [
"Apache-2.0"
] | null | null | null | README.md | Emjayekanem/Bookeet | db8af8e43b280e8e319cf09440542ddea3d451c0 | [
"Apache-2.0"
] | null | null | null | README.md | Emjayekanem/Bookeet | db8af8e43b280e8e319cf09440542ddea3d451c0 | [
"Apache-2.0"
] | null | null | null | # Bookeet
Mobile Ticket app For Movies, Music concerts, and events
| 22.666667 | 57 | 0.779412 | eng_Latn | 0.700007 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.